core/mtcore/math/core.hpp

Go to the documentation of this file.

/*
 
Copyright 2025 Matthew Tolman
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
   http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
 
*/
 
#ifndef MTCORE_MATH_CORE_HPP
#define MTCORE_MATH_CORE_HPP
 
#include <type_traits>


namespace mtcore::math {
  template<typename T, typename R = double>
  constexpr R floor_constexpr(T num) noexcept {
    // Check to see if we're at our maximum supported radix range
    // If we are, then the number we received is an integer since all the significant digits
    //    have to be positive at this point
    const T max = static_cast<T>(static_cast<uint64_t>(1) << static_cast<uint64_t>(std::numeric_limits<T>::digits - 1));
    if (num >= max || num <= -max) {
      return static_cast<R>(num);
    }
    const auto a = static_cast<T>(static_cast<int64_t>(num));
    return (num < 0 && num != a) ? static_cast<R>(a - 1) : static_cast<R>(a);
  }

  template<typename T, typename R = double>
  constexpr R ceil_constexpr(T num) noexcept {
    // Check to see if we're at our maximum supported radix range
    // If we are, then the number we received is an integer since all the significant digits
    //    have to be positive at this point
    const T max = static_cast<T>(static_cast<uint64_t>(1) << static_cast<uint64_t>(std::numeric_limits<T>::digits - 1));
    if (num >= max || num <= -max) {
      return num;
    }
    const auto a = static_cast<T>(static_cast<int64_t>(num));
    return (num > 0 && num != a) ? static_cast<R>(a + 1) : static_cast<R>(a);
  }

  template<typename T, typename R = T>
  constexpr R floor(T num) noexcept {
    if constexpr (std::is_integral<T>::value) {
      return static_cast<R>(num);
    }
    else if (std::is_constant_evaluated()) {
      return floor_constexpr<T, R>(num);
    }
    else {
      return static_cast<R>(std::floor(num));
    }
  }
 

  template<typename T, typename R = T>
  constexpr R ceil(T v) noexcept {
    if constexpr (std::is_integral_v<T>) {
      return static_cast<R>(v);
    }
    else if (std::is_constant_evaluated()) {
      return ceil_constexpr<T, R>(v);
    }
    else {
      return static_cast<R>(std::ceil(v));
    }
  }

  template<typename L, typename R, typename Res = L>
  constexpr Res mod(L left, R right) noexcept {
    if (std::is_integral_v<L> || std::is_integral_v<R>) {
      return static_cast<Res>(mod(static_cast<long double>(left), static_cast<long double>(right)));
    }
    else {
      return static_cast<Res>(left - right * math::floor(left / right));
    }
  }

  template<typename T>
  constexpr auto mod_range(T x, i64 a, i64 b) noexcept -> T {
    return a == b ? x : a + mod(x - a, b - a);
  }

  template<typename L, typename R, typename Res = L>
  constexpr auto amod(L x, R y) noexcept -> Res {
    return static_cast<Res>(y + mod(x, -y));
  }

  template<typename T, typename R = T>
  constexpr auto approx_eq(T x, R y, T epsilon = T{0.000001}) noexcept -> bool {
    return (x <= y + epsilon) & (x >= y - epsilon);
  }

  template<typename T>
  constexpr int sign(const T &v) {
    if (v < 0) {
      return -1;
    }
    if (v > 0) {
      return 1;
    }
    return 0;
  }

  template<typename L>
  constexpr L abs(L l) {
    return l * static_cast<L>(sign(l));
  }

  template<typename T>
  constexpr T int_pow(T val, int exp) {
    if (exp < 0) {
      return int_pow(1 / val, -exp);
    }
    else if (exp == 0) {
      return 1;
    }
    else if ((exp & 1) == 0) {
      return int_pow(val * val, exp / 2);
    }
    else {
      return val * int_pow(val * val, (exp - 1) / 2);
    }
  }

  template<std::integral T>
  constexpr T gcd(T a, T b) {
    if (b == 0) {
      return a;
    }
    return gcd(b, mod(a, b));
  }

  template<std::integral T>
  constexpr T lcm(T a, T b) {
    return abs(a) * (abs(b) / gcd(a, b));
  }
}  // namespace mtcore::math
 
#endif  // MTCORE_MATH_CORE_HPP