CpModel (com.google.ortools:ortools-java 9.12.9999 API)

java.lang.Object
- com.google.ortools.sat.CpModel

```
public final class CpModel
extends java.lang.Object
```
Main modeling class.
Proposes a factory to create all modeling objects understood by the SAT solver.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`CpModel.MismatchedArrayLengths` Exception thrown when parallel arrays have mismatched lengths.
`static class`	`CpModel.WrongLength` Exception thrown when an array has a wrong length.

Constructor Summary

Constructors
Constructor and Description

CpModel()

Constructors
Constructor and Description
`CpModel()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Constraint`	`addAbsEquality(LinearArgument target, LinearArgument expr)` Adds `target == Abs(expr)`.
`Constraint`	`addAllDifferent(java.lang.Iterable<? extends LinearArgument> expressions)` Adds `AllDifferent(expressions)`.
`Constraint`	`addAllDifferent(LinearArgument[] expressions)` Adds `AllDifferent(expressions)`.
`TableConstraint`	`addAllowedAssignments(java.lang.Iterable<? extends LinearArgument> expressions)` Adds `AllowedAssignments(expressions)`.
`TableConstraint`	`addAllowedAssignments(LinearArgument[] expressions)` Adds `AllowedAssignments(expressions)`.
`void`	`addAssumption(Literal lit)` Adds a literal to the model as assumption
`void`	`addAssumptions(Literal[] literals)` Adds multiple literals to the model as assumptions
`Constraint`	`addAtLeastOne(java.lang.Iterable<Literal> literals)` Same as addBoolOr.
`Constraint`	`addAtLeastOne(Literal[] literals)` Same as addBoolOr.
`Constraint`	`addAtMostOne(java.lang.Iterable<Literal> literals)` Adds `AtMostOne(literals): Sum(literals) <= 1`.
`Constraint`	`addAtMostOne(Literal[] literals)` Adds `AtMostOne(literals): Sum(literals) <= 1`.
`AutomatonConstraint`	`addAutomaton(java.lang.Iterable<? extends LinearArgument> transitionExpressions, long startingState, long[] finalStates)` Adds an automaton constraint.
`AutomatonConstraint`	`addAutomaton(LinearArgument[] transitionExpressions, long startingState, long[] finalStates)` Adds an automaton constraint.
`Constraint`	`addBoolAnd(java.lang.Iterable<Literal> literals)` Adds `And(literals) == true`.
`Constraint`	`addBoolAnd(Literal[] literals)` Adds `And(literals) == true`.
`Constraint`	`addBoolOr(java.lang.Iterable<Literal> literals)` Adds `Or(literals) == true`.
`Constraint`	`addBoolOr(Literal[] literals)` Adds `Or(literals) == true`.
`Constraint`	`addBoolXor(java.lang.Iterable<Literal> literals)` Adds `XOr(literals) == true`.
`Constraint`	`addBoolXor(Literal[] literals)` Adds `XOr(literals) == true`.
`CircuitConstraint`	`addCircuit()` Adds `Circuit()`.
`CumulativeConstraint`	`addCumulative(LinearArgument capacity)` Adds `Cumulative(capacity)`.
`CumulativeConstraint`	`addCumulative(long capacity)` Adds `Cumulative(capacity)`.
`void`	`addDecisionStrategy(java.lang.Iterable<? extends LinearArgument> expressions, DecisionStrategyProto.VariableSelectionStrategy varStr, DecisionStrategyProto.DomainReductionStrategy domStr)` Adds `DecisionStrategy(expressions, varStr, domStr)`.
`void`	`addDecisionStrategy(LinearArgument[] expressions, DecisionStrategyProto.VariableSelectionStrategy varStr, DecisionStrategyProto.DomainReductionStrategy domStr)` Adds `DecisionStrategy(expressions, varStr, domStr)`.
`Constraint`	`addDifferent(LinearArgument left, LinearArgument right)` Adds {@code left !
`Constraint`	`addDifferent(LinearArgument expr, long value)` Adds {@code expr !
`Constraint`	`addDivisionEquality(LinearArgument target, LinearArgument num, LinearArgument denom)` Adds `target == num / denom`, rounded towards 0.
`Constraint`	`addElement(LinearArgument index, int[] values, LinearArgument target)` Adds the element constraint: `values[index] == target`.
`Constraint`	`addElement(LinearArgument index, java.lang.Iterable<? extends LinearArgument> expressions, LinearArgument target)` Adds the element constraint: `expressions[index] == target`.
`Constraint`	`addElement(LinearArgument index, LinearArgument[] expressions, LinearArgument target)` Adds the element constraint: `expressions[index] == target`.
`Constraint`	`addElement(LinearArgument index, long[] values, LinearArgument target)` Adds the element constraint: `values[index] == target`.
`Constraint`	`addEquality(LinearArgument left, LinearArgument right)` Adds `left == right`.
`Constraint`	`addEquality(LinearArgument expr, long value)` Adds `expr == value`.
`Constraint`	`addExactlyOne(java.lang.Iterable<Literal> literals)` Adds `ExactlyOne(literals): Sum(literals) == 1`.
`Constraint`	`addExactlyOne(Literal[] literals)` Adds `ExactlyOne(literals): Sum(literals) == 1`.
`TableConstraint`	`addForbiddenAssignments(java.lang.Iterable<? extends LinearArgument> expressions)` Adds `ForbiddenAssignments(expressions)`.
`TableConstraint`	`addForbiddenAssignments(LinearArgument[] expressions)` Adds `ForbiddenAssignments(expressions)`.
`Constraint`	`addGreaterOrEqual(LinearArgument left, LinearArgument right)` Adds `left >= right`.
`Constraint`	`addGreaterOrEqual(LinearArgument expr, long value)` Adds `expr >= value`.
`Constraint`	`addGreaterThan(LinearArgument left, LinearArgument right)` Adds `left > right`.
`Constraint`	`addGreaterThan(LinearArgument expr, long value)` Adds `expr > value`.
`void`	`addHint(IntVar var, long value)` Adds hinting to a variable
`void`	`addHint(Literal lit, boolean value)` Adds hinting to a literal
`Constraint`	`addImplication(Literal a, Literal b)` Adds `a => b`.
`Constraint`	`addInverse(IntVar[] variables, IntVar[] inverseVariables)` Adds `Inverse(variables, inverseVariables)`.
`Constraint`	`addLessOrEqual(LinearArgument left, LinearArgument right)` Adds `left <= right`.
`Constraint`	`addLessOrEqual(LinearArgument expr, long value)` Adds `expr <= value`.
`Constraint`	`addLessThan(LinearArgument left, LinearArgument right)` Adds `left < right`.
`Constraint`	`addLessThan(LinearArgument expr, long value)` Adds `expr < value`.
`Constraint`	`addLinearConstraint(LinearArgument expr, long lb, long ub)` Adds `lb <= expr <= ub`.
`Constraint`	`addLinearExpressionInDomain(LinearArgument expr, Domain domain)` Adds `expr in domain`.
`void`	`addMapDomain(IntVar var, Literal[] booleans, long offset)` Adds `var == i + offset <=> booleans[i] == true for all i in [0, booleans.length)`.
`Constraint`	`addMaxEquality(LinearArgument target, java.lang.Iterable<? extends LinearArgument> exprs)` Adds `target == Max(exprs)`.
`Constraint`	`addMaxEquality(LinearArgument target, LinearArgument[] exprs)` Adds `target == Max(vars)`.
`Constraint`	`addMinEquality(LinearArgument target, java.lang.Iterable<? extends LinearArgument> exprs)` Adds `target == Min(exprs)`.
`Constraint`	`addMinEquality(LinearArgument target, LinearArgument[] exprs)` Adds `target == Min(vars)`.
`Constraint`	`addModuloEquality(LinearArgument target, LinearArgument var, LinearArgument mod)` Adds `target == var % mod`.
`Constraint`	`addModuloEquality(LinearArgument target, LinearArgument var, long mod)` Adds `target == var % mod`.
`MultipleCircuitConstraint`	`addMultipleCircuit()` Adds `MultipleCircuit()`.
`Constraint`	`addMultiplicationEquality(LinearArgument target, LinearArgument[] exprs)` Adds `target == Product(exprs)`.
`Constraint`	`addMultiplicationEquality(LinearArgument target, LinearArgument left, LinearArgument right)` Adds `target == left * right`.
`Constraint`	`addNoOverlap(IntervalVar[] intervalVars)` Adds `NoOverlap(intervalVars)`.
`Constraint`	`addNoOverlap(java.lang.Iterable<IntervalVar> intervalVars)` Adds `NoOverlap(intervalVars)`.
`NoOverlap2dConstraint`	`addNoOverlap2D()` Adds `NoOverlap2D(xIntervals, yIntervals)`.
`ReservoirConstraint`	`addReservoirConstraint(long minLevel, long maxLevel)` Adds a reservoir constraint with optional refill/emptying events.
`void`	`clearAssumptions()` Remove all assumptions from the model
`void`	`clearHints()` Remove all solution hints
`void`	`clearObjective()` Clears the objective.
`java.lang.Boolean`	`exportToFile(java.lang.String file)` Write the model as a protocol buffer to 'file'.
`Literal`	`falseLiteral()` Returns the false literal.
`BoolVar`	`getBoolVarFromProtoIndex(int index)` Rebuilds a Boolean variable from an index.
`CpModelProto.Builder`	`getBuilder()` Returns the model builder.
`CpModel`	`getClone()`
`IntVar`	`getIntVarFromProtoIndex(int index)` Rebuilds an integer variable from an index.
`boolean`	`hasObjective()` Checks if the model contains an objective.
`boolean`	`isPositive(Literal lit)`
`void`	`maximize(DoubleLinearExpr expr)` Adds a maximization objective of a linear expression.
`void`	`maximize(LinearArgument expr)` Adds a maximization objective of a linear expression.
`void`	`minimize(DoubleLinearExpr expr)` Adds a minimization objective of a linear expression.
`void`	`minimize(LinearArgument expr)` Adds a minimization objective of a linear expression.
`CpModelProto`	`model()`
`java.lang.String`	`modelStats()` Returns some statistics on model as a string.
`int`	`negated(int index)`
`BoolVar`	`newBoolVar(java.lang.String name)` Creates a Boolean variable with the given name.
`IntVar`	`newConstant(long value)` Creates a constant variable.
`IntervalVar`	`newFixedInterval(long start, long size, java.lang.String name)` Creates a fixed interval from its start and its size.
`IntervalVar`	`newFixedSizeIntervalVar(LinearArgument start, long size, java.lang.String name)` Creates an interval variable from an affine expression start, and a fixed size.
`IntervalVar`	`newIntervalVar(LinearArgument start, LinearArgument size, LinearArgument end, java.lang.String name)` Creates an interval variable from three affine expressions start, size, and end.
`IntVar`	`newIntVar(long lb, long ub, java.lang.String name)` Creates an integer variable with domain [lb, ub].
`IntVar`	`newIntVarFromDomain(Domain domain, java.lang.String name)` Creates an integer variable with given domain.
`IntervalVar`	`newOptionalFixedInterval(long start, long size, Literal isPresent, java.lang.String name)` Creates an optional fixed interval from start and size, and an isPresent literal.
`IntervalVar`	`newOptionalFixedSizeIntervalVar(LinearArgument start, long size, Literal isPresent, java.lang.String name)` Creates an optional interval variable from an affine expression start, and a fixed size.
`IntervalVar`	`newOptionalIntervalVar(LinearArgument start, LinearArgument size, LinearArgument end, Literal isPresent, java.lang.String name)` Creates an optional interval variable from three affine expressions start, size, end, and isPresent.
`Literal`	`trueLiteral()` Returns the true literal.
`java.lang.String`	`validate()` Returns a non empty string explaining the issue if the model is invalid.

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

- Constructor Detail
  - CpModel
```
public CpModel()
```
- Method Detail
  - getClone
```
public CpModel getClone()
```
  - newIntVar
```
public IntVar newIntVar(long lb,
                        long ub,
                        java.lang.String name)
```
    Creates an integer variable with domain [lb, ub].
  - newIntVarFromDomain
```
public IntVar newIntVarFromDomain(Domain domain,
                                  java.lang.String name)
```
    Creates an integer variable with given domain.
    
    Parameters:
    
    domain - an instance of the Domain class.
    
    name - the name of the variable
    
    Returns:
    
    a variable with the given domain.
  - newBoolVar
```
public BoolVar newBoolVar(java.lang.String name)
```
    Creates a Boolean variable with the given name.
  - newConstant
```
public IntVar newConstant(long value)
```
    Creates a constant variable.
  - trueLiteral
```
public Literal trueLiteral()
```
    Returns the true literal.
  - falseLiteral
```
public Literal falseLiteral()
```
    Returns the false literal.
  - getBoolVarFromProtoIndex
```
public BoolVar getBoolVarFromProtoIndex(int index)
```
    Rebuilds a Boolean variable from an index. Useful after cloning a model.
  - getIntVarFromProtoIndex
```
public IntVar getIntVarFromProtoIndex(int index)
```
    Rebuilds an integer variable from an index. Useful after cloning a model.
  - addBoolOr
```
public Constraint addBoolOr(Literal[] literals)
```
    Adds Or(literals) == true.
  - addBoolOr
```
public Constraint addBoolOr(java.lang.Iterable<Literal> literals)
```
    Adds Or(literals) == true.
  - addAtLeastOne
```
public Constraint addAtLeastOne(Literal[] literals)
```
    Same as addBoolOr. Sum(literals) >= 1.
  - addAtLeastOne
```
public Constraint addAtLeastOne(java.lang.Iterable<Literal> literals)
```
    Same as addBoolOr. Sum(literals) >= 1.
  - addAtMostOne
```
public Constraint addAtMostOne(Literal[] literals)
```
    Adds AtMostOne(literals): Sum(literals) <= 1.
  - addAtMostOne
```
public Constraint addAtMostOne(java.lang.Iterable<Literal> literals)
```
    Adds AtMostOne(literals): Sum(literals) <= 1.
  - addExactlyOne
```
public Constraint addExactlyOne(Literal[] literals)
```
    Adds ExactlyOne(literals): Sum(literals) == 1.
  - addExactlyOne
```
public Constraint addExactlyOne(java.lang.Iterable<Literal> literals)
```
    Adds ExactlyOne(literals): Sum(literals) == 1.
  - addBoolAnd
```
public Constraint addBoolAnd(Literal[] literals)
```
    Adds And(literals) == true.
  - addBoolAnd
```
public Constraint addBoolAnd(java.lang.Iterable<Literal> literals)
```
    Adds And(literals) == true.
  - addBoolXor
```
public Constraint addBoolXor(Literal[] literals)
```
    Adds XOr(literals) == true.
  - addBoolXor
```
public Constraint addBoolXor(java.lang.Iterable<Literal> literals)
```
    Adds XOr(literals) == true.
  - addImplication
```
public Constraint addImplication(Literal a,
                                 Literal b)
```
    Adds a => b.
  - addLinearExpressionInDomain
```
public Constraint addLinearExpressionInDomain(LinearArgument expr,
                                              Domain domain)
```
    Adds expr in domain.
  - addLinearConstraint
```
public Constraint addLinearConstraint(LinearArgument expr,
                                      long lb,
                                      long ub)
```
    Adds lb <= expr <= ub.
  - addEquality
```
public Constraint addEquality(LinearArgument expr,
                              long value)
```
    Adds expr == value.
  - addEquality
```
public Constraint addEquality(LinearArgument left,
                              LinearArgument right)
```
    Adds left == right.
  - addLessOrEqual
```
public Constraint addLessOrEqual(LinearArgument expr,
                                 long value)
```
    Adds expr <= value.
  - addLessOrEqual
```
public Constraint addLessOrEqual(LinearArgument left,
                                 LinearArgument right)
```
    Adds left <= right.
  - addLessThan
```
public Constraint addLessThan(LinearArgument expr,
                              long value)
```
    Adds expr < value.
  - addLessThan
```
public Constraint addLessThan(LinearArgument left,
                              LinearArgument right)
```
    Adds left < right.
  - addGreaterOrEqual
```
public Constraint addGreaterOrEqual(LinearArgument expr,
                                    long value)
```
    Adds expr >= value.
  - addGreaterOrEqual
```
public Constraint addGreaterOrEqual(LinearArgument left,
                                    LinearArgument right)
```
    Adds left >= right.
  - addGreaterThan
```
public Constraint addGreaterThan(LinearArgument expr,
                                 long value)
```
    Adds expr > value.
  - addGreaterThan
```
public Constraint addGreaterThan(LinearArgument left,
                                 LinearArgument right)
```
    Adds left > right.
  - addDifferent
```
public Constraint addDifferent(LinearArgument expr,
                               long value)
```
    Adds expr != value.
  - addDifferent
```
public Constraint addDifferent(LinearArgument left,
                               LinearArgument right)
```
    Adds left != right.
  - addAllDifferent
```
public Constraint addAllDifferent(LinearArgument[] expressions)
```
    Adds AllDifferent(expressions).
    This constraint forces all affine expressions to have different values.
    
    Parameters:
    
    expressions - a list of affine integer expressions
    
    Returns:
    
    an instance of the Constraint class
  - addAllDifferent
```
public Constraint addAllDifferent(java.lang.Iterable<? extends LinearArgument> expressions)
```
    Adds AllDifferent(expressions).
    
    See Also:
    
    addAllDifferent(LinearArgument[]).
  - addElement
```
public Constraint addElement(LinearArgument index,
                             LinearArgument[] expressions,
                             LinearArgument target)
```
    Adds the element constraint: expressions[index] == target.
  - addElement
```
public Constraint addElement(LinearArgument index,
                             java.lang.Iterable<? extends LinearArgument> expressions,
                             LinearArgument target)
```
    Adds the element constraint: expressions[index] == target.
  - addElement
```
public Constraint addElement(LinearArgument index,
                             long[] values,
                             LinearArgument target)
```
    Adds the element constraint: values[index] == target.
  - addElement
```
public Constraint addElement(LinearArgument index,
                             int[] values,
                             LinearArgument target)
```
    Adds the element constraint: values[index] == target.
  - addCircuit
```
public CircuitConstraint addCircuit()
```
    Adds Circuit().
    Adds an empty circuit constraint.
    A circuit is a unique Hamiltonian cycle in a subgraph of the total graph. In case a node 'i' is not in the cycle, then there must be a loop arc 'i -> i' associated with a true literal. Otherwise this constraint will fail.
  - addMultipleCircuit
```
public MultipleCircuitConstraint addMultipleCircuit()
```
    Adds MultipleCircuit().
    Adds an empty multiple circuit constraint.
    A multiple circuit is set of cycles in a subgraph of the total graph. The node index by 0 must be part of all cycles of length > 1. Each node with index > 0 belongs to exactly one cycle. If such node does not belong in any cycle of length > 1, then there must be a looping arc on this node attached to a literal that will be true. Otherwise, the constraint will fail.
  - addAllowedAssignments
```
public TableConstraint addAllowedAssignments(LinearArgument[] expressions)
```
    Adds AllowedAssignments(expressions).
    An AllowedAssignments constraint is a constraint on an array of affine expressions that forces, when all expressions are fixed to a single value, that the corresponding list of values is equal to one of the tuples of the tupleList.
    
    Parameters:
    
    expressions - a list of affine expressions (a * var + b)
    
    Returns:
    
    an instance of the TableConstraint class without any tuples. Tuples can be added directly to the table constraint.
  - addAllowedAssignments
```
public TableConstraint addAllowedAssignments(java.lang.Iterable<? extends LinearArgument> expressions)
```
    Adds AllowedAssignments(expressions).
    
    See Also:
    
    addAllowedAssignments(LinearArgument[] expressions)
  - addForbiddenAssignments
```
public TableConstraint addForbiddenAssignments(LinearArgument[] expressions)
```
    Adds ForbiddenAssignments(expressions).
    A ForbiddenAssignments constraint is a constraint on an array of affine expressions where the list of impossible combinations is provided in the tuples list.
    
    Parameters:
    
    expressions - a list of affine expressions (a * var + b)
    
    Returns:
    
    an instance of the TableConstraint class without any tuples. Tuples can be added directly to the table constraint.
  - addForbiddenAssignments
```
public TableConstraint addForbiddenAssignments(java.lang.Iterable<? extends LinearArgument> expressions)
```
    Adds ForbiddenAssignments(expressions).
    
    See Also:
    
    addForbiddenAssignments(LinearArgument[] expressions)
  - addAutomaton
```
public AutomatonConstraint addAutomaton(LinearArgument[] transitionExpressions,
                                        long startingState,
                                        long[] finalStates)
```
    Adds an automaton constraint.
    An automaton constraint takes a list of affine expressions (of size n), an initial state, a set of final states, and a set of transitions that will be added incrementally directly on the returned AutomatonConstraint instance. A transition is a triplet ('tail', 'transition', 'head'), where 'tail' and 'head' are states, and 'transition' is the label of an arc from 'head' to 'tail', corresponding to the value of one expression in the list of expressions.
    This automaton will be unrolled into a flow with n + 1 phases. Each phase contains the possible states of the automaton. The first state contains the initial state. The last phase contains the final states.
    Between two consecutive phases i and i + 1, the automaton creates a set of arcs. For each transition (tail, label, head), it will add an arc from the state 'tail' of phase i and the state 'head' of phase i + 1. This arc labeled by the value 'label' of the expression 'expressions[i]'. That is, this arc can only be selected if 'expressions[i]' is assigned the value 'label'.
    A feasible solution of this constraint is an assignment of expressions such that, starting from the initial state in phase 0, there is a path labeled by the values of the expressions that ends in one of the final states in the final phase.
    
    Parameters:
    
    transitionExpressions - a non empty list of affine expressions (a * var + b) whose values correspond to the labels of the arcs traversed by the automaton
    
    startingState - the initial state of the automaton
    
    finalStates - a non empty list of admissible final states
    
    Returns:
    
    an instance of the Constraint class
  - addAutomaton
```
public AutomatonConstraint addAutomaton(java.lang.Iterable<? extends LinearArgument> transitionExpressions,
                                        long startingState,
                                        long[] finalStates)
```
    Adds an automaton constraint.
    
    See Also:
    
    addAutomaton(LinearArgument[] transitionExpressions, long startingState, long[] finalStates)
  - addInverse
```
public Constraint addInverse(IntVar[] variables,
                             IntVar[] inverseVariables)
```
    Adds Inverse(variables, inverseVariables).
    An inverse constraint enforces that if 'variables[i]' is assigned a value 'j', then inverseVariables[j] is assigned a value 'i'. And vice versa.
    
    Parameters:
    
    variables - an array of integer variables
    
    inverseVariables - an array of integer variables
    
    Returns:
    
    an instance of the Constraint class
    
    Throws:
    
    CpModel.MismatchedArrayLengths - if variables and inverseVariables have different length
  - addReservoirConstraint
```
public ReservoirConstraint addReservoirConstraint(long minLevel,
                                                  long maxLevel)
```
    Adds a reservoir constraint with optional refill/emptying events.
    Maintain a reservoir level within bounds. The water level starts at 0, and at any time, it must be within [min_level, max_level].
    Given an event (time, levelChange, active), if active is true, and if time is assigned a value t, then the level of the reservoir changes by levelChange (which is constant) at time t. Therefore, at any time t:
    sum(levelChanges[i] * actives[i] if times[i] <= t) in [min_level, max_level]
    Note that min level must be <= 0, and the max level must be >= 0. Please use fixed level_changes to simulate an initial state.
    
    Parameters:
    
    minLevel - at any time, the level of the reservoir must be greater of equal than the min level. minLevel must me <= 0.
    
    maxLevel - at any time, the level of the reservoir must be less or equal than the max level. maxLevel must be >= 0.
    
    Returns:
    
    an instance of the ReservoirConstraint class
    
    Throws:
    
    java.lang.IllegalArgumentException - if minLevel > 0
    
    java.lang.IllegalArgumentException - if maxLevel < 0
  - addMapDomain
```
public void addMapDomain(IntVar var,
                         Literal[] booleans,
                         long offset)
```
    Adds var == i + offset <=> booleans[i] == true for all i in [0, booleans.length).
  - addMinEquality
```
public Constraint addMinEquality(LinearArgument target,
                                 LinearArgument[] exprs)
```
    Adds target == Min(vars).
  - addMinEquality
```
public Constraint addMinEquality(LinearArgument target,
                                 java.lang.Iterable<? extends LinearArgument> exprs)
```
    Adds target == Min(exprs).
  - addMaxEquality
```
public Constraint addMaxEquality(LinearArgument target,
                                 LinearArgument[] exprs)
```
    Adds target == Max(vars).
  - addMaxEquality
```
public Constraint addMaxEquality(LinearArgument target,
                                 java.lang.Iterable<? extends LinearArgument> exprs)
```
    Adds target == Max(exprs).
  - addDivisionEquality
```
public Constraint addDivisionEquality(LinearArgument target,
                                      LinearArgument num,
                                      LinearArgument denom)
```
    Adds target == num / denom, rounded towards 0.
  - addAbsEquality
```
public Constraint addAbsEquality(LinearArgument target,
                                 LinearArgument expr)
```
    Adds target == Abs(expr).
  - addModuloEquality
```
public Constraint addModuloEquality(LinearArgument target,
                                    LinearArgument var,
                                    LinearArgument mod)
```
    Adds target == var % mod.
  - addModuloEquality
```
public Constraint addModuloEquality(LinearArgument target,
                                    LinearArgument var,
                                    long mod)
```
    Adds target == var % mod.
  - addMultiplicationEquality
```
public Constraint addMultiplicationEquality(LinearArgument target,
                                            LinearArgument[] exprs)
```
    Adds target == Product(exprs).
  - addMultiplicationEquality
```
public Constraint addMultiplicationEquality(LinearArgument target,
                                            LinearArgument left,
                                            LinearArgument right)
```
    Adds target == left * right.
  - newIntervalVar
```
public IntervalVar newIntervalVar(LinearArgument start,
                                  LinearArgument size,
                                  LinearArgument end,
                                  java.lang.String name)
```
    Creates an interval variable from three affine expressions start, size, and end.
    An interval variable is a constraint, that is itself used in other constraints like NoOverlap.
    Internally, it ensures that start + size == end.
    
    Parameters:
    
    start - the start of the interval. It needs to be an affine or constant expression.
    
    size - the size of the interval. It needs to be an affine or constant expression.
    
    end - the end of the interval. It needs to be an affine or constant expression.
    
    name - the name of the interval variable
    
    Returns:
    
    An IntervalVar object
  - newFixedSizeIntervalVar
```
public IntervalVar newFixedSizeIntervalVar(LinearArgument start,
                                           long size,
                                           java.lang.String name)
```
    Creates an interval variable from an affine expression start, and a fixed size.
    An interval variable is a constraint, that is itself used in other constraints like NoOverlap.
    
    Parameters:
    
    start - the start of the interval. It needs to be an affine or constant expression.
    
    size - the fixed size of the interval.
    
    name - the name of the interval variable.
    
    Returns:
    
    An IntervalVar object
  - newFixedInterval
```
public IntervalVar newFixedInterval(long start,
                                    long size,
                                    java.lang.String name)
```
    Creates a fixed interval from its start and its size.
  - newOptionalIntervalVar
```
public IntervalVar newOptionalIntervalVar(LinearArgument start,
                                          LinearArgument size,
                                          LinearArgument end,
                                          Literal isPresent,
                                          java.lang.String name)
```
    Creates an optional interval variable from three affine expressions start, size, end, and isPresent.
    An optional interval variable is a constraint, that is itself used in other constraints like NoOverlap. This constraint is protected by an isPresent literal that indicates if it is active or not.
    Internally, it ensures that isPresent => start + size == end.
    
    Parameters:
    
    start - the start of the interval. It needs to be an affine or constant expression.
    
    size - the size of the interval. It needs to be an affine or constant expression.
    
    end - the end of the interval. It needs to be an affine or constant expression.
    
    isPresent - a literal that indicates if the interval is active or not. A inactive interval is simply ignored by all constraints.
    
    name - The name of the interval variable
    
    Returns:
    
    an IntervalVar object
  - newOptionalFixedSizeIntervalVar
```
public IntervalVar newOptionalFixedSizeIntervalVar(LinearArgument start,
                                                   long size,
                                                   Literal isPresent,
                                                   java.lang.String name)
```
    Creates an optional interval variable from an affine expression start, and a fixed size.
    An interval variable is a constraint, that is itself used in other constraints like NoOverlap.
    
    Parameters:
    
    start - the start of the interval. It needs to be an affine or constant expression.
    
    size - the fixed size of the interval.
    
    isPresent - a literal that indicates if the interval is active or not. A inactive interval is simply ignored by all constraints.
    
    name - the name of the interval variable.
    
    Returns:
    
    An IntervalVar object
  - newOptionalFixedInterval
```
public IntervalVar newOptionalFixedInterval(long start,
                                            long size,
                                            Literal isPresent,
                                            java.lang.String name)
```
    Creates an optional fixed interval from start and size, and an isPresent literal.
  - addNoOverlap
```
public Constraint addNoOverlap(IntervalVar[] intervalVars)
```
    Adds NoOverlap(intervalVars).
    A NoOverlap constraint ensures that all present intervals do not overlap in time.
    
    Parameters:
    
    intervalVars - the list of interval variables to constrain
    
    Returns:
    
    an instance of the Constraint class
  - addNoOverlap
```
public Constraint addNoOverlap(java.lang.Iterable<IntervalVar> intervalVars)
```
    Adds NoOverlap(intervalVars).
    
    See Also:
    
    addNoOverlap(IntervalVar[]).
  - addNoOverlap2D
```
public NoOverlap2dConstraint addNoOverlap2D()
```
    Adds NoOverlap2D(xIntervals, yIntervals).
    A NoOverlap2D constraint ensures that all present rectangles do not overlap on a plan. Each rectangle is aligned with the X and Y axis, and is defined by two intervals which represent its projection onto the X and Y axis.
    Furthermore, one box is optional if at least one of the x or y interval is optional.
    
    Returns:
    
    an instance of the NoOverlap2dConstraint class. This class allows adding rectangles incrementally.
  - addCumulative
```
public CumulativeConstraint addCumulative(LinearArgument capacity)
```
    Adds Cumulative(capacity).
    This constraint enforces that:
    forall t: sum(demands[i] if (start(intervals[t]) <= t < end(intervals[t])) and (t is present)) <= capacity.
    
    Parameters:
    
    capacity - the maximum capacity of the cumulative constraint. It must be a positive affine expression.
    
    Returns:
    
    an instance of the CumulativeConstraint class. this class allows adding (interval, demand) pairs incrementally.
  - addCumulative
```
public CumulativeConstraint addCumulative(long capacity)
```
    Adds Cumulative(capacity).
    
    See Also:
    
    addCumulative(LinearArgument capacity)
  - addHint
```
public void addHint(IntVar var,
                    long value)
```
    Adds hinting to a variable
  - addHint
```
public void addHint(Literal lit,
                    boolean value)
```
    Adds hinting to a literal
  - clearHints
```
public void clearHints()
```
    Remove all solution hints
  - addAssumption
```
public void addAssumption(Literal lit)
```
    Adds a literal to the model as assumption
  - addAssumptions
```
public void addAssumptions(Literal[] literals)
```
    Adds multiple literals to the model as assumptions
  - clearAssumptions
```
public void clearAssumptions()
```
    Remove all assumptions from the model
  - minimize
```
public void minimize(LinearArgument expr)
```
    Adds a minimization objective of a linear expression.
  - minimize
```
public void minimize(DoubleLinearExpr expr)
```
    Adds a minimization objective of a linear expression.
  - maximize
```
public void maximize(LinearArgument expr)
```
    Adds a maximization objective of a linear expression.
  - maximize
```
public void maximize(DoubleLinearExpr expr)
```
    Adds a maximization objective of a linear expression.
  - clearObjective
```
public void clearObjective()
```
    Clears the objective.
  - hasObjective
```
public boolean hasObjective()
```
    Checks if the model contains an objective.
  - addDecisionStrategy
```
public void addDecisionStrategy(LinearArgument[] expressions,
                                DecisionStrategyProto.VariableSelectionStrategy varStr,
                                DecisionStrategyProto.DomainReductionStrategy domStr)
```
    Adds DecisionStrategy(expressions, varStr, domStr).
  - addDecisionStrategy
```
public void addDecisionStrategy(java.lang.Iterable<? extends LinearArgument> expressions,
                                DecisionStrategyProto.VariableSelectionStrategy varStr,
                                DecisionStrategyProto.DomainReductionStrategy domStr)
```
    Adds DecisionStrategy(expressions, varStr, domStr).
  - modelStats
```
public java.lang.String modelStats()
```
    Returns some statistics on model as a string.
  - validate
```
public java.lang.String validate()
```
    Returns a non empty string explaining the issue if the model is invalid.
  - exportToFile
```
public java.lang.Boolean exportToFile(java.lang.String file)
```
    Write the model as a protocol buffer to 'file'.
    
    Parameters:
    
    file - file to write the model to. If the filename ends with 'txt', the model will be written as a text file, otherwise, the binary format will be used.
    
    Returns:
    
    true if the model was correctly written.
  - model
```
public CpModelProto model()
```
  - negated
```
public int negated(int index)
```
  - isPositive
```
public boolean isPositive(Literal lit)
```
  - getBuilder
```
public CpModelProto.Builder getBuilder()
```
    Returns the model builder.

Class CpModel

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

CpModel

Method Detail

getClone

newIntVar

newIntVarFromDomain

newBoolVar

newConstant

trueLiteral

falseLiteral

getBoolVarFromProtoIndex

getIntVarFromProtoIndex

addBoolOr

addBoolOr

addAtLeastOne

addAtLeastOne

addAtMostOne

addAtMostOne

addExactlyOne

addExactlyOne

addBoolAnd

addBoolAnd

addBoolXor

addBoolXor

addImplication

addLinearExpressionInDomain

addLinearConstraint

addEquality

addEquality

addLessOrEqual

addLessOrEqual

addLessThan

addLessThan

addGreaterOrEqual

addGreaterOrEqual

addGreaterThan

addGreaterThan

addDifferent

addDifferent

addAllDifferent

addAllDifferent

addElement

addElement

addElement

addElement

addCircuit

addMultipleCircuit

addAllowedAssignments

addAllowedAssignments

addForbiddenAssignments

addForbiddenAssignments

addAutomaton

addAutomaton

addInverse

addReservoirConstraint

addMapDomain

addMinEquality

addMinEquality

addMaxEquality

addMaxEquality

addDivisionEquality

addAbsEquality

addModuloEquality

addModuloEquality

addMultiplicationEquality

addMultiplicationEquality

newIntervalVar

newFixedSizeIntervalVar

newFixedInterval

newOptionalIntervalVar

newOptionalFixedSizeIntervalVar

newOptionalFixedInterval

addNoOverlap

addNoOverlap

addNoOverlap2D