17.5 Функции вспомогательные ¶

: y = ceil (x) ¶

Возвращает наименьшее целое число, не меньшее чем x.

Это эквивалентно округлению в сторону положительной бесконечности.

Если x комплексное, возвращает ceil (real (x)) + ceil (imag (x)) * I.

ceil ([-2.7, 2.7])
    ⇒ -2    3

См. также: floor, round, fix.

: y = fix (x) ¶

Отбрасывает дробную часть x и возвращает целую часть.

Это эквивалентно округлению к нулю. Если x комплексное, возвращает fix (real (x)) + fix (imag (x)) * I.

fix ([-2.7, 2.7])
   ⇒ -2    2

См. также: ceil, floor, round.

: y = floor (x) ¶

Возвращает наибольшее целое число, не большее чем x.

Это эквивалентно округлению к отрицательной бесконечности. Если x комплексное, возвращает floor (real (x)) + floor (imag (x)) * I.

floor ([-2.7, 2.7])
     ⇒ -3    2

См. также: ceil, round, fix.

: y = round (x) ¶

Возвращает целое число, ближайшее к x.

Если x комплексное, возвращает round (real (x)) + round (imag (x)) * I. Если есть два ближайших целых числа, возвращает то, которое дальше от нуля.

round ([-2.7, 2.7])
     ⇒ -3    3

См. также: ceil, floor, fix, roundb.

: y = roundb (x) ¶

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

Если x комплексное, возвращает roundb (real (x)) + roundb (imag (x)) * I.

См. также: round.

: m = max (x) ¶

: m = max (x, [], dim) ¶

: [m, im] = max (x) ¶

: m = max (x, y) ¶

Найти максимальные значения в массиве x.

Для векторового аргумента возвращает максимальное значение. Для матричного аргумента возвращает строковый вектор с максимальным значением каждого столбца. Для многомерного массива, max работает по первому неединичному измерению.

Если присутствует необязательный третий аргумент dim, то работа производится по этому измерению. В этом случае второй аргумент игнорируется и должен быть задан пустой матрицей.

Для двух входных данных (x и y), возвращает попарный максимум в соответствии с правилами векторно-матричных операций.

Таким образом,

max (max (x))

возвращает наибольший элемент 2-мерной матрицы x, и

max (2:5, pi)
    ⇒  3.1416  3.1416  4.0000  5.0000

сравнивает каждый элемент диапазона 2:5 с pi, и возвращает строковый вектор максимальных значений.

Для комплексных аргументов для сравнения используются модули элементов. Если модули одинаковы, результаты упорядочиваются по фазовому углу в диапазоне (-π, π]. Следовательно,

max ([-1 i 1 -i])
    ⇒ -1

потому что все записи имеют модуль 1, но -1 имеет наибольший фазовый угол со значением π.

Если вызывается с одним входом и двумя выходными аргументами, max также возвращает первый индекс максимального значения(й). Таким образом,

[x, ix] = max ([1, 3, 5, 2, 5])
    ⇒  x = 5
        ix = 3

См. также: min, cummax, cummin.

: m = min (x) ¶

: m = min (x, [], dim) ¶

: [m, im] = min (x) ¶

: m = min (x, y) ¶

Найти минимальные значения в массиве x.

Для векторового аргумента возвращает минимальное значение. Для матричного аргумента возвращает строковый вектор с минимальным значением каждого столбца. Для многомерного массива, min работает по первому неединичному измерению.

Если присутствует необязательный третий аргумент dim, то работа производится по этому измерению. В этом случае второй аргумент игнорируется и должен быть задан пустой матрицей.

Для двух входных данных (x и y), возвращает попарный минимум в соответствии с правилами векторно-матричных операций.

Таким образом,

min (min (x))

возвращает наименьший элемент 2-мерной матрицы x, и

min (2:5, pi)
    ⇒  2.0000  3.0000  3.1416  3.1416

сравнивает каждый элемент диапазона 2:5 с pi, и возвращает строковый вектор минимальных значений.

Для комплексных аргументов для сравнения используются модули элементов. Если модули одинаковы, результаты упорядочиваются по фазовому углу в диапазоне (-π, π]. Следовательно,

min ([-1 i 1 -i])
    ⇒ -i

потому что все записи имеют модуль 1, но -i имеет наименьший фазовый угол со значением -π/2.

Если вызывается с одним входом и двумя выходными аргументами, min также возвращает первый индекс минимального значения(й). Таким образом,

[x, ix] = min ([1, 3, 0, 2, 0])
    ⇒  x = 0
        ix = 3

См. также: max, cummin, cummax.

: M = cummax (x) ¶

: M = cummax (x, dim) ¶

: [M, IM] = cummax (…) ¶

Возвращает кумулятивные максимальные значения по измерению dim.

Если dim не указан, по умолчанию выполняется операция по столбцам. Например:

cummax ([1 3 2 6 4 5])
   ⇒  1  3  3  6  6  6

Если вызывается с двумя выходными аргументами, также возвращается индекс максимального значения.

[w, iw] = cummax ([1 3 2 6 4 5])
⇒
M =  1  3  3  6  6  6
IM = 1  2  2  4  4  4

См. также: cummin, max, min.

: M = cummin (x) ¶

: M = cummin (x, dim) ¶

: [M, IM] = cummin (x) ¶

Возвращает кумулятивные минимальные значения вдоль измерения dim.

Если dim не указано, по умолчанию используется операция по столбцам. Например:

cummin ([5 4 6 2 3 1])
   ⇒  5  4  4  2  2  1

Если вызывается с двумя выходными аргументами, также возвращается индекс минимального значения.

[M, IM] = cummin ([5 4 6 2 3 1])
⇒
M =  5  4  4  2  2  1
IM = 1  2  2  4  4  6

См. также: cummax, min, max.

: h = hypot (x, y) ¶

: h = hypot (x, y, z, …) ¶

Вычисляет элементно-поэлементную квадратный корень из суммы квадратов x и y.

Это эквивалентно sqrt (x.^2 + y.^2), но вычисляется таким образом, чтобы избежать переполнений для больших значений x или y.

hypot также может быть вызван с более чем 2 аргументами; в этом случае аргументы накапливаются слева направо:

hypot (hypot (x, y), z)
hypot (hypot (hypot (x, y), z), w), etc.

: dx = gradient (m) ¶

: [dx, dy, dz, …] = gradient (m) ¶

: […] = gradient (m, s) ¶

: […] = gradient (m, x, y, z, …) ¶

: […] = gradient (f, x0) ¶

: […] = gradient (f, x0, s) ¶

: […] = gradient (f, x0, x, y, …) ¶

Вычисляет градиент выборочных данных или функции.

Если m - вектор, вычисляется одномерный градиент m. Если m - матрица, градиент вычисляется для каждого измерения.

[dx, dy] = gradient (m) вычисляет одномерный градиент для направления x и y, если m - матрица. Дополнительные возвращаемые аргументы могут использоваться для многомерных матриц.

Постоянное расстояние между двумя точками можно указать параметром s. Если s - скаляр, предполагается, что это расстояние для всех измерений. В противном случае отдельные значения расстояния можно указать аргументами x, … Скалярные значения задают равномерное расстояние. Векторные значения для аргументов x, … задают координаты для этого измерения. Длина должна соответствовать соответствующему измерению m.

В граничных точках применяется линейная экстраполяция. Внутренние точки рассчитываются с использованием первого приближения численного градиента

y'(i) = 1/(x(i+1)-x(i-1)) * (y(i-1)-y(i+1)).

Если первый аргумент f является функцией-обработчиком, градиент функции в точках x0 аппроксимируется с помощью центральной разницы. Например, gradient (@cos, 0) аппроксимирует градиент косинусной функции в точке x0 = 0. Как и в случае выборочных данных, значения расстояния между точками, от которых оценивается градиент, можно установить с помощью аргументов s или dx, dy, … По умолчанию используется расстояние 1.

См. также: diff, del2.

: z = dot (x, y) ¶

: z = dot (x, y, dim) ¶

Вычисляет скалярное произведение двух векторов.

Если x и y являются матрицами, вычисляет скалярные произведения вдоль первого неединичного измерения.

Если необязательный аргумент dim задан, вычисляет скалярные произведения вдоль этого измерения.

Примечание по реализации: Это эквивалентно sum (conj (X) .* Y, dim), но избегает формирования временной матрицы и быстрее. Когда X и Y являются столбцовыми векторами, результат эквивалентен X' * Y. Хотя dot определен для целочисленных массивов, результат может отличаться от ожидаемого из-за ограниченного диапазона целочисленных объектов.

См. также: cross, divergence, tensorprod.

: z = cross (x, y) ¶

: z = cross (x, y, dim) ¶

Вычисляет векторное произведение двух 3-мерных векторов x и y.

Если x и y являются массивами, векторное произведение применяется к первому измерению с тремя элементами.

Необязательный аргумент dim заставляет вычислять векторное произведение вдоль указанного измерения. Будет выдано сообщение об ошибке, если указанное измерение не имеет размера три элемента.

Пример кода:

cross ([1, 1, 0], [0, 1, 1])
  ⇒
       1  -1   1

cross (magic (3), eye (3), 2)
  ⇒
       0   6  -1
      -7   0   3
       9  -4   0

См. также: dot, curl, divergence.

: div = divergence (x, y, z, fx, fy, fz) ¶

: div = divergence (fx, fy, fz) ¶

: div = divergence (x, y, fx, fy) ¶

: div = divergence (fx, fy) ¶

Вычисляет дивергенцию векторного поля, заданного массивами fx, fy и fz или fx, fy соответственно.

d               d               d
div F(x,y,z)  =   -- F(x,y,z)  +  -- F(x,y,z)  +  -- F(x,y,z)
                  dx              dy              dz

Координаты векторного поля можно указать аргументами x, y, z или x, y соответственно.

См. также: curl, gradient, del2, dot.

: [cx, cy, cz, v] = curl (x, y, z, fx, fy, fz) ¶

: [cz, v] = curl (x, y, fx, fy) ¶

: […] = curl (fx, fy, fz) ¶

: […] = curl (fx, fy) ¶

: v = curl (…) ¶

Вычислить ротор векторного поля, заданного массивами fx, fy и fz или fx, fy соответственно.

/ d         d       d         d       d         d     \
curl F(x,y,z)  =  | -- Fz  -  -- Fy,  -- Fx  -  -- Fz,  -- Fy  -  -- Fx |
                  \ dy        dz      dz        dx      dx        dy    /

Координаты векторного поля могут быть заданы аргументами x, y, z или x, y соответственно. v вычисляет скалярную компоненту вектора угловой скорости в направлении оси z для двумерного входного значения. Для трехмерного входного значения скалярное вращение вычисляется в каждой точке сетки в направлении векторного поля в этой точке.

См. также: divergence, gradient, del2, cross.

: L = del2 (M) ¶

: L = del2 (M, h) ¶

: L = del2 (M, dx, dy, …) ¶

Вычислить дискретный оператор Лапласа.

Для двумерной матрицы M это определяется как

1    / d^2            d^2         \
L  = --- * | ---  M(x,y) +  ---  M(x,y) |
      4    \ dx^2           dy^2        /

Для N-мерных массивов сумма в скобках расширяется, чтобы включить вторые производные по дополнительным измерениям.

Расстояние между точками оценки может быть определено h, которое является скалярной величиной, определяющей равноудаленное расстояние во всех измерениях. В качестве альтернативы расстояние в каждом измерении может быть определено отдельно dx, dy и т. д. Скалярный аргумент расстояния определяет равноудаленное расстояние, а векторный аргумент может быть использован для указания переменного расстояния. Длина векторов расстояния должна совпадать с соответствующим размером M. Значение по умолчанию для расстояния равно 1.

Измерения с менее чем 3 точками данных пропускаются. Граничные точки рассчитываются по линейной экстраполяции внутренних точек.

Пример: Вторая производная от 2*x^3

f = @(x) 2*x.^3;
dd = @(x) 12*x;
x = 1:6;
L = 4*del2 (f(x));
assert (L, dd (x));

См. также: gradient, diff.

: f = factorial (n) ¶

Возвращает факториал n, где n — действительное неотрицательное целое число.

Если n является скаляром, это эквивалентно prod (1:n). Для векторов или матриц возвращается факториал каждого элемента в массиве.

Для нецелых чисел см. обобщенную функцию факториала gamma. Обратите внимание, что функция факториала довольно быстро растет, и даже с значениями двойной точности произойдет переполнение, если n > 171. В таких случаях рассмотрите gammaln.

См. также: prod, gamma, gammaln.

: pf = factor (q) ¶

: [pf, n] = factor (q) ¶

Возвращает разложение на простые множители числа q.

Разложение на простые множители определяется как prod (pf) == q , где каждый элемент pf — простое число. Если q == 1, возвращается 1. Выход pf имеет тот же тип данных, что и вход.

С двумя выходными аргументами возвращаются уникальные простые множители pf и их кратности. То есть, prod (pf .^ n) == q.

Примечание по реализации: если вход q — single или double, то он не должен превышать соответствующее значение flintmax. Для больших значений преобразуйте их в uint64 , если они меньше 2^64:

factor (uint64 (18446744073709011493))
   ⇒     571111    761213  42431951

Для ещё больших значений используйте sym , если у вас установлен и загружен пакет Symbolic:

factor (sym ('9444733049654361449941'))
   ⇒ (sym)
              1           1
 1099511627689 ⋅8589934669

См. также: gcd, lcm, isprime, primes.

: g = gcd (a1, a2, …) ¶

: [g, v1, …] = gcd (a1, a2, …) ¶

Вычислить наибольший общий делитель (НОД) a1, a2, ….

Все аргументы должны быть одинакового размера или скалярными. Для массивов наибольший общий делитель вычисляется для каждого элемента по отдельности. Все элементы должны быть обычными или гауссовыми (комплексными) целыми числами. Обратите внимание, что для гауссовых целых чисел НОД уникален лишь до множителя-фазы (умножения на 1, -1, i или -i), поэтому возвращается произвольный наибольший общий делитель среди четырёх возможных.

Дополнительные выходные аргументы v1, … содержат целочисленные векторы такие, что:

g = v1 .* a1 + v2 .* a2 + ...

Пример кода:

gcd ([15, 9], [20, 18])
   ⇒  5  9

Совет по программированию: для нахождения НОД всех элементов одного массива используйте num2cell вместо вложенных вызовов или цикла:

x = [30 42 70 105];    # vector or array of inputs
gcd (num2cell (x) {:})
   ⇒     1

См. также: lcm, factor, isprime.

: l = lcm (x, y) ¶

: l = lcm (x, y, …) ¶

Вычислить наименьшее общее кратное (НОК) x и y или всех аргументов.

Все входные значения должны быть одинакового размера или скалярными. Все элементы должны быть действительными целыми числами или гауссовыми (комплексными) целыми числами. Для комплексных входных значений результат уникален только до множителя-фазы (+1, +i, -1, или -i), и один из четырёх возвращается произвольно.

Пример кода:

lcm (5:8, 9:12)
   ⇒  45  30  77  24

Совет по программированию: для нахождения НОК всех элементов одного массива используйте num2cell вместо вложенных вызовов или цикла:

x = 1:10;    # vector or array of inputs
lcm (num2cell (x) {:})
   ⇒     2520

См. также: factor, gcd, isprime.

: r = rem (x, y) ¶

Возвращает остаток от деления x / y.

Остаток вычисляется по формуле

x - y .* fix (x ./ y)

Сообщение об ошибке выводится, если размеры аргументов не совпадают или если хотя бы один аргумент комплексный.

Примечания по программированию: при вычислении с числами с плавающей запятой (double, single), значения, отличающиеся от целого числа на несколько eps, будут округлены до этого целого числа для совместимости с MATLAB. Любые целые числа с плавающей запятой, превышающие flintmax (2^53 для double), будут вычисляться неправильно. Для больших целочисленных значений преобразуйте вход в uint64 перед вызовом этой функции.

По соглашению,

rem (x, 0) = NaN  if x is a floating point variable
rem (x, 0) = 0    if x is an integer variable
rem (x, y)  returns a value with the signbit from x

Для противоположных соглашений см. функцию mod. В общем случае rem лучше всего использовать для вычисления остатка от деления двух положительных чисел. Для отрицательных чисел или периодических значений mod является лучшим выбором.

См. также: mod.

: m = mod (x, y) ¶

Вычислить остаток от деления x на y.

По концепции это определяется как

x - y .* floor (x ./ y)

и записано таким образом, чтобы возвращался правильный остаток для целочисленных типов. Эта функция корректно обрабатывает отрицательные значения. То есть, mod (-1, 3) равно 2, а не -1, так как rem (-1, 3) возвращает.

Ошибка возникает, если размерности аргументов не совпадают или если любой из аргументов является комплексным.

Примечания по программированию: При вычислении с числами с плавающей точкой (double, single), значения, находящиеся в пределах нескольких eps от целого числа, будут округляться до этого целого числа перед вычислением для совместимости с MATLAB. Любые целые числа с плавающей точкой, превышающие flintmax (2^53 для double), не будут вычисляться корректно. Для больших целых значений преобразуйте входные данные в uint64 перед вызовом этой функции.

По соглашению,

mod (x, 0) = x
mod (x, y)      returns a value with the signbit from y

Для противоположных соглашений см. функцию rem. В общем случае, mod является лучшим выбором, чем rem, когда любой из входных данных является отрицательным числом или когда значения являются периодическими.

См. также: rem.

: p = primes (n) ¶

Возвратить все простые числа до n.

Класс выходных данных (double, single, uint32 и т.д.) совпадает с классом входных данных n. Используемый алгоритм — решето Эратосфена.

Примечание: Для определенного числа n простых чисел вызовите list_primes (n). В качестве альтернативы, вызовите primes (n*log (k*n))(1:n), где k составляет примерно 5 или 6. Это работает, потому что расстояние от одного простого числа до следующего пропорционально логарифму простого числа в среднем. При интегрировании существует примерно n простых чисел меньше n * log (5*n).

См. также: list_primes, isprime.

: p = list_primes () ¶

: p = list_primes (n) ¶

Вывести первые n простых чисел.

Если n не указано, выводятся первые 25 простых чисел.

См. также: primes, isprime.

: y = sign (x) ¶

Вычислить функцию signum.

Она определяется как

-1, x < 0;
sign (x) =  0, x = 0;
            1, x > 0.

Для комплексных аргументов, sign возвращает x ./ abs (x).

Обратите внимание, что sign (-0.0) равно 0. Хотя IEEE 754 числа с плавающей точкой допускают подписанный ноль, 0.0 и -0.0 сравниваются как равные. Если необходимо проверить, является ли ноль подписанным, используйте функцию signbit.

См. также: signbit.

: y = signbit (x) ¶

Возвращает логическое значение true, если бит знака значения x установлен, и false в противном случае.

Это поведение согласуется с другими логическими функциями. См. Логические значения. Поведение отличается от функции языка C, которая возвращает ненулевое значение, если бит знака установлен.

Это не то же самое, что x < 0.0, потому что IEEE 754 числа с плавающей точкой допускают подписанный ноль. Сравнение -0.0 < 0.0 ложно, но signbit (-0.0) вернет ненулевое значение.

См. также: sign.