helper_modules.hpp

Go to the documentation of this file.

/*
Copyright© 2014 Akihiro Nishimura

This software is released under the MIT License.
http://opensource.org/licenses/mit-license.php
*/

#ifndef SIG_UTIL_HELPER_MODULES_HPP
#define SIG_UTIL_HELPER_MODULES_HPP

#include "../sigutil.hpp"
#include "../helper/type_convert.hpp"
#include <sstream> 


namespace sig
{

template <class B>
#if SIG_ENABLE_CONSTEXPR
constexpr
#endif
bool And(B&& cond){
    return static_cast<bool>(cond);
}


template <class B1, class... Bs>
#if SIG_ENABLE_CONSTEXPR
constexpr
#endif
bool And(B1&& cond, Bs&&... conds){
    return And(std::forward<Bs>(conds)...) && cond;
}


template <class B>
#if SIG_ENABLE_CONSTEXPR
constexpr
#endif
bool Or(B&& cond){
    return static_cast<bool>(cond);
}

template <class B1, class... Bs>
#if SIG_ENABLE_CONSTEXPR
constexpr
#endif
bool Or(B1&& cond, Bs&&... conds){
    return Or(conds...) || cond;
}



template <class B1, class B2>
#if SIG_ENABLE_CONSTEXPR
constexpr
#endif
bool Xor(B1&& a, B2&& b){
    return (a && !b) || (!a && b); 
}


template <class B1, class B2>
#if SIG_ENABLE_CONSTEXPR
constexpr
#endif
bool Consistency(B1&& a, B2&& b){
    return (a && b) || (!a && !b); 
}


template <class T>
#if SIG_ENABLE_CONSTEXPR
constexpr
#endif
auto min(T v) ->T
{
    return v;
}

template <class T1, class T2>
#if SIG_ENABLE_CONSTEXPR
constexpr
#endif
auto min(T1 v1, T2 v2)
{
    return v1 < v2 ? v1 : v2;
}


template <class T, class... Ts>
#if SIG_ENABLE_CONSTEXPR
constexpr
#endif
auto min(T v, Ts... vs)
{
    return min(v, min(vs...));
}


template <class T>
#if SIG_ENABLE_CONSTEXPR
constexpr 
#endif
auto max(T v) ->T
{
    return v;
}

template <class T1, class T2>
#if SIG_ENABLE_CONSTEXPR
constexpr 
#endif
auto max(T1 v1, T2 v2)
{
    return v1 < v2 ? v2 : v1;
}


template <class T, class... Ts>
#if SIG_ENABLE_CONSTEXPR
constexpr
#endif
auto max(T v, Ts... vs)
{
    return max(v, max(vs...));
}



template <class T>
constexpr bool is_number(T x)
{
    // false if x is a NaN.
    return (x == x);
}


template <class T>
constexpr bool is_finite_number(T x)
{
    return (x <= std::numeric_limits<T>::max() && x >= std::numeric_limits<T>::min());
}


template <class T>
#if SIG_ENABLE_CONSTEXPR
constexpr
#endif
T abs_delta(T v1, T v2)
{
    return v1 < v2 ? v2 - v1 : v1 - v2;
}


template <class T1, class T2>
#if SIG_ENABLE_CONSTEXPR
constexpr
#endif
auto abs_delta(T1 v1, T2 v2) ->decltype(v1 < v2 ? v2 - v1 : v1 - v2)
{
    return v1 < v2 ? v2 - v1 : v1 - v2;
}



template <class T1, class T2, typename std::enable_if<!(impl::is_string<T1>::value || impl::is_string<T2>::value)>::type*& = enabler>
bool equal(T1&& v1, T2&& v2)
{
    constexpr uint tolerant_rate = 10000;   //許容範囲の調整 (10^-16 * tolerant_rate)

    using T = typename std::common_type<T1, T2>::type;
    const T dmin = std::numeric_limits<T>::epsilon();

    return !(abs_delta(std::forward<T1>(v1), std::forward<T2>(v2)) > tolerant_rate * dmin);
}



template <class S1, class S2, typename std::enable_if<(impl::is_string<S1>::value && impl::is_string<S2>::value)>::type*& = enabler>
bool equal(S1&& v1, S2&& v2)
{
    return static_cast<impl::string_t<S1>>(std::forward<S1>(v1)) == static_cast<impl::string_t<S2>>(std::forward<S2>(v2));
}



template <class T1, class T2>
bool equal_tolerant(T1 v1, T2 v2, typename std::common_type<T1, T2>::type margin)
{
    return margin ? !(abs_delta(v1, v2) > margin) : equal(v1, v2);
}


template <class T, class U>
constexpr bool check_range(T const& val, U const& min, U const& max)
{
    return (min > val) || (val > max) ? false : true;
}


template <class T, class U>
bool modify_range(T& val, U const& min, U const& max)
{
    if (val<min){ val = min; return false; }
    if (val>max){ val = max; return false; }
    return true;
}


template <class T1, class T2>
constexpr bool greater(T1 v1, T2 v2){ return v1 > v2 ? true : false; };

template <class T1, class T2>
constexpr bool less(T1 v1, T2 v2){ return v1 < v2 ? true : false; };


struct identity_t
{
    template <class T>
#if SIG_ENABLE_CONSTEXPR
    constexpr
#endif
    T operator()(T v) const{ return v; }
};

struct increment_t
{
    template <class T>
#if SIG_ENABLE_CONSTEXPR
    constexpr
#endif
    T operator()(T v) const{ return ++v; }
};

struct decrement_t
{
    template <class T>
#if SIG_ENABLE_CONSTEXPR
    constexpr
#endif
    T operator()(T v) const{ return --v; }
};


struct plus_t
{
    template <class T1, class T2>
    auto operator()(T1&& v1, T2&& v2) const
        ->typename impl::remove_const_reference< decltype(std::forward<T1>(v1) + std::forward<T2>(v2)) >::type
    {
        return std::forward<T1>(v1) + std::forward<T2>(v2);
    }
};

struct minus_t
{
    template <class T1, class T2>
    auto operator()(T1&& v1, T2&& v2) const
        ->typename impl::remove_const_reference< decltype(std::forward<T1>(v1) - std::forward<T2>(v2)) >::type
    {
        return std::forward<T1>(v1) - std::forward<T2>(v2);
    }
};

struct mult_t
{
    template <class T1, class T2>
    auto operator()(T1&& v1, T2&& v2) const
        ->typename impl::remove_const_reference< decltype(std::forward<T1>(v1) * std::forward<T2>(v2)) >::type
    {
        return std::forward<T1>(v1) * std::forward<T2>(v2);
    }
};

struct div_t
{
    template <class T1, class T2>
    auto operator()(T1&& v1, T2&& v2) const
        ->typename impl::remove_const_reference< decltype(std::forward<T1>(v1) / std::forward<T2>(v2)) >::type
    {
        return std::forward<T1>(v1) / std::forward<T2>(v2);
    }
};

}
#endif