Start porting over some of the random generation stuff.

src/cryptonum/mod.rs

@@ -41,6 +41,7 @@ use std::cmp::Ordering;
 use std::fmt::{Debug,Error,Formatter};
 use std::ops::*;
 pub use self::traits::*;
+use self::primes::SMALL_PRIMES;
 
 construct_unsigned!(U512,   BarretMu512,   u512,     8);
 construct_unsigned!(U1024,  BarretMu1024,  u1024,   16);

src/cryptonum/primes.rs

@@ -1,9 +1,115 @@
+pub static SMALL_PRIMES: [u32; 310] = [
+      2,     3,     5,     7,    11,    13,    17,    19,    23,    29,
+     31,    37,    41,    43,    47,    53,    59,    61,    67,    71,
+     73,    79,    83,    89,    97,   101,   103,   107,   109,   113,
+    127,   131,   137,   139,   149,   151,   157,   163,   167,   173,
+    179,   181,   191,   193,   197,   199,   211,   223,   227,   229,
+    233,   239,   241,   251,   257,   263,   269,   271,   277,   281,
+    283,   293,   307,   311,   313,   317,   331,   337,   347,   349,
+    353,   359,   367,   373,   379,   383,   389,   397,   401,   409,
+    419,   421,   431,   433,   439,   443,   449,   457,   461,   463,
+    467,   479,   487,   491,   499,   503,   509,   521,   523,   541,
+    547,   557,   563,   569,   571,   577,   587,   593,   599,   601,
+    607,   613,   617,   619,   631,   641,   643,   647,   653,   659,
+    661,   673,   677,   683,   691,   701,   709,   719,   727,   733,
+    739,   743,   751,   757,   761,   769,   773,   787,   797,   809,
+    811,   821,   823,   827,   829,   839,   853,   857,   859,   863,
+    877,   881,   883,   887,   907,   911,   919,   929,   937,   941,
+    947,   953,   967,   971,   977,   983,   991,   997,  1009,  1013,
+   1019,  1021,  1031,  1033,  1039,  1049,  1051,  1061,  1063,  1069,
+   1087,  1091,  1093,  1097,  1103,  1109,  1117,  1123,  1129,  1151,
+   1153,  1163,  1171,  1181,  1187,  1193,  1201,  1213,  1217,  1223,
+   1229,  1231,  1237,  1249,  1259,  1277,  1279,  1283,  1289,  1291,
+   1297,  1301,  1303,  1307,  1319,  1321,  1327,  1361,  1367,  1373,
+   1381,  1399,  1409,  1423,  1427,  1429,  1433,  1439,  1447,  1451,
+   1453,  1459,  1471,  1481,  1483,  1487,  1489,  1493,  1499,  1511,
+   1523,  1531,  1543,  1549,  1553,  1559,  1567,  1571,  1579,  1583,
+   1597,  1601,  1607,  1609,  1613,  1619,  1621,  1627,  1637,  1657,
+   1663,  1667,  1669,  1693,  1697,  1699,  1709,  1721,  1723,  1733,
+   1741,  1747,  1753,  1759,  1777,  1783,  1787,  1789,  1801,  1811,
+   1823,  1831,  1847,  1861,  1867,  1871,  1873,  1877,  1879,  1889,
+   1901,  1907,  1913,  1931,  1933,  1949,  1951,  1973,  1979,  1987,
+   1993,  1997,  1999,  2003,  2011,  2017,  2027,  2029,  2039,  2053];
+
 macro_rules! derive_prime_operations
 {
-    ($type: ident) => {
+    ($type: ident, $count: expr) => {
+        impl $type {
+            fn miller_rabin<G: Rng>(&self, g: &mut G, iters: usize)
+                -> bool
+            {
+                let nm1 = self - $type::from(1 as u8);
+                // Quoth Wikipedia:
+                // write n - 1 as 2^r*d with d odd by factoring powers of 2 from n - 1
+                let mut d = nm1.clone();
+                let mut r = 0;
+                while d.is_even() {
+                    d >>= 1;
+                    r += 1;
+                    assert!(r < ($count * 64));
+                }
+                // WitnessLoop: repeat k times
+                'WitnessLoop: for _k in 0..iters {
+                    // pick a random integer a in the range [2, n - 2]
+                    let a = $type::random_in_range(g, &$type::from(2 as u8), &nm1);
+                    // x <- a^d mod n
+                    let mut x = a.modexp(&d, &self);
+                    // if x = 1 or x = n - 1 then
+                    if (&x == &$type::from(1 as u8)) || (&x == &nm1) {
+                        // continue WitnessLoop
+                        continue 'WitnessLoop;
+                    }
+                    // repeat r - 1 times:
+                    for _i in 0..r {
+                        // x <- x^2 mod n
+                        x = x.modexp(&$type::from(2 as u8), &self);
+                        // if x = 1 then
+                        if &x == &$type::from(1 as u8) {
+                            // return composite
+                            return false;
+                        }
+                        // if x = n - 1 then
+                        if &x == &nm1 {
+                            // continue WitnessLoop
+                            continue 'WitnessLoop;
+                        }
+                    }
+                    // return composite
+                    return false;
+                }
+                // return probably prime
+                true
+            }
+
+            fn random_in_range<G: Rng>(rng: &mut G, min: &$type, max: &$type)
+                -> $type
+            {
+                loop {
+                    let candidate = $type::random_number(rng);
+                    if (&candidate >= min) && (&candidate < max) {
+                        return candidate;
+                    }
+                }
+            }
+
+            fn random_number<G: Rng>(rng: &mut G) -> $type {
+                let mut components = [0; $count];
+                for i in 0..$count {
+                    components[i] = rng.gen();
+                }
+                $type{ contents: components }
+            }
+        }
+
         impl CryptoNumPrimes for $type {
-            fn probably_prime<G: Rng>(_g: &mut G, _iters: usize) -> bool {
+            fn probably_prime<G: Rng>(&self, g: &mut G, iters: usize) -> bool {
-                panic!("probably_prime");
+                for tester in SMALL_PRIMES.iter() {
+                    let testvalue = $type::from(*tester);
+                    if (self % testvalue).is_zero()  {
+                        return false;
+                    }
+                }
+                self.miller_rabin(g, iters)
             }
             fn generate_prime<G: Rng>(_g: &mut G, _iters: usize, _e: &Self, _min: &Self) -> Self {
                 panic!("generate_prime");

src/cryptonum/traits.rs

@@ -69,7 +69,7 @@ pub trait CryptoNumPrimes
     /// Determine if the given number is probably prime using a quick spot
     /// check and Miller-Rabin, using the given random number generator
     /// and number of iterations.
-    fn probably_prime<G: Rng>(g: &mut G, iters: usize) -> bool;
+    fn probably_prime<G: Rng>(&self, g: &mut G, iters: usize) -> bool;
     /// Generate a prime using the given random number generator, using
     /// the given number of rounds to determine if the number is probably
     /// prime. The other two numbers are a number for which the generator

src/cryptonum/unsigned.rs

@@ -194,7 +194,7 @@ macro_rules! construct_unsigned {
 
         derive_barrett!($type, $barrett, $count);
         derive_modulo_operations!($type);
-        derive_prime_operations!($type);
+        derive_prime_operations!($type, $count);
 
         impl Into<BigInt> for $type {
             fn into(self) -> BigInt {