62cbe9a228
- Create native project runtime.{rid}.Google.OrTools
- follow the microsoft convention e.g.:
https://www.nuget.org/packages/Microsoft.NETCore.App/
https://www.nuget.org/packages/runtime.linux-x64.Microsoft.NETCore.App/
- Target `make_dotnet` targets local nupkg instead of dll.
- Use 4096 RSA key for or-tools.snk
- Clean nuget cache in `clean_dotnet` recipe
Refactor:
- Move cs files to ortools/*/csharp
- Move dotnet project to ortools/dotnet/Google.OrTools
- Move example generation to temp_dotnet
- Avoid to mess the `BIN_DIR`
- Rework Google.OrTools.FSharp
Cleanup:
- Remove deps to netfx.props since we only support:
netstandard2.0 TFM and netcoreapp2.1 Runtime TFM
- Remove OrTools.nuspec.in
-> use newly added properties to .csproj format
- Remove of ortools/dotnet/OrTools project
- replaced by ortools/dotnet/Google.OrTools
- Remove provided protobuf.dll.
- Automatically retrieved from nuget.org
Misc:
- Add **/*.csproj to gitignore
- Add **/runtime.json to gitignore
- dotnet: Makefile windows fix
- make.exe doesn't support `else ifeq`
518 lines
18 KiB
C#
518 lines
18 KiB
C#
// Copyright 2010-2017 Google
|
|
// 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 partial class Solver : IDisposable {
|
|
public IntVar[] MakeIntVarArray(int count, long min, long max) {
|
|
IntVar[] array = new IntVar[count];
|
|
for (int i = 0; i < count; ++i) {
|
|
array[i] = MakeIntVar(min, max);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[] MakeIntVarArray(int count, long min, long max, string name) {
|
|
IntVar[] array = new IntVar[count];
|
|
for (int i = 0; i < count; ++i) {
|
|
string var_name = name + i;
|
|
array[i] = MakeIntVar(min, max, var_name);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[] MakeIntVarArray(int count, long[] values) {
|
|
IntVar[] array = new IntVar[count];
|
|
for (int i = 0; i < count; ++i) {
|
|
array[i] = MakeIntVar(values);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[] MakeIntVarArray(int count, long[] values, string name) {
|
|
IntVar[] array = new IntVar[count];
|
|
for (int i = 0; i < count; ++i) {
|
|
string var_name = name + i;
|
|
array[i] = MakeIntVar(values, var_name);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[] MakeIntVarArray(int count, int[] values) {
|
|
IntVar[] array = new IntVar[count];
|
|
for (int i = 0; i < count; ++i) {
|
|
array[i] = MakeIntVar(values);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[] MakeIntVarArray(int count, int[] values, string name) {
|
|
IntVar[] array = new IntVar[count];
|
|
for (int i = 0; i < count; ++i) {
|
|
string var_name = name + i;
|
|
array[i] = MakeIntVar(values, var_name);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[] MakeBoolVarArray(int count) {
|
|
IntVar[] array = new IntVar[count];
|
|
for (int i = 0; i < count; ++i) {
|
|
array[i] = MakeBoolVar();
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[] MakeBoolVarArray(int count, string name) {
|
|
IntVar[] array = new IntVar[count];
|
|
for (int i = 0; i < count; ++i) {
|
|
string var_name = name + i;
|
|
array[i] = MakeBoolVar(var_name);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[,] MakeIntVarMatrix(int rows, int cols, long min, long max) {
|
|
IntVar[,] array = new IntVar[rows, cols];
|
|
for (int i = 0; i < rows; ++i) {
|
|
for (int j = 0; j < cols; ++j) {
|
|
array[i,j] = MakeIntVar(min, max);
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[,] MakeIntVarMatrix(int rows, int cols,
|
|
long min, long max, string name) {
|
|
IntVar[,] array = new IntVar[rows, cols];
|
|
for (int i = 0; i < rows; ++i) {
|
|
for (int j = 0; j < cols; ++j) {
|
|
string var_name = name + "["+ i + ", " + j +"]";
|
|
array[i,j] = MakeIntVar(min, max, var_name);
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[,] MakeIntVarMatrix(int rows, int cols, long[] values) {
|
|
IntVar[,] array = new IntVar[rows, cols];
|
|
for (int i = 0; i < rows; ++i) {
|
|
for (int j = 0; j < cols; ++j) {
|
|
array[i,j] = MakeIntVar(values);
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[,] MakeIntVarMatrix(int rows, int cols,
|
|
long[] values, string name) {
|
|
IntVar[,] array = new IntVar[rows, cols];
|
|
for (int i = 0; i < rows; ++i) {
|
|
for (int j = 0; j < cols; ++j) {
|
|
string var_name = name + "["+ i + ", " + j +"]";
|
|
array[i,j] = MakeIntVar(values, var_name);
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[,] MakeIntVarMatrix(int rows, int cols, int[] values) {
|
|
IntVar[,] array = new IntVar[rows, cols];
|
|
for (int i = 0; i < rows; ++i) {
|
|
for (int j = 0; j < cols; ++j) {
|
|
array[i,j] = MakeIntVar(values);
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[,] MakeIntVarMatrix(int rows, int cols,
|
|
int[] values, string name) {
|
|
IntVar[,] array = new IntVar[rows, cols];
|
|
for (int i = 0; i < rows; ++i) {
|
|
for (int j = 0; j < cols; ++j) {
|
|
string var_name = name + "["+ i + ", " + j +"]";
|
|
array[i,j] = MakeIntVar(values, var_name);
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[,] MakeBoolVarMatrix(int rows, int cols) {
|
|
IntVar[,] array = new IntVar[rows, cols];
|
|
for (int i = 0; i < rows; ++i) {
|
|
for (int j = 0; j < cols; ++j) {
|
|
array[i,j] = MakeBoolVar();
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntVar[,] MakeBoolVarMatrix(int rows, int cols, string name) {
|
|
IntVar[,] array = new IntVar[rows, cols];
|
|
for (int i = 0; i < rows; ++i) {
|
|
for (int j = 0; j < cols; ++j) {
|
|
string var_name = name + "["+ i + ", " + j +"]";
|
|
array[i,j] = MakeBoolVar(var_name);
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntervalVar[] MakeFixedDurationIntervalVarArray(int count,
|
|
long start_min,
|
|
long start_max,
|
|
long duration,
|
|
bool optional) {
|
|
IntervalVar[] array = new IntervalVar[count];
|
|
for (int i = 0; i < count; ++i) {
|
|
array[i] = MakeFixedDurationIntervalVar(start_min,
|
|
start_max,
|
|
duration,
|
|
optional,
|
|
"");
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntervalVar[] MakeFixedDurationIntervalVarArray(int count,
|
|
long start_min,
|
|
long start_max,
|
|
long duration,
|
|
bool optional,
|
|
string name) {
|
|
IntervalVar[] array = new IntervalVar[count];
|
|
for (int i = 0; i < count; ++i) {
|
|
array[i] = MakeFixedDurationIntervalVar(start_min,
|
|
start_max,
|
|
duration,
|
|
optional,
|
|
name + i);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntervalVar[] MakeFixedDurationIntervalVarArray(int count,
|
|
long[] start_min,
|
|
long[] start_max,
|
|
long[] duration,
|
|
bool optional,
|
|
string name) {
|
|
IntervalVar[] array = new IntervalVar[count];
|
|
for (int i = 0; i < count; ++i) {
|
|
array[i] = MakeFixedDurationIntervalVar(start_min[i],
|
|
start_max[i],
|
|
duration[i],
|
|
optional,
|
|
name + i);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public IntervalVar[] MakeFixedDurationIntervalVarArray(int count,
|
|
int[] start_min,
|
|
int[] start_max,
|
|
int[] duration,
|
|
bool optional,
|
|
string name) {
|
|
IntervalVar[] array = new IntervalVar[count];
|
|
for (int i = 0; i < count; ++i) {
|
|
array[i] = MakeFixedDurationIntervalVar(start_min[i],
|
|
start_max[i],
|
|
duration[i],
|
|
optional,
|
|
name + i);
|
|
}
|
|
return array;
|
|
}
|
|
public IntervalVar[] MakeFixedDurationIntervalVarArray(IntVar[] starts,
|
|
int[] durations,
|
|
string name) {
|
|
int count = starts.Length;
|
|
IntervalVar[] array = new IntervalVar[count];
|
|
for (int i = 0; i < count; ++i) {
|
|
array[i] = MakeFixedDurationIntervalVar(starts[i],
|
|
durations[i],
|
|
name + i);
|
|
}
|
|
return array;
|
|
}
|
|
public IntervalVar[] MakeFixedDurationIntervalVarArray(IntVar[] starts,
|
|
long[] durations,
|
|
string name) {
|
|
int count = starts.Length;
|
|
IntervalVar[] array = new IntervalVar[count];
|
|
for (int i = 0; i < count; ++i) {
|
|
array[i] = MakeFixedDurationIntervalVar(starts[i],
|
|
durations[i],
|
|
name + i);
|
|
}
|
|
return array;
|
|
}
|
|
public void NewSearch(DecisionBuilder db) {
|
|
pinned_decision_builder_ = db;
|
|
pinned_search_monitors_.Clear();
|
|
NewSearchAux(db);
|
|
}
|
|
|
|
public void NewSearch(DecisionBuilder db, SearchMonitor sm1) {
|
|
pinned_decision_builder_ = db;
|
|
pinned_search_monitors_.Clear();
|
|
pinned_search_monitors_.Add(sm1);
|
|
NewSearchAux(db, sm1);
|
|
}
|
|
|
|
|
|
public void NewSearch(DecisionBuilder db,
|
|
SearchMonitor sm1,
|
|
SearchMonitor sm2) {
|
|
pinned_decision_builder_ = db;
|
|
pinned_search_monitors_.Clear();
|
|
pinned_search_monitors_.Add(sm1);
|
|
pinned_search_monitors_.Add(sm2);
|
|
NewSearchAux(db, sm1, sm2);
|
|
}
|
|
|
|
public void NewSearch(DecisionBuilder db,
|
|
SearchMonitor sm1,
|
|
SearchMonitor sm2,
|
|
SearchMonitor sm3) {
|
|
pinned_decision_builder_ = db;
|
|
pinned_search_monitors_.Clear();
|
|
pinned_search_monitors_.Add(sm1);
|
|
pinned_search_monitors_.Add(sm2);
|
|
pinned_search_monitors_.Add(sm3);
|
|
NewSearchAux(db, sm1, sm2, sm3);
|
|
}
|
|
|
|
public void NewSearch(DecisionBuilder db,
|
|
SearchMonitor sm1,
|
|
SearchMonitor sm2,
|
|
SearchMonitor sm3,
|
|
SearchMonitor sm4) {
|
|
pinned_decision_builder_ = db;
|
|
pinned_search_monitors_.Clear();
|
|
pinned_search_monitors_.Add(sm1);
|
|
pinned_search_monitors_.Add(sm2);
|
|
pinned_search_monitors_.Add(sm3);
|
|
pinned_search_monitors_.Add(sm4);
|
|
NewSearchAux(db, sm1, sm2, sm3, sm4);
|
|
}
|
|
|
|
public void NewSearch(DecisionBuilder db, SearchMonitor[] monitors) {
|
|
pinned_decision_builder_ = db;
|
|
pinned_search_monitors_.Clear();
|
|
pinned_search_monitors_.AddRange(monitors);
|
|
NewSearchAux(db, monitors);
|
|
}
|
|
|
|
public void EndSearch() {
|
|
pinned_decision_builder_ = null;
|
|
pinned_search_monitors_.Clear();
|
|
EndSearchAux();
|
|
}
|
|
|
|
private System.Collections.Generic.List<SearchMonitor> pinned_search_monitors_
|
|
= new System.Collections.Generic.List<SearchMonitor>();
|
|
private DecisionBuilder pinned_decision_builder_;
|
|
}
|
|
|
|
public partial class IntExpr : PropagationBaseObject {
|
|
public static IntExpr operator+(IntExpr a, IntExpr b) {
|
|
return a.solver().MakeSum(a, b);
|
|
}
|
|
public static IntExpr operator+(IntExpr a, long v) {
|
|
return a.solver().MakeSum(a, v);
|
|
}
|
|
public static IntExpr operator+(long v, IntExpr a) {
|
|
return a.solver().MakeSum(a, v);
|
|
}
|
|
public static IntExpr operator-(IntExpr a, IntExpr b) {
|
|
return a.solver().MakeDifference(a, b);
|
|
}
|
|
public static IntExpr operator-(IntExpr a, long v) {
|
|
return a.solver().MakeSum(a, -v);
|
|
}
|
|
public static IntExpr operator-(long v, IntExpr a) {
|
|
return a.solver().MakeDifference(v, a);
|
|
}
|
|
public static IntExpr operator*(IntExpr a, IntExpr b) {
|
|
return a.solver().MakeProd(a, b);
|
|
}
|
|
public static IntExpr operator*(IntExpr a, long v) {
|
|
return a.solver().MakeProd(a, v);
|
|
}
|
|
public static IntExpr operator*(long v, IntExpr a) {
|
|
return a.solver().MakeProd(a, v);
|
|
}
|
|
public static IntExpr operator/(IntExpr a, long v) {
|
|
return a.solver().MakeDiv(a, v);
|
|
}
|
|
public static IntExpr operator%(IntExpr a, long v) {
|
|
return a.solver().MakeModulo(a, v);
|
|
}
|
|
public static IntExpr operator-(IntExpr a) {
|
|
return a.solver().MakeOpposite(a);
|
|
}
|
|
public IntExpr Abs() {
|
|
return this.solver().MakeAbs(this);
|
|
}
|
|
public IntExpr Square() {
|
|
return this.solver().MakeSquare(this);
|
|
}
|
|
public static IntExprEquality operator ==(IntExpr a, IntExpr b) {
|
|
return new IntExprEquality(a, b, true);
|
|
}
|
|
public static IntExprEquality operator !=(IntExpr a, IntExpr b) {
|
|
return new IntExprEquality(a, b, false);
|
|
}
|
|
public static WrappedConstraint operator ==(IntExpr a, long v) {
|
|
return new WrappedConstraint(a.solver().MakeEquality(a, v));
|
|
}
|
|
public static WrappedConstraint operator !=(IntExpr a, long v) {
|
|
return new WrappedConstraint(a.solver().MakeNonEquality(a.Var(), v));
|
|
}
|
|
public static WrappedConstraint operator >=(IntExpr a, long v) {
|
|
return new WrappedConstraint(a.solver().MakeGreaterOrEqual(a, v));
|
|
}
|
|
public static WrappedConstraint operator >(IntExpr a, long v) {
|
|
return new WrappedConstraint(a.solver().MakeGreater(a, v));
|
|
}
|
|
public static WrappedConstraint operator <=(IntExpr a, long v) {
|
|
return new WrappedConstraint(a.solver().MakeLessOrEqual(a, v));
|
|
}
|
|
public static WrappedConstraint operator <(IntExpr a, long v) {
|
|
return new WrappedConstraint(a.solver().MakeLess(a, v));
|
|
}
|
|
public static WrappedConstraint operator >=(IntExpr a, IntExpr b) {
|
|
return new WrappedConstraint(a.solver().MakeGreaterOrEqual(a.Var(), b.Var()));
|
|
}
|
|
public static WrappedConstraint operator >(IntExpr a, IntExpr b) {
|
|
return new WrappedConstraint(a.solver().MakeGreater(a.Var(), b.Var()));
|
|
}
|
|
public static WrappedConstraint operator <=(IntExpr a, IntExpr b) {
|
|
return new WrappedConstraint(a.solver().MakeLessOrEqual(a.Var(), b.Var()));
|
|
}
|
|
public static WrappedConstraint operator <(IntExpr a, IntExpr b) {
|
|
return new WrappedConstraint(a.solver().MakeLess(a.Var(), b.Var()));
|
|
}
|
|
}
|
|
|
|
public partial class Constraint : PropagationBaseObject, IConstraintWithStatus {
|
|
public static implicit operator IntVar(Constraint eq)
|
|
{
|
|
return eq.Var();
|
|
}
|
|
|
|
public static implicit operator IntExpr(Constraint eq)
|
|
{
|
|
return eq.Var();
|
|
}
|
|
public static IntExpr operator+(Constraint a, Constraint b) {
|
|
return a.solver().MakeSum(a.Var(), b.Var());
|
|
}
|
|
public static IntExpr operator+(Constraint a, long v) {
|
|
return a.solver().MakeSum(a.Var(), v);
|
|
}
|
|
public static IntExpr operator+(long v, Constraint a) {
|
|
return a.solver().MakeSum(a.Var(), v);
|
|
}
|
|
public static IntExpr operator-(Constraint a, Constraint b) {
|
|
return a.solver().MakeDifference(a.Var(), b.Var());
|
|
}
|
|
public static IntExpr operator-(Constraint a, long v) {
|
|
return a.solver().MakeSum(a.Var(), -v);
|
|
}
|
|
public static IntExpr operator-(long v, Constraint a) {
|
|
return a.solver().MakeDifference(v, a.Var());
|
|
}
|
|
public static IntExpr operator*(Constraint a, Constraint b) {
|
|
return a.solver().MakeProd(a.Var(), b.Var());
|
|
}
|
|
public static IntExpr operator*(Constraint a, long v) {
|
|
return a.solver().MakeProd(a.Var(), v);
|
|
}
|
|
public static IntExpr operator*(long v, Constraint a) {
|
|
return a.solver().MakeProd(a.Var(), v);
|
|
}
|
|
public static IntExpr operator/(Constraint a, long v) {
|
|
return a.solver().MakeDiv(a.Var(), v);
|
|
}
|
|
public static IntExpr operator-(Constraint 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 ==(Constraint a, long v) {
|
|
return new WrappedConstraint(a.solver().MakeEquality(a.Var(), v));
|
|
}
|
|
public static WrappedConstraint operator ==(long v, Constraint a) {
|
|
return new WrappedConstraint(a.solver().MakeEquality(a.Var(), v));
|
|
}
|
|
public static WrappedConstraint operator !=(Constraint a, long v) {
|
|
return new WrappedConstraint(a.solver().MakeNonEquality(a.Var(), v));
|
|
}
|
|
public static WrappedConstraint operator !=(long v, Constraint a) {
|
|
return new WrappedConstraint(a.solver().MakeNonEquality(a.Var(), v));
|
|
}
|
|
public static WrappedConstraint operator >=(Constraint a, long v) {
|
|
return new WrappedConstraint(a.solver().MakeGreaterOrEqual(a.Var(), v));
|
|
}
|
|
public static WrappedConstraint operator >=(long v, Constraint a) {
|
|
return new WrappedConstraint(a.solver().MakeLessOrEqual(a.Var(), v));
|
|
}
|
|
public static WrappedConstraint operator >(Constraint a, long v) {
|
|
return new WrappedConstraint(a.solver().MakeGreater(a.Var(), v));
|
|
}
|
|
public static WrappedConstraint operator >(long v, Constraint a) {
|
|
return new WrappedConstraint(a.solver().MakeLess(a.Var(), v));
|
|
}
|
|
public static WrappedConstraint operator <=(Constraint a, long v) {
|
|
return new WrappedConstraint(a.solver().MakeLessOrEqual(a.Var(), v));
|
|
}
|
|
public static WrappedConstraint operator <=(long v, Constraint a) {
|
|
return new WrappedConstraint(a.solver().MakeGreaterOrEqual(a.Var(), v));
|
|
}
|
|
public static WrappedConstraint operator <(Constraint a, long v) {
|
|
return new WrappedConstraint(a.solver().MakeLess(a.Var(), v));
|
|
}
|
|
public static WrappedConstraint operator <(long v, Constraint a) {
|
|
return new WrappedConstraint(a.solver().MakeGreater(a.Var(), v));
|
|
}
|
|
public static WrappedConstraint operator >=(Constraint a, Constraint b) {
|
|
return new WrappedConstraint(a.solver().MakeGreaterOrEqual(a.Var(), b.Var()));
|
|
}
|
|
public static WrappedConstraint operator >(Constraint a, Constraint b) {
|
|
return new WrappedConstraint(a.solver().MakeGreater(a.Var(), b.Var()));
|
|
}
|
|
public static WrappedConstraint operator <=(Constraint a, Constraint b) {
|
|
return new WrappedConstraint(a.solver().MakeLessOrEqual(a.Var(), b.Var()));
|
|
}
|
|
public static WrappedConstraint operator <(Constraint a, Constraint b) {
|
|
return new WrappedConstraint(a.solver().MakeLess(a.Var(), b.Var()));
|
|
}
|
|
public static ConstraintEquality operator ==(Constraint a, Constraint b) {
|
|
return new ConstraintEquality(a, b, true);
|
|
}
|
|
public static ConstraintEquality operator !=(Constraint a, Constraint b) {
|
|
return new ConstraintEquality(a, b, false);
|
|
}
|
|
}
|
|
} // namespace Google.OrTools.ConstraintSolver
|