Changeset 13376

Timestamp:

11/24/15 17:44:26 (8 years ago)

Author:

abeham

Message:

#2521: working on refactoring

Location:

branches/ProblemRefactoring

Files:

• HeuristicLab.Core/3.3/Attributes/CreatableAttribute.cs (modified) (1 diff)
• HeuristicLab.Optimization/3.3/BasicProblems/CombinedEncoding.cs (moved) (moved from branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiEncoding.cs) (3 diffs)
• HeuristicLab.Optimization/3.3/BasicProblems/CombinedSolution.cs (copied) (copied from branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/MultiSolution.cs) (3 diffs)
• HeuristicLab.Optimization/3.3/BasicProblems/Individuals (deleted)
• HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingCreator.cs (modified) (1 diff)
• HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingCrossover.cs (modified) (1 diff)
• HeuristicLab.Optimization/3.3/BasicProblems/Problem.cs (modified) (1 diff)
• HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj (modified) (1 diff)
• HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj (modified) (2 diffs)
• HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs (modified) (1 diff)
• HeuristicLab.Problems.Programmable/3.3/ProgrammableProblemInstances.cs (modified) (10 diffs)
• HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs (modified) (1 diff)

branches/ProblemRefactoring/HeuristicLab.Core/3.3/Attributes/CreatableAttribute.cs

@@ -40 +40 @@
       public const string GeneticProgrammingProblems = Problems + SplitToken + "2" + OrderToken + "Genetic Programming";
       public const string ExternalEvaluationProblems = Problems + SplitToken + "3" + OrderToken + "External Evaluation";
+      public const string ProgrammableProblems = Problems + SplitToken + "4" + OrderToken + "Programmable";
+      public const string ProgrammableProblemsSingleObjective = ProgrammableProblems + "1" + OrderToken + "Single Objective";
+      public const string ProgrammableProblemsMultiObjective = ProgrammableProblems + "2" + OrderToken + "Multi Objective";
 
       public const string DataAnalysis = "3" + OrderToken + "Data Analysis";

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/CombinedEncoding.cs

@@ -29 +29 @@
 
 namespace HeuristicLab.Optimization {
-  [Item("MultiEncoding", "Describes a combined encoding consisting of multiple simpler encodings.")]
+  [Item("CombinedEncoding", "Describes a combined encoding consisting of multiple simpler encodings.")]
   [StorableClass]
-  public sealed class MultiEncoding : Encoding<CombinedSolution> {
+  public sealed class CombinedEncoding : Encoding<CombinedSolution> {
 
     private ItemCollection<IEncoding> encodings;
@@ -46 +46 @@
 
     [StorableConstructor]
-    private MultiEncoding(bool deserializing) : base(deserializing) { }
-    public override IDeepCloneable Clone(Cloner cloner) { return new MultiEncoding(this, cloner); }
-    private MultiEncoding(MultiEncoding original, Cloner cloner)
+    private CombinedEncoding(bool deserializing) : base(deserializing) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new CombinedEncoding(this, cloner); }
+    private CombinedEncoding(CombinedEncoding original, Cloner cloner)
       : base(original, cloner) {
       encodings = new ItemCollection<IEncoding>(original.Encodings.Select(cloner.Clone));
     }
-    public MultiEncoding()
-      : base("MultiEncoding") {
+    public CombinedEncoding()
+      : base("CombinedEncoding") {
       encodings = new ItemCollection<IEncoding>();
       SolutionCreator = new MultiEncodingCreator() { SolutionParameter = { ActualName = Name } };
@@ -62 +62 @@
     }
 
-    public MultiEncoding Add(IEncoding encoding) {
-      if (encoding is MultiEncoding) throw new InvalidOperationException("Nesting of MultiEncodings is not supported.");
+    public CombinedEncoding Add(IEncoding encoding) {
+      if (encoding is CombinedEncoding) throw new InvalidOperationException("Nesting of CombinedEncodings is not supported.");
       if (Encodings.Any(e => e.Name == encoding.Name)) throw new ArgumentException("Encoding name must be unique", "encoding.Name");
       encodings.Add(encoding);

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/CombinedSolution.cs

@@ -21 +21 @@
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Common;
@@ -32 +31 @@
   public sealed class CombinedSolution : Item, ISolution {
 
-    private MultiEncoding Encoding { get; set; }
-    protected IScope Scope { get; private set; }
+    private CombinedEncoding Encoding { get; set; }
+    private IScope Scope { get; set; }
 
     [StorableConstructor]
     private CombinedSolution(bool deserializing) : base(deserializing) { }
-
     private CombinedSolution(CombinedSolution original, Cloner cloner)
       : base(original, cloner) {
@@ -43 +41 @@
       Scope = cloner.Clone(original.Scope);
     }
-    public CombinedSolution(IScope scope, MultiEncoding encoding) {
+    public CombinedSolution(IScope scope, CombinedEncoding encoding) {
       Encoding = encoding;
       Scope = scope;

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingCreator.cs

@@ -65 +65 @@
 
     public override IOperation InstrumentedApply() {
-      SolutionParameter.ActualValue = new CombinedSolution(ExecutionContext.Scope, (MultiEncoding)EncodingParameter.ActualValue);
+      SolutionParameter.ActualValue = new CombinedSolution(ExecutionContext.Scope, (CombinedEncoding)EncodingParameter.ActualValue);
       return base.InstrumentedApply();
     }

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingCrossover.cs

@@ -38 +38 @@
 
     public override IOperation InstrumentedApply() {
-      SolutionParameter.ActualValue = new CombinedSolution(ExecutionContext.Scope, (MultiEncoding)EncodingParameter.ActualValue);
+      SolutionParameter.ActualValue = new CombinedSolution(ExecutionContext.Scope, (CombinedEncoding)EncodingParameter.ActualValue);
       return base.InstrumentedApply();
     }

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Problem.cs

@@ -127 +127 @@
       if (oldEncoding.GetType() != newEncoding.GetType()) return;
 
-      if (oldEncoding.GetType() == typeof(MultiEncoding)) {
-        var oldMultiEncoding = (MultiEncoding)oldEncoding;
-        var newMultiEncoding = (MultiEncoding)newEncoding;
+      if (oldEncoding.GetType() == typeof(CombinedEncoding)) {
+        var oldMultiEncoding = (CombinedEncoding)oldEncoding;
+        var newMultiEncoding = (CombinedEncoding)newEncoding;
         if (!oldMultiEncoding.Encodings.SequenceEqual(newMultiEncoding.Encodings, new TypeEqualityComparer<IEncoding>())) return;
 

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj

@@ -121 +121 @@
   <ItemGroup>
     <Compile Include="Algorithms\BasicAlgorithm.cs" />
-    <Compile Include="BasicProblems\Individuals\MultiSolution.cs" />
+    <Compile Include="BasicProblems\CombinedSolution.cs" />
     <Compile Include="BasicProblems\Interfaces\IMultiEncodingOperator.cs" />
     <Compile Include="BasicProblems\Interfaces\IMultiObjectiveProblem.cs" />
     <Compile Include="BasicProblems\Interfaces\ISingleObjectiveProblem.cs" />
-    <Compile Include="BasicProblems\MultiEncoding.cs" />
+    <Compile Include="BasicProblems\CombinedEncoding.cs" />
     <Compile Include="BasicProblems\Operators\MultiEncodingCreator.cs" />
     <Compile Include="BasicProblems\Operators\MultiEncodingCrossover.cs" />

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

@@ -160 +160 @@
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.LinearLinkageEncoding\3.3\HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj">
+      <Project>{be698769-975a-429e-828c-72bb2b6182c8}</Project>
+      <Name>HeuristicLab.Encodings.LinearLinkageEncoding-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Encodings.PermutationEncoding\3.3\HeuristicLab.Encodings.PermutationEncoding-3.3.csproj">
       <Project>{dbecb8b0-b166-4133-baf1-ed67c3fd7fca}</Project>
@@ -168 +173 @@
       <Project>{bb6d334a-4bb6-4674-9883-31a6ebb32cab}</Project>
       <Name>HeuristicLab.Encodings.RealVectorEncoding-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding\3.4\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj">
+      <Project>{06d4a186-9319-48a0-bade-a2058d462eea}</Project>
+      <Name>HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4</Name>
       <Private>False</Private>
     </ProjectReference>

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

@@ -88 +88 @@
       Parameters.Remove("Maximization");
       Parameters.Add(new ValueParameter<BoolArray>("Maximization", "Set to false if the problem should be minimized.", (BoolArray)new BoolArray(Maximization).AsReadOnly()) { Hidden = true });
-      var multiEnc = ProblemScript.Encoding as MultiEncoding;
+      var multiEnc = ProblemScript.Encoding as CombinedEncoding;
       if (multiEnc != null) multiEnc.Clear();
       ProblemScript.Initialize();

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

@@ -26 +26 @@
 using HeuristicLab.Encodings.BinaryVectorEncoding;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.LinearLinkageEncoding;
 using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -34 +36 @@
   #region single-objective
   [Item("Binary Vector Problem (single-objective)", "Represents a binary vector single-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsSingleObjective, Priority = 100)]
   [StorableClass]
   public sealed class SingleObjectiveBinaryVectorProgrammableProblem : SingleObjectiveProgrammableProblem<BinaryVectorEncoding, BinaryVector> {
@@ -57 +59 @@
   }
 
-  [Item("Combined Encoding Problem (single-objective)", "Represents a combined encoding single-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class SingleObjectiveMultiSolutionProgrammableProblem : SingleObjectiveProgrammableProblem<MultiEncoding, CombinedSolution> {
-
-    [StorableConstructor]
-    private SingleObjectiveMultiSolutionProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private SingleObjectiveMultiSolutionProgrammableProblem(SingleObjectiveMultiSolutionProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-
-    public SingleObjectiveMultiSolutionProgrammableProblem()
-      : base() {
-      ProblemScript.Code = ScriptTemplates.SingleObjectiveCombinedEncodingProblem_Template;
-    }
-
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveMultiSolutionProgrammableProblem(this, cloner);
-    }
-  }
-
   [Item("Integer Vector Problem (single-objective)", "Represents an integer vector single-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsSingleObjective, Priority = 101)]
   [StorableClass]
   public sealed class SingleObjectiveIntegerVectorProgrammableProblem : SingleObjectiveProgrammableProblem<IntegerVectorEncoding, IntegerVector> {
@@ -101 +83 @@
 
   [Item("Real Vector Problem (single-objective)", "Represents a real vector single-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsSingleObjective, Priority = 102)]
   [StorableClass]
   public sealed class SingleObjectiveRealVectorProgrammableProblem : SingleObjectiveProgrammableProblem<RealVectorEncoding, RealVector> {
@@ -124 +106 @@
 
   [Item("Permutation Problem (single-objective)", "Represents a permutation single-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsSingleObjective, Priority = 103)]
   [StorableClass]
   public sealed class SingleObjectivePermutationProgrammableProblem : SingleObjectiveProgrammableProblem<PermutationEncoding, Permutation> {
@@ -146 +128 @@
   }
 
-  //[Item("Symbolic Expression Tree Programmable Problem (single-objective)", "Represents a symbolic expression tree single-objective problem that can be programmed with a script.")]
-  //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  //[StorableClass]
-  //public sealed class SingleObjectiveSymbolicExpressionTreeProgrammableProblem : SingleObjectiveProgrammableProblem<SymbolicExpressionTreeEncoding, SymbolicExpressionTree> {
-
-  //  [StorableConstructor]
-  //  private SingleObjectiveSymbolicExpressionTreeProgrammableProblem(bool deserializing) : base(deserializing) { }
-  //  private SingleObjectiveSymbolicExpressionTreeProgrammableProblem(SingleObjectiveSymbolicExpressionTreeProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-  //  public SingleObjectiveSymbolicExpressionTreeProgrammableProblem()
-  //    : base(string.Format(ScriptTemplates.CompiledSingleObjectiveProblemDefinition, "HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "SymbolicExpressionTreeEncoding", "SymbolicExpressionTree")) { }
-
-  //  public override IDeepCloneable Clone(Cloner cloner) {
-  //    return new SingleObjectiveSymbolicExpressionTreeProgrammableProblem(this, cloner);
-  //  }
-  //}
-
-  //[Item("Linear Linkage Programmable Problem (single-objective)", "Represents a linear linkage single-objective problem that can be programmed with a script.")]
-  //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  //[StorableClass]
-  //public sealed class SingleObjectiveLinearLinkageProgrammableProblem : SingleObjectiveProgrammableProblem<LinearLinkageEncoding, LinearLinkage> {
-
-  //  [StorableConstructor]
-  //  private SingleObjectiveLinearLinkageProgrammableProblem(bool deserializing) : base(deserializing) { }
-  //  private SingleObjectiveLinearLinkageProgrammableProblem(SingleObjectiveLinearLinkageProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-  //  public SingleObjectiveLinearLinkageProgrammableProblem()
-  //    : base(string.Format(ScriptTemplates.CompiledSingleObjectiveProblemDefinition, "HeuristicLab.Encodings.LinearLinkageEncoding", "LinearLinkageEncoding", "LinearLinkage")) { }
-
-  //  public override IDeepCloneable Clone(Cloner cloner) {
-  //    return new SingleObjectiveLinearLinkageProgrammableProblem(this, cloner);
-  //  }
-  //}
+  [Item("Symbolic Expression Tree Problem (single-objective)", "Represents a symbolic expression tree single-objective problem that can be programmed with a script.")]
+  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsSingleObjective, Priority = 104)]
+  [StorableClass]
+  public sealed class SingleObjectiveSymbolicExpressionTreeProgrammableProblem : SingleObjectiveProgrammableProblem<SymbolicExpressionTreeEncoding, ISymbolicExpressionTree> {
+
+    [StorableConstructor]
+    private SingleObjectiveSymbolicExpressionTreeProgrammableProblem(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveSymbolicExpressionTreeProgrammableProblem(SingleObjectiveSymbolicExpressionTreeProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+    public SingleObjectiveSymbolicExpressionTreeProgrammableProblem()
+      : base() {
+      var codeTemplate = ScriptTemplates.SingleObjectiveProblem_Template;
+      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.SymbolicExpressionTreeEncoding");
+      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "SymbolicExpressionTreeEncoding");
+      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "ISymbolicExpressionTree");
+      ProblemScript.Code = codeTemplate;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveSymbolicExpressionTreeProgrammableProblem(this, cloner);
+    }
+  }
+
+  [Item("Linear Linkage Problem (single-objective)", "Represents a linear linkage single-objective problem that can be programmed with a script.")]
+  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsSingleObjective, Priority = 105)]
+  [StorableClass]
+  public sealed class SingleObjectiveLinearLinkageProgrammableProblem : SingleObjectiveProgrammableProblem<LinearLinkageEncoding, LinearLinkage> {
+
+    [StorableConstructor]
+    private SingleObjectiveLinearLinkageProgrammableProblem(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveLinearLinkageProgrammableProblem(SingleObjectiveLinearLinkageProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+    public SingleObjectiveLinearLinkageProgrammableProblem()
+      : base() {
+      var codeTemplate = ScriptTemplates.SingleObjectiveProblem_Template;
+      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.LinearLinkageEncoding");
+      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "LinearLinkageEncoding");
+      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "LinearLinkage");
+      ProblemScript.Code = codeTemplate;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveLinearLinkageProgrammableProblem(this, cloner);
+    }
+  }
+
+  [Item("Combined Encoding Problem (single-objective)", "Represents a combined encoding single-objective problem that can be programmed with a script.")]
+  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsSingleObjective, Priority = 1000)]
+  [StorableClass]
+  public sealed class SingleObjectiveCombinedEncodingProgrammableProblem : SingleObjectiveProgrammableProblem<CombinedEncoding, CombinedSolution> {
+
+    [StorableConstructor]
+    private SingleObjectiveCombinedEncodingProgrammableProblem(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveCombinedEncodingProgrammableProblem(SingleObjectiveCombinedEncodingProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+
+    public SingleObjectiveCombinedEncodingProgrammableProblem()
+      : base() {
+      ProblemScript.Code = ScriptTemplates.SingleObjectiveCombinedEncodingProblem_Template;
+    }
+
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveCombinedEncodingProgrammableProblem(this, cloner);
+    }
+  }
   #endregion
 
   #region multi-objective
   [Item("Binary Vector Problem (multi-objective)", "Represents a binary vector multi-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsMultiObjective, Priority = 100)]
   [StorableClass]
   public sealed class MultiObjectiveBinaryVectorProgrammableProblem : MultiObjectiveProgrammableProblem<BinaryVectorEncoding, BinaryVector> {
@@ -204 +218 @@
   }
 
-  [Item("Combined Encoding Problem (multi-objective)", "Represents a combined encoding multi-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class MultiObjectiveMultiSolutionProgrammableProblem : MultiObjectiveProgrammableProblem<MultiEncoding, CombinedSolution> {
-
-    [StorableConstructor]
-    private MultiObjectiveMultiSolutionProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private MultiObjectiveMultiSolutionProgrammableProblem(MultiObjectiveMultiSolutionProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-
-    public MultiObjectiveMultiSolutionProgrammableProblem()
-      : base() {
-      ProblemScript.Code = ScriptTemplates.MultiObjectiveCombinedEncodingProblem_Template;
-    }
-
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiObjectiveMultiSolutionProgrammableProblem(this, cloner);
-    }
-  }
-
   [Item("Integer Vector Problem (multi-objective)", "Represents an integer vector multi-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsMultiObjective, Priority = 101)]
   [StorableClass]
   public sealed class MultiObjectiveIntegerVectorProgrammableProblem : MultiObjectiveProgrammableProblem<IntegerVectorEncoding, IntegerVector> {
@@ -248 +242 @@
 
   [Item("Real Vector Problem (multi-objective)", "Represents a real vector multi-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsMultiObjective, Priority = 102)]
   [StorableClass]
   public sealed class MultiObjectiveRealVectorProgrammableProblem : MultiObjectiveProgrammableProblem<RealVectorEncoding, RealVector> {
@@ -271 +265 @@
 
   [Item("Permutation Problem (multi-objective)", "Represents a permutation multi-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsMultiObjective, Priority = 103)]
   [StorableClass]
   public sealed class MultiObjectivePermutationProgrammableProblem : MultiObjectiveProgrammableProblem<PermutationEncoding, Permutation> {
@@ -292 +286 @@
   }
 
-  //[Item("Symbolic Expression Tree Programmable Problem (multi-objective)", "Represents a symbolic expression tree multi-objective problem that can be programmed with a script.")]
-  //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  //[StorableClass]
-  //public sealed class MultiObjectiveSymbolicExpressionTreeProgrammableProblem : MultiObjectiveProgrammableProblem<SymbolicExpressionTreeEncoding, SymbolicExpressionTree> {
-
-  //  [StorableConstructor]
-  //  private MultiObjectiveSymbolicExpressionTreeProgrammableProblem(bool deserializing) : base(deserializing) { }
-  //  private MultiObjectiveSymbolicExpressionTreeProgrammableProblem(MultiObjectiveSymbolicExpressionTreeProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-  //  public MultiObjectiveSymbolicExpressionTreeProgrammableProblem()
-  //    : base(string.Format(ScriptTemplates.CompiledMultiObjectiveProblemDefinition, "HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "SymbolicExpressionTreeEncoding", "SymbolicExpressionTree")) { }
-
-  //  public override IDeepCloneable Clone(Cloner cloner) {
-  //    return new MultiObjectiveSymbolicExpressionTreeProgrammableProblem(this, cloner);
-  //  }
-  //}
-
-  //[Item("Linear Linkage Programmable Problem (multi-objective)", "Represents a linear linkage multi-objective problem that can be programmed with a script.")]
-  //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  //[StorableClass]
-  //public sealed class MultiObjectiveLinearLinkageProgrammableProblem : MultiObjectiveProgrammableProblem<LinearLinkageEncoding, LinearLinkage> {
-
-  //  [StorableConstructor]
-  //  private MultiObjectiveLinearLinkageProgrammableProblem(bool deserializing) : base(deserializing) { }
-  //  private MultiObjectiveLinearLinkageProgrammableProblem(MultiObjectiveLinearLinkageProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-  //  public MultiObjectiveLinearLinkageProgrammableProblem()
-  //    : base(string.Format(ScriptTemplates.CompiledMultiObjectiveProblemDefinition, "HeuristicLab.Encodings.LinearLinkageEncoding", "LinearLinkageEncoding", "LinearLinkage")) { }
-
-  //  public override IDeepCloneable Clone(Cloner cloner) {
-  //    return new MultiObjectiveLinearLinkageProgrammableProblem(this, cloner);
-  //  }
-  //}
+  [Item("Symbolic Expression Tree Programmable Problem (multi-objective)", "Represents a symbolic expression tree multi-objective problem that can be programmed with a script.")]
+  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsMultiObjective, Priority = 104)]
+  [StorableClass]
+  public sealed class MultiObjectiveSymbolicExpressionTreeProgrammableProblem : MultiObjectiveProgrammableProblem<SymbolicExpressionTreeEncoding, ISymbolicExpressionTree> {
+
+    [StorableConstructor]
+    private MultiObjectiveSymbolicExpressionTreeProgrammableProblem(bool deserializing) : base(deserializing) { }
+    private MultiObjectiveSymbolicExpressionTreeProgrammableProblem(MultiObjectiveSymbolicExpressionTreeProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+    public MultiObjectiveSymbolicExpressionTreeProgrammableProblem()
+      : base() {
+      var codeTemplate = ScriptTemplates.MultiObjectiveProblem_Template;
+      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.SymbolicExpressionTreeEncoding");
+      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "SymbolicExpressionTreeEncoding");
+      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "ISymbolicExpressionTree");
+      ProblemScript.Code = codeTemplate;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveSymbolicExpressionTreeProgrammableProblem(this, cloner);
+    }
+  }
+
+  [Item("Linear Linkage Programmable Problem (multi-objective)", "Represents a linear linkage multi-objective problem that can be programmed with a script.")]
+  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsMultiObjective, Priority = 105)]
+  [StorableClass]
+  public sealed class MultiObjectiveLinearLinkageProgrammableProblem : MultiObjectiveProgrammableProblem<LinearLinkageEncoding, LinearLinkage> {
+
+    [StorableConstructor]
+    private MultiObjectiveLinearLinkageProgrammableProblem(bool deserializing) : base(deserializing) { }
+    private MultiObjectiveLinearLinkageProgrammableProblem(MultiObjectiveLinearLinkageProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+    public MultiObjectiveLinearLinkageProgrammableProblem()
+      : base() {
+      var codeTemplate = ScriptTemplates.MultiObjectiveProblem_Template;
+      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.LinearLinkageEncoding");
+      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "LinearLinkageEncoding");
+      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "LinearLinkage");
+      ProblemScript.Code = codeTemplate;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveLinearLinkageProgrammableProblem(this, cloner);
+    }
+  }
+
+  [Item("Combined Encoding Problem (multi-objective)", "Represents a combined encoding multi-objective problem that can be programmed with a script.")]
+  [Creatable(CreatableAttribute.Categories.ProgrammableProblemsMultiObjective, Priority = 1000)]
+  [StorableClass]
+  public sealed class MultiObjectiveCombinedEncodingProgrammableProblem : MultiObjectiveProgrammableProblem<CombinedEncoding, CombinedSolution> {
+
+    [StorableConstructor]
+    private MultiObjectiveCombinedEncodingProgrammableProblem(bool deserializing) : base(deserializing) { }
+    private MultiObjectiveCombinedEncodingProgrammableProblem(MultiObjectiveCombinedEncodingProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+
+    public MultiObjectiveCombinedEncodingProgrammableProblem()
+      : base() {
+      ProblemScript.Code = ScriptTemplates.MultiObjectiveCombinedEncodingProblem_Template;
+    }
+
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveCombinedEncodingProgrammableProblem(this, cloner);
+    }
+  }
   #endregion
 }

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

@@ -91 +91 @@
       Parameters.Remove("Maximization");
       Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", (BoolValue)new BoolValue(Maximization).AsReadOnly()) { Hidden = true });
-      var multiEnc = ProblemScript.Encoding as MultiEncoding;
+      var multiEnc = ProblemScript.Encoding as CombinedEncoding;
       if (multiEnc != null) multiEnc.Clear();
       ProblemScript.Initialize();