ModelBuilder.cs

Go to the documentation of this file.

// 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.
 
namespace Google.OrTools.ModelBuilder
{
 
using Google.OrTools.Util;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using Google.Protobuf.Collections;

public class Model
{
    public Model()
    {
        helper_ = new ModelBuilderHelper();
        constantMap_ = new Dictionary<double, int>();
        tmp_var_value_map_ = new SortedDictionary<int, double>();
        tmp_terms_ = new Queue<Term>();
    }


    public Model Clone()
    {
        Model clonedModel = new Model();
        clonedModel.Helper.OverwriteModel(Helper);
        foreach (KeyValuePair<double, int> entry in constantMap_)
        {
            clonedModel.constantMap_[entry.Key] = entry.Value;
        }
        return clonedModel;
    }
 
    // Integer variables.

    public Variable NewVar(double lb, double ub, bool isIntegral, String name)
    {
        return new Variable(helper_, lb, ub, isIntegral, name);
    }


    public Variable NewNumVar(double lb, double ub, String name)
    {
        return new Variable(helper_, lb, ub, false, name);
    }


    public Variable NewIntVar(double lb, double ub, String name)
    {
        return new Variable(helper_, lb, ub, true, name);
    }


    public Variable NewBoolVar(String name)
    {
        return new Variable(helper_, 0, 1, true, name);
    }


    public Variable NewConstant(double value)
    {
        if (constantMap_.TryGetValue(value, out int index))
        {
            return new Variable(helper_, index);
        }
        Variable cste = new Variable(helper_, value, value, false, ""); // bounds and name.
        constantMap_.Add(value, cste.Index);
        return cste;
    }


    public Variable VarFromIndex(int index)
    {
        return new Variable(helper_, index);
    }


    public LinearConstraint Add(BoundedLinearExpression lin)
    {
        switch (lin.CtType)
        {
        case BoundedLinearExpression.Type.BoundExpression: {
            return AddLinearConstraint(lin.Left, lin.Lb, lin.Ub);
        }
        case BoundedLinearExpression.Type.VarEqVar: {
            return AddLinearConstraint(lin.Left - lin.Right, 0, 0);
        }
        case BoundedLinearExpression.Type.VarEqCst: {
            return AddLinearConstraint(lin.Left, lin.Lb, lin.Lb);
        }
        default: {
            throw new ArgumentException("Cannot use '" + lin.ToString() + "' as a linear constraint.");
        }
        }
    }


    public LinearConstraint AddLinearConstraint(LinearExpr expr, double lb, double ub)
    {
        LinearConstraint lin = new LinearConstraint(helper_);
        var dict = tmp_var_value_map_;
        dict.Clear();
        double offset = LinearExpr.GetVarValueMap(expr, dict, tmp_terms_);
        foreach (KeyValuePair<int, double> term in dict)
        {
            helper_.AddConstraintTerm(lin.Index, term.Key, term.Value);
        }
        if (lb == Double.NegativeInfinity || lb == Double.PositiveInfinity)
        {
            lin.LowerBound = lb;
        }
        else
        {
            lin.LowerBound = lb - offset;
        }
        if (ub == Double.NegativeInfinity || ub == Double.PositiveInfinity)
        {
            lin.UpperBound = ub;
        }
        else
        {
            lin.UpperBound = ub - offset;
        }
        return lin;
    }


    public LinearConstraint ConstraintFromIndex(int index)
    {
        return new LinearConstraint(helper_, index);
    }


    public EnforcedLinearConstraint AddEnforced(BoundedLinearExpression lin, Variable iVar, bool iValue)
    {
        switch (lin.CtType)
        {
        case BoundedLinearExpression.Type.BoundExpression: {
            return AddEnforcedLinearConstraint(lin.Left, lin.Lb, lin.Ub, iVar, iValue);
        }
        case BoundedLinearExpression.Type.VarEqVar: {
            return AddEnforcedLinearConstraint(lin.Left - lin.Right, 0, 0, iVar, iValue);
        }
        case BoundedLinearExpression.Type.VarEqCst: {
            return AddEnforcedLinearConstraint(lin.Left, lin.Lb, lin.Lb, iVar, iValue);
        }
        default: {
            throw new ArgumentException("Cannot use '" + lin.ToString() + "' as a linear constraint.");
        }
        }
    }


    public EnforcedLinearConstraint AddEnforcedLinearConstraint(LinearExpr expr, double lb, double ub, Variable iVar,
                                                                bool iValue)
    {
        EnforcedLinearConstraint lin = new EnforcedLinearConstraint(helper_);
        lin.IndicatorVariable = iVar;
        lin.IndicatorValue = iValue;
        var dict = tmp_var_value_map_;
        dict.Clear();
        double offset = LinearExpr.GetVarValueMap(expr, dict, tmp_terms_);
        foreach (KeyValuePair<int, double> term in dict)
        {
            helper_.AddEnforcedConstraintTerm(lin.Index, term.Key, term.Value);
        }
        if (lb == Double.NegativeInfinity || lb == Double.PositiveInfinity)
        {
            lin.LowerBound = lb;
        }
        else
        {
            lin.LowerBound = lb - offset;
        }
        if (ub == Double.NegativeInfinity || ub == Double.PositiveInfinity)
        {
            lin.UpperBound = ub;
        }
        else
        {
            lin.UpperBound = ub - offset;
        }
        return lin;
    }


    public EnforcedLinearConstraint EnforcedConstraintFromIndex(int index)
    {
        return new EnforcedLinearConstraint(helper_, index);
    }
 
    // Objective.

    public void Minimize(LinearExpr obj)
    {
        Optimize(obj, false);
    }


    public void Maximize(LinearExpr obj)
    {
        Optimize(obj, true);
    }


    public void Optimize(LinearExpr obj, bool maximize)
    {
        helper_.ClearObjective();
        var dict = tmp_var_value_map_;
        dict.Clear();
        double offset = LinearExpr.GetVarValueMap(obj, dict, tmp_terms_);
        foreach (KeyValuePair<int, double> term in dict)
        {
            if (term.Value != 0.0)
            {
                helper_.SetVarObjectiveCoefficient(term.Key, term.Value);
            }
        }
        helper_.SetObjectiveOffset(offset);
        helper_.SetMaximize(maximize);
    }


    public double ObjectiveOffset
    {
        get {
            return helper_.ObjectiveOffset();
        }
        set {
            helper_.SetObjectiveOffset(value);
        }
    }


    public void ClearHints()
    {
        helper_.ClearHints();
    }


    public void AddHint(Variable var, double value)
    {
        helper_.AddHint(var.Index, value);
    }


    public int VariablesCount()
    {
        return helper_.VariablesCount();
    }


    public int ConstraintsCount()
    {
        return helper_.ConstraintsCount();
    }


    public String Name
    {
        get {
            return helper_.Name();
        }
        set {
            helper_.SetName(value);
        }
    }


    public bool ExportToFile(String file)
    {
        return helper_.WriteModelToProtoFile(file);
    }


    public bool ImportFromFile(String file)
    {
        return helper_.ReadModelFromProtoFile(file);
    }
 
    public String ExportToMpsString(bool obfuscate)
    {
        return helper_.ExportToMpsString(obfuscate);
    }
 
    public String ExportToLpString(bool obfuscate)
    {
        return helper_.ExportToLpString(obfuscate);
    }
 
    public bool WriteToMpsFile(String filename, bool obfuscate)
    {
        return helper_.WriteToMpsFile(filename, obfuscate);
    }
 
    public bool ImportFromMpsString(String mpsString)
    {
        return helper_.ImportFromMpsString(mpsString);
    }
 
    public bool ImportFromMpsFile(String mpsFile)
    {
        return helper_.ImportFromMpsString(mpsFile);
    }
 
    public bool ImportFromLpString(String lpString)
    {
        return helper_.ImportFromLpString(lpString);
    }
 
    public bool ImportFromLpFile(String lpFile)
    {
        return helper_.ImportFromMpsString(lpFile);
    }


    public ModelBuilderHelper Helper
    {
        get {
            return helper_;
        }
    }
 
    private ModelBuilderHelper helper_;
    private Dictionary<double, int> constantMap_;
 
    // Used to process linear expressions.
    private SortedDictionary<int, double> tmp_var_value_map_;
    private Queue<Term> tmp_terms_;
}
 
} // namespace Google.OrTools.ModelBuilder