All Classes and Interfaces

Class
Description
Constraints |P| #= R
This class specifies an abstract class for clauses pools.
Constraints |X| #= Y
Constraints acos(P) = R
Defines a pruning activity comparatorfor variables.
Defines a pruning activity comparatorfor variables.
Defines a pruning activity comparatorfor variables.
Defines a pruning activity comparatorfor variables.
counts the activity of literals
It creates a constraints that subtracts from set variable A the elements from of the set variable B and assigns the result to set variable C.
The disjoint set constraint makes sure that two set variables do not contain any common element.
It creates an equality constraint to make sure that two set variables have the same value.
It creates an equality constraint to make sure that a set variable is equal to a given set.
Defines a AccumulatedFailureCount comparator (afc) for variables.
Defines a AccumulatedFailureCount comparator (afc) for variables.
Defines a AccumulatedFailureCount comparator (afc) for variables.
Defines a AccumulatedFailureCount comparator (afc) for variables.
It creates a constraint that makes sure that the set value of set variable A is included in the set value of set variable B.
It creates a constraint that makes sure that value of the variable A is included within a provided set.
It creates a constraint that makes sure that A intersected with B is equal to C.
It creates a <= b constraint on two set variables.
Alldiff constraint assures that all FDVs has different values.
 
Alldifferent constraint assures that all FDVs has differnet values.
Alldistinct constraint assures that all FDVs have different values.
 
It creates a < b constraint on two set variables.
Among constraint in its simplest form.
Among constraint in its general form.
Constraint c1 /\ c2 ...
AndBool constraint implements logic and operation on its arguments and returns result.
If both a and b are equal 1 then result variable is equal 1 too.
 
It specifies AR benchmark.
A directed, residual arc in the graph.
This class extends the definition of an arc by a lower bound on the capacity and connects the arc to variables that constrain it.
It is a simple logic puzzle about shoe purchases.
ArgMax constraint provides the index of the maximum variable from all variables on the list.
ArgMin constraint provides the index of the maximum variable from all variables on the list.
 
It stores information about a single array access encountered during parsing flatzinc file.
Constraints asin(P) = R
 
A class that can register to the Solver, to be notified when some events occur.
Assignment constraint implements facility to improve channeling constraints between dual viewpoints of permutation models.
 
 
 
 
 
 
 
 
 
 
 
 
 
ASTPrint.java
 
 
 
 
 
 
 
 
 
 
Constraints atan(P) = R
 
 
It creates a constraint that makes sure that A union B is equal to C.
It is a simple logic puzzle about babysitting.
interface for components that listen for backjumps, or restarts
 
 
It solves an arithmetic puzzle BASIC+LOGIC=PASCAL.
a basic preprocessor.
It models and solves Balanced Incomplete Block Design (BIBD) problem (CSPLIB-P28).
A database for binary clauses.
Binary Node of the tree representing linear constraint.
BinItem is used in bin-packing constraint to keep bin variable for an item and its weight.
Binpacking constraint implements bin packing problem.
 
It solves a simple logic puzzle about blueberry muffins.
 
I defines a boolean clause for 0/1 variables x_i and y_i.
Generation of boolean constraints in flatzinc
Defines a variable and related operations on it.
Defines interval of numbers which is part of FDV definition which consist of one or several intervals.
Defines a methods for enumerating intervals contained in the BoundDomain.
Defines a methods for enumerating values contained in the BoundDomain.
Defines a set interval determined by a least upper bound(lub) and a greatest lower bound(glb).
Defines a variable for Linear constraints to keep intermediate bounds values
Defines a current bounds for the Linear constraint.
 
It solves a simple logic puzzle about reporters breaking news stories.
Binary Node of the tree representing linear constraint.
It solves a simple logic puzzle about blocks.
Defines interface for a calculator for restart search
It solves a simple logic puzzle about sport calendar.
The set cardinality constraint.
The set cardinality constraint.
It is program to model and solve simple problems of car sequencing problem (CSPLIB-p1).
ChannelImply constraints "B => constraint".
 
It collects all int_eq_(reif|imp) constraint to create Channel(Reif|Imply) constraints, if possible.
ChannelReif constraints "constraint" <=> B.
 
 
Circuit constraint assures that all variables build a Hamiltonian circuit.
Defines a Variable for Circuit constraints and related operations on it.
Defines a current value of the CircuitVar and related operations on it.
Interface for clause databases or database stores.
module that listens to add/removal of clauses
constants that represent the state of a clause at some point in the search
CNF file format (low-level) parser.
exception occurring during parse
Defines an interface for comparing variables.
 
Conditional constraint implements conditional constraint satisfiability.
It solves a simple conference session placement problem.
It solves a simple conference talk placement problem.
The configuration for a solver.
A solver component for conflict learning.
module that listens to conflicts that are discovered.
Defines an interface of an object which can be plugined into the search right after executing the consistency function (at the beginning of each search node).
Defines functionality for constant calculator for restart search
 
 
The part of the parser responsible for parsing constraints.
The main solver structure, to be used either by a search component or by another program that uses it for conflict learning and detection.
Constraints cos(P) = R
Constraints cos(P) = R
Count constraint implements the counting over number of occurrences of a given value in a list of variables.
CountBounds constraint implements the counting over number of occurrences of a given value in a list of variables.
 
CountValuesBounds constraint implements the counting over numbers of occurrences of a given vector of values in a list of variables.
 
 
It shows how to visualize solving process for Gardner problem.
The class Run is used to run test programs for JaCoP package.
It is a simple newspaper reading job-shop like scheduling problem.
It shows how to visualize solving process for SendMoreMoney problem.
It shows how to visualize the solving process for Sudoku problem.
Defines functionality of credit search.
It is an example of the power of ExtensionalSupportMDD constraint which can be used to efficiently model and solve CrossWord puzzles.
Cryptogram.
Cumulative implements the cumulative/4 constraint using edge-finding algorithm and profile information on the resource use.
 
 
 
 
 
Defines a basic data structure to keep two profiles for the cumulative constraints.
 
 
Print-outs all variables defined in the constructor when restart search finds a solution.
 
A simple rule that always chooses the arc with maximum violation.
This provides a unique interface to several databases.
 
It specifies DCT benchmark.
A program solving problem of finding de Bruijn sequences.
module used for debug : it logs every event it is informed of
Standard unified interface/abstract class for constraints, which can only be decomposed.
Decreasing constraint assures that all variables are in decreasing order.
A standard database of clauses, implemented in an efficient way such that insertion or removal of clauses works fast.
The class gathers variables and array variables for default or complementary search.
Implements Depth First Search with number of possible plugins (listeners) to be attached to modify the search.
Derivative for float constraints
It specifies DFQ filter benchmark.
It specifies a simple diet problem.
Diff constraint assures that any two rectangles from a vector of rectangles does not overlap in at least one direction.
 
Diff2 constraint assures that any two rectangles from a vector of rectangles does not overlap in at least one direction.
Defines a Variable for Diff2 constraints and related operations on it.
Defines a current value of the Diff2Var and related operations on it.
Diffn constraint assures that any two rectangles from a vector of rectangles does not overlap in at least one direction.
 
Diffn constraint assures that any two rectangles from a vector of rectangles does not overlap in at least one direction.
Defines a basic data structure to keep the profile for the diff2/1 constraints.
Disjoint constraint assures that any two rectangles from a vector of rectangles does not overlap in at least one direction.
DisjointConditional constraint assures that any two rectangles from a vector of rectangles does not overlap in at least one direction.
Defines a basic data structure to keep the profile for the diffn/1 constraints.
Defines a Variable for Diff2 constraints and related operations on it.
Defines a current value of the Diff2Var and related operations on it.
Constraint |X - Y| #= Z
It solves a simple logic puzzle - Dollar and Ticket problem.
Defines a Domain and related operations on it.
clause database designed to handle efficiently CP domain constraints, with the interface of boolean clauses databases.
 
A domain based structure variable.
 
A component that translates CP variables ranges to boolean clauses to be added to the SAT solver
It specifies the logic puzzle (cryptogram) which need to satisfy the following equation that DONALD+GERALD=ROBERT.
It specifies DOT benchmark.
It constructs a constraint which makes sure that a given element is in the domain of the set variable.
Element constraint implements the element/4 constraint (both with integer list and variables list).
 
ElementFloat constraint defines a relation list[index - indexOffset] = value.
ElementFloatVariable constraint defines a relation list[index - indexOffset] = value.
ElementInteger constraint defines a relation list[index - indexOffset] = value.
 
It is an element constraint that make sure that set variable value has a domain equal to the index-th element of the supplied list of sets.
ElementSetVariable constraint defines a relation list[index - indexOffset] = value.
ElementVariable constraint defines a relation list[index - indexOffset] = value.
 
Constraint "constraint1"#<=> "constraint2"
If all x's are equal to each other then result variable is equal 1.
EquationSystem constraint implements the multivariate interval Newton method for pruning domains of variables in a system of non-linear equations.
It specifies EWF benchmark.
It is an abstract class to describe all necessary functions of any store.
It is an abstract class to describe all necessary functions of any store.
Defines a basic structure for exsclusive rectangles used in DisjointConditional
Defines a list of exclusive items.
Defines a listener which is called by the search if a child node is exited.
This listener is executed when search has finished executing is about to exit the labeling procedure.
It is a simple logic puzzle about children reading stories.
module used when an explanation is found
Constraints exp(P) #= Q for P and Q floats
Extensional constraint assures that none of the tuples explicitly given is enforced in the relation.
Extensional constraint assures that one of the tuples is enforced in the relation.
Extensional constraint assures that one of the tuples is enforced in the relation.
Extensional constraint assures that one of the tuples is enforced in the relation.
 
a factory for type E
Defines functionality for FailConstraintsStatistics plug-in, that collects statistics on the failed constraints; both for each individual constraint as well as a class of constraints.
It is thrown when search has encountered a dead end and backtracking must occurr.
It specifies FFT benchmark.
It provides the basic functionality which must be implemented by any filter problem.
This is a set of filter scheduling examples, commonly used in High-Level Synthesis.
FIR benchmark (16-point FIR filter).
FIR benchmark (16-point FIR filter)
It is program to solve problem of fitting numbers to made them equal to zero.
An executable to parse the flatzinc file and create the JaCoP model.
The class Run is used to run test programs for JaCoP package.
The class Run is used to run test programs for JaCoP package.
Generation of set constraints in flatzinc
 
Defines interval of numbers which is part of FDV definition which consist of one or several intervals.
 
Defines a methods for enumerating values contain in the intersal domain.
Defines a methods for enumerating values contain in the intersal domain.
Generation of set constraints in flatzinc
The class Run is used to run test programs for JaCoP package.
Generation of set constraints in flatzinc
Defines a Float Domain Variable and related operations on it.
It is quite complex logic puzzle about flowers.
 
called when the solver forget() method is called.
It is a very simple puzzle about islands and bridges.
Deterministic Finite Acyclic graph.
 
 
It is a simple logic puzzle about furniture moving.
An executable to parse and execute the flatzinc file.
It specifies a simple Gardner problem which use set functionality from JaCoP.
It specifies an adder using gates specified by extensional constraints.
GCC constraint counts the number of occurences of given values in x variables.
 
 
Deprecated.
Defines functionality for constant calculator for restart search
 
 
It specifies an example where squares of the given size must be placed within a square of a given size.
 
Generation of global constraints in flatzinc.
 
A simple logic puzzle about golf players.
It models a Golomb ruler problem.
 
module used to guide research by selecting the next literal to assert
A component that selects clauses to forget when solver.forget() is called.
A module that indicates if a restart would be useful now.
It is a simple logic puzzle about houses.
Constraint if constraint1 then constraint2
Constraint ( X => Y ) <=> Z.
Constraint if constraint1 then constraint2 else constraint3 *
It collects all int_eq_imp constraint to create ChannelImply constraints, if possible.
 
Defines an interface for defining different methods for selecting next search decision to be taken.
Constraints X to belong to a specified domain.
 
Increasing constraint assures that all variables are in increasing order.
Defines index domain view for a variable and related operations on it.
Defines a interface for different indomain enumeration methods.
IndomainDefaultValue - implements enumeration method based on the selection of the default value for each variable first.
IndomainHierarchical - implements enumeration method based on the selection of the preferred indomain for each variable.
IndomainList - implements enumeration method based on the selection of the preferred values for each variable.
IndomainMax - implements enumeration method based on the selection of the maximal value in the domain of the variable.
IndomainMedian - implements enumeration method based on the selection of the median value in the domain of FD variable and then right and left values.
IndomainMiddle - implements enumeration method based on the selection of the middle value in the domain of FD variable and then right and left values.
IndomainMin - implements enumeration method based on the selection of the minimal value in the domain of variable
IndomainRandom - implements enumeration method based on the selection of the random value in the domain of FD variable.
IndomainMin - implements enumeration method based on the selection of the maximal value in the domain of variable
IndomainMin - implements enumeration method based on the selection of the minimal value in the domain of variable
IndomainMin - implements enumeration method based on the selection of the maximal value in the domain of variable.
IndomainRandom - implements enumeration method based on the selection of the random value in the domain of FD variable.
This listener is executed when search has began executing and it is about to enter the labeling procedure.
It is simple input order selector of variables.
 
 
In order to avoid the cost of repeated calls to isInternalConstraintApplicable, we need 3 different states.
It is thrown when search has encountered a dead end and backtracking must occurr.
Defines interval of numbers which is part of FDV definition which consist of one or several intervals.
 
Defines interval of numbers which is part of FDV definition which consist of one or several intervals.
Defines a methods for enumerating values contain in the intersal domain.
Defines a methods for enumerating values contain in the domain.
Defines a methods for enumerating values contain in the intersal domain.
IntervalGaussSeidel implements Gauss-Seidel method for solving a system of linear equations Ax = b with interval matrix A of coefficients.
an efficient map with ints as keys.
 
A mix of a priority queue and a hashmap, specialized for ints
a node containing the data associated with each int
Special class for unboxed int FIFO
Defines a rectangle with integer origine and length used in the diffn constraint.
an efficient Set for unboxed int.
Special class for unboxed int stack
Represents tasks with integer start, duration and resource valurs for cumulative constraint
A class that implements, (hopefully) efficiently, a Trie on integers.
class of nodes of the Trie.
The most simple node possible
Defines a Finite Domain Variable (FDV) and related operations on it.
low level, efficient int vector
 
It is program to solve Kakro puzzles.
It specifies a knapsack constraint.
It shows the capabilities and usage of Knapsack constraint.
This class stores information about items being considered by a Knapsack constraint.
It solves Langford problem.
 
Defines LargestDomain comparator for Variables.
Defines LargestDomainFloat comparator for Variables.
Defines a LargestMax comparator for Variables.
Defines a LargestMaxFloat comparator for Variables.
Defines a LargestMin comparator for Variables.
Defines a LargestMinFloat comparator for Variables.
It solves a Latin Square problem.
Deprecated.
a node of the double linked list
Defines functionality of limited discrepancy search.
Simple least Diff problem.
It is a simple logic puzzle about lectures.
 
It constructs a Lex (lexicographical order) constraint.
Deprecated.
As of release 4.5.1 replaced by AltB and AleB constraints.
 
 
It constructs a LexOrder (lexicographical order) constraint.
Deprecated.
As of release 4.3.1 replaced by LinearInt constraint.
Linear constraint implements the weighted summation over several Variable's .
 
Defines functionality for constant calculator for restart search
Generation of linear constraints in flatzinc.
LinearFloat constraint implements the weighted summation over several Variable's .
 
LinearIntDom constraint implements the weighted summation over several variables.
Constraints Ln(P) #= Q for P and Q floats
 
A pool of long clauses, implemented with two watched an blocking literals to minimize cache misses.
Defines functionality for constant calculator for restart search
It solves a Magic squares problem.
A clause used for resolution, easily modifiable several times, and that can then be converted to an int[].
 
It solves a logic puzzle about singing women.
This constraint matches the elements of the given set variable onto a list of integer variables.
Matrix and operations on matrices.
Max constraint implements the Maximum/2 constraint.
Max constraint implements the Maximum/2 constraint.
Defines a maximum cardinality difference variable comparator.
Defines a maximum cardinality, of the greatest lowest bound, variable comparator.
Defines a maximum cardinality, of the least upper bound, variable comparator.
Defines a MaxRegret comparator for Variables.
Defines a MaxRegretFloat comparator for Variables.
MaxSimple constraint implements the Maximum/2 constraint.
Defines an MDD as used in the following paper.
Member constraint implements the membership of element e on list x.
Class containing int[] of different lengths, to avoid allocating/deallocating too much.
Min constraint implements the minimum/2 constraint.
Min constraint implements the minimum/2 constraint.
Defines a minimum cardinality difference variable comparator.
 
Defines a MinDomainOverDegree comparator for Variables.
It models and solves Minesweeper problem.
Defines a minimum cardinality, of the greatest lowest bound, variable comparator.
Defines a minimum cardinality, of the least upper bound, variable comparator.
MinSimple constraint implements the minimum/2 constraint.
Defines a MostConstrainedDynamic comparator for Variables.
Defines a MostConstraintStatic comparator for Variables.
It solves the Mixed Multi-Unit Combinatorial Auctions.
 
 
 
MultivariateIntervalNewton implements multivariate interval Newton method for solving a system of non linear equations.
 
 
Interface to the network used by VarHandlers.
Standard mutable variable definition
Standard mutable variable's value definition
This class extends the minimum-cost flow network by providing operations and data structures for removal and modification of arcs.
A builder class for the network flow constraints.
The network flow constraint.
 
It is a simple newspaper reading job-shop like scheduling problem.
A node (vertex) in the network.
 
NoGood constraints implements a constraint which disallows given combination of values for given variables.
NoGoodCollector collects no-goods from search when timeout has occurred.
It solves a nonogram example problem, sometimes also called Paint by Numbers.
 
It models and solves Nontransitive Dice Problem.
Nooverlap constraint assures that any two rectangles from a vector of rectangles does not overlap in at least one direction.
Constraint "not costraint"
It is thrown in flazinc when search reaches a number of specified solutions using option -n.
 
 
Defines functionality for OneSolution plug-in, that is the search with this plug-in will stop after funding first solution.
Generation of linear constraints in flatzinc
Implements optimization for floating point varibales
It parses the options provided to flatzinc parser/executable.
util to parse command-line arguments
a class to handle one option
Constraint c1 \/ c2 \/ ...
OrBool constraint implements logic and operation on its arguments and returns result.
If at least one variable is equal 1 then result variable is equal 1 too.
If at least one variable from the list is equal 1 then result variable is equal 1 too.
It stores information about the annotation for an output array.
It solves a simple parcel shipment problem.
This exception is thrown when parse errors are encountered.
 
 
 
Token literal values and constants.
Token Manager.
 
Constraint P / C = R for floats
Constraint P / Q = R for floats
Constraints P #= C
Constraints P #= Q for P and Q floats
It specifies an example where squares of the given size must be placed within a square of a given size.
Constraint P > C
Constraints P >= C for floats
Constraints P >= Q for floats
Constraint P > Q for floats
It solves the PigeonHole problem.
A pivot selection rule for the primal network simplex algorithm.
Constraint P < C for floats
Constraint X <= C for floats
Constraint P <= Q for floats
Constraint P < Q for floats
Constraint P - C = R
Constraint P - Q = R
Constraint P * C = R for floats
Constraint P * Q = R for floats
Constraints P != C
Constraints P #= Q for P and Q floats
Constraint P + C #= R
Constraint P + Q = R
 
Standard unified interface for all primitive constraints.
It is a simple example how it is possible to extend existing listeners to add your own functionality.
Prints the computed schedule
PrioritySearch selects first a row in the matrix based on metric of the variable at the pririty vector.
 
It solves a simple logic puzzle about voting city council.
Defines a basic data structure to keep the profile for the diffn/1 and cumulative/4 constraints.
Defines a basic data structure to keep the profile for the disjointConditonal/2
Defines a basic structure used to update profile for cumulative constraint.
Defines a basic structure used to update profile DisjointConditional when some rectangles can share the same place.
module called when a propagate event is called
 
 
It solves QuasiGroup Completion Problem (QCP).
It models the queens problem in different ways as well as applies different search methods.
Utility class that allows for constraints like Xor, Reified, etc that take other constraints as parameters to forward any changes of variables to the constraints that were provided as arguments.
It is simple and customizable selector of decisions (constraints) which will be enforced by search.
Defines a RandomVar comparator for variables.
Defines a rectangle used in the diffn constraint.
Defines a rectangle used in the diffn constraint.
Defines a rectangle used in the diffn constraint.
The class responsible for connecting two states in regular automaton of Regular constraint.
The state class representing a state in the regular automaton within Regular constraint.
It is a state representation which uses a domain representation to represent all integers which can transition from this state to the given successor state.
It is an implementation of the Regular state which uses a separate successor for each value.
Regular constraint accepts only the assignment to variables which is accepted by an automaton.
Instances of this class parse the word combination little language.
SyntaxException raised if not regular expression is being parsed.
It collects all int_eq_reif constraint to create ChannelReif constraints, if possible.
 
Replacement of Reified with IfThen.
Interface that provides the entity ability to be called after the level has been removed to finalize the removal of the level for the constraint.
Interface that provides ability to configure constraint store to replace a particular type of constraints into another one.
Implements restart search.
ReversibleSparseBitSet implements the main data structure for table constraint.
 
 
This class executes the provided example.
The main class for the SAT solver when it is used standalone (without being controlled by a master).
 
this class listens to changes in literals in SAT solver, and reminds what changes this implies for CP variables
interface representing the domain of a CP variable as a range.
Interface to mark the need (PrimitiveConstraint) or extra functionality (Constraint) to compute if the constraint is satisfied.
SatTranslation defines SAT clauses for typical logical constraints
wrapper to communicate between SAT solver and CP solver.
All searches needs to implement this interface in order to be manipulable by a large variety of search listeners.
The part of the parser responsible for parsing search part of the flatzinc specification.
A basic searching component, which controls the solver to solve the problem
Defines an interface for defining different methods for selecting next search decision to be taken.
It is a simple arithmetic logic puzzle, where SEND+MORE=MONEY.
It constructs a Sequence constraint.
Generation of set constraints in flatzinc
Defines a set interval determined by a least upper bound(lub) and a greatest lower bound(glb).
Defines a methods for enumerating values contained in the SetDomain.
Defines a Finite Domain Variable (FDV) and related operations on it.
Defines functionality for SGMPCS search
SGMPCSearch - implements Solution-Guided Multi-Point Constructive Search.
 
Defines functionality of shaving.
 
It is quite complex logic puzzle about siblings.
Different implementation of an ArrayList data structures.
It is responsible of remembering what variables have changed at given store level.
An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without unicode processing).
A simple representation for small domains, not lazy.
This class provides very simple HashSet functionality.
Defines an interface for defining different methods for selecting next search decision to be taken.
SimpleMatrixSelect selects first a row in the matrix based on metric of the variable at pivotPosition.
 
It is simple and customizable selector of decisions (constraints) which will be enforced by search.
It defines a simple solution listener which should be used if some basic functionality of search when a solution is encountered are required.
SimpleTable implements the table constraint using a method presented in
It defines a simple time out listener.
It creates an inclusion set constraint to make sure that provided set is included in a set variable a.
 
Constraints sin(P) = R
 
It is a simple logic puzzle about sleeping arrangements.
Defines small dense domain based on bits within a long number.
Defines interval enumeration of small dense domain.
Defines a methods for enumerating values contain in the domain.
Defines a Smallest Domain comparator for Variables.
Defines a Smallest Domain comparator for Variables.
Defines a SmallestMax comparator for Variables.
Defines a SmallestMaxFloat comparator for Variables.
Defines a SmallestMin comparator for variables.
Defines a SmallestMinFloat comparator for variables.
It is a Social Golfer example based on set variables.
This class provides soft-alldifferent constraint by decomposing it either into a network flow constraint or a set of primitive constraints.
This class provides soft-gcc constraint by decomposing it either into a network flow constraint or a set of primitive constraints.
module called when solution is found.
Defines an interface which needs to be implemented by all classes which wants to be informed about the solution.
 
 
An interface for solver components, that are connected together via the Core.
 
 
Sparse set representation of the set.
It is simple and customizable selector of decisions (constraints) which will be enforced by search.
It is simple and customizable selector of decisions (constraints) which will be enforced by search.
It is simple and customizable selector of decisions (constraints) which will be enforced by search.
It is simple and customizable selector of decisions (constraints) which will be enforced by search.
Constraint sqrt(P) = R for floats
called when the solver starts or stops.
Interface to mark the need of an entity to receive information about level being removed.
This class stores all the statistics gather during the execution of the network flow constraint.
 
collects statistics about the solver
It models and solves Steiner problem.
It solves a simple logic puzzle about artifacts.
It is an abstract class to describe all necessary functions of any store.
Interface to mark the need of an entity to receive information about Constraint Store within which this entity operates.
It constructs a Stretch constraint based on Regular constraint.
Subcircuit constraint assures that all variables build a subcircuit.
A simple model to solve Sudoku problem.
 
 
SumFloat constraint implements the weighted summation over several Variable's .
SumInt constraint implements the summation over several variables.
 
Deprecated.
As of release 4.3.1 replaced by LinearIntDom constraint.
It computes a weighted sum of the elements in the domain of the given set variable.
 
It solves Survo puzzle.
It is a container class which specifies all different switches to turn on debugging information.
 
Table implements the table constraint using a method presented in
TableMill generates tables for different constraint to be used in Table constraint
This class contains information about all variables, including the variables which are used by search.
 
Constraints sin(P) = R
 
Represents tasks for cumulative constraint
 
 
 
A database for ternary clauses.
 
 
Implements ThetaLambdaUnaryNode for ThetaLambdaUnaryTree.
 
Implements ThetaNode for ThetaTree.
 
 
It defines an interface of the class which wants to be informed about timeout occurring during search, as well as the number of solutions found before timeout has occurred.
 
This class provides mutable variable functionality.
 
Describes the input token stream.
Token Manager Error.
TODO TraceGenerator should accept as input to constructor a Search object.
It stores the current variables status (affected or not, with which value and explanation).
It defines an intialize listener which transforms part of the problem into an extensional constraint by searching for all partial solutions given the scope of the variables of interest.
 
This tree is a main data structure used and required by Knapsack constraint.
It contains information required by the leaf node of the item tree.
Implements TreeNode for Tree.
It contains information required by an internal node of the item tree.
It is thrown in flazinc when search is not needed since the solution is known.
It models Travelling Salesman Problem (TSP).
It solves a simple logic puzzle about music concert.
Util functions for arrays of tuples.
A database for unit clauses (length 1).
 
Contains utils for arrays manipulation
Defines a methods for enumerating values contained in the domain.
 
Constraint Values counts number of different values on a list of Variables.
Defines a variable and related operations on it.
Common interface to all objects that can handle one or more variables of the network flow constraint.
 
TODO, a short description what it does and how it is used.
VariableTrace is a daemon that prints information on variables whenever they are changed.
 
 
 
Defines a WeightedDegree comparator for variables.
Defines a WeightedDegreeFloat comparator for Variables.
Who killed agatha? (The Dreadsbury Mansion Murder Mystery).
 
A simple logic problem of transporting wolf, goat, and cabbage over the river.
a component that is aware of the existence of a SatWrapper
a class used to debug, but with additional data
Constraint X div Y #= Z
It creates a constraint that makes sure that the value assigned to the integer variable x is the only element of the set assigned to a set variable a.
 
Constraints X #= P for X and P floats
Constraints X #= Y
Constraint X ^ Y #= Z
Constraint X > C
Constraints X >= C
Constraints X >= Y
Constraint X > Y
It creates a constraint that makes sure that the value assigned to integer variable x is included in the set assigned to the set variable a.
Constraint X < C
Constraint X <= C
Constraint X <= Y
Constraint X < Y
 
 
Constraint X * Y #= C
 
 
Constraints X #\= Y
Xor constraint - xor("constraint", B).
Constraint ( x_0 xor x_1 xor ...
Constraint X + C #= Z.
Constraints X + C<= Z.
Constraint X + Y #= C
Constraint X + Y = Z
Constraint X + Y> C
Constraint X + Y=< Z
It models and solves Zebra logic puzzle.