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.
|