hv2d.cpp

/*****************************************************************************
 *   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.               *
 *****************************************************************************/


#include "hv2d.h"
#include "hv3d.h"

namespace pagmo { namespace util { namespace hv_algorithm {

hv2d::hv2d(const bool initial_sorting) : m_initial_sorting(initial_sorting) { }


double hv2d::compute(std::vector<fitness_vector> &points, const fitness_vector &r_point) const
{
        if (points.size() == 0) {
                return 0.0;
        } else if (points.size() == 1) {
                return base::volume_between(points[0], r_point);
        }

        if (m_initial_sorting) {
                sort(points.begin(), points.end(), fitness_vector_cmp(1, '<'));
        }

        double hypervolume = 0.0;

        // width of the sweeping line
        double w = r_point[0] - points[0][0];
        for(unsigned int idx = 0 ; idx < points.size() - 1 ; ++idx) {
                hypervolume += (points[idx + 1][1] - points[idx][1]) * w;
                w = std::max(w, r_point[0] - points[idx+1][0]);
        }
        hypervolume += (r_point[1] - points[points.size() - 1][1]) * w;

        return hypervolume;
}


bool hv2d::cmp_double_2d(double* a, double* b)
{
        return a[1] < b[1];
}


double hv2d::compute(double** points, unsigned int n_points, double* r_point) const
{
        if (n_points == 0) {
                return 0.0;
        }
        else if (n_points == 1) {
                return base::volume_between(points[0], r_point, 2);
        }

        if (m_initial_sorting) {
                std::sort(points, points + n_points, hv2d::cmp_double_2d);
        }

        double hypervolume = 0.0;

        // width of the sweeping line
        double w = r_point[0] - points[0][0];
        for(unsigned int idx = 0 ; idx < n_points - 1 ; ++idx) {
                hypervolume += (points[idx + 1][1] - points[idx][1]) * w;
                w = std::max(w, r_point[0] - points[idx+1][0]);
        }
        hypervolume += (r_point[1] - points[n_points - 1][1]) * w;

        return hypervolume;
}


std::vector<double> hv2d::contributions(std::vector<fitness_vector> &points, const fitness_vector &r_point) const
{
        std::vector<fitness_vector> new_points(points.size(), fitness_vector(3, 0.0));
        fitness_vector new_r(r_point);
        new_r.push_back(1.0);

        for(unsigned int i = 0 ; i < points.size() ; ++i) {
                new_points[i][0] = points[i][0];
                new_points[i][1] = points[i][1];
                new_points[i][2] = 0.0;
        }
        // Set sorting to off since contributions are sorted by third dimension
        return hv3d(false).contributions(new_points, new_r);
}



bool hv2d::point_pairs_cmp(const std::pair<fitness_vector, unsigned int> &a, const std::pair<fitness_vector, unsigned int> &b)
{
        return a.first[1] > b.first[1];
}

base_ptr hv2d::clone() const
{
        return base_ptr(new hv2d(*this));
}

std::string hv2d::get_name() const
{
        return "hv2d algorithm";
}


void hv2d::verify_before_compute(const std::vector<fitness_vector> &points, const fitness_vector &r_point) const
{
        if (r_point.size() != 2) {
                pagmo_throw(value_error, "Algorithm hv2d works only for 2-dimensional cases.");
        }

        base::assert_minimisation(points, r_point);
}

} } }

BOOST_CLASS_EXPORT_IMPLEMENT(pagmo::util::hv_algorithm::hv2d)