Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.ExtLibs/HeuristicLab.OrTools/6.9.0-pre/HeuristicLab.OrTools-6.9.0-pre/HeuristicLab.OrTools-6.9.0-pre.csproj
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.ExtLibs/HeuristicLab.OrTools/6.9.0-pre/HeuristicLab.OrTools-6.9.0-pre/HeuristicLab.OrTools-6.9.0-pre.csproj	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.ExtLibs/HeuristicLab.OrTools/6.9.0-pre/HeuristicLab.OrTools-6.9.0-pre/HeuristicLab.OrTools-6.9.0-pre.csproj	(revision 16233)
@@ -113,5 +113,5 @@
   </ItemGroup>
   <ItemGroup>
-    <Content Include="GLPK-4.65-license.txt">
+    <Content Include="glpk-license.txt">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
@@ -128,11 +128,11 @@
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </Content>
+    <Content Include="Google.OrTools.runtime.win-x64.dll">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
     <Content Include="Google.OrTools_version.txt">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
     <Content Include="Google.Protobuf.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </Content>
-    <Content Include="runtime.win-x64.Google.OrTools.dll">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </Content>
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.ExtLibs/HeuristicLab.OrTools/6.9.0-pre/HeuristicLab.OrTools-6.9.0-pre/Plugin.cs.frame
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.ExtLibs/HeuristicLab.OrTools/6.9.0-pre/HeuristicLab.OrTools-6.9.0-pre/Plugin.cs.frame	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.ExtLibs/HeuristicLab.OrTools/6.9.0-pre/HeuristicLab.OrTools-6.9.0-pre/Plugin.cs.frame	(revision 16233)
@@ -28,8 +28,8 @@
   [PluginFile("Google.OrTools.dll", PluginFileType.Assembly)]
   [PluginFile("Google.OrTools-license.txt", PluginFileType.License)]
-  [PluginFile("runtime.win-x64.Google.OrTools.dll", PluginFileType.NativeDll)]
+  [PluginFile("Google.OrTools.runtime.win-x64.dll", PluginFileType.NativeDll)]
   [PluginFile("Google.OrTools_version.txt", PluginFileType.Data)]
   [PluginFile("glpk_4_65.dll", PluginFileType.NativeDll)]
-  [PluginFile("GLPK-4.65-license.txt", PluginFileType.License)]
+  [PluginFile("glpk-license.txt", PluginFileType.License)]
   public class HeuristicLabOrToolsPlugin : PluginBase {
   }
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.ExtLibs/HeuristicLab.OrTools/6.9.0-pre/HeuristicLab.OrTools-6.9.0-pre/Properties/AssemblyInfo.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.ExtLibs/HeuristicLab.OrTools/6.9.0-pre/HeuristicLab.OrTools-6.9.0-pre/Properties/AssemblyInfo.cs	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.ExtLibs/HeuristicLab.OrTools/6.9.0-pre/HeuristicLab.OrTools-6.9.0-pre/Properties/AssemblyInfo.cs	(revision 16233)
@@ -54,3 +54,3 @@
 // [assembly: AssemblyVersion("1.0.*")]
 [assembly: AssemblyVersion("6.8.0.0")]
-[assembly: AssemblyFileVersion("6.8.0.16138")]
+[assembly: AssemblyFileVersion("6.8.0.16172")]
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/HeuristicLab.MathematicalOptimization-3.3.csproj
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/HeuristicLab.MathematicalOptimization-3.3.csproj	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/HeuristicLab.MathematicalOptimization-3.3.csproj	(revision 16233)
@@ -131,14 +131,22 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="LinearProgramming\Algorithms\BopSolver.cs" />
-    <Compile Include="LinearProgramming\Algorithms\CoinOrSolver.cs" />
-    <Compile Include="LinearProgramming\Algorithms\GlopSolver.cs" />
-    <Compile Include="LinearProgramming\Algorithms\GlpkSolver.cs" />
+    <Compile Include="LinearProgramming\Algorithms\Solvers\BopSolver.cs" />
+    <Compile Include="LinearProgramming\Algorithms\Solvers\CoinOrSolver.cs" />
+    <Compile Include="LinearProgramming\Algorithms\Solvers\Base\ExternalSolver.cs" />
+    <Compile Include="LinearProgramming\Algorithms\Solvers\GlopSolver.cs" />
+    <Compile Include="LinearProgramming\Algorithms\Solvers\GlpkSolver.cs" />
+    <Compile Include="LinearProgramming\Algorithms\Solvers\Base\IExternalSolver.cs" />
+    <Compile Include="LinearProgramming\Algorithms\Solvers\Base\IIncrementalSolver.cs" />
+    <Compile Include="LinearProgramming\Algorithms\Solvers\Base\ExternalIncrementalSolver.cs" />
+    <Compile Include="LinearProgramming\Algorithms\Solvers\Base\IncrementalSolver.cs" />
     <Compile Include="LinearProgramming\Algorithms\LinearProgrammingType.cs" />
-    <Compile Include="LinearProgramming\Algorithms\ScipSolver.cs" />
+    <Compile Include="LinearProgramming\Algorithms\Solvers\ScipSolver.cs" />
     <Compile Include="LinearProgramming\BasisStatus.cs" />
-    <Compile Include="LinearProgramming\Algorithms\CplexSolver.cs" />
-    <Compile Include="LinearProgramming\Algorithms\GurobiSolver.cs" />
-    <Compile Include="LinearProgramming\Algorithms\ISolver.cs" />
+    <Compile Include="LinearProgramming\Algorithms\Solvers\CplexSolver.cs" />
+    <Compile Include="LinearProgramming\Algorithms\Solvers\GurobiSolver.cs" />
+    <Compile Include="LinearProgramming\Algorithms\Solvers\Base\ISolver.cs" />
+    <Compile Include="LinearProgramming\IncrementalityValues.cs" />
+    <Compile Include="LinearProgramming\IntegerParam.cs" />
+    <Compile Include="LinearProgramming\LpAlgorithmValues.cs" />
     <Compile Include="LinearProgramming\Problems\ILinearProgrammingProblemDefinition.cs" />
     <Compile Include="LinearProgramming\Algorithms\LinearProgrammingAlgorithm.cs" />
@@ -149,5 +157,6 @@
     <Compile Include="LinearProgramming\OptimizationProblemType.cs" />
     <Compile Include="LinearProgramming\Problems\ProblemDefinitionScriptException.cs" />
-    <Compile Include="LinearProgramming\Algorithms\Solver.cs" />
+    <Compile Include="LinearProgramming\Algorithms\Solvers\Base\Solver.cs" />
+    <Compile Include="LinearProgramming\DoubleParam.cs" />
     <Compile Include="LinearProgramming\Views\LinearProgrammingProblemDefinitionScriptView.cs">
       <SubType>UserControl</SubType>
@@ -179,4 +188,8 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Analysis\3.3\HeuristicLab.Analysis-3.3.csproj">
+      <Project>{887425B4-4348-49ED-A457-B7D2C26DDBF9}</Project>
+      <Name>HeuristicLab.Analysis-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Clients.OKB\3.3\HeuristicLab.Clients.OKB-3.3.csproj">
       <Project>{73857A9C-9706-4B72-8D9C-210B5B6A5691}</Project>
Index: anches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/BopSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/BopSolver.cs	(revision 16232)
+++ 	(revision )
@@ -1,15 +1,0 @@
-﻿using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
-  [Item("BOP", "BOP (https://developers.google.com/optimization/reference/bop/bop_solver/) can be used out of the box.")]
-  [StorableClass]
-  public class BopSolver : Solver {
-
-    public BopSolver() {
-      Parameters.Remove(programmingTypeParam);
-    }
-
-    public override OptimizationProblemType OptimizationProblemType => OptimizationProblemType.BOP_INTEGER_PROGRAMMING;
-  }
-}
Index: anches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/CoinOrSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/CoinOrSolver.cs	(revision 16232)
+++ 	(revision )
@@ -1,14 +1,0 @@
-﻿using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
-  [Item("Clp/Cbc", "Clp (https://projects.coin-or.org/Clp) and Cbc (https://projects.coin-or.org/Cbc) can be used out of the box.")]
-  [StorableClass]
-  public class CoinOrSolver : Solver {
-
-    public override OptimizationProblemType OptimizationProblemType =>
-      LinearProgrammingType == LinearProgrammingType.LinearProgramming
-        ? OptimizationProblemType.CLP_LINEAR_PROGRAMMING
-        : OptimizationProblemType.CBC_MIXED_INTEGER_PROGRAMMING;
-  }
-}
Index: anches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/CplexSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/CplexSolver.cs	(revision 16232)
+++ 	(revision )
@@ -1,21 +1,0 @@
-﻿using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
-
-  [Item("CPLEX", "CPLEX (https://www.ibm.com/analytics/cplex-optimizer) must be installed and licenced.")]
-  [StorableClass]
-  public class CplexSolver : Solver {
-
-    public CplexSolver() {
-      Parameters.Add(libraryNameParam = new FixedValueParameter<StringValue>(nameof(LibraryName), new StringValue("cplex1280.dll")));
-    }
-
-    public override OptimizationProblemType OptimizationProblemType =>
-      LinearProgrammingType == LinearProgrammingType.LinearProgramming
-        ? OptimizationProblemType.CPLEX_LINEAR_PROGRAMMING
-        : OptimizationProblemType.CPLEX_MIXED_INTEGER_PROGRAMMING;
-  }
-}
Index: anches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/GlopSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/GlopSolver.cs	(revision 16232)
+++ 	(revision )
@@ -1,19 +1,0 @@
-﻿using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
-  [Item("Glop", "Glop (https://developers.google.com/optimization/lp/glop) can be used out of the box.")]
-  [StorableClass]
-  public class GlopSolver : Solver {
-
-    public GlopSolver() {
-      Parameters.Remove(programmingTypeParam);
-      Parameters.Add(programmingTypeParam = new FixedValueParameter<EnumValue<LinearProgrammingType>>(nameof(LinearProgrammingType),
-        (EnumValue<LinearProgrammingType>)new EnumValue<LinearProgrammingType>().AsReadOnly()));
-    }
-
-    public override OptimizationProblemType OptimizationProblemType => OptimizationProblemType.GLOP_LINEAR_PROGRAMMING;
-  }
-}
Index: anches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/GlpkSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/GlpkSolver.cs	(revision 16232)
+++ 	(revision )
@@ -1,20 +1,0 @@
-﻿using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
-  [Item("GLPK", "GLPK (https://www.gnu.org/software/glpk/) can be used out of the box.")]
-  [StorableClass]
-  public class GlpkSolver : Solver {
-
-    public GlpkSolver() {
-      Parameters.Add(libraryNameParam = new FixedValueParameter<StringValue>(nameof(LibraryName), new StringValue("glpk_4_65.dll")));
-    }
-
-    public override OptimizationProblemType OptimizationProblemType =>
-      LinearProgrammingType == LinearProgrammingType.LinearProgramming
-        ? OptimizationProblemType.GLPK_LINEAR_PROGRAMMING
-        : OptimizationProblemType.GLPK_MIXED_INTEGER_PROGRAMMING;
-  }
-}
Index: anches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/GurobiSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/GurobiSolver.cs	(revision 16232)
+++ 	(revision )
@@ -1,20 +1,0 @@
-﻿using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
-  [Item("Gurobi", "Gurobi (http://www.gurobi.com/) must be installed and licenced.")]
-  [StorableClass]
-  public class GurobiSolver : Solver {
-
-    public GurobiSolver() {
-      Parameters.Add(libraryNameParam = new FixedValueParameter<StringValue>(nameof(LibraryName), new StringValue("gurobi80.dll")));
-    }
-
-    public override OptimizationProblemType OptimizationProblemType =>
-      LinearProgrammingType == LinearProgrammingType.LinearProgramming
-        ? OptimizationProblemType.GUROBI_LINEAR_PROGRAMMING
-        : OptimizationProblemType.GUROBI_MIXED_INTEGER_PROGRAMMING;
-  }
-}
Index: anches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/ISolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/ISolver.cs	(revision 16232)
+++ 	(revision )
@@ -1,9 +1,0 @@
-﻿using HeuristicLab.Core;
-
-namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
-  public interface ISolver : IParameterizedNamedItem {
-    OptimizationProblemType OptimizationProblemType { get; }
-    string LibraryName { get; set; }
-    LinearProgrammingType LinearProgrammingType { get; set; }
-  }
-}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/LinearProgrammingAlgorithm.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/LinearProgrammingAlgorithm.cs	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/LinearProgrammingAlgorithm.cs	(revision 16233)
@@ -1,7 +1,10 @@
 ﻿using System;
 using System.Threading;
+using Google.OrTools.LinearSolver;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers;
+using HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base;
 using HeuristicLab.MathematicalOptimization.LinearProgramming.Problems;
 using HeuristicLab.Optimization;
@@ -10,8 +13,27 @@
 
 namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
-  [Item("Linear Programming Algorithm", "")]
-  [Creatable(CreatableAttribute.Categories.Algorithms, Priority = 162)]
+
+  [Item("Linear/Mixed Integer Programming (LP/MIP)", "")]
+  [Creatable(CreatableAttribute.Categories.SingleSolutionAlgorithms)]
   [StorableClass]
   public class LinearProgrammingAlgorithm : BasicAlgorithm {
+
+    [Storable]
+    private readonly IFixedValueParameter<DoubleValue> dualToleranceParam;
+
+    [Storable]
+    private readonly IFixedValueParameter<EnumValue<LpAlgorithmValues>> lpAlgorithmParam;
+
+    [Storable]
+    private readonly IFixedValueParameter<BoolValue> presolveParam;
+
+    [Storable]
+    private readonly IFixedValueParameter<DoubleValue> primalToleranceParam;
+
+    [Storable]
+    private readonly IFixedValueParameter<DoubleValue> relativeGapToleranceParam;
+
+    [Storable]
+    private readonly IFixedValueParameter<BoolValue> scalingParam;
 
     [Storable]
@@ -19,13 +41,27 @@
 
     [Storable]
-    private readonly IFixedValueParameter<DoubleValue> relativeGapToleranceParam;
-
-    [Storable]
     private readonly IFixedValueParameter<TimeSpanValue> timeLimitParam;
 
     public LinearProgrammingAlgorithm() {
-      Parameters.Add(solverParam = new ConstrainedValueParameter<ISolver>(nameof(Solver)));
-      Parameters.Add(relativeGapToleranceParam = new FixedValueParameter<DoubleValue>(nameof(RelativeGapTolerance), new DoubleValue()));
-      Parameters.Add(timeLimitParam = new FixedValueParameter<TimeSpanValue>(nameof(TimeLimit), new TimeSpanValue()));
+      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)));
+      Parameters.Add(timeLimitParam = new FixedValueParameter<TimeSpanValue>(nameof(TimeLimit),
+        "Limit for runtime. Set to zero for unlimited runtime.", new TimeSpanValue()));
+      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)));
+      Parameters.Add(dualToleranceParam = new FixedValueParameter<DoubleValue>(nameof(DualTolerance),
+        "Advanced usage: tolerance for dual feasibility of basic solutions.",
+        new DoubleValue(MPSolverParameters.kDefaultDualTolerance)));
+      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)));
+      Parameters.Add(scalingParam = new FixedValueParameter<BoolValue>(nameof(Scaling),
+        "Advanced usage: enable or disable matrix scaling.", new BoolValue()));
 
       Problem = new LinearProgrammingProblem();
@@ -42,5 +78,6 @@
     [StorableConstructor]
     private LinearProgrammingAlgorithm(bool deserializing)
-      : base(deserializing) { }
+      : base(deserializing) {
+    }
 
     private LinearProgrammingAlgorithm(LinearProgrammingAlgorithm original, Cloner cloner)
@@ -49,9 +86,29 @@
       relativeGapToleranceParam = cloner.Clone(original.relativeGapToleranceParam);
       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);
     }
 
-    public ISolver Solver {
-      get => solverParam.Value;
-      set => solverParam.Value = value;
+    public double DualTolerance {
+      get => dualToleranceParam.Value.Value;
+      set => dualToleranceParam.Value.Value = 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;
     }
 
@@ -62,4 +119,5 @@
 
     public override Type ProblemType { get; } = typeof(LinearProgrammingProblem);
+
     public double RelativeGapTolerance {
       get => relativeGapToleranceParam.Value.Value;
@@ -69,5 +127,17 @@
     public override ResultCollection Results { get; } = new ResultCollection();
 
-    public override bool SupportsPause { get; } = false;
+    public bool Scaling {
+      get => scalingParam.Value.Value;
+      set => scalingParam.Value.Value = value;
+    }
+
+    public ISolver Solver {
+      get => solverParam.Value;
+      set => solverParam.Value = value;
+    }
+
+    public override bool SupportsPause => Solver.SupportsPause;
+
+    public override bool SupportsStop => Solver.SupportsStop;
 
     public TimeSpan TimeLimit {
@@ -77,23 +147,27 @@
 
     public override IDeepCloneable Clone(Cloner cloner) => new LinearProgrammingAlgorithm(this, cloner);
-    protected override void Run(CancellationToken cancellationToken) {
-      using (var solver = LinearSolver.CreateSolver(Solver.OptimizationProblemType, Name,
-        Solver.LibraryName ?? string.Empty, s => Problem.ProblemDefinition.BuildModel(s))) {
-        solver.RelativeGapTolerance = RelativeGapTolerance;
-        solver.TimeLimit = TimeLimit;
 
-        solver.Solve();
+    public override void Pause() {
+      base.Pause();
+      Solver.Interrupt();
+    }
 
-        Problem.ProblemDefinition.Analyze(solver.Solver, Results);
-        Results.AddOrUpdateResult("Result Status", new EnumValue<ResultStatus>(solver.ResultStatus));
-        Results.AddOrUpdateResult("Best Objective Value", new DoubleValue(solver.ObjectiveValue ?? double.NaN));
-        Results.AddOrUpdateResult("Absolute Gap", new DoubleValue(solver.AbsoluteGap ?? double.NaN));
-        Results.AddOrUpdateResult("Relative Gap", new DoubleValue(solver.RelativeGap ?? double.NaN));
-        Results.AddOrUpdateResult("Number of Constraints", new IntValue(solver.NumberOfConstraints));
-        Results.AddOrUpdateResult("Number of Variables", new IntValue(solver.NumberOfVariables));
-        Results.AddOrUpdateResult("Number of Nodes", new DoubleValue(solver.NumberOfNodes));
-        Results.AddOrUpdateResult("Iterations", new DoubleValue(solver.Iterations));
+    public override void Prepare() {
+      base.Prepare();
+      Results.Clear();
+
+      foreach (var solver in solverParam.ValidValues) {
+        solver.Reset();
       }
     }
+
+    public override void Stop() {
+      base.Stop();
+      Solver.Interrupt();
+    }
+    protected override void Initialize(CancellationToken cancellationToken) {
+      base.Initialize(cancellationToken);
+    }
+    protected override void Run(CancellationToken cancellationToken) => Solver.Solve(this, cancellationToken);
   }
 }
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/LinearProgrammingType.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/LinearProgrammingType.cs	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/LinearProgrammingType.cs	(revision 16233)
@@ -1,3 +1,4 @@
 ﻿namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
+
   public enum LinearProgrammingType {
     LinearProgramming,
Index: anches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/ScipSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/ScipSolver.cs	(revision 16232)
+++ 	(revision )
@@ -1,21 +1,0 @@
-﻿using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
-  [Item("SCIP", "SCIP (http://scip.zib.de/) must be installed and licenced.")]
-  [StorableClass]
-  public class ScipSolver : Solver {
-
-    public ScipSolver() {
-      Parameters.Add(libraryNameParam = new FixedValueParameter<StringValue>(nameof(LibraryName), new StringValue("scip.dll")));
-      Parameters.Remove(programmingTypeParam);
-      Parameters.Add(programmingTypeParam = new FixedValueParameter<EnumValue<LinearProgrammingType>>(nameof(LinearProgrammingType),
-        (EnumValue<LinearProgrammingType>)new EnumValue<LinearProgrammingType>(LinearProgrammingType.MixedIntegerProgramming).AsReadOnly()));
-    }
-
-    public override OptimizationProblemType OptimizationProblemType =>
-      OptimizationProblemType.SCIP_MIXED_INTEGER_PROGRAMMING;
-  }
-}
Index: anches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solver.cs	(revision 16232)
+++ 	(revision )
@@ -1,47 +1,0 @@
-﻿using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
-
-  public class Solver : ParameterizedNamedItem, ISolver {
-
-    [Storable]
-    protected IFixedValueParameter<StringValue> libraryNameParam;
-
-
-    [Storable]
-    protected IFixedValueParameter<EnumValue<LinearProgrammingType>> programmingTypeParam;
-
-    public Solver() {
-      //  Parameters.Add(useMixedIntegerProgrammingParam = new FixedValueParameter<BoolValue>(nameof(UseMixedIntegerProgramming), (BoolValue)new BoolValue(false).AsReadOnly()));
-      Parameters.Add(programmingTypeParam = new FixedValueParameter<EnumValue<LinearProgrammingType>>(nameof(LinearProgrammingType), new EnumValue<LinearProgrammingType>()));
-    }
-
-    [StorableConstructor]
-    protected Solver(bool deserializing)
-      : base(deserializing) { }
-
-    protected Solver(Solver original, Cloner cloner)
-      : base(original, cloner) {
-      libraryNameParam = cloner.Clone(original.libraryNameParam);
-      programmingTypeParam = cloner.Clone(original.programmingTypeParam);
-    }
-
-    public string LibraryName {
-      get => libraryNameParam?.Value.Value;
-      set => libraryNameParam.Value.Value = value;
-    }
-
-    public virtual OptimizationProblemType OptimizationProblemType { get; }
-
-    public LinearProgrammingType LinearProgrammingType {
-      get => programmingTypeParam.Value.Value;
-      set => programmingTypeParam.Value.Value = value;
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) => new Solver(this, cloner);
-  }
-}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/ExternalIncrementalSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/ExternalIncrementalSolver.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/ExternalIncrementalSolver.cs	(revision 16233)
@@ -0,0 +1,28 @@
+﻿using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base {
+
+  [StorableClass]
+  public class ExternalIncrementalSolver : IncrementalSolver, IExternalSolver {
+    protected const string FileDialogFilter = "Dynamic-Link Library (*.dll)|*.dll|All Files (*.*)|*.*";
+
+    [Storable]
+    protected IFixedValueParameter<FileValue> libraryNameParam;
+
+    public ExternalIncrementalSolver() {
+    }
+
+    protected ExternalIncrementalSolver(ExternalIncrementalSolver original, Cloner cloner)
+      : base(original, cloner) {
+      libraryNameParam = cloner.Clone(original.libraryNameParam);
+    }
+
+    public string LibraryName {
+      get => libraryNameParam?.Value.Value;
+      set => libraryNameParam.Value.Value = value;
+    }
+  }
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/ExternalSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/ExternalSolver.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/ExternalSolver.cs	(revision 16233)
@@ -0,0 +1,29 @@
+﻿using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base {
+
+  [StorableClass]
+  public class ExternalSolver : Solver, IExternalSolver {
+
+    protected const string FileDialogFilter = "Dynamic-Link Library (*.dll)|*.dll|All Files (*.*)|*.*";
+
+    [Storable]
+    protected IFixedValueParameter<FileValue> libraryNameParam;
+
+    public ExternalSolver() {
+    }
+
+    protected ExternalSolver(ExternalSolver original, Cloner cloner)
+      : base(original, cloner) {
+      libraryNameParam = cloner.Clone(original.libraryNameParam);
+    }
+
+    public string LibraryName {
+      get => libraryNameParam?.Value.Value;
+      set => libraryNameParam.Value.Value = value;
+    }
+  }
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IExternalSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IExternalSolver.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IExternalSolver.cs	(revision 16233)
@@ -0,0 +1,6 @@
+﻿namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base {
+
+  public interface IExternalSolver : ISolver {
+    string LibraryName { get; set; }
+  }
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IIncrementalSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IIncrementalSolver.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IIncrementalSolver.cs	(revision 16233)
@@ -0,0 +1,9 @@
+﻿using System;
+
+namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base {
+
+  public interface IIncrementalSolver : ISolver {
+    bool Incrementality { get; set; }
+    TimeSpan QualityUpdateInterval { get; set; }
+  }
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/ISolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/ISolver.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/ISolver.cs	(revision 16233)
@@ -0,0 +1,20 @@
+﻿using System.Threading;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base {
+
+  public interface ISolver : IParameterizedNamedItem {
+    LinearProgrammingType LinearProgrammingType { get; set; }
+    OptimizationProblemType OptimizationProblemType { get; }
+    bool SupportsPause { get; }
+    bool SupportsStop { get; }
+
+    void Interrupt();
+
+    void Reset();
+
+    void Solve(LinearProgrammingAlgorithm algorithm);
+
+    void Solve(LinearProgrammingAlgorithm algorithm, CancellationToken cancellationToken);
+  }
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IncrementalSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IncrementalSolver.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IncrementalSolver.cs	(revision 16233)
@@ -0,0 +1,152 @@
+﻿using System;
+using System.Linq;
+using System.Threading;
+using Google.OrTools.LinearSolver;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base {
+
+  [StorableClass]
+  public class IncrementalSolver : Solver, IIncrementalSolver {
+    [Storable]
+    protected readonly IValueParameter<BoolValue> incrementalityParam;
+
+    [Storable]
+    protected readonly IValueParameter<TimeSpanValue> qualityUpdateIntervalParam;
+
+    private IndexedDataRow<double> bpcRow;
+
+    private IndexedDataRow<double> qpcRow;
+
+    [Storable]
+    private IndexedDataTable<double> qualityPerClock;
+
+    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);
+        } else {
+          qualityUpdateIntervalParam.Value = (TimeSpanValue)qualityUpdateIntervalParam.Value.AsReadOnly();
+        }
+      };
+    }
+
+    protected IncrementalSolver(IncrementalSolver original, Cloner cloner)
+        : base(original, cloner) {
+      programmingTypeParam = cloner.Clone(original.programmingTypeParam);
+      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 TimeSpan QualityUpdateInterval {
+      get => qualityUpdateIntervalParam.Value.Value;
+      set => qualityUpdateIntervalParam.Value.Value = value;
+    }
+
+    public override void Solve(LinearProgrammingAlgorithm algorithm, CancellationToken cancellationToken) {
+      if (!Incrementality) {
+        base.Solve(algorithm);
+        return;
+      }
+
+      var timeLimit = algorithm.TimeLimit;
+      var unlimitedRuntime = timeLimit == TimeSpan.Zero;
+
+      if (!unlimitedRuntime) {
+        var wallTime = ((TimeSpanValue)algorithm.Results.SingleOrDefault(r => r.Name == "Wall Time")?.Value)?.Value;
+        if (wallTime.HasValue) {
+          timeLimit -= wallTime.Value;
+        }
+      }
+    
+      var iterations = (long)timeLimit.TotalMilliseconds / (long)QualityUpdateInterval.TotalMilliseconds;
+      var remaining = timeLimit - TimeSpan.FromMilliseconds(iterations * QualityUpdateInterval.TotalMilliseconds);
+      var validResultStatuses = new[] { ResultStatus.NOT_SOLVED, ResultStatus.FEASIBLE };
+
+      while (unlimitedRuntime || iterations > 0) {
+        base.Solve(algorithm, QualityUpdateInterval, true);
+        UpdateQuality(algorithm);
+
+        var resultStatus = ((EnumValue<ResultStatus>)algorithm.Results["Result Status"].Value).Value;
+        if (!validResultStatuses.Contains(resultStatus) || cancellationToken.IsCancellationRequested)
+          return;
+
+        if (!unlimitedRuntime)
+          iterations--;
+      }
+
+      if (remaining > TimeSpan.Zero) {
+        base.Solve(algorithm, remaining, true);
+        UpdateQuality(algorithm);
+      }
+    }
+
+    private void UpdateQuality(LinearProgrammingAlgorithm algorithm) {
+      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");
+        algorithm.Results.AddOrUpdateResult("QualityPerClock", qualityPerClock);
+      }
+
+      var resultStatus = ((EnumValue<ResultStatus>)algorithm.Results["Result Status"].Value).Value;
+
+      if (new[] { ResultStatus.ABNORMAL, ResultStatus.NOT_SOLVED, 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 time = algorithm.ExecutionTime.TotalSeconds;
+
+      if (!qpcRow.Values.Any()) {
+        if (!double.IsInfinity(objective) && !double.IsNaN(objective)) {
+          qpcRow.Values.Add(Tuple.Create(time, objective));
+          qpcRow.Values.Add(Tuple.Create(time, objective));
+          qualityPerClock.Rows.Add(qpcRow);
+          algorithm.Results.AddOrUpdateResult("Best Solution Found At", new TimeSpanValue(TimeSpan.FromSeconds(time)));
+        }
+      } else {
+        var previousBest = qpcRow.Values.Last().Item2;
+        qpcRow.Values[qpcRow.Values.Count - 1] = Tuple.Create(time, objective);
+        if (!objective.IsAlmost(previousBest)) {
+          qpcRow.Values.Add(Tuple.Create(time, objective));
+          algorithm.Results.AddOrUpdateResult("Best Solution Found At", new TimeSpanValue(TimeSpan.FromSeconds(time)));
+        }
+      }
+
+      if (!bpcRow.Values.Any()) {
+        if (!double.IsInfinity(bound) && !double.IsNaN(bound)) {
+          bpcRow.Values.Add(Tuple.Create(time, bound));
+          bpcRow.Values.Add(Tuple.Create(time, bound));
+          qualityPerClock.Rows.Add(bpcRow);
+        }
+      } else {
+        var previousBest = bpcRow.Values.Last().Item2;
+        bpcRow.Values[bpcRow.Values.Count - 1] = Tuple.Create(time, bound);
+        if (!bound.IsAlmost(previousBest)) {
+          bpcRow.Values.Add(Tuple.Create(time, bound));
+        }
+      }
+    }
+  }
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/Solver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/Solver.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/Solver.cs	(revision 16233)
@@ -0,0 +1,97 @@
+﻿using System;
+using System.Threading;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base {
+
+  [StorableClass]
+  public class Solver : ParameterizedNamedItem, ISolver, IDisposable {
+
+    [Storable]
+    protected IValueParameter<EnumValue<LinearProgrammingType>> programmingTypeParam;
+
+    protected LinearSolver solver;
+
+    public Solver() {
+      Parameters.Add(programmingTypeParam =
+        new ValueParameter<EnumValue<LinearProgrammingType>>(nameof(LinearProgrammingType),
+          new EnumValue<LinearProgrammingType>()));
+    }
+
+    [StorableConstructor]
+    protected Solver(bool deserializing)
+      : base(deserializing) {
+    }
+
+    protected Solver(Solver original, Cloner cloner)
+      : base(original, cloner) {
+      programmingTypeParam = cloner.Clone(original.programmingTypeParam);
+    }
+
+    public LinearProgrammingType LinearProgrammingType {
+      get => programmingTypeParam.Value.Value;
+      set => programmingTypeParam.Value.Value = value;
+    }
+
+    public virtual OptimizationProblemType OptimizationProblemType { get; }
+    public virtual bool SupportsPause => false;
+    public virtual bool SupportsStop => false;
+
+    public override IDeepCloneable Clone(Cloner cloner) => new Solver(this, cloner);
+
+    public void Dispose() => solver?.Dispose();
+
+    public void Interrupt() => solver.Stop();
+
+    public virtual void Reset() {
+      solver = null;
+    }
+
+    public virtual void Solve(LinearProgrammingAlgorithm algorithm, CancellationToken cancellationToken) =>
+      Solve(algorithm, CancellationToken.None);
+
+    public virtual void Solve(LinearProgrammingAlgorithm algorithm) =>
+      Solve(algorithm, algorithm.TimeLimit, false);
+
+    public virtual void Solve(LinearProgrammingAlgorithm algorithm, TimeSpan timeLimit, bool incrementality) {
+      var libraryName = string.Empty;
+      if (this is ExternalSolver externalSolver)
+        libraryName = externalSolver.LibraryName;
+
+      if (solver == null) {
+        solver = LinearSolver.CreateSolver(OptimizationProblemType, Name,
+          libraryName, s => algorithm.Problem.ProblemDefinition.BuildModel(s));
+      }
+
+      solver.TimeLimit = timeLimit;
+      solver.RelativeGapTolerance = algorithm.RelativeGapTolerance;
+      solver.PrimalTolerance = algorithm.PrimalTolerance;
+      solver.DualTolerance = algorithm.DualTolerance;
+      solver.Presolve = algorithm.Presolve;
+      solver.Scaling = algorithm.Scaling;
+      solver.LpAlgorithm = algorithm.LpAlgorithm;
+      solver.Incrementality = incrementality;
+
+      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",
+        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));
+    }
+  }
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/BopSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/BopSolver.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/BopSolver.cs	(revision 16233)
@@ -0,0 +1,19 @@
+﻿using HeuristicLab.Core;
+using HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers {
+
+  [Item("BOP", "BOP (https://developers.google.com/optimization/reference/bop/bop_solver/) can be used out of the box.")]
+  [StorableClass]
+  public class BopSolver : IncrementalSolver {
+
+    public BopSolver() {
+      Parameters.Remove(programmingTypeParam);
+    }
+
+    public override OptimizationProblemType OptimizationProblemType => OptimizationProblemType.BOP_INTEGER_PROGRAMMING;
+    public override bool SupportsPause => true;
+    public override bool SupportsStop => true;
+  }
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/CoinOrSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/CoinOrSolver.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/CoinOrSolver.cs	(revision 16233)
@@ -0,0 +1,34 @@
+﻿using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers {
+
+  [Item("Clp/Cbc", "Clp (https://projects.coin-or.org/Clp) and Cbc (https://projects.coin-or.org/Cbc) can be used out of the box.")]
+  [StorableClass]
+  public class CoinOrSolver : IncrementalSolver {
+
+    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();
+        }
+      };
+    }
+
+    public override OptimizationProblemType OptimizationProblemType =>
+      LinearProgrammingType == LinearProgrammingType.LinearProgramming
+        ? OptimizationProblemType.CLP_LINEAR_PROGRAMMING
+        : OptimizationProblemType.CBC_MIXED_INTEGER_PROGRAMMING;
+  }
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/CplexSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/CplexSolver.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/CplexSolver.cs	(revision 16233)
@@ -0,0 +1,23 @@
+﻿using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers {
+
+  [Item("CPLEX", "CPLEX (https://www.ibm.com/analytics/cplex-optimizer) must be installed and licenced.")]
+  [StorableClass]
+  public class CplexSolver : ExternalIncrementalSolver {
+
+    public CplexSolver() {
+      Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName),
+        new FileValue { FileDialogFilter = FileDialogFilter, Value = "cplex1280.dll" }));
+    }
+
+    public override OptimizationProblemType OptimizationProblemType =>
+      LinearProgrammingType == LinearProgrammingType.LinearProgramming
+        ? OptimizationProblemType.CPLEX_LINEAR_PROGRAMMING
+        : OptimizationProblemType.CPLEX_MIXED_INTEGER_PROGRAMMING;
+  }
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GlopSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GlopSolver.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GlopSolver.cs	(revision 16233)
@@ -0,0 +1,20 @@
+﻿using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers {
+
+  [Item("Glop", "Glop (https://developers.google.com/optimization/lp/glop) can be used out of the box.")]
+  [StorableClass]
+  public class GlopSolver : IncrementalSolver {
+
+    public GlopSolver() {
+      programmingTypeParam.Value = (EnumValue<LinearProgrammingType>)programmingTypeParam.Value.AsReadOnly();
+    }
+
+    public override OptimizationProblemType OptimizationProblemType => OptimizationProblemType.GLOP_LINEAR_PROGRAMMING;
+    public override bool SupportsPause => true;
+    public override bool SupportsStop => true;
+  }
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GlpkSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GlpkSolver.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GlpkSolver.cs	(revision 16233)
@@ -0,0 +1,38 @@
+﻿using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers {
+
+  [Item("GLPK", "GLPK (https://www.gnu.org/software/glpk/) can be used out of the box.")]
+  [StorableClass]
+  public class GlpkSolver : ExternalIncrementalSolver {
+
+    public GlpkSolver() {
+      Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName),
+        new FileValue { FileDialogFilter = FileDialogFilter, Value = "glpk465.dll" }));
+
+      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();
+        }
+      };
+    }
+
+    public override OptimizationProblemType OptimizationProblemType =>
+      LinearProgrammingType == LinearProgrammingType.LinearProgramming
+        ? OptimizationProblemType.GLPK_LINEAR_PROGRAMMING
+        : OptimizationProblemType.GLPK_MIXED_INTEGER_PROGRAMMING;
+  }
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GurobiSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GurobiSolver.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GurobiSolver.cs	(revision 16233)
@@ -0,0 +1,32 @@
+﻿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;
+
+namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers {
+
+  [Item("Gurobi", "Gurobi (http://www.gurobi.com/) must be installed and licenced.")]
+  [StorableClass]
+  public class GurobiSolver : ExternalIncrementalSolver {
+
+    public GurobiSolver() {
+      Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName),
+        new FileValue { FileDialogFilter = FileDialogFilter, Value = "gurobi80.dll" }));
+    }
+
+    protected GurobiSolver(GurobiSolver original, Cloner cloner)
+          : base(original, cloner) {
+      programmingTypeParam = cloner.Clone(original.programmingTypeParam);
+    }
+
+    public override OptimizationProblemType OptimizationProblemType =>
+      LinearProgrammingType == LinearProgrammingType.LinearProgramming
+        ? OptimizationProblemType.GUROBI_LINEAR_PROGRAMMING
+        : OptimizationProblemType.GUROBI_MIXED_INTEGER_PROGRAMMING;
+
+    public override bool SupportsPause => true;
+    public override bool SupportsStop => true;
+  }
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/ScipSolver.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/ScipSolver.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/ScipSolver.cs	(revision 16233)
@@ -0,0 +1,27 @@
+﻿using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers {
+
+  [Item("SCIP", "SCIP (http://scip.zib.de/) must be installed and licenced.")]
+  [StorableClass]
+  public class ScipSolver : ExternalSolver {
+
+    public ScipSolver() {
+      Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName),
+        new FileValue { FileDialogFilter = FileDialogFilter, Value = "scip.dll" }));
+      programmingTypeParam.Value =
+        (EnumValue<LinearProgrammingType>)new EnumValue<LinearProgrammingType>(LinearProgrammingType
+          .MixedIntegerProgramming).AsReadOnly();
+    }
+
+    public override OptimizationProblemType OptimizationProblemType =>
+      OptimizationProblemType.SCIP_MIXED_INTEGER_PROGRAMMING;
+
+    public override bool SupportsPause => true;
+    public override bool SupportsStop => true;
+  }
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/DoubleParam.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/DoubleParam.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/DoubleParam.cs	(revision 16233)
@@ -0,0 +1,18 @@
+﻿namespace HeuristicLab.MathematicalOptimization.LinearProgramming {
+
+  // Enumeration of parameters that take continuous values.
+  public enum DoubleParam {
+
+    // Limit for relative MIP gap.
+    RELATIVE_MIP_GAP = 0,
+
+    // 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.
+    PRIMAL_TOLERANCE = 1,
+
+    // Advanced usage: tolerance for dual feasibility of basic solutions.
+    DUAL_TOLERANCE = 2
+  };
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/IncrementalityValues.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/IncrementalityValues.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/IncrementalityValues.cs	(revision 16233)
@@ -0,0 +1,12 @@
+﻿namespace HeuristicLab.MathematicalOptimization.LinearProgramming {
+
+  public enum IncrementalityValues {
+
+    // Start solve from scratch.
+    INCREMENTALITY_OFF = 0,
+
+    // Reuse results from previous solve as much as the underlying
+    // solver allows.
+    INCREMENTALITY_ON = 1
+  };
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/IntegerParam.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/IntegerParam.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/IntegerParam.cs	(revision 16233)
@@ -0,0 +1,18 @@
+﻿namespace HeuristicLab.MathematicalOptimization.LinearProgramming {
+
+  // Enumeration of parameters that take integer or categorical values.
+  public enum IntegerParam {
+
+    // Advanced usage: presolve mode.
+    PRESOLVE = 1000,
+
+    // Algorithm to solve linear programs.
+    LP_ALGORITHM = 1001,
+
+    // Advanced usage: incrementality from one solve to the next.
+    INCREMENTALITY = 1002,
+
+    // Advanced usage: enable or disable matrix scaling.
+    SCALING = 1003
+  };
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/LpAlgorithmValues.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/LpAlgorithmValues.cs	(revision 16233)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/LpAlgorithmValues.cs	(revision 16233)
@@ -0,0 +1,8 @@
+﻿namespace HeuristicLab.MathematicalOptimization.LinearProgramming {
+
+  public enum LpAlgorithmValues {
+    DualSimplex = 10,
+    PrimalSimplex = 11,
+    BarrierAlgorithm = 12
+  };
+}
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/ILinearProgrammingProblemDefinition.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/ILinearProgrammingProblemDefinition.cs	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/ILinearProgrammingProblemDefinition.cs	(revision 16233)
@@ -1,3 +1,4 @@
 ﻿#region License Information
+
 /* HeuristicLab
  * Copyright (C) 2002-2018 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -18,5 +19,6 @@
  * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
  */
-#endregion
+
+#endregion License Information
 
 using Google.OrTools.LinearSolver;
@@ -24,6 +26,9 @@
 
 namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Problems {
+
   public interface ILinearProgrammingProblemDefinition {
+
     void BuildModel(Solver solver);
+
     void Analyze(Solver solver, ResultCollection results);
   }
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/LinearProgrammingProblem.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/LinearProgrammingProblem.cs	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/LinearProgrammingProblem.cs	(revision 16233)
@@ -1,3 +1,4 @@
 ﻿#region License Information
+
 /* HeuristicLab
  * Copyright (C) 2002-2018 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -18,5 +19,6 @@
  * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
  */
-#endregion
+
+#endregion License Information
 
 using System.Drawing;
@@ -30,16 +32,15 @@
 
 namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Problems {
-  [Item("Linear Programming Programmable Problem (single-objective)", "Represents a single-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+
+  [Item("Linear/Mixed Integer Programming Problem (LP/MIP)", "")]
+  [Creatable(CreatableAttribute.Categories.CombinatorialProblems)]
   [StorableClass]
   public class LinearProgrammingProblem : Problem, IProgrammableItem {
 
-    public new static Image StaticItemImage => VSImageLibrary.Script;
-
-    private FixedValueParameter<LinearProgrammingProblemDefinitionScript> LinearProgrammingProblemScriptParameter => (FixedValueParameter<LinearProgrammingProblemDefinitionScript>)Parameters["ProblemScript"];
-
-    public LinearProgrammingProblemDefinitionScript ProblemScript => LinearProgrammingProblemScriptParameter.Value;
-
-    public ILinearProgrammingProblemDefinition ProblemDefinition => LinearProgrammingProblemScriptParameter.Value;
+    public LinearProgrammingProblem() {
+      Parameters.Add(new FixedValueParameter<LinearProgrammingProblemDefinitionScript>("ProblemScript",
+        "Defines the problem.", new LinearProgrammingProblemDefinitionScript { Name = Name }) { GetsCollected = false });
+      RegisterEvents();
+    }
 
     private LinearProgrammingProblem(LinearProgrammingProblem original, Cloner cloner)
@@ -47,12 +48,24 @@
       RegisterEvents();
     }
-    public override IDeepCloneable Clone(Cloner cloner) { return new LinearProgrammingProblem(this, cloner); }
 
     [StorableConstructor]
     private LinearProgrammingProblem(bool deserializing) : base(deserializing) { }
-    public LinearProgrammingProblem() {
-      Parameters.Add(new FixedValueParameter<LinearProgrammingProblemDefinitionScript>("ProblemScript", "Defines the problem.", new LinearProgrammingProblemDefinitionScript { Name = Name }) { GetsCollected = false });
-      //Operators.Add(new BestScopeSolutionAnalyzer());
-      RegisterEvents();
+
+    public new static Image StaticItemImage => VSImageLibrary.Script;
+    public ILinearProgrammingProblemDefinition ProblemDefinition => LinearProgrammingProblemScriptParameter.Value;
+    public LinearProgrammingProblemDefinitionScript ProblemScript => LinearProgrammingProblemScriptParameter.Value;
+
+    private FixedValueParameter<LinearProgrammingProblemDefinitionScript> LinearProgrammingProblemScriptParameter =>
+      (FixedValueParameter<LinearProgrammingProblemDefinitionScript>)Parameters["ProblemScript"];
+
+    public void BuildModel(Solver solver) => ProblemDefinition.BuildModel(solver);
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LinearProgrammingProblem(this, cloner);
+    }
+
+    protected override void OnNameChanged() {
+      base.OnNameChanged();
+      ProblemScript.Name = Name;
     }
 
@@ -62,42 +75,17 @@
     }
 
+    private void OnProblemDefinitionChanged() {
+      OnOperatorsChanged();
+      OnReset();
+    }
+
+    private void OnProblemScriptNameChanged() {
+      Name = ProblemScript.Name;
+    }
+
     private void RegisterEvents() {
       ProblemScript.ProblemDefinitionChanged += (o, e) => OnProblemDefinitionChanged();
       ProblemScript.NameChanged += (o, e) => OnProblemScriptNameChanged();
     }
-
-    private void OnProblemDefinitionChanged() {
-      //Parameters.Remove("Maximization");
-      //Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", (BoolValue)new BoolValue(Maximization).AsReadOnly()) { Hidden = true });
-
-      //Encoding = ProblemDefinition.Encoding;
-      OnOperatorsChanged();
-      OnReset();
-    }
-    protected override void OnNameChanged() {
-      base.OnNameChanged();
-      ProblemScript.Name = Name;
-    }
-    private void OnProblemScriptNameChanged() {
-      Name = ProblemScript.Name;
-    }
-
-    public void BuildModel(Solver solver) => ProblemDefinition.BuildModel(solver);
-
-    //public override bool Maximization {
-    //  get { return Parameters.ContainsKey("ProblemScript") ? ProblemDefinition.Maximization : false; }
-    //}
-
-    //public override double Evaluate(Individual individual, IRandom random) {
-    //  return ProblemDefinition.Evaluate(individual, random);
-    //}
-
-    //public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
-    //  ProblemDefinition.Analyze(individuals, qualities, results, random);
-    //}
-
-    //public override IEnumerable<Individual> GetNeighbors(Individual individual, IRandom random) {
-    //  return ProblemDefinition.GetNeighbors(individual, random);
-    //}
   }
 }
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/LinearProgrammingProblemDefinitionScript.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/LinearProgrammingProblemDefinitionScript.cs	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/LinearProgrammingProblemDefinitionScript.cs	(revision 16233)
@@ -1,3 +1,4 @@
 ﻿#region License Information
+
 /* HeuristicLab
  * Copyright (C) 2002-2018 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -18,5 +19,6 @@
  * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
  */
-#endregion
+
+#endregion License Information
 
 using System;
@@ -32,4 +34,5 @@
 
 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.")]
   [StorableClass]
@@ -39,4 +42,5 @@
     [Storable]
     private VariableStore variableStore;
+
     public VariableStore VariableStore => variableStore;
 
@@ -46,4 +50,5 @@
     [StorableConstructor]
     protected LinearProgrammingProblemDefinitionScript(bool deserializing) : base(deserializing) { }
+
     protected LinearProgrammingProblemDefinitionScript(LinearProgrammingProblemDefinitionScript original, Cloner cloner)
       : base(original, cloner) {
@@ -59,4 +64,5 @@
     private readonly object compileLock = new object();
     private volatile ILinearProgrammingProblemDefinition compiledProblemDefinition;
+
     protected ILinearProgrammingProblemDefinition CompiledProblemDefinition {
       get {
@@ -65,5 +71,6 @@
           lock (compileLock) {
             if (compiledProblemDefinition == null) {
-              if (codeChanged) throw new ProblemDefinitionScriptException("The code has been changed, but was not recompiled.");
+              if (codeChanged)
+                throw new ProblemDefinitionScriptException("The code has been changed, but was not recompiled.");
               Compile(false);
             }
@@ -73,9 +80,8 @@
       }
     }
+
     public dynamic Instance => compiledProblemDefinition;
 
-    public override Assembly Compile() {
-      return Compile(true);
-    }
+    public override Assembly Compile() => Compile(true);
 
     private Assembly Compile(bool fireChanged) {
@@ -83,14 +89,20 @@
       var types = assembly.GetTypes();
       if (!types.Any(x => typeof(CompiledProblemDefinition).IsAssignableFrom(x)))
-        throw new ProblemDefinitionScriptException("The compiled code doesn't contain a problem definition." + Environment.NewLine + "The problem definition must be a subclass of CompiledProblemDefinition.");
+        throw new ProblemDefinitionScriptException("The compiled code doesn't contain a problem definition." +
+                                                   Environment.NewLine +
+                                                   "The problem definition must be a subclass of CompiledProblemDefinition.");
       if (types.Count(x => typeof(CompiledProblemDefinition).IsAssignableFrom(x)) > 1)
-        throw new ProblemDefinitionScriptException("The compiled code contains multiple problem definitions." + Environment.NewLine + "Only one subclass of CompiledProblemDefinition is allowed.");
+        throw new ProblemDefinitionScriptException("The compiled code contains multiple problem definitions." +
+                                                   Environment.NewLine +
+                                                   "Only one subclass of CompiledProblemDefinition is allowed.");
 
       CompiledProblemDefinition inst;
       try {
-        inst = (CompiledProblemDefinition)Activator.CreateInstance(types.Single(x => typeof(CompiledProblemDefinition).IsAssignableFrom(x)));
+        inst = (CompiledProblemDefinition)Activator.CreateInstance(types.Single(x =>
+         typeof(CompiledProblemDefinition).IsAssignableFrom(x)));
       } catch (Exception e) {
         compiledProblemDefinition = null;
-        throw new ProblemDefinitionScriptException("Instantiating the problem definition failed." + Environment.NewLine + "Check your default constructor.", e);
+        throw new ProblemDefinitionScriptException(
+          "Instantiating the problem definition failed." + Environment.NewLine + "Check your default constructor.", e);
       }
 
@@ -100,5 +112,6 @@
       } catch (Exception e) {
         compiledProblemDefinition = null;
-        throw new ProblemDefinitionScriptException("Initializing the problem definition failed." + Environment.NewLine + "Check your Initialize() method.", e);
+        throw new ProblemDefinitionScriptException(
+          "Initializing the problem definition failed." + Environment.NewLine + "Check your Initialize() method.", e);
       }
 
@@ -108,5 +121,7 @@
       } catch (Exception e) {
         compiledProblemDefinition = null;
-        throw new ProblemDefinitionScriptException("Using the problem definition in the problem failed." + Environment.NewLine + "Examine this error message carefully (often there is an issue with the defined encoding).", e);
+        throw new ProblemDefinitionScriptException(
+          "Using the problem definition in the problem failed." + Environment.NewLine +
+          "Examine this error message carefully (often there is an issue with the defined encoding).", e);
       }
 
@@ -122,8 +137,6 @@
 
     public event EventHandler ProblemDefinitionChanged;
-    private void OnProblemDefinitionChanged() {
-      var handler = ProblemDefinitionChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
+
+    private void OnProblemDefinitionChanged() => ProblemDefinitionChanged?.Invoke(this, EventArgs.Empty);
 
     public string Filename { get; set; }
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/LinearProgrammingProblemDefintion.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/LinearProgrammingProblemDefintion.cs	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/LinearProgrammingProblemDefintion.cs	(revision 16233)
@@ -3,12 +3,11 @@
 
 namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Problems {
+
   public class LinearProgrammingProblemDefintion : CompiledProblemDefinition {
 
-    public override void Initialize() {
-
+    public void BuildModel(Solver solver) {
     }
 
-    public void BuildModel(Solver solver) {
-
+    public override void Initialize() {
     }
   }
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/ProblemDefinitionScriptException.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/ProblemDefinitionScriptException.cs	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/ProblemDefinitionScriptException.cs	(revision 16233)
@@ -1,3 +1,4 @@
 ﻿#region License Information
+
 /* HeuristicLab
  * Copyright (C) 2002-2018 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -18,5 +19,6 @@
  * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
  */
-#endregion
+
+#endregion License Information
 
 using System;
@@ -24,9 +26,16 @@
 
 namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Problems {
+
   [Serializable]
   public class ProblemDefinitionScriptException : Exception {
-    public ProblemDefinitionScriptException() { }
-    public ProblemDefinitionScriptException(string message) : base(message) { }
-    public ProblemDefinitionScriptException(string message, Exception inner) : base(message, inner) { }
+
+    public ProblemDefinitionScriptException() {
+    }
+
+    public ProblemDefinitionScriptException(string message) : base(message) {
+    }
+
+    public ProblemDefinitionScriptException(string message, Exception inner) : base(message, inner) {
+    }
 
     protected ProblemDefinitionScriptException(SerializationInfo info, StreamingContext context)
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Templates/CompiledLinearProgrammingProblemDefinition.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Templates/CompiledLinearProgrammingProblemDefinition.cs	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Templates/CompiledLinearProgrammingProblemDefinition.cs	(revision 16233)
@@ -6,6 +6,6 @@
 
 namespace HeuristicLab.MathematicalOptimization.LinearProgramming {
+
   public class CompiledLinearProgrammingProblemDefinition : CompiledProblemDefinition, ILinearProgrammingProblemDefinition {
-
     private Variable x;
     private Variable y;
@@ -18,5 +18,5 @@
     public void 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 
+      // Example model taken from https://developers.google.com/optimization/mip/integer_opt
       // Define the decision variables
       x = solver.MakeIntVar(0, 3.5, "x");
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Templates/ScriptTemplates.Designer.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Templates/ScriptTemplates.Designer.cs	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Templates/ScriptTemplates.Designer.cs	(revision 16233)
@@ -9,12 +9,4 @@
 //------------------------------------------------------------------------------
 
-using System.CodeDom.Compiler;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
-using System.Resources;
-using System.Runtime.CompilerServices;
-
 namespace HeuristicLab.MathematicalOptimization.LinearProgramming {
   /// <summary>
@@ -25,14 +17,14 @@
   // To add or remove a member, edit your .ResX file then rerun ResGen
   // with the /str option, or rebuild your VS project.
-  [GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
-  [DebuggerNonUserCode()]
-  [CompilerGenerated()]
+  [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
   internal class ScriptTemplates {
 
-    private static ResourceManager resourceMan;
+    private static global::System.Resources.ResourceManager resourceMan;
 
-    private static CultureInfo resourceCulture;
+    private static global::System.Globalization.CultureInfo resourceCulture;
 
-    [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+    [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
     internal ScriptTemplates() {
     }
@@ -41,9 +33,9 @@
     ///   Returns the cached ResourceManager instance used by this class.
     /// </summary>
-    [EditorBrowsable(EditorBrowsableState.Advanced)]
-    internal static ResourceManager ResourceManager {
+    [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+    internal static global::System.Resources.ResourceManager ResourceManager {
       get {
-        if (ReferenceEquals(resourceMan, null)) {
-          ResourceManager temp = new ResourceManager("HeuristicLab.MathematicalOptimization.LinearProgramming.Templates.ScriptTemplates" +
+        if (object.ReferenceEquals(resourceMan, null)) {
+          global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("HeuristicLab.MathematicalOptimization.LinearProgramming.Templates.ScriptTemplates" +
                   "", typeof(ScriptTemplates).Assembly);
           resourceMan = temp;
@@ -57,6 +49,6 @@
     ///   resource lookups using this strongly typed resource class.
     /// </summary>
-    [EditorBrowsable(EditorBrowsableState.Advanced)]
-    internal static CultureInfo Culture {
+    [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+    internal static global::System.Globalization.CultureInfo Culture {
       get {
         return resourceCulture;
@@ -68,18 +60,18 @@
 
     /// <summary>
-    ///   Looks up a localized string similar to using System;
-    ///using System.Linq;
-    ///using System.Collections.Generic;
-    ///using HeuristicLab.Common;
-    ///using HeuristicLab.Core;
+    ///   Looks up a localized string similar to using Google.OrTools.LinearSolver;
     ///using HeuristicLab.Data;
-    ///using HeuristicLab.Encodings.BinaryVectorEncoding;
-    ///using HeuristicLab.Encodings.IntegerVectorEncoding;
-    ///using HeuristicLab.Encodings.RealVectorEncoding;
-    ///using HeuristicLab.Encodings.PermutationEncoding;
-    ///using HeuristicLab.Encodings.LinearLinkageEncoding;
-    ///using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+    ///using HeuristicLab.MathematicalOptimization.LinearProgramming.Problems;
     ///using HeuristicLab.Optimization;
-    ///using H [rest of string was truncated]&quot;;.
+    ///using HeuristicLab.Problems.Programmable;
+    ///
+    ///namespace HeuristicLab.MathematicalOptimization.LinearProgramming {
+    ///  public class CompiledLinearProgrammingProblemDefinition : CompiledProblemDefinition, ILinearProgrammingProblemDefinition {
+    ///
+    ///    private Variable x;
+    ///    private Variable y;
+    ///
+    ///    public override void Initialize() {
+    ///      // [rest of string was truncated]&quot;;.
     /// </summary>
     internal static string CompiledLinearProgrammingProblemDefinition {
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Templates/ScriptTemplates.resx
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Templates/ScriptTemplates.resx	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Templates/ScriptTemplates.resx	(revision 16233)
@@ -60,6 +60,6 @@
             : and then encoded with base64 encoding.
     -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/QualityUpdateIntervalMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/QualityUpdateIntervalML/1998/namespace" />
     <xsd:element name="root" msdata:IsDataSet="true">
       <xsd:complexType>
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.Optimization.Views/3.3/BasicAlgorithmView.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.Optimization.Views/3.3/BasicAlgorithmView.cs	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.Optimization.Views/3.3/BasicAlgorithmView.cs	(revision 16233)
@@ -37,4 +37,5 @@
       base.SetEnabledStateOfControls();
       pauseButton.Enabled &= Content != null && Content.SupportsPause;
+      stopButton.Enabled &= Content != null && Content.SupportsStop;
     }
 
@@ -42,4 +43,5 @@
       base.SetEnabledStateOfExecutableButtons();
       pauseButton.Enabled &= Content != null && Content.SupportsPause;
+      stopButton.Enabled &= Content != null && Content.SupportsStop;
     }
   }
Index: /branches/2931_OR-Tools_LP_MIP/HeuristicLab.Optimization/3.3/Algorithms/BasicAlgorithm.cs
===================================================================
--- /branches/2931_OR-Tools_LP_MIP/HeuristicLab.Optimization/3.3/Algorithms/BasicAlgorithm.cs	(revision 16232)
+++ /branches/2931_OR-Tools_LP_MIP/HeuristicLab.Optimization/3.3/Algorithms/BasicAlgorithm.cs	(revision 16233)
@@ -36,4 +36,7 @@
 
     public abstract bool SupportsPause { get; }
+    public virtual bool SupportsStop {
+      get { return true; }
+    }
 
     [Storable]
