From 8edd89d784f24ca49dab8a9f3f097e0fedbd8a42 Mon Sep 17 00:00:00 2001 From: efischer Date: Thu, 24 Feb 2022 14:48:19 -0600 Subject: [PATCH] Added heap type selection, fixed error handling --- readme.md | 2 +- src/main/java/BiGpairSEQ.java | 13 +++++++++ src/main/java/InteractiveInterface.java | 39 ++++++++++++++++++++++--- src/main/java/Simulator.java | 24 +++++++++++++-- 4 files changed, 70 insertions(+), 8 deletions(-) diff --git a/readme.md b/readme.md index b56f128..41accf0 100644 --- a/readme.md +++ b/readme.md @@ -39,7 +39,7 @@ in practice. [Download the current version of BiGpairSEQ_Sim.](https://gitea.ejsf.synology.me/efischer/BiGpairSEQ/releases) -BiGpairSEQ_Sim is an executable .jar file. Requires Java 11 or higher. [OpenJDK 17](https://jdk.java.net/17/) +BiGpairSEQ_Sim is an executable .jar file. Requires Java 14 or higher. [OpenJDK 17](https://jdk.java.net/17/) recommended. Run with the command: diff --git a/src/main/java/BiGpairSEQ.java b/src/main/java/BiGpairSEQ.java index 0e327e4..8448c13 100644 --- a/src/main/java/BiGpairSEQ.java +++ b/src/main/java/BiGpairSEQ.java @@ -13,6 +13,7 @@ public class BiGpairSEQ { private static boolean cacheCells = false; private static boolean cachePlate = false; private static boolean cacheGraph = true; + private static String priorityQueueHeapType = "PAIRING"; public static void main(String[] args) { if (args.length == 0) { @@ -151,4 +152,16 @@ public class BiGpairSEQ { } BiGpairSEQ.cacheGraph = cacheGraph; } + + public static String getPriorityQueueHeapType() { + return priorityQueueHeapType; + } + + public static void setPairingHeap() { + priorityQueueHeapType = "PAIRING"; + } + + public static void setFibonacciHeap() { + priorityQueueHeapType = "FIBONACCI"; + } } diff --git a/src/main/java/InteractiveInterface.java b/src/main/java/InteractiveInterface.java index e749090..e3a19b5 100644 --- a/src/main/java/InteractiveInterface.java +++ b/src/main/java/InteractiveInterface.java @@ -38,10 +38,10 @@ public class InteractiveInterface { case 3 -> makeCDR3Graph(); case 4 -> matchCDR3s(); //case 6 -> matchCellsCDR1(); - case 8 -> options(); + case 8 -> mainOptions(); case 9 -> acknowledge(); case 0 -> quit = true; - default -> throw new InputMismatchException("Invalid input."); + default -> System.out.println("Invalid input."); } } catch (InputMismatchException | IOException ex) { System.out.println(ex); @@ -493,13 +493,14 @@ public class InteractiveInterface { // } // } - private static void options(){ + private static void mainOptions(){ boolean backToMain = false; while(!backToMain) { System.out.println("\n--------------OPTIONS---------------"); System.out.println("1) Turn " + getOnOff(!BiGpairSEQ.cacheCells()) + " cell sample file caching"); System.out.println("2) Turn " + getOnOff(!BiGpairSEQ.cachePlate()) + " plate file caching"); System.out.println("3) Turn " + getOnOff(!BiGpairSEQ.cacheGraph()) + " graph/data file caching"); + System.out.println("4) Maximum weight matching algorithm options"); System.out.println("0) Return to main menu"); try { input = sc.nextInt(); @@ -508,7 +509,7 @@ public class InteractiveInterface { case 2 -> BiGpairSEQ.setCachePlate(!BiGpairSEQ.cachePlate()); case 3 -> BiGpairSEQ.setCacheGraph(!BiGpairSEQ.cacheGraph()); case 0 -> backToMain = true; - default -> throw new InputMismatchException("Invalid input."); + default -> System.out.println("Invalid input"); } } catch (InputMismatchException ex) { System.out.println(ex); @@ -517,11 +518,41 @@ public class InteractiveInterface { } } + /** + * Helper function for printing menu items in mainOptions(). Returns a string based on the value of parameter. + * + * @param b - a boolean value + * @return String "on" if b is true, "off" if b is false + */ private static String getOnOff(boolean b) { if (b) { return "on";} else { return "off"; } } + private static void algorithmOptions(){ + boolean backToOptions = false; + while(!backToOptions) { + System.out.println("\n---------ALGORITHM OPTIONS----------"); + System.out.println("1) Use scaling algorithm by Duan and Su."); + System.out.println("2) Use Hungarian algorithm with Fibonacci heap priority queue"); + System.out.println("3) Use Hungarian algorithm with pairing heap priority queue"); + System.out.println("0) Return to Options menu"); + try { + input = sc.nextInt(); + switch (input) { + case 1 -> System.out.println("This option is not yet implemented. Choose another."); + case 2 -> BiGpairSEQ.setFibonacciHeap(); + case 3 -> BiGpairSEQ.setPairingHeap(); + case 0 -> backToOptions = true; + default -> System.out.println("Invalid input"); + } + } catch (InputMismatchException ex) { + System.out.println(ex); + sc.next(); + } + } + } + private static void acknowledge(){ System.out.println("This program simulates BiGpairSEQ, a graph theory based adaptation"); System.out.println("of the pairSEQ algorithm for pairing T cell receptor sequences."); diff --git a/src/main/java/Simulator.java b/src/main/java/Simulator.java index 7478a51..b26a4fb 100644 --- a/src/main/java/Simulator.java +++ b/src/main/java/Simulator.java @@ -3,6 +3,7 @@ import org.jgrapht.alg.matching.MaximumWeightBipartiteMatching; import org.jgrapht.generate.SimpleWeightedBipartiteGraphMatrixGenerator; import org.jgrapht.graph.DefaultWeightedEdge; import org.jgrapht.graph.SimpleWeightedGraph; +import org.jheaps.tree.FibonacciHeap; import org.jheaps.tree.PairingHeap; import java.math.BigDecimal; @@ -181,12 +182,29 @@ public class Simulator { //Find Maximum Weighted Matching //using jheaps library class PairingHeap for improved efficiency if(verbose){System.out.println("Finding maximum weighted matching");} - //Attempting to use addressable heap to improve performance - MaximumWeightBipartiteMatching maxWeightMatching = - new MaximumWeightBipartiteMatching(graph, + MaximumWeightBipartiteMatching maxWeightMatching; + //Use correct heap type for priority queue + String heapType = BiGpairSEQ.getPriorityQueueHeapType(); + switch (heapType) { + case "PAIRING" -> { + maxWeightMatching = new MaximumWeightBipartiteMatching(graph, plateVtoAMap.keySet(), plateVtoBMap.keySet(), i -> new PairingHeap(Comparator.naturalOrder())); + } + case "FIBONACCI" -> { + maxWeightMatching = new MaximumWeightBipartiteMatching(graph, + plateVtoAMap.keySet(), + plateVtoBMap.keySet(), + i -> new FibonacciHeap(Comparator.naturalOrder())); + } + default -> { + maxWeightMatching = new MaximumWeightBipartiteMatching(graph, + plateVtoAMap.keySet(), + plateVtoBMap.keySet()); + } + } + //get the matching MatchingAlgorithm.Matching graphMatching = maxWeightMatching.getMatching(); if(verbose){System.out.println("Matching completed");} Instant stop = Instant.now();