[auto-verifier] docs commit 9a95075

Author: web-flow

index.md

@@ -52,22 +52,25 @@ data:
     pages:
     - icon: ':heavy_check_mark:'
       path: weilycoder/poly/fft.hpp
-      title: Implementation of Fast Fourier Transform (FFT) and its inverse.
+      title: Fast Fourier Transform (FFT) implementation
     - icon: ':heavy_check_mark:'
       path: weilycoder/poly/fft_convolve.hpp
-      title: Functions for performing convolution using Fast Fourier Transform (FFT).
+      title: Multiplying polynomials using Fast Fourier Transform (FFT)
     - icon: ':heavy_check_mark:'
       path: weilycoder/poly/fft_utility.hpp
       title: Utility functions and constants for Fast Fourier Transform (FFT)
     - icon: ':heavy_check_mark:'
       path: weilycoder/poly/karatsuba.hpp
       title: Multiply two polynomials using the Karatsuba algorithm.
+    - icon: ':heavy_check_mark:'
+      path: weilycoder/poly/mtt_convolve.hpp
+      title: Multiply two polynomials under modulo using MTT with 3 NTT-friendly moduli.
     - icon: ':heavy_check_mark:'
       path: weilycoder/poly/ntt.hpp
-      title: Number Theoretic Transform (NTT)
+      title: Number Theoretic Transform (NTT) implementation
     - icon: ':heavy_check_mark:'
       path: weilycoder/poly/ntt_convolve.hpp
-      title: weilycoder/poly/ntt_convolve.hpp
+      title: Multiplying polynomials using Number Theoretic Transform (NTT)
   verificationCategories:
   - name: test
     pages:
@@ -80,6 +83,9 @@ data:
     - icon: ':heavy_check_mark:'
       path: test/convolution_mod.test.cpp
       title: test/convolution_mod.test.cpp
+    - icon: ':heavy_check_mark:'
+      path: test/convolution_mod_1000000007.test.cpp
+      title: test/convolution_mod_1000000007.test.cpp
     - icon: ':heavy_check_mark:'
       path: test/convolution_mod_2_64.test.cpp
       title: test/convolution_mod_2_64.test.cpp

test/aplusb.test.cpp.md

@@ -160,7 +160,7 @@ data:
   isVerificationFile: true
   path: test/aplusb.test.cpp
   requiredBy: []
-  timestamp: '2025-11-07 09:14:02+08:00'
+  timestamp: '2025-11-07 22:54:43+08:00'
   verificationStatus: TEST_ACCEPTED
   verifiedWith: []
 documentation_of: test/aplusb.test.cpp

test/biconnected_components.test.cpp.md

@@ -112,7 +112,7 @@ data:
   isVerificationFile: true
   path: test/biconnected_components.test.cpp
   requiredBy: []
-  timestamp: '2025-11-07 09:14:02+08:00'
+  timestamp: '2025-11-07 22:54:43+08:00'
   verificationStatus: TEST_ACCEPTED
   verifiedWith: []
 documentation_of: test/biconnected_components.test.cpp

test/convolution_mod.test.cpp.md

@@ -95,7 +95,7 @@ data:
   isVerificationFile: true
   path: test/convolution_mod_2_64.test.cpp
   requiredBy: []
-  timestamp: '2025-11-07 09:14:02+08:00'
+  timestamp: '2025-11-07 22:54:43+08:00'
   verificationStatus: TEST_ACCEPTED
   verifiedWith: []
 documentation_of: test/convolution_mod_2_64.test.cpp

test/convolution_mod_1000000007.test.cpp.md

@@ -47,68 +47,106 @@ data:
     \ weilycoder\n\n\n#line 1 \"weilycoder/number-theory/mod_utility.hpp\"\n\n\n\n\
     /**\n * @file mod_utility.hpp\n * @brief Modular Arithmetic Utilities\n */\n\n\
     #line 10 \"weilycoder/number-theory/mod_utility.hpp\"\n\nnamespace weilycoder\
-    \ {\nusing u128 = unsigned __int128;\n\ntemplate <bool bit32 = false>\nconstexpr\
-    \ uint64_t mod_add(uint64_t a, uint64_t b, uint64_t modulus) {\n  if constexpr\
-    \ (bit32) {\n    uint64_t res = a + b;\n    if (res >= modulus)\n      res -=\
-    \ modulus;\n    return res;\n  } else {\n    u128 res = static_cast<u128>(a) +\
-    \ b;\n    if (res >= modulus)\n      res -= modulus;\n    return res;\n  }\n}\n\
-    \ntemplate <bool bit32 = false>\nconstexpr uint64_t mod_sub(uint64_t a, uint64_t\
-    \ b, uint64_t modulus) {\n  if constexpr (bit32) {\n    uint64_t res = (a >= b)\
-    \ ? (a - b) : (modulus + a - b);\n    return res;\n  } else {\n    u128 res =\
-    \ (a >= b) ? (a - b) : (static_cast<u128>(modulus) + a - b);\n    return res;\n\
-    \  }\n}\n\n/**\n * @brief Perform modular multiplication for 64-bit integers.\n\
-    \ * @tparam bit32 If true, won't use 128-bit arithmetic. You should ensure that\n\
-    \ *         all inputs are small enough to avoid overflow (i.e. bit-32).\n * @param\
-    \ a The first multiplicand.\n * @param b The second multiplicand.\n * @param modulus\
-    \ The modulus.\n * @return (a * b) % modulus\n */\ntemplate <bool bit32 = false>\n\
-    constexpr uint64_t mod_mul(uint64_t a, uint64_t b, uint64_t modulus) {\n  if constexpr\
-    \ (bit32)\n    return a * b % modulus;\n  else\n    return static_cast<u128>(a)\
-    \ * b % modulus;\n}\n\n/**\n * @brief Perform modular multiplication for 64-bit\
+    \ {\nusing u128 = unsigned __int128;\n\n/**\n * @brief Perform modular addition\
+    \ for 64-bit integers.\n * @tparam bit32 If true, won't use 128-bit arithmetic.\
+    \ You should ensure that\n *         all inputs are small enough to avoid overflow\
+    \ (i.e. bit-32).\n * @param a The first addend.\n * @param b The second addend.\n\
+    \ * @param modulus The modulus.\n * @return (a + b) % modulus\n */\ntemplate <bool\
+    \ bit32 = false>\nconstexpr uint64_t mod_add(uint64_t a, uint64_t b, uint64_t\
+    \ modulus) {\n  if constexpr (bit32) {\n    uint64_t res = a + b;\n    if (res\
+    \ >= modulus)\n      res -= modulus;\n    return res;\n  } else {\n    u128 res\
+    \ = static_cast<u128>(a) + b;\n    if (res >= modulus)\n      res -= modulus;\n\
+    \    return res;\n  }\n}\n\n/**\n * @brief Perform modular addition for 64-bit\
     \ integers with a compile-time\n *        modulus.\n * @tparam Modulus The modulus.\n\
-    \ * @tparam bit32 If true, won't use 128-bit arithmetic. You should ensure that\n\
-    \ *         all inputs are small enough to avoid overflow (i.e. bit-32).\n * @param\
-    \ a The first multiplicand.\n * @param b The second multiplicand.\n * @return\
-    \ (a * b) % Modulus\n */\ntemplate <uint64_t Modulus, bool bit32 = false>\nconstexpr\
-    \ uint64_t mod_mul(uint64_t a, uint64_t b) {\n  if constexpr (bit32)\n    return\
-    \ a * b % Modulus;\n  else\n    return static_cast<u128>(a) * b % Modulus;\n}\n\
-    \n/**\n * @brief Perform modular exponentiation for 64-bit integers.\n * @tparam\
-    \ bit32 If true, won't use 128-bit arithmetic. You should ensure that\n *    \
-    \     all inputs are small enough to avoid overflow (i.e. bit-32).\n * @param\
-    \ base The base number.\n * @param exponent The exponent.\n * @param modulus The\
-    \ modulus.\n * @return (base^exponent) % modulus\n */\ntemplate <bool bit32 =\
-    \ false>\nconstexpr uint64_t mod_pow(uint64_t base, uint64_t exponent, uint64_t\
-    \ modulus) {\n  uint64_t result = 1 % modulus;\n  base %= modulus;\n  while (exponent\
-    \ > 0) {\n    if (exponent & 1)\n      result = mod_mul<bit32>(result, base, modulus);\n\
-    \    base = mod_mul<bit32>(base, base, modulus);\n    exponent >>= 1;\n  }\n \
-    \ return result;\n}\n} // namespace weilycoder\n\n\n#line 1 \"weilycoder/number-theory/prime.hpp\"\
-    \n\n\n\n/**\n * @file prime.hpp\n * @brief Prime Number Utilities\n */\n\n#line\
-    \ 11 \"weilycoder/number-theory/prime.hpp\"\n#include <type_traits>\n\nnamespace\
-    \ weilycoder {\n/**\n * @brief Miller-Rabin primality test for a given base.\n\
-    \ * @tparam bit32 If true, won't use 128-bit arithmetic. You should ensure that\n\
-    \ *         all inputs are small enough to avoid overflow (i.e. bit-32).\n * @tparam\
-    \ base The base to test.\n * @param n The number to test for primality.\n * @param\
-    \ d An odd component of n-1 (n-1 = d * 2^s).\n * @param s The exponent of 2 in\
-    \ the factorization of n-1.\n * @return true if n is probably prime for the given\
-    \ base, false if composite.\n */\ntemplate <bool bit32, uint64_t base>\nconstexpr\
-    \ bool miller_rabin_test(uint64_t n, uint64_t d, uint32_t s) {\n  uint64_t x =\
-    \ mod_pow<bit32>(base, d, n);\n  if (x == 0 || x == 1 || x == n - 1)\n    return\
-    \ true;\n  for (uint32_t r = 1; r < s; ++r) {\n    x = mod_mul<bit32>(x, x, n);\n\
-    \    if (x == n - 1)\n      return true;\n  }\n  return false;\n}\n\n/**\n * @brief\
-    \ Variadic template to test multiple bases in Miller-Rabin test.\n * @tparam bit32\
-    \ If true, won't use 128-bit arithmetic. You should ensure that\n *         all\
-    \ inputs are small enough to avoid overflow (i.e. bit-32).\n * @tparam base The\
-    \ first base to test.\n * @tparam Rest The remaining bases to test.\n * @param\
+    \ * @param a The first addend.\n * @param b The second addend.\n * @return (a\
+    \ + b) % Modulus\n */\ntemplate <uint64_t Modulus> constexpr uint64_t mod_add(uint64_t\
+    \ a, uint64_t b) {\n  if constexpr (Modulus <= UINT32_MAX) {\n    uint64_t res\
+    \ = a + b;\n    if (res >= Modulus)\n      res -= Modulus;\n    return res;\n\
+    \  } else {\n    u128 res = static_cast<u128>(a) + b;\n    if (res >= Modulus)\n\
+    \      res -= Modulus;\n    return res;\n  }\n}\n\n/**\n * @brief Perform modular\
+    \ subtraction for 64-bit integers.\n * @tparam bit32 If true, won't use 128-bit\
+    \ arithmetic. You should ensure that\n *         all inputs are small enough to\
+    \ avoid overflow (i.e. bit-32).\n * @param a The minuend.\n * @param b The subtrahend.\n\
+    \ * @param modulus The modulus.\n * @return (a - b) % modulus\n */\ntemplate <bool\
+    \ bit32 = false>\nconstexpr uint64_t mod_sub(uint64_t a, uint64_t b, uint64_t\
+    \ modulus) {\n  if constexpr (bit32) {\n    uint64_t res = (a >= b) ? (a - b)\
+    \ : (modulus + a - b);\n    return res;\n  } else {\n    u128 res = (a >= b) ?\
+    \ (a - b) : (static_cast<u128>(modulus) + a - b);\n    return res;\n  }\n}\n\n\
+    /**\n * @brief Perform modular subtraction for 64-bit integers with a compile-time\n\
+    \ *        modulus.\n * @tparam Modulus The modulus.\n * @param a The minuend.\n\
+    \ * @param b The subtrahend.\n * @return (a - b) % Modulus\n */\ntemplate <uint64_t\
+    \ Modulus> constexpr uint64_t mod_sub(uint64_t a, uint64_t b) {\n  if constexpr\
+    \ (Modulus <= UINT32_MAX) {\n    uint64_t res = (a >= b) ? (a - b) : (Modulus\
+    \ + a - b);\n    return res;\n  } else {\n    u128 res = (a >= b) ? (a - b) :\
+    \ (static_cast<u128>(Modulus) + a - b);\n    return res;\n  }\n}\n\n/**\n * @brief\
+    \ Perform modular multiplication for 64-bit integers.\n * @tparam bit32 If true,\
+    \ won't use 128-bit arithmetic. You should ensure that\n *         all inputs\
+    \ are small enough to avoid overflow (i.e. bit-32).\n * @param a The first multiplicand.\n\
+    \ * @param b The second multiplicand.\n * @param modulus The modulus.\n * @return\
+    \ (a * b) % modulus\n */\ntemplate <bool bit32 = false>\nconstexpr uint64_t mod_mul(uint64_t\
+    \ a, uint64_t b, uint64_t modulus) {\n  if constexpr (bit32)\n    return a * b\
+    \ % modulus;\n  else\n    return static_cast<u128>(a) * b % modulus;\n}\n\n/**\n\
+    \ * @brief Perform modular multiplication for 64-bit integers with a compile-time\n\
+    \ *        modulus.\n * @tparam Modulus The modulus.\n * @param a The first multiplicand.\n\
+    \ * @param b The second multiplicand.\n * @return (a * b) % Modulus\n */\ntemplate\
+    \ <uint64_t Modulus> constexpr uint64_t mod_mul(uint64_t a, uint64_t b) {\n  if\
+    \ constexpr (Modulus <= UINT32_MAX)\n    return a * b % Modulus;\n  else\n   \
+    \ return static_cast<u128>(a) * b % Modulus;\n}\n\n/**\n * @brief Perform modular\
+    \ exponentiation for 64-bit integers.\n * @tparam bit32 If true, won't use 128-bit\
+    \ arithmetic. You should ensure that\n *         all inputs are small enough to\
+    \ avoid overflow (i.e. bit-32).\n * @param base The base number.\n * @param exponent\
+    \ The exponent.\n * @param modulus The modulus.\n * @return (base^exponent) %\
+    \ modulus\n */\ntemplate <bool bit32 = false>\nconstexpr uint64_t mod_pow(uint64_t\
+    \ base, uint64_t exponent, uint64_t modulus) {\n  uint64_t result = 1 % modulus;\n\
+    \  base %= modulus;\n  while (exponent > 0) {\n    if (exponent & 1)\n      result\
+    \ = mod_mul<bit32>(result, base, modulus);\n    base = mod_mul<bit32>(base, base,\
+    \ modulus);\n    exponent >>= 1;\n  }\n  return result;\n}\n\n/**\n * @brief Perform\
+    \ modular exponentiation for 64-bit integers with a compile-time\n *        modulus.\n\
+    \ * @tparam Modulus The modulus.\n * @param base The base number.\n * @param exponent\
+    \ The exponent.\n * @return (base^exponent) % Modulus\n */\ntemplate <uint64_t\
+    \ Modulus>\nconstexpr uint64_t mod_pow(uint64_t base, uint64_t exponent) {\n \
+    \ uint64_t result = 1 % Modulus;\n  base %= Modulus;\n  while (exponent > 0) {\n\
+    \    if (exponent & 1)\n      result = mod_mul<Modulus>(result, base);\n    base\
+    \ = mod_mul<Modulus>(base, base);\n    exponent >>= 1;\n  }\n  return result;\n\
+    }\n\n/**\n * @brief Compute the modular inverse of a 64-bit integer using Fermat's\
+    \ Little\n *        Theorem.\n * @tparam Modulus The modulus (must be prime).\n\
+    \ * @param a The number to find the modular inverse of.\n * @return The modular\
+    \ inverse of a modulo Modulus.\n */\ntemplate <uint64_t Modulus> constexpr uint64_t\
+    \ mod_inv(uint64_t a) {\n  return mod_pow<Modulus>(a, Modulus - 2);\n}\n\n/**\n\
+    \ * @brief Compute the modular inverse of a compile-time 64-bit integer using\n\
+    \ *        Fermat's Little Theorem.\n * @tparam Modulus The modulus (must be prime).\n\
+    \ * @tparam a The number to find the modular inverse of.\n * @return The modular\
+    \ inverse of a modulo Modulus.\n */\ntemplate <uint64_t Modulus, uint64_t a> constexpr\
+    \ uint64_t mod_inv() {\n  return mod_pow<Modulus>(a, Modulus - 2);\n}\n} // namespace\
+    \ weilycoder\n\n\n#line 1 \"weilycoder/number-theory/prime.hpp\"\n\n\n\n/**\n\
+    \ * @file prime.hpp\n * @brief Prime Number Utilities\n */\n\n#line 11 \"weilycoder/number-theory/prime.hpp\"\
+    \n#include <type_traits>\n\nnamespace weilycoder {\n/**\n * @brief Miller-Rabin\
+    \ primality test for a given base.\n * @tparam bit32 If true, won't use 128-bit\
+    \ arithmetic. You should ensure that\n *         all inputs are small enough to\
+    \ avoid overflow (i.e. bit-32).\n * @tparam base The base to test.\n * @param\
     \ n The number to test for primality.\n * @param d An odd component of n-1 (n-1\
     \ = d * 2^s).\n * @param s The exponent of 2 in the factorization of n-1.\n *\
-    \ @return true if n is probably prime for all given bases, false if composite.\n\
-    \ */\ntemplate <bool bit32, uint64_t base, uint64_t... Rest>\nconstexpr std::enable_if_t<(sizeof...(Rest)\
-    \ != 0), bool>\nmiller_rabin_test(uint64_t n, uint64_t d, uint32_t s) {\n  return\
-    \ miller_rabin_test<bit32, base>(n, d, s) &&\n         miller_rabin_test<bit32,\
-    \ Rest...>(n, d, s);\n}\n\n/**\n * @brief Miller-Rabin primality test using multiple\
-    \ bases.\n * @tparam bit32 If true, won't use 128-bit arithmetic. You should ensure\
-    \ that\n *         all inputs are small enough to avoid overflow (i.e. bit-32).\n\
-    \ * @tparam bases The bases to test.\n * @param n The number to test for primality.\n\
-    \ * @return true if n is probably prime, false if composite.\n */\ntemplate <bool\
+    \ @return true if n is probably prime for the given base, false if composite.\n\
+    \ */\ntemplate <bool bit32, uint64_t base>\nconstexpr bool miller_rabin_test(uint64_t\
+    \ n, uint64_t d, uint32_t s) {\n  uint64_t x = mod_pow<bit32>(base, d, n);\n \
+    \ if (x == 0 || x == 1 || x == n - 1)\n    return true;\n  for (uint32_t r = 1;\
+    \ r < s; ++r) {\n    x = mod_mul<bit32>(x, x, n);\n    if (x == n - 1)\n     \
+    \ return true;\n  }\n  return false;\n}\n\n/**\n * @brief Variadic template to\
+    \ test multiple bases in Miller-Rabin test.\n * @tparam bit32 If true, won't use\
+    \ 128-bit arithmetic. You should ensure that\n *         all inputs are small\
+    \ enough to avoid overflow (i.e. bit-32).\n * @tparam base The first base to test.\n\
+    \ * @tparam Rest The remaining bases to test.\n * @param n The number to test\
+    \ for primality.\n * @param d An odd component of n-1 (n-1 = d * 2^s).\n * @param\
+    \ s The exponent of 2 in the factorization of n-1.\n * @return true if n is probably\
+    \ prime for all given bases, false if composite.\n */\ntemplate <bool bit32, uint64_t\
+    \ base, uint64_t... Rest>\nconstexpr std::enable_if_t<(sizeof...(Rest) != 0),\
+    \ bool>\nmiller_rabin_test(uint64_t n, uint64_t d, uint32_t s) {\n  return miller_rabin_test<bit32,\
+    \ base>(n, d, s) &&\n         miller_rabin_test<bit32, Rest...>(n, d, s);\n}\n\
+    \n/**\n * @brief Miller-Rabin primality test using multiple bases.\n * @tparam\
+    \ bit32 If true, won't use 128-bit arithmetic. You should ensure that\n *    \
+    \     all inputs are small enough to avoid overflow (i.e. bit-32).\n * @tparam\
+    \ bases The bases to test.\n * @param n The number to test for primality.\n *\
+    \ @return true if n is probably prime, false if composite.\n */\ntemplate <bool\
     \ bit32, uint64_t... bases> constexpr bool miller_rabin(uint64_t n) {\n  if (n\
     \ < 2)\n    return false;\n  if (n == 2 || n == 3)\n    return true;\n  if (n\
     \ % 2 == 0)\n    return false;\n\n  uint64_t d = n - 1, s = 0;\n  for (; d % 2\
@@ -201,7 +239,7 @@ data:
   isVerificationFile: true
   path: test/factorize.test.cpp
   requiredBy: []
-  timestamp: '2025-11-07 09:14:02+08:00'
+  timestamp: '2025-11-07 22:54:43+08:00'
   verificationStatus: TEST_ACCEPTED
   verifiedWith: []
 documentation_of: test/factorize.test.cpp

test/convolution_mod_2_64.test.cpp.md

@@ -162,7 +162,7 @@ data:
   isVerificationFile: true
   path: test/many_aplusb.test.cpp
   requiredBy: []
-  timestamp: '2025-11-07 09:14:02+08:00'
+  timestamp: '2025-11-07 22:54:43+08:00'
   verificationStatus: TEST_ACCEPTED
   verifiedWith: []
 documentation_of: test/many_aplusb.test.cpp

test/factorize.test.cpp.md

@@ -161,7 +161,7 @@ data:
   isVerificationFile: true
   path: test/many_aplusb_128bit.test.cpp
   requiredBy: []
-  timestamp: '2025-11-07 09:14:02+08:00'
+  timestamp: '2025-11-07 22:54:43+08:00'
   verificationStatus: TEST_ACCEPTED
   verifiedWith: []
 documentation_of: test/many_aplusb_128bit.test.cpp