{-# OPTIONS_HADDOCK show-extensions #-}

-- |
-- Module      :  Phladiprelio.ConstraintsEncoded
-- Copyright   :  (c) OleksandrZhabenko 2020-2023
-- License     :  MIT
-- Stability   :  Experimental
-- Maintainer  :  oleksandr.zhabenko@yahoo.com
--
-- Provides a way to encode the needed constraint with possibly less symbols.
-- Uses arrays instead of vectors.

{-# LANGUAGE FlexibleInstances, FlexibleContexts, NoImplicitPrelude, BangPatterns #-}

module Phladiprelio.ConstraintsEncoded (
  -- * Data types
  EncodedContraints(..)
  , EncodedCnstrs
  -- * Functions to work with them
  -- ** Read functions
 , readMaybeECG
  -- ** Process-encoding functions
  , decodeConstraint1
  , decodeLConstraints
  , isConstraint1
  -- ** Modifiers and getters
  , getIEl
  , setIEl
  -- ** Predicates
  , isE
  , isP
  , isF
  , isQ
  , isT
  , isSA
  , isSB
  , isV
  , isW
  , isH
  , isR
  , isM
  -- * Algebraic general conversion
  , validOrdStr
  , generalConversion
  , filterGeneralConv
) where

import GHC.Base
import GHC.List
import GHC.Num ((+),(-),abs)
import Text.Show (show, Show(..))
import Text.Read (readMaybe)
import Data.Maybe
import Data.List (nub, words, groupBy)
import GHC.Arr
import Data.Char (isDigit, isLetter)
import Phladiprelio.Constraints
import Data.SubG (InsertLeft(..))
import Data.Tuple (fst)

data EncodedContraints a b = E 
                           | P a b 
                           | Q a a a a a 
                           | T a a a a 
                           | SA a a b 
                           | SB a a b 
                           | F a a a 
                           | V a a a 
                           | W a a a 
                           | H a a a a 
                           | R a a a a 
                           | M a a a a 
                           deriving (EncodedContraints a b -> EncodedContraints a b -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b.
(Eq a, Eq b) =>
EncodedContraints a b -> EncodedContraints a b -> Bool
/= :: EncodedContraints a b -> EncodedContraints a b -> Bool
$c/= :: forall a b.
(Eq a, Eq b) =>
EncodedContraints a b -> EncodedContraints a b -> Bool
== :: EncodedContraints a b -> EncodedContraints a b -> Bool
$c== :: forall a b.
(Eq a, Eq b) =>
EncodedContraints a b -> EncodedContraints a b -> Bool
Eq, EncodedContraints a b -> EncodedContraints a b -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a} {b}. (Ord a, Ord b) => Eq (EncodedContraints a b)
forall a b.
(Ord a, Ord b) =>
EncodedContraints a b -> EncodedContraints a b -> Bool
forall a b.
(Ord a, Ord b) =>
EncodedContraints a b -> EncodedContraints a b -> Ordering
forall a b.
(Ord a, Ord b) =>
EncodedContraints a b
-> EncodedContraints a b -> EncodedContraints a b
min :: EncodedContraints a b
-> EncodedContraints a b -> EncodedContraints a b
$cmin :: forall a b.
(Ord a, Ord b) =>
EncodedContraints a b
-> EncodedContraints a b -> EncodedContraints a b
max :: EncodedContraints a b
-> EncodedContraints a b -> EncodedContraints a b
$cmax :: forall a b.
(Ord a, Ord b) =>
EncodedContraints a b
-> EncodedContraints a b -> EncodedContraints a b
>= :: EncodedContraints a b -> EncodedContraints a b -> Bool
$c>= :: forall a b.
(Ord a, Ord b) =>
EncodedContraints a b -> EncodedContraints a b -> Bool
> :: EncodedContraints a b -> EncodedContraints a b -> Bool
$c> :: forall a b.
(Ord a, Ord b) =>
EncodedContraints a b -> EncodedContraints a b -> Bool
<= :: EncodedContraints a b -> EncodedContraints a b -> Bool
$c<= :: forall a b.
(Ord a, Ord b) =>
EncodedContraints a b -> EncodedContraints a b -> Bool
< :: EncodedContraints a b -> EncodedContraints a b -> Bool
$c< :: forall a b.
(Ord a, Ord b) =>
EncodedContraints a b -> EncodedContraints a b -> Bool
compare :: EncodedContraints a b -> EncodedContraints a b -> Ordering
$ccompare :: forall a b.
(Ord a, Ord b) =>
EncodedContraints a b -> EncodedContraints a b -> Ordering
Ord, Int -> EncodedContraints a b -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a b.
(Show a, Show b) =>
Int -> EncodedContraints a b -> ShowS
forall a b. (Show a, Show b) => [EncodedContraints a b] -> ShowS
forall a b. (Show a, Show b) => EncodedContraints a b -> String
showList :: [EncodedContraints a b] -> ShowS
$cshowList :: forall a b. (Show a, Show b) => [EncodedContraints a b] -> ShowS
show :: EncodedContraints a b -> String
$cshow :: forall a b. (Show a, Show b) => EncodedContraints a b -> String
showsPrec :: Int -> EncodedContraints a b -> ShowS
$cshowsPrec :: forall a b.
(Show a, Show b) =>
Int -> EncodedContraints a b -> ShowS
Show)

validOrdStr0 
  :: String 
  -> Int -- ^ Number of seen so far \'(\' parentheses
  -> Int -- ^ Number of seen so far \')\' parentheses
  -> Bool
validOrdStr0 :: String -> Int -> Int -> Bool
validOrdStr0 xs :: String
xs@(Char
'E':String
ys) Int
n Int
m = String -> Int -> Int -> Bool
validOrdStr0 String
ys Int
n Int
m
validOrdStr0 xs :: String
xs@(Char
' ':Char
y:Char
t:String
ys) Int
n Int
m
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"ABFHMPQRTVW" Bool -> Bool -> Bool
&& Char -> Bool
isDigit Char
t = String -> Int -> Int -> Bool
validOrdStr0 (forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isDigit String
ys) Int
n Int
m
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"-(E" = String -> Int -> Int -> Bool
validOrdStr0 (Char
yforall a. a -> [a] -> [a]
:Char
tforall a. a -> [a] -> [a]
:String
ys) Int
n Int
m
  | Bool
otherwise = Bool
False  
validOrdStr0 xs :: String
xs@(Char
'(':Char
y:Char
t:String
ys) Int
n Int
m
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"ABFHMPQRTVW" Bool -> Bool -> Bool
&& Char -> Bool
isDigit Char
t = String -> Int -> Int -> Bool
validOrdStr0 (forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isDigit String
ys) (Int
n forall a. Num a => a -> a -> a
+ Int
1) Int
m
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"-(E" = String -> Int -> Int -> Bool
validOrdStr0 (Char
yforall a. a -> [a] -> [a]
:Char
tforall a. a -> [a] -> [a]
:String
ys) (Int
n forall a. Num a => a -> a -> a
+ Int
1) Int
m
  | Bool
otherwise = Bool
False  
validOrdStr0 xs :: String
xs@(Char
')':Char
y:Char
t:String
ys) Int
n Int
m
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"ABFHMPQRTVW" Bool -> Bool -> Bool
&& Char -> Bool
isDigit Char
t = String -> Int -> Int -> Bool
validOrdStr0 (forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isDigit String
ys) Int
n (Int
m forall a. Num a => a -> a -> a
+ Int
1)
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"-()E" = String -> Int -> Int -> Bool
validOrdStr0 (Char
yforall a. a -> [a] -> [a]
:Char
tforall a. a -> [a] -> [a]
:String
ys) Int
n (Int
m forall a. Num a => a -> a -> a
+ Int
1)
  | Bool
otherwise = Bool
False  
validOrdStr0 xs :: String
xs@(Char
'-':Char
y:Char
t:String
ys) Int
n Int
m
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"ABFHMPQRTVW" Bool -> Bool -> Bool
&& Char -> Bool
isDigit Char
t = String -> Int -> Int -> Bool
validOrdStr0 (forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isDigit String
ys) Int
n Int
m 
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"-)" Bool -> Bool -> Bool
|| Char -> Bool
isDigit Char
y = Bool
False
  | Bool
otherwise = String -> Int -> Int -> Bool
validOrdStr0 (Char
yforall a. a -> [a] -> [a]
:Char
tforall a. a -> [a] -> [a]
:String
ys) Int
n Int
m 
validOrdStr0 xs :: String
xs@(Char
x:Char
y:Char
t:String
ys) Int
n Int
m 
  | Char
x forall a. Eq a => a -> [a] -> Bool
`elem` String
"ABFHMPQRTVW" = if Char -> Bool
isDigit Char
y then String -> Int -> Int -> Bool
validOrdStr0 (forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isDigit (Char
tforall a. a -> [a] -> [a]
:String
ys)) Int
n Int
m else Bool
False
  | Bool
otherwise = String -> Int -> Int -> Bool
validOrdStr0 (Char
yforall a. a -> [a] -> [a]
:Char
tforall a. a -> [a] -> [a]
:String
ys) Int
n (Int
m forall a. Num a => a -> a -> a
+ Int
1) 
validOrdStr0 xs :: String
xs@(Char
x:Char
')':String
ys) Int
n Int
m 
  | Char -> Bool
isDigit Char
x Bool -> Bool -> Bool
|| Char
x forall a. Eq a => a -> a -> Bool
== Char
')' = String -> Int -> Int -> Bool
validOrdStr0 String
ys Int
n (if Char
x forall a. Eq a => a -> a -> Bool
== Char
')' then Int
m forall a. Num a => a -> a -> a
+ Int
2 else Int
m forall a. Num a => a -> a -> a
+ Int
1) 
  | Bool
otherwise = Bool
False
validOrdStr0 xs :: String
xs@(Char
x:Char
y:String
ys) Int
n Int
m 
  | Char
x forall a. Eq a => a -> [a] -> Bool
`elem` String
"(ABFHMQRTVW" = Bool
False
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
" -(ABFHMPQRTVW" = Bool
False
  | Char
x forall a. Eq a => a -> a -> Bool
== Char
'P' Bool -> Bool -> Bool
&& Bool -> Bool
not (Char -> Bool
isDigit Char
y) = Bool
False
  | Char
x forall a. Eq a => a -> a -> Bool
== Char
')' Bool -> Bool -> Bool
&& Char
y forall a. Eq a => a -> [a] -> Bool
`notElem` String
")E" = Bool
False
  | Char
x forall a. Eq a => a -> a -> Bool
== Char
'P' Bool -> Bool -> Bool
&& Int
n forall a. Eq a => a -> a -> Bool
== Int
m = Bool
True
  | Char
x forall a. Eq a => a -> a -> Bool
== Char
')' Bool -> Bool -> Bool
&& Char
y forall a. Eq a => a -> a -> Bool
== Char
')' = Int
n forall a. Eq a => a -> a -> Bool
== (Int
m forall a. Num a => a -> a -> a
+ Int
2)
  | Char
x forall a. Eq a => a -> a -> Bool
== Char
')' Bool -> Bool -> Bool
&& Char
y forall a. Eq a => a -> a -> Bool
== Char
'E' = Int
n forall a. Eq a => a -> a -> Bool
== (Int
m forall a. Num a => a -> a -> a
+ Int
1)
  | (Char
x forall a. Eq a => a -> [a] -> Bool
`elem` String
"E -") Bool -> Bool -> Bool
&& Char
y forall a. Eq a => a -> a -> Bool
== Char
'E' = Int
n forall a. Eq a => a -> a -> Bool
== Int
m 
  | Char
x forall a. Eq a => a -> a -> Bool
== Char
'E' Bool -> Bool -> Bool
&& Char
y forall a. Eq a => a -> a -> Bool
== Char
')' = Int
n forall a. Eq a => a -> a -> Bool
== (Int
m forall a. Num a => a -> a -> a
+ Int
1)
  | Bool
otherwise = Bool
False
validOrdStr0 xs :: String
xs@(Char
x:String
ys) Int
n Int
m 
  | Char -> Bool
isDigit Char
x Bool -> Bool -> Bool
|| (Char
x forall a. Eq a => a -> [a] -> Bool
`elem` String
")E") = if Char
x forall a. Eq a => a -> a -> Bool
== Char
')' then Int
n forall a. Eq a => a -> a -> Bool
== (Int
m forall a. Num a => a -> a -> a
+ Int
1) else Int
n forall a. Eq a => a -> a -> Bool
== Int
m 
  | Bool
otherwise = Bool
False
validOrdStr0 String
_ Int
n Int
m  = Int
n forall a. Eq a => a -> a -> Bool
== Int
m

-- | An extended predicate to check whether the 'String' is a probably correct representation of the
-- constraints algebraic expression for 'generalConversion' evaluation.
validOrdStr :: String -> Bool
validOrdStr :: String -> Bool
validOrdStr String
xs = String -> Int -> Int -> Bool
validOrdStr0 String
xs Int
0 Int
0 
{-# INLINE validOrdStr #-}

stage1Parsing :: String -> [String]
stage1Parsing :: String -> [String]
stage1Parsing =  forall a. (a -> a -> Bool) -> [a] -> [[a]]
groupBy (\Char
x Char
y -> Char
x forall a. Eq a => a -> a -> Bool
== Char
'(' Bool -> Bool -> Bool
&& Char
y forall a. Eq a => a -> a -> Bool
== Char
'(' Bool -> Bool -> Bool
|| Char -> Bool
isLetter Char
x Bool -> Bool -> Bool
&& Char -> Bool
isDigit Char
y Bool -> Bool -> Bool
|| Char
x forall a. Eq a => a -> a -> Bool
== Char
')' Bool -> Bool -> Bool
&& Char
y forall a. Eq a => a -> a -> Bool
== Char
')')
{-# INLINE stage1Parsing #-}

convertToBools 
  :: Int 
  -> Array Int Int 
  -> [String] 
  -> String -- ^ The result is a 'String' that Haskell can evaluate to 'Bool' (some logical expression).
convertToBools :: Int -> Array Int Int -> [String] -> String
convertToBools Int
n Array Int Int
arr xss :: [String]
xss@(String
"-":[String]
yss) = String
"not " forall a. Monoid a => a -> a -> a
`mappend` (Int -> Array Int Int -> [String] -> String
convertToBools Int
n Array Int Int
arr [String]
yss)
convertToBools Int
n Array Int Int
arr xss :: [String]
xss@(String
" ":[String]
yss) = String
" || " forall a. Monoid a => a -> a -> a
`mappend` (Int -> Array Int Int -> [String] -> String
convertToBools Int
n Array Int Int
arr [String]
yss)
convertToBools Int
n Array Int Int
arr xss :: [String]
xss@(String
xs:yss :: [String]
yss@(String
ys:[String]
tss))
  | forall a. (a -> Bool) -> [a] -> Bool
any (forall a. Eq a => a -> a -> Bool
== Char
'(') String
xs = String
xs forall a. Monoid a => a -> a -> a
`mappend` String
" " forall a. Monoid a => a -> a -> a
`mappend` Int -> Array Int Int -> [String] -> String
convertToBools Int
n Array Int Int
arr [String]
yss
  | forall a. (a -> Bool) -> [a] -> Bool
any (forall a. Eq a => a -> a -> Bool
== Char
')') String
xs = String
xs forall a. Monoid a => a -> a -> a
`mappend` (if String
ys forall a. Eq a => a -> a -> Bool
== String
" " then String
"" else String
" && ") forall a. Monoid a => a -> a -> a
`mappend` Int -> Array Int Int -> [String] -> String
convertToBools Int
n Array Int Int
arr [String]
yss
  | String
xs forall a. Eq a => a -> [a] -> Bool
`elem` [String
"True",String
"False"] = String
xs forall a. Monoid a => a -> a -> a
`mappend` (case String
ys of 
                                                 Char
')':String
_ -> String
" " 
                                                 String
" "   -> String
" "
                                                 String
_     -> String
" && ") forall a. Monoid a => a -> a -> a
`mappend` Int -> Array Int Int -> [String] -> String
convertToBools Int
n Array Int Int
arr [String]
yss 
  | Bool
otherwise = let cnstrs :: EncodedContraints Int (Array Int Int)
cnstrs = forall a. a -> Maybe a -> a
fromMaybe forall a b. EncodedContraints a b
E forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String -> Maybe (EncodedContraints Int (Array Int Int))
readMaybeECG Int
n forall a b. (a -> b) -> a -> b
$ String
xs in 
                      forall a. Show a => a -> String
show (Bool
-> Array Int Int -> EncodedContraints Int (Array Int Int) -> Bool
isConstraint1 Bool
True Array Int Int
arr EncodedContraints Int (Array Int Int)
cnstrs) 
                      forall a. Monoid a => a -> a -> a
`mappend` (case String
ys of 
                                   Char
')':String
_ -> String
" " 
                                   String
" "   -> String
" "
                                   String
_     -> String
" && ") forall a. Monoid a => a -> a -> a
`mappend` Int -> Array Int Int -> [String] -> String
convertToBools Int
n Array Int Int
arr [String]
yss 
convertToBools Int
n Array Int Int
arr xss :: [String]
xss@(String
xs:[String]
yss) 
  | forall a. (a -> Bool) -> [a] -> Bool
any (forall a. Eq a => a -> a -> Bool
== Char
')') String
xs = String
xs 
  | String
xs forall a. Eq a => a -> [a] -> Bool
`elem` [String
"True",String
"False"] = String
xs
  | Bool
otherwise = (forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool
-> Array Int Int -> EncodedContraints Int (Array Int Int) -> Bool
isConstraint1 Bool
True Array Int Int
arr forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a -> a
fromMaybe forall a b. EncodedContraints a b
E forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String -> Maybe (EncodedContraints Int (Array Int Int))
readMaybeECG Int
n forall a b. (a -> b) -> a -> b
$ String
xs) -- `mappend` "!!!!!"
convertToBools Int
n Array Int Int
arr [String]
_ = String
""

splitNoParenAtDisjunction :: [String] -> [[String]]
splitNoParenAtDisjunction :: [String] -> [[String]]
splitNoParenAtDisjunction xss :: [String]
xss@(String
xs:[String]
yss) 
  | forall a. [a] -> Bool
null [String]
tss = []
  | Bool
otherwise = [String]
tss forall a. a -> [a] -> [a]
: [String] -> [[String]]
splitNoParenAtDisjunction [String]
wss 
      where ([String]
tss,[String]
uss) = forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== String
"||") [String]
xss
            wss :: [String]
wss = forall a. Int -> [a] -> [a]
drop Int
1 [String]
uss 
splitNoParenAtDisjunction [String]
_ = []

noParenString0 :: [String] -> Bool 
noParenString0 :: [String] -> Bool
noParenString0 xss :: [String]
xss@(String
xs:String
ys:String
ts:[String]
yss) 
  | String
xs forall a. Eq a => a -> a -> Bool
== String
"not" = 
      case String
ys of 
        String
"True" -> Bool
False 
        String
"False" -> [String] -> Bool
noParenString0 [String]
yss 
  | Bool
otherwise = 
      case String
xs of
        String
"True" -> [String] -> Bool
noParenString0 (String
tsforall a. a -> [a] -> [a]
:[String]
yss)
        String
"False" -> Bool
False 
noParenString0 xss :: [String]
xss@(String
"not":String
ys:[String]
yss) = if String
ys forall a. Eq a => a -> a -> Bool
== String
"True" then Bool
False else Bool
True 
noParenString0 xss :: [String]
xss@(String
xs:[String]
yss) 
  | String
xs forall a. Eq a => a -> a -> Bool
== String
"True" = Bool
True 
  | Bool
otherwise = Bool
False 
noParenString0 [String]
_ = Bool
True

noParenString :: [String] -> Bool
noParenString :: [String] -> Bool
noParenString = [Bool] -> Bool
or forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map [String] -> Bool
noParenString0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> [[String]]
splitNoParenAtDisjunction
{-# INLINE noParenString #-}

oneChange :: Int -> Array Int Int -> [String] -> [String]
oneChange :: Int -> Array Int Int -> [String] -> [String]
oneChange Int
m Array Int Int
arr [String]
xss 
  | forall a. [a] -> Bool
null [String]
wss = [forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> Bool
noParenString forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
words forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Array Int Int -> [String] -> String
convertToBools Int
m Array Int Int
arr forall a b. (a -> b) -> a -> b
$ [String]
xss]
  | Bool
otherwise = ((\([String]
jss, Int
m, [String]
qss) -> [String]
jss forall a. Monoid a => a -> a -> a
`mappend` [forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> Bool
noParenString forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
words forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Array Int Int -> [String] -> String
convertToBools Int
m Array Int Int
arr forall a b. (a -> b) -> a -> b
$ [String]
qss]) forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
                  forall a b. (a -> b -> b) -> b -> [a] -> b
foldr (\String
xs uss :: ([String], Int, [String])
uss@([String]
tss, Int
n, [String]
rss) -> if String
xs forall a. Eq a => a -> a -> Bool
== String
"(" Bool -> Bool -> Bool
&& Int
n forall a. Eq a => a -> a -> Bool
== Int
0 
                                                      then ([String]
tss, Int
1, [String]
rss) 
                                                      else if forall a. (a -> Bool) -> [a] -> Bool
any (forall a. Eq a => a -> a -> Bool
== Char
'(') String
xs Bool -> Bool -> Bool
&& Int
n forall a. Eq a => a -> a -> Bool
== Int
0
                                                               then (forall a. Int -> [a] -> [a]
drop Int
1 String
xsforall a. a -> [a] -> [a]
:[String]
tss, Int
n, [String]
rss)
                                                               else case Int
n of 
                                                                      Int
0 -> ([String]
tss, Int
0, String
xsforall a. a -> [a] -> [a]
:[String]
rss)
                                                                      Int
1 -> (String
xsforall a. a -> [a] -> [a]
:[String]
tss, Int
1, [String]
rss)) ([], Int
0, []) forall a b. (a -> b) -> a -> b
$ [String]
yss) forall a. Monoid a => a -> a -> a
`mappend` [String]
kss
  where ([String]
yss,[String]
wss) = forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. (a -> Bool) -> [a] -> Bool
any (forall a. Eq a => a -> a -> Bool
== Char
')')) [String]
xss
        kss :: [String]
kss = case [String]
wss of
                String
ws:[String]
vss -> if forall a. [a] -> Int
length String
ws forall a. Eq a => a -> a -> Bool
== Int
1 then [String]
vss else forall a. Int -> [a] -> [a]
drop Int
1 String
ws forall a. a -> [a] -> [a]
: [String]
vss
                [String]
_      -> [String]
wss

generalConversion :: Int -> String -> Array Int Int -> Bool
generalConversion :: Int -> String -> Array Int Int -> Bool
generalConversion Int
m String
xs Array Int Int
arr
  | String -> Bool
validOrdStr String
xs =  (\String
ks -> if String
ks forall a. Eq a => a -> a -> Bool
== String
"True" Bool -> Bool -> Bool
|| String
ks forall a. Eq a => a -> a -> Bool
== String
"E" then Bool
True else Bool
False) forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
      forall a. [a] -> a
head forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> a
head forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
dropWhile ((forall a. Eq a => a -> a -> Bool
/= Int
1) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Int
length)  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> [a]
drop Int
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> a) -> a -> [a]
iterate (Int -> Array Int Int -> [String] -> [String]
oneChange Int
m Array Int Int
arr) forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
stage1Parsing forall a b. (a -> b) -> a -> b
$ String
xs 
  | Bool
otherwise = Bool
False
{-# INLINE generalConversion #-}

-- | Can be thought of as 'filter' ('generalConversion' ... ) @<arrays>@ but is somewhat more efficient.
filterGeneralConv :: Int -> String -> [Array Int Int] -> [Array Int Int]
filterGeneralConv :: Int -> String -> [Array Int Int] -> [Array Int Int]
filterGeneralConv Int
m String
cnstrns [Array Int Int]
xs 
  | String -> Bool
validOrdStr String
cnstrns = let !xss :: [String]
xss = String -> [String]
stage1Parsing String
cnstrns in  
    forall a. (a -> Bool) -> [a] -> [a]
filter (\Array Int Int
arr -> (\String
ks -> if String
ks forall a. Eq a => a -> a -> Bool
== String
"True" Bool -> Bool -> Bool
|| String
ks forall a. Eq a => a -> a -> Bool
== String
"E" then Bool
True else Bool
False) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> a
head forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> a
head forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
dropWhile ((forall a. Eq a => a -> a -> Bool
/= Int
1) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Int
length) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> [a]
drop Int
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> a) -> a -> [a]
iterate (Int -> Array Int Int -> [String] -> [String]
oneChange Int
m Array Int Int
arr) forall a b. (a -> b) -> a -> b
$ [String]
xss) [Array Int Int]
xs
  | Bool
otherwise = []
{-# INLINE filterGeneralConv #-}

-- | Inspired by the: https://hackage.haskell.org/package/base-4.14.0.0/docs/Data-Maybe.html
-- Is provided here as a more general way to read the 'String' into a 'EncodedCnstrs'. 
-- It is up to user to check whether the parameters are in the correct form, the function does
-- not do the full checking.
readMaybeECG :: Int -> String -> Maybe EncodedCnstrs
readMaybeECG :: Int -> String -> Maybe (EncodedContraints Int (Array Int Int))
readMaybeECG Int
n String
xs
 | forall a. [a] -> Bool
null String
xs = forall a. Maybe a
Nothing
 | Int
n forall a. Ord a => a -> a -> Bool
>=Int
0 Bool -> Bool -> Bool
&& Int
n forall a. Ord a => a -> a -> Bool
<= Int
9 =
     let h :: Char
h = forall a. [a] -> a
head String
xs
         ts :: String
ts = forall a. (a -> Bool) -> [a] -> [a]
filter (\Char
x -> Char
x forall a. Ord a => a -> a -> Bool
>= Char
'0' Bool -> Bool -> Bool
&& [Char
x] forall a. Ord a => a -> a -> Bool
<= forall a. Show a => a -> String
show Int
n) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
tail forall a b. (a -> b) -> a -> b
$ String
xs in
      case Char
h of
       Char
'E' -> forall a. a -> Maybe a
Just forall a b. EncodedContraints a b
E
       Char
_   -> Int
-> Char -> String -> Maybe (EncodedContraints Int (Array Int Int))
f Int
n Char
h String
ts
 | Bool
otherwise = forall a. Maybe a
Nothing
         where f :: Int
-> Char -> String -> Maybe (EncodedContraints Int (Array Int Int))
f Int
n Char
c String
ts 
                 | Char
c forall a. Eq a => a -> [a] -> Bool
`elem` String
"HFMRQTVW" = let ys :: [Int]
ys = forall a. Eq a => [a] -> [a]
nub forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Maybe a] -> [a]
catMaybes forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (\Char
t -> forall a. Read a => String -> Maybe a
readMaybe [Char
t]::Maybe Int) forall a b. (a -> b) -> a -> b
$ String
ts
                                             res :: Maybe (EncodedContraints Int b)
res 
                                               | forall a. [a] -> Int
length [Int]
ys forall a. Eq a => a -> a -> Bool
/= forall {a}. Num a => Char -> a
g Char
c = forall a. Maybe a
Nothing
                                               | Char
c forall a. Eq a => a -> a -> Bool
== Char
'Q' = let [Int
y,Int
z,Int
u,Int
w] = forall a b. (a -> b) -> [a] -> [b]
map (\Int
rr -> if Int
rr  forall a. Eq a => a -> a -> Bool
== Int
0 then Int
9 else Int
rr forall a. Num a => a -> a -> a
- Int
1) [Int]
ys in forall a. a -> Maybe a
Just (forall a b. a -> a -> a -> a -> a -> EncodedContraints a b
Q Int
n Int
y Int
z Int
u Int
w)
                                               | Char
c forall a. Eq a => a -> [a] -> Bool
`elem` String
"FVW" = let [Int
y,Int
z] = forall a b. (a -> b) -> [a] -> [b]
map (\Int
rr -> if Int
rr  forall a. Eq a => a -> a -> Bool
== Int
0 then Int
9 else Int
rr forall a. Num a => a -> a -> a
- Int
1) [Int]
ys in forall a. a -> Maybe a
Just ((case Char
c of {Char
'F' -> forall a b. a -> a -> a -> EncodedContraints a b
F; Char
'V'-> forall a b. a -> a -> a -> EncodedContraints a b
V; ~Char
ww -> forall a b. a -> a -> a -> EncodedContraints a b
W}) Int
n Int
y Int
z)
                                               | Bool
otherwise = let [Int
y,Int
z,Int
u] = forall a b. (a -> b) -> [a] -> [b]
map (\Int
rr -> if Int
rr  forall a. Eq a => a -> a -> Bool
== Int
0 then Int
9 else Int
rr forall a. Num a => a -> a -> a
- Int
1) [Int]
ys in forall a. a -> Maybe a
Just ((case Char
c of {Char
'T' -> forall a b. a -> a -> a -> a -> EncodedContraints a b
T; Char
'H' -> forall a b. a -> a -> a -> a -> EncodedContraints a b
H; Char
'M' -> forall a b. a -> a -> a -> a -> EncodedContraints a b
M; ~Char
rr -> forall a b. a -> a -> a -> a -> EncodedContraints a b
R}) Int
n Int
y Int
z Int
u) in forall {b}. Maybe (EncodedContraints Int b)
res
                 | Char
c forall a. Eq a => a -> [a] -> Bool
`elem` String
"AB" = let y :: Maybe Int
y = forall a. Read a => String -> Maybe a
readMaybe (forall a. Int -> [a] -> [a]
take Int
1 String
ts)::Maybe Int in
                                     if forall a. Maybe a -> Bool
isJust Maybe Int
y then
                                         let y0 :: Int
y0 = forall a. HasCallStack => Maybe a -> a
fromJust Maybe Int
y
                                             zs :: [Int]
zs = forall a b. (a -> b) -> [a] -> [b]
map (\Int
rr -> if Int
rr  forall a. Eq a => a -> a -> Bool
== Int
0 then Int
9 else Int
rr forall a. Num a => a -> a -> a
- Int
1) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
filter (forall a. Eq a => a -> a -> Bool
/= Int
y0) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => [a] -> [a]
nub forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Maybe a] -> [a]
catMaybes forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (\Char
t -> forall a. Read a => String -> Maybe a
readMaybe [Char
t]::Maybe Int) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> [a]
drop Int
1 forall a b. (a -> b) -> a -> b
$ String
ts in
                                               case [Int]
zs of
                                                 [] -> forall a. Maybe a
Nothing
                                                 ~[Int]
x2 -> forall a. a -> Maybe a
Just ((if Char
c forall a. Eq a => a -> a -> Bool
== Char
'A' then forall a b. a -> a -> b -> EncodedContraints a b
SA else forall a b. a -> a -> b -> EncodedContraints a b
SB) Int
n (if Int
y0 forall a. Eq a => a -> a -> Bool
== Int
0 then Int
9 else Int
y0 forall a. Num a => a -> a -> a
- Int
1) (forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,forall a. [a] -> Int
length [Int]
x2 forall a. Num a => a -> a -> a
- Int
1) [Int]
x2))
                                     else forall a. Maybe a
Nothing 
                 | Char
c forall a. Eq a => a -> a -> Bool
== Char
'P' = if forall a. [a] -> Bool
null String
ts then forall a. a -> Maybe a
Just forall a b. EncodedContraints a b
E else forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> EncodedContraints a b
P Int
n forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,forall a. [a] -> Int
length String
ts forall a. Num a => a -> a -> a
- Int
1) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (\Char
r -> case (forall a. HasCallStack => Maybe a -> a
fromJust (forall a. Read a => String -> Maybe a
readMaybe [Char
r]::Maybe Int)) of {Int
0 -> Int
9; Int
n -> Int
nforall a. Num a => a -> a -> a
-Int
1}) forall a b. (a -> b) -> a -> b
$ String
ts
                 | Bool
otherwise = forall a. Maybe a
Nothing
               g :: Char -> a
g Char
c 
                 | Char
c forall a. Eq a => a -> [a] -> Bool
`elem` String
"FVW" = a
2
                 | Char
c forall a. Eq a => a -> a -> Bool
== Char
'Q' = a
4
                 | Bool
otherwise = a
3


type EncodedCnstrs = EncodedContraints Int (Array Int Int)

-- | Must be applied to the correct array of permutation indeces. Otherwise, it gives runtime error (exception). All the integers inside the
-- 'EncodedCnstrs' must be in the range [0..n-1] where @n@ corresponds to the maximum element in the permutation 'Array' 'Int' 'Int'. 
decodeConstraint1 :: (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) => EncodedCnstrs -> t (Array Int Int) -> t (Array Int Int)
decodeConstraint1 :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
EncodedContraints Int (Array Int Int)
-> t (Array Int Int) -> t (Array Int Int)
decodeConstraint1 EncodedContraints Int (Array Int Int)
E = forall a. a -> a
id
decodeConstraint1 (P Int
_ Array Int Int
v) = 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
v
decodeConstraint1 (Q Int
_ Int
i Int
j Int
k Int
l) = 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
decodeConstraint1 (T Int
_ Int
i Int
j Int
k) = 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
decodeConstraint1 (SA Int
_ Int
i Array Int Int
v) = 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
i Array Int Int
v
decodeConstraint1 (SB Int
_ Int
i Array Int Int
v) = 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
i Array Int Int
v
decodeConstraint1 (F Int
_ Int
i Int
j) = 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
decodeConstraint1 (V Int
_ Int
i Int
j) = 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 (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i)
decodeConstraint1 (W Int
_ Int
i Int
j) = 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 (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i)
decodeConstraint1 (H Int
_ Int
i Int
j Int
k) = 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 (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j)
decodeConstraint1 (R Int
_ Int
i Int
j Int
k) = 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 (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j)
decodeConstraint1 (M Int
_ Int
i Int
j Int
k) = 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 (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j)

-- | Must be applied to the correct array of permutation indeces. Otherwise, it gives runtime error (exception). All the integers inside the
-- 'EncodedCnstrs' must be in the range [0..n-1] where @n@ corresponds to the maximum element in the permutation 'Array' 'Int' 'Int'.
decodeLConstraints :: (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) => [EncodedCnstrs] -> t (Array Int Int) -> t (Array Int Int)
decodeLConstraints :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
[EncodedContraints Int (Array Int Int)]
-> t (Array Int Int) -> t (Array Int Int)
decodeLConstraints (EncodedContraints Int (Array Int Int)
x:[EncodedContraints Int (Array Int Int)]
xs) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
[EncodedContraints Int (Array Int Int)]
-> t (Array Int Int) -> t (Array Int Int)
decodeLConstraints' [EncodedContraints Int (Array Int Int)]
ys forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
EncodedContraints Int (Array Int Int)
-> t (Array Int Int) -> t (Array Int Int)
decodeConstraint1 EncodedContraints Int (Array Int Int)
y
  where y :: EncodedContraints Int (Array Int Int)
y = forall a. Ord a => [a] -> a
minimum (EncodedContraints Int (Array Int Int)
xforall a. a -> [a] -> [a]
:[EncodedContraints Int (Array Int Int)]
xs)
        ys :: [EncodedContraints Int (Array Int Int)]
ys = forall a. (a -> Bool) -> [a] -> [a]
filter (forall a. Eq a => a -> a -> Bool
/= EncodedContraints Int (Array Int Int)
y) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {a} {b}. [EncodedContraints a b] -> [EncodedContraints a b]
g forall a b. (a -> b) -> a -> b
$ (EncodedContraints Int (Array Int Int)
xforall a. a -> [a] -> [a]
:[EncodedContraints Int (Array Int Int)]
xs)
        g :: [EncodedContraints a b] -> [EncodedContraints a b]
g (EncodedContraints a b
E:[EncodedContraints a b]
zs) = [EncodedContraints a b] -> [EncodedContraints a b]
g [EncodedContraints a b]
zs
        g (EncodedContraints a b
z:[EncodedContraints a b]
zs) = EncodedContraints a b
z forall a. a -> [a] -> [a]
: [EncodedContraints a b] -> [EncodedContraints a b]
g [EncodedContraints a b]
zs
        g [EncodedContraints a b]
_ = []
        decodeLConstraints' :: [EncodedContraints Int (Array Int Int)]
-> t (Array Int Int) -> t (Array Int Int)
decodeLConstraints' (EncodedContraints Int (Array Int Int)
z:[EncodedContraints Int (Array Int Int)]
zs) = [EncodedContraints Int (Array Int Int)]
-> t (Array Int Int) -> t (Array Int Int)
decodeLConstraints' [EncodedContraints Int (Array Int Int)]
zs forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
EncodedContraints Int (Array Int Int)
-> t (Array Int Int) -> t (Array Int Int)
decodeConstraint1 EncodedContraints Int (Array Int Int)
z
        decodeLConstraints' [EncodedContraints Int (Array Int Int)]
_ = forall a. a -> a
id
decodeLConstraints [EncodedContraints Int (Array Int Int)]
_ = forall a. a -> a
id

isConstraint1 :: Bool -> Array Int Int -> EncodedCnstrs -> Bool
isConstraint1 :: Bool
-> Array Int Int -> EncodedContraints Int (Array Int Int) -> Bool
isConstraint1 Bool
bool Array Int Int
arr EncodedContraints Int (Array Int Int)
E = Bool
bool
isConstraint1 Bool
True Array Int Int
arr (F Int
_ Int
i Int
j) = Int -> Int -> Array Int Int -> Bool
unsafeOrderIJ Int
i Int
j Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (T Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Array Int Int -> Bool
isTripleOrdered Int
i Int
j Int
k Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (Q Int
_ Int
i Int
j Int
k Int
l) = Int -> Int -> Int -> Int -> Array Int Int -> Bool
isQuadrupleOrdered Int
i Int
j Int
k Int
l Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (SA Int
_ Int
i Array Int Int
arr2) = Int -> Array Int Int -> Array Int Int -> Bool
isSeveralAOrdered Int
i Array Int Int
arr2 Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (SB Int
_ Int
i Array Int Int
arr2) = Int -> Array Int Int -> Array Int Int -> Bool
isSeveralBOrdered Int
i Array Int Int
arr2 Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (P Int
_ Array Int Int
arr2) = Array Int Int -> Array Int Int -> Bool
isFixedPoint Array Int Int
arr2 Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (H Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isSignDistIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j) Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (M Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isMixedDistIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j) Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (R Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isUnsignDistIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j) Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (V Int
_ Int
i Int
j) = Int -> Int -> Int -> Array Int Int -> Bool
unsafeSignDistanceIJ Int
i Int
j (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (W Int
_ Int
i Int
j) = Int -> Int -> Int -> Array Int Int -> Bool
unsafeUnsignDistanceIJ Int
i Int
j (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (F Int
_ Int
i Int
j) = Int -> Int -> Array Int Int -> Bool
unsafeOrderIJ Int
j Int
i Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (T Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Array Int Int -> Bool
notTripleOrdered Int
i Int
j Int
k Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (Q Int
_ Int
i Int
j Int
k Int
l) = Int -> Int -> Int -> Int -> Array Int Int -> Bool
notQuadrupleOrdered Int
i Int
j Int
k Int
l Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (SA Int
_ Int
i Array Int Int
arr2) = Int -> Array Int Int -> Array Int Int -> Bool
notSeveralAOrdered Int
i Array Int Int
arr2 Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (SB Int
_ Int
i Array Int Int
arr2) = Int -> Array Int Int -> Array Int Int -> Bool
notSeveralBOrdered Int
i Array Int Int
arr2 Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (P Int
_ Array Int Int
arr2) = Array Int Int -> Array Int Int -> Bool
notFixedPoint Array Int Int
arr2 Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (H Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
notSignDistIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j) Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (M Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
notMixedDistIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j) Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (R Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
notUnsignDistIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j) Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (V Int
_ Int
i Int
j) = Int -> Int -> Int -> Array Int Int -> Bool
unsafeSignDistanceIJ Int
j Int
i (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (W Int
_ Int
i Int
j) = Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Int -> Array Int Int -> Bool
unsafeUnsignDistanceIJ Int
i Int
j (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) forall a b. (a -> b) -> a -> b
$ Array Int Int
arr 

isE :: EncodedCnstrs -> Bool
isE :: EncodedContraints Int (Array Int Int) -> Bool
isE EncodedContraints Int (Array Int Int)
E = Bool
True
isE EncodedContraints Int (Array Int Int)
_ = Bool
False

isP :: EncodedCnstrs -> Bool
isP :: EncodedContraints Int (Array Int Int) -> Bool
isP (P Int
_ Array Int Int
_) = Bool
True
isP EncodedContraints Int (Array Int Int)
_ = Bool
False

isF :: EncodedCnstrs -> Bool
isF :: EncodedContraints Int (Array Int Int) -> Bool
isF (F Int
_ Int
_ Int
_) = Bool
True
isF EncodedContraints Int (Array Int Int)
_ = Bool
False

isT :: EncodedCnstrs -> Bool
isT :: EncodedContraints Int (Array Int Int) -> Bool
isT (T Int
_ Int
_ Int
_ Int
_) = Bool
True
isT EncodedContraints Int (Array Int Int)
_ = Bool
False

isQ :: EncodedCnstrs -> Bool
isQ :: EncodedContraints Int (Array Int Int) -> Bool
isQ (Q Int
_ Int
_ Int
_ Int
_ Int
_) = Bool
True
isQ EncodedContraints Int (Array Int Int)
_ = Bool
False

isSA :: EncodedCnstrs -> Bool
isSA :: EncodedContraints Int (Array Int Int) -> Bool
isSA (SA Int
_ Int
_ Array Int Int
_) = Bool
True
isSA EncodedContraints Int (Array Int Int)
_ = Bool
False

isSB :: EncodedCnstrs -> Bool
isSB :: EncodedContraints Int (Array Int Int) -> Bool
isSB (SB Int
_ Int
_ Array Int Int
_) = Bool
True
isSB EncodedContraints Int (Array Int Int)
_ = Bool
False

isV :: EncodedCnstrs -> Bool
isV :: EncodedContraints Int (Array Int Int) -> Bool
isV (V Int
_ Int
_ Int
_) = Bool
True
isV EncodedContraints Int (Array Int Int)
_ = Bool
False

isW :: EncodedCnstrs -> Bool
isW :: EncodedContraints Int (Array Int Int) -> Bool
isW (W Int
_ Int
_ Int
_) = Bool
True
isW EncodedContraints Int (Array Int Int)
_ = Bool
False

isH :: EncodedCnstrs -> Bool
isH :: EncodedContraints Int (Array Int Int) -> Bool
isH (H Int
_ Int
_ Int
_ Int
_) = Bool
True
isH EncodedContraints Int (Array Int Int)
_ = Bool
False

isR :: EncodedCnstrs -> Bool
isR :: EncodedContraints Int (Array Int Int) -> Bool
isR (R Int
_ Int
_ Int
_ Int
_) = Bool
True
isR EncodedContraints Int (Array Int Int)
_ = Bool
False

isM :: EncodedCnstrs -> Bool
isM :: EncodedContraints Int (Array Int Int) -> Bool
isM (M Int
_ Int
_ Int
_ Int
_) = Bool
True
isM EncodedContraints Int (Array Int Int)
_ = Bool
False


{-| Works only with the correctly defined argument though it is not checked. Use with this caution.
-}
getIEl :: EncodedCnstrs -> Int
getIEl :: EncodedContraints Int (Array Int Int) -> Int
getIEl EncodedContraints Int (Array Int Int)
E = -Int
1
getIEl (P Int
_ Array Int Int
arr) = forall i e. Array i e -> Int -> e
unsafeAt Array Int Int
arr Int
0
getIEl (Q Int
_ Int
i Int
_ Int
_ Int
_) = Int
i
getIEl (T Int
_ Int
i Int
_ Int
_) = Int
i
getIEl (SA Int
_ Int
i Array Int Int
_) = Int
i
getIEl (SB Int
_ Int
i Array Int Int
_) = Int
i
getIEl (F Int
_ Int
i Int
_) = Int
i
getIEl (V Int
_ Int
i Int
_) = Int
i
getIEl (W Int
_ Int
i Int
_) = Int
i
getIEl (H Int
_ Int
i Int
_ Int
_) = Int
i
getIEl (R Int
_ Int
i Int
_ Int
_) = Int
i
getIEl (M Int
_ Int
i Int
_ Int
_) = Int
i

{-| Works only with the correctly defined arguments though it is not checked. Use with this caution.
-}
setIEl :: Int -> EncodedCnstrs -> EncodedCnstrs
setIEl :: Int
-> EncodedContraints Int (Array Int Int)
-> EncodedContraints Int (Array Int Int)
setIEl Int
_ EncodedContraints Int (Array Int Int)
E = forall a b. EncodedContraints a b
E
setIEl Int
i (P Int
n Array Int Int
arr) = forall a b. a -> b -> EncodedContraints a b
P Int
n (Array Int Int
arr forall i e. Ix i => Array i e -> [(i, e)] -> Array i e
// [(Int
0,Int
i)])
setIEl Int
i (Q Int
n Int
_ Int
j Int
k Int
l) = forall a b. a -> a -> a -> a -> a -> EncodedContraints a b
Q Int
n Int
i Int
j Int
k Int
l
setIEl Int
i (T Int
n Int
_ Int
j Int
k) = forall a b. a -> a -> a -> a -> EncodedContraints a b
T Int
n Int
i Int
j Int
k
setIEl Int
i (SA Int
n Int
_ Array Int Int
v) = forall a b. a -> a -> b -> EncodedContraints a b
SA Int
n Int
i Array Int Int
v
setIEl Int
i (SB Int
n Int
_ Array Int Int
v) = forall a b. a -> a -> b -> EncodedContraints a b
SB Int
n Int
i Array Int Int
v
setIEl Int
i (F Int
n Int
_ Int
j) = forall a b. a -> a -> a -> EncodedContraints a b
F Int
n Int
i Int
j
setIEl Int
i (V Int
n Int
_ Int
j) = forall a b. a -> a -> a -> EncodedContraints a b
V Int
n Int
i Int
j
setIEl Int
i (W Int
n Int
_ Int
j) = forall a b. a -> a -> a -> EncodedContraints a b
W Int
n Int
i Int
j
setIEl Int
i (H Int
n Int
_ Int
j Int
k) = forall a b. a -> a -> a -> a -> EncodedContraints a b
H Int
n Int
i Int
j Int
k
setIEl Int
i (R Int
n Int
_ Int
j Int
k) = forall a b. a -> a -> a -> a -> EncodedContraints a b
R Int
n Int
i Int
j Int
k
setIEl Int
i (M Int
n Int
_ Int
j Int
k) = forall a b. a -> a -> a -> a -> EncodedContraints a b
M Int
n Int
i Int
j Int
k