rawConversion | R Documentation |
Conversion to and from and manipulation of objects of type "raw"
,
both used as bits or “packed” 8 bits.
charToRaw(x) rawToChar(x, multiple = FALSE) rawShift(x, n) rawToBits(x) intToBits(x) packBits(x, type = c("raw", "integer", "double")) numToInts(x) numToBits(x)
x |
object to be converted or shifted. |
multiple |
logical: should the conversion be to a single character string or multiple individual characters? |
n |
the number of bits to shift. Positive numbers shift right
and negative numbers shift left: allowed values are |
type |
the result type, partially matched. |
packBits
accepts raw, integer or logical inputs, the last two
without any NAs.
numToBits(.)
and packBits(., type="double")
are
inverse functions of each other, see also the examples.
Note that ‘bytes’ are not necessarily the same as characters, e.g. in UTF-8 locales.
charToRaw
converts a length-one character string to raw bytes.
It does so without taking into account any declared encoding (see
Encoding
).
rawToChar
converts raw bytes either to a single character
string or a character vector of single bytes (with ""
for
0
). (Note that a single character string could contain
embedded nuls; only trailing nulls are allowed and will be removed.)
In either case it is possible to create a result which is invalid in a
multibyte locale, e.g. one using UTF-8. Long vectors are
allowed if multiple
is true.
rawShift(x, n)
shift the bits in x
by n
positions
to the right, see the argument n
, above.
rawToBits
returns a raw vector of 8 times the length of a raw
vector with entries 0 or 1. intToBits
returns a raw vector
of 32 times the length of an integer vector with entries 0 or 1.
(Non-integral numeric values are truncated to integers.) In
both cases the unpacking is least-significant bit first.
packBits
packs its input (using only the lowest bit for raw or
integer vectors) least-significant bit first to a raw, integer or double
(“numeric”) vector.
numToInts()
and
numToBits()
split double
precision numeric vectors
either into to two integer
s each or into 64 bits each,
stored as raw
. In both cases the unpacking is least-significant
element first.
x <- "A test string" (y <- charToRaw(x)) is.vector(y) # TRUE rawToChar(y) rawToChar(y, multiple = TRUE) (xx <- c(y, charToRaw("&"), charToRaw(" more"))) rawToChar(xx) rawShift(y, 1) rawShift(y,-2) rawToBits(y) showBits <- function(r) stats::symnum(as.logical(rawToBits(r))) z <- as.raw(5) z ; showBits(z) showBits(rawShift(z, 1)) # shift to right showBits(rawShift(z, 2)) showBits(z) showBits(rawShift(z, -1)) # shift to left showBits(rawShift(z, -2)) # .. showBits(rawShift(z, -3)) # shifted off entirely packBits(as.raw(0:31)) i <- -2:3 stopifnot(exprs = { identical(i, packBits(intToBits(i), "integer")) identical(packBits( 0:31) , packBits(as.raw(0:31))) }) str(pBi <- packBits(intToBits(i))) data.frame(B = matrix(pBi, nrow=6, byrow=TRUE), hex = format(as.hexmode(i)), i) ## Look at internal bit representation of ... ## ... of integers : bitI <- function(x) vapply(as.integer(x), function(x) { b <- substr(as.character(rev(intToBits(x))), 2L, 2L) paste0(c(b[1L], " ", b[2:32]), collapse = "") }, "") print(bitI(-8:8), width = 35, quote = FALSE) ## ... of double precision numbers in format 'sign exp | mantissa' ## where 1 bit sign 1 <==> "-"; ## 11 bit exp is the base-2 exponent biased by 2^10 - 1 (1023) ## 52 bit mantissa is without the implicit leading '1' # ## Bit representation [ sign | exponent | mantissa ] of double prec numbers : bitC <- function(x) noquote(vapply(as.double(x), function(x) { # split one double b <- substr(as.character(rev(numToBits(x))), 2L, 2L) paste0(c(b[1L], " ", b[2:12], " | ", b[13:64]), collapse = "") }, "")) bitC(17) bitC(c(-1,0,1)) bitC(2^(-2:5)) bitC(1+2^-(1:53))# from 0.5 converge to 1 ### numToBits(.) <==> intToBits(numToInts(.)) : d2bI <- function(x) vapply(as.double(x), function(x) intToBits(numToInts(x)), raw(64L)) d2b <- function(x) vapply(as.double(x), function(x) numToBits(x) , raw(64L)) set.seed(1) x <- c(sort(rt(2048, df=1.5)), 2^(-10:10), 1+2^-(1:53)) str(bx <- d2b(x)) # a 64 x 2122 raw matrix stopifnot( identical(bx, d2bI(x)) ) ## Show that packBits(*, "double") is the inverse of numToBits() : packBits(numToBits(pi), type="double") bitC(2050) b <- numToBits(2050) identical(b, numToBits(packBits(b, type="double"))) pbx <- apply(bx, 2, packBits, type="double") stopifnot( identical(pbx, x))
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.