From feba60b41e03c5a2c83342dac30bd5284a0cad9b Mon Sep 17 00:00:00 2001 From: Lisa Date: Wed, 26 Jun 2019 09:57:31 +0200 Subject: [PATCH] Initial commit 12.1 --- src/main/java/_12/_1/FibonacciDynamic.java | 26 ++++++ .../java/_12/_1/FibonacciDynamicParallel.java | 47 +++++++++++ src/main/java/_12/_1/FibonacciParallel.java | 50 ++++++++++++ src/main/java/_12/_1/FibonacciRecursive.java | 17 ++++ src/main/java/_12/_1/FibonacciTest.java | 81 +++++++++++++++++++ src/main/java/provided/_12/_1/Fibonacci.java | 7 ++ 6 files changed, 228 insertions(+) create mode 100644 src/main/java/_12/_1/FibonacciDynamic.java create mode 100644 src/main/java/_12/_1/FibonacciDynamicParallel.java create mode 100644 src/main/java/_12/_1/FibonacciParallel.java create mode 100644 src/main/java/_12/_1/FibonacciRecursive.java create mode 100644 src/main/java/_12/_1/FibonacciTest.java create mode 100644 src/main/java/provided/_12/_1/Fibonacci.java diff --git a/src/main/java/_12/_1/FibonacciDynamic.java b/src/main/java/_12/_1/FibonacciDynamic.java new file mode 100644 index 0000000..d0eea67 --- /dev/null +++ b/src/main/java/_12/_1/FibonacciDynamic.java @@ -0,0 +1,26 @@ +package _12._1; + +import provided._12._1.Fibonacci; +import java.util.HashMap; +import java.util.Map; + +public class FibonacciDynamic extends Fibonacci { + protected Map map = new HashMap<>(); + + public FibonacciDynamic() { + this.map.put(0, (long) 0); + this.map.put(1, (long) 1); + } + + @Override + public long calculate(int n) { + if (this.map.containsKey(n)) { + return this.map.get(n); + } else { + long result = calculate(n-1) + calculate(n-2); + this.map.put(n, result); + return result; + } + } + +} diff --git a/src/main/java/_12/_1/FibonacciDynamicParallel.java b/src/main/java/_12/_1/FibonacciDynamicParallel.java new file mode 100644 index 0000000..a1cc450 --- /dev/null +++ b/src/main/java/_12/_1/FibonacciDynamicParallel.java @@ -0,0 +1,47 @@ +package _12._1; + + +public class FibonacciDynamicParallel extends FibonacciDynamic { + + @Override + public long calculate(int n) { + if (this.map.containsKey(n)) { + return this.map.get(n); + } else { + FibonacciThread thread1 = new FibonacciThread(n-1); + FibonacciThread thread2 = new FibonacciThread(n-2); + thread1.start(); + thread2.start(); + + try { + thread1.join(); + thread2.join(); + + } catch (InterruptedException e) { + e.printStackTrace(); + } + + long result = thread1.getResult() + thread2.getResult(); + this.map.put(n, result); + return result; + } + } + + class FibonacciThread extends Thread { + private int n; + private long result; + + public FibonacciThread(int n) { + this.n = n; + } + + @Override + public void run() { + result = calculate(n); + } + + public long getResult() { + return result; + } + } +} diff --git a/src/main/java/_12/_1/FibonacciParallel.java b/src/main/java/_12/_1/FibonacciParallel.java new file mode 100644 index 0000000..b0a5d13 --- /dev/null +++ b/src/main/java/_12/_1/FibonacciParallel.java @@ -0,0 +1,50 @@ +package _12._1; + +import provided._12._1.Fibonacci; + +public class FibonacciParallel extends Fibonacci { + + @Override + public long calculate(int n) { + if (n == 0) { + return 0; + } else if (n == 1) { + return 1; + } else { + FibonacciThread thread1 = new FibonacciThread(n-1); + FibonacciThread thread2 = new FibonacciThread(n-2); + thread1.start(); + thread2.start(); + + try { + thread1.join(); + thread2.join(); + + } catch (InterruptedException e) { + e.printStackTrace(); + } + return thread1.getResult() + thread2.getResult(); + } + } + + + class FibonacciThread extends Thread { + private int n; + private long result; + + public FibonacciThread(int n) { + this.n = n; + } + + @Override + public void run() { + result = calculate(n); + } + + public long getResult() { + return result; + } + } +} + + diff --git a/src/main/java/_12/_1/FibonacciRecursive.java b/src/main/java/_12/_1/FibonacciRecursive.java new file mode 100644 index 0000000..01b3872 --- /dev/null +++ b/src/main/java/_12/_1/FibonacciRecursive.java @@ -0,0 +1,17 @@ +package _12._1; + +import provided._12._1.Fibonacci; + +public class FibonacciRecursive extends Fibonacci { + + @Override + public long calculate(int n) { + if (n == 0) { + return 0; + } else if (n == 1) { + return 1; + } else { + return calculate(n-1) + calculate(n-2); + } + } +} diff --git a/src/main/java/_12/_1/FibonacciTest.java b/src/main/java/_12/_1/FibonacciTest.java new file mode 100644 index 0000000..176e0ed --- /dev/null +++ b/src/main/java/_12/_1/FibonacciTest.java @@ -0,0 +1,81 @@ +package _12._1; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.assertEquals; + + +class FibonacciTest { + + private static final int[] NUMBERS = new int[] { 3, 5, 8, 12, 9, 18, 15, 10, 7, 11, 20 }; + + @Test + void test() { + + int count = 0; + long start; + long stop; + long time; + start = System.nanoTime(); + FibonacciRecursive r = new FibonacciRecursive(); + long[] rResult = new long[NUMBERS.length]; + for (int i : NUMBERS) { + rResult[count] = r.calculate(i); + count++; + } + stop = System.nanoTime(); + time = (stop - start) / 1000000L; + System.out.println("Rekursiv runtime: " + time + " ms"); + + + + count = 0; + start = System.nanoTime(); + FibonacciParallel p = new FibonacciParallel(); + long[] pResult = new long[NUMBERS.length]; + for (int i : NUMBERS) { + pResult[count] = p.calculate(i); + count++; + } + stop = System.nanoTime(); + time = (stop - start) / 1000000L; + System.out.println("Parallel runtime: " + time + " ms"); + + + count = 0; + start = System.nanoTime(); + FibonacciDynamic d = new FibonacciDynamic(); + long[] dResult = new long[NUMBERS.length]; + for (int i : NUMBERS) { + dResult[count] = d.calculate(i); + count++; + } + stop = System.nanoTime(); + time = (stop - start) / 1000000L; + System.out.println("Dynamic runtime: " + time + " ms"); + + + count = 0; + start = System.nanoTime(); + FibonacciDynamicParallel dp = new FibonacciDynamicParallel(); + long[] dpResult = new long[NUMBERS.length]; + for (int i : NUMBERS) { + dpResult[count] = dp.calculate(i); + count++; + } + stop = System.nanoTime(); + time = (stop - start) / 1000000L; + System.out.println("Dynamic Parallel runtime: " + time + " ms"); + + + + for (int i = 0; i < NUMBERS.length; i++) { + assertEquals(rResult[i], pResult[i]); + assertEquals(rResult[i], dResult[i]); + assertEquals(rResult[i], dpResult[i]); + assertEquals(pResult[i], dResult[i]); + assertEquals(pResult[i], dpResult[i]); + assertEquals(dResult[i], dpResult[i]); + } + + } +} diff --git a/src/main/java/provided/_12/_1/Fibonacci.java b/src/main/java/provided/_12/_1/Fibonacci.java new file mode 100644 index 0000000..5f61a15 --- /dev/null +++ b/src/main/java/provided/_12/_1/Fibonacci.java @@ -0,0 +1,7 @@ +package provided._12._1; + +public abstract class Fibonacci { + + public abstract long calculate(int n); + +}