Make main methods instantiate the surrounding class

Author: SvenWoltmann

src/main/java/eu/happycoders/sort/CountOperations.java

@@ -20,21 +20,25 @@ public class CountOperations {
   private static final int MAX_COUNTING_TIME_SECS = 20;
 
   public static void main(String[] args) {
+    new CountOperations().run();
+  }
+
+  private void run() {
     for (SortAlgorithm algorithm : UltimateTest.ALGORITHMS) {
       if (algorithm.supportsCounting()) {
         countOps(algorithm);
       }
     }
   }
 
-  private static void countOps(SortAlgorithm algorithm) {
+  private void countOps(SortAlgorithm algorithm) {
     // Test with a random, a sorted, and a reversed (= sorted descending) array
     countOps(algorithm, false, "random", ArrayUtils::createRandomArray);
     countOps(algorithm, true, "ascending", ArrayUtils::createSortedArray);
     countOps(algorithm, true, "descending", ArrayUtils::createReversedArray);
   }
 
-  private static void countOps(
+  private void countOps(
       SortAlgorithm algorithm,
       boolean sorted,
       String inputOrder,
@@ -67,7 +71,7 @@ private static void countOps(
     }
   }
 
-  private static Counters countOps(SortAlgorithm algorithm, int[] elements) {
+  private Counters countOps(SortAlgorithm algorithm, int[] elements) {
     Counters counters = new Counters();
     algorithm.sort(elements, counters);
     return counters;

src/main/java/eu/happycoders/sort/FindMinimumTest.java

@@ -11,24 +11,28 @@
 public class FindMinimumTest {
   private static final int NUM_SIZES = 29;
   private static final int NUM_TESTS = 100;
-  private static final int[] counts = new int[NUM_SIZES];
+  private final int[] counts = new int[NUM_SIZES];
 
   public static void main(String[] args) {
+    new FindMinimumTest().run();
+  }
+
+  private void run() {
     for (int i = 0; i < NUM_TESTS; i++) {
       test();
       printResults(i + 1);
     }
   }
 
-  private static void test() {
+  private void test() {
     for (int i = 0; i < NUM_SIZES; i++) {
       int size = 2 << i;
       int assignments = countAssignmentsForSize(size);
       counts[i] += assignments;
     }
   }
 
-  private static int countAssignmentsForSize(int size) {
+  private int countAssignmentsForSize(int size) {
     int[] array = ArrayUtils.createRandomArray(size);
     int min = Integer.MAX_VALUE;
     int assignments = 0;
@@ -42,7 +46,7 @@ private static int countAssignmentsForSize(int size) {
     return assignments;
   }
 
-  private static void printResults(int iterations) {
+  private void printResults(int iterations) {
     System.out.printf(Locale.US, "Results after %d iterations:%n", iterations);
     for (int i = 0; i < NUM_SIZES; i++) {
       int size = 2 << i;

src/main/java/eu/happycoders/sort/UltimateTest.java

@@ -64,9 +64,13 @@ public class UltimateTest {
 
   private static final boolean TEST_SORTED_INPUT = true;
 
-  private static final Map<String, Scorecard> scorecards = new HashMap<>();
+  private final Map<String, Scorecard> scorecards = new HashMap<>();
 
   public static void main(String[] args) {
+    new UltimateTest().run();
+  }
+
+  private void run() {
     for (int i = 1; i <= WARM_UPS; i++) {
       System.out.printf("%n===== Warm up %d of %d =====%n", i, WARM_UPS);
       for (SortAlgorithm algorithm : ALGORITHMS) {
@@ -90,7 +94,7 @@ public static void main(String[] args) {
     }
   }
 
-  private static void test(SortAlgorithm algorithm, boolean warmingUp) {
+  private void test(SortAlgorithm algorithm, boolean warmingUp) {
     // Test with a random, a sorted, and a reversed (= sorted descending) array
     test(algorithm, InputOrder.RANDOM, ArrayUtils::createRandomArray, warmingUp);
 
@@ -100,7 +104,7 @@ private static void test(SortAlgorithm algorithm, boolean warmingUp) {
     }
   }
 
-  private static void test(
+  private void test(
       SortAlgorithm algorithm,
       InputOrder inputOrder,
       Function<Integer, int[]> arraySupplier,
@@ -134,20 +138,20 @@ private static void test(
     }
   }
 
-  private static long measureTime(SortAlgorithm algorithm, int[] elements) {
+  private long measureTime(SortAlgorithm algorithm, int[] elements) {
     System.gc();
     long time = System.nanoTime();
     algorithm.sort(elements);
     return System.nanoTime() - time;
   }
 
-  private static Scorecard scorecard(
+  private Scorecard scorecard(
       SortAlgorithm algorithm, String inputOrder, int size, boolean create) {
     String key = algorithm.getName() + "/" + inputOrder + "/" + size;
     return create ? scorecards.computeIfAbsent(key, Scorecard::new) : scorecards.get(key);
   }
 
-  private static void printResults(int iteration, SortAlgorithm algorithm, String inputOrder) {
+  private void printResults(int iteration, SortAlgorithm algorithm, String inputOrder) {
     System.out.printf(
         "%n--- Results for iteration %d for: %s (order: %s) ---%n",
         iteration, algorithm.getName(), inputOrder);

src/main/java/eu/happycoders/sort/comparisons/CompareBubbleSorts.java

@@ -19,13 +19,18 @@ public class CompareBubbleSorts extends DirectComparison {
   private static final int SIZE = 40_000; // ~500 ms for Bubble Sort
 
   public static void main(String[] args) {
+    new CompareBubbleSorts().run();
+  }
+
+  private void run() {
     List<SortAlgorithm> algorithms =
         List.of(
             new BubbleSort(),
             new BubbleSortOpt1(),
             new BubbleSortOpt2(),
             new BubbleSortParallelOddEven(),
             new BubbleSortParallelDivideAndConquer());
+
     runTest(algorithms.toArray(SortAlgorithm[]::new), SIZE);
   }
 }

src/main/java/eu/happycoders/sort/comparisons/CompareImprovedDualPivotQuicksort.java

@@ -17,6 +17,10 @@ public class CompareImprovedDualPivotQuicksort extends DirectComparison {
   private static final int SIZE = 5_555_555; // ~500 ms for Quicksort
 
   public static void main(String[] args) {
+    new CompareImprovedDualPivotQuicksort().run();
+  }
+
+  private void run() {
     List<SortAlgorithm> algorithms = new ArrayList<>();
     algorithms.add(new DualPivotQuicksort(DualPivotQuicksort.PivotStrategy.THIRDS));
     for (int threshold = 2; threshold < 1 << 8; threshold <<= 1) {
@@ -32,6 +36,7 @@ public static void main(String[] args) {
                 threshold + threshold / 2, DualPivotQuicksort.PivotStrategy.THIRDS));
       }
     }
+
     runTest(algorithms.toArray(SortAlgorithm[]::new), SIZE);
   }
 }

src/main/java/eu/happycoders/sort/comparisons/CompareImprovedQuicksort.java

@@ -20,6 +20,10 @@ public class CompareImprovedQuicksort extends DirectComparison {
   private static final int SIZE = 5_555_555; // ~500 ms for Quicksort
 
   public static void main(String[] args) {
+    new CompareImprovedQuicksort().run();
+  }
+
+  private void run() {
     List<SortAlgorithm> algorithms = new ArrayList<>();
     algorithms.add(new QuicksortVariant1(PivotStrategy.MIDDLE));
     algorithms.add(new QuicksortVariant1(PivotStrategy.MEDIAN3));
@@ -42,7 +46,7 @@ public static void main(String[] args) {
     runTest(algorithms.toArray(SortAlgorithm[]::new), SIZE);
   }
 
-  private static void addAllVariantsForThreshold(List<SortAlgorithm> algorithms, int threshold) {
+  private void addAllVariantsForThreshold(List<SortAlgorithm> algorithms, int threshold) {
     // Variant 1
     algorithms.add(new QuicksortImproved(threshold, new QuicksortVariant1(PivotStrategy.MIDDLE)));
     algorithms.add(new QuicksortImproved(threshold, new QuicksortVariant1(PivotStrategy.MEDIAN3)));

src/main/java/eu/happycoders/sort/comparisons/CompareMergeSorts.java

@@ -15,8 +15,13 @@ public class CompareMergeSorts extends DirectComparison {
   private static final int SIZE = 4_444_444; // ~600 ms for Merge Sort
 
   public static void main(String[] args) {
+    new CompareMergeSorts().run();
+  }
+
+  private void run() {
     SortAlgorithm[] algorithms =
         new SortAlgorithm[] {new MergeSort(), new MergeSort2(), new MergeSort3()};
+
     runTest(algorithms, SIZE);
   }
 }

src/main/java/eu/happycoders/sort/comparisons/CompareQuicksorts.java

@@ -19,6 +19,10 @@ public class CompareQuicksorts extends DirectComparison {
   private static final int SIZE = 5_555_555; // ~500 ms for Quicksort
 
   public static void main(String[] args) {
+    new CompareQuicksorts().run();
+  }
+
+  private void run() {
     List<SortAlgorithm> algorithms = new ArrayList<>();
 
     algorithms.add(new QuicksortSimple());

src/main/java/eu/happycoders/sort/comparisons/DirectComparison.java

@@ -18,11 +18,11 @@ public class DirectComparison {
   private static final int ITERATIONS = 100;
   private static final int PRINT_RESULTS_ALL_X_ITERATIONS = 10;
 
-  private static final Map<String, Scorecard> scorecards = new HashMap<>();
+  private final Map<String, Scorecard> scorecards = new HashMap<>();
 
-  private static int longestNameLength;
+  private int longestNameLength;
 
-  public static void runTest(SortAlgorithm[] algorithms, int size) {
+  public void runTest(SortAlgorithm[] algorithms, int size) {
     longestNameLength = Scorecard.findLongestAlgorithmName(algorithms);
 
     int numAlgorithms = algorithms.length;
@@ -69,7 +69,7 @@ private static int[] getShuffledIndices(int numTestSets) {
     return indices;
   }
 
-  private static long measure(SortAlgorithm sortAlgorithm, int[] elements) {
+  private long measure(SortAlgorithm sortAlgorithm, int[] elements) {
     System.gc();
 
     long time = System.nanoTime();
@@ -89,11 +89,11 @@ private static long measure(SortAlgorithm sortAlgorithm, int[] elements) {
     return time;
   }
 
-  private static Scorecard scorecardForAlgorithm(SortAlgorithm algorithm) {
+  private Scorecard scorecardForAlgorithm(SortAlgorithm algorithm) {
     return scorecards.computeIfAbsent(algorithm.getName(), Scorecard::new);
   }
 
-  private static void printResults(SortAlgorithm[] algorithms, int iterations) {
+  private void printResults(SortAlgorithm[] algorithms, int iterations) {
     System.out.printf("%n----- Results after %d iterations-----%n", iterations);
 
     // 1. Find the fastest median

src/main/java/eu/happycoders/sort/pivot/PivotComparator.java

@@ -25,22 +25,27 @@ public class PivotComparator {
   private static final int MIN_SIZE = 500;
   private static final int MAX_SIZE = 1_000;
 
-  private static final Map<String, PivotScorecard> scorecards = new HashMap<>();
+  private final Map<String, PivotScorecard> scorecards = new HashMap<>();
 
-  private static int longestNameLength;
+  private int longestNameLength;
 
   public static void main(String[] args) {
+    new PivotComparator().run();
+  }
+
+  private void run() {
     PartitioningAlgorithm[] algorithms =
         new PartitioningAlgorithm[] {
           new QuicksortVariant1(PivotStrategy.MIDDLE),
           new QuicksortVariant1(PivotStrategy.RANDOM),
           new QuicksortVariant1(PivotStrategy.RIGHT),
           new QuicksortVariant1(PivotStrategy.MEDIAN3)
         };
+
     runTest(algorithms);
   }
 
-  private static void runTest(PartitioningAlgorithm[] algorithms) {
+  private void runTest(PartitioningAlgorithm[] algorithms) {
     longestNameLength = Scorecard.findLongestAlgorithmName(algorithms);
 
     int numAlgorithms = algorithms.length;
@@ -78,7 +83,7 @@ private static void runTest(PartitioningAlgorithm[] algorithms) {
    * @return the percentage of the larger partition; e.g., if we get 100 and 50 elements, the result
    *     is 66.7.
    */
-  private static double partition(PartitioningAlgorithm algorithm, int[] elements) {
+  private double partition(PartitioningAlgorithm algorithm, int[] elements) {
     int numElements = elements.length;
     int pivotPos = algorithm.partition(elements, 0, numElements - 1);
 
@@ -87,7 +92,7 @@ private static double partition(PartitioningAlgorithm algorithm, int[] elements)
     return longerPartSize * 100.0 / (numElements - 1);
   }
 
-  private static PivotScorecard scorecardForAlgorithm(SortAlgorithm algorithm) {
+  private PivotScorecard scorecardForAlgorithm(SortAlgorithm algorithm) {
     return scorecards.computeIfAbsent(algorithm.getName(), PivotScorecard::new);
   }
 }