Class IlcAnyVarArray

The class IlcAnyVarArray is the class for an array of instances of IlcAnyVar. Three integers—indexMin, indexMax, and indexStep—play an important role in such an array of constrained enumerated variables. The index of those variables ranges from indexMin, inclusive, to indexMax, exclusive, in steps of indexStep. The index of the first variable in the array is indexMin; the second one is indexMin+indexStep, and so forth. The quantity indicated by indexMax-indexMin must be a multiple of indexStep.

Generic Constraints

The array makes it easier to implement generic constraints. In this context, a generic constraint is a constraint that applies to all of the variables in the array. Member functions of the array class are available to post such generic constraints. A generic constraint is then allocated and recorded only once for all the variables in the array. This fact represents a significant economy in memory, compared to allocating and recording one constraint per variable.

Interval Constraints

Arrays of constrained variables also allow you to define interval constraints which propagate in a global way when the domains of one or more constrained variables in the array are modified. Propagation is then performed through a goal. Member functions such as whenValueInterval or whenDomainInterval associate goals with propagation events for this purpose.

Reversibility

All the functions and member functions capable of modifying arrays of constrained enumerated variables are reversible. In particular, when modifiers and functions posting constraints are called, the state before their call will be saved by Solver.

Empty Handle 0r Null Array

It is possible to create a null array, or in other words, an empty handle. When you do so, only these operations are allowed on that null array:

• copy: You can assign the null array to a new array.
• access its size: The member function getSize for the null array returns 0 (zero).
• create an iterator: You can create an iterator to traverse the null array. The member function ok returns IlcFalse for a null array.

Attempts to access a null array in any other way will throw an exception (an instance of IloSolver::SolverErrorException).

This constructor creates an uninitialized array of length size. The argument size must be strictly greater than 0 (zero). The index range of the array is [0 size). Each element of the array must be assigned before the array can be used.

This constructor creates an array of copies of the given constrained enumerated variable prototype. Each copy initially has the same domain as prototype currently has, but the copies do not share the constraints of prototype. That is, the copies are independent. The index range of the array is [indexMin indexMax). The step of the array is indexStep. Solver will throw an exception (an instance of IloSolver::SolverErrorException) if any of the following conditions occur:

• indexMin is not strictly less than indexMax;
• indexStep is not strictly positive;
• (indexMax-indexMin) is not a multiple of indexStep.

This constructor keeps no pointer to the prototype variable. That variable may be an automatic object allocated on the C++ stack.

This member function returns a copy of the invoking array of constrained variables and associates that copy with the solver indicated by solver.

When it is called during the execution of a constraint or a demon associated with an array by the member function whenDomainInterval, this member function returns the maximum of the range of the array [indexMin indexMax) over which some removal of values has occurred. The returned value of this member function is not meaningful outside the execution of a goal associated with the array by the member function whenDomainInterval.

When it is called during the execution of a constraint or a demon associated with an array by the member function whenDomainInterval, this member function returns the minimum of the range of the array [indexMin indexMax) over which some removal of values has occurred. The returned value of this member function is not meaningful outside the execution of a goal associated with the array by the member function whenDomainInterval.

This member function returns the maximal index of the invoking array of constrained enumerated variables.

This member function returns the minimal index of the invoking array of constrained enumerated variables.

This member function returns the index step of the invoking array of constrained enumerated variables. The meaning of this index step is that the indexed variable value may change only at indices equal to (getIndexMin() + i * getIndexStep()).

When it is called during the execution of a constraint or a demon associated with an array by the member functions whenValue, whenDomain, or whenRange, this member function returns the index in the invoking array of the constrained variable that triggered the propagation event. Calling this member function outside the execution of the goal will throw an exception (an instance of IloSolver::SolverErrorException) with the message “unbound index”.

This member function returns the number of variables in the invoking array.

This member function returns an instance of IloSolver associated with the invoking object.

This member function returns a pointer to the implementation object of the solver where the invoking object was extracted.

When it is called during the execution of a constraint or a demon associated with an array by the member function whenValueInterval, this member function returns the maximum of the range of the array [indexMin indexMax) over which some binding has occurred. The returned value of this member function is not meaningful outside the execution of a goal associated with the array by the member function whenValueInterval.

When it is called during the execution of a constraint or a demon associated with an array by the member function whenValueInterval, this member function returns the minimum of the range of the array [indexMin indexMax) over which some binding has occurred. The returned value of this member function is not meaningful outside the execution of a goal associated with the array by the member function whenValueInterval.

This member function returns the variable corresponding to the given index in the invoking array of constrained enumerated variables. However, if before is IlcTrue, then getVariable returns the variable before the variable at the given index. Solver will throw an exception (an instance of IloSolver::SolverErrorException) with the message "bad index" if the given index is not a valid one for the invoking array of constrained enumerated variables. Solver will throw the same exception if index=0 and before=IlcTrue.

If t is an array of constrained enumerated variables, then these three expressions return the same value:

 t.getVariable(index, IlcFalse)

 t.getVariable(index + 1, IlcTrue)

 t[index]

This subscripting operator returns a constrained enumerated expression. For clarity, let's call A the invoking array. When var is bound to the value i, then the domain of the variable is the domain of A[i]. More generally, the domain of the variable is the union of the domains of the expressions A[i] where the i are in the domain of var.

This operator returns a generic variable, which is a constrained variable representing an element of the array. That generic variable is said to "stem from" the index i.

This subscripting operator returns a reference to a constrained enumerated variable corresponding to the given index in the invoking array of constrained enumerated variables. Solver will throw an exception (an instance of IloSolver::SolverErrorException) with the message “bad index” if the given index is not a valid one for the invoking array of constrained integer variables.

This member function associates demon with the domain propagation event of every variable in the invoking array. Whenever a value is removed from the domain of any of the variables in the invoking array, the demon will be executed immediately.

When the demon is executed, the index of the constrained variable that triggered the domain event can be known by a call to the member function getIndexValue.

Since a constraint is also a demon, a constraint can also be passed as an argument to this member function. When a value is removed from the domain of any of the variables in the invoking array, the constraint will be propagated.

This member function associates demon with the domain propagation event of every variable in the invoking array. It specifies that a given demon reacts globally to modifications of the domains of a collection of variables in the array. Whenever a domain propagation event or a series of such events occurs, the demon will be executed immediately.

Since a constraint is also a demon, a constraint can also be passed as an argument to this member function. Whenever a domain propagation event or a series of such events occurs, the constraint will be propagated.

A call to the demon signifies that some removal of values from domain(s) occurred over the index range [indexMin indexMax). It does not mean that values have been removed from the domains of all the variables in the range.

This member function associates demon with the value propagation event of every variable in the invoking array. When one of the variables in the array receives a value, the demon will be executed immediately.

When the demon is executed, the index of the bound constrained variable can be known by a call to the member function getIndexValue.

Since a constraint is also a demon, a constraint can also be passed as an argument to this member function. When one of the variables in the array receives a value, the constraint will be propagated.

This member function associates demon with the value propagation event of every variable in the invoking array. It specifies that a given demon reacts globally to the binding of a collection of variables in the array. When a value propagation event or a series of such events occurs, the demon will be executed immediately.

Since a constraint is also a demon, a constraint can also be passed as an argument to this member function. When a value propagation event or a series of such events occurs, the constraint will be propagated.

A call to the demon signifies that some variable binding occurred over the index range [indexMin indexMax). It does not mean that all the variables in the range have been bound.