Alge.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Math/Float.h"
#include "Honey/Math/Double.h"
#include "Honey/Math/Quad.h"

namespace honey
{

template<class Real>
class Alge_ : mt::NoCopy
{
    typedef typename Numeral<Real>::Real_           Real_;
    typedef typename Numeral<Real>::Int             Int;
    typedef typename std::make_unsigned<Int>::type  UInt;
    
public:
    static Int abs(Int x)                                                   { return x >= 0 ? x : -x;  }
    static UInt abs(UInt x)                                                 { return x;  }
    static Real abs(Real x)                                                 { return Real_::abs(x); }

    static Int sign(Int x)                                                  { return x > 0 ? 1 : x < 0 ? -1 : 0; }
    static UInt sign(UInt x)                                                { return x > 0 ? 1 : 0; }
    static Real sign(Real x)                                                { return x > 0 ? 1 : x < 0 ? -1 : 0; }
    
    static Real ceil(Real x)                                                { return Real_::ceil(x); }
    static Real floor(Real x)                                               { return Real_::floor(x); }
    static Real round(Real x)                                               { return Real_::round(x); }

    static Real trunc(Real x)                                               { return Real_::trunc(x); }
    static Real frac(Real x)                                                { return Real_::frac(x); }

    static Real mod(Real x, Real y)                                         { return Real_::mod(x, y); }
    static Real modNormalize(Real mod, Real val)
    {
        Real norm = Alge_::mod(val, mod*2);
        return norm > mod ? -mod*2 + norm : norm < -mod ? mod*2 + norm : norm;
    }
    static Real modDistSigned(Real mod, Real x, Real y)
    {
        Real dist = y - x;
        return abs(dist) > mod ? (dist >= 0 ? dist - mod*2 : dist + mod*2) : dist;
    }

    template<class Num> static Num sqr(Num x)                               { return x*x; }

    static Real sqrt(Real x)                                                { return Real_::sqrt(x); }
    static Real sqrtInv(Real x)                                             { return 1 / Real_::sqrt(x); }

    static Real exp(Real x)                                                 { return Real_::exp(x); }
    static Real expm1(Real x);

    static Real pow(Real x, Real y)                                         { return Real_::pow(x, y); }

    static const Real logMin;
    static const Real logMax;
    static Real log(Real x)                                                 { return Real_::log(x); }
    static Real log(Real x, Real base)                                      { return Real_::log(x) / Real_::log(base); }
    static Real log1p(Real x);

    template<class Num, class Num2>
    static typename std::common_type<Num, Num2>::type
        min(Num a, Num2 b)                                                  { return a <= b ? a : b; }

    template<class Num, class Num2>
    static typename std::common_type<Num, Num2>::type
        max(Num a, Num2 b)                                                  { return a >= b ? a : b; }
    
    template<class Num, class Num2, class Num3>
    static typename std::common_type<Num, Num2, Num3>::type
        clamp(Num val, Num2 min, Num3 max)                                  { return val < min ? min : val > max ? max : val; }

    static bool isNan(Real x)                                               { return x != x; }

    static bool isNear(Int a, Int b, Int tol)                               { return abs(a - b) <= tol; }
    static bool isNear(Real a, Real b, Real tol = Real_::zeroTol)           { return abs(a - b) <= tol; }
    static bool isNearZero(Real val, Real tol = Real_::zeroTol)             { return abs(val) <= tol; }

    template<class Num, class Num2, class Num3>
    static bool isInRange(Num val, Num2 min, Num3 max)                      { return val >= min && val <= max; }

    static Real hypot(Real a, Real b);


    static tuple<bool,Real,Real> solve(Real a, Real b, Real c, Real d, Real u, Real v);
};  

typedef Alge_<Real>         Alge;
typedef Alge_<Float>        Alge_f;
typedef Alge_<Double>       Alge_d;
typedef Alge_<Quad>         Alge_q;

extern template class Alge_<Float>;
extern template class Alge_<Double>;
extern template class Alge_<Quad>;

}