bitmapped vectors of booleans (no NAs), coercion from and
to logicals, integers and integer subscripts; fast boolean
operators and fast summary statistics. With 'bit' vectors you
can store true binary booleans {FALSE,TRUE} at the expense of 1
bit only, on a 32 bit architecture this means factor 32 less
RAM and factor 32 more speed on boolean operations. With this
speed gain it even pays-off to convert to bit in order to avoid
a single boolean operation on logicals or a single set
operation on (longer) integer subscripts, the pay-off is
dramatic when such components are used more than once. Reading
from and writing to bit is approximately as fast as accessing
standard logicals - mostly due to R's time for memory
allocation. The package allows to work with pre-allocated
memory for return values by calling .Call() directly: when
evaluating the speed of C-access with pre-allocated vector
memory, coping from bit to logical requires only 70% of the
time for copying from logical to logical; and copying from
logical to bit comes at a performance penalty of 150%. the
package now contains further classes for representing logical
selections: 'bitwhich' for very skewed selections and 'ri' for
selecting ranges of values for chunked processing. All three
index classes can be used for subsetting 'ff' objects (ff-2.1.0
and higher).
2009-07-23 20:00:38 UTC; Jens Oehlschlaegel

Classes and Methods for Fast Memory-Efficient Boolean Selections
Jens Oehlschlägel [aut, cre], Brian Ripley [ctb]
testthat (>= 0.11.0), roxygen2, knitr, rmarkdown,
microbenchmark, bit64 (>= 4.0.0), ff (>= 4.0.0)
Provided are classes for boolean and skewed boolean vectors,
fast boolean methods, fast unique and non-unique integer sorting,
fast set operations on sorted and unsorted sets of integers, and
foundations for ff (range index, compression, chunked processing).

A S3 class for vectors of 64bit integers
Package 'bit64' provides serializable S3 atomic 64bit
(signed) integers that can be used in vectors, matrices, arrays
and data.frames. Methods are available for coercion from and to
logicals, integers, doubles, characters as well as many
elementwise and summary functions.  With 'integer64' vectors
you can store very large integers at the expense of 64 bits,
which is by factor 7 better than 'int64' from package 'int64'.
Due to the smaller memory footprint, the atomic vector
architecture and using only S3 instead of S4 classes, most
operations are one to three orders of magnitude faster: Example
speedups are 4x for serialization, 250x for adding, 900x for
coercion and 2000x for object creation. Also 'integer64' avoids
an ongoing (potentially infinite) penalty for garbage
collection observed during existence of 'int64' objects (see
code in example section).  Last but not least, this package has
no commercial copyright attached, it is not sponsored by any
commercial company or otherwise influenced by commercial
interests. Its mix of high-level R code with low-level C-code
protects against misuse outside the GPLed R context.