Changeset 3154

Timestamp:

03/22/10 01:20:49 (15 years ago)

Author:

abeham

Message:

Updated test functions problem #934

Location:

trunk/sources/HeuristicLab.Problems.TestFunctions.SingleObjective/3.3

Files:

• Evaluators/AckleyEvaluator.cs (modified) (3 diffs)
• Evaluators/BealeEvaluator.cs (modified) (5 diffs)
• Evaluators/BoothEvaluator.cs (modified) (5 diffs)
• Evaluators/GriewangkEvaluator.cs (modified) (5 diffs)
• Evaluators/LevyEvaluator.cs (modified) (5 diffs)
• Evaluators/MatyasEvaluator.cs (modified) (5 diffs)
• Evaluators/RastriginEvaluator.cs (modified) (4 diffs)
• Evaluators/RosenbrockEvaluator.cs (modified) (5 diffs)
• Evaluators/SchwefelEvaluator.cs (modified) (5 diffs)
• Evaluators/SphereEvaluator.cs (modified) (5 diffs)
• Evaluators/ZakharovEvaluator.cs (modified) (5 diffs)
• HeuristicLab.Problems.TestFunctions.SingleObjective-3.3.csproj (modified) (1 diff)
• SingleObjectiveTestFunction.cs (modified) (4 diffs)

trunk/sources/HeuristicLab.Problems.TestFunctions.SingleObjective/3.3/Evaluators/AckleyEvaluator.cs

@@ -22 +22 @@
 using System;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.TestFunctions.SingleObjective {
@@ -32 +32 @@
   /// Optimum: 0.0 at (0, 0, ..., 0)
   /// </summary
-  [Item("AckleyEvaluator", "Evaluates the Ackley function on a given point. The optimum of the Ackley Function is 0 at the origin.")]
+  [Item("AckleyEvaluator", "Evaluates the Ackley function on a given point. The optimum of this function is 0 at the origin.")]
   [StorableClass]
   public class AckleyEvaluator : SingleObjectiveTestFunctionEvaluator {
@@ -42 +42 @@
     }
     /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
     /// Gets the lower and upper bound of the function.
     /// </summary>
     public override DoubleMatrix Bounds {
       get { return new DoubleMatrix(new double[,] { { -32.768, 32.768 } }); }
-    }
-    /// <summary>
-    /// Gets the optimum function value (0).
-    /// </summary>
-    public override double BestKnownQuality {
-      get { return 0; }
     }
     /// <summary>

trunk/sources/HeuristicLab.Problems.TestFunctions.SingleObjective/3.3/Evaluators/BealeEvaluator.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -21 +21 @@
 
 using System;
-using System.Collections.Generic;
-using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.TestFunctions { 
+namespace HeuristicLab.Problems.TestFunctions.SingleObjective {
   /// <summary>
   /// Beale Function<br/>
@@ -30 +32 @@
   /// Optimum: 0.0 at (3.0, 0.5)
   /// </summary>
-  public class BealeEvaluator : TestFunctionEvaluatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return
-@"Beale Function
-
-Domain:  [-4.5 , 4.5]^2
-Optimum: 0.0 at (3.0, 0.5)";
-          }
+  [Item("BealeEvaluator", "Evaluates the Beale function on a given point. The optimum of this function is 0 at (3,0.5).")]
+  [StorableClass]
+  public class BealeEvaluator : SingleObjectiveTestFunctionEvaluator {
+    /// <summary>
+    /// Returns false as the Beale function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -4.5, 4.5 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (2).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 2; }
+    }
+    /// <summary>
+    /// Gets the maximum problem size (2).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return 2; }
     }
 
@@ -46 +71 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Beale function at the given point.</returns>
-    public static double Apply(double[] point) {
+    public static double Apply(RealVector point) {
       return Math.Pow(1.5 - point[0] * (1 - point[1]), 2) + Math.Pow(2.25 - point[0] * (1 - (point[1] * point[1])), 2) + Math.Pow((2.625 - point[0] * (1 - (point[1] * point[1] * point[1]))), 2);
     }
@@ -56 +81 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Beale function at the given point.</returns>
-    protected override double EvaluateFunction(double[] point) {
+    protected override double EvaluateFunction(RealVector point) {
       return Apply(point);
     }

trunk/sources/HeuristicLab.Problems.TestFunctions.SingleObjective/3.3/Evaluators/BoothEvaluator.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -21 +21 @@
 
 using System;
-using System.Collections.Generic;
-using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.TestFunctions {
+namespace HeuristicLab.Problems.TestFunctions.SingleObjective {
   /// <summary>
   /// Booth Function<br/>
@@ -30 +32 @@
   /// Optimum: 0.0 at (1.0, 3.0)
   /// </summary>
-  public class BoothEvaluator : TestFunctionEvaluatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get {
-        return
-          @"Booth Function
-
-Domain:  [-10.0 , 10.0]^2
-Optimum: 0.0 at (1.0, 3.0)";
-      }
+  [Item("BoothEvaluator", "Evaluates the Booth function on a given point. The optimum of this function is 0 at (1,3).")]
+  [StorableClass]
+  public class BoothEvaluator : SingleObjectiveTestFunctionEvaluator {
+    /// <summary>
+    /// Returns false as the Booth function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -10, 10 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (2).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 2; }
+    }
+    /// <summary>
+    /// Gets the maximum problem size (2).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return 2; }
     }
 
@@ -47 +71 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Booth function at the given point.</returns>
-    public static double Apply(double[] point) {
+    public static double Apply(RealVector point) {
       return Math.Pow(point[0] + 2 * point[1] - 7, 2) + Math.Pow(2 * point[0] + point[1] - 5, 2);
     }
@@ -57 +81 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Booth function at the given point.</returns>
-    protected override double EvaluateFunction(double[] point) {
+    protected override double EvaluateFunction(RealVector point) {
       return Apply(point);
     }

trunk/sources/HeuristicLab.Problems.TestFunctions.SingleObjective/3.3/Evaluators/GriewangkEvaluator.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -21 +21 @@
 
 using System;
-using System.Collections.Generic;
-using System.Text;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Operators;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.TestFunctions {
+namespace HeuristicLab.Problems.TestFunctions.SingleObjective {
   /// <summary>
   /// Griewangk Function<br/>
@@ -33 +32 @@
   /// Optimum: 0.0 at (0, 0, ..., 0)
   /// </summary>
-  public class GriewangkEvaluator : TestFunctionEvaluatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return
-@"Griewangk Function
-
-Domain:  [-600.0 , 600.0]^n
-Optimum: 0.0 at (0, 0, ..., 0)";
-          }
+  [Item("GriewangkEvaluator", "Evaluates the Griewangk function on a given point. The optimum of this function is 0 at the origin.")]
+  [StorableClass]
+  public class GriewangkEvaluator : SingleObjectiveTestFunctionEvaluator {
+    /// <summary>
+    /// Returns false as the Griewangk function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -600, 600 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (2).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 2; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
     }
 
@@ -49 +71 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Griewangk function at the given point.</returns>
-    public static double Apply(double[] point) {
+    public static double Apply(RealVector point) {
       double result = 0;
       double val = 0;
@@ -71 +93 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Griewangk function at the given point.</returns>
-    protected override double EvaluateFunction(double[] point) {
+    protected override double EvaluateFunction(RealVector point) {
       return Apply(point);
     }

trunk/sources/HeuristicLab.Problems.TestFunctions.SingleObjective/3.3/Evaluators/LevyEvaluator.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -21 +21 @@
 
 using System;
-using System.Collections.Generic;
-using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.TestFunctions {
+namespace HeuristicLab.Problems.TestFunctions.SingleObjective {
   /// <summary>
   /// Levy Function<br/>
@@ -30 +32 @@
   /// Optimum: 0.0 at (1.0, 1.0, ..., 1.0)
   /// </summary>
-  public class LevyEvaluator : TestFunctionEvaluatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return
-@"Levy Function
-
-Domain:  [-10.0 , 10.0]^n
-Optimum: 0.0 at (1.0, 1.0, ..., 1.0)";
-          }
+  [Item("LevyEvaluator", "Evaluates the Levy function on a given point. The optimum of this function is 0 at (1,1,...,1).")]
+  [StorableClass]
+  public class LevyEvaluator : SingleObjectiveTestFunctionEvaluator {
+    /// <summary>
+    /// Returns false as the Levy function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -10, 10 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (2).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 2; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
     }
 
@@ -46 +71 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Levy function at the given point.</returns>
-    public static double Apply(double[] point) {
+    public static double Apply(RealVector point) {
       int length = point.Length;
       double[] z = new double[length];
@@ -70 +95 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Levy function at the given point.</returns>
-    protected override double EvaluateFunction(double[] point) {
+    protected override double EvaluateFunction(RealVector point) {
       return Apply(point);
     }

trunk/sources/HeuristicLab.Problems.TestFunctions.SingleObjective/3.3/Evaluators/MatyasEvaluator.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -21 +21 @@
 
 using System;
-using System.Collections.Generic;
-using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.TestFunctions {
+namespace HeuristicLab.Problems.TestFunctions.SingleObjective {
   /// <summary>
   /// Matyas Function<br/>
@@ -30 +32 @@
   /// Optimum: 0.0 at (0.0, 0.0)
   /// </summary>
-  public class MatyasEvaluator : TestFunctionEvaluatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return
-@"Matyas Function
-
-Domain:  [-10.0 , 10.0]^2
-Optimum: 0.0 at (0.0, 0.0)";
-          }
+  [Item("MatyasEvaluator", "Evaluates the Matyas function on a given point. The optimum of this function is 0 at the origin.")]
+  [StorableClass]
+  public class MatyasEvaluator : SingleObjectiveTestFunctionEvaluator {
+    /// <summary>
+    /// Returns false as the Beale function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -10, 10 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (2).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 2; }
+    }
+    /// <summary>
+    /// Gets the maximum problem size (2).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return 2; }
     }
 
@@ -46 +71 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Matyas function at the given point.</returns>
-    public static double Apply(double[] point) {
+    public static double Apply(RealVector point) {
       return 0.26 * (point[0] * point[0] + point[1] * point[1]) - 0.48 * point[0] * point[1];
     }
@@ -56 +81 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Matyas function at the given point.</returns>
-    protected override double EvaluateFunction(double[] point) {
+    protected override double EvaluateFunction(RealVector point) {
       return Apply(point);
     }

trunk/sources/HeuristicLab.Problems.TestFunctions.SingleObjective/3.3/Evaluators/RastriginEvaluator.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -21 +21 @@
 
 using System;
-using System.Collections.Generic;
-using System.Text;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Operators;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.TestFunctions {
+namespace HeuristicLab.Problems.TestFunctions.SingleObjective {
   /// <summary>
   /// Rastrigin Function<br/>
-  /// Domain:  [-5.12 , 5.12]^n<br/>
+  /// Domain:  [-5.12 , 5.12]^n <br/>
   /// Optimum: 0.0 at (0, 0, ..., 0)
-  /// </summary>
-  public class RastriginEvaluator : TestFunctionEvaluatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return
-@"Rastrigin Function
-
-Domain:  [-5.12 , 5.12]^n
-Optimum: 0.0 at (0, 0, ..., 0)";
-          }
+  /// </summary
+  [Item("RastriginEvaluator", "Evaluates the Rastrigin function on a given point. The optimum of this function is 0 at the origin.")]
+  [StorableClass]
+  public class RastriginEvaluator : SingleObjectiveTestFunctionEvaluator {
+    /// <summary>
+    /// Returns false as the Rastrigin function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -5.12, 5.12 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (1).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 1; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
     }
 
@@ -49 +71 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Rastrigin function at the given point.</returns>
-    public static double Apply(double[] point) {
+    public static double Apply(RealVector point) {
       double result = 10 * point.Length;
       for (int i = 0; i < point.Length; i++) {
@@ -64 +86 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Rastrigin function at the given point.</returns>
-    protected override double EvaluateFunction(double[] point) {
+    protected override double EvaluateFunction(RealVector point) {
       return Apply(point);
     }

trunk/sources/HeuristicLab.Problems.TestFunctions.SingleObjective/3.3/Evaluators/RosenbrockEvaluator.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -21 +21 @@
 
 using System;
-using System.Collections.Generic;
-using System.Text;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Operators;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.TestFunctions {
+namespace HeuristicLab.Problems.TestFunctions.SingleObjective {
   /// <summary>
   /// Rosenbrock Function<br/>
@@ -33 +32 @@
   /// Optimum: 0.0 at (1, 1, ..., 1)
   /// </summary>
-  public class RosenbrockEvaluator : TestFunctionEvaluatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return
-@"Rosenbrock Function
-
-Domain:  [-2.048 , 2.048]^n
-Optimum: 0.0 at (1, 1, ..., 1)";
-          }
+  [Item("RosenbrockEvaluator", "Evaluates the Rosenbrock function on a given point. The optimum of this function is 0 at (1,1,...,1).")]
+  [StorableClass]
+  public class RosenbrockEvaluator : SingleObjectiveTestFunctionEvaluator {
+    /// <summary>
+    /// Returns false as the Rosenbrock function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -2.048, 2.048 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (2).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 2; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
     }
 
@@ -49 +71 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Rosenbrock function at the given point.</returns>
-    public static double Apply(double[] point) {
+    public static double Apply(RealVector point) {
       double result = 0;
       for (int i = 0; i < point.Length - 1; i++) {
@@ -64 +86 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Rosenbrock function at the given point.</returns>
-    protected override double EvaluateFunction(double[] point) {
+    protected override double EvaluateFunction(RealVector point) {
       return Apply(point);
     }

trunk/sources/HeuristicLab.Problems.TestFunctions.SingleObjective/3.3/Evaluators/SchwefelEvaluator.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -21 +21 @@
 
 using System;
-using System.Collections.Generic;
-using System.Text;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Operators;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.TestFunctions {
+namespace HeuristicLab.Problems.TestFunctions.SingleObjective {
   /// <summary>
   /// Schwefel Function (Sine Root)<br/>
@@ -33 +32 @@
   /// Optimum: 0.0 at (420.968746453712, 420.968746453712, ..., 420.968746453712)
   /// </summary>
-  public class SchwefelEvaluator : TestFunctionEvaluatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return
-@"Schwefel Function (Sine Root)
-
-Domain:  [-500.0 , 500.0]^n
-Optimum: 0.0 at (420.968746453712, 420.968746453712, ..., 420.968746453712)";
-          }
+  [Item("SchwefelEvaluator", "Evaluates the Schwefel function on a given point. The optimum of this function is 0 at (420.968746453712,420.968746453712,...,420.968746453712).")]
+  [StorableClass]
+  public class SchwefelEvaluator : SingleObjectiveTestFunctionEvaluator {
+    /// <summary>
+    /// Returns false as the Rosenbrock function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -500, 500 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (1).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 1; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
     }
 
@@ -49 +71 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Schwefel function at the given point.</returns>
-    public static double Apply(double[] point) {
+    public static double Apply(RealVector point) {
       double result = 418.982887272433 * point.Length;
       for (int i = 0; i < point.Length; i++)
@@ -62 +84 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Schwefel function at the given point.</returns>
-    protected override double EvaluateFunction(double[] point) {
+    protected override double EvaluateFunction(RealVector point) {
       return Apply(point);
     }

trunk/sources/HeuristicLab.Problems.TestFunctions.SingleObjective/3.3/Evaluators/SphereEvaluator.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -21 +21 @@
 
 using System;
-using System.Collections.Generic;
-using System.Text;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Operators;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.TestFunctions {
+namespace HeuristicLab.Problems.TestFunctions.SingleObjective {
   /// <summary>
   /// Sphere Function<br/>
@@ -33 +32 @@
   /// Optimum: 0.0 at (0, 0, ..., 0)
   /// </summary>
-  public class SphereEvaluator : TestFunctionEvaluatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return
-@"Sphere Function
-
-Domain:  [-5.12 , 5.12]^n
-Optimum: 0.0 at (0, 0, ..., 0)";
-          }
+  [Item("SphereEvaluator", "Evaluates the Sphere function on a given point. The optimum of this function is 0 at the origin.")]
+  [StorableClass]
+  public class SphereEvaluator : SingleObjectiveTestFunctionEvaluator {
+    /// <summary>
+    /// Returns false as the Rosenbrock function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -5.12, 5.12 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (1).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 1; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
     }
 
@@ -49 +71 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Sphere function at the given point.</returns>
-    public static double Apply(double[] point) {
+    public static double Apply(RealVector point) {
       double result = 0;
       for (int i = 0; i < point.Length; i++)
@@ -62 +84 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Sphere function at the given point.</returns>
-    protected override double EvaluateFunction(double[] point) {
+    protected override double EvaluateFunction(RealVector point) {
       return Apply(point);
     }

trunk/sources/HeuristicLab.Problems.TestFunctions.SingleObjective/3.3/Evaluators/ZakharovEvaluator.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -21 +21 @@
 
 using System;
-using System.Collections.Generic;
-using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.TestFunctions {
+namespace HeuristicLab.Problems.TestFunctions.SingleObjective {
   /// <summary>
   /// Zakharov Function<br/>
@@ -30 +32 @@
   /// Optimum: 0.0 at (0.0, 0.0, ..., 0.0)
   /// </summary>
-  public class ZakharovEvaluator : TestFunctionEvaluatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return
-@"Zakharov Function
-
-Domain:  [-5.0 , 10.0]^n
-Optimum: 0.0 at (0.0, 0.0, ..., 0.0)";
-          }
+  [Item("ZakharovEvaluator", "Evaluates the Zakharov function on a given point. The optimum of this function is 0 at the origin.")]
+  [StorableClass]
+  public class ZakharovEvaluator : SingleObjectiveTestFunctionEvaluator {
+    /// <summary>
+    /// Returns false as the Ackley function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -5, 10 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (1).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 1; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
     }
 
@@ -46 +71 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Zakharov function at the given point.</returns>
-    public static double Apply(double[] point) {
+    public static double Apply(RealVector point) {
       int length = point.Length;
       double s1 = 0;
@@ -64 +89 @@
     /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
     /// <returns>The result value of the Zakharov function at the given point.</returns>
-    protected override double EvaluateFunction(double[] point) {
+    protected override double EvaluateFunction(RealVector point) {
       return Apply(point);
     }

trunk/sources/HeuristicLab.Problems.TestFunctions.SingleObjective/3.3/HeuristicLab.Problems.TestFunctions.SingleObjective-3.3.csproj

@@ -53 +53 @@
   <ItemGroup>
     <Compile Include="Evaluators\AckleyEvaluator.cs" />
+    <Compile Include="Evaluators\BealeEvaluator.cs" />
+    <Compile Include="Evaluators\BoothEvaluator.cs" />
+    <Compile Include="Evaluators\GriewangkEvaluator.cs" />
+    <Compile Include="Evaluators\LevyEvaluator.cs" />
+    <Compile Include="Evaluators\MatyasEvaluator.cs" />
+    <Compile Include="Evaluators\RastriginEvaluator.cs" />
+    <Compile Include="Evaluators\RosenbrockEvaluator.cs" />
+    <Compile Include="Evaluators\SchwefelEvaluator.cs" />
     <Compile Include="Evaluators\SingleObjectiveTestFunctionEvaluator.cs" />
+    <Compile Include="Evaluators\SphereEvaluator.cs" />
+    <Compile Include="Evaluators\ZakharovEvaluator.cs" />
     <Compile Include="HeuristicLabProblemsTestFunctionsSingleObjectivePlugin.cs" />
     <Compile Include="Interfaces\ISingleObjectiveTestFunctionEvaluator.cs" />

trunk/sources/HeuristicLab.Problems.TestFunctions.SingleObjective/3.3/SingleObjectiveTestFunction.cs

@@ -83 +83 @@
 
     #region Properties
+    public BoolValue Maximization {
+      get { return MaximizationParameter.Value; }
+      set { MaximizationParameter.Value = value; }
+    }
     public DoubleMatrix Bounds {
       get { return BoundsParameter.Value; }
@@ -193 +197 @@
     private void EvaluatorParameter_ValueChanged(object sender, EventArgs e) {
       ParameterizeEvaluator();
+      Maximization.Value = Evaluator.Maximization;
+      BoundsParameter.Value = Evaluator.Bounds;
+      if (ProblemSize.Value < Evaluator.MinimumProblemSize)
+        ProblemSize.Value = Evaluator.MinimumProblemSize;
+      else if (ProblemSize.Value > Evaluator.MaximumProblemSize)
+        ProblemSize.Value = Evaluator.MaximumProblemSize;
+      BestKnownQuality = new DoubleValue(Evaluator.BestKnownQuality);
       Evaluator_QualityParameter_ActualNameChanged(null, EventArgs.Empty);
     }
@@ -200 +211 @@
     private void VisualizerParameter_ValueChanged(object sender, EventArgs e) {
       ParameterizeVisualizer();
+    }
+    private void BoundsParameter_ValueChanged(object sender, EventArgs e) {
+      Bounds.ToStringChanged += new EventHandler(Bounds_ToStringChanged);
+      Bounds_ToStringChanged(null, EventArgs.Empty);
+    }
+    private void Bounds_ToStringChanged(object sender, EventArgs e) {
+      if (Bounds.Columns != 2 || Bounds.Rows < 1)
+        Bounds = new DoubleMatrix(1, 2);
+    }
+    private void Bounds_ItemChanged(object sender, EventArgs<int, int> e) {
+      if (e.Value2 == 0 && Bounds[e.Value, 1] <= Bounds[e.Value, 0])
+        Bounds[e.Value, 1] = Bounds[e.Value, 0] + 0.1;
+      if (e.Value2 == 1 && Bounds[e.Value, 0] >= Bounds[e.Value, 1])
+        Bounds[e.Value, 0] = Bounds[e.Value, 1] - 0.1;
     }
     #endregion
@@ -209 +234 @@
       ProblemSizeParameter.ValueChanged += new EventHandler(ProblemSizeParameter_ValueChanged);
       ProblemSize.ValueChanged += new EventHandler(ProblemSize_ValueChanged);
+      BoundsParameter.ValueChanged += new EventHandler(BoundsParameter_ValueChanged);
+      Bounds.ToStringChanged += new EventHandler(Bounds_ToStringChanged);
+      Bounds.ItemChanged += new EventHandler<EventArgs<int, int>>(Bounds_ItemChanged);
       SolutionCreatorParameter.ValueChanged += new EventHandler(SolutionCreatorParameter_ValueChanged);
       SolutionCreator.RealVectorParameter.ActualNameChanged += new EventHandler(SolutionCreator_RealVectorParameter_ActualNameChanged);