{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_HADDOCK show-extensions #-}

{- |
Module      :  Aftovolio.Constraints
Copyright   :  (c) OleksandrZhabenko 2020-2024
License     :  MIT
Stability   :  Experimental
Maintainer  :  oleksandr.zhabenko@yahoo.com

Provides several most important variants of constraints for the
permutations. All the 'Array'
here must consists of unique 'Int' starting from 0 to n-1 and the 'Int'
arguments must be in the range [0..n-1] though these inner constraints are
not checked. It is up to user to check them.
Uses arrays instead of vectors.
The word \"unsafe\" in the names means that there is no checking whether the arguments are
within the elements of the arrays, this checking is intended to be done elsewhere before applying
the functions here. Without such a checking the result are meaningless.
-}
module Aftovolio.Constraints (
    -- * Predicates
    unsafeOrderIJ,
    unsafeSignDistanceIJ,
    unsafeUnsignDistanceIJ,
    isSignDistIJK3,
    isUnsignDistIJK3,
    isMixedDistIJK3,
    isTripleOrdered,
    isQuadrupleOrdered,
    isQuintupleOrdered,
    isSeveralAOrdered,
    isSeveralBOrdered,
    isFixedPointTup,
    isFixedPoint,
    notSignDistIJK3,
    notUnsignDistIJK3,
    notMixedDistIJK3,
    notTripleOrdered,
    notQuadrupleOrdered,
    notQuintupleOrdered,
    notSeveralAOrdered,
    notSeveralBOrdered,
    notFixedPointTup,
    notFixedPoint,
    isGrouppedTogether,
    notGrouppedTogether,

    -- * Functions to work with permutations with basic constraints ('Array'-based)
    filterOrderIJ,
    unsafeTriples,
    unsafeQuadruples,
    unsafeQuintuples,
    filterGrouppedTogether,

    -- ** With multiple elements specified
    unsafeSeveralA,
    unsafeSeveralB,

    -- ** With fixed points
    fixedPointsG,
    fixedPointsS,

    -- * Distances between elements
    filterSignDistanceIJ,
    filterUnsignDistanceIJ,
    filterSignDistanceIJK3,
    filterUnsignDistanceIJK3,
    filterMixedDistanceIJK3,
) where

import Data.Bits (clearBit, setBit, shiftR, testBit, (.&.))
import Data.Foldable (Foldable, all, any, foldr)
import Data.InsertLeft (InsertLeft (..), filterG)
import GHC.Arr
import GHC.Base hiding (foldr)
import GHC.Int (Int8 (..))
import GHC.Num (Num, (+), (-))
import Data.Tuple (snd)

f2 :: (Foldable t, Eq p) => p -> p -> t p -> Int8
f2 :: forall (t :: * -> *) p. (Foldable t, Eq p) => p -> p -> t p -> Int8
f2 p
i p
j = (p -> Int8 -> Int8) -> Int8 -> t p -> Int8
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr p -> Int8 -> Int8
g (Int8
0 :: Int8) -- (== 3)
  where
    g :: p -> Int8 -> Int8
g p
x Int8
y
        | Int8
y Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
3 = Int8
3
        | p
x p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
j = Bool -> Int8 -> Int -> Int8
bitChange (Int8 -> Int -> Int8
forall a. Bits a => a -> Int -> a
shiftR Int8
y Int
1 Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
0) Int8
y Int
0
        | p
x p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
i = Bool -> Int8 -> Int -> Int8
bitChange (Int8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Int8
y Int
0) Int8
y Int
1
        | Bool
otherwise = Int8
y
{-# INLINE f2 #-}
{-# SPECIALIZE f2 :: Int -> Int -> Array Int Int -> Int8 #-}

f3 :: (Foldable t, Eq p) => p -> p -> p -> t p -> Int8
f3 :: forall (t :: * -> *) p.
(Foldable t, Eq p) =>
p -> p -> p -> t p -> Int8
f3 p
i p
j p
k = (p -> Int8 -> Int8) -> Int8 -> t p -> Int8
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr p -> Int8 -> Int8
g (Int8
0 :: Int8) -- (== 7)
  where
    g :: p -> Int8 -> Int8
g p
x Int8
y
        | Int8
y Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
7 = Int8
7
        | p
x p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
k = Bool -> Int8 -> Int -> Int8
bitChange (Int8 -> Int -> Int8
forall a. Bits a => a -> Int -> a
shiftR Int8
y Int
1 Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
0) Int8
y Int
0 -- u, not (t && u))
        | p
x p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
j = Bool -> Int8 -> Int -> Int8
bitChange (Bool -> Bool
not (Int8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Int8
y Int
2) Bool -> Bool -> Bool
&& Int8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Int8
y Int
0) Int8
y Int
1 -- (t, w && not t, w)
        | p
x p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
i = Bool -> Int8 -> Int -> Int8
bitChange (Int8 -> Int -> Int8
forall a. Bits a => a -> Int -> a
clearBit Int8
y Int
2 Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
3) Int8
y Int
2 -- (u && w, u, w)
        | Bool
otherwise = Int8
y
{-# INLINE f3 #-}
{-# SPECIALIZE f3 :: Int -> Int -> Int -> Array Int Int -> Int8 #-}

f4 :: (Foldable t, Eq p) => p -> p -> p -> p -> t p -> Int8
f4 :: forall (t :: * -> *) p.
(Foldable t, Eq p) =>
p -> p -> p -> p -> t p -> Int8
f4 p
i p
j p
k p
l = (p -> Int8 -> Int8) -> Int8 -> t p -> Int8
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr p -> Int8 -> Int8
g (Int8
0 :: Int8) -- (== 15)
  where
    g :: p -> Int8 -> Int8
g p
x Int8
y
        | Int8
y Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
15 = Int8
15
        | p
x p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
l = Bool -> Int8 -> Int -> Int8
bitChange (Int8 -> Int -> Int8
forall a. Bits a => a -> Int -> a
shiftR Int8
y Int
1 Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
0) Int8
y Int
0
        | p
x p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
k = Bool -> Int8 -> Int -> Int8
bitChange (Int8 -> Int -> Int8
forall a. Bits a => a -> Int -> a
shiftR Int8
y Int
2 Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
0 Bool -> Bool -> Bool
&& Int8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Int8
y Int
0) Int8
y Int
1
        | p
x p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
j = Bool -> Int8 -> Int -> Int8
bitChange (Bool -> Bool
not (Int8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Int8
y Int
3) Bool -> Bool -> Bool
&& Int8
y Int8 -> Int8 -> Int8
forall a. Bits a => a -> a -> a
.&. Int8
3 Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
3) Int8
y Int
2
        | p
x p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
i = Bool -> Int8 -> Int -> Int8
bitChange (Int8 -> Int -> Int8
forall a. Bits a => a -> Int -> a
clearBit Int8
y Int
3 Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
7) Int8
y Int
3
        | Bool
otherwise = Int8
y
{-# INLINE f4 #-}
{-# SPECIALIZE f4 :: Int -> Int -> Int -> Int -> Array Int Int -> Int8 #-}

f5 :: (Foldable t, Eq p) => p -> p -> p -> p -> p -> t p -> Int8
f5 :: forall (t :: * -> *) p.
(Foldable t, Eq p) =>
p -> p -> p -> p -> p -> t p -> Int8
f5 p
i p
j p
k p
l p
m = (p -> Int8 -> Int8) -> Int8 -> t p -> Int8
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr p -> Int8 -> Int8
g (Int8
0 :: Int8) -- (== 31)
  where
    g :: p -> Int8 -> Int8
g p
x Int8
y
        | Int8
y Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
31 = Int8
31
        | p
x p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
m = Bool -> Int8 -> Int -> Int8
bitChange (Int8 -> Int -> Int8
forall a. Bits a => a -> Int -> a
shiftR Int8
y Int
1 Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
0) Int8
y Int
0
        | p
x p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
l = Bool -> Int8 -> Int -> Int8
bitChange (Int8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Int8
y Int
0 Bool -> Bool -> Bool
&& Int8 -> Int -> Int8
forall a. Bits a => a -> Int -> a
shiftR Int8
y Int
2 Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
0) Int8
y Int
1
        | p
x p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
k = Bool -> Int8 -> Int -> Int8
bitChange (Int8 -> Int -> Int8
forall a. Bits a => a -> Int -> a
shiftR Int8
y Int
3 Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
0 Bool -> Bool -> Bool
&& Int8
y Int8 -> Int8 -> Int8
forall a. Bits a => a -> a -> a
.&. Int8
3 Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
3) Int8
y Int
2
        | p
x p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
j = Bool -> Int8 -> Int -> Int8
bitChange (Bool -> Bool
not (Int8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Int8
y Int
4) Bool -> Bool -> Bool
&& Int8
y Int8 -> Int8 -> Int8
forall a. Bits a => a -> a -> a
.&. Int8
7 Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
7) Int8
y Int
3
        | p
x p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
i = Bool -> Int8 -> Int -> Int8
bitChange (Int8 -> Int -> Int8
forall a. Bits a => a -> Int -> a
clearBit Int8
y Int
4 Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
15) Int8
y Int
4
        | Bool
otherwise = Int8
y
{-# INLINE f5 #-}
{-# SPECIALIZE f5 ::
    Int -> Int -> Int -> Int -> Int -> Array Int Int -> Int8
    #-}

-- | @n@ must be in the range [0..7] though it is not checked here.
bitChange ::
    Bool ->
    Int8 ->
    Int ->
    Int8
bitChange :: Bool -> Int8 -> Int -> Int8
bitChange Bool
bool = (if Bool
bool then Int8 -> Int -> Int8
forall a. Bits a => a -> Int -> a
setBit else Int8 -> Int -> Int8
forall a. Bits a => a -> Int -> a
clearBit)
{-# INLINE bitChange #-}

-- | Being given the data satisfying the constraints in the module header checks whether in the 'Array' the first argument stands before the second one.
unsafeOrderIJ :: Int -> Int -> Array Int Int -> Bool
unsafeOrderIJ :: Int -> Int -> Array Int Int -> Bool
unsafeOrderIJ Int
i Int
j = (Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
3) (Int8 -> Bool) -> (Array Int Int -> Int8) -> Array Int Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Array Int Int -> Int8
forall (t :: * -> *) p. (Foldable t, Eq p) => p -> p -> t p -> Int8
f2 Int
i Int
j
{-# INLINE unsafeOrderIJ #-}

{- | Being given the data satisfying the constraints in the module header checks whether in the
'Array' the distance between positions of the first two arguments values is equal to the signed
third argument.
-}
unsafeSignDistanceIJ ::
    Int ->
    Int ->
    -- | Can be of both signs, but not equal to 0. The positive value gives 'True' for the first argument being find earlier in the 'Array' than the second and the distance between their positions are equal to 'abs' @d@ (this argument). The negative value gives 'True' for the second argument  being earlier in the 'Array' than the first one and the distance between their positions are equal to 'abs' @d@ (this argument).
    Int ->
    Array Int Int ->
    Bool
unsafeSignDistanceIJ :: Int -> Int -> Int -> Array Int Int -> Bool
unsafeSignDistanceIJ Int
i Int
j Int
d =
    (\(Int
_, Int
_, Int
r) -> if Int
r Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
100 then (Int
100 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
r) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
d else Int
r Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
d)
        ((Int, Int, Int) -> Bool)
-> (Array Int Int -> (Int, Int, Int)) -> Array Int Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> (Int, Int, Int) -> (Int, Int, Int))
-> (Int, Int, Int) -> Array Int Int -> (Int, Int, Int)
forall a b. (a -> b -> b) -> b -> Array Int a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Int -> (Int, Int, Int) -> (Int, Int, Int)
forall a1 a2.
(Ord a1, Ord a2, Num a1, Num a2) =>
a2 -> (a2, a2, a1) -> (a2, a2, a1)
helpG2 (Int
j, Int
i, -Int
1)
{-# INLINE unsafeSignDistanceIJ #-}

helpG2 :: (Ord a1, Ord a2, Num a1, Num a2) => a2 -> (a2, a2, a1) -> (a2, a2, a1)
helpG2 :: forall a1 a2.
(Ord a1, Ord a2, Num a1, Num a2) =>
a2 -> (a2, a2, a1) -> (a2, a2, a1)
helpG2 a2
z (a2
t, a2
u, a1
n)
    | a1
n a1 -> a1 -> Bool
forall a. Ord a => a -> a -> Bool
< a1
0 =
        if (a2
z a2 -> a2 -> Bool
forall a. Eq a => a -> a -> Bool
/= a2
t Bool -> Bool -> Bool
&& a2
z a2 -> a2 -> Bool
forall a. Eq a => a -> a -> Bool
/= a2
u) then (a2
t, a2
u, a1
n) else (a2
t, a2
u, if a2
z a2 -> a2 -> Bool
forall a. Eq a => a -> a -> Bool
== a2
t then a1
1 else a1
101)
    | a2
z a2 -> a2 -> Bool
forall a. Eq a => a -> a -> Bool
/= a2
u Bool -> Bool -> Bool
&& a2
z a2 -> a2 -> Bool
forall a. Eq a => a -> a -> Bool
/= a2
t Bool -> Bool -> Bool
&& a2
t a2 -> a2 -> Bool
forall a. Ord a => a -> a -> Bool
>= a2
0 = (a2
t, a2
u, a1
n a1 -> a1 -> a1
forall a. Num a => a -> a -> a
+ a1
1)
    | Bool
otherwise = (-a2
1, a2
u, a1
n)
{-# INLINE helpG2 #-}
{-# SPECIALIZE helpG2 :: Int -> (Int, Int, Int) -> (Int, Int, Int) #-}

{- | Being given the data satisfying the constraints in the module header checks whether in the
'Array' the distance between positions of the first two arguments values is equal to the unsigned
third argument. The following is true: if 'unsafeSignDistanceIJ' @i@ @j@ @d@ @array@ == 'True' then
'unsafeUnsignDistanceIJ' @i@ @j@ @d@ @array@ == 'True', but not necessarily vice versa.
-}
unsafeUnsignDistanceIJ ::
    Int ->
    Int ->
    -- | Only for positive values can give 'True', if the distance between the positions of the elements equal to the first two arguments are equal to this argument. Otherwise, 'False'.
    Int ->
    Array Int Int ->
    Bool
unsafeUnsignDistanceIJ :: Int -> Int -> Int -> Array Int Int -> Bool
unsafeUnsignDistanceIJ Int
i Int
j Int
d = (\(Int
_, Int
_, Int
r) -> Int
r Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
d) ((Int, Int, Int) -> Bool)
-> (Array Int Int -> (Int, Int, Int)) -> Array Int Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> (Int, Int, Int) -> (Int, Int, Int))
-> (Int, Int, Int) -> Array Int Int -> (Int, Int, Int)
forall a b. (a -> b -> b) -> b -> Array Int a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Int -> (Int, Int, Int) -> (Int, Int, Int)
forall a1 a2.
(Ord a1, Ord a2, Num a1, Num a2) =>
a2 -> (a2, a2, a1) -> (a2, a2, a1)
helpG3 (Int
j, Int
i, -Int
1)
{-# INLINE unsafeUnsignDistanceIJ #-}

helpG3 :: (Ord a1, Ord a2, Num a1, Num a2) => a2 -> (a2, a2, a1) -> (a2, a2, a1)
helpG3 :: forall a1 a2.
(Ord a1, Ord a2, Num a1, Num a2) =>
a2 -> (a2, a2, a1) -> (a2, a2, a1)
helpG3 a2
z (a2
t, a2
u, a1
n)
    | a1
n a1 -> a1 -> Bool
forall a. Ord a => a -> a -> Bool
< a1
0 = if (a2
z a2 -> a2 -> Bool
forall a. Eq a => a -> a -> Bool
/= a2
t Bool -> Bool -> Bool
&& a2
z a2 -> a2 -> Bool
forall a. Eq a => a -> a -> Bool
/= a2
u) then (a2
t, a2
u, a1
n) else (a2
t, a2
u, a1
1)
    | a2
z a2 -> a2 -> Bool
forall a. Eq a => a -> a -> Bool
/= a2
u Bool -> Bool -> Bool
&& a2
z a2 -> a2 -> Bool
forall a. Eq a => a -> a -> Bool
/= a2
t Bool -> Bool -> Bool
&& a2
t a2 -> a2 -> Bool
forall a. Ord a => a -> a -> Bool
>= a2
0 = (a2
t, a2
u, a1
n a1 -> a1 -> a1
forall a. Num a => a -> a -> a
+ a1
1)
    | Bool
otherwise = (-a2
1, a2
u, a1
n)
{-# INLINE helpG3 #-}
{-# SPECIALIZE helpG3 :: Int -> (Int, Int, Int) -> (Int, Int, Int) #-}

-- | Being given the data satisfying the constraints in the module header returns the elements that satisfy 'unsafeOrderIJ' as a predicate.
filterOrderIJ ::
    (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
    Int ->
    Int ->
    t (Array Int Int) ->
    t (Array Int Int)
filterOrderIJ :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Int -> t (Array Int Int) -> t (Array Int Int)
filterOrderIJ Int
i Int
j = (Array Int Int -> Bool) -> t (Array Int Int) -> t (Array Int Int)
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> t a
filterG (Int -> Int -> Array Int Int -> Bool
unsafeOrderIJ Int
i Int
j)
{-# INLINE filterOrderIJ #-}
{-# SPECIALIZE filterOrderIJ ::
    Int -> Int -> [Array Int Int] -> [Array Int Int]
    #-}

-- | Being given the data satisfying the constraints in the module header returns the elements that satisfy 'unsafeSignDistanceIJ' as a predicate.
filterSignDistanceIJ ::
    (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
    Int ->
    Int ->
    Int ->
    t (Array Int Int) ->
    t (Array Int Int)
filterSignDistanceIJ :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Int -> Int -> t (Array Int Int) -> t (Array Int Int)
filterSignDistanceIJ Int
i Int
j Int
d = (Array Int Int -> Bool) -> t (Array Int Int) -> t (Array Int Int)
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> t a
filterG (Int -> Int -> Int -> Array Int Int -> Bool
unsafeSignDistanceIJ Int
i Int
j Int
d)
{-# INLINE filterSignDistanceIJ #-}
{-# SPECIALIZE filterSignDistanceIJ ::
    Int -> Int -> Int -> [Array Int Int] -> [Array Int Int]
    #-}

-- | Being given the data satisfying the constraints in the module header returns the elements that satisfy 'unsafeUnsignDistanceIJ' as a predicate.
filterUnsignDistanceIJ ::
    (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
    Int ->
    Int ->
    Int ->
    t (Array Int Int) ->
    t (Array Int Int)
filterUnsignDistanceIJ :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Int -> Int -> t (Array Int Int) -> t (Array Int Int)
filterUnsignDistanceIJ Int
i Int
j Int
d = (Array Int Int -> Bool) -> t (Array Int Int) -> t (Array Int Int)
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> t a
filterG (Int -> Int -> Int -> Array Int Int -> Bool
unsafeUnsignDistanceIJ Int
i Int
j Int
d)
{-# INLINE filterUnsignDistanceIJ #-}
{-# SPECIALIZE filterUnsignDistanceIJ ::
    Int -> Int -> Int -> [Array Int Int] -> [Array Int Int]
    #-}

-- | Being given the data satisfying the constraints in the module header returns the elements that pairwisely (1 and 2, 2 and 3) satisfy 'unsafeSignDistanceIJ' as a predicate.
filterSignDistanceIJK3 ::
    (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
    Int ->
    Int ->
    Int ->
    Int ->
    Int ->
    t (Array Int Int) ->
    t (Array Int Int)
filterSignDistanceIJK3 :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int
-> Int
-> Int
-> Int
-> Int
-> t (Array Int Int)
-> t (Array Int Int)
filterSignDistanceIJK3 Int
i Int
j Int
k Int
d1 Int
d2 = (Array Int Int -> Bool) -> t (Array Int Int) -> t (Array Int Int)
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> t a
filterG (Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isSignDistIJK3 Int
i Int
j Int
k Int
d1 Int
d2)
{-# INLINE filterSignDistanceIJK3 #-}
{-# SPECIALIZE filterSignDistanceIJK3 ::
    Int -> Int -> Int -> Int -> Int -> [Array Int Int] -> [Array Int Int]
    #-}

-- | Being given the data satisfying the constraints in the module header returns the elements that pairwisely (1 and 2, 2 and 3) satisfy 'unsafeUnsignDistanceIJ' as a predicate.
filterUnsignDistanceIJK3 ::
    (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
    Int ->
    Int ->
    Int ->
    Int ->
    Int ->
    t (Array Int Int) ->
    t (Array Int Int)
filterUnsignDistanceIJK3 :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int
-> Int
-> Int
-> Int
-> Int
-> t (Array Int Int)
-> t (Array Int Int)
filterUnsignDistanceIJK3 Int
i Int
j Int
k Int
d1 Int
d2 = (Array Int Int -> Bool) -> t (Array Int Int) -> t (Array Int Int)
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> t a
filterG (Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isUnsignDistIJK3 Int
i Int
j Int
k Int
d1 Int
d2)
{-# INLINE filterUnsignDistanceIJK3 #-}
{-# SPECIALIZE filterUnsignDistanceIJK3 ::
    Int -> Int -> Int -> Int -> Int -> [Array Int Int] -> [Array Int Int]
    #-}

-- | Being given the data satisfying the constraints in the module header returns the elements that satisfy both 'unsafeSignDistanceIJ' with the 1st, 2nd and 4th arguments and 'unsafeUnsignDistanceIJ' with the 2nd, 3rd and 5th arguments as predicates.
filterMixedDistanceIJK3 ::
    (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
    Int ->
    Int ->
    Int ->
    Int ->
    Int ->
    t (Array Int Int) ->
    t (Array Int Int)
filterMixedDistanceIJK3 :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int
-> Int
-> Int
-> Int
-> Int
-> t (Array Int Int)
-> t (Array Int Int)
filterMixedDistanceIJK3 Int
i Int
j Int
k Int
d1 Int
d2 = (Array Int Int -> Bool) -> t (Array Int Int) -> t (Array Int Int)
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> t a
filterG (Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isMixedDistIJK3 Int
i Int
j Int
k Int
d1 Int
d2)
{-# INLINE filterMixedDistanceIJK3 #-}
{-# SPECIALIZE filterMixedDistanceIJK3 ::
    Int -> Int -> Int -> Int -> Int -> [Array Int Int] -> [Array Int Int]
    #-}

{- | Being given the data satisfying the constraints in the module header reduces the number of further computations in the foldable structure of
the permutations each one being represented as 'Array' 'Int' 'Int' where the elements are all the numbers in the range [0..n-1] without duplication if the
arguments are the indices of the duplicated words or their concatenated combinations in the corresponding line.
The first three arguments
can be the indices of the the triple duplicated elements (words or their concatenated combinations in the @phonetic-languages@ series of packages).
-}
unsafeTriples ::
    (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
    Int ->
    Int ->
    Int ->
    t (Array Int Int) ->
    t (Array Int Int)
unsafeTriples :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Int -> Int -> t (Array Int Int) -> t (Array Int Int)
unsafeTriples Int
i Int
j Int
k = (Array Int Int -> Bool) -> t (Array Int Int) -> t (Array Int Int)
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> t a
filterG (Int -> Int -> Int -> Array Int Int -> Bool
isTripleOrdered Int
i Int
j Int
k)
{-# INLINE unsafeTriples #-}
{-# SPECIALIZE unsafeTriples ::
    Int -> Int -> Int -> [Array Int Int] -> [Array Int Int]
    #-}

{- | Being given the data satisfying the constraints in the module header reduces the number of further computations in the foldable structure of
the permutations each one being represented as 'Array' 'Int' 'Int' where the elements are all the numbers in the range [0..n-1] without duplication if the
arguments are the indices of the duplicated words or their concatenated combinations in the corresponding line.
The first four arguments
can the indices of the the quadruple duplicated elements (words or their concatenated combinations in the @phonetic-languages@ series of packages).
-}
unsafeQuadruples ::
    (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
    Int ->
    Int ->
    Int ->
    Int ->
    t (Array Int Int) ->
    t (Array Int Int)
unsafeQuadruples :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Int -> Int -> Int -> t (Array Int Int) -> t (Array Int Int)
unsafeQuadruples Int
i Int
j Int
k Int
l = (Array Int Int -> Bool) -> t (Array Int Int) -> t (Array Int Int)
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> t a
filterG (Int -> Int -> Int -> Int -> Array Int Int -> Bool
isQuadrupleOrdered Int
i Int
j Int
k Int
l)
{-# INLINE unsafeQuadruples #-}
{-# SPECIALIZE unsafeQuadruples ::
    Int -> Int -> Int -> Int -> [Array Int Int] -> [Array Int Int]
    #-}

{- | Being given the data satisfying the constraints in the module header reduces the number of further computations in the foldable structure of
the permutations each one being represented as 'Array' 'Int' 'Int' where the elements are all the numbers in the range [0..n-1] without duplication if the
arguments are the indices of the duplicated words or their concatenated combinations in the corresponding line.
The first five arguments
can be the indices of the the quintuple duplicated elements (words or their concatenated combinations in the @phonetic-languages@ series of packages).
-}
unsafeQuintuples ::
    (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
    Int ->
    Int ->
    Int ->
    Int ->
    Int ->
    t (Array Int Int) ->
    t (Array Int Int)
unsafeQuintuples :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int
-> Int
-> Int
-> Int
-> Int
-> t (Array Int Int)
-> t (Array Int Int)
unsafeQuintuples Int
i Int
j Int
k Int
l Int
m = (Array Int Int -> Bool) -> t (Array Int Int) -> t (Array Int Int)
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> t a
filterG (Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isQuintupleOrdered Int
i Int
j Int
k Int
l Int
m)
{-# INLINE unsafeQuintuples #-}
{-# SPECIALIZE unsafeQuintuples ::
    Int -> Int -> Int -> Int -> Int -> [Array Int Int] -> [Array Int Int]
    #-}

{- | Being given the data satisfying the constraints in the module header reduces the number of further computations in the foldable structure of
the permutations each one being represented as 'Array' 'Int' 'Int' where the elements are all the numbers in the range [0..n-1] without duplication.
The first argument
is the index of the the element (a word or their concatenated combination in the @phonetic-languages@ series of packages), the second argument
is 'Array' 'Int' of indices that are in the range [0..n-1]. Filters (and reduces further complex computations) the permutations so that only the
variants with the indices in the second argument all stand AFTER the element with the index equal to the first argument.
-}
unsafeSeveralA ::
    (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
    Int ->
    Array Int Int ->
    t (Array Int Int) ->
    t (Array Int Int)
unsafeSeveralA :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Array Int Int -> t (Array Int Int) -> t (Array Int Int)
unsafeSeveralA !Int
i0 Array Int Int
arr = (Array Int Int -> Bool) -> t (Array Int Int) -> t (Array Int Int)
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> t a
filterG (Int -> Array Int Int -> Array Int Int -> Bool
isSeveralAOrdered Int
i0 Array Int Int
arr)
{-# INLINE unsafeSeveralA #-}
{-# SPECIALIZE unsafeSeveralA ::
    Int -> Array Int Int -> [Array Int Int] -> [Array Int Int]
    #-}

{- | Being given the data satisfying the constraints in the module header reduces the number of further computations in the foldable structure of
the permutations each one being represented as 'Array' 'Int' 'Int' where the elements are all the numbers in the range [0..n-1] without duplication.
The first argument
is the index of the the element (a word or their concatenated combination in the @phonetic-languages@ series of packages), the second argument
is 'Array' of indices that are in the range [0..n-1]. Filters (and reduces further complex computations) the permutations so that only the
variants with the indices in the second argument all stand BEFORE the element with the index equal to the first argument.
-}
unsafeSeveralB ::
    (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
    Int ->
    Array Int Int ->
    t (Array Int Int) ->
    t (Array Int Int)
unsafeSeveralB :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Array Int Int -> t (Array Int Int) -> t (Array Int Int)
unsafeSeveralB !Int
i0 Array Int Int
arr = (Array Int Int -> Bool) -> t (Array Int Int) -> t (Array Int Int)
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> t a
filterG (Int -> Array Int Int -> Array Int Int -> Bool
isSeveralBOrdered Int
i0 Array Int Int
arr)
{-# INLINE unsafeSeveralB #-}
{-# SPECIALIZE unsafeSeveralB ::
    Int -> Array Int Int -> [Array Int Int] -> [Array Int Int]
    #-}

--------------------------------------------------------------------------------

{- | Reduces the number of permutations using filtering leaving just those ones permutations where elements on the
first elements in the tuples in the first argument 'Array' places are moved to the places indexed with the second
elements in the tuples respectively.
-}
fixedPointsG ::
    (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
    Array Int (Int, Int) ->
    t (Array Int Int) ->
    t (Array Int Int)
fixedPointsG :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Array Int (Int, Int) -> t (Array Int Int) -> t (Array Int Int)
fixedPointsG Array Int (Int, Int)
arr = (Array Int Int -> Bool) -> t (Array Int Int) -> t (Array Int Int)
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> t a
filterG (Array Int (Int, Int) -> Array Int Int -> Bool
isFixedPointTup Array Int (Int, Int)
arr)
{-# INLINE fixedPointsG #-}
{-# SPECIALIZE fixedPointsG ::
    Array Int (Int, Int) -> [Array Int Int] -> [Array Int Int]
    #-}

{- | A simplified variant of the 'fixedPointsG' function where the specified elements stay on their place and that is
why are 'fixed points' in the permutation specified.
-}
fixedPointsS ::
    (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
    Array Int Int ->
    t (Array Int Int) ->
    t (Array Int Int)
fixedPointsS :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Array Int Int -> t (Array Int Int) -> t (Array Int Int)
fixedPointsS Array Int Int
arr = (Array Int Int -> Bool) -> t (Array Int Int) -> t (Array Int Int)
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> t a
filterG (Array Int Int -> Array Int Int -> Bool
isFixedPoint Array Int Int
arr)
{-# INLINE fixedPointsS #-}
{-# SPECIALIZE fixedPointsS ::
    Array Int Int -> [Array Int Int] -> [Array Int Int]
    #-}

filterGrouppedTogether :: 
    (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
    Int -> 
    Int -> 
    t (Array Int Int) -> 
    t (Array Int Int)
filterGrouppedTogether :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Int -> t (Array Int Int) -> t (Array Int Int)
filterGrouppedTogether Int
i Int
j = (Array Int Int -> Bool) -> t (Array Int Int) -> t (Array Int Int)
forall (t :: * -> *) a.
(InsertLeft t a, Monoid (t a)) =>
(a -> Bool) -> t a -> t a
filterG (Int -> Int -> Array Int Int -> Bool
isGrouppedTogether Int
i Int
j) 
{-# INLINE filterGrouppedTogether #-}
{-# SPECIALIZE filterGrouppedTogether ::
    Int -> Int -> [Array Int Int] -> [Array Int Int]
    #-}

------------------------------------------

isSignDistIJK3 :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isSignDistIJK3 :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isSignDistIJK3 Int
i Int
j Int
k Int
d1 Int
d2 Array Int Int
arr = Int -> Int -> Int -> Array Int Int -> Bool
unsafeSignDistanceIJ Int
i Int
j Int
d1 Array Int Int
arr Bool -> Bool -> Bool
&& Int -> Int -> Int -> Array Int Int -> Bool
unsafeSignDistanceIJ Int
j Int
k Int
d2 Array Int Int
arr
{-# INLINE isSignDistIJK3 #-}

isUnsignDistIJK3 :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isUnsignDistIJK3 :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isUnsignDistIJK3 Int
i Int
j Int
k Int
d1 Int
d2 Array Int Int
arr = Int -> Int -> Int -> Array Int Int -> Bool
unsafeUnsignDistanceIJ Int
i Int
j Int
d1 Array Int Int
arr Bool -> Bool -> Bool
&& Int -> Int -> Int -> Array Int Int -> Bool
unsafeUnsignDistanceIJ Int
j Int
k Int
d2 Array Int Int
arr
{-# INLINE isUnsignDistIJK3 #-}

isMixedDistIJK3 :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isMixedDistIJK3 :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isMixedDistIJK3 Int
i Int
j Int
k Int
d1 Int
d2 Array Int Int
arr = Int -> Int -> Int -> Array Int Int -> Bool
unsafeSignDistanceIJ Int
i Int
j Int
d1 Array Int Int
arr Bool -> Bool -> Bool
&& Int -> Int -> Int -> Array Int Int -> Bool
unsafeUnsignDistanceIJ Int
j Int
k Int
d2 Array Int Int
arr
{-# INLINE isMixedDistIJK3 #-}

isTripleOrdered :: Int -> Int -> Int -> Array Int Int -> Bool
isTripleOrdered :: Int -> Int -> Int -> Array Int Int -> Bool
isTripleOrdered Int
i Int
j Int
k = (Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
7) (Int8 -> Bool) -> (Array Int Int -> Int8) -> Array Int Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Int -> Array Int Int -> Int8
forall (t :: * -> *) p.
(Foldable t, Eq p) =>
p -> p -> p -> t p -> Int8
f3 Int
i Int
j Int
k
{-# INLINE isTripleOrdered #-}

isQuadrupleOrdered :: Int -> Int -> Int -> Int -> Array Int Int -> Bool
isQuadrupleOrdered :: Int -> Int -> Int -> Int -> Array Int Int -> Bool
isQuadrupleOrdered Int
i Int
j Int
k Int
l = (Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
15) (Int8 -> Bool) -> (Array Int Int -> Int8) -> Array Int Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Int -> Int -> Array Int Int -> Int8
forall (t :: * -> *) p.
(Foldable t, Eq p) =>
p -> p -> p -> p -> t p -> Int8
f4 Int
i Int
j Int
k Int
l
{-# INLINE isQuadrupleOrdered #-}

isQuintupleOrdered :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isQuintupleOrdered :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isQuintupleOrdered Int
i Int
j Int
k Int
l Int
m = (Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
31) (Int8 -> Bool) -> (Array Int Int -> Int8) -> Array Int Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Int -> Int -> Int -> Array Int Int -> Int8
forall (t :: * -> *) p.
(Foldable t, Eq p) =>
p -> p -> p -> p -> p -> t p -> Int8
f5 Int
i Int
j Int
k Int
l Int
m
{-# INLINE isQuintupleOrdered #-}

isSeveralAOrdered :: Int -> Array Int Int -> Array Int Int -> Bool
isSeveralAOrdered :: Int -> Array Int Int -> Array Int Int -> Bool
isSeveralAOrdered !Int
i0 !Array Int Int
arr1 Array Int Int
arr2 = (Int -> Bool) -> Array Int Int -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (\Int
k -> Int -> Int -> Array Int Int -> Bool
unsafeOrderIJ Int
i0 Int
k Array Int Int
arr2) Array Int Int
arr1
{-# INLINE isSeveralAOrdered #-}

isSeveralBOrdered :: Int -> Array Int Int -> Array Int Int -> Bool
isSeveralBOrdered :: Int -> Array Int Int -> Array Int Int -> Bool
isSeveralBOrdered !Int
i0 !Array Int Int
arr1 Array Int Int
arr2 = (Int -> Bool) -> Array Int Int -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (\Int
k -> Int -> Int -> Array Int Int -> Bool
unsafeOrderIJ Int
k Int
i0 Array Int Int
arr2) Array Int Int
arr1
{-# INLINE isSeveralBOrdered #-}

isFixedPointTup :: Array Int (Int, Int) -> Array Int Int -> Bool
isFixedPointTup :: Array Int (Int, Int) -> Array Int Int -> Bool
isFixedPointTup Array Int (Int, Int)
arr1 Array Int Int
arr2 = ((Int, Int) -> Bool) -> Array Int (Int, Int) -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (\(Int
k, Int
j) -> Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt Array Int Int
arr2 Int
k Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
j) Array Int (Int, Int)
arr1
{-# INLINE isFixedPointTup #-}

isFixedPoint :: Array Int Int -> Array Int Int -> Bool
isFixedPoint :: Array Int Int -> Array Int Int -> Bool
isFixedPoint Array Int Int
arr1 Array Int Int
arr2 = (Int -> Bool) -> Array Int Int -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (\Int
k -> Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt Array Int Int
arr2 Int
k Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
k) Array Int Int
arr1
{-# INLINE isFixedPoint #-}

isGrouppedTogether :: Int -> Int -> Array Int Int -> Bool
isGrouppedTogether :: Int -> Int -> Array Int Int -> Bool
isGrouppedTogether Int
i Int
j = (Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> -Integer
1) (Integer -> Bool)
-> (Array Int Int -> Integer) -> Array Int Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int, Integer) -> Integer
forall a b. (a, b) -> b
snd ((Int, Integer) -> Integer)
-> (Array Int Int -> (Int, Integer)) -> Array Int Int -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> (Int, Integer) -> (Int, Integer))
-> (Int, Integer) -> Array Int Int -> (Int, Integer)
forall a b. (a -> b -> b) -> b -> Array Int a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Int -> (Int, Integer) -> (Int, Integer)
forall {a}. (Num a, Eq a) => Int -> (Int, a) -> (Int, a)
f6 (Int, Integer)
v
    where v :: (Int, Integer)
v = (Int
0,Integer
0)
          f6 :: Int -> (Int, a) -> (Int, a)
f6 Int
x (Int
k,a
l)
              | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
i Bool -> Bool -> Bool
|| Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
j = 
                     case Int
k of 
                         Int
0 -> (Int
0, a
l) 
                         Int
b -> if Int
b Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1 then (Int
b, -a
1) else (Int
b, a
l)
              | Bool
otherwise = 
                     case a
l of
                         -1 -> (Int
0, -a
1)
                         a
c  -> (Int
k Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1, a
c a -> a -> a
forall a. Num a => a -> a -> a
+ a
1)
{-# INLINE isGrouppedTogether #-}


notSignDistIJK3 :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
notSignDistIJK3 :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
notSignDistIJK3 Int
i Int
j Int
k Int
d1 Int
d2 Array Int Int
arr = Int -> Int -> Int -> Array Int Int -> Bool
unsafeSignDistanceIJ Int
j Int
i Int
d1 Array Int Int
arr Bool -> Bool -> Bool
|| Int -> Int -> Int -> Array Int Int -> Bool
unsafeSignDistanceIJ Int
k Int
j Int
d2 Array Int Int
arr
{-# INLINE notSignDistIJK3 #-}

notUnsignDistIJK3 :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
notUnsignDistIJK3 :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
notUnsignDistIJK3 Int
i Int
j Int
k Int
d1 Int
d2 = Bool -> Bool
not (Bool -> Bool) -> (Array Int Int -> Bool) -> Array Int Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isUnsignDistIJK3 Int
i Int
j Int
k Int
d1 Int
d2
{-# INLINE notUnsignDistIJK3 #-}

notMixedDistIJK3 :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
notMixedDistIJK3 :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
notMixedDistIJK3 Int
i Int
j Int
k Int
d1 Int
d2 Array Int Int
arr = Int -> Int -> Int -> Array Int Int -> Bool
unsafeSignDistanceIJ Int
j Int
i Int
d1 Array Int Int
arr Bool -> Bool -> Bool
|| Bool -> Bool
not (Int -> Int -> Int -> Array Int Int -> Bool
unsafeUnsignDistanceIJ Int
j Int
k Int
d2 Array Int Int
arr)
{-# INLINE notMixedDistIJK3 #-}

notTripleOrdered :: Int -> Int -> Int -> Array Int Int -> Bool
notTripleOrdered :: Int -> Int -> Int -> Array Int Int -> Bool
notTripleOrdered Int
i Int
j Int
k = (Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Int8
7) (Int8 -> Bool) -> (Array Int Int -> Int8) -> Array Int Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Int -> Array Int Int -> Int8
forall (t :: * -> *) p.
(Foldable t, Eq p) =>
p -> p -> p -> t p -> Int8
f3 Int
i Int
j Int
k
{-# INLINE notTripleOrdered #-}

notQuadrupleOrdered :: Int -> Int -> Int -> Int -> Array Int Int -> Bool
notQuadrupleOrdered :: Int -> Int -> Int -> Int -> Array Int Int -> Bool
notQuadrupleOrdered Int
i Int
j Int
k Int
l = (Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Int8
15) (Int8 -> Bool) -> (Array Int Int -> Int8) -> Array Int Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Int -> Int -> Array Int Int -> Int8
forall (t :: * -> *) p.
(Foldable t, Eq p) =>
p -> p -> p -> p -> t p -> Int8
f4 Int
i Int
j Int
k Int
l
{-# INLINE notQuadrupleOrdered #-}

notQuintupleOrdered :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
notQuintupleOrdered :: Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
notQuintupleOrdered Int
i Int
j Int
k Int
l Int
m = (Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Int8
31) (Int8 -> Bool) -> (Array Int Int -> Int8) -> Array Int Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Int -> Int -> Int -> Array Int Int -> Int8
forall (t :: * -> *) p.
(Foldable t, Eq p) =>
p -> p -> p -> p -> p -> t p -> Int8
f5 Int
i Int
j Int
k Int
l Int
m
{-# INLINE notQuintupleOrdered #-}

notSeveralAOrdered :: Int -> Array Int Int -> Array Int Int -> Bool
notSeveralAOrdered :: Int -> Array Int Int -> Array Int Int -> Bool
notSeveralAOrdered !Int
i0 !Array Int Int
arr1 = Bool -> Bool
not (Bool -> Bool) -> (Array Int Int -> Bool) -> Array Int Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Array Int Int -> Array Int Int -> Bool
isSeveralAOrdered Int
i0 Array Int Int
arr1
{-# INLINE notSeveralAOrdered #-}

notSeveralBOrdered :: Int -> Array Int Int -> Array Int Int -> Bool
notSeveralBOrdered :: Int -> Array Int Int -> Array Int Int -> Bool
notSeveralBOrdered !Int
i0 !Array Int Int
arr1 = Bool -> Bool
not (Bool -> Bool) -> (Array Int Int -> Bool) -> Array Int Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Array Int Int -> Array Int Int -> Bool
isSeveralBOrdered Int
i0 Array Int Int
arr1
{-# INLINE notSeveralBOrdered #-}

notFixedPointTup :: Array Int (Int, Int) -> Array Int Int -> Bool
notFixedPointTup :: Array Int (Int, Int) -> Array Int Int -> Bool
notFixedPointTup Array Int (Int, Int)
arr1 Array Int Int
arr2 = ((Int, Int) -> Bool) -> Array Int (Int, Int) -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (\(Int
k, Int
j) -> Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt Array Int Int
arr2 Int
k Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
j) Array Int (Int, Int)
arr1
{-# INLINE notFixedPointTup #-}

notFixedPoint :: Array Int Int -> Array Int Int -> Bool
notFixedPoint :: Array Int Int -> Array Int Int -> Bool
notFixedPoint Array Int Int
arr1 Array Int Int
arr2 = (Int -> Bool) -> Array Int Int -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (\Int
k -> Array Int Int -> Int -> Int
forall i e. Array i e -> Int -> e
unsafeAt Array Int Int
arr2 Int
k Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
k) Array Int Int
arr1
{-# INLINE notFixedPoint #-}

notGrouppedTogether :: Int -> Int -> Array Int Int -> Bool
notGrouppedTogether :: Int -> Int -> Array Int Int -> Bool
notGrouppedTogether Int
i Int
j = Bool -> Bool
not (Bool -> Bool) -> (Array Int Int -> Bool) -> Array Int Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Array Int Int -> Bool
isGrouppedTogether Int
i Int
j
{-# INLINE notGrouppedTogether #-}