ValCstPair.cs

Go to the documentation of this file.

// Copyright 2010-2024 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.ConstraintSolver
{
using System;
using System.Collections.Generic;
 
public interface IConstraintWithStatus
{
    Solver solver();
    IntVar Var();
}
 
public abstract class BaseEquality : IConstraintWithStatus
{
    abstract public Solver solver();
    abstract public IntVar Var();
 
    public static IntExpr operator +(BaseEquality a, BaseEquality b)
    {
        return a.solver().MakeSum(a.Var(), b.Var());
    }
    public static IntExpr operator +(BaseEquality a, long v)
    {
        return a.solver().MakeSum(a.Var(), v);
    }
    public static IntExpr operator +(long v, BaseEquality a)
    {
        return a.solver().MakeSum(a.Var(), v);
    }
    public static IntExpr operator -(BaseEquality a, BaseEquality b)
    {
        return a.solver().MakeDifference(a.Var(), b.Var());
    }
    public static IntExpr operator -(BaseEquality a, long v)
    {
        return a.solver().MakeSum(a.Var(), -v);
    }
    public static IntExpr operator -(long v, BaseEquality a)
    {
        return a.solver().MakeDifference(v, a.Var());
    }
    public static IntExpr operator *(BaseEquality a, BaseEquality b)
    {
        return a.solver().MakeProd(a.Var(), b.Var());
    }
    public static IntExpr operator *(BaseEquality a, long v)
    {
        return a.solver().MakeProd(a.Var(), v);
    }
    public static IntExpr operator *(long v, BaseEquality a)
    {
        return a.solver().MakeProd(a.Var(), v);
    }
    public static IntExpr operator /(BaseEquality a, long v)
    {
        return a.solver().MakeDiv(a.Var(), v);
    }
    public static IntExpr operator -(BaseEquality a)
    {
        return a.solver().MakeOpposite(a.Var());
    }
    public IntExpr Abs()
    {
        return this.solver().MakeAbs(this.Var());
    }
    public IntExpr Square()
    {
        return this.solver().MakeSquare(this.Var());
    }
    public static WrappedConstraint operator ==(BaseEquality a, long v)
    {
        return new WrappedConstraint(a.solver().MakeEquality(a.Var(), v));
    }
    public static WrappedConstraint operator ==(long v, BaseEquality a)
    {
        return new WrappedConstraint(a.solver().MakeEquality(a.Var(), v));
    }
    public static WrappedConstraint operator !=(BaseEquality a, long v)
    {
        return new WrappedConstraint(a.solver().MakeNonEquality(a.Var(), v));
    }
    public static WrappedConstraint operator !=(long v, BaseEquality a)
    {
        return new WrappedConstraint(a.solver().MakeNonEquality(a.Var(), v));
    }
    public static WrappedConstraint operator >=(BaseEquality a, long v)
    {
        return new WrappedConstraint(a.solver().MakeGreaterOrEqual(a.Var(), v));
    }
    public static WrappedConstraint operator >=(long v, BaseEquality a)
    {
        return new WrappedConstraint(a.solver().MakeLessOrEqual(a.Var(), v));
    }
    public static WrappedConstraint operator>(BaseEquality a, long v)
    {
        return new WrappedConstraint(a.solver().MakeGreater(a.Var(), v));
    }
    public static WrappedConstraint operator>(long v, BaseEquality a)
    {
        return new WrappedConstraint(a.solver().MakeLess(a.Var(), v));
    }
    public static WrappedConstraint operator <=(BaseEquality a, long v)
    {
        return new WrappedConstraint(a.solver().MakeLessOrEqual(a.Var(), v));
    }
    public static WrappedConstraint operator <=(long v, BaseEquality a)
    {
        return new WrappedConstraint(a.solver().MakeGreaterOrEqual(a.Var(), v));
    }
    public static WrappedConstraint operator<(BaseEquality a, long v)
    {
        return new WrappedConstraint(a.solver().MakeLess(a.Var(), v));
    }
    public static WrappedConstraint operator<(long v, BaseEquality a)
    {
        return new WrappedConstraint(a.solver().MakeGreater(a.Var(), v));
    }
    public static WrappedConstraint operator >=(BaseEquality a, BaseEquality b)
    {
        return new WrappedConstraint(a.solver().MakeGreaterOrEqual(a.Var(), b.Var()));
    }
    public static WrappedConstraint operator>(BaseEquality a, BaseEquality b)
    {
        return new WrappedConstraint(a.solver().MakeGreater(a.Var(), b.Var()));
    }
    public static WrappedConstraint operator <=(BaseEquality a, BaseEquality b)
    {
        return new WrappedConstraint(a.solver().MakeLessOrEqual(a.Var(), b.Var()));
    }
    public static WrappedConstraint operator<(BaseEquality a, BaseEquality b)
    {
        return new WrappedConstraint(a.solver().MakeLess(a.Var(), b.Var()));
    }
    public static ConstraintEquality operator ==(BaseEquality a, BaseEquality b)
    {
        return new ConstraintEquality(a, b, true);
    }
    public static ConstraintEquality operator !=(BaseEquality a, BaseEquality b)
    {
        return new ConstraintEquality(a, b, false);
    }
}
 
public class WrappedConstraint : BaseEquality
{
    public bool Val { get; set; }
 
    public Constraint Cst { get; set; }
 
    public WrappedConstraint(Constraint cst) : this(true, cst)
    {
    }
 
    public WrappedConstraint(bool val) : this(val, null)
    {
    }
 
    public WrappedConstraint(bool val, Constraint cst)
    {
        this.Val = val;
        this.Cst = cst;
    }
 
    public static implicit operator bool(WrappedConstraint valCstPair)
    {
        return valCstPair.Val;
    }
 
    public static implicit operator Constraint(WrappedConstraint valCstPair)
    {
        return valCstPair.Cst;
    }
 
    public static implicit operator IntVar(WrappedConstraint eq)
    {
        return eq.Var();
    }
 
    public static implicit operator IntExpr(WrappedConstraint eq)
    {
        return eq.Var();
    }
 
    public override Solver solver()
    {
        return this.Cst.solver();
    }
 
    public override IntVar Var()
    {
        return Cst.Var();
    }
}
 
public class IntExprEquality : BaseEquality
{
    public IntExprEquality(IntExpr a, IntExpr b, bool equality)
    {
        this.left_ = a;
        this.right_ = b;
        this.equality_ = equality;
    }
 
    bool IsTrue()
    {
        return (object)left_ == (object)right_ ? equality_ : !equality_;
    }
 
    Constraint ToConstraint()
    {
        return equality_ ? left_.solver().MakeEquality(left_.Var(), right_.Var())
                         : left_.solver().MakeNonEquality(left_.Var(), right_.Var());
    }
 
    public static bool operator true(IntExprEquality eq)
    {
        return eq.IsTrue();
    }
 
    public static bool operator false(IntExprEquality eq)
    {
        return !eq.IsTrue();
    }
 
    public static implicit operator Constraint(IntExprEquality eq)
    {
        return eq.ToConstraint();
    }
 
    public override IntVar Var()
    {
        return equality_ ? left_.solver().MakeIsEqualVar(left_, right_)
                         : left_.solver().MakeIsDifferentVar(left_, right_);
    }
 
    public static implicit operator IntVar(IntExprEquality eq)
    {
        return eq.Var();
    }
 
    public static implicit operator IntExpr(IntExprEquality eq)
    {
        return eq.Var();
    }
 
    public override Solver solver()
    {
        return left_.solver();
    }
 
    private IntExpr left_;
    private IntExpr right_;
    private bool equality_;
}
 
public class ConstraintEquality : BaseEquality
{
    public ConstraintEquality(IConstraintWithStatus a, IConstraintWithStatus b, bool equality)
    {
        this.left_ = a;
        this.right_ = b;
        this.equality_ = equality;
    }
 
    bool IsTrue()
    {
        return (object)left_ == (object)right_ ? equality_ : !equality_;
    }
 
    Constraint ToConstraint()
    {
        return equality_ ? left_.solver().MakeEquality(left_.Var(), right_.Var())
                         : left_.solver().MakeNonEquality(left_.Var(), right_.Var());
    }
 
    public static bool operator true(ConstraintEquality eq)
    {
        return eq.IsTrue();
    }
 
    public static bool operator false(ConstraintEquality eq)
    {
        return !eq.IsTrue();
    }
 
    public static implicit operator Constraint(ConstraintEquality eq)
    {
        return eq.ToConstraint();
    }
 
    public override IntVar Var()
    {
        return equality_ ? left_.solver().MakeIsEqualVar(left_.Var(), right_.Var())
                         : left_.solver().MakeIsDifferentVar(left_.Var(), right_.Var());
    }
 
    public static implicit operator IntVar(ConstraintEquality eq)
    {
        return eq.Var();
    }
 
    public static implicit operator IntExpr(ConstraintEquality eq)
    {
        return eq.Var();
    }
 
    public override Solver solver()
    {
        return left_.solver();
    }
 
    private IConstraintWithStatus left_;
    private IConstraintWithStatus right_;
    private bool equality_;
}
} // namespace Google.OrTools.ConstraintSolver