JAL-1680 group consensus speeded up with a different QuickSort algorithm

diff --git a/src/jalview/util/QuickSort.java b/src/jalview/util/QuickSort.java
index cedf656..c341807 100755 (executable)
--- a/src/jalview/util/QuickSort.java
+++ b/src/jalview/util/QuickSort.java
@@ -20,15 +20,54 @@
  */
 package jalview.util;
 
+import java.util.Arrays;
+import java.util.Comparator;
+
 /**
  * A class to perform efficient sorting of arrays of objects based on arrays of
- * scores or other attributes. For example, residues by frequency.
+ * scores or other attributes. For example, residues by percentage frequency.
  * 
  * @author gmcarstairs
  *
  */
 public class QuickSort
 {
+  static class FloatComparator implements Comparator<Integer>
+  {
+
+    private final float[] values;
+
+    FloatComparator(float[] v)
+    {
+      values = v;
+    }
+
+    @Override
+    public int compare(Integer o1, Integer o2)
+    {
+      return Float.compare(values[o1], values[o2]);
+    }
+    
+  }
+
+  static class IntComparator implements Comparator<Integer>
+  {
+
+    private final int[] values;
+
+    IntComparator(int[] v)
+    {
+      values = v;
+    }
+
+    @Override
+    public int compare(Integer o1, Integer o2)
+    {
+      return Integer.compare(values[o1], values[o2]);
+    }
+
+  }
+
   /**
    * Sorts both arrays with respect to ascending order of the items in the first
    * array.
@@ -160,6 +199,41 @@ public class QuickSort
     }
   }
 
+  static int partition(float[] arr, int p, int r, char[] s)
+  {
+    float x = arr[p];
+    int i = p - 1;
+    int j = r + 1;
+
+    while (true)
+    {
+      do
+      {
+        j = j - 1;
+      } while (arr[j] > x);
+
+      do
+      {
+        i = i + 1;
+      } while (arr[i] < x);
+
+      if (i < j)
+      {
+        float tmp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = tmp;
+
+        char tmp2 = s[i];
+        s[i] = s[j];
+        s[j] = tmp2;
+      }
+      else
+      {
+        return j;
+      }
+    }
+  }
+
   static int partition(int[] arr, int p, int r, Object[] s)
   {
     int x = arr[p];
@@ -264,4 +338,218 @@ public class QuickSort
       }
     }
   }
+
+  /**
+   * Sorts both arrays to give ascending order in the first array, by first
+   * partitioning into zero and non-zero values before sorting the latter.
+   * 
+   * @param arr
+   * @param s
+   */
+  public static void sort(float[] arr, char[] s)
+  {
+    /*
+     * Sort all zero values to the front
+     */
+    float[] f1 = new float[arr.length];
+    char[] s1 = new char[s.length];
+    int nextZeroValue = 0;
+    int nextNonZeroValue = arr.length - 1;
+    for (int i = 0; i < arr.length; i++)
+    {
+      float val = arr[i];
+      if (val > 0f)
+      {
+        f1[nextNonZeroValue] = val;
+        s1[nextNonZeroValue] = s[i];
+        nextNonZeroValue--;
+      }
+      else
+      {
+        f1[nextZeroValue] = val;
+        s1[nextZeroValue] = s[i];
+        nextZeroValue++;
+      }
+    }
+
+    /*
+     * Copy zero values back to original arrays
+     */
+    System.arraycopy(f1, 0, arr, 0, nextZeroValue);
+    System.arraycopy(s1, 0, s, 0, nextZeroValue);
+
+    if (nextZeroValue == arr.length)
+    {
+      return; // all zero
+    }
+    /*
+     * Sort the non-zero values
+     */
+    float[] nonZeroFloats = Arrays
+            .copyOfRange(f1, nextZeroValue, f1.length);
+    char[] nonZeroChars = Arrays.copyOfRange(s1, nextZeroValue, s1.length);
+    externalSort(nonZeroFloats, nonZeroChars);
+    // sort(nonZeroFloats, 0, nonZeroFloats.length - 1, nonZeroChars);
+
+    /*
+     * Assemble sorted non-zero results
+     */
+    System.arraycopy(nonZeroFloats, 0, arr, nextZeroValue,
+            nonZeroFloats.length);
+    System.arraycopy(nonZeroChars, 0, s, nextZeroValue, nonZeroChars.length);
+  }
+
+  /**
+   * Sort by making an array of indices, and sorting it using a comparator that
+   * refers to the float values.
+   * 
+   * @see http
+   *      ://stackoverflow.com/questions/4859261/get-the-indices-of-an-array-
+   *      after-sorting
+   * @param arr
+   * @param s
+   */
+  protected static void externalSort(float[] arr, char[] s)
+  {
+    final int length = arr.length;
+    Integer[] indices = makeIndexArray(length);
+    Arrays.sort(indices, new FloatComparator(arr));
+
+    /*
+     * Copy the array values as per the sorted indices
+     */
+    float[] sortedFloats = new float[length];
+    char[] sortedChars = new char[s.length];
+    for (int i = 0; i < length; i++)
+    {
+      sortedFloats[i] = arr[indices[i]];
+      sortedChars[i] = s[indices[i]];
+    }
+
+    /*
+     * And copy the sorted values back into the arrays
+     */
+    System.arraycopy(sortedFloats, 0, arr, 0, length);
+    System.arraycopy(sortedChars, 0, s, 0, s.length);
+  }
+
+  /**
+   * Make an array whose values are 0...length.
+   * 
+   * @param length
+   * @return
+   */
+  protected static Integer[] makeIndexArray(final int length)
+  {
+    Integer[] indices = new Integer[length];
+    for (int i = 0; i < length; i++)
+    {
+      indices[i] = i;
+    }
+    return indices;
+  }
+
+  static void sort(float[] arr, int p, int r, char[] s)
+  {
+    int q;
+    if (p < r)
+    {
+      q = partition(arr, p, r, s);
+      sort(arr, p, q, s);
+      sort(arr, q + 1, r, s);
+    }
+  }
+
+  /**
+   * Sorts both arrays to give ascending order in the first array, by first
+   * partitioning into zero and non-zero values before sorting the latter.
+   * 
+   * @param arr
+   * @param s
+   */
+  public static void sort(int[] arr, char[] s)
+  {
+    /*
+     * Sort all zero values to the front
+     */
+    int[] f1 = new int[arr.length];
+    char[] s1 = new char[s.length];
+    int nextZeroValue = 0;
+    int nextNonZeroValue = arr.length - 1;
+    for (int i = 0; i < arr.length; i++)
+    {
+      int val = arr[i];
+      if (val > 0f)
+      {
+        f1[nextNonZeroValue] = val;
+        s1[nextNonZeroValue] = s[i];
+        nextNonZeroValue--;
+      }
+      else
+      {
+        f1[nextZeroValue] = val;
+        s1[nextZeroValue] = s[i];
+        nextZeroValue++;
+      }
+    }
+  
+    /*
+     * Copy zero values back to original arrays
+     */
+    System.arraycopy(f1, 0, arr, 0, nextZeroValue);
+    System.arraycopy(s1, 0, s, 0, nextZeroValue);
+  
+    if (nextZeroValue == arr.length)
+    {
+      return; // all zero
+    }
+    /*
+     * Sort the non-zero values
+     */
+    int[] nonZeroInts = Arrays
+            .copyOfRange(f1, nextZeroValue, f1.length);
+    char[] nonZeroChars = Arrays.copyOfRange(s1, nextZeroValue, s1.length);
+    externalSort(nonZeroInts, nonZeroChars);
+    // sort(nonZeroFloats, 0, nonZeroFloats.length - 1, nonZeroChars);
+  
+    /*
+     * Assemble sorted non-zero results
+     */
+    System.arraycopy(nonZeroInts, 0, arr, nextZeroValue, nonZeroInts.length);
+    System.arraycopy(nonZeroChars, 0, s, nextZeroValue, nonZeroChars.length);
+  }
+
+  /**
+   * Sort by making an array of indices, and sorting it using a comparator that
+   * refers to the float values.
+   * 
+   * @see http
+   *      ://stackoverflow.com/questions/4859261/get-the-indices-of-an-array-
+   *      after-sorting
+   * @param arr
+   * @param s
+   */
+  protected static void externalSort(int[] arr, char[] s)
+  {
+    final int length = arr.length;
+    Integer[] indices = makeIndexArray(length);
+    Arrays.sort(indices, new IntComparator(arr));
+
+    /*
+     * Copy the array values as per the sorted indices
+     */
+    int[] sortedInts = new int[length];
+    char[] sortedChars = new char[s.length];
+    for (int i = 0; i < length; i++)
+    {
+      sortedInts[i] = arr[indices[i]];
+      sortedChars[i] = s[indices[i]];
+    }
+
+    /*
+     * And copy the sorted values back into the arrays
+     */
+    System.arraycopy(sortedInts, 0, arr, 0, length);
+    System.arraycopy(sortedChars, 0, s, 0, s.length);
+  }
 }

diff --git a/test/jalview/util/QuickSortTest.java b/test/jalview/util/QuickSortTest.java
index 03aa463..2293163 100644 (file)
--- a/test/jalview/util/QuickSortTest.java
+++ b/test/jalview/util/QuickSortTest.java
@@ -1,5 +1,6 @@
 package jalview.util;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 import java.util.Arrays;
@@ -95,4 +96,26 @@ public class QuickSortTest
     assertTrue(Arrays.equals(new Object[]
     { "Z", "Y", "A", "X", "B" }, things));
   }
+
+  /**
+   * Test that exercises sort with a mostly zero-valued sortby array. May be of
+   * interest to check the sort algorithm is efficient.
+   */
+  @Test
+  public void testSort_MostlyZeroValues()
+  {
+    char[] residues = new char[64];
+    for (int i = 0; i < 64; i++)
+    {
+      residues[i] = (char) i;
+    }
+    float[] counts = new float[64];
+    counts[43] = 16;
+    counts[59] = 7;
+    counts[62] = 2;
+    QuickSort.sort(counts, residues);
+    assertEquals(43, residues[63]);
+    assertEquals(59, residues[62]);
+    assertEquals(62, residues[61]);
+  }
 }