ModelSolver.java

Go to the documentation of this file.

// Copyright 2010-2022 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.modelbuilder;
 
import java.time.Duration;
import java.util.function.Consumer;
 
public final class ModelSolver {
  static class ModelSolverException extends RuntimeException {
    public ModelSolverException(String methodName, String msg) {
      // Call constructor of parent Exception
      super(methodName + ": " + msg);
    }
  }
 
  public ModelSolver(String solverName) {
    this.helper = new ModelSolverHelper(solverName);
    this.logCallback = null;
  }
 
  public SolveStatus solve(ModelBuilder model) {
    if (logCallback == null) {
      helper.clearLogCallback();
    } else {
      helper.setLogCallback(logCallback);
    }
    helper.solve(model.getHelper());
    if (!helper.hasResponse()) {
      return SolveStatus.UNKNOWN_STATUS;
    }
    return helper.getStatus();
  }
 
  public void enableOutput(boolean enable) {
    helper.enableOutput(enable);
  }
 
  public void setTimeLimit(Duration limit) {
    helper.setTimeLimitInSeconds((double) limit.toMillis() / 1000.0);
  }
 
  public void setSolverSpecificParameters(String parameters) {
    helper.setSolverSpecificParameters(parameters);
  }
 
  public boolean solverIsSupported() {
    return helper.solverIsSupported();
  }
 
  public boolean interruptSolve() {
    return helper.interruptSolve();
  }
 
  public boolean hasResponse() {
    return helper.hasResponse();
  }
 
  public boolean hasSolution() {
    return helper.hasSolution();
  }
 
  public double getObjectiveValue() {
    if (!helper.hasSolution()) {
      throw new ModelSolverException(
          "ModelSolver.getObjectiveValue()", "solve() was not called or no solution was found");
    }
    return helper.getObjectiveValue();
  }
 
  public double getBestObjectiveBound() {
    if (!helper.hasSolution()) {
      throw new ModelSolverException(
          "ModelSolver.getBestObjectiveBound()", "solve() was not called or no solution was found");
    }
    return helper.getBestObjectiveBound();
  }
 
  public double getValue(Variable var) {
    if (!helper.hasSolution()) {
      throw new ModelSolverException(
          "ModelSolver.getValue())", "solve() was not called or no solution was found");
    }
    return helper.getVariableValue(var.getIndex());
  }
  public double getReducedCost(Variable var) {
    if (!helper.hasSolution()) {
      throw new ModelSolverException(
          "ModelSolver.getReducedCost())", "solve() was not called or no solution was found");
    }
    return helper.getReducedCost(var.getIndex());
  }
 
  public double getDualValue(LinearConstraint ct) {
    if (!helper.hasSolution()) {
      throw new ModelSolverException(
          "ModelSolver.getDualValue())", "solve() was not called or no solution was found");
    }
    return helper.getDualValue(ct.getIndex());
  }
 
  public double getActivity(LinearConstraint ct) {
    if (!helper.hasSolution()) {
      throw new ModelSolverException(
          "ModelSolver.getActivity())", "solve() was not called or no solution was found");
    }
    return helper.getActivity(ct.getIndex());
  }
 
  public void setLogCallback(Consumer<String> cb) {
    this.logCallback = cb;
  }
 
  public double getWallTime() {
    return helper.getWallTime();
  }
 
  public double getUserTime() {
    return helper.getUserTime();
  }
 
  private final ModelSolverHelper helper;
  private Consumer<String> logCallback;
}