The CP type exposes the following members.
Methods
| Name | Description | |
|---|---|---|
|
|
AbortSearch |
This methods stops the current search and can be useful for interrupting the
CP solver in an iteractive application.
|
|
|
AddKPI |
Adds a named KPI to CP Optimizer.
|
|
|
AddTuple |
This method adds a tuple represented by the array array to the tuple set ts.
|
|
|
Alternative(IIntervalVar, array<IIntervalVar>[]()[][]) |
This method creates an alternative constraint between interval variable a and
the set of interval variables in the array bs.
|
|
|
Alternative(IIntervalVar, array<IIntervalVar>[]()[][], IIntExpr) |
This method creates an alternative constraint between interval variable a and
the set of interval variables in the array bs with cardinality c.
If a is present, c intervals in bs
will be selected by the alternative constraint.
|
|
|
Alternative(IIntervalVar, array<IIntervalVar>[]()[][], Int32) |
This method creates an alternative constraint between interval variable a and
the set of interval variables in the array bs with cardinality c.
If a is present, c intervals in bs
will be selected by the alternative constraint.
|
|
|
Alternative(IIntervalVar, array<IIntervalVar>[]()[][], String) |
This method creates an alternative constraint between interval variable a and
the set of interval variables in the array bs.
|
|
|
Alternative(IIntervalVar, array<IIntervalVar>[]()[][], IIntExpr, String) |
This method creates an alternative constraint between interval variable a and
the set of interval variables in the array bs with cardinality c.
If a is present, c intervals in bs
will be selected by the alternative constraint.
|
|
|
Alternative(IIntervalVar, array<IIntervalVar>[]()[][], Int32, String) |
This method creates an alternative constraint between interval variable a and
the set of interval variables in the array bs with cardinality c.
If a is present, c intervals in bs
will be selected by the alternative constraint.
|
|
|
AlwaysConstant(IStateFunction, IIntervalVar) |
This method returns a constraint that ensures that whenever
interval variable a is present state function
f is defined everywhere between the start and the end
of interval variable a and remains constant over this
interval.
|
|
|
AlwaysConstant(IStateFunction, Int32, Int32) |
This method returns a constraint that ensures that state
function f is defined everywhere on the interval
[start,end) and remains constant over this
interval.
|
|
|
AlwaysConstant(IStateFunction, IIntervalVar, Boolean, Boolean) |
This method returns a constraint that ensures that whenever
interval variable a is present state function
f is defined everywhere between the start and the end
of interval variable a and remains constant over this
interval.
|
|
|
AlwaysConstant(IStateFunction, Int32, Int32, Boolean, Boolean) |
This method returns a constraint that ensures that state
function f is defined everywhere on the interval
[start,end) and remains constant over this
interval.
|
|
|
AlwaysEqual(ICumulFunctionExpr, IIntervalVar, Int32) |
This method returns a constraint that states that whenever
interval variable a is present, the value of cumul
function expression f should be always equal to
v between the start and the end of
a.
|
|
|
AlwaysEqual(IStateFunction, IIntervalVar, Int32) |
This method returns a constraint that ensures that whenever
interval variable a is present state function
f is defined everywhere between the start and the end
of interval variable a and remains equal to value
v over this interval.
|
|
|
AlwaysEqual(ICumulFunctionExpr, Int32, Int32, Int32) |
This method returns a constraint that states that the value of
cumul function expression f should be always equal to
v between start and
end.
|
|
|
AlwaysEqual(IStateFunction, Int32, Int32, Int32) |
This method returns a constraint that ensures that state
function f is defined everywhere on the interval
[start,end) and remains equal to value v
over this interval.
|
|
|
AlwaysEqual(IStateFunction, IIntervalVar, Int32, Boolean, Boolean) |
This method returns a constraint that ensures that whenever
interval variable a is present state function
f is defined everywhere between the start and the end
of interval variable a and remains equal to value
v over this interval.
|
|
|
AlwaysEqual(IStateFunction, Int32, Int32, Int32, Boolean, Boolean) |
This method returns a constraint that ensures that state
function f is defined everywhere on the interval
[start,end) and remains equal to value v
over this interval.
|
|
|
AlwaysIn(ICumulFunctionExpr, IIntervalVar, Int32, Int32) |
This method returns a constraint that states that whenever
interval variable a is present, the value of cumul
function expression f should be always within the
range [vmin,vmax] between the start and the end of
a.
|
|
|
AlwaysIn(IStateFunction, IIntervalVar, Int32, Int32) |
This method returns a constraint that ensures that whenever
interval variable a is present, the value of state
function f, if defined, remains in the range
[vmin,vmax] for any point t between the
start and the end of interval variable a.
|
|
|
AlwaysIn(ICumulFunctionExpr, Int32, Int32, Int32, Int32) |
This method returns a constraint that states that the value of
cumul function expression f should be always within
the range [vmin,vmax] between start and
end.
|
|
|
AlwaysIn(IStateFunction, Int32, Int32, Int32, Int32) |
This method returns a constraint that ensures that, if it is
defined, the value of state function f remains in the
range [vmin,vmax] for any point t in
the interval of integers [start,end).
|
|
|
AlwaysNoState(IStateFunction, IIntervalVar) |
This method returns a constraint that ensures that whenever
interval variable a is present state function
f is undefined everywhere between the start and the
end of interval variable a.
|
|
|
AlwaysNoState(IStateFunction, Int32, Int32) |
This method returns a constraint that ensures that state
function f is undefined everywhere on the interval of
integers [start,end).
|
|
|
ArrayEltName |
This method is a shortcut to name.concat("[").concat(System.String.valueOf(index)).concat("]")
|
|
|
Before |
This method returns a constraint that states that whenever
both interval variables pred and succ are
present, interval variable pred must be ordered before
interval variable succ (but not necessarily
immediately before) in the sequence variable seq.
|
|
|
Clear | |
|
|
ClearAbort |
This method should be called after AbortSearch before any subsequent
call to Solve or StartNewSearch.
|
|
|
ClearExplanations |
This method is used to clear the set of failure indices to be explained.
|
|
|
ClearStartingPoint |
This method removes any starting point specified on the
invoking CP Optimizer engine: subsequent searches will not use
any starting point information, unless a new starting point is
set.
For more information on starting points, see the
Starting Point concept.
|
|
|
Constant(Double, String) |
Creates and returns a new constant expression equal to value.
|
|
|
Constant(Int32, String) |
Creates and returns a new constant expression equal to value.
|
|
|
CumulFunctionExpr()()()() |
This method creates a constant cumul function expression everywhere equal to 0
that the user can modify subsequently with the operators +=, -=.
|
|
|
CumulFunctionExpr(String) |
This method creates a constant cumul function expression everywhere equal to 0
that the user can modify subsequently with the operators +=, -=.
You can specify a name of your own choice.
|
|
|
Diff |
This operator returns a cumul function expression equal to the difference of its arguments.
|
|
|
Div(Int32, IIntExpr) |
Creates and returns the integer division e1 / e2.
|
|
|
Div(IIntExpr, IIntExpr) |
Creates and returns the integer division e1 / e2.
|
|
|
Div(IIntExpr, Int32) |
Creates and returns the integer division e1 / e2.
|
|
|
DomainMax |
This method returns a variable evaluator. This evaluator returns the maximum value in the current domain of the variable.
|
|
|
DomainMin |
This method returns a variable evaluator.
|
|
|
DomainSize |
This method returns a variable evaluator. This evaluator returns the number of elements in the current domain of the evaluated variable.
|
|
|
DumpModel(TextWriter) |
Dumps the current model and internal data using TextWriter class.
|
|
|
DumpModel(String) |
Dumps the current model and internal data into a file.
|
|
|
End |
Frees the memory ressources allocated by invoking CP Optimizer
(Overrides IloModelerImplEnd()()()().) |
|
|
EndAtEnd(IIntervalVar, IIntervalVar) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance end(b)-end(a)between the
end of interval a and the end of interval
b must be equal to 0. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
EndAtEnd(IIntervalVar, IIntervalVar, IIntExpr) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance end(b)-end(a)between the
end of interval a and the end of interval
b must be equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
EndAtEnd(IIntervalVar, IIntervalVar, Int32) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance end(b)-end(a)between the
end of interval a and the end of interval
b must be equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
EndAtStart(IIntervalVar, IIntervalVar) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance start(b)-end(a)between the
end of interval a and the start of interval
b must be equal to 0. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
EndAtStart(IIntervalVar, IIntervalVar, IIntExpr) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance start(b)-end(a)between the
end of interval a and the start of interval
b must be equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
EndAtStart(IIntervalVar, IIntervalVar, Int32) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance start(b)-end(a)between the
end of interval a and the start of interval
b must be equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
EndBeforeEnd(IIntervalVar, IIntervalVar) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance end(b)-end(a)between the
end of interval a and the end of interval
b must be greater than or equal to 0. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
EndBeforeEnd(IIntervalVar, IIntervalVar, IIntExpr) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance end(b)-end(a)between the
end of interval a and the end of interval
b must be greater than or equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
EndBeforeEnd(IIntervalVar, IIntervalVar, Int32) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance end(b)-end(a)between the
end of interval a and the end of interval
b must be greater than or equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
EndBeforeStart(IIntervalVar, IIntervalVar) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance start(b)-end(a)between the
end of interval a and the start of interval
b must be greater than or equal to 0. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
EndBeforeStart(IIntervalVar, IIntervalVar, IIntExpr) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance start(b)-end(a)between the
end of interval a and the start of interval
b must be greater than or equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
EndBeforeStart(IIntervalVar, IIntervalVar, Int32) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance start(b)-end(a)between the
end of interval a and the start of interval
b must be greater than or equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
EndEval(IIntervalVar, INumToNumSegmentFunction) |
This method returns a numerical expression that represents the
value of function f evaluated on the end of interval
variable a whenever the interval variable is
present. When the interval variable is absent, it returns 0.
|
|
|
EndEval(IIntervalVar, INumToNumSegmentFunction, Double) |
This method returns a numerical expression that represents the
value of function f evaluated on the end of interval
variable a whenever the interval variable is
present. When the interval variable is absent, it returns the
constant numerical value absVal (by default: 0).
|
|
|
EndOf(IIntervalVar) |
This method returns an integer expression that represents the end
of interval variable a whenever the interval variable
is present. When the interval variable is absent, it returns
0.
|
|
|
EndOf(IIntervalVar, Int32) |
This method returns an integer expression that represents the end
of interval variable a whenever the interval variable
is present. When the interval variable is absent, it returns the
constant integer value absVal (by default: 0).
|
|
|
EndOfNext(IIntervalSequenceVar, IIntervalVar, Int32) |
This method returns an integer expression that represents the
end of the interval variable that is next to interval
a in sequence variable seq. When
interval a is present and is the last interval of
sequence seq, it returns the constant integer value
lastVal. When interval a is absent, it
returns 0.
|
|
|
EndOfNext(IIntervalSequenceVar, IIntervalVar, Int32, Int32) |
This method returns an integer expression that represents the
end of the interval variable that is next to interval
a in sequence variable seq. When
interval a is present and is the last interval of
sequence seq, it returns the constant integer value
lastVal. When interval a is absent, it
returns the constant integer value absVal.
|
|
|
EndOfPrevious(IIntervalSequenceVar, IIntervalVar, Int32) |
This method returns an integer expression that represents the
end of the interval variable that is previous to interval
a in sequence variable seq. When
interval a is present and is the first interval of
sequence seq, it returns the constant integer value
firstVal. When interval a is absent, it
returns 0.
|
|
|
EndOfPrevious(IIntervalSequenceVar, IIntervalVar, Int32, Int32) |
This method returns an integer expression that represents the
end of the interval variable that is previous to interval
a in sequence variable seq. When
interval a is present and is the first interval of
sequence seq, it returns the constant integer value
firstVal. When interval a is absent, it
returns the constant integer value absVal.
|
|
|
EndSearch |
This method terminates a search and deletes the
internal objects created by CP to carry out the search.
|
|
|
Eq(Int32, IIntExpr) |
Creates and returns the new constraint v == e.
|
|
|
Eq(IIntExpr, IIntExpr) |
Creates and returns the new constraint e1 == e2.
|
|
|
Eq(IIntExpr, Int32) |
Creates and returns the new constraint e == v.
|
|
|
Equals |
Determines whether the specified Object is equal to the current Object. (Inherited from Object.) |
|
|
Equiv |
Creates and returns the new constraint c1 <=> c2, in which the two constraints c1 and c2 are
equivalent.
|
|
|
Error |
Returns the error output stream of the invoking CP object. This stream is used by CP for printing errors. It can be set with the method CP.SetError.
|
|
|
ExplainFailure(Int32) |
This method specifies a tag (index) of the failure to explain. Several failures tags can be added.
|
|
|
ExplainFailure(array<Int32>[]()[][]) |
This method specifies an array of tags (indices) of failures to explain.
|
|
|
ExplicitValueEval(array<Int32>[]()[][], array<Double>[]()[][]) |
This method is a shortcut to explicitValueEval(vals, evaluation, 0).
|
|
|
ExplicitValueEval(array<Int32>[]()[][], array<Int32>[]()[][]) |
This method is a shortcut to explicitValueEval(vals, evaluation, 0).
|
|
|
ExplicitValueEval(array<Int32>[]()[][], array<Double>[]()[][], Double) |
This method returns a value evaluator. The evaluations of elements of vals are explicitly defined in the array of floating-point values evaluation; that is, the evaluation of vals[i] is evaluation[i]. The arrays vals and evaluation must have the same size. The evaluation of a value that does not appear in vals is given by defaultEval.
|
|
|
ExplicitValueEval(array<Int32>[]()[][], array<Int32>[]()[][], Double) |
This method returns a value evaluator.
|
|
|
ExplicitVarEval(array<IIntVar>[]()[][], array<Double>[]()[][]) |
This method is a shortcut to explicitVarEval(vars, vals, 0).
|
|
|
ExplicitVarEval(array<IIntVar>[]()[][], array<Int32>[]()[][]) |
This method is a shortcut to explicitVarEval(vars, vals, 0).
|
|
|
ExplicitVarEval(array<IIntVar>[]()[][], array<Double>[]()[][], Double) |
This method returns a variable evaluator. The evaluation of variables from the array vars are
explicitly defined in the array of floating-point values vals; that is, the evaluation of
vars[i] is vals[i]. The arrays vars and vals must have
the same size. The evaluation of a variable that does not appear in the array is given by
defaultEval.
|
|
|
ExplicitVarEval(array<IIntVar>[]()[][], array<Int32>[]()[][], Double) |
This method returns a variable evaluator. The evaluations of variables in the array vars are
explicitly defined in the array of integer values vals; that is, the evaluation of
vars[i] is vals[i]. The arrays vars and vals must have the same size.
The evaluation of a variable that does not appear in the array is given by defaultEval.
|
|
|
Exponent |
Creates and returns the new expression exp(e).
|
|
|
ExportModel(TextWriter) |
Exports the current model using TextWriter class.
|
|
|
ExportModel(String) |
Exports the current model into a file.
|
|
|
FalseConstraint |
Creates and returns a new constraint that is always false.
|
|
|
Finalize |
Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.) |
|
|
First |
This method returns a constraint that states that whenever
interval variable a is present, it must be ordered
first in the sequence variable seq.
|
|
|
Floor |
Creates and returns a new expression.
|
|
|
ForbidEnd |
This method returns a constraint that states that whenever
interval variable a is present, it cannot end at a
value t such that f(t-1)=0.
|
|
|
ForbidExtent |
This method returns a constraint that states that whenever
interval variable a is present, it cannot contain a
value t such that f(t)=0.
|
|
|
ForbidStart |
This method returns a constraint that states that whenever
interval variable a is present, it cannot start at a
value t such that f(t)=0.
|
|
|
Ge(Int32, ICumulFunctionExpr) |
This method returns a constraint that states that the value of cumul function expression
f should never be greater than vmax.
(Overrides IloModelerImplGe(Int32, ICumulFunctionExpr).) |
|
|
Ge(Int32, IIntExpr) |
Creates and returns the new constraint v >= e.
|
|
|
Ge(ICumulFunctionExpr, IIntExpr) |
This method returns a constraint that states that the value of cumul function expression
f should never be less than vmin.
|
|
|
Ge(ICumulFunctionExpr, Int32) |
This method returns a constraint that states that the value of cumul function expression
f should never be less than vmin.
(Overrides IloModelerImplGe(ICumulFunctionExpr, Int32).) |
|
|
Ge(IIntExpr, ICumulFunctionExpr) |
This method returns a constraint that states that the value of cumul function expression
f should never be greater than vmax.
|
|
|
Ge(IIntExpr, IIntExpr) |
Creates and returns the new constraint e1 >= e2.
|
|
|
Ge(IIntExpr, Int32) |
Creates and returns the new constraint e >= v.
|
|
|
GetAllConstrainedICumulFunctionExprs |
Gets all cumul functions in the current model.
|
|
|
GetAllIIntervalSequenceVars |
Gets all interval sequence variables in the current model.
|
|
|
GetAllIIntervalVars |
Gets all interval variables in the current model.
|
|
|
GetAllIIntVars |
Get all integer variables in the current model.
|
|
|
GetAllIStateFunctions |
Gets all state functions in the current model.
|
|
|
GetAllKPINames |
This method returns names of all KPIs.
|
|
|
GetConflict(IConstraint) |
This method returns the conflict status for a given constraint cst.
|
|
|
GetConflict(IIntervalVar) |
This method returns the conflict status for a given interval
variable var.
|
|
|
GetConflict(INumVar) |
This method returns the conflict status for a given numerical
variable var.
|
|
|
GetDomain |
This method returns the current domain of interval variable a as maintained by the
invoking instance of CP.
|
|
|
GetDomainSize |
This method returns the size of the domain of variable var as maintained in the invoking
instance of CP. An assertion is violated if var is not of integral type.
|
|
|
GetEnd(String) |
Returns the current end time of the interval variable with the specified name.
|
|
|
GetEnd(IIntervalVar) |
This method returns the current value of the end of interval
variable a in the invoking instance of CP. An assertion
is violated if a is not fixed.
|
|
|
GetEndMax |
This method returns the maximum value for the end of interval
variable a in the invoking instance of CP.
|
|
|
GetEndMin |
This method returns the minimum value for the end of interval
variable a in the invoking instance of CP.
|
|
|
GetFirst |
This method assumes that interval sequence variable seq is fixed.
It returns the interval variable at the first position in the sequence.
|
|
|
GetHashCode |
Serves as a hash function for a particular type. (Inherited from Object.) |
|
|
GetICumulFunctionExpr |
Finds a cumulative function expression in the current model by its name.
|
|
|
GetIIntervalSequenceVar |
Finds an interval sequence variable in the current model by its name.
|
|
|
GetIIntervalVar |
Finds an interval variable in the current model by its name.
|
|
|
GetIIntVar |
Finds an integer variable in the current model by its name.
|
|
|
GetIncumbentValue(String) | |
|
|
GetIncumbentValue(INumExpr) | |
|
|
GetInfo(CP..::..DoubleInfo) |
This method returns the value of the floating-point information which in the invoked CP instance.
|
|
|
GetInfo(CP..::..IntInfo) |
This method returns the value of the integer information which in the invoked CP instance.
|
|
|
GetIntValue |
This method returns the current value of the variable v in the invoking instance of
CP. An assertion is violated if v is not fixed to a value.
|
|
|
GetIStateFunction |
Finds a state function in the current model by its name.
|
|
|
GetKPIValue | |
|
|
GetLast |
This method assumes that interval sequence variable seq is fixed.
It returns the interval variable at the last position in the sequence.
|
|
|
GetLength(String) |
Returns the current length of the interval variable with the specified name.
|
|
|
GetLength(IIntervalVar) |
This method returns the current value of the length of interval variable a in the invoking instance of CP. An assertion is violated if a is not fixed.
|
|
|
GetLengthMax |
This method returns the maximum value for the length of interval variable a in the invoking instance of CP.
|
|
|
GetLengthMin |
This method returns the minimum value for the length of interval variable a in the invoking instance of CP.
|
|
|
GetMax |
This method returns the maximum value of the variable v in the invoking instance
of CP.
|
|
|
GetMin |
This method returns the minimum value of the variable v in the invoking instance
of CP.
|
|
|
GetNext |
This method assumes that interval sequence variable seq is fixed.
It returns the interval variable that immediately follows interval a in the sequence.
|
|
|
GetNumberOfSegments(ICumulFunctionExpr) |
This method assumes that the cumul function expression
f is fixed. It returns the number of segments of the
cumul function expression f.
|
|
|
GetNumberOfSegments(IStateFunction) |
This method assumes that state function
f is fixed. It returns the number of segments of the
state function f.
|
|
|
GetObjBounds |
This method returns the numeric values of all objective bounds
in a multi-objective function associated with the CP engine.
|
|
|
GetObjGaps |
This method returns the numeric values of all objective gaps
in a multi-objective function associated with the CP engine.
|
|
|
GetObjValues |
This method returns the numeric values of all objectives
in a multi-objective function associated with the CP engine.
|
|
|
GetParameterDefault(CP..::..DoubleParam) |
This method returns the default value of the floating-point parameter param in the invoked
CP instance.
|
|
|
GetParameterDefault(CP..::..IntParam) |
This method returns the default value of the integer parameter param in the invoked
CP instance.
|
|
|
GetPrev |
This method assumes that interval sequence variable seq is fixed.
It returns the interval variable that immediately precedes interval a in the
sequence.
|
|
|
GetRandomInt |
This method returns a pseudo-randomly generated integer value in the range [0..n).
|
|
|
GetSegmentEnd(ICumulFunctionExpr, Int32) |
This method assumes that the cumul function expression
f is fixed. It returns the end of the
ith segment of the cumul function expression f.
|
|
|
GetSegmentEnd(IStateFunction, Int32) |
This method assumes that state function
f is fixed. It returns the end of the
ith segment of the
state function f.
|
|
|
GetSegmentStart(ICumulFunctionExpr, Int32) |
This method assumes that the cumul function expression
f is fixed. It returns the start of the
ith segment of the cumul function expression f.
|
|
|
GetSegmentStart(IStateFunction, Int32) |
This method assumes that state function
f is fixed. It returns the start of the
ith segment of the
state function f.
|
|
|
GetSegmentValue(ICumulFunctionExpr, Int32) |
This method assumes that the cumul function expression
f is fixed. It returns the value of the
ith segment of the cumul function expression f.
|
|
|
GetSegmentValue(IStateFunction, Int32) |
This method assumes that state function
f is fixed. It returns the value of the
ith segment of the
state function f.
|
|
|
GetSize(String) |
Returns the current size of the interval variable with the specified name.
|
|
|
GetSize(IIntervalVar) |
This method returns the current value of the size of interval
variable a in the invoking instance of CP. An assertion
is violated if a is not fixed.
|
|
|
GetSizeMax |
This method returns the maximum value for the size of interval
variable a in the invoking instance of CP.
|
|
|
GetSizeMin |
This method returns the minimum value for the size of interval
variable a in the invoking instance of CP.
|
|
|
GetStart(String) |
Returns the current start time of the interval variable with the specified name.
|
|
|
GetStart(IIntervalVar) |
This method returns the current value of the start of interval
variable a in the invoking instance of CP. An assertion
is violated if a is not fixed.
|
|
|
GetStartMax |
This method returns the maximum value for the start of interval
variable a in the invoking instance of CP.
|
|
|
GetStartMin |
This method returns the minimum value for the start of interval
variable a in the invoking instance of CP.
|
|
|
GetSymbolicValueName |
This method returns the value of the integer information which in the invoked CP instance.
|
|
|
GetType |
Gets the type of the current instance. (Inherited from Object.) |
|
|
GetValue(String) |
Returns the current value of an integer variable with the specified name.
|
|
|
GetValue(IIntExpr) |
This method returns the current value of the expression expr in the invoking instance of
CP.
|
|
|
GetValue(IIntVar) |
This method returns the current value of the variable v in the invoking instance of
CP. An assertion is violated if v is not fixed to a value.
|
|
|
GetValue(INumExpr) |
This method returns the current value of the expression expr in the invoking instance of
CP.
|
|
|
GetValue(INumVar) |
This method returns the current value of the variable v in the invoking instance of
CP. An assertion is violated if v is not fixed to a value.
|
|
|
GetValue(ICumulFunctionExpr, Int32) |
This method assumes that cumul function expression
f is fixed. It returns the value of the
corresponding stepwise non-negative function at point
t.
|
|
|
GetValue(IStateFunction, Int32) |
This method assumes that state function
f is fixed. It returns the value of the
corresponding stepwise non-negative function at point
t.
|
|
|
Gt(Int32, IIntExpr) |
Creates and returns the new constraint v >= e.
|
|
|
Gt(IIntExpr, IIntExpr) |
Creates and returns the new constraint e1 >= e2.
|
|
|
Gt(IIntExpr, Int32) |
Creates and returns the new constraint e >= v.
|
|
|
HasObjective |
This method returns true if and only if the invoking CP solver
has extracted a model involving an objective.
|
|
|
HeightAtEnd(IIntervalVar, ICumulFunctionExpr) |
Whenever interval variable a is present, this
function returns an integer expression that represents the total
contribution of the end of interval variable a to
the cumul function expression f. When interval variable a
is absent, this method returns 0.
|
|
|
HeightAtEnd(IIntervalVar, ICumulFunctionExpr, Int32) |
Whenever interval variable a is present, this
function returns an integer expression that represents the total
contribution of the end of interval variable a to
the cumul function expressionf. When interval variable a is
absent, this method
returns a constant integer expression equal to absVal
(by default: 0).
|
|
|
HeightAtStart(IIntervalVar, ICumulFunctionExpr) |
Whenever interval variable a is present, this
function returns an integer expression that represents the total
contribution of the start of interval variable a to
the cumul function expression f. When interval variable
a is absent, this method returns 0.
|
|
|
HeightAtStart(IIntervalVar, ICumulFunctionExpr, Int32) |
Whenever interval variable a is present, this
function returns an integer expression that represents the total
contribution of the start of interval variable a to
the cumul function expression f.
When interval variable a is absent, this method
returns a constant integer expression equal to absVal
(by default: 0).
|
|
|
IfThenElse |
Creates and returns the new constraint (c1 => c2) && (! c1 => c3), that is, if the
first constraint is satisfied, it implies the second, and if it is violated, it implies the third.
|
|
|
ImpactOfLastBranch |
This method returns a variable evaluator. The evaluation is the domain reduction that the last instantiation made by search has achieved on the evaluated variable. Values returned range from 0 to 1.0. If the value is close to zero then there wasn't much domain reduction on the evaluated variable during the last instantiation. If the value is close to one, the domain was reduced considerably.
|
|
|
Imply |
Creates and returns the new constraint c1 => c2, that is, the first constraint implies the
other.
|
|
|
ImportModel(Stream) |
Imports model from a stream.
|
|
|
ImportModel(String) |
Imports model from a file.
|
|
|
Inferred(IIntVar) |
Returns an addable which identifies var as having its
value inferred by the values taken on by non-inferred variables.
It is a shorthand for Inferred when only one variable
is being passed.
|
|
|
Inferred(array<IIntVar>[]()[][]) |
Returns an "addable" which identifies certain variables as having their
values inferred by the values taken on by non-inferred variables.
|
|
|
IntervalSequenceVar(array<IIntervalVar>[]()[][]) |
This method creates an instance of sequence variable on the set of interval variables
defined by array a.
|
|
|
IntervalSequenceVar(array<IIntervalVar>[]()[][], array<Int32>[]()[][]) |
This method creates an instance of sequence variable on the set of interval variables
defined by array a. An array of non-negative
integer types is specified. Arrays a and types must be of the same size and
interval variable a[i] will have type types[i] in the sequence variable.
|
|
|
IntervalSequenceVar(array<IIntervalVar>[]()[][], String) |
This method creates an instance of sequence variable on the set of interval variables
defined by array a. You can specify a name of your own choice.
|
|
|
IntervalSequenceVar(array<IIntervalVar>[]()[][], array<Int32>[]()[][], String) |
This method creates an instance of sequence variable on the set of interval variables
defined by array a. An array of non-negative
integer types is specified. Arrays a and types must be of the same size and
interval variable a[i] will have type types[i] in the sequence variable.
You can specify a name of your own choice.
|
|
|
IntervalVar()()()() |
This method creates an interval variable. The start, end and size of the new interval variable range from 0 to the constant
CP.IntervalMax. If you need an optional interval
variable, you need to use the method SetOptional. As no intensity function is specified,
the size of the interval variable will be equal to its length.
|
|
|
IntervalVar(Int32) |
This method creates an interval variable. The start and end of the new interval variable range from 0 to the constant
CP.IntervalMax. The size of the new interval variable is fixed and equal to sz. The
created interval variable is present; if you need an optional interval variable, you need to use the
method SetOptional. As no intensity function is specified, the size of the interval
variable will be equal to its length.
|
|
|
IntervalVar(String) |
This method creates an interval variable. The start, end and size of the new interval variable range from 0 to the constant
CP.IntervalMax. If you need an optional interval
variable, you need to use the method SetOptional. As no intensity function is specified,
the size of the interval variable will be equal to its length.
|
|
|
IntervalVar(Int32, Int32) |
This method creates an interval variable. The start and end of the new interval variable range from 0 to the constant
CP.IntervalMax. The size of the new interval variable ranges from szmin to
szmax. By default, the created interval variable is present but it can be made optional by
passing a true value (True) for opt. As no intensity function is specified,
the size of the interval variable will be equal to its length.
|
|
|
IntervalVar(Int32, String) |
This method creates an interval variable. The start and end of the new interval variable range from 0 to the constant
CP.IntervalMax. The size of the new interval variable is fixed and equal to sz. The
created interval variable is present; if you need an optional interval variable, you need to use the
method SetOptional. As no intensity function is specified, the size of the interval
variable will be equal to its length.
|
|
|
IntervalVar(Int32, Int32, Boolean, INumToNumStepFunction, Int32) |
This method creates an interval variable. The start and end of the new interval variable range from 0 to the constant
CP.IntervalMax. The size of the new interval variable ranges from szmin to
szmax. By default, the created interval variable is present but it can be made optional by
passing a true value (True) for opt. The intensity function is
intensity. This intensity function is an integer step function expressed as a percentage (and so must
bounded in the range [0,100]).
|
|
|
IntExpr |
Creates and returns a new IIntExpr from the IConstraint
|
|
|
IntExprArray |
Creates and returns an array of null expressions.
|
|
|
IntTable |
Creates and returns a new table table.
|
|
|
IntValueChooser(IValueSelector) |
This method returns an IIntValueChooser made with the IValueSelector arg.
|
|
|
IntValueChooser(array<IValueSelector>[]()[][]) |
This method returns an IIntValueChooser made with the array of IValueSelector arg.
|
|
|
IntVar(array<Int32>[]()[][]) |
Creates and returns a new integer variable with a domain of possible values.
|
|
|
IntVar(array<Int32>[]()[][], String) |
Creates and returns a new integer variable with a domain of possible values and a name.
|
|
|
IntVarChooser(IVarSelector) |
This method returns an IIntVarChooser made with the IVarSelector arg.
|
|
|
IntVarChooser(array<IVarSelector>[]()[][]) |
This method returns an IIntVarChooser made with the array of IVarSelector arg.
|
|
|
IsAbsent(String) |
Checks whether an interval variable with the specified name is currently set to be absent.
|
|
|
IsAbsent(IIntervalVar) |
This method returns true if and only if interval variable
a is absent in the invoking instance of CP.
|
|
|
IsFixed(ICumulFunctionExpr) |
This method indicates whether the cumul function
expression f takes on a particular value as
maintained by the invoking CP instance.
|
|
|
IsFixed(IIntervalSequenceVar) |
This method indicates if the domain of the interval sequence variable seq
takes on a particular value as maintained by the invoking CP instance.
An interval sequence variable is said to be fixed if and only if all the interval variables
of the sequence are either absent or ordered.
|
|
|
IsFixed(IIntervalVar) |
This method indicates if the domain of a takes
on a particular value as maintained by the invoking CP
instance. An interval variable is said to be fixed if and only if it is
either absent or present with fixed start, end and size value.
|
|
|
IsFixed(INumVar) |
This method indicates if the domain of var takes on a particular value as maintained by the
invoking CP instance.
|
|
|
IsFixed(IStateFunction) |
This method indicates if the state function
f takes on a particular value as
maintained by the invoking CP instance.
|
|
|
IsInDomain |
This method indicates whether value is contained in the current domain of
var as maintained by the invoking CP instance. An assertion is violated if
var is not of integral type.
|
|
|
Isomorphism(array<IIntervalVar>[]()[][], array<IIntervalVar>[]()[][]) |
This method creates an isomorphism constraint between the set of interval variables in
the array domain and the set of interval variables in the array intervals.
|
|
|
Isomorphism(array<IIntervalVar>[]()[][], array<IIntervalVar>[]()[][], String) |
This method creates an isomorphism constraint between the set of interval variables in
the array domain and the set of interval variables in the array intervals.
The set of integer expressions in the array map is the indexer from intervals
to domain with the default index value for absent intervals absVal.
|
|
|
Isomorphism(array<IIntervalVar>[]()[][], array<IIntervalVar>[]()[][], array<IIntExpr>[]()[][], Int32) |
This method creates an isomorphism constraint between the set of interval variables in
the array domain and the set of interval variables in the array intervals.
The set of integer expressions in the array map is the indexer from intervals
to domain with the default index value for absent intervals absVal.
|
|
|
Isomorphism(array<IIntervalVar>[]()[][], array<IIntervalVar>[]()[][], array<IIntExpr>[]()[][], Int32, String) |
This method creates an isomorphism constraint between the set of interval variables in
the array domain and the set of interval variables in the array intervals.
The set of integer expressions in the array map is the indexer from intervals
to domain with the default index value for absent intervals absVal.
|
|
|
IsPresent(String) |
Checks whether an interval variable with the specified name is currently set to be present.
|
|
|
IsPresent(IIntervalVar) |
This method returns true if and only if interval variable
a is present in the invoking instance of CP.
|
|
|
Last |
This method returns a constraint that states that whenever
interval variable a is present, it must be ordered
last in the sequence variable seq.
|
|
|
Le(Int32, ICumulFunctionExpr) |
This method returns a constraint that states that the value of cumul function expression
f should never be less than than vmin.
(Overrides IloModelerImplLe(Int32, ICumulFunctionExpr).) |
|
|
Le(Int32, IIntExpr) |
Creates and returns the new constraint v <= e.
|
|
|
Le(ICumulFunctionExpr, IIntExpr) |
This method returns a constraint that states that the value of cumul function expression
f should never be greater than vmax.
|
|
|
Le(ICumulFunctionExpr, Int32) |
This method returns a constraint that states that the value of cumul function expression
f should never be greater than vmax.
(Overrides IloModelerImplLe(ICumulFunctionExpr, Int32).) |
|
|
Le(IIntExpr, ICumulFunctionExpr) |
This method returns a constraint that states that the value of cumul function expression
f should never be less than than vmin.
|
|
|
Le(IIntExpr, IIntExpr) |
Creates and returns the new constraint e1 <= e2.
|
|
|
Le(IIntExpr, Int32) |
Creates and returns the new constraint e <= v.
|
|
|
LengthEval(IIntervalVar, INumToNumSegmentFunction) |
This method returns a numerical expression that represents the
value of function f evaluated on the length of interval
variable a whenever the interval variable is
present. When the interval variable is absent, it returns 0.
|
|
|
LengthEval(IIntervalVar, INumToNumSegmentFunction, Double) |
This method returns a numerical expression that represents the
value of function f evaluated on the length of interval
variable a whenever the interval variable is
present. When the interval variable is absent, it returns the
constant numerical value absVal (by default: 0).
|
|
|
LengthOf(IIntervalVar) |
This method returns an integer expression that represents the
length of interval variable a whenever the interval
variable is present. When the interval variable is absent, it
returns 0.
|
|
|
LengthOf(IIntervalVar, Int32) |
This method returns an integer expression that represents the
length of interval variable a whenever the interval
variable is present. When the interval variable is absent, it
returns the constant integer value absVal (by default:
0).
|
|
|
LengthOfNext(IIntervalSequenceVar, IIntervalVar, Int32) |
This method returns an integer expression that represents the
length of the interval variable that is next to interval
a in sequence variable seq. When
interval a is present and is the last interval of
sequence seq, it returns the constant integer value
lastVal. When interval a is absent, it
returns 0.
|
|
|
LengthOfNext(IIntervalSequenceVar, IIntervalVar, Int32, Int32) |
This method returns an integer expression that represents the
length of the interval variable that is next to interval
a in sequence variable seq. When
interval a is present and is the last interval of
sequence seq, it returns the constant integer value
lastVal. When interval a is absent, it
returns the constant integer value absVal.
|
|
|
LengthOfPrevious(IIntervalSequenceVar, IIntervalVar, Int32) |
This method returns an integer expression that represents the
length of the interval variable that is previous to interval
a in sequence variable seq. When
interval a is present and is the first interval of
sequence seq, it returns the constant integer value
firstVal. When interval a is absent, it
returns 0.
|
|
|
LengthOfPrevious(IIntervalSequenceVar, IIntervalVar, Int32, Int32) |
This method returns an integer expression that represents the
length of the interval variable that is previous to interval
a in sequence variable seq. When
interval a is present and is the first interval of
sequence seq, it returns the constant integer value
firstVal. When interval a is absent, it
returns the constant integer value absVal.
|
|
|
Log |
Creates and returns the new expression log(e).
|
|
|
Lt(Int32, IIntExpr) |
Creates and returns the new constraint v < e.
|
|
|
Lt(IIntExpr, IIntExpr) |
Creates and returns the new constraint e1 < e2.
|
|
|
Lt(IIntExpr, Int32) |
Creates and returns the new constraint e < v.
|
|
|
Maximize(IIntExpr) |
Creates a maximization objective.
|
|
|
Maximize(IMultiCriterionExpr) |
Creates a maximization multi-criteria objective.
|
|
|
MemberwiseClone |
Creates a shallow copy of the current Object. (Inherited from Object.) |
|
|
Minimize(IIntExpr) |
Creates a minimization objective.
|
|
|
Minimize(IMultiCriterionExpr) |
Creates a minimization multi-criteria objective.
|
|
|
Modulo |
Creates and returns the modulo expression e % r.
|
|
|
Neq(Int32, IIntExpr) |
Creates and returns the new constraint v != e.
|
|
|
Neq(IIntExpr, IIntExpr) |
Creates and returns the new constraint e1 != e2.
|
|
|
Neq(IIntExpr, Int32) |
Creates and returns the new constraint e != v.
|
|
|
Next | |
|
|
NoOverlap(IIntervalSequenceVar) |
This constructor creates a no-overlap constraint on the
sequence variable seq. This constraint states that the
interval variables of the sequence do not overlap and that the
order of intervals in the sequence is the order implied by the
relative position of the start and end points of the
non-overlapping intervals.
|
|
|
NoOverlap(array<IIntervalVar>[]()[][]) |
This constructor creates a no-overlap constraint on the set of
interval variables defined by array a.
|
|
|
NoOverlap(IIntervalSequenceVar, ITransitionDistance) |
This constructor creates a no-overlap constraint on the
sequence variable seq. This constraint states that the
interval variables of the sequence do not overlap and that the
order of intervals in the sequence is the order implied by the
relative position of the start and end points of the
non-overlapping intervals. A transition distance
tdist is used to specify a minimal distance
between two interval variables in the sequence. The transition
distance holds between an interval and all its successors in the
sequence.
|
|
|
NoOverlap(array<IIntervalVar>[]()[][], String) |
This constructor creates a no-overlap constraint on the set of
interval variables defined by array a. By default, the name of
the no-overlap constraint is the empty string, but you can specify
a name of your own choice.
|
|
|
NoOverlap(IIntervalSequenceVar, ITransitionDistance, Boolean) |
This constructor creates a no-overlap constraint on the
sequence variable seq. This constraint states that the
interval variables of the sequence do not overlap and that the
order of intervals in the sequence is the order implied by the
relative position of the start and end points of the
non-overlapping intervals. A transition distance
tdist is used to specify a minimal distance
between two interval variables in the sequence. If direct is
true, the transition distance holds between an interval and its
immediate successor in the sequence otherwise, if
direct is false, the transition distance holds
between an interval and all its successors in the sequence.
|
|
|
NoOverlap(IIntervalSequenceVar, ITransitionDistance, String) |
This constructor creates a no-overlap constraint on the
sequence variable seq. This constraint states that the
interval variables of the sequence do not overlap and that the
order of intervals in the sequence is the order implied by the
relative position of the start and end points of the
non-overlapping intervals. A transition distance
tdist is used to specify a minimal distance
between two interval variables in the sequence.
The transition distance holds between an interval and all its
successors in the sequence. By default, the
name of the no-overlap constraint is the empty string, but you
can specify a name of your own choice.
|
|
|
NoOverlap(IIntervalSequenceVar, ITransitionDistance, Boolean, String) |
This constructor creates a no-overlap constraint on the
sequence variable seq. This constraint states that the
interval variables of the sequence do not overlap and that the
order of intervals in the sequence is the order implied by the
relative position of the start and end points of the
non-overlapping intervals. A transition distance
tdist is used to specify a minimal distance
between two interval variables in the sequence. If direct is
true, the transition distance holds between an interval and its
immediate successor in the sequence otherwise, if
direct is false, the transition distance holds
between an interval and all its successors in the sequence. By default, the
name of the no-overlap constraint is the empty string, but you
can specify a name of your own choice.
|
|
|
NumExprArray |
Creates and returns an array of null expressions.
|
|
|
NumToNumSegmentFunction()()()() |
This constructor creates a piecewise linear function that is constant. It is defined everywhere
with value 0.
|
|
|
NumToNumSegmentFunction(array<Double>[]()[][], array<Double>[]()[][]) |
This constructor creates a piecewise linear function defined everywhere
whose segments are defined by the two argument arrays x and v.
|
|
|
NumToNumSegmentFunctionCursor |
This constructor creates a cursor to inspect piecewise linear function f.
This cursor lets you iterate forward or backward over the steps of the function.
The cursor initially specifies the step of the function that contains x.
|
|
|
NumToNumStepFunction |
This constructor creates a step function defined everywhere with value 0.
|
|
|
NumToNumStepFunctionCursor |
This constructor creates a cursor to inspect step function f.
This cursor lets you iterate forward or backward over the steps of the function.
The cursor initially specifies the step of the function that contains x.
|
|
|
Output |
Returns the output stream of the invoking CP object. This stream is used by CP for printing logging information. It can be set with the method CP.SetOut.
|
|
|
OverlapLength(IIntervalVar, IIntervalVar) |
This method returns an integer expression that represents the
length of the overlap of interval variable a1 and
interval variable a2 whenever interval variables
a1 and a2 are present. When interval
variable a1 or a2 is absent, the function
returns zero.
|
|
|
OverlapLength(IIntervalVar, IIntervalVar, Int32) |
This method returns an integer expression that represents the
length of the overlap of interval variable a1 and
interval variable a2 whenever interval variables
a1 and a2 are present. When interval
variable a1 or a2 is absent, the function
returns the constant integer value absVal.
|
|
|
OverlapLength(IIntervalVar, Int32, Int32) |
This method returns an integer expression that represents the
length of the overlap of interval variable a and
constant interval [start, end) whenever interval
variable a is present. When interval variable
a is absent, the function returns zero.
|
|
|
OverlapLength(IIntervalVar, Int32, Int32, Int32) |
This method returns an integer expression that represents the
length of the overlap of interval variable a and
constant interval [start, end) whenever interval
variable a is present. When interval variable
a is absent, the function returns the constant integer
value absVal.
|
|
|
Pack(array<IIntExpr>[]()[][], array<IIntExpr>[]()[][], array<Int32>[]()[][]) |
Creates and returns a pack constraint which maintains the load of a set of containers or bins, given a set of
weighted items and an assignment of items to containers.
|
|
|
Pack(array<IIntExpr>[]()[][], array<IIntExpr>[]()[][], array<Int32>[]()[][], IIntExpr) |
Creates and returns a pack constraint which maintains the load of a set of containers or bins, given a set of
weighted items and an assignment of items to containers.
|
|
|
PiecewiseLinear(INumExpr, Double, array<Double>[]()[][], array<Double>[]()[][], Double) |
This method creates an expression to represent a continuous or discontinuous
piecewise linear function f of the variable e.
|
|
|
PiecewiseLinear(INumExpr, array<Double>[]()[][], array<Double>[]()[][], Double, Double) |
This method creates an expression to represent a continuous or discontinuous
piecewise linear function f of the variable e.
|
|
|
PiecewiseLinearFunction(array<Double>[]()[][], array<Double>[]()[][], Double, Double) |
This method builds an instance of piecewise linear function defined everywhere.
The array point contains the n breakpoints of the
function such that point [i-1] <= point [i] for i = 1, . . ., n-1. The array slope
contains the n+1 slopes of the n+1 segments of the function. The values a and
fa must be coordinates of a point such that fa = f(a).
|
|
|
PiecewiseLinearFunction(array<Double>[]()[][], array<Double>[]()[][], Double, Double, String) |
This method builds an instance of piecewise linear function defined everywhere.
|
|
|
Power(Double, INumExpr) |
Creates and returns the new expression e1 ^ e2c>.
|
|
|
Power(INumExpr, INumExpr) |
Creates and returns the new expression e1 ^ e2c>.
|
|
|
Power(INumExpr, Double) |
Creates and returns the new expression e1 ^ e2c>.
|
|
|
PresenceOf |
This method returns a constraint that states that interval
variable a is present. You must add this constraint
to a model and extract the model for an algorithm in order for it
to be taken into account.
|
|
|
Previous |
This method returns a constraint that states that whenever
both interval variables prev and next are
present, interval variable prev must be ordered
immediately before interval variable next in the
sequence variable seq.
|
|
|
PrintInformation()()()() | |
|
|
PrintInformation(TextWriter) |
This method displays statistics about the current
state of the CP Optimizer instance using text writer s.
For more information, see {see cref='PrintInformation'}.
|
|
|
Propagate()()()() |
Propagates all constraints without a goal.
|
|
|
Propagate(IConstraint) |
Propagates a constraint
|
|
|
Pulse(IIntervalVar, Int32) |
This method returns an elementary cumul function expression
that,
whenever interval variable a is present, is
equal to v between the start and the end of
interval variable a and equal to 0
everywhere else. When interval variable a is absent,
the function is the constant null function.
|
|
|
Pulse(Int32, Int32, Int32) |
This method returns an elementary cumul function expression
that is constant over a certain interval and null before that.
|
|
|
Pulse(IIntervalVar, Int32, Int32) |
This elementary cumul function expression,
whenever interval variable a is present, is
equal to a value v such that vmin <= v <=
vmax everywhere between the start and the end of interval
variable a and equal to 0 everywhere
else. The choice of the value v in the range
[vmin,vmax] is a decision of the problem. When interval
variable a is absent, the function is the constant null
function.
|
|
|
Quot(Double, INumExpr) |
Creates and returns the new expression e1 / e2.
|
|
|
Quot(INumExpr, INumExpr) |
Creates and returns the new expression e1 / e2.
|
|
|
Quot(INumExpr, Double) |
Creates and returns the new expression e1 / e2.
|
|
|
Range |
Creates and returns an IRange object. The new IRange object is initialized to
represent the constraint -b <= expr <= +b.
|
|
|
RefineConflict()()()() |
This method identifies a minimal conflict for the infeasibility of the
current model. Since the conflict is minimal, removal of any one of these
constraints will remove that particular cause for infeasibility. There may
be other conflicts in the model; consequently, repair of a given conflict
does not guarantee feasibility of the remaining model.
|
|
|
RefineConflict(array<IConstraint>[]()[][]) |
This method identifies a minimal conflict for the infeasibility of a subset
of the constraints of the current model. Since the conflict is minimal, removal
of any one of these constraints will remove that particular cause for infeasibility.
There may be other conflicts in the model; consequently, repair of a given conflict
does not guarantee feasibility of the remaining model.
|
|
|
RefineConflict(array<IConstraint>[]()[][], array<Double>[]()[][]) |
This method identifies a minimal conflict for the infeasibility of a subset
of the constraints of the current model. Since the conflict is minimal, removal
of any one of these constraints will remove that particular cause for infeasibility.
There may be other conflicts in the model; consequently, repair of a given conflict
does not guarantee feasibility of the remaining model.
|
|
|
RemoveAllKPIs |
Remove all KPIs from CP Optimizer.
|
|
|
RemoveKPI |
Remove a KPI from CP Optimizer.
|
|
|
Restore |
This method uses the invoking CP Optimizer to instantiate the variables in solution with
their saved values. The value of any objective added to the solution is not restored. If the solution does not
violate any constraints of the model extracted by the invoking CP Optimizer, then ITrue is
returned and the state of the constrained variables in CP Optimizer reflect those stored in
solution. Otherwise CP Optimizer's state remains unchanged and IFalse is
returned.
|
|
|
SameCommonSubsequence(IIntervalSequenceVar, IIntervalSequenceVar) |
This method creates a same-common-subsequence constraint between sequence variables
seq1 and seq2.
|
|
|
SameCommonSubsequence(IIntervalSequenceVar, IIntervalSequenceVar, String) |
This method creates a same-common-subsequence constraint between sequence variables
seq1 and seq2.
|
|
|
SameCommonSubsequence(IIntervalSequenceVar, IIntervalSequenceVar, array<IIntervalVar>[]()[][], array<IIntervalVar>[]()[][]) |
This method creates a same-common-subsequence constraint between sequence variables
seq1 and seq2.
|
|
|
SameCommonSubsequence(IIntervalSequenceVar, IIntervalSequenceVar, array<IIntervalVar>[]()[][], array<IIntervalVar>[]()[][], String) |
This method creates a same-common-subsequence constraint between sequence variables
seq1 and seq2.
|
|
|
SameSequence(IIntervalSequenceVar, IIntervalSequenceVar) |
This method creates a same-sequence constraint between sequence variables
seq1 and seq2.
|
|
|
SameSequence(IIntervalSequenceVar, IIntervalSequenceVar, String) |
This method creates a same-sequence constraint between sequence variables
seq1 and seq2.
|
|
|
SameSequence(IIntervalSequenceVar, IIntervalSequenceVar, array<IIntervalVar>[]()[][], array<IIntervalVar>[]()[][]) |
This method creates a same-sequence constraint between sequence variables
seq1 and seq2.
|
|
|
SameSequence(IIntervalSequenceVar, IIntervalSequenceVar, array<IIntervalVar>[]()[][], array<IIntervalVar>[]()[][], String) |
This method creates a same-sequence constraint between sequence variables
seq1 and seq2.
Sequence variables seq1 and seq2 should be of the same size n.
The mapping between interval variables of the two sequences is specified by arrays a1
and a2. Arrays a1 and a2 should be of same size n.
The constraint states that the two sequences seq1 and
seq2 are identical modulo a mapping between intervals a1[i] and
a2[i]. You can specify a name of your own choice for the constraint.
|
|
|
SelectLargest(IIntValueEval) |
This method returns a selector of value assignments to a variable that selects all values having the largest
evaluation according to the evaluator eval.
|
|
|
SelectLargest(IIntVarEval) |
This method returns a selector of integer variables that selects
all variables having the largest evaluation
according to the evaluator eval.
|
|
|
SelectLargest(Double, IIntValueEval) |
This method returns a selector of value assignments to a variable that selects at least minNumber
values having the largest evaluation according to the evaluator eval. The parameter
minNumber must be at least 1.
|
|
|
SelectLargest(Double, IIntVarEval) |
This method returns a selector of integer variables that selects at least minNumber variables
having the largest evaluation according to the evaluator eval. The parameter minNumber
must be at least 1.
|
|
|
SelectLargest(IIntValueEval, Double) |
This method returns a selector of integer variable assignments that selects all domain values whose evaluations
are in the range [max - tol, max], where max is is the maximum valuation by
eval over the domain values to be evaluated. The parameter tol must be non-negative.
|
|
|
SelectLargest(IIntVarEval, Double) |
This method returns a selector of integer variables that selects all
variables whose evaluations are in the
range [max - tol, max], where max is is the maximum valuation by eval over
the variables to be evaluated. The parameter tol must be non-negative.
|
|
|
SelectRandomValue |
This method returns a selector of integer variable value assignments that selects a domain value randomly. It selects only one value.
|
|
|
SelectRandomVar |
This method returns a selector of integer variables that selects a variable randomly from those available. It selects only one variable.
|
|
|
SelectSmallest(IIntValueEval) |
This method returns a selector of value assignments to a variable that selects all values having the smallest
evaluation according to the evaluator eval.
|
|
|
SelectSmallest(IIntVarEval) |
This method returns a selector of integer variables that selects all variables having the smallest evaluation
according to the evaluator eval.
|
|
|
SelectSmallest(Double, IIntValueEval) |
This method returns a selector of integer variable assignments that selects at least minNumber
domain values having the smallest evaluation according to the evaluator eval. The parameter
minNumber must be at least 1.
|
|
|
SelectSmallest(Double, IIntVarEval) |
This method returns a selector of integer variables that selects at least minNumber variables
having the smallest evaluation according to the evaluator eval. The parameter minNumber
must be at least 1.
|
|
|
SelectSmallest(IIntValueEval, Double) |
This method returns a selector of integer variable assignments that selects all domain values whose evaluations
are in the range [min, min + tol], where min is is the minimum valuation by
eval over the domain values to be evaluated. The parameter tol must be non-negative.
|
|
|
SelectSmallest(IIntVarEval, Double) |
This method returns a selector of integer variables that selects all variables whose evaluations are in the
range [min, min + tol], where min is is the minimum valuation by eval over
the variables to be evaluated. The parameter tol must be non-negative.
|
|
|
SetError |
Sets the error stream of the invoking CP object. After this call, all errors will be output via the new stream. Passing null as the new output stream will turn off all errors.
|
|
|
SetOut |
Sets the default output stream of the invoking CP object. After this call, all logging output will be output via the new stream. Passing null as the new output stream will turn off all logging output.
|
|
|
SetStartingPoint |
This method sets solution sp as the new
starting point for subsequent searches of the invoking
CP Optimizer engine.
For more information on starting points, see the
Starting Point concept.
|
|
|
SetWarning |
Sets the warning stream of the invoking CP object. After this call, all warnings will be output via the new stream. Passing null as the new output stream will turn off all warnings.
|
|
|
SizeEval(IIntervalVar, INumToNumSegmentFunction) |
This method returns a numerical expression that represents the
value of function f evaluated on the size of interval
variable a whenever the interval variable is
present. When the interval variable is absent, it returns 0.
|
|
|
SizeEval(IIntervalVar, INumToNumSegmentFunction, Double) |
This method returns a numerical expression that represents the
value of function f evaluated on the size of interval
variable a whenever the interval variable is
present. When the interval variable is absent, it returns the
constant numerical value absVal (by default: 0).
|
|
|
SizeOf(IIntervalVar) |
This method returns an integer expression that represents the
size of interval variable a whenever the interval
variable is present. When the interval variable is absent, it
returns 0.
|
|
|
SizeOf(IIntervalVar, Int32) |
This method returns an integer expression that represents the
size of interval variable a whenever the interval
variable is present. When the interval variable is absent, it
returns the constant integer value absVal (by default:
0).
|
|
|
SizeOfNext(IIntervalSequenceVar, IIntervalVar, Int32) |
This method returns an integer expression that represents the
size of the interval variable that is next to interval
a in sequence variable seq. When
interval a is present and is the last interval of
sequence seq, it returns the constant integer value
lastVal. When interval a is absent, it
returns 0.
|
|
|
SizeOfNext(IIntervalSequenceVar, IIntervalVar, Int32, Int32) |
This method returns an integer expression that represents the
size of the interval variable that is next to interval
a in sequence variable seq. When
interval a is present and is the last interval of
sequence seq, it returns the constant integer value
lastVal. When interval a is absent, it
returns the constant integer value absVal.
|
|
|
SizeOfPrevious(IIntervalSequenceVar, IIntervalVar, Int32) |
This method returns an integer expression that represents the
size of the interval variable that is previous to interval
a in sequence variable seq. When
interval a is present and is the first interval of
sequence seq, it returns the constant integer value
firstVal. When interval a is absent, it
returns 0.
|
|
|
SizeOfPrevious(IIntervalSequenceVar, IIntervalVar, Int32, Int32) |
This method returns an integer expression that represents the
size of the interval variable that is previous to interval
a in sequence variable seq. When
interval a is present and is the first interval of
sequence seq, it returns the constant integer value
firstVal. When interval a is absent, it
returns the constant integer value absVal.
|
|
|
Solution |
This method creates and returns an instance of ISolution.
You can define what variables are stored in the solution by adding
variables direction to the solution returned.
|
|
|
Solve |
This method solves a problem using CP Optimizer's built-in strategy. The built-in
strategy is determined
by setting the parameter CP.SearchType.
|
|
|
Span(IIntervalVar, array<IIntervalVar>[]()[][]) |
This method creates a span constraint between interval variable a and the set
of interval variables in the array bs.
|
|
|
Span(IIntervalVar, array<IIntervalVar>[]()[][], String) |
This method creates a span constraint between interval variable a and the set
of interval variables in the array bs.
|
|
|
StartAtEnd(IIntervalVar, IIntervalVar) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance end(b)-start(a)between the
start of interval a and the end of interval
b must be equal to 0. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
StartAtEnd(IIntervalVar, IIntervalVar, IIntExpr) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance end(b)-start(a)between the
start of interval a and the end of interval
b must be equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
StartAtEnd(IIntervalVar, IIntervalVar, Int32) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance end(b)-start(a)between the
start of interval a and the end of interval
b must be equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
StartAtStart(IIntervalVar, IIntervalVar) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance start(b)-start(a)between the
start of interval a and the start of interval
b must be equal to 0. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
StartAtStart(IIntervalVar, IIntervalVar, IIntExpr) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance start(b)-start(a)between the
start of interval a and the start of interval
b must be equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
StartAtStart(IIntervalVar, IIntervalVar, Int32) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance start(b)-start(a)between the
start of interval a and the start of interval
b must be equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
StartBeforeEnd(IIntervalVar, IIntervalVar) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance end(b)-start(a) between the
start of interval a and the end of interval
b must be greater than or equal to 0. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
StartBeforeEnd(IIntervalVar, IIntervalVar, IIntExpr) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance end(b)-start(a)between the
start of interval a and the end of interval
b must be greater than or equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
StartBeforeEnd(IIntervalVar, IIntervalVar, Int32) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance end(b)-start(a) between the
start of interval a and the end of interval
b must be greater than or equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
StartBeforeStart(IIntervalVar, IIntervalVar) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance start(b)-start(a) between the
start of interval a and the start of interval
b must be greater than or equal to 0. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
StartBeforeStart(IIntervalVar, IIntervalVar, IIntExpr) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance start(b)-start(a) between the
start of interval a and the start of interval
b must be greater than or equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
StartBeforeStart(IIntervalVar, IIntervalVar, Int32) |
This method returns a constraint that states that whenever
both interval variables a and b are
present, the distance start(b)-start(a) between the
start of interval a and the start of interval
b must be greater than or equal to z. You must add
this constraint to a model and extract the model for an algorithm
in order for it to be taken into account.
|
|
|
StartEval(IIntervalVar, INumToNumSegmentFunction) |
This method returns a numerical expression that represents the
value of function f evaluated on the start of interval
variable a whenever the interval variable is
present. When the interval variable is absent, it returns 0.
|
|
|
StartEval(IIntervalVar, INumToNumSegmentFunction, Double) |
This method returns a numerical expression that represents the
value of function f evaluated on the start of interval
variable a whenever the interval variable is
present. When the interval variable is absent, it returns the
constant numerical value absVal (by default: 0).
|
|
|
StartNewSearch |
This method starts a new search using the built-in strategy of CP. It should be used in conjunction with the methods Next()()()() and EndSearch()()()().
|
|
|
StartOf(IIntervalVar) |
This method returns an integer expression that represents the
start of interval variable a whenever the interval
variable is present. When the interval variable is absent, it
returns 0.
|
|
|
StartOf(IIntervalVar, Int32) |
This method returns an integer expression that represents the
start of interval variable a whenever the interval
variable is present. When the interval variable is absent, it
returns the constant integer value absVal (by default:
0).
|
|
|
StartOfNext(IIntervalSequenceVar, IIntervalVar, Int32) |
This method returns an integer expression that represents the
start of the interval variable that is next to interval
a in sequence variable seq. When
interval a is present and is the last interval of
sequence seq, it returns the constant integer value
lastVal. When interval a is absent, it
returns 0.
|
|
|
StartOfNext(IIntervalSequenceVar, IIntervalVar, Int32, Int32) |
This method returns an integer expression that represents the
start of the interval variable that is next to interval
a in sequence variable seq. When
interval a is present and is the last interval of
sequence seq, it returns the constant integer value
lastVal. When interval a is absent, it
returns the constant integer value absVal.
|
|
|
StartOfPrevious(IIntervalSequenceVar, IIntervalVar, Int32) |
This method returns an integer expression that represents the
start of the interval variable that is previous to interval
a in sequence variable seq. When
interval a is present and is the first interval of
sequence seq, it returns the constant integer value
firstVal. When interval a is absent, it
returns 0.
|
|
|
StartOfPrevious(IIntervalSequenceVar, IIntervalVar, Int32, Int32) |
This method returns an integer expression that represents the
start of the interval variable that is previous to interval
a in sequence variable seq. When
interval a is present and is the first interval of
sequence seq, it returns the constant integer value
firstVal. When interval a is absent, it
returns the constant integer value absVal.
|
|
|
StateFunction()()()() |
This method creates an instance of state function.
|
|
|
StateFunction(String) |
This method creates an instance of state function.
You can specify a name of your own
choice.
|
|
|
StateFunction(ITransitionDistance) |
This method creates an instance of state function with transition distance
tdist.
|
|
|
StateFunction(ITransitionDistance, String) |
This method creates an instance of state function with transition distance
tdist. You can specify a name of your own choice.
|
|
|
StaticLex(INumExpr) |
This method defines a multicriteria expression for lexicographic ordering.
|
|
|
StaticLex(array<INumExpr>[]()[][]) |
This method defines a multicriteria expression for lexicographic ordering.
|
|
|
StaticLex(INumExpr, INumExpr) |
This method defines a multicriteria expression for lexicographic ordering.
|
|
|
StaticLex(array<INumExpr>[]()[][], String) |
This method defines a multicriteria expression for lexicographic ordering.
|
|
|
StaticLex(INumExpr, INumExpr, INumExpr) |
This method defines a multicriteria expression for lexicographic ordering.
|
|
|
StaticLex(INumExpr, INumExpr, INumExpr, INumExpr) |
This method defines a multicriteria expression for lexicographic ordering.
|
|
|
Step |
This method returns an elementary cumul function expression
that is equal to 0 before point t and
equal to v after point t.
|
|
|
StepAtEnd(IIntervalVar, Int32) |
This method returns an elementary cumul function expression
that is constant over a certain interval and null before that.
|
|
|
StepAtEnd(IIntervalVar, Int32, Int32) |
This method returns an elementary cumul function expression
that, whenever interval variable a is present, is
equal to a 0 before the end of a and
equal to a value v such that vmin <= v <=
vmax after the end of a. The choice of the
value v in the range [vmin,vmax] is a
decision of the problem. When interval variable a is
absent, the function is the constant null function.
|
|
|
StepAtStart(IIntervalVar, Int32) |
This method returns an elementary cumul function expression
that is constant over a certain interval and null before that.
|
|
|
StepAtStart(IIntervalVar, Int32, Int32) |
This method returns an elementary cumul function expression
that, whenever interval variable a is present, is
equal to a 0 before the start of a and
equal to a value v such that vmin <= v <=
vmax after the start of a. The choice of the
value v in the range [vmin,vmax] is a
decision of the problem. When interval variable a is
absent, the function is the constant null function.
|
|
|
Store |
This method stores the values of the objects added to solution by examining their current
values in the invoking CP.
|
|
|
StrictLexicographic |
Creates and returns a constraint which maintains two arrays to be lexicographically ordered.
|
|
|
SubCircuit |
Creates and returns a circuit-imposing constraint in a model.
|
|
|
Synchronize(IIntervalVar, array<IIntervalVar>[]()[][]) |
This method creates a synchronization constraint between interval variable a
and the set of interval variables in the array bs.
|
|
|
Synchronize(IIntervalVar, array<IIntervalVar>[]()[][], String) |
This method creates a synchronization constraint between interval variable a
and the set of interval variables in the array bs.
|
|
|
ToString |
Returns a string that represents the current object. (Inherited from Object.) |
|
|
TransitionDistance(Int32) |
This method returns an instance of transition distance of the specified size i.
Initially, the transition distance between any two indices is 0. You need to fill the transition distance using
the method setValue.
|
|
|
TransitionDistance(Int32, String) |
This method returns an instance of transition distance of the specified size i.
Initially, the transition distance between any two indices is 0. You need to fill the transition distance using
the method setValue. You can specify a name of your own choice.
|
|
|
TransitionDistance(array<array<Int32>[]()[][]>[]()[][], String) |
This method returns an instance of transition distance. The 2-dimensional integer array
argument dtable gives the values of the transition distance.
You can specify a name of your own choice.
|
|
|
TrueConstraint |
Creates and returns a new constraint that is always true.
|
|
|
TypeOfNext(IIntervalSequenceVar, IIntervalVar, Int32) |
This method returns an integer expression that represents the
type of the interval variable that is next to interval
a in sequence variable seq. When
interval a is present and is the last interval of
sequence seq, it returns the constant integer value
lastVal. When interval a is absent, it
returns 0.
|
|
|
TypeOfNext(IIntervalSequenceVar, IIntervalVar, Int32, Int32) |
This method returns an integer expression that represents the
type of the interval variable that is next to interval
a in sequence variable seq. When
interval a is present and is the last interval of
sequence seq, it returns the constant integer value
lastVal. When interval a is absent, it
returns the constant integer value absVal.
|
|
|
TypeOfPrevious(IIntervalSequenceVar, IIntervalVar, Int32) |
This method returns an integer expression that represents the
type of the interval variable that is previous to interval
a in sequence variable seq. When
interval a is present and is the first interval of
sequence seq, it returns the constant integer value
firstVal. When interval a is absent, it
returns 0.
|
|
|
TypeOfPrevious(IIntervalSequenceVar, IIntervalVar, Int32, Int32) |
This method returns an integer expression that represents the
type of the interval variable that is previous to interval
a in sequence variable seq. When
interval a is present and is the first interval of
sequence seq, it returns the constant integer value
firstVal. When interval a is absent, it
returns the constant integer value absVal.
|
|
|
Value |
This method returns a value evaluator. It returns as evaluation the value itself. This is useful to define instantiation strategies that choose the smallest or the largest value in a domain.
|
|
|
ValueImpact |
This method returns a value evaluator. The evaluation is the average reduction of the search space observed so far when instantiating the selected variable to the evaluated value. The greater the evaluation, the more space reduction this instantiation achieves. In general it is a good strategy to prefer a value having the smallest impact.
|
|
|
ValueIndex(array<Int32>[]()[][]) |
This method is a shortcut to valueIndex(vals, -1).
|
|
|
ValueIndex(array<Int32>[]()[][], Int32) |
This method returns a value evaluator. The evaluation of each value is the index of the value in the array vals. That is, the evaluation of valueArray[i] is i. If the value does not appear in the array, defaultEval is the evaluation returned.
|
|
|
ValueSuccessRate |
This method returns a value evaluator. The evaluation is the success rate of instantiating the selected variable to the evaluated value. Assuming the selected variable has been instantiated to the evaluated value n times so far and this has resulted in f failures, the success rate is (n-f)/n.
|
|
|
VarImpact |
This method returns a variable evaluator. The evaluation is the the average reduction of the search space observed so far for this variable. The greater the evaluation, the more space reduction this variable achieves. In general, it is a good strategy to start with variable having the greatest impact in order to reduce the search space size.
|
|
|
VarLocalImpact()()()() |
This method is a shortcut to varLocalImpact(-1).
|
|
|
VarLocalImpact(Int32) |
This method returns a variable evaluator. The evaluation is the impact of the variable computed at the current node of the search tree. This computation is made by probing on values from the domain of the variables. The parameter effort indicates how much effort sould be spent to compute this impact. When effort is equal to -1, every value of the domain is probed otherwise the nunber of probes effort will increase as the effort value increases.
|
|
|
VarSuccessRate |
This method returns a variable evaluator. The evaluation is the the success rate of the variable. Assuming the evaluated variable has been instantiated n times so far and this has resulted in f failures, the success rate is (n-f)/n.
|
|
|
Warning |
Returns the warning output stream of the invoking CP object. This stream is used by CP for printing warnings. It can be set with the method CP.SetWarning.
|
|
|
WriteConflict()()()() |
This method can be used as a shorthand for
cp.WriteConflict(cp.Output()).
|
|
|
WriteConflict(TextWriter) |
This method displays the current conflict. It will not display the
constraints that were initially specified as being part of the conflict and that
were consequently not refined by the conflict refiner (constraints not in the
array of constraints passed to RefineConflict or constraints or
groups with preference 0).
|