From fbc04966755ca2ab2fea65f6e09fe6e454038f7d Mon Sep 17 00:00:00 2001
From: eugenefischer <66030419+eugenefischer@users.noreply.github.com>
Date: Wed, 9 Apr 2025 11:18:21 -0500
Subject: [PATCH] update readme and default heap type

---
 readme.md                     | 46 +++++++++++++++++------------------
 src/main/java/BiGpairSEQ.java |  2 +-
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/readme.md b/readme.md
index 727f5dc..23d7c79 100644
--- a/readme.md
+++ b/readme.md
@@ -1,31 +1,31 @@
 # BiGpairSEQ SIMULATOR
 
 ## CONTENTS
-1. ABOUT
-2. THEORY
-3. THE BiGpairSEQ ALGORITHM
-4. USAGE
-   1. RUNNING THE PROGRAM
-   2. COMMAND LINE OPTIONS
-   3. INTERACTIVE INTERFACE
-   4. INPUT/OUTPUT
+1. [ABOUT](#about)
+2. [THEORY](#theory)
+3. [THE BiGpairSEQ ALGORITHM](#the-bigpairseq-algorithm)
+4. [USAGE](#usage)
+   1. [RUNNING THE PROGRAM](#running-the-program)
+   2. [COMMAND LINE OPTIONS](#command-line-options)
+   3. [INTERACTIVE INTERFACE](#interactive-interface)
+   4. [INPUT/OUTPUT](#inputoutput)
       1. Cell Sample Files
       2. Sample Plate Files
       3. Graph/Data Files
       4. Matching Results Files
-5. RESULTS
+5. [RESULTS](#results)
    1. SAMPLE PLATES WITH VARYING NUMBERS OF CELLS PER WELL
    2. SIMULATING EXPERIMENTS FROM pairSEQ PAPER
-6. TODO
-7. CITATIONS
-8. ACKNOWLEDGEMENTS
-9. AUTHOR
-10. DISCLOSURE
+6. [TODO](#todo)
+7. [CITATIONS](#citations)
+8. [ACKNOWLEDGEMENTS](#acknowledgements)
+9. [AUTHOR](#author)
+10. [DISCLOSURE](#disclosure)
 
 ## ABOUT
 
 This program simulates BiGpairSEQ (Bipartite Graph pairSEQ), a graph theory-based adaptation
-of the pairSEQ algorithm (Howie, et al. 2015) for pairing T cell receptor sequences.
+of the pairSEQ algorithm ([Howie, et al. 2015](#citations)) for pairing T cell receptor sequences.
 
 ## THEORY
 
@@ -51,17 +51,17 @@ matching (MWM) on a bipartite graph--the subset of vertex-disjoint edges whose w
 
 This is a well-studied combinatorial optimization problem, with many known algorithms that produce 
 provably-optimal solutions. The most theoretically efficient algorithm known to the author for maximum weight matching of a bipartite
-graph with strictly integral weights is from Duan and Su (2012). For a graph with m edges, n vertices per side, 
+graph with strictly integral weights is from [Duan and Su (2012)](#citations). For a graph with m edges, n vertices per side, 
 and maximum integer edge weight N, their algorithm runs in **O(m sqrt(n) log(N))** time. As the graph representation of 
-a pairSEQ experiment is bipartite with integer weights, this algorithm seems ideal for BiGpairSEQ. Unfortunately, it's a 
-fairly new algorithm, and not yet implemented by the graph theory library used in this simulator (JGraphT), nor has the author had 
-time to implement it himself.
+a pairSEQ experiment is bipartite with integer weights, this algorithm seems ideal for BiGpairSEQ. Unfortunately, it is not 
+implemented by the graph theory library used in this simulator (JGraphT), and the author has not yet had time to write a
+full, optimized implementation himself for testing.
 
 So this program instead uses the [Fibonacci heap](https://en.wikipedia.org/wiki/Fibonacci_heap) based algorithm of Fredman and Tarjan (1987) (essentially
-[the Hungarian algorithm](https://en.wikipedia.org/wiki/Hungarian_algorithm) augmented with a more efficeint priority queue) which has a worst-case
-runtime of **O(n (n log(n) + m))**. The algorithm is implemented as described in Melhorn and Näher (1999). (The simulator
-allows the substitution of a [pairing heap](https://en.wikipedia.org/wiki/Pairing_heap) for a Fibonacci heap, though the relative performance difference of the two
-has not yet been thoroughly tested.)
+[the Hungarian algorithm](https://en.wikipedia.org/wiki/Hungarian_algorithm) augmented with a more efficient priority queue) which has a worst-case
+runtime of **O(n (n log(n) + m))**. The algorithm is implemented as described in [Melhorn and Näher (1999)](#citations). (The simulator can use either a
+Fibonacci heap or a [pairing heap](https://en.wikipedia.org/wiki/Pairing_heap) as desired. By default, a pairing heap is used,
+as in practice they often offer superior performance.)
 
 One possible advantage of this less efficient algorithm is that the Hungarian algorithm and its variations work with both the balanced and the unbalanced assignment problem
 (that is, cases where both sides of the bipartite graph have the same number of vertices and those in which they don't.)
diff --git a/src/main/java/BiGpairSEQ.java b/src/main/java/BiGpairSEQ.java
index 52b2f38..17aad88 100644
--- a/src/main/java/BiGpairSEQ.java
+++ b/src/main/java/BiGpairSEQ.java
@@ -14,7 +14,7 @@ public class BiGpairSEQ {
     private static boolean cachePlate = false;
     private static boolean cacheGraph = false;
     private static AlgorithmType matchingAlgoritmType = AlgorithmType.HUNGARIAN;
-    private static HeapType priorityQueueHeapType = HeapType.FIBONACCI;
+    private static HeapType priorityQueueHeapType = HeapType.PAIRING;
     private static boolean outputBinary = true;
     private static boolean outputGraphML = false;
     private static boolean calculatePValue = false;