min минимум

## Синтаксис

                m = min(A)
                Col = min(A, 'c')
                Row = min(A, 'r'|'m')
                M = min(A1, A2,..., An)
                M = min(list(A1, A2,..., An))
                [.., K] = min(..)

## Аргументы

A, A1, ..., An

  скаляры, векторы, матрицы или гиперматрицы кодированных целых чисел или вещественных чисел в полном или разрежённом формате. Они должны иметь одинаковые размеры или быть смешанными со скалярами (скаляры, следовательно, неявно расширяются до размеров массивов). Разрежённые массивы не могут смешиваться с полными массивами, за исключением скаляров.

m

  одиночное число = минимум из всех значений элементов `A`. Всегда в полном формате, даже если `A` является разряжённой.

Col

  вектор-столбец, если `A` является двумерной матрицей или гиперматрицей размерами `size(A)` с размером `size(A,2)` равным 1: минимумы по столбцам (для каждой строки). Если `A` - разрежённая матрица, то `Col` тоже разрежённый.

Row

  вектор-строка, если `A` является двумерной матрицей или гиперматрицей размерами `size(A)` с размером `size(A,2)` равным 1: минимумы по строкам (для каждого стролбца). Если `A` - разрежённая матрица, то `Row` тоже разрежённый.

M

  Массив размером = `size(A1)`, такой, что для каждого `q` `M(q) = min(A1(q),A2(q),..An(q))`. Если `A`,...,`An` - разрежённые матрицы, то `M` тоже разрежённый.

K

  Указывает в `A` (первый) найденный минимум. Когда используется `[m,K]=min(A)`, то

  - Если `A` вектор, то `K` - скаляр.
  - В противном случае `K` является вектор-строкой `[i,j,..]` индексов.

  Для других синтаксисов `K` имеет форму и размеры, соответствующие `Col`, `Row` и `M`.

  Для синтаксиса `[M,K] = min(A1,A2,..,An)` имеем для каждого линейного индекса `q`: `[M(q),K(q)] = min([A1(q) A2(q) .. An(q)])`.

  `K` всегда в полном формате, даже когда `A, A1,..,An` в разрежённом виде. Следовательно, когда используется синтаксис `[M,K]=min(A1,A2,..)` с огромными, но разрежёнными матрицами, то это приводит к огромной полной матрице `K`. Пользователь должен проверить достаточно ли памяти имеется для этого.

## Описание

Для `A` вещественного вектора или матрицы `min(A)` даёт наименьший элемент в `A`.

`[m,K]=min(A)` даёт дополнительно индексы первого минимума.

Может быть использован второй строковый аргумент `'r'` или `'c'`: `'r'` используется для получения вектор-строки `Row` такой что `Row(j)` содержит минимум `j`-го столбца `A(:,j)`, `K(j)` даёт индекс строки, которая содержит минимум столбца №`j`.

`'c'` используется для парной операции по строкам `A`. `'m'` используется для совместимости с Matlab.

`[M,K]=min(list(A1,...,An))` является эквивалентным для `[M,K]=min(A1,A2,...,An)`.

- `min()` игнорирует значения `NaN` (если есть не только значения `NaN`).
- `min([])` возвращает `[]` для значений и индексов.

If `min(A1, A2,..., An)` is used with a huge input sparse matrix of low density, together with a strictly negative scalar input, the sparse result will no longer have any 0 value: It will be a sparse array with density=1, that may lead to a memory failure.

## Примеры

    [m, k] = min([])
    [m, k] = min([5 3 ; 2 %nan])
    [m, n] = min([5 3 ; 2 %nan], 4)
    [m, k] = min([5 -1 2], [1 5 1], [0 1 3])
    [m, k] = min(list([5 -1 2], [1 5 1], [0 1 3]))

    --> [m, k] = min([])
     m  =
        []
     k  =
        []

    --> [m, k] = min([5 3 ; 2 %nan])
     m  =
       2.
     k  =
       2.   1.

    --> [m, k] = min([5 3 ; 2 %nan], 4)
     m  =
       4.   3.
       2.   4.
     k  =
       2.   1.
       1.   2.

    --> [m, k] = min([5 -1 2], [1 5 1], [0 1 3])
     m  =
       0.  -1.   1.
     k  =
       3.   1.   2.

С опциями "r" или "c":

    A = grand(4,6,"uin",0,30); A(3,4) = %nan
    [Row, K] = min(A, "r")
    [Col, K] = min(A, "c")

    --> A = grand(4,6,"uin",0,30); A(3,4) = %nan
     A  =
       24.   14.   24.   4.    6.    11.
       23.   25.   29.   6.    19.   5.
       30.   2.    20.   Nan    6.   6.
       20.   8.    13.   14.   16.   3.

    --> [Row, K] = min(A, "r")
     Row  =
       20.   2.   13.   4.   6.   3.
     K  =
       4.   3.   4.   1.   1.   4.

    --> [Col, K] = min(A, "c")
     Col  =
       4.
       5.
       2.
       3.
     K  =
       4.
       6.
       2.
       6.

С разрежёнными входными данными:

    s = sprand(5,4,0.5); k = s~=0; s(k) = round((s(k)-0.5)*10), full(s)
    [Row, K] = min(s, "r")
    [Col, K] = min(s, "c")
    [M, K] = min(s,1);   [full(s)  ones(s(:,1))*%nan  full(M)]
    issparse(M)
    K

    --> s = sprand(5,4,0.5); k = s~=0; s(k) = round((s(k)-0.5)*10), full(s)
     s  =
    (  5,  4) sparse matrix
    (  1,  3)     5.
    (  1,  4)    -2.
    (  2,  1)    -3.
    (  2,  3)    -5.
    (  3,  1)     3.
    (  3,  2)    -1.
    (  3,  3)     3.
    (  3,  4)     4.
    (  5,  3)     4.
    (  5,  4)    -5.
     ans  =
       0.   0.   5.  -2.
      -3.   0.  -5.   0.
       3.  -1.   3.   4.
       0.   0.   0.   0.
       0.   0.   4.  -5.

    --> [Row, K] = min(s, "r")
     Row  =
    (  1,  4) sparse matrix
    (  1,  1)    -3.
    (  1,  2)    -1.
    (  1,  3)    -5.
    (  1,  4)    -5.
     K  =
       2.   3.   2.   5.

    --> [Col, K] = min(s, "c")
     Col  =
    (  5,  1) sparse matrix
    (  1,  1)    -2.
    (  2,  1)    -5.
    (  3,  1)    -1.
    (  5,  1)    -5.
     K  =
       4.
       3.
       2.
       1.
       4.

    --> [M, K] = min(s,1);   [full(s)  ones(s(:,1))*%nan  full(M)]
     ans  =
       0.   0.   5.  -2.   Nan   0.   0.   1.  -2.
      -3.   0.  -5.   0.   Nan  -3.   0.  -5.   0.
       3.  -1.   3.   4.   Nan   1.  -1.   1.   1.
       0.   0.   0.   0.   Nan   0.   0.   0.   0.
       0.   0.   4.  -5.   Nan   0.   0.   1.  -5.

    --> issparse(M)
     ans  =
       1.
    --> K
     K  =
       1.   1.   2.   1.
       1.   1.   1.   1.
       2.   1.   2.   2.
       1.   1.   1.   1.
       1.   1.   2.   1.

## Смотрите также

- max
- strange
- mean
- gsort
- find
- full

## История

6.0.2 Теперь min() действительно работает с разрежёнными матрицами