source: branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/MultiObjectiveTestFunction.cs @ 13771

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System.Collections.Generic;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.RealVectorEncoding;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {
  /// <summary>
  /// Base class for a test function evaluator.
  /// </summary>
  [Item("Multi-Objective Function", "Base class for multi objective functions.")]
  [StorableClass]
  public abstract class MultiObjectiveTestFunction : ParameterizedNamedItem, IMultiObjectiveTestFunction {
    public static double[] IllegalValue(int size, bool[] maximization) {
      double[] res = new double[size];
      for (int i = 0; i < size; i++) {
        res[i] = maximization[i] ? double.MinValue : double.MaxValue;
      }
      return res;
    }

    /// <summary>
    /// These operators should not change their name through the GUI
    /// </summary>
    public override bool CanChangeName {
      get { return false; }
    }
    /// <summary>
    /// Returns whether the actual function constitutes a maximization or minimization problem.
    /// </summary>
    public abstract bool[] Maximization(int objectives);
    /// <summary>
    /// Gets the lower and upper bound of the function.
    /// </summary>
    public abstract double[,] Bounds(int objectives);
    /// <summary>
    /// Gets the minimum problem size.
    /// </summary>
    public abstract int MinimumSolutionLength { get; }
    /// <summary>
    /// Gets the maximum problem size.
    /// </summary>
    public abstract int MaximumSolutionLength { get; }


    /// <summary>
    /// Gets and sets the actual solution size.
    /// </summary>
    ///
    [Storable]
    private int objectives;
    /// <summary>
    /// Gets the minimum solution size.
    /// </summary>
    public abstract int MinimumObjectives { get; }
    /// <summary>
    /// Gets the maximum solution size.
    /// </summary>
    public abstract int MaximumObjectives { get; }

    /// <summary>
    /// retrieves the optimal pareto front (if known from a file)
    /// </summary>
    public abstract IEnumerable<double[]> OptimalParetoFront(int objectives);


    /// <summary>
    /// returns a Reference Point for Hypervolume calculation (currently default=(11|11))
    /// </summary>
    public abstract double[] ReferencePoint(int objectives);


    /// <summary>
    /// returns the best known Hypervolume for this Problem   (currently default=-1) 
    /// </summary>
    public virtual double BestKnownHypervolume(int objectives) {
      return -1;
    }

    [StorableConstructor]
    protected MultiObjectiveTestFunction(bool deserializing) : base(deserializing) { }
    protected MultiObjectiveTestFunction(MultiObjectiveTestFunction original, Cloner cloner) : base(original, cloner) {
      this.objectives = original.objectives;
    }
    protected MultiObjectiveTestFunction(int minimumObjectives = 1, int maximumObjectives = int.MaxValue, int minimumSolutionLength = 1, int maximumSolutionLength = int.MaxValue) : base() {
      Parameters.Add(new FixedValueParameter<IntValue>("MinimumObjectives", "The dimensionality of the problem instance (number of variables in the function).", new IntValue(minimumObjectives)));
      Parameters.Add(new FixedValueParameter<IntValue>("MaximumObjectives", "The dimensionality of the problem instance (number of variables in the function).", new IntValue(maximumObjectives)));
      Parameters.Add(new FixedValueParameter<IntValue>("MinimumSolutionLength", "The dimensionality of the problem instance (number of variables in the function).", new IntValue(minimumSolutionLength)));
      Parameters.Add(new FixedValueParameter<IntValue>("MaximumSolutionLength", "The dimensionality of the problem instance (number of variables in the function).", new IntValue(maximumSolutionLength)));
    }

    /// <summary>
    /// Evaluates the test function for a specific <paramref name="point"/>.
    /// </summary>
    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    /// <returns>The result values of the function at the given point.</returns>
    public abstract double[] Evaluate(RealVector point, int objectives);

  }
}