Changeset 16373 for branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming

Timestamp:

12/12/18 14:23:45 (5 years ago)

Author:

ddorfmei

Message:

#2931:

• upgraded Google OR-Tools to version 6.10
• added TextValue and TextValueView to be able to display and edit a multiline string
• added parameter to set solver specific parameters for supported solvers
• added support for the Protocol Buffers representation of models (import/export)
• added import of MPS models
• added pause/stop functionality to CplexSolver and GlpkSolver
• refactored wrapper (LinearSolver and related enums)
• added new algorithm category Exact for LinearProgrammingAlgorithm

Location:

branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming

Files:

• Algorithms/LinearProgrammingAlgorithm.cs (modified) (7 diffs)
• Algorithms/ProblemType.cs (moved) (moved from branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/LinearProgrammingType.cs) (1 diff)
• Algorithms/Solvers/Base/IIncrementalSolver.cs (modified) (1 diff)
• Algorithms/Solvers/Base/ISolver.cs (modified) (1 diff)
• Algorithms/Solvers/Base/IncrementalSolver.cs (modified) (10 diffs)
• Algorithms/Solvers/Base/Solver.cs (modified) (6 diffs)
• Algorithms/Solvers/BopSolver.cs (modified) (3 diffs)
• Algorithms/Solvers/CoinOrSolver.cs (modified) (3 diffs)
• Algorithms/Solvers/CplexSolver.cs (modified) (3 diffs)
• Algorithms/Solvers/GlopSolver.cs (modified) (3 diffs)
• Algorithms/Solvers/GlpkSolver.cs (modified) (2 diffs)
• Algorithms/Solvers/GurobiSolver.cs (modified) (3 diffs)
• Algorithms/Solvers/ScipSolver.cs (modified) (3 diffs)
• Problems/ILinearProgrammingProblemDefinition.cs (modified) (1 diff)
• Problems/LinearProgrammingProblem.cs (modified) (3 diffs)
• Problems/LinearProgrammingProblemDefinitionScript.cs (modified) (2 diffs)
• Templates/CompiledLinearProgrammingProblemDefinition.cs (modified) (3 diffs)
• Wrapper (added)
• Wrapper/DoubleParam.cs (moved) (moved from branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/DoubleParam.cs) (2 diffs)
• Wrapper/IncrementalityValues.cs (moved) (moved from branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/IncrementalityValues.cs) (1 diff)
• Wrapper/IntegerParam.cs (moved) (moved from branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/IntegerParam.cs) (1 diff)
• Wrapper/LpAlgorithmValues.cs (moved) (moved from branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/LpAlgorithmValues.cs) (1 diff)
• Wrapper/ProtoWriteFormat.cs (added)
• Wrapper/SolverResponseStatus.cs (added)

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

@@ -35 +35 @@
 namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
 
-  [Item("Linear/Mixed Integer Programming (LP/MIP)", "")]
-  [Creatable(CreatableAttribute.Categories.SingleSolutionAlgorithms)]
+  [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
+  [Creatable(CreatableAttribute.Categories.ExactAlgorithms)]
   [StorableClass]
   public class LinearProgrammingAlgorithm : BasicAlgorithm {
@@ -53 +54 @@
 
     [Storable]
-    private readonly IFixedValueParameter<DoubleValue> relativeGapToleranceParam;
+    private readonly IFixedValueParameter<PercentValue> relativeGapToleranceParam;
 
     [Storable]
@@ -65 +66 @@
 
     public IConstrainedValueParameter<ISolver> SolverParameter {
-      get { return solverParam; }
-      set { solverParam = value; }
+      get => solverParam;
+      set => solverParam = value;
     }
 
@@ -72 +73 @@
       Parameters.Add(solverParam =
         new ConstrainedValueParameter<ISolver>(nameof(Solver), "The solver used to solve the model."));
-      Parameters.Add(relativeGapToleranceParam = new FixedValueParameter<DoubleValue>(nameof(RelativeGapTolerance),
-        "Limit for relative MIP gap.", new DoubleValue(MPSolverParameters.kDefaultRelativeMipGap)));
+
+      ISolver defaultSolver;
+      solverParam.ValidValues.Add(new BopSolver());
+      solverParam.ValidValues.Add(defaultSolver = new CoinOrSolver());
+      solverParam.ValidValues.Add(new CplexSolver());
+      solverParam.ValidValues.Add(new GlopSolver());
+      solverParam.ValidValues.Add(new GlpkSolver());
+      solverParam.ValidValues.Add(new GurobiSolver());
+      solverParam.ValidValues.Add(new ScipSolver());
+      solverParam.Value = defaultSolver;
+
+      Parameters.Add(relativeGapToleranceParam = new FixedValueParameter<PercentValue>(nameof(RelativeGapTolerance),
+        "Limit for relative MIP gap.", new PercentValue(MPSolverParameters.kDefaultRelativeMipGap)));
       Parameters.Add(timeLimitParam = new FixedValueParameter<TimeSpanValue>(nameof(TimeLimit),
         "Limit for runtime. Set to zero for unlimited runtime.", new TimeSpanValue()));
@@ -92 +104 @@
 
       Problem = new LinearProgrammingProblem();
-
-      solverParam.ValidValues.Add(new CoinOrSolver());
-      solverParam.ValidValues.Add(new CplexSolver());
-      solverParam.ValidValues.Add(new GlpkSolver());
-      solverParam.ValidValues.Add(new GurobiSolver());
-      solverParam.ValidValues.Add(new ScipSolver());
-      solverParam.ValidValues.Add(new BopSolver());
-      solverParam.ValidValues.Add(new GlopSolver());
     }
 
@@ -176 +180 @@
     public override void Pause() {
       base.Pause();
-      Solver.Interrupt();
+      Solver.InterruptSolve();
     }
 
@@ -190 +194 @@
     public override void Stop() {
       base.Stop();
-      Solver.Interrupt();
-    }
-
-    protected override void Initialize(CancellationToken cancellationToken) {
-      base.Initialize(cancellationToken);
+      Solver.InterruptSolve();
     }
 

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

@@ -22 +22 @@
 namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
 
-  public enum LinearProgrammingType {
+  public enum ProblemType {
     LinearProgramming,
     MixedIntegerProgramming

branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IIncrementalSolver.cs

@@ -25 +25 @@
 
   public interface IIncrementalSolver : ISolver {
-    bool Incrementality { get; set; }
     TimeSpan QualityUpdateInterval { get; set; }
+    bool SupportsQualityUpdate { get; }
   }
 }

branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/ISolver.cs

@@ -26 +26 @@
 
   public interface ISolver : IParameterizedNamedItem {
-    LinearProgrammingType LinearProgrammingType { get; set; }
+    ProblemType ProblemType { get; set; }
     bool SupportsPause { get; }
     bool SupportsStop { get; }
 
-    void Interrupt();
+    bool InterruptSolve();
 
     void Reset();

branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IncrementalSolver.cs

@@ -23 +23 @@
 using System.Linq;
 using System.Threading;
-using Google.OrTools.LinearSolver;
 using HeuristicLab.Analysis;
 using HeuristicLab.Common;
@@ -35 +34 @@
   [StorableClass]
   public class IncrementalSolver : Solver, IIncrementalSolver {
-
-    [Storable]
-    protected readonly IValueParameter<BoolValue> incrementalityParam;
 
     [Storable]
@@ -55 +51 @@
 
     public IncrementalSolver() {
-      Parameters.Add(incrementalityParam = new ValueParameter<BoolValue>(nameof(Incrementality),
-        "Advanced usage: incrementality from one solve to the next.",
-        new BoolValue(MPSolverParameters.kDefaultIncrementality == MPSolverParameters.INCREMENTALITY_ON)));
       Parameters.Add(qualityUpdateIntervalParam =
         new ValueParameter<TimeSpanValue>(nameof(QualityUpdateInterval),
-          "Time interval before solver is paused, resuls are retrieved and solver is resumed.",
-          new TimeSpanValue(new TimeSpan(0, 0, 10))));
-
-      incrementalityParam.Value.ValueChanged += (sender, args) => {
-        if (((BoolValue)sender).Value) {
-          qualityUpdateIntervalParam.Value = new TimeSpanValue(qualityUpdateIntervalParam.Value.Value);
+          "Time interval before solver is paused, results are retrieved and solver is resumed. " +
+          "Set to zero for no intermediate results and faster solving.", new TimeSpanValue(new TimeSpan(0, 0, 10))));
+      problemTypeParam.Value.ValueChanged += (sender, args) => {
+        if (SupportsQualityUpdate) {
+          if (!Parameters.Contains(qualityUpdateIntervalParam)) {
+            Parameters.Add(qualityUpdateIntervalParam);
+          }
         } else {
-          qualityUpdateIntervalParam.Value = (TimeSpanValue)qualityUpdateIntervalParam.Value.AsReadOnly();
+          Parameters.Remove(qualityUpdateIntervalParam);
         }
       };
@@ -74 +68 @@
     protected IncrementalSolver(IncrementalSolver original, Cloner cloner)
         : base(original, cloner) {
-      programmingTypeParam = cloner.Clone(original.programmingTypeParam);
+      problemTypeParam = cloner.Clone(original.problemTypeParam);
       qualityUpdateIntervalParam = cloner.Clone(original.qualityUpdateIntervalParam);
-      incrementalityParam = cloner.Clone(original.incrementalityParam);
       if (original.qualityPerClock != null)
         qualityPerClock = cloner.Clone(original.qualityPerClock);
     }
 
-    public bool Incrementality {
-      get => incrementalityParam.Value.Value;
-      set => incrementalityParam.Value.Value = value;
-    }
+    public virtual bool SupportsQualityUpdate => true;
 
     public TimeSpan QualityUpdateInterval {
@@ -91 +81 @@
     }
 
+    protected virtual TimeSpan TimeLimit => QualityUpdateInterval;
+
     public override void Solve(LinearProgrammingAlgorithm algorithm, CancellationToken cancellationToken) {
-      if (!Incrementality) {
+      if (!SupportsQualityUpdate || QualityUpdateInterval == TimeSpan.Zero) {
         base.Solve(algorithm, cancellationToken);
         return;
@@ -101 +93 @@
 
       if (!unlimitedRuntime) {
-        var wallTime = ((TimeSpanValue)algorithm.Results.SingleOrDefault(r => r.Name == "Wall Time")?.Value)?.Value;
-        if (wallTime.HasValue) {
-          timeLimit -= wallTime.Value;
-        }
+        timeLimit -= algorithm.ExecutionTime;
       }
 
       var iterations = (long)timeLimit.TotalMilliseconds / (long)QualityUpdateInterval.TotalMilliseconds;
       var remaining = timeLimit - TimeSpan.FromMilliseconds(iterations * QualityUpdateInterval.TotalMilliseconds);
-      var validResultStatuses = new[] { ResultStatus.NOT_SOLVED, ResultStatus.FEASIBLE };
+      var validResultStatuses = new[] { ResultStatus.NotSolved, ResultStatus.Feasible };
 
       while (unlimitedRuntime || iterations > 0) {
-        base.Solve(algorithm, QualityUpdateInterval, true);
+        if (cancellationToken.IsCancellationRequested)
+          return;
+
+        base.Solve(algorithm, TimeLimit);
         UpdateQuality(algorithm);
 
-        var resultStatus = ((EnumValue<ResultStatus>)algorithm.Results["Result Status"].Value).Value;
-        if (!validResultStatuses.Contains(resultStatus) || cancellationToken.IsCancellationRequested)
+        var resultStatus = ((EnumValue<ResultStatus>)algorithm.Results[nameof(solver.ResultStatus)].Value).Value;
+        if (!validResultStatuses.Contains(resultStatus))
           return;
 
@@ -124 +116 @@
 
       if (remaining > TimeSpan.Zero) {
-        base.Solve(algorithm, remaining, true);
+        base.Solve(algorithm, remaining);
         UpdateQuality(algorithm);
       }
@@ -132 +124 @@
       if (!algorithm.Results.Exists(r => r.Name == "QualityPerClock")) {
         qualityPerClock = new IndexedDataTable<double>("Quality per Clock");
-        qpcRow = new IndexedDataRow<double>("First-hit Graph Objective");
-        bpcRow = new IndexedDataRow<double>("First-hit Graph Bound");
+        qpcRow = new IndexedDataRow<double>("Objective Value");
+        bpcRow = new IndexedDataRow<double>("Bound");
         algorithm.Results.AddOrUpdateResult("QualityPerClock", qualityPerClock);
       }
 
-      var resultStatus = ((EnumValue<ResultStatus>)algorithm.Results["Result Status"].Value).Value;
+      var resultStatus = ((EnumValue<ResultStatus>)algorithm.Results[nameof(solver.ResultStatus)].Value).Value;
 
-      if (new[] { ResultStatus.ABNORMAL, ResultStatus.NOT_SOLVED, ResultStatus.UNBOUNDED }.Contains(resultStatus))
+      if (new[] { ResultStatus.Abnormal, ResultStatus.NotSolved, ResultStatus.Unbounded }.Contains(resultStatus))
         return;
 
-      var objective = ((DoubleValue)algorithm.Results["Best Objective Value"].Value).Value;
-      var bound = ((DoubleValue)algorithm.Results["Best Objective Bound"].Value).Value;
+      var objective = ((DoubleValue)algorithm.Results[$"Best{nameof(solver.ObjectiveValue)}"].Value).Value;
+      var bound = solver.IsMip ? ((DoubleValue)algorithm.Results[$"Best{nameof(solver.ObjectiveBound)}"].Value).Value : double.NaN;
       var time = algorithm.ExecutionTime.TotalSeconds;
 
@@ -151 +143 @@
           qpcRow.Values.Add(Tuple.Create(time, objective));
           qualityPerClock.Rows.Add(qpcRow);
-          algorithm.Results.AddOrUpdateResult("Best Solution Found At", new TimeSpanValue(TimeSpan.FromSeconds(time)));
+          algorithm.Results.AddOrUpdateResult($"Best{nameof(solver.ObjectiveValue)}FoundAt", new TimeSpanValue(TimeSpan.FromSeconds(time)));
         }
       } else {
@@ -158 +150 @@
         if (!objective.IsAlmost(previousBest)) {
           qpcRow.Values.Add(Tuple.Create(time, objective));
-          algorithm.Results.AddOrUpdateResult("Best Solution Found At", new TimeSpanValue(TimeSpan.FromSeconds(time)));
+          algorithm.Results.AddOrUpdateResult($"Best{nameof(solver.ObjectiveValue)}FoundAt", new TimeSpanValue(TimeSpan.FromSeconds(time)));
         }
       }
+
+      if (!solver.IsMip)
+        return;
 
       if (!bpcRow.Values.Any()) {

branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/Solver.cs

@@ -34 +34 @@
 
     [Storable]
-    protected IValueParameter<EnumValue<LinearProgrammingType>> programmingTypeParam;
+    protected IValueParameter<EnumValue<ProblemType>> problemTypeParam;
 
     protected LinearSolver solver;
 
+    [Storable]
+    protected IFixedValueParameter<TextValue> solverSpecificParametersParam;
+
     public Solver() {
-      Parameters.Add(programmingTypeParam =
-        new ValueParameter<EnumValue<LinearProgrammingType>>(nameof(LinearProgrammingType),
-          new EnumValue<LinearProgrammingType>()));
+      Parameters.Add(problemTypeParam =
+        new ValueParameter<EnumValue<ProblemType>>(nameof(ProblemType), new EnumValue<ProblemType>()));
+      Parameters.Add(solverSpecificParametersParam =
+        new FixedValueParameter<TextValue>(nameof(SolverSpecificParameters), new TextValue()));
     }
 
@@ -51 +55 @@
     protected Solver(Solver original, Cloner cloner)
       : base(original, cloner) {
-      programmingTypeParam = cloner.Clone(original.programmingTypeParam);
+      problemTypeParam = cloner.Clone(original.problemTypeParam);
+      solverSpecificParametersParam = cloner.Clone(original.solverSpecificParametersParam);
     }
 
-    public LinearProgrammingType LinearProgrammingType {
-      get => programmingTypeParam.Value.Value;
-      set => programmingTypeParam.Value.Value = value;
+    public ProblemType ProblemType {
+      get => problemTypeParam.Value.Value;
+      set => problemTypeParam.Value.Value = value;
     }
 
+    public TextValue SolverSpecificParameters => solverSpecificParametersParam.Value;
+
+    public virtual bool SupportsPause => true;
+    public virtual bool SupportsStop => true;
     protected virtual OptimizationProblemType OptimizationProblemType { get; }
-    public virtual bool SupportsPause => false;
-    public virtual bool SupportsStop => false;
 
     public override IDeepCloneable Clone(Cloner cloner) => new Solver(this, cloner);
@@ -67 +74 @@
     public void Dispose() => solver?.Dispose();
 
-    public void Interrupt() => solver.Stop();
+    public bool InterruptSolve() => solver?.InterruptSolve() ?? false;
 
     public virtual void Reset() {
@@ -78 +85 @@
 
     public virtual void Solve(LinearProgrammingAlgorithm algorithm) =>
-      Solve(algorithm, algorithm.TimeLimit, false);
+      Solve(algorithm, algorithm.TimeLimit);
 
-    public virtual void Solve(LinearProgrammingAlgorithm algorithm, TimeSpan timeLimit, bool incrementality) {
+    public virtual void Solve(LinearProgrammingAlgorithm algorithm, TimeSpan timeLimit) {
       string libraryName = null;
       if (this is IExternalSolver externalSolver)
@@ -86 +93 @@
 
       if (solver == null) {
-        solver = LinearSolver.CreateSolver(OptimizationProblemType, Name,
-          libraryName, s => algorithm.Problem.ProblemDefinition.BuildModel(s));
+        solver = new LinearSolver(OptimizationProblemType, s => algorithm.Problem.ProblemDefinition.BuildModel(s), Name,
+          libraryName);
       }
 
@@ -97 +104 @@
       solver.Scaling = algorithm.Scaling;
       solver.LpAlgorithm = algorithm.LpAlgorithm;
-      solver.Incrementality = incrementality;
+      solver.Incrementality = true;
+
+      if (!solver.SetSolverSpecificParameters(SolverSpecificParameters.Value))
+        throw new ArgumentException("Solver specific parameters could not be set.");
 
       solver.Solve();
 
       algorithm.Problem.ProblemDefinition.Analyze(solver.Solver, algorithm.Results);
-      algorithm.Results.AddOrUpdateResult("Result Status", new EnumValue<ResultStatus>(solver.ResultStatus));
-      algorithm.Results.AddOrUpdateResult("Best Objective Value",
+      algorithm.Results.AddOrUpdateResult(nameof(solver.ResultStatus),
+        new EnumValue<ResultStatus>(solver.ResultStatus));
+      algorithm.Results.AddOrUpdateResult($"Best{nameof(solver.ObjectiveValue)}",
         new DoubleValue(solver.ObjectiveValue ?? double.NaN));
-      algorithm.Results.AddOrUpdateResult("Best Objective Bound",
-        new DoubleValue(solver.ObjectiveBound ?? double.NaN));
-      algorithm.Results.AddOrUpdateResult("Absolute Gap", new DoubleValue(solver.AbsoluteGap ?? double.NaN));
-      algorithm.Results.AddOrUpdateResult("Relative Gap", new DoubleValue(solver.RelativeGap ?? double.NaN));
-      algorithm.Results.AddOrUpdateResult("Number of Constraints", new IntValue(solver.NumberOfConstraints));
-      algorithm.Results.AddOrUpdateResult("Number of Variables", new IntValue(solver.NumberOfVariables));
-      algorithm.Results.AddOrUpdateResult("Number of Nodes", new DoubleValue(solver.NumberOfNodes));
-      algorithm.Results.AddOrUpdateResult("Iterations", new DoubleValue(solver.Iterations));
-      algorithm.Results.AddOrUpdateResult("Solver Version", new StringValue(solver.SolverVersion));
-      algorithm.Results.AddOrUpdateResult("Wall Time", new TimeSpanValue(solver.WallTime ?? TimeSpan.Zero));
+
+      if (solver.IsMip) {
+        algorithm.Results.AddOrUpdateResult($"Best{nameof(solver.ObjectiveBound)}",
+          new DoubleValue(solver.ObjectiveBound ?? double.NaN));
+        algorithm.Results.AddOrUpdateResult(nameof(solver.AbsoluteGap),
+          new DoubleValue(solver.AbsoluteGap ?? double.NaN));
+        algorithm.Results.AddOrUpdateResult(nameof(solver.RelativeGap),
+          new PercentValue(solver.RelativeGap ?? double.NaN));
+      }
+
+      algorithm.Results.AddOrUpdateResult(nameof(solver.NumberOfConstraints), new IntValue(solver.NumberOfConstraints));
+      algorithm.Results.AddOrUpdateResult(nameof(solver.NumberOfVariables), new IntValue(solver.NumberOfVariables));
+
+      if (solver.IsMip) {
+        algorithm.Results.AddOrUpdateResult(nameof(solver.NumberOfNodes), new DoubleValue(solver.NumberOfNodes));
+      }
+
+      algorithm.Results.AddOrUpdateResult(nameof(solver.Iterations), new DoubleValue(solver.Iterations));
+      algorithm.Results.AddOrUpdateResult(nameof(solver.SolverVersion), new StringValue(solver.SolverVersion));
     }
   }

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

@@ -20 +20 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -32 +35 @@
 
     public BopSolver() {
-      Parameters.Remove(programmingTypeParam);
+      Parameters.Remove(problemTypeParam);
+      Parameters.Add(new FixedValueParameter<StringValue>(nameof(ProblemType), new StringValue("ZeroOneProgramming").AsReadOnly()));
+      SolverSpecificParameters.Value =
+        "# for file format, see Protocol Buffers text format (https://developers.google.com/protocol-buffers/docs/overview#whynotxml)" + Environment.NewLine +
+        "# for parameters, see https://github.com/google/or-tools/blob/v6.10/ortools/bop/bop_parameters.proto" + Environment.NewLine +
+        "# example:" + Environment.NewLine +
+        "# random_seed: 10" + Environment.NewLine;
     }
 
@@ -44 +53 @@
     }
 
-    public override bool SupportsPause => true;
-
-    public override bool SupportsStop => true;
-
     protected override OptimizationProblemType OptimizationProblemType =>
-              OptimizationProblemType.BOP_INTEGER_PROGRAMMING;
+               OptimizationProblemType.BopIntegerProgramming;
   }
 }

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

@@ -22 +22 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -33 +32 @@
 
     public CoinOrSolver() {
-      programmingTypeParam.Value.ValueChanged += (sender, args) => {
-        if (((EnumValue<LinearProgrammingType>)sender).Value == LinearProgrammingType.LinearProgramming) {
-          incrementalityParam.Value = new BoolValue(true);
-          incrementalityParam.Value.ValueChanged += (s, a) => {
-            if (((BoolValue)s).Value) {
-              qualityUpdateIntervalParam.Value = new TimeSpanValue(qualityUpdateIntervalParam.Value.Value);
-            } else {
-              qualityUpdateIntervalParam.Value = (TimeSpanValue)qualityUpdateIntervalParam.Value.AsReadOnly();
-            }
-          };
-        } else {
-          incrementalityParam.Value = (BoolValue)new BoolValue().AsReadOnly();
-        }
-      };
+      Parameters.Remove(solverSpecificParametersParam);
     }
 
@@ -58 +44 @@
     }
 
+    public override bool SupportsPause => false;
+
+    public override bool SupportsQualityUpdate => ProblemType == ProblemType.LinearProgramming;
+
+    public override bool SupportsStop => false;
+
     protected override OptimizationProblemType OptimizationProblemType =>
-      LinearProgrammingType == LinearProgrammingType.LinearProgramming
-        ? OptimizationProblemType.CLP_LINEAR_PROGRAMMING
-        : OptimizationProblemType.CBC_MIXED_INTEGER_PROGRAMMING;
+      ProblemType == ProblemType.LinearProgramming
+        ? OptimizationProblemType.ClpLinearProgramming
+        : OptimizationProblemType.CbcMixedIntegerProgramming;
   }
 }

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

@@ -20 +20 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -36 +37 @@
       Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName),
         new FileValue { FileDialogFilter = FileDialogFilter, Value = Properties.Settings.Default.CplexLibraryName }));
+      SolverSpecificParameters.Value =
+        "CPLEX Parameter File Version 12.8.0" + Environment.NewLine +
+        "# for file format, see https://www.ibm.com/support/knowledgecenter/SSSA5P_12.8.0/ilog.odms.cplex.help/CPLEX/FileFormats/topics/PRM.html" + Environment.NewLine +
+        "# for parameters, see https://www.ibm.com/support/knowledgecenter/SSSA5P_12.8.0/ilog.odms.cplex.help/CPLEX/Parameters/topics/introListTopical.html" + Environment.NewLine +
+        "# example:" + Environment.NewLine +
+        "# CPXPARAM_RandomSeed 10" + Environment.NewLine;
     }
 
@@ -48 +55 @@
 
     protected override OptimizationProblemType OptimizationProblemType =>
-      LinearProgrammingType == LinearProgrammingType.LinearProgramming
-        ? OptimizationProblemType.CPLEX_LINEAR_PROGRAMMING
-        : OptimizationProblemType.CPLEX_MIXED_INTEGER_PROGRAMMING;
+      ProblemType == ProblemType.LinearProgramming
+        ? OptimizationProblemType.CplexLinearProgramming
+        : OptimizationProblemType.CplexMixedIntegerProgramming;
   }
 }

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

@@ -20 +20 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -33 +34 @@
 
     public GlopSolver() {
-      programmingTypeParam.Value = (EnumValue<LinearProgrammingType>)programmingTypeParam.Value.AsReadOnly();
+      problemTypeParam.Value = (EnumValue<ProblemType>)problemTypeParam.Value.AsReadOnly();
+      SolverSpecificParameters.Value =
+        "# for file format, see Protocol Buffers text format (https://developers.google.com/protocol-buffers/docs/overview#whynotxml)" + Environment.NewLine +
+        "# for parameters, see https://github.com/google/or-tools/blob/v6.10/ortools/glop/parameters.proto" + Environment.NewLine +
+        "# example:" + Environment.NewLine +
+        "# random_seed: 10" + Environment.NewLine;
     }
 
@@ -45 +51 @@
     }
 
-    public override bool SupportsPause => true;
-
-    public override bool SupportsStop => true;
-
     protected override OptimizationProblemType OptimizationProblemType =>
-              OptimizationProblemType.GLOP_LINEAR_PROGRAMMING;
+      OptimizationProblemType.GlopLinearProgramming;
   }
 }

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

@@ -34 +34 @@
 
     public GlpkSolver() {
+      Parameters.Remove(solverSpecificParametersParam);
       Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName),
         new FileValue { FileDialogFilter = FileDialogFilter, Value = Properties.Settings.Default.GlpkLibraryName }));
-
-      programmingTypeParam.Value.ValueChanged += (sender, args) => {
-        if (((EnumValue<LinearProgrammingType>)sender).Value == LinearProgrammingType.LinearProgramming) {
-          incrementalityParam.Value = new BoolValue(true);
-          incrementalityParam.Value.ValueChanged += (s, a) => {
-            if (((BoolValue)s).Value) {
-              qualityUpdateIntervalParam.Value = new TimeSpanValue(qualityUpdateIntervalParam.Value.Value);
-            } else {
-              qualityUpdateIntervalParam.Value = (TimeSpanValue)qualityUpdateIntervalParam.Value.AsReadOnly();
-            }
-          };
-        } else {
-          incrementalityParam.Value = (BoolValue)new BoolValue().AsReadOnly();
-        }
-      };
     }
 
@@ -62 +48 @@
     }
 
+    public override bool SupportsPause => ProblemType == ProblemType.LinearProgramming; // TODO: pause working for linear programs?
+
+    public override bool SupportsQualityUpdate => ProblemType == ProblemType.LinearProgramming;
+
     protected override OptimizationProblemType OptimizationProblemType =>
-      LinearProgrammingType == LinearProgrammingType.LinearProgramming
-        ? OptimizationProblemType.GLPK_LINEAR_PROGRAMMING
-        : OptimizationProblemType.GLPK_MIXED_INTEGER_PROGRAMMING;
+      ProblemType == ProblemType.LinearProgramming
+        ? OptimizationProblemType.GlpkLinearProgramming
+        : OptimizationProblemType.GlpkMixedIntegerProgramming;
   }
 }

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

@@ -20 +20 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -36 +37 @@
       Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName),
         new FileValue { FileDialogFilter = FileDialogFilter, Value = Properties.Settings.Default.GurobiLibraryName }));
+      SolverSpecificParameters.Value =
+        "# for file format, see http://www.gurobi.com/documentation/8.1/refman/prm_format.html" + Environment.NewLine +
+        "# for parameters, see http://www.gurobi.com/documentation/8.1/refman/parameters.html" + Environment.NewLine +
+        "# example:" + Environment.NewLine +
+        "# Seed 10" + Environment.NewLine;
     }
 
     protected GurobiSolver(GurobiSolver original, Cloner cloner)
           : base(original, cloner) {
-      programmingTypeParam = cloner.Clone(original.programmingTypeParam);
+      problemTypeParam = cloner.Clone(original.problemTypeParam);
     }
 
@@ -48 +54 @@
     }
 
-    public override bool SupportsPause => true;
-
-    public override bool SupportsStop => true;
-
     protected override OptimizationProblemType OptimizationProblemType =>
-              LinearProgrammingType == LinearProgrammingType.LinearProgramming
-        ? OptimizationProblemType.GUROBI_LINEAR_PROGRAMMING
-        : OptimizationProblemType.GUROBI_MIXED_INTEGER_PROGRAMMING;
+      ProblemType == ProblemType.LinearProgramming
+        ? OptimizationProblemType.GurobiLinearProgramming
+        : OptimizationProblemType.GurobiMixedIntegerProgramming;
   }
 }

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

@@ -20 +20 @@
 #endregion
 
+using System;
+using System.Threading;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -31 +33 @@
   [Item("SCIP", "SCIP (http://scip.zib.de/) must be installed and licenced.")]
   [StorableClass]
-  public class ScipSolver : ExternalSolver {
+  public class ScipSolver : ExternalIncrementalSolver {
+
+    private TimeSpan timeLimit = TimeSpan.Zero;
 
     public ScipSolver() {
       Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName),
         new FileValue { FileDialogFilter = FileDialogFilter, Value = Properties.Settings.Default.ScipLibraryName }));
-      programmingTypeParam.Value =
-        (EnumValue<LinearProgrammingType>)new EnumValue<LinearProgrammingType>(LinearProgrammingType
-          .MixedIntegerProgramming).AsReadOnly();
+      problemTypeParam.Value =
+        (EnumValue<ProblemType>)new EnumValue<ProblemType>(ProblemType.MixedIntegerProgramming).AsReadOnly();
+      SolverSpecificParameters.Value =
+        "# for file format and parameters, see https://scip.zib.de/doc/html/PARAMETERS.php" + Environment.NewLine +
+        "# example:" + Environment.NewLine +
+        "# branching/random/seed = 10" + Environment.NewLine;
     }
 
@@ -50 +57 @@
     }
 
-    public override bool SupportsPause => true;
+    protected override OptimizationProblemType OptimizationProblemType =>
+      OptimizationProblemType.ScipMixedIntegerProgramming;
+    protected override TimeSpan TimeLimit => timeLimit += QualityUpdateInterval;
 
-    public override bool SupportsStop => true;
-
-    protected override OptimizationProblemType OptimizationProblemType =>
-      OptimizationProblemType.SCIP_MIXED_INTEGER_PROGRAMMING;
+    public override void Solve(LinearProgrammingAlgorithm algorithm, CancellationToken cancellationToken) {
+      timeLimit = TimeSpan.Zero;
+      base.Solve(algorithm, cancellationToken);
+    }
   }
 }

branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/ILinearProgrammingProblemDefinition.cs

@@ -27 +27 @@
   public interface ILinearProgrammingProblemDefinition {
 
-    void BuildModel(Solver solver);
+    bool BuildModel(Solver solver);
 
     void Analyze(Solver solver, ResultCollection results);

branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/LinearProgrammingProblem.cs

@@ -21 +21 @@
 
 using System.Drawing;
-using Google.OrTools.LinearSolver;
 using HeuristicLab.Common;
 using HeuristicLab.Common.Resources;
@@ -31 +30 @@
 namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Problems {
 
-  [Item("Linear/Mixed Integer Programming Problem (LP/MIP)", "")]
+  [Item("Linear/Mixed Integer Programming Problem (LP/MIP)", "Represents a linear/mixed integer problem.")]
   [Creatable(CreatableAttribute.Categories.CombinatorialProblems)]
   [StorableClass]
@@ -56 +55 @@
     private FixedValueParameter<LinearProgrammingProblemDefinitionScript> LinearProgrammingProblemScriptParameter =>
       (FixedValueParameter<LinearProgrammingProblemDefinitionScript>)Parameters["ProblemScript"];
-
-    public void BuildModel(Solver solver) => ProblemDefinition.BuildModel(solver);
 
     public override IDeepCloneable Clone(Cloner cloner) {

branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/LinearProgrammingProblemDefinitionScript.cs

@@ -33 +33 @@
 namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Problems {
 
-  [Item("Single-objective Problem Definition Script", "Script that defines the parameter vector and evaluates the solution for a programmable problem.")]
+  [Item("Linear/Mixed Integer Programming Problem Definition Script", "Script that defines the model and evaluates the solution for a linear/mixed integer programming problem.")]
   [StorableClass]
   public sealed class LinearProgrammingProblemDefinitionScript : Script, ILinearProgrammingProblemDefinition, IStorableContent {
@@ -144 +144 @@
     }
 
-    public void BuildModel(Solver solver) => CompiledProblemDefinition.BuildModel(solver);
+    public bool BuildModel(Solver solver) => CompiledProblemDefinition.BuildModel(solver);
 
     public void Analyze(Solver solver, ResultCollection results) => CompiledProblemDefinition.Analyze(solver, results);

branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Templates/CompiledLinearProgrammingProblemDefinition.cs

@@ -16 +16 @@
     private Variable x;
     private Variable y;
-    
+
     public override void Initialize() {
       // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
       // Add additional initialization code e.g. private variables that you need for evaluating
     }
-    
-    public void BuildModel(Solver solver) {
+
+    public bool BuildModel(Solver solver) {
       // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
       // Example model taken from https://developers.google.com/optimization/mip/integer_opt
@@ -32 +32 @@
       // Define the objective
       solver.Maximize(x + 10 * y);
+      return true;
     }
-    
+
     public void Analyze(Solver solver, ResultCollection results) {
       // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
@@ -43 +44 @@
       //results.AddOrUpdateResult("y", new DoubleValue(solver.LookupVariableOrNull("y").SolutionValue()));
     }
-    
+
     // Implement further classes and methods
   }

branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Wrapper/DoubleParam.cs

@@ -26 +26 @@
 
     // Limit for relative MIP gap.
-    RELATIVE_MIP_GAP = 0,
+    RelativeMipGap = 0,
 
     // Advanced usage: tolerance for primal feasibility of basic
@@ -32 +32 @@
     // tolerance of integer solutions for MIP or the tolerance used
     // during presolve.
-    PRIMAL_TOLERANCE = 1,
+    PrimalTolerance = 1,
 
     // Advanced usage: tolerance for dual feasibility of basic solutions.
-    DUAL_TOLERANCE = 2
-  };
+    DualTolerance = 2
+  }
 }

branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Wrapper/IncrementalityValues.cs

@@ -25 +25 @@
 
     // Start solve from scratch.
-    INCREMENTALITY_OFF = 0,
+    IncrementalityOff = 0,
 
     // Reuse results from previous solve as much as the underlying
     // solver allows.
-    INCREMENTALITY_ON = 1
-  };
+    IncrementalityOn = 1
+  }
 }

branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Wrapper/IntegerParam.cs

@@ -26 +26 @@
 
     // Advanced usage: presolve mode.
-    PRESOLVE = 1000,
+    Presolve = 1000,
 
     // Algorithm to solve linear programs.
-    LP_ALGORITHM = 1001,
+    LpAlgorithm = 1001,
 
     // Advanced usage: incrementality from one solve to the next.
-    INCREMENTALITY = 1002,
+    Incrementality = 1002,
 
     // Advanced usage: enable or disable matrix scaling.
-    SCALING = 1003
-  };
+    Scaling = 1003
+  }
 }

branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Wrapper/LpAlgorithmValues.cs

@@ -26 +26 @@
     PrimalSimplex = 11,
     BarrierAlgorithm = 12
-  };
+  }
 }