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

// Copyright 2010-2018 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)
  {
    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 .swig 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