Changeset 16310 for branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/Analyzers

Timestamp:

11/20/18 14:53:51 (6 years ago)

Author:

bwerth

Message:

#2943 worked on MOBasicProblem and MOAnalyzers

Location:

branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Problems.TestFunctions.MultiObjective

Files:

• . (modified) (1 prop)
• 3.3/Analyzers/CrowdingAnalyzer.cs (modified) (1 diff)
• 3.3/Analyzers/GenerationalDistanceAnalyzer.cs (modified) (1 diff)
• 3.3/Analyzers/HypervolumeAnalyzer.cs (modified) (2 diffs)
• 3.3/Analyzers/InvertedGenerationalDistanceAnalyzer.cs (modified) (1 diff)
• 3.3/Analyzers/MOTFAnalyzer.cs (modified) (1 diff)
• 3.3/Analyzers/ScatterPlotAnalyzer.cs (modified) (5 diffs)
• 3.3/Analyzers/SpacingAnalyzer.cs (modified) (1 diff)

branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/Analyzers/CrowdingAnalyzer.cs

@@ -30 +30 @@
 namespace HeuristicLab.Problems.TestFunctions.MultiObjective {
   [StorableClass]
-  [Item("CrowdingAnalyzer", "The mean crowding distance for each point of the Front (see Multi-Objective Performance Metrics - Shodhganga for more information)")]
+  [Item("CrowdingAnalyzer", "This analyzer is functionally equivalent to the CrowdingAnalyzer in HeuristicLab.Analysis, but is kept as not to break backwards compatibility")]
   public class CrowdingAnalyzer : MOTFAnalyzer {
 
-    public IResultParameter<DoubleValue> CrowdingResultParameter {
-      get { return (IResultParameter<DoubleValue>)Parameters["Crowding"]; }
-    }
+    public IResultParameter<DoubleValue> CrowdingResultParameter => (IResultParameter<DoubleValue>)Parameters["Crowding"];
 
     [StorableConstructor]
     protected CrowdingAnalyzer(bool deserializing) : base(deserializing) { }
-    public CrowdingAnalyzer(CrowdingAnalyzer original, Cloner cloner)
-      : base(original, cloner) {
-    }
+    public CrowdingAnalyzer(CrowdingAnalyzer original, Cloner cloner): base(original, cloner) {}
     public override IDeepCloneable Clone(Cloner cloner) {
       return new CrowdingAnalyzer(this, cloner);

branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/Analyzers/GenerationalDistanceAnalyzer.cs

@@ -31 +31 @@
 namespace HeuristicLab.Problems.TestFunctions.MultiObjective {
   [StorableClass]
-  [Item("GenerationalDistanceAnalyzer", "The generational distance between the current and the best known front (see Multi-Objective Performance Metrics - Shodhganga for more information)")]
+  [Item("GenerationalDistanceAnalyzer", "This analyzer is functionally equivalent to the GenerationalDistanceAnalyzer in HeuristicLab.Analysis, but is kept as not to break backwards compatibility")]
   public class GenerationalDistanceAnalyzer : MOTFAnalyzer {
 
     private IFixedValueParameter<DoubleValue> DampeningParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters["Dampening"]; }
-      set { Parameters["Dampening"].ActualValue = value; }
+      get => (IFixedValueParameter<DoubleValue>)Parameters["Dampening"];
+      set => Parameters["Dampening"].ActualValue = value;
     }
 
     public double Dampening {
-      get { return DampeningParameter.Value.Value; }
-      set { DampeningParameter.Value.Value = value; }
+      get => DampeningParameter.Value.Value;
+      set => DampeningParameter.Value.Value = value;
     }
 
-    public IResultParameter<DoubleValue> GenerationalDistanceResultParameter {
-      get { return (IResultParameter<DoubleValue>)Parameters["Generational Distance"]; }
-    }
+    public IResultParameter<DoubleValue> GenerationalDistanceResultParameter => (IResultParameter<DoubleValue>)Parameters["Generational Distance"];
 
     [StorableConstructor]

branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/Analyzers/HypervolumeAnalyzer.cs

@@ -32 +32 @@
 namespace HeuristicLab.Problems.TestFunctions.MultiObjective {
   [StorableClass]
-  [Item("HypervolumeAnalyzer", "Computes the enclosed Hypervolume between the current front and a given reference Point")]
+  [Item("HypervolumeAnalyzer", "This analyzer is functionally equivalent to the HypervolumeAnalyzer in HeuristicLab.Analysis, but is kept as not to break backwards compatibility")]
   public class HypervolumeAnalyzer : MOTFAnalyzer {
 
-    public ILookupParameter<DoubleArray> ReferencePointParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters["ReferencePoint"]; }
-    }
-    public IResultParameter<DoubleValue> HypervolumeResultParameter {
-      get { return (IResultParameter<DoubleValue>)Parameters["Hypervolume"]; }
-    }
-    public IResultParameter<DoubleValue> BestKnownHypervolumeResultParameter {
-      get { return (IResultParameter<DoubleValue>)Parameters["Best known hypervolume"]; }
-    }
-    public IResultParameter<DoubleValue> HypervolumeDistanceResultParameter {
-      get { return (IResultParameter<DoubleValue>)Parameters["Absolute Distance to BestKnownHypervolume"]; }
-    }
+    public ILookupParameter<DoubleArray> ReferencePointParameter => (ILookupParameter<DoubleArray>)Parameters["ReferencePoint"];
+
+    public IResultParameter<DoubleValue> HypervolumeResultParameter => (IResultParameter<DoubleValue>)Parameters["Hypervolume"];
+
+    public IResultParameter<DoubleValue> BestKnownHypervolumeResultParameter => (IResultParameter<DoubleValue>)Parameters["Best known hypervolume"];
+
+    public IResultParameter<DoubleValue> HypervolumeDistanceResultParameter => (IResultParameter<DoubleValue>)Parameters["Absolute Distance to BestKnownHypervolume"];
 
 
     [StorableConstructor]
-    protected HypervolumeAnalyzer(bool deserializing)
-      : base(deserializing) {
-    }
+    protected HypervolumeAnalyzer(bool deserializing) : base(deserializing) {}
 
-    protected HypervolumeAnalyzer(HypervolumeAnalyzer original, Cloner cloner)
-      : base(original, cloner) {
-    }
+    protected HypervolumeAnalyzer(HypervolumeAnalyzer original, Cloner cloner) : base(original, cloner) {}
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new HypervolumeAnalyzer(this, cloner);
@@ -69 +61 @@
       BestKnownHypervolumeResultParameter.DefaultValue = new DoubleValue(0);
       HypervolumeDistanceResultParameter.DefaultValue = new DoubleValue(0);
-
-
     }
 

branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/Analyzers/InvertedGenerationalDistanceAnalyzer.cs

@@ -30 +30 @@
 namespace HeuristicLab.Problems.TestFunctions.MultiObjective {
   [StorableClass]
-  [Item("InvertedGenerationalDistanceAnalyzer", "The inverted generational distance between the current and the best known front (see Multi-Objective Performance Metrics - Shodhganga for more information)")]
+  [Item("InvertedGenerationalDistanceAnalyzer", "This analyzer is functionally equivalent to the InvertedGenerationalDistanceAnalyzer in HeuristicLab.Analysis, but is kept as not to break backwards compatibility")]
   public class InvertedGenerationalDistanceAnalyzer : MOTFAnalyzer {
-    public override bool EnabledByDefault { get { return false; } }
+    public override bool EnabledByDefault => false;
 
-    private IFixedValueParameter<DoubleValue> DampeningParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters["Dampening"]; }
+    private IFixedValueParameter<DoubleValue> DampeningParameter => (IFixedValueParameter<DoubleValue>)Parameters["Dampening"];
+
+    public double Dampening {
+      get => DampeningParameter.Value.Value;
+      set => DampeningParameter.Value.Value = value;
     }
 
-    public double Dampening {
-      get { return DampeningParameter.Value.Value; }
-      set { DampeningParameter.Value.Value = value; }
-    }
-
-    public IResultParameter<DoubleValue> InvertedGenerationalDistanceResultParameter {
-      get { return (IResultParameter<DoubleValue>)Parameters["Inverted Generational Distance"]; }
-    }
+    public IResultParameter<DoubleValue> InvertedGenerationalDistanceResultParameter => (IResultParameter<DoubleValue>)Parameters["Inverted Generational Distance"];
 
     [StorableConstructor]

branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/Analyzers/MOTFAnalyzer.cs

@@ -33 +33 @@
   [StorableClass]
   public abstract class MOTFAnalyzer : SingleSuccessorOperator, IMultiObjectiveTestFunctionAnalyzer {
-    public virtual bool EnabledByDefault { get { return true; } }
+    public virtual bool EnabledByDefault => true;
 
-    public IScopeTreeLookupParameter<DoubleArray> QualitiesParameter {
-      get { return (IScopeTreeLookupParameter<DoubleArray>)Parameters["Qualities"]; }
-    }
+    public IScopeTreeLookupParameter<DoubleArray> QualitiesParameter => (IScopeTreeLookupParameter<DoubleArray>)Parameters["Qualities"];
 
-    public ILookupParameter<ResultCollection> ResultsParameter {
-      get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
-    }
+    public ILookupParameter<ResultCollection> ResultsParameter => (ILookupParameter<ResultCollection>)Parameters["Results"];
 
-    public ILookupParameter<IMultiObjectiveTestFunction> TestFunctionParameter {
-      get { return (ILookupParameter<IMultiObjectiveTestFunction>)Parameters["TestFunction"]; }
-    }
+    public ILookupParameter<IMultiObjectiveTestFunction> TestFunctionParameter => (ILookupParameter<IMultiObjectiveTestFunction>)Parameters["TestFunction"];
 
-    public ILookupParameter<DoubleMatrix> BestKnownFrontParameter {
-      get { return (ILookupParameter<DoubleMatrix>)Parameters["BestKnownFront"]; }
-    }
+    public ILookupParameter<DoubleMatrix> BestKnownFrontParameter => (ILookupParameter<DoubleMatrix>)Parameters["BestKnownFront"];
 
     protected MOTFAnalyzer(MOTFAnalyzer original, Cloner cloner) : base(original, cloner) { }

branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/Analyzers/ScatterPlotAnalyzer.cs

@@ -23 +23 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Optimization;
@@ -33 +34 @@
   public class ScatterPlotAnalyzer : MOTFAnalyzer {
 
-    public IScopeTreeLookupParameter<RealVector> IndividualsParameter {
-      get { return (IScopeTreeLookupParameter<RealVector>)Parameters["Individuals"]; }
-    }
+    public IScopeTreeLookupParameter<RealVector> IndividualsParameter => (IScopeTreeLookupParameter<RealVector>)Parameters["Individuals"];
 
-    public IResultParameter<ParetoFrontScatterPlot> ScatterPlotResultParameter {
-      get { return (IResultParameter<ParetoFrontScatterPlot>)Parameters["Scatterplot"]; }
-    }
-
+    public IResultParameter<ParetoFrontScatterPlot> ScatterPlotResultParameter => (IResultParameter<ParetoFrontScatterPlot>)Parameters["Scatterplot"];
 
     [StorableConstructor]
@@ -52 +48 @@
       Parameters.Add(new ScopeTreeLookupParameter<RealVector>("Individuals", "The individual solutions to the problem"));
       Parameters.Add(new ResultParameter<ParetoFrontScatterPlot>("Scatterplot", "The scatterplot for the current and optimal (if known front)"));
-
     }
 
@@ -59 +54 @@
       var individuals = IndividualsParameter.ActualValue;
       var testFunction = TestFunctionParameter.ActualValue;
-      var objectives = qualities[0].Length;
-      var problemSize = individuals[0].Length;
+      var objectives = qualities.Length != 0 ? qualities[0].Length:0;    
+      var problemSize = individuals.Length != 0 ? individuals[0].Length:0;
 
-      var optimalFront = new double[0][];
-      var front = testFunction.OptimalParetoFront(objectives);
-      if (front != null) optimalFront = front.ToArray();
+      var optimalFront = new double[0][];               
+      if (testFunction != null) {
+        var front = testFunction.OptimalParetoFront(objectives);
+        if (front != null) optimalFront = front.ToArray();
+      }
+      else {
+        var mat = BestKnownFrontParameter.ActualValue;
+        optimalFront = mat == null ? null : Enumerable.Range(0, mat.Rows).Select(r => Enumerable.Range(0, mat.Columns).Select(c => mat[r, c]).ToArray()).ToArray();
+      }
 
       var qualityClones = qualities.Select(s => s.ToArray()).ToArray();
@@ -70 +71 @@
 
       ScatterPlotResultParameter.ActualValue = new ParetoFrontScatterPlot(qualityClones, solutionClones, optimalFront, objectives, problemSize);
-
       return base.Apply();
     }

branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/Analyzers/SpacingAnalyzer.cs

@@ -29 +29 @@
 namespace HeuristicLab.Problems.TestFunctions.MultiObjective {
   [StorableClass]
-  [Item("SpacingAnalyzer", "The spacing of the current front (see Multi-Objective Performance Metrics - Shodhganga for more information)")]
+  [Item("SpacingAnalyzer", "This analyzer is functionally equivalent to the SpacingAnalyzer in HeuristicLab.Analysis, but is kept as not to break backwards compatibility")]
   public class SpacingAnalyzer : MOTFAnalyzer {
 
-    public IResultParameter<DoubleValue> SpacingResultParameter {
-      get { return (IResultParameter<DoubleValue>)Parameters["Spacing"]; }
-    }
+    public IResultParameter<DoubleValue> SpacingResultParameter => (IResultParameter<DoubleValue>)Parameters["Spacing"];
+
     [StorableConstructor]
     protected SpacingAnalyzer(bool deserializing) : base(deserializing) { }
-
 
     protected SpacingAnalyzer(SpacingAnalyzer original, Cloner cloner) : base(original, cloner) { }