Rle-class

Rle objects

The Rle class is a general container for storing an atomic vector that is stored in a run-length encoding format. It is based on the rle function from the base package.

Keywords
classes, methods
Constructor

Rle(values, lengths): This constructor creates an Rle instance 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. lengths can be missing in which case values is turned into an Rle.

Getters

In the code snippets below, 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).

Setters

In the code snippets below, 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).

Coercion

From atomic vector to Rle In the code snippets below, from is an atomic vector:

as(from, "Rle"): This coercion creates an Rle instances out of an atomic vector from.
From Rle to other objects In the code snippets below, 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.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).

General Methods

In the code snippets below, 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.
values
the Rle to insert.
after
the subscript in x 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.rm
remove missing values from check.
strictly
check for _strictly_ increasing values.
length(x): Returns the underlying vector length of x.
match(x, table, nomatch = NA_integer_, incomparables = NULL): Matches the values in x to table:
table
the values to be matched against.
nomatch
the value to be returned in the case when no match is found.
incomparables
a vector of values that cannot be matched. Any value in x 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:
times
Vector giving the number of times to repeat each element if of length length(x), or to repeat the whole vector if of length 1.
length.out
Non-negative integer. The desired length of the output vector.
each
Non-negative integer. Each element of x is repeated each times.
rev(x): Reverses the order of the values in x.
show(object): Prints out the Rle object in a user-friendly way.
order(..., na.last = TRUE, decreasing = FALSE, method = c("shell", "radix")): 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.
decreasing
If TRUE, sort values in decreasing order. If FALSE, sort values in increasing order.
na.last
If TRUE, 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.

Set Operations

In the code snippets below, 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.

See Also

Rle-utils, Rle-runstat, and aggregate for more operations on Rle objects.

rle

Vector-class

Aliases
  • class:Rle
  • Rle-class
  • Rle
  • Rle,ANY-method
  • Rle,Rle-method
  • length,Rle-method
  • runLength
  • runLength,Rle-method
  • runValue
  • runValue,Rle-method
  • nrun
  • nrun,Rle-method
  • start,Rle-method
  • end,Rle-method
  • width,Rle-method
  • runLength<-
  • runLength<-,Rle-method
  • runValue<-
  • runValue<-,Rle-method
  • as.vector,Rle-method
  • as.vectorORfactor
  • as.vectorORfactor,Rle-method
  • as.factor,Rle-method
  • as.data.frame,Rle-method
  • as.list,Rle-method
  • coerce,Rle,list-method
  • coerce,vector,Rle-method
  • coerce,logical,Rle-method
  • coerce,integer,Rle-method
  • coerce,numeric,Rle-method
  • coerce,complex,Rle-method
  • coerce,character,Rle-method
  • coerce,raw,Rle-method
  • coerce,factor,Rle-method
  • coerce,Rle,vector-method
  • coerce,Rle,logical-method
  • coerce,Rle,integer-method
  • coerce,Rle,numeric-method
  • coerce,Rle,complex-method
  • coerce,Rle,character-method
  • coerce,Rle,raw-method
  • coerce,Rle,factor-method
  • coerce,Rle,data.frame-method
  • extractROWS,Rle,ANY-method
  • [,Rle-method
  • [<-,Rle-method
  • extractROWS,Rle,RangeNSBS-method
  • rev.Rle
  • rev,Rle-method
  • rep.int,Rle-method
  • rep,Rle-method
  • c,Rle-method
  • append,Rle,vector-method
  • append,vector,Rle-method
  • %in%,Rle,ANY-method
  • findRun
  • findRun,Rle-method
  • is.na,Rle-method
  • is.unsorted,Rle-method
  • match,Rle,ANY-method
  • show,Rle-method
  • showAsCell,Rle-method
  • order,Rle-method
  • sort,Rle-method
  • table,Rle-method
  • unique,Rle-method
  • duplicated,Rle-method
  • setdiff,Rle,Rle-method
  • setdiff,ANY,Rle-method
  • setdiff,Rle,ANY-method
  • intersect,Rle,Rle-method
  • intersect,ANY,Rle-method
  • intersect,Rle,ANY-method
  • union,Rle,Rle-method
  • union,ANY,Rle-method
  • union,Rle,ANY-method
Examples
  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)
Documentation reproduced from package S4Vectors, version 0.10.2, License: Artistic-2.0

Community examples

Looks like there are no examples yet.