Add modint and frac, comb; release 0.4.0

Author: Mr-Python-in-China

library/mrpython/modint.hpp

@@ -0,0 +1,78 @@
+#ifndef MP_LIBRARY_MODINT_HPP
+#define MP_LIBRARY_MODINT_HPP
+#include <iostream>
+#include <mrpython/numeric.hpp>
+#include <type_traits>
+
+namespace mrpython {
+template <unsigned P> class modint {
+  static_assert(P > 0, "modint: P must be positive");
+  static_assert(P < (1U << 31), "modint: P must be less than 2^31");
+
+  unsigned int v;
+
+ public:
+  template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
+  constexpr modint(T x)
+      : v((std::is_unsigned<T>::value
+               ? static_cast<unsigned int>(x % static_cast<T>(P))
+               : static_cast<unsigned int>((x % static_cast<T>(P) + P) % P))) {}
+  constexpr modint(void): v(0) {}
+  constexpr modint& operator+=(modint x) {
+    if ((this->v += x.v) >= P) this->v -= P;
+    return *this;
+  }
+  constexpr modint& operator-=(modint x) {
+    if (this->v < x.v) this->v += P;
+    this->v -= x.v;
+    return *this;
+  }
+  constexpr modint& operator*=(unsigned int x) {
+    this->v = (unsigned long long int)this->v * x % P;
+    return *this;
+  }
+  template <typename T,
+            typename = std::enable_if_t<std::is_integral<T>::value &&
+                                        !std::is_same<T, unsigned int>::value>>
+  constexpr modint& operator*=(T x) {
+    return *this *= modint(x);
+  }
+  constexpr modint& operator*=(modint x) {
+    this->v = (unsigned long long int)this->v * x.v % P;
+    return *this;
+  }
+  constexpr modint& operator/=(modint x) { return *this *= x.inv(); }
+  constexpr friend modint operator+(modint a, modint b) {
+    a += b;
+    return a;
+  }
+  constexpr friend modint operator-(modint a, modint b) {
+    a -= b;
+    return a;
+  }
+  template <typename T,
+            typename = std::enable_if_t<std::is_same<T, modint>::value ||
+                                        std::is_integral<T>::value>>
+  constexpr friend modint operator*(modint a, T b) {
+    a *= b;
+    return a;
+  }
+  template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
+  constexpr friend modint operator*(T a, modint b) {
+    b *= a;
+    return b;
+  }
+  constexpr friend modint operator/(modint a, modint b) { return a /= b; }
+  constexpr modint operator-(void) const { return modint() - *this; }
+  constexpr unsigned int val(void) const { return v; }
+  constexpr friend std::ostream& operator<<(std::ostream& out, modint x) {
+    return out << x.v;
+  }
+  constexpr modint inv(void) const { return mrpython::fastPow(*this, P - 2); }
+  constexpr modint pow(unsigned long long int n) const {
+    return mrpython::fastPow(*this, n);
+  }
+  static constexpr unsigned modval() { return P; }
+};
+}  // namespace mrpython
+#endif  // MP_LIBRARY_MODINT_HPP

library/mrpython/numeric.hpp

@@ -0,0 +1,26 @@
+#ifndef MP_LIBRARY_NUMERIC_HPP
+#define MP_LIBRARY_NUMERIC_HPP
+
+#include <vector>
+namespace mrpython {
+template <typename T, typename F = std::multiplies<T>>
+constexpr T fastPow(T a, unsigned long long int n, T ans = 1,
+                    F const& f = F()) {
+  while (n) {
+    if (n & 1) ans = f(ans, a);
+    a = f(a, a);
+    n >>= 1;
+  }
+  return ans;
+}
+template <typename T> T frac(unsigned int n) {
+  static std::vector<T> mem = {1};
+  while (mem.size() <= n) mem.push_back(mem.back() * mem.size());
+  return mem[n];
+}
+template <typename T> T comb(unsigned int n, unsigned int m) {
+  return n < m ? 0 : frac<T>(n) / (frac<T>(m) * frac<T>(n - m));
+}
+}  // namespace mrpython
+
+#endif

library/mrpython/utility.hpp

@@ -1,7 +1,7 @@
 #ifndef MP_LIBRARY_UTILITY_HPP
 #define MP_LIBRARY_UTILITY_HPP
 #include <algorithm>
-#include <limits>
+#include <functional>
 
 namespace mrpython {
 struct max {

library/test/all.hpp

@@ -1,3 +1,4 @@
 #include "lazy_segment_tree/all.hpp"
+#include "modint.cpp"
 #include "sparse_table/all.hpp"
 #include "typical_segment_tree/all.hpp"