IRanges (version 2.0.1)

AtomicList: Lists of Atomic Vectors in Natural and Rle Form

Description

An extension of List that holds only atomic vectors in either a natural or run-length encoded form.

Arguments

Constructors

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 = TRUE): Concatenates the run-length encoded atomic vectors in ... into a new RleList. If compress, the internal storage of the data is compressed.

Coercion

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.
as(from, "NormalIRangesList"), as(from, "CompressedNormalIRangesList"), as(from, "SimpleNormalIRangesList"): Creates a CompressedNormalIRangesList/SimpleNormalIRangesList instance from a LogicalList or logical RleList instance.
as(from, "CharacterList"), as(from, "ComplexList"), as(from, "IntegerList"), as(from, "LogicalList"), as(from, "NumericList"), as(from, "RawList"), as(from, "RleList"): Coerces an AtomicList from to another derivative of AtomicList.
as(from, "AtomicList"): If from is a vector, converts it to an AtomicList of the appropriate type.

Group Generics

AtomicList objects have support for S4 group generic functionality to operate within elements across objects:
Arith
"+", "-", "*", "^", "%%", "%/%", "/"
Compare
"==", ">", "<"< code="">, "!=", "<="< code="">, ">="
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"
See S4groupGeneric for more details.

Other Basic Methods

The AtomicList objects also support a large number of basic methods. Like the group generics above, these methods perform the corresponding operation on each element of the list separately. The methods are:
General
is.na, duplicated, unique, match, %in%, table, order, sort
Logical
!, which, which.max, which.min
Numeric
diff, pmax, pmax.int, pmin, pmin.int, mean, var, cov, cor, sd, median, quantile, mad, IQR
Running Window
smoothEnds, runmed. runmean, runsum, runwtsum, runq
Character
nchar, chartr, tolower, toupper, sub, gsub

RleList Methods

RleList has a number of methods that are not shared by other AtomicList derivatives.
runLength(x): Gets the run lengths of each element of the list, as an IntegerList.
runValue(x), runValue(x) <- value: Gets or sets the run values of each element of the list, as an AtomicList.
ranges(x): Gets the run ranges as a RangesList.

Specialized Methods

drop(x): Checks if every element of x is of length one, and, if so, unlists x. Otherwise, an error is thrown.
unstrsplit(x, sep="")
: A fast sapply(x, paste0, collapse=sep). See ?unstrsplit for the details.

Details

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.

See Also

List for the applicable methods.

Examples

Run this code
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)
col123 <- c(col1, col2, col3)
col123

## revElements
revElements(col123)
revElements(col123, 4:5)

## group generics
2 * col1
col1 + col1
col1 > 2
sum(col1)  # equivalent to (but faster than) 'sapply(col1, sum)'
mean(col1)  # equivalent to 'sapply(col1, mean)'

Run the code above in your browser using DataCamp Workspace