Round                  package:base                  R Documentation

Rounding of Numbers

Description:

     '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'.

Usage:

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

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

Arguments:

       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.

Details:

     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 as from R 2.7.0 arguments
     are matched by name in 'round' and 'signif' (whereas the default
     method for 'ceiling', 'floor' and 'trunc' ignore argument names).

S4 methods:

     '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.

References:

     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'.)

See Also:

     'as.integer'.

Examples:

     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))

