# SortIndex

## SortIndex(d, i)

Returns the elements of «i» re-arranged so that the values of «d» (which must be indexed by «i») are in ascending order. In the event of a tie, the original order is preserved.

If «i» is omitted, «d» must be a one-dimensional array (i.e. a list). In this case, SortIndex returns an unindexed list of elements. Use the one-parameter form only when you want an unindexed result, for example to define an index variable. The one-parameter form does array abstract when a new dimension is added to d.

If «i» is specified, «d» may be multi-dimensional. Each slice of «d» is sorted separately along «i», with the result being an array having the same dimensions as «d», but where each element is the corresponding element in «i» indicating the sort.

If «d» has indexes other than «i», each “column” is individually sorted, with the resulting sort order being indexed by the extra dimensions. To obtain the sorted array «d», use this: d[i = Sortindex(d, i)]

## Example

To sort the elements of an index (in ascending order), use

SortIndex(I)

To sort the elements of an array A, along I, use

A[I = sortIndex(A, I)]

## Optional parameters

### CaseInsensitive

When sorting text values, values are compared by default in a case-sensitive fashion, with capital letters coming before lower case letters. For example, "Zebra" comes before "apple" in a case-sensitive order.

To make the sorting case insensitive, specify the optional parameter caseInsensitive: true:

SortIndex(D, caseInsensitive: true)

### Descending

The default sort order for SortIndex is ascending. The descending sort order can be obtained by using: SortIndex(d, descending: true).

For an array containing only numeric values, the descending sort order can also be obtained as: SortIndex(-d).

If the data being sorted contains different data types, the (ascending) sort order used is: references, text, parsed expressions, Handles, NaN, numbers, Null, Undefined. All text values are sorted relative to other text values, and all numbers are sorted relative to other numeric values. References have no defined sort order, so the ordering among references is arbitrary and the resulting sort order is heterogeneous.

### KeyIndex

In the event of a tie, SortIndex preserves the original ordering. A multi-key sort finds the order by sorting on a primary key, but in the event of a tie, breaks the tie using a secondary key. The pattern can continue to tertiary keys, etc. In the general case, each key may have a different ascending/descending order or differ on whether comparisons should be case-sensitive.

The values used for the primary key, and the values used for each fall-back key, must all share a common index, «i». To pass these to SortIndex, you must bundle these together along another index, «keyIndex», where the first element along «keyIndex» is your primary key, the second element is your secondary key, etc. After you bundle these together, the first parameter to SortIndex will be a 2-D array indexed by «i» and «keyIndex». For example:

Index K := ['last', 'first']
SortIndex(Array(K, [lastName, firstName]), Person, K)

In this example, we use lastName as the primary key and firstName as the secondary key. If the optional parameters «descending» or «caseInsensitive» are also passed, these may optionally be indexed by «keyIndex» if the order or case sensitivity varies by key.

### Position

By default, SortIndex returns the elements of the index in the sorted order. In some cases, you may want the positions of the first element, etc., rather than the index elements (see Associative vs. Positional Indexing). To obtain the positions, specify the optional parameter position:true: SortIndex]](D, position: true)

Using positional notation, the original array can be re-ordered using: D[@I = SortIndex(D, I, position: true)]

The use of positional indexing would be required, for example, if you index might contain duplicate values (note that in general, it is very bad style to have duplicate elements in an index).

## Details & More Examples

### Example 1

To sort an array A (indexed by indexes Row and Col) according to the values in Col = key, use

A[Row = SortIndex(A[Col = 'key'], Row)]

### Example 2

Let:

Variable Maint_costs :=
Car_type ▶
VW Honda BMW
1950 1800 2210
Index Sorted_cars := SortIndex(Maint_costs)

Then:

SortIndex(Maint_costs, Car_type) →
Car_type ▶
VW Honda BMW
Honda VW BMW
SortIndex(Maint_costs) →
SortIndex ▶
Honda VW BMV
Maint_costs[Car_type = Sorted_cars] →
Honda VW BMW
1800 1950 2210