R: Low-level intger64 methods for in-RAM sorting and ordering

ramsort.integer64 {bit64} | R Documentation

## Low-level intger64 methods for in-RAM sorting and ordering

### Description

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.

### Usage

    ## 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, ...)

### Arguments

`x` | a vector to be sorted by `ramsort` and `ramsortorder`, i.e. the output of `sort`
`i` | integer positions to be modified by `ramorder` and `ramsortorder`, default is 1:n, in this case the output is similar to `order`
`has.na` | boolean scalar defining whether the input vector might contain `NA`s. If we know we don't have NAs, this may speed-up. Note that you risk a crash if there are unexpected `NA`s with `has.na=FALSE`
`na.last` | boolean scalar telling ramsort whether to sort `NA`s last or first. Note that 'boolean' means that there is no third option `NA` as in `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 `quicksort` switches from recursing to `shellsort`
`radixbits` | size of radix in bits
`VERBOSE` | cat some info about chosen method
`...` | further arguments, passed from generics, ignored in methods

### Details

see `ramsort`

### Value

These functions return the number of `NAs` found or assumed during sorting

### Note

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`

### Author(s)

Jens Oehlschlägel <Jens.Oehlschlaegel@truecluster.com>

### See Also

`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

### Examples

      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.2 Index]