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

Timestamp:

11/20/18 14:53:51 (5 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)
• 3.3/Calculators (deleted)
• 3.3/HeuristicLab.Problems.TestFunctions.MultiObjective-3.3.csproj (modified) (1 diff)
• 3.3/MultiObjectiveTestFunctionProblem.cs (modified) (7 diffs)
• 3.3/NonDominatedSelect.cs (deleted)

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) { }

branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/HeuristicLab.Problems.TestFunctions.MultiObjective-3.3.csproj

@@ -146 +146 @@
     <Compile Include="TestFunctions\IHR\IHR2.cs" />
     <Compile Include="TestFunctions\Misc\ELLI1.cs" />
-    <Compile Include="NonDominatedSelect.cs" />
     <Compile Include="Interfaces\IMultiObjectiveTestFunction.cs" />
     <Compile Include="MultiObjectiveTestFunctionProblem.cs" />

branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/MultiObjectiveTestFunctionProblem.cs

@@ -39 +39 @@
     #region Parameter Properties
     public new IValueParameter<BoolArray> MaximizationParameter {
-      get { return (IValueParameter<BoolArray>)Parameters["Maximization"]; }
+      get { return (IValueParameter<BoolArray>)Parameters[MaximizationParameterName]; }
     }
     public IFixedValueParameter<IntValue> ProblemSizeParameter {
@@ -86 +86 @@
     }
 
-    protected MultiObjectiveTestFunctionProblem(MultiObjectiveTestFunctionProblem original, Cloner cloner)
-      : base(original, cloner) {
+    protected MultiObjectiveTestFunctionProblem(MultiObjectiveTestFunctionProblem original, Cloner cloner) : base(original, cloner) {
       RegisterEventHandlers();
     }
@@ -94 +93 @@
     }
 
-    public MultiObjectiveTestFunctionProblem()
-      : base() {
+    public MultiObjectiveTestFunctionProblem() : base() {
       Parameters.Add(new FixedValueParameter<IntValue>("ProblemSize", "The dimensionality of the problem instance (number of variables in the function).", new IntValue(2)));
       Parameters.Add(new FixedValueParameter<IntValue>("Objectives", "The dimensionality of the solution vector (number of objectives).", new IntValue(2)));
@@ -130 +128 @@
     public double[] CheckContraints(RealVector individual) {
       var constrainedTestFunction = (IConstrainedTestFunction)TestFunction;
-      if (constrainedTestFunction != null) {
-        return constrainedTestFunction.CheckConstraints(individual, Objectives);
-      }
-      return new double[0];
+      return constrainedTestFunction != null ? constrainedTestFunction.CheckConstraints(individual, Objectives) : new double[0];
     }
 
@@ -169 +164 @@
       ParameterizeAnalyzers();
     }
+
     protected override void OnEvaluatorChanged() {
       base.OnEvaluatorChanged();
@@ -199 +195 @@
     #region Helpers
     private void InitializeOperators() {
-      Operators.Add(new CrowdingAnalyzer());
-      Operators.Add(new GenerationalDistanceAnalyzer());
-      Operators.Add(new InvertedGenerationalDistanceAnalyzer());
-      Operators.Add(new HypervolumeAnalyzer());
-      Operators.Add(new SpacingAnalyzer());
+      Operators.Add(new Analysis.CrowdingAnalyzer());
+      Operators.Add(new Analysis.GenerationalDistanceAnalyzer());
+      Operators.Add(new Analysis.InvertedGenerationalDistanceAnalyzer());
+      Operators.Add(new Analysis.HypervolumeAnalyzer());
+      Operators.Add(new Analysis.SpacingAnalyzer());
+      Operators.Add(new Analysis.TimelineAnalyzer());
       Operators.Add(new ScatterPlotAnalyzer());
-
-      ParameterizeAnalyzers();
-    }
-
-    private IEnumerable<IMultiObjectiveTestFunctionAnalyzer> Analyzers {
-      get { return Operators.OfType<IMultiObjectiveTestFunctionAnalyzer>(); }
-    }
+      ParameterizeAnalyzers();
+    }
+
+    private IEnumerable<IMultiObjectiveTestFunctionAnalyzer> Analyzers => Operators.OfType<IMultiObjectiveTestFunctionAnalyzer>();
 
     private void ParameterizeAnalyzers() {
@@ -219 +213 @@
         analyzer.TestFunctionParameter.ActualName = TestFunctionParameter.Name;
         analyzer.BestKnownFrontParameter.ActualName = BestKnownFrontParameter.Name;
-
-        var scatterPlotAnalyzer = analyzer as ScatterPlotAnalyzer;
-        if (scatterPlotAnalyzer != null) {
+        if (analyzer is ScatterPlotAnalyzer scatterPlotAnalyzer) 
           scatterPlotAnalyzer.IndividualsParameter.ActualName = Encoding.Name;
-        }
       }
     }
-
     #endregion
   }