All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary
| Class |
Description |
| AbsPeqR |
Constraints |P| #= R
|
| AbstractClausesDatabase |
This class specifies an abstract class for clauses pools.
|
| AbsXeqY |
Constraints |X| #= Y
|
| AcosPeqR |
Constraints acos(P) = R
|
| ActivityMax<T extends Var> |
Defines a pruning activity comparatorfor variables.
|
| ActivityMaxDeg<T extends Var> |
Defines a pruning activity comparatorfor variables.
|
| ActivityMin<T extends Var> |
Defines a pruning activity comparatorfor variables.
|
| ActivityMinDeg<T extends Var> |
Defines a pruning activity comparatorfor variables.
|
| ActivityModule |
counts the activity of literals
|
| AdiffBeqC |
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.
|
| AdisjointB |
The disjoint set constraint makes sure that two set variables
do not contain any common element.
|
| AeqB |
It creates an equality constraint to make sure that two set variables
have the same value.
|
| AeqS |
It creates an equality constraint to make sure that a set variable
is equal to a given set.
|
| AFCMax<T extends Var> |
Defines a AccumulatedFailureCount comparator (afc) for variables.
|
| AFCMaxDeg<T extends Var> |
Defines a AccumulatedFailureCount comparator (afc) for variables.
|
| AFCMin<T extends Var> |
Defines a AccumulatedFailureCount comparator (afc) for variables.
|
| AFCMinDeg<T extends Var> |
Defines a AccumulatedFailureCount comparator (afc) for variables.
|
| AinB |
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.
|
| AinS |
It creates a constraint that makes sure that value of the variable A is included within
a provided set.
|
| AintersectBeqC |
It creates a constraint that makes sure that A intersected with B
is equal to C.
|
| AleB |
It creates a <= b constraint on two set variables.
|
| Alldiff |
Alldiff constraint assures that all FDVs has different values.
|
| Alldiff.Element |
|
| Alldifferent |
Alldifferent constraint assures that all FDVs has differnet values.
|
| Alldistinct |
Alldistinct constraint assures that all FDVs have different values.
|
| AllowedArea |
|
| AltB |
It creates a < b constraint on two set variables.
|
| Among |
Among constraint in its simplest form.
|
| AmongVar |
Among constraint in its general form.
|
| And |
Constraint c1 /\ c2 ...
|
| AndBool |
AndBool constraint implements logic and operation on its arguments
and returns result.
|
| AndBoolSimple |
If both a and b are equal 1 then result variable is equal 1 too.
|
| AndBoolVector |
If all x's are equal 1 then result variable is equal 1 too.
|
| AR |
It specifies AR benchmark.
|
| Arc |
A directed, residual arc in the graph.
|
| ArcCompanion |
This class extends the definition of an arc by a lower bound on the capacity
and connects the arc to variables that constrain it.
|
| ArchFriends |
It is a simple logic puzzle about shoe purchases.
|
| ArgMax |
ArgMax constraint provides the index of the maximum
variable from all variables on the list.
|
| ArgMin |
ArgMin constraint provides the index of the maximum
variable from all variables on the list.
|
| Arithmetic |
|
| ArrayAccess |
It stores information about a single array access encountered during parsing flatzinc file.
|
| AsinPeqR |
Constraints asin(P) = R
|
| Assert |
|
| AssertionListener |
A class that can register to the Solver, to be notified when some events
occur.
|
| Assignment |
Assignment constraint implements facility to improve channeling constraints
between dual viewpoints of permutation models.
|
| ASTAnnExpr |
|
| ASTAnnotation |
|
| ASTArrayLiteral |
|
| ASTBoolTiExprTail |
|
| ASTConstElem |
|
| ASTConstraint |
|
| ASTConstraintItems |
|
| ASTFloatTiExprTail |
|
| ASTIntFlatExpr |
|
| ASTIntLiterals |
|
| ASTIntTiExprTail |
|
| ASTmodel |
|
| ASTModelEnd |
|
| ASTPrint |
ASTPrint.java
|
| ASTScalarFlatExpr |
|
| ASTSetLiteral |
|
| ASTSetTiExprTail |
|
| ASTSolveExpr |
|
| ASTSolveItem |
|
| ASTSolveKind |
|
| ASTVarDeclItem |
|
| ASTVarDeclItems |
|
| ASTVariableExpr |
|
| AtanPeqR |
Constraints atan(P) = R
|
| AtLeast |
AtLeast constraint implements the counting over number of occurrences of
a given value in a list of variables.
|
| AtMost |
AtMost constraint implements the counting over number of occurrences of
a given value in a list of variables.
|
| AunionBeqC |
It creates a constraint that makes sure that A union B is equal to C.
|
| BabySitting |
It is a simple logic puzzle about babysitting.
|
| BackjumpListener |
interface for components that listen for backjumps, or restarts
|
| Backtrackable |
|
| BacktrackableManager |
|
| BasicLogicPascal |
It solves an arithmetic puzzle BASIC+LOGIC=PASCAL.
|
| BasicPreprocessor |
a basic preprocessor.
|
| BIBD |
It models and solves Balanced Incomplete Block Design (BIBD) problem (CSPLIB-P28).
|
| BinaryClausesDatabase |
A database for binary clauses.
|
| BinaryNode |
Binary Node of the tree representing linear constraint.
|
| BinItem |
BinItem is used in bin-packing constraint to keep bin variable for an item
and its weight.
|
| Binpacking |
Binpacking constraint implements bin packing problem.
|
| BipartiteGraphMatching |
|
| BlueberryMuffins |
It solves a simple logic puzzle about blueberry muffins.
|
| BNode |
|
| BoolClause |
I defines a boolean clause for 0/1 variables x_i and y_i.
|
| BoolConstraints |
Generation of boolean constraints in flatzinc
|
| BooleanVar |
Defines a variable and related operations on it.
|
| BoundDomain |
Defines interval of numbers which is part of FDV definition which consist of
one or several intervals.
|
| BoundDomainIntervalEnumeration |
Defines a methods for enumerating intervals contained in the BoundDomain.
|
| BoundDomainValueEnumeration |
Defines a methods for enumerating values contained in the BoundDomain.
|
| BoundSetDomain |
Defines a set interval determined by a least upper bound(lub) and a
greatest lower bound(glb).
|
| BoundsVar |
Defines a variable for Linear constraints to keep intermediate bounds
values
|
| BoundsVarValue |
Defines a current bounds for the Linear constraint.
|
| BoxDisplay |
|
| BreakingNews |
It solves a simple logic puzzle about reporters breaking news stories.
|
| BTree |
Binary Node of the tree representing linear constraint.
|
| BuildingBlocks |
It solves a simple logic puzzle about blocks.
|
| Calculator<T extends Var> |
Defines interface for a calculator for restart search
|
| CalendarMen |
It solves a simple logic puzzle about sport calendar.
|
| CardA |
The set cardinality constraint.
|
| CardAeqX |
The set cardinality constraint.
|
| CarSequencing |
It is program to model and solve simple problems of car sequencing problem (CSPLIB-p1).
|
| CircleIntersection |
|
| Circuit |
Circuit constraint assures that all variables build a Hamiltonian
circuit.
|
| CircuitVar |
Defines a Variable for Circuit constraints and related operations on it.
|
| CircuitVarValue |
Defines a current value of the CircuitVar and related operations on it.
|
| ClauseDatabaseInterface |
Interface for clause databases or database stores.
|
| ClauseListener |
module that listens to add/removal of clauses
|
| ClauseState |
constants that represent the state of a clause at some point in the search
|
| CnfParser |
CNF file format (low-level) parser.
|
| CnfParser.ParseException |
exception occurring during parse
|
| ComparatorVariable<T extends Var> |
Defines an interface for comparing variables.
|
| ComparisonConstraints |
Generation of comparison constraints in flatzinc
|
| Conditional |
Conditional constraint implements conditional constraint
satisfiability.
|
| Conference |
It solves a simple conference session placement problem.
|
| ConferenceTalkPlacement |
It solves a simple conference talk placement problem.
|
| Config |
The configuration for a solver.
|
| ConflictLearning |
A solver component for conflict learning.
|
| ConflictListener |
module that listens to conflicts that are discovered.
|
| ConsistencyListener |
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).
|
| ConstantCalculator<T extends Var> |
Defines functionality for constant calculator for restart search
|
| Constraint |
Standard unified interface/abstract class for all constraints.
|
| ConstraintFncs |
|
| Constraints |
The part of the parser responsible for parsing constraints.
|
| Core |
The main solver structure, to be used either by a search component or by
another program that uses it for conflict learning and detection.
|
| CosPeqR |
Constraints cos(P) = R
|
| CosPeqR_decomposed |
Constraints cos(P) = R
|
| Count |
Count constraint implements the counting over number of occurrences of
a given value in a list of variables.
|
| CountBounds |
CountBounds constraint implements the counting over number of occurrences of
a given value in a list of variables.
|
| CPvizGardner |
It shows how to visualize solving process for Gardner problem.
|
| CPvizNetworkFlow |
The class Run is used to run test programs for JaCoP package.
|
| CPvizNewspaper |
It is a simple newspaper reading job-shop like scheduling problem.
|
| CPvizSendMoreMoney |
It shows how to visualize solving process for SendMoreMoney problem.
|
| CPvizSudoku |
It shows how to visualize the solving process for Sudoku problem.
|
| CreditCalculator<T extends Var> |
Defines functionality of credit search.
|
| CrossWord |
It is an example of the power of ExtensionalSupportMDD constraint which can be used
to efficiently model and solve CrossWord puzzles.
|
| Cryptogram |
Cryptogram.
|
| Cumulative |
Cumulative implements the cumulative/4 constraint using edge-finding
algorithm and profile information on the resource use.
|
| Cumulative |
Cumulative implements the scheduling constraint using
|
| CumulativeBasic |
CumulativeBasic implements the cumulative constraint using time tabling
algorithm.
|
| CumulativeBasic.Event |
|
| CumulativePrimary |
CumulativePrimary implements the cumulative constraint using time tabling
algorithm.
|
| CumulativePrimary.Event |
|
| CumulativeProfiles |
Defines a basic data structure to keep two profiles for the cumulative
constraints.
|
| CumulativeUnary |
CumulativeUnary implements the scheduling constraint for unary resources using
|
| CurveFitting |
|
| CustomReport |
Print-outs all variables defined in the constructor when restart
search finds a solution.
|
| Cyclohexane |
|
| Danzig |
A simple rule that always chooses the arc with maximum violation.
|
| DatabasesStore |
This provides a unique interface to several databases.
|
| DBox |
|
| DCT |
It specifies DCT benchmark.
|
| DeBruijn |
A program solving problem of finding de Bruijn sequences.
|
| DebugModule |
module used for debug : it logs every event it is informed of
|
| DecomposedConstraint<T extends Constraint> |
Standard unified interface/abstract class for constraints, which can only be decomposed.
|
| DefaultClausesDatabase |
A standard database of clauses, implemented in an efficient way such that insertion
or removal of clauses works fast.
|
| DefaultSearchVars |
The class gathers variables and array variables for default or
complementary search.
|
| DepthFirstSearch<T extends Var> |
Implements Depth First Search with number of possible plugins (listeners) to
be attached to modify the search.
|
| Derivative |
Derivative for float constraints
|
| DFQ |
It specifies DFQ filter benchmark.
|
| Diet |
It specifies a simple diet problem.
|
| Diff |
Diff constraint assures that any two rectangles from a vector of rectangles
does not overlap in at least one direction.
|
| Diff.Pair |
|
| Diff2 |
Diff2 constraint assures that any two rectangles from a vector of
rectangles does not overlap in at least one direction.
|
| Diff2Var |
Defines a Variable for Diff2 constraints and related operations on it.
|
| Diff2VarValue |
Defines a current value of the Diff2Var and related operations on it.
|
| Diffn |
Diffn constraint assures that any two rectangles from a vector of rectangles
does not overlap in at least one direction.
|
| Diffn.Event |
|
| DiffnDecomposed |
Diffn constraint assures that any two rectangles from a vector of rectangles
does not overlap in at least one direction.
|
| DiffnProfile |
Defines a basic data structure to keep the profile for the diff2/1
constraints.
|
| Disjoint |
Disjoint constraint assures that any two rectangles from a vector of
rectangles does not overlap in at least one direction.
|
| DisjointConditional |
DisjointConditional constraint assures that any two rectangles from a vector
of rectangles does not overlap in at least one direction.
|
| DisjointConditionalProfile |
Defines a basic data structure to keep the profile for the diffn/1
constraints.
|
| DisjointCondVar |
Defines a Variable for Diff2 constraints and related operations on it.
|
| DisjointCondVarValue |
Defines a current value of the Diff2Var and related operations on it.
|
| Distance |
Constraint |X - Y| #= Z
|
| DollarAndTicket |
It solves a simple logic puzzle - Dollar and Ticket problem.
|
| Domain |
Defines a Domain and related operations on it.
|
| DomainClausesDatabase |
clause database designed to handle efficiently CP domain constraints, with
the interface of boolean clauses databases.
|
| DomainHoles |
|
| DomainStructure |
A domain based structure variable.
|
| DomainStructure.Behavior |
|
| DomainTranslator |
A component that translates CP variables ranges to boolean clauses to
be added to the SAT solver
|
| DonaldGeraldRobert |
It specifies the logic puzzle (cryptogram) which need to satisfy the following
equation that DONALD+GERALD=ROBERT.
|
| DOT |
It specifies DOT benchmark.
|
| EinA |
It constructs a constraint which makes sure that a given element is
in the domain of the set variable.
|
| Element |
Element constraint implements the element/4 constraint (both with integer
list and variables list).
|
| ElementConstraints |
Generation of boolean constraints in flatzinc
|
| ElementFloat |
ElementFloat constraint defines a relation
list[index - indexOffset] = value.
|
| ElementFloatVariable |
ElementFloatVariable constraint defines a relation
list[index - indexOffset] = value.
|
| ElementInteger |
ElementInteger constraint defines a relation
list[index - indexOffset] = value.
|
| ElementIntegerFast |
ElementIntegerFast constraint defines a relation
list[index - indexOffset] = value.
|
| ElementSet |
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 |
ElementSetVariable constraint defines a relation
list[index - indexOffset] = value.
|
| ElementVariable |
ElementVariable constraint defines a relation
list[index - indexOffset] = value.
|
| ElementVariableFast |
ElementVariableFast constraint defines a relation
list[index - indexOffset] = value.
|
| Eq |
Constraint "constraint1"#<=> "constraint2"
|
| EqBool |
If all x's are equal to each other then result variable is equal 1.
|
| EquationSystem |
EquationSystem constraint implements the multivariate interval
Newton method for pruning domains of variables in a system of
non-linear equations.
|
| EWF |
It specifies EWF benchmark.
|
| ExampleFD |
It is an abstract class to describe all necessary functions of any store.
|
| ExampleSet |
It is an abstract class to describe all necessary functions of any store.
|
| ExclusiveItem |
Defines a basic structure for exsclusive rectangles used in
DisjointConditional
|
| ExclusiveList |
Defines a list of exclusive items.
|
| ExitChildListener<T extends Var> |
Defines a listener which is called by the search if a child node is exited.
|
| ExitListener |
This listener is executed when search has finished executing is about to exit
the labeling procedure.
|
| Exodus |
It is a simple logic puzzle about children reading stories.
|
| ExplanationListener |
module used when an explanation is found
|
| ExpPeqR |
Constraints exp(P) #= Q for P and Q floats
|
| ExtensionalConflictVA |
Extensional constraint assures that none of the tuples explicitly given is enforced in the
relation.
|
| ExtensionalSupportMDD |
Extensional constraint assures that one of the tuples is enforced in the
relation.
|
| ExtensionalSupportSTR |
Extensional constraint assures that one of the tuples is enforced in the
relation.
|
| ExtensionalSupportVA |
Extensional constraint assures that one of the tuples is enforced in the
relation.
|
| ExternalConstraint |
|
| Factory<E> |
a factory for type E
|
| FailConstraintsStatistics<T extends Var> |
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.
|
| FailException |
It is thrown when search has encountered a dead end and backtracking must occurr.
|
| FFT |
It specifies FFT benchmark.
|
| Filter |
It provides the basic functionality which must be implemented by any
filter problem.
|
| FilterBenchmark |
This is a set of filter scheduling examples, commonly used in High-Level Synthesis.
|
| FIR |
FIR benchmark (16-point FIR filter).
|
| FIR16 |
FIR benchmark (16-point FIR filter)
|
| FittingNumbers |
It is program to solve problem of fitting numbers to made them equal to zero.
|
| FlatzincLoader |
An executable to parse the flatzinc file and create the JaCoP model.
|
| FlatzincSGMPCS |
The class Run is used to run test programs for JaCoP package.
|
| FlatzincSolver |
The class Run is used to run test programs for JaCoP package.
|
| FloatComparisonConstraints |
Generation of set constraints in flatzinc
|
| FloatDomain |
Defines an integer domain and related operations on it.
|
| FloatInterval |
Defines interval of numbers which is part of FDV definition which consist of
one or several intervals.
|
| FloatIntervalDomain |
Defines interval of numbers which is part of FDV definition which consist of
one or several intervals.
|
| FloatIntervalDomainIntervalEnumeration |
Defines a methods for enumerating values contain in the intersal domain.
|
| FloatIntervalEnumeration |
Defines a methods for enumerating values contain in the intersal domain.
|
| FloatLinearConstraints |
Generation of set constraints in flatzinc
|
| FloatMinimize |
The class Run is used to run test programs for JaCoP package.
|
| FloatOperationConstraints |
Generation of set constraints in flatzinc
|
| FloatVar |
Defines a Float Domain Variable and related operations on it.
|
| Flowers |
It is quite complex logic puzzle about flowers.
|
| ForbiddenArea |
|
| ForgetListener |
called when the solver forget() method is called.
|
| FourIslands |
It is a very simple puzzle about islands and bridges.
|
| FSM |
Deterministic Finite Acyclic graph.
|
| FSMState |
|
| FSMTransition |
|
| FurnitureMoving |
It is a simple logic puzzle about furniture moving.
|
| Fz2jacop |
An executable to parse and execute the flatzinc file.
|
| Gardner |
It specifies a simple Gardner problem which use set functionality from JaCoP.
|
| Gates |
It specifies an adder using gates specified by extensional constraints.
|
| GCC |
GCC constraint counts the number of occurences of given
values in x variables.
|
| GCC.Component |
|
| GCC.XDomain |
|
| GenericMemoryPool<E> |
Deprecated. |
| GeometricCalculator<T extends Var> |
Defines functionality for constant calculator for restart search
|
| Geost |
|
| Geost.SweepDirection |
|
| GeostExample |
It specifies an example where squares of the given size must be placed within
a square of a given size.
|
| GeostObject |
|
| GlobalConstraints |
Generation of global constraints in flatzinc
|
| GlobalConstraints.Pair |
|
| Golf |
A simple logic puzzle about golf players.
|
| Golomb |
It models a Golomb ruler problem.
|
| HeuristicAssertionModule |
module used to guide research by selecting the next literal to assert
|
| HeuristicForgetModule |
A component that selects clauses to forget when solver.forget() is called.
|
| HeuristicRestartModule |
A module that indicates if a restart would be useful now.
|
| HistoricHomes |
It is a simple logic puzzle about houses.
|
| IfThen |
Constraint if constraint1 then constraint2
|
| IfThenBool |
Constraint ( X => Y ) <=> Z.
|
| IfThenElse |
Constraint if constraint1 then constraint2 else constraint3
*
|
| Implies |
Constraint b => c (implication or half-reification)
|
| ImproveSolution<T extends Var> |
Defines an interface for defining different methods for selecting next search
decision to be taken.
|
| In |
Constraints X to belong to a specified domain.
|
| InArea |
|
| IndexDomainView |
Defines index domain view for a variable and related operations on it.
|
| Indomain<T extends Var> |
Defines a interface for different indomain enumeration methods.
|
| IndomainDefaultValue<T extends Var> |
IndomainDefaultValue - implements enumeration method based on the
selection of the default value for each variable first.
|
| IndomainHierarchical<T extends Var> |
IndomainHierarchical - implements enumeration method based on the selection
of the preferred indomain for each variable.
|
| IndomainList<T extends IntVar> |
IndomainList - implements enumeration method based on the selection
of the preferred values for each variable.
|
| IndomainMax<T extends IntVar> |
IndomainMax - implements enumeration method based on the selection of the
maximal value in the domain of the variable.
|
| IndomainMedian<T extends IntVar> |
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<T extends IntVar> |
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<T extends IntVar> |
IndomainMin - implements enumeration method based on the selection of the
minimal value in the domain of variable
|
| IndomainRandom<T extends IntVar> |
IndomainRandom - implements enumeration method based on the selection of the
random value in the domain of FD variable.
|
| IndomainSetMax<T extends SetVar> |
IndomainMin - implements enumeration method based on the selection of the
maximal value in the domain of variable
|
| IndomainSetMin<T extends SetVar> |
IndomainMin - implements enumeration method based on the selection of the
minimal value in the domain of variable
|
| IndomainSetRandom<T extends SetVar> |
IndomainMin - implements enumeration method based on the selection of the
maximal value in the domain of variable
|
| IndomainSimpleRandom<T extends IntVar> |
IndomainRandom - implements enumeration method based on the selection of the
random value in the domain of FD variable.
|
| InitializeListener |
This listener is executed when search has began executing and it is about to enter
the labeling procedure.
|
| InputOrderSelect<T extends Var> |
It is simple input order selector of variables.
|
| IntDomain |
Defines an integer domain and related operations on it.
|
| InternalConstraint |
|
| InternalConstraint.Applicability |
In order to avoid the cost of repeated calls to isInternalConstraintApplicable,
we need 3 different states.
|
| InternalException |
It is thrown when search has encountered a dead end and backtracking must occurr.
|
| Interval |
Defines interval of numbers which is part of FDV definition which consist of
one or several intervals.
|
| IntervalBasedBacktrackableManager |
|
| IntervalDomain |
Defines interval of numbers which is part of FDV definition which consist of
one or several intervals.
|
| IntervalDomainIntervalEnumeration |
Defines a methods for enumerating values contain in the intersal domain.
|
| IntervalDomainValueEnumeration |
Defines a methods for enumerating values contain in the domain.
|
| IntervalEnumeration |
Defines a methods for enumerating values contain in the intersal domain.
|
| IntervalGaussSeidel |
IntervalGaussSeidel implements Gauss-Seidel method for solving a
system of linear equations Ax = b with interval matrix A of
coefficients.
|
| IntHashMap<E> |
an efficient map with ints as keys.
|
| IntMap<E> |
|
| IntPriorityQueue |
A mix of a priority queue and a hashmap, specialized for ints
|
| IntPriorityQueue.Node |
a node containing the data associated with each int
|
| IntQueue |
Special class for unboxed int FIFO
|
| IntRectangle |
Defines a rectangle with integer origine and length used in the diffn
constraint.
|
| IntSet |
an efficient Set for unboxed int.
|
| IntStack |
Special class for unboxed int stack
|
| IntTask |
Represents tasks with integer start, duration and resource valurs for
cumulative constraint
|
| IntTrie<N extends IntTrie.Node<N>> |
A class that implements, (hopefully) efficiently, a Trie on integers.
|
| IntTrie.Node<E> |
class of nodes of the Trie.
|
| IntTrie.SimpleNode |
The most simple node possible
|
| IntVar |
Defines a Finite Domain Variable (FDV) and related operations on it.
|
| IntVec |
low level, efficient int vector
|
| JJTParserState |
|
| Kakro |
It is program to solve Kakro puzzles.
|
| Knapsack |
It specifies a knapsack constraint.
|
| KnapsackExample |
It shows the capabilities and usage of Knapsack constraint.
|
| KnapsackItem |
This class stores information about items being considered by a Knapsack constraint.
|
| Langford |
It solves Langford problem.
|
| Laplace |
|
| LargestDomain<T extends Var> |
Defines LargestDomain comparator for Variables.
|
| LargestDomainFloat<T extends Var> |
Defines LargestDomainFloat comparator for Variables.
|
| LargestMax<T extends IntVar> |
Defines a LargestMax comparator for Variables.
|
| LargestMaxFloat<T extends FloatVar> |
Defines a LargestMaxFloat comparator for Variables.
|
| LargestMin<T extends IntVar> |
Defines a LargestMin comparator for Variables.
|
| LargestMinFloat<T extends FloatVar> |
Defines a LargestMinFloat comparator for Variables.
|
| LatinSquare |
It solves a Latin Square problem.
|
| LazyCpVarDomain<E extends IntVar> |
Deprecated. |
| LazyCpVarDomain.ListNode |
a node of the double linked list
|
| LDS<T extends Var> |
Defines functionality of limited discrepancy search.
|
| LeastDiff |
Simple least Diff problem.
|
| LectureSeries |
It is a simple logic puzzle about lectures.
|
| LengauerTarjan |
|
| Lex |
It constructs a Lex (lexicographical order) constraint.
|
| Lex |
Deprecated.
|
| LexicalAnalyzer |
|
| LexicographicalOrder |
|
| LexOrder |
It constructs a LexOrder (lexicographical order) constraint.
|
| Linear |
Deprecated.
|
| Linear |
Linear constraint implements the weighted summation over several
Variable's .
|
| Linear.VarWeightComparator<T extends VariableNode> |
|
| LinearCalculator<T extends Var> |
Defines functionality for constant calculator for restart search
|
| LinearConstraints |
Generation of linear constraints in flatzinc
|
| LinearFloat |
LinearFloat constraint implements the weighted summation over several
Variable's .
|
| LinearInt |
LinearInt constraint implements the weighted summation over several
variables .
|
| LinearIntDom |
LinearIntDom constraint implements the weighted summation over several
variables.
|
| LnPeqR |
Constraints Ln(P) #= Q for P and Q floats
|
| Loan |
|
| LongClausesDatabase |
A pool of long clauses, implemented with two watched an blocking literals
to minimize cache misses.
|
| LubyCalculator<T extends Var> |
Defines functionality for constant calculator for restart search
|
| MagicSquares |
It solves a Magic squares problem.
|
| MapClause |
A clause used for resolution, easily modifiable several times, and that
can then be converted to an int[].
|
| Markov |
|
| MasterClass |
It solves a logic puzzle about singing women.
|
| Match |
This constraint matches the elements of the given set variable
onto a list of integer variables.
|
| Matrix |
Matrix and operations on matrices.
|
| Max |
Max constraint implements the Maximum/2 constraint.
|
| Max |
Max constraint implements the Maximum/2 constraint.
|
| MaxCardDiff<T extends SetVar> |
Defines a maximum cardinality difference variable comparator.
|
| MaxGlbCard<T extends SetVar> |
Defines a maximum cardinality, of the greatest lowest bound, variable comparator.
|
| MaxLubCard<T extends SetVar> |
Defines a maximum cardinality, of the least upper bound, variable comparator.
|
| MaxRegret<T extends IntVar> |
Defines a MaxRegret comparator for Variables.
|
| MaxRegretFloat<T extends FloatVar> |
Defines a MaxRegretFloat comparator for Variables.
|
| MaxSimple |
MaxSimple constraint implements the Maximum/2 constraint.
|
| MDD |
Defines an MDD as used in the following paper.
|
| Member |
Member constraint implements the membership of element e on list x.
|
| MemoryPool |
Class containing int[] of different lengths, to avoid allocating/deallocating too much.
|
| Min |
Min constraint implements the minimum/2 constraint.
|
| Min |
Min constraint implements the minimum/2 constraint.
|
| MinCardDiff<T extends SetVar> |
Defines a minimum cardinality difference variable comparator.
|
| MinCostFlow |
|
| MinDomainOverDegree<T extends Var> |
Defines a MinDomainOverDegree comparator for Variables.
|
| MineSweeper |
It models and solves Minesweeper problem.
|
| MinGlbCard<T extends SetVar> |
Defines a minimum cardinality, of the greatest lowest bound, variable comparator.
|
| MinLubCard<T extends SetVar> |
Defines a minimum cardinality, of the least upper bound, variable comparator.
|
| MinSimple |
MinSimple constraint implements the minimum/2 constraint.
|
| MostConstrainedDynamic<T extends Var> |
Defines a MostConstrainedDynamic comparator for Variables.
|
| MostConstrainedStatic<T extends Var> |
Defines a MostConstraintStatic comparator for Variables.
|
| MUCA |
It solves the Mixed Multi-Unit Combinatorial Auctions.
|
| MUCA.Delta |
|
| MUCA.Transformation |
|
| MultiVarHandler |
|
| MultivariateIntervalNewton |
MultivariateIntervalNewton implements multivariate interval Newton
method for solving a system of non linear equations.
|
| MutableDomain |
|
| MutableDomainValue |
|
| MutableNetwork |
Interface to the network used by VarHandlers.
|
| MutableVar |
Standard mutable variable definition
|
| MutableVarValue |
Standard mutable variable's value definition
|
| Network |
This class extends the minimum-cost flow network by providing operations and
data structures for removal and modification of arcs.
|
| NetworkBuilder |
A builder class for the network flow constraints.
|
| NetworkFlow |
The network flow constraint.
|
| NetworkSimplex |
|
| Newspaper |
It is a simple newspaper reading job-shop like scheduling problem.
|
| Node |
A node (vertex) in the network.
|
| Node |
|
| NoGood |
NoGood constraints implements a constraint which disallows given combination
of values for given variables.
|
| NoGoodsCollector<T extends IntVar> |
NoGoodCollector collects no-goods from search when timeout has occurred.
|
| Nonogram |
It solves a nonogram example problem, sometimes also called Paint by Numbers.
|
| NonOverlapping |
|
| NonTransitiveDice |
It models and solves Nontransitive Dice Problem.
|
| Nooverlap |
Nooverlap constraint assures that any two rectangles from a vector of rectangles
does not overlap in at least one direction.
|
| Not |
Constraint "not costraint"
|
| ObstacleObject |
|
| ObstacleObjectFrame |
|
| OneSolution<T extends Var> |
Defines functionality for OneSolution plug-in, that is the search
with this plug-in will stop after funding first solution.
|
| OperationConstraints |
Generation of linear constraints in flatzinc
|
| Optimize<T extends Var> |
Implements optimization for floating point varibales
|
| Options |
It parses the options provided to flatzinc parser/executable.
|
| OptParse<E> |
util to parse command-line arguments
|
| OptParse.OptHandler<E> |
a class to handle one option
|
| Or |
Constraint c1 \/ c2 \/ ...
|
| OrBool |
OrBool constraint implements logic and operation on its arguments
and returns result.
|
| OrBoolSimple |
If at least one variable is equal 1 then result variable is equal 1 too.
|
| OrBoolVector |
If at least one variable from the list is equal 1 then result variable is equal 1 too.
|
| OutputArrayAnnotation |
It stores information about the annotation for an output array.
|
| Parcel |
It solves a simple parcel shipment problem.
|
| ParseException |
This exception is thrown when parse errors are encountered.
|
| Parser |
|
| Parser.JJCalls |
|
| Parser.LookaheadSuccess |
|
| ParserConstants |
Token literal values and constants.
|
| ParserTokenManager |
Token Manager.
|
| ParserTreeConstants |
|
| PdivCeqR |
Constraint P / C = R for floats
|
| PdivQeqR |
Constraint P / Q = R for floats
|
| PeqC |
Constraints P #= C
|
| PeqQ |
Constraints P #= Q for P and Q floats
|
| PerfectSquare |
It specifies an example where squares of the given size must be placed within
a square of a given size.
|
| PgtC |
Constraint P > C
|
| PgteqC |
Constraints P >= C for floats
|
| PgteqQ |
Constraints P >= Q for floats
|
| PgtQ |
Constraint P > Q for floats
|
| PigeonHole |
It solves the PigeonHole problem.
|
| PivotRule |
A pivot selection rule for the primal network simplex algorithm.
|
| PltC |
Constraint P < C for floats
|
| PlteqC |
Constraint X <= C for floats
|
| PlteqQ |
Constraint P <= Q for floats
|
| PltQ |
Constraint P < Q for floats
|
| PminusCeqR |
Constraint P - C = R
|
| PminusQeqR |
Constraint P - Q = R
|
| PmulCeqR |
Constraint P * C = R for floats
|
| PmulQeqR |
Constraint P * Q = R for floats
|
| PneqC |
Constraints P != C
|
| PneqQ |
Constraints P #= Q for P and Q floats
|
| PplusCeqR |
Constraint P + C #= R
|
| PplusQeqR |
Constraint P + Q = R
|
| PredefinedOrder |
|
| PrimitiveConstraint |
Standard unified interface for all primitive constraints.
|
| PrintOutListener<T extends Var> |
It is a simple example how it is possible to extend existing listeners to
add your own functionality.
|
| PrintSchedule |
Prints the computed schedule
|
| PrioritySearch<T extends Var> |
PrioritySearch selects first a row in the matrix based on metric of
the variable at the pririty vector.
|
| PrioritySearch.SolutionsLimitReached |
|
| ProAndCon |
It solves a simple logic puzzle about voting city council.
|
| Profile |
Defines a basic data structure to keep the profile for the diffn/1 and
cumulative/4 constraints.
|
| ProfileConditional |
Defines a basic data structure to keep the profile for the
disjointConditonal/2
|
| ProfileItem |
Defines a basic structure used to update profile for cumulative constraint.
|
| ProfileItemCondition |
Defines a basic structure used to update profile DisjointConditional when
some rectangles can share the same place.
|
| PropagateListener |
module called when a propagate event is called
|
| Pruning |
|
| Pruning.PruningStrategy |
|
| QCP |
It solves QuasiGroup Completion Problem (QCP).
|
| Queens |
It models the queens problem in different ways as well as applies
different search methods.
|
| QueueForward<T extends Constraint> |
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.
|
| RandomSelect<T extends Var> |
It is simple and customizable selector of decisions (constraints) which will
be enforced by search.
|
| RandomVar<T extends Var> |
Defines a RandomVar comparator for variables.
|
| Rectangle |
Defines a rectangle used in the diffn constraint.
|
| Rectangle |
Defines a rectangle used in the diffn constraint.
|
| RectangleWithCondition |
Defines a rectangle used in the diffn constraint.
|
| RegEdge |
The class responsible for connecting two states in regular automaton
of Regular constraint.
|
| RegState |
The state class representing a state in the regular automaton
within Regular constraint.
|
| RegStateDom |
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.
|
| RegStateInt |
It is an implementation of the Regular state which uses a separate successor for each
value.
|
| Regular |
Regular constraint accepts only the assignment to variables which is accepted by
an automaton.
|
| RegularExpressionParser |
Instances of this class parse the word combination little language.
|
| RegularExpressionParser.SyntaxException |
SyntaxException raised if not regular expression is being parsed.
|
| Reified |
Reified constraints "constraint" <=> B
|
| ReifiedIfThen |
Replacement of Reified with IfThen.
|
| RemoveLevelLate |
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.
|
| Replaceable<T extends Constraint> |
Interface that provides ability to configure constraint store to
replace a particular type of constraints into another one.
|
| RestartSearch<T extends Var> |
Implements restart search.
|
| ReversibleSparseBitSet |
ReversibleSparseBitSet implements the main data structure for table constraint.
|
| RootBNode |
|
| Rosenbrock |
|
| RunExample |
This class executes the provided example.
|
| RunSolver |
The main class for the SAT solver when it is used standalone (without being
controlled by a master).
|
| RunWhenShuttingDown |
|
| SatChangesListener |
this class listens to changes in literals in SAT solver, and reminds
what changes this implies for CP variables
|
| SatCPBridge |
interface representing the domain of a CP variable as a range.
|
| SatisfiedPresent |
Interface to mark the need (PrimitiveConstraint) or extra functionality
(Constraint) to compute if the constraint is satisfied.
|
| SatTranslation |
SatTranslation defines SAT clauses for typical logical constraints
|
| SatWrapper |
wrapper to communicate between SAT solver and CP solver.
|
| Search<T extends Var> |
All searches needs to implement this interface in order to be manipulable by
a large variety of search listeners.
|
| SearchItem |
The part of the parser responsible for parsing search part of the flatzinc specification.
|
| SearchModule |
A basic searching component, which controls the solver to solve the problem
|
| SelectChoicePoint<T extends Var> |
Defines an interface for defining different methods for selecting next search
decision to be taken.
|
| SendMoreMoney |
It is a simple arithmetic logic puzzle, where SEND+MORE=MONEY.
|
| Sequence |
It constructs a Sequence constraint.
|
| SetConstraints |
Generation of set constraints in flatzinc
|
| SetDomain |
Defines a set interval determined by a least upper bound(lub) and a
greatest lower bound(glb).
|
| SetDomainValueEnumeration |
Defines a methods for enumerating values contained in the SetDomain.
|
| SetVar |
Defines a Finite Domain Variable (FDV) and related operations on it.
|
| SGMPCSCalculator<T extends Var> |
Defines functionality for SGMPCS search
|
| SGMPCSearch |
SGMPCSearch - implements Solution-Guided Multi-Point Constructive
Search.
|
| Shape |
|
| Shaving<T extends IntVar> |
Defines functionality of shaving.
|
| ShiftOrder |
|
| SiblingUproar |
It is quite complex logic puzzle about siblings.
|
| SimpleArrayList<V> |
Different implementation of an ArrayList data structures.
|
| SimpleBacktrackableManager |
It is responsible of remembering what variables have changed at given
store level.
|
| SimpleCharStream |
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
|
| SimpleCpVarDomain |
A simple representation for small domains, not lazy.
|
| SimpleHashSet<E> |
This class provides very simple HashSet functionality.
|
| SimpleImprovementSearch<T extends IntVar> |
Defines an interface for defining different methods for selecting next search
decision to be taken.
|
| SimpleMatrixSelect<T extends Var> |
SimpleMatrixSelect selects first a row in the matrix based on metric of the
variable at pivotPosition.
|
| SimpleNode |
|
| SimpleSelect<T extends Var> |
It is simple and customizable selector of decisions (constraints) which will
be enforced by search.
|
| SimpleSolutionListener<T extends Var> |
It defines a simple solution listener which should be used if some basic
functionality of search when a solution is encountered are required.
|
| SimpleTable |
SimpleTable implements the table constraint using a method presented in
|
| SimpleTimeOut |
It defines a simple time out listener.
|
| SinA |
It creates an inclusion set constraint to make sure that provided set is
included in a set variable a.
|
| SinCosExample |
|
| SinPeqR |
Constraints sin(P) = R
|
| SixHumpCamelFunction |
|
| SleepingArrangements |
It is a simple logic puzzle about sleeping arrangements.
|
| SmallDenseDomain |
Defines small dense domain based on bits within a long number.
|
| SmallDenseDomainIntervalEnumeration |
Defines interval enumeration of small dense domain.
|
| SmallDenseDomainValueEnumeration |
Defines a methods for enumerating values contain in the domain.
|
| SmallestDomain<T extends Var> |
Defines a Smallest Domain comparator for Variables.
|
| SmallestDomainFloat<T extends Var> |
Defines a Smallest Domain comparator for Variables.
|
| SmallestMax<T extends IntVar> |
Defines a SmallestMax comparator for Variables.
|
| SmallestMaxFloat<T extends FloatVar> |
Defines a SmallestMaxFloat comparator for Variables.
|
| SmallestMin<T extends IntVar> |
Defines a SmallestMin comparator for variables.
|
| SmallestMinFloat<T extends FloatVar> |
Defines a SmallestMinFloat comparator for variables.
|
| SocialGolfer |
It is a Social Golfer example based on set variables.
|
| SoftAlldifferent |
This class provides soft-alldifferent constraint by decomposing it
either into a network flow constraint or a set of primitive constraints.
|
| SoftGCC |
This class provides soft-gcc constraint by decomposing it
either into a network flow constraint or a set of primitive constraints.
|
| SolutionListener |
module called when solution is found.
|
| SolutionListener<T extends Var> |
Defines an interface which needs to be implemented by all classes which wants
to be informed about the solution.
|
| Solve |
The parser part responsible for parsing the solve part of the flatzinc file,
building a related search and executing it.
|
| Solve.PrecisionSetting |
|
| SolverComponent |
An interface for solver components, that are connected together via the Core.
|
| SolverState |
|
| SophisticatedLengauerTarjan |
|
| SparseSet |
Sparse set representation of the set.
|
| SplitRandomSelect<T extends IntVar> |
It is simple and customizable selector of decisions (constraints) which will
be enforced by search.
|
| SplitRandomSelectFloat<T extends Var> |
It is simple and customizable selector of decisions (constraints) which will
be enforced by search.
|
| SplitSelect<T extends IntVar> |
It is simple and customizable selector of decisions (constraints) which will
be enforced by search.
|
| SplitSelectFloat<T extends Var> |
It is simple and customizable selector of decisions (constraints) which will
be enforced by search.
|
| SqrtPeqR |
Constraint sqrt(P) = R for floats
|
| StartStopListener |
called when the solver starts or stops.
|
| Stateful |
Interface to mark the need of an entity to receive information about level being removed.
|
| Statistics |
This class stores all the statistics gather during the execution of the network flow constraint.
|
| StatisticsBase |
|
| StatModule |
collects statistics about the solver
|
| Steiner |
It models and solves Steiner problem.
|
| StonesOfHeaven |
It solves a simple logic puzzle about artifacts.
|
| Store |
It is an abstract class to describe all necessary functions of any store.
|
| StoreAware |
Interface to mark the need of an entity to receive information about Constraint Store within which this
entity operates.
|
| Stretch |
It constructs a Stretch constraint based on Regular constraint.
|
| Subcircuit |
Subcircuit constraint assures that all variables build a
subcircuit.
|
| Sudoku |
A simple model to solve Sudoku problem.
|
| Sum |
Deprecated.
|
| SumBool |
SumBool constraint implements the summation over several
0/1 variables.
|
| SumFloat |
SumFloat constraint implements the weighted summation over several
Variable's .
|
| SumInt |
SumInt constraint implements the summation over several variables.
|
| SumWeight |
SumWeight constraint implements the weighted summation over several
variables .
|
| SumWeightDom |
Deprecated.
|
| SumWeightedSet |
It computes a weighted sum of the elements in the domain of the given set variable.
|
| Support |
Basic support for generation of constraints in flatzinc
|
| SurvoPuzzle |
It solves Survo puzzle.
|
| SwitchesPruningLogging |
It is a container class which specifies all different switches to turn
on debugging information.
|
| SystemTimer |
|
| Table |
Table implements the table constraint using a method presented in
|
| TableMill |
TableMill generates tables for different constraint to be used in Table constraint
|
| Tables |
This class contains information about all variables, including
the variables which are used by search.
|
| TanExample |
|
| TanPeqR |
Constraints sin(P) = R
|
| Task |
Represents tasks for cumulative constraint
|
| Task |
Represents tasks for cumulative constraint
|
| TaskNormalView |
Represents tasks for cumulative constraint
|
| TaskReversedView |
Represents tasks for cumulative constraint
|
| TaskView |
Represents tasks for cumulative constraint
|
| TernaryClausesDatabase |
A database for ternary clauses.
|
| ThetaLambdaNode |
Implements ThetaLambdaNode for ThetaLambdaTree.
|
| ThetaLambdaTree |
Implements ThetaLambdaTree and operations on this tree for Cumulative constraint
|
| ThetaLambdaUnaryNode |
Implements ThetaLambdaUnaryNode for ThetaLambdaUnaryTree.
|
| ThetaLambdaUnaryTree |
Implements ThetaLambdaUnaryTree and operations on this tree for Cumulative constraint
|
| ThetaNode |
Implements ThetaNode for ThetaTree.
|
| ThetaTree |
Implements ThetaTree and operations on this tree for Cumulative constraint
|
| ThreadTimer |
|
| TimeOutListener |
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.
|
| Timer |
|
| TimeStamp<T> |
This class provides mutable variable functionality.
|
| TinyTSP |
|
| Token |
Describes the input token stream.
|
| TokenMgrError |
Token Manager Error.
|
| TraceGenerator<T extends Var> |
TODO
TraceGenerator should accept as input to constructor a Search object.
|
| Trail |
It stores the current variables status (affected or not, with which value and explanation).
|
| TransformExtensional |
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.
|
| Tree |
Implements ThetaLambdaTree and operations on this tree for Cumulative constraint
|
| Tree |
This tree is a main data structure used and required by Knapsack constraint.
|
| TreeLeaf |
It contains information required by the leaf node of the item tree.
|
| TreeNode |
Implements TreeNode for Tree.
|
| TreeNode |
It contains information required by an internal node of the item tree.
|
| TrivialSolution |
It is thrown in flazinc when search is not needed since the solution is known.
|
| TSP |
It models Travelling Salesman Problem (TSP).
|
| Tunapalooza |
It solves a simple logic puzzle about music concert.
|
| TupleUtils |
Util functions for arrays of tuples.
|
| UnaryClausesDatabase |
A database for unit clauses (length 1).
|
| UsesQueueVariable |
|
| Utils |
Contains utils for arrays manipulation
|
| ValueEnumeration |
Defines a methods for enumerating values contained in the domain.
|
| ValuePrecede |
It defines Value Precedence constraint for integers.
|
| Values |
Constraint Values counts number of different values on a list of Variables.
|
| Var |
Defines a variable and related operations on it.
|
| VarHandler |
Common interface to all objects that can handle one or more variables of the
network flow constraint.
|
| VariableNode |
|
| VariablesParameters |
TODO, a short description what it does and how it is used.
|
| VariableTrace |
VariableTrace is a daemon that prints information on variables whenever they are changed.
|
| VarNode |
|
| VarWeightNode |
|
| ViolationMeasure |
|
| WeightedDegree<T extends Var> |
Defines a WeightedDegree comparator for variables.
|
| WeightedDegreeFloat<T extends Var> |
Defines a WeightedDegreeFloat comparator for Variables.
|
| WhoKilledAgatha |
Who killed agatha? (The Dreadsbury Mansion Murder Mystery).
|
| Wilkinson |
|
| WolfGoatCabbage |
A simple logic problem of transporting wolf, goat, and cabbage over the river.
|
| WrapperComponent |
a component that is aware of the existence of a SatWrapper
|
| WrapperDebugModule |
a class used to debug, but with additional data
|
| XdivYeqZ |
Constraint X div Y #= Z
|
| XeqA |
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.
|
| XeqC |
Constraints X #= C
|
| XeqP |
Constraints X #= P for X and P floats
|
| XeqY |
Constraints X #= Y
|
| XexpYeqZ |
Constraint X ^ Y #= Z
|
| XgtC |
Constraint X > C
|
| XgteqC |
Constraints X >= C
|
| XgteqY |
Constraints X >= Y
|
| XgtY |
Constraint X > Y
|
| XinA |
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.
|
| XltC |
Constraint X < C
|
| XlteqC |
Constraint X <= C
|
| XlteqY |
Constraint X <= Y
|
| XltY |
Constraint X < Y
|
| XmodYeqZ |
Constraint X mod Y = Z
|
| XmulCeqZ |
Constraint X * C #= Z
|
| XmulYeqC |
Constraint X * Y #= C
|
| XmulYeqZ |
Constraint X * Y #= Z
|
| XneqC |
Constraints X #\= C
|
| XneqY |
Constraints X #\= Y
|
| Xor |
Xor constraint - xor("constraint", B).
|
| XorBool |
Constraint ( x_0 xor x_1 xor ...
|
| XplusCeqZ |
Constraint X + C #= Z.
|
| XplusClteqZ |
Constraints X + C<= Z.
|
| XplusYeqC |
Constraint X + Y #= C
|
| XplusYeqZ |
Constraint X + Y = Z
|
| XplusYgtC |
Constraint X + Y> C
|
| XplusYlteqZ |
Constraint X + Y=< Z
|
| XplusYplusCeqZ |
Constraints X + Y + C #= Z.
|
| XplusYplusQeqZ |
Constraint X + Y + Q = Z
|
| XplusYplusQgtC |
Constraint X + Y + Q > C
|
| Zebra |
It models and solves Zebra logic puzzle.
|