math.hpp

 
#ifndef UFO_NUMERIC_MATH_HPP
#define UFO_NUMERIC_MATH_HPP
 
// STL
#include <algorithm>
#include <cassert>
#include <cmath>
#include <concepts>
#include <limits>
#include <numbers>
#include <ranges>
 
namespace ufo
{
template <class T>
[[nodiscard]] constexpr int sign(T val) noexcept
{
    if constexpr (std::is_unsigned_v<T>) {
        return T(0) < val;
    } else {
        return (T(0) < val) - (val < T(0));
    }
}
 
template <std::floating_point T>
[[nodiscard]] constexpr T radians(T deg) noexcept
{
    return deg * std::numbers::pi_v<T> / T(180);
}
 
template <std::floating_point T>
[[nodiscard]] constexpr T degrees(T rad) noexcept
{
    return rad * T(180) / std::numbers::pi_v<T>;
}
 
template <class T>
  requires std::is_arithmetic_v<T>
[[nodiscard]] constexpr T ipow(T base, int exp) noexcept
{
    T result = std::ranges::fold_left(std::views::repeat(base, std::abs(exp)), T(1),
                                      std::multiplies<>());
    return 0 <= exp ? result : T(1) / result;
}
 
template <std::floating_point T>
[[nodiscard]] constexpr T probabilityToLogit(T probability)
{
    assert(T(0) <= probability && T(1) >= probability);
    if (T(0) >= probability) {
        return -std::numeric_limits<T>::infinity();
    }
    if (T(1) <= probability) {
        return std::numeric_limits<T>::infinity();
    }
    return std::log(probability / (T(1) - probability));
}
 
template <std::floating_point T>
[[nodiscard]] constexpr T logitToProbability(T logit)
{
    return T(1) / (T(1) + std::exp(-logit));
}
 
}  // namespace ufo
 
#endif  // UFO_NUMERIC_MATH_HPP