-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Constraint Programming
--   
--   Monadic Constraint Programming framework
@package monadiccp
@version 0.7.4

module Control.CP.PriorityQueue
data Ord k => PriorityQueue k a
empty :: Ord k => PriorityQueue k a
is_empty :: PriorityQueue t t1 -> Bool
minKey :: Ord k => PriorityQueue k a -> k
minKeyValue :: Ord k => PriorityQueue k a -> (k, a)
insert :: Ord k => k -> a -> PriorityQueue k a -> PriorityQueue k a
deleteMin :: Ord k => PriorityQueue k a -> ((k, a), PriorityQueue k a)
deleteMinAndInsert :: Ord k => k -> a -> PriorityQueue k a -> PriorityQueue k a

module Control.CP.Queue
class Queue q where type family Elem q :: *
emptyQ :: Queue q => q -> q
isEmptyQ :: Queue q => q -> Bool
popQ :: Queue q => q -> (Elem q, q)
pushQ :: Queue q => Elem q -> q -> q
instance Ord a => Queue (PriorityQueue a (a, b, c))
instance Queue (Seq a)
instance Queue [a]

module Control.CP.Solver
class Monad solver => Solver solver where type family Constraint solver :: * type family Label solver :: * markn _ = mark
add :: Solver solver => Constraint solver -> solver Bool
run :: Solver solver => solver a -> a
mark :: Solver solver => solver (Label solver)
markn :: Solver solver => Int -> solver (Label solver)
goto :: Solver solver => Label solver -> solver ()
class Solver solver => Term solver term where type family Help solver term
newvar :: Term solver term => solver term
help :: Term solver term => solver () -> term -> Help solver term
instance (Monoid w, Term s t) => Term (WriterT w s) t
instance (Monoid w, Solver s) => Solver (WriterT w s)

module Control.CP.SearchTree
data Tree s a
Fail :: Tree s a
Return :: a -> Tree s a
Try :: Tree s a -> Tree s a -> Tree s a
Add :: Constraint s -> Tree s a -> Tree s a
NewVar :: (t -> Tree s a) -> Tree s a
Label :: s (Tree s a) -> Tree s a
transformTree :: Solver s => Mixin (Tree s a -> Tree s a)
bindTree :: Solver s => Tree s a -> (a -> Tree s b) -> Tree s b
insertTree :: Solver s => Tree s a -> Tree s () -> Tree s a
(/\) :: MonadTree tree => tree a -> tree b -> tree b
true :: MonadTree tree => tree ()
disj :: MonadTree tree => [tree a] -> tree a
conj :: MonadTree tree => [tree ()] -> tree ()
disj2 :: MonadTree tree => [tree a] -> tree a
prim :: MonadTree tree => TreeSolver tree a -> tree a
addC :: MonadTree tree => Constraint (TreeSolver tree) -> tree ()
addT :: MonadTree tree => Constraint (TreeSolver tree) -> tree Bool
exist :: (MonadTree tree, Term (TreeSolver tree) t) => Int -> ([t] -> tree a) -> tree a
forall :: (MonadTree tree, Term (TreeSolver tree) t) => [t] -> (t -> tree ()) -> tree ()

-- | show
indent :: Int -> String
showTree :: (Show (Constraint s), Show a, Solver s) => Int -> Tree s a -> s String
mapTree :: (Solver s1, Solver s2, MonadTree m, TreeSolver m ~ s2) => (forall t. s1 t -> s2 t) -> Tree s1 a -> m a

-- | Generalization of the search tree data type, allowing monad
--   transformer decoration.
class (Monad m, Solver (TreeSolver m)) => MonadTree m where type family TreeSolver m :: * -> *
addTo :: MonadTree m => Constraint (TreeSolver m) -> m a -> m a
false :: MonadTree m => m a
(\/) :: MonadTree m => m a -> m a -> m a
exists :: (MonadTree m, Term (TreeSolver m) t) => (t -> m a) -> m a
label :: MonadTree m => (TreeSolver m) (m a) -> m a
untree :: Solver s => v -> Tree s v -> s v
instance MonadTree t => MonadTree (StateT s t)
instance (Monoid w, MonadTree t) => MonadTree (WriterT w t)
instance MonadTree t => MonadTree (ReaderT env t)
instance Show (Tree s a)
instance (MonadTree m, Solver (TreeSolver m)) => MonadTree (ContT r m)
instance Solver solver => MonadTree (Tree solver)
instance Solver s => Monad (Tree s)
instance Solver s => Functor (Tree s)

module Control.CP.Transformers
eval :: (Solver solver, Queue q, Elem q ~ (Label solver, Tree solver (ForResult t), TreeState t), Transformer t, ForSolver t ~ solver) => Tree solver (ForResult t) -> q -> t -> solver (Int, [ForResult t])
eval' :: SearchSig solver q t (ForResult t)
continue :: ContinueSig solver q t (ForResult t)
data NodeBoundedST (solver :: * -> *) a
data DepthBoundedST (solver :: * -> *) a
class Transformer t where type family EvalState t :: * type family TreeState t :: * type family ForSolver t :: * -> * type family ForResult t :: * leftT _ _ = id rightT = leftT nextT = eval' returnT i wl t es = continue i wl t es endT i wl t es = return (i, [])
leftT, rightT :: Transformer t => t -> EvalState t -> TreeState t -> TreeState t
nextT :: Transformer t => SearchSig (ForSolver t) q t (ForResult t)
initT :: Transformer t => t -> Tree (ForSolver t) (ForResult t) -> (ForSolver t) (EvalState t, TreeState t)
returnT :: Transformer t => ContinueSig solver q t (ForResult t)
endT :: Transformer t => ContinueSig solver q t (ForResult t)
instance Solver solver => Transformer (NodeBoundedST solver a)
instance Solver solver => Transformer (DepthBoundedST solver a)

module Control.CP.ComposableTransformers
solve :: (Queue q, Solver solver, CTransformer c, CForSolver c ~ solver, Elem q ~ (Label solver, Tree solver (CForResult c), CTreeState c)) => q -> c -> Tree solver (CForResult c) -> (Int, [CForResult c])
restart :: (Queue q, Solver solver, CTransformer c, CForSolver c ~ solver, Elem q ~ (Label solver, Tree solver (CForResult c), CTreeState c)) => q -> [c] -> Tree solver (CForResult c) -> (Int, [CForResult c])
type NewBound solver = solver (Bound solver)
newtype Bound solver
Bound :: (forall a. Tree solver a -> Tree solver a) -> Bound solver
data Composition es ts solver a
(:-) :: c1 -> c2 -> Composition (CEvalState c1, CEvalState c2) (CTreeState c1, CTreeState c2) solver a
class Solver (CForSolver c) => CTransformer c where type family CTreeState c :: * type family CForSolver c :: * -> * type family CForResult c :: * leftCT _ = id rightCT = leftCT nextCT = evalCT returnCT = continueCT completeCT _ _ = True
data RestartST es ts (solver :: * -> *) a
RestartST :: [SealedCST es ts solver a] -> (Tree solver a -> solver (Tree solver a)) -> RestartST es ts a
data SealedCST es ts solver a
Seal :: c -> SealedCST (CEvalState c) (CTreeState c) (CForSolver c) (CForResult c)
newtype CNodeBoundedST (solver :: * -> *) a
CNBST :: Int -> CNodeBoundedST a
newtype CDepthBoundedST (solver :: * -> *) a
CDBST :: Int -> CDepthBoundedST a
newtype CBranchBoundST (solver :: * -> *) a
CBBST :: (NewBound solver) -> CBranchBoundST a
data CFirstSolutionST (solver :: * -> *) a
CFSST :: CFirstSolutionST a
data CSolutionBoundST (solver :: * -> *) a
CSBST :: Int -> CSolutionBoundST a
data CIdentityCST (solver :: * -> *) a
CIST :: CIdentityCST a
newtype CRandomST (solver :: * -> *) a
CRST :: Int -> CRandomST a
newtype CLimitedDiscrepancyST (solver :: * -> *) a
CLDST :: Int -> CLimitedDiscrepancyST a
instance Solver solver => Transformer (RestartST es ts solver a)
instance Solver solver => CTransformer (SealedCST es ts solver a)
instance Solver solver => CTransformer (CBranchBoundST solver a)
instance Solver solver => CTransformer (Composition es ts solver a)
instance Solver solver => CTransformer (CSolutionBoundST solver a)
instance Solver solver => CTransformer (CFirstSolutionST solver a)
instance Solver solver => CTransformer (CIdentityCST solver a)
instance Solver solver => CTransformer (CRandomST solver a)
instance Solver solver => CTransformer (CLimitedDiscrepancyST solver a)
instance Solver solver => CTransformer (CDepthBoundedST solver a)
instance Solver solver => CTransformer (CNodeBoundedST solver a)
instance Solver solver => Transformer (TStack es ts solver a)

module Control.CP.EnumTerm
class (Solver s, Term s t, Show (TermBaseType s t)) => EnumTerm s t where type family TermBaseType s t :: * getDomainSize x = do { r <- getDomain x; return $ length r } getValue x = do { d <- getDomain x; return $ case d of { [v] -> Just v _ -> Nothing } } splitDomain x = do { d <- getDomain x; case d of { [] -> return ([], True) [_] -> return ([[]], True) _ -> do { rr <- mapM (setValue x) d; return (rr, True) } } } splitDomains [] = return ([[]], []) splitDomains (a@(x : b)) = do { s <- getDomainSize x; if s == 0 then return ([], []) else if s == 1 then splitDomains b else do { (r, v) <- splitDomain x; if v then return (r, b) else return (r, a) } } defaultOrder = firstFail enumerator = Nothing
getDomainSize :: EnumTerm s t => t -> s (Int)
getDomain :: EnumTerm s t => t -> s [TermBaseType s t]
setValue :: EnumTerm s t => t -> TermBaseType s t -> s [Constraint s]
splitDomain :: EnumTerm s t => t -> s ([[Constraint s]], Bool)
splitDomains :: EnumTerm s t => [t] -> s ([[Constraint s]], [t])
getValue :: EnumTerm s t => t -> s (Maybe (TermBaseType s t))
defaultOrder :: EnumTerm s t => [t] -> s [t]
enumerator :: (EnumTerm s t, MonadTree m, TreeSolver m ~ s) => Maybe ([t] -> m ())
assignment :: (EnumTerm s t, MonadTree m, TreeSolver m ~ s) => t -> m (TermBaseType s t)
assignments :: (EnumTerm s t, MonadTree m, TreeSolver m ~ s) => [t] -> m [TermBaseType s t]
inOrder :: EnumTerm s t => [t] -> s [t]
firstFail :: EnumTerm s t => [t] -> s [t]
middleOut :: EnumTerm s t => [t] -> s [t]
endsOut :: EnumTerm s t => [t] -> s [t]
labelling :: (MonadTree m, TreeSolver m ~ s, EnumTerm s t) => ([t] -> s [t]) -> [t] -> m ()
levelList :: (Solver s, MonadTree m, TreeSolver m ~ s) => [m ()] -> m ()
enumerate :: (MonadTree m, TreeSolver m ~ s, EnumTerm s t) => [t] -> m ()

module Data.Expr.Sugar

-- | integer operators/functions | --
(@+) :: (Eq t, Eq c, Eq b, ToExpr t c b p, ToExpr t c b q) => p -> q -> Expr t c b
(@-) :: (Eq t, Eq c, Eq b, ToExpr t c b p, ToExpr t c b q) => p -> q -> Expr t c b
(@*) :: (Eq t, Eq c, Eq b, ToExpr t c b p, ToExpr t c b q) => p -> q -> Expr t c b
(@/) :: (Eq t, Eq c, Eq b, ToExpr t c b p, ToExpr t c b q) => p -> q -> Expr t c b
(@%) :: (Eq t, Eq c, Eq b, ToExpr t c b p, ToExpr t c b q) => p -> q -> Expr t c b
(@?) :: (Eq t, Eq c, Eq b) => BoolExpr t c b -> (Expr t c b, Expr t c b) -> Expr t c b
(@??) :: (Eq t, Eq c, Eq b) => BoolExpr t c b -> (BoolExpr t c b, BoolExpr t c b) -> BoolExpr t c b

-- | list operators/functions | --
(!) :: (Eq t, Eq c, Eq b) => ColExpr t c b -> Expr t c b -> Expr t c b
(@!!) :: (Eq t, Eq c, Eq b) => ColExpr t c b -> Integer -> Expr t c b
(@++) :: (Eq t, Eq c, Eq b) => ColExpr t c b -> ColExpr t c b -> ColExpr t c b
(@..) :: (Eq t, Eq c, Eq b) => Expr t c b -> Expr t c b -> ColExpr t c b
size :: (Eq t, Eq c, Eq b) => ColExpr t c b -> Expr t c b
slice :: (Eq t, Eq c, Eq b) => ColExpr t c b -> ColExpr t c b -> ColExpr t c b
xhead :: (Eq t, Eq c, Eq b, ToColExpr t c b p) => p -> Expr t c b
xtail :: (Eq t, Eq c, Eq b, ToColExpr t c b p) => p -> ColExpr t c b
xmap :: (Eq t, Eq c, Eq b) => (Expr t c b -> Expr t c b) -> ColExpr t c b -> ColExpr t c b
xfold :: (Eq t, Eq c, Eq b) => (Expr t c b -> Expr t c b -> Expr t c b) -> Expr t c b -> ColExpr t c b -> Expr t c b
list :: (Eq t, Eq c, Eq b) => [Expr t c b] -> ColExpr t c b
channel :: (Eq t, Eq c, Eq b) => BoolExpr t c b -> Expr t c b
xsum :: (Num (Expr t c b), Eq t, Eq c, Eq b) => ColExpr t c b -> Expr t c b
(@||) :: (Eq b, Eq c, Eq s, ToBoolExpr s c b b2, ToBoolExpr s c b b1) => b1 -> b2 -> BoolExpr s c b
(@&&) :: (Eq b, Eq c, Eq s, ToBoolExpr s c b b2, ToBoolExpr s c b b1) => b1 -> b2 -> BoolExpr s c b

-- | boolean operators/functions | --
inv :: (Eq t, Eq c, Eq b, ToBoolExpr t c b p) => p -> BoolExpr t c b
(@>) :: (Eq t, Eq c, Eq b) => Expr t c b -> Expr t c b -> BoolExpr t c b
(@<) :: (Eq t, Eq c, Eq b) => Expr t c b -> Expr t c b -> BoolExpr t c b
(@>=) :: (Eq t, Eq c, Eq b) => Expr t c b -> Expr t c b -> BoolExpr t c b
(@<=) :: (Eq t, Eq c, Eq b) => Expr t c b -> Expr t c b -> BoolExpr t c b
loopall :: (Eq t, Eq c, Eq b) => (Expr t c b, Expr t c b) -> (Expr t c b -> BoolExpr t c b) -> BoolExpr t c b
loopany :: (Eq t, Eq c, Eq b) => (Expr t c b, Expr t c b) -> (Expr t c b -> BoolExpr t c b) -> BoolExpr t c b
forall :: (Eq t, Eq c, Eq b) => (ColExpr t c b) -> (Expr t c b -> BoolExpr t c b) -> BoolExpr t c b
forany :: (Eq t, Eq c, Eq b) => (ColExpr t c b) -> (Expr t c b -> BoolExpr t c b) -> BoolExpr t c b

-- | Data types | --
data Expr t c b
data ColExpr t c b
data BoolExpr t c b

-- | convertion from/to expression types | --
class ToExpr tt cc bb t
toExpr :: ToExpr tt cc bb t => t -> Expr tt cc bb
class ToColExpr tt cc bb c
toColExpr :: ToColExpr tt cc bb c => c -> ColExpr tt cc bb
class ToBoolExpr tt cc bb b
toBoolExpr :: ToBoolExpr tt cc bb b => b -> BoolExpr tt cc bb
sorted :: (Eq b, Eq c, Eq s) => ColExpr s c b -> BoolExpr s c b
sSorted :: (Eq b, Eq c, Eq s) => ColExpr s c b -> BoolExpr s c b
allDiff :: (Eq b, Eq c, Eq s) => ColExpr s c b -> BoolExpr s c b
allDiffD :: (Eq b, Eq c, Eq s) => ColExpr s c b -> BoolExpr s c b
class (Eq tt, Eq cc, Eq bb) => ExprClass tt cc bb a where a @/= b = boolSimplify $ BoolNot $ a @= b
(@=) :: ExprClass tt cc bb a => a -> a -> BoolExpr tt cc bb
(@/=) :: ExprClass tt cc bb a => a -> a -> BoolExpr tt cc bb
class (Eq tt, Eq cc, Eq bb) => ExprRange tt cc bb r
(@:) :: ExprRange tt cc bb r => Expr tt cc bb -> r -> BoolExpr tt cc bb
instance (Eq t, Eq c, Eq b) => ExprRange t c b (ColExpr t c b)
instance (Eq t, Eq c, Eq b) => ExprRange t c b (Expr t c b, Expr t c b)
instance (Eq t, Eq c, Eq b) => ExprClass t c b (ColExpr t c b)
instance (Eq t, Eq c, Eq b) => ExprClass t c b (BoolExpr t c b)
instance (Eq t, Eq c, Eq b) => ExprClass t c b (Expr t c b)
instance ToBoolExpr t a b b
instance ToColExpr t a b a
instance ToExpr t a b t
instance ToBoolExpr t a b (BoolExpr t a b)
instance ToBoolExpr tt cc bb Bool
instance (Eq b, Eq a, Eq t) => ToColExpr t a b [Expr t a b]
instance (Eq t, Eq a, Eq b) => ToColExpr t a b (Expr t a b)
instance ToColExpr t a b (ColExpr t a b)
instance (Eq t, Eq a, Eq b) => ToExpr t a b (BoolExpr t a b)
instance ToExpr tt cc bb Int
instance ToExpr t a b (Expr t a b)
instance ToExpr tt cc bb Integer
instance (Ord s, Ord c, Ord b, Eq s, Eq c, Eq b, Show s, Show c, Show b) => Integral (Expr s c b)
instance (Eq s, Eq c, Eq b) => Enum (Expr s c b)
instance (Ord s, Ord c, Ord b, Eq s, Eq c, Eq b, Show s, Show c, Show b) => Real (Expr s c b)
instance (Eq s, Eq c, Eq b, Show s, Show c, Show b) => Num (Expr s c b)

module Control.CP.FD.Model
type Model = ModelBool
data ModelIntTerm t
ModelIntVar :: Int -> ModelIntTerm t
ModelIntPar :: Int -> ModelIntTerm t
data ModelBoolTerm t
ModelBoolVar :: Int -> ModelBoolTerm t
ModelBoolPar :: Int -> ModelBoolTerm t
ModelExtra :: t -> ModelBoolTerm t
data ModelColTerm t
ModelColVar :: Int -> ModelColTerm t
ModelColPar :: Int -> ModelColTerm t
data ModelFunctions
ForNewBool :: (ModelBoolExpr ModelFunctions -> Model) -> ModelFunctions
ForNewInt :: (ModelIntExpr ModelFunctions -> Model) -> ModelFunctions
ForNewCol :: (ModelColExpr ModelFunctions -> Model) -> ModelFunctions
type ModelInt = ModelIntExpr ModelFunctions
class ToModelInt t
asExpr :: ToModelInt t => t -> ModelInt
type ModelIntArg = ModelIntTerm ModelFunctions
type ModelCol = ModelColExpr ModelFunctions
class ToModelCol t
asCol :: ToModelCol t => t -> ModelCol
type ModelColArg = ModelColTerm ModelFunctions
type ModelBool = ModelBoolExpr ModelFunctions
class ToModelBool t
asBool :: ToModelBool t => t -> ModelBool
type ModelBoolArg = ModelBoolTerm ModelFunctions
modelVariantInt :: ModelIntExpr x -> Bool
modelVariantBool :: ModelBoolExpr x -> Bool
modelVariantCol :: ModelColExpr x -> Bool
class ModelTermType s
newModelTerm :: ModelTermType s => (s -> Model) -> Model
showModel :: Model -> String
cte :: Integral a => a -> ModelInt
instance Ord t => Ord (ModelColTerm t)
instance Eq t => Eq (ModelColTerm t)
instance Ord t => Ord (ModelIntTerm t)
instance Eq t => Eq (ModelIntTerm t)
instance Ord t => Ord (ModelBoolTerm t)
instance Eq t => Eq (ModelBoolTerm t)
instance Show (ModelIntTerm t)
instance Show (ModelColTerm t)
instance Show t => Show (ModelBoolTerm t)
instance Show ModelIntros
instance Eq ModelIntros
instance ToColExpr (ModelIntTerm ModelFunctions) (ModelColTerm ModelFunctions) (ModelBoolTerm ModelFunctions) t => ToModelCol t
instance ToBoolExpr (ModelIntTerm ModelFunctions) (ModelColTerm ModelFunctions) (ModelBoolTerm ModelFunctions) t => ToModelBool t
instance ToExpr (ModelIntTerm ModelFunctions) (ModelColTerm ModelFunctions) (ModelBoolTerm ModelFunctions) t => ToModelInt t
instance ModelTermType ModelCol
instance ModelTermType ModelInt
instance ModelTermType ModelBool
instance Ord ModelFunctions
instance Eq ModelFunctions
instance Show ModelFunctions
instance Ord ModelIntros

module Control.CP.FD.FD

-- | definition of FDInstance, a Solver wrapper that adds power to post
--   boolean expressions as constraints
data FDSolver s => FDInstance s a

-- | A solver needs to be an instance of this FDSolver class in order to
--   create an FDInstance around it.
class (Solver s, Term s (FDIntTerm s), Term s (FDBoolTerm s), Eq (FDBoolSpecType s), Ord (FDBoolSpecType s), Enum (FDBoolSpecType s), Bounded (FDBoolSpecType s), Show (FDBoolSpecType s), Eq (FDIntSpecType s), Ord (FDIntSpecType s), Enum (FDIntSpecType s), Bounded (FDIntSpecType s), Show (FDIntSpecType s), Eq (FDColSpecType s), Ord (FDColSpecType s), Enum (FDColSpecType s), Bounded (FDColSpecType s), Show (FDColSpecType s), Show (FDIntSpec s), Show (FDColSpec s), Show (FDBoolSpec s)) => FDSolver s where type family FDIntTerm s :: * type family FDBoolTerm s :: * type family FDIntSpec s :: * type family FDBoolSpec s :: * type family FDColSpec s :: * type family FDIntSpecType s :: * type family FDBoolSpecType s :: * type family FDColSpecType s :: * fdTypeReqBool = return (\ (EGEdge {egeLinks = EGTypeData {boolData = l}}) -> map (\ x -> (x, fromList [minBound .. maxBound])) l) fdTypeReqInt = return (\ (EGEdge {egeLinks = EGTypeData {intData = l}}) -> map (\ x -> (x, fromList [minBound .. maxBound])) l) fdTypeReqCol = return (\ (EGEdge {egeLinks = EGTypeData {colData = l}}) -> map (\ x -> (x, fromList [minBound .. maxBound])) l) fdTypeVarInt = return $ singleton maxBound fdTypeVarBool = return $ singleton maxBound fdSpecify = mixinId
fdIntSpec_const :: FDSolver s => EGPar -> (FDIntSpecType s, s (FDIntSpec s))
fdBoolSpec_const :: FDSolver s => EGBoolPar -> (FDBoolSpecType s, s (FDBoolSpec s))
fdColSpec_const :: FDSolver s => EGColPar -> (FDColSpecType s, s (FDColSpec s))
fdColSpec_list :: FDSolver s => [FDIntSpec s] -> (FDColSpecType s, s (FDColSpec s))
fdIntSpec_term :: FDSolver s => FDIntTerm s -> (FDIntSpecType s, s (FDIntSpec s))
fdBoolSpec_term :: FDSolver s => FDBoolTerm s -> (FDBoolSpecType s, s (FDBoolSpec s))
fdColSpec_size :: FDSolver s => EGPar -> (FDColSpecType s, s (FDColSpec s))
fdIntVarSpec :: FDSolver s => FDIntSpec s -> s (Maybe (FDIntTerm s))
fdBoolVarSpec :: FDSolver s => FDBoolSpec s -> s (Maybe (FDBoolTerm s))
fdTypeReqBool :: FDSolver s => s (EGEdge -> [(EGVarId, FDBoolSpecTypeSet s)])
fdTypeReqInt :: FDSolver s => s (EGEdge -> [(EGVarId, FDIntSpecTypeSet s)])
fdTypeReqCol :: FDSolver s => s (EGEdge -> [(EGVarId, FDColSpecTypeSet s)])
fdTypeVarInt :: FDSolver s => s (Set (FDIntSpecType s))
fdTypeVarBool :: FDSolver s => s (Set (FDBoolSpecType s))
fdSpecify :: FDSolver s => Mixin (SpecFn s)
fdColInspect :: FDSolver s => FDColSpec s -> s [FDIntTerm s]
fdProcess :: FDSolver s => Mixin (EGConstraintSpec -> FDSpecInfo s -> FDInstance s ())
fdEqualBool :: FDSolver s => FDBoolSpec s -> FDBoolSpec s -> FDInstance s ()
fdEqualInt :: FDSolver s => FDIntSpec s -> FDIntSpec s -> FDInstance s ()
fdEqualCol :: FDSolver s => FDColSpec s -> FDColSpec s -> FDInstance s ()
fdConstrainIntTerm :: FDSolver s => FDIntTerm s -> Integer -> s (Constraint s)
fdSplitIntDomain :: FDSolver s => FDIntTerm s -> s ([Constraint s], Bool)
fdSplitBoolDomain :: FDSolver s => FDBoolTerm s -> s ([Constraint s], Bool)
type FDSpecInfo s = ([FDSpecInfoBool s], [FDSpecInfoInt s], [FDSpecInfoCol s])
data FDSpecInfoBool s
FDSpecInfoBool :: (Maybe (FDBoolSpecType s) -> Maybe (FDBoolSpec s)) -> Maybe EGVarId -> Maybe EGBoolPar -> Set (FDBoolSpecType s) -> FDSpecInfoBool s
fdspBoolSpec :: FDSpecInfoBool s -> Maybe (FDBoolSpecType s) -> Maybe (FDBoolSpec s)
fdspBoolVar :: FDSpecInfoBool s -> Maybe EGVarId
fdspBoolVal :: FDSpecInfoBool s -> Maybe EGBoolPar
fdspBoolTypes :: FDSpecInfoBool s -> Set (FDBoolSpecType s)
data FDSpecInfoInt s
FDSpecInfoInt :: (Maybe (FDIntSpecType s) -> Maybe (FDIntSpec s)) -> Maybe EGVarId -> Maybe EGPar -> Set (FDIntSpecType s) -> FDSpecInfoInt s
fdspIntSpec :: FDSpecInfoInt s -> Maybe (FDIntSpecType s) -> Maybe (FDIntSpec s)
fdspIntVar :: FDSpecInfoInt s -> Maybe EGVarId
fdspIntVal :: FDSpecInfoInt s -> Maybe EGPar
fdspIntTypes :: FDSpecInfoInt s -> Set (FDIntSpecType s)
data FDSpecInfoCol s
FDSpecInfoCol :: (Maybe (FDColSpecType s) -> Maybe (FDColSpec s)) -> Maybe EGVarId -> Maybe EGColPar -> Set (FDColSpecType s) -> FDSpecInfoCol s
fdspColSpec :: FDSpecInfoCol s -> Maybe (FDColSpecType s) -> Maybe (FDColSpec s)
fdspColVar :: FDSpecInfoCol s -> Maybe EGVarId
fdspColVal :: FDSpecInfoCol s -> Maybe EGColPar
fdspColTypes :: FDSpecInfoCol s -> Set (FDColSpecType s)

-- | lift a monad action for the underlying solver to a monad action for an
--   FDInstance around it
liftFD :: FDSolver s => s a -> FDInstance s a
addFD :: (Show (Constraint s), FDSolver s) => Constraint s -> FDInstance s ()
type SpecFn s = EGEdge -> SpecFnRes s
type SpecFnRes s = ([(Int, EGVarId, Bool, SpecBool s)], [(Int, EGVarId, Bool, SpecInt s)], [(Int, EGVarId, Bool, SpecCol s)])
data SpecResult t
SpecResNone :: SpecResult t
SpecResSpec :: t -> SpecResult t
SpecResUnify :: EGVarId -> SpecResult t
getBoolSpec_ :: FDSolver s => EGVarId -> FDBoolSpecTypeSet s -> FDInstance s (Maybe (FDBoolSpecType s, FDBoolSpec s))
getIntSpec_ :: FDSolver s => EGVarId -> FDIntSpecTypeSet s -> FDInstance s (Maybe (FDIntSpecType s, FDIntSpec s))
getColSpec_ :: FDSolver s => EGVarId -> FDColSpecTypeSet s -> FDInstance s (Maybe (FDColSpecType s, FDColSpec s))
getBoolSpec :: FDSolver s => EGVarId -> FDInstance s (Maybe (FDBoolSpec s))
getIntSpec :: FDSolver s => EGVarId -> FDInstance s (Maybe (FDIntSpec s))
getColSpec :: (Show (FDColSpec s), FDSolver s) => EGVarId -> FDInstance s (Maybe (FDColSpec s))
getEdge :: FDSolver s => EGEdgeId -> FDInstance s (Maybe EGEdge)
markEdge :: FDSolver s => EGEdgeId -> FDInstance s ()
setFailed :: FDSolver s => FDInstance s ()
getLevel :: FDSolver s => FDInstance s Int
getIntVal :: FDSolver s => EGVarId -> FDInstance s (Maybe EGPar)
getBoolVal :: FDSolver s => EGVarId -> FDInstance s (Maybe EGBoolPar)
getColVal :: FDSolver s => EGVarId -> FDInstance s (Maybe EGColPar)
getIntTerm :: FDSolver s => [ModelInt] -> FDInstance s [FDIntTerm s]
getBoolTerm :: FDSolver s => [ModelBool] -> FDInstance s [FDBoolTerm s]
getColTerm :: FDSolver s => [ModelCol] -> FDColSpecType s -> FDInstance s [FDColSpec s]
getSingleIntTerm :: FDSolver s => ModelInt -> FDInstance s (FDIntTerm s)
getDefBoolSpec :: FDSolver s => FDSpecInfoBool s -> FDBoolSpec s
getDefIntSpec :: FDSolver s => FDSpecInfoInt s -> FDIntSpec s
getDefColSpec :: FDSolver s => FDSpecInfoCol s -> FDColSpec s
getFullBoolSpec :: (MonadState (FDState s) m, FDSolver s) => EGVarId -> m (FDSpecInfoBool s)
getFullIntSpec :: (MonadState (FDState s) m, FDSolver s) => EGVarId -> m (FDSpecInfoInt s)
getFullColSpec :: (MonadState (FDState s) m, FDSolver s) => EGVarId -> m (FDSpecInfoCol s)
getColItems :: FDSolver s => ModelCol -> FDColSpecType s -> FDInstance s [FDIntTerm s]
fdSpecInfo_spec :: FDSolver s => ([Either (FDSpecInfoBool s) (FDBoolSpecType s, FDBoolSpec s)], [Either (FDSpecInfoInt s) (FDIntSpecType s, FDIntSpec s)], [Either (FDSpecInfoCol s) (FDColSpecType s, FDColSpec s)]) -> FDSpecInfo s
specInfoBoolTerm :: FDSolver s => FDBoolTerm s -> s (FDSpecInfoBool s)
specInfoIntTerm :: FDSolver s => FDIntTerm s -> s (FDSpecInfoInt s)
newInt :: FDSolver s => FDInstance s ModelInt
newBool :: FDSolver s => FDInstance s ModelBool
newCol :: FDSolver s => FDInstance s ModelCol
procSubModel :: FDSolver s => EGModel -> (Int -> FDSpecInfoBool s, Int -> FDSpecInfoInt s, Int -> FDSpecInfoCol s) -> FDInstance s ()
procSubModelEx :: FDSolver s => EGModel -> (Int -> Maybe (FDSpecInfoBool s), Int -> Maybe (FDSpecInfoInt s), Int -> Maybe (FDSpecInfoCol s)) -> FDInstance s ()
specSubModelEx :: FDSolver s => EGModel -> (Int -> Maybe (FDSpecInfoBool s), Int -> Maybe (FDSpecInfoInt s), Int -> Maybe (FDSpecInfoCol s)) -> FDInstance s (Map EGVarId (FDSpecInfoBool s), Map EGVarId (FDSpecInfoInt s), Map EGVarId (FDSpecInfoCol s))
runFD :: FDSolver s => FDInstance s a -> s a
setMinimizeVar :: (Show (FDIntTerm s), FDSolver s) => ModelInt -> FDInstance s ()
boundMinimize :: (Show (FDIntTerm s), FDSolver s, EnumTerm s (FDIntTerm s), Integral (TermBaseType s (FDIntTerm s))) => NewBound (FDInstance s)
getMinimizeTerm :: (Show (FDIntTerm s), FDSolver s) => FDInstance s (Maybe (FDIntTerm s))
getMinimizeVar :: (Show (FDIntTerm s), FDSolver s) => FDInstance s (Maybe ModelInt)
fdNewvar :: (FDSolver s, Term s t) => FDInstance s (Maybe t)
instance Eq TermType
instance Ord TermType
instance Bounded TermType
instance Enum TermType
instance Show TermType
instance Monad s => Monad (FDInstance s)
instance Monad s => MonadState (FDState s) (FDInstance s)
instance (FDSolver s, EnumTerm s (FDBoolTerm s)) => EnumTerm (FDInstance s) ModelBool
instance (FDSolver s, EnumTerm s (FDIntTerm s)) => EnumTerm (FDInstance s) ModelInt
instance FDSolver s => Term (FDInstance s) ModelCol
instance FDSolver s => Term (FDInstance s) ModelBool
instance FDSolver s => Term (FDInstance s) ModelInt
instance FDSolver s => Solver (FDInstance s)
instance Show (FDColSpec s) => Show (FDSpecInfoCol s)
instance Show (FDIntSpec s) => Show (FDSpecInfoInt s)
instance Show (FDBoolSpec s) => Show (FDSpecInfoBool s)
instance (Ord (FDColSpec s), Ord (FDColSpecType s)) => Ord (FDSpecInfoCol s)
instance (Ord (FDColSpec s), Ord (FDColSpecType s)) => Eq (FDSpecInfoCol s)
instance (Ord (FDIntSpec s), Ord (FDIntSpecType s)) => Ord (FDSpecInfoInt s)
instance (Ord (FDIntSpec s), Ord (FDIntSpecType s)) => Eq (FDSpecInfoInt s)
instance (Ord (FDBoolSpec s), Ord (FDBoolSpecType s)) => Ord (FDSpecInfoBool s)
instance (Ord (FDBoolSpec s), Ord (FDBoolSpecType s)) => Eq (FDSpecInfoBool s)
instance Show (TermTypeSpec s)

module Control.CP.FD.Interface

-- | A solver needs to be an instance of this FDSolver class in order to
--   create an FDInstance around it.
class (Solver s, Term s (FDIntTerm s), Term s (FDBoolTerm s), Eq (FDBoolSpecType s), Ord (FDBoolSpecType s), Enum (FDBoolSpecType s), Bounded (FDBoolSpecType s), Show (FDBoolSpecType s), Eq (FDIntSpecType s), Ord (FDIntSpecType s), Enum (FDIntSpecType s), Bounded (FDIntSpecType s), Show (FDIntSpecType s), Eq (FDColSpecType s), Ord (FDColSpecType s), Enum (FDColSpecType s), Bounded (FDColSpecType s), Show (FDColSpecType s), Show (FDIntSpec s), Show (FDColSpec s), Show (FDBoolSpec s)) => FDSolver s where fdTypeReqBool = return (\ (EGEdge {egeLinks = EGTypeData {boolData = l}}) -> map (\ x -> (x, fromList [minBound .. maxBound])) l) fdTypeReqInt = return (\ (EGEdge {egeLinks = EGTypeData {intData = l}}) -> map (\ x -> (x, fromList [minBound .. maxBound])) l) fdTypeReqCol = return (\ (EGEdge {egeLinks = EGTypeData {colData = l}}) -> map (\ x -> (x, fromList [minBound .. maxBound])) l) fdTypeVarInt = return $ singleton maxBound fdTypeVarBool = return $ singleton maxBound fdSpecify = mixinId

-- | definition of FDInstance, a Solver wrapper that adds power to post
--   boolean expressions as constraints
data FDSolver s => FDInstance s a

-- | integer operators/functions | --
(@+) :: (Eq t, Eq c, Eq b, ToExpr t c b p, ToExpr t c b q) => p -> q -> Expr t c b
(@-) :: (Eq t, Eq c, Eq b, ToExpr t c b p, ToExpr t c b q) => p -> q -> Expr t c b
(@*) :: (Eq t, Eq c, Eq b, ToExpr t c b p, ToExpr t c b q) => p -> q -> Expr t c b
(@/) :: (Eq t, Eq c, Eq b, ToExpr t c b p, ToExpr t c b q) => p -> q -> Expr t c b
(@%) :: (Eq t, Eq c, Eq b, ToExpr t c b p, ToExpr t c b q) => p -> q -> Expr t c b

-- | list operators/functions | --
(!) :: (Eq t, Eq c, Eq b) => ColExpr t c b -> Expr t c b -> Expr t c b
(@!!) :: (Eq t, Eq c, Eq b) => ColExpr t c b -> Integer -> Expr t c b
(@..) :: (Eq t, Eq c, Eq b) => Expr t c b -> Expr t c b -> ColExpr t c b
(@++) :: (Eq t, Eq c, Eq b) => ColExpr t c b -> ColExpr t c b -> ColExpr t c b
size :: (Eq t, Eq c, Eq b) => ColExpr t c b -> Expr t c b
xfold :: (Eq t, Eq c, Eq b) => (Expr t c b -> Expr t c b -> Expr t c b) -> Expr t c b -> ColExpr t c b -> Expr t c b
xsum :: (Num (Expr t c b), Eq t, Eq c, Eq b) => ColExpr t c b -> Expr t c b
xhead :: (Eq t, Eq c, Eq b, ToColExpr t c b p) => p -> Expr t c b
xtail :: (Eq t, Eq c, Eq b, ToColExpr t c b p) => p -> ColExpr t c b
list :: (Eq t, Eq c, Eq b) => [Expr t c b] -> ColExpr t c b
slice :: (Eq t, Eq c, Eq b) => ColExpr t c b -> ColExpr t c b -> ColExpr t c b
xmap :: (Eq t, Eq c, Eq b) => (Expr t c b -> Expr t c b) -> ColExpr t c b -> ColExpr t c b
cte :: Integral a => a -> ModelInt
(@||) :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => Tree DummySolver () -> Tree DummySolver () -> m ()
(@&&) :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => Tree DummySolver () -> Tree DummySolver () -> m ()
inv :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => Tree DummySolver () -> m ()
(@=) :: (ModelExprClass a, Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => a -> a -> m ()
(@/=) :: (ModelExprClass a, Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => a -> a -> m ()
(@<) :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => ModelInt -> ModelInt -> m ()
(@>) :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => ModelInt -> ModelInt -> m ()
(@<=) :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => ModelInt -> ModelInt -> m ()
(@>=) :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => ModelInt -> ModelInt -> m ()
(@:) :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s, ExprRange ModelIntArg ModelColArg ModelBoolArg r, Term s ModelInt, Term s ModelBool, Term s ModelCol) => ModelInt -> r -> m ()
(@?) :: Tree DummySolver () -> (Expr (ModelIntTerm ModelFunctions) (ModelColTerm ModelFunctions) (ModelBoolTerm ModelFunctions), Expr (ModelIntTerm ModelFunctions) (ModelColTerm ModelFunctions) (ModelBoolTerm ModelFunctions)) -> Expr (ModelIntTerm ModelFunctions) (ModelColTerm ModelFunctions) (ModelBoolTerm ModelFunctions)
(@??) :: (MonadTree m, ~ * (Constraint (TreeSolver m)) (Either Model q)) => Tree DummySolver () -> (Tree DummySolver (), Tree DummySolver ()) -> m ()
channel :: Tree DummySolver () -> ModelInt
val :: Tree DummySolver () -> ModelInt
sorted :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => ModelCol -> m ()
sSorted :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => ModelCol -> m ()
forall :: (Term s ModelInt, Term s ModelBool, Term s ModelCol, Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => ModelCol -> (ModelInt -> Tree DummySolver ()) -> m ()
forany :: (Term s ModelInt, Term s ModelBool, Term s ModelCol, Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => ModelCol -> (ModelInt -> Tree DummySolver ()) -> m ()
loopall :: (Term s ModelInt, Term s ModelBool, Term s ModelCol, Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => (ModelInt, ModelInt) -> (ModelInt -> Tree DummySolver ()) -> m ()
allDiff :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => ModelCol -> m ()
allDiffD :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => ModelCol -> m ()
loopany :: (Term s ModelInt, Term s ModelBool, Term s ModelCol, Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => (ModelInt, ModelInt) -> (ModelInt -> Tree DummySolver ()) -> m ()
allin :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s, ExprRange ModelIntArg ModelColArg ModelBoolArg r, Term s ModelInt, Term s ModelBool, Term s ModelCol) => ModelCol -> r -> m ()
asExpr :: ToModelInt t => t -> ModelInt
asCol :: ToModelCol t => t -> ModelCol
asBool :: (FDSolver s, MonadTree m, TreeSolver m ~ FDInstance s, ToModelBool t) => t -> m ()
colList :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => ModelCol -> Int -> m [ModelInt]
labelCol :: (FDSolver s, MonadTree m, TreeSolver m ~ FDInstance s, EnumTerm s (FDIntTerm s)) => ModelCol -> m [TermBaseType s (FDIntTerm s)]
type ModelInt = ModelIntExpr ModelFunctions
type ModelCol = ModelColExpr ModelFunctions
type ModelBool = ModelBoolExpr ModelFunctions
exists :: (MonadTree m, Term (TreeSolver m) t) => (t -> m a) -> m a
true :: MonadTree tree => tree ()
false :: MonadTree m => m a
instance ModelExprClass (Tree DummySolver ())
instance ModelExprClass ModelBool
instance ModelExprClass ModelCol
instance ModelExprClass ModelInt
instance Solver DummySolver
instance ModelTermType t => Term DummySolver t
instance Monad DummySolver

module Control.CP.FD.OvertonFD.OvertonFD
data OvertonFD a
fd_objective :: OvertonFD FDVar
fd_domain :: FDVar -> OvertonFD [Int]
data FDVar
data OConstraint
OHasValue :: FDVar -> Int -> OConstraint
OSame :: FDVar -> FDVar -> OConstraint
ODiff :: FDVar -> FDVar -> OConstraint
OLess :: FDVar -> FDVar -> OConstraint
OLessEq :: FDVar -> FDVar -> OConstraint
OAdd :: FDVar -> FDVar -> FDVar -> OConstraint
OSub :: FDVar -> FDVar -> FDVar -> OConstraint
OMult :: FDVar -> FDVar -> FDVar -> OConstraint
OAbs :: FDVar -> FDVar -> OConstraint
lookup :: FDVar -> OvertonFD Domain
instance Ord FDVar
instance Eq FDVar
instance Show FDVar
instance Show OConstraint
instance Eq OConstraint
instance Show FDState
instance Monad OvertonFD
instance MonadState FDState OvertonFD
instance Ord FDState
instance Eq FDState
instance Show VarInfo
instance EnumTerm OvertonFD FDVar
instance Term OvertonFD FDVar
instance Solver OvertonFD

module Control.CP.FD.Solvers
dfs :: [a]
bfs :: Seq a
pfs :: Ord a => PriorityQueue a (a, b, c)
nb :: Int -> CNodeBoundedST s a
db :: Int -> CDepthBoundedST s a
bb :: NewBound s -> CBranchBoundST s a
sb :: Int -> CSolutionBoundST s a
fs :: CFirstSolutionST s a
it :: CIdentityCST s a
ra :: Int -> CRandomST s a
ld :: Int -> CLimitedDiscrepancyST s a

module Control.CP.FD.Gecode.Common
class (Solver s, Term s (GecodeIntVar s), Term s (GecodeBoolVar s), Eq (GecodeIntVar s), Eq (GecodeBoolVar s), Eq (GecodeColVar s), Ord (GecodeIntVar s), Ord (GecodeBoolVar s), Ord (GecodeColVar s), Show (GecodeIntVar s), Show (GecodeBoolVar s), Show (GecodeColVar s)) => GecodeSolver s where type family GecodeIntVar s :: * type family GecodeBoolVar s :: * type family GecodeColVar s :: * col_regList _ = return ()
newInt_at :: GecodeSolver s => GecodeColVar s -> GecodeIntConst -> s (GecodeIntVar s)
newInt_cond :: GecodeSolver s => GecodeBoolConst -> GecodeIntVar s -> GecodeIntVar s -> s (GecodeIntVar s)
newCol_list :: GecodeSolver s => [GecodeIntVar s] -> s (GecodeColVar s)
newCol_size :: GecodeSolver s => GecodeIntConst -> s (GecodeColVar s)
newCol_cat :: GecodeSolver s => GecodeColVar s -> GecodeColVar s -> s (GecodeColVar s)
splitIntDomain :: GecodeSolver s => GecodeIntVar s -> s ([GecodeConstraint s], Bool)
splitBoolDomain :: GecodeSolver s => GecodeBoolVar s -> s ([GecodeConstraint s], Bool)
col_getSize :: GecodeSolver s => GecodeColVar s -> s GecodeIntConst
col_regList :: GecodeSolver s => GecodeColConst -> s ()
data GecodeSolver s => GecodeConstraint s
GCBoolVal :: (GecodeBoolVar s) -> GecodeBoolConst -> GecodeConstraint s
GCBoolEqual :: (GecodeBoolVar s) -> (GecodeBoolVar s) -> GecodeConstraint s
GCIntVal :: (GecodeIntVar s) -> GecodeIntConst -> GecodeConstraint s
GCLinear :: (GecodeLinear s) -> GecodeOperator -> GecodeConstraint s
GCLinearReif :: (GecodeLinear s) -> GecodeOperator -> (GecodeBoolVar s) -> GecodeConstraint s
GCColEqual :: (GecodeColVar s) -> (GecodeColVar s) -> GecodeConstraint s
GCMult :: (GecodeIntVar s) -> (GecodeIntVar s) -> (GecodeIntVar s) -> GecodeConstraint s
GCDiv :: (GecodeIntVar s) -> (GecodeIntVar s) -> (GecodeIntVar s) -> GecodeConstraint s
GCMod :: (GecodeIntVar s) -> (GecodeIntVar s) -> (GecodeIntVar s) -> GecodeConstraint s
GCAbs :: (GecodeIntVar s) -> (GecodeIntVar s) -> GecodeConstraint s
GCAt :: (GecodeIntVarOrConst s) -> (GecodeColVarOrConst s) -> (GecodeIntVarOrConst s) -> GecodeConstraint s
GCChannel :: (GecodeIntVar s) -> (GecodeBoolVar s) -> GecodeConstraint s
GCSize :: (GecodeColVar s) -> (GecodeIntVarOrConst s) -> GecodeConstraint s
GCCat :: (GecodeColVar s) -> (GecodeColVar s) -> (GecodeColVar s) -> GecodeConstraint s
GCSlice :: (GecodeColVar s) -> (GecodeColSection s) -> GecodeConstraint s
GCAnd :: [GecodeBoolVar s] -> (GecodeBoolVar s) -> GecodeConstraint s
GCOr :: [GecodeBoolVar s] -> (GecodeBoolVar s) -> GecodeConstraint s
GCNot :: (GecodeBoolVar s) -> (GecodeBoolVar s) -> GecodeConstraint s
GCEquiv :: (GecodeBoolVar s) -> (GecodeBoolVar s) -> (GecodeBoolVar s) -> GecodeConstraint s
GCAllDiff :: Bool -> (GecodeColVarOrSection s) -> GecodeConstraint s
GCSorted :: (GecodeColVarOrSection s) -> GecodeOperator -> GecodeConstraint s
GCAll :: (GecodeIBFn s) -> (GecodeColVarOrSection s) -> (Maybe (GecodeBoolVar s)) -> GecodeConstraint s
GCAny :: (GecodeIBFn s) -> (GecodeColVarOrSection s) -> (Maybe (GecodeBoolVar s)) -> GecodeConstraint s
GCAllC :: (GecodeCBFn s) -> (GecodeListConst) -> (Maybe (GecodeBoolVar s)) -> GecodeConstraint s
GCAnyC :: (GecodeCBFn s) -> (GecodeListConst) -> (Maybe (GecodeBoolVar s)) -> GecodeConstraint s
GCMap :: (GecodeIIFn s) -> (GecodeColVarOrSection s) -> (GecodeColVar s) -> GecodeConstraint s
GCFold :: (GecodeIIIFn s) -> (GecodeColVarOrSection s) -> (GecodeIntVar s) -> (GecodeIntVar s) -> GecodeConstraint s
GCFoldC :: (GecodeICIFn s) -> (GecodeIntConst) -> (GecodeIntVar s) -> (GecodeIntVar s) -> GecodeConstraint s
GCSum :: (GecodeColVarOrSection s) -> (GecodeIntVarOrConst s) -> GecodeConstraint s
GCCount :: (GecodeColVar s) -> (GecodeIntVarOrConst s) -> GecodeOperator -> (GecodeIntVarOrConst s) -> GecodeConstraint s
GCDom :: (GecodeIntVar s) -> (GecodeColVarOrConst s) -> (Maybe (GecodeBoolVar s)) -> GecodeConstraint s
GCCond :: (GecodeConstraint s) -> GecodeBoolConst -> GecodeConstraint s
data GecodeOperator
GOEqual :: GecodeOperator
GODiff :: GecodeOperator
GOLess :: GecodeOperator
GOLessEqual :: GecodeOperator
data GecodeBoolSpecType
GBSConst :: GecodeBoolSpecType
GBSCondConst :: GecodeBoolSpecType
GBSVar :: GecodeBoolSpecType
data GecodeIntSpecType
GISConst :: GecodeIntSpecType
GISLinear :: GecodeIntSpecType
GISVar :: GecodeIntSpecType
data GecodeColSpecType
GCSConst :: GecodeColSpecType
GCSSection :: GecodeColSpecType
GCSVar :: GecodeColSpecType
data GecodeIntSpec s
GITConst :: GecodeIntConst -> GecodeIntSpec s
GITLinear :: (GecodeLinear s) -> GecodeIntSpec s
GITVar :: (GecodeIntVar s) -> GecodeIntSpec s
data GecodeBoolSpec s
GBTConst :: GecodeBoolConst -> GecodeBoolSpec s
GBTCondConst :: GecodeBoolConst -> GecodeBoolConst -> GecodeBoolSpec s
GBTVar :: (GecodeBoolVar s) -> GecodeBoolSpec s
data GecodeColSpec s
GCTConst :: (GecodeColConst) -> GecodeColSpec s
GCTSection :: (GecodeColSection s) -> GecodeColSpec s
GCTVar :: (GecodeColVar s) -> GecodeColSpec s
newtype GecodeIBFn s
GecodeIBFn :: (GecodeIntVar s -> GecodeBoolVar s -> s ()) -> GecodeIBFn s
newtype GecodeIIFn s
GecodeIIFn :: (GecodeIntVar s -> GecodeIntVar s -> s ()) -> GecodeIIFn s
newtype GecodeIIIFn s
GecodeIIIFn :: (GecodeIntVar s -> GecodeIntVar s -> GecodeIntVar s -> s ()) -> GecodeIIIFn s
newtype GecodeICIFn s
GecodeICIFn :: (GecodeIntVar s -> GecodeIntConst -> GecodeIntVar s -> s ()) -> GecodeICIFn s
newtype GecodeCBFn s
GecodeCBFn :: (GecodeIntConst -> GecodeBoolVar s -> s ()) -> GecodeCBFn s
newtype GecodeCIFn s
GecodeCIFn :: (GecodeIntConst -> GecodeIntVar s -> s ()) -> GecodeCIFn s
type GecodeIntConst = Expr GecodeIntParam GecodeColParam GecodeBoolParam
type GecodeBoolConst = BoolExpr GecodeIntParam GecodeColParam GecodeBoolParam
type GecodeColConst = ColExpr GecodeIntParam GecodeColParam GecodeBoolParam
type GecodeListConst = (GecodeIntConst, GecodeIntConst -> GecodeIntConst)
newtype GecodeIntParam
GIParam :: Int -> GecodeIntParam
newtype GecodeBoolParam
GBParam :: Int -> GecodeBoolParam
newtype GecodeColParam
GCParam :: Int -> GecodeColParam
type GecodeLinear s = Linear (GecodeIntVar s) GecodeIntConst
type GecodeColVarOrSection s = Either (GecodeColVar s) (GecodeColSection s)
data (GecodeSolver s, Constraint s ~ GecodeConstraint s) => GecodeWrappedSolver s a
liftGC :: (GecodeSolver s, Constraint s ~ GecodeConstraint s) => s a -> (GecodeWrappedSolver s) a
unliftGC :: (GecodeSolver s, Constraint s ~ GecodeConstraint s) => (GecodeWrappedSolver s) a -> s a
toConst :: Integral a => a -> GecodeIntConst
fromConst :: Num a => GecodeIntConst -> a
toBoolConst :: Bool -> GecodeBoolConst
fromBoolConst :: GecodeBoolConst -> Bool
addMeta :: (GecodeSolver s, Constraint s ~ GecodeConstraint s) => Mixin (GecodeConstraint s -> s Bool)
procConstraint :: (GecodeSolver s, GecodeSolver t) => GecodeConstraint t -> s ()
instance (GecodeSolver s, Eq (GecodeIntVar s), Eq (GecodeBoolVar s), Eq (GecodeColVar s), Ord (GecodeIntVar s), Ord (GecodeBoolVar s), Ord (GecodeColVar s), Show (GecodeIntVar s), Show (GecodeBoolVar s), Show (GecodeColVar s)) => Show (GecodeConstraint s)
instance (Eq (GecodeColVar s), Show (GecodeColVar s), Ord (GecodeColVar s)) => Show (GecodeColSpec s)
instance (Eq (GecodeBoolVar s), Show (GecodeBoolVar s), Ord (GecodeBoolVar s)) => Show (GecodeBoolSpec s)
instance (Eq (GecodeIntVar s), Show (GecodeIntVar s), Ord (GecodeIntVar s)) => Show (GecodeIntSpec s)
instance Show GecodeIntParam
instance Eq GecodeIntParam
instance Ord GecodeIntParam
instance Show GecodeBoolParam
instance Eq GecodeBoolParam
instance Ord GecodeBoolParam
instance Show GecodeColParam
instance Eq GecodeColParam
instance Ord GecodeColParam
instance Enum GecodeIntSpecType
instance Bounded GecodeIntSpecType
instance Eq GecodeIntSpecType
instance Ord GecodeIntSpecType
instance Show GecodeIntSpecType
instance Enum GecodeBoolSpecType
instance Bounded GecodeBoolSpecType
instance Eq GecodeBoolSpecType
instance Ord GecodeBoolSpecType
instance Show GecodeBoolSpecType
instance Enum GecodeColSpecType
instance Bounded GecodeColSpecType
instance Eq GecodeColSpecType
instance Ord GecodeColSpecType
instance Show GecodeColSpecType
instance Eq GecodeOperator
instance Ord GecodeOperator
instance Show GecodeOperator
instance (GecodeSolver s, GecodeConstraint s ~ Constraint s) => FDSolver (GecodeWrappedSolver s)
instance (GecodeSolver s, Term s t, Constraint s ~ GecodeConstraint s) => Term (GecodeWrappedSolver s) t
instance (GecodeSolver s, Constraint s ~ GecodeConstraint s) => Solver (GecodeWrappedSolver s)
instance (GecodeSolver s, Constraint s ~ GecodeConstraint s) => Monad (GecodeWrappedSolver s)
instance (GecodeSolver s, Constraint s ~ GecodeConstraint s, EnumTerm s t) => EnumTerm (GecodeWrappedSolver s) t
instance (GecodeSolver s, Constraint s ~ GecodeConstraint s) => GecodeSolver (GecodeWrappedSolver s)
instance GecodeSolver s => Show (GecodeFn s)
instance Show (GecodeICIFn s)
instance Show (GecodeIIIFn s)
instance Show (GecodeIIFn s)
instance Show (GecodeCIFn s)
instance Show (GecodeCBFn s)
instance Show (GecodeIBFn s)
instance Show (GecodeIntConst -> GecodeIntConst)
instance Procable a => Procable [a]
instance Procable (a, GecodeListConst)
instance Procable GecodeListConst
instance (Ord b, Num a, Procable a) => Procable (Linear b a)
instance Procable a => Procable (Either b a)
instance Procable GecodeColConst
instance Procable GecodeBoolConst
instance Procable GecodeIntConst

module Control.CP.FD.OvertonFD.Sugar
instance FDSolver OvertonFD

module Control.CP.FD.Gecode.CodegenSolver
generateGecode :: CompilableModel t => t -> String
data CodegenGecodeSolver a
data CodegenGecodeOptions
CodegenGecodeOptions :: Bool -> Bool -> CodegenGecodeOptions
noTrailing :: CodegenGecodeOptions -> Bool
noGenSearch :: CodegenGecodeOptions -> Bool
setOptions :: (CodegenGecodeOptions -> CodegenGecodeOptions) -> CodegenGecodeSolver ()
instance Show IntParDef
instance Show ColParDef
instance Show CodegenGecodeOptions
instance Eq BoolVar
instance Ord BoolVar
instance Show BoolVar
instance Eq ColVar
instance Ord ColVar
instance Show ColVar
instance Eq IntVar
instance Ord IntVar
instance Show IntVar
instance Show ColDef
instance Monad CodegenGecodeSolver
instance MonadState CodegenGecodeState CodegenGecodeSolver
instance Show CodegenGecodeState
instance Num CPPExpr
instance CompilableModel (Tree (FDInstance (GecodeWrappedSolver CodegenGecodeSolver)) ModelCol)
instance CompilableModel m => CompilableModel (ModelCol -> m)
instance CompilableModel m => CompilableModel (ModelInt -> m)
instance CompilableModel (FDInstance (GecodeWrappedSolver CodegenGecodeSolver) (SearchSpec ModelInt ModelCol ModelBool))
instance CompilableModel (FDInstance (GecodeWrappedSolver CodegenGecodeSolver) ModelCol)
instance CompilableModel (CodegenGecodeSolver a)
instance GecodeSolver CodegenGecodeSolver
instance Term CodegenGecodeSolver BoolVar
instance Term CodegenGecodeSolver IntVar
instance Show (CPPExpr -> CPPExpr)
instance Ord (CPPExpr -> CPPExpr)
instance Eq (CPPExpr -> CPPExpr)
instance Solver CodegenGecodeSolver

module Control.CP.FD.Example
example_main :: ExampleModel [String] -> ExampleModel ModelInt -> ExampleModel ModelCol -> Bool -> IO ()
example_sat_main :: ExampleModel [String] -> ExampleModel ModelInt -> ExampleModel ModelCol -> IO ()
example_sat_main_void :: ExampleModel () -> IO ()
example_sat_main_single :: Read n => ExampleModel n -> IO ()
example_sat_main_single_expr :: ExampleModel ModelInt -> IO ()
example_sat_main_coll_expr :: ExampleModel ModelCol -> IO ()
example_min_main :: ExampleMinModel [String] -> ExampleMinModel ModelInt -> ExampleMinModel ModelCol -> IO ()
example_min_main_void :: ExampleMinModel () -> IO ()
example_min_main_single :: Read n => ExampleMinModel n -> IO ()
example_min_main_single_expr :: ExampleMinModel ModelInt -> IO ()
example_min_main_coll_expr :: ExampleMinModel ModelCol -> IO ()
type ExampleModel t = forall s m. (Show (FDIntTerm s), FDSolver s, MonadTree m, TreeSolver m ~ (FDInstance s)) => t -> m (ModelCol)
type ExampleMinModel t = forall s m. (Show (FDIntTerm s), FDSolver s, MonadTree m, TreeSolver m ~ (FDInstance s)) => t -> m (ModelInt, ModelCol)