Extremes {base} | R Documentation |

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

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)

`...` |
numeric or character arguments (see Note). |

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

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

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`

).

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

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

`range`

(*both* min and max) and
`which.min`

(`which.max`

) for the *arg min*,
i.e., the location where an extreme value occurs.

require(stats) 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")

[Package *base* version 2.5.0 Index]