The functions max and min return the maximum and minimum, respectively, of one or more arguments.

Most often the arguments are of type numeric: integers, rationals, or floating-point numbers.  However, the functionality is more general, as described in this section.

When given a list, set, Array, Vector, or Matrix (a container) as an argument, the maximum or minimum element in the container is returned. Multiple container arguments will result in the maximum of the maximums or minimum of the minimums.

Each value processed by max and min is recognized as falling into one of four categories: algebraic, numeric, Boolean, or string.

The values can be a mix of algebraic values and one of the numeric, Boolean, or string categories of values. If there are values of more than one of these three categories, an exception is raised.

If the values consist solely of numeric, Boolean, or string values, the maximum or minimum value is returned.

If any values are algebraic and a maximum or minimum cannot be determined, an unevaluated call to max or min is returned, with arguments consisting of the algebraic values, and one argument consisting of the maximum or minimum of the non-algebraic values if any were present.

In most cases, a call to max or min containing an undefined value returns undefined.

A call to max where one of the arguments is positive infinity and all the others are algebraic or numeric returns positive infinity. Likewise, a call to min containing negative infinity returns negative infinity. This is true even if one of the other arguments to max or min is undefined.

To ignore undefined values when computing the maximum or minimum, use the optional index defined. That is, max[defined](...).

By default, a call to max or min with no arguments or with only empty container arguments returns negative or positive infinity, respectively. If called with the index nodefault, the result is NULL instead.

The functions max[index] and min[index] return the index of the maximum or minimum element in the container C.

Only one argument can be supplied when using the [index] variations.  The mandate for this option is that C[ max[index](C) ] give the maximal element.  That mandate cannot be fulfilled when C is a sequence, or when C is a container that has other containers inside (such as a list of vectors); an error is raised in these situations.

These routines use evalr to try to resolve the relevant inequalities. Since evalr uses the current setting of Digits for its computations, it may help to increase Digits if either max(...) or min(...) returns unevaluated.

The maximum and minimum of polynomials can be converted to a piecewise function.

The max and min commands are thread-safe as of Maple 15.

For more information on thread safety, see index/threadsafe.

$\min \left(1\right)$

$1$

$\max \left(\frac{3}{2}\,1.49\right)$

$\frac{3}{2}$

$\max \left(\frac{3}{5}\,\ln \left(2\right)\,\frac{9}{13}\,-\mathrm{\infty }\right)$

$\ln \left(2\right)$

$a≔24\:$

$b≔-3\:$

$\max \left(a\,b\right)$

$24$

$\min \left(\frac{3}{2}\,1.49\,f\left(x\right)\right)$

$\min \left(1.49\,f\left(x\right)\right)$

$\max \left(\frac{3}{2}\,1.49\,\mathrm{undefined}\,2.5\right)$

$\mathrm{undefined}$

$\max \left[\mathrm{defined}\right]\left(\frac{3}{2}\,1.49\,\mathrm{undefined}\,2.5\right)$

$2.5$

$\min \left[\mathrm{defined}\right]\left(\mathrm{undefined}\,8\,-3446\right)$

$\mathrm{-3446}$

$\max \left(\frac{3}{2}\,1.49\,\mathrm{undefined}\,\mathrm{\infty }\right)$

$\mathrm{\infty }$

$\max \left(x+1\,x+2\,y\right)$

$\max \left(y\,x+2\right)$

$\max \left(\mathrm{true}\,\mathrm{false}\right)$

$\mathrm{true}$

$\max \left(\mathrm{true}\,\mathrm{FAIL}\right)$

$\mathrm{FAIL}$

$\min \left(\mathrm{true}\,\mathrm{FAIL}\right)$

$\mathrm{FAIL}$

$\min \left(\right)$

$\mathrm{\infty }$

$\max \left(\right)$

$-\mathrm{\infty }$

$\max \left[\mathrm{nodefault}\right]\left(\right)$

$\mathrm{convert}\left(\max \left(x^2-2\,x+3\right)\,\mathrm{piecewise}\right)$

$\left\{\begin{array}{cc}{x}^2-2& x\le \frac{1}{2}-\frac{\sqrt{21}}{2}\\ x+3& x\le \frac{1}{2}+\frac{\sqrt{21}}{2}\\ x^2-2& \frac{1}{2}+\frac{\sqrt{21}}{2}<x\end{array}\right.$

$\mathrm{convert}\left(\min \left(x^3+8\&comma;x+8\right)\&comma;\mathrm{piecewise}\right)$

$\left\{\begin{array}{cc}{x}^3+8& x\le \mathrm{-1}\\ x+8& x\le 0\\ x^3+8& x\le 1\\ x+8& 1<x\end{array}\right.$

$\max \left(\left[1\&comma;2\&comma;3\&comma;4\right]\&comma;⟨5\&comma;6\&comma;7⟩\right)$

$7$

$L≔\left[11\&comma;12\&comma;13\&comma;14\right]$

$L≔\left[11\&comma;12\&comma;13\&comma;14\right]$

$\mathrm{ind}≔\max \left[\mathrm{index}\right]\left(L\right)$

$\mathrm{ind}≔4$

$L\left[\mathrm{ind}\right]$

$14$

$M≔\mathrm{Matrix}\left(\left[\left[11\&comma;12\right]\&comma;\left[21\&comma;22\right]\right]\right)$

$M≔\left[\begin{array}{cc}11& 12\\ 21& 22\end{array}\right]$

$\mathrm{ind}≔\max \left[\mathrm{index}\right]\left(M\right)$

$\mathrm{ind}≔2,2$

$M\left[\mathrm{ind}\right]$

$22$

$M≔\mathrm{Matrix}\left(\left[\left[11\&comma;12\right]\&comma;\left[21\&comma;22\right]\right]\right)$

$M≔\left[\begin{array}{cc}11& 12\\ 21& 22\end{array}\right]$

$M\left[1\right]≔\left[44\&comma;55\&comma;66\right]$

$M_1≔\left[44\&comma;55\&comma;66\right]$

$M$

$\left[\begin{array}{cc}\left[44\&comma;55\&comma;66\right]& \left[44\&comma;55\&comma;66\right]\\ 21& 22\end{array}\right]$

$\mathrm{ind}≔\max \left[\mathrm{index}\right]\left(M\right)$

Error, max value cannot be reached via a one-level index

$V≔⟨-4\&comma;77\&comma;\mathrm{undefined}\&comma;-\mathrm{\infty }⟩$

$V≔\left[\begin{array}{c}\mathrm{-4}\\ 77\\ \mathrm{undefined}\\ -\mathrm{\infty }\end{array}\right]$

$\mathrm{ind}≔\max \left['\mathrm{index}','\mathrm{defined}'\right]\left(V\right)$

$\mathrm{ind}≔2$

$V\left[\mathrm{ind}\right]$

$77$

The C parameter was introduced in Maple 2015.

For more information on Maple 2015 changes, see Updates in Maple 2015.

The nodefault option was introduced in Maple 2017.

For more information on Maple 2017 changes, see Updates in Maple 2017.

The max and min commands were updated in Maple 2021.