ramsort.integer64 {bit64} | R Documentation |

Fast low-level methods for sorting and ordering.
The `..sortorder`

methods do sorting and ordering at once, which requires more RAM than ordering but is (almost) as fast as as sorting.

```
## S3 method for class 'integer64'
shellsort(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
## S3 method for class 'integer64'
shellsortorder(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
## S3 method for class 'integer64'
shellorder(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
## S3 method for class 'integer64'
mergesort(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
## S3 method for class 'integer64'
mergeorder(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
## S3 method for class 'integer64'
mergesortorder(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
## S3 method for class 'integer64'
quicksort(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE
, restlevel=floor(1.5*log2(length(x))), ...)
## S3 method for class 'integer64'
quicksortorder(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE
, restlevel=floor(1.5*log2(length(x))), ...)
## S3 method for class 'integer64'
quickorder(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE
, restlevel=floor(1.5*log2(length(x))), ...)
## S3 method for class 'integer64'
radixsort(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, ...)
## S3 method for class 'integer64'
radixsortorder(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, ...)
## S3 method for class 'integer64'
radixorder(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, ...)
## S3 method for class 'integer64'
ramsort(x, has.na = TRUE, na.last=FALSE, decreasing = FALSE, stable = TRUE
, optimize = c("time", "memory"), VERBOSE = FALSE, ...)
## S3 method for class 'integer64'
ramsortorder(x, i, has.na = TRUE, na.last=FALSE, decreasing = FALSE, stable = TRUE
, optimize = c("time", "memory"), VERBOSE = FALSE, ...)
## S3 method for class 'integer64'
ramorder(x, i, has.na = TRUE, na.last=FALSE, decreasing = FALSE, stable = TRUE
, optimize = c("time", "memory"), VERBOSE = FALSE, ...)
```

`x` |
a vector to be sorted by |

`i` |
integer positions to be modified by |

`has.na` |
boolean scalar defining whether the input vector might contain |

`na.last` |
boolean scalar telling ramsort whether to sort |

`decreasing` |
boolean scalar telling ramsort whether to sort increasing or decreasing |

`stable` |
boolean scalar defining whether stable sorting is needed. Allowing non-stable may speed-up. |

`optimize` |
by default ramsort optimizes for 'time' which requires more RAM, set to 'memory' to minimize RAM requirements and sacrifice speed |

`restlevel` |
number of remaining recursionlevels before |

`radixbits` |
size of radix in bits |

`VERBOSE` |
cat some info about chosen method |

`...` |
further arguments, passed from generics, ignored in methods |

see `ramsort`

These functions return the number of `NAs`

found or assumed during sorting

Note that these methods purposely violate the functional programming paradigm: they are called for the side-effect of changing some of their arguments.
The `sort`

-methods change `x`

, the `order`

-methods change `i`

, and the `sortoder`

-methods change both `x`

and `i`

Jens OehlschlĂ¤gel <Jens.Oehlschlaegel@truecluster.com>

`ramsort`

for the generic, `ramsort.default`

for the methods provided by package `ff`

, `sort.integer64`

for the sort interface and `sortcache`

for caching the work of sorting

```
x <- as.integer64(sample(c(rep(NA, 9), 1:9), 32, TRUE))
x
message("ramsort example")
s <- clone(x)
ramsort(s)
message("s has been changed in-place - whether or not ramsort uses an in-place algorithm")
s
message("ramorder example")
s <- clone(x)
o <- seq_along(s)
ramorder(s, o)
message("o has been changed in-place - s remains unchanged")
s
o
s[o]
message("ramsortorder example")
o <- seq_along(s)
ramsortorder(s, o)
message("s and o have both been changed in-place - this is much faster")
s
o
```

[Package *bit64* version 4.0.5 Index]