Lines Matching defs:right
96 * {@code right} index is inclusive, and it does no range checking
97 * on {@code left} or {@code right}.
101 * @param right the index of the last element, inclusive, to be sorted
103 private static void doSort(int[] a, int left, int right) {
105 if (right - left + 1 < INSERTION_SORT_THRESHOLD) {
106 for (int i = left + 1; i <= right; i++) {
115 dualPivotQuicksort(a, left, right);
125 * @param right the index of the last element, inclusive, to be sorted
127 private static void dualPivotQuicksort(int[] a, int left, int right) {
129 int sixth = (right - left + 1) / 6;
131 int e5 = right - sixth;
132 int e3 = (left + right) >>> 1; // The midpoint
163 int pivot2 = ae4; a[e4] = a[right];
167 int great = right - 1; // The index before first element of right part
175 * left part center part right part
187 * all in (great, right) > pivot2
200 } else if (ak > pivot2) { // Move a[k] to right part
221 * left part center part right part
233 * all in (great, right) > pivot
248 } else { // (a[k] > pivot1) - Move a[k] to right part
272 a[right] = a[great + 1]; a[great + 1] = pivot2;
274 // Sort left and right parts recursively, excluding known pivot values
276 doSort(a, great + 2, right);
301 * left part center part right part
320 if (ak == pivot2) { // Move a[k] to right part
374 * {@code right} index is inclusive, and it does no range checking on
375 * {@code left} or {@code right}.
379 * @param right the index of the last element, inclusive, to be sorted
381 private static void doSort(long[] a, int left, int right) {
383 if (right - left + 1 < INSERTION_SORT_THRESHOLD) {
384 for (int i = left + 1; i <= right; i++) {
393 dualPivotQuicksort(a, left, right);
403 * @param right the index of the last element, inclusive, to be sorted
405 private static void dualPivotQuicksort(long[] a, int left, int right) {
407 int sixth = (right - left + 1) / 6;
409 int e5 = right - sixth;
410 int e3 = (left + right) >>> 1; // The midpoint
441 long pivot2 = ae4; a[e4] = a[right];
445 int great = right - 1; // The index before first element of right part
453 * left part center part right part
465 * all in (great, right) > pivot2
478 } else if (ak > pivot2) { // Move a[k] to right part
499 * left part center part right part
511 * all in (great, right) > pivot
526 } else { // (a[k] > pivot1) - Move a[k] to right part
550 a[right] = a[great + 1]; a[great + 1] = pivot2;
552 // Sort left and right parts recursively, excluding known pivot values
554 doSort(a, great + 2, right);
579 * left part center part right part
598 if (ak == pivot2) { // Move a[k] to right part
655 * {@code right} index is inclusive, and it does no range checking on
656 * {@code left} or {@code right}.
660 * @param right the index of the last element, inclusive, to be sorted
662 private static void doSort(short[] a, int left, int right) {
664 if (right - left + 1 < INSERTION_SORT_THRESHOLD) {
665 for (int i = left + 1; i <= right; i++) {
673 } else if (right-left+1 > COUNTING_SORT_THRESHOLD_FOR_SHORT_OR_CHAR) {
677 for (int i = left; i <= right; i++) {
680 for (int i = 0, k = left; i < count.length && k <= right; i++) {
688 dualPivotQuicksort(a, left, right);
698 * @param right the index of the last element, inclusive, to be sorted
700 private static void dualPivotQuicksort(short[] a, int left, int right) {
702 int sixth = (right - left + 1) / 6;
704 int e5 = right - sixth;
705 int e3 = (left + right) >>> 1; // The midpoint
736 short pivot2 = ae4; a[e4] = a[right];
740 int great = right - 1; // The index before first element of right part
748 * left part center part right part
760 * all in (great, right) > pivot2
773 } else if (ak > pivot2) { // Move a[k] to right part
794 * left part center part right part
806 * all in (great, right) > pivot
821 } else { // (a[k] > pivot1) - Move a[k] to right part
845 a[right] = a[great + 1]; a[great + 1] = pivot2;
847 // Sort left and right parts recursively, excluding known pivot values
849 doSort(a, great + 2, right);
874 * left part center part right part
893 if (ak == pivot2) { // Move a[k] to right part
950 * {@code right} index is inclusive, and it does no range checking on
951 * {@code left} or {@code right}.
955 * @param right the index of the last element, inclusive, to be sorted
957 private static void doSort(char[] a, int left, int right) {
959 if (right - left + 1 < INSERTION_SORT_THRESHOLD) {
960 for (int i = left + 1; i <= right; i++) {
968 } else if (right-left+1 > COUNTING_SORT_THRESHOLD_FOR_SHORT_OR_CHAR) {
972 for (int i = left; i <= right; i++) {
975 for (int i = 0, k = left; i < count.length && k <= right; i++) {
981 dualPivotQuicksort(a, left, right);
991 * @param right the index of the last element, inclusive, to be sorted
993 private static void dualPivotQuicksort(char[] a, int left, int right) {
995 int sixth = (right - left + 1) / 6;
997 int e5 = right - sixth;
998 int e3 = (left + right) >>> 1; // The midpoint
1029 char pivot2 = ae4; a[e4] = a[right];
1033 int great = right - 1; // The index before first element of right part
1041 * left part center part right part
1053 * all in (great, right) > pivot2
1066 } else if (ak > pivot2) { // Move a[k] to right part
1087 * left part center part right part
1099 * all in (great, right) > pivot
1114 } else { // (a[k] > pivot1) - Move a[k] to right part
1138 a[right] = a[great + 1]; a[great + 1] = pivot2;
1140 // Sort left and right parts recursively, excluding known pivot values
1142 doSort(a, great + 2, right);
1167 * left part center part right part
1186 if (ak == pivot2) { // Move a[k] to right part
1243 * {@code right} index is inclusive, and it does no range checking on
1244 * {@code left} or {@code right}.
1248 * @param right the index of the last element, inclusive, to be sorted
1250 private static void doSort(byte[] a, int left, int right) {
1252 if (right - left + 1 < INSERTION_SORT_THRESHOLD) {
1253 for (int i = left + 1; i <= right; i++) {
1261 } else if (right - left + 1 > COUNTING_SORT_THRESHOLD_FOR_BYTE) {
1265 for (int i = left; i <= right; i++) {
1268 for (int i = 0, k = left; i < count.length && k <= right; i++) {
1276 dualPivotQuicksort(a, left, right);
1286 * @param right the index of the last element, inclusive, to be sorted
1288 private static void dualPivotQuicksort(byte[] a, int left, int right) {
1290 int sixth = (right - left + 1) / 6;
1292 int e5 = right - sixth;
1293 int e3 = (left + right) >>> 1; // The midpoint
1324 byte pivot2 = ae4; a[e4] = a[right];
1328 int great = right - 1; // The index before first element of right part
1336 * left part center part right part
1348 * all in (great, right) > pivot2
1361 } else if (ak > pivot2) { // Move a[k] to right part
1382 * left part center part right part
1394 * all in (great, right) > pivot
1409 } else { // (a[k] > pivot1) - Move a[k] to right part
1433 a[right] = a[great + 1]; a[great + 1] = pivot2;
1435 // Sort left and right parts recursively, excluding known pivot values
1437 doSort(a, great + 2, right);
1462 * left part center part right part
1481 if (ak == pivot2) { // Move a[k] to right part
1556 * @param right the index of the last element, inclusive, to be sorted
1558 private static void sortNegZeroAndNaN(float[] a, int left, int right) {
1564 int n = right;
1596 // Turn the right number of positive zeros back into negative zeros
1629 * {@code right} index is inclusive, it does no range checking on
1630 * {@code left} or {@code right}, and it does not handle negative
1635 * @param right the index of the last element, inclusive, to be sorted
1637 private static void doSort(float[] a, int left, int right) {
1639 if (right - left + 1 < INSERTION_SORT_THRESHOLD) {
1640 for (int i = left + 1; i <= right; i++) {
1649 dualPivotQuicksort(a, left, right);
1659 * @param right the index of the last element, inclusive, to be sorted
1661 private static void dualPivotQuicksort(float[] a, int left, int right) {
1663 int sixth = (right - left + 1) / 6;
1665 int e5 = right - sixth;
1666 int e3 = (left + right) >>> 1; // The midpoint
1697 float pivot2 = ae4; a[e4] = a[right];
1701 int great = right - 1; // The index before first element of right part
1709 * left part center part right part
1721 * all in (great, right) > pivot2
1734 } else if (ak > pivot2) { // Move a[k] to right part
1755 * left part center part right part
1767 * all in (great, right) > pivot
1782 } else { // (a[k] > pivot1) - Move a[k] to right part
1806 a[right] = a[great + 1]; a[great + 1] = pivot2;
1808 // Sort left and right parts recursively, excluding known pivot values
1810 doSort(a, great + 2, right);
1835 * left part center part right part
1854 if (ak == pivot2) { // Move a[k] to right part
1929 * @param right the index of the last element, inclusive, to be sorted
1931 private static void sortNegZeroAndNaN(double[] a, int left, int right) {
1937 int n = right;
1969 // Turn the right number of positive zeros back into negative zeros
2002 * {@code right} index is inclusive, it does no range checking on
2003 * {@code left} or {@code right}, and it does not handle negative
2008 * @param right the index of the last element, inclusive, to be sorted
2010 private static void doSort(double[] a, int left, int right) {
2012 if (right - left + 1 < INSERTION_SORT_THRESHOLD) {
2013 for (int i = left + 1; i <= right; i++) {
2022 dualPivotQuicksort(a, left, right);
2032 * @param right the index of the last element, inclusive, to be sorted
2034 private static void dualPivotQuicksort(double[] a, int left, int right) {
2036 int sixth = (right - left + 1) / 6;
2038 int e5 = right - sixth;
2039 int e3 = (left + right) >>> 1; // The midpoint
2070 double pivot2 = ae4; a[e4] = a[right];
2074 int great = right - 1; // The index before first element of right part
2082 * left part center part right part
2094 * all in (great, right) > pivot2
2107 } else if (ak > pivot2) { // Move a[k] to right part
2128 * left part center part right part
2140 * all in (great, right) > pivot
2155 } else { // (a[k] > pivot1) - Move a[k] to right part
2179 a[right] = a[great + 1]; a[great + 1] = pivot2;
2181 // Sort left and right parts recursively, excluding known pivot values
2183 doSort(a, great + 2, right);
2208 * left part center part right part
2227 if (ak == pivot2) { // Move a[k] to right part