reorganize files and format

include/bmath/mint.hh

@@ -0,0 +1,206 @@
+#ifndef BMATH_MINT_HH
+#define BMATH_MINT_HH
+
+namespace bmath {
+
+#include <format>
+#include <iterator>
+#include <ostream>
+#include <stdexcept>
+#include <string>
+
+inline constexpr uint64_t DEFAULT_MOD = 1'000'000'007;
+
+template <std::unsigned_integral T, T M = static_cast<T>(DEFAULT_MOD)>
+  requires(M > 0 && DEFAULT_MOD <= std::numeric_limits<T>::max())
+class mint {
+ public:
+  [[nodiscard]] constexpr explicit mint() : value{} {}
+  [[nodiscard]] constexpr explicit mint(T t) : value{t % M} {}
+  [[nodiscard]] constexpr explicit operator T() const noexcept { return value; }
+
+  [[nodiscard]] constexpr mint operator+(mint const other) const noexcept {
+    T result{add(static_cast<T>(other.get()))};
+
+    return mint<T, M>{result};
+  }
+
+  constexpr mint& operator+=(mint const other) const noexcept {
+    value += other.value;
+
+    return *this;
+  }
+
+  [[nodiscard]] constexpr mint<T, M> operator-(
+      mint const other) const noexcept {
+    T result{sub(static_cast<T>(other.get()))};
+
+    return mint<T, M>{result};
+  }
+
+  [[nodiscard]] constexpr mint operator*(mint const other) const noexcept {
+    T result{mul(static_cast<T>(other.get()))};
+
+    return mint<T, M>{result};
+  }
+
+  constexpr mint& operator*=(mint const other) noexcept {
+    value *= other.value;
+
+    return *this;
+  }
+
+  [[nodiscard]] constexpr mint operator/(mint const other) const noexcept {
+    if constexpr (other.get() == 0) {
+      static_assert(false, "Cannot divide by 0");
+    } else if (other.get() == 0) {
+      throw std::domain_error("Cannot divide by 0");
+    }
+
+    T result{div(static_cast<T>(other.get()))};
+
+    return mint<T, M>{result};
+  }
+
+  constexpr mint& operator/=(mint const other) noexcept {
+    if constexpr (other.get() == 0) {
+      static_assert(false, "Cannot divide by 0");
+    } else if (other.get() == 0) {
+      throw std::domain_error("Cannot divide by 0");
+    }
+
+    value /= other.value;
+
+    return *this;
+  }
+
+  [[nodiscard]] constexpr mint operator%(mint const other) const noexcept {
+    T result = mod(other);
+
+    return mint<T, M>{result};
+  }
+
+  constexpr mint& operator%=(mint const other) const noexcept {
+    value %= other.value;
+
+    return *this;
+  }
+
+  [[nodiscard]] constexpr mint operator-() const noexcept {
+    return mint<T, M>{M - get()};
+  }
+
+  constexpr mint operator++() noexcept {
+    value += 1;
+
+    return *this;
+  }
+
+  constexpr mint operator++(int) noexcept {
+    auto _this = *this;
+
+    value += 1;
+
+    return _this;
+  }
+
+  [[nodiscard]] constexpr T get() const noexcept { return value; }
+
+  [[nodiscard]] constexpr bool operator==(mint const other) const noexcept {
+    return get() == static_cast<T>(other.get());
+  }
+
+  template <std::convertible_to<T> OtherT, OtherT OtherM>
+  friend std::ostream& operator<<(std::ostream& out,
+                                  mint<OtherT, OtherM> const other) {
+    return out << other.get();
+  }
+
+ private:
+  T value{};
+
+  [[nodiscard]] constexpr T add(T other) const noexcept {
+    return (get() + other) % M;
+  }
+
+  [[nodiscard]] constexpr T sub(T other) const noexcept {
+    return (get() - other + M) % M;
+  }
+
+  [[nodiscard]] constexpr T mul(T other) const noexcept {
+    return (get() * other) % M;
+  }
+
+  [[nodiscard]] constexpr T div(T other) const noexcept {
+    return get() / other;
+  }
+
+  [[nodiscard]] constexpr T mod(T other) const noexcept {
+    return get() % other;
+  }
+};
+
+template <std::unsigned_integral T, T M, std::unsigned_integral U>
+  requires(M > 0)
+[[nodiscard]] static constexpr bmath::mint<T, M> pow(mint<T, M> base,
+                                                     U exponent) {
+  if (exponent < 0) {
+    throw std::domain_error(
+        std::format("cannot compute pow({}, {}) with negative exponent {}",
+                    base, exponent, exponent));
+  }
+
+  if (base.get() == 0) {
+    if (exponent == 0) {
+      throw std::domain_error("pow(0, 0) is indeterminate");
+    }
+
+    return mint<T, M>{0};
+  }
+
+  if (base.get() == 1 || exponent == 0) {
+    return mint<T, M>{1};
+  }
+
+  mint<T, M> t{1};
+
+  while (exponent > 0) {
+    if (exponent & 1) {
+      t *= base;
+    }
+    base *= base;
+    exponent >>= 1;
+  }
+
+  return t;
+}
+
+template <std::unsigned_integral T, T M = DEFAULT_MOD>
+  requires(M > 0)
+[[nodiscard]] std::string to_string(mint<T, M> const number) {
+  return std::to_string(number.get());
+}
+
+}  // namespace bmath
+
+template <class CharT, std::integral T, T M>
+struct std::formatter<bmath::mint<T, M>, CharT> {
+  std::formatter<std::basic_string_view<CharT>, CharT> inner;
+
+  constexpr auto parse(std::basic_format_parse_context<CharT>& pc) {
+    return inner.parse(pc);
+  }
+
+  template <class Ctx>
+  auto format(bmath::mint<T, M> const x, Ctx& ctx) const {
+    std::basic_string<CharT> tmp;
+    if constexpr (std::same_as<CharT, wchar_t>) {
+      std::format_to(std::back_inserter(tmp), L"{}", x.get());
+    } else {
+      std::format_to(std::back_inserter(tmp), "{}", x.get());
+    }
+    return inner.format(tmp, ctx);
+  }
+};
+
+#endif