CpModel.java

Go to the documentation of this file.

// Copyright 2010-2021 Google LLC
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
package com.google.ortools.sat;
 
import com.google.ortools.sat.AllDifferentConstraintProto;
import com.google.ortools.sat.AutomatonConstraintProto;
import com.google.ortools.sat.BoolArgumentProto;
import com.google.ortools.sat.CircuitConstraintProto;
import com.google.ortools.sat.CpModelProto;
import com.google.ortools.sat.CpObjectiveProto;
import com.google.ortools.sat.CumulativeConstraintProto;
import com.google.ortools.sat.DecisionStrategyProto;
import com.google.ortools.sat.ElementConstraintProto;
import com.google.ortools.sat.FloatObjectiveProto;
import com.google.ortools.sat.InverseConstraintProto;
import com.google.ortools.sat.LinearArgumentProto;
import com.google.ortools.sat.LinearConstraintProto;
import com.google.ortools.sat.LinearExpressionProto;
import com.google.ortools.sat.NoOverlap2DConstraintProto;
import com.google.ortools.sat.NoOverlapConstraintProto;
import com.google.ortools.sat.ReservoirConstraintProto;
import com.google.ortools.sat.TableConstraintProto;
import com.google.ortools.util.Domain;
import java.util.LinkedHashMap;
import java.util.Map;
 
// TODO(user): Rewrite API to be closer to the C++ CpModel class.
public final class CpModel {
  static class CpModelException extends RuntimeException {
    public CpModelException(String methodName, String msg) {
      // Call constructor of parent Exception
      super(methodName + ": " + msg);
    }
  }
 
  public static class MismatchedArrayLengths extends CpModelException {
    public MismatchedArrayLengths(String methodName, String array1Name, String array2Name) {
      super(methodName, array1Name + " and " + array2Name + " have mismatched lengths");
    }
  }
 
  public static class WrongLength extends CpModelException {
    public WrongLength(String methodName, String msg) {
      super(methodName, msg);
    }
  }
  public CpModel() {
    modelBuilder = CpModelProto.newBuilder();
    constantMap = new LinkedHashMap<>();
  }
 
  // Integer variables.
 
  public IntVar newIntVar(long lb, long ub, String name) {
    return new IntVar(modelBuilder, new Domain(lb, ub), name);
  }
 
  public IntVar newIntVarFromDomain(Domain domain, String name) {
    return new IntVar(modelBuilder, domain, name);
  }
 
  public IntVar newBoolVar(String name) {
    return new IntVar(modelBuilder, new Domain(0, 1), name);
  }
 
  public IntVar newConstant(long value) {
    if (constantMap.containsKey(value)) {
      return constantMap.get(value);
    }
    IntVar cste = new IntVar(modelBuilder, new Domain(value), ""); // bounds and name.
    constantMap.put(value, cste);
    return cste;
  }
 
  public Literal trueLiteral() {
    return newConstant(1);
  }
 
  public Literal falseLiteral() {
    return newConstant(0);
  }
 
  // Boolean Constraints.
 
  public Constraint addBoolOr(Literal[] literals) {
    Constraint ct = new Constraint(modelBuilder);
    BoolArgumentProto.Builder boolOr = ct.getBuilder().getBoolOrBuilder();
    for (Literal lit : literals) {
      boolOr.addLiterals(lit.getIndex());
    }
    return ct;
  }
 
  public Constraint addBoolAnd(Literal[] literals) {
    Constraint ct = new Constraint(modelBuilder);
    BoolArgumentProto.Builder boolOr = ct.getBuilder().getBoolAndBuilder();
    for (Literal lit : literals) {
      boolOr.addLiterals(lit.getIndex());
    }
    return ct;
  }
 
  public Constraint addBoolXor(Literal[] literals) {
    Constraint ct = new Constraint(modelBuilder);
    BoolArgumentProto.Builder boolOr = ct.getBuilder().getBoolXorBuilder();
    for (Literal lit : literals) {
      boolOr.addLiterals(lit.getIndex());
    }
    return ct;
  }
 
  public Constraint addImplication(Literal a, Literal b) {
    return addBoolOr(new Literal[] {a.not(), b});
  }
 
  // Linear constraints.
 
  public Constraint addLinearExpressionInDomain(LinearExpr expr, Domain domain) {
    Constraint ct = new Constraint(modelBuilder);
    LinearConstraintProto.Builder lin = ct.getBuilder().getLinearBuilder();
    for (int i = 0; i < expr.numElements(); ++i) {
      lin.addVars(expr.getVariable(i).getIndex()).addCoeffs(expr.getCoefficient(i));
    }
    long offset = expr.getOffset();
    if (offset != 0) {
      lin.addVars(newConstant(1).getIndex()).addCoeffs(offset);
    }
    for (long b : domain.flattenedIntervals()) {
      lin.addDomain(b);
    }
    return ct;
  }
 
  public Constraint addLinearConstraint(LinearExpr expr, long lb, long ub) {
    return addLinearExpressionInDomain(expr, new Domain(lb, ub));
  }
 
  public Constraint addEquality(LinearExpr expr, long value) {
    return addLinearExpressionInDomain(expr, new Domain(value));
  }
 
  public Constraint addEquality(LinearExpr left, LinearExpr right) {
    return addLinearExpressionInDomain(new Difference(left, right), new Domain(0));
  }
 
  public Constraint addEqualityWithOffset(LinearExpr left, LinearExpr right, long offset) {
    return addLinearExpressionInDomain(new Difference(left, right), new Domain(-offset));
  }
 
  public Constraint addLessOrEqual(LinearExpr expr, long value) {
    return addLinearExpressionInDomain(expr, new Domain(Long.MIN_VALUE, value));
  }
 
  public Constraint addLessOrEqual(LinearExpr left, LinearExpr right) {
    return addLinearExpressionInDomain(new Difference(left, right), new Domain(Long.MIN_VALUE, 0));
  }
 
  public Constraint addLessThan(LinearExpr expr, long value) {
    return addLinearExpressionInDomain(expr, new Domain(Long.MIN_VALUE, value - 1));
  }
 
  public Constraint addLessThan(LinearExpr left, LinearExpr right) {
    return addLinearExpressionInDomain(new Difference(left, right), new Domain(Long.MIN_VALUE, -1));
  }
 
  public Constraint addLessOrEqualWithOffset(LinearExpr left, LinearExpr right, long offset) {
    return addLinearExpressionInDomain(
        new Difference(left, right), new Domain(Long.MIN_VALUE, -offset));
  }
 
  public Constraint addGreaterOrEqual(LinearExpr expr, long value) {
    return addLinearExpressionInDomain(expr, new Domain(value, Long.MAX_VALUE));
  }
 
  public Constraint addGreaterOrEqual(LinearExpr left, LinearExpr right) {
    return addLinearExpressionInDomain(new Difference(left, right), new Domain(0, Long.MAX_VALUE));
  }
 
  public Constraint addGreaterThan(LinearExpr expr, long value) {
    return addLinearExpressionInDomain(expr, new Domain(value + 1, Long.MAX_VALUE));
  }
 
  public Constraint addGreaterThan(LinearExpr left, LinearExpr right) {
    return addLinearExpressionInDomain(new Difference(left, right), new Domain(1, Long.MAX_VALUE));
  }
 
  public Constraint addGreaterOrEqualWithOffset(LinearExpr left, LinearExpr right, long offset) {
    return addLinearExpressionInDomain(
        new Difference(left, right), new Domain(-offset, Long.MAX_VALUE));
  }
 
  public Constraint addDifferent(LinearExpr expr, long value) {
    return addLinearExpressionInDomain(expr,
        Domain.fromFlatIntervals(
            new long[] {Long.MIN_VALUE, value - 1, value + 1, Long.MAX_VALUE}));
  }
 
  public Constraint addDifferent(LinearExpr left, LinearExpr right) {
    return addLinearExpressionInDomain(new Difference(left, right),
        Domain.fromFlatIntervals(new long[] {Long.MIN_VALUE, -1, 1, Long.MAX_VALUE}));
  }
 
  public Constraint addDifferentWithOffset(LinearExpr left, LinearExpr right, long offset) {
    return addLinearExpressionInDomain(new Difference(left, right),
        Domain.fromFlatIntervals(
            new long[] {Long.MIN_VALUE, -offset - 1, -offset + 1, Long.MAX_VALUE}));
  }
 
  // Integer constraints.
 
  public Constraint addAllDifferent(IntVar[] variables) {
    Constraint ct = new Constraint(modelBuilder);
    AllDifferentConstraintProto.Builder allDiff = ct.getBuilder().getAllDiffBuilder();
    for (IntVar var : variables) {
      allDiff.addExprs(getLinearExpressionProtoBuilderFromLinearExpr(var, /*negate=*/false));
    }
    return ct;
  }
 
  public Constraint addAllDifferent(LinearExpr[] expressions) {
    Constraint ct = new Constraint(modelBuilder);
    AllDifferentConstraintProto.Builder allDiff = ct.getBuilder().getAllDiffBuilder();
    for (LinearExpr expr : expressions) {
      allDiff.addExprs(getLinearExpressionProtoBuilderFromLinearExpr(expr, /*negate=*/false));
    }
    return ct;
  }
 
  public Constraint addElement(IntVar index, IntVar[] variables, IntVar target) {
    Constraint ct = new Constraint(modelBuilder);
    ElementConstraintProto.Builder element =
        ct.getBuilder().getElementBuilder().setIndex(index.getIndex());
    for (IntVar var : variables) {
      element.addVars(var.getIndex());
    }
    element.setTarget(target.getIndex());
    return ct;
  }
 
  public Constraint addElement(IntVar index, long[] values, IntVar target) {
    Constraint ct = new Constraint(modelBuilder);
    ElementConstraintProto.Builder element =
        ct.getBuilder().getElementBuilder().setIndex(index.getIndex());
    for (long v : values) {
      element.addVars(indexFromConstant(v));
    }
    element.setTarget(target.getIndex());
    return ct;
  }
 
  public Constraint addElement(IntVar index, int[] values, IntVar target) {
    Constraint ct = new Constraint(modelBuilder);
    ElementConstraintProto.Builder element =
        ct.getBuilder().getElementBuilder().setIndex(index.getIndex());
    for (long v : values) {
      element.addVars(indexFromConstant(v));
    }
    element.setTarget(target.getIndex());
    return ct;
  }
 
  public Constraint addCircuit(int[] tails, int[] heads, Literal[] literals) {
    if (tails.length != heads.length) {
      throw new MismatchedArrayLengths("CpModel.addCircuit", "tails", "heads");
    }
    if (tails.length != literals.length) {
      throw new MismatchedArrayLengths("CpModel.addCircuit", "tails", "literals");
    }
 
    Constraint ct = new Constraint(modelBuilder);
    CircuitConstraintProto.Builder circuit = ct.getBuilder().getCircuitBuilder();
    for (int t : tails) {
      circuit.addTails(t);
    }
    for (int h : heads) {
      circuit.addHeads(h);
    }
    for (Literal lit : literals) {
      circuit.addLiterals(lit.getIndex());
    }
    return ct;
  }
 
  public Constraint addAllowedAssignments(IntVar[] variables, long[][] tuplesList) {
    Constraint ct = new Constraint(modelBuilder);
    TableConstraintProto.Builder table = ct.getBuilder().getTableBuilder();
    for (IntVar var : variables) {
      table.addVars(var.getIndex());
    }
    int numVars = variables.length;
    for (int t = 0; t < tuplesList.length; ++t) {
      if (tuplesList[t].length != numVars) {
        throw new WrongLength("CpModel.addAllowedAssignments",
            "tuple " + t + " does not have the same length as the variables");
      }
      for (int i = 0; i < tuplesList[t].length; ++i) {
        table.addValues(tuplesList[t][i]);
      }
    }
    return ct;
  }
 
  public Constraint addAllowedAssignments(IntVar[] variables, int[][] tuplesList) {
    Constraint ct = new Constraint(modelBuilder);
    TableConstraintProto.Builder table = ct.getBuilder().getTableBuilder();
    for (IntVar var : variables) {
      table.addVars(var.getIndex());
    }
    int numVars = variables.length;
    for (int t = 0; t < tuplesList.length; ++t) {
      if (tuplesList[t].length != numVars) {
        throw new WrongLength("CpModel.addAllowedAssignments",
            "tuple " + t + " does not have the same length as the variables");
      }
      for (int i = 0; i < tuplesList[t].length; ++i) {
        table.addValues(tuplesList[t][i]);
      }
    }
    return ct;
  }
 
  public Constraint addForbiddenAssignments(IntVar[] variables, long[][] tuplesList) {
    Constraint ct = addAllowedAssignments(variables, tuplesList);
    // Reverse the flag.
    ct.getBuilder().getTableBuilder().setNegated(true);
    return ct;
  }
 
  public Constraint addForbiddenAssignments(IntVar[] variables, int[][] tuplesList) {
    Constraint ct = addAllowedAssignments(variables, tuplesList);
    // Reverse the flag.
    ct.getBuilder().getTableBuilder().setNegated(true);
    return ct;
  }
 
  public Constraint addAutomaton(
      IntVar[] transitionVariables, long startingState, long[] finalStates, long[][] transitions) {
    Constraint ct = new Constraint(modelBuilder);
    AutomatonConstraintProto.Builder automaton = ct.getBuilder().getAutomatonBuilder();
    for (IntVar var : transitionVariables) {
      automaton.addVars(var.getIndex());
    }
    automaton.setStartingState(startingState);
    for (long c : finalStates) {
      automaton.addFinalStates(c);
    }
    for (long[] t : transitions) {
      if (t.length != 3) {
        throw new WrongLength("CpModel.addAutomaton", "transition does not have length 3");
      }
      automaton.addTransitionTail(t[0]).addTransitionLabel(t[1]).addTransitionHead(t[2]);
    }
    return ct;
  }
 
  public Constraint addInverse(IntVar[] variables, IntVar[] inverseVariables) {
    if (variables.length != inverseVariables.length) {
      throw new MismatchedArrayLengths("CpModel.addInverse", "variables", "inverseVariables");
    }
    Constraint ct = new Constraint(modelBuilder);
    InverseConstraintProto.Builder inverse = ct.getBuilder().getInverseBuilder();
    for (IntVar var : variables) {
      inverse.addFDirect(var.getIndex());
    }
    for (IntVar var : inverseVariables) {
      inverse.addFInverse(var.getIndex());
    }
    return ct;
  }
 
  public Constraint addReservoirConstraint(
      IntVar[] times, long[] levelChanges, long minLevel, long maxLevel) {
    if (times.length != levelChanges.length) {
      throw new MismatchedArrayLengths("CpModel.addReservoirConstraint", "times", "levelChanges");
    }
    if (minLevel > 0) {
      throw new IllegalArgumentException("CpModel.addReservoirConstraint: minLevel must be <= 0");
    }
    if (maxLevel < 0) {
      throw new IllegalArgumentException("CpModel.addReservoirConstraint: maxLevel must be >= 0");
    }
    Constraint ct = new Constraint(modelBuilder);
    ReservoirConstraintProto.Builder reservoir = ct.getBuilder().getReservoirBuilder();
    for (IntVar time : times) {
      reservoir.addTimeExprs(getLinearExpressionProtoBuilderFromLinearExpr(time, /*negate=*/false));
    }
    for (long d : levelChanges) {
      reservoir.addLevelChanges(d);
    }
    reservoir.setMinLevel(minLevel).setMaxLevel(maxLevel);
    return ct;
  }
 
  public Constraint addReservoirConstraint(
      IntVar[] times, int[] levelChanges, long minLevel, long maxLevel) {
    return addReservoirConstraint(times, toLongArray(levelChanges), minLevel, maxLevel);
  }
 
  public Constraint addReservoirConstraint(
      LinearExpr[] times, long[] levelChanges, long minLevel, long maxLevel) {
    if (times.length != levelChanges.length) {
      throw new MismatchedArrayLengths("CpModel.addReservoirConstraint", "times", "levelChanges");
    }
    if (minLevel > 0) {
      throw new IllegalArgumentException("CpModel.addReservoirConstraint: minLevel must be <= 0");
    }
    if (maxLevel < 0) {
      throw new IllegalArgumentException("CpModel.addReservoirConstraint: maxLevel must be >= 0");
    }
    Constraint ct = new Constraint(modelBuilder);
    ReservoirConstraintProto.Builder reservoir = ct.getBuilder().getReservoirBuilder();
    for (LinearExpr time : times) {
      reservoir.addTimeExprs(getLinearExpressionProtoBuilderFromLinearExpr(time, /*negate=*/false));
    }
    for (long d : levelChanges) {
      reservoir.addLevelChanges(d);
    }
    reservoir.setMinLevel(minLevel).setMaxLevel(maxLevel);
    return ct;
  }
 
  public Constraint addReservoirConstraint(
      LinearExpr[] times, int[] levelChanges, long minLevel, long maxLevel) {
    return addReservoirConstraint(times, toLongArray(levelChanges), minLevel, maxLevel);
  }
 
  public Constraint addReservoirConstraintWithActive(
      IntVar[] times, long[] levelChanges, IntVar[] actives, long minLevel, long maxLevel) {
    if (times.length != levelChanges.length) {
      throw new MismatchedArrayLengths(
          "CpModel.addReservoirConstraintWithActive", "times", "levelChanges");
    }
    if (times.length != actives.length) {
      throw new MismatchedArrayLengths(
          "CpModel.addReservoirConstraintWithActive", "times", "actives");
    }
    if (minLevel > 0) {
      throw new IllegalArgumentException(
          "CpModel.addReservoirConstraintWithActive: minLevel must be <= 0");
    }
    if (maxLevel < 0) {
      throw new IllegalArgumentException(
          "CpModel.addReservoirConstraintWithActive: maxLevel must be >= 0");
    }
 
    Constraint ct = new Constraint(modelBuilder);
    ReservoirConstraintProto.Builder reservoir = ct.getBuilder().getReservoirBuilder();
    for (IntVar time : times) {
      reservoir.addTimeExprs(getLinearExpressionProtoBuilderFromLinearExpr(time, /*negate=*/false));
    }
    for (long d : levelChanges) {
      reservoir.addLevelChanges(d);
    }
    for (IntVar var : actives) {
      reservoir.addActiveLiterals(var.getIndex());
    }
    reservoir.setMinLevel(minLevel).setMaxLevel(maxLevel);
    return ct;
  }
 
  public Constraint addReservoirConstraintWithActive(
      IntVar[] times, int[] levelChanges, IntVar[] actives, long minLevel, long maxLevel) {
    return addReservoirConstraintWithActive(
        times, toLongArray(levelChanges), actives, minLevel, maxLevel);
  }
 
  public Constraint addReservoirConstraintWithActive(
      LinearExpr[] times, long[] levelChanges, IntVar[] actives, long minLevel, long maxLevel) {
    if (times.length != levelChanges.length) {
      throw new MismatchedArrayLengths(
          "CpModel.addReservoirConstraintWithActive", "times", "levelChanges");
    }
    if (times.length != actives.length) {
      throw new MismatchedArrayLengths(
          "CpModel.addReservoirConstraintWithActive", "times", "actives");
    }
    if (minLevel > 0) {
      throw new IllegalArgumentException(
          "CpModel.addReservoirConstraintWithActive: minLevel must be <= 0");
    }
    if (maxLevel < 0) {
      throw new IllegalArgumentException(
          "CpModel.addReservoirConstraintWithActive: maxLevel must be >= 0");
    }
 
    Constraint ct = new Constraint(modelBuilder);
    ReservoirConstraintProto.Builder reservoir = ct.getBuilder().getReservoirBuilder();
    for (LinearExpr time : times) {
      reservoir.addTimeExprs(getLinearExpressionProtoBuilderFromLinearExpr(time, /*negate=*/false));
    }
    for (long l : levelChanges) {
      reservoir.addLevelChanges(l);
    }
    for (IntVar var : actives) {
      reservoir.addActiveLiterals(var.getIndex());
    }
    reservoir.setMinLevel(minLevel).setMaxLevel(maxLevel);
    return ct;
  }
 
  public Constraint addReservoirConstraintWithActive(
      LinearExpr[] times, int[] levelChanges, IntVar[] actives, long minLevel, long maxLevel) {
    return addReservoirConstraintWithActive(
        times, toLongArray(levelChanges), actives, minLevel, maxLevel);
  }
 
  public void addMapDomain(IntVar var, Literal[] booleans, long offset) {
    for (int i = 0; i < booleans.length; ++i) {
      addEquality(var, offset + i).onlyEnforceIf(booleans[i]);
      addDifferent(var, offset + i).onlyEnforceIf(booleans[i].not());
    }
  }
 
  public Constraint addMinEquality(LinearExpr target, IntVar[] vars) {
    Constraint ct = new Constraint(modelBuilder);
    LinearArgumentProto.Builder linMax = ct.getBuilder().getLinMaxBuilder();
    linMax.setTarget(getLinearExpressionProtoBuilderFromLinearExpr(target, /*negate=*/true));
    for (IntVar var : vars) {
      linMax.addExprs(getLinearExpressionProtoBuilderFromLinearExpr(var, /*negate=*/true));
    }
    return ct;
  }
 
  public Constraint addMinEquality(LinearExpr target, LinearExpr[] exprs) {
    Constraint ct = new Constraint(modelBuilder);
    LinearArgumentProto.Builder linMax = ct.getBuilder().getLinMaxBuilder();
    linMax.setTarget(getLinearExpressionProtoBuilderFromLinearExpr(target, /*negate=*/true));
    for (LinearExpr expr : exprs) {
      linMax.addExprs(getLinearExpressionProtoBuilderFromLinearExpr(expr, /*negate=*/true));
    }
    return ct;
  }
 
  public Constraint addMaxEquality(LinearExpr target, IntVar[] vars) {
    Constraint ct = new Constraint(modelBuilder);
    LinearArgumentProto.Builder linMax = ct.getBuilder().getLinMaxBuilder();
    linMax.setTarget(getLinearExpressionProtoBuilderFromLinearExpr(target, /*negate=*/false));
    for (IntVar var : vars) {
      linMax.addExprs(getLinearExpressionProtoBuilderFromLinearExpr(var, /*negate=*/false));
    }
    return ct;
  }
 
  public Constraint addMaxEquality(LinearExpr target, LinearExpr[] exprs) {
    Constraint ct = new Constraint(modelBuilder);
    LinearArgumentProto.Builder linMax = ct.getBuilder().getLinMaxBuilder();
    linMax.setTarget(getLinearExpressionProtoBuilderFromLinearExpr(target, /*negate=*/false));
    for (LinearExpr expr : exprs) {
      linMax.addExprs(getLinearExpressionProtoBuilderFromLinearExpr(expr, /*negate=*/false));
    }
    return ct;
  }
 
  public Constraint addDivisionEquality(LinearExpr target, LinearExpr num, LinearExpr denom) {
    Constraint ct = new Constraint(modelBuilder);
    ct.getBuilder()
        .getIntDivBuilder()
        .setTarget(getLinearExpressionProtoBuilderFromLinearExpr(target, /*negate=*/false))
        .addExprs(getLinearExpressionProtoBuilderFromLinearExpr(num, /*negate=*/false))
        .addExprs(getLinearExpressionProtoBuilderFromLinearExpr(denom, /*negate=*/false));
    return ct;
  }
 
  public Constraint addAbsEquality(LinearExpr target, LinearExpr expr) {
    Constraint ct = new Constraint(modelBuilder);
    LinearArgumentProto.Builder linMax = ct.getBuilder().getLinMaxBuilder();
    linMax.setTarget(getLinearExpressionProtoBuilderFromLinearExpr(target, /*negate=*/false));
    linMax.addExprs(getLinearExpressionProtoBuilderFromLinearExpr(expr, /*negate=*/false));
    linMax.addExprs(getLinearExpressionProtoBuilderFromLinearExpr(expr, /*negate=*/true));
    return ct;
  }
 
  public Constraint addModuloEquality(LinearExpr target, LinearExpr var, LinearExpr mod) {
    Constraint ct = new Constraint(modelBuilder);
    ct.getBuilder()
        .getIntModBuilder()
        .setTarget(getLinearExpressionProtoBuilderFromLinearExpr(target, /*negate=*/false))
        .addExprs(getLinearExpressionProtoBuilderFromLinearExpr(var, /*negate=*/false))
        .addExprs(getLinearExpressionProtoBuilderFromLinearExpr(mod, /*negate=*/false));
    return ct;
  }
 
  public Constraint addModuloEquality(LinearExpr target, LinearExpr var, long mod) {
    Constraint ct = new Constraint(modelBuilder);
    ct.getBuilder()
        .getIntModBuilder()
        .setTarget(getLinearExpressionProtoBuilderFromLinearExpr(target, /*negate=*/false))
        .addExprs(getLinearExpressionProtoBuilderFromLinearExpr(var, /*negate=*/false))
        .addExprs(getLinearExpressionProtoBuilderFromLong(mod));
    return ct;
  }
 
  public Constraint addMultiplicationEquality(LinearExpr target, IntVar[] vars) {
    Constraint ct = new Constraint(modelBuilder);
    LinearArgumentProto.Builder intProd = ct.getBuilder().getIntProdBuilder();
    intProd.setTarget(getLinearExpressionProtoBuilderFromLinearExpr(target, /*negate=*/false));
    for (IntVar var : vars) {
      intProd.addExprs(getLinearExpressionProtoBuilderFromLinearExpr(var, /*negate=*/false));
    }
    return ct;
  }
 
  public Constraint addMultiplicationEquality(LinearExpr target, LinearExpr[] exprs) {
    Constraint ct = new Constraint(modelBuilder);
    LinearArgumentProto.Builder intProd = ct.getBuilder().getIntProdBuilder();
    intProd.setTarget(getLinearExpressionProtoBuilderFromLinearExpr(target, /*negate=*/false));
    for (LinearExpr expr : exprs) {
      intProd.addExprs(getLinearExpressionProtoBuilderFromLinearExpr(expr, /*negate=*/false));
    }
    return ct;
  }
 
  // Scheduling support.
 
  public IntervalVar newIntervalVar(
      LinearExpr start, LinearExpr size, LinearExpr end, String name) {
    addEquality(new Sum(start, size), end);
    return new IntervalVar(modelBuilder,
        getLinearExpressionProtoBuilderFromLinearExpr(start, /*negate=*/false),
        getLinearExpressionProtoBuilderFromLinearExpr(size, /*negate=*/false),
        getLinearExpressionProtoBuilderFromLinearExpr(end, /*negate=*/false), name);
  }
 
  public IntervalVar newFixedSizeIntervalVar(LinearExpr start, long size, String name) {
    return new IntervalVar(modelBuilder,
        getLinearExpressionProtoBuilderFromLinearExpr(start, /*negate=*/false),
        getLinearExpressionProtoBuilderFromLong(size),
        getLinearExpressionProtoBuilderFromLinearExpr(new Sum(start, size), /*negate=*/false),
        name);
  }
 
  public IntervalVar newFixedInterval(long start, long size, String name) {
    return new IntervalVar(modelBuilder, getLinearExpressionProtoBuilderFromLong(start),
        getLinearExpressionProtoBuilderFromLong(size),
        getLinearExpressionProtoBuilderFromLong(start + size), name);
  }
 
  public IntervalVar newOptionalIntervalVar(
      LinearExpr start, LinearExpr size, LinearExpr end, Literal isPresent, String name) {
    addEquality(new Sum(start, size), end).onlyEnforceIf(isPresent);
    return new IntervalVar(modelBuilder,
        getLinearExpressionProtoBuilderFromLinearExpr(start, /*negate=*/false),
        getLinearExpressionProtoBuilderFromLinearExpr(size, /*negate=*/false),
        getLinearExpressionProtoBuilderFromLinearExpr(end, /*negate=*/false), isPresent.getIndex(),
        name);
  }
 
  public IntervalVar newOptionalFixedSizeIntervalVar(
      LinearExpr start, long size, Literal isPresent, String name) {
    return new IntervalVar(modelBuilder,
        getLinearExpressionProtoBuilderFromLinearExpr(start, /*negate=*/false),
        getLinearExpressionProtoBuilderFromLong(size),
        getLinearExpressionProtoBuilderFromLinearExpr(new Sum(start, size), /*negate=*/false),
        isPresent.getIndex(), name);
  }
 
  public IntervalVar newOptionalFixedInterval(
      long start, long size, Literal isPresent, String name) {
    return new IntervalVar(modelBuilder, getLinearExpressionProtoBuilderFromLong(start),
        getLinearExpressionProtoBuilderFromLong(size),
        getLinearExpressionProtoBuilderFromLong(start + size), isPresent.getIndex(), name);
  }
 
  public Constraint addNoOverlap(IntervalVar[] intervalVars) {
    Constraint ct = new Constraint(modelBuilder);
    NoOverlapConstraintProto.Builder noOverlap = ct.getBuilder().getNoOverlapBuilder();
    for (IntervalVar var : intervalVars) {
      noOverlap.addIntervals(var.getIndex());
    }
    return ct;
  }
 
  public Constraint addNoOverlap2D(IntervalVar[] xIntervals, IntervalVar[] yIntervals) {
    Constraint ct = new Constraint(modelBuilder);
    NoOverlap2DConstraintProto.Builder noOverlap2d = ct.getBuilder().getNoOverlap2DBuilder();
    for (IntervalVar x : xIntervals) {
      noOverlap2d.addXIntervals(x.getIndex());
    }
    for (IntervalVar y : yIntervals) {
      noOverlap2d.addYIntervals(y.getIndex());
    }
    return ct;
  }
 
  public Constraint addCumulative(
      IntervalVar[] intervals, LinearExpr[] demands, LinearExpr capacity) {
    Constraint ct = new Constraint(modelBuilder);
    CumulativeConstraintProto.Builder cumul = ct.getBuilder().getCumulativeBuilder();
    for (IntervalVar interval : intervals) {
      cumul.addIntervals(interval.getIndex());
    }
    for (LinearExpr d : demands) {
      cumul.addDemands(getLinearExpressionProtoBuilderFromLinearExpr(d, false));
    }
    cumul.setCapacity(getLinearExpressionProtoBuilderFromLinearExpr(capacity, false));
    return ct;
  }
 
  public Constraint addCumulative(IntervalVar[] intervals, LinearExpr[] demands, long capacity) {
    Constraint ct = new Constraint(modelBuilder);
    CumulativeConstraintProto.Builder cumul = ct.getBuilder().getCumulativeBuilder();
    for (IntervalVar interval : intervals) {
      cumul.addIntervals(interval.getIndex());
    }
    for (LinearExpr d : demands) {
      cumul.addDemands(getLinearExpressionProtoBuilderFromLinearExpr(d, false));
    }
    cumul.getCapacityBuilder().setOffset(capacity);
    return ct;
  }
 
  public Constraint addCumulative(IntervalVar[] intervals, IntVar[] demands, LinearExpr capacity) {
    Constraint ct = new Constraint(modelBuilder);
    CumulativeConstraintProto.Builder cumul = ct.getBuilder().getCumulativeBuilder();
    for (IntervalVar interval : intervals) {
      cumul.addIntervals(interval.getIndex());
    }
    for (IntVar var : demands) {
      cumul.addDemandsBuilder().addVars(var.getIndex()).addCoeffs(1);
    }
    cumul.setCapacity(getLinearExpressionProtoBuilderFromLinearExpr(capacity, false));
    return ct;
  }
 
  public Constraint addCumulative(IntervalVar[] intervals, IntVar[] demands, long capacity) {
    Constraint ct = new Constraint(modelBuilder);
    CumulativeConstraintProto.Builder cumul = ct.getBuilder().getCumulativeBuilder();
    for (IntervalVar interval : intervals) {
      cumul.addIntervals(interval.getIndex());
    }
    for (IntVar var : demands) {
      cumul.addDemandsBuilder().addVars(var.getIndex()).addCoeffs(1);
    }
    cumul.getCapacityBuilder().setOffset(capacity);
    return ct;
  }
 
  public Constraint addCumulative(IntervalVar[] intervals, long[] demands, LinearExpr capacity) {
    Constraint ct = new Constraint(modelBuilder);
    CumulativeConstraintProto.Builder cumul = ct.getBuilder().getCumulativeBuilder();
    for (IntervalVar interval : intervals) {
      cumul.addIntervals(interval.getIndex());
    }
    for (long d : demands) {
      cumul.addDemandsBuilder().setOffset(d);
    }
    cumul.setCapacity(getLinearExpressionProtoBuilderFromLinearExpr(capacity, false));
    return ct;
  }
 
  public Constraint addCumulative(IntervalVar[] intervals, int[] demands, LinearExpr capacity) {
    return addCumulative(intervals, toLongArray(demands), capacity);
  }
 
  public Constraint addCumulative(IntervalVar[] intervals, long[] demands, long capacity) {
    Constraint ct = new Constraint(modelBuilder);
    CumulativeConstraintProto.Builder cumul = ct.getBuilder().getCumulativeBuilder();
    for (IntervalVar interval : intervals) {
      cumul.addIntervals(interval.getIndex());
    }
    for (long d : demands) {
      cumul.addDemandsBuilder().setOffset(d);
    }
    cumul.getCapacityBuilder().setOffset(capacity);
    return ct;
  }
 
  public Constraint addCumulative(IntervalVar[] intervals, int[] demands, long capacity) {
    return addCumulative(intervals, toLongArray(demands), capacity);
  }
 
  public void addHint(IntVar var, long value) {
    modelBuilder.getSolutionHintBuilder().addVars(var.getIndex());
    modelBuilder.getSolutionHintBuilder().addValues(value);
  }
 
  public void clearHints() {
    modelBuilder.clearSolutionHint();
  }
 
  public void addAssumption(Literal lit) {
    modelBuilder.addAssumptions(lit.getIndex());
  }
 
  public void addAssumptions(Literal[] literals) {
    for (Literal lit : literals) {
      addAssumption(lit);
    }
  }
 
  public void clearAssumptions() {
    modelBuilder.clearAssumptions();
  }
 
  // Objective.
 
  public void minimize(LinearExpr expr) {
    CpObjectiveProto.Builder obj = modelBuilder.getObjectiveBuilder();
    for (int i = 0; i < expr.numElements(); ++i) {
      obj.addVars(expr.getVariable(i).getIndex()).addCoeffs(expr.getCoefficient(i));
    }
    obj.setOffset(expr.getOffset());
  }
 
  public void minimize(DoubleLinearExpr expr) {
    FloatObjectiveProto.Builder obj = modelBuilder.getFloatingPointObjectiveBuilder();
    for (int i = 0; i < expr.numElements(); ++i) {
      obj.addVars(expr.getVariable(i).getIndex()).addCoeffs(expr.getCoefficient(i));
    }
    obj.setOffset(expr.getOffset()).setMaximize(false);
  }
 
  public void maximize(LinearExpr expr) {
    CpObjectiveProto.Builder obj = modelBuilder.getObjectiveBuilder();
    for (int i = 0; i < expr.numElements(); ++i) {
      obj.addVars(expr.getVariable(i).getIndex()).addCoeffs(-expr.getCoefficient(i));
    }
    obj.setOffset(-expr.getOffset());
    obj.setScalingFactor(-1.0);
  }
 
  public void maximize(DoubleLinearExpr expr) {
    FloatObjectiveProto.Builder obj = modelBuilder.getFloatingPointObjectiveBuilder();
    for (int i = 0; i < expr.numElements(); ++i) {
      obj.addVars(expr.getVariable(i).getIndex()).addCoeffs(expr.getCoefficient(i));
    }
    obj.setOffset(expr.getOffset()).setMaximize(true);
  }
 
  // DecisionStrategy
 
  public void addDecisionStrategy(IntVar[] variables,
      DecisionStrategyProto.VariableSelectionStrategy varStr,
      DecisionStrategyProto.DomainReductionStrategy domStr) {
    DecisionStrategyProto.Builder ds = modelBuilder.addSearchStrategyBuilder();
    for (IntVar var : variables) {
      ds.addVariables(var.getIndex());
    }
    ds.setVariableSelectionStrategy(varStr).setDomainReductionStrategy(domStr);
  }
 
  public String modelStats() {
    return CpSatHelper.modelStats(model());
  }
 
  public String validate() {
    return CpSatHelper.validateModel(model());
  }
 
  public Boolean exportToFile(String file) {
    return CpSatHelper.writeModelToFile(model(), file);
  }
 
  // Helpers
 
  long[] toLongArray(int[] values) {
    long[] result = new long[values.length];
    for (int i = 0; i < values.length; ++i) {
      result[i] = values[i];
    }
    return result;
  }
 
  int indexFromConstant(long constant) {
    IntVar constVar = newConstant(constant);
    return constVar.getIndex();
  }
 
  LinearExpressionProto.Builder getLinearExpressionProtoBuilderFromLinearExpr(
      LinearExpr expr, boolean negate) {
    LinearExpressionProto.Builder builder = LinearExpressionProto.newBuilder();
    final int numVariables = expr.numElements();
    final long mult = negate ? -1 : 1;
    for (int i = 0; i < numVariables; ++i) {
      builder.addVars(expr.getVariable(i).getIndex());
      builder.addCoeffs(expr.getCoefficient(i) * mult);
    }
    builder.setOffset(expr.getOffset() * mult);
    return builder;
  }
 
  LinearExpressionProto.Builder getLinearExpressionProtoBuilderFromLong(long value) {
    LinearExpressionProto.Builder builder = LinearExpressionProto.newBuilder();
    builder.setOffset(value);
    return builder;
  }
 
  // Getters.
 
  public CpModelProto model() {
    return modelBuilder.build();
  }
 
  public int negated(int index) {
    return -index - 1;
  }
 
  public CpModelProto.Builder getBuilder() {
    return modelBuilder;
  }
 
  private final CpModelProto.Builder modelBuilder;
  private final Map<Long, IntVar> constantMap;
}