compile-time-known mod for speedup (#61)

* compiler-known mod

* fix clippy

* use global const mod instead

---------

Co-authored-by: Luke Videckis <lukevideckis@gmail.com>

Author: lrvideckis

examples/data_structures/seg_tree_yosupo.rs

@@ -3,6 +3,8 @@
 use proconio::input;
 use programming_team_code_rust::data_structures::seg_tree::SegTree;
 
+const MOD: u64 = 998_244_353;
+
 fn main() {
     input! {
         n: usize,
@@ -12,16 +14,16 @@ fn main() {
     let a = (0..n)
         .map(|_| {
             input! {
-                c: usize,
-                d: usize
+                c: u64,
+                d: u64
             }
             (c, d)
         })
-        .collect::<Vec<(usize, usize)>>();
+        .collect::<Vec<(u64, u64)>>();
 
-    let mut seg_tree = SegTree::<(usize, usize)>::build_on_array(
+    let mut seg_tree = SegTree::<(u64, u64)>::build_on_array(
         &a,
-        move |x, y| (x.0 * y.0 % 998244353, (y.0 * x.1 + y.1) % 998244353),
+        move |x, y| (x.0 * y.0 % MOD, (y.0 * x.1 + y.1) % MOD),
         (1, 0),
     );
 
@@ -34,19 +36,19 @@ fn main() {
             0 => {
                 input! {
                     idx: usize,
-                    c: usize,
-                    d: usize
+                    c: u64,
+                    d: u64
                 }
                 seg_tree.set(idx, (c, d));
             }
             _ => {
                 input! {
                     le: usize,
                     ri: usize,
-                    x: usize
+                    x: u64
                 }
                 let (c, d) = seg_tree.query(le..ri);
-                println!("{}", (c * x + d) % 998244353);
+                println!("{}", (c * x + d) % MOD);
             }
         }
     }

examples/graphs/hld_path_composite_yosupo.rs

@@ -4,6 +4,8 @@ use proconio::input;
 use programming_team_code_rust::data_structures::seg_tree::SegTree;
 use programming_team_code_rust::graphs::hld::HLD;
 
+const MOD: u64 = 998_244_353;
+
 fn main() {
     input! {
         n: usize,
@@ -13,12 +15,12 @@ fn main() {
     let a = (0..n)
         .map(|_| {
             input! {
-                c: usize,
-                d: usize
+                c: u64,
+                d: u64
             }
             (c, d)
         })
-        .collect::<Vec<(usize, usize)>>();
+        .collect::<Vec<(u64, u64)>>();
 
     input! {
         edges: [(usize, usize); n - 1],
@@ -37,14 +39,14 @@ fn main() {
         input_a[hld.tin[i]] = elem;
     }
 
-    let mut st_forwards = SegTree::<(usize, usize)>::build_on_array(
+    let mut st_forwards = SegTree::<(u64, u64)>::build_on_array(
         &input_a,
-        move |x, y| (x.0 * y.0 % 998244353, (y.0 * x.1 + y.1) % 998244353),
+        move |x, y| (x.0 * y.0 % MOD, (y.0 * x.1 + y.1) % MOD),
         (1, 0),
     );
-    let mut st_backwards = SegTree::<(usize, usize)>::build_on_array(
+    let mut st_backwards = SegTree::<(u64, u64)>::build_on_array(
         &input_a,
-        move |x, y| (x.0 * y.0 % 998244353, (x.0 * y.1 + x.1) % 998244353),
+        move |x, y| (x.0 * y.0 % MOD, (x.0 * y.1 + x.1) % MOD),
         (1, 0),
     );
 
@@ -57,8 +59,8 @@ fn main() {
             0 => {
                 input! {
                     u: usize,
-                    c: usize,
-                    d: usize
+                    c: u64,
+                    d: u64
                 }
                 st_forwards.set(hld.tin[u], (c, d));
                 st_backwards.set(hld.tin[u], (c, d));
@@ -67,7 +69,7 @@ fn main() {
                 input! {
                     u: usize,
                     v: usize,
-                    x: usize
+                    x: u64
                 }
                 let (mut u_anc_val, mut v_anc_val) = (st_forwards.unit, st_backwards.unit);
                 hld.path(u, v, |range, v_anc| {
@@ -78,7 +80,7 @@ fn main() {
                     }
                 });
                 let res = (st_forwards.op)(&u_anc_val, &v_anc_val);
-                println!("{}", (res.0 * x + res.1) % 998244353);
+                println!("{}", (res.0 * x + res.1) % MOD);
             }
         }
     }

examples/numbers/binom.rs

@@ -1,19 +1,13 @@
-// verification-helper: PROBLEM https://judge.yosupo.jp/problem/binomial_coefficient_prime_mod
+// verification-helper: PROBLEM https://onlinejudge.u-aizu.ac.jp/problems/DPL_5_E
 
 use proconio::input;
 use programming_team_code_rust::numbers::binom::Binom;
 
 fn main() {
     input! {
-        t: usize,
-        m: u64,
-    }
-    let mut binom = Binom::new(m);
-    for _ in 0..t {
-        input! {
-            n: usize,
-            k: usize,
-        }
-        println!("{}", binom.comb(n, k));
+        n: usize,
+        k: usize,
     }
+    let mut binom = Binom::default();
+    println!("{}", binom.comb(k, n));
 }

src/numbers/binom.rs

@@ -1,55 +1,49 @@
 //! # Binomial Coefficient
 
+const MOD: u64 = 1_000_000_007;
+
 /// # Example
 /// ```
 /// use programming_team_code_rust::numbers::binom::Binom;
 ///
-/// let mut binom = Binom::new(1_000_000_007);
+/// let mut binom = Binom::default();
 /// assert_eq!(binom.comb(5, 2), 10);
 /// assert_eq!(binom.comb(10, 3), 120);
 /// ```
 pub struct Binom {
     inv: Vec<u64>,
     fact: Vec<u64>,
     inv_fact: Vec<u64>,
-    modulo: u64,
 }
 
-impl Binom {
-    /// Create a new instance of Binom.
-    ///
-    /// # Complexity
-    /// - Time: O(1)
-    /// - Space: O(1)
-    pub fn new(modulo: u64) -> Binom {
-        Binom {
-            inv: vec![1; 2],
-            fact: vec![1; 2],
-            inv_fact: vec![1; 2],
-            modulo,
+impl Default for Binom {
+    fn default() -> Self {
+        Self {
+            inv: vec![1, 1],
+            fact: vec![1, 1],
+            inv_fact: vec![1, 1],
         }
     }
+}
 
+impl Binom {
     /// Calculate C(n, k)
     ///
     /// # Complexity
     /// - Time: O(1) amortized O(n)
     /// - Space: O(n)
     pub fn comb(&mut self, n: usize, k: usize) -> u64 {
-        assert!((n as u64) < self.modulo);
+        assert!((n as u64) < MOD);
         if n < k {
             return 0;
         }
         while self.inv.len() <= n {
             let i = self.inv.len();
-            self.inv.push(
-                self.modulo
-                    - (self.modulo / i as u64) * self.inv[self.modulo as usize % i] % self.modulo,
-            );
-            self.fact.push(self.fact[i - 1] * i as u64 % self.modulo);
-            self.inv_fact
-                .push(self.inv_fact[i - 1] * self.inv[i] % self.modulo);
+            self.inv
+                .push(MOD - (MOD / i as u64) * self.inv[MOD as usize % i] % MOD);
+            self.fact.push(self.fact[i - 1] * i as u64 % MOD);
+            self.inv_fact.push(self.inv_fact[i - 1] * self.inv[i] % MOD);
         }
-        self.fact[n] * self.inv_fact[k] % self.modulo * self.inv_fact[n - k] % self.modulo
+        self.fact[n] * self.inv_fact[k] % MOD * self.inv_fact[n - k] % MOD
     }
 }