Changeset 16373 for branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms
- Timestamp:
- 12/12/18 14:23:45 (6 years ago)
- Location:
- branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms
- Files:
-
- 12 edited
- 1 moved
Legend:
- Unmodified
- Added
- Removed
-
branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/LinearProgrammingAlgorithm.cs
r16288 r16373 35 35 namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms { 36 36 37 [Item("Linear/Mixed Integer Programming (LP/MIP)", "")] 38 [Creatable(CreatableAttribute.Categories.SingleSolutionAlgorithms)] 37 [Item("Linear/Mixed Integer Programming (LP/MIP)", "Linear/mixed integer programming implemented in several solvers. " + 38 "See also https://dev.heuristiclab.com/trac.fcgi/wiki/Documentation/Howto/LinearMixedIntegerProgramming")] // TODO: update link 39 [Creatable(CreatableAttribute.Categories.ExactAlgorithms)] 39 40 [StorableClass] 40 41 public class LinearProgrammingAlgorithm : BasicAlgorithm { … … 53 54 54 55 [Storable] 55 private readonly IFixedValueParameter< DoubleValue> relativeGapToleranceParam;56 private readonly IFixedValueParameter<PercentValue> relativeGapToleranceParam; 56 57 57 58 [Storable] … … 65 66 66 67 public IConstrainedValueParameter<ISolver> SolverParameter { 67 get { return solverParam; }68 set { solverParam = value; }68 get => solverParam; 69 set => solverParam = value; 69 70 } 70 71 … … 72 73 Parameters.Add(solverParam = 73 74 new ConstrainedValueParameter<ISolver>(nameof(Solver), "The solver used to solve the model.")); 74 Parameters.Add(relativeGapToleranceParam = new FixedValueParameter<DoubleValue>(nameof(RelativeGapTolerance), 75 "Limit for relative MIP gap.", new DoubleValue(MPSolverParameters.kDefaultRelativeMipGap))); 75 76 ISolver defaultSolver; 77 solverParam.ValidValues.Add(new BopSolver()); 78 solverParam.ValidValues.Add(defaultSolver = new CoinOrSolver()); 79 solverParam.ValidValues.Add(new CplexSolver()); 80 solverParam.ValidValues.Add(new GlopSolver()); 81 solverParam.ValidValues.Add(new GlpkSolver()); 82 solverParam.ValidValues.Add(new GurobiSolver()); 83 solverParam.ValidValues.Add(new ScipSolver()); 84 solverParam.Value = defaultSolver; 85 86 Parameters.Add(relativeGapToleranceParam = new FixedValueParameter<PercentValue>(nameof(RelativeGapTolerance), 87 "Limit for relative MIP gap.", new PercentValue(MPSolverParameters.kDefaultRelativeMipGap))); 76 88 Parameters.Add(timeLimitParam = new FixedValueParameter<TimeSpanValue>(nameof(TimeLimit), 77 89 "Limit for runtime. Set to zero for unlimited runtime.", new TimeSpanValue())); … … 92 104 93 105 Problem = new LinearProgrammingProblem(); 94 95 solverParam.ValidValues.Add(new CoinOrSolver());96 solverParam.ValidValues.Add(new CplexSolver());97 solverParam.ValidValues.Add(new GlpkSolver());98 solverParam.ValidValues.Add(new GurobiSolver());99 solverParam.ValidValues.Add(new ScipSolver());100 solverParam.ValidValues.Add(new BopSolver());101 solverParam.ValidValues.Add(new GlopSolver());102 106 } 103 107 … … 176 180 public override void Pause() { 177 181 base.Pause(); 178 Solver.Interrupt ();182 Solver.InterruptSolve(); 179 183 } 180 184 … … 190 194 public override void Stop() { 191 195 base.Stop(); 192 Solver.Interrupt(); 193 } 194 195 protected override void Initialize(CancellationToken cancellationToken) { 196 base.Initialize(cancellationToken); 196 Solver.InterruptSolve(); 197 197 } 198 198 -
branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/ProblemType.cs
r16372 r16373 22 22 namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms { 23 23 24 public enum LinearProgrammingType {24 public enum ProblemType { 25 25 LinearProgramming, 26 26 MixedIntegerProgramming -
branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IIncrementalSolver.cs
r16288 r16373 25 25 26 26 public interface IIncrementalSolver : ISolver { 27 bool Incrementality { get; set; }28 27 TimeSpan QualityUpdateInterval { get; set; } 28 bool SupportsQualityUpdate { get; } 29 29 } 30 30 } -
branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/ISolver.cs
r16288 r16373 26 26 27 27 public interface ISolver : IParameterizedNamedItem { 28 LinearProgrammingType LinearProgrammingType { get; set; }28 ProblemType ProblemType { get; set; } 29 29 bool SupportsPause { get; } 30 30 bool SupportsStop { get; } 31 31 32 void Interrupt();32 bool InterruptSolve(); 33 33 34 34 void Reset(); -
branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IncrementalSolver.cs
r16288 r16373 23 23 using System.Linq; 24 24 using System.Threading; 25 using Google.OrTools.LinearSolver;26 25 using HeuristicLab.Analysis; 27 26 using HeuristicLab.Common; … … 35 34 [StorableClass] 36 35 public class IncrementalSolver : Solver, IIncrementalSolver { 37 38 [Storable]39 protected readonly IValueParameter<BoolValue> incrementalityParam;40 36 41 37 [Storable] … … 55 51 56 52 public IncrementalSolver() { 57 Parameters.Add(incrementalityParam = new ValueParameter<BoolValue>(nameof(Incrementality),58 "Advanced usage: incrementality from one solve to the next.",59 new BoolValue(MPSolverParameters.kDefaultIncrementality == MPSolverParameters.INCREMENTALITY_ON)));60 53 Parameters.Add(qualityUpdateIntervalParam = 61 54 new ValueParameter<TimeSpanValue>(nameof(QualityUpdateInterval), 62 "Time interval before solver is paused, resuls are retrieved and solver is resumed.", 63 new TimeSpanValue(new TimeSpan(0, 0, 10)))); 64 65 incrementalityParam.Value.ValueChanged += (sender, args) => { 66 if (((BoolValue)sender).Value) { 67 qualityUpdateIntervalParam.Value = new TimeSpanValue(qualityUpdateIntervalParam.Value.Value); 55 "Time interval before solver is paused, results are retrieved and solver is resumed. " + 56 "Set to zero for no intermediate results and faster solving.", new TimeSpanValue(new TimeSpan(0, 0, 10)))); 57 problemTypeParam.Value.ValueChanged += (sender, args) => { 58 if (SupportsQualityUpdate) { 59 if (!Parameters.Contains(qualityUpdateIntervalParam)) { 60 Parameters.Add(qualityUpdateIntervalParam); 61 } 68 62 } else { 69 qualityUpdateIntervalParam.Value = (TimeSpanValue)qualityUpdateIntervalParam.Value.AsReadOnly();63 Parameters.Remove(qualityUpdateIntervalParam); 70 64 } 71 65 }; … … 74 68 protected IncrementalSolver(IncrementalSolver original, Cloner cloner) 75 69 : base(original, cloner) { 76 pro grammingTypeParam = cloner.Clone(original.programmingTypeParam);70 problemTypeParam = cloner.Clone(original.problemTypeParam); 77 71 qualityUpdateIntervalParam = cloner.Clone(original.qualityUpdateIntervalParam); 78 incrementalityParam = cloner.Clone(original.incrementalityParam);79 72 if (original.qualityPerClock != null) 80 73 qualityPerClock = cloner.Clone(original.qualityPerClock); 81 74 } 82 75 83 public bool Incrementality { 84 get => incrementalityParam.Value.Value; 85 set => incrementalityParam.Value.Value = value; 86 } 76 public virtual bool SupportsQualityUpdate => true; 87 77 88 78 public TimeSpan QualityUpdateInterval { … … 91 81 } 92 82 83 protected virtual TimeSpan TimeLimit => QualityUpdateInterval; 84 93 85 public override void Solve(LinearProgrammingAlgorithm algorithm, CancellationToken cancellationToken) { 94 if (! Incrementality) {86 if (!SupportsQualityUpdate || QualityUpdateInterval == TimeSpan.Zero) { 95 87 base.Solve(algorithm, cancellationToken); 96 88 return; … … 101 93 102 94 if (!unlimitedRuntime) { 103 var wallTime = ((TimeSpanValue)algorithm.Results.SingleOrDefault(r => r.Name == "Wall Time")?.Value)?.Value; 104 if (wallTime.HasValue) { 105 timeLimit -= wallTime.Value; 106 } 95 timeLimit -= algorithm.ExecutionTime; 107 96 } 108 97 109 98 var iterations = (long)timeLimit.TotalMilliseconds / (long)QualityUpdateInterval.TotalMilliseconds; 110 99 var remaining = timeLimit - TimeSpan.FromMilliseconds(iterations * QualityUpdateInterval.TotalMilliseconds); 111 var validResultStatuses = new[] { ResultStatus.N OT_SOLVED, ResultStatus.FEASIBLE};100 var validResultStatuses = new[] { ResultStatus.NotSolved, ResultStatus.Feasible }; 112 101 113 102 while (unlimitedRuntime || iterations > 0) { 114 base.Solve(algorithm, QualityUpdateInterval, true); 103 if (cancellationToken.IsCancellationRequested) 104 return; 105 106 base.Solve(algorithm, TimeLimit); 115 107 UpdateQuality(algorithm); 116 108 117 var resultStatus = ((EnumValue<ResultStatus>)algorithm.Results[ "Result Status"].Value).Value;118 if (!validResultStatuses.Contains(resultStatus) || cancellationToken.IsCancellationRequested)109 var resultStatus = ((EnumValue<ResultStatus>)algorithm.Results[nameof(solver.ResultStatus)].Value).Value; 110 if (!validResultStatuses.Contains(resultStatus)) 119 111 return; 120 112 … … 124 116 125 117 if (remaining > TimeSpan.Zero) { 126 base.Solve(algorithm, remaining , true);118 base.Solve(algorithm, remaining); 127 119 UpdateQuality(algorithm); 128 120 } … … 132 124 if (!algorithm.Results.Exists(r => r.Name == "QualityPerClock")) { 133 125 qualityPerClock = new IndexedDataTable<double>("Quality per Clock"); 134 qpcRow = new IndexedDataRow<double>(" First-hit Graph Objective");135 bpcRow = new IndexedDataRow<double>(" First-hit GraphBound");126 qpcRow = new IndexedDataRow<double>("Objective Value"); 127 bpcRow = new IndexedDataRow<double>("Bound"); 136 128 algorithm.Results.AddOrUpdateResult("QualityPerClock", qualityPerClock); 137 129 } 138 130 139 var resultStatus = ((EnumValue<ResultStatus>)algorithm.Results[ "Result Status"].Value).Value;131 var resultStatus = ((EnumValue<ResultStatus>)algorithm.Results[nameof(solver.ResultStatus)].Value).Value; 140 132 141 if (new[] { ResultStatus.A BNORMAL, ResultStatus.NOT_SOLVED, ResultStatus.UNBOUNDED}.Contains(resultStatus))133 if (new[] { ResultStatus.Abnormal, ResultStatus.NotSolved, ResultStatus.Unbounded }.Contains(resultStatus)) 142 134 return; 143 135 144 var objective = ((DoubleValue)algorithm.Results[ "Best Objective Value"].Value).Value;145 var bound = ((DoubleValue)algorithm.Results["Best Objective Bound"].Value).Value;136 var objective = ((DoubleValue)algorithm.Results[$"Best{nameof(solver.ObjectiveValue)}"].Value).Value; 137 var bound = solver.IsMip ? ((DoubleValue)algorithm.Results[$"Best{nameof(solver.ObjectiveBound)}"].Value).Value : double.NaN; 146 138 var time = algorithm.ExecutionTime.TotalSeconds; 147 139 … … 151 143 qpcRow.Values.Add(Tuple.Create(time, objective)); 152 144 qualityPerClock.Rows.Add(qpcRow); 153 algorithm.Results.AddOrUpdateResult( "Best Solution FoundAt", new TimeSpanValue(TimeSpan.FromSeconds(time)));145 algorithm.Results.AddOrUpdateResult($"Best{nameof(solver.ObjectiveValue)}FoundAt", new TimeSpanValue(TimeSpan.FromSeconds(time))); 154 146 } 155 147 } else { … … 158 150 if (!objective.IsAlmost(previousBest)) { 159 151 qpcRow.Values.Add(Tuple.Create(time, objective)); 160 algorithm.Results.AddOrUpdateResult( "Best Solution FoundAt", new TimeSpanValue(TimeSpan.FromSeconds(time)));152 algorithm.Results.AddOrUpdateResult($"Best{nameof(solver.ObjectiveValue)}FoundAt", new TimeSpanValue(TimeSpan.FromSeconds(time))); 161 153 } 162 154 } 155 156 if (!solver.IsMip) 157 return; 163 158 164 159 if (!bpcRow.Values.Any()) { -
branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/Solver.cs
r16288 r16373 34 34 35 35 [Storable] 36 protected IValueParameter<EnumValue< LinearProgrammingType>> programmingTypeParam;36 protected IValueParameter<EnumValue<ProblemType>> problemTypeParam; 37 37 38 38 protected LinearSolver solver; 39 39 40 [Storable] 41 protected IFixedValueParameter<TextValue> solverSpecificParametersParam; 42 40 43 public Solver() { 41 Parameters.Add(programmingTypeParam = 42 new ValueParameter<EnumValue<LinearProgrammingType>>(nameof(LinearProgrammingType), 43 new EnumValue<LinearProgrammingType>())); 44 Parameters.Add(problemTypeParam = 45 new ValueParameter<EnumValue<ProblemType>>(nameof(ProblemType), new EnumValue<ProblemType>())); 46 Parameters.Add(solverSpecificParametersParam = 47 new FixedValueParameter<TextValue>(nameof(SolverSpecificParameters), new TextValue())); 44 48 } 45 49 … … 51 55 protected Solver(Solver original, Cloner cloner) 52 56 : base(original, cloner) { 53 programmingTypeParam = cloner.Clone(original.programmingTypeParam); 57 problemTypeParam = cloner.Clone(original.problemTypeParam); 58 solverSpecificParametersParam = cloner.Clone(original.solverSpecificParametersParam); 54 59 } 55 60 56 public LinearProgrammingType LinearProgrammingType {57 get => pro grammingTypeParam.Value.Value;58 set => pro grammingTypeParam.Value.Value = value;61 public ProblemType ProblemType { 62 get => problemTypeParam.Value.Value; 63 set => problemTypeParam.Value.Value = value; 59 64 } 60 65 66 public TextValue SolverSpecificParameters => solverSpecificParametersParam.Value; 67 68 public virtual bool SupportsPause => true; 69 public virtual bool SupportsStop => true; 61 70 protected virtual OptimizationProblemType OptimizationProblemType { get; } 62 public virtual bool SupportsPause => false;63 public virtual bool SupportsStop => false;64 71 65 72 public override IDeepCloneable Clone(Cloner cloner) => new Solver(this, cloner); … … 67 74 public void Dispose() => solver?.Dispose(); 68 75 69 public void Interrupt() => solver.Stop();76 public bool InterruptSolve() => solver?.InterruptSolve() ?? false; 70 77 71 78 public virtual void Reset() { … … 78 85 79 86 public virtual void Solve(LinearProgrammingAlgorithm algorithm) => 80 Solve(algorithm, algorithm.TimeLimit , false);87 Solve(algorithm, algorithm.TimeLimit); 81 88 82 public virtual void Solve(LinearProgrammingAlgorithm algorithm, TimeSpan timeLimit , bool incrementality) {89 public virtual void Solve(LinearProgrammingAlgorithm algorithm, TimeSpan timeLimit) { 83 90 string libraryName = null; 84 91 if (this is IExternalSolver externalSolver) … … 86 93 87 94 if (solver == null) { 88 solver = LinearSolver.CreateSolver(OptimizationProblemType, Name,89 libraryName , s => algorithm.Problem.ProblemDefinition.BuildModel(s));95 solver = new LinearSolver(OptimizationProblemType, s => algorithm.Problem.ProblemDefinition.BuildModel(s), Name, 96 libraryName); 90 97 } 91 98 … … 97 104 solver.Scaling = algorithm.Scaling; 98 105 solver.LpAlgorithm = algorithm.LpAlgorithm; 99 solver.Incrementality = incrementality; 106 solver.Incrementality = true; 107 108 if (!solver.SetSolverSpecificParameters(SolverSpecificParameters.Value)) 109 throw new ArgumentException("Solver specific parameters could not be set."); 100 110 101 111 solver.Solve(); 102 112 103 113 algorithm.Problem.ProblemDefinition.Analyze(solver.Solver, algorithm.Results); 104 algorithm.Results.AddOrUpdateResult("Result Status", new EnumValue<ResultStatus>(solver.ResultStatus)); 105 algorithm.Results.AddOrUpdateResult("Best Objective Value", 114 algorithm.Results.AddOrUpdateResult(nameof(solver.ResultStatus), 115 new EnumValue<ResultStatus>(solver.ResultStatus)); 116 algorithm.Results.AddOrUpdateResult($"Best{nameof(solver.ObjectiveValue)}", 106 117 new DoubleValue(solver.ObjectiveValue ?? double.NaN)); 107 algorithm.Results.AddOrUpdateResult("Best Objective Bound", 108 new DoubleValue(solver.ObjectiveBound ?? double.NaN)); 109 algorithm.Results.AddOrUpdateResult("Absolute Gap", new DoubleValue(solver.AbsoluteGap ?? double.NaN)); 110 algorithm.Results.AddOrUpdateResult("Relative Gap", new DoubleValue(solver.RelativeGap ?? double.NaN)); 111 algorithm.Results.AddOrUpdateResult("Number of Constraints", new IntValue(solver.NumberOfConstraints)); 112 algorithm.Results.AddOrUpdateResult("Number of Variables", new IntValue(solver.NumberOfVariables)); 113 algorithm.Results.AddOrUpdateResult("Number of Nodes", new DoubleValue(solver.NumberOfNodes)); 114 algorithm.Results.AddOrUpdateResult("Iterations", new DoubleValue(solver.Iterations)); 115 algorithm.Results.AddOrUpdateResult("Solver Version", new StringValue(solver.SolverVersion)); 116 algorithm.Results.AddOrUpdateResult("Wall Time", new TimeSpanValue(solver.WallTime ?? TimeSpan.Zero)); 118 119 if (solver.IsMip) { 120 algorithm.Results.AddOrUpdateResult($"Best{nameof(solver.ObjectiveBound)}", 121 new DoubleValue(solver.ObjectiveBound ?? double.NaN)); 122 algorithm.Results.AddOrUpdateResult(nameof(solver.AbsoluteGap), 123 new DoubleValue(solver.AbsoluteGap ?? double.NaN)); 124 algorithm.Results.AddOrUpdateResult(nameof(solver.RelativeGap), 125 new PercentValue(solver.RelativeGap ?? double.NaN)); 126 } 127 128 algorithm.Results.AddOrUpdateResult(nameof(solver.NumberOfConstraints), new IntValue(solver.NumberOfConstraints)); 129 algorithm.Results.AddOrUpdateResult(nameof(solver.NumberOfVariables), new IntValue(solver.NumberOfVariables)); 130 131 if (solver.IsMip) { 132 algorithm.Results.AddOrUpdateResult(nameof(solver.NumberOfNodes), new DoubleValue(solver.NumberOfNodes)); 133 } 134 135 algorithm.Results.AddOrUpdateResult(nameof(solver.Iterations), new DoubleValue(solver.Iterations)); 136 algorithm.Results.AddOrUpdateResult(nameof(solver.SolverVersion), new StringValue(solver.SolverVersion)); 117 137 } 118 138 } -
branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/BopSolver.cs
r16288 r16373 20 20 #endregion 21 21 22 using System; 22 23 using HeuristicLab.Common; 23 24 using HeuristicLab.Core; 25 using HeuristicLab.Data; 24 26 using HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base; 27 using HeuristicLab.Parameters; 25 28 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable; 26 29 … … 32 35 33 36 public BopSolver() { 34 Parameters.Remove(programmingTypeParam); 37 Parameters.Remove(problemTypeParam); 38 Parameters.Add(new FixedValueParameter<StringValue>(nameof(ProblemType), new StringValue("ZeroOneProgramming").AsReadOnly())); 39 SolverSpecificParameters.Value = 40 "# for file format, see Protocol Buffers text format (https://developers.google.com/protocol-buffers/docs/overview#whynotxml)" + Environment.NewLine + 41 "# for parameters, see https://github.com/google/or-tools/blob/v6.10/ortools/bop/bop_parameters.proto" + Environment.NewLine + 42 "# example:" + Environment.NewLine + 43 "# random_seed: 10" + Environment.NewLine; 35 44 } 36 45 … … 44 53 } 45 54 46 public override bool SupportsPause => true;47 48 public override bool SupportsStop => true;49 50 55 protected override OptimizationProblemType OptimizationProblemType => 51 OptimizationProblemType.BOP_INTEGER_PROGRAMMING;56 OptimizationProblemType.BopIntegerProgramming; 52 57 } 53 58 } -
branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/CoinOrSolver.cs
r16288 r16373 22 22 using HeuristicLab.Common; 23 23 using HeuristicLab.Core; 24 using HeuristicLab.Data;25 24 using HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base; 26 25 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable; … … 33 32 34 33 public CoinOrSolver() { 35 programmingTypeParam.Value.ValueChanged += (sender, args) => { 36 if (((EnumValue<LinearProgrammingType>)sender).Value == LinearProgrammingType.LinearProgramming) { 37 incrementalityParam.Value = new BoolValue(true); 38 incrementalityParam.Value.ValueChanged += (s, a) => { 39 if (((BoolValue)s).Value) { 40 qualityUpdateIntervalParam.Value = new TimeSpanValue(qualityUpdateIntervalParam.Value.Value); 41 } else { 42 qualityUpdateIntervalParam.Value = (TimeSpanValue)qualityUpdateIntervalParam.Value.AsReadOnly(); 43 } 44 }; 45 } else { 46 incrementalityParam.Value = (BoolValue)new BoolValue().AsReadOnly(); 47 } 48 }; 34 Parameters.Remove(solverSpecificParametersParam); 49 35 } 50 36 … … 58 44 } 59 45 46 public override bool SupportsPause => false; 47 48 public override bool SupportsQualityUpdate => ProblemType == ProblemType.LinearProgramming; 49 50 public override bool SupportsStop => false; 51 60 52 protected override OptimizationProblemType OptimizationProblemType => 61 LinearProgrammingType == LinearProgrammingType.LinearProgramming62 ? OptimizationProblemType.C LP_LINEAR_PROGRAMMING63 : OptimizationProblemType.C BC_MIXED_INTEGER_PROGRAMMING;53 ProblemType == ProblemType.LinearProgramming 54 ? OptimizationProblemType.ClpLinearProgramming 55 : OptimizationProblemType.CbcMixedIntegerProgramming; 64 56 } 65 57 } -
branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/CplexSolver.cs
r16288 r16373 20 20 #endregion 21 21 22 using System; 22 23 using HeuristicLab.Common; 23 24 using HeuristicLab.Core; … … 36 37 Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName), 37 38 new FileValue { FileDialogFilter = FileDialogFilter, Value = Properties.Settings.Default.CplexLibraryName })); 39 SolverSpecificParameters.Value = 40 "CPLEX Parameter File Version 12.8.0" + Environment.NewLine + 41 "# 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 + 42 "# for parameters, see https://www.ibm.com/support/knowledgecenter/SSSA5P_12.8.0/ilog.odms.cplex.help/CPLEX/Parameters/topics/introListTopical.html" + Environment.NewLine + 43 "# example:" + Environment.NewLine + 44 "# CPXPARAM_RandomSeed 10" + Environment.NewLine; 38 45 } 39 46 … … 48 55 49 56 protected override OptimizationProblemType OptimizationProblemType => 50 LinearProgrammingType == LinearProgrammingType.LinearProgramming51 ? OptimizationProblemType.C PLEX_LINEAR_PROGRAMMING52 : OptimizationProblemType.C PLEX_MIXED_INTEGER_PROGRAMMING;57 ProblemType == ProblemType.LinearProgramming 58 ? OptimizationProblemType.CplexLinearProgramming 59 : OptimizationProblemType.CplexMixedIntegerProgramming; 53 60 } 54 61 } -
branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GlopSolver.cs
r16288 r16373 20 20 #endregion 21 21 22 using System; 22 23 using HeuristicLab.Common; 23 24 using HeuristicLab.Core; … … 33 34 34 35 public GlopSolver() { 35 programmingTypeParam.Value = (EnumValue<LinearProgrammingType>)programmingTypeParam.Value.AsReadOnly(); 36 problemTypeParam.Value = (EnumValue<ProblemType>)problemTypeParam.Value.AsReadOnly(); 37 SolverSpecificParameters.Value = 38 "# for file format, see Protocol Buffers text format (https://developers.google.com/protocol-buffers/docs/overview#whynotxml)" + Environment.NewLine + 39 "# for parameters, see https://github.com/google/or-tools/blob/v6.10/ortools/glop/parameters.proto" + Environment.NewLine + 40 "# example:" + Environment.NewLine + 41 "# random_seed: 10" + Environment.NewLine; 36 42 } 37 43 … … 45 51 } 46 52 47 public override bool SupportsPause => true;48 49 public override bool SupportsStop => true;50 51 53 protected override OptimizationProblemType OptimizationProblemType => 52 OptimizationProblemType.GLOP_LINEAR_PROGRAMMING;54 OptimizationProblemType.GlopLinearProgramming; 53 55 } 54 56 } -
branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GlpkSolver.cs
r16288 r16373 34 34 35 35 public GlpkSolver() { 36 Parameters.Remove(solverSpecificParametersParam); 36 37 Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName), 37 38 new FileValue { FileDialogFilter = FileDialogFilter, Value = Properties.Settings.Default.GlpkLibraryName })); 38 39 programmingTypeParam.Value.ValueChanged += (sender, args) => {40 if (((EnumValue<LinearProgrammingType>)sender).Value == LinearProgrammingType.LinearProgramming) {41 incrementalityParam.Value = new BoolValue(true);42 incrementalityParam.Value.ValueChanged += (s, a) => {43 if (((BoolValue)s).Value) {44 qualityUpdateIntervalParam.Value = new TimeSpanValue(qualityUpdateIntervalParam.Value.Value);45 } else {46 qualityUpdateIntervalParam.Value = (TimeSpanValue)qualityUpdateIntervalParam.Value.AsReadOnly();47 }48 };49 } else {50 incrementalityParam.Value = (BoolValue)new BoolValue().AsReadOnly();51 }52 };53 39 } 54 40 … … 62 48 } 63 49 50 public override bool SupportsPause => ProblemType == ProblemType.LinearProgramming; // TODO: pause working for linear programs? 51 52 public override bool SupportsQualityUpdate => ProblemType == ProblemType.LinearProgramming; 53 64 54 protected override OptimizationProblemType OptimizationProblemType => 65 LinearProgrammingType == LinearProgrammingType.LinearProgramming66 ? OptimizationProblemType.G LPK_LINEAR_PROGRAMMING67 : OptimizationProblemType.G LPK_MIXED_INTEGER_PROGRAMMING;55 ProblemType == ProblemType.LinearProgramming 56 ? OptimizationProblemType.GlpkLinearProgramming 57 : OptimizationProblemType.GlpkMixedIntegerProgramming; 68 58 } 69 59 } -
branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GurobiSolver.cs
r16288 r16373 20 20 #endregion 21 21 22 using System; 22 23 using HeuristicLab.Common; 23 24 using HeuristicLab.Core; … … 36 37 Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName), 37 38 new FileValue { FileDialogFilter = FileDialogFilter, Value = Properties.Settings.Default.GurobiLibraryName })); 39 SolverSpecificParameters.Value = 40 "# for file format, see http://www.gurobi.com/documentation/8.1/refman/prm_format.html" + Environment.NewLine + 41 "# for parameters, see http://www.gurobi.com/documentation/8.1/refman/parameters.html" + Environment.NewLine + 42 "# example:" + Environment.NewLine + 43 "# Seed 10" + Environment.NewLine; 38 44 } 39 45 40 46 protected GurobiSolver(GurobiSolver original, Cloner cloner) 41 47 : base(original, cloner) { 42 pro grammingTypeParam = cloner.Clone(original.programmingTypeParam);48 problemTypeParam = cloner.Clone(original.problemTypeParam); 43 49 } 44 50 … … 48 54 } 49 55 50 public override bool SupportsPause => true;51 52 public override bool SupportsStop => true;53 54 56 protected override OptimizationProblemType OptimizationProblemType => 55 LinearProgrammingType == LinearProgrammingType.LinearProgramming56 ? OptimizationProblemType.G UROBI_LINEAR_PROGRAMMING57 : OptimizationProblemType.G UROBI_MIXED_INTEGER_PROGRAMMING;57 ProblemType == ProblemType.LinearProgramming 58 ? OptimizationProblemType.GurobiLinearProgramming 59 : OptimizationProblemType.GurobiMixedIntegerProgramming; 58 60 } 59 61 } -
branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/ScipSolver.cs
r16288 r16373 20 20 #endregion 21 21 22 using System; 23 using System.Threading; 22 24 using HeuristicLab.Common; 23 25 using HeuristicLab.Core; … … 31 33 [Item("SCIP", "SCIP (http://scip.zib.de/) must be installed and licenced.")] 32 34 [StorableClass] 33 public class ScipSolver : ExternalSolver { 35 public class ScipSolver : ExternalIncrementalSolver { 36 37 private TimeSpan timeLimit = TimeSpan.Zero; 34 38 35 39 public ScipSolver() { 36 40 Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName), 37 41 new FileValue { FileDialogFilter = FileDialogFilter, Value = Properties.Settings.Default.ScipLibraryName })); 38 programmingTypeParam.Value = 39 (EnumValue<LinearProgrammingType>)new EnumValue<LinearProgrammingType>(LinearProgrammingType 40 .MixedIntegerProgramming).AsReadOnly(); 42 problemTypeParam.Value = 43 (EnumValue<ProblemType>)new EnumValue<ProblemType>(ProblemType.MixedIntegerProgramming).AsReadOnly(); 44 SolverSpecificParameters.Value = 45 "# for file format and parameters, see https://scip.zib.de/doc/html/PARAMETERS.php" + Environment.NewLine + 46 "# example:" + Environment.NewLine + 47 "# branching/random/seed = 10" + Environment.NewLine; 41 48 } 42 49 … … 50 57 } 51 58 52 public override bool SupportsPause => true; 59 protected override OptimizationProblemType OptimizationProblemType => 60 OptimizationProblemType.ScipMixedIntegerProgramming; 61 protected override TimeSpan TimeLimit => timeLimit += QualityUpdateInterval; 53 62 54 public override bool SupportsStop => true;55 56 protected override OptimizationProblemType OptimizationProblemType =>57 OptimizationProblemType.SCIP_MIXED_INTEGER_PROGRAMMING;63 public override void Solve(LinearProgrammingAlgorithm algorithm, CancellationToken cancellationToken) { 64 timeLimit = TimeSpan.Zero; 65 base.Solve(algorithm, cancellationToken); 66 } 58 67 } 59 68 }
Note: See TracChangeset
for help on using the changeset viewer.