ortools-clone/ortools/linear_solver/csharp/LinearConstraint.cs

// 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.LinearSolver
{
using System;
using System.Collections.Generic;

public class LinearConstraint
{
    public virtual String ToString()
    {
        return "LinearConstraint";
    }

    public virtual Constraint Extract(Solver solver)
    {
        return null;
    }
}

public class RangeConstraint : LinearConstraint
{
    public RangeConstraint(LinearExpr expr, double lb, double ub)
    {
        this.expr_ = expr;
        this.lb_ = lb;
        this.ub_ = ub;
    }

    public override String ToString()
    {
        return "" + lb_ + " <= " + expr_.ToString() + " <= " + ub_;
    }

    public override Constraint Extract(Solver solver)
    {
        Dictionary<Variable, double> coefficients = new Dictionary<Variable, double>();
        double constant = expr_.Visit(coefficients);
        Constraint ct = solver.MakeConstraint(lb_ - constant, ub_ - constant);
        foreach (KeyValuePair<Variable, double> pair in coefficients)
        {
            ct.SetCoefficient(pair.Key, pair.Value);
        }
        return ct;
    }

    public static implicit operator bool(RangeConstraint ct)
    {
        return false;
    }

    private LinearExpr expr_;
    private double lb_;
    private double ub_;
}

public class Equality : LinearConstraint
{
    public Equality(LinearExpr left, LinearExpr right, bool equality)
    {
        this.left_ = left;
        this.right_ = right;
        this.equality_ = equality;
    }

    public override String ToString()
    {
        return "" + left_.ToString() + " == " + right_.ToString();
    }

    public override Constraint Extract(Solver solver)
    {
        if (!equality_)
        {
            throw new ArgumentException("Operator != not supported for LinearExpression");
        }
        Dictionary<Variable, double> coefficients = new Dictionary<Variable, double>();
        double constant = left_.Visit(coefficients);
        constant += right_.DoVisit(coefficients, -1);
        Constraint ct = solver.MakeConstraint(-constant, -constant);
        foreach (KeyValuePair<Variable, double> pair in coefficients)
        {
            ct.SetCoefficient(pair.Key, pair.Value);
        }
        return ct;
    }

    public static implicit operator bool(Equality ct)
    {
        return (object)ct.left_ == (object)ct.right_ ? ct.equality_ : !ct.equality_;
    }

    private LinearExpr left_;
    private LinearExpr right_;
    private bool equality_;
}

public class VarEquality : LinearConstraint
{
    public VarEquality(Variable left, Variable right, bool equality)
    {
        this.left_ = left;
        this.right_ = right;
        this.equality_ = equality;
    }

    public override String ToString()
    {
        return "" + left_.Name() + " == " + right_.Name();
    }

    public override Constraint Extract(Solver solver)
    {
        Constraint ct = solver.MakeConstraint(0.0, 0.0);
        ct.SetCoefficient(left_, 1.0);
        ct.SetCoefficient(right_, -1.0);
        return ct;
    }

    public static implicit operator bool(VarEquality ct)
    {
        return (object)ct.left_ == (object)ct.right_ ? ct.equality_ : !ct.equality_;
    }

    private Variable left_;
    private Variable right_;
    private bool equality_;
}

// TODO(user): Try to move this code back to the .i with @define macros.
public partial class MPConstraintVector : IDisposable,
                                          System.Collections.IEnumerable
#if !SWIG_DOTNET_1
    ,
                                          System.Collections.Generic.IList<Constraint>
#endif
{
    // cast from C# MPConstraint array
    public static implicit operator MPConstraintVector(Constraint[] inVal)
    {
        var outVal = new MPConstraintVector();
        foreach (Constraint element in inVal)
        {
            outVal.Add(element);
        }
        return outVal;
    }

    // cast to C# MPConstraint array
    public static implicit operator Constraint[](MPConstraintVector inVal)
    {
        var outVal = new Constraint[inVal.Count];
        inVal.CopyTo(outVal);
        return outVal;
    }
}
} // namespace Google.OrTools.LinearSolver