Support modular division of signed numbers.

src/signed/invoc.rs

@@ -1,15 +1,21 @@
+moddiv_impls!(I192, I384);
 signed_impls!(I192, U192);
 subtraction_impls!(I192, I256, U256);
+mul_impls!(I192, I384);
+div_impls!(I192, U192);
 conversion_impls!(I192, U192, I256, U256);
+conversion_impls!(I192, U192, I384, U384);
 conversion_impls!(I192, U192, I512, U512);
 egcd_impls!(I256, U192, I192);
 modinv_impls!(U192, I256, U256);
+moddiv_impls!(I256, I512);
 add_impls!(I256, I320, U320);
 signed_impls!(I256, U256);
 cmp_impls!(I256);
 shift_impls!(I256, U256);
 subtraction_impls!(I256, I320, U320);
 mul_impls!(I256, I512);
+div_impls!(I256, U256);
 conversion_impls!(I256, U256, I320, U320);
 conversion_impls!(I256, U256, I512, U512);
 conversion_impls!(I256, U256, I640, U640);
@@ -23,12 +29,23 @@ subtraction_impls!(I320, I384, U384);
 mul_impls!(I320, I640);
 conversion_impls!(I320, U320, I384, U384);
 conversion_impls!(I320, U320, I640, U640);
+moddiv_impls!(I384, I768);
 signed_impls!(I384, U384);
 subtraction_impls!(I384, I448, U448);
+mul_impls!(I384, I768);
+div_impls!(I384, U384);
 conversion_impls!(I384, U384, I448, U448);
+conversion_impls!(I384, U384, I768, U768);
 conversion_impls!(I384, U384, I896, U896);
+egcd_impls!(I448, U384, I384);
+modinv_impls!(U384, I448, U448);
+add_impls!(I448, I512, U512);
 signed_impls!(I448, U448);
+cmp_impls!(I448);
+shift_impls!(I448, U448);
+subtraction_impls!(I448, I512, U512);
 mul_impls!(I448, I896);
+conversion_impls!(I448, U448, I512, U512);
 conversion_impls!(I448, U448, I896, U896);
 signed_impls!(I512, U512);
 subtraction_impls!(I512, I576, U576);
@@ -38,20 +55,31 @@ conversion_impls!(I512, U512, I576, U576);
 conversion_impls!(I512, U512, I1024, U1024);
 egcd_impls!(I576, U512, I512);
 modinv_impls!(U512, I576, U576);
+moddiv_impls!(I576, I1152);
 add_impls!(I576, I640, U640);
 signed_impls!(I576, U576);
 cmp_impls!(I576);
 shift_impls!(I576, U576);
 subtraction_impls!(I576, I640, U640);
+mul_impls!(I576, I1152);
+div_impls!(I576, U576);
 conversion_impls!(I576, U576, I640, U640);
+conversion_impls!(I576, U576, I1152, U1152);
 conversion_impls!(I576, U576, I1280, U1280);
+egcd_impls!(I640, U576, I576);
+modinv_impls!(U576, I640, U640);
+add_impls!(I640, I704, U704);
 signed_impls!(I640, U640);
+cmp_impls!(I640);
+shift_impls!(I640, U640);
 subtraction_impls!(I640, I704, U704);
 mul_impls!(I640, I1280);
 div_impls!(I640, U640);
 conversion_impls!(I640, U640, I704, U704);
 conversion_impls!(I640, U640, I1280, U1280);
 signed_impls!(I704, U704);
+signed_impls!(I768, U768);
+div_impls!(I768, U768);
 signed_impls!(I896, U896);
 subtraction_impls!(I896, I960, U960);
 mul_impls!(I896, I1792);
@@ -70,6 +98,7 @@ shift_impls!(I1088, U1088);
 subtraction_impls!(I1088, I1152, U1152);
 conversion_impls!(I1088, U1088, I1152, U1152);
 signed_impls!(I1152, U1152);
+div_impls!(I1152, U1152);
 signed_impls!(I1280, U1280);
 subtraction_impls!(I1280, I1344, U1344);
 mul_impls!(I1280, I2560);
@@ -164,7 +193,9 @@ mod tests {
 
     generate_sigadd_tests!(I256, U256, i256, I320, U320);
     generate_sigadd_tests!(I320, U320, i320, I384, U384);
+    generate_sigadd_tests!(I448, U448, i448, I512, U512);
     generate_sigadd_tests!(I576, U576, i576, I640, U640);
+    generate_sigadd_tests!(I640, U640, i640, I704, U704);
     generate_sigadd_tests!(I1088, U1088, i1088, I1152, U1152);
     generate_sigadd_tests!(I1600, U1600, i1600, I1664, U1664);
     generate_sigadd_tests!(I2112, U2112, i2112, I2176, U2176);
@@ -182,6 +213,7 @@ mod tests {
     generate_sigsub_tests!(I256, U256, i256, I320, U320);
     generate_sigsub_tests!(I320, U320, i320, I384, U384);
     generate_sigsub_tests!(I384, U384, i384, I448, U448);
+    generate_sigsub_tests!(I448, U448, i448, I512, U512);
     generate_sigsub_tests!(I512, U512, i512, I576, U576);
     generate_sigsub_tests!(I576, U576, i576, I640, U640);
     generate_sigsub_tests!(I640, U640, i640, I704, U704);
@@ -209,6 +241,7 @@ mod tests {
     generate_signed_tests!(I576, U576, i576);
     generate_signed_tests!(I640, U640, i640);
     generate_signed_tests!(I704, U704, i704);
+    generate_signed_tests!(I768, U768, i768);
     generate_signed_tests!(I896, U896, i896);
     generate_signed_tests!(I960, U960, i960);
     generate_signed_tests!(I1024, U1024, i1024);
@@ -250,6 +283,7 @@ mod tests {
     generate_sigconversion_tests!(I576, U576, i576);
     generate_sigconversion_tests!(I640, U640, i640);
     generate_sigconversion_tests!(I704, U704, i704);
+    generate_sigconversion_tests!(I768, U768, i768);
     generate_sigconversion_tests!(I896, U896, i896);
     generate_sigconversion_tests!(I960, U960, i960);
     generate_sigconversion_tests!(I1024, U1024, i1024);
@@ -287,7 +321,9 @@ mod tests {
 
     generate_sigcmp_tests!(I256, U256, i256);
     generate_sigcmp_tests!(I320, U320, i320);
+    generate_sigcmp_tests!(I448, U448, i448);
     generate_sigcmp_tests!(I576, U576, i576);
+    generate_sigcmp_tests!(I640, U640, i640);
     generate_sigcmp_tests!(I1088, U1088, i1088);
     generate_sigcmp_tests!(I1600, U1600, i1600);
     generate_sigcmp_tests!(I2112, U2112, i2112);
@@ -301,10 +337,13 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_sigmul_tests!(I192, U192, i192, I384, U384);
     generate_sigmul_tests!(I256, U256, i256, I512, U512);
     generate_sigmul_tests!(I320, U320, i320, I640, U640);
+    generate_sigmul_tests!(I384, U384, i384, I768, U768);
     generate_sigmul_tests!(I448, U448, i448, I896, U896);
     generate_sigmul_tests!(I512, U512, i512, I1024, U1024);
+    generate_sigmul_tests!(I576, U576, i576, I1152, U1152);
     generate_sigmul_tests!(I640, U640, i640, I1280, U1280);
     generate_sigmul_tests!(I896, U896, i896, I1792, U1792);
     generate_sigmul_tests!(I1280, U1280, i1280, I2560, U2560);
@@ -313,9 +352,15 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_sigdiv_tests!(I192, U192, i192);
+    generate_sigdiv_tests!(I256, U256, i256);
+    generate_sigdiv_tests!(I384, U384, i384);
     generate_sigdiv_tests!(I512, U512, i512);
+    generate_sigdiv_tests!(I576, U576, i576);
     generate_sigdiv_tests!(I640, U640, i640);
+    generate_sigdiv_tests!(I768, U768, i768);
     generate_sigdiv_tests!(I896, U896, i896);
+    generate_sigdiv_tests!(I1152, U1152, i1152);
     generate_sigdiv_tests!(I1280, U1280, i1280);
   }
   mod sigshiftl {
@@ -324,7 +369,9 @@ mod tests {
 
     generate_sigshiftl_tests!(I256, U256, i256);
     generate_sigshiftl_tests!(I320, U320, i320);
+    generate_sigshiftl_tests!(I448, U448, i448);
     generate_sigshiftl_tests!(I576, U576, i576);
+    generate_sigshiftl_tests!(I640, U640, i640);
     generate_sigshiftl_tests!(I1088, U1088, i1088);
     generate_sigshiftl_tests!(I1600, U1600, i1600);
     generate_sigshiftl_tests!(I2112, U2112, i2112);
@@ -340,7 +387,9 @@ mod tests {
 
     generate_sigshiftr_tests!(I256, U256, i256);
     generate_sigshiftr_tests!(I320, U320, i320);
+    generate_sigshiftr_tests!(I448, U448, i448);
     generate_sigshiftr_tests!(I576, U576, i576);
+    generate_sigshiftr_tests!(I640, U640, i640);
     generate_sigshiftr_tests!(I1088, U1088, i1088);
     generate_sigshiftr_tests!(I1600, U1600, i1600);
     generate_sigshiftr_tests!(I2112, U2112, i2112);
@@ -356,7 +405,9 @@ mod tests {
 
     generate_egcd_tests!(I192, U192, i192, I256, U256);
     generate_egcd_tests!(I256, U256, i256, I320, U320);
+    generate_egcd_tests!(I384, U384, i384, I448, U448);
     generate_egcd_tests!(I512, U512, i512, I576, U576);
+    generate_egcd_tests!(I576, U576, i576, I640, U640);
     generate_egcd_tests!(ignore I1024, U1024, i1024, I1088, U1088);
     generate_egcd_tests!(ignore I1536, U1536, i1536, I1600, U1600);
     generate_egcd_tests!(ignore I2048, U2048, i2048, I2112, U2112);
@@ -366,13 +417,24 @@ mod tests {
     generate_egcd_tests!(ignore I8192, U8192, i8192, I8256, U8256);
     generate_egcd_tests!(ignore I15360, U15360, i15360, I15424, U15424);
   }
+  mod moddiv {
+    use super::super::*;
+    use testing::{build_test_path,run_test};
+
+    generate_moddiv_tests!(I192, U192, i192);
+    generate_moddiv_tests!(I256, U256, i256);
+    generate_moddiv_tests!(I384, U384, i384);
+    generate_moddiv_tests!(I576, U576, i576);
+  }
   mod modinv {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
     generate_modinv_tests!(I192, U192, i192);
     generate_modinv_tests!(I256, U256, i256);
+    generate_modinv_tests!(I384, U384, i384);
     generate_modinv_tests!(I512, U512, i512);
+    generate_modinv_tests!(I576, U576, i576);
     generate_modinv_tests!(I1024, U1024, i1024);
     generate_modinv_tests!(ignore I2048, U2048, i2048);
     generate_modinv_tests!(ignore I3072, U3072, i3072);

src/signed/mod.rs

@@ -22,6 +22,8 @@ mod div;
 #[macro_use]
 mod egcd;
 #[macro_use]
+mod moddiv;
+#[macro_use]
 mod modinv;
 #[macro_use]
 mod mul;
@@ -43,6 +45,7 @@ use std::ops::{Sub,SubAssign};
 use unsigned::*;
 
 pub use self::egcd::EGCD;
+pub use self::moddiv::ModDiv;
 pub use self::modinv::ModInv;
 
 include!("invoc.rs");

src/signed/moddiv.rs

@@ -0,0 +1,62 @@
+/// Computations of the modular inverse.
+pub trait ModDiv: Sized {
+    /// Compute the modular division of the number by the given number and
+    /// modulus. The divisor *must* have a modular inverse for this function
+    /// to succeed.
+    fn moddiv(&self, divisor: &Self, phi: &Self) -> Self;
+}
+
+macro_rules! moddiv_impls {
+    ($sname: ident, $dbl: ident) => {
+        impl ModDiv for $sname {
+            fn moddiv(&self, divisor: &Self, phi: &Self) -> Self
+            {
+                assert!(!divisor.is_negative());
+                let safe_divisor = divisor % phi;
+                let unsigned_i = safe_divisor.value.modinv(&phi.value).expect("no modular inverse of moddiv divisor");
+                let i = $sname::new(false, unsigned_i);
+                let selfi = i * self;
+                $sname::from( selfi % $dbl::from(phi) )
+            }
+        }
+    };
+}
+
+#[cfg(test)]
+macro_rules! generate_moddiv_tests {
+    ($sname: ident, $tname: ident, $mname: ident) => {
+        #[test]
+        fn $mname() {
+            generate_moddiv_tests!(body $sname, $tname, $mname);
+        }
+    };
+    (ignore $sname: ident, $tname: ident, $mname: ident) => {
+        #[test]
+        #[ignore]
+        fn $mname() {
+            generate_moddiv_tests!(body $sname, $tname, $mname);
+        }
+    };
+    (body $sname: ident, $tname: ident, $mname: ident) => {
+        let fname = build_test_path("moddiv", stringify!($sname));
+        run_test(fname.to_string(), 4, |case| {
+            let (nega, abytes) = case.get("a").unwrap();
+            let (negb, bbytes) = case.get("b").unwrap();
+            let (negm, mbytes) = case.get("m").unwrap();
+            let (negc, cbytes) = case.get("c").unwrap();
+
+            let a = $sname::new(*nega, $tname::from_bytes(abytes));
+            let b = $sname::new(*negb, $tname::from_bytes(bbytes));
+            let m = $sname::new(*negm, $tname::from_bytes(mbytes));
+            let c = $sname::new(*negc, $tname::from_bytes(cbytes));
+            let res = a.moddiv(&b, &m);
+            println!("-------------");
+            println!("a: {:x}", a);
+            println!("b: {:x}", b);
+            println!("m: {:x}", m);
+            println!("c: {:x}", c);
+            println!("r: {:x}", res);
+            assert_eq!(c, res);
+        });
+    };
+}

src/unsigned/invoc.rs

@@ -57,12 +57,14 @@ conversion_impls!(U320, U640);
 addition_impls!(U384, U448);
 base_impls!(U384, 6);
 random_impls!(U384, UniformU384);
+barrett_impl!(BarrettU384, U384, U448, U768, U832);
 div_impls!(U384, U768);
 multiply_impls!(U384, U768);
 shift_impls!(U384, 6);
 subtraction_impls!(U384, 6);
 conversion_impls!(U384, U448);
 conversion_impls!(U384, U768);
+conversion_impls!(U384, U832);
 conversion_impls!(U384, U896);
 conversion_impls!(U384, U1024);
 addition_impls!(U448, U512);
@@ -70,8 +72,11 @@ base_impls!(U448, 7);
 random_impls!(U448, UniformU448);
 div_impls!(U448, U896);
 multiply_impls!(U448, U896);
+shift_impls!(U448, 7);
 subtraction_impls!(U448, 7);
 conversion_impls!(U448, U512);
+conversion_impls!(U448, U768);
+conversion_impls!(U448, U832);
 conversion_impls!(U448, U896);
 addition_impls!(U512, U576);
 base_impls!(U512, 8);
@@ -95,6 +100,7 @@ prime_gen_impls!(U512);
 addition_impls!(U576, U640);
 base_impls!(U576, 9);
 random_impls!(U576, UniformU576);
+barrett_impl!(BarrettU576, U576, U640, U1152, U1216);
 div_impls!(U576, U1152);
 multiply_impls!(U576, U1152);
 shift_impls!(U576, 9);
@@ -103,6 +109,7 @@ conversion_impls!(U576, U640);
 conversion_impls!(U576, U1024);
 conversion_impls!(U576, U1088);
 conversion_impls!(U576, U1152);
+conversion_impls!(U576, U1216);
 conversion_impls!(U576, U1280);
 addition_impls!(U640, U704);
 base_impls!(U640, 10);
@@ -112,18 +119,35 @@ multiply_impls!(U640, U1280);
 shift_impls!(U640, 10);
 subtraction_impls!(U640, 10);
 conversion_impls!(U640, U704);
+conversion_impls!(U640, U1152);
+conversion_impls!(U640, U1216);
 conversion_impls!(U640, U1280);
 base_impls!(U704, 11);
 random_impls!(U704, UniformU704);
 subtraction_impls!(U704, 11);
+addition_impls!(U768, U832);
 base_impls!(U768, 12);
 random_impls!(U768, UniformU768);
+div_impls!(U768, U1536);
+multiply_impls!(U768, U1536);
+shift_impls!(U768, 12);
 subtraction_impls!(U768, 12);
+conversion_impls!(U768, U832);
+conversion_impls!(U768, U1536);
+addition_impls!(U832, U896);
+base_impls!(U832, 13);
+random_impls!(U832, UniformU832);
+div_impls!(U832, U1664);
+multiply_impls!(U832, U1664);
+subtraction_impls!(U832, 13);
+conversion_impls!(U832, U896);
+conversion_impls!(U832, U1664);
 addition_impls!(U896, U960);
 base_impls!(U896, 14);
 random_impls!(U896, UniformU896);
 div_impls!(U896, U1792);
 multiply_impls!(U896, U1792);
+shift_impls!(U896, 14);
 subtraction_impls!(U896, 14);
 conversion_impls!(U896, U960);
 conversion_impls!(U896, U1792);
@@ -161,18 +185,29 @@ conversion_impls!(U1088, U1152);
 conversion_impls!(U1088, U2048);
 conversion_impls!(U1088, U2112);
 conversion_impls!(U1088, U2176);
+addition_impls!(U1152, U1216);
 base_impls!(U1152, 18);
 random_impls!(U1152, UniformU1152);
 div_impls!(U1152, U2304);
 multiply_impls!(U1152, U2304);
 shift_impls!(U1152, 18);
 subtraction_impls!(U1152, 18);
+conversion_impls!(U1152, U1216);
 conversion_impls!(U1152, U2304);
+addition_impls!(U1216, U1280);
+base_impls!(U1216, 19);
+random_impls!(U1216, UniformU1216);
+div_impls!(U1216, U2432);
+multiply_impls!(U1216, U2432);
+subtraction_impls!(U1216, 19);
+conversion_impls!(U1216, U1280);
+conversion_impls!(U1216, U2432);
 addition_impls!(U1280, U1344);
 base_impls!(U1280, 20);
 random_impls!(U1280, UniformU1280);
 div_impls!(U1280, U2560);
 multiply_impls!(U1280, U2560);
+shift_impls!(U1280, 20);
 subtraction_impls!(U1280, 20);
 conversion_impls!(U1280, U1344);
 conversion_impls!(U1280, U2560);
@@ -249,6 +284,9 @@ subtraction_impls!(U2176, 34);
 base_impls!(U2304, 36);
 random_impls!(U2304, UniformU2304);
 subtraction_impls!(U2304, 36);
+base_impls!(U2432, 38);
+random_impls!(U2432, UniformU2432);
+subtraction_impls!(U2432, 38);
 base_impls!(U2560, 40);
 random_impls!(U2560, UniformU2560);
 subtraction_impls!(U2560, 40);
@@ -523,11 +561,13 @@ mod tests {
     generate_base_tests!(U640, u640);
     generate_base_tests!(U704, u704);
     generate_base_tests!(U768, u768);
+    generate_base_tests!(U832, u832);
     generate_base_tests!(U896, u896);
     generate_base_tests!(U960, u960);
     generate_base_tests!(U1024, u1024);
     generate_base_tests!(U1088, u1088);
     generate_base_tests!(U1152, u1152);
+    generate_base_tests!(U1216, u1216);
     generate_base_tests!(U1280, u1280);
     generate_base_tests!(U1344, u1344);
     generate_base_tests!(U1536, u1536);
@@ -538,6 +578,7 @@ mod tests {
     generate_base_tests!(U2112, u2112);
     generate_base_tests!(U2176, u2176);
     generate_base_tests!(U2304, u2304);
+    generate_base_tests!(U2432, u2432);
     generate_base_tests!(U2560, u2560);
     generate_base_tests!(U3072, u3072);
     generate_base_tests!(U3136, u3136);
@@ -584,11 +625,13 @@ mod tests {
     generate_conversion_tests!(U640, u640);
     generate_conversion_tests!(U704, u704);
     generate_conversion_tests!(U768, u768);
+    generate_conversion_tests!(U832, u832);
     generate_conversion_tests!(U896, u896);
     generate_conversion_tests!(U960, u960);
     generate_conversion_tests!(U1024, u1024);
     generate_conversion_tests!(U1088, u1088);
     generate_conversion_tests!(U1152, u1152);
+    generate_conversion_tests!(U1216, u1216);
     generate_conversion_tests!(U1280, u1280);
     generate_conversion_tests!(U1344, u1344);
     generate_conversion_tests!(U1536, u1536);
@@ -599,6 +642,7 @@ mod tests {
     generate_conversion_tests!(U2112, u2112);
     generate_conversion_tests!(U2176, u2176);
     generate_conversion_tests!(U2304, u2304);
+    generate_conversion_tests!(U2432, u2432);
     generate_conversion_tests!(U2560, u2560);
     generate_conversion_tests!(U3072, u3072);
     generate_conversion_tests!(U3136, u3136);
@@ -645,11 +689,13 @@ mod tests {
     generate_codec_tests!(U640, u640);
     generate_codec_tests!(U704, u704);
     generate_codec_tests!(U768, u768);
+    generate_codec_tests!(U832, u832);
     generate_codec_tests!(U896, u896);
     generate_codec_tests!(U960, u960);
     generate_codec_tests!(U1024, u1024);
     generate_codec_tests!(U1088, u1088);
     generate_codec_tests!(U1152, u1152);
+    generate_codec_tests!(U1216, u1216);
     generate_codec_tests!(U1280, u1280);
     generate_codec_tests!(U1344, u1344);
     generate_codec_tests!(U1536, u1536);
@@ -660,6 +706,7 @@ mod tests {
     generate_codec_tests!(U2112, u2112);
     generate_codec_tests!(U2176, u2176);
     generate_codec_tests!(U2304, u2304);
+    generate_codec_tests!(U2432, u2432);
     generate_codec_tests!(U2560, u2560);
     generate_codec_tests!(U3072, u3072);
     generate_codec_tests!(U3136, u3136);
@@ -709,11 +756,13 @@ mod tests {
     generate_cmp_tests!(U640, u640);
     generate_cmp_tests!(U704, u704);
     generate_cmp_tests!(U768, u768);
+    generate_cmp_tests!(U832, u832);
     generate_cmp_tests!(U896, u896);
     generate_cmp_tests!(U960, u960);
     generate_cmp_tests!(U1024, u1024);
     generate_cmp_tests!(U1088, u1088);
     generate_cmp_tests!(U1152, u1152);
+    generate_cmp_tests!(U1216, u1216);
     generate_cmp_tests!(U1280, u1280);
     generate_cmp_tests!(U1344, u1344);
     generate_cmp_tests!(U1536, u1536);
@@ -724,6 +773,7 @@ mod tests {
     generate_cmp_tests!(U2112, u2112);
     generate_cmp_tests!(U2176, u2176);
     generate_cmp_tests!(U2304, u2304);
+    generate_cmp_tests!(U2432, u2432);
     generate_cmp_tests!(U2560, u2560);
     generate_cmp_tests!(U3072, u3072);
     generate_cmp_tests!(U3136, u3136);
@@ -773,11 +823,13 @@ mod tests {
     generate_sub_tests!(U640, u640);
     generate_sub_tests!(U704, u704);
     generate_sub_tests!(U768, u768);
+    generate_sub_tests!(U832, u832);
     generate_sub_tests!(U896, u896);
     generate_sub_tests!(U960, u960);
     generate_sub_tests!(U1024, u1024);
     generate_sub_tests!(U1088, u1088);
     generate_sub_tests!(U1152, u1152);
+    generate_sub_tests!(U1216, u1216);
     generate_sub_tests!(U1280, u1280);
     generate_sub_tests!(U1344, u1344);
     generate_sub_tests!(U1536, u1536);
@@ -788,6 +840,7 @@ mod tests {
     generate_sub_tests!(U2112, u2112);
     generate_sub_tests!(U2176, u2176);
     generate_sub_tests!(U2304, u2304);
+    generate_sub_tests!(U2432, u2432);
     generate_sub_tests!(U2560, u2560);
     generate_sub_tests!(U3072, u3072);
     generate_sub_tests!(U3136, u3136);
@@ -831,12 +884,16 @@ mod tests {
     generate_shiftl_tests!(U256, u256);
     generate_shiftl_tests!(U320, u320);
     generate_shiftl_tests!(U384, u384);
+    generate_shiftl_tests!(U448, u448);
     generate_shiftl_tests!(U512, u512);
     generate_shiftl_tests!(U576, u576);
     generate_shiftl_tests!(U640, u640);
+    generate_shiftl_tests!(U768, u768);
+    generate_shiftl_tests!(U896, u896);
     generate_shiftl_tests!(U1024, u1024);
     generate_shiftl_tests!(U1088, u1088);
     generate_shiftl_tests!(U1152, u1152);
+    generate_shiftl_tests!(U1280, u1280);
     generate_shiftl_tests!(U1536, u1536);
     generate_shiftl_tests!(U1600, u1600);
     generate_shiftl_tests!(U2048, u2048);
@@ -871,12 +928,16 @@ mod tests {
     generate_shiftr_tests!(U256, u256);
     generate_shiftr_tests!(U320, u320);
     generate_shiftr_tests!(U384, u384);
+    generate_shiftr_tests!(U448, u448);
     generate_shiftr_tests!(U512, u512);
     generate_shiftr_tests!(U576, u576);
     generate_shiftr_tests!(U640, u640);
+    generate_shiftr_tests!(U768, u768);
+    generate_shiftr_tests!(U896, u896);
     generate_shiftr_tests!(U1024, u1024);
     generate_shiftr_tests!(U1088, u1088);
     generate_shiftr_tests!(U1152, u1152);
+    generate_shiftr_tests!(U1280, u1280);
     generate_shiftr_tests!(U1536, u1536);
     generate_shiftr_tests!(U1600, u1600);
     generate_shiftr_tests!(U2048, u2048);
@@ -915,9 +976,13 @@ mod tests {
     generate_add_tests!(U512, u512, U576);
     generate_add_tests!(U576, u576, U640);
     generate_add_tests!(U640, u640, U704);
+    generate_add_tests!(U768, u768, U832);
+    generate_add_tests!(U832, u832, U896);
     generate_add_tests!(U896, u896, U960);
     generate_add_tests!(U1024, u1024, U1088);
     generate_add_tests!(U1088, u1088, U1152);
+    generate_add_tests!(U1152, u1152, U1216);
+    generate_add_tests!(U1216, u1216, U1280);
     generate_add_tests!(U1280, u1280, U1344);
     generate_add_tests!(U1600, u1600, U1664);
     generate_add_tests!(U2048, u2048, U2112);
@@ -946,10 +1011,13 @@ mod tests {
     generate_mul_tests!(U512, u512, U1024);
     generate_mul_tests!(U576, u576, U1152);
     generate_mul_tests!(U640, u640, U1280);
+    generate_mul_tests!(U768, u768, U1536);
+    generate_mul_tests!(U832, u832, U1664);
     generate_mul_tests!(U896, u896, U1792);
     generate_mul_tests!(U1024, u1024, U2048);
     generate_mul_tests!(U1088, u1088, U2176);
     generate_mul_tests!(U1152, u1152, U2304);
+    generate_mul_tests!(U1216, u1216, U2432);
     generate_mul_tests!(U1280, u1280, U2560);
     generate_mul_tests!(U1536, u1536, U3072);
     generate_mul_tests!(U1600, u1600, U3200);
@@ -986,10 +1054,13 @@ mod tests {
     generate_div_tests!(U512, u512);
     generate_div_tests!(U576, u576);
     generate_div_tests!(U640, u640);
+    generate_div_tests!(U768, u768);
+    generate_div_tests!(U832, u832);
     generate_div_tests!(U896, u896);
     generate_div_tests!(U1024, u1024);
     generate_div_tests!(U1088, u1088);
     generate_div_tests!(U1152, u1152);
+    generate_div_tests!(U1216, u1216);
     generate_div_tests!(U1280, u1280);
     generate_div_tests!(U1536, u1536);
     generate_div_tests!(U2048, u2048);
@@ -1019,7 +1090,9 @@ mod tests {
 
     generate_barrett_gen_tests!(U192, u192, U256);
     generate_barrett_gen_tests!(U256, u256, U320);
+    generate_barrett_gen_tests!(U384, u384, U448);
     generate_barrett_gen_tests!(U512, u512, U576);
+    generate_barrett_gen_tests!(U576, u576, U640);
     generate_barrett_gen_tests!(U1024, u1024, U1088);
     generate_barrett_gen_tests!(U1536, u1536, U1600);
     generate_barrett_gen_tests!(ignore U2048, u2048, U2112);
@@ -1035,7 +1108,9 @@ mod tests {
 
     generate_barrett_red_tests!(U192, u192, U256, U384);
     generate_barrett_red_tests!(U256, u256, U320, U512);
+    generate_barrett_red_tests!(U384, u384, U448, U768);
     generate_barrett_red_tests!(U512, u512, U576, U1024);
+    generate_barrett_red_tests!(U576, u576, U640, U1152);
     generate_barrett_red_tests!(U1024, u1024, U1088, U2048);
     generate_barrett_red_tests!(U1536, u1536, U1600, U3072);
     generate_barrett_red_tests!(U2048, u2048, U2112, U4096);

test-generator/Invocs.hs

@@ -102,6 +102,7 @@ main = do
            SignedMul    -> hPutStrLn hndl ("mul_impls!(I" ++ show size ++ ", I" ++ show (size * 2) ++ ");")
            SignedDiv    -> hPutStrLn hndl ("div_impls!(I" ++ show size ++ ", U" ++ show size ++ ");")
            EGCD         -> hPutStrLn hndl ("egcd_impls!(I" ++ show (size + 64) ++ ", U" ++ show size ++ ", I" ++ show size ++ ");")
+           ModDiv       -> hPutStrLn hndl ("moddiv_impls!(I" ++ show size ++ ", I" ++ show (size * 2) ++ ");")
            ModInv       -> hPutStrLn hndl ("modinv_impls!(U" ++ show size ++ ", I" ++ show (size + 64) ++ ", U" ++ show (size + 64) ++ ");")
            SigConvert v -> hPutStrLn hndl ("conversion_impls!(I" ++ show size ++ ", U" ++ show size ++ ", I" ++ show v ++ ", U" ++ show v ++ ");")
            _            -> return ()
@@ -118,5 +119,6 @@ main = do
        generateSigTestBlock hndl "sigshiftl"     SignedShift True  16384 []       []
        generateSigTestBlock hndl "sigshiftr"     SignedShift True  16384 []       []
        generateSigTestBlock hndl "egcd"          EGCD        True  1024  [(+ 64)] [(+ 64)]
+       generateSigTestBlock hndl "moddiv"        ModDiv      True  2048  []       []
        generateSigTestBlock hndl "modinv"        ModInv      True  2048  []       []
        hPutStrLn hndl "}"

test-generator/Math.hs

@@ -4,11 +4,13 @@ module Math(
        , barrett, computeK, base
        , modulate, modulate'
        , isqrt
+       , divmod
        , showX, showB
        )
  where
 
 import Data.Bits(shiftL,shiftR)
+import GHC.Integer.GMP.Internals(recipModInteger)
 import Numeric(showHex)
 
 data AlgState = AlgState {
@@ -122,6 +124,13 @@ isqrt bits val = final
      | num >= (res + bit) = (num - (res + bit), res + (bit `shiftL` 1))
      | otherwise          = (num, res)
 
+divmod :: Integer -> Integer -> Integer -> Maybe Integer
+divmod x y m =
+  let y' = y `mod` m
+  in case recipModInteger y' m of
+       0 -> Nothing
+       i -> Just ((x * i) `mod` m)
+
 _run :: Integer -> Integer -> IO ()
 _run inputx inputy =
   do let (x, y, g, initState) = initialState inputx inputy 1

test-generator/Requirements.hs

@@ -11,6 +11,7 @@ data Operation = Add
                | BaseOps
                | Barretts
                | Div
+               | ModDiv
                | ModExp
                | ModMul
                | ModSq
@@ -64,6 +65,7 @@ needs = [ Need RSA         (\ size -> [Req (size `div` 2) Sub,
                                        Req size (Convert (((size * 2) + 64) * 2))
                                        ])
         , Need ECDSA       (\ size -> [Req size SignedSub,
+                                       Req size ModDiv,
                                        Req (size + 64) SignedMul,
                                        Req ((size + 64) * 2) SignedSub,
                                        Req ((size + 64) * 2) SignedDiv,
@@ -117,6 +119,12 @@ needs = [ Need RSA         (\ size -> [Req (size `div` 2) Sub,
                                        Req size Mul,
                                        Req size (Convert (size + 64))
                                       ])
+        , Need ModDiv      (\ size -> [Req size ModInv,
+                                       Req size SignedMul,
+                                       Req size SignedDiv,
+                                       Req (size * 2) SignedDiv,
+                                       Req size (SigConvert (size * 2))
+                                      ])
         , Need ModSq       (\ size -> [Req size BaseOps,
                                        Req (size * 2) BaseOps,
                                        Req size Barretts,
@@ -160,7 +168,8 @@ needs = [ Need RSA         (\ size -> [Req (size `div` 2) Sub,
                                        Req (size * 2) SignedBase,
                                        Req size (SigConvert (size * 2))
                                       ])
-        , Need SignedDiv   (\ size -> [Req size Div
+        , Need SignedDiv   (\ size -> [Req size Div,
+                                       Req size Add
                                       ])
         , Need EGCD        (\ size -> [Req size SignedBase,
                                        Req size BaseOps,

test-generator/Tests.hs

@@ -43,6 +43,7 @@ testDatabase = [
     (SignedSub,   "sigsub",         "signed subtraction",      sigsubTest),
     (SquareRoot,  "sqrt",           "square root",             sqrtTest),
     (EGCD,        "egcd",           "EGCD",                    egcdTest),
+    (ModDiv,      "moddiv",         "modular division",        moddivTest),
     (ModInv,      "modinv",         "modular inversion",       modinvTest)
   ]
 
@@ -278,6 +279,22 @@ egcdTest size memory0 =
                                    ("v", showX v)]
   in assert (v == gcd x y) (res, v, memory2)
 
+moddivTest :: Test
+moddivTest size memoryIn =
+  let attempt memory0 =
+        let (a, memory1) = genSign (generateNum memory0 "a" size)
+            (b, memory2) = generateNum memory1 "b" size
+            (m, memory3) = generateNum memory2 "m" size
+            maybe_res    = divmod a b m
+        in case maybe_res of
+             Nothing ->
+               attempt memory3
+             Just c ->
+               let res = Map.fromList [("a", showX a), ("b", showX b),
+                                       ("m", showX m), ("c", showX c)]
+               in (res, c, memory3)
+  in attempt memoryIn
+
 modinvTest :: Test
 modinvTest size memoryIn =
   let attempt memory0 =