math.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_DETAIL_MATH_H
#define EGT_DETAIL_MATH_H
 
#include <algorithm>
#include <cassert>
#include <cmath>
#include <stdexcept>
#include <type_traits>
 
namespace egt
{
inline namespace v1
{
namespace detail
{
 
template<typename T>
constexpr T pi()
{
    return std::acos(-T(1));
}
 
template<typename T>
constexpr T pi_2()
{
    return std::acos(-T(0));
}
 
template<class T>
constexpr T mmod(T a, T n)
{
    return a - std::floor(a / n) * n;
}
 
template<class T>
constexpr T angle_diff(T angle_start, T angle_stop, bool clockwise = true)
{
    if (clockwise)
    {
        angle_stop -= angle_start;
        if (angle_stop < 0.0f)
            angle_stop += 360.0f;
        return angle_stop;
    }
 
    angle_stop -= angle_start;
    return mmod(360.0f - angle_stop, 360.0f);
}
 
template <class T>
constexpr T to_degrees(T radians)
{
    return radians * (180.0f / pi<T>());
}
 
template <class T>
constexpr T to_radians(T zero, T degrees)
{
    degrees += zero;
    return degrees * (pi<T>() / 180.0f);
}
 
template <class T>
constexpr const T& clamp(const T& v, const T& lo, const T& hi)
{
    return assert(!(hi < lo)),
           (v < lo) ? lo : (hi < v) ? hi : v;
}
 
template <class T>
constexpr T fabs(T x,
                 // NOLINTNEXTLINE(readability-named-parameter)
                 typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr)
{
    return x >= 0 ? x :
           x < 0 ? -x :
           throw std::runtime_error("can't make sense of floating point value");
}
 
constexpr bool float_equal(const float f1, const float f2)
{
    constexpr auto epsilon = 1.0e-05f;
    if (fabs(f1 - f2) <= epsilon)
        return true;
    return fabs(f1 - f2) <= epsilon * std::max(fabs(f1), fabs(f2));
}
 
constexpr bool float_equal(const double f1, const double f2)
{
    constexpr auto epsilon = 1.0e-9;
    if (fabs(f1 - f2) <= epsilon)
        return true;
    return fabs(f1 - f2) <= epsilon * std::max(fabs(f1), fabs(f2));
}
 
template<class T>
constexpr T normalize(T value, T min, T max, T target_min, T target_max)
{
    assert(!float_equal(min, max));
    const auto r = ((value - min) / (max - min)) *
                   (target_max - target_min) + target_min;
    assert(!std::isnan(r));
    return r;
}
 
template<class T>
constexpr T normalize_to_angle(T value, T min, T max, T angle_start, T angle_stop, bool clockwise = true)
{
    assert(!float_equal(min, max));
    assert(!float_equal(angle_start, angle_stop));
    const auto a = normalize<T>(value, min, max, 0, angle_diff(angle_start, angle_stop, clockwise));
    assert(!std::isnan(a));
    return clockwise ? angle_start + a : angle_start - a;
}
 
}
}
}
 
#endif