AtomicList {IRanges} | R Documentation |
An extension of Sequence
that holds
only atomic vectors in either a natural or run-length encoded form.
The lists of atomic vectors are LogicalList
, IntegerList
,
NumericList
, ComplexList
, CharacterList
, and
RawList
. There is also an RleList
class for
run-length encoded versions of these atomic vector types.
Each of the above mentioned classes is virtual with Compressed* and Simple* non-virtual representations.
LogicalList(..., compress = TRUE)
: Concatenates the
logical
vectors in ...
into a new LogicalList
.
If compress
, the internal storage of the data is compressed.IntegerList(..., compress = TRUE)
: Concatenates the
integer
vectors in ...
into a new IntegerList
.
If compress
, the internal storage of the data is compressed.NumericList(..., compress = TRUE)
: Concatenates the
numeric
vectors in ...
into a new NumericList
.
If compress
, the internal storage of the data is compressed.ComplexList(..., compress = TRUE)
: Concatenates the
complex
vectors in ...
into a new ComplexList
.
If compress
, the internal storage of the data is compressed.CharacterList(..., compress = TRUE)
: Concatenates the
character
vectors in ...
into a new CharacterList
.
If compress
, the internal storage of the data is compressed.RawList(..., compress = TRUE)
: Concatenates the
raw
vectors in ...
into a new RawList
.
If compress
, the internal storage of the data is compressed.RleList(..., compress = FALSE)
: Concatenates the
run-length encoded atomic vectors in ...
into a new
RleList
.
If compress
, the internal storage of the data is compressed.
as.vector(x)
, as(from, "vector")
: Creates a vector based
on the values contained in x
.
as.logical(x)
, as(from, "logical")
: Creates a logical
vector based on the values contained in x
.
as.integer(x)
, as(from, "integer")
: Creates an integer
vector based on the values contained in x
.
as.numeric(x)
, as(from, "numeric")
: Creates a numeric
vector based on the values contained in x
.
as.complex(x)
, as(from, "complex")
: Creates a complex
vector based on the values contained in x
.
as.character(x)
, as(from, "character")
: Creates a character
vector based on the values contained in x
.
as.raw(x)
, as(from, "raw")
: Creates a raw
vector based on the values contained in x
.
as.factor(x)
, as(from, "factor")
: Creates a factor object
based on the values contained in x
.
as.data.frame(x, row.names = NULL, optional = FALSE)
,
as(from, "data.frame")
: Creates a data.frame
object based
on the values contained in x
. Essentially the same as calling
data.frame(space=rep(names(x), elementLengths(x)), as.vector(x))
.
as(from, "CompressedSplitDataFrameList")
,
as(from, "SimpleSplitDataFrameList")
: Creates a
CompressedSplitDataFrameList/SimpleSplitDataFrameList
instance from an AtomicList instance.
as(from, "IRangesList")
, as(from, "CompressedIRangesList")
,
as(from, "SimpleIRangesList")
: Creates a
CompressedIRangesList/SimpleIRangesList
instance from a LogicalList or logical RleList instance. Note that the
elements of this instance are guaranteed to be normal.
AtomicList objects have support for S4 group generic functionality to operate within elements across objects:
Arith
"+"
, "-"
, "*"
, "^"
,
"%%"
, "%/%"
, "/"
Compare
"=="
, ">"
, "<"
, "!="
,
"<="
, ">="
Logic
"&"
, "|"
Ops
"Arith"
, "Compare"
, "Logic"
Math
"abs"
, "sign"
, "sqrt"
,
"ceiling"
, "floor"
, "trunc"
, "cummax"
,
"cummin"
, "cumprod"
, "cumsum"
, "log"
,
"log10"
, "log2"
, "log1p"
, "acos"
,
"acosh"
, "asin"
, "asinh"
, "atan"
,
"atanh"
, "exp"
, "expm1"
, "cos"
,
"cosh"
, "sin"
, "sinh"
, "tan"
, "tanh"
,
"gamma"
, "lgamma"
, "digamma"
, "trigamma"
Math2
"round"
, "signif"
Summary
"max"
, "min"
, "range"
,
"prod"
, "sum"
, "any"
, "all"
Complex
"Arg"
, "Conj"
, "Im"
,
"Mod"
, "Re"
RleList objects have support for the following fixed width running window summary methods:
runmean(x, k, endrule = c("drop", "constant"))
:
Calculates the means for fixed width running windows across x
.
x
k
endrule == "constant"
."drop"
"constant"
runmed(x, k, endrule = c("median", "keep", "constant"))
:
Calculates the medians for fixed width running windows across x
.
x
k
endrule != "drop"
."drop"
"keep"
k2 = k %/% 2
, i.e., y[[i]][j] = x[[i]][j]
for
j \in \{1,\ldots,k_2; n-k_2+1,\ldots,n\}
j = 1,..,k2 and (n-k2+1),..,n;"constant"
"median"
smoothEnds
.runsum(x, k, endrule = c("drop", "constant"))
:
Calculates the sums for fixed width running windows across x
.
x
k
endrule == "constant"
."drop"
"constant"
runwtsum(x, k, wt, endrule = c("drop", "constant"))
:
Calculates the sums for fixed width running windows across x
.
x
k
endrule == "constant"
.wt
k
that
provides the weights to use."drop"
"constant"
runq(x, k, i, endrule = c("drop", "constant"))
:
Calculates the order statistic for fixed width running windows across
x
.
x
k
endrule == "constant"
.i
"drop"
"constant"
P. Aboyoun
Sequence
for the applicable methods.
int1 <- c(1L,2L,3L,5L,2L,8L) int2 <- c(15L,45L,20L,1L,15L,100L,80L,5L) collection <- IntegerList(int1, int2) ## names names(collection) <- c("one", "two") names(collection) names(collection) <- NULL # clear names names(collection) names(collection) <- "one" names(collection) # c("one", NA) ## extraction collection[[1]] # range1 collection[["1"]] # NULL, does not exist collection[["one"]] # range1 collection[[NA_integer_]] # NULL ## subsetting collection[numeric()] # empty collection[NULL] # empty collection[] # identity collection[c(TRUE, FALSE)] # first element collection[2] # second element collection[c(2,1)] # reversed collection[-1] # drop first collection$one ## replacement collection$one <- int2 collection[[2]] <- int1 ## combining col1 <- IntegerList(one = int1, int2) col2 <- IntegerList(two = int2, one = int1) col3 <- IntegerList(int2) append(col1, col2) append(col1, col2, 0) c(col1, col2, col3) ## group generics 2 * col1 col1 + col1 col1 > 2 log(col1) sum(col1) ## get the mean for each element sapply(col1, mean)