moeoBinaryQualityIndicator.h

// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-

//-----------------------------------------------------------------------------
// moeoBinaryQualityIndicator.h
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2006
/*
    This library...

    Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
 */
//-----------------------------------------------------------------------------

#ifndef _moeoBinaryQualityIndicator_h
#define _moeoBinaryQualityIndicator_h

// for std::exceptions
#include <stdexcept>
// for eoBF
#include <eoFunctor.h>


template < class EOFitness > class moeoBinaryQualityIndicator:public eoBF < const EOFitness &, const EOFitness &,
  double >
{

public:

  moeoBinaryQualityIndicator ():eoBF < const EOFitness &, const EOFitness &,
    double >()
  {
    bounds.reserve (traits::nObjectives ());
    bounds.resize (traits::nObjectives ());
  }


  void setBounds (const unsigned _iObj, const double _min, const double _max)
  {
    bounds[_iObj] = Range (_min, _max);
  }


protected:

  class Range
  {
  public:
    Range ()
    {
      min = 0;
      max = 0;
      r = 0;
    }
    Range (const double _min, const double _max)
    {
      min = _min;
      max = _max;
      r = max - min;
      if (r < 0)
        throw std::logic_error ("Negative range in eoBinaryQualityIndicator");
    }
    double minimum ()
    {
      return min;
    }
    double maximum ()
    {
      return max;
    }
    double range ()
    {
      return r;
    }
  private:
    double min, max, r;
  };


  std::vector < Range > bounds;


private:

  typedef typename EOFitness::fitness_traits traits;

};





template < class EOFitness > class moeoAdditiveBinaryEpsilonIndicator:public moeoBinaryQualityIndicator <
  EOFitness
  >
{

public:

moeoAdditiveBinaryEpsilonIndicator ():moeoBinaryQualityIndicator < EOFitness >
    ()
  {
  }


  double operator  () (const EOFitness & _fitness_eo1,
                       const EOFitness & _fitness_eo2)
  {
    double epsilon, tmp;
    // computation of the epsilon value for the first objective
    epsilon = epsilonValue (_fitness_eo1, _fitness_eo2, 0);
    // computation of the epsilon value for other objectives
    for (unsigned i = 1; i < traits::nObjectives (); i++)
      {
        tmp = epsilonValue (_fitness_eo1, _fitness_eo2, i);
        epsilon = std::max (epsilon, tmp);
      }
    // the maximum epsilon value
    return epsilon;
  }


private:

  typedef typename EOFitness::fitness_traits traits;
  using moeoBinaryQualityIndicator < EOFitness >::bounds;


  double epsilonValue (const EOFitness & _fitness_eo1,
                       const EOFitness & _fitness_eo2, const unsigned _iObj)
  {
    double result;
    if (bounds[_iObj].range () == 0)
      {
        // min==max => every individuals has the same value for this objective      
        result = 0;
      }
    else
      {
        // computation of the epsilon value for the objective _iObj (in case of a minimization)
        result =
          (_fitness_eo1[_iObj] -
           bounds[_iObj].minimum ()) / bounds[_iObj].range ();
        result -=
          (_fitness_eo2[_iObj] -
           bounds[_iObj].minimum ()) / bounds[_iObj].range ();
        // if we are maximizing, invert the value
        if (traits::maximizing (_iObj))
          result = -result;
      }
    // the espilon value
    return result;
  }

};





template < class EOFitness > class moeoBinaryHypervolumeIndicator:public moeoBinaryQualityIndicator <
  EOFitness >
{

public:

moeoBinaryHypervolumeIndicator (double _rho):moeoBinaryQualityIndicator < EOFitness >
    ()
  {
    rho = _rho;
    // consistency check
    if (rho < 1)
      {
        cout <<
          "Warning, reference point rho for the hypervolume calculation must not be smaller than 1"
          << endl;
        cout << "Adjusted to 1" << endl;
        rho = 1;
      }
  }


  double operator  () (const EOFitness & _fitness_eo1,
                       const EOFitness & _fitness_eo2)
  {
    double result;
    if (_fitness_eo1.dominates (_fitness_eo2))
      result =
        -hypervolumeIndicatorValue (_fitness_eo1, _fitness_eo2,
                                    traits::nObjectives ());
    else
      result =
        hypervolumeIndicatorValue (_fitness_eo2, _fitness_eo1,
                                   traits::nObjectives ());
    return result;
  }


private:

  typedef typename EOFitness::fitness_traits traits;
  using moeoBinaryQualityIndicator < EOFitness >::bounds;

  double rho;


  double hypervolumeIndicatorValue (const EOFitness & _fitness_eo1,
                                    const EOFitness & _fitness_eo2,
                                    const unsigned _iObj, const bool _flag =
                                    false)
  {
    double result;
    if (bounds[_iObj - 1].range () == 0)
      {
        // min==max => every individuals as the same value for this objective      
        result = 0;
      }
    else
      {
        if (traits::maximizing (_iObj - 1))     // maximizing
          result =
            hypervolumeIndicatorValueMax (_fitness_eo1, _fitness_eo2, _iObj,
                                          _flag);
        else                    // minimizing
          result =
            hypervolumeIndicatorValueMin (_fitness_eo1, _fitness_eo2, _iObj,
                                          _flag);
      }
    return result;
  }


  double hypervolumeIndicatorValueMin (const EOFitness & _fitness_eo1,
                                       const EOFitness & _fitness_eo2,
                                       const unsigned _iObj, const bool _flag)
  {
    double result;
    double r = rho * bounds[_iObj - 1].range ();
    double max = bounds[_iObj - 1].minimum () + r;
    // fitness of individuals _eo1 and _eo2 for the objective _iObj (if flag==true, _eo2 is not taken into account)
    double fitness_eo1 = _fitness_eo1[_iObj - 1];
    double fitness_eo2;
    if (_flag)
      fitness_eo2 = max;
    else
      fitness_eo2 = _fitness_eo2[_iObj - 1];
    // computation of the volume
    if (_iObj == 1)
      {
        if (fitness_eo1 < fitness_eo2)
          result = (fitness_eo2 - fitness_eo1) / r;
        else
          result = 0;
      }
    else
      {
        if (fitness_eo1 < fitness_eo2)
          {
            result =
              hypervolumeIndicatorValue (_fitness_eo1, _fitness_eo2,
                                         _iObj - 1) * (max - fitness_eo2) / r;
            result +=
              hypervolumeIndicatorValue (_fitness_eo1, _fitness_eo2,
                                         _iObj - 1,
                                         true) * (fitness_eo2 -
                                                  fitness_eo1) / r;
          }
        else
          result =
            hypervolumeIndicatorValue (_fitness_eo1, _fitness_eo2,
                                       _iObj - 1) * (max - fitness_eo2) / r;
      }
    // the volume
    return result;
  }


  double hypervolumeIndicatorValueMax (const EOFitness & _fitness_eo1,
                                       const EOFitness & _fitness_eo2,
                                       const unsigned _iObj, const bool _flag)
  {
    double result;
    double r = rho * bounds[_iObj - 1].range ();
    double min = bounds[_iObj - 1].maximum () - r;
    // fitness of individuals _eo1 and _eo2 for the objective _iObj (if flag==true, _eo2 is not taken into account)
    double fitness_eo1 = _fitness_eo1[_iObj - 1];
    double fitness_eo2;
    if (_flag)
      fitness_eo2 = min;
    else
      fitness_eo2 = _fitness_eo2[_iObj - 1];
    // computation of the volume
    if (_iObj == 1)
      {
        if (fitness_eo1 > fitness_eo2)
          result = (fitness_eo1 - fitness_eo2) / r;
        else
          result = 0;
      }
    else
      {
        if (fitness_eo1 > fitness_eo2)
          {
            result =
              hypervolumeIndicatorValue (_fitness_eo1, _fitness_eo2,
                                         _iObj - 1) * (fitness_eo2 - min) / r;
            result +=
              hypervolumeIndicatorValue (_fitness_eo1, _fitness_eo2,
                                         _iObj - 1,
                                         true) * (fitness_eo1 -
                                                  fitness_eo2) / r;
          }
        else
          result =
            hypervolumeIndicatorValue (_fitness_eo1, _fitness_eo2,
                                       _iObj - 1) * (fitness_eo2 - min) / r;
      }
    // the volume
    return result;
  }

};

#endif

---