If F is the symbol `<` and L contains only elements of type({numeric, real_infinity}), then L is sorted in ascending numerical order.

If L contains only strings then L is sorted in lexicographic order.

If L contains any elements which are objects implementing a `<` method, then L is sorted using that method as a comparison function.

If F is the symbol `>` and L contains only elements of type({numeric, real_infinity}), then L is sorted in descending numerical order.

If L contains only strings then L is sorted in reverse lexicographic order.

If L contains any elements which are objects implementing a `<` method, then L is sorted using the inverse of that method as a comparison function.

If F is the symbol address, then the elements are sorted by address (a non-deterministic run-time specific property of the underlying data structure).

If F is the symbol general, then the elements are sorted in the following way:

numeric values are sorted in ascending numerical order

symbols and strings are sorted in lexorder (ASCII order)

indexed names and unevaluated functions are sorted first by the name part, then, if both objects being compared have an index, then the index or argument sequence

lists, sets, and rtables are compared element-wise as long as there are still elements in the container.  The shorter container is considered less-than if it entirely matches the first n-elements of the other container.  Multi-dimension rtables are scanned in memory order, which is column-major by default.

specialized types are sorted by their id-classification, or objectid

If F is the symbol length, then the elements are sorted by length where length is as determined by the length function.

If F is the symbol lexorder or string, then lists of strings or symbols are sorted into lexicographic order.  If the list also contains indexed names, then the general comparison method is used.

If L is a list of lists and F is the indexed symbol lexorder[n], where n is a positive integer, then L is sorted into lexicographic order based on the nth element of each sublist of L.

Lexicographic ordering of strings and symbols assumes the collating sequence of the US-ASCII character set.

If F is the symbol numeric and L contains only elements of type(extended_numeric), then L is sorted in ascending numerical order with undefined at the end.

If F is the symbol setorder then the elements are sorted the same way set elements are sorted.  The "--setsort=n" command-line argument allows you to change the default ordering of sets.  These same orderings can be used by choosing setorder[n] for n, an integer in the range 1..8.

When F does not match one of the symbols listed above, it must be a Boolean-valued function of two arguments.  Specifically, $F\left(a\&comma;b\right)$ returns $\mathrm{false}$ if and only if $b$ must precede $a$ in the sorted output.  That is $F\left(a\&comma;b\right)$ is a non-strict less than comparison function.  In addition, $F\left(a\&comma;b\right)$ must be defined for all pairs $a,b$ for $a$ and $b$ in the input structure and $F\left(a\&comma;b\right)$ must be transitive, that is, if $F\left(a\&comma;b\right)=\mathrm{true}$ and $F\left(b\&comma;c\right)=\mathrm{true}$ then $F\left(a\&comma;c\right)=\mathrm{true}$.

If no ordering function F is specified, a list, Vector, or Array is sorted as follows:

If all elements are of type {numeric, real_infinity}, they are sorted into increasing numerical order.

If all elements are strings or symbols, they are sorted in lexicographical order.

If any elements are objects implementing a `<` method, that method is used for any comparison where either element is such an object, and any other elements are compared using the same rules used to sort sets as described below.

Otherwise, all elements of L are sorted by the same rules used to sort sets.  This mixed-element sort is optimized to balance speed and "niceness" of the result.  Data types of the same structure are grouped together; within that internal object length is used as the next criteria; further down, individual properties such as numeric order are used when comparing elements during the sort process.

The option descending=true can be used to reverse the order of the comparison.

The option ascending=true is the default.  Reversing the order can also be achieved by specifying ascending=false.

When using the option inplace=true or when called using the indexed name sort['inplace'], the command attempts to sort the given Array or Vector in-place.  If the first argument is not a mutable data structure, such as a list, then the sorting will be done in a copy.  Similarly, if the source rtable has an indexing function that cannot be preserved during sort, such as scalar[], then the result will be a copy.

The function KF(a) -> a' maps each element in L to a key value.  L is sorted by sorting the corresponding keys.  Using a key function is preferable to a comparison function because the key function is called $\mathrm{O}\left(n\right)$ times, whereas a comparison function will be called $\mathrm{O}\left(n\log \left(n\right)\right)$ times.  This is generally faster.  In addition, sorting the keys may be done in parallel, whereas this may not be possible with a comparison function.

The key function, KF, can be used in addition to a custom comparison function, F.

The comparison function F is a non-strict less than function.  This is the default, as detailed in the "Description" above.

The syntax nonstrict=F can be used in place of F as the second argument, or the syntax sort(L,F,nonstrict=true) can be used to achieve the same result.

If an argument output=permutation is supplied, then sort does not return the sorted argument, but the permutation that would be applied to the argument in order to sort it. The permutation is given as a list of integers: the ith entry of the permutation is the integer j such that the jth entry of L would occur at the ith position in the sorted argument. This means that if $a=\mathrm{sort}\left(L\&comma;'\mathrm{output}=\mathrm{permutation}'\right)$ for a list $L$, then $\mathrm{sort}\left(L\right)$ could be obtained as $L_a$. (For one-dimensional Arrays A, there may be an offset between the jth entry and the entry obtained as A[j], but the correctly sorted result can be obtained using programmer indexing as $A\left(a\right)$.)

If an argument output = sorted is supplied, sort returns the sorted argument. This is the default behavior. In order to obtain both the sorted argument and the permutation, specify the option output = [sorted, permutation]. This returns a sequence of two elements, the first being the sorted argument, the second the permutation.

The pass option can be used to pass additional arguments to the custom comparison function.  F is a function that accepts two arguments, (a,b) and returns true or false.  A simple ascending sort may look like this: sort( [3,1,-2], (a,b)->a <= b ). By using the pass option, F can be passed additional arguments.   sort( [3,1,-2], (a,b,f)->f(a) <= f(b), 'pass'=abs ).

The comparison function F is a strict less than function.  That is $F\left(a\&comma;b\right)$ returns $\mathrm{true}$ if and only if $a$ must precede $b$ in the sorted output.  F must still be defined for all pairs of inputs and be transitive, as described above.  This argument is necessary if you want to specify a less than or equal to comparison function and want stable sorting.  Specifying a strict less than function without using the strict option will result in an non-stable, sorted output.

The syntax strict=F can be used to replace F as the second argument, or the syntax sort(L,F,strict=true) can be used to achieve the same result.

$\mathrm{sort}\left(\left[2\&comma;1\&comma;3\right]\&comma;\mathrm{numeric}\right)$

$\left[1\&comma;2\&comma;3\right]$

$\mathrm{sort}\left(\left[2\&comma;1\&comma;3\right]\&comma;\mathrm{`>`}\right)$

$\left[3\&comma;2\&comma;1\right]$

undefined is positioned at the end of the sorted list

$\mathrm{sort}\left(\left[-\mathrm{\infty }\&comma;-1\&comma;1\&comma;2\&comma;1.123\&comma;\mathrm{undefined}\&comma;\mathrm{\infty }\right]\&comma;\mathrm{numeric}\right)$

$\left[-\mathrm{\infty }\&comma;\mathrm{-1}\&comma;1\&comma;1.123\&comma;2\&comma;\mathrm{\infty }\&comma;\mathrm{undefined}\right]$

$\mathrm{sort}\left(\left[c\&comma;a\&comma;d\right]\&comma;\mathrm{lexorder}\right)$

$\left[a\&comma;c\&comma;d\right]$

$\mathrm{sort}\left(\left[''a''\&comma;''A''\&comma;''Z''\&comma;''b''\right]\right)$

$\left[''A''\&comma;''Z''\&comma;''a''\&comma;''b''\right]$

$\mathrm{sort}\left(\left[''a''\&comma;''A''\&comma;''Z''\&comma;''b''\right]\&comma;\mathrm{StringTools}:-\mathrm{Compare}\right)$

$\left[''A''\&comma;''Z''\&comma;''a''\&comma;''b''\right]$

$\mathrm{sort}\left(\left[''a''\&comma;''c''\&comma;''Z''\&comma;''B''\right]\&comma;\mathrm{StringTools}:-\mathrm{CompareCI}\right)$

$\left[''a''\&comma;''B''\&comma;''c''\&comma;''Z''\right]$

Note that using case-insensitive compare will apply stable ordering of elements that resolve to the same string but have different capitalization.

$\mathrm{StringTools}:-\mathrm{CompareCI}\left(''abc''\&comma;''ABC''\right)$

$\mathrm{true}$

$\mathrm{StringTools}:-\mathrm{CompareCI}\left(''ABC''\&comma;''abc''\right)$

$\mathrm{true}$

Ensure lexorder is specified when sorting names and indexed names, as the default algorithm may not produce what you expect

$\mathrm{sort}\left(\left[x\&comma;x\left[1\right]\&comma;x\left[1,2\right]\&comma;x\left[3\right]\right]\&comma;\mathrm{lexorder}\right)$

$\left[x\&comma;x_1\&comma;x_{1,2}\&comma;x_3\right]$

$\mathrm{sort}\left(\left[a\&comma;\mathrm{ba}\&comma;\mathrm{aaa}\&comma;\mathrm{aa}\right]\&comma;\mathrm{length}\right)$

$\left[a\&comma;\mathrm{ba}\&comma;\mathrm{aa}\&comma;\mathrm{aaa}\right]$

$\mathrm{sort}\left(\left[a\&comma;\mathrm{ba}\&comma;\mathrm{aaa}\&comma;\mathrm{aa}\right]\&comma;\mathrm{length}\&comma;'\mathrm{descending}'\right)$

$\left[\mathrm{aaa}\&comma;\mathrm{aa}\&comma;\mathrm{ba}\&comma;a\right]$

This example uses the pass option to allow a third argument to the comparison procedure.  Here, the {0,undefined} set will be passed as the third argument in each call to ecmp.

ecmp := proc(a,b,exclude)
   if a in exclude then
       false;
   elif b in exclude then
       true;
   else
       a <= b;
   end if;
end proc:

$\mathrm{sort}\left(\left[3\&comma;\mathrm{undefined}\&comma;1\&comma;0\&comma;2\right]\&comma;\mathrm{ecmp}\&comma;'\mathrm{pass}'=\left\{0\&comma;\mathrm{undefined}\right\}\right)$

$\left[1\&comma;2\&comma;3\&comma;0\&comma;\mathrm{undefined}\right]$

Here we have two lists and want to sort them both according to the same ordering. This is done by finding a permutation vector, then applying it to both lists.

$\mathrm{z1}≔\left[''three''\&comma;''four''\&comma;''two''\right]\&colon;$

$\mathrm{z2}≔\left[3\&comma;4\&comma;2\right]\&colon;$

$\mathrm{permutation}≔\mathrm{sort}\left(\mathrm{z2}\&comma;'\mathrm{output}=\mathrm{permutation}'\right)$

$\mathrm{permutation}≔\left[3\&comma;1\&comma;2\right]$

$\mathrm{z1}\left[\mathrm{permutation}\right]$

$\left[''two''\&comma;''three''\&comma;''four''\right]$

$\mathrm{z2}\left[\mathrm{permutation}\right]$

$\left[2\&comma;3\&comma;4\right]$

Or, we can use the output=[sorted,permutation] option to get both the sorted result and the permutation in one call.

$\mathrm{z3}≔⟨''five''\&comma;''eight''\&comma;''two''\&comma;''four''⟩\&colon;$

$\mathrm{z4}≔\mathrm{Array}\left(\left[5\&comma;8\&comma;2\&comma;4\right]\right)\&colon;$

$\mathrm{result},\mathrm{permutation2}≔\mathrm{sort}\left(\mathrm{z4}\&comma;'\mathrm{output}=\left[\mathrm{sorted}\&comma;\mathrm{permutation}\right]'\right)$

$\mathrm{result},\mathrm{permutation2}≔\left[\begin{array}{cccc}2& 4& 5& 8\end{array}\right],\left[3\&comma;4\&comma;1\&comma;2\right]$

$\mathrm{result}$

$\left[\begin{array}{cccc}2& 4& 5& 8\end{array}\right]$

$\mathrm{z3}\left[\mathrm{permutation2}\right]$

$\left[\begin{array}{c}''two''\\ ''four''\\ ''five''\\ ''eight''\end{array}\right]$

Here the key function is applied first, computing the degree of each element, then the list is sorted by those degrees.

$\mathrm{sort}\left(\left[x^2\&comma;x\&comma;x^5\right]\&comma;'\mathrm{numeric}'\&comma;\mathrm{`=`}\left(\mathrm{key}\&comma;x\mapsto \mathrm{degree}\left(x\right)\right)\right)$

$\left[x\&comma;x^2\&comma;x^5\right]$

$\mathrm{sort}\left(\left[x^2\&comma;x\&comma;x^5\right]\&comma;'\mathrm{numeric}'\&comma;\mathrm{key}=\mathrm{degree}\&comma;\mathrm{descending}\right)$

$\left[x^5\&comma;x^2\&comma;x\right]$

Here we have a list where each entry is a sublist of the form [name,date,offset,size].  We want to sort by the name element at position 1 in the sublist.

$l≔\mathrm{LibraryTools}:-\mathrm{ShowContents}\left(\right)\&colon;$

$\mathrm{sl}≔\mathrm{sort}\left(l\&comma;\mathrm{lexorder}\left[1\right]\right)\&colon;$

$\mathrm{sl}\left[1..10\right]$

An example of stable sorting.  Sort based on the first element in the sublist. Notice that sublists whose first elements are equal are ordered based on their position in the input list.

$\mathrm{sort}\left(\left[\left[1\&comma;1\right]\&comma;\left[2\&comma;1\right]\&comma;\left[3\&comma;1\right]\&comma;\left[1\&comma;2\right]\&comma;\left[2\&comma;2\right]\&comma;\left[3\&comma;2\right]\&comma;\left[1\&comma;3\right]\&comma;\left[2\&comma;3\right]\&comma;\left[3\&comma;3\right]\right]\&comma;\left(x\&comma;y\right)\mapsto x\left[1\right]\le y\left[1\right]\right)$

$\left[\left[1\&comma;1\right]\&comma;\left[1\&comma;2\right]\&comma;\left[1\&comma;3\right]\&comma;\left[2\&comma;1\right]\&comma;\left[2\&comma;2\right]\&comma;\left[2\&comma;3\right]\&comma;\left[3\&comma;1\right]\&comma;\left[3\&comma;2\right]\&comma;\left[3\&comma;3\right]\right]$

Specifying the strict option allows the use of a strict less than comparison function while still producing stable sorting.

$\mathrm{sort}\left(\left[\left[1\&comma;1\right]\&comma;\left[2\&comma;1\right]\&comma;\left[3\&comma;1\right]\&comma;\left[1\&comma;2\right]\&comma;\left[2\&comma;2\right]\&comma;\left[3\&comma;2\right]\&comma;\left[1\&comma;3\right]\&comma;\left[2\&comma;3\right]\&comma;\left[3\&comma;3\right]\right]\&comma;\mathrm{`=`}\left(\mathrm{strict}\&comma;\left(x\&comma;y\right)\mapsto x\left[1\right]<y\left[1\right]\right)\right)$

$\left[\left[1\&comma;1\right]\&comma;\left[1\&comma;2\right]\&comma;\left[1\&comma;3\right]\&comma;\left[2\&comma;1\right]\&comma;\left[2\&comma;2\right]\&comma;\left[2\&comma;3\right]\&comma;\left[3\&comma;1\right]\&comma;\left[3\&comma;2\right]\&comma;\left[3\&comma;3\right]\right]$

$\mathrm{sort}\left(\left[\left[1\&comma;1\right]\&comma;\left[2\&comma;1\right]\&comma;\left[3\&comma;1\right]\&comma;\left[1\&comma;2\right]\&comma;\left[2\&comma;2\right]\&comma;\left[3\&comma;2\right]\&comma;\left[1\&comma;3\right]\&comma;\left[2\&comma;3\right]\&comma;\left[3\&comma;3\right]\right]\&comma;'\mathrm{numeric}'\&comma;\mathrm{`=`}\left(\mathrm{key}\&comma;x\mapsto x\left[1\right]\right)\right)$

$\left[\left[1\&comma;1\right]\&comma;\left[1\&comma;2\right]\&comma;\left[1\&comma;3\right]\&comma;\left[2\&comma;1\right]\&comma;\left[2\&comma;2\right]\&comma;\left[2\&comma;3\right]\&comma;\left[3\&comma;1\right]\&comma;\left[3\&comma;2\right]\&comma;\left[3\&comma;3\right]\right]$

$\mathrm{myVec}≔⟨2\&comma;1\&comma;4⟩$

$\mathrm{myVec}≔\left[\begin{array}{c}2\\ 1\\ 4\end{array}\right]$

$\mathrm{sort}\left['\mathrm{inplace}'\right]\left(\mathrm{myVec}\right)$

$\left[\begin{array}{c}1\\ 2\\ 4\end{array}\right]$

$\mathrm{myVec}$

$\left[\begin{array}{c}1\\ 2\\ 4\end{array}\right]$

$\mathrm{myList}≔\left[2\&comma;1\&comma;4\right]$

$\mathrm{myList}≔\left[2\&comma;1\&comma;4\right]$

$\mathrm{sort}\left['\mathrm{inplace}'\right]\left(\mathrm{myList}\right)$

$\left[1\&comma;2\&comma;4\right]$

$\mathrm{myList}$

$\left[2\&comma;1\&comma;4\right]$

$L≔\left[''a''\&comma;''aaaaaaaa''\&comma;''b''\&comma;''bbbbbbbb''\&comma;a\&comma;\mathrm{aaaaaaaa}\&comma;b\&comma;\mathrm{bbbbbbbb}\right]$

$L≔\left[''a''\&comma;''aaaaaaaa''\&comma;''b''\&comma;''bbbbbbbb''\&comma;a\&comma;\mathrm{aaaaaaaa}\&comma;b\&comma;\mathrm{bbbbbbbb}\right]$

$\mathrm{seq}\left(\mathrm{sort}\left(L\&comma;\mathrm{setorder}\left[i\right]\right)\&comma;i=1..8\right)$

$\left[''a''\&comma;''b''\&comma;''aaaaaaaa''\&comma;''bbbbbbbb''\&comma;a\&comma;b\&comma;\mathrm{aaaaaaaa}\&comma;\mathrm{bbbbbbbb}\right],\left[''b''\&comma;''a''\&comma;''bbbbbbbb''\&comma;''aaaaaaaa''\&comma;b\&comma;a\&comma;\mathrm{bbbbbbbb}\&comma;\mathrm{aaaaaaaa}\right],\left[''aaaaaaaa''\&comma;''bbbbbbbb''\&comma;''a''\&comma;''b''\&comma;\mathrm{aaaaaaaa}\&comma;\mathrm{bbbbbbbb}\&comma;a\&comma;b\right],\left[''bbbbbbbb''\&comma;''aaaaaaaa''\&comma;''b''\&comma;''a''\&comma;\mathrm{bbbbbbbb}\&comma;\mathrm{aaaaaaaa}\&comma;b\&comma;a\right],\left[\mathrm{aaaaaaaa}\&comma;\mathrm{bbbbbbbb}\&comma;a\&comma;b\&comma;''aaaaaaaa''\&comma;''bbbbbbbb''\&comma;''a''\&comma;''b''\right],\left[\mathrm{bbbbbbbb}\&comma;\mathrm{aaaaaaaa}\&comma;b\&comma;a\&comma;''bbbbbbbb''\&comma;''aaaaaaaa''\&comma;''b''\&comma;''a''\right],\left[a\&comma;b\&comma;\mathrm{aaaaaaaa}\&comma;\mathrm{bbbbbbbb}\&comma;''a''\&comma;''b''\&comma;''aaaaaaaa''\&comma;''bbbbbbbb''\right],\left[b\&comma;a\&comma;\mathrm{bbbbbbbb}\&comma;\mathrm{aaaaaaaa}\&comma;''b''\&comma;''a''\&comma;''bbbbbbbb''\&comma;''aaaaaaaa''\right]$