seq                   package:base                   R Documentation

_S_e_q_u_e_n_c_e _G_e_n_e_r_a_t_i_o_n

_D_e_s_c_r_i_p_t_i_o_n:

     Generate regular sequences.

_U_s_a_g_e:

     from:to
        a:b

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

_A_r_g_u_m_e_n_t_s:

    from: starting value of sequence.

      to: (maximal) end value of the sequence.

      by: increment of the sequence.

length.out: desired length of the sequence.

along.with: take the length from the length of this argument.

     a,b: 'factor's of same length.

_D_e_t_a_i_l_s:

     The binary operator ':' has two meanings: for factors 'a:b' is
     equivalent to 'interaction(a, b)' (except for labelling by 'la:lb'
     not 'la.lb').  For numeric arguments 'a:b' is equivalent to
     'seq(from=a, to=b)'.

     The interpretation of the unnamed arguments of 'seq' is _not_
     standard, and it is recommended always to name the arguments when
     programming.

     Function 'seq' is generic, and only the default method is
     described here.

     The operator ':' and the 'seq(from, to)' form generate the
     sequence 'from, from+1, ..., to'.

     The second form generates 'from, from+by', ..., up to the sequence
     value less than or equal to 'to'.

     The third generates a sequence of 'length.out' equally spaced
     values from 'from' to 'to'.

     The fourth form generates the sequence '1, 2, ...,
     length(along.with)'.

     The last generates the sequence '1, 2, ..., length(from)' (as if
     argument 'along' 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).

     If 'from' and 'to' are factors of the same length, then 'from :
     to' returns the "cross" of the two.

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

_V_a_l_u_e:

     Currently, the default method returns a result of _storage mode_
     '"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.

_R_e_f_e_r_e_n_c_e_s:

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

_S_e_e _A_l_s_o:

     The method 'seq.POSIXt'.

     'rep', 'sequence', 'row', 'col'.

     As an alternative to using ':' for factors, 'interaction'.

_E_x_a_m_p_l_e_s:

     1:4
     pi:6 # float
     6:pi # integer

     seq(0,1, length=11)
     seq(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

     for (x in list(NULL, letters[1:6], list(1,pi)))
       cat("x=",deparse(x),";  seq(along = x):",seq(along = x),"\n")

     f1 <- gl(2,3); f1
     f2 <- gl(3,2); f2
     f1:f2 # a factor, the "cross"  f1 x f2

