SortIndex

SortIndex(d, i)

Returns a permutation of the index elements re-arranged to indicate the ascending sorted ordering of array elements. In the event of a tie, the original order is preserved.

If «i» is not specified, you should guarantee that «d» will always 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 dimensionality of «d», but where each element is the corresponding element in «i» indicating the sort.

If «d» is indexed by dimensions 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)]

Examples

To sort the elemets of an index (in ascending order):

SortIndex( I )

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

A[I=sortIndex(A, I)]

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)]

Maint_costs →

	Car_type ▶
	VW	Honda	BMW
	1950	1800	2210

SortIndex(Maint_costs, Car_type) →

	Car_type ▶
	VW	Honda	BMW
	Honda	VW	BMW

SortIndex(Maint_costs) →

	SortIndex ▶
	Honda	VW	BMV

Define Sorted_cars as an index node:

INDEX Sorted_cars := Sortindex(Maint_costs)

Maint_costs[Car_type = Sorted_cars] →

	Honda	VW	BMW
	1800	1950	2210

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 seconary 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).

History

Analytica 4.2
- Case-sensitive sort option; in Analytica 4.1 and earlier, use SortIndex(TextUpperCase(D))
- Descending sort option; in Analytica 4.1 and earlier, reverse the elements after the sort using Var r := SortIndex(D) Do Slice(r, Size(r)..1)
- Multi-key sorting using the optional «keyIndex» parameter; in Analytica 4.1 and earlier sort by the secondary key first, and then sort again using the primary key: Index order1 := SortIndex(firstname, Person); SortIndex(lastName[Person=order1], Person)
- Positions of the sorted elements