ortools-clone/ortools/linear_solver/java/linear_solver.swig

// Copyright 2010-2025 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.

// This .swig file exposes the linear programming and integer programming
// solver.
//
// The java API is pretty much identical to the C++ API, with methods
// systematically renamed to the Java-style "lowerCamelCase", and using
// the Java-style getProperty() instead of the C++ Property(), for getters.

%include "enums.swg"  // For native Java enum support.
%include "stdint.i"

%include "ortools/base/base.i"

// We prefer our in-house vector wrapper to std_vector.i, because it
// converts to and from native java arrays.
%import "ortools/util/java/vector.swig"

%include "ortools/util/java/proto.i"

// We need to forward-declare the proto here, so that the PROTO_* macros
// involving them work correctly. The order matters very much: this declaration
// needs to be before the %{ #include ".../linear_solver.h" %}.
namespace operations_research {
class MPModelProto;
class MPModelRequest;
class MPSolutionResponse;
}  // namespace operations_research

%{
#include "ortools/linear_solver/linear_solver.h"
#include "ortools/linear_solver/model_exporter.h"
%}

%typemap(javaimports) SWIGTYPE %{
import java.lang.reflect.*;
%}

// Conversion of array of MPVariable or MPConstraint from/to C++ vectors.
CONVERT_VECTOR_WITH_CAST(operations_research::MPVariable, MPVariable, REINTERPRET_CAST,
    com/google/ortools/linearsolver);
CONVERT_VECTOR_WITH_CAST(operations_research::MPConstraint, MPConstraint, REINTERPRET_CAST,
    com/google/ortools/linearsolver);

// Support the proto-based APIs.
PROTO_INPUT(
    operations_research::MPModelProto,
    com.google.ortools.linearsolver.MPModelProto,
    input_model);
PROTO2_RETURN(
    operations_research::MPModelProto,
    com.google.ortools.linearsolver.MPModelProto);
PROTO_INPUT(
    operations_research::MPModelRequest,
    com.google.ortools.linearsolver.MPModelRequest,
    model_request);
PROTO_INPUT(
    operations_research::MPSolutionResponse,
    com.google.ortools.linearsolver.MPSolutionResponse,
    response);
PROTO2_RETURN(
    operations_research::MPSolutionResponse,
    com.google.ortools.linearsolver.MPSolutionResponse);

%extend operations_research::MPSolver {
  /**
   * Loads a model and returns the error message, which will be empty iff the
   * model is valid. Clears all names (see also loadModelFromProtoKeepNames()).
   */
  std::string loadModelFromProto(
      const operations_research::MPModelProto& input_model) {
    std::string error_message;
    $self->LoadModelFromProto(input_model, &error_message);
    return error_message;
  }

  /**
   * Like loadModelFromProto(), but keeps the names and returns an error if
   * there are duplicate names.
   */
  std::string loadModelFromProtoKeepNames(
      const operations_research::MPModelProto& input_model) {
    std::string error_message;
    $self->LoadModelFromProto(input_model, &error_message,
                              /*clear_names=*/false);
    return error_message;
  }

  // Replaces MPSolver::LoadModelFromProtoWithUniqueNamesOrDie
  std::string loadModelFromProtoWithUniqueNamesOrDie(
      const operations_research::MPModelProto& input_model) {
    std::unordered_set<std::string> names;
    for (const auto var : input_model.variable()) {
      if (!var.name().empty() && !names.insert(var.name()).second) {
        LOG(FATAL) << "found duplicated variable names " + var.name();
      }
    }
    std::string error_message;
    $self->LoadModelFromProtoWithUniqueNamesOrDie(input_model, &error_message);
    return error_message;
  }

  /**
   * Export the loaded model to proto and returns it.
   */
  operations_research::MPModelProto exportModelToProto() {
    operations_research::MPModelProto model;
    $self->ExportModelToProto(&model);
    return model;
  }

  /**
   * Fills the solution found to a response proto and returns it.
   */
  operations_research::MPSolutionResponse createSolutionResponseProto() {
    operations_research::MPSolutionResponse response;
    $self->FillSolutionResponseProto(&response);
    return response;
  }

  /**
   * Load a solution encoded in a protocol buffer onto this solver for easy
  access via the MPSolver interface.
   *
   * IMPORTANT: This may only be used in conjunction with ExportModel(),
  following this example:
   *
   \code
     MPSolver my_solver;
     ... add variables and constraints ...
     MPModelProto model_proto;
     my_solver.ExportModelToProto(&model_proto);
     MPSolutionResponse solver_response;
     MPSolver::SolveWithProto(model_proto, &solver_response);
     if (solver_response.result_status() == MPSolutionResponse::OPTIMAL) {
       CHECK_OK(my_solver.LoadSolutionFromProto(solver_response));
       ... inspect the solution using the usual API: solution_value(), etc...
     }
  \endcode
   *
   * The response must be in OPTIMAL or FEASIBLE status.
   *
   * Returns a false if a problem arised (typically, if it wasn't used
   *     like it should be):
   * - loading a solution whose variables don't correspond to the solver's
   *   current variables
   * - loading a solution with a status other than OPTIMAL / FEASIBLE.
   *
   * Note: the objective value isn't checked. You can use VerifySolution() for
   *       that.
   */
   bool loadSolutionFromProto(const MPSolutionResponse& response) {
     const absl::Status status =
         $self->LoadSolutionFromProto(response);
     LOG_IF(ERROR, !status.ok()) << "LoadSolutionFromProto() failed: " << status;
     return status.ok();
   }

  /**
   * Solves the given model proto and returns a response proto.
   */
  static operations_research::MPSolutionResponse solveWithProto(
      const operations_research::MPModelRequest& model_request) {
    operations_research::MPSolutionResponse response;
    operations_research::MPSolver::SolveWithProto(model_request, &response);
    return response;
  }

  /**
   * Export the loaded model in LP format.
   */
  std::string exportModelAsLpFormat(bool obfuscate = false) {
    operations_research::MPModelExportOptions options;
    options.obfuscate = obfuscate;
    operations_research::MPModelProto model;
    $self->ExportModelToProto(&model);
    return ExportModelAsLpFormat(model, options).value_or("");
  }

  /**
   * Export the loaded model in MPS format.
   */
  std::string exportModelAsMpsFormat(bool fixed_format, bool obfuscate) {
    operations_research::MPModelExportOptions options;
    options.obfuscate = obfuscate;
    operations_research::MPModelProto model;
    $self->ExportModelToProto(&model);
    return ExportModelAsMpsFormat(model, options).value_or("");
  }

  /**
   * Write the loaded model to file in MPS format.
   */
   bool writeModelToMpsFile(const std::string& filename, bool fixed_format,
                            bool obfuscate) {
    operations_research::MPModelExportOptions options;
    options.obfuscate = obfuscate;
    operations_research::MPModelProto model;
    $self->ExportModelToProto(&model);
    return WriteModelToMpsFile(filename, model, options).ok();
  }

  /**
   * Sets a hint for solution.
   *
   * If a feasible or almost-feasible solution to the problem is already known,
   * it may be helpful to pass it to the solver so that it can be used. A
   * solver that supports this feature will try to use this information to
   * create its initial feasible solution.
   *
   * Note that it may not always be faster to give a hint like this to the
   * solver. There is also no guarantee that the solver will use this hint or
   * try to return a solution "close" to this assignment in case of multiple
   * optimal solutions.
   */
  void setHint(const std::vector<operations_research::MPVariable*>& variables,
               const std::vector<double>& values) {
    if (variables.size() != values.size()) {
      LOG(FATAL) << "Different number of variables and values when setting "
                 << "hint.";
    }
    std::vector<std::pair<const operations_research::MPVariable*, double> >
        hint(variables.size());
    for (int i = 0; i < variables.size(); ++i) {
      hint[i] = std::make_pair(variables[i], values[i]);
    }
    $self->SetHint(hint);
  }

  /**
   * Sets the number of threads to be used by the solver.
   */
  bool setNumThreads(int num_theads) {
    return $self->SetNumThreads(num_theads).ok();
  }
}  // Extend operations_research::MPSolver

// Add java code on MPSolver.
%typemap(javacode) operations_research::MPSolver %{
  /**
   * Creates and returns an array of variables.
   */
  public MPVariable[] makeVarArray(int count, double lb, double ub, boolean integer) {
    MPVariable[] array = new MPVariable[count];
    for (int i = 0; i < count; ++i) {
      array[i] = makeVar(lb, ub, integer, "");
    }
    return array;
  }

  /**
   * Creates and returns an array of named variables.
   */
  public MPVariable[] makeVarArray(int count, double lb, double ub, boolean integer,
                                   String var_name) {
    MPVariable[] array = new MPVariable[count];
    for (int i = 0; i < count; ++i) {
      array[i] = makeVar(lb, ub, integer, var_name + i);
    }
    return array;
  }

  public MPVariable[] makeNumVarArray(int count, double lb, double ub) {
    return makeVarArray(count, lb, ub, false);
  }

  public MPVariable[] makeNumVarArray(int count, double lb, double ub, String var_name) {
    return makeVarArray(count, lb, ub, false, var_name);
  }

  public MPVariable[] makeIntVarArray(int count, double lb, double ub) {
    return makeVarArray(count, lb, ub, true);
  }

  public MPVariable[] makeIntVarArray(int count, double lb, double ub, String var_name) {
    return makeVarArray(count, lb, ub, true, var_name);
  }

  public MPVariable[] makeBoolVarArray(int count) {
    return makeVarArray(count, 0.0, 1.0, true);
  }

  public MPVariable[] makeBoolVarArray(int count, String var_name) {
    return makeVarArray(count, 0.0, 1.0, true, var_name);
  }
%}  // %typemap(javacode) operations_research::MPSolver

%ignoreall

%unignore operations_research;

// List of the classes exposed.
%unignore operations_research::MPSolver;
%unignore operations_research::MPSolver::MPSolver;
%unignore operations_research::MPSolver::~MPSolver;
%newobject operations_research::MPSolver::CreateSolver;
%rename (createSolver) operations_research::MPSolver::CreateSolver;
%rename (solverVersion) operations_research::MPSolver::SolverVersion;

%unignore operations_research::MPConstraint;
%unignore operations_research::MPVariable;
%unignore operations_research::MPObjective;
%unignore operations_research::MPSolverParameters;

// Expose the MPSolver::OptimizationProblemType enum.
%unignore operations_research::MPSolver::OptimizationProblemType;
%unignore operations_research::MPSolver::GLOP_LINEAR_PROGRAMMING;
%unignore operations_research::MPSolver::CLP_LINEAR_PROGRAMMING;
%unignore operations_research::MPSolver::GLPK_LINEAR_PROGRAMMING;
%unignore operations_research::MPSolver::PDLP_LINEAR_PROGRAMMING;
%unignore operations_research::MPSolver::SCIP_MIXED_INTEGER_PROGRAMMING;
%unignore operations_research::MPSolver::CBC_MIXED_INTEGER_PROGRAMMING;
%unignore operations_research::MPSolver::GLPK_MIXED_INTEGER_PROGRAMMING;
%unignore operations_research::MPSolver::BOP_INTEGER_PROGRAMMING;
%unignore operations_research::MPSolver::SAT_INTEGER_PROGRAMMING;
// These aren't unit tested, as they only run on machines with a Gurobi license.
%unignore operations_research::MPSolver::GUROBI_LINEAR_PROGRAMMING;
%unignore operations_research::MPSolver::GUROBI_MIXED_INTEGER_PROGRAMMING;
%unignore operations_research::MPSolver::CPLEX_LINEAR_PROGRAMMING;
%unignore operations_research::MPSolver::CPLEX_MIXED_INTEGER_PROGRAMMING;
%unignore operations_research::MPSolver::XPRESS_LINEAR_PROGRAMMING;
%unignore operations_research::MPSolver::XPRESS_MIXED_INTEGER_PROGRAMMING;

// Expose the MPSolver::ResultStatus enum.
%unignore operations_research::MPSolver::ResultStatus;
%unignore operations_research::MPSolver::OPTIMAL;
%unignore operations_research::MPSolver::FEASIBLE;  // no test
%unignore operations_research::MPSolver::INFEASIBLE;  // no test
%unignore operations_research::MPSolver::UNBOUNDED;  // no test
%unignore operations_research::MPSolver::ABNORMAL;  // no test
%unignore operations_research::MPSolver::MODEL_INVALID;  // no test
%unignore operations_research::MPSolver::NOT_SOLVED;  // no test

// Expose the MPSolver's basic API, with some non-trivial renames.
%rename (objective) operations_research::MPSolver::MutableObjective;
// We intentionally don't expose MakeRowConstraint(LinearExpr), because this
// "natural language" API is specific to C++: other languages may add their own
// syntactic sugar on top of MPSolver instead of this.
%rename (makeConstraint) operations_research::MPSolver::MakeRowConstraint(double, double);
%rename (makeConstraint) operations_research::MPSolver::MakeRowConstraint();
%rename (makeConstraint) operations_research::MPSolver::MakeRowConstraint(double, double, const std::string&);
%rename (makeConstraint) operations_research::MPSolver::MakeRowConstraint(const std::string&);

// Expose the MPSolver's basic API, with trivial renames.
%rename (makeBoolVar) operations_research::MPSolver::MakeBoolVar;  // no test
%rename (makeIntVar) operations_research::MPSolver::MakeIntVar;
%rename (makeNumVar) operations_research::MPSolver::MakeNumVar;
%rename (makeVar) operations_research::MPSolver::MakeVar;  // no test
%rename (solve) operations_research::MPSolver::Solve;
%rename (verifySolution) operations_research::MPSolver::VerifySolution;
%rename (reset) operations_research::MPSolver::Reset;  // no test
%rename (infinity) operations_research::MPSolver::infinity;
%rename (setTimeLimit) operations_research::MPSolver::set_time_limit;  // no test
%rename (isMip) operations_research::MPSolver::IsMIP;  // no test

// Proto-based API of the MPSolver. Use is encouraged.
// Note: the following proto-based methods aren't listed here, but are
// supported (that's because we re-implement them in java below):
// - loadModelFromProto
// - exportModelToProto
// - createSolutionResponseProto
// - solveWithProto
%unignore operations_research::MPSolver::LoadStatus;
%unignore operations_research::MPSolver::NO_ERROR;  // no test
%unignore operations_research::MPSolver::UNKNOWN_VARIABLE_ID;  // no test
// - loadSolutionFromProto;  // Use hand-written version.

// Expose some of the more advanced MPSolver API.
%rename (problemType) operations_research::MPSolver::ProblemType;  // no test
%rename (supportsProblemType) operations_research::MPSolver::SupportsProblemType;  // no test
%rename (setSolverSpecificParametersAsString)
    operations_research::MPSolver::SetSolverSpecificParametersAsString;  // no test
%rename (interruptSolve) operations_research::MPSolver::InterruptSolve;  // no test
%rename (wallTime) operations_research::MPSolver::wall_time;
%rename (clear) operations_research::MPSolver::Clear;  // no test
%unignore operations_research::MPSolver::constraint;
%unignore operations_research::MPSolver::constraints;
%unignore operations_research::MPSolver::variable;
%unignore operations_research::MPSolver::variables;
%rename (numVariables) operations_research::MPSolver::NumVariables;
%rename (numConstraints) operations_research::MPSolver::NumConstraints;
%rename (enableOutput) operations_research::MPSolver::EnableOutput;  // no test
%rename (suppressOutput) operations_research::MPSolver::SuppressOutput;  // no test
%rename (lookupConstraintOrNull) operations_research::MPSolver::LookupConstraintOrNull;  // no test
%rename (lookupVariableOrNull) operations_research::MPSolver::LookupVariableOrNull;  // no test
%rename (write) operations_research::MPSolver::Write;  // no test

// Expose very advanced parts of the MPSolver API. For expert users only.
%rename (computeConstraintActivities) operations_research::MPSolver::ComputeConstraintActivities;
%rename (computeExactConditionNumber) operations_research::MPSolver::ComputeExactConditionNumber;
%rename (nodes) operations_research::MPSolver::nodes;
%rename (iterations) operations_research::MPSolver::iterations;
%unignore operations_research::MPSolver::BasisStatus;  // no test
%unignore operations_research::MPSolver::FREE;  // no test
%unignore operations_research::MPSolver::AT_LOWER_BOUND;
%unignore operations_research::MPSolver::AT_UPPER_BOUND;  // no test
%unignore operations_research::MPSolver::FIXED_VALUE;  // no test
%unignore operations_research::MPSolver::BASIC;
%ignore operations_research::MPSolver::SetStartingLpBasis; // no typemap for const vector<BasisStatus>&

// MPVariable: writer API.
%rename (setInteger) operations_research::MPVariable::SetInteger;
%rename (setLb) operations_research::MPVariable::SetLB;  // no test
%rename (setUb) operations_research::MPVariable::SetUB;  // no test
%rename (setBounds) operations_research::MPVariable::SetBounds;  // no test

// MPVariable: reader API.
%rename (solutionValue) operations_research::MPVariable::solution_value;
%rename (lb) operations_research::MPVariable::lb;  // no test
%rename (ub) operations_research::MPVariable::ub;  // no test
%rename (name) operations_research::MPVariable::name;  // no test
%rename (basisStatus) operations_research::MPVariable::basis_status;
%rename (reducedCost) operations_research::MPVariable::reduced_cost;  // For experts only.
%rename (index) operations_research::MPVariable::index;  // no test

// MPConstraint: writer API.
%rename (setCoefficient) operations_research::MPConstraint::SetCoefficient;
%rename (setLb) operations_research::MPConstraint::SetLB;  // no test
%rename (setUb) operations_research::MPConstraint::SetUB;  // no test
%rename (setBounds) operations_research::MPConstraint::SetBounds;  // no test
%rename (setIsLazy) operations_research::MPConstraint::set_is_lazy;

// MPConstraint: reader API.
%rename (getCoefficient) operations_research::MPConstraint::GetCoefficient;
%rename (lb) operations_research::MPConstraint::lb;  // no test
%rename (ub) operations_research::MPConstraint::ub;  // no test
%rename (name) operations_research::MPConstraint::name;
%rename (basisStatus) operations_research::MPConstraint::basis_status;
%rename (dualValue) operations_research::MPConstraint::dual_value;  // For experts only.
%rename (isLazy) operations_research::MPConstraint::is_lazy;  // For experts only.
%rename (index) operations_research::MPConstraint::index;

// MPObjective: writer API.
%rename (setCoefficient) operations_research::MPObjective::SetCoefficient;
%rename (setMinimization) operations_research::MPObjective::SetMinimization;  // no test
%rename (setMaximization) operations_research::MPObjective::SetMaximization;
%rename (setOptimizationDirection) operations_research::MPObjective::SetOptimizationDirection;
%rename (clear) operations_research::MPObjective::Clear;  // no test
%rename (setOffset) operations_research::MPObjective::SetOffset;

// MPObjective: reader API.
%rename (value) operations_research::MPObjective::Value;
%rename (getCoefficient) operations_research::MPObjective::GetCoefficient;
%rename (minimization) operations_research::MPObjective::minimization;
%rename (maximization) operations_research::MPObjective::maximization;
%rename (offset) operations_research::MPObjective::offset;
%rename (bestBound) operations_research::MPObjective::BestBound;

// MPSolverParameters API. For expert users only.
// TODO(user): unit test all of it.

%unignore operations_research::MPSolverParameters;  // no test
%unignore operations_research::MPSolverParameters::MPSolverParameters;  // no test

// Expose the MPSolverParameters::DoubleParam enum.
%unignore operations_research::MPSolverParameters::DoubleParam;  // no test
%unignore operations_research::MPSolverParameters::RELATIVE_MIP_GAP;  // no test
%unignore operations_research::MPSolverParameters::PRIMAL_TOLERANCE;  // no test
%unignore operations_research::MPSolverParameters::DUAL_TOLERANCE;  // no test
%rename (getDoubleParam) operations_research::MPSolverParameters::GetDoubleParam;  // no test
%rename (setDoubleParam) operations_research::MPSolverParameters::SetDoubleParam;  // no test
%unignore operations_research::MPSolverParameters::kDefaultRelativeMipGap;  // no test
%unignore operations_research::MPSolverParameters::kDefaultPrimalTolerance;  // no test
%unignore operations_research::MPSolverParameters::kDefaultDualTolerance;  // no test

// Expose the MPSolverParameters::IntegerParam enum.
%unignore operations_research::MPSolverParameters::IntegerParam;  // no test
%unignore operations_research::MPSolverParameters::PRESOLVE;  // no test
%unignore operations_research::MPSolverParameters::LP_ALGORITHM;  // no test
%unignore operations_research::MPSolverParameters::INCREMENTALITY;  // no test
%unignore operations_research::MPSolverParameters::SCALING;  // no test
%rename (getIntegerParam) operations_research::MPSolverParameters::GetIntegerParam;  // no test
%rename (setIntegerParam) operations_research::MPSolverParameters::SetIntegerParam;  // no test

// Expose the MPSolverParameters::PresolveValues enum.
%unignore operations_research::MPSolverParameters::PresolveValues;  // no test
%unignore operations_research::MPSolverParameters::PRESOLVE_OFF;  // no test
%unignore operations_research::MPSolverParameters::PRESOLVE_ON;  // no test
%unignore operations_research::MPSolverParameters::kDefaultPresolve;  // no test

// Expose the MPSolverParameters::LpAlgorithmValues enum.
%unignore operations_research::MPSolverParameters::LpAlgorithmValues;  // no test
%unignore operations_research::MPSolverParameters::DUAL;  // no test
%unignore operations_research::MPSolverParameters::PRIMAL;  // no test
%unignore operations_research::MPSolverParameters::BARRIER;  // no test

// Expose the MPSolverParameters::IncrementalityValues enum.
%unignore operations_research::MPSolverParameters::IncrementalityValues;  // no test
%unignore operations_research::MPSolverParameters::INCREMENTALITY_OFF;  // no test
%unignore operations_research::MPSolverParameters::INCREMENTALITY_ON;  // no test
%unignore operations_research::MPSolverParameters::kDefaultIncrementality;  // no test

// Expose the MPSolverParameters::ScalingValues enum.
%unignore operations_research::MPSolverParameters::ScalingValues;  // no test
%unignore operations_research::MPSolverParameters::SCALING_OFF;  // no test
%unignore operations_research::MPSolverParameters::SCALING_ON;  // no test

// Expose the model exporters.
%unignore operations_research::MPModelExportOptions;
%unignore operations_research::MPModelExportOptions::MPModelExportOptions;
%typemap(javaclassmodifiers) operations_research::MPModelExportOptions
    "public final class";
%rename (Obfuscate) operations_research::MPModelExportOptions::obfuscate;
%rename (LogInvalidNames) operations_research::MPModelExportOptions::log_invalid_names;
%rename (ShowUnusedVariables) operations_research::MPModelExportOptions::show_unused_variables;
%rename (MaxLineLength) operations_research::MPModelExportOptions::max_line_length;

%include "ortools/linear_solver/linear_solver.h"
%include "ortools/linear_solver/model_exporter.h"

%unignoreall