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

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

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

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

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

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

поскольку модуль всех элементов равен 1, но -1 имеет наибольший фазовый угол, равный pi.

При вызове с одним входным и двумя выходными аргументами 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))

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

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

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

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

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

поскольку модуль всех элементов равен 1, но -i имеет наименьший фазовый угол, равный -pi/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 также можно вызывать более чем с двумя аргументами; в этом случае аргументы накапливаются слева направо:

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. Для многомерных матриц можно указать дополнительные выходные аргументы.

Параметр 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)

Вычисляет векторное произведение двух трехмерных векторов 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 * log (5*n), примерно n.

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

: p = list_primes ()

: p = list_primes (n)

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

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

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

: y = sign (x)

Вычисляет функцию знака.

Она определяется следующим образом:

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