Merge branch 'master' of git://github.com/mciancia/java-algorithms-implementation into mciancia-master

Author: phishman3579

README.md

@@ -68,10 +68,12 @@ This is a collection of algorithms and data structures which I've implement over
   + using recursion
   + using only shifts
   + using logarithms
+  + using FFT
 * Primes
   + is prime
   + prime factorization
   + sieve of eratosthenes
+* FFT
 
 ## Numbers
 * Integers
@@ -93,6 +95,12 @@ This is a collection of algorithms and data structures which I've implement over
     - using divide and modulus
     - using right shift and modulus
     - using BigDecimal
+* Complex
+  + addition
+  + subtraction
+  + multiplication
+  + absolute value
+  + polar value
 
 ## Path
 * Find shortest path(s) in a Graph from a starting Vertex

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

@@ -0,0 +1,35 @@
+package com.jwetherell.algorithms.mathematics;
+
+import com.jwetherell.algorithms.numbers.Complex;
+
+import static com.jwetherell.algorithms.numbers.Complex.polar;
+
+/**
+ * Simple implementation of Cooley-Tukey FFT algorithm
+ * Coefficients array size must be power of 2
+ *
+ * @author Mateusz Cianciara <e.cianciara@gmail.com>
+ */
+public class FFT {
+    //coefficients size must be power of 2
+    public static void FFT(Complex[] coefficients) {
+        int size = coefficients.length;
+        if (size <= 1) return;
+        Complex[] even = new Complex[size / 2];
+        Complex[] odd = new Complex[size / 2];
+        for (int i = 0; i < size; i++) {
+            if (i % 2 == 0) {
+                even[i / 2] = coefficients[i];
+            } else {
+                odd[(i - 1) / 2] = coefficients[i];
+            }
+        }
+        FFT(even);
+        FFT(odd);
+        for (int k = 0; k < size / 2; k++) {
+            Complex t = polar(1.0, -2 * Math.PI * k / size).multiply(odd[k]);
+            coefficients[k] = even[k].add(t);
+            coefficients[k + size / 2] = even[k].sub(t);
+        }
+    }
+}

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

@@ -1,5 +1,10 @@
 package com.jwetherell.algorithms.mathematics;
 
+import com.jwetherell.algorithms.numbers.Complex;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
 public class Multiplication {
 
     public static final long multiplication(int a, int b) {
@@ -47,4 +52,78 @@ public static final long multiplyUsingLogs(int a, int b) {
         long result = Math.round(Math.pow(10, (Math.log10(absA) + Math.log10(absB))));
         return (a > 0 && b > 0 || a < 0 && b < 0) ? result : -result;
     }
+
+    public static String multiplyUsingFFT(String a, String b) {
+        if (a.equals("0") || b.equals("0")) {
+            return "0";
+        }
+        boolean negative = false;
+        if ((a.charAt(0) == '-' && b.charAt(0) != '-') || (a.charAt(0) != '-' && b.charAt(0) == '-')) {
+            negative = true;
+        }
+        if (a.charAt(0) == '-') {
+            a = a.substring(1);
+        }
+        if (b.charAt(0) == '-') {
+            b = b.substring(1);
+        }
+        int size = 1;
+        while (size < (a.length() + b.length())) {
+            size *= 2;
+        }
+        Complex[] aCoefficients = new Complex[size];
+        Complex[] bCoefficients = new Complex[size];
+        for (int i = 0; i < size; i++) {
+            aCoefficients[i] = new Complex();
+            bCoefficients[i] = new Complex();
+        }
+        for (int i = 0; i < a.length(); i++) {
+            aCoefficients[i] = new Complex((double) (Character.getNumericValue(a.charAt(a.length() - i - 1))), 0.0);
+        }
+        for (int i = 0; i < b.length(); i++) {
+            bCoefficients[i] = new Complex((double) (Character.getNumericValue(b.charAt(b.length() - i - 1))), 0.0);
+        }
+
+
+        FFT.FFT(aCoefficients);
+        FFT.FFT(bCoefficients);
+
+
+        for (int i = 0; i < size; i++) {
+            aCoefficients[i] = aCoefficients[i].multiply(bCoefficients[i]);
+        }
+        for (int i = 0; i < size / 2; i++) {
+            Complex temp = aCoefficients[i];
+            aCoefficients[i] = aCoefficients[size - i - 1];
+            aCoefficients[size - i - 1] = temp;
+        }
+        FFT.FFT(aCoefficients);
+
+        ArrayList<Integer> res = new ArrayList<Integer>();
+        int pass = 0;
+        for (int i = 0; i < size; i++) {
+            res.add((int) (pass + Math.floor((aCoefficients[i].abs() + 1) / size)));
+            if (res.get(i) >= 10) {
+                pass = res.get(i) / 10;
+                res.set(i, res.get(i) % 10);
+            } else {
+                pass = 0;
+            }
+        }
+        Collections.reverse(res);
+        StringBuilder result = new StringBuilder();
+        if (negative) {
+            result.append('-');
+        }
+        boolean startPrinting = false;
+        for (Integer x : res) {
+            if (x != 0) {
+                startPrinting = true;
+            }
+            if (startPrinting) {
+                result.append(x);
+            }
+        }
+        return result.toString();
+    }
 }

src/com/jwetherell/algorithms/numbers/Complex.java

@@ -0,0 +1,52 @@
+package com.jwetherell.algorithms.numbers;
+
+/**
+ * @author Mateusz Cianciara <e.cianciara@gmail.com>
+ */
+public class Complex {
+    public double real;
+    public double imaginary;
+
+    public Complex() {
+        this.real = 0.0;
+        this.imaginary = 0.0;
+    }
+
+    public Complex(double r, double i) {
+        this.real = r;
+        this.imaginary = i;
+    }
+
+    public Complex multiply(final Complex x) {
+        Complex copy = new Complex(this.real, this.imaginary);
+        copy.real = this.real * x.real - this.imaginary * x.imaginary;
+        copy.imaginary = this.imaginary * x.real + this.real * x.imaginary;
+        return copy;
+    }
+
+    public Complex add(final Complex x) {
+        Complex copy = new Complex(this.real, this.imaginary);
+        copy.real += x.real;
+        copy.imaginary += x.imaginary;
+        return copy;
+    }
+
+    public Complex sub(final Complex x) {
+        Complex copy = new Complex(this.real, this.imaginary);
+        copy.real -= x.real;
+        copy.imaginary -= x.imaginary;
+        return copy;
+    }
+
+    public double abs() {
+        return Math.sqrt(this.real * this.real + this.imaginary * this.imaginary);
+    }
+
+    public String toString() {
+        return "(" + this.real + "," + this.imaginary + ")";
+    }
+
+    public static Complex polar(final double rho, final double theta) {
+        return new Complex(rho * Math.cos(theta), rho * Math.sin(theta));
+    }
+}

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

@@ -31,6 +31,7 @@ private static int nextRandomInt(int min, int max) {
     public void multiplication() {
         int a = nextRandomInt(MIN, MAX);
         int b = nextRandomInt(MIN, MAX);
+        String resultString;
         long result = Multiplication.multiplyUsingLoop(a, b);
         long check = Multiplication.multiplication(a, b);
         assertTrue("Multiplication using a loop. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check));
@@ -46,6 +47,11 @@ public void multiplication() {
         result = Multiplication.multiplyUsingLogs(a, b);
         check = Multiplication.multiplication(a, b);
         assertTrue("Multiplication using logs. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check));
+
+        result = Integer.parseInt(Multiplication.multiplyUsingFFT(Integer.toString(a), Integer.toString(b)));
+        check = Multiplication.multiplication(a, b);
+        assertTrue("Multiplication using FFT. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check));
+
     }
 
     @Test