WIP

cmpute · cmpute · commit da5723435b13 · 2024-05-14T20:39:14.000+08:00
diff --git a/integer/CHANGELOG.md b/integer/CHANGELOG.md
@@ -10,6 +10,7 @@
 - The alterative `Debug` output of `UBig` and `IBig` will include `(digits: x, bits: y)` instead of `(x digits, y bits)`.
 - Implement bit operations (`BitAnd`, `BitOr`, `BitXor`) between `UBig` and `IBig`, and between `IBig` and unsigned primitive integers.
 - Fix a bug in `UBig::split_bits` and `UBig::clear_high_bits`
+- Reduce unsafe code ([#52](https://github.com/cmpute/dashu/pull/52) thanks to @eduardosm)
 
 ## 0.4.1
 
diff --git a/integer/src/arch/generic_16_bit/mod.rs b/integer/src/arch/generic_16_bit/mod.rs
@@ -4,6 +4,4 @@ pub(crate) mod add;
 #[path = "../generic/digits.rs"]
 pub(crate) mod digits;
 
-pub(crate) mod ntt;
-
 pub(crate) mod word;
diff --git a/integer/src/arch/generic_16_bit/ntt.rs b/integer/src/arch/generic_16_bit/ntt.rs
diff --git a/integer/src/arch/generic_32_bit/mod.rs b/integer/src/arch/generic_32_bit/mod.rs
@@ -4,6 +4,4 @@ pub(crate) mod add;
 #[path = "../generic/digits.rs"]
 pub(crate) mod digits;
 
-pub(crate) mod ntt;
-
 pub(crate) mod word;
diff --git a/integer/src/arch/generic_32_bit/ntt.rs b/integer/src/arch/generic_32_bit/ntt.rs
diff --git a/integer/src/arch/generic_64_bit/mod.rs b/integer/src/arch/generic_64_bit/mod.rs
@@ -4,6 +4,4 @@ pub(crate) mod add;
 #[path = "../generic/digits.rs"]
 pub(crate) mod digits;
 
-pub(crate) mod ntt;
-
 pub(crate) mod word;
diff --git a/integer/src/arch/generic_64_bit/ntt.rs b/integer/src/arch/generic_64_bit/ntt.rs
diff --git a/integer/src/arch/mod.rs b/integer/src/arch/mod.rs
@@ -4,7 +4,6 @@ use cfg_if::cfg_if;
 
 pub(crate) use arch_impl::add;
 pub(crate) use arch_impl::digits;
-pub(crate) use arch_impl::ntt;
 pub(crate) use arch_impl::word;
 
 // Architecture choice. The logic works like this:
diff --git a/integer/src/arch/x86/mod.rs b/integer/src/arch/x86/mod.rs
@@ -3,8 +3,5 @@ pub(crate) mod add;
 #[path = "../generic/digits.rs"]
 pub(crate) mod digits;
 
-#[path = "../generic_32_bit/ntt.rs"]
-pub(crate) mod ntt;
-
 #[path = "../generic_32_bit/word.rs"]
 pub(crate) mod word;
diff --git a/integer/src/arch/x86_64/mod.rs b/integer/src/arch/x86_64/mod.rs
@@ -3,8 +3,5 @@ pub(crate) mod add;
 #[path = "../generic/digits.rs"]
 pub(crate) mod digits;
 
-#[path = "../generic_64_bit/ntt.rs"]
-pub(crate) mod ntt;
-
 #[path = "../generic_64_bit/word.rs"]
 pub(crate) mod word;
diff --git a/integer/src/mul/karatsuba.rs b/integer/src/mul/karatsuba.rs
@@ -20,7 +20,7 @@ pub const MIN_LEN: usize = 3;
 
 /// Temporary memory required for multiplication.
 ///
-/// n bounds the length of the Smaller factor in words.
+/// n bounds the length of the smaller factor in words.
 pub fn memory_requirement_up_to(n: usize) -> Layout {
     /* We prove by induction that:
      * f(n) <= 2n + 2 log_2 (n-1)
diff --git a/integer/src/mul/mod.rs b/integer/src/mul/mod.rs
@@ -24,8 +24,7 @@ const_assert!(THRESHOLD_KARATSUBA + 1 >= toom_3::MIN_LEN);
 
 mod helpers;
 mod karatsuba;
-#[allow(dead_code)]
-pub(crate) mod ntt;
+mod schoenhagen;
 mod simple;
 mod toom_3;
 
diff --git a/integer/src/mul/ntt.rs b/integer/src/mul/ntt.rs
diff --git a/integer/src/mul/schoenhagen.rs b/integer/src/mul/schoenhagen.rs
@@ -0,0 +1,84 @@
+//! Number-theoretic multiplication algorithm.
+
+// TODO(0.5): try the implementation of concrete-ntt
+
+use crate::arch::{
+    word::Word,
+};
+
+struct FermatReducer(usize);
+
+enum FermatResidue<'a> {
+    Minus1,
+    Normal(&'a mut [Word])
+}
+
+impl FermatReducer {
+    fn reduce(&self, value: &mut [Word]) -> FermatResidue<'_> {
+        todo!()
+    }
+
+    /// Do butterfly operation in-place efficiently
+    /// 
+    /// (lhs, rhs) = ((lhs + rhs) % modulus, (lhs + rhs) % modulus)
+    fn butterfly(&self, lhs: &mut FermatResidue<'_>, rhs: &mut FermatResidue<'_>) {
+        todo!()
+    }
+
+    fn shl(&self) {
+        todo!()
+    }
+
+    fn mul(&self) {
+        todo!()
+    }
+}
+
+struct FFTParams {
+    m: usize, // bit size of the coefficients
+    l: usize, // size of the polynomial
+    n: usize // the modulus used in FFT is 2^n + 1
+}
+
+fn fft_forward() {
+
+}
+
+fn fft_reverse() {
+
+}
+
+fn memory_requirement_up_to() {
+    
+}
+
+fn add_signed_mul_same_len() {
+
+}
+
+fn add_signed_mul() {
+
+}
+
+// #[cfg(test)]
+// mod tests {
+//     use super::*;
+
+//     #[test]
+//     fn test_inverse() {
+//         let one: Word = 1;
+//         let one = RingElement::from(one);
+//         assert_eq!(MAX_ORDER_ROOT.inverse().mul(MAX_ORDER_ROOT), one);
+//         assert_eq!(MAX_ORDER_ROOT.inverse().inverse(), MAX_ORDER_ROOT);
+//     }
+
+//     #[test]
+//     fn test_roots() {
+//         let one: Word = 1;
+//         let one = RingElement::from(one);
+//         assert_eq!(ROOTS[0], one);
+//         assert_ne!(ROOTS[1], one);
+//         assert_eq!(INVERSE_ROOTS[0], one);
+//         assert_ne!(INVERSE_ROOTS[1], one);
+//     }
+// }
diff --git a/integer/src/mul/toom_3.rs b/integer/src/mul/toom_3.rs
@@ -53,7 +53,7 @@ pub fn memory_requirement_up_to(n: usize) -> Layout {
      */
 
     // Note: the recurence also works when we transition to Karatsuba, because
-    // Karatsuba memory requirements are Smaller.
+    // Karatsuba memory requirements are smaller.
     let num_words = 4 * n + 13 * (math::ceil_log2(n) as usize);
     memory::array_layout::<Word>(num_words)
 }
