new model_builder C# sample

ortools/linear_solver/csharp/ModelBuilder.cs

@@ -36,8 +36,8 @@ public ModelBuilder()
     {
         helper_ = new ModelBuilderHelper();
         constantMap_ = new Dictionary<double, int>();
-        var_value_map_ = new SortedDictionary<int, double>();
-        terms_ = new Queue<Term>();
+        tmp_var_value_map_ = new SortedDictionary<int, double>();
+        tmp_terms_ = new Queue<Term>();
     }
 
     /// <summary>
@@ -160,9 +160,9 @@ public LinearConstraint Add(BoundedLinearExpression lin)
     /// <returns>the linear constraint</returns>
     public LinearConstraint AddLinearConstraint(LinearExpr expr, double lb, double ub)
     {
-        var dict = var_value_map_;
+        var dict = tmp_var_value_map_;
         dict.Clear();
-        double offset = LinearExpr.GetVarValueMap(expr, dict, terms_);
+        double offset = LinearExpr.GetVarValueMap(expr, dict, tmp_terms_);
         LinearConstraint lin = new LinearConstraint(helper_);
         foreach (KeyValuePair<int, double> term in dict)
         {
@@ -235,9 +235,9 @@ public void Maximize(LinearExpr obj)
     public void Optimize(LinearExpr obj, bool maximize)
     {
         helper_.ClearObjective();
-        var dict = var_value_map_;
+        var dict = tmp_var_value_map_;
         dict.Clear();
-        double offset = LinearExpr.GetVarValueMap(obj, dict, terms_);
+        double offset = LinearExpr.GetVarValueMap(obj, dict, tmp_terms_);
         foreach (KeyValuePair<int, double> term in dict)
         {
             if (term.Value != 0.0)
@@ -330,8 +330,8 @@ public ModelBuilderHelper Helper
     private Dictionary<double, int> constantMap_;
 
     // Used to process linear exppressions.
-    private SortedDictionary<int, double> var_value_map_;
-    private Queue<Term> terms_;
+    private SortedDictionary<int, double> tmp_var_value_map_;
+    private Queue<Term> tmp_terms_;
 }
 
 } // namespace Google.OrTools.ModelBuilder

ortools/linear_solver/samples/CloneModelMb.cs

@@ -0,0 +1,101 @@
+// Copyright 2010-2022 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Minimal example to call the SCIP solver.
+// [START program]
+// [START import]
+using System;
+using Google.OrTools.ModelBuilder;
+// [END import]
+
+public class SimpleMipProgramMb
+{
+    static void Main()
+    {
+        // [START model]
+        // Create the model builder.
+        ModelBuilder model = new ModelBuilder();
+        // [END model]
+
+        // [START variables]
+        // Create the variables x and y.
+        Variable x = model.NewIntVar(0.0, double.PositiveInfinity, "x");
+        Variable y = model.NewIntVar(0.0, double.PositiveInfinity, "y");
+        // [END variables]
+
+        // [START constraints]
+        // x + 7 * y <= 17.5.
+        model.Add(x + 7 * y <= 17.5);
+
+        // x <= 3.5.
+        LinearConstraint c2 = model.Add(x <= 3.5);
+        // [END constraints]
+
+        // [START objective]
+        // Maximize x + 10 * y.
+        model.Maximize(x + 10 * y);
+        // [END objective]
+
+        // [Start clone]
+        // Clone the model.
+        Console.WriteLine("Cloning the model");
+        ModelBuilder modelCopy = model.Clone();
+        Variable xCopy = modelCopy.VarFromIndex(x.Index);
+        Variable yCopy = modelCopy.VarFromIndex(y.Index);
+        Variable zCopy = modelCopy.NewBoolVar("z");
+        LinearConstraint c2Copy = modelCopy.ConstraintFromIndex(c2.Index);
+
+        // Add a new constraint.
+        LinearConstraint unusedC3Copy = modelCopy.Add(xCopy >= 1);
+
+        // Modify a constraint.
+        c2Copy.AddTerm(zCopy, 2.0);
+
+        Console.WriteLine("Number of constraints in the original model = " + model.ConstraintsCount());
+        Console.WriteLine("Number of constraints in the cloned model = " + modelCopy.ConstraintsCount());
+        // [END clone]        
+
+        // [START solver]
+        // Create the model solver with the GLOP backend.
+        ModelSolver solver = new ModelSolver("SCIP");
+        if (!solver.SolverIsSupported())
+        {
+            return;
+        }
+        // [END solver]
+
+        // [START solve]
+        var resultStatus = solver.Solve(modelCopy);
+        // [END solve]
+
+        // [START print_solution]
+        // Check that the problem has an optimal solution.
+        if (resultStatus != SolveStatus.OPTIMAL)
+        {
+            Console.WriteLine("The problem does not have an optimal solution!");
+            return;
+        }
+        Console.WriteLine("Solution:");
+        Console.WriteLine("Objective value = " + solver.ObjectiveValue);
+        Console.WriteLine("x = " + solver.Value(xCopy));
+        Console.WriteLine("y = " + solver.Value(yCopy));
+        Console.WriteLine("z = " + solver.Value(zCopy));
+        // [END print_solution]
+
+        // [START advanced]
+        Console.WriteLine("\nAdvanced usage:");
+        Console.WriteLine("Problem solved in " + solver.WallTime + " milliseconds");
+        // [END advanced]
+    }
+}
+// [END program]