feat: Implement logarithm and integration functions for polynomial operations

Author: weilycoder

test/log_of_formal_power_series.test.cpp

@@ -0,0 +1,21 @@
+#define PROBLEM "https://judge.yosupo.jp/problem/log_of_formal_power_series"
+
+#include "../weilycoder/poly/elementary_func/logarithm.hpp"
+#include <iostream>
+#include <vector>
+using namespace std;
+using namespace weilycoder;
+
+int main() {
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit | cin.badbit);
+  size_t n;
+  cin >> n;
+  vector<uint64_t> a(n);
+  for (size_t i = 0; i < n; ++i)
+    cin >> a[i];
+  auto res = ntt_logarithm<998244353>(a, n);
+  for (size_t i = 0; i < n; ++i)
+    cout << res[i] << " \n"[i + 1 == n];
+  return 0;
+}

weilycoder/poly/elementary_func/derivative.hpp

@@ -0,0 +1,18 @@
+#ifndef WEILYCODER_POLY_ELEMENTARY_FUNC_DERIVATIVE_HPP
+#define WEILYCODER_POLY_ELEMENTARY_FUNC_DERIVATIVE_HPP
+
+#include <vector>
+
+namespace weilycoder {
+template <typename T, typename MultiplyFunc>
+std::vector<T> derivative(const std::vector<T> &poly, MultiplyFunc number_mul) {
+  if (poly.size() <= 1)
+    return {};
+  std::vector<T> res(poly.size() - 1);
+  for (size_t i = 1; i < poly.size(); ++i)
+    res[i - 1] = number_mul(poly[i], T(i));
+  return res;
+}
+} // namespace weilycoder
+
+#endif

weilycoder/poly/elementary_func/integrate.hpp

@@ -0,0 +1,23 @@
+#ifndef WEILYCODER_POLY_ELEMENTARY_FUNC_INTEGRATE_HPP
+#define WEILYCODER_POLY_ELEMENTARY_FUNC_INTEGRATE_HPP
+
+#include "../../number_theory/mod_utility.hpp"
+#include <vector>
+
+namespace weilycoder {
+template <typename T, typename MultiplyFunc, typename InverseFunc>
+std::vector<T> integrate(const std::vector<T> &poly, MultiplyFunc number_mul,
+                         InverseFunc number_inv) {
+  std::vector<T> res(poly.size() + 1);
+  for (size_t i = 0; i < poly.size(); ++i)
+    res[i + 1] = number_mul(poly[i], number_inv(T(i + 1)));
+  return res;
+}
+
+template <uint64_t mod>
+std::vector<uint64_t> ntt_poly_integrate(const std::vector<uint64_t> &poly) {
+  return integrate<>(poly, mod_inv<mod>);
+}
+} // namespace weilycoder
+
+#endif

weilycoder/poly/elementary_func/logarithm.hpp

@@ -0,0 +1,34 @@
+#ifndef WEILYCODER_POLY_ELEMENTARY_FUNC_LOGARITHM_HPP
+#define WEILYCODER_POLY_ELEMENTARY_FUNC_LOGARITHM_HPP
+
+#include "../../number_theory/mod_utility.hpp"
+#include "../ntt_convolve.hpp"
+#include "derivative.hpp"
+#include "integrate.hpp"
+#include "inverse.hpp"
+#include "multiply.hpp"
+#include <cstdint>
+#include <vector>
+
+namespace weilycoder {
+template <typename T, typename PolyMultiplyFunc, typename SubtractFunc,
+          typename MultiplyFunc, typename InverseFunc>
+std::vector<T> logarithm(const std::vector<T> &poly, size_t n,
+                         PolyMultiplyFunc multiply, SubtractFunc number_sub,
+                         MultiplyFunc number_mul, InverseFunc number_inv) {
+  if (poly.empty() || poly[0] != T(1))
+    throw std::invalid_argument(
+        "Logarithm is only defined for polynomials with constant term 1.");
+  auto inv = poly_inv(poly, n, multiply, number_sub, number_inv);
+  auto prod = poly_mul(derivative(poly, number_mul), inv, n - 1, multiply);
+  return integrate(prod, number_mul, number_inv);
+}
+
+template <uint64_t mod>
+std::vector<uint64_t> ntt_logarithm(const std::vector<uint64_t> &poly, size_t n) {
+  return logarithm(poly, n, ntt_convolve<mod>, mod_sub<mod>, mod_mul<mod>,
+                   mod_inv<mod>);
+}
+} // namespace weilycoder
+
+#endif