eoParetoFitness.h

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

//-----------------------------------------------------------------------------
// eoParetoFitness.h
// (c) Maarten Keijzer and Marc Schoenauer, 2001
/*
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Contact: mak@dhi.dk
             Marc.Schoenauer@inria.fr
 */
//-----------------------------------------------------------------------------

#ifndef _eoParetoFitness_h
#define _eoParetoFitness_h

#include <math.h>
#include <vector>
#include <stdexcept>
#include <iostream>


class eoParetoFitnessTraits
{
  public :

  static unsigned nObjectives()          { return 2; }
  static double tol()               { return 1e-6; }
  static bool maximizing(int which) { return true; } // by default: all are maximizing
};

class eoVariableParetoTraits : public eoParetoFitnessTraits
{
public :
  static void setUp(unsigned _n, std::vector<bool> & _b)
  {
    // possible problems
    if ( nObj && (nObj != _n) )    // was already set to a different value
      {
        std::cout << "WARNING\n";
        std::cout << "WARNING : you are changing the number of objectives\n";
        std::cout << "WARNING : Make sure all existing objects are destroyed\n";
        std::cout << "WARNING\n";
      }
    nObj=_n; 
    bObj=_b;
    if (nObj != bObj.size())
      throw std::runtime_error("Number of objectives and min/max size don't match in VariableParetoTraits::setup");
  }

  static unsigned nObjectives()
  { 
#ifndef NDEBUG
    if (!nObj)
      throw std::runtime_error("Number of objectives not assigned in VariableParetoTraits");
#endif
    return nObj; 
  }
  static bool maximizing(unsigned _i) 
  {
#ifndef NDEBUG
    if (_i >= bObj.size())
      throw std::runtime_error("Wrong index in VariableParetoTraits");
#endif
    return bObj[_i]; 
  }
private:
  static unsigned nObj;
  static std::vector<bool> bObj;
};

template <class FitnessTraits = eoParetoFitnessTraits>
class eoParetoFitness : public std::vector<double>
{
public :

  typedef FitnessTraits fitness_traits;

  eoParetoFitness(void) : std::vector<double>(FitnessTraits::nObjectives(),0.0) {}

  // Ctr from a std::vector<double>
  eoParetoFitness(std::vector<double> & _v) : std::vector<double>(_v) {}
  

  static void setUp(unsigned _n, std::vector<bool> & _b) {FitnessTraits::setUp(_n, _b);}
  static bool maximizing(unsigned _i) { return FitnessTraits::maximizing(_i);}

  //bool operator<(const eoParetoFitness<FitnessTraits>& _other) const
  bool dominates(const eoParetoFitness<FitnessTraits>& _other) const
  {
    bool dom = false;

    double tol = FitnessTraits::tol();
    const std::vector<double>& performance = *this;
    const std::vector<double>& otherperformance = _other;

    for (unsigned i = 0; i < FitnessTraits::nObjectives(); ++i)
    {
      bool maxim = FitnessTraits::maximizing(i);
      double aval = maxim? performance[i] : -performance[i];
      double bval = maxim? otherperformance[i] : -otherperformance[i];

      if (fabs(aval - bval) > tol)
      {
        if (aval < bval)
        {
          return false; // cannot dominate
        }
        // else aval < bval
        dom = true; // for the moment: goto next objective
      }
      //else they're equal in this objective, goto next
    }

    return dom;
  }

  bool operator<(const eoParetoFitness<FitnessTraits>& _other) const
  {
    double tol = FitnessTraits::tol();
    const std::vector<double>& performance = *this;
    const std::vector<double>& otherperformance = _other;
    for (unsigned i = 0; i < FitnessTraits::nObjectives(); ++i)
    {
      bool maxim = FitnessTraits::maximizing(i);
      double aval = maxim? performance[i] : -performance[i];
      double bval = maxim? otherperformance[i] : -otherperformance[i];

      if (fabs(aval-bval) > tol)
      {
        if (aval < bval)
          return true;

        return false;
      }
    }

    return false;
  }

  bool operator>(const eoParetoFitness<FitnessTraits>& _other) const
  {
    return _other < *this;
  }

  bool operator<=(const eoParetoFitness<FitnessTraits>& _other) const
  {
    return operator==(_other) || operator<(_other);
  }

  bool operator>=(const eoParetoFitness<FitnessTraits>& _other) const
  {
    return _other <= *this;
  }

  bool operator==(const eoParetoFitness<FitnessTraits>& _other) const
  { // check if they're all within tolerance
    for (unsigned i = 0; i < size(); ++i)
    {
      if (fabs(operator[](i) - _other[i]) > FitnessTraits::tol())
      {
        return false;
      }
    }
    return true;
  }

  bool operator!=(const eoParetoFitness<FitnessTraits>& _other) const
  { return ! operator==(_other); }

};

template <class FitnessTraits>
std::ostream& operator<<(std::ostream& os, const eoParetoFitness<FitnessTraits>& fitness)
{
  for (unsigned i = 0; i < fitness.size(); ++i)
  {
    os << fitness[i] << ' ';
  }
  return os;
}

template <class FitnessTraits>
std::istream& operator>>(std::istream& is, eoParetoFitness<FitnessTraits>& fitness)
{
  fitness = eoParetoFitness<FitnessTraits>();
  for (unsigned i = 0; i < fitness.size(); ++i)
  {
    is >> fitness[i];
  }
  return is;
}

#endif

---