utils.hpp

Go to the documentation of this file.

#pragma once
 
#include <concepts>
#include <type_traits>
#include <cassert>
 
#include "consts.hpp"
#include "err.hpp"
#include "config.hpp"
 
#include "intrinsics.hpp"
 
namespace nem
{
 
    template <std::floating_point T> constexpr T is_infinite(T value) noexcept { return !nem::intr::_nem_isfinite(value); }
    template <std::floating_point T> constexpr T is_nan(T value) noexcept { return !nem::intr::_nem_isfinite(value); }
 
    template <std::integral T> constexpr T is_infinite(T) noexcept { return false; }
    template <std::integral T> constexpr T is_nan(T) noexcept { return false; }
 
 
 
    template <std::floating_point T> constexpr T copysign(T to, T from) noexcept
    {
        //to = static_cast<T>(__builtin_copysign(static_cast<double>(to), static_cast<double>(from)));
        return nem::intr::_nem_copysign(to, from);
    }
    template <nem::scalar_type T> constexpr T sign(T value) noexcept { return nem::copysign<T>((T)1.0, value); }
 
    template <typename T> constexpr T abs(T value) noexcept { return T{ value >= 0 ? value : -value }; }
    template <std::floating_point T> constexpr T abs(T value) noexcept { return nem::intr::_nem_fabs(value); }
 
    
    template <nem::scalar_type T> constexpr bool is_zero(T a) noexcept { return nem::abs(a) < eps<T>(); }
    template <std::integral T> constexpr bool is_zero(T a) noexcept { return a == 0; }
    
    template <nem::scalar_type T> constexpr bool is_zero_or_neg(T a) noexcept { return a <= eps<T>(); }
 
    template <nem::scalar_type T> constexpr bool equal(T a, T b) noexcept { return nem::is_zero(a - b); }
 
    template <nem::scalar_type T> constexpr T get_max(T a, T b) noexcept { return (a > b) ? a : b; }
 
    template <nem::scalar_type T> constexpr T get_min(T a, T b) noexcept { return (a < b) ? a : b; }
 
    template <nem::scalar_type T> constexpr T average(T a, T b) noexcept { return (a + b) / (T)2.0; }
 
 
 
    template <typename T> constexpr T pow2(T value) noexcept { return T{ value * value }; }
    template <typename T> constexpr T pow3(T value) noexcept { return T{ value * value * value }; }
    template <typename T> constexpr T pow4(T value) noexcept { return T{ value * value * value * value }; }
    template <typename T> constexpr T sqr (T value) noexcept { return T{ value * value }; }
    template <typename T> constexpr T cube(T value) noexcept { return T{ value * value * value }; }
    
 
    template <nem::scalar_type T> constexpr T truncate(T value) noexcept
    {
        return (T)(long long int)value;
    }
 
    template <nem::scalar_type T> constexpr T floor(T value) noexcept
    {   
        const T trunc = nem::truncate(value);
        return trunc - (trunc > value); // subtract 1 if truncation made the number bigger, which can happen only when the value is negative AND not-whole. If it is whole, then truncation never changes the number. If the number is positive and not-whole,
        // | sign(value) | is whole? | sign(trunc - value) |
        // |      +      |    yes    |           0         | -->  2.0 ->  2.0
        // |      +      |     no    |          -1         | -->  2.3 ->  2.0
        // |      -      |    yes    |           0         | --> -2.0 -> -2.0
        // |      -      |     no    |          +1         | --> -2.3 -> -3.0
    }
 
    template <nem::scalar_type T> constexpr T ceil(T value) noexcept
    {
        const T floored = nem::floor(value);
        return floored + (floored < value);
        // | sign(value) | is whole? | sign(trunc - value) |
        // |      +      |    yes    |           0         | -->  2.0 ->  2.0
        // |      +      |     no    |          -1         | -->  2.3 ->  3.0
        // |      -      |    yes    |           0         | --> -2.0 -> -2.0
        // |      -      |     no    |          +1         | --> -2.3 -> -2.0
    }
 
    template <nem::scalar_type T> constexpr T mod(T a, T b)
    {
        if (nem::is_zero(b))
        {
            return nem::error::invalid_result<T>(nem::error::Kind::DivisionByZero);
        }
        const T absb = nem::abs(b);
        const T v = a - nem::floor(a / b) * b;
        const T r = v < 0 ? v + absb : v;
        return nem::equal(r, absb) ? (T)0.0 : r;
    }
 
    template <std::floating_point T> constexpr T frac(T value) noexcept
    {
        return value - nem::truncate(value);
    }
    
    template <std::floating_point T> constexpr T round(T value) noexcept
    {
        const T floored = nem::floor(value);
        const T ceiled = floored + (floored < value); // ceil without extra floor
        const T neg_dist = value - floored;
        const T pos_dist = ceiled - value;
        const bool up = pos_dist < (neg_dist + nem::eps<T>()); // 0.5 -> up
        return ceiled * up + floored * !up; // branchless
    }
 
 
    template <std::floating_point T> constexpr T floor(T value, T step)
    {
        if (nem::is_zero_or_neg(step))
        {
            return nem::error::invalid_result<T>(nem::error::Kind::DivisionByZero, "Flooring only supports positive step values");
        }
        return nem::floor(value / step) * step;
    }
 
    template <std::integral T> constexpr T floor(T value, T step) noexcept
    {
        return (T)(nem::floor<nem::real>(static_cast<nem::real>(value), static_cast<nem::real>(step)));
    }
 
    template <std::floating_point T> constexpr T ceil(T value, T step)
    {
        if (nem::is_zero_or_neg(step))
        {
            return nem::error::invalid_result<T>(nem::error::Kind::DivisionByZero, "Ceiling only supports positive step values");
        }
        return nem::ceil(value / step) * step;
    }
 
    template <std::integral T> constexpr T ceil(T value, T step)
    {
        return (T)(nem::ceil<nem::real>(static_cast<nem::real>(value), static_cast<nem::real>(step)));
    }
 
    template <std::floating_point T> constexpr T round(T value, T step)
    {
        if (nem::is_zero_or_neg(step))
        {
            return nem::error::invalid_result<T>(nem::error::Kind::DivisionByZero, "Rounding only supports positive step values");
        }
        return nem::round(value / step) * step;
    }
 
    template <std::integral T> constexpr T round(T value, T step)
    {
        return (T)(nem::round<nem::real>(static_cast<nem::real>(value), static_cast<nem::real>(step)) + nem::eps<nem::real>());
    }
    
 
    template <nem::scalar_type T> constexpr T repeat(T value, T lengthExcl)
    {
        return nem::mod(value, lengthExcl);
    }
 
    template <nem::scalar_type T> constexpr T repeat(T value, T minIncl, T maxExcl)
    {
        return minIncl + nem::mod(value - minIncl, maxExcl - minIncl);
    }
 
    template <nem::scalar_type T> constexpr T pingpong(T value, T length)
    {
        const T t = nem::repeat(value, length * (T)2.0);
        return length - nem::abs(t - length);
    }
 
    template <nem::scalar_type T> constexpr T pingpong(T value, T minIncl, T maxExcl)
    {
        return minIncl + nem::pingpong(value - minIncl, maxExcl - minIncl);
    }
 
    template <std::totally_ordered T> constexpr T clamp(T value, T minIncl, T maxIncl) noexcept
    { 
        if (value > maxIncl) return maxIncl;
        else if (value < minIncl) return minIncl;
        return value;
    }
    template <std::totally_ordered T> constexpr T clamp01(T value) noexcept
    {
        return nem::clamp(value, (T)0.0, (T)1.0);
    }
 
 
    template <typename T> constexpr T smoothstep(T edge0, T edge1, T x)
    {
        const T length = edge1 - edge0;
        if (nem::is_zero(length))
        {
            return nem::error::invalid_result<T>(nem::error::Kind::DivisionByZero, "Smoothstep edges are too closeby");
        }
        x = nem::clamp((x - edge0) / (edge1 - edge0), (T)0.0, (T)1.0);
        return x * x * ((T)3.0 - (T)2.0 * x);
    }
    template <typename T> constexpr T lerp(T a, T b, T t) { return b * t + a * ((T)1.0 - t); }
 
 
    template <nem::scalar_type T> constexpr T remap(T value, T fromMin, T fromMax, T toMin, T toMax)
    {
        const T fromLength = fromMax - fromMin;
        if (nem::is_zero(fromLength))
        {
            return nem::error::invalid_result<T>(nem::error::Kind::DivisionByZero, "Remapping from length is zero");
        }
        return toMin + (toMax - toMin) * ((value - fromMin) / fromLength);
    }
 
 
    template <std::floating_point T> constexpr T is_whole(T value)
    {
        return nem::is_zero(nem::frac(value));
    }
    
    template <std::integral T> constexpr T is_whole(T value)
    {
        return true;
    }
}