[auto-verifier] docs commit ee7753d

Author: web-flow

index.md

@@ -34,13 +34,28 @@ data:
   - name: weilycoder/number-theory
     pages:
     - icon: ':heavy_check_mark:'
-      path: weilycoder/number-theory/modint.hpp
-      title: Modular Integer Arithmetic Utilities
+      path: weilycoder/number-theory/factorize.hpp
+      title: Functions for factorizing numbers using Pollard's Rho algorithm
+    - icon: ':heavy_check_mark:'
+      path: weilycoder/number-theory/mod_utility.hpp
+      title: Modular Arithmetic Utilities
     - icon: ':heavy_check_mark:'
       path: weilycoder/number-theory/prime.hpp
       title: Prime Number Utilities
+    - icon: ':heavy_check_mark:'
+      path: weilycoder/number-theory/primitive_root.hpp
+      title: Functions to find primitive roots modulo a prime
   - name: weilycoder/poly
     pages:
+    - icon: ':heavy_check_mark:'
+      path: weilycoder/poly/fft.hpp
+      title: Implementation of Fast Fourier Transform (FFT) and its inverse.
+    - icon: ':heavy_check_mark:'
+      path: weilycoder/poly/fft_convolve.hpp
+      title: Functions for performing convolution 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.
@@ -56,12 +71,18 @@ data:
     - icon: ':heavy_check_mark:'
       path: test/convolution_mod_2_64.test.cpp
       title: test/convolution_mod_2_64.test.cpp
+    - icon: ':heavy_check_mark:'
+      path: test/factorize.test.cpp
+      title: test/factorize.test.cpp
     - icon: ':heavy_check_mark:'
       path: test/many_aplusb.test.cpp
       title: test/many_aplusb.test.cpp
     - icon: ':heavy_check_mark:'
       path: test/many_aplusb_128bit.test.cpp
       title: test/many_aplusb_128bit.test.cpp
+    - icon: ':heavy_check_mark:'
+      path: test/multiplication_of_big_integers.fft.test.cpp
+      title: test/multiplication_of_big_integers.fft.test.cpp
     - icon: ':heavy_check_mark:'
       path: test/point_add_range_sum.test.cpp
       title: test/point_add_range_sum.test.cpp
@@ -74,6 +95,9 @@ data:
     - icon: ':heavy_check_mark:'
       path: test/primality_test.test.cpp
       title: test/primality_test.test.cpp
+    - icon: ':heavy_check_mark:'
+      path: test/primitive_root.test.cpp
+      title: test/primitive_root.test.cpp
     - icon: ':heavy_check_mark:'
       path: test/static_range_sum.test.cpp
       title: test/static_range_sum.test.cpp

test/aplusb.test.cpp.md

@@ -160,7 +160,7 @@ data:
   isVerificationFile: true
   path: test/aplusb.test.cpp
   requiredBy: []
-  timestamp: '2025-11-05 00:26:33+08:00'
+  timestamp: '2025-11-06 23:46:32+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-05 00:26:33+08:00'
+  timestamp: '2025-11-06 23:46:32+08:00'
   verificationStatus: TEST_ACCEPTED
   verifiedWith: []
 documentation_of: test/biconnected_components.test.cpp

test/convolution_mod_2_64.test.cpp.md

@@ -95,7 +95,7 @@ data:
   isVerificationFile: true
   path: test/convolution_mod_2_64.test.cpp
   requiredBy: []
-  timestamp: '2025-11-05 00:26:33+08:00'
+  timestamp: '2025-11-06 23:46:32+08:00'
   verificationStatus: TEST_ACCEPTED
   verifiedWith: []
 documentation_of: test/convolution_mod_2_64.test.cpp

test/factorize.test.cpp.md

@@ -0,0 +1,173 @@
+---
+data:
+  _extendedDependsOn:
+  - icon: ':heavy_check_mark:'
+    path: weilycoder/number-theory/factorize.hpp
+    title: Functions for factorizing numbers using Pollard's Rho algorithm
+  - icon: ':heavy_check_mark:'
+    path: weilycoder/number-theory/mod_utility.hpp
+    title: Modular Arithmetic Utilities
+  - icon: ':heavy_check_mark:'
+    path: weilycoder/number-theory/prime.hpp
+    title: Prime Number Utilities
+  _extendedRequiredBy: []
+  _extendedVerifiedWith: []
+  _isVerificationFailed: false
+  _pathExtension: cpp
+  _verificationStatusIcon: ':heavy_check_mark:'
+  attributes:
+    '*NOT_SPECIAL_COMMENTS*': ''
+    PROBLEM: https://judge.yosupo.jp/problem/factorize
+    links:
+    - https://judge.yosupo.jp/problem/factorize
+  bundledCode: "#line 1 \"test/factorize.test.cpp\"\n#define PROBLEM \"https://judge.yosupo.jp/problem/factorize\"\
+    \n\n#line 1 \"weilycoder/number-theory/factorize.hpp\"\n\n\n\n/**\n * @file factorize.hpp\n\
+    \ * @brief Functions for factorizing numbers using Pollard's Rho algorithm\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#include <cstdint>\n\nnamespace\
+    \ weilycoder {\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\
+    uint64_t modular_multiply_64(uint64_t a, uint64_t b, uint64_t modulus) {\n  if\
+    \ constexpr (bit32)\n    return a * b % modulus;\n  else\n    return static_cast<unsigned\
+    \ __int128>(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 * @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>\n\
+    uint64_t modular_multiply_64(uint64_t a, uint64_t b) {\n  if constexpr (bit32)\n\
+    \    return a * b % Modulus;\n  else\n    return static_cast<unsigned __int128>(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 fast_power_64(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 = modular_multiply_64<bit32>(result,\
+    \ base, modulus);\n    base = modular_multiply_64<bit32>(base, base, modulus);\n\
+    \    exponent >>= 1;\n  }\n  return result;\n}\n}\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 =\
+    \ fast_power_64<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 = modular_multiply_64<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\
+    \ == 0; d /= 2)\n    ++s;\n\n  return miller_rabin_test<bit32, bases...>(n, d,\
+    \ s);\n}\n\n/**\n * @brief Miller-Rabin primality test optimized for 64-bit integers.\n\
+    \ *        Uses a fixed set of bases that guarantee correctness\n *        for\
+    \ 64-bit integers.\n * @param n The number to test for primality.\n * @return\
+    \ true if n is prime, false if not prime.\n */\nconstexpr bool miller_rabin64(uint64_t\
+    \ n) {\n  return miller_rabin<false, 2, 325, 9375, 28178, 450775, 9780504, 1795265022>(n);\n\
+    }\n\n/**\n * @brief Miller-Rabin primality test optimized for 32-bit integers.\n\
+    \ *        Uses a fixed set of bases that guarantee correctness\n *        for\
+    \ 32-bit integers.\n * @param n The number to test for primality.\n * @return\
+    \ true if n is prime, false if not prime.\n */\nconstexpr bool miller_rabin32(uint32_t\
+    \ n) { return miller_rabin<true, 2, 7, 61>(n); }\n\nconstexpr bool is_prime(uint64_t\
+    \ n) {\n  if (n <= UINT32_MAX)\n    return miller_rabin32(static_cast<uint32_t>(n));\n\
+    \  return miller_rabin64(n);\n}\n} // namespace weilycoder\n\n\n#line 11 \"weilycoder/number-theory/factorize.hpp\"\
+    \n#include <algorithm>\n#include <array>\n#line 14 \"weilycoder/number-theory/factorize.hpp\"\
+    \n#include <numeric>\n#include <random>\n#include <utility>\n#include <vector>\n\
+    \nnamespace weilycoder {\n/**\n * @brief Pollard's Rho algorithm to find a non-trivial\
+    \ factor of x\n * @tparam bit32 Whether to use 32-bit modular multiplication\n\
+    \ * @param x The number to factorize\n * @param c The constant in the polynomial\
+    \ x^2 + c\n * @return A non-trivial factor of x\n */\ntemplate <bool bit32 = false>\
+    \ constexpr uint64_t pollard_rho(uint64_t x, uint64_t c) {\n  if (x % 2 == 0)\n\
+    \    return 2;\n  uint32_t step = 0, goal = 1;\n  uint64_t s = 0, t = 0;\n  uint64_t\
+    \ value = 1;\n  for (;; goal <<= 1, s = t, value = 1) {\n    for (step = 1; step\
+    \ <= goal; ++step) {\n      t = modular_multiply_64<bit32>(t, t, x) + c;\n   \
+    \   if (t >= x)\n        t -= x;\n      uint64_t diff = (s >= t ? s - t : t -\
+    \ s);\n      value = modular_multiply_64<bit32>(value, diff, x);\n      if (step\
+    \ % 127 == 0) {\n        uint64_t d = std::gcd(value, x);\n        if (d > 1)\n\
+    \          return d;\n      }\n    }\n    uint64_t d = std::gcd(value, x);\n \
+    \   if (d > 1)\n      return d;\n  }\n  return x;\n}\n\n/**\n * @brief Pollard's\
+    \ Rho algorithm to find a non-trivial factor of x\n * @tparam bit32 Whether to\
+    \ use 32-bit modular multiplication\n * @param x The number to factorize\n * @return\
+    \ A non-trivial factor of x\n */\ntemplate <bool bit32 = false> uint64_t pollard_rho(uint64_t\
+    \ x) {\n  static std::minstd_rand rng{};\n  if (x % 2 == 0)\n    return 2;\n \
+    \ uint64_t c = rng() % (x - 1) + 1;\n  return pollard_rho<bit32>(x, c);\n}\n\n\
+    /**\n * @brief Factorize a number into its prime factors\n * @tparam bit32 Whether\
+    \ to use 32-bit modular multiplication\n * @param x The number to factorize\n\
+    \ * @return A vector of prime factors of x\n */\ntemplate <bool bit32 = false>\
+    \ std::vector<uint64_t> factorize(uint64_t x) {\n  std::vector<uint64_t> factors;\n\
+    \  std::vector<std::pair<uint64_t, size_t>> stk;\n  stk.emplace_back(x, 1);\n\
+    \  while (!stk.empty()) {\n    auto [cur, cnt] = stk.back();\n    stk.pop_back();\n\
+    \    if (cur == 1)\n      continue;\n    if (is_prime(cur)) {\n      factors.resize(factors.size()\
+    \ + cnt, cur);\n      continue;\n    }\n    uint64_t factor = cur;\n    do\n \
+    \     factor = pollard_rho<bit32>(cur);\n    while (factor == cur);\n    size_t\
+    \ factor_count = 0;\n    while (cur % factor == 0)\n      cur /= factor, ++factor_count;\n\
+    \    stk.emplace_back(cur, cnt);\n    stk.emplace_back(factor, factor_count *\
+    \ cnt);\n  }\n  std::sort(factors.begin(), factors.end());\n  return factors;\n\
+    }\n\n/**\n * @brief Factorize a number into its prime factors with fixed-size\
+    \ array\n * @tparam N The size of the output array\n * @tparam bit32 Whether to\
+    \ use 32-bit modular multiplication\n * @param x The number to factorize\n * @return\
+    \ An array of prime factors of x\n */\ntemplate <size_t N = 64, bool bit32 = false>\n\
+    constexpr std::array<uint64_t, N> factorize_fixed(uint64_t x) {\n  size_t factor_idx\
+    \ = 0, stk_idx = 0;\n  std::array<uint64_t, N> factors{};\n  std::array<std::pair<uint64_t,\
+    \ size_t>, 64> stk{};\n  stk[stk_idx++] = {x, 1};\n  while (stk_idx > 0) {\n \
+    \   auto [cur, cnt] = stk[--stk_idx];\n    if (cur == 1)\n      continue;\n  \
+    \  if (is_prime(cur))\n      std::fill(factors.begin() + factor_idx, factors.begin()\
+    \ + factor_idx + cnt, cur),\n          factor_idx += cnt;\n    else {\n      uint64_t\
+    \ factor = cur;\n      do\n        factor = pollard_rho<bit32>(cur);\n      while\
+    \ (factor == cur);\n      size_t factor_count = 0;\n      while (cur % factor\
+    \ == 0)\n        cur /= factor, ++factor_count;\n      stk[stk_idx++] = {cur,\
+    \ cnt};\n      stk[stk_idx++] = {factor, factor_count * cnt};\n    }\n  }\n  std::sort(factors.begin(),\
+    \ factors.begin() + factor_idx);\n  return factors;\n}\n} // namespace weilycoder\n\
+    \n\n#line 4 \"test/factorize.test.cpp\"\n#include <iostream>\nusing namespace\
+    \ std;\nusing namespace weilycoder;\n\nint main() {\n  cin.tie(nullptr)->sync_with_stdio(false);\n\
+    \  cin.exceptions(cin.failbit | cin.badbit);\n  size_t t;\n  cin >> t;\n  while\
+    \ (t--) {\n    uint64_t x;\n    cin >> x;\n    auto primes = factorize<>(x);\n\
+    \    cout << primes.size();\n    for (auto p : primes)\n      cout << ' ' << p;\n\
+    \    cout << '\\n';\n  }\n  return 0;\n}\n"
+  code: "#define PROBLEM \"https://judge.yosupo.jp/problem/factorize\"\n\n#include\
+    \ \"../weilycoder/number-theory/factorize.hpp\"\n#include <iostream>\nusing namespace\
+    \ std;\nusing namespace weilycoder;\n\nint main() {\n  cin.tie(nullptr)->sync_with_stdio(false);\n\
+    \  cin.exceptions(cin.failbit | cin.badbit);\n  size_t t;\n  cin >> t;\n  while\
+    \ (t--) {\n    uint64_t x;\n    cin >> x;\n    auto primes = factorize<>(x);\n\
+    \    cout << primes.size();\n    for (auto p : primes)\n      cout << ' ' << p;\n\
+    \    cout << '\\n';\n  }\n  return 0;\n}"
+  dependsOn:
+  - weilycoder/number-theory/factorize.hpp
+  - weilycoder/number-theory/mod_utility.hpp
+  - weilycoder/number-theory/prime.hpp
+  isVerificationFile: true
+  path: test/factorize.test.cpp
+  requiredBy: []
+  timestamp: '2025-11-06 23:46:32+08:00'
+  verificationStatus: TEST_ACCEPTED
+  verifiedWith: []
+documentation_of: test/factorize.test.cpp
+layout: document
+redirect_from:
+- /verify/test/factorize.test.cpp
+- /verify/test/factorize.test.cpp.html
+title: test/factorize.test.cpp
+---

test/many_aplusb.test.cpp.md

@@ -162,7 +162,7 @@ data:
   isVerificationFile: true
   path: test/many_aplusb.test.cpp
   requiredBy: []
-  timestamp: '2025-11-05 00:26:33+08:00'
+  timestamp: '2025-11-06 23:46:32+08:00'
   verificationStatus: TEST_ACCEPTED
   verifiedWith: []
 documentation_of: test/many_aplusb.test.cpp

test/many_aplusb_128bit.test.cpp.md

@@ -161,7 +161,7 @@ data:
   isVerificationFile: true
   path: test/many_aplusb_128bit.test.cpp
   requiredBy: []
-  timestamp: '2025-11-05 00:26:33+08:00'
+  timestamp: '2025-11-06 23:46:32+08:00'
   verificationStatus: TEST_ACCEPTED
   verifiedWith: []
 documentation_of: test/many_aplusb_128bit.test.cpp