These are generic stubs for low-level sorting and ordering methods implemented in packages
'bit64' and 'ff'.
The ..sortorder
methods do sorting and ordering at once, which requires more RAM than ordering but is (almost) as fast as as sorting.
ramsort(x, …)
ramorder(x, i, …)
ramsortorder(x, i, …)
mergesort(x, …)
mergeorder(x, i, …)
mergesortorder(x, i, …)
quicksort(x, …)
quickorder(x, i, …)
quicksortorder(x, i, …)
shellsort(x, …)
shellorder(x, i, …)
shellsortorder(x, i, …)
radixsort(x, …)
radixorder(x, i, …)
radixsortorder(x, i, …)
keysort(x, …)
keyorder(x, i, …)
keysortorder(x, i, …)
a vector to be sorted by ramsort
and ramsortorder
, i.e. the output of sort
integer positions to be modified by ramorder
and ramsortorder
, default is 1:n, in this case the output is similar to order
further arguments to the sorting methods
These functions return the number of NAs
found or assumed during sorting
generic | ff | bit64 |
ramsort |
ramsort.default |
ramsort.integer64 |
shellsort |
shellsort.default |
shellsort.integer64 |
quicksort |
quicksort.integer64 |
|
mergesort |
mergesort.default |
mergesort.integer64 |
radixsort |
radixsort.default |
radixsort.integer64 |
keysort |
keysort.default |
|
generic | ff | |
bit64 |
ramorder |
ramorder.default |
ramorder.integer64 |
shellorder |
shellorder.default |
shellorder.integer64 |
quickorder |
|
quickorder.integer64 |
mergeorder |
mergeorder.default |
mergeorder.integer64 |
radixorder |
radixorder.default |
radixorder.integer64 |
keyorder |
keyorder.default |
generic | ||
ff | bit64 |
ramsortorder |
ramsortorder.integer64 |
shellsortorder |
|
shellsortorder.integer64 |
quicksortorder |
|
quicksortorder.integer64 |
mergesortorder |
|
mergesortorder.integer64 |
radixsortorder |
|
radixsortorder.integer64 |
keysortorder |
|
generic |
The sort
generics do sort their argument 'x', some methods need temporary RAM of the same size as 'x'.
The order
generics do order their argument 'i' leaving 'x' as it was,
some methods need temporary RAM of the same size as 'i'.
The sortorder
generics do sort their argument 'x' and order their argument 'i',
this way of ordering is much faster at the price of requiring temporary RAM for both,
'x' and 'i', if the method requires temporary RAM.
The ram
generics are high-level functions containing an optimizer that chooses the 'best' algorithms given some context.