Changed location for generating testData. Theoretically 3x speed increase

Author: JoonaHa

TreeTimeComplexity/src/main/java/main/BenchmarkResultGUI.java

@@ -16,6 +16,7 @@
  */
 package main;
 
+import algorithms.IntQuickSort;
 import utils.Operations;
 import algorithms.MinBinaryHeap;
 import algorithms.MinBinomialHeap;
@@ -44,6 +45,7 @@ public class BenchmarkResultGUI {
     private int iterations;
     private Operations[] operations;
     private InputTypes sorting;
+    private int[] benchData;
 
     /**
      * Class for creating barchart window
@@ -58,6 +60,8 @@ public BenchmarkResultGUI(int inputLenght, int iterations, Operations[] operatio
         this.iterations = iterations;
         this.operations = operations;
         this.sorting = sorting;
+        //Create test data for bechmarks
+        this.benchData = createTestData(iterations);
 
     }
 
@@ -84,9 +88,9 @@ public Scene run() {
         series3.setName("Fibonacci Heap");
         ObservableList<Label> list = FXCollections.<Label>observableArrayList();
 
-        Benchmark benBinary = new Benchmark(new MinBinaryHeap(), this.iterations, this.inputLenght, this.sorting);
-        Benchmark benBinomial = new Benchmark(new MinBinomialHeap(), this.iterations, this.inputLenght, this.sorting);
-        Benchmark benFibonacci = new Benchmark(new MinFibonaciHeap(), this.iterations, this.inputLenght, this.sorting);
+        Benchmark benBinary = new Benchmark(new MinBinaryHeap(), this.iterations, this.benchData);
+        Benchmark benBinomial = new Benchmark(new MinBinomialHeap(), this.iterations, this.benchData);
+        Benchmark benFibonacci = new Benchmark(new MinFibonaciHeap(), this.iterations, this.benchData);
 
         for (Operations operation : operations) {
 
@@ -172,4 +176,25 @@ public Scene run() {
         return chartScene;
     }
 
+    private int[] createTestData(int size) {
+
+        int[] values = new int[size];
+
+        for (int i = 0; i < size; i++) {
+
+            values[i] = ((int) ((System.nanoTime() % 10000 * 0.0001) * Integer.MAX_VALUE));
+        }
+
+        //sort generated  data based on the instance varibale this.sorting
+        if (this.sorting.equals(InputTypes.ASCENDING)) {
+            values = IntQuickSort.quickSortAscend(values, 0, size - 1);
+        }
+        if (this.sorting.equals(InputTypes.DESCENDING)) {
+            values = IntQuickSort.quickSortDescen(values, 0, size - 1);
+
+        }
+
+        return values;
+    }
+
 }

TreeTimeComplexity/src/main/java/utils/Benchmark.java

@@ -16,7 +16,6 @@
  */
 package utils;
 
-import algorithms.IntQuickSort;
 import algorithms.MinHeaps;
 import java.util.stream.LongStream;
 
@@ -30,7 +29,6 @@ public class Benchmark {
     private MinHeaps heap;
     private int[] input;
     private int iterations;
-    private InputTypes sorting;
 
     /**
      * *
@@ -39,16 +37,12 @@ public class Benchmark {
      * @param heap Object to benchmark
      * @param iterations Number of iterations the benchmark will run. The
      * average running time calculation is based on the number of iterations.
-     * @param inputLenght Lenght of randomised input data which will be used for
-     * testing.
-     * @param sorting Is the input data random or in ascending or descending
-     * order.
+     * @param testInput array of int to benchmark on
      */
-    public Benchmark(MinHeaps heap, int iterations, int inputLenght, InputTypes sorting) {
+    public Benchmark(MinHeaps heap, int iterations, int[] testInput) {
         this.heap = heap;
         this.iterations = iterations;
-        this.sorting = sorting;
-        this.input = createTestData(inputLenght);
+        this.input = testInput;
     }
 
     // Public methods for benchmarking specific operations.
@@ -283,25 +277,4 @@ private long findMax(long[] array) {
     }
 
     //Generate pseudorandom testdata from last digits of system.nanotime()
-    private int[] createTestData(int size) {
-
-        int[] values = new int[size];
-
-        for (int i = 0; i < size; i++) {
-
-            values[i] = ((int) ((System.nanoTime() % 10000 * 0.0001) * Integer.MAX_VALUE));
-        }
-
-        //sort generated  data based on the instance varibale this.sorting
-        if (this.sorting.equals(InputTypes.ASCENDING)) {
-            values = IntQuickSort.quickSortAscend(values, 0, size - 1);
-        }
-        if (this.sorting.equals(InputTypes.DESCENDING)) {
-            values = IntQuickSort.quickSortDescen(values, 0, size - 1);
-
-        }
-
-        return values;
-    }
-
 }