R: Sequence Generation

seq {base} | R Documentation

## Sequence Generation

### Description

Generate regular sequences. `seq` is a standard generic with a default method. `seq.int` is an internal generic which can be much faster but has a few restrictions. `seq_along` and `seq_len` are very fast primitives for two common cases.

### Usage

    seq(...)

    ## Default S3 method:
    seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)),
        length.out = NULL, along.with = NULL, ...)

    seq.int(from, to, by, length.out, along.with, ...)

    seq_along(along.with)
    seq_len(length.out)

### Arguments

`...` | arguments passed to or from methods.
`from, to` | the starting and (maximal) end value of the sequence.
`by` | number: increment of the sequence.
`length.out` | desired length of the sequence. A non-negative number, which for `seq` and `seq.int` will be rounded up if fractional.
`along.with` | take the length from the length of this argument.

### Details

The interpretation of the unnamed arguments of `seq` and `seq.int` is not standard, and it is recommended always to name the arguments when programming.

Both `seq` are `seq.int` are generic, and only the default method is described here. Typical usages are

    seq(from, to)
    seq(from, to, by= )
    seq(from, to, length.out= )
    seq(along.with= )
    seq(from)
    seq(length.out= )

The first form generates the sequence `from, from+/-1, ..., to` (identical to `from:to`).

The second form generates `from, from+by`, ..., up to the sequence value less than or equal to `to`. Specifying `to - from` and `by` of opposite signs is an error. Note that the final value can go just beyond `to` to allow for rounding error.

The third generates a sequence of `length.out` equally spaced values from `from` to `to`. (`length.out` is usually abbreviated to `length` or `len`, and `seq_len` is much faster.)

The fourth form generates the sequence `1, 2, ..., length(along.with)`. (`along.with` is usually abbreviated to `along`, and `seq_along` is much faster.)

The fifth form generates the sequence `1, 2, ..., length(from)` (as if argument `along.with` had been specified), unless the argument is numeric of length 1 when it is interpreted as `1:from` (even for `seq(0)` for compatibility with S).

The final form generates `1, 2, ..., length.out` unless `length.out = 0`, when it generates `integer(0)`.

Very small sequences (with `from - to` of the order of 10^{-14} times the larger of the ends) will return `from`.

For `seq`(only), up to two of `from`, `to` and `by` can be supplied as complex values provided `length.out` or `along.with` is specified.

### Value

Currently, the default method returns a result of type `"integer"` if `from` is (numerically equal to an) integer and, e.g., only `to` is specified, or also if only `length` or only `along.with` is specified. Note: this may change in the future and programmers should not rely on it.

### References

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language. Wadsworth & Brooks/Cole.

### See Also

The methods `seq.Date` and `seq.POSIXt`.

`:`, `rep`, `sequence`, `row`, `col`.

### Examples

    seq(0, 1, length.out=11)
    seq(stats::rnorm(20))
    seq(1, 9, by = 2) # match
    seq(1, 9, by = pi)# stay below
    seq(1, 6, by = 3)
    seq(1.575, 5.125, by=0.05)
    seq(17) # same as 1:17

[Package base version 2.8.1 Index]