ir_components.hpp

Go to the documentation of this file.

//=======================================================================
// Copyright (c) 2013 Piotr Wygocki
//               2014 Piotr Godlewski
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//=======================================================================
#ifndef PAAL_IR_COMPONENTS_HPP
#define PAAL_IR_COMPONENTS_HPP


#include "paal/data_structures/components/components.hpp"
#include "paal/lp/ids.hpp"
#include "paal/lp/lp_base.hpp"
#include "paal/lp/problem_type.hpp"
#include "paal/utils/floating.hpp"
#include "paal/utils/functors.hpp"

#include <boost/optional.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/tuple/tuple.hpp>

#include <cmath>

namespace paal {
namespace ir {

class default_round_condition {
  public:
    default_round_condition(double epsilon = utils::compare<double>::default_epsilon()): m_compare(epsilon) { }

    template <typename Problem, typename LP>
    boost::optional<double> operator()(Problem &, const LP &lp,
                                       lp::col_id col) {
        double x = lp.get_col_value(col);
        double r = std::round(x);
        if (m_compare.e(x,r)) {
            return r;
        }
        return boost::none;
    }

  protected:
    const utils::compare<double> m_compare;
};

template <int...> class round_condition_equals {
    round_condition_equals() = delete;
};

template <int arg, int... args>
class round_condition_equals<arg,
                             args...> : public round_condition_equals<args...> {
  public:
    round_condition_equals(double epsilon = utils::compare<double>::default_epsilon()): round_condition_equals<args...>(epsilon) { }

    template <typename Problem, typename LP>
    boost::optional<double> operator()(Problem &, const LP &lp,
                                       lp::col_id col) {
        return get(lp, lp.get_col_value(col));
    }

  protected:
    template <typename LP>
    boost::optional<double> get(const LP & lp, double x) {
        if (this->m_compare.e(x, arg)) {
            return double(arg);
        } else {
            return round_condition_equals<args...>::get(lp, x);
        }
    }
};

template <> class round_condition_equals<> {
  public:
    round_condition_equals(double epsilon = utils::compare<double>::default_epsilon()): m_compare(epsilon) { }

  protected:
    template <typename LP> boost::optional<double> get(const LP &lp, double x) {
        return boost::none;
    }

    const utils::compare<double> m_compare;
};

template <typename Cond, typename F> class round_condition_to_fun {
  public:
    round_condition_to_fun(Cond c = Cond(), F f = F()) : m_cond(c), m_f(f) {}

    template <typename Problem, typename LP>
    boost::optional<double> operator()(Problem &, const LP &lp,
                                       lp::col_id col) {
        double x = lp.get_col_value(col);
        if (m_cond(x)) {
            return m_f(x);
        }
        return boost::none;
    }

  private:
    Cond m_cond;
    F m_f;
};

class cond_bigger_equal_than {
  public:
    cond_bigger_equal_than(double b, double epsilon = utils::compare<double>::default_epsilon())
        : m_bound(b), m_compare(epsilon) {}

    bool operator()(double x) { return m_compare.ge(x, m_bound); }

  private:
    double m_bound;
    const utils::compare<double> m_compare;
};

struct round_condition_greater_than_half  :
    public round_condition_to_fun<cond_bigger_equal_than, utils::return_one_functor> {
        round_condition_greater_than_half(double epsilon = utils::compare<double>::default_epsilon()) :
            round_condition_to_fun(cond_bigger_equal_than(0.5, epsilon)) {}
};

struct default_solve_lp_to_extreme_point {
    template <typename Problem, typename LP>
    lp::problem_type operator()(Problem &, LP &lp) {
        return lp.solve_simplex(lp::PRIMAL);
    }
};

struct default_resolve_lp_to_extreme_point {
    template <typename Problem, typename LP>
    lp::problem_type operator()(Problem &, LP &lp) {
        return lp.resolve_simplex(lp::PRIMAL);
    }
};

class default_stop_condition {
  public:
    default_stop_condition(double epsilon = utils::compare<double>::default_epsilon()): m_compare(epsilon) { }

    template <typename Problem, typename LP>
    bool operator()(Problem &, const LP &lp) {
        for (lp::col_id col : lp.get_columns()) {
            double col_val = lp.get_col_value(col);
            if (!m_compare.e(col_val, std::round(col_val))) {
                return false;
            }
        }

        return true;
    }

  protected:
    const utils::compare<double> m_compare;
};

class relaxations_limit_condition {
  public:
    relaxations_limit_condition(int limit = 1) : m_limit(limit) {}

    bool operator()(int relaxed) { return relaxed >= m_limit; }

  private:
    int m_limit;
};

class Init;
class RoundCondition;
class RelaxCondition;
class SetSolution;
class SolveLP;
class ResolveLP;
class StopCondition;
class RelaxationsLimit;

using components = data_structures::components<
    Init,
    data_structures::NameWithDefault<RoundCondition, default_round_condition>,
    data_structures::NameWithDefault<RelaxCondition, utils::always_false>,
    data_structures::NameWithDefault<SetSolution, utils::skip_functor>,
    data_structures::NameWithDefault<SolveLP, default_solve_lp_to_extreme_point>,
    data_structures::NameWithDefault<ResolveLP, default_resolve_lp_to_extreme_point>,
    data_structures::NameWithDefault<StopCondition, default_stop_condition>,
    data_structures::NameWithDefault<RelaxationsLimit, utils::always_false>>;

template <typename... Args>
using IRcomponents = typename components::type<Args...>;

template <typename... Args>
auto make_IRcomponents(Args &&... args)
    ->decltype(components::make_components(std::forward<Args>(args)...)) {
    return components::make_components(std::forward<Args>(args)...);
}

} // ir
} // paal

#endif // PAAL_IR_COMPONENTS_HPP