Merge branch 'arytmetyk-master'

Author: phishman3579

README.md

@@ -88,6 +88,7 @@ This is a collection of algorithms and data structures which I've implement over
   + is prime
   + prime factorization
   + sieve of eratosthenes
+  + Miller-Rabin test
   + [Co-Primes (relatively prime, mutually prime)](src/com/jwetherell/algorithms/mathematics/Coprimes.java)
   + [Greatest Common Divisor](src/com/jwetherell/algorithms/mathematics/GreatestCommonDivisor.java)
     - using Euclid's algorithm

src/com/jwetherell/algorithms/mathematics/Exponentiation.java

@@ -17,24 +17,25 @@
  * <p>
  * This implementation is the fast version of this algorithm with a complexity of O(lg N) also
  * <br>
+ *
  * @author Bartlomiej Drozd <[email protected]>
  * @author Justin Wetherell <[email protected]>
  */
 public class Exponentiation {
 
     public static int recursiveExponentiation(int base, int exponent) {
-        if (exponent == 0) 
+        if (exponent == 0)
             return 1;
-        if (exponent == 1) 
+        if (exponent == 1)
             return base;
 
         return recursiveExponentiation(base, exponent - 1) * base;
     }
 
     public static int fastRecursiveExponentiation(int base, int exponent) {
-        if (exponent == 0) 
+        if (exponent == 0)
             return 1;
-        if (exponent == 1) 
+        if (exponent == 1)
             return base;
 
         final int resultOnHalfExponent = fastRecursiveExponentiation(base, exponent / 2);
@@ -46,12 +47,12 @@ public static int fastRecursiveExponentiation(int base, int exponent) {
     }
 
     public static int fastRecursiveExponentiationModulo(int base, int exponent, int mod) {
-        if (exponent == 0) 
+        if (exponent == 0)
             return 1;
-        if (exponent == 1) 
+        if (exponent == 1)
             return base;
 
-        final int resultOnHalfExponent = fastRecursiveExponentiation(base, exponent / 2);
+        final int resultOnHalfExponent = fastRecursiveExponentiationModulo(base, exponent / 2, mod);
         if ((exponent % 2) == 0)
             return (resultOnHalfExponent * resultOnHalfExponent) % mod;
         else

src/com/jwetherell/algorithms/mathematics/Primes.java

@@ -2,10 +2,24 @@
 
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
+/**
+ * @author Justin Wetherell <[email protected]>
+ * @author Bartlomiej Drozd <[email protected]>
+ */
 public class Primes {
 
+    /**
+     * In number theory, the prime factors of a positive integer are the prime numbers that divide that integer exactly. The prime 
+     * factorization of a positive integer is a list of the integer's prime factors, together with their multiplicities; the process 
+     * of determining these factors is called integer factorization. The fundamental theorem of arithmetic says that every positive 
+     * integer has a single unique prime factorization.
+     * <p>
+     * https://en.wikipedia.org/wiki/Prime_factor
+     * <br>
+     */
     public static final Map<Long, Long> getPrimeFactorization(long number) {
         Map<Long, Long> map = new HashMap<Long, Long>();
         long n = number;
@@ -34,15 +48,15 @@ public static final Map<Long, Long> getPrimeFactorization(long number) {
         return map;
     }
 
-    /*
+    /**
      * isPrime() using the square root properties
-     * 
+     * <p>
      * 1 is not a prime. All primes except 2 are odd. All primes greater than 3
      * can be written in the form 6k+/-1. Any number n can have only one
-     * primefactor greater than n . The consequence for primality testing of a
+     * prime factor greater than n . The consequence for primality testing of a
      * number n is: if we cannot find a number f less than or equal n that
-     * divides n then n is prime: the only primefactor of n is n itself
-     */
+     * divides n then n is prime: the only prime factor of n is n itself
+     **/
     public static final boolean isPrime(long number) {
         if (number == 1)
             return false;
@@ -52,11 +66,11 @@ public static final boolean isPrime(long number) {
             return false; // short circuit
         if (number < 9)
             return true; // we have already excluded 4, 6 and 8.
-                         // (testing for 5 & 7)
+        // (testing for 5 & 7)
         if (number % 3 == 0)
             return false; // short circuit
         long r = (long) (Math.sqrt(number)); // n rounded to the greatest integer
-                                            // r so that r*r<=n
+        // r so that r*r<=n
         int f = 5;
         while (f <= r) {
             if (number % f == 0)
@@ -69,30 +83,87 @@ public static final boolean isPrime(long number) {
     }
 
     /*
-     * Sieve of Eratosthenes
+     * Sieve of Eratosthenes, only has to be set once.
      */
     private static boolean[] sieve = null;
 
+    /**
+     * In mathematics, the sieve of Eratosthenes is a simple, ancient algorithm for finding all prime numbers up to any given limit.
+     * <p>
+     * It does so by iteratively marking as composite (i.e., not prime) the multiples of each prime, starting with the first prime 
+     * number, 2. The multiples of a given prime are generated as a sequence of numbers starting from that prime, with constant 
+     * difference between them that is equal to that prime.
+     * <p>
+     * https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
+     * <br>
+     */
     public static final boolean sieveOfEratosthenes(int number) {
         if (number == 1) {
             return false;
         }
         if (sieve == null || number >= sieve.length) {
             int start = 2;
+
             if (sieve == null) {
-                sieve = new boolean[number+1];
+                sieve = new boolean[number + 1];
             } else if (number >= sieve.length) {
-                sieve = Arrays.copyOf(sieve, number+1);
+                sieve = Arrays.copyOf(sieve, number + 1);
             }
 
             for (int i = start; i <= Math.sqrt(number); i++) {
                 if (!sieve[i]) {
-                    for (int j = i*2; j <= number; j += i) {
+                    for (int j = i * 2; j <= number; j += i) {
                         sieve[j] = true;
                     }
                 }
             }
         }
         return !sieve[number];
     }
+
+    /**
+     * Miller-Rabin primality test is the fastest way to check if number is prime.
+     * Regular version of this algorithm returns false when number is composite and true
+     * when number is probably prime. Here is implemented a deterministic version of this
+     * algorithm, witnesses are not randomized. Used set of witnesses guarantees that result
+     * will be correct for sure (not probably) for any number lower than 10^18.
+     * <p>
+     * https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test
+     * <br>
+     */
+    public static final boolean millerRabinTest(int number) {
+        final List<Integer> witnesses = Arrays.asList(2, 325, 9375, 28178, 450775, 9780504, 1795265022);
+
+        if (number == 0 || number == 1)
+            return false;
+        if (number == 2 || number == 3)
+            return true;
+
+        int maximumPowerOf2 = 0;
+        while (((number - 1) % Exponentiation.fastRecursiveExponentiation(2, maximumPowerOf2)) == 0)
+            maximumPowerOf2++;
+        maximumPowerOf2--;
+
+        int d = (number - 1) / Exponentiation.fastRecursiveExponentiation(2, maximumPowerOf2);
+        boolean isPrime = true;
+        for (int a : witnesses) {
+            if (a > number)
+                break;
+            if (Exponentiation.fastRecursiveExponentiationModulo(a, d, number) != 1) {
+                boolean isLocalPrime = false;
+                for (int r = 0; r < maximumPowerOf2; r++) {
+                    if (Exponentiation.fastRecursiveExponentiationModulo(a, d * Exponentiation.fastRecursiveExponentiation(2, r), number) == (number - 1)) {
+                        isLocalPrime = true;
+                        break;
+                    }
+                }
+                if (!isLocalPrime) {
+                    isPrime = false;
+                    break;
+                }
+            }
+        }
+
+        return isPrime;
+    }
 }

test/com/jwetherell/algorithms/mathematics/test/CoprimesTest.java

@@ -12,10 +12,10 @@ public class CoprimesTest {
 
     @Test
     public void totientTest(){
-        List<Long> args = Arrays.asList(1L, 17L, 96L, 498L, 4182119424L);
-        List<Long> expected = Arrays.asList(1L, 16L, 32L, 164L, 1194891264L);
-        for(int i = 0; i < args.size(); i++) {
+        final List<Long> args = Arrays.asList(1L, 17L, 96L, 498L, 4182119424L);
+        final List<Long> expected = Arrays.asList(1L, 16L, 32L, 164L, 1194891264L);
+
+        for(int i = 0; i < args.size(); i++)
             assertEquals(expected.get(i), Coprimes.getNumberOfCoprimes(args.get(i)));
-        }
     }
 }

test/com/jwetherell/algorithms/mathematics/test/ExponentiationTest.java

@@ -14,30 +14,30 @@ public class ExponentiationTest {
 
     @Test
     public void recusriveExponentiationTest() {
-        List<Integer> baseList = Arrays.asList(1, 2, 4, 6, 8, 17, 24);
-        List<Integer> exponentList = Arrays.asList(1000, 27, 14, 11, 10, 7, 5);
-        List<Integer> expectedResultList = Arrays.asList(1, 134217728, 268435456, 362797056, 1073741824, 410338673, 7962624);
+        final List<Integer> baseList = Arrays.asList(1, 2, 4, 6, 8, 17, 24);
+        final List<Integer> exponentList = Arrays.asList(1000, 27, 14, 11, 10, 7, 5);
+        final List<Integer> expectedResultList = Arrays.asList(1, 134217728, 268435456, 362797056, 1073741824, 410338673, 7962624);
 
         for (int i = 0; i < expectedResultList.size(); i++)
             assertEquals(expectedResultList.get(i), Exponentiation.recursiveExponentiation(baseList.get(i), exponentList.get(i)));
     }
 
     @Test
     public void fastRecusriveExponentiationTest() {
-        List<Integer> baseList = Arrays.asList(1, 2, 4, 6, 8, 17, 24);
-        List<Integer> exponentList = Arrays.asList(1000, 27, 14, 11, 10, 7, 5);
-        List<Integer> expectedResultList = Arrays.asList(1, 134217728, 268435456, 362797056, 1073741824, 410338673, 7962624);
+        final List<Integer> baseList = Arrays.asList(1, 2, 4, 6, 8, 17, 24);
+        final List<Integer> exponentList = Arrays.asList(1000, 27, 14, 11, 10, 7, 5);
+        final List<Integer> expectedResultList = Arrays.asList(1, 134217728, 268435456, 362797056, 1073741824, 410338673, 7962624);
 
         for (int i = 0; i < expectedResultList.size(); i++)
             assertEquals(expectedResultList.get(i), Exponentiation.fastRecursiveExponentiation(baseList.get(i), exponentList.get(i)));
     }
 
     @Test
     public void fastRecusriveExponentiationModuloTest() {
-        List<Integer> baseList = Arrays.asList(1, 2, 4, 6, 8, 17, 24);
-        List<Integer> exponentList = Arrays.asList(1000, 27, 14, 11, 10, 7, 5);
-        List<Integer> divisorList = Arrays.asList(2, 6, 3, 2, 9, 11, 5);
-        List<Integer> expectedResultList = Arrays.asList(1, 2, 1, 0, 1, 8, 4);
+        final List<Integer> baseList = Arrays.asList(1, 2, 4, 6, 8, 17, 24, 2);
+        final List<Integer> exponentList = Arrays.asList(1000, 27, 14, 11, 10, 7, 5, 1089);
+        final List<Integer> divisorList = Arrays.asList(2, 6, 3, 2, 9, 11, 5, 2179);
+        final List<Integer> expectedResultList = Arrays.asList(1, 2, 1, 0, 1, 8, 4, 2178);
 
         for (int i = 0; i < expectedResultList.size(); i++)
             assertEquals(expectedResultList.get(i), Exponentiation.fastRecursiveExponentiationModulo(baseList.get(i), exponentList.get(i), divisorList.get(i)));

test/com/jwetherell/algorithms/mathematics/test/GCD.java renamed to test/com/jwetherell/algorithms/mathematics/test/GCDTest.java

@@ -8,7 +8,7 @@
 import com.jwetherell.algorithms.mathematics.GreatestCommonDivisor;
 
 
-public class GCD {
+public class GCDTest {
 
     @Test
     public void testRecursiveGCD() {
@@ -37,5 +37,4 @@ public void testEuclideanGCD() {
         check = 5;
         assertTrue("Euclids GCD error. expected="+check+" got="+gcd, (gcd==check));
     }
-
 }