Refactor

Author: adamant-pwn

cp-algo/all

@@ -8,7 +8,7 @@
 namespace cp_algo {
     using namespace data_structures;
     using namespace geometry;
-    using namespace algebra;
+    using namespace math;
     using namespace linalg;
     using namespace random;
 }

cp-algo/data_structures/segtree/metas/affine.hpp

@@ -1,12 +1,12 @@
 #ifndef CP_ALGO_DATA_STRUCTURES_SEGMENT_TREE_METAS_AFFINE_HPP
 #define CP_ALGO_DATA_STRUCTURES_SEGMENT_TREE_METAS_AFFINE_HPP
 #include "base.hpp"
-#include "../../../algebra/affine.hpp"
+#include "../../../math/affine.hpp"
 namespace cp_algo::data_structures::segtree::metas {
     template<typename base>
     struct affine_meta: base_meta<affine_meta<base>> {
         using meta = affine_meta;
-        using lin = algebra::lin<base>;
+        using lin = math::lin<base>;
 
         base sum = 0;
         lin to_push = {};

cp-algo/data_structures/treap/metas/reverse.hpp

@@ -1,12 +1,12 @@
 #ifndef CP_ALGO_DATA_STRUCTURES_TREAP_METAS_REVERSE_HPP
 #define CP_ALGO_DATA_STRUCTURES_TREAP_METAS_REVERSE_HPP
 #include "base.hpp"
-#include "../../../algebra/affine.hpp"
+#include "../../../math/affine.hpp"
 #include <algorithm>
 namespace cp_algo::data_structures::treap::metas {
         template<typename base>
         struct reverse_meta: base_meta {
-            using lin = algebra::lin<base>;
+            using lin = math::lin<base>;
             base val;
             size_t sz = 1;
             bool reverse = false;

cp-algo/linalg/frobenius.hpp

@@ -1,16 +1,16 @@
 #ifndef CP_ALGO_LINALG_FROBENIUS_HPP
 #define CP_ALGO_LINALG_FROBENIUS_HPP
+#include "../math/poly.hpp"
 #include "matrix.hpp"
-#include "../algebra/poly.hpp"
 #include <algorithm>
 #include <vector>
-namespace cp_algo::linalg {
+namespace cp_algo::math::linalg {
     enum frobenius_mode {blocks, full};
     template<frobenius_mode mode = blocks>
     auto frobenius_form(auto const& A) {
         using matrix = std::decay_t<decltype(A)>;
         using base = matrix::base;
-        using polyn = algebra::poly_t<base>;
+        using polyn = math::poly_t<base>;
         assert(A.n() == A.m());
         size_t n = A.n();
         std::vector<polyn> charps;
@@ -76,7 +76,7 @@ namespace cp_algo::linalg {
 
     template<typename base>
     auto frobenius_pow(matrix<base> A, uint64_t k) {
-        using polyn = algebra::poly_t<base>;
+        using polyn = math::poly_t<base>;
         auto [T, Tinv, charps] = frobenius_form<full>(A);
         std::vector<matrix<base>> blocks;
         for(auto charp: charps) {

cp-algo/linalg/matrix.hpp

@@ -1,14 +1,14 @@
 #ifndef CP_ALGO_LINALG_MATRIX_HPP
 #define CP_ALGO_LINALG_MATRIX_HPP
 #include "../random/rng.hpp"
-#include "../algebra/common.hpp"
+#include "../math/common.hpp"
 #include "vector.hpp"
 #include <iostream>
 #include <optional>
 #include <cassert>
 #include <vector>
 #include <array>
-namespace cp_algo::linalg {
+namespace cp_algo::math::linalg {
     template<typename base_t>
     struct matrix: valarray_base<matrix<base_t>, vec<base_t>> {
         using base = base_t;

cp-algo/linalg/vector.hpp

@@ -1,14 +1,14 @@
 #ifndef CP_ALGO_LINALG_VECTOR_HPP
 #define CP_ALGO_LINALG_VECTOR_HPP
-#include "../algebra/modint.hpp"
 #include "../random/rng.hpp"
+#include "../math/modint.hpp"
 #include <functional>
 #include <algorithm>
 #include <valarray>
 #include <iostream>
 #include <iterator>
 #include <cassert>
-namespace cp_algo::linalg {
+namespace cp_algo::math::linalg {
     template<class vec, typename base>
     struct valarray_base: std::valarray<base> {
         using Base = std::valarray<base>;
@@ -120,7 +120,7 @@ namespace cp_algo::linalg {
     };
 
     template<typename base>
-    requires(std::is_base_of_v<algebra::modint_base<base>, base>)
+    requires(std::is_base_of_v<math::modint_base<base>, base>)
     struct vec<base>: vec_base<vec<base>, base> {
         using Base = vec_base<vec<base>, base>;
         using Base::Base;

cp-algo/algebra/README.md renamed to cp-algo/math/README.md

@@ -1,10 +1,10 @@
-#ifndef CP_ALGO_ALGEBRA_AFFINE_HPP
-#define CP_ALGO_ALGEBRA_AFFINE_HPP
+#ifndef CP_ALGO_MATH_AFFINE_HPP
+#define CP_ALGO_MATH_AFFINE_HPP
 #include <optional>
 #include <utility>
 #include <cassert>
 #include <tuple>
-namespace cp_algo::algebra {
+namespace cp_algo::math {
     // a * x + b
     template<typename base>
     struct lin {
@@ -68,4 +68,4 @@ namespace cp_algo::algebra {
         }
     };
 }
-#endif // CP_ALGO_ALGEBRA_AFFINE_HPP
+#endif // CP_ALGO_MATH_AFFINE_HPP

cp-algo/algebra/affine.hpp renamed to cp-algo/math/affine.hpp

@@ -1,8 +1,8 @@
-#ifndef CP_ALGO_ALGEBRA_ALL
-#define CP_ALGO_ALGEBRA_ALL
+#ifndef CP_ALGO_MATH_ALL
+#define CP_ALGO_MATH_ALL
 #include "modint.hpp"
 #include "affine.hpp"
 #include "common.hpp"
 #include "poly.hpp"
 #include "fft.hpp"
-#endif // CP_ALGO_ALGEBRA_ALL
+#endif // CP_ALGO_MATH_ALL

cp-algo/algebra/all renamed to cp-algo/math/all

@@ -0,0 +1,25 @@
+#ifndef CP_ALGO_MATH_COMBINATORICS_HPP
+#define CP_ALGO_MATH_COMBINATORICS_HPP
+#include "common.hpp"
+namespace cp_algo::math {
+    template<typename T>
+    T binom_large(T n, int r) {
+        assert(r < math::maxn);
+        T ans = 1;
+        for(int i = 0; i < r; i++) {
+            ans = ans * T(n - i) * small_inv<T>(i + 1);
+        }
+        return ans;
+    }
+    template<typename T>
+    T binom(int n, int r) {
+        if(r < 0 || r > n) {
+            return T(0);
+        } else if(n > math::maxn) {
+            return binom_large(n, r);
+        } else {
+            return math::fact<T>(n) * math::rfact<T>(r) * math::rfact<T>(n-r);
+        }
+    }
+}
+#endif // CP_ALGO_MATH_COMBINATORICS_HPP