templates.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_TEMPLATES_H
#define MTCORE_MATH_TEMPLATES_H
 
#include "mtcore/math/core.hpp"
#include "mtcore/meta/base.hpp"
 
#include <ratio>
 
namespace mtcore::math {
  template<intmax_t A, intmax_t B>
  struct GCD;
 
  template<intmax_t A>
  struct GCD<A, 0> {
    static constexpr auto value = A;
  };
 
  template<intmax_t A, intmax_t B>
  struct GCD {
    static constexpr auto t     = B;
    static constexpr auto b     = math::mod(A, B);
    static constexpr auto a     = t;
    static constexpr auto value = GCD<a, b>::value;
  };

  template<intmax_t A, intmax_t B>
  struct LCM {
    static constexpr auto value = math::abs(A) * (math::abs(B) / GCD<A, B>::value);
  };

  template<typename T1, typename T2>
  struct MultRatios;
 
  template<intmax_t N1, intmax_t D1, intmax_t N2, intmax_t D2>
  struct MultRatios<std::ratio<N1, D1>, std::ratio<N2, D2>> {
    static constexpr auto NRaw = N1 * N2;
    static constexpr auto DRaw = D1 * D2;
    static constexpr auto Gcd  = math::gcd(NRaw, DRaw);
    static constexpr auto N    = NRaw / Gcd;
    static constexpr auto D    = DRaw / Gcd;
 
    using T = std::ratio<N, D>;
  };
 
  static_assert(std::same_as<MultRatios<std::ratio<2, 3>, std::ratio<2, 3>>::T, std::ratio<4, 9>>);

  template<typename T1, typename T2>
  struct AddRatios;
 
  template<intmax_t N1, intmax_t D1, intmax_t N2, intmax_t D2>
  struct AddRatios<std::ratio<N1, D1>, std::ratio<N2, D2>> {
    static constexpr auto NewDenom = math::lcm(D1, D2);
    static constexpr auto M1       = NewDenom / math::gcd(D1, NewDenom);
    static constexpr auto M2       = NewDenom / math::gcd(D2, NewDenom);
    static constexpr auto NN1      = N1 * M1;
    static constexpr auto NN2      = N2 * M2;
    static constexpr auto NN       = NN1 + NN2;
    static constexpr auto NG       = math::gcd(NN, NewDenom);
 
    using T = std::ratio<NN / NG, NewDenom / NG>;
  };
 
  static_assert(std::same_as<AddRatios<std::ratio<2, 15>, std::ratio<1, 5>>::T, std::ratio<1, 3>>);

  template<typename T>
  struct RatioParts;
 
  template<intmax_t Num, intmax_t Den>
  struct RatioParts<std::ratio<Num, Den>> {
    static constexpr intmax_t Numerator   = Num;
    static constexpr intmax_t Denominator = Den;
  };
 
  static_assert(RatioParts<std::ratio<2, 15>>::Numerator == 2);
  static_assert(RatioParts<std::ratio<2, 15>>::Denominator == 15);

  template<typename T>
  struct InvertRatio;
 
  template<intmax_t Num, intmax_t Den>
  struct InvertRatio<std::ratio<Num, Den>> {
    using T = std::ratio<Den, Num>;
  };

  template<typename T>
  struct NegateRatio;
 
  template<intmax_t Num, intmax_t Den>
  struct NegateRatio<std::ratio<Num, Den>> {
    using T = std::ratio<-Num, Den>;
  };

  template<typename T, int Pow, bool Odd, bool Neg, bool Z>
  struct IntPowRatioImpl;
 
  template<intmax_t N, intmax_t D>
  struct IntPowRatioImpl<std::ratio<N, D>, 0, false, false, true> {
    using T = std::ratio<1>;
  };
 
  template<intmax_t N, intmax_t D, int Pow, bool Odd>
  struct IntPowRatioImpl<std::ratio<N, D>, Pow, Odd, true, false> {
    using T = typename IntPowRatioImpl<std::ratio<D, N>, -Pow, (-Pow) % 2 == 1, false, false>::T;
  };
 
  template<intmax_t N, intmax_t D, int Pow>
  struct IntPowRatioImpl<std::ratio<N, D>, Pow, false, false, false> {
    using R                  = std::ratio<N, D>;
    static constexpr auto PN = Pow / 2;
    using T = typename IntPowRatioImpl<typename MultRatios<R, R>::T, PN, PN % 2 == 1, false, PN == 0>::T;
  };
 
  template<intmax_t N, intmax_t D, int Pow>
  struct IntPowRatioImpl<std::ratio<N, D>, Pow, true, false, false> {
    using R = std::ratio<N, D>;
    using T = typename meta::If<
      Pow == 1, R, typename MultRatios<R, typename IntPowRatioImpl<R, Pow - 1, false, false, Pow - 1 == 0>::T>::T>::T;
  };
 
  template<typename R, int Pow>
  struct IntPowRatio {
    using T = typename IntPowRatioImpl < R, Pow, Pow % 2 == 1, Pow<0, Pow == 0>::T;
  };
 
  static_assert(std::same_as<std::ratio<4, 9>, IntPowRatio<std::ratio<2, 3>, 2>::T>);
 
  static_assert(std::same_as<std::ratio<8, 27>, IntPowRatio<std::ratio<2, 3>, 3>::T>);
}  // namespace mtcore::math
 
#endif  // MTCORE_MATH_TEMPLATES_H