Class NegativeCostFitnessFunction<T extends Copyable<T>>

Type Parameters:
T - The type of object under optimization.
All Implemented Interfaces:
FitnessFunction<T>, FitnessFunction.Double<T>

public final class NegativeCostFitnessFunction<T extends Copyable<T>> extends Object implements FitnessFunction.Double<T>
This class provides a convenient mechanism for transforming optimization cost values to fitness values. Most of the algorithms in the library require a cost function to minimize through a class that implements either OptimizationProblem or IntegerCostOptimizationProblem. However, the evolutionary algorithms in the library require a fitness function such that higher fitness implies better solution. Furthermore, some selection operators further assume that fitness values are positive, such as FitnessProportionalSelection and StochasticUniversalSampling.

This class transforms the cost of solution s to fitness with the following transformation: fitness(s) = -cost(s), where cost(s) refers to the OptimizationProblem.cost(T) method.

Because this transformation produces negative fitness values, it is not compatible with all selection operators. However, many of the selection operators in the library work even with negative fitness values, such as any selection operator that uses only relative fitness values. For example, TournamentSelection and other selection operators that only care if one fitness is higher or lower than another will work fine with negative fitness values.

Incompatible Selection Operators: The library does include some selection operators that require positive fitness values. Thus, the NegativeIntegerCostFitnessFunction is incompatible with such selection operators, which include the following: FitnessProportionalSelection, StochasticUniversalSampling, BiasedFitnessProportionalSelection, and BiasedStochasticUniversalSampling. The behavior of these selection operators that select population members with probabilities that are proportional to their fitness is undefined for negative fitnesses.

  • Constructor Details

    • NegativeCostFitnessFunction

      public NegativeCostFitnessFunction(OptimizationProblem<T> problem)
      Constructs a fitness function that transforms the cost of solution s to fitness with the following transformation: fitness(s) = -cost(s).
      problem - The optimization problem.
  • Method Details

    • fitness

      public double fitness(T candidate)
      Description copied from interface: FitnessFunction.Double
      Computes the fitness of a candidate solution to a problem, for use by genetic algorithms and other evolutionary algorithms.
      Specified by:
      fitness in interface FitnessFunction.Double<T extends Copyable<T>>
      candidate - The solution whose fitness is to be evaluated.
      the fitness of candidate
    • getProblem

      public OptimizationProblem<T> getProblem()
      Description copied from interface: FitnessFunction
      Gets a reference to the problem that this fitness function is for.
      Specified by:
      getProblem in interface FitnessFunction<T extends Copyable<T>>
      a reference to the problem.