bin/jalview/util/QuickSort.js

   1 Clazz.declarePackage ("jalview.util");
   2 Clazz.load (null, "jalview.util.QuickSort", ["java.lang.Float", "java.util.Arrays"], function () {
   3 c$ = Clazz.declareType (jalview.util, "QuickSort");
   4 c$.sortInt = Clazz.defineMethod (c$, "sortInt",
   5 function (arr, s) {
   6 jalview.util.QuickSort.sortInt (arr, 0, arr.length - 1, s);
   7 }, "~A,~A");
   8 c$.sortFloatObject = Clazz.defineMethod (c$, "sortFloatObject",
   9 function (arr, s) {
  10 jalview.util.QuickSort.sortFloat (arr, 0, arr.length - 1, s);
  11 }, "~A,~A");
  12 c$.sortDouble = Clazz.defineMethod (c$, "sortDouble",
  13 function (arr, s) {
  14 jalview.util.QuickSort.sortDouble (arr, 0, arr.length - 1, s);
  15 }, "~A,~A");
  16 c$.sort = Clazz.defineMethod (c$, "sort",
  17 function (arr, s) {
  18 jalview.util.QuickSort.stringSort (arr, 0, arr.length - 1, s);
  19 }, "~A,~A");
  20 c$.stringSort = Clazz.defineMethod (c$, "stringSort",
  21 ($fz = function (arr, p, r, s) {
  22 var q;
  23 if (p < r) {
  24 q = jalview.util.QuickSort.stringPartition (arr, p, r, s);
  25 jalview.util.QuickSort.stringSort (arr, p, q, s);
  26 jalview.util.QuickSort.stringSort (arr, q + 1, r, s);
  27 }}, $fz.isPrivate = true, $fz), "~A,~N,~N,~A");
  28 c$.sortFloat = Clazz.defineMethod (c$, "sortFloat",
  29 ($fz = function (arr, p, r, s) {
  30 var q;
  31 if (p < r) {
  32 q = jalview.util.QuickSort.partitionFloat (arr, p, r, s);
  33 jalview.util.QuickSort.sortFloat (arr, p, q, s);
  34 jalview.util.QuickSort.sortFloat (arr, q + 1, r, s);
  35 }}, $fz.isPrivate = true, $fz), "~A,~N,~N,~A");
  36 c$.sortInt = Clazz.defineMethod (c$, "sortInt",
  37 ($fz = function (arr, p, r, s) {
  38 var q;
  39 if (p < r) {
  40 q = jalview.util.QuickSort.partitionInt (arr, p, r, s);
  41 jalview.util.QuickSort.sortInt (arr, p, q, s);
  42 jalview.util.QuickSort.sortInt (arr, q + 1, r, s);
  43 }}, $fz.isPrivate = true, $fz), "~A,~N,~N,~A");
  44 c$.partitionFloat = Clazz.defineMethod (c$, "partitionFloat",
  45 ($fz = function (arr, p, r, s) {
  46 var x = arr[p];
  47 var i = p - 1;
  48 var j = r + 1;
  49 while (true) {
  50 do {
  51 j = j - 1;
  52 } while (arr[j] > x);
  53 do {
  54 i = i + 1;
  55 } while (arr[i] < x);
  56 if (i < j) {
  57 var tmp = arr[i];
  58 arr[i] = arr[j];
  59 arr[j] = tmp;
  60 var tmp2 = s[i];
  61 s[i] = s[j];
  62 s[j] = tmp2;
  63 } else {
  64 return j;
  65 }}
  66 }, $fz.isPrivate = true, $fz), "~A,~N,~N,~A");
  67 c$.partitionInt = Clazz.defineMethod (c$, "partitionInt",
  68 ($fz = function (arr, p, r, s) {
  69 var x = arr[p];
  70 var i = p - 1;
  71 var j = r + 1;
  72 while (true) {
  73 do {
  74 j = j - 1;
  75 } while (arr[j] > x);
  76 do {
  77 i = i + 1;
  78 } while (arr[i] < x);
  79 if (i < j) {
  80 var tmp = arr[i];
  81 arr[i] = arr[j];
  82 arr[j] = tmp;
  83 var tmp2 = s[i];
  84 s[i] = s[j];
  85 s[j] = tmp2;
  86 } else {
  87 return j;
  88 }}
  89 }, $fz.isPrivate = true, $fz), "~A,~N,~N,~A");
  90 c$.stringPartition = Clazz.defineMethod (c$, "stringPartition",
  91 ($fz = function (arr, p, r, s) {
  92 var x = arr[p];
  93 var i = p - 1;
  94 var j = r + 1;
  95 while (true) {
  96 do {
  97 j = j - 1;
  98 } while (arr[j].compareTo (x) < 0);
  99 do {
 100 i = i + 1;
 101 } while (arr[i].compareTo (x) > 0);
 102 if (i < j) {
 103 var tmp = arr[i];
 104 arr[i] = arr[j];
 105 arr[j] = tmp;
 106 var tmp2 = s[i];
 107 s[i] = s[j];
 108 s[j] = tmp2;
 109 } else {
 110 return j;
 111 }}
 112 }, $fz.isPrivate = true, $fz), "~A,~N,~N,~A");
 113 c$.sortFloatChar = Clazz.defineMethod (c$, "sortFloatChar",
 114 function (arr, s) {
 115 var f1 =  Clazz.newFloatArray (arr.length, 0);
 116 var s1 =  Clazz.newCharArray (s.length, '\0');
 117 var nextZeroValue = 0;
 118 var nextNonZeroValue = arr.length - 1;
 119 for (var i = 0; i < arr.length; i++) {
 120 var val = arr[i];
 121 if (val > 0) {
 122 f1[nextNonZeroValue] = val;
 123 s1[nextNonZeroValue] = s[i];
 124 nextNonZeroValue--;
 125 } else {
 126 f1[nextZeroValue] = val;
 127 s1[nextZeroValue] = s[i];
 128 nextZeroValue++;
 129 }}
 130 System.arraycopy (f1, 0, arr, 0, nextZeroValue);
 131 System.arraycopy (s1, 0, s, 0, nextZeroValue);
 132 if (nextZeroValue == arr.length) {
 133 return;
 134 }var nonZeroFloats = java.util.Arrays.copyOfRange (f1, nextZeroValue, f1.length);
 135 var nonZeroChars = java.util.Arrays.copyOfRange (s1, nextZeroValue, s1.length);
 136 jalview.util.QuickSort.externalSortFloat (nonZeroFloats, nonZeroChars);
 137 System.arraycopy (nonZeroFloats, 0, arr, nextZeroValue, nonZeroFloats.length);
 138 System.arraycopy (nonZeroChars, 0, s, nextZeroValue, nonZeroChars.length);
 139 }, "~A,~A");
 140 c$.externalSortFloat = Clazz.defineMethod (c$, "externalSortFloat",
 141 ($fz = function (arr, s) {
 142 var length = arr.length;
 143 var indices = jalview.util.QuickSort.makeIndexArray (length);
 144 java.util.Arrays.sort (indices,  new jalview.util.QuickSort.FloatComparator (arr));
 145 var sortedFloats =  Clazz.newFloatArray (length, 0);
 146 var sortedChars =  Clazz.newCharArray (s.length, '\0');
 147 for (var i = 0; i < length; i++) {
 148 sortedFloats[i] = arr[indices[i]];
 149 sortedChars[i] = s[indices[i]];
 150 }
 151 System.arraycopy (sortedFloats, 0, arr, 0, length);
 152 System.arraycopy (sortedChars, 0, s, 0, s.length);
 153 }, $fz.isPrivate = true, $fz), "~A,~A");
 154 c$.makeIndexArray = Clazz.defineMethod (c$, "makeIndexArray",
 155 ($fz = function (length) {
 156 var indices =  new Array (length);
 157 for (var i = 0; i < length; i++) {
 158 indices[i] = new Integer (i);
 159 }
 160 return indices;
 161 }, $fz.isPrivate = true, $fz), "~N");
 162 c$.sortIntChar = Clazz.defineMethod (c$, "sortIntChar",
 163 function (arr, s) {
 164 var f1 =  Clazz.newIntArray (arr.length, 0);
 165 var s1 =  Clazz.newCharArray (s.length, '\0');
 166 var nextZeroValue = 0;
 167 var nextNonZeroValue = arr.length - 1;
 168 for (var i = 0; i < arr.length; i++) {
 169 var val = arr[i];
 170 if (val > 0) {
 171 f1[nextNonZeroValue] = val;
 172 s1[nextNonZeroValue] = s[i];
 173 nextNonZeroValue--;
 174 } else {
 175 f1[nextZeroValue] = val;
 176 s1[nextZeroValue] = s[i];
 177 nextZeroValue++;
 178 }}
 179 System.arraycopy (f1, 0, arr, 0, nextZeroValue);
 180 System.arraycopy (s1, 0, s, 0, nextZeroValue);
 181 if (nextZeroValue == arr.length) {
 182 return;
 183 }var nonZeroInts = java.util.Arrays.copyOfRange (f1, nextZeroValue, f1.length);
 184 var nonZeroChars = java.util.Arrays.copyOfRange (s1, nextZeroValue, s1.length);
 185 jalview.util.QuickSort.externalSortInt (nonZeroInts, nonZeroChars);
 186 System.arraycopy (nonZeroInts, 0, arr, nextZeroValue, nonZeroInts.length);
 187 System.arraycopy (nonZeroChars, 0, s, nextZeroValue, nonZeroChars.length);
 188 }, "~A,~A");
 189 c$.externalSortInt = Clazz.defineMethod (c$, "externalSortInt",
 190 ($fz = function (arr, s) {
 191 var length = arr.length;
 192 var indices = jalview.util.QuickSort.makeIndexArray (length);
 193 java.util.Arrays.sort (indices,  new jalview.util.QuickSort.IntComparator (arr));
 194 var sortedInts =  Clazz.newIntArray (length, 0);
 195 var sortedChars =  Clazz.newCharArray (s.length, '\0');
 196 for (var i = 0; i < length; i++) {
 197 sortedInts[i] = arr[indices[i]];
 198 sortedChars[i] = s[indices[i]];
 199 }
 200 System.arraycopy (sortedInts, 0, arr, 0, length);
 201 System.arraycopy (sortedChars, 0, s, 0, s.length);
 202 }, $fz.isPrivate = true, $fz), "~A,~A");
 203 Clazz.pu$h ();
 204 c$ = Clazz.decorateAsClass (function () {
 205 this.values = null;
 206 Clazz.instantialize (this, arguments);
 207 }, jalview.util.QuickSort, "FloatComparator", null, java.util.Comparator);
 208 Clazz.makeConstructor (c$,
 209 function (a) {
 210 this.values = a;
 211 }, "~A");
 212 Clazz.overrideMethod (c$, "compare",
 213 function (a, b) {
 214 return Float.compare (this.values[a.intValue ()], this.values[b]);
 215 }, "Integer,Integer");
 216 c$ = Clazz.p0p ();
 217 Clazz.pu$h ();
 218 c$ = Clazz.decorateAsClass (function () {
 219 this.values = null;
 220 Clazz.instantialize (this, arguments);
 221 }, jalview.util.QuickSort, "IntComparator", null, java.util.Comparator);
 222 Clazz.makeConstructor (c$,
 223 function (a) {
 224 this.values = a;
 225 }, "~A");
 226 Clazz.overrideMethod (c$, "compare",
 227 function (a, b) {
 228 return Integer.compare (this.values[a], this.values[b]);
 229 }, "Integer,Integer");
 230 c$ = Clazz.p0p ();
 231 });