Changeset 16582 for branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/LinearProgrammingAlgorithm.cs

Timestamp:

01/29/19 17:45:06 (5 years ago)

Author:

ddorfmei

Message:

#2931: solved the issues found during the review

File:

• branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/LinearProgrammingAlgorithm.cs (modified) (7 diffs)

branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/LinearProgrammingAlgorithm.cs

@@ -30 +30 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.MathematicalOptimization.LinearProgramming {
-
-  [Item("Linear/Mixed Integer Programming (LP/MIP)", "Linear/mixed integer programming implemented in several solvers. " +
-    "See also https://dev.heuristiclab.com/trac.fcgi/wiki/Documentation/Howto/LinearMixedIntegerProgramming")] // TODO: update link
+namespace HeuristicLab.ExactOptimization.LinearProgramming {
+
+  [Item("Mixed-Integer Linear Programming (LP, MIP)", "Linear/mixed integer programming implemented in several solvers. " +
+    "See also https://dev.heuristiclab.com/trac.fcgi/wiki/Documentation/Reference/ExactOptimization")]
   [Creatable(CreatableAttribute.Categories.ExactAlgorithms)]
   [StorableClass]
-  public class LinearProgrammingAlgorithm : BasicAlgorithm {
+  public sealed class LinearProgrammingAlgorithm : BasicAlgorithm {
 
     [Storable]
@@ -42 +42 @@
 
     [Storable]
-    private readonly IFixedValueParameter<FileValue> exportModelParam;
-
-    [Storable]
-    private readonly IFixedValueParameter<EnumValue<LpAlgorithmValues>> lpAlgorithmParam;
-
-    [Storable]
     private readonly IFixedValueParameter<BoolValue> presolveParam;
 
@@ -64 +58 @@
     [Storable]
     private IConstrainedValueParameter<ILinearSolver> linearSolverParam;
+
+    #region Problem Properties
+
+    public new LinearProblem Problem {
+      get => (LinearProblem)base.Problem;
+      set => base.Problem = value;
+    }
+
+    public override Type ProblemType { get; } = typeof(LinearProblem);
+
+    #endregion
+    #region Parameter Properties
+
+    public IFixedValueParameter<DoubleValue> DualToleranceParameter => dualToleranceParam;
+    public IConstrainedValueParameter<ILinearSolver> LinearSolverParameter => linearSolverParam;
+    public IFixedValueParameter<BoolValue> PresolveParameter => presolveParam;
+    public IFixedValueParameter<DoubleValue> PrimalToleranceParameter => primalToleranceParam;
+    public IFixedValueParameter<PercentValue> RelativeGapToleranceParameter => relativeGapToleranceParam;
+    public IFixedValueParameter<BoolValue> ScalingParameter => scalingParam;
+    public IFixedValueParameter<TimeSpanValue> TimeLimitParameter => timeLimitParam;
+
+    #endregion
+    #region Properties
+
+    public double DualTolerance {
+      get => dualToleranceParam.Value.Value;
+      set => dualToleranceParam.Value.Value = value;
+    }
+
+    public ILinearSolver LinearSolver {
+      get => linearSolverParam.Value;
+      set => linearSolverParam.Value = value;
+    }
+
+    public bool Presolve {
+      get => presolveParam.Value.Value;
+      set => presolveParam.Value.Value = value;
+    }
+
+    public double PrimalTolerance {
+      get => primalToleranceParam.Value.Value;
+      set => primalToleranceParam.Value.Value = value;
+    }
+
+    public double RelativeGapTolerance {
+      get => relativeGapToleranceParam.Value.Value;
+      set => relativeGapToleranceParam.Value.Value = value;
+    }
+
+    public bool Scaling {
+      get => scalingParam.Value.Value;
+      set => scalingParam.Value.Value = value;
+    }
+
+    public override bool SupportsPause => LinearSolver.SupportsPause;
+    public override bool SupportsStop => LinearSolver.SupportsStop;
+
+    public TimeSpan TimeLimit {
+      get => timeLimitParam.Value.Value;
+      set => timeLimitParam.Value.Value = value;
+    }
+
+    #endregion
 
     public LinearProgrammingAlgorithm() {
@@ -70 +127 @@
 
       ILinearSolver defaultSolver;
-      linearSolverParam.ValidValues.Add(new BopSolver());
       linearSolverParam.ValidValues.Add(defaultSolver = new CoinOrSolver());
       linearSolverParam.ValidValues.Add(new CplexSolver());
       linearSolverParam.ValidValues.Add(new GlopSolver());
-      linearSolverParam.ValidValues.Add(new GlpkSolver());
       linearSolverParam.ValidValues.Add(new GurobiSolver());
       linearSolverParam.ValidValues.Add(new ScipSolver());
@@ -80 +135 @@
 
       Parameters.Add(relativeGapToleranceParam = new FixedValueParameter<PercentValue>(nameof(RelativeGapTolerance),
-        "Limit for relative MIP gap.", new PercentValue(MPSolverParameters.kDefaultRelativeMipGap)));
+        "Limit for relative MIP gap.", new PercentValue(SolverParameters.DefaultRelativeMipGap)));
       Parameters.Add(timeLimitParam = new FixedValueParameter<TimeSpanValue>(nameof(TimeLimit),
-        "Limit for runtime. Set to zero for unlimited runtime.", new TimeSpanValue()));
+        "Limit for runtime. Set to zero for unlimited runtime.",
+        new TimeSpanValue(new TimeSpan(0, 1, 0))));
       Parameters.Add(presolveParam =
-        new FixedValueParameter<BoolValue>(nameof(Presolve), "Advanced usage: presolve mode.", new BoolValue()));
-      Parameters.Add(lpAlgorithmParam = new FixedValueParameter<EnumValue<LpAlgorithmValues>>(nameof(LpAlgorithm),
-        "Algorithm to solve linear programs.", new EnumValue<LpAlgorithmValues>(LpAlgorithmValues.DualSimplex)));
+        new FixedValueParameter<BoolValue>(nameof(Presolve), "Advanced usage: presolve mode.",
+          new BoolValue(SolverParameters.DefaultPresolve == SolverParameters.PresolveValues.PresolveOn)) { Hidden = true });
       Parameters.Add(dualToleranceParam = new FixedValueParameter<DoubleValue>(nameof(DualTolerance),
         "Advanced usage: tolerance for dual feasibility of basic solutions.",
-        new DoubleValue(MPSolverParameters.kDefaultDualTolerance)));
+        new DoubleValue(SolverParameters.DefaultDualTolerance)) { Hidden = true });
       Parameters.Add(primalToleranceParam = new FixedValueParameter<DoubleValue>(nameof(PrimalTolerance),
         "Advanced usage: tolerance for primal feasibility of basic solutions. " +
         "This does not control the integer feasibility tolerance of integer " +
         "solutions for MIP or the tolerance used during presolve.",
-        new DoubleValue(MPSolverParameters.kDefaultPrimalTolerance)));
+        new DoubleValue(SolverParameters.DefaultPrimalTolerance)) { Hidden = true });
       Parameters.Add(scalingParam = new FixedValueParameter<BoolValue>(nameof(Scaling),
-        "Advanced usage: enable or disable matrix scaling.", new BoolValue()));
-      Parameters.Add(exportModelParam =
-        new FixedValueParameter<FileValue>(nameof(ExportModel),
-          "Path of the file the model should be exported to. Run the algorithm to export the model.",
-          new FileValue {
-            SaveFile = true,
-            FileDialogFilter = "CPLEX LP File (*.lp)|*.lp|" +
-                               "Mathematical Programming System File (*.mps)|*.mps|" +
-                               "Google OR-Tools Protocol Buffers Text File (*.prototxt)|*.prototxt|" +
-                               "Google OR-Tools Protocol Buffers Binary File (*.bin)|*.bin"
-          }));
-
-      Problem = new LinearProgrammingProblem();
+        "Advanced usage: enable or disable matrix scaling.", new BoolValue()) { Hidden = true });
+
+      Problem = new LinearProblem();
     }
 
     [StorableConstructor]
-    protected LinearProgrammingAlgorithm(bool deserializing)
+    private LinearProgrammingAlgorithm(bool deserializing)
       : base(deserializing) {
     }
 
-    protected LinearProgrammingAlgorithm(LinearProgrammingAlgorithm original, Cloner cloner)
+    private LinearProgrammingAlgorithm(LinearProgrammingAlgorithm original, Cloner cloner)
       : base(original, cloner) {
       linearSolverParam = cloner.Clone(original.linearSolverParam);
@@ -122 +167 @@
       timeLimitParam = cloner.Clone(original.timeLimitParam);
       presolveParam = cloner.Clone(original.presolveParam);
-      lpAlgorithmParam = cloner.Clone(original.lpAlgorithmParam);
       dualToleranceParam = cloner.Clone(original.dualToleranceParam);
       primalToleranceParam = cloner.Clone(original.primalToleranceParam);
       scalingParam = cloner.Clone(original.scalingParam);
-      exportModelParam = cloner.Clone(original.exportModelParam);
-    }
-
-    public double DualTolerance {
-      get => dualToleranceParam.Value.Value;
-      set => dualToleranceParam.Value.Value = value;
-    }
-
-    public string ExportModel {
-      get => exportModelParam.Value.Value;
-      set => exportModelParam.Value.Value = value;
-    }
-
-    public ILinearSolver LinearSolver {
-      get => linearSolverParam.Value;
-      set => linearSolverParam.Value = value;
-    }
-
-    public IConstrainedValueParameter<ILinearSolver> LinearSolverParameter {
-      get => linearSolverParam;
-      set => linearSolverParam = value;
-    }
-
-    public LpAlgorithmValues LpAlgorithm {
-      get => lpAlgorithmParam.Value.Value;
-      set => lpAlgorithmParam.Value.Value = value;
-    }
-
-    public bool Presolve {
-      get => presolveParam.Value.Value;
-      set => presolveParam.Value.Value = value;
-    }
-
-    public double PrimalTolerance {
-      get => primalToleranceParam.Value.Value;
-      set => primalToleranceParam.Value.Value = value;
-    }
-
-    public new LinearProgrammingProblem Problem {
-      get => (LinearProgrammingProblem)base.Problem;
-      set => base.Problem = value;
-    }
-
-    public override Type ProblemType { get; } = typeof(LinearProgrammingProblem);
-
-    public double RelativeGapTolerance {
-      get => relativeGapToleranceParam.Value.Value;
-      set => relativeGapToleranceParam.Value.Value = value;
-    }
-
-    public override ResultCollection Results { get; } = new ResultCollection();
-
-    public bool Scaling {
-      get => scalingParam.Value.Value;
-      set => scalingParam.Value.Value = value;
-    }
-
-    public override bool SupportsPause => LinearSolver.SupportsPause;
-
-    public override bool SupportsStop => LinearSolver.SupportsStop;
-
-    public TimeSpan TimeLimit {
-      get => timeLimitParam.Value.Value;
-      set => timeLimitParam.Value.Value = value;
     }
 
@@ -216 +196 @@
       LinearSolver.PrimalTolerance = PrimalTolerance;
       LinearSolver.DualTolerance = DualTolerance;
-      LinearSolver.LpAlgorithm = LpAlgorithm;
       LinearSolver.Presolve = Presolve;
       LinearSolver.RelativeGapTolerance = RelativeGapTolerance;
       LinearSolver.Scaling = Scaling;
       LinearSolver.TimeLimit = TimeLimit;
-      LinearSolver.ExportModel = ExportModel;
-      var executionTime = ExecutionTime;
-      ExecutionTimeChanged += (sender, args) => executionTime = ExecutionTime;
-      LinearSolver.Solve(Problem.ProblemDefinition, ref executionTime, Results, cancellationToken);
+      LinearSolver.Solve(Problem.ProblemDefinition, Results, cancellationToken);
     }
   }