VariableFactory (org.choco-solver-choco-solver 3.3.1-j7 API)

java.lang.Object
- org.chocosolver.solver.variables.VariableFactory

Direct Known Subclasses:

VF
```
public class VariableFactory
extends Object
```
A factory to create variables (boolean, integer, set, graph, task and real) and views (most of them rely on integer variable).

Note that, for the sack of readability, the Java naming convention is not respected for methods arguments.

Since:

18 nov. 2010

Author:

Charles Prud'homme, Jean-Guillaume Fages

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`MAX_INT_BOUND` Provide a minimum value for integer variable lower bound.
`static int`	`MIN_INT_BOUND` Provide a minimum value for integer variable lower bound.

Method Summary

Methods
Modifier and Type	Method and Description
`static IntVar`	`abs(IntVar VAR)` Create a view over VAR such that: \|VAR\|.
`static BoolVar`	`bool(String NAME, Solver SOLVER)` Build a boolean variable, ie domain is [0,1]
`static BoolVar[]`	`boolArray(String NAME, int SIZE, Solver SOLVER)` Build a boolean variable array, ie each variable's domain is [0,1]
`static BoolVar[][]`	`boolMatrix(String NAME, int DIM1, int DIM2, Solver SOLVER)` Build a DIM1*DIM2-sized boolean variable matrix
`static IntVar`	`bounded(String NAME, int MIN, int MAX, Solver SOLVER)` Build an integer variable whose domain representation is abstracted by two integers: a lower bound and an upper bound.
`static IntVar[]`	`boundedArray(String NAME, int SIZE, int MIN, int MAX, Solver SOLVER)` Build and array of bounded variables (each variable domain is represented by two integers)
`static IntVar[][]`	`boundedMatrix(String NAME, int DIM1, int DIM2, int MIN, int MAX, Solver SOLVER)` Build a DIM1*DIM2-sized matrix of bounded variables (each variable domain is represented by two integers)
`static IntVar[]`	`castToIntVar(Variable... VARIABLES)` Casts VARIABLES into an integer variable array
`static IntVar`	`enumerated(String NAME, int[] VALUES, Solver SOLVER)` Build an integer variable whose domain is explicitly represented with a BitSet.
`static IntVar`	`enumerated(String NAME, int MIN, int MAX, Solver SOLVER)` Build an integer variable whose domain is explicitly represented with a BitSet.
`static IntVar[]`	`enumeratedArray(String NAME, int SIZE, int[] VALUES, Solver SOLVER)` Build an integer variable array with enumerated domains.
`static IntVar[]`	`enumeratedArray(String NAME, int SIZE, int MIN, int MAX, Solver SOLVER)` Build an array of integer variables whose domains are explicitly represented
`static IntVar[][]`	`enumeratedMatrix(String NAME, int DIM1, int DIM2, int[] VALUES, Solver SOLVER)` Build a DIM1*DIM2-sized matrix of integer variables with enumerated domains.
`static IntVar[][]`	`enumeratedMatrix(String NAME, int DIM1, int DIM2, int MIN, int MAX, Solver SOLVER)` Build a DIM1*DIM2-sized matrix of integer variables whose domains are explicitly represented
`static BoolVar`	`eq(BoolVar VAR)` Create a kind of clone of VAR such that, the resulting view is defined on VAR.
`static IntVar`	`eq(IntVar VAR)` Create a kind of clone of VAR (an offset view with CSTE= 0), such that, the resulting view is defined on VAR.
`static IntVar`	`fixed(boolean VALUE, Solver SOLVER)` get a specific boolean variable, whom domain is reduced to the singleton {VALUE}.
`static IntVar`	`fixed(int VALUE, Solver SOLVER)` Create a specific integer variable whom domain is reduced to the singleton {VALUE}.
`static SetVar`	`fixed(String NAME, int[] VALUE, Solver SOLVER)` Create a specific set variable, named NAME whom domain is reduced to the singleton {VALUE}.
`static IntVar`	`fixed(String NAME, int VALUE, Solver SOLVER)` Create a specific integer variable, named NAME whom domain is reduced to the singleton {VALUE}.
`static IntVar`	`integer(String NAME, int MIN, int MAX, Solver SOLVER)` Build an integer variable whose domain representation is abstracted by two integers: a lower bound and an upper bound.
`static IntVar[]`	`integerArray(String NAME, int SIZE, int MIN, int MAX, Solver SOLVER)` Build and array of bounded variables (each variable domain is represented by two integers)
`static IntVar[][]`	`integerMatrix(String NAME, int DIM1, int DIM2, int MIN, int MAX, Solver SOLVER)` Build a DIM1*DIM2-sized matrix of bounded variables (each variable domain is represented by two integers)
`static IntVar`	`minus(IntVar VAR)` Create a view over VAR holding : −VAR.
`static BoolVar`	`not(BoolVar BOOL)` Create a view over BOOL holding the logical negation of BOOL (ie, ¬BOOL).
`static IntVar`	`offset(IntVar VAR, int CSTE)` Create an offset view based on VAR, such that, the resulting view is defined on VAR + CSTE.
`static BoolVar`	`one(Solver SOLVER)` Retrieve the specific one/true boolvar.
`static RealVar[]`	`real(IntVar[] VARS, double PRECISION)` Create an array of real variables based on an array of integer variables VAR.
`static RealVar`	`real(IntVar VAR, double PRECISION)` Create a real variable based on an integer variable VAR.
`static RealVar`	`real(String NAME, double MIN, double MAX, double PRECISION, Solver SOLVER)` Build a real variable with a bounded domain initialized to [MIN,MAX]
`static RealVar[]`	`realArray(String NAME, int SIZE, double MIN, double MAX, double PRECISION, Solver SOLVER)` Build a SIZE-sized array of real variables.
`static RealVar[][]`	`realMatrix(String NAME, int DIM1, int DIM2, double MIN, double MAX, double PRECISION, Solver SOLVER)` Build a DIM1*DIM2-sized matrix of real variables.
`static IntVar`	`scale(IntVar VAR, int CSTE)` Create a view over VAR such that: VAR×CSTE (CSTE>-2).
`static SetVar`	`set(String NAME, int[] ENVELOPE, int[] KERNEL, Solver SOLVER)` Builds a set variable with an initial domain given by ENVELOP and KERNEL.
`static SetVar`	`set(String NAME, int[] ENVELOPE, SetType ENV_TYPE, int[] KERNEL, SetType KER_TYPE, Solver SOLVER)` Builds a set variable with an initial domain given by ENVELOP and KERNEL.
`static SetVar`	`set(String NAME, int[] ENVELOPE, Solver SOLVER)` Builds a set variable with an initial domain given by ENVELOP and KERNEL.
`static SetVar`	`set(String NAME, int MIN_ELEMENT, int MAX_ELEMENT, Solver SOLVER)` Builds a set variable with an initial domain given by ENVELOP = [MIN_ELEMENT,MAX_ELEMENT] and an empty KERNEL.
`static Task`	`task(IntVar START, IntVar DURATION, IntVar END)` Build a Task software component (not a variable) which ensures that START + DURATION = END
`static IntVar[][]`	`toMatrix(IntVar[] VARS, int DIM1, int DIM2)` Inserts VARS into a new DIM1DIM2-size matrix: put variable of VARS[iDIM2+j] into mat[i][j]
`static BoolVar`	`zero(Solver SOLVER)` Retrieve the specific zero/false boolvar.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - MIN_INT_BOUND
```
public static final int MIN_INT_BOUND
```
    Provide a minimum value for integer variable lower bound. Do not prevent from underflow, but may avoid it, somehow.
    
    See Also:
    Constant Field Values
  - MAX_INT_BOUND
```
public static final int MAX_INT_BOUND
```
    Provide a minimum value for integer variable lower bound. Do not prevent from overflow, but may avoid it, somehow.
    
    See Also:
    Constant Field Values
- Method Detail
  - bool
```
public static BoolVar bool(String NAME,
           Solver SOLVER)
```
    Build a boolean variable, ie domain is [0,1]
    
    Parameters:
    NAME - name of the variable
    SOLVER - solver involving the variable
    
    Returns:
    a BoolVar
  - boolArray
```
public static BoolVar[] boolArray(String NAME,
                  int SIZE,
                  Solver SOLVER)
```
    Build a boolean variable array, ie each variable's domain is [0,1]
    
    Parameters:
    NAME - name of the variables
    SIZE - number of variables
    SOLVER - solver involving the variable
    
    Returns:
    an array of BoolVar
  - boolMatrix
```
public static BoolVar[][] boolMatrix(String NAME,
                     int DIM1,
                     int DIM2,
                     Solver SOLVER)
```
    Build a DIM1*DIM2-sized boolean variable matrix
    
    Parameters:
    NAME - name of the variables
    DIM1 - number of rows
    DIM2 - number of columns
    SOLVER - solver involving the variable
    
    Returns:
    a BoolVar matrix
  - integer
```
public static IntVar integer(String NAME,
             int MIN,
             int MAX,
             Solver SOLVER)
```
    Build an integer variable whose domain representation is abstracted by two integers: a lower bound and an upper bound.
    Its initial domain is [MIN,MAX]
    This API automatically selects the way the domain is represented by checking its size and by comparing it to Settings.getMaxDomSizeForEnumerated(): a domain size below this value calls VariableFactory.enumerated, VariableFactory.bounded otherwise.
    
    Parameters:
    NAME - name of the variable
    MIN - initial lower bound
    MAX - initial upper bound
    SOLVER - solver involving the variable
    
    Returns:
    an integer variable with a bounded domain
    See Also:
    bounded(String, int, int, org.chocosolver.solver.Solver), enumerated(String, int, int, org.chocosolver.solver.Solver)
  - integerArray
```
public static IntVar[] integerArray(String NAME,
                    int SIZE,
                    int MIN,
                    int MAX,
                    Solver SOLVER)
```
    Build and array of bounded variables (each variable domain is represented by two integers)
    
    Parameters:
    NAME - name of the variables
    SIZE - number of variables
    MIN - initial lower bound
    MAX - initial upper bound
    SOLVER - solver involving the variable
    
    Returns:
    an array of integer variables with bounded domains
    See Also:
    integer(String, int, int, org.chocosolver.solver.Solver), bounded(String, int, int, org.chocosolver.solver.Solver), enumerated(String, int, int, org.chocosolver.solver.Solver)
  - integerMatrix
```
public static IntVar[][] integerMatrix(String NAME,
                       int DIM1,
                       int DIM2,
                       int MIN,
                       int MAX,
                       Solver SOLVER)
```
    Build a DIM1*DIM2-sized matrix of bounded variables (each variable domain is represented by two integers)
    
    Parameters:
    NAME - name of the variables
    DIM1 - number of rows
    DIM2 - number of columns
    MIN - initial lower bound
    MAX - initial upper bound
    SOLVER - solver involving the variable
    
    Returns:
    an array of integer variables with bounded domains
    See Also:
    integer(String, int, int, org.chocosolver.solver.Solver), bounded(String, int, int, org.chocosolver.solver.Solver), enumerated(String, int, int, org.chocosolver.solver.Solver)
  - bounded
```
public static IntVar bounded(String NAME,
             int MIN,
             int MAX,
             Solver SOLVER)
```
    Build an integer variable whose domain representation is abstracted by two integers: a lower bound and an upper bound.
    Its initial domain is [MIN,MAX]
    
    Parameters:
    NAME - name of the variable
    MIN - initial lower bound
    MAX - initial upper bound
    SOLVER - solver involving the variable
    
    Returns:
    an integer variable with a bounded domain
  - boundedArray
```
public static IntVar[] boundedArray(String NAME,
                    int SIZE,
                    int MIN,
                    int MAX,
                    Solver SOLVER)
```
    Build and array of bounded variables (each variable domain is represented by two integers)
    
    Parameters:
    NAME - name of the variables
    SIZE - number of variables
    MIN - initial lower bound
    MAX - initial upper bound
    SOLVER - solver involving the variable
    
    Returns:
    an array of integer variables with bounded domains
  - boundedMatrix
```
public static IntVar[][] boundedMatrix(String NAME,
                       int DIM1,
                       int DIM2,
                       int MIN,
                       int MAX,
                       Solver SOLVER)
```
    Build a DIM1*DIM2-sized matrix of bounded variables (each variable domain is represented by two integers)
    
    Parameters:
    NAME - name of the variables
    DIM1 - number of rows
    DIM2 - number of columns
    MIN - initial lower bound
    MAX - initial upper bound
    SOLVER - solver involving the variable
    
    Returns:
    an array of integer variables with bounded domains
  - enumerated
```
public static IntVar enumerated(String NAME,
                int MIN,
                int MAX,
                Solver SOLVER)
```
    Build an integer variable whose domain is explicitly represented with a BitSet. Its initial domain is {MIN,MIN+1...MAX-1,MAX}
    
    Parameters:
    NAME - name of the variable
    MIN - initial lower bound
    MAX - initial upper bound
    SOLVER - solver involving the variable
    
    Returns:
    an integer variable with an enumerated domain
  - enumeratedArray
```
public static IntVar[] enumeratedArray(String NAME,
                       int SIZE,
                       int MIN,
                       int MAX,
                       Solver SOLVER)
```
    Build an array of integer variables whose domains are explicitly represented
    
    Parameters:
    NAME - name of the variables
    SIZE - number of variables
    MIN - initial lower bound
    MAX - initial upper bound
    SOLVER - solver involving the variable
    
    Returns:
    an array of integer variables with enumerated domains
  - enumeratedMatrix
```
public static IntVar[][] enumeratedMatrix(String NAME,
                          int DIM1,
                          int DIM2,
                          int MIN,
                          int MAX,
                          Solver SOLVER)
```
    Build a DIM1*DIM2-sized matrix of integer variables whose domains are explicitly represented
    
    Parameters:
    NAME - name of the variables
    DIM1 - number of rows
    DIM2 - number of columns
    MIN - initial lower bound
    MAX - initial upper bound
    SOLVER - solver involving the variable
    
    Returns:
    a matrix of integer variables with enumerated domains
  - enumerated
```
public static IntVar enumerated(String NAME,
                int[] VALUES,
                Solver SOLVER)
```
    Build an integer variable whose domain is explicitly represented with a BitSet. Its initial domain is VALUES
    
    Parameters:
    NAME - name of the variable
    VALUES - initial domain
    SOLVER - solver involving the variable
    
    Returns:
    an integer variable with an enumerated domain, initialized to VALUES
  - enumeratedArray
```
public static IntVar[] enumeratedArray(String NAME,
                       int SIZE,
                       int[] VALUES,
                       Solver SOLVER)
```
    Build an integer variable array with enumerated domains. Each domain is initialized to VALUE
    
    Parameters:
    NAME - name of the variables
    SIZE - number of variables
    VALUES - initial domain
    SOLVER - solver involving the variable
    
    Returns:
    an integer variable array with enumerated domains initialized to VALUES
  - enumeratedMatrix
```
public static IntVar[][] enumeratedMatrix(String NAME,
                          int DIM1,
                          int DIM2,
                          int[] VALUES,
                          Solver SOLVER)
```
    Build a DIM1*DIM2-sized matrix of integer variables with enumerated domains. Each domain is initialized to VALUE
    
    Parameters:
    NAME - name of the variables
    DIM1 - number of rows
    DIM2 - number of columns
    VALUES - initial domain
    SOLVER - solver involving the variable
    
    Returns:
    an integer variable matrix with enumerated domains initialized to VALUES
  - real
```
public static RealVar real(String NAME,
           double MIN,
           double MAX,
           double PRECISION,
           Solver SOLVER)
```
    Build a real variable with a bounded domain initialized to [MIN,MAX]
    
    Parameters:
    NAME - name of the variable
    MIN - initial lower bound
    MAX - initial upper bound
    PRECISION - double precision (e.g., 0.00001d)
    SOLVER - solver involving the variable
    
    Returns:
    a real variable with a bounded domain initialized to [MIN,MAX]
  - realArray
```
public static RealVar[] realArray(String NAME,
                  int SIZE,
                  double MIN,
                  double MAX,
                  double PRECISION,
                  Solver SOLVER)
```
    Build a SIZE-sized array of real variables. Each domain is initialized to [MIN,MAX]
    
    Parameters:
    NAME - name of the variables
    SIZE - number of variables
    MIN - initial lower bound
    MAX - initial upper bound
    PRECISION - double precision (e.g., 0.00001d)
    SOLVER - solver involving the variable
    
    Returns:
    a real variable array with bounded domains initialized to [MIN,MAX]
  - realMatrix
```
public static RealVar[][] realMatrix(String NAME,
                     int DIM1,
                     int DIM2,
                     double MIN,
                     double MAX,
                     double PRECISION,
                     Solver SOLVER)
```
    Build a DIM1*DIM2-sized matrix of real variables. Each domain is initialized to [MIN,MAX]
    
    Parameters:
    NAME - name of the variables
    DIM1 - number of rows
    DIM2 - number of columns
    MIN - initial lower bound
    MAX - initial upper bound
    PRECISION - double precision (e.g., 0.00001d)
    SOLVER - solver involving the variable
    
    Returns:
    a real variable matrix with bounded domains initialized to [MIN,MAX]
  - set
```
public static SetVar set(String NAME,
         int[] ENVELOPE,
         SetType ENV_TYPE,
         int[] KERNEL,
         SetType KER_TYPE,
         Solver SOLVER)
```
    Builds a set variable with an initial domain given by ENVELOP and KERNEL.
    
    Parameters:
    NAME - name of the variable
    ENVELOPE - elements potentially in the set
    ENV_TYPE - type of data structure for storing the envelope
    KERNEL - elements that must belong to the final set
    KER_TYPE - type of data structure for storing the kernel
    SOLVER - solver involving the variable
    
    Returns:
    a set variable
  - set
```
public static SetVar set(String NAME,
         int[] ENVELOPE,
         int[] KERNEL,
         Solver SOLVER)
```
    Builds a set variable with an initial domain given by ENVELOP and KERNEL.
    
    Parameters:
    NAME - name of the variable
    ENVELOPE - elements potentially in the set
    KERNEL - elements that must belong to the final set
    SOLVER - solver involving the variable
    
    Returns:
    a set variable
  - set
```
public static SetVar set(String NAME,
         int[] ENVELOPE,
         Solver SOLVER)
```
    Builds a set variable with an initial domain given by ENVELOP and KERNEL.
    
    Parameters:
    NAME - name of the variable
    ENVELOPE - elements potentially in the set
    SOLVER - solver involving the variable
    
    Returns:
    a set variable
  - set
```
public static SetVar set(String NAME,
         int MIN_ELEMENT,
         int MAX_ELEMENT,
         Solver SOLVER)
```
    Builds a set variable with an initial domain given by ENVELOP = [MIN_ELEMENT,MAX_ELEMENT] and an empty KERNEL. Uses a BitSet representation for both the envelope and the kernel
    
    Parameters:
    NAME - name of the variable
    MIN_ELEMENT - lower bound
    MAX_ELEMENT - upper bound
    SOLVER - solver involving the variable
    
    Returns:
    a set variable
  - task
```
public static Task task(IntVar START,
        IntVar DURATION,
        IntVar END)
```
    Build a Task software component (not a variable) which ensures that START + DURATION = END
    
    Parameters:
    START - IntVar representing the start of the task
    DURATION - IntVar representing the duration of the task
    END - IntVar representing the end of the task
    
    Returns:
    A task Object ensuring that START + DURATION = END
  - castToIntVar
```
public static IntVar[] castToIntVar(Variable... VARIABLES)
```
    Casts VARIABLES into an integer variable array
    
    Parameters:
    VARIABLES - variables
    
    Returns:
    an IntVar array containing variables in VARIABLES
  - toMatrix
```
public static IntVar[][] toMatrix(IntVar[] VARS,
                  int DIM1,
                  int DIM2)
```
    Inserts VARS into a new DIM1*DIM2-size matrix: put variable of VARS[i*DIM2+j] into mat[i][j]
    
    Parameters:
    VARS - variables
    DIM1 - number of rows
    DIM2 - number of columns Note that DIM1*DIM2 is supposed to be equal to VARS.length
    
    Returns:
    a matrix representation of VARS
  - fixed
```
public static IntVar fixed(int VALUE,
           Solver SOLVER)
```
    Create a specific integer variable whom domain is reduced to the singleton {VALUE}.
    This API does not require any name, a default one will be assigned to the variable. Furthermore, the object created will be cached, if not already, to avoid creating multiple occurrence of the same "constant" variable.
    If one want to avoid the caching process, the following API should be used: VariableFactory#fixed(String NAME, int VALUE, Solver SOLVER)
    
    Parameters:
    VALUE - the value
    SOLVER - the solver to build the integer variable in.
  - zero
```
public static BoolVar zero(Solver SOLVER)
```
    Retrieve the specific zero/false boolvar.
    
    Parameters:
    SOLVER - the solver to build the integer variable in.
  - one
```
public static BoolVar one(Solver SOLVER)
```
    Retrieve the specific one/true boolvar.
    
    Parameters:
    SOLVER - the solver to build the integer variable in.
  - fixed
```
public static IntVar fixed(String NAME,
           int VALUE,
           Solver SOLVER)
```
    Create a specific integer variable, named NAME whom domain is reduced to the singleton {VALUE}.
    Beware: if the name start with "cste -- ", the resulting variable will be cached.
    
    Parameters:
    NAME - name of the constant
    VALUE - its value
    SOLVER - the solver to build the integer variable in.
  - fixed
```
public static IntVar fixed(boolean VALUE,
           Solver SOLVER)
```
    get a specific boolean variable, whom domain is reduced to the singleton {VALUE}. This variable is unnamed as it is actually a solver constant
    
    Parameters:
    VALUE - its value
    SOLVER - the solver to build the integer variable in.
  - fixed
```
public static SetVar fixed(String NAME,
           int[] VALUE,
           Solver SOLVER)
```
    Create a specific set variable, named NAME whom domain is reduced to the singleton {VALUE}.
    
    Parameters:
    NAME - name of the constant
    VALUE - its value, a set of integers (duplicates will be removed)
    SOLVER - the solver to build the integer variable in.
  - offset
```
public static IntVar offset(IntVar VAR,
            int CSTE)
```
    Create an offset view based on VAR, such that, the resulting view is defined on VAR + CSTE.
    The resulting IntVar does not have explicit domain: it relies on the domain of VAR for reading and writing operations. Any operations on this will transformed to operations on VAR following the offset rules.
    
    Parameters:
    VAR - an integer variable
    CSTE - a constant
  - eq
```
public static IntVar eq(IntVar VAR)
```
    Create a kind of clone of VAR (an offset view with CSTE= 0), such that, the resulting view is defined on VAR.
    The resulting IntVar does not have explicit domain: it relies on the domain of VAR for reading and writing operations. Any operations on this will transformed to operations on VAR following the offset rules.
    
    Parameters:
    VAR - an integer variable
  - eq
```
public static BoolVar eq(BoolVar VAR)
```
    Create a kind of clone of VAR such that, the resulting view is defined on VAR.
    The resulting BoolVar does not have explicit domain: it relies on the domain of VAR for reading and writing operations. Any operations on this will transformed to operations on VAR.
    
    Parameters:
    VAR - an integer variable
  - not
```
public static BoolVar not(BoolVar BOOL)
```
    Create a view over BOOL holding the logical negation of BOOL (ie, ¬BOOL).
    The resulting BoolVar does not have explicit domain: it relies on the domain of BOOL for reading and writing operations. Any operations on this will transformed to operations on VAR following the "not" rules.
    
    Parameters:
    BOOL - a boolean variable.
  - minus
```
public static IntVar minus(IntVar VAR)
```
    Create a view over VAR holding : −VAR. That is if VAR = [a,b], then this = [-b,-a].
    The resulting IntVar does not have explicit domain: it relies on the domain of VAR for reading and writing operations. Any operations on this will transformed to operations on VAR following the "minus" rules.
    
    Parameters:
    VAR - an integer variable
  - scale
```
public static IntVar scale(IntVar VAR,
           int CSTE)
```
    Create a view over VAR such that: VAR×CSTE (CSTE>-2).
    
    - if CSTE < -1, throws an exception;
    - if CSTE = -1, returns a minus view;
    - if CSTE = 0, returns a fixed variable;
    - if CSTE = 1, returns VAR;
    - otherwise, returns a scale view;
    The resulting IntVar does not have explicit domain: it relies on the domain of VAR for reading and writing operations. Any operations on this will transformed to operations on VAR following the "scale" rules.
    
    Parameters:
    VAR - an integer variable
    CSTE - a constant.
  - abs
```
public static IntVar abs(IntVar VAR)
```
    Create a view over VAR such that: |VAR|.
    
    - if VAR is already instantiated, returns a fixed variable;
    - if the lower bound of VAR is greater or equal to 0, returns VAR;
    - if the upper bound of VAR is less or equal to 0, return a minus view;
    - otherwise, returns an absolute view;
    The resulting IntVar does not have explicit domain: it relies on the domain of VAR for reading and writing operations. Any operations on this will transformed to operations on VAR following the "absolute" rules.
    
    Parameters:
    VAR - an integer variable.
  - real
```
public static RealVar real(IntVar VAR,
           double PRECISION)
```
    Create a real variable based on an integer variable VAR. The PRECISION is used to evaluate when the view is instantiated, that is, when the size of the domain of the view is strictly less than PRECISION.
    
    Parameters:
    VAR - an integer variable
    PRECISION - used to evaluate the instantiation of the view.
  - real
```
public static RealVar[] real(IntVar[] VARS,
             double PRECISION)
```
    Create an array of real variables based on an array of integer variables VAR. The PRECISION is used to evaluate when the view is instantiated, that is, when the size of the domain of the view is strictly less than PRECISION.
    
    Parameters:
    VARS - array of integer variables
    PRECISION - used to evaluate the instantiation of each view.
    
    Returns:
    array of RealVar

Class VariableFactory

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MIN_INT_BOUND

MAX_INT_BOUND

Method Detail

bool

boolArray

boolMatrix

integer

integerArray

integerMatrix

bounded

boundedArray

boundedMatrix

enumerated

enumeratedArray

enumeratedMatrix

enumerated

enumeratedArray

enumeratedMatrix

real

realArray

realMatrix

set

set

set

set

task

castToIntVar

toMatrix

fixed

zero

one

fixed

fixed

fixed

offset

eq

eq

not

minus

scale

abs

real

real