util/hv_algorithm/base.h

/*****************************************************************************
 *   Copyright (C) 2004-2015 The PaGMO development team,                     *
 *   Advanced Concepts Team (ACT), European Space Agency (ESA)               *
 *                                                                           *
 *   https://github.com/esa/pagmo                                            *
 *                                                                           *
 *   act@esa.int                                                             *
 *                                                                           *
 *   This program is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU General Public License as published by    *
 *   the Free Software Foundation; either version 2 of the License, or       *
 *   (at your option) any later version.                                     *
 *                                                                           *
 *   This program 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 General Public License for more details.                            *
 *                                                                           *
 *   You should have received a copy of the GNU General Public License       *
 *   along with this program; if not, write to the                           *
 *   Free Software Foundation, Inc.,                                         *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
 *****************************************************************************/

#ifndef PAGMO_UTIL_HV_ALGORITHM_BASE_H
#define PAGMO_UTIL_HV_ALGORITHM_BASE_H

#include <iostream>
#include <string>
#include <typeinfo>
#include <boost/lexical_cast.hpp>

#include "../../config.h"
#include "../../exceptions.h"
#include "../../serialization.h"
#include "../../types.h"

namespace pagmo { namespace util {

namespace hv_algorithm {

class base;

typedef boost::shared_ptr<base> base_ptr;


class __PAGMO_VISIBLE base
{
public:

        virtual double compute(std::vector<fitness_vector> &points, const fitness_vector &r_point) const = 0;
        virtual double exclusive(const unsigned int, std::vector<fitness_vector> &, const fitness_vector &) const;
        virtual unsigned int least_contributor(std::vector<fitness_vector> &, const fitness_vector &) const;
        virtual unsigned int greatest_contributor(std::vector<fitness_vector> &, const fitness_vector &) const;
        virtual std::vector<double> contributions(std::vector<fitness_vector> &, const fitness_vector &) const;


        virtual void verify_before_compute(const std::vector<fitness_vector> &points, const fitness_vector &r_point) const = 0;


        virtual base_ptr clone() const = 0;

        virtual std::string get_name() const;
        virtual ~base();

protected:
        void assert_minimisation(const std::vector<fitness_vector> &, const fitness_vector &) const;

        virtual unsigned int extreme_contributor(std::vector<fitness_vector> &, const fitness_vector &, bool (*)(double, double)) const;

        // comparison functions for the least and the greatest contributor methods
        static bool cmp_least(const double, const double);
        static bool cmp_greatest(const double, const double);

public:
        static double volume_between(const fitness_vector &, const fitness_vector &, unsigned int = 0);

protected:
        // Domination results of the 'dom_cmp' methods
        enum {
                DOM_CMP_B_DOMINATES_A = 1, // second argument dominates the first one
                DOM_CMP_A_DOMINATES_B = 2, // first argument dominates the second one
                DOM_CMP_A_B_EQUAL = 3, // both points are equal
                DOM_CMP_INCOMPARABLE = 4 // points are incomparable
        };

        static double volume_between(double*, double*, unsigned int);
        static int dom_cmp(double*, double*, unsigned int);
        static int dom_cmp(const fitness_vector &, const fitness_vector &, unsigned int = 0);

private:
        friend class boost::serialization::access;
        template <class Archive>
        void serialize(Archive &ar, const unsigned int) {
                (void)ar;
        }
};


class fitness_vector_cmp
{
public:
        fitness_vector_cmp(int dim, char cmp_type);


        inline bool operator()(const fitness_vector &lhs, const fitness_vector &rhs)
        {
                return (*m_cmp_obj)(lhs,rhs);
        }
private:
        struct cmp_fun
        {
                int m_dim;
                cmp_fun(int dim) : m_dim(dim) { }
                virtual ~cmp_fun() { };
                virtual inline bool operator()(const fitness_vector &lhs, const fitness_vector &rhs)
                {
                        return lhs[0] < rhs[0];
                }
        };

        struct cmp_le : cmp_fun
        {
                cmp_le(int dim) : cmp_fun(dim) { }
                inline bool operator()(const fitness_vector &lhs, const fitness_vector &rhs)
                {
                        return lhs[m_dim] < rhs[m_dim];
                }
        };

        struct cmp_ge : cmp_fun
        {
                cmp_ge(int dim) : cmp_fun(dim) { }
                inline bool operator()(const fitness_vector &lhs, const fitness_vector &rhs)
                {
                        return lhs[m_dim] > rhs[m_dim];
                }
        };

        boost::shared_ptr<cmp_fun> m_cmp_obj;
};

} } }

BOOST_SERIALIZATION_ASSUME_ABSTRACT(pagmo::util::hv_algorithm::base)

#endif