Solver.cs

Go to the documentation of this file.

//------------------------------------------------------------------------------
// <auto-generated />
//
// This file was automatically generated by SWIG (https://www.swig.org).
// Version 4.2.1
//
// Do not make changes to this file unless you know what you are doing - modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
 
namespace Google.OrTools.LinearSolver {
 
public partial class Solver : global::System.IDisposable {
  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  protected bool swigCMemOwn;
 
  internal Solver(global::System.IntPtr cPtr, bool cMemoryOwn) {
    swigCMemOwn = cMemoryOwn;
    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  }
 
  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Solver obj) {
    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  }
 
  internal static global::System.Runtime.InteropServices.HandleRef swigRelease(Solver obj) {
    if (obj != null) {
      if (!obj.swigCMemOwn)
        throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
      global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
      obj.swigCMemOwn = false;
      obj.Dispose();
      return ptr;
    } else {
      return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
    }
  }
 
  ~Solver() {
    Dispose(false);
  }
 
  public void Dispose() {
    Dispose(true);
    global::System.GC.SuppressFinalize(this);
  }
 
  protected virtual void Dispose(bool disposing) {
    lock(this) {
      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
        if (swigCMemOwn) {
          swigCMemOwn = false;
          operations_research_linear_solverPINVOKE.delete_Solver(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  }
 
  public Solver(string name, Solver.OptimizationProblemType problem_type) : this(operations_research_linear_solverPINVOKE.new_Solver(name, (int)problem_type), true) {
    if (operations_research_linear_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_linear_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public static Solver CreateSolver(string solver_id) {
    global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_CreateSolver(solver_id);
    Solver ret = (cPtr == global::System.IntPtr.Zero) ? null : new Solver(cPtr, true);
    if (operations_research_linear_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_linear_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static bool SupportsProblemType(Solver.OptimizationProblemType problem_type) {
    bool ret = operations_research_linear_solverPINVOKE.Solver_SupportsProblemType((int)problem_type);
    return ret;
  }
 
  public bool IsMip() {
    bool ret = operations_research_linear_solverPINVOKE.Solver_IsMip(swigCPtr);
    return ret;
  }
 
  public void Clear() {
    operations_research_linear_solverPINVOKE.Solver_Clear(swigCPtr);
  }
 
  public int NumVariables() {
    int ret = operations_research_linear_solverPINVOKE.Solver_NumVariables(swigCPtr);
    return ret;
  }
 
  public MPVariableVector variables() {
    MPVariableVector ret = new MPVariableVector(operations_research_linear_solverPINVOKE.Solver_variables(swigCPtr), false);
    return ret;
  }
 
  public Variable Variable(int index) {
    global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_Variable(swigCPtr, index);
    Variable ret = (cPtr == global::System.IntPtr.Zero) ? null : new Variable(cPtr, false);
    return ret;
  }
 
  public Variable LookupVariableOrNull(string var_name) {
    global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_LookupVariableOrNull(swigCPtr, var_name);
    Variable ret = (cPtr == global::System.IntPtr.Zero) ? null : new Variable(cPtr, false);
    if (operations_research_linear_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_linear_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Variable MakeVar(double lb, double ub, bool integer, string name) {
    global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_MakeVar(swigCPtr, lb, ub, integer, name);
    Variable ret = (cPtr == global::System.IntPtr.Zero) ? null : new Variable(cPtr, false);
    if (operations_research_linear_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_linear_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Variable MakeNumVar(double lb, double ub, string name) {
    global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_MakeNumVar(swigCPtr, lb, ub, name);
    Variable ret = (cPtr == global::System.IntPtr.Zero) ? null : new Variable(cPtr, false);
    if (operations_research_linear_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_linear_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Variable MakeIntVar(double lb, double ub, string name) {
    global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_MakeIntVar(swigCPtr, lb, ub, name);
    Variable ret = (cPtr == global::System.IntPtr.Zero) ? null : new Variable(cPtr, false);
    if (operations_research_linear_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_linear_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Variable MakeBoolVar(string name) {
    global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_MakeBoolVar(swigCPtr, name);
    Variable ret = (cPtr == global::System.IntPtr.Zero) ? null : new Variable(cPtr, false);
    if (operations_research_linear_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_linear_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public int NumConstraints() {
    int ret = operations_research_linear_solverPINVOKE.Solver_NumConstraints(swigCPtr);
    return ret;
  }
 
  public MPConstraintVector constraints() {
    MPConstraintVector ret = new MPConstraintVector(operations_research_linear_solverPINVOKE.Solver_constraints(swigCPtr), false);
    return ret;
  }
 
  public Constraint Constraint(int index) {
    global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_Constraint(swigCPtr, index);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint LookupConstraintOrNull(string constraint_name) {
    global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_LookupConstraintOrNull(swigCPtr, constraint_name);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_linear_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_linear_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeConstraint(double lb, double ub) {
    global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_MakeConstraint__SWIG_0(swigCPtr, lb, ub);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeConstraint() {
    global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_MakeConstraint__SWIG_1(swigCPtr);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeConstraint(double lb, double ub, string name) {
    global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_MakeConstraint__SWIG_2(swigCPtr, lb, ub, name);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_linear_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_linear_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeConstraint(string name) {
    global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_MakeConstraint__SWIG_3(swigCPtr, name);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_linear_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_linear_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Objective Objective() {
    global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_Objective(swigCPtr);
    Objective ret = (cPtr == global::System.IntPtr.Zero) ? null : new Objective(cPtr, false);
    return ret;
  }
 
  public Solver.ResultStatus Solve() {
    Solver.ResultStatus ret = (Solver.ResultStatus)operations_research_linear_solverPINVOKE.Solver_Solve__SWIG_0(swigCPtr);
    return ret;
  }
 
  public Solver.ResultStatus Solve(MPSolverParameters param) {
    Solver.ResultStatus ret = (Solver.ResultStatus)operations_research_linear_solverPINVOKE.Solver_Solve__SWIG_1(swigCPtr, MPSolverParameters.getCPtr(param));
    if (operations_research_linear_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_linear_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public  double[]  ComputeConstraintActivities() {
  global::System.IntPtr cPtr = operations_research_linear_solverPINVOKE.Solver_ComputeConstraintActivities(swigCPtr);
  DoubleVector tmpVector = null;
  if (cPtr != global::System.IntPtr.Zero) {
    tmpVector = new DoubleVector(cPtr, true);
    double[] outArray = new double[tmpVector.Count];
    tmpVector.CopyTo(outArray);
    return outArray;
  }
  return null;
}
 
  public bool VerifySolution(double tolerance, bool log_errors) {
    bool ret = operations_research_linear_solverPINVOKE.Solver_VerifySolution(swigCPtr, tolerance, log_errors);
    return ret;
  }
 
  public void Reset() {
    operations_research_linear_solverPINVOKE.Solver_Reset(swigCPtr);
  }
 
  public bool InterruptSolve() {
    bool ret = operations_research_linear_solverPINVOKE.Solver_InterruptSolve(swigCPtr);
    return ret;
  }
 
  public bool SetSolverSpecificParametersAsString(string parameters) {
    bool ret = operations_research_linear_solverPINVOKE.Solver_SetSolverSpecificParametersAsString(swigCPtr, parameters);
    if (operations_research_linear_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_linear_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void EnableOutput() {
    operations_research_linear_solverPINVOKE.Solver_EnableOutput(swigCPtr);
  }
 
  public void SuppressOutput() {
    operations_research_linear_solverPINVOKE.Solver_SuppressOutput(swigCPtr);
  }
 
  public long Iterations() {
    long ret = operations_research_linear_solverPINVOKE.Solver_Iterations(swigCPtr);
    return ret;
  }
 
  public long Nodes() {
    long ret = operations_research_linear_solverPINVOKE.Solver_Nodes(swigCPtr);
    return ret;
  }
 
  public string SolverVersion() {
    string ret = operations_research_linear_solverPINVOKE.Solver_SolverVersion(swigCPtr);
    return ret;
  }
 
  public double ComputeExactConditionNumber() {
    double ret = operations_research_linear_solverPINVOKE.Solver_ComputeExactConditionNumber(swigCPtr);
    return ret;
  }
 
  public void SetTimeLimit(long time_limit_milliseconds) {
    operations_research_linear_solverPINVOKE.Solver_SetTimeLimit(swigCPtr, time_limit_milliseconds);
  }
 
  public long WallTime() {
    long ret = operations_research_linear_solverPINVOKE.Solver_WallTime(swigCPtr);
    return ret;
  }
 
  public string ExportModelAsLpFormat(bool obfuscated) {
    string ret = operations_research_linear_solverPINVOKE.Solver_ExportModelAsLpFormat(swigCPtr, obfuscated);
    return ret;
  }
 
  public string ExportModelAsMpsFormat(bool fixed_format, bool obfuscated) {
    string ret = operations_research_linear_solverPINVOKE.Solver_ExportModelAsMpsFormat(swigCPtr, fixed_format, obfuscated);
    return ret;
  }
 
  public void SetHint(MPVariableVector variables,  double[]  values) {
    operations_research_linear_solverPINVOKE.Solver_SetHint(swigCPtr, MPVariableVector.getCPtr(variables),  values.Length, values );
    if (operations_research_linear_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_linear_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool SetNumThreads(int num_theads) {
    bool ret = operations_research_linear_solverPINVOKE.Solver_SetNumThreads(swigCPtr, num_theads);
    return ret;
  }
 
  public enum OptimizationProblemType {
    CLP_LINEAR_PROGRAMMING = 0,
    GLPK_LINEAR_PROGRAMMING = 1,
    GLOP_LINEAR_PROGRAMMING = 2,
    PDLP_LINEAR_PROGRAMMING = 8,
    SCIP_MIXED_INTEGER_PROGRAMMING = 3,
    GLPK_MIXED_INTEGER_PROGRAMMING = 4,
    CBC_MIXED_INTEGER_PROGRAMMING = 5,
    BOP_INTEGER_PROGRAMMING = 12,
    SAT_INTEGER_PROGRAMMING = 14,
    GUROBI_LINEAR_PROGRAMMING = 6,
    GUROBI_MIXED_INTEGER_PROGRAMMING = 7,
    CPLEX_LINEAR_PROGRAMMING = 10,
    CPLEX_MIXED_INTEGER_PROGRAMMING = 11,
    XPRESS_LINEAR_PROGRAMMING = 101,
    XPRESS_MIXED_INTEGER_PROGRAMMING = 102
  }
 
  public enum ResultStatus {
    OPTIMAL,
    FEASIBLE,
    INFEASIBLE,
    UNBOUNDED,
    ABNORMAL,
    MODEL_INVALID,
    NOT_SOLVED = 6
  }
 
  public enum BasisStatus {
    FREE = 0,
    AT_LOWER_BOUND,
    AT_UPPER_BOUND,
    FIXED_VALUE,
    BASIC
  }
 
}
 
}