Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
11/24/15 17:44:26 (9 years ago)
Author:
abeham
Message:

#2521: working on refactoring

Location:
branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj

    r13373 r13376  
    160160      <Private>False</Private>
    161161    </ProjectReference>
     162    <ProjectReference Include="..\..\HeuristicLab.Encodings.LinearLinkageEncoding\3.3\HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj">
     163      <Project>{be698769-975a-429e-828c-72bb2b6182c8}</Project>
     164      <Name>HeuristicLab.Encodings.LinearLinkageEncoding-3.3</Name>
     165      <Private>False</Private>
     166    </ProjectReference>
    162167    <ProjectReference Include="..\..\HeuristicLab.Encodings.PermutationEncoding\3.3\HeuristicLab.Encodings.PermutationEncoding-3.3.csproj">
    163168      <Project>{dbecb8b0-b166-4133-baf1-ed67c3fd7fca}</Project>
    … …  
    168173      <Project>{bb6d334a-4bb6-4674-9883-31a6ebb32cab}</Project>
    169174      <Name>HeuristicLab.Encodings.RealVectorEncoding-3.3</Name>
     175      <Private>False</Private>
     176    </ProjectReference>
     177    <ProjectReference Include="..\..\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding\3.4\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj">
     178      <Project>{06d4a186-9319-48a0-bade-a2058d462eea}</Project>
     179      <Name>HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4</Name>
    170180      <Private>False</Private>
    171181    </ProjectReference>

  • branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs

    r13365 r13376  
    8888      Parameters.Remove("Maximization");
    8989      Parameters.Add(new ValueParameter<BoolArray>("Maximization", "Set to false if the problem should be minimized.", (BoolArray)new BoolArray(Maximization).AsReadOnly()) { Hidden = true });
    90       var multiEnc = ProblemScript.Encoding as MultiEncoding;
     90      var multiEnc = ProblemScript.Encoding as CombinedEncoding;
    9191      if (multiEnc != null) multiEnc.Clear();
    9292      ProblemScript.Initialize();

  • branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/ProgrammableProblemInstances.cs

    r13373 r13376  
    2626using HeuristicLab.Encodings.BinaryVectorEncoding;
    2727using HeuristicLab.Encodings.IntegerVectorEncoding;
     28using HeuristicLab.Encodings.LinearLinkageEncoding;
    2829using HeuristicLab.Encodings.PermutationEncoding;
    2930using HeuristicLab.Encodings.RealVectorEncoding;
     31using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    3032using HeuristicLab.Optimization;
    3133using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    … …  
    3436  #region single-objective
    3537  [Item("Binary Vector Problem (single-objective)", "Represents a binary vector single-objective problem that can be programmed with a script.")]
    36   [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
     38  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsSingleObjective, Priority = 100)]
    3739  [StorableClass]
    3840  public sealed class SingleObjectiveBinaryVectorProgrammableProblem : SingleObjectiveProgrammableProblem<BinaryVectorEncoding, BinaryVector> {
    … …  
    5759  }
    5860
    59   [Item("Combined Encoding Problem (single-objective)", "Represents a combined encoding single-objective problem that can be programmed with a script.")]
    60   [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
    61   [StorableClass]
    62   public sealed class SingleObjectiveMultiSolutionProgrammableProblem : SingleObjectiveProgrammableProblem<MultiEncoding, CombinedSolution> {
    63 
    64     [StorableConstructor]
    65     private SingleObjectiveMultiSolutionProgrammableProblem(bool deserializing) : base(deserializing) { }
    66     private SingleObjectiveMultiSolutionProgrammableProblem(SingleObjectiveMultiSolutionProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
    67 
    68     public SingleObjectiveMultiSolutionProgrammableProblem()
    69       : base() {
    70       ProblemScript.Code = ScriptTemplates.SingleObjectiveCombinedEncodingProblem_Template;
    71     }
    72 
    73 
    74     public override IDeepCloneable Clone(Cloner cloner) {
    75       return new SingleObjectiveMultiSolutionProgrammableProblem(this, cloner);
    76     }
    77   }
    78 
    7961  [Item("Integer Vector Problem (single-objective)", "Represents an integer vector single-objective problem that can be programmed with a script.")]
    80   [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
     62  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsSingleObjective, Priority = 101)]
    8163  [StorableClass]
    8264  public sealed class SingleObjectiveIntegerVectorProgrammableProblem : SingleObjectiveProgrammableProblem<IntegerVectorEncoding, IntegerVector> {
    … …  
    10183
    10284  [Item("Real Vector Problem (single-objective)", "Represents a real vector single-objective problem that can be programmed with a script.")]
    103   [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
     85  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsSingleObjective, Priority = 102)]
    10486  [StorableClass]
    10587  public sealed class SingleObjectiveRealVectorProgrammableProblem : SingleObjectiveProgrammableProblem<RealVectorEncoding, RealVector> {
    … …  
    124106
    125107  [Item("Permutation Problem (single-objective)", "Represents a permutation single-objective problem that can be programmed with a script.")]
    126   [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
     108  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsSingleObjective, Priority = 103)]
    127109  [StorableClass]
    128110  public sealed class SingleObjectivePermutationProgrammableProblem : SingleObjectiveProgrammableProblem<PermutationEncoding, Permutation> {
    … …  
    146128  }
    147129
    148   //[Item("Symbolic Expression Tree Programmable Problem (single-objective)", "Represents a symbolic expression tree single-objective problem that can be programmed with a script.")]
    149   //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
    150   //[StorableClass]
    151   //public sealed class SingleObjectiveSymbolicExpressionTreeProgrammableProblem : SingleObjectiveProgrammableProblem<SymbolicExpressionTreeEncoding, SymbolicExpressionTree> {
    152 
    153   //  [StorableConstructor]
    154   //  private SingleObjectiveSymbolicExpressionTreeProgrammableProblem(bool deserializing) : base(deserializing) { }
    155   //  private SingleObjectiveSymbolicExpressionTreeProgrammableProblem(SingleObjectiveSymbolicExpressionTreeProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
    156   //  public SingleObjectiveSymbolicExpressionTreeProgrammableProblem()
    157   //    : base(string.Format(ScriptTemplates.CompiledSingleObjectiveProblemDefinition, "HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "SymbolicExpressionTreeEncoding", "SymbolicExpressionTree")) { }
    158 
    159   //  public override IDeepCloneable Clone(Cloner cloner) {
    160   //    return new SingleObjectiveSymbolicExpressionTreeProgrammableProblem(this, cloner);
    161   //  }
    162   //}
    163 
    164   //[Item("Linear Linkage Programmable Problem (single-objective)", "Represents a linear linkage single-objective problem that can be programmed with a script.")]
    165   //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
    166   //[StorableClass]
    167   //public sealed class SingleObjectiveLinearLinkageProgrammableProblem : SingleObjectiveProgrammableProblem<LinearLinkageEncoding, LinearLinkage> {
    168 
    169   //  [StorableConstructor]
    170   //  private SingleObjectiveLinearLinkageProgrammableProblem(bool deserializing) : base(deserializing) { }
    171   //  private SingleObjectiveLinearLinkageProgrammableProblem(SingleObjectiveLinearLinkageProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
    172   //  public SingleObjectiveLinearLinkageProgrammableProblem()
    173   //    : base(string.Format(ScriptTemplates.CompiledSingleObjectiveProblemDefinition, "HeuristicLab.Encodings.LinearLinkageEncoding", "LinearLinkageEncoding", "LinearLinkage")) { }
    174 
    175   //  public override IDeepCloneable Clone(Cloner cloner) {
    176   //    return new SingleObjectiveLinearLinkageProgrammableProblem(this, cloner);
    177   //  }
    178   //}
     130  [Item("Symbolic Expression Tree Problem (single-objective)", "Represents a symbolic expression tree single-objective problem that can be programmed with a script.")]
     131  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsSingleObjective, Priority = 104)]
     132  [StorableClass]
     133  public sealed class SingleObjectiveSymbolicExpressionTreeProgrammableProblem : SingleObjectiveProgrammableProblem<SymbolicExpressionTreeEncoding, ISymbolicExpressionTree> {
     134
     135    [StorableConstructor]
     136    private SingleObjectiveSymbolicExpressionTreeProgrammableProblem(bool deserializing) : base(deserializing) { }
     137    private SingleObjectiveSymbolicExpressionTreeProgrammableProblem(SingleObjectiveSymbolicExpressionTreeProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
     138    public SingleObjectiveSymbolicExpressionTreeProgrammableProblem()
     139      : base() {
     140      var codeTemplate = ScriptTemplates.SingleObjectiveProblem_Template;
     141      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.SymbolicExpressionTreeEncoding");
     142      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "SymbolicExpressionTreeEncoding");
     143      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "ISymbolicExpressionTree");
     144      ProblemScript.Code = codeTemplate;
     145    }
     146
     147    public override IDeepCloneable Clone(Cloner cloner) {
     148      return new SingleObjectiveSymbolicExpressionTreeProgrammableProblem(this, cloner);
     149    }
     150  }
     151
     152  [Item("Linear Linkage Problem (single-objective)", "Represents a linear linkage single-objective problem that can be programmed with a script.")]
     153  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsSingleObjective, Priority = 105)]
     154  [StorableClass]
     155  public sealed class SingleObjectiveLinearLinkageProgrammableProblem : SingleObjectiveProgrammableProblem<LinearLinkageEncoding, LinearLinkage> {
     156
     157    [StorableConstructor]
     158    private SingleObjectiveLinearLinkageProgrammableProblem(bool deserializing) : base(deserializing) { }
     159    private SingleObjectiveLinearLinkageProgrammableProblem(SingleObjectiveLinearLinkageProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
     160    public SingleObjectiveLinearLinkageProgrammableProblem()
     161      : base() {
     162      var codeTemplate = ScriptTemplates.SingleObjectiveProblem_Template;
     163      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.LinearLinkageEncoding");
     164      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "LinearLinkageEncoding");
     165      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "LinearLinkage");
     166      ProblemScript.Code = codeTemplate;
     167    }
     168
     169    public override IDeepCloneable Clone(Cloner cloner) {
     170      return new SingleObjectiveLinearLinkageProgrammableProblem(this, cloner);
     171    }
     172  }
     173
     174  [Item("Combined Encoding Problem (single-objective)", "Represents a combined encoding single-objective problem that can be programmed with a script.")]
     175  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsSingleObjective, Priority = 1000)]
     176  [StorableClass]
     177  public sealed class SingleObjectiveCombinedEncodingProgrammableProblem : SingleObjectiveProgrammableProblem<CombinedEncoding, CombinedSolution> {
     178
     179    [StorableConstructor]
     180    private SingleObjectiveCombinedEncodingProgrammableProblem(bool deserializing) : base(deserializing) { }
     181    private SingleObjectiveCombinedEncodingProgrammableProblem(SingleObjectiveCombinedEncodingProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
     182
     183    public SingleObjectiveCombinedEncodingProgrammableProblem()
     184      : base() {
     185      ProblemScript.Code = ScriptTemplates.SingleObjectiveCombinedEncodingProblem_Template;
     186    }
     187
     188
     189    public override IDeepCloneable Clone(Cloner cloner) {
     190      return new SingleObjectiveCombinedEncodingProgrammableProblem(this, cloner);
     191    }
     192  }
    179193  #endregion
    180194
    181195  #region multi-objective
    182196  [Item("Binary Vector Problem (multi-objective)", "Represents a binary vector multi-objective problem that can be programmed with a script.")]
    183   [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
     197  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsMultiObjective, Priority = 100)]
    184198  [StorableClass]
    185199  public sealed class MultiObjectiveBinaryVectorProgrammableProblem : MultiObjectiveProgrammableProblem<BinaryVectorEncoding, BinaryVector> {
    … …  
    204218  }
    205219
    206   [Item("Combined Encoding Problem (multi-objective)", "Represents a combined encoding multi-objective problem that can be programmed with a script.")]
    207   [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
    208   [StorableClass]
    209   public sealed class MultiObjectiveMultiSolutionProgrammableProblem : MultiObjectiveProgrammableProblem<MultiEncoding, CombinedSolution> {
    210 
    211     [StorableConstructor]
    212     private MultiObjectiveMultiSolutionProgrammableProblem(bool deserializing) : base(deserializing) { }
    213     private MultiObjectiveMultiSolutionProgrammableProblem(MultiObjectiveMultiSolutionProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
    214 
    215     public MultiObjectiveMultiSolutionProgrammableProblem()
    216       : base() {
    217       ProblemScript.Code = ScriptTemplates.MultiObjectiveCombinedEncodingProblem_Template;
    218     }
    219 
    220 
    221     public override IDeepCloneable Clone(Cloner cloner) {
    222       return new MultiObjectiveMultiSolutionProgrammableProblem(this, cloner);
    223     }
    224   }
    225 
    226220  [Item("Integer Vector Problem (multi-objective)", "Represents an integer vector multi-objective problem that can be programmed with a script.")]
    227   [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
     221  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsMultiObjective, Priority = 101)]
    228222  [StorableClass]
    229223  public sealed class MultiObjectiveIntegerVectorProgrammableProblem : MultiObjectiveProgrammableProblem<IntegerVectorEncoding, IntegerVector> {
    … …  
    248242
    249243  [Item("Real Vector Problem (multi-objective)", "Represents a real vector multi-objective problem that can be programmed with a script.")]
    250   [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
     244  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsMultiObjective, Priority = 102)]
    251245  [StorableClass]
    252246  public sealed class MultiObjectiveRealVectorProgrammableProblem : MultiObjectiveProgrammableProblem<RealVectorEncoding, RealVector> {
    … …  
    271265
    272266  [Item("Permutation Problem (multi-objective)", "Represents a permutation multi-objective problem that can be programmed with a script.")]
    273   [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
     267  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsMultiObjective, Priority = 103)]
    274268  [StorableClass]
    275269  public sealed class MultiObjectivePermutationProgrammableProblem : MultiObjectiveProgrammableProblem<PermutationEncoding, Permutation> {
    … …  
    292286  }
    293287
    294   //[Item("Symbolic Expression Tree Programmable Problem (multi-objective)", "Represents a symbolic expression tree multi-objective problem that can be programmed with a script.")]
    295   //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
    296   //[StorableClass]
    297   //public sealed class MultiObjectiveSymbolicExpressionTreeProgrammableProblem : MultiObjectiveProgrammableProblem<SymbolicExpressionTreeEncoding, SymbolicExpressionTree> {
    298 
    299   //  [StorableConstructor]
    300   //  private MultiObjectiveSymbolicExpressionTreeProgrammableProblem(bool deserializing) : base(deserializing) { }
    301   //  private MultiObjectiveSymbolicExpressionTreeProgrammableProblem(MultiObjectiveSymbolicExpressionTreeProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
    302   //  public MultiObjectiveSymbolicExpressionTreeProgrammableProblem()
    303   //    : base(string.Format(ScriptTemplates.CompiledMultiObjectiveProblemDefinition, "HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "SymbolicExpressionTreeEncoding", "SymbolicExpressionTree")) { }
    304 
    305   //  public override IDeepCloneable Clone(Cloner cloner) {
    306   //    return new MultiObjectiveSymbolicExpressionTreeProgrammableProblem(this, cloner);
    307   //  }
    308   //}
    309 
    310   //[Item("Linear Linkage Programmable Problem (multi-objective)", "Represents a linear linkage multi-objective problem that can be programmed with a script.")]
    311   //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
    312   //[StorableClass]
    313   //public sealed class MultiObjectiveLinearLinkageProgrammableProblem : MultiObjectiveProgrammableProblem<LinearLinkageEncoding, LinearLinkage> {
    314 
    315   //  [StorableConstructor]
    316   //  private MultiObjectiveLinearLinkageProgrammableProblem(bool deserializing) : base(deserializing) { }
    317   //  private MultiObjectiveLinearLinkageProgrammableProblem(MultiObjectiveLinearLinkageProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
    318   //  public MultiObjectiveLinearLinkageProgrammableProblem()
    319   //    : base(string.Format(ScriptTemplates.CompiledMultiObjectiveProblemDefinition, "HeuristicLab.Encodings.LinearLinkageEncoding", "LinearLinkageEncoding", "LinearLinkage")) { }
    320 
    321   //  public override IDeepCloneable Clone(Cloner cloner) {
    322   //    return new MultiObjectiveLinearLinkageProgrammableProblem(this, cloner);
    323   //  }
    324   //}
     288  [Item("Symbolic Expression Tree Programmable Problem (multi-objective)", "Represents a symbolic expression tree multi-objective problem that can be programmed with a script.")]
     289  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsMultiObjective, Priority = 104)]
     290  [StorableClass]
     291  public sealed class MultiObjectiveSymbolicExpressionTreeProgrammableProblem : MultiObjectiveProgrammableProblem<SymbolicExpressionTreeEncoding, ISymbolicExpressionTree> {
     292
     293    [StorableConstructor]
     294    private MultiObjectiveSymbolicExpressionTreeProgrammableProblem(bool deserializing) : base(deserializing) { }
     295    private MultiObjectiveSymbolicExpressionTreeProgrammableProblem(MultiObjectiveSymbolicExpressionTreeProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
     296    public MultiObjectiveSymbolicExpressionTreeProgrammableProblem()
     297      : base() {
     298      var codeTemplate = ScriptTemplates.MultiObjectiveProblem_Template;
     299      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.SymbolicExpressionTreeEncoding");
     300      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "SymbolicExpressionTreeEncoding");
     301      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "ISymbolicExpressionTree");
     302      ProblemScript.Code = codeTemplate;
     303    }
     304
     305    public override IDeepCloneable Clone(Cloner cloner) {
     306      return new MultiObjectiveSymbolicExpressionTreeProgrammableProblem(this, cloner);
     307    }
     308  }
     309
     310  [Item("Linear Linkage Programmable Problem (multi-objective)", "Represents a linear linkage multi-objective problem that can be programmed with a script.")]
     311  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsMultiObjective, Priority = 105)]
     312  [StorableClass]
     313  public sealed class MultiObjectiveLinearLinkageProgrammableProblem : MultiObjectiveProgrammableProblem<LinearLinkageEncoding, LinearLinkage> {
     314
     315    [StorableConstructor]
     316    private MultiObjectiveLinearLinkageProgrammableProblem(bool deserializing) : base(deserializing) { }
     317    private MultiObjectiveLinearLinkageProgrammableProblem(MultiObjectiveLinearLinkageProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
     318    public MultiObjectiveLinearLinkageProgrammableProblem()
     319      : base() {
     320      var codeTemplate = ScriptTemplates.MultiObjectiveProblem_Template;
     321      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.LinearLinkageEncoding");
     322      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "LinearLinkageEncoding");
     323      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "LinearLinkage");
     324      ProblemScript.Code = codeTemplate;
     325    }
     326
     327    public override IDeepCloneable Clone(Cloner cloner) {
     328      return new MultiObjectiveLinearLinkageProgrammableProblem(this, cloner);
     329    }
     330  }
     331
     332  [Item("Combined Encoding Problem (multi-objective)", "Represents a combined encoding multi-objective problem that can be programmed with a script.")]
     333  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsMultiObjective, Priority = 1000)]
     334  [StorableClass]
     335  public sealed class MultiObjectiveCombinedEncodingProgrammableProblem : MultiObjectiveProgrammableProblem<CombinedEncoding, CombinedSolution> {
     336
     337    [StorableConstructor]
     338    private MultiObjectiveCombinedEncodingProgrammableProblem(bool deserializing) : base(deserializing) { }
     339    private MultiObjectiveCombinedEncodingProgrammableProblem(MultiObjectiveCombinedEncodingProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
     340
     341    public MultiObjectiveCombinedEncodingProgrammableProblem()
     342      : base() {
     343      ProblemScript.Code = ScriptTemplates.MultiObjectiveCombinedEncodingProblem_Template;
     344    }
     345
     346
     347    public override IDeepCloneable Clone(Cloner cloner) {
     348      return new MultiObjectiveCombinedEncodingProgrammableProblem(this, cloner);
     349    }
     350  }
    325351  #endregion
    326352}

  • branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs

    r13365 r13376  
    9191      Parameters.Remove("Maximization");
    9292      Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", (BoolValue)new BoolValue(Maximization).AsReadOnly()) { Hidden = true });
    93       var multiEnc = ProblemScript.Encoding as MultiEncoding;
     93      var multiEnc = ProblemScript.Encoding as CombinedEncoding;
    9494      if (multiEnc != null) multiEnc.Clear();
    9595      ProblemScript.Initialize();
Note: See TracChangeset for help on using the changeset viewer.