Description Usage Arguments Inmemory versus ondisk realization Accessors Subsetting See Also Examples
Wrapping an arraylike object (typically an ondisk object) in a DelayedArray object allows one to perform common array operations on it without loading the object in memory. In order to reduce memory usage and optimize performance, operations on the object are either delayed or executed using a block processing mechanism.
1 2 3 4 5 
seed 
An arraylike object. 
x, object 
A DelayedArray object. For 
... 
Additional arguments passed to methods. 
To realize a DelayedArray object (i.e. to trigger execution of the
delayed operations carried by the object and return the result as an
ordinary array), call as.array
on it. However this realizes the
full object at once in memory which could require too much memory
if the object is big. A big DelayedArray object is preferrably realized
on disk e.g. by calling writeHDF5Array
on
it (this function is defined in the HDF5Array package) or coercing it
to an HDF5Array object with as(x, "HDF5Array")
.
Other ondisk backends can be supported. This uses a block processing
strategy so that the full object is not realized at once in memory. Instead
the object is processed block by block i.e. the blocks are realized in
memory and written to disk one at a time.
See ?writeHDF5Array
in the HDF5Array package
for more information about this.
DelayedArray objects support the same set of getters as ordinary arrays
i.e. dim()
, length()
, and dimnames()
.
In addition, they support seed()
, nseed()
, path()
,
and type()
.
type()
is the DelayedArray equivalent of typeof()
(or
storage.mode()
) for ordinary arrays and vectors. Note that, for
convenience and consistency, type()
also supports ordinary arrays
and vectors. It also supports any arraylike object, that is, any object
x
for which dim(x)
is not NULL.
dimnames()
, seed()
, and path()
also work as setters.
A DelayedArray object can be subsetted with [
like an ordinary array,
but with the following differences:
Multidimensional single bracket subsetting (i.e. subsetting
of the form x[i_1, i_2, ..., i_n]
with one (possibly missing)
subscript per dimension) returns a DelayedArray object where the
subsetting is actually delayed. So it's a very light operation.
One notable exception to this is when drop=TRUE
and the
result has only one dimension, in which case it is returned as an
ordinary vector (atomic or list).
Note that NAs in the subscripts are not supported.
Linear single bracket subsetting (a.k.a. 1Dstyle subsetting,
that is, subsetting of the form x[i]
) only works if the
subscript i
is a numeric vector at the moment. Furthermore,
i
cannot contain NAs and all the indices in it must be >= 1
and <= length(x)
for now. It returns an atomic vector of the
same length as i
. This is NOT a delayed operation (block
processing is triggered).
Subsetting with [[
is supported but only the linear form
of it at the moment i.e. the x[[i]]
form where i
is a
single numeric value >= 1 and <= length(x)
. It is equivalent
to x[i][[1]]
.
Subassignment to a DelayedArray object with [<
is also supported
like with an ordinary array, but with the following restrictions:
Multidimensional subassignment (i.e. subassignment of the
form x[i_1, i_2, ..., i_n] < value
with one (possibly
missing) subscript per dimension) only accepts a replacement
value (a.k.a. right value) that is an arraylike object (e.g.
ordinary array, dgCMatrix object, DelayedArray object, etc...)
or an ordinary vector (atomic or list) of length 1.
Linear subassignment (a.k.a. 1Dstyle subassignment, that
is, subassignment of the form x[i] < value
) only works if
the subscript i
is a logical DelayedArray object of the same
dimensions as x
and if the replacement value is an ordinary
vector (atomic or list) of length 1.
Filling with a vector, that is, subassignment of the form
x[] < v
where v
is an ordinary vector (atomic or
list), is only supported if the length of the vector is a divisor
of nrow(x)
.
These 3 forms of subassignment are implemented as delayed operations so are very light.
Single value replacement (x[[...]] < value
) is not supported yet.
realize
for realizing a DelayedArray object in memory
or on disk.
block_processing for more information about block processing of an arraylike object.
DelayedArrayutils for common operations on DelayedArray objects.
DelayedArraystats for statistical functions on DelayedArray objects.
DelayedMatrixstats for DelayedMatrix row/col summarization.
RleArray objects.
HDF5Array objects in the HDF5Array package.
DataFrame objects in the S4Vectors package.
array objects in base R.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193  ## 
## A. WRAP AN ORDINARY ARRAY IN A DelayedArray OBJECT
## 
a < array(runif(1500000), dim=c(10000, 30, 5))
A < DelayedArray(a)
A
## The seed of a DelayedArray object is **always** treated as a
## "readonly" object so will never be modified by the operations
## we perform on A:
stopifnot(identical(a, seed(A)))
type(A)
## Multidimensional single bracket subsetting:
m < a[11:20 , 5, 3] # an ordinary matrix
M < A[11:20 , 5, 3] # a DelayedMatrix object
stopifnot(identical(m, as.array(M)))
## Linear single bracket subsetting:
A[11:20]
A[A <= 1e5]
stopifnot(identical(a[a <= 1e5], A[A <= 1e5]))
## Subassignment:
A[A < 0.2] < NA
a[a < 0.2] < NA
stopifnot(identical(a, as.array(A)))
A[2:5, 1:2, ] < array(1:40, c(4, 2, 5))
a[2:5, 1:2, ] < array(1:40, c(4, 2, 5))
stopifnot(identical(a, as.array(A)))
## Other operations:
crazy < function(x) (5 * x[ , , 1] ^ 3 + 1L) * log(x[, , 2])
b < crazy(a)
head(b)
B < crazy(A) # very fast! (all operations are delayed)
B
cs < colSums(b)
CS < colSums(B)
stopifnot(identical(cs, CS))
## 
## B. WRAP A DataFrame OBJECT IN A DelayedArray OBJECT
## 
## Generate random coverage and score along an imaginary chromosome:
cov < Rle(sample(20, 5000, replace=TRUE), sample(6, 5000, replace=TRUE))
score < Rle(sample(100, nrun(cov), replace=TRUE), runLength(cov))
DF < DataFrame(cov, score)
A2 < DelayedArray(DF)
A2
seed(A2) # 'DF'
## Coercion of a DelayedMatrix object to DataFrame produces a DataFrame
## object with Rle columns:
as(A2, "DataFrame")
stopifnot(identical(DF, as(A2, "DataFrame")))
t(A2) # transposition is delayed so is very fast and memoryefficient
colSums(A2)
## 
## C. AN HDF5Array OBJECT IS A (PARTICULAR KIND OF) DelayedArray OBJECT
## 
library(HDF5Array)
A3 < as(a, "HDF5Array") # write 'a' to an HDF5 file
A3
is(A3, "DelayedArray") # TRUE
seed(A3) # an HDF5ArraySeed object
B3 < crazy(A3) # very fast! (all operations are delayed)
B3 # not an HDF5Array object anymore because
# now it carries delayed operations
CS3 < colSums(B3)
stopifnot(identical(cs, CS3))
## 
## D. PERFORM THE DELAYED OPERATIONS
## 
as(B3, "HDF5Array") # "realize" 'B3' on disk
## If this is just an intermediate result, you can either keep going
## with B3 or replace it with its "realized" version:
B3 < as(B3, "HDF5Array") # no more delayed operations on new 'B3'
seed(B3)
path(B3)
## For convenience, realize() can be used instead of explicit coercion.
## The current "realization backend" controls where realization
## happens e.g. in memory if set to NULL or in an HDF5 file if set
## to "HDF5Array":
D < cbind(B3, exp(B3))
D
setRealizationBackend("HDF5Array")
D < realize(D)
D
## See '?realize' for more information about "realization backends".
## 
## E. MODIFY THE PATH OF A DelayedArray OBJECT
## 
## This can be useful if the file containing the array data is on a
## shared partition but the exact path to the partition depends on the
## machine from which the data is being accessed.
## For example:
## Not run:
library(HDF5Array)
A < HDF5Array("/path/to/lab_data/my_precious_data.h5")
path(A)
## Operate on A...
## Now A carries delayed operations.
## Make sure path(A) still works:
path(A)
## Save A:
save(A, file="A.rda")
## A.rda should be small (it doesn't contain the array data).
## Send it to a coworker that has access to my_precious_data.h5.
## Coworker loads it:
load("A.rda")
path(A)
## A is broken because path(A) is incorrect for coworker:
A # error!
## Coworker fixes the path (in this case this is better done using the
## dirname() setter rather than the path() setter):
dirname(A) < "E:/other/path/to/lab_data"
## A "works" again:
A
## End(Not run)
## 
## F. WRAP A SPARSE MATRIX IN A DelayedArray OBJECT
## 
## Not run:
library(Matrix)
M < 75000L
N < 1800L
p < sparseMatrix(sample(M, 9000000, replace=TRUE),
sample(N, 9000000, replace=TRUE),
x=runif(9000000), dims=c(M, N))
P < DelayedArray(p)
P
p2 < as(P, "sparseMatrix")
stopifnot(identical(p, p2))
## The following is based on the following post by Murat Tasan on the
## Rhelp mailing list:
## https://stat.ethz.ch/pipermail/rhelp/2017May/446702.html
## As pointed out by Murat, the straightforward row normalization
## directly on sparse matrix 'p' would consume too much memory:
row_normalized_p < p / rowSums(p^2) # consumes too much memory
## because the rowSums() result is being recycled (appropriately) into a
## *dense* matrix with dimensions equal to dim(p).
## Murat came up with the following solution that is very fast and
## memoryefficient:
row_normalized_p1 < Diagonal(x=1/sqrt(Matrix::rowSums(p^2)))
## With a DelayedArray object, the straightforward approach uses a
## block processing strategy behind the scene so it doesn't consume
## too much memory.
## First, let's see the block processing in action:
DelayedArray:::set_verbose_block_processing(TRUE)
## and check the automatic block size:
getAutoBlockSize()
row_normalized_P < P / sqrt(DelayedArray::rowSums(P^2))
## Increasing the block size increases the speed but also memory usage:
setAutoBlockSize(2e8)
row_normalized_P2 < P / sqrt(DelayedArray::rowSums(P^2))
stopifnot(all.equal(row_normalized_P, row_normalized_P2))
## Back to sparse representation:
DelayedArray:::set_verbose_block_processing(FALSE)
row_normalized_p2 < as(row_normalized_P, "sparseMatrix")
stopifnot(all.equal(row_normalized_p1, row_normalized_p2))
setAutoBlockSize()
## End(Not run)

Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.