View Javadoc

1   package liblinear;
2   
3   
4   final class ArraySorter {
5   
6       /**
7        * <p>Sorts the specified array of doubles into <b>descending</b> order.</p>
8        *
9        * <em>This code is borrowed from Sun's JDK 1.6.0.07</em>
10       */
11      public static void reversedMergesort(double[] a) {
12          reversedMergesort(a, 0, a.length);
13      }
14  
15      private static void reversedMergesort(double x[], int off, int len) {
16          // Insertion sort on smallest arrays
17          if (len < 7) {
18              for (int i = off; i < len + off; i++)
19                  for (int j = i; j > off && x[j - 1] < x[j]; j--)
20                      swap(x, j, j - 1);
21              return;
22          }
23  
24          // Choose a partition element, v
25          int m = off + (len >> 1); // Small arrays, middle element
26          if (len > 7) {
27              int l = off;
28              int n = off + len - 1;
29              if (len > 40) { // Big arrays, pseudomedian of 9
30                  int s = len / 8;
31                  l = med3(x, l, l + s, l + 2 * s);
32                  m = med3(x, m - s, m, m + s);
33                  n = med3(x, n - 2 * s, n - s, n);
34              }
35              m = med3(x, l, m, n); // Mid-size, med of 3
36          }
37          double v = x[m];
38  
39          // Establish Invariant: v* (<v)* (>v)* v*
40          int a = off, b = a, c = off + len - 1, d = c;
41          while (true) {
42              while (b <= c && x[b] >= v) {
43                  if (x[b] == v) swap(x, a++, b);
44                  b++;
45              }
46              while (c >= b && x[c] <= v) {
47                  if (x[c] == v) swap(x, c, d--);
48                  c--;
49              }
50              if (b > c) break;
51              swap(x, b++, c--);
52          }
53  
54          // Swap partition elements back to middle
55          int s, n = off + len;
56          s = Math.min(a - off, b - a);
57          vecswap(x, off, b - s, s);
58          s = Math.min(d - c, n - d - 1);
59          vecswap(x, b, n - s, s);
60  
61          // Recursively sort non-partition-elements
62          if ((s = b - a) > 1) reversedMergesort(x, off, s);
63          if ((s = d - c) > 1) reversedMergesort(x, n - s, s);
64      }
65  
66      /**
67       * Swaps x[a] with x[b].
68       */
69      private static void swap(double x[], int a, int b) {
70          double t = x[a];
71          x[a] = x[b];
72          x[b] = t;
73      }
74  
75      /**
76       * Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)].
77       */
78      private static void vecswap(double x[], int a, int b, int n) {
79          for (int i = 0; i < n; i++, a++, b++)
80              swap(x, a, b);
81      }
82  
83      /**
84       * Returns the index of the median of the three indexed doubles.
85       */
86      private static int med3(double x[], int a, int b, int c) {
87          return (x[a] < x[b] ? (x[b] < x[c] ? b : x[a] < x[c] ? c : a) : (x[b] > x[c] ? b : x[a] > x[c] ? c : a));
88      }
89  
90  
91  }