Barrett versions of modsq/modmul/modexp, with tests.

generate.hs

@@ -130,9 +130,10 @@ generateInvocs =
            BaseOps    -> hPutStrLn hndl ("base_impls!(U" ++ show size ++ ", " ++ show (size `div` 64) ++ ");")
            Barretts   -> hPutStrLn hndl ("barrett_impl!(BarrettU" ++ show size ++ ", U" ++ show size ++ ", U" ++ show (size + 64) ++ ", U" ++ show (size * 2) ++ ", U" ++ show ((size * 2) + 64) ++ ");")
            Div        -> hPutStrLn hndl ("div_impls!(U" ++ show size ++ ", U" ++ show (size * 2) ++ ");")
-           ModExp     -> hPutStrLn hndl ("modexp_impls!(U" ++ show size ++ ");")
+           ModExp     -> hPutStrLn hndl ("modexp_impls!(U" ++ show size ++ ", U" ++ show size ++ ");") >>
-           ModMul     -> hPutStrLn hndl ("modmul_impls!(U" ++ show size ++ ", U" ++ show (size * 2) ++ ");")
+                         hPutStrLn hndl ("modexp_impls!(U" ++ show size ++ ", BarrettU" ++ show size ++ ");")
-           ModSq      -> hPutStrLn hndl ("modsq_impls!(U" ++ show size ++ ", U" ++ show (size * 2) ++ ");")
+           ModMul     -> hPutStrLn hndl ("modmul_impls!(U" ++ show size ++ ", U" ++ show (size * 2) ++ ", BarrettU" ++ show size ++ ");")
+           ModSq      -> hPutStrLn hndl ("modsq_impls!(U" ++ show size ++ ", U" ++ show (size * 2) ++ ", BarrettU" ++ show size ++ ");")
            Mul        -> hPutStrLn hndl ("multiply_impls!(U" ++ show size ++ ", U" ++ show (size * 2) ++ ");")
            Shifts     -> hPutStrLn hndl ("shift_impls!(U" ++ show size ++ ", " ++ show (size `div` 64) ++ ");")
            Square     -> hPutStrLn hndl ("square_impls!(U" ++ show size ++ ", U" ++ show (size * 2) ++ ", " ++ show size ++ ");")
@@ -157,6 +158,9 @@ generateInvocs =
        generateTestBlock hndl "modmul"         ModMul   True  []
        generateTestBlock hndl "modexp"         ModExp   True  []
        generateTestBlock hndl "square"         Square   True  [(* 2)]
+       generateTestBlock hndl "barrett_modsq"  Barretts True  [(+ 64)]
+       generateTestBlock hndl "barrett_modmul" Barretts True  [(+ 64)]
+       generateTestBlock hndl "barrett_modexp" Barretts True  [(+ 64)]
        hPutStrLn hndl "}"
 
 log :: String -> IO ()
@@ -327,29 +331,38 @@ generateAllTheTests =
      generateTests ModSq "modsq" dbB $ \ size memory0 ->
        let (a, memory1) = generateNum memory0 "a" size
            (m, memory2) = generateNum memory1 "m" size
+           k            = computeK m
+           u            = barrett m
            c            = (a * a) `mod` m
            res          = Map.fromList [("a", showX a), ("m", showX m),
-                                        ("c", showX c)]
+                                        ("c", showX c), ("u", showX u),
+                                        ("k", showX k)]
        in (res, c, memory2)
      let (dbC, genC) = emptyDatabase genB
      generateTests ModMul "modmul" dbC $ \ size memory0 ->
        let (a, memory1) = generateNum memory0 "a" size
            (b, memory2) = generateNum memory1 "b" size
            (m, memory3) = generateNum memory2 "m" size
+           k            = computeK m
+           u            = barrett m
            c            = (a * b) `mod` m
            res          = Map.fromList [("a", showX a), ("b", showX b),
-                                        ("m", showX m), ("c", showX c)]
+                                        ("m", showX m), ("c", showX c),
+                                        ("u", showX u), ("k", showX k)]
        in (res, c, memory3)
      let (dbD, genD) = emptyDatabase genC
      generateTests ModExp "modexp" dbD $ \ size memory0 ->
        let (b, memory1) = generateNum memory0 "b" size
            (e, memory2) = generateNum memory1 "e" size
            (m, memory3) = generateNum memory2 "m" size
+           k            = computeK m
+           u            = barrett m
            r            = powModInteger b e m
            res          = Map.fromList [("b", showX b), ("e", showX e),
-                                        ("m", showX m), ("r", showX r)]
+                                        ("m", showX m), ("r", showX r),
+                                        ("u", showX u), ("k", showX k)]
        in (res, r, memory3)
-     let (dbE, genE) = emptyDatabase genC
+     let (dbE, genE) = emptyDatabase genD
      generateTests Square "square" dbE $ \ size memory0 ->
        let (a, memory1) = generateNum memory0 "a" size
            r            = modulate    (a * a)     (2 * size)

src/unsigned/invoc.rs

@@ -1,8 +1,9 @@
 base_impls!(U192, 3);
 barrett_impl!(BarrettU192, U192, U256, U384, U448);
-modexp_impls!(U192);
+modexp_impls!(U192, U192);
-modmul_impls!(U192, U384);
+modexp_impls!(U192, BarrettU192);
-modsq_impls!(U192, U384);
+modmul_impls!(U192, U384, BarrettU192);
+modsq_impls!(U192, U384, BarrettU192);
 multiply_impls!(U192, U384);
 square_impls!(U192, U384, 192);
 conversion_impls!(U192, U256);
@@ -10,9 +11,10 @@ conversion_impls!(U192, U384);
 conversion_impls!(U192, U448);
 base_impls!(U256, 4);
 barrett_impl!(BarrettU256, U256, U320, U512, U576);
-modexp_impls!(U256);
+modexp_impls!(U256, U256);
-modmul_impls!(U256, U512);
+modexp_impls!(U256, BarrettU256);
-modsq_impls!(U256, U512);
+modmul_impls!(U256, U512, BarrettU256);
+modsq_impls!(U256, U512, BarrettU256);
 multiply_impls!(U256, U512);
 square_impls!(U256, U512, 256);
 conversion_impls!(U256, U320);
@@ -24,12 +26,14 @@ base_impls!(U320, 5);
 multiply_impls!(U320, U640);
 conversion_impls!(U320, U512);
 conversion_impls!(U320, U576);
+conversion_impls!(U320, U640);
 base_impls!(U384, 6);
 barrett_impl!(BarrettU384, U384, U448, U768, U832);
 div_impls!(U384, U768);
-modexp_impls!(U384);
+modexp_impls!(U384, U384);
-modmul_impls!(U384, U768);
+modexp_impls!(U384, BarrettU384);
-modsq_impls!(U384, U768);
+modmul_impls!(U384, U768, BarrettU384);
+modsq_impls!(U384, U768, BarrettU384);
 multiply_impls!(U384, U768);
 shift_impls!(U384, 6);
 square_impls!(U384, U768, 384);
@@ -49,9 +53,10 @@ conversion_impls!(U448, U896);
 base_impls!(U512, 8);
 barrett_impl!(BarrettU512, U512, U576, U1024, U1088);
 div_impls!(U512, U1024);
-modexp_impls!(U512);
+modexp_impls!(U512, U512);
-modmul_impls!(U512, U1024);
+modexp_impls!(U512, BarrettU512);
-modsq_impls!(U512, U1024);
+modmul_impls!(U512, U1024, BarrettU512);
+modsq_impls!(U512, U1024, BarrettU512);
 multiply_impls!(U512, U1024);
 shift_impls!(U512, 8);
 square_impls!(U512, U1024, 512);
@@ -62,9 +67,10 @@ addition_impls!(U576, U640);
 base_impls!(U576, 9);
 barrett_impl!(BarrettU576, U576, U640, U1152, U1216);
 div_impls!(U576, U1152);
-modexp_impls!(U576);
+modexp_impls!(U576, U576);
-modmul_impls!(U576, U1152);
+modexp_impls!(U576, BarrettU576);
-modsq_impls!(U576, U1152);
+modmul_impls!(U576, U1152, BarrettU576);
+modsq_impls!(U576, U1152, BarrettU576);
 multiply_impls!(U576, U1152);
 shift_impls!(U576, 9);
 square_impls!(U576, U1152, 576);
@@ -76,8 +82,10 @@ conversion_impls!(U576, U1152);
 conversion_impls!(U576, U1216);
 base_impls!(U640, 10);
 multiply_impls!(U640, U1280);
+shift_impls!(U640, 10);
 conversion_impls!(U640, U1152);
 conversion_impls!(U640, U1216);
+conversion_impls!(U640, U1280);
 addition_impls!(U768, U832);
 base_impls!(U768, 12);
 div_impls!(U768, U1536);
@@ -96,6 +104,7 @@ conversion_impls!(U832, U896);
 conversion_impls!(U832, U1664);
 addition_impls!(U896, U960);
 base_impls!(U896, 14);
+shift_impls!(U896, 14);
 subtraction_impls!(U896, 14);
 conversion_impls!(U896, U960);
 base_impls!(U960, 15);
@@ -103,9 +112,10 @@ addition_impls!(U1024, U1088);
 base_impls!(U1024, 16);
 barrett_impl!(BarrettU1024, U1024, U1088, U2048, U2112);
 div_impls!(U1024, U2048);
-modexp_impls!(U1024);
+modexp_impls!(U1024, U1024);
-modmul_impls!(U1024, U2048);
+modexp_impls!(U1024, BarrettU1024);
-modsq_impls!(U1024, U2048);
+modmul_impls!(U1024, U2048, BarrettU1024);
+modsq_impls!(U1024, U2048, BarrettU1024);
 multiply_impls!(U1024, U2048);
 shift_impls!(U1024, 16);
 square_impls!(U1024, U2048, 1024);
@@ -140,6 +150,7 @@ subtraction_impls!(U1216, 19);
 conversion_impls!(U1216, U1280);
 conversion_impls!(U1216, U2432);
 base_impls!(U1280, 20);
+shift_impls!(U1280, 20);
 addition_impls!(U1536, U1600);
 base_impls!(U1536, 24);
 subtraction_impls!(U1536, 24);
@@ -154,9 +165,10 @@ addition_impls!(U2048, U2112);
 base_impls!(U2048, 32);
 barrett_impl!(BarrettU2048, U2048, U2112, U4096, U4160);
 div_impls!(U2048, U4096);
-modexp_impls!(U2048);
+modexp_impls!(U2048, U2048);
-modmul_impls!(U2048, U4096);
+modexp_impls!(U2048, BarrettU2048);
-modsq_impls!(U2048, U4096);
+modmul_impls!(U2048, U4096, BarrettU2048);
+modsq_impls!(U2048, U4096, BarrettU2048);
 multiply_impls!(U2048, U4096);
 shift_impls!(U2048, 32);
 square_impls!(U2048, U4096, 2048);
@@ -176,6 +188,7 @@ conversion_impls!(U2112, U4160);
 conversion_impls!(U2112, U4224);
 addition_impls!(U2176, U2240);
 base_impls!(U2176, 34);
+shift_impls!(U2176, 34);
 subtraction_impls!(U2176, 34);
 conversion_impls!(U2176, U2240);
 base_impls!(U2240, 35);
@@ -191,9 +204,10 @@ conversion_impls!(U2432, U2496);
 base_impls!(U2496, 39);
 base_impls!(U3072, 48);
 barrett_impl!(BarrettU3072, U3072, U3136, U6144, U6208);
-modexp_impls!(U3072);
+modexp_impls!(U3072, U3072);
-modmul_impls!(U3072, U6144);
+modexp_impls!(U3072, BarrettU3072);
-modsq_impls!(U3072, U6144);
+modmul_impls!(U3072, U6144, BarrettU3072);
+modsq_impls!(U3072, U6144, BarrettU3072);
 multiply_impls!(U3072, U6144);
 square_impls!(U3072, U6144, 3072);
 conversion_impls!(U3072, U3136);
@@ -203,13 +217,15 @@ base_impls!(U3136, 49);
 multiply_impls!(U3136, U6272);
 conversion_impls!(U3136, U6144);
 conversion_impls!(U3136, U6208);
+conversion_impls!(U3136, U6272);
 addition_impls!(U4096, U4160);
 base_impls!(U4096, 64);
 barrett_impl!(BarrettU4096, U4096, U4160, U8192, U8256);
 div_impls!(U4096, U8192);
-modexp_impls!(U4096);
+modexp_impls!(U4096, U4096);
-modmul_impls!(U4096, U8192);
+modexp_impls!(U4096, BarrettU4096);
-modsq_impls!(U4096, U8192);
+modmul_impls!(U4096, U8192, BarrettU4096);
+modsq_impls!(U4096, U8192, BarrettU4096);
 multiply_impls!(U4096, U8192);
 shift_impls!(U4096, 64);
 square_impls!(U4096, U8192, 4096);
@@ -229,6 +245,7 @@ conversion_impls!(U4160, U8256);
 conversion_impls!(U4160, U8320);
 addition_impls!(U4224, U4288);
 base_impls!(U4224, 66);
+shift_impls!(U4224, 66);
 subtraction_impls!(U4224, 66);
 conversion_impls!(U4224, U4288);
 base_impls!(U4288, 67);
@@ -247,11 +264,13 @@ subtraction_impls!(U6208, 97);
 conversion_impls!(U6208, U6272);
 conversion_impls!(U6208, U12416);
 base_impls!(U6272, 98);
+shift_impls!(U6272, 98);
 base_impls!(U7680, 120);
 barrett_impl!(BarrettU7680, U7680, U7744, U15360, U15424);
-modexp_impls!(U7680);
+modexp_impls!(U7680, U7680);
-modmul_impls!(U7680, U15360);
+modexp_impls!(U7680, BarrettU7680);
-modsq_impls!(U7680, U15360);
+modmul_impls!(U7680, U15360, BarrettU7680);
+modsq_impls!(U7680, U15360, BarrettU7680);
 multiply_impls!(U7680, U15360);
 square_impls!(U7680, U15360, 7680);
 conversion_impls!(U7680, U7744);
@@ -261,13 +280,15 @@ base_impls!(U7744, 121);
 multiply_impls!(U7744, U15488);
 conversion_impls!(U7744, U15360);
 conversion_impls!(U7744, U15424);
+conversion_impls!(U7744, U15488);
 addition_impls!(U8192, U8256);
 base_impls!(U8192, 128);
 barrett_impl!(BarrettU8192, U8192, U8256, U16384, U16448);
 div_impls!(U8192, U16384);
-modexp_impls!(U8192);
+modexp_impls!(U8192, U8192);
-modmul_impls!(U8192, U16384);
+modexp_impls!(U8192, BarrettU8192);
-modsq_impls!(U8192, U16384);
+modmul_impls!(U8192, U16384, BarrettU8192);
+modsq_impls!(U8192, U16384, BarrettU8192);
 multiply_impls!(U8192, U16384);
 shift_impls!(U8192, 128);
 square_impls!(U8192, U16384, 8192);
@@ -287,6 +308,7 @@ conversion_impls!(U8256, U16448);
 conversion_impls!(U8256, U16512);
 addition_impls!(U8320, U8384);
 base_impls!(U8320, 130);
+shift_impls!(U8320, 130);
 subtraction_impls!(U8320, 130);
 conversion_impls!(U8320, U8384);
 base_impls!(U8384, 131);
@@ -303,9 +325,10 @@ base_impls!(U12480, 195);
 base_impls!(U15360, 240);
 barrett_impl!(BarrettU15360, U15360, U15424, U30720, U30784);
 div_impls!(U15360, U30720);
-modexp_impls!(U15360);
+modexp_impls!(U15360, U15360);
-modmul_impls!(U15360, U30720);
+modexp_impls!(U15360, BarrettU15360);
-modsq_impls!(U15360, U30720);
+modmul_impls!(U15360, U30720, BarrettU15360);
+modsq_impls!(U15360, U30720, BarrettU15360);
 multiply_impls!(U15360, U30720);
 shift_impls!(U15360, 240);
 square_impls!(U15360, U30720, 15360);
@@ -323,6 +346,7 @@ conversion_impls!(U15424, U30720);
 conversion_impls!(U15424, U30784);
 conversion_impls!(U15424, U30848);
 base_impls!(U15488, 242);
+shift_impls!(U15488, 242);
 addition_impls!(U16384, U16448);
 base_impls!(U16384, 256);
 div_impls!(U16384, U32768);
@@ -341,6 +365,7 @@ conversion_impls!(U16448, U16512);
 conversion_impls!(U16448, U32896);
 addition_impls!(U16512, U16576);
 base_impls!(U16512, 258);
+shift_impls!(U16512, 258);
 subtraction_impls!(U16512, 258);
 conversion_impls!(U16512, U16576);
 base_impls!(U16576, 259);
@@ -362,6 +387,7 @@ conversion_impls!(U30784, U30848);
 conversion_impls!(U30784, U61568);
 addition_impls!(U30848, U30912);
 base_impls!(U30848, 482);
+shift_impls!(U30848, 482);
 subtraction_impls!(U30848, 482);
 conversion_impls!(U30848, U30912);
 base_impls!(U30912, 483);
@@ -720,26 +746,36 @@ mod tests {
     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!(U832, u832);
+    generate_shiftl_tests!(U896, u896);
     generate_shiftl_tests!(U1024, u1024);
     generate_shiftl_tests!(U1088, u1088);
     generate_shiftl_tests!(U1152, u1152);
     generate_shiftl_tests!(U1216, u1216);
+    generate_shiftl_tests!(U1280, u1280);
     generate_shiftl_tests!(U2048, u2048);
     generate_shiftl_tests!(U2112, u2112);
+    generate_shiftl_tests!(U2176, u2176);
     generate_shiftl_tests!(U4096, u4096);
     generate_shiftl_tests!(U4160, u4160);
+    generate_shiftl_tests!(U4224, u4224);
     generate_shiftl_tests!(U6144, u6144);
     generate_shiftl_tests!(U6208, u6208);
+    generate_shiftl_tests!(U6272, u6272);
     generate_shiftl_tests!(U8192, u8192);
     generate_shiftl_tests!(U8256, u8256);
+    generate_shiftl_tests!(U8320, u8320);
     generate_shiftl_tests!(U15360, u15360);
     generate_shiftl_tests!(U15424, u15424);
+    generate_shiftl_tests!(U15488, u15488);
     generate_shiftl_tests!(U16384, u16384);
     generate_shiftl_tests!(U16448, u16448);
+    generate_shiftl_tests!(U16512, u16512);
     generate_shiftl_tests!(U30720, u30720);
     generate_shiftl_tests!(U30784, u30784);
+    generate_shiftl_tests!(U30848, u30848);
   }
   mod shiftr {
     use super::super::*;
@@ -749,26 +785,36 @@ mod tests {
     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!(U832, u832);
+    generate_shiftr_tests!(U896, u896);
     generate_shiftr_tests!(U1024, u1024);
     generate_shiftr_tests!(U1088, u1088);
     generate_shiftr_tests!(U1152, u1152);
     generate_shiftr_tests!(U1216, u1216);
+    generate_shiftr_tests!(U1280, u1280);
     generate_shiftr_tests!(U2048, u2048);
     generate_shiftr_tests!(U2112, u2112);
+    generate_shiftr_tests!(U2176, u2176);
     generate_shiftr_tests!(U4096, u4096);
     generate_shiftr_tests!(U4160, u4160);
+    generate_shiftr_tests!(U4224, u4224);
     generate_shiftr_tests!(U6144, u6144);
     generate_shiftr_tests!(U6208, u6208);
+    generate_shiftr_tests!(U6272, u6272);
     generate_shiftr_tests!(U8192, u8192);
     generate_shiftr_tests!(U8256, u8256);
+    generate_shiftr_tests!(U8320, u8320);
     generate_shiftr_tests!(U15360, u15360);
     generate_shiftr_tests!(U15424, u15424);
+    generate_shiftr_tests!(U15488, u15488);
     generate_shiftr_tests!(U16384, u16384);
     generate_shiftr_tests!(U16448, u16448);
+    generate_shiftr_tests!(U16512, u16512);
     generate_shiftr_tests!(U30720, u30720);
     generate_shiftr_tests!(U30784, u30784);
+    generate_shiftr_tests!(U30848, u30848);
   }
   mod add {
     use super::super::*;
@@ -979,4 +1025,55 @@ mod tests {
     generate_square_tests!(U8192, u8192, U16384);
     generate_square_tests!(U15360, u15360, U30720);
   }
+  mod barrett_modsq {
+    use super::super::*;
+    use testing::run_test;
+
+    generate_barrett_modsq_tests!(U192, u192, U256);
+    generate_barrett_modsq_tests!(U256, u256, U320);
+    generate_barrett_modsq_tests!(U384, u384, U448);
+    generate_barrett_modsq_tests!(U512, u512, U576);
+    generate_barrett_modsq_tests!(U576, u576, U640);
+    generate_barrett_modsq_tests!(U1024, u1024, U1088);
+    generate_barrett_modsq_tests!(U2048, u2048, U2112);
+    generate_barrett_modsq_tests!(U3072, u3072, U3136);
+    generate_barrett_modsq_tests!(U4096, u4096, U4160);
+    generate_barrett_modsq_tests!(U7680, u7680, U7744);
+    generate_barrett_modsq_tests!(U8192, u8192, U8256);
+    generate_barrett_modsq_tests!(U15360, u15360, U15424);
+  }
+  mod barrett_modmul {
+    use super::super::*;
+    use testing::run_test;
+
+    generate_barrett_modmul_tests!(U192, u192, U256);
+    generate_barrett_modmul_tests!(U256, u256, U320);
+    generate_barrett_modmul_tests!(U384, u384, U448);
+    generate_barrett_modmul_tests!(U512, u512, U576);
+    generate_barrett_modmul_tests!(U576, u576, U640);
+    generate_barrett_modmul_tests!(U1024, u1024, U1088);
+    generate_barrett_modmul_tests!(U2048, u2048, U2112);
+    generate_barrett_modmul_tests!(U3072, u3072, U3136);
+    generate_barrett_modmul_tests!(U4096, u4096, U4160);
+    generate_barrett_modmul_tests!(U7680, u7680, U7744);
+    generate_barrett_modmul_tests!(U8192, u8192, U8256);
+    generate_barrett_modmul_tests!(U15360, u15360, U15424);
+  }
+  mod barrett_modexp {
+    use super::super::*;
+    use testing::run_test;
+
+    generate_barrett_modexp_tests!(U192, u192, U256);
+    generate_barrett_modexp_tests!(U256, u256, U320);
+    generate_barrett_modexp_tests!(U384, u384, U448);
+    generate_barrett_modexp_tests!(U512, u512, U576);
+    generate_barrett_modexp_tests!(U576, u576, U640);
+    generate_barrett_modexp_tests!(U1024, u1024, U1088);
+    generate_barrett_modexp_tests!(U2048, u2048, U2112);
+    generate_barrett_modexp_tests!(U3072, u3072, U3136);
+    generate_barrett_modexp_tests!(U4096, u4096, U4160);
+    generate_barrett_modexp_tests!(U7680, u7680, U7744);
+    generate_barrett_modexp_tests!(U8192, u8192, U8256);
+    generate_barrett_modexp_tests!(U15360, u15360, U15424);
+  }
 }

src/unsigned/modexp.rs

@@ -3,9 +3,9 @@ pub trait ModExp<T> {
 }
 
 macro_rules! modexp_impls {
-    ($name: ident) => {
+    ($name: ident, $other: ident) => {
-        impl ModExp<$name> for $name {
+        impl ModExp<$other> for $name {
-            fn modexp(&self, ine: &$name, m: &$name) -> $name {
+            fn modexp(&self, ine: &$name, m: &$other) -> $name {
                 // S <- g
                 let mut s = self.clone();
                 // A <- 1
@@ -18,7 +18,6 @@ macro_rules! modexp_impls {
                     // If e is odd then A <- A * S
                     if e.value[0] & 1 != 0 {
                         a = a.modmul(&s, m);
-                        println!("Updating a to {:X}", a);
                     }
                     // e <- floor(e / 2)
                     let mut carry = 0;
@@ -35,8 +34,6 @@ macro_rules! modexp_impls {
             }
         }
     };
-    ($name: ident, $barrett: ident) => {
-    };
 }
 
 #[cfg(test)]
@@ -45,7 +42,7 @@ macro_rules! generate_modexp_tests {
         #[test]
         fn $lname() {
             let fname = format!("testdata/modexp/{}.tests", stringify!($name));
-            run_test(fname.to_string(), 4, |case| {
+            run_test(fname.to_string(), 6, |case| {
                 let (neg0, bbytes) = case.get("b").unwrap();
                 let (neg1, ebytes) = case.get("e").unwrap();
                 let (neg2, mbytes) = case.get("m").unwrap();
@@ -61,3 +58,35 @@ macro_rules! generate_modexp_tests {
         }
     };
 }
+
+#[cfg(test)]
+macro_rules! generate_barrett_modexp_tests {
+    ($name: ident, $lname: ident, $bname: ident) => {
+        #[test]
+        fn $lname() {
+            let fname = format!("testdata/modexp/{}.tests", stringify!($name));
+            run_test(fname.to_string(), 6, |case| {
+                let (neg0, bbytes) = case.get("b").unwrap();
+                let (neg1, ebytes) = case.get("e").unwrap();
+                let (neg2, mbytes) = case.get("m").unwrap();
+                let (neg3, rbytes) = case.get("r").unwrap();
+                let (neg4, kbytes) = case.get("k").unwrap();
+                let (neg5, ubytes) = case.get("u").unwrap();
+                assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5);
+
+                let b    = $name::from_bytes(bbytes);
+                let e    = $name::from_bytes(ebytes);
+                let m    = $name::from_bytes(mbytes);
+                let r    = $name::from_bytes(rbytes);
+                let kbig = $name::from_bytes(kbytes);
+                let k    = usize::from(kbig);
+                let mu   = $bname::from_bytes(ubytes);
+                let bar  = $name::new_barrett(k, $bname::from(m), mu);
+
+                if k == b.value.len() {
+                    assert_eq!(r, b.modexp(&e, &bar));
+                }
+            });
+        }
+    };
+}

src/unsigned/modmul.rs

@@ -3,7 +3,7 @@ pub trait ModMul<T> {
 }
 
 macro_rules! modmul_impls {
-    ($name: ident, $dbl: ident) => {
+    ($name: ident, $dbl: ident, $barrett: ident) => {
         impl ModMul<$name> for $name {
             fn modmul(&self, x: &$name, m: &$name) -> $name {
                 let mulres      = (self as &$name) * x;
@@ -12,6 +12,13 @@ macro_rules! modmul_impls {
                 $name::from(bigres)
             }
         }
+
+        impl ModMul<$barrett> for $name {
+            fn modmul(&self, x: &$name, m: &$barrett) -> $name {
+                let mulres = (self as &$name) * x;
+                m.reduce(&mulres)
+            }
+        }
     };
 }
 
@@ -21,7 +28,7 @@ macro_rules! generate_modmul_tests {
         #[test]
         fn $lname() {
             let fname = format!("testdata/modmul/{}.tests", stringify!($name));
-            run_test(fname.to_string(), 4, |case| {
+            run_test(fname.to_string(), 6, |case| {
                 let (neg0, abytes) = case.get("a").unwrap();
                 let (neg1, bbytes) = case.get("b").unwrap();
                 let (neg2, mbytes) = case.get("m").unwrap();
@@ -37,3 +44,37 @@ macro_rules! generate_modmul_tests {
         }
     };
 }
+
+#[cfg(test)]
+macro_rules! generate_barrett_modmul_tests {
+    ($name: ident, $lname: ident, $bname: ident) => {
+        #[test]
+        fn $lname() {
+            let fname = format!("testdata/modmul/{}.tests", stringify!($name));
+            run_test(fname.to_string(), 6, |case| {
+                let (neg0, abytes) = case.get("a").unwrap();
+                let (neg1, bbytes) = case.get("b").unwrap();
+                let (neg2, mbytes) = case.get("m").unwrap();
+                let (neg3, cbytes) = case.get("c").unwrap();
+                let (neg4, kbytes) = case.get("k").unwrap();
+                let (neg5, ubytes) = case.get("u").unwrap();
+                assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5);
+
+                let a    = $name::from_bytes(abytes);
+                let b    = $name::from_bytes(bbytes);
+                let m    = $name::from_bytes(mbytes);
+                let c    = $name::from_bytes(cbytes);
+                let kbig = $name::from_bytes(kbytes);
+                let k    = usize::from(kbig);
+                let mu   = $bname::from_bytes(ubytes);
+                let bar  = $name::new_barrett(k, $bname::from(m), mu);
+
+                if k == a.value.len() {
+                    assert_eq!(c, a.modmul(&b, &bar));
+                }
+
+
+            });
+        }
+    };
+}

src/unsigned/modsq.rs

@@ -3,7 +3,7 @@ pub trait ModSquare<T> {
 }
 
 macro_rules! modsq_impls {
-    ($name: ident, $dbl: ident) => {
+    ($name: ident, $dbl: ident, $barrett: ident) => {
         impl ModSquare<$name> for $name {
             fn modsq(&self, m: &$name) -> $name {
                 let bigsquare = self.square();
@@ -12,6 +12,13 @@ macro_rules! modsq_impls {
                 $name::from(res)
             }
         }
+
+        impl ModSquare<$barrett> for $name {
+            fn modsq(&self, m: &$barrett) -> $name {
+                let bigsquare = self.square();
+                m.reduce(&bigsquare)
+            }
+        }
     };
 }
 
@@ -21,7 +28,7 @@ macro_rules! generate_modsq_tests {
         #[test]
         fn $lname() {
             let fname = format!("testdata/modsq/{}.tests", stringify!($name));
-            run_test(fname.to_string(), 3, |case| {
+            run_test(fname.to_string(), 5, |case| {
                 let (neg0, abytes) = case.get("a").unwrap();
                 let (neg1, mbytes) = case.get("m").unwrap();
                 let (neg2, cbytes) = case.get("c").unwrap();
@@ -35,3 +42,33 @@ macro_rules! generate_modsq_tests {
         }
     };
 }
+
+#[cfg(test)]
+macro_rules! generate_barrett_modsq_tests {
+    ($name: ident, $lname: ident, $bname: ident) => {
+        #[test]
+        fn $lname() {
+            let fname = format!("testdata/modsq/{}.tests", stringify!($name));
+            run_test(fname.to_string(), 5, |case| {
+                let (neg0, abytes) = case.get("a").unwrap();
+                let (neg1, mbytes) = case.get("m").unwrap();
+                let (neg2, cbytes) = case.get("c").unwrap();
+                let (neg3, kbytes) = case.get("k").unwrap();
+                let (neg4, ubytes) = case.get("u").unwrap();
+                assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4);
+
+                let a    = $name::from_bytes(abytes);
+                let m    = $name::from_bytes(mbytes);
+                let c    = $name::from_bytes(cbytes);
+                let kbig = $name::from_bytes(kbytes);
+                let k    = usize::from(kbig);
+                let mu   = $bname::from_bytes(ubytes);
+                let bar  = $name::new_barrett(k, $bname::from(m), mu);
+
+                if k == a.value.len() {
+                    assert_eq!(c, a.modsq(&bar));
+                }
+            });
+        }
+    };
+}

src/unsigned/sub.rs

@@ -85,10 +85,12 @@ macro_rules! generate_sub_tests {
                 let (neg2, cbytes) = case.get("c").unwrap();
                 assert!(!neg0 && !neg1 && !neg2);
 
-                let a = $name::from_bytes(abytes);
+                let mut a = $name::from_bytes(abytes);
                 let b     = $name::from_bytes(bbytes);
                 let c     = $name::from_bytes(cbytes);
-                assert_eq!(c, a - b);
+                assert_eq!(c, &a - &b);
+                a -= b;
+                assert_eq!(c, a);
             });
         }
     };