private static void SolverTryout()
{
Solver s = new Solver("trysolver", Solver.OptimizationProblemType.BOP_INTEGER_PROGRAMMING);
Variable x = s.MakeIntVar(0.0, 2, "x");
Variable y = s.MakeIntVar(0.0, 2, "y");
Console.WriteLine(s.NumVariables());
s.Add(10 * x + 4 * y >= 20);
s.Add(5 * x + 5 * y >= 20);
s.Add(2 * x + 6 * y >= 12);
Console.WriteLine("Constraint Count:" + s.NumConstraints());
s.Minimize(1100 * x + 1000 * y);
Solver.ResultStatus resultStatus = s.Solve();
if (!resultStatus.Equals(Solver.ResultStatus.OPTIMAL))
{
Console.WriteLine("error");
return;
}
Console.WriteLine("Solution:");
Console.WriteLine("value: " + s.Objective().Value());
Console.WriteLine("x: " + x.SolutionValue());
Console.WriteLine("y: " + y.SolutionValue());
}
/**
* Volsay problem.
*
* From the OPL model volsay.mod.
*
* Also see
* http://www.hakank.org/or-tools/volsay.cs
* http://www.hakank.org/or-tools/volsay2.py
*/
private static void Solve()
{
Solver solver = new Solver("Volsay2", Solver.OptimizationProblemType.CLP_LINEAR_PROGRAMMING);
int num_products = 2;
IEnumerable <int> PRODUCTS = Enumerable.Range(0, num_products);
int Gas = 0;
int Chloride = 1;
String[] products = { "Gas", "Chloride" };
//
// Variables
//
Variable[] production = new Variable[num_products];
foreach (int p in PRODUCTS)
{
production[p] = solver.MakeNumVar(0, 100000, products[p]);
}
int num_constraints = 2;
IEnumerable <int> CONSTRAINTS = Enumerable.Range(0, num_constraints);
Constraint[] cons = new Constraint[num_constraints];
cons[0] = solver.Add(production[Gas] + production[Chloride] <= 50);
cons[1] = solver.Add(3 * production[Gas] + 4 * production[Chloride] <= 180);
solver.Maximize(40 * production[Gas] + 50 * production[Chloride]);
Console.WriteLine("NumConstraints: {0}", solver.NumConstraints());
Solver.ResultStatus resultStatus = solver.Solve();
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("The problem don't have an optimal solution.");
return;
}
foreach (int p in PRODUCTS)
{
Console.WriteLine("{0,-10}: {1} ReducedCost: {2}", products[p], production[p].SolutionValue(),
production[p].ReducedCost());
}
double[] activities = solver.ComputeConstraintActivities();
foreach (int c in CONSTRAINTS)
{
Console.WriteLine("Constraint {0} DualValue {1} Activity: {2} lb: {3} ub: {4}", c.ToString(),
cons[c].DualValue(), activities[cons[c].Index()], cons[c].Lb(),
cons[c].Ub());
}
Console.WriteLine("\nWallTime: " + solver.WallTime());
Console.WriteLine("Iterations: " + solver.Iterations());
}
public static void SolveInstance(RPQ_Instance instance)
{
Solver solver = Solver.CreateSolver("SimpleMipProgram",
"CBC_MIXED_INTEGER_PROGRAMMING");
//maksymalnawartosczmiennych,liczonazduzaprzesada
int variablesMaxValue = 0;
foreach (RPQ_Job job in instance.jobs)
{
variablesMaxValue += job.r + job.p + job.q;
}
//zmienne:
//alfypotrzebnedoustaleniakolejnosci:
var alfas = solver.MakeIntVarMatrix(instance.jobs.Count,
instance.jobs.Count, 0, 1);
//czasyrozpoczynaniaposzczegolnychzadan:
var starts = solver.MakeIntVarArray(instance.jobs.Count,
0, variablesMaxValue);
//cmax:
var cmax = solver.MakeIntVar(0, variablesMaxValue, "cmax");
//ograniczenia:
//kazdezzadanmusizostacnajpierwprzygotowane:
foreach (RPQ_Job job in instance.jobs)
{
solver.Add(starts[job.id] >= job.r);
}
//Cmaxmusibycmniejszyodwszystkichczasowzakonczen(zq):
foreach (RPQ_Job job in instance.jobs)
{
solver.Add(cmax >= starts[job.id] + job.p + job.q);
}
//ogariczeniaodpowiadajacezakolejnoscwykonywaniazadan:
for (int i = 0; i < instance.jobs.Count; i++)
{
for (int j = i + 1; j < instance.jobs.Count; j++)
{
var job1 = instance.jobs[i];
var job2 = instance.jobs[j];
solver.Add(starts[job1.id] + job1.p <= starts[job2.id] +
alfas[job1.id, job2.id] * variablesMaxValue);
solver.Add(starts[job2.id] + job2.p <= starts[job1.id] +
alfas[job2.id, job1.id] * variablesMaxValue);
solver.Add(alfas[job1.id, job2.id] + alfas[job2.id, job1.id] == 1);
}
}
solver.Minimize(cmax);
Solver.ResultStatus resultStatus = solver.Solve();
// Console.WriteLine(solver.);
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("Solver didn’t find optimal solution!");
}
Console.WriteLine("Objective value=" + solver.Objective().Value());
}
static void Main()
{
// [START solver]
Solver solver = Solver.CreateSolver("GLOP");
// [END solver]
// x and y are continuous non-negative variables.
// [START variables]
Variable x = solver.MakeNumVar(0.0, double.PositiveInfinity, "x");
Variable y = solver.MakeNumVar(0.0, double.PositiveInfinity, "y");
Console.WriteLine("Number of variables = " + solver.NumVariables());
// [END variables]
// [START constraints]
// x + 2y <= 14.
solver.Add(x + 2 * y <= 14.0);
// 3x - y >= 0.
solver.Add(3 * x - y >= 0.0);
// x - y <= 2.
solver.Add(x - y <= 2.0);
Console.WriteLine("Number of constraints = " + solver.NumConstraints());
// [END constraints]
// [START objective]
// Objective function: 3x + 4y.
solver.Maximize(3 * x + 4 * y);
// [END objective]
// [START solve]
Solver.ResultStatus resultStatus = solver.Solve();
// [END solve]
// [START print_solution]
// Check that the problem has an optimal solution.
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("The problem does not have an optimal solution!");
return;
}
Console.WriteLine("Solution:");
Console.WriteLine("Objective value = " + solver.Objective().Value());
Console.WriteLine("x = " + x.SolutionValue());
Console.WriteLine("y = " + y.SolutionValue());
// [END print_solution]
// [START advanced]
Console.WriteLine("\nAdvanced usage:");
Console.WriteLine("Problem solved in " + solver.WallTime() + " milliseconds");
Console.WriteLine("Problem solved in " + solver.Iterations() + " iterations");
Console.WriteLine("Problem solved in " + solver.Nodes() + " branch-and-bound nodes");
// [END advanced]
}
static void Main()
{
// [START solver]
// Create the linear solver with the SCIP backend.
Solver solver = Solver.CreateSolver("SCIP");
// [END solver]
// [START variables]
// x and y are integer non-negative variables.
Variable x = solver.MakeIntVar(0.0, double.PositiveInfinity, "x");
Variable y = solver.MakeIntVar(0.0, double.PositiveInfinity, "y");
Console.WriteLine("Number of variables = " + solver.NumVariables());
// [END variables]
// [START constraints]
// x + 7 * y <= 17.5.
solver.Add(x + 7 * y <= 17.5);
// x <= 3.5.
solver.Add(x <= 3.5);
Console.WriteLine("Number of constraints = " + solver.NumConstraints());
// [END constraints]
// [START objective]
// Maximize x + 10 * y.
solver.Maximize(x + 10 * y);
// [END objective]
// [START solve]
Solver.ResultStatus resultStatus = solver.Solve();
// [END solve]
// [START print_solution]
// Check that the problem has an optimal solution.
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("The problem does not have an optimal solution!");
return;
}
Console.WriteLine("Solution:");
Console.WriteLine("Objective value = " + solver.Objective().Value());
Console.WriteLine("x = " + x.SolutionValue());
Console.WriteLine("y = " + y.SolutionValue());
// [END print_solution]
// [START advanced]
Console.WriteLine("\nAdvanced usage:");
Console.WriteLine("Problem solved in " + solver.WallTime() + " milliseconds");
Console.WriteLine("Problem solved in " + solver.Iterations() + " iterations");
Console.WriteLine("Problem solved in " + solver.Nodes() + " branch-and-bound nodes");
// [END advanced]
}
private static void RunIntegerProgrammingExample(String solverType)
{
Solver solver = Solver.CreateSolver(solverType);
if (solver == null)
{
Console.WriteLine("Could not create solver " + solverType);
return;
}
// x1 and x2 are integer non-negative variables.
Variable x1 = solver.MakeIntVar(0.0, double.PositiveInfinity, "x1");
Variable x2 = solver.MakeIntVar(0.0, double.PositiveInfinity, "x2");
// Minimize x1 + 2 * x2.
Objective objective = solver.Objective();
objective.SetMinimization();
objective.SetCoefficient(x1, 1);
objective.SetCoefficient(x2, 2);
// 2 * x2 + 3 * x1 >= 17.
Constraint ct = solver.MakeConstraint(17, double.PositiveInfinity);
ct.SetCoefficient(x1, 3);
ct.SetCoefficient(x2, 2);
Solver.ResultStatus resultStatus = solver.Solve();
// Check that the problem has an optimal solution.
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("The problem does not have an optimal solution!");
return;
}
Console.WriteLine("Problem solved in " + solver.WallTime() +
" milliseconds");
// The objective value of the solution.
Console.WriteLine("Optimal objective value = " + objective.Value());
// The value of each variable in the solution.
Console.WriteLine("x1 = " + x1.SolutionValue());
Console.WriteLine("x2 = " + x2.SolutionValue());
Console.WriteLine("Advanced usage:");
Console.WriteLine("Problem solved in " + solver.Nodes() +
" branch-and-bound nodes");
}
private static void RPQ_Solution(List <Task> Tasks)
{
Solver solver = Solver.CreateSolver("SimpleMipProgram", "CBC_MIXED_INTEGER_PROGRAMMING");
int variablesMaxValue = 0;
foreach (var element in Tasks)
{
variablesMaxValue += element.R + element.P + element.Q;
}
var alfas = solver.MakeIntVarMatrix(Tasks.Count, Tasks.Count, 0, 1); //tutaj moze byc inaczej patrz argumenty
var starts = solver.MakeIntVarArray(Tasks.Count, 0, variablesMaxValue);
var cmax = solver.MakeIntVar(0, variablesMaxValue, "cmax");
foreach (var element in Tasks)
{
solver.Add(starts[element.Id] >= element.R);
}
foreach (var element in Tasks)
{
solver.Add(cmax >= starts[element.Id] + element.P + element.Q);
}
for (int i = 0; i < Tasks.Count; i++)
{
for (int j = i + 1; j < Tasks.Count; j++)
{
var task1 = Tasks[i];
var task2 = Tasks[j];
solver.Add(starts[task1.Id] + task1.P <= starts[task2.Id] + alfas[task1.Id, task2.Id] * variablesMaxValue);
solver.Add(starts[task2.Id] + task2.P <= starts[task1.Id] + alfas[task2.Id, task1.Id] * variablesMaxValue);
solver.Add(alfas[task1.Id, task2.Id] + alfas[task2.Id, task1.Id] == 1);
}
}
solver.Minimize(cmax);
Solver.ResultStatus resultStatus = solver.Solve();
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("Solve nie znalazl optymala");
}
Console.WriteLine("Obiect_value = " + solver.Objective().Value());
}
private static void RPQ_Solution(List <Job> Jobs)
{
Solver solver = Solver.CreateSolver("SimpleMipProgram", "CBC_MIXED_INTEGER_PROGRAMMING");
int variablesMaxValue = 0;
foreach (var job in Jobs)
{
variablesMaxValue += job.r + job.p + job.q;
}
var alfas = solver.MakeIntVarMatrix(Jobs.Count, Jobs.Count, 0, 1);
var starts = solver.MakeIntVarArray(Jobs.Count, 0, variablesMaxValue);
var cmax = solver.MakeIntVar(0, variablesMaxValue, "cmax");
foreach (var job in Jobs)
{
solver.Add(starts[job.id] >= job.r);
}
foreach (var job in Jobs)
{
solver.Add(cmax >= starts[job.id] + job.p + job.q);
}
for (int i = 0; i < Jobs.Count; i++)
{
for (int j = i + 1; j < Jobs.Count; j++)
{
var job1 = Jobs[i];
var job2 = Jobs[j];
solver.Add(starts[job1.id] + job1.p <= starts[job2.id] + alfas[job1.id, job2.id] * variablesMaxValue);
solver.Add(starts[job2.id] + job2.p <= starts[job1.id] + alfas[job2.id, job1.id] * variablesMaxValue);
solver.Add(alfas[job1.id, job2.id] + alfas[job2.id, job1.id] == 1);
}
}
solver.Minimize(cmax);
Solver.ResultStatus resultStatus = solver.Solve();
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("Solve nie znalazl optymalnego rozwiazania");
}
Console.WriteLine("Object_value = " + solver.Objective().Value());
}
/**
* Volsay problem.
*
* From the OPL model volsay.mod.
*
* Also see http://www.hakank.org/or-tools/volsay.py
*/
private static void Solve()
{
Solver solver = new Solver(
"Volsay", Solver.OptimizationProblemType.CLP_LINEAR_PROGRAMMING);
//
// Variables
//
Variable Gas = solver.MakeNumVar(0, 100000, "Gas");
Variable Chloride = solver.MakeNumVar(0, 100000, "Cloride");
Constraint c1 = solver.Add(Gas + Chloride <= 50);
Constraint c2 = solver.Add(3 * Gas + 4 * Chloride <= 180);
solver.Maximize(40 * Gas + 50 * Chloride);
Solver.ResultStatus resultStatus = solver.Solve();
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("The problem don't have an optimal solution.");
return;
}
Console.WriteLine("Objective: {0}", solver.Objective().Value());
Console.WriteLine("Gas : {0} ReducedCost: {1}",
Gas.SolutionValue(),
Gas.ReducedCost());
Console.WriteLine("Chloride : {0} ReducedCost: {1}",
Chloride.SolutionValue(),
Chloride.ReducedCost());
double[] activities = solver.ComputeConstraintActivities();
Console.WriteLine("c1 : DualValue: {0} Activity: {1}",
c1.DualValue(),
activities[c1.Index()]);
Console.WriteLine("c2 : DualValue: {0} Activity: {1}",
c2.DualValue(),
activities[c2.Index()]);
Console.WriteLine("\nWallTime: " + solver.WallTime());
Console.WriteLine("Iterations: " + solver.Iterations());
}
public static void RPQProblemMIP(List <SchedulingTask> tasks)
{
Solver solver = Solver.CreateSolver("SimpleMipProgram", "CBC_MIXED_INTEGER_PROGRAMMING");
int variablesMaxValue = 0;
foreach (SchedulingTask task in tasks)
{
variablesMaxValue += task.R + task.P + task.Q;
}
var alfas = solver.MakeIntVarMatrix(tasks.Count, tasks.Count, 0, 1);
var starts = solver.MakeIntVarArray(tasks.Count, 0, variablesMaxValue);
var cmax = solver.MakeIntVar(0, variablesMaxValue, "cmax");
foreach (SchedulingTask task in tasks)
{
solver.Add(starts[tasks.IndexOf(task)] >= task.R);
}
foreach (SchedulingTask task in tasks)
{
solver.Add(cmax >= starts[tasks.IndexOf(task)] + task.P + task.Q);
}
for (int i = 0; i < tasks.Count; i++)
{
for (int j = i + 1; j < tasks.Count; j++)
{
var job1 = tasks[i];
var job2 = tasks[j];
var job1ID = tasks.IndexOf(job1);
var job2ID = tasks.IndexOf(job2);
solver.Add(starts[job1ID] + job1.P <= starts[job2ID] +
alfas[job1ID, job2ID] * variablesMaxValue);
solver.Add(starts[job2ID] + job2.P <= starts[job1ID] +
alfas[job2ID, job1ID] * variablesMaxValue);
solver.Add(alfas[job1ID, job2ID] + alfas[job2ID, job1ID] == 1);
}
}
solver.Minimize(cmax);
Solver.ResultStatus resultStatus = solver.Solve();
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("Solver didn’t find optimal solution!");
}
Console.WriteLine("Objective value = " + solver.Objective().Value());
}
public AssignmentDescription Run()
{
this.AddObjective();
this.AddConstraints();
Solver.ResultStatus status = this.solver_.Solve();
if (status == Solver.ResultStatus.OPTIMAL)
{
var result = new AssignmentDescription();
foreach (NodeDescription n in this.assignment_.Nodes)
{
result.Nodes.Add(n);
}
foreach (TaskDescription t in this.assignment_.Tasks)
{
result.Tasks.Add(t);
}
for (int i = 1; i < this.assignment_.Nodes.Count; i++)
{
for (int j = 0; j < this.assignment_.Tasks.Count; j++)
{
if (this.variables_[i, j].SolutionValue() > 0)
{
if (!result.Assignments.TryGetValue(i, out ISet <int> tasks))
{
tasks = new HashSet <int>();
result.Assignments.Add(i, tasks);
}
tasks.Add(j);
Console.WriteLine($"Task {j} assigned to node {i} with cost {this.costs_[i, j]}.");
}
}
}
Console.WriteLine($"Total cost is {this.solver_.Objective().Value()}");
return(result);
}
throw new NotImplementedException($"Not implemented for status: {status}");
}
public LPResult?Solve()
{
Solver.ResultStatus resultStatus = _solver.Solve();
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("No an optimal solution!");
return(null);
}
else
{
// Test only
//Console.WriteLine("Objective value = " + _solver.Objective().Value());
//foreach (var item in _solver.variables())
//{
// Console.WriteLine($"{item.Name()} = {item.SolutionValue()}");
//}
return(new LPResult {
SolutionVector = _solver.variables()
});
}
}
static void Main()
{
Console.WriteLine("Hello World!");
// GLOP = Google's linear programming system
// SCIP = Solving Constraint Integer Programs
Solver solver = Solver.CreateSolver("SCIP");
// Variables
Variable teamOf2 = solver.MakeIntVar(0, 1, "teamOf2");
Variable teamOf3 = solver.MakeIntVar(0, 2, "teamOf3");
Variable teamOf4 = solver.MakeIntVar(0, 1, "teamOf4");
Console.WriteLine("Number of variables = " + solver.NumVariables());
// Constraints
solver.Add(2 * teamOf2 + 3 * teamOf3 + 4 * teamOf4 <= 5);
// Function
solver.Maximize(2 * teamOf2 + 3 * teamOf3 + 4 * teamOf4);
Console.WriteLine("");
// Solve
Solver.ResultStatus resultStatus = solver.Solve();
// Result
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("The problem does not have an optimal solution!");
return;
}
Console.WriteLine("Solution:");
Console.WriteLine("Objective value = " + solver.Objective().Value());
Console.WriteLine("team Of 2 = " + teamOf2.SolutionValue());
Console.WriteLine("team Of 3 = " + teamOf3.SolutionValue());
Console.WriteLine("team Of 4 = " + teamOf4.SolutionValue());
}
private static void RunLinearProgrammingExample(String solverType)
{
Console.WriteLine($"---- Linear programming example with {solverType} ----");
Solver solver = Solver.CreateSolver(solverType);
if (solver == null)
{
Console.WriteLine("Could not create solver " + solverType);
return;
}
// x1, x2 and x3 are continuous non-negative variables.
Variable x1 = solver.MakeNumVar(0.0, double.PositiveInfinity, "x1");
Variable x2 = solver.MakeNumVar(0.0, double.PositiveInfinity, "x2");
Variable x3 = solver.MakeNumVar(0.0, double.PositiveInfinity, "x3");
// Maximize 10 * x1 + 6 * x2 + 4 * x3.
Objective objective = solver.Objective();
objective.SetCoefficient(x1, 10);
objective.SetCoefficient(x2, 6);
objective.SetCoefficient(x3, 4);
objective.SetMaximization();
// x1 + x2 + x3 <= 100.
Constraint c0 = solver.MakeConstraint(double.NegativeInfinity, 100.0);
c0.SetCoefficient(x1, 1);
c0.SetCoefficient(x2, 1);
c0.SetCoefficient(x3, 1);
// 10 * x1 + 4 * x2 + 5 * x3 <= 600.
Constraint c1 = solver.MakeConstraint(double.NegativeInfinity, 600.0);
c1.SetCoefficient(x1, 10);
c1.SetCoefficient(x2, 4);
c1.SetCoefficient(x3, 5);
// 2 * x1 + 2 * x2 + 6 * x3 <= 300.
Constraint c2 = solver.MakeConstraint(double.NegativeInfinity, 300.0);
c2.SetCoefficient(x1, 2);
c2.SetCoefficient(x2, 2);
c2.SetCoefficient(x3, 6);
Console.WriteLine("Number of variables = " + solver.NumVariables());
Console.WriteLine("Number of constraints = " + solver.NumConstraints());
Solver.ResultStatus resultStatus = solver.Solve();
// Check that the problem has an optimal solution.
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("The problem does not have an optimal solution!");
return;
}
Console.WriteLine("Problem solved in " + solver.WallTime() +
" milliseconds");
// The objective value of the solution.
Console.WriteLine("Optimal objective value = " +
solver.Objective().Value());
// The value of each variable in the solution.
Console.WriteLine("x1 = " + x1.SolutionValue());
Console.WriteLine("x2 = " + x2.SolutionValue());
Console.WriteLine("x3 = " + x3.SolutionValue());
Console.WriteLine("Advanced usage:");
double[] activities = solver.ComputeConstraintActivities();
Console.WriteLine("Problem solved in " + solver.Iterations() +
" iterations");
Console.WriteLine("x1: reduced cost = " + x1.ReducedCost());
Console.WriteLine("x2: reduced cost = " + x2.ReducedCost());
Console.WriteLine("x3: reduced cost = " + x3.ReducedCost());
Console.WriteLine("c0: dual value = " + c0.DualValue());
Console.WriteLine(" activity = " + activities[c0.Index()]);
Console.WriteLine("c1: dual value = " + c1.DualValue());
Console.WriteLine(" activity = " + activities[c1.Index()]);
Console.WriteLine("c2: dual value = " + c2.DualValue());
Console.WriteLine(" activity = " + activities[c2.Index()]);
}
private static void RunLinearProgrammingExampleNaturalApi(
String solverType, bool printModel)
{
Console.WriteLine(
$"---- Linear programming example (Natural API) with {solverType} ----");
Solver solver = Solver.CreateSolver(solverType);
if (solver == null)
{
Console.WriteLine("Could not create solver " + solverType);
return;
}
// x1, x2 and x3 are continuous non-negative variables.
Variable x1 = solver.MakeNumVar(0.0, double.PositiveInfinity, "x1");
Variable x2 = solver.MakeNumVar(0.0, double.PositiveInfinity, "x2");
Variable x3 = solver.MakeNumVar(0.0, double.PositiveInfinity, "x3");
solver.Maximize(10 * x1 + 6 * x2 + 4 * x3);
Constraint c0 = solver.Add(x1 + x2 + x3 <= 100);
Constraint c1 = solver.Add(10 * x1 + x2 * 4 + 5 * x3 <= 600);
Constraint c2 = solver.Add(2 * x1 + 2 * x2 + 6 * x3 <= 300);
Console.WriteLine("Number of variables = " + solver.NumVariables());
Console.WriteLine("Number of constraints = " + solver.NumConstraints());
if (printModel)
{
string model = solver.ExportModelAsLpFormat(false);
Console.WriteLine(model);
}
Solver.ResultStatus resultStatus = solver.Solve();
// Check that the problem has an optimal solution.
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("The problem does not have an optimal solution!");
return;
}
Console.WriteLine("Problem solved in " + solver.WallTime() +
" milliseconds");
// The objective value of the solution.
Console.WriteLine("Optimal objective value = " +
solver.Objective().Value());
// The value of each variable in the solution.
Console.WriteLine("x1 = " + x1.SolutionValue());
Console.WriteLine("x2 = " + x2.SolutionValue());
Console.WriteLine("x3 = " + x3.SolutionValue());
Console.WriteLine("Advanced usage:");
double[] activities = solver.ComputeConstraintActivities();
Console.WriteLine("Problem solved in " + solver.Iterations() +
" iterations");
Console.WriteLine("x1: reduced cost = " + x1.ReducedCost());
Console.WriteLine("x2: reduced cost = " + x2.ReducedCost());
Console.WriteLine("x3: reduced cost = " + x3.ReducedCost());
Console.WriteLine("c0: dual value = " + c0.DualValue());
Console.WriteLine(" activity = " + activities[c0.Index()]);
Console.WriteLine("c1: dual value = " + c1.DualValue());
Console.WriteLine(" activity = " + activities[c1.Index()]);
Console.WriteLine("c2: dual value = " + c2.DualValue());
Console.WriteLine(" activity = " + activities[c2.Index()]);
}
public static void Main()
{
// Instantiate the data problem.
// [START data]
double[] Weights = { 48, 30, 42, 36, 36, 48, 42, 42, 36, 24, 30, 30, 42, 36, 36 };
double[] Values = { 10, 30, 25, 50, 35, 30, 15, 40, 30, 35, 45, 10, 20, 30, 25 };
int NumItems = Weights.Length;
int[] allItems = Enumerable.Range(0, NumItems).ToArray();
double[] BinCapacities = { 100, 100, 100, 100, 100 };
int NumBins = BinCapacities.Length;
int[] allBins = Enumerable.Range(0, NumBins).ToArray();
// [END data]
// [START solver]
// Create the linear solver with the SCIP backend.
Solver solver = Solver.CreateSolver("SCIP");
// [END solver]
// Variables.
// [START variables]
Variable[,] x = new Variable[NumItems, NumBins];
foreach (int i in allItems)
{
foreach (int b in allBins)
{
x[i, b] = solver.MakeBoolVar($"x_{i}_{b}");
}
}
// [END variables]
// Constraints.
// [START constraints]
// Each item is assigned to at most one bin.
foreach (int i in allItems)
{
Constraint constraint = solver.MakeConstraint(0, 1, "");
foreach (int b in allBins)
{
constraint.SetCoefficient(x[i, b], 1);
}
}
// The amount packed in each bin cannot exceed its capacity.
foreach (int b in allBins)
{
Constraint constraint = solver.MakeConstraint(0, BinCapacities[b], "");
foreach (int i in allItems)
{
constraint.SetCoefficient(x[i, b], Weights[i]);
}
}
// [END constraints]
// Objective.
// [START objective]
Objective objective = solver.Objective();
foreach (int i in allItems)
{
foreach (int b in allBins)
{
objective.SetCoefficient(x[i, b], Values[i]);
}
}
objective.SetMaximization();
// [END objective]
// [START solve]
Solver.ResultStatus resultStatus = solver.Solve();
// [END solve]
// [START print_solution]
// Check that the problem has an optimal solution.
if (resultStatus == Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine($"Total packed value: {solver.Objective().Value()}");
double TotalWeight = 0.0;
foreach (int b in allBins)
{
double BinWeight = 0.0;
double BinValue = 0.0;
Console.WriteLine("Bin " + b);
foreach (int i in allItems)
{
if (x[i, b].SolutionValue() == 1)
{
Console.WriteLine($"Item {i} weight: {Weights[i]} values: {Values[i]}");
BinWeight += Weights[i];
BinValue += Values[i];
}
}
Console.WriteLine("Packed bin weight: " + BinWeight);
Console.WriteLine("Packed bin value: " + BinValue);
TotalWeight += BinWeight;
}
Console.WriteLine("Total packed weight: " + TotalWeight);
}
else
{
Console.WriteLine("The problem does not have an optimal solution!");
}
// [END print_solution]
}
// [END data_model]
public static void Main()
{
// [START data]
DataModel data = new DataModel();
// [END data]
// [END program_part1]
// [START solver]
// Create the linear solver with the CBC backend.
Solver solver = Solver.CreateSolver("MultipleKnapsackMip", "CBC");
// [END solver]
// [START program_part2]
// [START variables]
Variable[,] x = new Variable[data.NumItems, data.NumBins];
for (int i = 0; i < data.NumItems; i++)
{
for (int j = 0; j < data.NumBins; j++)
{
x[i, j] = solver.MakeIntVar(0, 1, $"x_{i}_{j}");
}
}
// [END variables]
// [START constraints]
for (int i = 0; i < data.NumItems; ++i)
{
Constraint constraint = solver.MakeConstraint(0, 1, "");
for (int j = 0; j < data.NumBins; ++j)
{
constraint.SetCoefficient(x[i, j], 1);
}
}
for (int j = 0; j < data.NumBins; ++j)
{
Constraint constraint = solver.MakeConstraint(0, data.BinCapacities[j], "");
for (int i = 0; i < data.NumItems; ++i)
{
constraint.SetCoefficient(x[i, j], DataModel.Weights[i]);
}
}
// [END constraints]
// [START objective]
Objective objective = solver.Objective();
for (int i = 0; i < data.NumItems; ++i)
{
for (int j = 0; j < data.NumBins; ++j)
{
objective.SetCoefficient(x[i, j], DataModel.Values[i]);
}
}
objective.SetMaximization();
// [END objective]
// [START solve]
Solver.ResultStatus resultStatus = solver.Solve();
// [END solve]
// [START print_solution]
// Check that the problem has an optimal solution.
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("The problem does not have an optimal solution!");
return;
}
Console.WriteLine("Total packed value: " + solver.Objective().Value());
double TotalWeight = 0.0;
for (int j = 0; j < data.NumBins; ++j)
{
double BinWeight = 0.0;
double BinValue = 0.0;
Console.WriteLine("Bin " + j);
for (int i = 0; i < data.NumItems; ++i)
{
if (x[i, j].SolutionValue() == 1)
{
Console.WriteLine($"Item {i} weight: {DataModel.Weights[i]} values: {DataModel.Values[i]}");
BinWeight += DataModel.Weights[i];
BinValue += DataModel.Values[i];
}
}
Console.WriteLine("Packed bin weight: " + BinWeight);
Console.WriteLine("Packed bin value: " + BinValue);
TotalWeight += BinWeight;
}
Console.WriteLine("Total packed weight: " + TotalWeight);
// [END print_solution]
}
static void Main()
{
// Data.
// [START data]
int[,] costs =
{
{ 90, 76, 75, 70, 50, 74 }, { 35, 85, 55, 65, 48, 101 }, { 125, 95, 90, 105, 59, 120 },
{ 45, 110, 95, 115, 104, 83 }, { 60, 105, 80, 75, 59, 62 }, { 45, 65, 110, 95, 47, 31 },
{ 38, 51, 107, 41, 69, 99 }, { 47, 85, 57, 71, 92, 77 }, { 39, 63, 97, 49, 118, 56 },
{ 47, 101, 71, 60, 88, 109 }, { 17, 39, 103, 64, 61, 92 }, { 101, 45, 83, 59, 92, 27 },
};
int numWorkers = costs.GetLength(0);
int numTasks = costs.GetLength(1);
int[] allWorkers = Enumerable.Range(0, numWorkers).ToArray();
int[] allTasks = Enumerable.Range(0, numTasks).ToArray();
// [END data]
// Allowed groups of workers:
// [START allowed_groups]
int[,] group1 =
{
// group of worker 0-3
{ 2, 3 }, { 1, 3 }, { 1, 2 }, { 0, 1 }, { 0, 2 },
};
int[,] group2 =
{
// group of worker 4-7
{ 6, 7 }, { 5, 7 }, { 5, 6 }, { 4, 5 }, { 4, 7 },
};
int[,] group3 =
{
// group of worker 8-11
{ 10, 11 }, { 9, 11 }, { 9, 10 }, { 8, 10 }, { 8, 11 },
};
// [END allowed_groups]
// Solver.
// [START solver]
Solver solver = Solver.CreateSolver("SCIP");
// [END solver]
// Variables.
// [START variables]
// x[i, j] is an array of 0-1 variables, which will be 1
// if worker i is assigned to task j.
Variable[,] x = new Variable[numWorkers, numTasks];
foreach (int worker in allWorkers)
{
foreach (int task in allTasks)
{
x[worker, task] = solver.MakeBoolVar($"x[{worker},{task}]");
}
}
// [END variables]
// Constraints
// [START constraints]
// Each worker is assigned to at most one task.
foreach (int worker in allWorkers)
{
Constraint constraint = solver.MakeConstraint(0, 1, "");
foreach (int task in allTasks)
{
constraint.SetCoefficient(x[worker, task], 1);
}
}
// Each task is assigned to exactly one worker.
foreach (int task in allTasks)
{
Constraint constraint = solver.MakeConstraint(1, 1, "");
foreach (int worker in allWorkers)
{
constraint.SetCoefficient(x[worker, task], 1);
}
}
// [END constraints]
// [START assignments]
// Create variables for each worker, indicating whether they work on some task.
Variable[] work = new Variable[numWorkers];
foreach (int worker in allWorkers)
{
work[worker] = solver.MakeBoolVar($"work[{worker}]");
}
foreach (int worker in allWorkers)
{
Variable[] vars = new Variable[numTasks];
foreach (int task in allTasks)
{
vars[task] = x[worker, task];
}
solver.Add(work[worker] == LinearExprArrayHelper.Sum(vars));
}
// Group1
Constraint constraint_g1 = solver.MakeConstraint(1, 1, "");
for (int i = 0; i < group1.GetLength(0); ++i)
{
// a*b can be transformed into 0 <= a + b - 2*p <= 1 with p in [0,1]
// p is True if a AND b, False otherwise
Constraint constraint = solver.MakeConstraint(0, 1, "");
constraint.SetCoefficient(work[group1[i, 0]], 1);
constraint.SetCoefficient(work[group1[i, 1]], 1);
Variable p = solver.MakeBoolVar($"g1_p{i}");
constraint.SetCoefficient(p, -2);
constraint_g1.SetCoefficient(p, 1);
}
// Group2
Constraint constraint_g2 = solver.MakeConstraint(1, 1, "");
for (int i = 0; i < group2.GetLength(0); ++i)
{
// a*b can be transformed into 0 <= a + b - 2*p <= 1 with p in [0,1]
// p is True if a AND b, False otherwise
Constraint constraint = solver.MakeConstraint(0, 1, "");
constraint.SetCoefficient(work[group2[i, 0]], 1);
constraint.SetCoefficient(work[group2[i, 1]], 1);
Variable p = solver.MakeBoolVar($"g2_p{i}");
constraint.SetCoefficient(p, -2);
constraint_g2.SetCoefficient(p, 1);
}
// Group3
Constraint constraint_g3 = solver.MakeConstraint(1, 1, "");
for (int i = 0; i < group3.GetLength(0); ++i)
{
// a*b can be transformed into 0 <= a + b - 2*p <= 1 with p in [0,1]
// p is True if a AND b, False otherwise
Constraint constraint = solver.MakeConstraint(0, 1, "");
constraint.SetCoefficient(work[group3[i, 0]], 1);
constraint.SetCoefficient(work[group3[i, 1]], 1);
Variable p = solver.MakeBoolVar($"g3_p{i}");
constraint.SetCoefficient(p, -2);
constraint_g3.SetCoefficient(p, 1);
}
// [END assignments]
// Objective
// [START objective]
Objective objective = solver.Objective();
foreach (int worker in allWorkers)
{
foreach (int task in allTasks)
{
objective.SetCoefficient(x[worker, task], costs[worker, task]);
}
}
objective.SetMinimization();
// [END objective]
// Solve
// [START solve]
Solver.ResultStatus resultStatus = solver.Solve();
// [END solve]
// Print solution.
// [START print_solution]
// Check that the problem has a feasible solution.
if (resultStatus == Solver.ResultStatus.OPTIMAL || resultStatus == Solver.ResultStatus.FEASIBLE)
{
Console.WriteLine($"Total cost: {solver.Objective().Value()}\n");
foreach (int worker in allWorkers)
{
foreach (int task in allTasks)
{
// Test if x[i, j] is 0 or 1 (with tolerance for floating point
// arithmetic).
if (x[worker, task].SolutionValue() > 0.5)
{
Console.WriteLine($"Worker {worker} assigned to task {task}. Cost: {costs[worker, task]}");
}
}
}
}
else
{
Console.WriteLine("No solution found.");
}
// [END print_solution]
}
static void Main()
{
// Data.
// [START data_model]
int[,] costs =
{
{ 90, 80, 75, 70 }, { 35, 85, 55, 65 }, { 125, 95, 90, 95 }, { 45, 110, 95, 115 }, { 50, 100, 90, 100 },
};
int numWorkers = costs.GetLength(0);
int numTasks = costs.GetLength(1);
// [END data_model]
// Solver.
// [START solver]
Solver solver = Solver.CreateSolver("SCIP");
// [END solver]
// Variables.
// [START variables]
// x[i, j] is an array of 0-1 variables, which will be 1
// if worker i is assigned to task j.
Variable[,] x = new Variable[numWorkers, numTasks];
for (int i = 0; i < numWorkers; ++i)
{
for (int j = 0; j < numTasks; ++j)
{
x[i, j] = solver.MakeIntVar(0, 1, $"worker_{i}_task_{j}");
}
}
// [END variables]
// Constraints
// [START constraints]
// Each worker is assigned to at most one task.
for (int i = 0; i < numWorkers; ++i)
{
Constraint constraint = solver.MakeConstraint(0, 1, "");
for (int j = 0; j < numTasks; ++j)
{
constraint.SetCoefficient(x[i, j], 1);
}
}
// Each task is assigned to exactly one worker.
for (int j = 0; j < numTasks; ++j)
{
Constraint constraint = solver.MakeConstraint(1, 1, "");
for (int i = 0; i < numWorkers; ++i)
{
constraint.SetCoefficient(x[i, j], 1);
}
}
// [END constraints]
// Objective
// [START objective]
Objective objective = solver.Objective();
for (int i = 0; i < numWorkers; ++i)
{
for (int j = 0; j < numTasks; ++j)
{
objective.SetCoefficient(x[i, j], costs[i, j]);
}
}
objective.SetMinimization();
// [END objective]
// Solve
// [START solve]
Solver.ResultStatus resultStatus = solver.Solve();
// [END solve]
// Print solution.
// [START print_solution]
// Check that the problem has a feasible solution.
if (resultStatus == Solver.ResultStatus.OPTIMAL || resultStatus == Solver.ResultStatus.FEASIBLE)
{
Console.WriteLine($"Total cost: {solver.Objective().Value()}\n");
for (int i = 0; i < numWorkers; ++i)
{
for (int j = 0; j < numTasks; ++j)
{
// Test if x[i, j] is 0 or 1 (with tolerance for floating point
// arithmetic).
if (x[i, j].SolutionValue() > 0.5)
{
Console.WriteLine($"Worker {i} assigned to task {j}. Cost: {costs[i, j]}");
}
}
}
}
else
{
Console.WriteLine("No solution found.");
}
// [END print_solution]
}
public int[][] Schedule()
{
int[][] result = null;
#region Declare solver
Solver solver = Solver.CreateSolver("SchedulingProgram", "GLOP");
#endregion
#region Create the variables
Variable[][] shifts = new Variable[numEmp][];
for (int e = 0; e < numEmp; e++)
{
shifts[e] = new Variable[numShift];
for (int s = 0; s < numShift; s++)
{
if (availability[e][s] != 0)
{
shifts[e][s] = solver.MakeBoolVar($"n{e}s{s}");
}
}
}
#endregion
#region Define the constraints
//Each shift have enough employee
for (int s = 0; s < numShift; s++)
{
Constraint ct = solver.MakeConstraint(rangeEmpForEachShift[s][0], rangeEmpForEachShift[s][1]);
for (int e = 0; e < numEmp; e++)
{
if (shifts[e][s] != null)
{
ct.SetCoefficient(shifts[e][s], 1);
}
}
}
//Each employee works least at rangeShiftForEachEmp[e][0] shift and most at rangeShiftForEachEmp[e][1] shift;
for (int e = 0; e < numEmp; e++)
{
Constraint ct = solver.MakeConstraint(rangeShiftForEachEmp[e][0], rangeShiftForEachEmp[e][1]);
for (int s = 0; s < numShift; s++)
{
if (shifts[e][s] != null)
{
ct.SetCoefficient(shifts[e][s], 1);
}
}
}
//Make permanent employees
//for (int e = 0; e < numEmp; e++)
//{
// for (int s = 0; s < numShift; s++)
// {
// if (permanentEmployees[e][s] == 1)
// {
// Constraint permanentConstraint = solver.MakeConstraint(1, 1);
// permanentConstraint.SetCoefficient(shifts[e][s], 1);
// }
// }
//}
#endregion
#region Define the objective function
// Optimization of Employee Satisfaction
double[][] weightedArr = CalWeightedPrefer(availability, preference);
Objective obj = solver.Objective();
for (int e = 0; e < numEmp; e++)
{
for (int s = 0; s < numShift; s++)
{
if (shifts[e][s] != null)
{
obj.SetCoefficient(shifts[e][s], weightedArr[e][s]);
}
}
}
obj.SetMaximization();
#endregion
#region Invoke the solver and display the results
Solver.ResultStatus status = solver.Solve();
if (status != Solver.ResultStatus.INFEASIBLE)
{
result = new int[shifts.Length][];
for (int e = 0; e < shifts.Length; e++)
{
result[e] = new int[shifts[e].Length];
for (int s = 0; s < shifts[e].Length; s++)
{
result[e][s] = shifts[e][s] != null ? (int)shifts[e][s].SolutionValue() : 0;
}
}
}
#endregion
return(result);
}
static void Main()
{
// Data.
// [START data]
int[,] costs =
{
{ 90, 76, 75, 70 }, { 35, 85, 55, 65 }, { 125, 95, 90, 105 },
{ 45, 110, 95, 115 }, { 60, 105, 80, 75 }, { 45, 65, 110, 95 },
};
int numWorkers = costs.GetLength(0);
int numTasks = costs.GetLength(1);
int[] allWorkers = Enumerable.Range(0, numWorkers).ToArray();
int[] allTasks = Enumerable.Range(0, numTasks).ToArray();
int[] team1 = { 0, 2, 4 };
int[] team2 = { 1, 3, 5 };
// Maximum total of tasks for any team
int teamMax = 2;
// [END data]
// Solver.
// [START solver]
Solver solver = Solver.CreateSolver("SCIP");
// [END solver]
// Variables.
// [START variables]
// x[i, j] is an array of 0-1 variables, which will be 1
// if worker i is assigned to task j.
Variable[,] x = new Variable[numWorkers, numTasks];
foreach (int worker in allWorkers)
{
foreach (int task in allTasks)
{
x[worker, task] = solver.MakeBoolVar($"x[{worker},{task}]");
}
}
// [END variables]
// Constraints
// [START constraints]
// Each worker is assigned to at most one task.
foreach (int worker in allWorkers)
{
Constraint constraint = solver.MakeConstraint(0, 1, "");
foreach (int task in allTasks)
{
constraint.SetCoefficient(x[worker, task], 1);
}
}
// Each task is assigned to exactly one worker.
foreach (int task in allTasks)
{
Constraint constraint = solver.MakeConstraint(1, 1, "");
foreach (int worker in allWorkers)
{
constraint.SetCoefficient(x[worker, task], 1);
}
}
// Each team takes at most two tasks.
Constraint team1Tasks = solver.MakeConstraint(0, teamMax, "");
foreach (int worker in team1)
{
foreach (int task in allTasks)
{
team1Tasks.SetCoefficient(x[worker, task], 1);
}
}
Constraint team2Tasks = solver.MakeConstraint(0, teamMax, "");
foreach (int worker in team2)
{
foreach (int task in allTasks)
{
team2Tasks.SetCoefficient(x[worker, task], 1);
}
}
// [END constraints]
// Objective
// [START objective]
Objective objective = solver.Objective();
foreach (int worker in allWorkers)
{
foreach (int task in allTasks)
{
objective.SetCoefficient(x[worker, task], costs[worker, task]);
}
}
objective.SetMinimization();
// [END objective]
// Solve
// [START solve]
Solver.ResultStatus resultStatus = solver.Solve();
// [END solve]
// Print solution.
// [START print_solution]
// Check that the problem has a feasible solution.
if (resultStatus == Solver.ResultStatus.OPTIMAL || resultStatus == Solver.ResultStatus.FEASIBLE)
{
Console.WriteLine($"Total cost: {solver.Objective().Value()}\n");
foreach (int worker in allWorkers)
{
foreach (int task in allTasks)
{
// Test if x[i, j] is 0 or 1 (with tolerance for floating point
// arithmetic).
if (x[worker, task].SolutionValue() > 0.5)
{
Console.WriteLine($"Worker {worker} assigned to task {task}. Cost: {costs[worker, task]}");
}
}
}
}
else
{
Console.WriteLine("No solution found.");
}
// [END print_solution]
}
// [END data_model]
public static void Main()
{
// [START data]
DataModel data = new DataModel();
// [END data]
// [END program_part1]
// [START solver]
// Create the linear solver with the SCIP backend.
Solver solver = Solver.CreateSolver("SCIP");
// [END solver]
// [START program_part2]
// [START variables]
Variable[] x = new Variable[data.NumVars];
for (int j = 0; j < data.NumVars; j++)
{
x[j] = solver.MakeIntVar(0.0, double.PositiveInfinity, $"x_{j}");
}
Console.WriteLine("Number of variables = " + solver.NumVariables());
// [END variables]
// [START constraints]
for (int i = 0; i < data.NumConstraints; ++i)
{
Constraint constraint = solver.MakeConstraint(0, data.Bounds[i], "");
for (int j = 0; j < data.NumVars; ++j)
{
constraint.SetCoefficient(x[j], data.ConstraintCoeffs[i, j]);
}
}
Console.WriteLine("Number of constraints = " + solver.NumConstraints());
// [END constraints]
// [START objective]
Objective objective = solver.Objective();
for (int j = 0; j < data.NumVars; ++j)
{
objective.SetCoefficient(x[j], data.ObjCoeffs[j]);
}
objective.SetMaximization();
// [END objective]
// [START solve]
Solver.ResultStatus resultStatus = solver.Solve();
// [END solve]
// [START print_solution]
// Check that the problem has an optimal solution.
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("The problem does not have an optimal solution!");
return;
}
Console.WriteLine("Solution:");
Console.WriteLine("Optimal objective value = " + solver.Objective().Value());
for (int j = 0; j < data.NumVars; ++j)
{
Console.WriteLine("x[" + j + "] = " + x[j].SolutionValue());
}
// [END print_solution]
// [START advanced]
Console.WriteLine("\nAdvanced usage:");
Console.WriteLine("Problem solved in " + solver.WallTime() + " milliseconds");
Console.WriteLine("Problem solved in " + solver.Iterations() + " iterations");
Console.WriteLine("Problem solved in " + solver.Nodes() + " branch-and-bound nodes");
// [END advanced]
}
public static void Main()
{
Solver solver = Solver.CreateSolver("SCIP");
Dictionary <Player, Variable> players = new Dictionary <Player, Variable>();
using (Fantasy_FootballEntities entities = new Fantasy_FootballEntities())
{
foreach (Player player in entities.Players) //This could be done with SQL UNION operator, but this is faster.
{
players[player] = solver.MakeIntVar(0, 1, player.Name + " of " + player.Team + " as primary " + player.Position);
players[new Player()
{
Name = player.Name, Position = "B1", Price = player.Price, ProjectedPoints = player.ProjectedPoints * (1 / (double)2), Team = player.Team
}] =
solver.MakeIntVar(0, 1, player.Name + " of " + player.Team + " as secondary " + player.Position);
players[new Player()
{
Name = player.Name, Position = "B2", Price = player.Price, ProjectedPoints = player.ProjectedPoints * (1 / (double)4), Team = player.Team
}] =
solver.MakeIntVar(0, 1, player.Name + " of " + player.Team + " as tertiary " + player.Position);
players[new Player()
{
Name = player.Name, Position = "B3", Price = player.Price, ProjectedPoints = player.ProjectedPoints * (1 / (double)8), Team = player.Team
}] =
solver.MakeIntVar(0, 1, player.Name + " of " + player.Team + " as quaternary " + player.Position);
players[new Player()
{
Name = player.Name, Position = "B4", Price = player.Price, ProjectedPoints = player.ProjectedPoints * (1 / (double)16), Team = player.Team
}] =
solver.MakeIntVar(0, 1, player.Name + " of " + player.Team + " as quinary " + player.Position);
players[new Player()
{
Name = player.Name, Position = "B5", Price = player.Price, ProjectedPoints = player.ProjectedPoints * (1 / (double)32), Team = player.Team
}] =
solver.MakeIntVar(0, 1, player.Name + " of " + player.Team + " as senary " + player.Position);
players[new Player()
{
Name = player.Name, Position = "B6", Price = player.Price, ProjectedPoints = player.ProjectedPoints * (1 / (double)64), Team = player.Team
}] =
solver.MakeIntVar(0, 1, player.Name + " of " + player.Team + " as septenary " + player.Position);
} //Bijection between the Player objects and the Variable objects.
}
Console.WriteLine("Number of variables = " + solver.NumVariables());
//Sum of salaries must be below 100.
Constraint salaryCap = solver.MakeConstraint(0, 100, "Max Salary");
foreach (Player player in players.Keys)
{
salaryCap.SetCoefficient(players[player], player.Price);
}
//Number of players must be below 15.
Constraint rosterCap = solver.MakeConstraint(0, 15, "Roster Size Limit");
foreach (Player player in players.Keys)
{
rosterCap.SetCoefficient(players[player], 1);
}
//Sum of starting casts for each player must be equal to or less than 1.
List <Constraint> castCaps = new List <Constraint>();
foreach (var group in players.Keys.GroupBy(p => new { p.Name, p.Team })) //Get all the unique individuals. This is bijective with the primary key of the database table.
{
Constraint castCap = solver.MakeConstraint(0, 1, group.Key.Name + " of " + group.Key.Team + " position restriction.");
foreach (var player in group)
{
castCap.SetCoefficient(players[player], 1);
}
castCaps.Add(castCap);
}
#region Slot Limits
//QB count must be 1.
Constraint QBCap = solver.MakeConstraint(1, 1, "QB Limit");
foreach (Player player in players.Keys.Where(p => p.Position == "QB"))
{
QBCap.SetCoefficient(players[player], 1);
}
//WR count must be 3.
Constraint WRCap = solver.MakeConstraint(3, 3, "WR Limit");
foreach (Player player in players.Keys.Where(p => p.Position == "WR"))
{
WRCap.SetCoefficient(players[player], 1);
}
//RB count must be 3.
Constraint RBCap = solver.MakeConstraint(2, 2, "RB Limit");
foreach (Player player in players.Keys.Where(p => p.Position == "RB"))
{
RBCap.SetCoefficient(players[player], 1);
}
//TE count must be 1.
Constraint TECap = solver.MakeConstraint(1, 1, "TE Limit");
foreach (Player player in players.Keys.Where(p => p.Position == "TE"))
{
TECap.SetCoefficient(players[player], 1);
}
//K count must be 1. This constraint is actually redundant.
Constraint KCap = solver.MakeConstraint(1, 1, "K Limit");
foreach (Player player in players.Keys.Where(p => p.Position == "K"))
{
KCap.SetCoefficient(players[player], 1);
}
//DEF count must be 1. This constraint is also redundant.
Constraint DEFCap = solver.MakeConstraint(1, 1, "DEF Limit");
foreach (Player player in players.Keys.Where(p => p.Position == "DEF"))
{
DEFCap.SetCoefficient(players[player], 1);
}
#endregion
#region Total Roster Limits
//Have fun doing this in Python. LINQ rocks for anything requiring relational algebra outside of SQL.
//No more than 2 total QB.
Constraint hardQBCap = solver.MakeConstraint(0, 2, "Total QB Limit");
foreach (Player player in players.Keys.Where(p => p.Position == "QB").Join(players.Keys, p => new { p.Name, p.Team }, q => new { q.Name, q.Team }, (p, q) => q))
{
hardQBCap.SetCoefficient(players[player], 1);
}
//No more than 2 total TE.
Constraint hardTECap = solver.MakeConstraint(0, 2, "Total TE Limit");
foreach (Player player in players.Keys.Where(p => p.Position == "TE").Join(players.Keys, p => new { p.Name, p.Team }, q => new { q.Name, q.Team }, (p, q) => q))
{
hardTECap.SetCoefficient(players[player], 1);
}
//No more than 1 total K.
Constraint hardKCap = solver.MakeConstraint(0, 1, "Total K Limit");
foreach (Player player in players.Keys.Where(p => p.Position == "K").Join(players.Keys, p => new { p.Name, p.Team }, q => new { q.Name, q.Team }, (p, q) => q))
{
hardKCap.SetCoefficient(players[player], 1);
}
//No more than 1 total DEF.
Constraint hardDEFCap = solver.MakeConstraint(0, 1, "Total DEF Limit");
foreach (Player player in players.Keys.Where(p => p.Position == "DEF").Join(players.Keys, p => new { p.Name, p.Team }, q => new { q.Name, q.Team }, (p, q) => q))
{
hardDEFCap.SetCoefficient(players[player], 1);
}
#endregion
Console.WriteLine("Number of constraints = " + solver.NumConstraints()); //For the record, whoever wrote this library has no clue what accessors are in C#.
Objective objective = solver.Objective();
foreach (Player player in players.Keys)
{
objective.SetCoefficient(players[player], player.ProjectedPoints);
}
objective.SetMaximization();
Solver.ResultStatus resultStatus = solver.Solve();
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("The problem does not have an optimal solution!");
}
else
{
Console.WriteLine("Solution:");
Console.WriteLine("Optimal objective value = " + solver.Objective().Value());
double cost = 0;
foreach (Player player in players.Keys)
{
if (players[player].SolutionValue() == 1)
{
Console.WriteLine(players[player].Name());
cost += players[player].SolutionValue() * player.Price;
}
}
Console.WriteLine("Total used funds: $" + cost);
}
Console.WriteLine("\nAdvanced usage:");
Console.WriteLine("Problem solved in " + solver.WallTime() + " milliseconds");
Console.WriteLine("Problem solved in " + solver.Iterations() + " iterations");
Console.WriteLine("Problem solved in " + solver.Nodes() + " branch-and-bound nodes");
Console.ReadLine();
}
// [END data_model]
public static void Main()
{
// [START data]
DataModel data = new DataModel();
// [END data]
// [END program_part1]
// [START solver]
// Create the linear solver with the SCIP backend.
Solver solver = Solver.CreateSolver("SCIP");
// [END solver]
// [START program_part2]
// [START variables]
Variable[,] x = new Variable[data.NumItems, data.NumBins];
for (int i = 0; i < data.NumItems; i++)
{
for (int j = 0; j < data.NumBins; j++)
{
x[i, j] = solver.MakeIntVar(0, 1, $"x_{i}_{j}");
}
}
Variable[] y = new Variable[data.NumBins];
for (int j = 0; j < data.NumBins; j++)
{
y[j] = solver.MakeIntVar(0, 1, $"y_{j}");
}
// [END variables]
// [START constraints]
for (int i = 0; i < data.NumItems; ++i)
{
Constraint constraint = solver.MakeConstraint(1, 1, "");
for (int j = 0; j < data.NumBins; ++j)
{
constraint.SetCoefficient(x[i, j], 1);
}
}
for (int j = 0; j < data.NumBins; ++j)
{
Constraint constraint = solver.MakeConstraint(0, Double.PositiveInfinity, "");
constraint.SetCoefficient(y[j], data.BinCapacity);
for (int i = 0; i < data.NumItems; ++i)
{
constraint.SetCoefficient(x[i, j], -DataModel.Weights[i]);
}
}
// [END constraints]
// [START objective]
Objective objective = solver.Objective();
for (int j = 0; j < data.NumBins; ++j)
{
objective.SetCoefficient(y[j], 1);
}
objective.SetMinimization();
// [END objective]
// [START solve]
Solver.ResultStatus resultStatus = solver.Solve();
// [END solve]
// [START print_solution]
// Check that the problem has an optimal solution.
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("The problem does not have an optimal solution!");
return;
}
Console.WriteLine($"Number of bins used: {solver.Objective().Value()}");
double TotalWeight = 0.0;
for (int j = 0; j < data.NumBins; ++j)
{
double BinWeight = 0.0;
if (y[j].SolutionValue() == 1)
{
Console.WriteLine($"Bin {j}");
for (int i = 0; i < data.NumItems; ++i)
{
if (x[i, j].SolutionValue() == 1)
{
Console.WriteLine($"Item {i} weight: {DataModel.Weights[i]}");
BinWeight += DataModel.Weights[i];
}
}
Console.WriteLine($"Packed bin weight: {BinWeight}");
TotalWeight += BinWeight;
}
}
Console.WriteLine($"Total packed weight: {TotalWeight}");
// [END print_solution]
}
static void Main()
{
// Data.
// [START data]
int[,] costs =
{
{ 90, 76, 75, 70, 50, 74, 12, 68 }, { 35, 85, 55, 65, 48, 101, 70, 83 },
{ 125, 95, 90, 105, 59, 120, 36, 73 }, { 45, 110, 95, 115, 104, 83, 37, 71 },
{ 60, 105, 80, 75, 59, 62, 93, 88 }, { 45, 65, 110, 95, 47, 31, 81, 34 },
{ 38, 51, 107, 41, 69, 99, 115, 48 }, { 47, 85, 57, 71, 92, 77, 109, 36 },
{ 39, 63, 97, 49, 118, 56, 92, 61 }, { 47, 101, 71, 60, 88, 109, 52, 90 },
};
int numWorkers = costs.GetLength(0);
int numTasks = costs.GetLength(1);
int[] allWorkers = Enumerable.Range(0, numWorkers).ToArray();
int[] allTasks = Enumerable.Range(0, numTasks).ToArray();
int[] taskSizes = { 10, 7, 3, 12, 15, 4, 11, 5 };
// Maximum total of task sizes for any worker
int totalSizeMax = 15;
// [END data]
// Solver.
// [START solver]
Solver solver = Solver.CreateSolver("SCIP");
// [END solver]
// Variables.
// [START variables]
// x[i, j] is an array of 0-1 variables, which will be 1
// if worker i is assigned to task j.
Variable[,] x = new Variable[numWorkers, numTasks];
foreach (int worker in allWorkers)
{
foreach (int task in allTasks)
{
x[worker, task] = solver.MakeBoolVar($"x[{worker},{task}]");
}
}
// [END variables]
// Constraints
// [START constraints]
// Each worker is assigned to at most max task size.
foreach (int worker in allWorkers)
{
Constraint constraint = solver.MakeConstraint(0, totalSizeMax, "");
foreach (int task in allTasks)
{
constraint.SetCoefficient(x[worker, task], taskSizes[task]);
}
}
// Each task is assigned to exactly one worker.
foreach (int task in allTasks)
{
Constraint constraint = solver.MakeConstraint(1, 1, "");
foreach (int worker in allWorkers)
{
constraint.SetCoefficient(x[worker, task], 1);
}
}
// [END constraints]
// Objective
// [START objective]
Objective objective = solver.Objective();
foreach (int worker in allWorkers)
{
foreach (int task in allTasks)
{
objective.SetCoefficient(x[worker, task], costs[worker, task]);
}
}
objective.SetMinimization();
// [END objective]
// Solve
// [START solve]
Solver.ResultStatus resultStatus = solver.Solve();
// [END solve]
// Print solution.
// [START print_solution]
// Check that the problem has a feasible solution.
if (resultStatus == Solver.ResultStatus.OPTIMAL || resultStatus == Solver.ResultStatus.FEASIBLE)
{
Console.WriteLine($"Total cost: {solver.Objective().Value()}\n");
foreach (int worker in allWorkers)
{
foreach (int task in allTasks)
{
// Test if x[i, j] is 0 or 1 (with tolerance for floating point
// arithmetic).
if (x[worker, task].SolutionValue() > 0.5)
{
Console.WriteLine($"Worker {worker} assigned to task {task}. Cost: {costs[worker, task]}");
}
}
}
}
else
{
Console.WriteLine("No solution found.");
}
// [END print_solution]
}
private static void Witi_SOLUTION()
{
Solver solver = Solver.CreateSolver("SimpleMipProgram", "CBC_MIXED_INTEGER_PROGRAMMING");
string[] text = File.ReadAllLines(@"test.txt"); //SPD/SPD/BIN/DEBUG
string dataStart = text[0];
string[] result = dataStart.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
HowManyTasks = Convert.ToInt32(result[0]);
List <WiTi> witiTasks = new List <WiTi>();
for (int i = 1; i <= HowManyTasks; i++)
{
result = text[i].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
witiTasks.Add(new WiTi {
P = Convert.ToInt32(result[0]), W = Convert.ToInt32(result[1]), D = Convert.ToInt32(result[2])
});
}
int Time = 0;
int variablesMaxValue = 0;
foreach (var element in witiTasks)
{
Time += element.P;
int kara = 0;
if (element.D < Time)
{
kara = element.W * (Time - element.D);
}
variablesMaxValue += kara;
Console.WriteLine(variablesMaxValue + " | " + Time);
}
var alfas = solver.MakeIntVarMatrix(witiTasks.Count, witiTasks.Count, 0, 1);
var starts = solver.MakeIntVarArray(witiTasks.Count, 0, Time);
var ends = solver.MakeIntVarArray(witiTasks.Count, 0, Time);
var cmax = solver.MakeIntVar(0, variablesMaxValue, "cmax");
//int helpTime = 0;
var suma = new LinearExpr();
for (int i = 0; i < witiTasks.Count; i++)
{
solver.Add(ends[i] >= starts[i] + witiTasks[i].P);
solver.Add(ends[i] >= witiTasks[i].D);
solver.Add(cmax >= witiTasks[i].W * (ends[i] - witiTasks[i].D) + suma);
suma += witiTasks[i].W * (ends[i] - witiTasks[i].D);
}
for (int i = 0; i < witiTasks.Count; i++)
{
for (int j = i + 1; j < witiTasks.Count; j++)
{
solver.Add(starts[i] + witiTasks[i].P <= starts[j] + alfas[i, j] * variablesMaxValue);
solver.Add(starts[j] + witiTasks[j].P <= starts[i] + alfas[j, i] * variablesMaxValue);
solver.Add(alfas[i, j] + alfas[j, i] == 1);
}
}
solver.Minimize(cmax);
Solver.ResultStatus resultStatus = solver.Solve();
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
Console.WriteLine("Solve nie znalazl optymala");
}
else
{
Console.WriteLine("Obiect_value = " + solver.Objective().Value());
}
}
private Tuple <double, List <double>, List <double> > Solve(List <Constraint> _constraints, List <double> _function, OptDirectionEnum _optDirection, int xCount, int zCount)
{
Solver solver = Solver.CreateSolver("GLOP");
List <Variable> variables = new List <Variable>();
//add y
for (int i = 0; i < _function.Count; i++)
{
variables.Add(solver.MakeNumVar(0.0, double.PositiveInfinity, "y" + i));
}
List <Google.OrTools.LinearSolver.Constraint> constraints = CreateConstraints(solver, _constraints);
SetConstraints(constraints, _constraints, variables);
//setup function
Objective objective = solver.Objective();
for (int i = 0; i < _function.Count; i++)
{
objective.SetCoefficient(variables[i], _function[i]);
}
if (_optDirection == OptDirectionEnum.max)
{
objective.SetMaximization();
}
else
{
objective.SetMinimization();
}
Solver.ResultStatus resultStatus = solver.Solve();
// Check that the problem has an optimal solution.
if (resultStatus != Solver.ResultStatus.OPTIMAL)
{
throw new NoOptimumException();
//Console.WriteLine("The problem does not have an optimal solution!");
}
if (variables[0].SolutionValue() == 0)
{
throw new Y0IsNullException();
}
List <double> ys = new List <double>();
for (int i = 0; i < xCount + 1; i++)
{
ys.Add(variables[i].SolutionValue());
}
List <double> zs = new List <double>();
for (int i = 0; i < zCount; i++)
{
zs.Add(variables[xCount + 1 + i].SolutionValue());
}
return(new Tuple <double, List <double>, List <double> >(solver.Objective().Value(), ConvertToX(ys), zs));
}
