interval.hpp

Go to the documentation of this file.

// This file is a part of NiHu, a C++ BEM template library.
//
// Copyright (C) 2012-2014  Peter Fiala <fiala@hit.bme.hu>
// Copyright (C) 2012-2014  Peter Rucz <rucz@hit.bme.hu>
//
// 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 3 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, see <http://www.gnu.org/licenses/>.
 
#ifndef INTERVAL_HPP_INCLUDED
#define INTERVAL_HPP_INCLUDED
 
#include "../core/global_definitions.hpp"
 
#include "algorithm.hpp"
#include "integer.hpp"
#include "vector.hpp"
 
#include <ratio>
#include <stdexcept>
 
namespace tmp
{
 
typedef std::giga ratio_infinite;
 
template <class X, class Y>
struct break_point
{
    typedef break_point type;
    typedef X x;
    typedef Y y;
 
    template<class scalar_t = double>
    constexpr static scalar_t x_value(void)
    {
        return scalar_t(x::num)/scalar_t(x::den);
    }
};
 
 
template <class Inter1, class Inter2>
struct merge_intervals
{
    template <class Iter, class Begin>
    struct copy_cond
    {
        typedef typename tmp::deref<typename tmp::prev<Iter>::type>::type prev;
        typedef typename tmp::deref<Iter>::type cur;
        typedef typename std::integral_constant<
            bool,
            std::ratio_greater<
                typename cur::x,
                typename prev::x
            >::type::value
            &&
            tmp::less<
                typename cur::y,
                typename prev::y
            >::type::value
        > type;
    };
 
    template <class Begin>
    struct copy_cond<Begin, Begin> : std::true_type {};
 
    template <class BP1, class BP2>
    struct compare_by_y_desc : tmp::less<
        typename BP1::y,
        typename BP2::y
    > {};
 
    template <class BP1, class BP2>
    struct compare_by_x_asc : std::ratio_less<
        typename BP1::x,
        typename BP2::x
    > {};
 
    typedef typename tmp::bubble_sort<
        typename tmp::concatenate<Inter1, Inter2>::type,
        compare_by_x_asc<tmp::_1, tmp::_2>
    >::type half_sorted;
 
    typedef typename tmp::bubble_sort<
        half_sorted,
        compare_by_y_desc<tmp::_1, tmp::_2>
    >::type sorted;
 
    typedef typename tmp::copy_if<
        sorted,
        tmp::inserter<
            typename tmp::empty<sorted>::type,
            tmp::push_back<tmp::_1, tmp::_2>
        >,
        copy_cond<tmp::_1, typename tmp::begin<sorted>::type>
    >::type type;
};
 
template <class interval>
int eval_interval(double r)
{
    typedef typename tmp::deref<
        typename tmp::begin<interval>::type
    >::type bp;
    // compare radius with first x value
    if (r < bp::x_value())
        return bp::y::value;
    else
        return eval_interval<typename tmp::pop_front<interval>::type>(r);
}
 
template <>
int eval_interval<tmp::vector<> >(double);
 
} // end of namespace tmp
 
#endif /* INTERVAL_HPP_INCLUDED */