394 lines
12 KiB
C#
394 lines
12 KiB
C#
// Copyright 2010-2022 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;
|
|
|
|
// IntVar[] helper class.
|
|
public static class IntVarArrayHelper
|
|
{
|
|
// All Different
|
|
public static Constraint AllDifferent(this IntVar[] vars)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeAllDifferent(vars);
|
|
}
|
|
// Allowed assignment
|
|
public static Constraint AllowedAssignments(this IntVar[] vars, IntTupleSet tuples)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeAllowedAssignments(vars, tuples);
|
|
}
|
|
// sum of all vars.
|
|
public static IntExpr Sum(this IntVar[] vars)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeSum(vars);
|
|
}
|
|
// sum of all constraints.
|
|
public static IntExpr Sum(this IConstraintWithStatus[] cts)
|
|
{
|
|
Solver solver = GetSolver(cts);
|
|
IntVar[] vars = new IntVar[cts.Length];
|
|
for (int i = 0; i < cts.Length; ++i)
|
|
{
|
|
vars[i] = cts[i].Var();
|
|
}
|
|
return solver.MakeSum(vars);
|
|
}
|
|
public static IntExpr Sum(this IntExpr[] exprs)
|
|
{
|
|
Solver solver = GetSolver(exprs);
|
|
IntVar[] vars = new IntVar[exprs.Length];
|
|
for (int i = 0; i < exprs.Length; ++i)
|
|
{
|
|
vars[i] = exprs[i].Var();
|
|
}
|
|
return solver.MakeSum(vars);
|
|
}
|
|
|
|
// scalar product
|
|
public static IntExpr ScalProd(this IntVar[] vars, long[] coefs)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeScalProd(vars, coefs);
|
|
}
|
|
|
|
// scalar product
|
|
public static IntExpr ScalProd(this IntVar[] vars, int[] coefs)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeScalProd(vars, coefs);
|
|
}
|
|
|
|
// get solver from array of integer variables
|
|
private static Solver GetSolver(IntVar[] vars)
|
|
{
|
|
if (vars is null || vars.Length <= 0)
|
|
throw new ArgumentException("Array <vars> cannot be null or empty");
|
|
|
|
return vars[0].solver();
|
|
}
|
|
// get solver from array of integer expressions
|
|
private static Solver GetSolver(IntExpr[] expressions)
|
|
{
|
|
if (expressions is null || expressions.Length <= 0)
|
|
throw new ArgumentException("Array <expr> cannot be null or empty");
|
|
|
|
return expressions[0].solver();
|
|
}
|
|
private static Solver GetSolver(IConstraintWithStatus[] cts)
|
|
{
|
|
if (cts is null || cts.Length <= 0)
|
|
throw new ArgumentException("Array <cts> cannot be null or empty");
|
|
|
|
return cts[0].solver();
|
|
}
|
|
public static IntExpr Element(this IntVar[] array, IntExpr index)
|
|
{
|
|
return index.solver().MakeElement(array, index.Var());
|
|
}
|
|
// min of all vars.
|
|
public static IntExpr Min(this IntVar[] vars)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeMin(vars);
|
|
}
|
|
// min of all vars.
|
|
public static IntExpr Max(this IntVar[] vars)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeMax(vars);
|
|
}
|
|
// count of all vars.
|
|
public static Constraint Count(this IntVar[] vars, long value, long count)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeCount(vars, value, count);
|
|
}
|
|
// count of all vars.
|
|
public static Constraint Count(this IntVar[] vars, long value, IntExpr count)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeCount(vars, value, count.Var());
|
|
}
|
|
public static Constraint Distribute(this IntVar[] vars, long[] values, IntVar[] cards)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeDistribute(vars, values, cards);
|
|
}
|
|
public static Constraint Distribute(this IntVar[] vars, int[] values, IntVar[] cards)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeDistribute(vars, values, cards);
|
|
}
|
|
public static Constraint Distribute(this IntVar[] vars, IntVar[] cards)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeDistribute(vars, cards);
|
|
}
|
|
public static Constraint Distribute(this IntVar[] vars, long card_min, long card_max, long card_size)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeDistribute(vars, card_min, card_max, card_size);
|
|
}
|
|
public static Constraint Transition(this IntVar[] vars, IntTupleSet transitions, long initial_state,
|
|
long[] final_states)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeTransitionConstraint(vars, transitions, initial_state, final_states);
|
|
}
|
|
public static Constraint Transition(this IntVar[] vars, IntTupleSet transitions, long initial_state,
|
|
int[] final_states)
|
|
{
|
|
Solver solver = GetSolver(vars);
|
|
return solver.MakeTransitionConstraint(vars, transitions, initial_state, final_states);
|
|
}
|
|
|
|
// Matrix API
|
|
public static IntVar[] Flatten(this IntVar[,] vars)
|
|
{
|
|
int rows = vars.GetLength(0);
|
|
int cols = vars.GetLength(1);
|
|
IntVar[] flat = new IntVar[cols * rows];
|
|
for (int i = 0; i < rows; i++)
|
|
{
|
|
for (int j = 0; j < cols; j++)
|
|
{
|
|
flat[i * cols + j] = vars[i, j];
|
|
}
|
|
}
|
|
return flat;
|
|
}
|
|
}
|
|
|
|
// TODO(user): Try to move this code back to the .i with @define macros.
|
|
public partial class IntVarVector : IDisposable,
|
|
System.Collections.IEnumerable
|
|
#if !SWIG_DOTNET_1
|
|
,
|
|
System.Collections.Generic.IList<IntVar>
|
|
#endif
|
|
{
|
|
// cast from C# IntVar array
|
|
public static implicit operator IntVarVector(IntVar[] inVal)
|
|
{
|
|
var outVal = new IntVarVector();
|
|
foreach (IntVar element in inVal)
|
|
{
|
|
outVal.Add(element);
|
|
}
|
|
return outVal;
|
|
}
|
|
|
|
// cast to C# IntVar array
|
|
public static implicit operator IntVar[](IntVarVector inVal)
|
|
{
|
|
var outVal = new IntVar[inVal.Count];
|
|
inVal.CopyTo(outVal);
|
|
return outVal;
|
|
}
|
|
}
|
|
|
|
public partial class SearchMonitorVector : IDisposable,
|
|
System.Collections.IEnumerable
|
|
#if !SWIG_DOTNET_1
|
|
,
|
|
System.Collections.Generic.IList<SearchMonitor>
|
|
#endif
|
|
{
|
|
// cast from C# SearchMonitor array
|
|
public static implicit operator SearchMonitorVector(SearchMonitor[] inVal)
|
|
{
|
|
var outVal = new SearchMonitorVector();
|
|
foreach (SearchMonitor element in inVal)
|
|
{
|
|
outVal.Add(element);
|
|
}
|
|
return outVal;
|
|
}
|
|
|
|
// cast to C# SearchMonitor array
|
|
public static implicit operator SearchMonitor[](SearchMonitorVector inVal)
|
|
{
|
|
var outVal = new SearchMonitor[inVal.Count];
|
|
inVal.CopyTo(outVal);
|
|
return outVal;
|
|
}
|
|
}
|
|
|
|
public partial class DecisionBuilderVector : IDisposable,
|
|
System.Collections.IEnumerable
|
|
#if !SWIG_DOTNET_1
|
|
,
|
|
System.Collections.Generic.IList<DecisionBuilder>
|
|
#endif
|
|
{
|
|
// cast from C# DecisionBuilder array
|
|
public static implicit operator DecisionBuilderVector(DecisionBuilder[] inVal)
|
|
{
|
|
var outVal = new DecisionBuilderVector();
|
|
foreach (DecisionBuilder element in inVal)
|
|
{
|
|
outVal.Add(element);
|
|
}
|
|
return outVal;
|
|
}
|
|
|
|
// cast to C# DecisionBuilder array
|
|
public static implicit operator DecisionBuilder[](DecisionBuilderVector inVal)
|
|
{
|
|
var outVal = new DecisionBuilder[inVal.Count];
|
|
inVal.CopyTo(outVal);
|
|
return outVal;
|
|
}
|
|
}
|
|
|
|
public partial class IntervalVarVector : IDisposable,
|
|
System.Collections.IEnumerable
|
|
#if !SWIG_DOTNET_1
|
|
,
|
|
System.Collections.Generic.IList<IntervalVar>
|
|
#endif
|
|
{
|
|
// cast from C# IntervalVar array
|
|
public static implicit operator IntervalVarVector(IntervalVar[] inVal)
|
|
{
|
|
var outVal = new IntervalVarVector();
|
|
foreach (IntervalVar element in inVal)
|
|
{
|
|
outVal.Add(element);
|
|
}
|
|
return outVal;
|
|
}
|
|
|
|
// cast to C# IntervalVar array
|
|
public static implicit operator IntervalVar[](IntervalVarVector inVal)
|
|
{
|
|
var outVal = new IntervalVar[inVal.Count];
|
|
inVal.CopyTo(outVal);
|
|
return outVal;
|
|
}
|
|
}
|
|
|
|
public partial class SequenceVarVector : IDisposable,
|
|
System.Collections.IEnumerable
|
|
#if !SWIG_DOTNET_1
|
|
,
|
|
System.Collections.Generic.IList<SequenceVar>
|
|
#endif
|
|
{
|
|
// cast from C# SequenceVar array
|
|
public static implicit operator SequenceVarVector(SequenceVar[] inVal)
|
|
{
|
|
var outVal = new SequenceVarVector();
|
|
foreach (SequenceVar element in inVal)
|
|
{
|
|
outVal.Add(element);
|
|
}
|
|
return outVal;
|
|
}
|
|
|
|
// cast to C# SequenceVar array
|
|
public static implicit operator SequenceVar[](SequenceVarVector inVal)
|
|
{
|
|
var outVal = new SequenceVar[inVal.Count];
|
|
inVal.CopyTo(outVal);
|
|
return outVal;
|
|
}
|
|
}
|
|
|
|
public partial class LocalSearchOperatorVector : IDisposable,
|
|
System.Collections.IEnumerable
|
|
#if !SWIG_DOTNET_1
|
|
,
|
|
System.Collections.Generic.IList<LocalSearchOperator>
|
|
#endif
|
|
{
|
|
// cast from C# LocalSearchOperator array
|
|
public static implicit operator LocalSearchOperatorVector(LocalSearchOperator[] inVal)
|
|
{
|
|
var outVal = new LocalSearchOperatorVector();
|
|
foreach (LocalSearchOperator element in inVal)
|
|
{
|
|
outVal.Add(element);
|
|
}
|
|
return outVal;
|
|
}
|
|
|
|
// cast to C# LocalSearchOperator array
|
|
public static implicit operator LocalSearchOperator[](LocalSearchOperatorVector inVal)
|
|
{
|
|
var outVal = new LocalSearchOperator[inVal.Count];
|
|
inVal.CopyTo(outVal);
|
|
return outVal;
|
|
}
|
|
}
|
|
|
|
public partial class LocalSearchFilterVector : IDisposable,
|
|
System.Collections.IEnumerable
|
|
#if !SWIG_DOTNET_1
|
|
,
|
|
System.Collections.Generic.IList<LocalSearchFilter>
|
|
#endif
|
|
{
|
|
// cast from C# LocalSearchFilter array
|
|
public static implicit operator LocalSearchFilterVector(LocalSearchFilter[] inVal)
|
|
{
|
|
var outVal = new LocalSearchFilterVector();
|
|
foreach (LocalSearchFilter element in inVal)
|
|
{
|
|
outVal.Add(element);
|
|
}
|
|
return outVal;
|
|
}
|
|
|
|
// cast to C# LocalSearchFilter array
|
|
public static implicit operator LocalSearchFilter[](LocalSearchFilterVector inVal)
|
|
{
|
|
var outVal = new LocalSearchFilter[inVal.Count];
|
|
inVal.CopyTo(outVal);
|
|
return outVal;
|
|
}
|
|
}
|
|
|
|
public partial class SymmetryBreakerVector : IDisposable,
|
|
System.Collections.IEnumerable
|
|
#if !SWIG_DOTNET_1
|
|
,
|
|
System.Collections.Generic.IList<SymmetryBreaker>
|
|
#endif
|
|
{
|
|
// cast from C# SymmetryBreaker array
|
|
public static implicit operator SymmetryBreakerVector(SymmetryBreaker[] inVal)
|
|
{
|
|
var outVal = new SymmetryBreakerVector();
|
|
foreach (SymmetryBreaker element in inVal)
|
|
{
|
|
outVal.Add(element);
|
|
}
|
|
return outVal;
|
|
}
|
|
|
|
// cast to C# SymmetryBreaker array
|
|
public static implicit operator SymmetryBreaker[](SymmetryBreakerVector inVal)
|
|
{
|
|
var outVal = new SymmetryBreaker[inVal.Count];
|
|
inVal.CopyTo(outVal);
|
|
return outVal;
|
|
}
|
|
}
|
|
} // namespace Google.OrTools.ConstraintSolver
|