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) возвращает попарный максимум в соответствии с правилами для Broadcasting.

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

max (max (x))

возвращает наибольший элемент 2-D матрицы 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) возвращает попарный минимум в соответствии с правилами для Broadcasting.

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

min (min (x))

возвращает наименьший элемент 2-D матрицы 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 также может вызываться с более чем 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.

: 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

См. также: 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, …) ¶

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

Для 2-мерной матрицы 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

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

: l = lcm (x, y) ¶

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

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

Все элементы должны быть числовыми и иметь один размер или быть скалярами.

См. также: 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.