KAbs 
This class creates a X = abs(Y) constraint
Example :

KAbs.PropagationLevel 
Propagation level of the constraint

KAbsoluteToleranceOptimalityChecker 
An OptimalityToleranceChecker to use with any type of
KNumVar objective, which use an absolute difference criteria.

KACBinConstraint 
This class implements a generic class for propagation of any binary constraint by local 2consistency (arc consistency) \
Two algorithms (AC3 and AC2001) are available for propagation of the constraint.
Example : X == Y + C

KACBinConstraint.acAlgorithms 
Differents level of propagation for the constraints

KACBinTableConstraint 
This class implements a generic class for propagation of any binary constraint by local 2consistency (arc consistency).
Two algorithms (AC3 and AC2001) are available for propagation of the constraint.

KACBinTableConstraint.acAlgorithms 
Arcconsistency algorithms for binary table constraint

KAllDifferent 
This class creates a X1 <> X2 <> ...

KAllDifferent.PropagationLevel 
Differents level of propagation for the constraints

KAssignAndForbid 
Assign And Forbid branching scheme
Example :

KAssignVar 
AssignVar Branching scheme
Example:

KAuxVar 
This class represents an auxiliary variable to use in relaxations.
KAuxVar objects represent auxiliary variables, consisting of a name, lower
and upper bounds, and a type that is either "global" or "continuous".

KBestBoundValue 
Value selector that selects the value of a variable that implies the best
bound for the objective.
For each possible value in the domain of a given variable, the variable
is instantiated on this value and the propagation is launched.

KBiLevelLinearRelaxationSolverConfigurator 

KBinTerm 
This class represent an expression of the form X (+ , ) Y + cste where X and
Y are variables and cste an integer constant.

KBranchingScheme 
Abstract class defining branching schemes.
Search is made thanks to a tree search algorithm.

KBranchingSchemeArray 
This class implements an array of KBranchingScheme
Example :

KBranchingSchemeGroup 
A branching scheme group represents a list of branching schemes to use nested
branching schemes.

KBranchingSchemeGroupArray 
List of brancing scheme group.

KBranchingSchemeGroupSelector 
Selection object to choose among a list of branching scheme group.

KBranchingSchemeGroupSerializer 
A nested branching scheme.
From a list of branching scheme groups, this brancing scheme apply
iteratively each group.
The default group selector uses input order.

KClpLinearRelaxationSolver 
Linear relaxation solver for Clp

KCoinLinearRelaxationSolver 
This linear relaxation solver relies on CoinMP to solve the LP/MIP problem.
Example:

KConditionNumLinComb 
Conditionnal numeric linear combination constraint.
This constraint can be represented as a linear combination
Sum(a_i * X_i * f(X_i)) { <= , != , == } C where the function f(X_i) is an
indicator (1 or 0) function to specify.

KConditionNumLinComb.LinCombOperator 
Available operators for the combination

KConjunction 
This class creates a Binary conjunction on two constraints `C1 and C2`.
Example :

KConstraint 
This class is an abstract interface for all constraints in Artelys Kalis

KConstraintArray 
This class implements an array of KConstraint
Example :

KCopiableRelaxationSolverConfigurator 

KCumulativeResourceConstraint 
This constraint states that some tasks requiring a resource do not exceed the
resource capacity.

KCumulativeResourceConstraintResourceUsage 
A timedependant resource usage constraint.

KCycle 
The cycle constraint ensures that the graph implicitly represented by a set of variables and their domain contains no subtours (tour visiting a partial number of nodes).

KDiscreteResource 
Discrete resource
A discrete resource can process several tasks at the same time.
The following schema shows an example with three tasks A,B and C executing on
a disjunctive resource and on a cumulative resource with resource usage 3 for
task A, 1 for task B and 1 for task C :
Tasks may require, provide, consume and produce resources :
 A task requires a resource if some amount of the resource capacity must be made available for the execution of the activity.

KDiscreteResource.PropagationHint 
Propagation Hint Attributes

KDisjunction 
This class creates a Binary disjunction on two constraints `C1 or C2`
Example :

KDisjunctionArray 
This class implements an array of KDisjunction
Example :

KDisjunctionInputOrder 
This class implements a disjunction selector that selects the disjunction in the input order.

KDisjunctionPriorityOrder 
This class implements a disjunction selector that selects first the disjunction ith the highest priority
Example :

KDisjunctionSelector 
Abstract interface class for disjunction selection heuristic

KDistanceEqualXyc 
This class creates a abs(XY) == C constraint
Example :

KDistanceGreaterThanXyc 
This class creates a abs(XY) >= C constraint
Example :

KDistanceLowerThanXyc 
This class creates a abs(XY) <= C constraint
Example :

KDistanceNotEqualXyc 
This class creates a abs(XY) != C constraint
Example :

KDoubleAnnotation 

KDoubleArray 
This class implements an array of doubles
Example :

KElement 
This class creates a x == tab[i + cste] constraint
Example :

KElement2D 
This class creates a X == Tab[I + cste1][J + cste2] constraint
Example :

KEltTerm 
This class represent an expression of type Tab[I] where Tab is an array of integer value and I is the indexing variable
Example :

KEltTerm2D 
This class represent an expression of type Tab[I+a][J+b] where Tab is an array of integer value; I,J are the indexing variable and a and b indexing offsets
Example :

KEqualXc 
This class creates a X == C constraint.
Example :

KEqualXyc 
This class creates a X == Y + C constraint.
Example :

KEquiv 
This class creates an Equivalence on two constraints `C1 <==> C2`.
Example :

KFinishedMessage 

KFloatVar 
This class implements a variable with continuous real valued domain.
Conceptually the continuous variables can be represented the following way :
Example:

KFloatVar.PrecisionRelativity 

KFloatVarBranchingScheme 
This branching scheme is suited for branching on KFloatVar objects.

KFloatVarSelector 
Float variable selector

KGeneralizedArcConsistencyConstraint 
This class implements a generic class for propagation of any nary constraint by forward checking/arc consistency or generalized arc consistency

KGeneralizedArcConsistencyConstraint.acAlgorithms 
Possible propagation algorithms

KGeneralizedArcConsistencyTableConstraint 
This class implements a generic class for propagation of any nary constraint by generalized arc consistency \

KGlobalCardinalityConstraint 
This class implements a Global Cardinality Constraint.
A GCC (Global Cardinality Constraint) over a set of variables is defined by three arrays called
values,
lowerBound, and upperBound.

KGreaterOrEqualXc 
This class creates a X >= C constraint.
Example :

KGreaterOrEqualXyc 
This class creates a X >= Y + C constraint
Example :

KGuard 
This class creates an implication on two constraints `C1 ==> C2`
Example :

KHybridSolution 
This class represents a solution of a relaxation solver, that is, a mapping
from variables (KNumVar and/or KAuxVar) to their value.
Example :

KInputOrder 
This class implements a variable selector that selects the first uninstantiated variable in the input order.
Example :

KIntAnnotation 

KIntArray 
This class implements an array of integers
Example :

KIntegerObjectiveOptimalityChecker 
An OptimalityToleranceChecker to use with integer objective only.

KIntervalDomain 
Branching scheme for splitting float variables into a set of intervals.
This branching scheme split the domain of a float variable into interval
of length `gap`.

KIntMatrix 
This class implements an matrix of integers

KIntSetIntAnnotation 

KIntVar 
This class implements an integer variable with enumerated (finite) domain.
Decision variables are the variable quantities that we are trying to
instantiate in order to satisfy the constraints of our problem.
In this version, Artelys Kalis works with integer variables : decision
variables which are constrained to take only integer values.
These integer variables are represented by instances of the class KIntVar.
Example :

KIntVarArray 
This class implements an array of KIntVar with enumerated (finite) domains
Example :

KIntVarBranchingScheme 
Abstract class for Branching scheme.

KIntVarMatrix 
This class implements an matrix of KIntVar
Example :

KLargestDomain 
This class implements a variable selector that selects the first uninstantiated variable with the smallest domain.
Example :

KLargestDurationDomain 
Largest domain duration task selection heuristic

KLargestEarliestCompletionTime 
Largest Earliest Completion time task selection heuristic

KLargestEarliestStartTime 
Largest Earliest Start time task selection heuristic

KLargestLatestCompletionTime 
Largest Latest Completion time task selection heuristic

KLargestLatestStartTime 
Largest Latest Start time task selection heuristic

KLargestMax 
This class implements a variable selector that selects first the variable
with the largest upperbound in its domain.
Example:

KLargestMin 
This class implements a variable selector that selects first the variable
with the largest lower bound.
Example:

KLargestReducedCost 
This variable selector selects the variable with biggest reduced cost in current LP solution
of the provided linear relaxation solver.
Note that it does NOT call the solve() method of the solver automatically.
The current LP solution is simply read as it is.

KLessOrEqualXc 
This class creates a X <= C constraint.

KLinComb 
This class creates a Sum(ai.Xi) { <= , != , == } C constraint
Example :

KLinComb.LinCombOperator 

KLinearRelaxation 
This class represents a linear relaxation of a domain.
A linear relaxation consists of the following.
 A set of involved variables
 A type for each variable (either continuous or global).

KLinearRelaxationSolver 
This class is intended as a superclass for linear relaxation solvers.
Such a solver must be provided with
 a linear relaxation (KLinearRelaxation)
 an objective variable (KNumVar)
 a sense for optimization (KProblem::Sense).
It relies on a LP/MIP solver to provide the following information:
 a value (a bound for the relaxed problem, cf method getBound())
 a solution, possibly not feasible for the original problem, but which can be used to guide the search for a feasible solution
 if the problem is LP, reduced costs (that can be used for instance in the "reduced cost fixing" procedure).

KLinearRelaxationSolver.SolveAlgorithm 
Resolution algorithms

KLinearRelaxationSolverConfigurator 

KLinRel 
This class represents a linear relation (equality or inequality) between variables.
Variables involved in the KLinRel object can be a mix of KNumVar and KAuxVar.

KLinTerm 
This class represent a linear term of the form Sum(coeffs[i].lvars[i]) + cst
Example :

KMax 
This class creates a vMax = max(X1,X2,...,Xn) constraint
Example :

KMaxDegree 
This class implements a variable selector that selects first the variable
involved in the maximum number of constraints.
Example :

KMaxRegretOnLowerBound 
This class implements a variable selector that selects first the variable with maximum regret on its lowerbound.
Example :

KMaxRegretOnUpperBound 
This class implements a variable selector that selects first the variable
with maximum regret on its upperbound.
Example :

KMaxToMin 
This class implements a value selector that returns values in decreasing
order.
Example :

KMessage 

KMessageBox 

KMiddle 
This class implements a value selector that selects the nearest value from
the middle value in the domain of the variable.
Example :

KMin 
This class creates a vMin = min(X1,X2,...,Xn) constraint
Example :

KMinMaxConflict 
Value selector that selects the value of a variable that implies the best
problem size reduction when instantiated.
For each possible value of the domain of the variable, the variable is
instantiated and the problem size reduction is evaluated.

KMinToMax 
This class implements a value selector that returns values in increasing
order.
Example :

KMostFractional 
This variable selector selects the variable with biggest fractional part in
the current solution held by the provided linear relaxation solver.
Note that it does NOT call the "solve" method of the solver, so if you want
the relaxation to be resolved at each node, you must use method
KSolver::setOtherNodesRelaxationSolver.

KNearestNeighbor 
A nearest neighboor branching scheme based on a distance matrix.

KNearestRelaxedValue 
This value selector chooses the value closest to the relaxed solution
contained in the provided solver.

KNearestValue 
This class implements a value selector that selects the nearest value from
target in the domain of the variable.
Example :

KNonLinearTerm 
This class represent a non linear term.
Example :

KNonLinearTerm.AlgebricOperator 

KNonLinearTerm.CompareOperator 

KNonLinearTerm.NonLinFunction 

KNotEqualXc 
This class creates a X != C constraint
Example :

KNotEqualXyc 
This class creates a X <> Y + C constraint
Example :

KNumAnnotation 

KNumDistanceEqualXyc 
This class creates a abs(XY) == C constraint
Example :

KNumDistanceGreaterThanXyc 
This class creates a `abs(XY) >= C` constraint
Example :

KNumDistanceLowerThanXyc 
This class creates a `abs(XY) <= C` constraint
Example :

KNumEqualXc 
This class creates a `X == C` constraint
Example :

KNumEqualXYc 
This class creates a `X == Y + C` constraint
Example :

KNumEqualXYZ 
This class creates a `X == Y + Z` constraint
Example :

KNumGreaterOrEqualXc 
This class creates a `X >= C` constraint
Example :

KNumGreaterOrEqualXyc 
This class creates a `X >= Y + C` constraint
Example :

KNumInputOrder 
This class implements a variable selector that selects the first uninstantiated variable in the input order.
Example :

KNumLargestReducedCost 
This variable selector selects the variable with biggest reduced cost in
current LP solution of the provided linear relaxation solver.

KNumLessOrEqualXc 
This class creates a `X <= C` constraint
Example :

KNumLinComb 
This class creates a Sum(ai.Xi) { <= , != , == } C constraint
Example :

KNumLinComb.LinCombOperator 

KNumLowerOrEqualXyc 
This class creates a `X <= Y + C` constraint
Example :

KNumMiddle 
This class implements a value selector that selects the nearest value from
the middle value in the domain of the variable.
Example :

KNumNearestRelaxedValue 
This value selector chooses the value closest to the relaxed solution
contained in the provided solver.
If the relaxed value for a KFloatVar variable is within its bounds, the
selected value is simply the relaxed value.

KNumNearestValue 
This class implements a value selector that selects the nearest value from target in the domain of the variable .
Example :

KNumNonLinearComb 
This class represents a constraint to propagate any non linear constraint of
the form KNonLinearTerm COMPARATOR KNonLinearTerm.

KNumNonLinearComb.NonLinearCombOperator 
Available operators for the constraint

KNumObjectiveOptimalityChecker 
An OptimalityToleranceChecker to use with any type of
KNumVar objective, which use both a relative and absolute
difference criteria.

KNumSmallestDomain 
Smallest domain variable selector

KNumValueSelector 
Abstract interface class for value selection heuristic

KNumVar 
Superclass of decision variables

KNumVar.Type 
Variable types

KNumVarArray 
This class implements an array of KNumVar.
Example :

KNumVariableSelector 
Abstract interface class for variable selection heuristic.

KNumXEqualsAbsY 
This class creates a `X = Y` constraint
Example :

KNumXEqualsAtan2YZ 
This class creates a X = atan2(Y, Z) constraint.
Atan2(Y, Z) is defined as follow :
 atan(Y/Z) if Z > 0
 atan(Y/Z) + PI if Z < 0 and Y >= 0
 atan(Y/Z)  PI if Z < 0 and Y < 0
 (+ PI / 2) if Z = 0 and Y > 0
 ( PI / 2) if Z = 0 and Y < 0
 undefined if Z = 0 and Y = 0
Domain of X variable is at least (PI, PI].
Example :

KNumXEqualsLnY 
This class creates a X = ln(Y) constraint
Example :

KNumXEqualsYArithPowC 
This class creates a X = Y ^ C constraint
Example :

KNumXEqualsYSquared 
This class creates a `X = Y^2` constraint
Example :

KNumXEqualsYTimesC 
This class creates a `X = Y * C` constraint
Example :

KNumXEqualsYTimesZ 
This class creates a `X == Y * Z` constraint
Example :

KNumXOperatorACosY 
This class creates a X {==,<=,>=} acos(Y) constraint
Example :

KNumXOperatorASinY 
This class creates a X {==,<=,>=} asin(Y) constraint
Example :

KNumXOperatorATanY 
This class creates a X {==,<=,>=} atan(Y) constraint
Example :

KNumXOperatorCosY 
This class creates a X {==,<=,>=} cos(Y) constraint
Example :

KNumXOperatorExpY 
This class creates a X {==,<=,>=} exp(Y) constraint
Example :

KNumXOperatorLnY 
This class creates a X {==,<=,>=} ln(Y) constraint
Example :

KNumXOperatorSinY 
This class creates a X {==,<=,>=} sin(Y) constraint
Example :

KNumXOperatorTanY 
This class creates a X {==,<=,>=} tan(Y) constraint
Example :

KOccurrence 
This class creates an occurence constraint of a value in a list of variables
Example :

KOccurTerm 
This class represent an expression of type occur(target,lvars) where target
is the value for wich we want to restrict the number of occurence(s) in the
lVars array of variables.
Example :

KOptimalityToleranceChecker 
This interface sets a framework for objects providing method to check if the
current solution is close enough to the optimum, and, if not, to give a new
bound to set on the objective variable.

KOptimizeListener 

KOptimizeWithISListener 

KOtherNodeLinearRelaxationSolverConfigurator 

KParallelBranchingScheme 
Parallel branching scheme
Example:

KParallelSolverEventListener 

KPathOrder 
A variable selector based on a path order.
The initial successor is chosen randomly.

KProbe 
Probe branching scheme

KProbeDisjunction 
ProbeDisjunction branching scheme

KProblem 
Constraint satisfaction and optimization problems include variables,
constraints ( modeling entities ) and might have solutions after search.
Such problems are represented in Artelys Kalis by objects of the class
KProblem.

KProblem.constraintClass 
Constraint classes for which an automatic relaxation is available

KProblem.LogLevel 
Ouput log level

KProblem.Sense 
Sense for optimization

KRandomValue 
This class implements a value selector that selects a value at random in the domain of the variable.
Example :

KRandomVariable 
This class implements a variable selector that selects an uninstantiated
variable at random.
Example :

KRelation 
A relation term between an expression and constants.

KRelation.Comparator 

KRelativeToleranceOptimalityChecker 
An OptimalityToleranceChecker to use with any type of
KNumVar objective, which use a relative difference criteria.

KRelaxationSolver 
This class is intended as a superclass for linear relaxation solvers.
Such a solver must be provided with
 a linear relaxation (KLinearRelaxation)
 an objective variable (KNumVar)
 a sense for optimization (KProblem::Sense).
It relies on a LP/MIP solver to provide the following information:
 a value (a bound for the relaxed problem, cf method getBound())
 a solution, possibly not feasible for the original problem, but which can be used to guide the search for a feasible solution
 if the problem is LP, reduced costs (that can be used for instance in the "reduced cost fixing" procedure).

KRelaxationSolverConfigurator 

KResource 
Resources (machines, raw material etc) can be of two different types :
 Disjunctive when the resource can process only one task at a time (represented by the class KUnaryResource).
 Cumulative when the resource can process several tasks at the same time (represented by the class KDiscreteResource).
Traditional examples of disjunctive resources are Jobshop problems,
cumulative resources are heavily used for the ResourceConstrained Project
Scheduling Problem (RCPSP).

KResourceArray 
This class implements an array of KResource
Example :

KResourceSelector 
Resource selection heuristic

KResourceUsage 
A KResourceUsage object can be used to describe the a specific usage of a
given resource.

KResourceUsageArray 
Utility container for storing a list of KResourceUsage

KSchedule 
Scheduling and planning problems are concerned with determining a plan for
the execution of a given set of tasks.
The objective may be to generate a feasible schedule that satisfies the given
constraints (such as sequence of tasks or limited resource availability) or
to optimize a given criterion such as the makespan of the schedule.
ArtelysKalis defines several aggregate modeling objects to simplify the
formulation of standard scheduling problems like tasks,resources and schedule
objects.

KSchedule.ScheduleStatus 

KSession 
Nothing can be done in Artelys Kalis outside a KSession object.

KSettleDisjunction 
KSettleDisjunction branching scheme
Example :

KSmallestDomain 
This class implements a variable selector that selects the first uninstantiated variable with the smallest domain.
Example :

KSmallestDomDegRatio 
This class implements a variable selector that selects first the variable with the smallest ratio domain size / degree in the constraint graph.
Example :

KSmallestEarliestCompletionTime 
Smallest Earliest Completion time task selection heuristic

KSmallestEarliestStartTime 
Smallest Earliest Start time task selection heuristic

KSmallestLatestCompletionTime 
Smallest Latest Completion time task selection heuristic

KSmallestLatestStartTime 
Smallest Latest Start time task selection heuristic

KSmallestMax 
This class implements a variable selector that selects first the variable
with the smallest upperbound.
Example:

KSmallestMin 
This class implements a variable selector that selects the first uninstantiated variable with the smallest value in its domain.
Example :

KSmallestTargetStartTime 
Smallest Target Start time task selection heuristic

KSolution 
This class represents a solution of a KProblem.
Example :

KSolutionArray 
An array of KSolution objects

KSolutionContainer 
This class represent a pool of solution of a KProblem.
Example:

KSolver 
KSolver is the main class for solving problems defined in a KProblem instance.
Once the problem has been fully built, we can begin to look for solutions.
For this, the main class to be used is KSolver, which allows us to :
look for one solution
look for all solutions
look for another solution when we already know some of them
look for the optimal solution according to the problem objective
A KSolver object must be associated to a specific problem.

KSolver.DblAttrib 
Double attributes

KSolver.DblControl 
Double controls

KSolver.IntAttrib 
Integer attributes

KSolver.IntControl 
Integer controls

KSolver.SearchLimitAttrib 
Search limit attributes

KSolver.ToleranceLimitAttrib 
Tolerance limits attributes

KSolverEventListener 
Callbacks for a KSolver events.

KSplitDomain 
SplitDomain Branching scheme
Example :

KSplitNumDomain 
SplitDomain Branching scheme
Example :

KTask 
Tasks (processing operations, activities) are represented by the class KTask.

KTaskArray 
This class implements an array of KTask
Example :

KTaskInputOrder 
Tasks input order selection heuristic

KTaskRandomOrder 
Tasks random order selection heuristic

KTaskSelector 
Abstract interface class for task selection heuristic
A custom scheduling optimization strategy can be specified by using the
KTaskSerializer branching scheme to select the task to be scheduled and value
choice heuristics for its start and duration variables.

KTaskSerializer 
Taskbased branching strategy
A custom scheduling optimization strategy can be specified by using the
KTaskSerializer branching scheme to select the task to be scheduled and value
choice heuristics for its start, duration and assignments variables.

KTaskSerializer.varOrder 
Variable branching orders for each task

KTasksRankConstraint 
Constraint linking tasks and rank variables for unary scheduling.

KTerm 
Superclass of KUnTerm and KBinTerm

KTimeTable 
Timetable object for timedependant resource usage constraint.

KTopNodeLinearRelaxationSolverConfigurator 

KTupleArray 
This class implements an array of tuples of fixed arity
Example :

KUnaryResource 
Unary Resource
Unary resources can process only one task at a time.
The following schema shows an example with three tasks A,B and C executing
on a disjunctive resource and on a cumulative resource with resource usage 3
for task A, 1 for task B and 1 for task C :
Tasks may require, provide, consume and produce resources :
 A task requires a resource if some amount of the resource capacity must be made available for the execution of the activity.

KUnaryResource.PropagationHint 
Propagation Hint Attributes

KUnaryResourceConstraint 
This constraint states that some tasks are not overlapping chronologically.
Resources (machines, raw material etc) can be of two different types :
 Disjunctive when the resource can process only one task at a time (represented by the class KUnaryResource).
 Cumulative when the resource can process several tasks at the same time (represented by the class
KDiscreteResource).
Traditional examples of disjunctive resources are Jobshop problems, cumulative resources are heavily used for the
ResourceConstrained Project Scheduling Problem (RCPSP).

KUnaryResourceConstraint.PropagationLevel 
Differents level of propagation for the constraints

KUnTerm 
This class represent an expression of the form X + cste where X is a variable
and cste , an integer constant

KUserConstraint 
Abstract interface class for definition of user constraints
To create your own constraints in Artelys Kalis, you must create a specific
class that inherits from the KUserConstraint class.

KUserConstraint.askRet 
Return values for `askIfEntailed`

KUserNumConstraint 
The KUserNumConstraint is the generic counterpart to the KUserConstraint for
implementing user constraints when using numeric variables.

KUserNumConstraint.askRet 
askIfEntailed return values

KValueSelector 
Abstract interface class for value selection heuristic

KVariableSelector 
Abstract interface class for variable selection heuristic

KWidestDomain 
This class implements a variable selector that selects the first
uninstantiated variable with the widest domain.
Example :

KXEqualYMinusZ 
This class creates a X == Y  Z constraint
Example :

KXPRSLinearRelaxationSolver 
This linear relaxation solver relies on XPress Optimizer to solve the LP/MIP
problem.
Example:
