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.