Round                  package:base                  R Documentation

_R_o_u_n_d_i_n_g _o_f _N_u_m_b_e_r_s

_D_e_s_c_r_i_p_t_i_o_n:

     'ceiling' takes a single numeric argument 'x' and returns a
     numeric vector containing the smallest integers not less than the
     corresponding elements of 'x'.

     'floor' takes a single numeric argument 'x' and returns a numeric
     vector containing the largest integers not greater than the
     corresponding elements of 'x'.

     'trunc' takes a single numeric argument 'x' and returns a numeric
     vector containing the integers formed by truncating the values in
     'x' toward '0'.

     'round' rounds the values in its first argument to the specified
     number of decimal places (default 0).

     'signif' rounds the values in its first argument to the specified
     number of significant digits.

     'zapsmall' determines a 'digits' argument 'dr' for calling
     'round(x, digits = dr)' such that values close to zero (compared
     with the maximal absolute value) are 'zapped', i.e., treated as
     '0'.

_U_s_a_g_e:

     ceiling(x)
     floor(x)
     trunc(x, ...)

     round(x, digits = 0)
     signif(x, digits = 6)
     zapsmall(x, digits = getOption("digits"))

_A_r_g_u_m_e_n_t_s:

       x: a numeric vector.  A complex vector is allowed for 'round',
          'signif' and 'zapsmall'.

  digits: integer indicating the precision to be used.

     ...: arguments to be passed to methods.

_D_e_t_a_i_l_s:

     All but 'zapsmall' are generic functions: methods can be defined
     for them individually or via the 'Math' group generic.

     Note that for rounding off a 5, the IEC 60559 standard is expected
     to be used, '_go to the even digit_'. Therefore 'round(0.5)' is
     '0' and 'round(-1.5)' is '-2'.  However, this is dependent on OS
     services and on representation error (since e.g. '0.15' is not
     represented exactly, the rounding rule applies to the represented
     number and not to the printed number, and so 'round(0.15, 1)'
     could be either '0.1' or '0.2').

     For 'signif' the recognized values of 'digits' are '1...22'. 
     Complex numbers are rounded to retain the specified number of
     digits in the larger of the components.  Each element of the
     vector is rounded individually, unlike printing.

     All except 'zapsmall' are primitive, but arguments are matched by
     name in 'round' and 'signif' (whereas the default methods for
     'ceiling', 'floor' and 'trunc' ignore argument names).

_S_4 _m_e_t_h_o_d_s:

     'ceiling', 'floor' and 'trunc' are S4 generic and members of the
     'Math' group generic.  As an S4 generic, 'trunc' has only one
     argument.

     'round' and 'signif' are S4 generic and members of the 'Math2'
     group generic.

_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. (Except 'zapsmall'.)

     Chambers, J. M. (1998) _Programming with Data. A Guide to the S
     Language_. Springer. ('zapsmall'.)

_S_e_e _A_l_s_o:

     'as.integer'.

_E_x_a_m_p_l_e_s:

     round(.5 + -2:4) # IEEE rounding: -2  0  0  2  2  4  4
     ( x1 <- seq(-2, 4, by = .5) )
     round(x1)#-- IEEE rounding !
     x1[trunc(x1) != floor(x1)]
     x1[round(x1) != floor(x1 + .5)]
     (non.int <- ceiling(x1) != floor(x1))

     x2 <- pi * 100^(-1:3)
     round(x2, 3)
     signif(x2, 3)

     print   (x2 / 1000, digits=4)
     zapsmall(x2 / 1000, digits=4)
     zapsmall(exp(1i*0:4*pi/2))