Changeset 10754

Timestamp:

04/15/14 22:34:05 (10 years ago)

Author:

abeham

Message:

#2174: minor refactorings

Location:

branches/SimSharp

Files:

• HeuristicLab.Encodings.ParameterVector/ParameterVectorBuilder.cs (modified) (3 diffs)
• HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj (modified) (1 diff)
• HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveEvaluator.cs (moved) (moved from branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Operators/SimOptSingleObjectiveEvaluator.cs) (4 diffs)
• HeuristicLab.Problems.Programmable/3.3/ProblemBase.cs (moved) (moved from branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/ProgrammableProblemBase.cs) (1 diff)
• HeuristicLab.Problems.Programmable/3.3/ProgrammableProblemScript.cs (copied) (copied from branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/ProgrammableProblemScript.cs) (4 diffs)
• HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemBase.cs (copied) (copied from branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/ProgrammableProblemBase.cs) (1 diff)
• HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs (modified) (2 diffs)
• HeuristicLab.Problems.Programmable/3.3/SingleObjectiveScript.cs (copied) (copied from branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/ProgrammableProblemScript.cs) (4 diffs)

branches/SimSharp/HeuristicLab.Encodings.ParameterVector/ParameterVectorBuilder.cs

@@ -32 +32 @@
 
     public ParameterVectorBuilder() {
-      booleanParameters = new HashSet<string>();
-      integerParameters = new Dictionary<string, Tuple<int, int, int?>>();
-      realParameters = new Dictionary<string, Tuple<double, double>>();
+      booleanParameters = null;
+      integerParameters = null;
+      realParameters = null;
       permutationParameter = null;
     }
 
     public ParameterVectorBuilder AddBoolean(string name) {
+      if (booleanParameters == null) booleanParameters = new HashSet<string>();
       booleanParameters.Add(name);
       return this;
@@ -44 +45 @@
 
     public ParameterVectorBuilder AddInteger(string name, int min, int max, int? step = null) {
+      if (integerParameters == null) integerParameters = new Dictionary<string, Tuple<int, int, int?>>();
       integerParameters.Add(name, Tuple.Create(min, max, step));
       return this;
@@ -49 +51 @@
 
     public ParameterVectorBuilder AddReal(string name, double min, double max) {
+      if (realParameters == null) realParameters = new Dictionary<string, Tuple<double, double>>();
       realParameters.Add(name, Tuple.Create(min, max));
       return this;

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

@@ -139 +139 @@
     <Compile Include="Operators\ParameterVectorManipulator.cs" />
     <Compile Include="Operators\ParameterVectorCrossover.cs" />
-    <Compile Include="Operators\SimOptSingleObjectiveEvaluator.cs" />
+    <Compile Include="Operators\SingleObjectiveEvaluator.cs" />
     <Compile Include="Operators\ParameterVectorCreater.cs" />
-    <Compile Include="ProgrammableProblemBase.cs" />
+    <Compile Include="ProblemBase.cs" />
+    <Compile Include="SingleObjectiveProblemBase.cs" />
     <Compile Include="ProgrammableProblemScript.cs" />
+    <Compile Include="SingleObjectiveScript.cs" />
     <Compile Include="SingleObjectiveProgrammableProblem.cs" />
     <None Include="HeuristicLab.snk" />

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveEvaluator.cs

@@ -31 +31 @@
 
 namespace HeuristicLab.Problems.Programmable {
-  [Item("SimOptSingleObjectiveEvaluator", "Evaluates a parameter vector as received from a SimOptRunner.")]
+  [Item("Single-objective Evaluator", "Calls the script's Evaluate method to get the quality value of the parameter vector.")]
   [StorableClass]
-  public class SimOptSingleObjectiveEvaluator : SingleSuccessorOperator, ISingleObjectiveProgrammableProblemEvaluator, IStochasticOperator {
+  public class SingleObjectiveEvaluator : SingleSuccessorOperator, ISingleObjectiveProgrammableProblemEvaluator, IStochasticOperator {
 
     public ILookupParameter<IRandom> RandomParameter {
@@ -39 +39 @@
     }
 
-    public ILookupParameter<ProgrammableProblemScript> ScriptParameter {
-      get { return (ILookupParameter<ProgrammableProblemScript>)Parameters["Script"]; }
+    public ILookupParameter<SingleObjectiveScript> ScriptParameter {
+      get { return (ILookupParameter<SingleObjectiveScript>)Parameters["Script"]; }
     }
 
@@ -52 +52 @@
 
     [StorableConstructor]
-    protected SimOptSingleObjectiveEvaluator(bool deserializing) : base(deserializing) { }
-    protected SimOptSingleObjectiveEvaluator(SimOptSingleObjectiveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public SimOptSingleObjectiveEvaluator() {
+    protected SingleObjectiveEvaluator(bool deserializing) : base(deserializing) { }
+    protected SingleObjectiveEvaluator(SingleObjectiveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public SingleObjectiveEvaluator() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
-      Parameters.Add(new LookupParameter<ProgrammableProblemScript>("Script", "The script that will execute the evaluation function and define the parameter vector."));
+      Parameters.Add(new LookupParameter<SingleObjectiveScript>("Script", "The script that will execute the evaluation function and define the parameter vector."));
       Parameters.Add(new LookupParameter<ParameterVector>("ParameterVector", "The vector that holds the parameters."));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
@@ -62 +62 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SimOptSingleObjectiveEvaluator(this, cloner);
+      return new SingleObjectiveEvaluator(this, cloner);
     }
 

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/ProblemBase.cs

@@ -20 +20 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Encodings.ParameterVectorEncoding;
 
 namespace HeuristicLab.Problems.Programmable {
-  public abstract class ProgrammableProblemBase {
-    public abstract bool IsMaximizationProblem { get; }
+  public abstract class ProblemBase {
     public abstract ParameterVector GetParametersToOptimize();
-    public abstract void EvaluateFeasibility(ParameterVector vector);
-    public abstract double Evaluate(IRandom random, ParameterVector vector);
   }
 }

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/ProgrammableProblemScript.cs

@@ -29 +29 @@
 
 namespace HeuristicLab.Problems.Programmable {
-  [Item("ProgrammableProblemScript", "Script that defines the parameter vector and evaluates the solution.")]
+  [Item("ProgrammableProblemScript", "Script that defines the parameter vector and evaluates the solution for a programmable problem.")]
   [StorableClass]
-  public class ProgrammableProblemScript : Script, IStorableContent {
-    public string Filename { get; set; }
+  public abstract class ProgrammableProblemScript : Script {
     protected bool SuppressEvents { get; set; }
 
@@ -41 +40 @@
     public ProgrammableProblemScript() { }
 
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ProgrammableProblemScript(this, cloner);
-    }
-
-    private volatile ProgrammableProblemBase instance;
+    private volatile ProblemBase instance;
     private object locker = new object();
-    public ProgrammableProblemBase Instance {
+    public ProblemBase Instance {
       get {
         SuppressEvents = true;
@@ -70 +65 @@
       protected set {
         instance = value;
-        OnInstanceChanged();
-      }
-    }
-
-    protected override string CodeTemplate {
-      get {
-        return @"using System;
-using System.Linq;
-using System.Collections.Generic;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.ParameterVectorEncoding;
-using HeuristicLab.Encodings.PermutationEncoding;
-
-public class MyProblem : HeuristicLab.Problems.Programmable.ProgrammableProblemBase {
-  public MyProblem() {
-    // initialize private fields
-  }
-  public override bool IsMaximizationProblem { get { return false; } }
-  public override ParameterVector GetParametersToOptimize() {
-    return new ParameterVectorBuilder()
-      // .AddBoolean(""Parameter"")
-      // .AddInteger(""Parameter"", min: 5, max: 15, step: 3)
-      // .AddReal(""Parameter"", min: 0.0, max: 1.0)
-      // .SetPermutation(type: PermutationTypes.Absolute, length: 10)
-    .Build();
-  }
-
-  public override void EvaluateFeasibility(ParameterVector vector) {
-    vector.IsFeasible = true
-    // && vector.Integer(""Parameter1"") < vector.Integer(""Parameter2"");
-    // && (vector.Real(""Parameter3"") >= 1.0 || (vector.Real(""Parameter3"") < 1.0 && vector.Integer(""Parameter1"") < 5));
-    ;
-  }
-
-  public override double Evaluate(IRandom random, ParameterVector vector) {
-    var quality = 0.0;
-    return quality;
-  }
-
-  // implement further classes and methods
-}";
+        if (!SuppressEvents) OnInstanceChanged();
       }
     }
@@ -120 +73 @@
       var types = assembly.GetTypes();
       try {
-        instance = (ProgrammableProblemBase)Activator.CreateInstance(types.First(x => typeof(ProgrammableProblemBase).IsAssignableFrom(x)));
+        Instance = (ProblemBase)Activator.CreateInstance(types.First(x => typeof(ProblemBase).IsAssignableFrom(x)));
       } catch {
-        instance = null;
+        Instance = null;
       }
-      if (!SuppressEvents) OnInstanceChanged();
       return assembly;
     }

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemBase.cs

@@ -24 +24 @@
 
 namespace HeuristicLab.Problems.Programmable {
-  public abstract class ProgrammableProblemBase {
+  public abstract class SingleObjectiveProblemBase : ProblemBase {
     public abstract bool IsMaximizationProblem { get; }
-    public abstract ParameterVector GetParametersToOptimize();
-    public abstract void EvaluateFeasibility(ParameterVector vector);
     public abstract double Evaluate(IRandom random, ParameterVector vector);
   }

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

@@ -47 +47 @@
     }
 
-    public IValueParameter<ProgrammableProblemScript> ScriptParameter {
-      get { return (IValueParameter<ProgrammableProblemScript>)Parameters["Script"]; }
+    public IValueParameter<SingleObjectiveScript> ScriptParameter {
+      get { return (IValueParameter<SingleObjectiveScript>)Parameters["Script"]; }
     }
 
@@ -89 +89 @@
     private SingleObjectiveProgrammableProblem(SingleObjectiveProgrammableProblem original, Cloner cloner)
       : base(original, cloner) {
+      Crossover = cloner.Clone(original.Crossover);
+      Manipulator = cloner.Clone(original.Manipulator);
       RegisterEventHandlers();
     }
     public SingleObjectiveProgrammableProblem()
-      : base(new SimOptSingleObjectiveEvaluator(), new ParameterVectorCreater()) {
-      Parameters.Add(new ValueParameter<ProgrammableProblemScript>("Script", "Defines the problem.", new ProgrammableProblemScript() { Name = ItemName }));
+      : base(new SingleObjectiveEvaluator(), new ParameterVectorCreater()) {
+      Parameters.Add(new ValueParameter<SingleObjectiveScript>("Script", "Defines the problem.", new SingleObjectiveScript() { Name = ItemName }));
       Parameters.Add(new OptionalValueParameter<IntValue>("BinaryVectorLength", "The length of the binary vector."));
       Parameters.Add(new OptionalValueParameter<IntValue>("IntegerVectorLength", "The length of the integer vector."));

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveScript.cs

@@ -20 +20 @@
 #endregion
 
-using System;
-using System.Linq;
-using System.Reflection;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Scripting;
 
 namespace HeuristicLab.Problems.Programmable {
-  [Item("ProgrammableProblemScript", "Script that defines the parameter vector and evaluates the solution.")]
+  [Item("Single-objective Script", "Script that defines the parameter vector and evaluates the solution for a programmable problem.")]
   [StorableClass]
-  public class ProgrammableProblemScript : Script, IStorableContent {
+  public class SingleObjectiveScript : ProgrammableProblemScript, IStorableContent {
     public string Filename { get; set; }
-    protected bool SuppressEvents { get; set; }
 
     [StorableConstructor]
-    protected ProgrammableProblemScript(bool deserializing) : base(deserializing) { }
-    protected ProgrammableProblemScript(ProgrammableProblemScript original, Cloner cloner)
+    protected SingleObjectiveScript(bool deserializing) : base(deserializing) { }
+    protected SingleObjectiveScript(SingleObjectiveScript original, Cloner cloner)
       : base(original, cloner) { }
-    public ProgrammableProblemScript() { }
+    public SingleObjectiveScript() { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new ProgrammableProblemScript(this, cloner);
+      return new SingleObjectiveScript(this, cloner);
     }
 
-    private volatile ProgrammableProblemBase instance;
-    private object locker = new object();
-    public ProgrammableProblemBase Instance {
-      get {
-        SuppressEvents = true;
-        try {
-          var oldInstance = instance;
-          var compilationNecessary = false;
-          if (instance == null) {
-            lock (locker) {
-              if (instance == null) {
-                compilationNecessary = true;
-                Compile();
-              }
-            }
-          }
-          if (compilationNecessary && (oldInstance != null || instance != null))
-            OnInstanceChanged();
-          return instance;
-        } finally {
-          SuppressEvents = false;
-        }
-      }
-      protected set {
-        instance = value;
-        OnInstanceChanged();
-      }
+    public new SingleObjectiveProblemBase Instance {
+      get { return (SingleObjectiveProblemBase)base.Instance; }
+      protected set { base.Instance = value; }
     }
 
@@ -85 +56 @@
 using HeuristicLab.Encodings.PermutationEncoding;
 
-public class MyProblem : HeuristicLab.Problems.Programmable.ProgrammableProblemBase {
+public class MyProblem : HeuristicLab.Problems.Programmable.SingleObjectiveProblemBase {
   public MyProblem() {
     // initialize private fields
@@ -99 +70 @@
   }
 
-  public override void EvaluateFeasibility(ParameterVector vector) {
-    vector.IsFeasible = true
-    // && vector.Integer(""Parameter1"") < vector.Integer(""Parameter2"");
-    // && (vector.Real(""Parameter3"") >= 1.0 || (vector.Real(""Parameter3"") < 1.0 && vector.Integer(""Parameter1"") < 5));
-    ;
-  }
-
   public override double Evaluate(IRandom random, ParameterVector vector) {
     var quality = 0.0;
+    // quality = vector.Boolean(""Parameter"") ? vector.Real(""Parameter"") : vector.Integer(""Parameter"");
     return quality;
   }
@@ -115 +80 @@
       }
     }
-
-    public override Assembly Compile() {
-      var assembly = base.Compile();
-      var types = assembly.GetTypes();
-      try {
-        instance = (ProgrammableProblemBase)Activator.CreateInstance(types.First(x => typeof(ProgrammableProblemBase).IsAssignableFrom(x)));
-      } catch {
-        instance = null;
-      }
-      if (!SuppressEvents) OnInstanceChanged();
-      return assembly;
-    }
-
-    protected override void OnCodeChanged() {
-      base.OnCodeChanged();
-      instance = null;
-    }
-
-    public event EventHandler InstanceChanged;
-    protected void OnInstanceChanged() {
-      var handler = InstanceChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
   }
 }