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)); }