rle function from the base package.
Rle(values):
This constructor creates an Rle instances out of an atomic
vector values.
Rle(values, lengths):
This constructor creates an Rle instances out of an atomic
vector or factor object values and an integer or numeric vector
lengths with all positive elements that represent how many times
each value is repeated. The length of these two vectors must be the same.
as(from, "Rle"):
This constructor creates an Rle instances out of an atomic
vector from.
x is an Rle object: runLength(x):
Returns the run lengths for x.
runValue(x):
Returns the run values for x.
nrun(x):
Returns the number of runs in x.
start(x):
Returns the starts of the runs for x.
end(x):
Returns the ends of the runs for x.
width(x):
Same as runLength(x).
x is an Rle object: runLength(x) <- value:
Replaces x with a new Rle object using run values
runValue(x) and run lengths value.
runValue(x) <- value:
Replaces x with a new Rle object using run values
value and run lengths runLength(x).
x and from are Rle objects: as.vector(x, mode="any"), as(from, "vector"):
Creates an atomic vector based on the values contained in
x. The vector will be coerced to the requested mode,
unless mode is "any", in which case the most appropriate
type is chosen.
as.vectorORfactor(x): Creates an atomic vector or factor,
based on the type of values contained in x. This is the
most general way to decompress the Rle to a native R data
structure.
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), as(from, "data.frame"): Creates
a data.frame with a single column holding the result of
as.vector(x).
x is an Rle object: x[i, drop=getOption("dropRle", default=FALSE)]:
Subsets x by index i, where i can be positive
integers, negative integers, a logical vector of the same length as
x, an Rle object of the same length as x
containing logical values, or an IRanges object.
When drop=FALSE returns an Rle object. When drop=TRUE,
returns an atomic vector.
x[i] <- value:
Replaces elements in x specified by i with corresponding
elements in value. Supports the same types for i as
x[i].
x %in% table:
Returns a logical Rle representing set membership in
table.
append(x, values, after = length(x)):
Insert one Rle into another Rle.
valuesafterx after which the values
are to be inserted.c(x, ...):
Combines a set of Rle objects.
findRun(x, vec):
Returns an integer vector indicating the run indices in Rle vec
that are referenced by the indices in the integer vector x.
head(x, n = 6L):
If n is non-negative, returns the first n elements of x.
If n is negative, returns all but the last abs(n) elements
of x.
is.na(x):
Returns a logical Rle indicating with values are NA.
is.unsorted(x, na.rm = FALSE, strictly = FALSE):
Returns a logical value specifying if x is unsorted.
na.rmstrictlylength(x):
Returns the underlying vector length of x.
match(x, table, nomatch = NA_integer_, incomparables = NULL):
Matches the values in x to table:
tablenomatchincomparablesx matching a value in this vector is assigned
the nomatch value.rep(x, times, length.out, each), rep.int(x, times):
Repeats the values in x through one of the following conventions:
timeslength(x), or to repeat the whole vector
if of length 1.length.outeachx is
repeated each times.rev(x):
Reverses the order of the values in x.
shiftApply(SHIFT, X, Y, FUN, ..., OFFSET = 0L, simplify = TRUE, verbose = FALSE):
Let i be the indices in SHIFT,
X_i = window(X, 1 + OFFSET, length(X) - SHIFT[i]), and
Y_i = window(Y, 1 + SHIFT[i], length(Y) - OFFSET). Calculates
the set of FUN(X_i, Y_i, ...) values and return the results in a
convenient form:
SHIFTX, YFUNmatch.fun, to be
applied to each set of shifted vectors.FUN.simplifyverbosei indices to track the iterations.show(object):
Prints out the Rle object in a user-friendly way.
order(..., na.last = TRUE, decreasing = FALSE):
Returns a permutation which rearranges its first argument
into ascending or descending order, breaking ties by further
arguments. See order.
sort(x, decreasing = FALSE, na.last = NA):
Sorts the values in x.
decreasingTRUE, sort values in decreasing
order. If FALSE, sort values in increasing order.na.lastTRUE, missing values are placed last.
If FALSE, they are placed first. If NA, they are
removed.subset(x, subset):
Returns a new Rle object made of the subset using logical vector
subset.
table(...):
Returns a table containing the counts of the unique values. Supported
arguments include useNA with values of `no' and `ifany'.
Multiple Rle's must be combined with c() before calling table.
tail(x, n = 6L):
If n is non-negative, returns the last n elements of x.
If n is negative, returns all but the first abs(n) elements
of x.
unique(x, incomparables = FALSE, ...):
Returns the unique run values. The incomparables argument takes a
vector of values that cannot be compared with FALSE being a special
value that means that all values can be compared.
x and y are Rle object or
some other vector-like object:
setdiff(x, y): Returns the unique elements in
x that are not in y.
union(x, y):
Returns the unique elements in either x or y.
intersect(x, y):
Returns the unique elements in both x and y.
x <- Rle(10:1, 1:10)
x
runLength(x)
runValue(x)
nrun(x)
diff(x)
unique(x)
sort(x)
x[c(1,3,5,7,9)]
x > 4
x2 <- Rle(LETTERS[c(21:26, 25:26)], 8:1)
table(x2)
y <- Rle(c(TRUE,TRUE,FALSE,FALSE,TRUE,FALSE,TRUE,TRUE,TRUE))
y
as.vector(y)
rep(y, 10)
c(y, x > 5)
Run the code above in your browser using DataLab