Package com.google.ortools.sat

Class 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.

    • 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.

      • addLinearConstraint

        public Constraint addLinearConstraint​(LinearArgument expr,
                                      long lb,
                                      long ub)
        Adds lb <= expr <= ub.

      • 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).

      • addElement

        public Constraint addElement​(IntVar index,
                             IntVar[] variables,
                             IntVar target)
        Adds the element constraint: variables[index] == target.

      • addElement

        public Constraint addElement​(IntVar index,
                             long[] values,
                             IntVar target)
        Adds the element constraint: values[index] == target.

      • addElement

        public Constraint addElement​(IntVar index,
                             int[] values,
                             IntVar 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 path in a subgraph of the total graph. In case a node 'i' is not in the path, 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​(IntVar[] variables)
        Adds AllowedAssignments(variables).

        An AllowedAssignments constraint is a constraint on an array of variables that forces, when all variables are fixed to a single value, that the corresponding list of values is equal to one of the tuples of the tupleList.

        Parameters:
        variables - a list of variables
        Returns:
        an instance of the TableConstraint class without any tuples. Tuples can be added directly to the table constraint.

      • addForbiddenAssignments

        public TableConstraint addForbiddenAssignments​(IntVar[] variables)
        Adds ForbiddenAssignments(variables).

        A ForbiddenAssignments constraint is a constraint on an array of variables where the list of impossible combinations is provided in the tuples list.

        Parameters:
        variables - a list of variables
        Returns:
        an instance of the TableConstraint class without any tuples. Tuples can be added directly to the table constraint.

      • addAutomaton

        public AutomatonConstraint addAutomaton​(IntVar[] transitionVariables,
                                        long startingState,
                                        long[] finalStates)
        Adds an automaton constraint.

        An automaton constraint takes a list of variables (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 variable in the list of variables.

        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 variables 'variables[i]'. That is, this arc can only be selected if 'variables[i]' is assigned the value 'label'.

        A feasible solution of this constraint is an assignment of variables such that, starting from the initial state in phase 0, there is a path labeled by the values of the variables that ends in one of the final states in the final phase.

        Parameters:
        transitionVariables - a non empty list of variables 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

      • 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).

      • 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).

      • 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.

      • addHint

        public void addHint​(IntVar var,
                    long value)
        Adds hinting to a variable

      • 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.

      • 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.

      • negated

        public int negated​(int index)