moeoNormalizedSolutionVsSolutionBinaryMetric.h

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

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

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

#ifndef MOEONORMALIZEDSOLUTIONVSSOLUTIONBINARYMETRIC_H_
#define MOEONORMALIZEDSOLUTIONVSSOLUTIONBINARYMETRIC_H_

#include <stdexcept>
#include <metric/moeoMetric.h>


template < class ObjectiveVector, class R >
class moeoNormalizedSolutionVsSolutionBinaryMetric : public moeoSolutionVsSolutionBinaryMetric < ObjectiveVector, R >
{
public:

    moeoNormalizedSolutionVsSolutionBinaryMetric()
    {
        bounds.resize(ObjectiveVector::Traits::nObjectives());
    }


    void setup(double _min, double _max, unsigned _obj)
    {
        if (_min == _max)
        {
            _min -= tiny();
            _max += tiny();
        }
        bounds[_obj] = eoRealInterval(_min, _max);
    }

    virtual void setup(eoRealInterval _realInterval, unsigned _obj)
    {
        bounds[_obj] = _realInterval;
    }


    static double tiny()
    {
        return 1e-6;
    }


protected:

    std::vector < eoRealInterval > bounds;

};


template < class ObjectiveVector >
class moeoAdditiveEpsilonBinaryMetric : public moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double >
{
public:

    double operator()(const ObjectiveVector & _o1, const ObjectiveVector & _o2)
    {
        // computation of the epsilon value for the first objective
        double result = epsilon(_o1, _o2, 0);
        // computation of the epsilon value for the other objectives
        double tmp;
        for (unsigned i=1; i<ObjectiveVector::Traits::nObjectives(); i++)
        {
            tmp = epsilon(_o1, _o2, i);
            result = std::max(result, tmp);
        }
        // returns the maximum epsilon value
        return result;
    }


private:

    using moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > :: bounds;


    double epsilon(const ObjectiveVector & _o1, const ObjectiveVector & _o2, const unsigned _obj)
    {
        double result;
        // if the objective _obj have to be minimized
        if (ObjectiveVector::Traits::minimizing(_obj))
        {
            // _o1[_obj] - _o2[_obj]
            result = ( (_o1[_obj] - bounds[_obj].minimum()) / bounds[_obj].range() ) - ( (_o2[_obj] - bounds[_obj].minimum()) / bounds[_obj].range() );
        }
        // if the objective _obj have to be maximized
        else
        {
            // _o2[_obj] - _o1[_obj]
            result = ( (_o2[_obj] - bounds[_obj].minimum()) / bounds[_obj].range() ) - ( (_o1[_obj] - bounds[_obj].minimum()) / bounds[_obj].range() );
        }
        return result;
    }

};


template < class ObjectiveVector >
class moeoHypervolumeBinaryMetric : public moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double >
{
public:

    moeoHypervolumeBinaryMetric(double _rho = 1.1) : rho(_rho)
    {
        // not-a-maximization problem check
        for (unsigned i=0; i<ObjectiveVector::Traits::nObjectives(); i++)
        {
            if (ObjectiveVector::Traits::maximizing(i))
            {
                throw std::runtime_error("Hypervolume binary metric not yet implemented for a maximization problem in moeoHypervolumeBinaryMetric");
            }
        }
        // consistency check
        if (rho < 1)
        {
            cout << "Warning, value used to compute the reference point rho for the hypervolume calculation must not be smaller than 1" << endl;
            cout << "Adjusted to 1" << endl;
            rho = 1;
        }
    }


    double operator()(const ObjectiveVector & _o1, const ObjectiveVector & _o2)
    {
        double result;
        // if _o1 dominates _o2
        if ( paretoComparator(_o1,_o2) )
        {
            result = - hypervolume(_o1, _o2, ObjectiveVector::Traits::nObjectives()-1);
        }
        else
        {
            result = hypervolume(_o2, _o1, ObjectiveVector::Traits::nObjectives()-1);
        }
        return result;
    }


private:

    double rho;
    using moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > :: bounds;
    moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator;

    double hypervolume(const ObjectiveVector & _o1, const ObjectiveVector & _o2, const unsigned _obj, const bool _flag = false)
    {
        double result;
        double range = rho * bounds[_obj].range();
        double max = bounds[_obj].minimum() + range;
        // value of _1 for the objective _obj
        double v1 = _o1[_obj];
        // value of _2 for the objective _obj (if _flag=true, v2=max)
        double v2;
        if (_flag)
        {
            v2 = max;
        }
        else
        {
            v2 = _o2[_obj];
        }
        // computation of the volume
        if (_obj == 0)
        {
            if (v1 < v2)
            {
                result = (v2 - v1) / range;
            }
            else
            {
                result = 0;
            }
        }
        else
        {
            if (v1 < v2)
            {
                result = ( hypervolume(_o1, _o2, _obj-1, true) * (v2 - v1) / range ) + ( hypervolume(_o1, _o2, _obj-1) * (max - v2) / range );
            }
            else
            {
                result = hypervolume(_o1, _o2, _obj-1) * (max - v2) / range;
            }
        }
        return result;
    }

};


#endif /*MOEONORMALIZEDSOLUTIONVSSOLUTIONBINARYMETRIC_H_*/

---