Changeset 16373


Ignore:
Timestamp:
12/12/18 14:23:45 (7 months ago)
Author:
ddorfmei
Message:

#2931:

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

Legend:

Unmodified
Added
Removed
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab 3.3.sln

    r16070 r16373  
    8686    {9D792B6D-836B-46DC-9D69-50B4B1E7B87F} = {9D792B6D-836B-46DC-9D69-50B4B1E7B87F}
    8787    {399EBB6E-37A1-4AE4-B8CD-0D461FF286A3} = {399EBB6E-37A1-4AE4-B8CD-0D461FF286A3}
     88    {FA3B9270-48B7-4C77-9FEA-2A6EDE82E909} = {FA3B9270-48B7-4C77-9FEA-2A6EDE82E909}
    8889    {3C906172-E044-4DF0-B4FD-AA21192D5D3E} = {3C906172-E044-4DF0-B4FD-AA21192D5D3E}
    8990    {DC3D7072-7999-4719-B65D-3997744D5DC1} = {DC3D7072-7999-4719-B65D-3997744D5DC1}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.Core/3.3/Attributes/CreatableAttribute.cs

    r15583 r16373  
    3535      public const string PopulationBasedAlgorithms = Algorithms + SplitToken + "1" + OrderToken + "Population Based";
    3636      public const string SingleSolutionAlgorithms = Algorithms + SplitToken + "2" + OrderToken + "Single Solution";
     37      public const string ExactAlgorithms = Algorithms + SplitToken + "3" + OrderToken + "Exact";
    3738
    3839      public const string Problems = "2" + OrderToken + "Problems";
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.Data.Views/3.3/HeuristicLab.Data.Views-3.3.csproj

    r16070 r16373  
    221221      <DependentUpon>StringConvertibleMatrixView.cs</DependentUpon>
    222222    </Compile>
     223    <Compile Include="TextValueView.cs">
     224      <SubType>UserControl</SubType>
     225    </Compile>
     226    <Compile Include="TextValueView.Designer.cs">
     227      <DependentUpon>TextValueView.cs</DependentUpon>
     228    </Compile>
    223229    <Compile Include="StringConvertibleValueView.cs">
    224230      <SubType>UserControl</SubType>
     
    290296      <Install>true</Install>
    291297    </BootstrapperPackage>
     298  </ItemGroup>
     299  <ItemGroup>
     300    <EmbeddedResource Include="TextValueView.resx">
     301      <DependentUpon>TextValueView.cs</DependentUpon>
     302    </EmbeddedResource>
    292303  </ItemGroup>
    293304  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.Data.Views/3.3/TextValueView.Designer.cs

    r16337 r16373  
    2121
    2222namespace HeuristicLab.Data.Views {
    23   partial class StringConvertibleValueView {
     23  partial class TextValueView {
    2424    /// <summary>
    2525    /// Required designer variable.
     
    5959      // valueTextBox
    6060      //
    61       this.valueTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
    62             | System.Windows.Forms.AnchorStyles.Right)));
    63       this.valueTextBox.Location = new System.Drawing.Point(17, 0);
     61      this.valueTextBox.Dock = System.Windows.Forms.DockStyle.Fill;
     62      this.valueTextBox.Location = new System.Drawing.Point(0, 0);
     63      this.valueTextBox.Multiline = true;
    6464      this.valueTextBox.Name = "valueTextBox";
    65       this.valueTextBox.Size = new System.Drawing.Size(132, 20);
     65      this.valueTextBox.ScrollBars = System.Windows.Forms.ScrollBars.Horizontal;
     66      this.valueTextBox.Size = new System.Drawing.Size(194, 40);
    6667      this.valueTextBox.TabIndex = 2;
    6768      this.valueTextBox.KeyDown += new System.Windows.Forms.KeyEventHandler(this.valueTextBox_KeyDown);
     
    9091      this.splitContainer.Location = new System.Drawing.Point(0, 0);
    9192      this.splitContainer.Name = "splitContainer";
     93      this.splitContainer.Orientation = System.Windows.Forms.Orientation.Horizontal;
    9294      //
    9395      // splitContainer.Panel1
    9496      //
    9597      this.splitContainer.Panel1.Controls.Add(this.valueLabel);
     98      this.splitContainer.Panel1MinSize = 19;
    9699      //
    97100      // splitContainer.Panel2
    98101      //
    99102      this.splitContainer.Panel2.Controls.Add(this.valueTextBox);
    100       this.splitContainer.Size = new System.Drawing.Size(194, 21);
    101       this.splitContainer.SplitterDistance = 41;
     103      this.splitContainer.Size = new System.Drawing.Size(194, 60);
     104      this.splitContainer.SplitterDistance = 19;
    102105      this.splitContainer.SplitterWidth = 1;
    103106      this.splitContainer.TabIndex = 0;
    104107      this.splitContainer.TabStop = false;
    105108      //
    106       // StringConvertibleValueView
     109      // TextValueView
    107110      //
    108       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
    109111      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
    110112      this.Controls.Add(this.splitContainer);
    111       this.Name = "StringConvertibleValueView";
    112       this.Size = new System.Drawing.Size(194, 21);
     113      this.Name = "TextValueView";
     114      this.Size = new System.Drawing.Size(194, 60);
    113115      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
    114116      this.splitContainer.Panel1.ResumeLayout(false);
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.Data.Views/3.3/TextValueView.cs

    r16337 r16373  
    2727
    2828namespace HeuristicLab.Data.Views {
    29   [View("StringConvertibleValue View")]
    30   [Content(typeof(IStringConvertibleValue), true)]
    31   public partial class StringConvertibleValueView : AsynchronousContentView {
     29  [View("TextValue View")]
     30  [Content(typeof(ITextValue), true)]
     31  public partial class TextValueView : AsynchronousContentView {
    3232    public new IStringConvertibleValue Content {
    3333      get { return (IStringConvertibleValue)base.Content; }
     
    4848    }
    4949
    50     public StringConvertibleValueView() {
     50    public TextValueView() {
    5151      InitializeComponent();
    5252      errorProvider.SetIconAlignment(valueTextBox, ErrorIconAlignment.MiddleLeft);
     
    8686
    8787    protected virtual void valueTextBox_KeyDown(object sender, KeyEventArgs e) {
    88       if ((e.KeyCode == Keys.Enter) || (e.KeyCode == Keys.Return))
     88      if (e.Shift && (e.KeyCode == Keys.Enter || e.KeyCode == Keys.Return))
    8989        valueLabel.Select();  // select label to validate data
    9090
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.Data/3.3/HeuristicLab.Data-3.3.csproj

    r16070 r16373  
    124124    <Compile Include="ComparisonType.cs" />
    125125    <Compile Include="EnumValue.cs" />
     126    <Compile Include="Interfaces\ITextValue.cs" />
    126127    <Compile Include="Interfaces\IValueTypeArray.cs" />
    127128    <Compile Include="Path Types\DirectoryValue.cs" />
     
    151152    <Compile Include="StringConvertibleArray.cs" />
    152153    <Compile Include="StringMatrix.cs" />
     154    <Compile Include="TextValue.cs" />
    153155    <Compile Include="StringValue.cs" />
    154156    <Compile Include="TimeSpanValue.cs" />
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.Data/3.3/Interfaces/ITextValue.cs

    r16337 r16373  
    2424
    2525namespace HeuristicLab.Data {
    26   public interface IStringConvertibleValue : IContent {
    27     bool ReadOnly { get; }
    28 
    29     bool Validate(string value, out string errorMessage);
    30     string GetValue();
    31     bool SetValue(string value);
    32 
    33     event EventHandler ValueChanged;
     26  public interface ITextValue : IStringConvertibleValue {
    3427  }
    3528}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.Data/3.3/TextValue.cs

    r16337 r16373  
    2020#endregion
    2121
    22 using System;
    23 using System.Drawing;
    2422using HeuristicLab.Common;
    2523using HeuristicLab.Core;
     
    2725
    2826namespace HeuristicLab.Data {
    29   [Item("StringValue", "Represents a string.")]
     27  [Item("TextValue", "Represents a multiline string.")]
    3028  [StorableClass]
    31   public class StringValue : Item, IComparable, IStringConvertibleValue {
    32     public static new Image StaticItemImage {
    33       get { return HeuristicLab.Common.Resources.VSImageLibrary.Field; }
     29  public class TextValue : StringValue, ITextValue {
     30
     31    public TextValue() {
     32      this.value = string.Empty;
     33      this.readOnly = false;
    3434    }
    3535
    36     [Storable]
    37     protected string value;
    38     public virtual string Value {
    39       get { return value; }
    40       set {
    41         if (ReadOnly) throw new NotSupportedException("Value cannot be set. StringValue is read-only.");
    42         if (value != this.value) {
    43           if ((value != null) || (this.value != string.Empty)) {
    44             this.value = value != null ? value : string.Empty;
    45             OnValueChanged();
    46           }
    47         }
    48       }
    49     }
    50 
    51     [Storable]
    52     protected bool readOnly;
    53     public virtual bool ReadOnly {
    54       get { return readOnly; }
     36    public TextValue(string value) {
     37      this.value = value ?? string.Empty;
     38      this.readOnly = false;
    5539    }
    5640
    5741    [StorableConstructor]
    58     protected StringValue(bool deserializing) : base(deserializing) { }
    59     protected StringValue(StringValue original, Cloner cloner)
     42    protected TextValue(bool deserializing) : base(deserializing) { }
     43
     44    protected TextValue(TextValue original, Cloner cloner)
    6045      : base(original, cloner) {
    61       this.value = original.value != null ? original.value : string.Empty;
     46      this.value = original.value ?? string.Empty;
    6247      this.readOnly = original.readOnly;
    63     }
    64     public StringValue() {
    65       this.value = string.Empty;
    66       this.readOnly = false;
    67     }
    68     public StringValue(string value) {
    69       this.value = value != null ? value : string.Empty;
    70       this.readOnly = false;
    7148    }
    7249
    7350    public override IDeepCloneable Clone(Cloner cloner) {
    74       return new StringValue(this, cloner);
     51      return new TextValue(this, cloner);
    7552    }
    76 
    77     public virtual StringValue AsReadOnly() {
    78       StringValue readOnlyStringValue = (StringValue)this.Clone();
    79       readOnlyStringValue.readOnly = true;
    80       return readOnlyStringValue;
    81     }
    82 
    83     public override string ToString() {
    84       return value;
    85     }
    86 
    87     public virtual int CompareTo(object obj) {
    88       StringValue other = obj as StringValue;
    89       if (other != null)
    90         return Value.CompareTo(other.Value);
    91       else
    92         return Value.CompareTo(obj);
    93     }
    94 
    95     public event EventHandler ValueChanged;
    96     protected virtual void OnValueChanged() {
    97       if (ValueChanged != null)
    98         ValueChanged(this, EventArgs.Empty);
    99       OnToStringChanged();
    100     }
    101 
    102     protected virtual bool Validate(string value, out string errorMessage) {
    103       if (value == null) {
    104         errorMessage = "Invalid Value (string must not be null)";
    105         return false;
    106       } else {
    107         errorMessage = string.Empty;
    108         return true;
    109       }
    110     }
    111     protected virtual string GetValue() {
    112       return Value;
    113     }
    114     protected virtual bool SetValue(string value) {
    115       if (value != null) {
    116         Value = value;
    117         return true;
    118       } else {
    119         return false;
    120       }
    121     }
    122 
    123     #region IStringConvertibleValue Members
    124     bool IStringConvertibleValue.Validate(string value, out string errorMessage) {
    125       return Validate(value, out errorMessage);
    126     }
    127     string IStringConvertibleValue.GetValue() {
    128       return GetValue();
    129     }
    130     bool IStringConvertibleValue.SetValue(string value) {
    131       return SetValue(value);
    132     }
    133     #endregion
    13453  }
    13554}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.ExtLibs.sln

    r16172 r16373  
    7575Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.IGraph-0.8.0-pre", "HeuristicLab.ExtLibs\HeuristicLab.Igraph\0.8.0-pre\HeuristicLab.Igraph-0.8.0-pre\HeuristicLab.IGraph-0.8.0-pre.csproj", "{088D34F2-32EA-43FF-BAA8-22428D5B66BE}"
    7676EndProject
    77 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.OrTools-6.9.0-pre", "HeuristicLab.ExtLibs\HeuristicLab.OrTools\6.9.0-pre\HeuristicLab.OrTools-6.9.0-pre\HeuristicLab.OrTools-6.9.0-pre.csproj", "{AEC895BC-C519-49D3-9A94-6B1C71AD6671}"
     77Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.OrTools-6.10.0", "HeuristicLab.ExtLibs\HeuristicLab.OrTools\6.10.0\HeuristicLab.OrTools-6.10.0\HeuristicLab.OrTools-6.10.0.csproj", "{AEC895BC-C519-49D3-9A94-6B1C71AD6671}"
    7878EndProject
    7979Global
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.ExtLibs/HeuristicLab.OrTools/6.10.0/HeuristicLab.OrTools-6.10.0/HeuristicLab.OrTools-6.10.0.csproj

    r16368 r16373  
    99    <AppDesignerFolder>Properties</AppDesignerFolder>
    1010    <RootNamespace>HeuristicLab.OrTools</RootNamespace>
    11     <AssemblyName>HeuristicLab.OrTools-6.9.0-pre</AssemblyName>
     11    <AssemblyName>HeuristicLab.OrTools-6.10.0</AssemblyName>
    1212    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
    1313    <FileAlignment>512</FileAlignment>
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.ExtLibs/HeuristicLab.OrTools/6.10.0/HeuristicLab.OrTools-6.10.0/Plugin.cs.frame

    r16288 r16373  
    2828namespace HeuristicLab.OrTools {
    2929
    30   [Plugin("HeuristicLab.OrTools", "Provides functionality of Google OR-Tools in HeuristicLab. Requires Windows 64-bit", "6.9.0.$WCREV$")]
    31   [PluginFile("HeuristicLab.OrTools-6.9.0-pre.dll", PluginFileType.Assembly)]
     30  [Plugin("HeuristicLab.OrTools", "Provides functionality of Google OR-Tools in HeuristicLab. Requires Windows 64-bit", "6.10.0.$WCREV$")]
     31  [PluginFile("HeuristicLab.OrTools-6.10.0.dll", PluginFileType.Assembly)]
    3232  [PluginFile("Google.OrTools.dll", PluginFileType.Assembly)]
    3333  [PluginFile("Google.OrTools-license.txt", PluginFileType.License)]
     
    4040
    4141    ~HeuristicLabOrToolsPlugin() {
    42       OnUnload(); // HACK: remove once ticket #2961 is solved
     42      OnUnload(); // HACK: remove once ticket #2961 is resolved
    4343    }
    4444
     
    4646      base.OnUnload();
    4747
    48       var thisClass = typeof(HeuristicLabOrToolsPlugin);
    49       var dir = new FileInfo(thisClass.Assembly.Location).Directory;
    50       if (dir == null)
     48      var dllDir = new FileInfo(GetType().Assembly.Location).Directory;
     49      if (dllDir == null)
    5150        return;
    5251
    53       var nativeDlls = thisClass.GetCustomAttributes(typeof(PluginFileAttribute), true)
     52      var nativeDlls = GetType().GetCustomAttributes(typeof(PluginFileAttribute), true)
    5453        .Cast<PluginFileAttribute>()
    5554        .Where(pf => pf.FileType == PluginFileType.NativeDll)
    5655        .Select(pf => pf.FileName);
    5756
    58       foreach (var nativeDll in dir.EnumerateFiles().Where(f => nativeDlls.Contains(f.Name))) {
     57      foreach (var nativeDll in dllDir.EnumerateFiles().Where(f => nativeDlls.Contains(f.Name))) {
    5958        var handle = LoadLibrary(nativeDll.FullName);
    6059        if (handle == IntPtr.Zero)
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.ExtLibs/HeuristicLab.OrTools/6.10.0/HeuristicLab.OrTools-6.10.0/Properties/AssemblyInfo.cs.frame

    r16070 r16373  
    5353// by using the '*' as shown below:
    5454// [assembly: AssemblyVersion("1.0.*")]
    55 [assembly: AssemblyVersion("6.8.0.0")]
    56 [assembly: AssemblyFileVersion("6.8.0.$WCREV$")]
     55[assembly: AssemblyVersion("6.10.0.0")]
     56[assembly: AssemblyFileVersion("6.10.0.$WCREV$")]
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/HeuristicLab.MathematicalOptimization-3.3.csproj

    r16288 r16373  
    115115      <HintPath>..\..\bin\Google.OrTools.dll</HintPath>
    116116    </Reference>
    117     <Reference Include="HeuristicLab.OrTools-6.9.0-pre, Version=6.8.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
     117    <Reference Include="HeuristicLab.OrTools-6.10.0, Version=6.10.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    118118      <SpecificVersion>False</SpecificVersion>
    119       <HintPath>..\..\bin\HeuristicLab.OrTools-6.9.0-pre.dll</HintPath>
     119      <HintPath>..\..\bin\HeuristicLab.OrTools-6.10.0.dll</HintPath>
    120120    </Reference>
    121121    <Reference Include="System" />
     
    136136    <Compile Include="LinearProgramming\Algorithms\Solvers\Base\ExternalIncrementalSolver.cs" />
    137137    <Compile Include="LinearProgramming\Algorithms\Solvers\Base\IncrementalSolver.cs" />
    138     <Compile Include="LinearProgramming\Algorithms\LinearProgrammingType.cs" />
     138    <Compile Include="LinearProgramming\Algorithms\ProblemType.cs" />
    139139    <Compile Include="LinearProgramming\Algorithms\Solvers\ScipSolver.cs" />
    140     <Compile Include="LinearProgramming\BasisStatus.cs" />
     140    <Compile Include="LinearProgramming\Wrapper\BasisStatus.cs" />
    141141    <Compile Include="LinearProgramming\Algorithms\Solvers\CplexSolver.cs" />
    142142    <Compile Include="LinearProgramming\Algorithms\Solvers\GurobiSolver.cs" />
    143143    <Compile Include="LinearProgramming\Algorithms\Solvers\Base\ISolver.cs" />
    144     <Compile Include="LinearProgramming\IncrementalityValues.cs" />
    145     <Compile Include="LinearProgramming\IntegerParam.cs" />
    146     <Compile Include="LinearProgramming\LpAlgorithmValues.cs" />
     144    <Compile Include="LinearProgramming\Wrapper\IncrementalityValues.cs" />
     145    <Compile Include="LinearProgramming\Wrapper\IntegerParam.cs" />
     146    <Compile Include="LinearProgramming\Wrapper\LpAlgorithmValues.cs" />
    147147    <Compile Include="LinearProgramming\Problems\ILinearProgrammingProblemDefinition.cs" />
    148148    <Compile Include="LinearProgramming\Algorithms\LinearProgrammingAlgorithm.cs" />
    149149    <Compile Include="LinearProgramming\Problems\LinearProgrammingProblem.cs" />
    150     <Compile Include="LinearProgramming\LinearSolverExtensions.cs" />
    151     <Compile Include="LinearProgramming\LinearSolver.cs" />
     150    <Compile Include="LinearProgramming\Wrapper\LinearSolverExtensions.cs" />
     151    <Compile Include="LinearProgramming\Wrapper\LinearSolver.cs" />
    152152    <Compile Include="LinearProgramming\Problems\LinearProgrammingProblemDefintion.cs" />
    153     <Compile Include="LinearProgramming\OptimizationProblemType.cs" />
     153    <Compile Include="LinearProgramming\Wrapper\OptimizationProblemType.cs" />
    154154    <Compile Include="LinearProgramming\Problems\ProblemDefinitionScriptException.cs" />
    155155    <Compile Include="LinearProgramming\Algorithms\Solvers\Base\Solver.cs" />
    156     <Compile Include="LinearProgramming\DoubleParam.cs" />
     156    <Compile Include="LinearProgramming\Wrapper\DoubleParam.cs" />
    157157    <Compile Include="LinearProgramming\Views\LinearProgrammingProblemDefinitionScriptView.cs">
    158158      <SubType>UserControl</SubType>
     
    161161      <DependentUpon>LinearProgrammingProblemDefinitionScriptView.cs</DependentUpon>
    162162    </Compile>
    163     <Compile Include="LinearProgramming\ResultStatus.cs" />
     163    <Compile Include="LinearProgramming\Wrapper\ProtoWriteFormat.cs" />
     164    <Compile Include="LinearProgramming\Wrapper\ResultStatus.cs" />
    164165    <Compile Include="LinearProgramming\Views\LinearProgrammingProblemView.cs">
    165166      <SubType>UserControl</SubType>
     
    175176      <DependentUpon>ScriptTemplates.resx</DependentUpon>
    176177    </Compile>
     178    <Compile Include="LinearProgramming\Wrapper\SolverResponseStatus.cs" />
    177179    <Compile Include="Properties\AssemblyInfo.cs" />
    178180    <Compile Include="Properties\Settings.Designer.cs">
     
    181183      <DependentUpon>Settings.settings</DependentUpon>
    182184    </Compile>
    183     <None Include="app.config" />
     185    <None Include="app.config">
     186      <SubType>Designer</SubType>
     187    </None>
    184188    <None Include="Plugin.cs.frame" />
    185189    <Compile Include="Plugin.cs" />
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/LinearProgrammingAlgorithm.cs

    r16288 r16373  
    3535namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
    3636
    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)]
    3940  [StorableClass]
    4041  public class LinearProgrammingAlgorithm : BasicAlgorithm {
     
    5354
    5455    [Storable]
    55     private readonly IFixedValueParameter<DoubleValue> relativeGapToleranceParam;
     56    private readonly IFixedValueParameter<PercentValue> relativeGapToleranceParam;
    5657
    5758    [Storable]
     
    6566
    6667    public IConstrainedValueParameter<ISolver> SolverParameter {
    67       get { return solverParam; }
    68       set { solverParam = value; }
     68      get => solverParam;
     69      set => solverParam = value;
    6970    }
    7071
     
    7273      Parameters.Add(solverParam =
    7374        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)));
    7688      Parameters.Add(timeLimitParam = new FixedValueParameter<TimeSpanValue>(nameof(TimeLimit),
    7789        "Limit for runtime. Set to zero for unlimited runtime.", new TimeSpanValue()));
     
    92104
    93105      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());
    102106    }
    103107
     
    176180    public override void Pause() {
    177181      base.Pause();
    178       Solver.Interrupt();
     182      Solver.InterruptSolve();
    179183    }
    180184
     
    190194    public override void Stop() {
    191195      base.Stop();
    192       Solver.Interrupt();
    193     }
    194 
    195     protected override void Initialize(CancellationToken cancellationToken) {
    196       base.Initialize(cancellationToken);
     196      Solver.InterruptSolve();
    197197    }
    198198
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/ProblemType.cs

    r16372 r16373  
    2222namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms {
    2323
    24   public enum LinearProgrammingType {
     24  public enum ProblemType {
    2525    LinearProgramming,
    2626    MixedIntegerProgramming
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IIncrementalSolver.cs

    r16288 r16373  
    2525
    2626  public interface IIncrementalSolver : ISolver {
    27     bool Incrementality { get; set; }
    2827    TimeSpan QualityUpdateInterval { get; set; }
     28    bool SupportsQualityUpdate { get; }
    2929  }
    3030}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/ISolver.cs

    r16288 r16373  
    2626
    2727  public interface ISolver : IParameterizedNamedItem {
    28     LinearProgrammingType LinearProgrammingType { get; set; }
     28    ProblemType ProblemType { get; set; }
    2929    bool SupportsPause { get; }
    3030    bool SupportsStop { get; }
    3131
    32     void Interrupt();
     32    bool InterruptSolve();
    3333
    3434    void Reset();
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/IncrementalSolver.cs

    r16288 r16373  
    2323using System.Linq;
    2424using System.Threading;
    25 using Google.OrTools.LinearSolver;
    2625using HeuristicLab.Analysis;
    2726using HeuristicLab.Common;
     
    3534  [StorableClass]
    3635  public class IncrementalSolver : Solver, IIncrementalSolver {
    37 
    38     [Storable]
    39     protected readonly IValueParameter<BoolValue> incrementalityParam;
    4036
    4137    [Storable]
     
    5551
    5652    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)));
    6053      Parameters.Add(qualityUpdateIntervalParam =
    6154        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          }
    6862        } else {
    69           qualityUpdateIntervalParam.Value = (TimeSpanValue)qualityUpdateIntervalParam.Value.AsReadOnly();
     63          Parameters.Remove(qualityUpdateIntervalParam);
    7064        }
    7165      };
     
    7468    protected IncrementalSolver(IncrementalSolver original, Cloner cloner)
    7569        : base(original, cloner) {
    76       programmingTypeParam = cloner.Clone(original.programmingTypeParam);
     70      problemTypeParam = cloner.Clone(original.problemTypeParam);
    7771      qualityUpdateIntervalParam = cloner.Clone(original.qualityUpdateIntervalParam);
    78       incrementalityParam = cloner.Clone(original.incrementalityParam);
    7972      if (original.qualityPerClock != null)
    8073        qualityPerClock = cloner.Clone(original.qualityPerClock);
    8174    }
    8275
    83     public bool Incrementality {
    84       get => incrementalityParam.Value.Value;
    85       set => incrementalityParam.Value.Value = value;
    86     }
     76    public virtual bool SupportsQualityUpdate => true;
    8777
    8878    public TimeSpan QualityUpdateInterval {
     
    9181    }
    9282
     83    protected virtual TimeSpan TimeLimit => QualityUpdateInterval;
     84
    9385    public override void Solve(LinearProgrammingAlgorithm algorithm, CancellationToken cancellationToken) {
    94       if (!Incrementality) {
     86      if (!SupportsQualityUpdate || QualityUpdateInterval == TimeSpan.Zero) {
    9587        base.Solve(algorithm, cancellationToken);
    9688        return;
     
    10193
    10294      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;
    10796      }
    10897
    10998      var iterations = (long)timeLimit.TotalMilliseconds / (long)QualityUpdateInterval.TotalMilliseconds;
    11099      var remaining = timeLimit - TimeSpan.FromMilliseconds(iterations * QualityUpdateInterval.TotalMilliseconds);
    111       var validResultStatuses = new[] { ResultStatus.NOT_SOLVED, ResultStatus.FEASIBLE };
     100      var validResultStatuses = new[] { ResultStatus.NotSolved, ResultStatus.Feasible };
    112101
    113102      while (unlimitedRuntime || iterations > 0) {
    114         base.Solve(algorithm, QualityUpdateInterval, true);
     103        if (cancellationToken.IsCancellationRequested)
     104          return;
     105
     106        base.Solve(algorithm, TimeLimit);
    115107        UpdateQuality(algorithm);
    116108
    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))
    119111          return;
    120112
     
    124116
    125117      if (remaining > TimeSpan.Zero) {
    126         base.Solve(algorithm, remaining, true);
     118        base.Solve(algorithm, remaining);
    127119        UpdateQuality(algorithm);
    128120      }
     
    132124      if (!algorithm.Results.Exists(r => r.Name == "QualityPerClock")) {
    133125        qualityPerClock = new IndexedDataTable<double>("Quality per Clock");
    134         qpcRow = new IndexedDataRow<double>("First-hit Graph Objective");
    135         bpcRow = new IndexedDataRow<double>("First-hit Graph Bound");
     126        qpcRow = new IndexedDataRow<double>("Objective Value");
     127        bpcRow = new IndexedDataRow<double>("Bound");
    136128        algorithm.Results.AddOrUpdateResult("QualityPerClock", qualityPerClock);
    137129      }
    138130
    139       var resultStatus = ((EnumValue<ResultStatus>)algorithm.Results["Result Status"].Value).Value;
     131      var resultStatus = ((EnumValue<ResultStatus>)algorithm.Results[nameof(solver.ResultStatus)].Value).Value;
    140132
    141       if (new[] { ResultStatus.ABNORMAL, ResultStatus.NOT_SOLVED, ResultStatus.UNBOUNDED }.Contains(resultStatus))
     133      if (new[] { ResultStatus.Abnormal, ResultStatus.NotSolved, ResultStatus.Unbounded }.Contains(resultStatus))
    142134        return;
    143135
    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;
    146138      var time = algorithm.ExecutionTime.TotalSeconds;
    147139
     
    151143          qpcRow.Values.Add(Tuple.Create(time, objective));
    152144          qualityPerClock.Rows.Add(qpcRow);
    153           algorithm.Results.AddOrUpdateResult("Best Solution Found At", new TimeSpanValue(TimeSpan.FromSeconds(time)));
     145          algorithm.Results.AddOrUpdateResult($"Best{nameof(solver.ObjectiveValue)}FoundAt", new TimeSpanValue(TimeSpan.FromSeconds(time)));
    154146        }
    155147      } else {
     
    158150        if (!objective.IsAlmost(previousBest)) {
    159151          qpcRow.Values.Add(Tuple.Create(time, objective));
    160           algorithm.Results.AddOrUpdateResult("Best Solution Found At", new TimeSpanValue(TimeSpan.FromSeconds(time)));
     152          algorithm.Results.AddOrUpdateResult($"Best{nameof(solver.ObjectiveValue)}FoundAt", new TimeSpanValue(TimeSpan.FromSeconds(time)));
    161153        }
    162154      }
     155
     156      if (!solver.IsMip)
     157        return;
    163158
    164159      if (!bpcRow.Values.Any()) {
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/Base/Solver.cs

    r16288 r16373  
    3434
    3535    [Storable]
    36     protected IValueParameter<EnumValue<LinearProgrammingType>> programmingTypeParam;
     36    protected IValueParameter<EnumValue<ProblemType>> problemTypeParam;
    3737
    3838    protected LinearSolver solver;
    3939
     40    [Storable]
     41    protected IFixedValueParameter<TextValue> solverSpecificParametersParam;
     42
    4043    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()));
    4448    }
    4549
     
    5155    protected Solver(Solver original, Cloner cloner)
    5256      : base(original, cloner) {
    53       programmingTypeParam = cloner.Clone(original.programmingTypeParam);
     57      problemTypeParam = cloner.Clone(original.problemTypeParam);
     58      solverSpecificParametersParam = cloner.Clone(original.solverSpecificParametersParam);
    5459    }
    5560
    56     public LinearProgrammingType LinearProgrammingType {
    57       get => programmingTypeParam.Value.Value;
    58       set => programmingTypeParam.Value.Value = value;
     61    public ProblemType ProblemType {
     62      get => problemTypeParam.Value.Value;
     63      set => problemTypeParam.Value.Value = value;
    5964    }
    6065
     66    public TextValue SolverSpecificParameters => solverSpecificParametersParam.Value;
     67
     68    public virtual bool SupportsPause => true;
     69    public virtual bool SupportsStop => true;
    6170    protected virtual OptimizationProblemType OptimizationProblemType { get; }
    62     public virtual bool SupportsPause => false;
    63     public virtual bool SupportsStop => false;
    6471
    6572    public override IDeepCloneable Clone(Cloner cloner) => new Solver(this, cloner);
     
    6774    public void Dispose() => solver?.Dispose();
    6875
    69     public void Interrupt() => solver.Stop();
     76    public bool InterruptSolve() => solver?.InterruptSolve() ?? false;
    7077
    7178    public virtual void Reset() {
     
    7885
    7986    public virtual void Solve(LinearProgrammingAlgorithm algorithm) =>
    80       Solve(algorithm, algorithm.TimeLimit, false);
     87      Solve(algorithm, algorithm.TimeLimit);
    8188
    82     public virtual void Solve(LinearProgrammingAlgorithm algorithm, TimeSpan timeLimit, bool incrementality) {
     89    public virtual void Solve(LinearProgrammingAlgorithm algorithm, TimeSpan timeLimit) {
    8390      string libraryName = null;
    8491      if (this is IExternalSolver externalSolver)
     
    8693
    8794      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);
    9097      }
    9198
     
    97104      solver.Scaling = algorithm.Scaling;
    98105      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.");
    100110
    101111      solver.Solve();
    102112
    103113      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)}",
    106117        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));
    117137    }
    118138  }
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/BopSolver.cs

    r16288 r16373  
    2020#endregion
    2121
     22using System;
    2223using HeuristicLab.Common;
    2324using HeuristicLab.Core;
     25using HeuristicLab.Data;
    2426using HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base;
     27using HeuristicLab.Parameters;
    2528using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2629
     
    3235
    3336    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;
    3544    }
    3645
     
    4453    }
    4554
    46     public override bool SupportsPause => true;
    47 
    48     public override bool SupportsStop => true;
    49 
    5055    protected override OptimizationProblemType OptimizationProblemType =>
    51               OptimizationProblemType.BOP_INTEGER_PROGRAMMING;
     56               OptimizationProblemType.BopIntegerProgramming;
    5257  }
    5358}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/CoinOrSolver.cs

    r16288 r16373  
    2222using HeuristicLab.Common;
    2323using HeuristicLab.Core;
    24 using HeuristicLab.Data;
    2524using HeuristicLab.MathematicalOptimization.LinearProgramming.Algorithms.Solvers.Base;
    2625using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     
    3332
    3433    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);
    4935    }
    5036
     
    5844    }
    5945
     46    public override bool SupportsPause => false;
     47
     48    public override bool SupportsQualityUpdate => ProblemType == ProblemType.LinearProgramming;
     49
     50    public override bool SupportsStop => false;
     51
    6052    protected override OptimizationProblemType OptimizationProblemType =>
    61       LinearProgrammingType == LinearProgrammingType.LinearProgramming
    62         ? OptimizationProblemType.CLP_LINEAR_PROGRAMMING
    63         : OptimizationProblemType.CBC_MIXED_INTEGER_PROGRAMMING;
     53      ProblemType == ProblemType.LinearProgramming
     54        ? OptimizationProblemType.ClpLinearProgramming
     55        : OptimizationProblemType.CbcMixedIntegerProgramming;
    6456  }
    6557}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/CplexSolver.cs

    r16288 r16373  
    2020#endregion
    2121
     22using System;
    2223using HeuristicLab.Common;
    2324using HeuristicLab.Core;
     
    3637      Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName),
    3738        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;
    3845    }
    3946
     
    4855
    4956    protected override OptimizationProblemType OptimizationProblemType =>
    50       LinearProgrammingType == LinearProgrammingType.LinearProgramming
    51         ? OptimizationProblemType.CPLEX_LINEAR_PROGRAMMING
    52         : OptimizationProblemType.CPLEX_MIXED_INTEGER_PROGRAMMING;
     57      ProblemType == ProblemType.LinearProgramming
     58        ? OptimizationProblemType.CplexLinearProgramming
     59        : OptimizationProblemType.CplexMixedIntegerProgramming;
    5360  }
    5461}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GlopSolver.cs

    r16288 r16373  
    2020#endregion
    2121
     22using System;
    2223using HeuristicLab.Common;
    2324using HeuristicLab.Core;
     
    3334
    3435    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;
    3642    }
    3743
     
    4551    }
    4652
    47     public override bool SupportsPause => true;
    48 
    49     public override bool SupportsStop => true;
    50 
    5153    protected override OptimizationProblemType OptimizationProblemType =>
    52               OptimizationProblemType.GLOP_LINEAR_PROGRAMMING;
     54      OptimizationProblemType.GlopLinearProgramming;
    5355  }
    5456}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GlpkSolver.cs

    r16288 r16373  
    3434
    3535    public GlpkSolver() {
     36      Parameters.Remove(solverSpecificParametersParam);
    3637      Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName),
    3738        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       };
    5339    }
    5440
     
    6248    }
    6349
     50    public override bool SupportsPause => ProblemType == ProblemType.LinearProgramming; // TODO: pause working for linear programs?
     51
     52    public override bool SupportsQualityUpdate => ProblemType == ProblemType.LinearProgramming;
     53
    6454    protected override OptimizationProblemType OptimizationProblemType =>
    65       LinearProgrammingType == LinearProgrammingType.LinearProgramming
    66         ? OptimizationProblemType.GLPK_LINEAR_PROGRAMMING
    67         : OptimizationProblemType.GLPK_MIXED_INTEGER_PROGRAMMING;
     55      ProblemType == ProblemType.LinearProgramming
     56        ? OptimizationProblemType.GlpkLinearProgramming
     57        : OptimizationProblemType.GlpkMixedIntegerProgramming;
    6858  }
    6959}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/GurobiSolver.cs

    r16288 r16373  
    2020#endregion
    2121
     22using System;
    2223using HeuristicLab.Common;
    2324using HeuristicLab.Core;
     
    3637      Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName),
    3738        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;
    3844    }
    3945
    4046    protected GurobiSolver(GurobiSolver original, Cloner cloner)
    4147          : base(original, cloner) {
    42       programmingTypeParam = cloner.Clone(original.programmingTypeParam);
     48      problemTypeParam = cloner.Clone(original.problemTypeParam);
    4349    }
    4450
     
    4854    }
    4955
    50     public override bool SupportsPause => true;
    51 
    52     public override bool SupportsStop => true;
    53 
    5456    protected override OptimizationProblemType OptimizationProblemType =>
    55               LinearProgrammingType == LinearProgrammingType.LinearProgramming
    56         ? OptimizationProblemType.GUROBI_LINEAR_PROGRAMMING
    57         : OptimizationProblemType.GUROBI_MIXED_INTEGER_PROGRAMMING;
     57      ProblemType == ProblemType.LinearProgramming
     58        ? OptimizationProblemType.GurobiLinearProgramming
     59        : OptimizationProblemType.GurobiMixedIntegerProgramming;
    5860  }
    5961}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Algorithms/Solvers/ScipSolver.cs

    r16288 r16373  
    2020#endregion
    2121
     22using System;
     23using System.Threading;
    2224using HeuristicLab.Common;
    2325using HeuristicLab.Core;
     
    3133  [Item("SCIP", "SCIP (http://scip.zib.de/) must be installed and licenced.")]
    3234  [StorableClass]
    33   public class ScipSolver : ExternalSolver {
     35  public class ScipSolver : ExternalIncrementalSolver {
     36
     37    private TimeSpan timeLimit = TimeSpan.Zero;
    3438
    3539    public ScipSolver() {
    3640      Parameters.Add(libraryNameParam = new FixedValueParameter<FileValue>(nameof(LibraryName),
    3741        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;
    4148    }
    4249
     
    5057    }
    5158
    52     public override bool SupportsPause => true;
     59    protected override OptimizationProblemType OptimizationProblemType =>
     60      OptimizationProblemType.ScipMixedIntegerProgramming;
     61    protected override TimeSpan TimeLimit => timeLimit += QualityUpdateInterval;
    5362
    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    }
    5867  }
    5968}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/ILinearProgrammingProblemDefinition.cs

    r16288 r16373  
    2727  public interface ILinearProgrammingProblemDefinition {
    2828
    29     void BuildModel(Solver solver);
     29    bool BuildModel(Solver solver);
    3030
    3131    void Analyze(Solver solver, ResultCollection results);
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/LinearProgrammingProblem.cs

    r16288 r16373  
    2121
    2222using System.Drawing;
    23 using Google.OrTools.LinearSolver;
    2423using HeuristicLab.Common;
    2524using HeuristicLab.Common.Resources;
     
    3130namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Problems {
    3231
    33   [Item("Linear/Mixed Integer Programming Problem (LP/MIP)", "")]
     32  [Item("Linear/Mixed Integer Programming Problem (LP/MIP)", "Represents a linear/mixed integer problem.")]
    3433  [Creatable(CreatableAttribute.Categories.CombinatorialProblems)]
    3534  [StorableClass]
     
    5655    private FixedValueParameter<LinearProgrammingProblemDefinitionScript> LinearProgrammingProblemScriptParameter =>
    5756      (FixedValueParameter<LinearProgrammingProblemDefinitionScript>)Parameters["ProblemScript"];
    58 
    59     public void BuildModel(Solver solver) => ProblemDefinition.BuildModel(solver);
    6057
    6158    public override IDeepCloneable Clone(Cloner cloner) {
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Problems/LinearProgrammingProblemDefinitionScript.cs

    r16288 r16373  
    3333namespace HeuristicLab.MathematicalOptimization.LinearProgramming.Problems {
    3434
    35   [Item("Single-objective Problem Definition Script", "Script that defines the parameter vector and evaluates the solution for a programmable problem.")]
     35  [Item("Linear/Mixed Integer Programming Problem Definition Script", "Script that defines the model and evaluates the solution for a linear/mixed integer programming problem.")]
    3636  [StorableClass]
    3737  public sealed class LinearProgrammingProblemDefinitionScript : Script, ILinearProgrammingProblemDefinition, IStorableContent {
     
    144144    }
    145145
    146     public void BuildModel(Solver solver) => CompiledProblemDefinition.BuildModel(solver);
     146    public bool BuildModel(Solver solver) => CompiledProblemDefinition.BuildModel(solver);
    147147
    148148    public void Analyze(Solver solver, ResultCollection results) => CompiledProblemDefinition.Analyze(solver, results);
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Templates/CompiledLinearProgrammingProblemDefinition.cs

    r16288 r16373  
    1616    private Variable x;
    1717    private Variable y;
    18    
     18
    1919    public override void Initialize() {
    2020      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
    2121      // Add additional initialization code e.g. private variables that you need for evaluating
    2222    }
    23    
    24     public void BuildModel(Solver solver) {
     23
     24    public bool BuildModel(Solver solver) {
    2525      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
    2626      // Example model taken from https://developers.google.com/optimization/mip/integer_opt
     
    3232      // Define the objective
    3333      solver.Maximize(x + 10 * y);
     34      return true;
    3435    }
    35    
     36
    3637    public void Analyze(Solver solver, ResultCollection results) {
    3738      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
     
    4344      //results.AddOrUpdateResult("y", new DoubleValue(solver.LookupVariableOrNull("y").SolutionValue()));
    4445    }
    45    
     46
    4647    // Implement further classes and methods
    4748  }
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Wrapper/DoubleParam.cs

    r16372 r16373  
    2626
    2727    // Limit for relative MIP gap.
    28     RELATIVE_MIP_GAP = 0,
     28    RelativeMipGap = 0,
    2929
    3030    // Advanced usage: tolerance for primal feasibility of basic
     
    3232    // tolerance of integer solutions for MIP or the tolerance used
    3333    // during presolve.
    34     PRIMAL_TOLERANCE = 1,
     34    PrimalTolerance = 1,
    3535
    3636    // Advanced usage: tolerance for dual feasibility of basic solutions.
    37     DUAL_TOLERANCE = 2
    38   };
     37    DualTolerance = 2
     38  }
    3939}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Wrapper/IncrementalityValues.cs

    r16372 r16373  
    2525
    2626    // Start solve from scratch.
    27     INCREMENTALITY_OFF = 0,
     27    IncrementalityOff = 0,
    2828
    2929    // Reuse results from previous solve as much as the underlying
    3030    // solver allows.
    31     INCREMENTALITY_ON = 1
    32   };
     31    IncrementalityOn = 1
     32  }
    3333}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Wrapper/IntegerParam.cs

    r16372 r16373  
    2626
    2727    // Advanced usage: presolve mode.
    28     PRESOLVE = 1000,
     28    Presolve = 1000,
    2929
    3030    // Algorithm to solve linear programs.
    31     LP_ALGORITHM = 1001,
     31    LpAlgorithm = 1001,
    3232
    3333    // Advanced usage: incrementality from one solve to the next.
    34     INCREMENTALITY = 1002,
     34    Incrementality = 1002,
    3535
    3636    // Advanced usage: enable or disable matrix scaling.
    37     SCALING = 1003
    38   };
     37    Scaling = 1003
     38  }
    3939}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/LinearProgramming/Wrapper/LpAlgorithmValues.cs

    r16372 r16373  
    2626    PrimalSimplex = 11,
    2727    BarrierAlgorithm = 12
    28   };
     28  }
    2929}
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/Plugin.cs.frame

    r16288 r16373  
    2424namespace HeuristicLab.MathematicalOptimization {
    2525
    26   [Plugin("HeuristicLab.MathematicalOptimization", "Provides support for mathematical optimization based on Google OR-Tools", "3.3.15.$WCREV$")]
     26  [Plugin("HeuristicLab.MathematicalOptimization", "Provides support for mathematical optimization based on Google OR-Tools. " +
     27    "Requires the Microsoft Visual C++ 2017 Redistributable (x64) - 14.16.27012: https://aka.ms/vs/15/release/vc_redist.x64.exe", "3.3.15.$WCREV$")]
    2728  [PluginFile("HeuristicLab.MathematicalOptimization-3.3.dll", PluginFileType.Assembly)]
    2829  [PluginDependency("HeuristicLab.Analysis", "3.3")]
     
    3738  [PluginDependency("HeuristicLab.MainForm.WindowsForms", "3.3")]
    3839  [PluginDependency("HeuristicLab.Optimization", "3.3")]
    39   [PluginDependency("HeuristicLab.OrTools", "6.9")]
     40  [PluginDependency("HeuristicLab.OrTools", "6.10")]
    4041  [PluginDependency("HeuristicLab.Parameters", "3.3")]
    4142  [PluginDependency("HeuristicLab.Persistence", "3.3")]
  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.MathematicalOptimization/3.3/app.config

    r16288 r16373  
    1212      </setting>
    1313      <setting name="GurobiLibraryName" serializeAs="String">
    14         <value>gurobi80.dll</value>
     14        <value>gurobi81.dll</value>
    1515      </setting>
    1616      <setting name="CplexLibraryName" serializeAs="String">
  • branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding.Views/3.3/HeuristicLab.Encodings.ParameterConfigurationEncoding.Views-3.3.csproj

    r15171 r16373  
    1818    <DebugType>full</DebugType>
    1919    <Optimize>false</Optimize>
    20     <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     20    <OutputPath>..\..\..\..\trunk\bin\</OutputPath>
    2121    <DefineConstants>DEBUG;TRACE</DefineConstants>
    2222    <ErrorReport>prompt</ErrorReport>
     
    4141    <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    4242      <SpecificVersion>False</SpecificVersion>
    43       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
     43      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Collections-3.3.dll</HintPath>
    4444      <Private>False</Private>
    4545    </Reference>
    4646    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    4747      <SpecificVersion>False</SpecificVersion>
    48       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
     48      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Common-3.3.dll</HintPath>
    4949      <Private>False</Private>
    5050    </Reference>
    5151    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    5252      <SpecificVersion>False</SpecificVersion>
    53       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common.Resources-3.3.dll</HintPath>
     53      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Common.Resources-3.3.dll</HintPath>
    5454      <Private>False</Private>
    5555    </Reference>
    5656    <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    5757      <SpecificVersion>False</SpecificVersion>
    58       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
     58      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Core-3.3.dll</HintPath>
    5959      <Private>False</Private>
    6060    </Reference>
    6161    <Reference Include="HeuristicLab.Core.Views-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    6262      <SpecificVersion>False</SpecificVersion>
    63       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core.Views-3.3.dll</HintPath>
     63      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Core.Views-3.3.dll</HintPath>
    6464      <Private>False</Private>
    6565    </Reference>
    6666    <Reference Include="HeuristicLab.Data-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    6767      <SpecificVersion>False</SpecificVersion>
    68       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
     68      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Data-3.3.dll</HintPath>
    6969      <Private>False</Private>
    7070    </Reference>
    7171    <Reference Include="HeuristicLab.Data.Views-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    7272      <SpecificVersion>False</SpecificVersion>
    73       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data.Views-3.3.dll</HintPath>
     73      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Data.Views-3.3.dll</HintPath>
    7474      <Private>False</Private>
    7575    </Reference>
    7676    <Reference Include="HeuristicLab.MainForm-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    7777      <SpecificVersion>False</SpecificVersion>
    78       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.MainForm-3.3.dll</HintPath>
     78      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.MainForm-3.3.dll</HintPath>
    7979      <Private>False</Private>
    8080    </Reference>
    8181    <Reference Include="HeuristicLab.MainForm.WindowsForms-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    8282      <SpecificVersion>False</SpecificVersion>
    83       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.MainForm.WindowsForms-3.3.dll</HintPath>
     83      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.MainForm.WindowsForms-3.3.dll</HintPath>
    8484      <Private>False</Private>
    8585    </Reference>
    8686    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    8787      <SpecificVersion>False</SpecificVersion>
    88       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
     88      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
    8989      <Private>False</Private>
    9090    </Reference>
    9191    <Reference Include="HeuristicLab.Optimization.Views-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    9292      <SpecificVersion>False</SpecificVersion>
    93       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization.Views-3.3.dll</HintPath>
     93      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Optimization.Views-3.3.dll</HintPath>
    9494      <Private>False</Private>
    9595    </Reference>
    9696    <Reference Include="HeuristicLab.Optimizer-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    9797      <SpecificVersion>False</SpecificVersion>
    98       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimizer-3.3.dll</HintPath>
     98      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Optimizer-3.3.dll</HintPath>
    9999      <Private>False</Private>
    100100    </Reference>
    101101    <Reference Include="HeuristicLab.Parameters-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    102102      <SpecificVersion>False</SpecificVersion>
    103       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
     103      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
    104104      <Private>False</Private>
    105105    </Reference>
    106106    <Reference Include="HeuristicLab.Parameters.Views-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    107107      <SpecificVersion>False</SpecificVersion>
    108       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters.Views-3.3.dll</HintPath>
     108      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Parameters.Views-3.3.dll</HintPath>
    109109      <Private>False</Private>
    110110    </Reference>
    111111    <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    112112      <SpecificVersion>False</SpecificVersion>
    113       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
     113      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
    114114      <Private>False</Private>
    115115    </Reference>
    116116    <Reference Include="HeuristicLab.Problems.Instances-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    117117      <SpecificVersion>False</SpecificVersion>
    118       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
     118      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
    119119      <Private>False</Private>
    120120    </Reference>
  • branches/ParameterConfigurationEncoding/HeuristicLab.Encodings.ParameterConfigurationEncoding/3.3/HeuristicLab.Encodings.ParameterConfigurationEncoding-3.3.csproj

    r15171 r16373  
    1818    <DebugType>full</DebugType>
    1919    <Optimize>false</Optimize>
    20     <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     20    <OutputPath>..\..\..\..\trunk\bin\</OutputPath>
    2121    <DefineConstants>DEBUG;TRACE</DefineConstants>
    2222    <ErrorReport>prompt</ErrorReport>
     
    4141    <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    4242      <SpecificVersion>False</SpecificVersion>
    43       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
     43      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Collections-3.3.dll</HintPath>
    4444      <Private>False</Private>
    4545    </Reference>
    4646    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    4747      <SpecificVersion>False</SpecificVersion>
    48       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
     48      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Common-3.3.dll</HintPath>
    4949      <Private>False</Private>
    5050    </Reference>
    5151    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    5252      <SpecificVersion>False</SpecificVersion>
    53       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common.Resources-3.3.dll</HintPath>
     53      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Common.Resources-3.3.dll</HintPath>
    5454      <Private>False</Private>
    5555    </Reference>
    5656    <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    5757      <SpecificVersion>False</SpecificVersion>
    58       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
     58      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Core-3.3.dll</HintPath>
    5959      <Private>False</Private>
    6060    </Reference>
    6161    <Reference Include="HeuristicLab.Data-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    6262      <SpecificVersion>False</SpecificVersion>
    63       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
     63      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Data-3.3.dll</HintPath>
    6464      <Private>False</Private>
    6565    </Reference>
    6666    <Reference Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    6767      <SpecificVersion>False</SpecificVersion>
    68       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.dll</HintPath>
     68      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.dll</HintPath>
    6969      <Private>False</Private>
    7070    </Reference>
    7171    <Reference Include="HeuristicLab.Encodings.RealVectorEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    7272      <SpecificVersion>False</SpecificVersion>
    73       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.RealVectorEncoding-3.3.dll</HintPath>
     73      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Encodings.RealVectorEncoding-3.3.dll</HintPath>
    7474      <Private>False</Private>
    7575    </Reference>
    7676    <Reference Include="HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    7777      <SpecificVersion>False</SpecificVersion>
    78       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.dll</HintPath>
     78      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.dll</HintPath>
    7979      <Private>False</Private>
    8080    </Reference>
    8181    <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    8282      <SpecificVersion>False</SpecificVersion>
    83       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
     83      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Operators-3.3.dll</HintPath>
    8484      <Private>False</Private>
    8585    </Reference>
    8686    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    8787      <SpecificVersion>False</SpecificVersion>
    88       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
     88      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
    8989      <Private>False</Private>
    9090    </Reference>
    9191    <Reference Include="HeuristicLab.Parameters-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    9292      <SpecificVersion>False</SpecificVersion>
    93       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
     93      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
    9494      <Private>False</Private>
    9595    </Reference>
    9696    <Reference Include="HeuristicLab.Persistence-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    9797      <SpecificVersion>False</SpecificVersion>
    98       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
     98      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
    9999      <Private>False</Private>
    100100    </Reference>
    101101    <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    102102      <SpecificVersion>False</SpecificVersion>
    103       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
     103      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
    104104      <Private>False</Private>
    105105    </Reference>
    106106    <Reference Include="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    107107      <SpecificVersion>False</SpecificVersion>
    108       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.DataAnalysis-3.4.dll</HintPath>
     108      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Problems.DataAnalysis-3.4.dll</HintPath>
    109109      <Private>False</Private>
    110110    </Reference>
    111111    <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    112112      <SpecificVersion>False</SpecificVersion>
    113       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.dll</HintPath>
     113      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.dll</HintPath>
    114114      <Private>False</Private>
    115115    </Reference>
    116116    <Reference Include="HeuristicLab.Problems.Instances-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    117117      <SpecificVersion>False</SpecificVersion>
    118       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
     118      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
    119119      <Private>False</Private>
    120120    </Reference>
    121121    <Reference Include="HeuristicLab.Random-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    122122      <SpecificVersion>False</SpecificVersion>
    123       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
     123      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Random-3.3.dll</HintPath>
    124124      <Private>False</Private>
    125125    </Reference>
Note: See TracChangeset for help on using the changeset viewer.