Extremes                package:base                R Documentation

_M_a_x_i_m_a _a_n_d _M_i_n_i_m_a

_D_e_s_c_r_i_p_t_i_o_n:

     Returns the (parallel) maxima and minima of the input values.

_U_s_a_g_e:

     max(..., na.rm = FALSE)
     min(..., na.rm = FALSE)

     pmax(..., na.rm = FALSE)
     pmin(..., na.rm = FALSE)

     pmax.int(..., na.rm = FALSE)
     pmin.int(..., na.rm = FALSE)

_A_r_g_u_m_e_n_t_s:

     ...: numeric or character arguments (see Note).

   na.rm: a logical indicating whether missing values should be
          removed.

_D_e_t_a_i_l_s:

     'max' and 'min' return the maximum or minimum of _all_ the  values
     present in their arguments, as 'integer' if all are 'logical' or
     'integer', as 'double' if all are numeric, and character
     otherwise.

     If 'na.rm' is 'FALSE' an 'NA' value in any of the arguments will
     cause a value of 'NA' to be returned, otherwise 'NA' values are
     ignored.

     The minimum and maximum of a numeric empty set are '+Inf' and
     '-Inf' (in this order!) which ensures _transitivity_, e.g.,
     'min(x1, min(x2)) == min(x1, x2)'.  For numeric 'x' 'max(x) ==
     -Inf' and 'min(x) == +Inf' whenever 'length(x) == 0' (after
     removing missing values if requested).  However, 'pmax' and 'pmin'
     return 'NA' if all the parallel elements are 'NA' even for 'na.rm
     = TRUE'.

     'pmax' and 'pmin' take one or more vectors (or matrices) as
     arguments and return a single vector giving the 'parallel' maxima
     (or minima) of the vectors.  The first element of the result is
     the maximum (minimum) of the first elements of all the arguments,
     the second element of the result is the maximum (minimum) of the
     second elements of all the arguments and so on.  Shorter inputs
     are recycled if necessary.  'attributes' (such as 'names' or
     'dim') are transferred from the first argument (if applicable).

     'pmax.int' and 'pmin.int' are faster internal versions only used
     when all arguments are atomic vectors and there are no classes:
     they drop all attributes.  (Note that all versions fail for raw
     and complex vectors since these have no ordered.)

     'max' and 'min' are generic functions: methods can be defined for
     them individually or via the 'Summary' group generic.  For this to
     work properly, the arguments '...' should be unnamed, and dispatch
     is on the first argument.

     By definition the min/max of any vector containing an 'NaN' is
     'NaN', except that the min/max of any vector containing an 'NA' is
     'NA' even if it also contains an 'NaN'.  Note that 'max(NA, Inf)
     == NA' even though the maximum would be 'Inf' whatever the missing
     value actually is.

     The max/min of an empty character vector is a character 'NA'. (One
     could argue that as '""' is the smallest character element, the
     maximum should be '""', but there is no obvious candidate for the
     minimum.)

_V_a_l_u_e:

     For 'min' or 'max', a length-one vector.  For 'pmin' or 'pmax', a
     vector of length the longest of the input vectors.

     The type of the result will be that of the highest of the inputs
     in the hierarchy integer < real < character.

     For 'min' and 'max' if there are only numeric inputs and all are
     empty (after possible removal of 'NA's), the result is double
     ('Inf' or '-Inf').

_S_4 _m_e_t_h_o_d_s:

     'max' and 'min' are part of the S4 'Summary' group generic. 
     Methods for them must use the signature 'x, ..., na.rm'.

_N_o_t_e:

     'Numeric' arguments are vectors of type integer and numeric, and
     logical (coerced to integer).  For historical reasons, 'NULL' is
     accepted as equivalent to 'integer(0)'.

     'pmax' and 'pmin' will also work on classed objects with
     appropriate methods for comparison, 'is.na' and 'rep' (if
     recycling of arguments is needed).

_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:

     'range' (_both_ min and max) and 'which.min' ('which.max') for the
     _arg min_, i.e., the location where an extreme value occurs.

_E_x_a_m_p_l_e_s:

     require(stats); require(graphics)
      min(5:1, pi) #-> one number
     pmin(5:1, pi) #->  5  numbers

     x <- sort(rnorm(100));  cH <- 1.35
     pmin(cH, quantile(x)) # no names
     pmin(quantile(x), cH) # has names
     plot(x, pmin(cH, pmax(-cH, x)), type='b', main= "Huber's function")

