moeoEntropyMetric.h

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

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

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

#ifndef MOEOENTROPYMETRIC_H_
#define MOEOENTROPYMETRIC_H_

#include <metric/moeoMetric.h>

template < class EOT > class moeoEntropyMetric:public moeoVectorVsVectorBM < EOT,
  double >
{
public:

  typedef typename EOT::Fitness EOFitness;

  double operator  () (const std::vector < EOFitness > &_set1,
                       const std::vector < EOFitness > &_set2)
  {
    // normalization
    std::vector < EOFitness > set1 = _set1;
    std::vector < EOFitness > set2 = _set2;
    removeDominated (set1);
    removeDominated (set2);
    prenormalize (set1);
    normalize (set1);
    normalize (set2);

    // making of PO*
    std::vector < EOFitness > star;     // rotf :-)
    computeUnion (set1, set2, star);
    removeDominated (star);

    // making of PO1 U PO*
    std::vector < EOFitness > union_set1_star;  // rotf again ...
    computeUnion (set1, star, union_set1_star);

    unsigned C = union_set1_star.size ();
    float omega = 0;
    float entropy = 0;

    for (unsigned i = 0; i < C; i++)
      {
        unsigned N_i = howManyInNicheOf (union_set1_star, union_set1_star[i],
                                         star.size ());
        unsigned n_i =
          howManyInNicheOf (set1, union_set1_star[i], star.size ());
        if (n_i > 0)
          {
            omega += 1.0 / N_i;
            entropy +=
              (float) n_i / (N_i * C) * log (((float) n_i / C) / log (2.0));
          }
      }
    entropy /= -log (omega);
    entropy *= log (2.0);
    return entropy;
  }


private:

  std::vector < double >vect_min_val;
  std::vector < double >vect_max_val;

  void removeDominated (std::vector < EOFitness > &_f)
  {
    for (unsigned i = 0; i < _f.size (); i++)
      {
        bool dom = false;
        for (unsigned j = 0; j < _f.size (); j++)
          if (i != j && _f[j].dominates (_f[i]))
            {
              dom = true;
              break;
            }
        if (dom)
          {
            _f[i] = _f.back ();
            _f.pop_back ();
            i--;
          }
      }
  }

  void prenormalize (const std::vector < EOFitness > &_f)
  {
    vect_min_val.clear ();
    vect_max_val.clear ();

    for (unsigned char i = 0; i < EOFitness::fitness_traits::nObjectives ();
         i++)
      {
        float min_val = _f.front ()[i], max_val = min_val;
        for (unsigned j = 1; j < _f.size (); j++)
          {
            if (_f[j][i] < min_val)
              min_val = _f[j][i];
            if (_f[j][i] > max_val)
              max_val = _f[j][i];
          }
        vect_min_val.push_back (min_val);
        vect_max_val.push_back (max_val);
      }
  }

  void normalize (std::vector < EOFitness > &_f)
  {
    for (unsigned i = 0; i < EOFitness::fitness_traits::nObjectives (); i++)
      for (unsigned j = 0; j < _f.size (); j++)
        _f[j][i] =
          (_f[j][i] - vect_min_val[i]) / (vect_max_val[i] - vect_min_val[i]);
  }

  void computeUnion (const std::vector < EOFitness > &_f1,
                     const std::vector < EOFitness > &_f2,
                     std::vector < EOFitness > &_f)
  {
    _f = _f1;
    for (unsigned i = 0; i < _f2.size (); i++)
      {
        bool b = false;
        for (unsigned j = 0; j < _f1.size (); j++)
          if (_f1[j] == _f2[i])
            {
              b = true;
              break;
            }
        if (!b)
          _f.push_back (_f2[i]);
      }
  }

  unsigned howManyInNicheOf (const std::vector < EOFitness > &_f,
                             const EOFitness & _s, unsigned _size)
  {
    unsigned n = 0;
    for (unsigned i = 0; i < _f.size (); i++)
      {
        if (euclidianDistance (_f[i], _s) < (_s.size () / (double) _size))
          n++;
      }
    return n;
  }

  double euclidianDistance (const EOFitness & _set1, const EOFitness & _to,
                            unsigned _deg = 2)
  {
    double dist = 0;
    for (unsigned i = 0; i < _set1.size (); i++)
      dist += pow (fabs (_set1[i] - _to[i]), (int) _deg);
    return pow (dist, 1.0 / _deg);
  }

};

#endif /*MOEOENTROPYMETRIC_H_ */

---