Changeset 11485 for branches/ProgrammableProblem/HeuristicLab.Problems.Programmable

Timestamp:

10/21/14 19:10:35 (10 years ago)

Author:

abeham

Message:

#2174:

• fixed some bugs
• changed IsMaximizationProblem/Maximization to be an abstract property
• changed Analyze to include an empty virtual definition

Location:

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3

Files:

• MultiObjectiveProblemDefinition.cs (modified) (2 diffs)
• MultiObjectiveProblemScript.cs (modified) (2 diffs)
• ProblemScriptBase.cs (modified) (2 diffs)
• SingleObjectiveProblemDefinition.cs (modified) (1 diff)
• SingleObjectiveProblemScript.cs (modified) (1 diff)

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemDefinition.cs

@@ -20 +20 @@
 #endregion
 
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -29 +28 @@
   [Item("Multi-objective Problem Definition", "Base class for custom multi-objective problem definitions.")]
   public abstract class MultiObjectiveProblemDefinition : ProblemDefinition, IMultiObjectiveProblemDefinition {
-    [Storable(Name = "Storable")]
-    private bool[] maximization;
-    public bool[] Maximization {
-      get { return maximization; }
-      set {
-        if (maximization.SequenceEqual(value)) return;
-        maximization = value;
-        OnProblemDefinitionChanged();
-      }
-    }
 
+    public abstract bool[] Maximization { get; }
     public abstract double[] Evaluate(IRandom random, Individual vector);
-
-    public abstract void Analyze(Individual[] vectors, double[][] qualities, ResultCollection results);
+    public virtual void Analyze(Individual[] vectors, double[][] qualities, ResultCollection results) { }
 
     [StorableConstructor]
     protected MultiObjectiveProblemDefinition(bool deserializing) : base(deserializing) { }
-    protected MultiObjectiveProblemDefinition(MultiObjectiveProblemDefinition original, Cloner cloner)
-      : base(original, cloner) {
-      this.maximization = (bool[])original.maximization.Clone();
-    }
+    protected MultiObjectiveProblemDefinition(MultiObjectiveProblemDefinition original, Cloner cloner) : base(original, cloner) { }
     protected MultiObjectiveProblemDefinition(Encoding encoding) : this(encoding, "MultiObjectiveProblemDefinition", null) { }
     protected MultiObjectiveProblemDefinition(Encoding encoding, string name) : this(encoding, name, null) { }
-    protected MultiObjectiveProblemDefinition(Encoding encoding, string name, string description)
-      : base(encoding) { }
+    protected MultiObjectiveProblemDefinition(Encoding encoding, string name, string description) : base(encoding, name, description) { }
   }
 }

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemScript.cs

@@ -66 +66 @@
   }
 
-  public double[] Evaluate(IRandom random, ParameterVector vector) {
+  public double[] Evaluate(IRandom random, Individual individual) {
     var qualities = new [] { 0.0, 0.0 };
     // use vars.yourVariable to access variables in the variable store i.e. yourVariable
-    // qualities = new [] { vector.RealVector(""r"").Sum(x => x * x), vector.RealVector(""r"").Sum(x => x * x * x) };
+    // qualities = new [] { individual.RealVector(""r"").Sum(x => x * x), individual.RealVector(""r"").Sum(x => x * x * x) };
     return qualities;
   }
 
-  public void Analyze(ParameterVector[] vectors, double[][] qualities, ResultCollection results) {
+  public void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results) {
     // write or update results given the range of vectors and resulting qualities
     // use e.g. vars.yourVariable to access variables in the variable store i.e. yourVariable
   }
 
-  public IEnumerable<ParameterVector> GetNeighbors(IRandom random, ParameterVector vector) {
+  public override IEnumerable<Individual> GetNeighbors(IRandom random, Individual individual) {
     // Create new vectors, based on the given one that represent small changes
     // This method is only called from move-based algorithms (LocalSearch, SimulatedAnnealing, etc.)
@@ -84 +84 @@
       // this is not an infinite loop as only a finite amount of samples will be drawn
       // it is possible to return a concrete amount of neighbors also
-      var neighbor = (ParameterVector)vector.Clone();
+      var neighbor = (Individual)individual.Clone();
       //e.g. make a bit flip in a binary parameter
       //var bIndex = random.Next(neighbor.BinaryVector(""b"").Length);

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/ProblemScriptBase.cs

@@ -20 +20 @@
 #endregion
 
+using System;
+using HeuristicLab.Common;
+
 namespace HeuristicLab.Problems.Programmable {
   public abstract class ProblemScriptBase : ProblemDefinition {
@@ -27 +30 @@
     public dynamic vars { get; set; }
     public abstract void Initialize();
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      throw new InvalidOperationException("ProblemScript instances cannot be cloned.");
+    }
   }
 }

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinition.cs

@@ -27 +27 @@
 namespace HeuristicLab.Problems.Programmable {
   [Item("Single-objective Problem Definition", "Base class for custom single-objective problem definitions.")]
-  [StorableClass]
   public abstract class SingleObjectiveProblemDefinition : ProblemDefinition, ISingleObjectiveProblemDefinition {
-    [Storable(Name = "Storable")]
-    private bool isMaximizationProblem;
-    public bool IsMaximizationProblem {
-      get { return isMaximizationProblem; }
-      set {
-        if (isMaximizationProblem == value) return;
-        isMaximizationProblem = value;
-        OnProblemDefinitionChanged();
-      }
-    }
 
+    public abstract bool IsMaximizationProblem { get; }
     public abstract double Evaluate(IRandom random, Individual vector);
-
-    public abstract void Analyze(Individual[] vectors, double[] qualities, ResultCollection results);
+    public virtual void Analyze(Individual[] vectors, double[] qualities, ResultCollection results) { }
 
     [StorableConstructor]
     protected SingleObjectiveProblemDefinition(bool deserializing) : base(deserializing) { }
-    protected SingleObjectiveProblemDefinition(SingleObjectiveProblemDefinition original, Cloner cloner)
-      : base(original, cloner) {
-      this.isMaximizationProblem = original.isMaximizationProblem;
-    }
+    protected SingleObjectiveProblemDefinition(SingleObjectiveProblemDefinition original, Cloner cloner) : base(original, cloner) { }
     protected SingleObjectiveProblemDefinition(Encoding encoding) : this(encoding, "SingleObjectiveProblemDefinition", null) { }
     protected SingleObjectiveProblemDefinition(Encoding encoding, string name) : this(encoding, name, null) { }
-    protected SingleObjectiveProblemDefinition(Encoding encoding, string name, string description)
-      : base(encoding) { }
+    protected SingleObjectiveProblemDefinition(Encoding encoding, string name, string description) : base(encoding, name, description) { }
   }
 }

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemScript.cs

@@ -78 +78 @@
   }
 
-  public IEnumerable<Individual> GetNeighbors(IRandom random, Individual individual) {
+  public override IEnumerable<Individual> GetNeighbors(IRandom random, Individual individual) {
     // Create new vectors, based on the given one that represent small changes
     // This method is only called from move-based algorithms (LocalSearch, SimulatedAnnealing, etc.)