CRNMath.h

Go to the documentation of this file.

/* Copyright 2006-2016 Yann LEYDIER, CoReNum, INSA-Lyon, Université Paris Descartes, ENS-Lyon
 *
 * This file is part of libcrn.
 *
 * libcrn is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * libcrn 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with libcrn.  If not, see <http://www.gnu.org/licenses/>.
 *
 * file: CRNMath.h
 * \author Yann LEYDIER
 */

#ifndef CRNMath_HEADER
#define CRNMath_HEADER

#include <CRN.h>
#include <cmath>
#include <complex>
#include <algorithm>

#if defined(CRN_PF_ANDROID)
inline double log2(double n)
{
    return log(n) / log(2.0);
}
#endif

#ifndef M_PI
#   define M_PI 3.14159265358979323846
#endif

namespace crn
{
    template<typename T> inline const T& Max(const T &a, const T &b) { return std::max(a, b); }
    template<typename T> inline const T& Min(const T &a, const T &b) { return std::min(a, b); }
    template<typename T> inline const T& Max(const T &a, const T &b, const T&c) { return std::max(std::max(a, b), c); }
    template<typename T> inline const T& Min(const T &a, const T &b, const T&c) { return std::min(std::min(a, b), c); }
    template<typename T> constexpr typename TypeInfo<T>::SumType Twice(const T&v) noexcept(noexcept(v+v)) { return v + v; }
    template<typename T> constexpr typename TypeInfo<T>::SumType Thrice(const T&v) noexcept(noexcept(v+v)) { return v + v + v; }
    template<typename T> constexpr int SignOf(const T &x) noexcept(noexcept(x<0)) { return (x < 0) ? -1 : 1; }
    template<typename T> constexpr SumType<T> Sqr(const T&v) noexcept(noexcept(v*v)) { return v * v; }
    template<typename T> constexpr T Abs(const T &v) noexcept(noexcept(v<0)&&noexcept(-v)) { return (v < 0) ? -v : v; }
    template<typename T> inline T Abs(const std::complex<T> &v) noexcept(noexcept(std::abs(std::complex<T>(0)))) { return std::abs(v); }
    template<typename T> inline T AbsMax(const T &a, const T &b) noexcept(noexcept(Abs(a))) { return Abs(a) >= Abs(b) ? a : b; }
    template<typename T> inline T AbsMin(const T &a, const T &b) noexcept(noexcept(Abs(a))) { return Abs(a) < Abs(b) ? a : b; }
    template<typename T> inline T AbsMaxSameSign(const T &a, const T &b) noexcept(noexcept(Abs(a))&&noexcept(SignOf(a))) { if (SignOf(a) == SignOf(b)) return Abs(a) >= Abs(b) ? a : b; else return T(0); }
    template<typename T> inline T AbsMinSameSign(const T &a, const T &b) noexcept(noexcept(Abs(a))&&noexcept(SignOf(a))) { if (SignOf(a) == SignOf(b)) return Abs(a) < Abs(b) ? a : b; else return T(0); }
    template<typename T> inline const T& Cap(const T &v, const T &min, const T &max) { return Min(max, Max(min, v)); }

    inline double Gauss(double x, double sigma) { return exp((- x * x) / (2.0 * sigma * sigma)); }

    inline double MeanGauss(double x, double sigma) { return (Gauss(x, sigma) + Gauss(x + 0.5, sigma) + Gauss(x - 0.5, sigma)) / 3.0; }

    inline double Pythagoras(double a, double b) noexcept { double aa = Abs(a), ab = Abs(b); return (aa  > ab) ? aa * sqrt(1.0 + Sqr(ab / aa)) : ((ab == 0.0) ? 0.0 : ab * sqrt(1.0 + Sqr(aa / ab))); }
    inline double Pythagoras(int a, int b) noexcept { double aa = Abs(a), ab = Abs(b); return (aa  > ab) ? aa * sqrt(1.0 + Sqr(ab / aa)) : ((ab == 0.0) ? 0.0 : ab * sqrt(1.0 + Sqr(aa / ab))); }
    
    inline double Pythagoras(double a, double b, double c) noexcept { return sqrt(Sqr(a) + Sqr(b) + Sqr(c)); }
    
    template <class ITER> inline double Pythagoras(ITER it_begin, ITER it_end)
    {
        auto cumul_squares = 0.0;
        
        for (ITER it = it_begin; it != it_end; ++it)
            cumul_squares += Sqr(*it);
        
        return sqrt(cumul_squares);
    }
    
    template <class ITER> inline void Scale(ITER it_begin, ITER it_end, const double s)
    {
        for (ITER it = it_begin; it != it_end; ++it)
            (*it) *= s;
    }

}

#include <CRNMath/CRNTrigonometry.h>

namespace crn
{
    enum class Direction { INVALID = 0, LEFT = 1, RIGHT = 2, TOP = 4, BOTTOM = 8 };
    template<typename Unit> Direction ToDirection(const Angle<Unit> &ang) noexcept
    {
        Angle<ByteAngle> a(ang);
        if (a == Angle<ByteAngle>::LEFT())
        {
            return Direction::LEFT;
        }
        else if (a == Angle<ByteAngle>::RIGHT())
        {
            return Direction::RIGHT;
        }
        else if (a == Angle<ByteAngle>::TOP())
        {
            return Direction::TOP;
        }
        else if (a == Angle<ByteAngle>::BOTTOM())
        {
            return Direction::BOTTOM;
        }
        else
        {
            return Direction::INVALID;
        }
    }

    enum class Orientation { INVALID = 0, HORIZONTAL, VERTICAL };
    Orientation ToOrientation(Direction d) noexcept;

    enum class DistanceType { INVALID = 0, D4, D8, EUCLIDEAN };

    template<
        typename T,
        typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0
        >
    double Distance(T o1, T o2)
    {
     return double(Abs(o1 - o2));
    }
    
}

CRN_DECLARE_ENUM_OPERATORS(crn::Direction)
CRN_DECLARE_ENUM_OPERATORS(crn::Orientation)

#endif