Merge pull request kodecocodes#262 from scha00/master

Miller-Rabin primality test: probabilistic version

Author: kelvinlauKL

Miller-Rabin Primality Test/Images/img_pseudo.png

@@ -0,0 +1,24 @@
+//: Playground - noun: a place where people can play
+
+// Real primes
+mrPrimalityTest(5)
+mrPrimalityTest(439)
+mrPrimalityTest(1201)
+mrPrimalityTest(143477)
+mrPrimalityTest(1299869)
+mrPrimalityTest(15487361)
+mrPrimalityTest(179426363)
+mrPrimalityTest(32416187747)
+
+// Fake primes
+mrPrimalityTest(15)
+mrPrimalityTest(435)
+mrPrimalityTest(1207)
+mrPrimalityTest(143473)
+mrPrimalityTest(1291869)
+mrPrimalityTest(15487161)
+mrPrimalityTest(178426363)
+mrPrimalityTest(32415187747)
+
+// With iteration
+mrPrimalityTest(32416190071, iteration: 10)

Miller-Rabin Primality Test/MRPrimality.playground/Contents.swift

@@ -0,0 +1,111 @@
+//
+//  MRPrimality.swift
+//  
+//
+//  Created by Sahn Cha on 2016. 10. 18..
+//
+//
+
+import Foundation
+
+/*
+  Miller-Rabin Primality Test.
+  One of the most used algorithms for primality testing.
+  Since this is a probabilistic algorithm, it needs to be executed multiple times to increase accuracy.
+  
+  Inputs:
+    n: UInt64 { target integer to be tested for primality }
+    k: Int    { optional. number of iterations }
+ 
+  Outputs:
+    true      { probably prime }
+    false     { composite }
+ */
+public func mrPrimalityTest(_ n: UInt64, iteration k: Int = 1) -> Bool {
+  guard n > 2 && n % 2 == 1 else { return false }
+  
+  var d = n - 1
+  var s = 0
+  
+  while d % 2 == 0 {
+    d /= 2
+    s += 1
+  }
+  
+  let range = UInt64.max - UInt64.max % (n - 2)
+  var r: UInt64 = 0
+  repeat {
+    arc4random_buf(&r, MemoryLayout.size(ofValue: r))
+  } while r >= range
+  
+  r = r % (n - 2) + 2
+  
+  for _ in 1 ... k {
+    var x = powmod64(r, d, n)
+    if x == 1 || x == n - 1 { continue }
+    
+    if s == 1 { s = 2 }
+    
+    for _ in 1 ... s - 1 {
+      x = powmod64(x, 2, n)
+      if x == 1 { return false }
+      if x == n - 1 { break }
+    }
+    
+    if x != n - 1 { return false }
+  }
+  
+  return true
+}
+
+/*
+  Calculates (base^exp) mod m.
+ 
+  Inputs:
+    base: UInt64  { base }
+    exp: UInt64   { exponent }
+    m: UInt64     { modulus }
+ 
+  Outputs:
+    the result
+ */
+private func powmod64(_ base: UInt64, _ exp: UInt64, _ m: UInt64) -> UInt64 {
+  if m == 1 { return 0 }
+  
+  var result: UInt64 = 1
+  var b = base % m
+  var e = exp
+  
+  while e > 0 {
+    if e % 2 == 1 { result = mulmod64(result, b, m) }
+    b = mulmod64(b, b, m)
+    e >>= 1
+  }
+  
+  return result
+}
+
+/*
+  Calculates (first * second) mod m, hopefully without overflow. :]
+ 
+  Inputs:
+    first: UInt64   { first integer }
+    second: UInt64  { second integer }
+    m: UInt64       { modulus }
+ 
+  Outputs:
+    the result
+ */
+private func mulmod64(_ first: UInt64, _ second: UInt64, _ m: UInt64) -> UInt64 {
+  var result: UInt64 = 0
+  var a = first
+  var b = second
+  
+  while a != 0 {
+    if a % 2 == 1 { result = ((result % m) + (b % m)) % m } // This may overflow if 'm' is a 64bit number && both 'result' and 'b' are very close to but smaller than 'm'.
+    a >>= 1
+    b = (b << 1) % m
+  }
+  
+  return result
+}

Miller-Rabin Primality Test/MRPrimality.playground/Sources/MRPrimality.swift

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='macos'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>

Miller-Rabin Primality Test/MRPrimality.playground/contents.xcplayground

@@ -0,0 +1,111 @@
+//
+//  MRPrimality.swift
+//  
+//
+//  Created by Sahn Cha on 2016. 10. 18..
+//
+//
+
+import Foundation
+
+/*
+  Miller-Rabin Primality Test.
+  One of the most used algorithms for primality testing.
+  Since this is a probabilistic algorithm, it needs to be executed multiple times to increase accuracy.
+  
+  Inputs:
+    n: UInt64 { target integer to be tested for primality }
+    k: Int    { optional. number of iterations }
+ 
+  Outputs:
+    true      { probably prime }
+    false     { composite }
+ */
+public func mrPrimalityTest(_ n: UInt64, iteration k: Int = 1) -> Bool {
+  guard n > 2 && n % 2 == 1 else { return false }
+  
+  var d = n - 1
+  var s = 0
+  
+  while d % 2 == 0 {
+    d /= 2
+    s += 1
+  }
+  
+  let range = UInt64.max - UInt64.max % (n - 2)
+  var r: UInt64 = 0
+  repeat {
+    arc4random_buf(&r, MemoryLayout.size(ofValue: r))
+  } while r >= range
+  
+  r = r % (n - 2) + 2
+  
+  for _ in 1 ... k {
+    var x = powmod64(r, d, n)
+    if x == 1 || x == n - 1 { continue }
+    
+    if s == 1 { s = 2 }
+    
+    for _ in 1 ... s - 1 {
+      x = powmod64(x, 2, n)
+      if x == 1 { return false }
+      if x == n - 1 { break }
+    }
+    
+    if x != n - 1 { return false }
+  }
+  
+  return true
+}
+
+/*
+  Calculates (base^exp) mod m.
+ 
+  Inputs:
+    base: UInt64  { base }
+    exp: UInt64   { exponent }
+    m: UInt64     { modulus }
+ 
+  Outputs:
+    the result
+ */
+private func powmod64(_ base: UInt64, _ exp: UInt64, _ m: UInt64) -> UInt64 {
+  if m == 1 { return 0 }
+  
+  var result: UInt64 = 1
+  var b = base % m
+  var e = exp
+  
+  while e > 0 {
+    if e % 2 == 1 { result = mulmod64(result, b, m) }
+    b = mulmod64(b, b, m)
+    e >>= 1
+  }
+  
+  return result
+}
+
+/*
+  Calculates (first * second) mod m, hopefully without overflow. :]
+ 
+  Inputs:
+    first: UInt64   { first integer }
+    second: UInt64  { second integer }
+    m: UInt64       { modulus }
+ 
+  Outputs:
+    the result
+ */
+private func mulmod64(_ first: UInt64, _ second: UInt64, _ m: UInt64) -> UInt64 {
+  var result: UInt64 = 0
+  var a = first
+  var b = second
+  
+  while a != 0 {
+    if a % 2 == 1 { result = ((result % m) + (b % m)) % m } // This may overflow if 'm' is a 64bit number && both 'result' and 'b' are very close to but smaller than 'm'.
+    a >>= 1
+    b = (b << 1) % m
+  }
+  
+  return result
+}

Miller-Rabin Primality Test/MRPrimality.swift

@@ -0,0 +1,43 @@
+# Miller-Rabin Primality Test
+
+In 1976, Gray Miller introduced an algorithm, through his ph.d thesis[1], which determines a primality of the given number. The original algorithm was deterministic under the Extended Reimann Hypothesis, which is yet to be proven. After four years, Michael O. Rabin improved the algorithm[2] by using probabilistic approach and it no longer assumes the unproven hypothesis.
+
+## Probabilistic
+
+The result of the test is simply a boolean. However, `true` does not implicate _the number is prime_. In fact, it means _the number is **probably** prime_. But `false` does mean _the number is composite_.
+
+In order to increase the accuracy of the test, it needs to be iterated few times. If it returns `true` in every single iteration, then we can say with confidence that _the number is pro......bably prime_.
+
+## Algorithm
+
+Let `n` be the given number, and write `n-1` as `2^s·d`, where `d` is odd. And choose a random number `a` within the range from `2` to `n - 1`.
+
+Now make a sequence, in modulo `n`, as following:
+
+> a^d, a^(2·d), a^(4·d), ... , a^((2^(s-1))·d), a^((2^s)·d) = a^(n-1)
+
+And we say the number `n` passes the test, _probably prime_, if 1) `a^d` is congruence to `1` in modulo `n`, or 2) `a^((2^k)·d)` is congruence to `-1` for some `k = 1, 2, ..., s-1`.
+
+### Pseudo Code
+
+The following pseudo code is excerpted from Wikipedia[3]:
+
+![Image of Pseudocode](./Images/img_pseudo.png)
+
+## Usage
+
+```swift
+mrPrimalityTest(7)                      // test if 7 is prime. (default iteration = 1)
+mrPrimalityTest(7, iteration: 10)       // test if 7 is prime && iterate 10 times.
+```
+
+## Reference
+1. G. L. Miller, "Riemann's Hypothesis and Tests for Primality". _J. Comput. System Sci._ 13 (1976), 300-317.
+2. M. O. Rabin, "Probabilistic algorithm for testing primality". _Journal of Number Theory._ 12 (1980), 128-138.
+3. Miller–Rabin primality test - Wikipedia, the free encyclopedia
+
+_Written for Swift Algorithm Club by **Sahn Cha**, @scha00_
+
+[1]: https://cs.uwaterloo.ca/research/tr/1975/CS-75-27.pdf
+[2]: http://www.sciencedirect.com/science/article/pii/0022314X80900840
+[3]: https://en.wikipedia.org/wiki/Miller–Rabin_primality_test