Математика

Математические операторы

-(x)

Унарный минус-оператор.

+(x, y...)

Оператор сложения. x+y+z+... вызывает эту функцию со всеми аргументами, т.е. +(x, y, z, ...).

-(x, y)

Оператор вычитания.

*(x, y...)

Оператор умножения. x*y*z*... вызывает эту функцию со всеми аргументами, т.е. *(x, y, z, ...).

/(x, y)

Оператор правого деления: умножение x на обратное значение y справа. Для целочисленных аргументов даёт результаты с плавающей запятой.

\(x, y)

Оператор левого деления: умножение y на обратное значение x слева. Для целочисленных аргументов даёт результаты с плавающей запятой.

^(x, y)

Оператор возведения в степень.

.+(x, y)

Оператор поэлементного сложения.

.-(x, y)

Оператор поэлементного вычитания.

.*(x, y)

Оператор поэлементного умножения.

./(x, y)

Оператор поэлементного правого деления.

.\(x, y)

Оператор поэлементного левого деления.

.^(x, y)

Оператор поэлементного возведения в степень.

fma(x, y, z)

Вычисляет x*y+z без округления промежуточного результата x*y. На некоторых системах это значительно дороже, чем x*y+z. fma используется для повышения точности в определённых алгоритмах. См. muladd.

muladd(x, y, z)

Комбинированный оператор умножения-сложения, вычисляет x*y+z эффективным способом. На некоторых системах это может быть эквивалентно x*y+z, или fma(x,y,z). muladd используется для повышения производительности. См. fma.

div(x, y)

÷(x, y)

Частное от целочисленного деления. Вычисляет x/y, усечённое до целого числа.

fld(x, y)

Наибольшее целое число, меньшее или равное x/y.

cld(x, y)

Наименьшее целое число, большее или равное x/y.

mod(x, y)

Модуль после целочисленного деления, возвращая значение в диапазоне \([0,y)\), если y положительно, или \((y,0]\) если y отрицательно.

x == fld(x,y)*y + mod(x,y)

mod2pi(x)

Модуль после деления на 2π, возвращая значение в диапазоне \([0,2π)\).

Эта функция вычисляет поплавковую точку представления модуля после деления на численно точное 2π, и поэтому не совсем такая же, как mod(x,2π), которая бы вычислила модуль x относительно деления на число с плавающей запятой 2π.

rem(x, y)

%(x, y)

Остаток от целочисленного деления, возвращая значение той же знак, что и x, и меньшее по величине, чем y. Это значение всегда точное.

x == div(x,y)*y + rem(x,y)

divrem(x, y)

Частное и остаток от целочисленного деления. Эквивалентно (div(x,y), rem(x,y)) или (x÷y, x%y).

fldmod(x, y)

Целочисленное частное и остаток после деления. Эквивалентно (fld(x,y), mod(x,y)).

fld1(x, y)

Целочисленное деление, возвращающее значение, согласованное с mod1(x,y)

x == fld(x,y)*y + mod(x,y)
x == (fld1(x,y)-1)*y + mod1(x,y)

mod1(x, y)

Модуль после целочисленного деления, возвращающее значение r такое, что mod(r, y) == mod(x, y) в диапазоне \((0, y]\) для положительного y и в диапазоне \([y,0)\) для отрицательного y.

fldmod1(x, y)

Возвращает (fld1(x,y), mod1(x,y)).

//(num, den)

Деление двух целых чисел или рациональных чисел, давая результат Rational.

rationalize([T<:Integer=Int, ]x; tol::Real=eps(x))

Приближённое число с плавающей точкой x как рациональное число с компонентами указанного целого типа. Результат будет отличаться от x не более чем на tol. Если T не указано, оно по умолчанию Int.

julia> rationalize(5.6)
28//5

julia> a = rationalize(BigInt, 10.3)
103//10

julia> typeof(num(a))
BigInt

num(x)

Числитель рационального представления x.

den(x)

Знаменатель рационального представления x.

<<(x, n)

Оператор сдвига влево, x << n. Для n >= 0, результат — x сдвинут влево на n бит, заполняя нулями. Это эквивалентно x * 2^n. Для n < 0, это эквивалентно x >> -n.

julia> Int8(3) << 2
12

julia> bits(Int8(3))
"00000011"

julia> bits(Int8(12))
"00001100"

См. также >>(), >>>().

>>(x, n)

Оператор сдвига вправо, x >> n. Для n >= 0, результат — x сдвинут вправо на n бит, где n >= 0, заполняя нулями, если x >= 0, знаками, если x < 0, сохраняя знак x. Это эквивалентно fld(x, 2^n). Для n < 0, это эквивалентно x << -n.

julia> Int8(13) >> 2
3

julia> bits(Int8(13))
"00001101"

julia> bits(Int8(3))
"00000011"

julia> Int8(-14) >> 2
-4

julia> bits(Int8(-14))
"11110010"

julia> bits(Int8(-4))
"11111100"

См. также >>>(), <<().

>>>(x, n)

Оператор беззнакового сдвига вправо, x >>> n. Для n >= 0, результат — x сдвинут вправо на n бит, где n >= 0, заполняя нулями. Для n < 0, это эквивалентно x << -n.

Для Unsigned целочисленных типов, это эквивалентно >>(). Для Signed целочисленных типов, это эквивалентно signed(unsigned(x) >> n).

julia> Int8(-14) >>> 2
60

julia> bits(Int8(-14))
"11110010"

julia> bits(Int8(60))
"00111100"

BigInt рассматриваются как имеющие бесконечный размер, поэтому заполнения не требуется, и это эквивалентно >>().

См. также >>(), <<().

:(start, [step, ]stop)

Оператор диапазона. a:b строит диапазон от a до b с шагом 1, и a:s:b аналогично, но использует шаг s. Эти синтаксисы вызывают функцию colon. Двоеточие также используется в индексации для выбора целых измерений.

colon(start, [step, ]stop)

Вызывается синтаксисом : для построения диапазонов.

range(start, [step, ]length)

Построить диапазон по длине, задав начальное значение и необязательный шаг (по умолчанию 1).

Base.OneTo(n)

Определите AbstractUnitRange, который ведет себя как 1:n, с дополнительным отличием, что нижняя граница гарантируется (системой типов) как 1.

==(x, y)

Общий оператор равенства, дающий результат Bool . Возвращается к ===. Должен быть реализован для всех типов с понятием равенства, основанным на абстрактном значении, которое представляет экземпляр. Например, все числовые типы сравниваются по числовому значению, игнорируя тип. Строки сравниваются как последовательности символов, игнорируя кодировку.

Следует стандарту IEEE для чисел с плавающей точкой.

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

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

!=(x, y)

≠(x, y)

Оператор сравнения «не равно». Всегда возвращает противоположный результат, что и ==. Новые типы, как правило, не должны реализовывать этот оператор, а полагаться на стандартное определение !=(x,y) = !(x==y).

===(x, y)

≡(x, y)

См. оператор is().

!==(x, y)

≢(x, y)

Эквивалентно !is(x, y).

<(x, y)

Оператор сравнения «меньше». Новые числовые типы должны реализовывать эту функцию для двух аргументов нового типа. Из-за поведения значений NaN с плавающей запятой, < реализует частичный порядок. Типы с каноническим частичным порядком должны реализовывать <, а типы с каноническим полным порядком должны реализовывать isless.

<=(x, y)

≤(x, y)

Оператор сравнения «меньше или равно».

>(x, y)

Оператор сравнения «больше». В общем случае, новые типы должны реализовывать < вместо этой функции, и полагаться на стандартное определение >(x,y) = y<x.

>=(x, y)

≥(x, y)

Оператор сравнения «больше или равно».

.==(x, y)

Оператор сравнения на равенство по элементам.

.!=(x, y)

.≠(x, y)

Оператор сравнения «не равно» по элементам.

.<(x, y)

Оператор сравнения «меньше» по элементам.

.<=(x, y)

.≤(x, y)

Оператор сравнения «меньше или равно» по элементам.

.>(x, y)

Оператор сравнения «больше» по элементам.

.>=(x, y)

.≥(x, y)

Оператор сравнения «больше или равно» по элементам.

cmp(x, y)

Возвращает -1, 0 или 1, в зависимости от того, x меньше, равно или больше y соответственно. Использует полный порядок, реализованный isless. Для чисел с плавающей запятой использует <, но выбрасывает ошибку для не упорядоченных аргументов.

~(x)

Битовое отрицание.

&(x, y)

Битовое И.

|(x, y)

Битовое ИЛИ.

$(x, y)

Битовое исключающее ИЛИ.

!(x)

Логическое отрицание.

x && y

Короткое замыкание логического И.

x || y

Короткое замыкание логического ИЛИ.

Математические функции

isapprox(x, y; rtol::Real=sqrt(eps), atol::Real=0)

Сравнение на приблизительное равенство: true если norm(x-y) <= atol + rtol*max(norm(x), norm(y)). По умолчанию atol равно нулю, а значение rtol по умолчанию зависит от типов x и y.

Для вещественных или комплексных чисел с плавающей запятой rtol по умолчанию равно sqrt(eps(typeof(real(x-y)))). Это соответствует требованию равенства примерно половины цифр мантиссы. Для других типов rtol по умолчанию равно нулю.

x и y также могут быть массивами чисел, в этом случае norm по умолчанию равно vecnorm, но может быть изменено путем передачи ключевого аргумента norm::Function. (Для чисел norm эквивалентно abs.) Когда x и y являются массивами, если norm(x-y) не является конечным (т.е. ±Inf или NaN), сравнение переходит к проверке, являются ли все элементы x и y приблизительно равными покомпонентно.

Бинарный оператор ≈ эквивалентен isapprox с аргументами по умолчанию, а x ≉ y эквивалентен !isapprox(x,y).

sin(x)

Вычислить синус x, где x в радианах.

cos(x)

Вычислить косинус x, где x в радианах.

tan(x)

Вычислить тангенс x, где x в радианах.

sind(x)

Вычислить синус x, где x в градусах.

cosd(x)

Вычислить косинус x, где x в градусах.

tand(x)

Вычислить тангенс x, где x в градусах.

sinpi(x)

Вычислить \(\sin(\pi x)\) более точно, чем sin(pi*x), особенно для больших значений x.

cospi(x)

Вычислить \(\cos(\pi x)\) более точно, чем cos(pi*x), особенно для больших значений x.

sinh(x)

Вычислить гиперболический синус x.

cosh(x)

Вычислить гиперболический косинус x.

tanh(x)

Вычислить гиперболический тангенс x.

asin(x)

Вычислить обратный синус x, где результат в радианах.

acos(x)

Вычислить обратный косинус x, где результат в радианах.

atan(x)

Вычислить обратный тангенс x, где результат в радианах.

atan2(y, x)

Вычислить обратный тангенс y/x, используя знаки x и y для определения квадранта результата.

asind(x)

Вычислить обратный синус x, где результат в градусах.

acosd(x)

Вычислить обратный косинус x, где результат в градусах.

atand(x)

Вычислить обратный тангенс x, где результат в градусах.

sec(x)

Вычислить секанс x, где x в радианах.

csc(x)

Вычислить косеканс x, где x в радианах.

cot(x)

Вычислить котангенс x, где x в радианах.

secd(x)

Вычислить секанс x, где x в градусах.

cscd(x)

Вычислить косеканс x, где x в градусах.

cotd(x)

Вычислить котангенс x, где x в градусах.

asec(x)

Вычислить обратный секанс x, где результат в радианах.

acsc(x)

Вычислить обратный косеканс x, где результат в радианах.

acot(x)

Вычислить обратный котангенс x, где результат в радианах.

asecd(x)

Вычислить обратный секанс x, где результат в градусах.

acscd(x)

Вычислить обратный косеканс x, где результат в градусах.

acotd(x)

Вычислить обратный котангенс x, где результат в градусах.

sech(x)

Вычислить гиперболический секанс x

csch(x)

Вычислить гиперболический косекант от x.

coth(x)

Вычислить гиперболический котангенс от x.

asinh(x)

Вычислить обратный гиперболический синус от x.

acosh(x)

Вычислить обратный гиперболический косинус от x.

atanh(x)

Вычислить обратный гиперболический тангенс от x.

asech(x)

Вычислить обратный гиперболический секант от x.

acsch(x)

Вычислить обратный гиперболический косекант от x.

acoth(x)

Вычислить обратный гиперболический котангенс от x.

sinc(x)

Вычислить \(\sin(\pi x) / (\pi x)\), если \(x \neq 0\), и \(1\), если \(x = 0\).

cosc(x)

Вычислить \(\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)\), если \(x \neq 0\), и \(0\), если \(x = 0\). Это производная от sinc(x).

deg2rad(x)

Преобразовать x из градусов в радианы.

rad2deg(x)

Преобразовать x из радиан в градусы.

hypot(x, y)

Вычислить гипотенузу \(\sqrt{x^2+y^2}\), избегая переполнения и потери точности.

hypot(x...)

Вычислить гипотенузу \(\sqrt{\sum x_i^2}\), избегая переполнения и потери точности.

log(x)

Вычислить натуральный логарифм от x . Бросает исключение DomainError для отрицательных аргументов Real. Используйте комплексные отрицательные аргументы для получения комплексных результатов.

Есть экспериментальная реализация в модуле Base.Math.JuliaLibm, которая обычно быстрее и точнее.

log(b, x)

Вычислить логарифм по основанию b от x . Бросает исключение DomainError для отрицательных аргументов Real.

julia> log(4,8)
1.5

julia> log(4,2)
0.5

Примечание

Если b является степенью 2 или 10, следует использовать log2 или log10, так как они обычно быстрее и точнее. Например,

julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0

log2(x)

Вычислить логарифм по основанию 2 от x . Бросает исключение DomainError для отрицательных аргументов Real.

log10(x)

Вычислить логарифм по основанию 10 от x . Бросает исключение DomainError для отрицательных аргументов Real.

log1p(x)

Точно вычислить натуральный логарифм от 1+x . Бросает исключение DomainError для аргументов меньше -1.

Есть экспериментальная реализация в модуле Base.Math.JuliaLibm, которая обычно быстрее и точнее.

frexp(val)

Возвращает (x,exp) такое, что x имеет величину в интервале \([1/2, 1)\) или 0, и val = \(x \times 2^{exp}\).

exp(x)

Вычислить \(e^x\).

exp2(x)

Вычислить \(2^x\).

exp10(x)

Вычислить \(10^x\).

ldexp(x, n)

Вычислить \(x \times 2^n\).

modf(x)

Возвращает пару (fpart, ipart) дробной и целой частей числа. Обе части имеют тот же знак, что и аргумент.

expm1(x)

Точно вычислить \(e^x-1\).

round([T, ]x[, digits[, base]][, r::RoundingMode])

Округляет x до целого значения в соответствии с указанным RoundingMode, возвращая значение того же типа, что и x . При отсутствии указания режима округления используется глобальный режим (см. rounding()), который по умолчанию округляет до ближайшего целого (RoundNearest режим), а при равенстве (дробная часть равна 0,5) округляет к ближайшему четному числу.

julia> round(1.7)
2.0

julia> round(1.5)
2.0

julia> round(2.5)
2.0

Необязательный аргумент RoundingMode изменит способ округления.

round(T, x, [r::RoundingMode]) преобразует результат к типу T, бросая исключение InexactError, если значение не может быть представлено.

round(x, digits) округляет до указанного числа цифр после запятой (или до указанного числа цифр перед запятой, если отрицательное число). round(x, digits, base) округляет с основанием, отличным от 10.

julia> round(pi, 2)
3.14

julia> round(pi, 3, 2)
3.125

Примечание

Округление до указанного числа цифр в основаниях, отличных от 2, может быть неточным при работе с двоичными числами с плавающей точкой. Например, значение Float64, представленное как 1.15, фактически меньше, чем 1,15, но будет округлено до 1,2.

julia> x = 1.15
1.15

julia> @sprintf "%.20f" x
"1.14999999999999991118"

julia> x < 115//100
true

julia> round(x, 1)
1.2

RoundingMode

Тип, используемый для управления режимом округления операций с плавающей точкой (через функции rounding()/setrounding()), или в качестве необязательных аргументов для округления до ближайшего целого (через функцию round()).

В настоящее время поддерживаются следующие режимы округления:

• RoundNearest (по умолчанию)
• RoundNearestTiesAway
• RoundNearestTiesUp
• RoundToZero
• RoundFromZero (только для BigFloat)
• RoundUp
• RoundDown

RoundNearest

Режим округления по умолчанию. Округляет до ближайшего целого, а при равенстве (дробная часть равна 0,5) округляет к ближайшему четному числу.

RoundNearestTiesAway

Округляет до ближайшего целого, а при равенстве округляет в сторону от нуля (поведение C/C++ round()).

RoundNearestTiesUp

Округляет до ближайшего целого, а при равенстве округляет к положительной бесконечности (поведение Java/JavaScript round()).

RoundToZero

round() с этим режимом округления является псевдонимом для trunc().

RoundUp

round() с этим режимом округления является псевдонимом для ceil().

RoundDown

round() с этим режимом округления является псевдонимом для floor().

round(z, RoundingModeReal, RoundingModeImaginary)

Возвращает ближайшее целое значение того же типа, что и комплексное значение z к z, разрывая связи с использованием указанных RoundingMode. Первый RoundingMode используется для округления вещественных компонентов, а второй — для округления мнимых компонентов.

ceil([T, ]x[, digits[, base]])

ceil(x) возвращает ближайшее целое значение того же типа, что и x, которое больше или равно x.

ceil(T, x) преобразует результат в тип T, выбрасывая исключение InexactError если значение не может быть представлено.

digits и base работают так же, как для round().

floor([T, ]x[, digits[, base]])

floor(x) возвращает ближайшее целое значение того же типа, что и x, которое меньше или равно x.

floor(T, x) преобразует результат в тип T, выбрасывая исключение InexactError если значение не может быть представлено.

digits и base работают так же, как для round().

trunc([T, ]x[, digits[, base]])

trunc(x) возвращает ближайшее целое значение того же типа, что и x, модуль которого меньше или равен x.

trunc(T, x) преобразует результат в тип T, выбрасывая исключение InexactError если значение не может быть представлено.

digits и base работают так же, как для round().

unsafe_trunc(T, x)

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

signif(x, digits[, base])

Округляет (в смысле round) x таким образом, чтобы значащих цифр было digits, в представлении по основанию base, по умолчанию 10. Например, signif(123.456, 2) равно 120.0, и signif(357.913, 4, 2) равно 352.0.

min(x, y, ...)

Возвращает минимальное значение из аргументов. Операция выполняется поэлементно для массивов.

max(x, y, ...)

Возвращает максимальное значение из аргументов. Операция выполняется поэлементно для массивов.

minmax(x, y)

Возвращает (min(x,y), max(x,y)). См. также: extrema(), который возвращает (minimum(x), maximum(x)).

julia> minmax('c','b')
('b','c')

clamp(x, lo, hi)

Возвращает x если lo <= x <= hi. Если x < lo, возвращает lo. Если x > hi, возвращает hi. Аргументы приводятся к общему типу. Операция выполняется поэлементно над массивами, если x является массивом.

julia> clamp([pi, 1.0, big(10.)], 2., 9.)
3-element Array{BigFloat,1}:
 3.141592653589793238462643383279502884197169399375105820974944592307816406286198
 2.000000000000000000000000000000000000000000000000000000000000000000000000000000
 9.000000000000000000000000000000000000000000000000000000000000000000000000000000

clamp!(array::AbstractArray, lo, hi)

Ограничивает значения в array заданным диапазоном, на месте. См. также clamp().

abs(x)

Модуль x.

Когда abs применяется к целым числам со знаком, может произойти переполнение, что приведёт к возвращению отрицательного значения. Это переполнение происходит только тогда, когда abs применяется к минимальному представимому значению целого числа со знаком. То есть, когда x == typemin(typeof(x)), abs(x) == x < 0, а не -x как можно было бы ожидать.

Base.checked_abs(x)

Вычисляет abs(x), проверяя на ошибки переполнения, где это применимо. Например, стандартные целые числа со знаком в дополнительном коде (например, Int) не могут представлять abs(typemin(Int)), что приводит к переполнению.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_neg(x)

Вычисляет -x, проверяя на ошибки переполнения, где это применимо. Например, стандартные целые числа со знаком в дополнительном коде (например, Int) не могут представлять -typemin(Int), что приводит к переполнению.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_add(x, y)

Вычисляет x+y, проверяя на ошибки переполнения, где это применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_sub(x, y)

Вычисляет x-y, проверяя на ошибки переполнения, где это применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_mul(x, y)

Вычисляет x*y, проверяя на ошибки переполнения, где это применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_div(x, y)

Вычисляет div(x,y), проверяя на ошибки переполнения, где это применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_rem(x, y)

Вычисляет x%y, проверяя на ошибки переполнения, где это применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_fld(x, y)

Вычисляет fld(x,y), проверяя на ошибки переполнения, где это применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_mod(x, y)

Вычисляет mod(x,y), проверяя на ошибки переполнения, где это применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_cld(x, y)

Вычисляет cld(x,y), проверяя на ошибки переполнения, где это применимо.

Защита от переполнения может привести к заметному снижению производительности.

abs2(x)

Возвращает квадрат модуля x.

copysign(x, y)

Возвращает x с тем же знаком, что и y.

sign(x)

Возвращает ноль, если x==0, и \(x/|x|\) в противном случае (т.е., ±1 для вещественных x).

signbit(x)

Возвращает true если знак x отрицательный, иначе false.

flipsign(x, y)

Возвращает x с изменённым знаком, если y отрицательно. Например, abs(x) = flipsign(x,x).

sqrt(x)

Возвращает \(\sqrt{x}\). Выбрасывает DomainError для отрицательных Real аргументов. Используйте комплексные отрицательные аргументы вместо этого. Префиксный оператор √ эквивалентен sqrt.

isqrt(n)

Целочисленный квадратный корень: наибольшее целое m такое, что m*m <= n.

cbrt(x)

Возвращает \(x^{1/3}\). Префиксный оператор ∛ эквивалентен cbrt.

erf(x)

Вычисляет функцию ошибки от x, определённую как \(\frac{2}{\sqrt{\pi}} \int_0^x e^{-t^2} dt\) для произвольных комплексных x.

erfc(x)

Вычисляет дополнительную функцию ошибки от x, определённую как \(1 - \operatorname{erf}(x)\).

erfcx(x)

Вычисляет масштабированную дополнительную функцию ошибки от x, определённую как \(e^{x^2} \operatorname{erfc}(x)\). Также обратите внимание, что \(\operatorname{erfcx}(-ix)\) вычисляет функцию Фаддеева \(w(x)\).

erfi(x)

Вычисляет мнимую функцию ошибки от x, определённую как \(-i \operatorname{erf}(ix)\).

dawson(x)

Вычисляет функцию Доусона (масштабированная мнимая функция ошибки) от x, определённую как \(\frac{\sqrt{\pi}}{2} e^{-x^2} \operatorname{erfi}(x)\).

erfinv(x)

Вычисляет обратную функцию ошибки вещественного x, определённую как \(\operatorname{erf}(\operatorname{erfinv}(x)) = x\).

erfcinv(x)

Вычисляет обратную дополнительную функцию ошибки вещественного x, определённую как \(\operatorname{erfc}(\operatorname{erfcinv}(x)) = x\).

real(z)

Возвращает действительную часть комплексного числа z.

imag(z)

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

reim(z)

Возвращает действительную и мнимую части комплексного числа z.

conj(z)

Вычисляет комплексно-сопряжённое число комплексного числа z.

angle(z)

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

cis(z)

Возвращает \(\exp(iz)\).

binomial(n, k)

Количество способов выбрать k из n элементов.

factorial(n)

Факториал n. Если n — целое число, факториал вычисляется как целое число (преобразованное к типу как минимум 64 бита). Обратите внимание, что это может привести к переполнению, если n не мало, но вы можете использовать factorial(big(n)) для точного вычисления результата с произвольной точностью. Если n не целое число, factorial(n) эквивалентно gamma(n+1).

gcd(x, y)

Наибольший общий (положительный) делитель (или ноль, если x и y оба равны нулю).

lcm(x, y)

Наименьшее общее кратное (неотрицательное).

gcdx(x, y)

Вычисляет наибольший общий (положительный) делитель x и y, а также коэффициенты Безу, т. е. целые коэффициенты u и v, которые удовлетворяют \(ux+vy = d = gcd(x,y)\). \(gcdx(x,y)\) возвращает \((d,u,v)\).

julia> gcdx(12, 42)
(6,-3,1)

julia> gcdx(240, 46)
(2,-9,47)

Примечание

Коэффициенты Безу не определяются однозначно. gcdx возвращает минимальные коэффициенты Безу, которые вычисляются с помощью расширенного алгоритма Евклида. (См.: D. Knuth, TAoCP, 2/e, стр. 325, Алгоритм X.) Для целых чисел со знаком эти коэффициенты u и v минимальны в том смысле, что \(|u| < |y/d|\) и \(|v| < |x/d|\). Кроме того, знаки u и v выбираются так, чтобы d было положительным. Для беззнаковых целых чисел коэффициенты u и v могут быть близки к своим typemax, и тождество в этом случае выполняется только с помощью арифметики по модулю беззнаковых целых чисел.

ispow2(n) → Bool

Проверяет, является ли n степенью двойки.

nextpow2(n)

Наименьшая степень двойки, не меньшая, чем n. Возвращает 0 для n==0, и возвращает -nextpow2(-n) для отрицательных аргументов.

prevpow2(n)

Наибольшая степень двойки, не большая, чем n. Возвращает 0 для n==0, и возвращает -prevpow2(-n) для отрицательных аргументов.

nextpow(a, x)

Наименьшее a^n , не меньшее, чем x, где n — неотрицательное целое число. a должно быть больше 1, а x должно быть больше 0.

prevpow(a, x)

Наибольшее a^n , не большее, чем x, где n — неотрицательное целое число. a должно быть больше 1, а x не должно быть меньше 1.

nextprod([k_1, k_2, ..., ]n)

Следующее целое число, не меньшее, чем n , которое можно представить в виде \(\prod k_i^{p_i}\) для целых чисел \(p_1\), \(p_2\) и т. д.

invmod(x, m)

Вычисляет обратное число x по модулю m: y такое, что \(x y = 1 \pmod m\), при \(div(x,y) = 0\). Неопределено для \(m = 0\) или если \(gcd(x,m) \neq 1\).

powermod(x, p, m)

Вычисляет \(x^p \pmod m\).

gamma(x)

Вычисляет гамма-функцию от x.

lgamma(x)

Вычисляет логарифм абсолютного значения gamma() для Real x, в то время как для Complex x вычисляет логарифм gamma(x).

lfact(x)

Вычисляет логарифмический факториал x

digamma(x)

Вычисляет функцию дигамма от x (логарифмическую производную от gamma(x)).

invdigamma(x)

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

trigamma(x)

Вычисляет функцию тригамма от x (логарифмическую вторую производную от gamma(x)).

polygamma(m, x)

Вычисляет функцию полигамма порядка m от аргумента x ((m+1)th производная логарифма gamma(x)).

airy(k, x)

k производная функции Эйри \(\operatorname{Ai}(x)\).

airyai(x)

Функция Эйри \(\operatorname{Ai}(x)\).

airyprime(x)

Производная функции Эйри \(\operatorname{Ai}'(x)\).

airyaiprime(x)

Производная функции Эйри \(\operatorname{Ai}'(x)\).

airybi(x)

Функция Эйри \(\operatorname{Bi}(x)\).

airybiprime(x)

Производная функции Эйри \(\operatorname{Bi}'(x)\).

airyx(k, x)

масштабированная k-я производная функции Эйри, возвращает \(\operatorname{Ai}(x) e^{\frac{2}{3} x \sqrt{x}}\) для k == 0 || k == 1, и \(\operatorname{Ai}(x) e^{- \left| \operatorname{Re} \left( \frac{2}{3} x \sqrt{x} \right) \right|}\) для k == 2 || k == 3.

besselj0(x)

Функция Бесселя первого рода нулевого порядка, \(J_0(x)\).

besselj1(x)

Функция Бесселя первого рода первого порядка, \(J_1(x)\).

besselj(nu, x)

Функция Бесселя первого рода порядка nu, \(J_\nu(x)\).

besseljx(nu, x)

Масштабированная функция Бесселя первого рода порядка nu, \(J_\nu(x) e^{- | \operatorname{Im}(x) |}\).

bessely0(x)

Функция Бесселя второго рода нулевого порядка, \(Y_0(x)\).

bessely1(x)

Функция Бесселя второго рода первого порядка, \(Y_1(x)\).

bessely(nu, x)

Функция Бесселя второго рода порядка nu, \(Y_\nu(x)\).

besselyx(nu, x)

Масштабированная функция Бесселя второго рода порядка nu, \(Y_\nu(x) e^{- | \operatorname{Im}(x) |}\).

hankelh1(nu, x)

Функция Бесселя третьего рода порядка nu, \(H^{(1)}_\nu(x)\).

hankelh1x(nu, x)

Масштабированная функция Бесселя третьего рода порядка nu, \(H^{(1)}_\nu(x) e^{-x i}\).

hankelh2(nu, x)

Функция Бесселя третьего рода порядка nu, \(H^{(2)}_\nu(x)\).

hankelh2x(nu, x)

Масштабированная функция Бесселя третьего рода порядка nu, \(H^{(2)}_\nu(x) e^{x i}\).

besselh(nu, [k=1, ]x)

Функция Бесселя третьего рода порядка nu (функция Ханкеля). k равно либо 1, либо 2, выбирая hankelh1() или hankelh2() соответственно. k по умолчанию равно 1, если оно опущено. (См. также besselhx() для варианта с экспоненциальным масштабированием.)

besselhx(nu, [k=1, ]z)

Вычислить масштабированную функцию Ханкеля \(\exp(∓iz) H_ν^{(k)}(z)\), где \(k\) равно 1 или 2, \(H_ν^{(k)}(z)\) — besselh(nu, k, z), а \(∓\) — \(-\) для \(k=1\) и \(+ \) для \(k=2\). k по умолчанию равно 1, если оно опущено.

Причина создания этой функции заключается в том, что \(H_ν^{(k)}(z)\) асимптотически пропорциональна \(\exp(∓iz)/\sqrt{z}\) для больших \(|z|\), и поэтому функция besselh() подвержена переполнению или потере точности, когда z имеет большую мнимую часть. Функция besselhx отменяет этот экспоненциальный множитель (аналитически), поэтому она избегает этих проблем.

besseli(nu, x)

Модифицированная функция Бесселя первого рода порядка nu, \(I_\nu(x)\).

besselix(nu, x)

Масштабированная модифицированная функция Бесселя первого рода порядка nu, \(I_\nu(x) e^{- | \operatorname{Re}(x) |}\).

besselk(nu, x)

Модифицированная функция Бесселя второго рода порядка nu, \(K_\nu(x)\).

besselkx(nu, x)

Масштабированная модифицированная функция Бесселя второго рода порядка nu, \(K_\nu(x) e^x\).

beta(x, y)

Интеграл Эйлера первого рода \(\operatorname{B}(x,y) = \Gamma(x)\Gamma(y)/\Gamma(x+y)\).

lbeta(x, y)

Натуральный логарифм абсолютного значения функции бета \(\log(|\operatorname{B}(x,y)|)\).

eta(x)

Функция Дирихле эта \(\eta(s) = \sum^\infty_{n=1}(-1)^{n-1}/n^{s}\).

zeta(s)

Функция Римана дзета \(\zeta(s)\).

zeta(s, z)

Обобщенная функция дзета \(\zeta(s, z)\), определенная суммой \(\sum_{k=0}^\infty ((k+z)^2)^{-s/2}\), где любой член с \(k+z=0\) исключается. Для \(\Re z > 0\) это определение эквивалентно функции дзета Гурвица \(\sum_{k=0}^\infty (k+z)^{-s}\). Для \(z=1\) она дает функцию дзета Римана \(\zeta(s)\).

ndigits(n, b = 10)

Вычислить количество цифр в числе n в системе счисления b.

widemul(x, y)

Перемножить x и y, представив результат в более широком типе.

@evalpoly(z, c...)

Вычислить многочлен \(\sum_k c[k] z^{k-1}\) для коэффициентов c[1], c[2], ...; то есть коэффициенты заданы в порядке возрастания степени z. Этот макрос расширяется до эффективного встроенного кода, использующего метод Хорнера или, для комплексных z, более эффективный алгоритм типа Гоертцеля.

Статистики

mean(v[, region])

Вычислить среднее значение всего массива v, или по умолчанию по измерениям в region.

Примечание

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

mean(f::Function, v)

Применить функцию f к каждому элементу v и вычислить среднее.

mean!(r, v)

Вычислить среднее значение v по единичным измерениям r и записать результат в r.

std(v[, region]; corrected::Bool=true, mean=nothing)

Вычислить выборочное стандартное отклонение вектора или массива v, необязательно по измерениям в region. Алгоритм возвращает оценку стандартного отклонения генерирующего распределения при предположении, что каждый элемент v — независимо и одинаково распределенная случайная величина, взятая из этого генерирующего распределения. Это вычисление эквивалентно вычислению sqrt(sum((v - mean(v)).^2) / (length(v) - 1)). Может быть предоставлено предварительно вычисленное значение mean.

Примечание

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

stdm(v, m::Number; corrected::Bool=true)

Вычислить выборочное стандартное отклонение вектора v с известным средним значением m. Если corrected равно true, сумма масштабируется с помощью n-1, в противном случае с помощью n, если corrected равно false, где n = length(x).

Примечание

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

var(v[, region])

Вычислить выборочную дисперсию вектора или массива v, необязательно по измерениям в region. Алгоритм вернет оценку дисперсии генерирующего распределения при предположении, что каждый элемент v — независимо и одинаково распределенная случайная величина, взятая из этого генерирующего распределения. Это вычисление эквивалентно вычислению sumabs2(v - mean(v)) / (length(v) - 1). Примечание: Julia не игнорирует NaN значения при вычислении. Для приложений, требующих обработки пропущенных данных, рекомендуется использовать пакет DataArray.

varm(v, m[, region]; corrected::Bool=true)

Вычислить выборочную дисперсию набора v с известным(и) средним(и) значением(и) m, необязательно по region. m может содержать средние значения для каждого измерения v. Если corrected равно true, сумма масштабируется с помощью n-1, в противном случае с помощью n, если corrected равно false, где n = length(x).

Примечание

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

middle(x)

Вычислить середину скалярного значения, что эквивалентно самому x, но с типом middle(x, x) для согласованности.

middle(x, y)

Вычислить середину двух вещественных чисел x и y, что эквивалентно вычислению их среднего значения ((x + y) / 2).

middle(range)

Вычислить середину диапазона, что заключается в вычислении среднего его экстремумов. Поскольку диапазон отсортирован, среднее вычисляется по первому и последнему элементу.

julia> middle(1:10)
5.5

middle(a)

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

julia> a = [1,2,3.6,10.9]
4-element Array{Float64,1}:
  1.0
  2.0
  3.6
 10.9

julia> middle(a)
5.95

median(v[, region])

Вычислить медиану всего массива v, или необязательно по измерениям в region. При четном количестве элементов точного медианного элемента не существует, поэтому результат эквивалентен вычислению среднего двух медианных элементов.

Примечание

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

median!(v)

Подобно median, но может перезаписать входной вектор.

midpoints(e)

Вычислить середины интервалов с границами e. Результат — вектор/диапазон длиной length(e) - 1. Примечание: Julia не игнорирует NaN значения при вычислении.

quantile(v, p; sorted=false)

Вычислить квантиль(и) вектора v в заданной вероятности или векторе p. Ключевое слово-аргумент sorted указывает, можно ли считать v отсортированным.

Значение p должно находиться в интервале [0,1], а v не должно содержать NaN значений.

Квантили вычисляются с помощью линейной интерполяции между точками ((k-1)/(n-1), v[k]), для k = 1:n где n = length(v). Это соответствует определению 7 Гиндмана и Фана (1996) и совпадает со значением по умолчанию в R.

Примечание

Julia не игнорирует NaN значения при вычислении. Для приложений, требующих обработки пропущенных данных, рекомендуется использовать пакет DataArrays.jl. quantile выбросит ArgumentError в случае наличия NaN значений в массиве данных.

• Гиндман, Р.Дж. и Фан, Ю. (1996) «Выборочные квантили в статистических пакетах», The American Statistician, том 50, № 4, стр. 361-365

quantile!([q, ]v, p; sorted=false)

Вычислить квантиль(и) вектора v по вероятностям p, с необязательной передачей результата в массив q (если не указан, создаётся новый массив вывода). Ключевое слово-аргумент sorted указывает, можно ли считать v отсортированным; если false (значение по умолчанию), элементы v могут быть частично отсортированы.

Элементы p должны находиться в интервале [0,1], и v не должно содержать NaN значений.

Квантили вычисляются с помощью линейной интерполяции между точками ((k-1)/(n-1), v[k]), для k = 1:n где n = length(v). Это соответствует определению 7 Гиндмана и Фана (1996) и совпадает со значением по умолчанию в R.

Примечание

Julia не игнорирует NaN значения при вычислении. Для приложений, требующих обработки пропущенных данных, рекомендуется использовать пакет DataArrays.jl. quantile! выбросит ArgumentError в случае наличия NaN значений в массиве данных.

• Гиндман, Р.Дж. и Фан, Ю. (1996) «Выборочные квантили в статистических пакетах», The American Statistician, том 50, № 4, стр. 361-365

cov(x[, corrected=true])

Вычислить дисперсию вектора x. Если corrected равно true (значение по умолчанию), то сумма масштабируется с помощью n-1, в противном случае, если corrected равно false где n = length(x), с помощью n.

cov(X[, vardim=1, corrected=true])

Вычислить ковариационную матрицу матрицы X по размерности vardim. Если corrected равно true (значение по умолчанию), то сумма масштабируется с помощью n-1, в противном случае, если corrected равно false где n = size(X, vardim), с помощью n.

cov(x, y[, corrected=true])

Вычислить ковариацию между векторами x и y. Если corrected равно true (значение по умолчанию), то сумма масштабируется с помощью n-1, в противном случае, если corrected равно false где n = length(x) = length(y), с помощью n.

cov(X, Y[, vardim=1, corrected=true])

Вычислить ковариацию между векторами или матрицами X и Y по размерности vardim. Если corrected равно true (значение по умолчанию), то сумма масштабируется с помощью n-1, в противном случае, если corrected равно false где n = size(X, vardim) = size(Y, vardim), с помощью n.

cor(x)

Возвращает число один.

cor(X[, vardim=1])

Вычислить матрицу корреляции Пирсона для матрицы X по размерности vardim.

cor(x, y)

Вычислить корреляцию Пирсона между векторами x и y.

cor(X, Y[, vardim=1])

Вычислить корреляцию Пирсона между векторами или матрицами X и Y по размерности vardim.

Обработка сигналов

Функции быстрой Фурье-трансформации (БПФ) в Julia реализуются путём вызова функций из FFTW.

fft(A[, dims])

Выполняет многомерную БПФ массива A. Необязательный аргумент dims указывает итерируемый подмножество размерностей (например, целое число, диапазон, кортеж или массив), по которым нужно выполнить преобразование. Наиболее эффективно, если размер A по преобразованным размерностям является произведением малых простых чисел; см. nextprod(). См. также plan_fft() для ещё большей эффективности.

Одномерная БПФ вычисляет одномерное дискретное преобразование Фурье (ДПФ), как определено

\[\operatorname{DFT}(A)[k] = \sum_{n=1}^{\operatorname{length}(A)} \exp\left(-i\frac{2\pi (n-1)(k-1)}{\operatorname{length}(A)} \right) A[n].\]

Многомерная БПФ просто выполняет эту операцию по каждой преобразованной размерности A.

Примечание

• Julia по умолчанию запускает FFTW с 1 потоком. Более высокая производительность обычно возможна путём увеличения числа потоков. Используйте FFTW.set_num_threads(Sys.CPU_CORES) для использования столько потоков, сколько ядер на вашем компьютере.
• По умолчанию выполняется многомерная БПФ. Библиотеки БПФ в других языках, таких как Python и Octave, выполняют одномерную БПФ по первой неединичной размерности массива. Это стоит учитывать при проведении сравнений. Более подробная информация доступна в разделе Примечательные различия с другими языками руководства.

fft!(A[, dims])

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

ifft(A[, dims])

Многомерное обратное БПФ.

Одномерное обратное БПФ вычисляет

\[\operatorname{IDFT}(A)[k] = \frac{1}{\operatorname{length}(A)} \sum_{n=1}^{\operatorname{length}(A)} \exp\left(+i\frac{2\pi (n-1)(k-1)} {\operatorname{length}(A)} \right) A[n].\]

Многомерное обратное БПФ просто выполняет эту операцию по каждой преобразованной размерности A.

ifft!(A[, dims])

То же, что и ifft(), но работает на месте с A.

bfft(A[, dims])

Аналогично ifft(), но вычисляет ненормализованное обратное (обратное) преобразование, которое необходимо разделить на произведение размеров преобразованных размерностей, чтобы получить обратное. (Это немного эффективнее, чем ifft(), поскольку он опускает шаг масштабирования, который в некоторых приложениях можно объединить с другими вычислительными шагами в другом месте.)

\[\operatorname{BDFT}(A)[k] = \operatorname{length}(A) \operatorname{IDFT}(A)[k]\]

bfft!(A[, dims])

То же, что и bfft(), но работает на месте с A.

plan_fft(A [, dims]; flags=FFTW.ESTIMATE; timelimit=Inf)

Предварительно спланируйте оптимизированное преобразование Фурье (FFT) по заданным измерениям (dims) массивов, соответствующих форме и типу A. (Два первых аргумента имеют тот же смысл, что и для fft().) Возвращает объект P, который представляет линейный оператор, вычисленный с помощью FFT, и который содержит всю информацию, необходимую для быстрого вычисления fft(A, dims).

Чтобы применить P к массиву A, используйте P * A; в общем случае синтаксис применения планов очень похож на синтаксис матриц. (План можно применить только к массивам такого же размера, что и A для которого был создан план.) Вы также можете применить план с предварительно выделенным выходным массивом Â, вызвав A_mul_B!(Â, plan, A). (Однако для A_mul_B!, входной массив A должен быть массивом комплексных чисел с плавающей точкой, подобным выходному Â.) Вы можете вычислить план обратного преобразования, используя inv(P) и применить обратный план с помощью P \ Â (обратный план кешируется и повторно используется для последующих вызовов inv или \), а также применить обратный план к предварительно выделенному выходному массиву A с помощью A_ldiv_B!(A, P, Â).

Аргумент flags представляет собой побитовое ИЛИ флагов планировщика FFTW, по умолчанию FFTW.ESTIMATE. Например, передача FFTW.MEASURE или FFTW.PATIENT вместо этого потратит несколько секунд (или более), тестируя различные возможные алгоритмы FFT и выбирая самый быстрый; см. руководство FFTW для получения дополнительной информации о флагах планировщика. Необязательный аргумент timelimit задает приблизительную верхнюю границу допустимого времени планирования в секундах. Передача FFTW.MEASURE или FFTW.PATIENT может привести к тому, что входной массив A будет перезаписан нулями во время создания плана.

plan_fft!() эквивалентно plan_fft(), но создает план, который работает непосредственно над его аргументом (который должен быть массивом комплексных чисел с плавающей точкой). plan_ifft() и т.д. аналогичны, но создают планы, выполняющие эквивалент обратных преобразований ifft() и т.д.

plan_ifft(A [, dims]; flags=FFTW.ESTIMATE; timelimit=Inf)

То же, что и plan_fft(), но создает план, выполняющий обратные преобразования ifft().

plan_bfft(A [, dims]; flags=FFTW.ESTIMATE; timelimit=Inf)

То же, что и plan_fft(), но создает план, выполняющий ненормализованное обратное преобразование bfft().

plan_fft!(A [, dims]; flags=FFTW.ESTIMATE; timelimit=Inf)

То же, что и plan_fft(), но работает непосредственно над A.

plan_ifft!(A [, dims]; flags=FFTW.ESTIMATE; timelimit=Inf)

То же, что и plan_ifft(), но работает непосредственно над A.

plan_bfft!(A [, dims]; flags=FFTW.ESTIMATE; timelimit=Inf)

То же, что и plan_bfft(), но работает непосредственно над A.

rfft(A[, dims])

Многомерное преобразование Фурье (FFT) действительного массива A, используя тот факт, что преобразование обладает сопряжённой симметрией, чтобы сэкономить примерно половину времени вычислений и затрат памяти по сравнению с fft(). Если A имеет размер (n_1, ..., n_d), результат имеет размер (div(n_1,2)+1, ..., n_d).

Необязательный аргумент dims указывает итерируемое подмножество одной или нескольких размерностей A для преобразования, подобно fft(). Вместо (приблизительного) удвоения первой размерности A в результате, размерность dims[1] удваивается аналогичным образом.

irfft(A, d[, dims])

Обратное преобразование rfft(): для комплексного массива A даёт соответствующий действительный массив, чьё преобразование Фурье даёт A в первой половине. Как и в rfft(), dims является необязательным подмножеством размерностей для преобразования, по умолчанию 1:ndims(A).

d представляет длину преобразованного действительного массива вдоль размерности dims[1], которая должна удовлетворять div(d,2)+1 == size(A,dims[1]). (Этот параметр нельзя вывести из size(A), так как оба 2*size(A,dims[1])-2 и 2*size(A,dims[1])-1 являются допустимыми размерами для преобразованного действительного массива.)

brfft(A, d[, dims])

Аналогично irfft(), но вычисляет ненормализованное обратное преобразование (аналогично bfft()), которое необходимо разделить на произведение размеров преобразованных размерностей (действительного выходного массива), чтобы получить обратное преобразование.

plan_rfft(A [, dims]; flags=FFTW.ESTIMATE; timelimit=Inf)

Предварительно спланируйте оптимизированное преобразование Фурье с действительным входом, аналогично plan_fft(), за исключением rfft() вместо fft(). Два первых аргумента и размер преобразованного результата такие же, как и для rfft().

plan_brfft(A, d [, dims]; flags=FFTW.ESTIMATE; timelimit=Inf)

Предварительно спланируйте оптимизированное ненормализованное преобразование с действительным входом, аналогично plan_rfft(), за исключением brfft() вместо rfft(). Два первых аргумента и размер преобразованного результата такие же, как и для brfft().

plan_irfft(A, d [, dims]; flags=FFTW.ESTIMATE; timelimit=Inf)

Предварительно спланируйте оптимизированное обратное преобразование Фурье с действительным входом, аналогично plan_rfft(), за исключением irfft() и brfft() соответственно. Три первых аргумента имеют тот же смысл, что и для irfft().

dct(A[, dims])

Вычисляет многомерное дискретное косинусное преобразование (DCT) типа II массива A, используя унитарную нормализацию DCT. Необязательный аргумент dims указывает итерируемое подмножество размерностей (например, целое число, диапазон, кортеж или массив) для преобразования. Наиболее эффективно, если размер A по преобразованным размерностям является произведением малых простых чисел; см. nextprod(). См. также plan_dct() для ещё большей эффективности.

dct!(A[, dims])

То же, что и dct!(), за исключением того, что оно работает непосредственно над A, который должен быть массивом действительных или комплексных чисел с плавающей точкой.

idct(A[, dims])

Вычисляет многомерное обратное дискретное косинусное преобразование (DCT) массива A (технически, DCT типа III с унитарной нормализацией). Необязательный аргумент dims указывает итерируемое подмножество размерностей (например, целое число, диапазон, кортеж или массив) для преобразования. Наиболее эффективно, если размер A по преобразованным размерностям является произведением малых простых чисел; см. nextprod(). См. также plan_idct() для ещё большей эффективности.

idct!(A[, dims])

То же, что и idct!(), но работает непосредственно над A.

plan_dct(A[, dims[, flags[, timelimit]]])

Предварительно спланируйте оптимизированное дискретное косинусное преобразование (DCT), аналогично plan_fft(), за исключением того, что генерирует функцию, вычисляющую dct(). Два первых аргумента имеют тот же смысл, что и для dct().

plan_dct!(A[, dims[, flags[, timelimit]]])

То же, что и plan_dct(), но работает непосредственно над A.

plan_idct(A[, dims[, flags[, timelimit]]])

Предварительно спланировать оптимизированное обратное дискретное косинусное преобразование (DCT), аналогичное plan_fft(), за исключением того, что создается функция, вычисляющая idct(). Первые два аргумента имеют то же значение, что и для idct().

plan_idct!(A[, dims[, flags[, timelimit]]])

То же, что и plan_idct(), но выполняется на месте с A.

fftshift(x)

Поменять местами первую и вторую половины каждого измерения x.

fftshift(x, dim)

Поменять местами первую и вторую половины заданного измерения массива x.

ifftshift(x[, dim])

Отменяет действие fftshift.

filt(b, a, x[, si])

Применить фильтр, описываемый векторами a и b к вектору x, с необязательным начальным вектором состояния фильтра si (по умолчанию нули).

filt!(out, b, a, x[, si])

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

deconv(b, a)

Построить вектор c такой, что b = conv(a,c) + r. Эквивалентно делению многочленов.

conv(u, v)

Свертка двух векторов. Используется алгоритм БПФ.

conv2(u, v, A)

Двумерная свертка матрицы A с двумерным разделительным ядром, сгенерированным векторами u и v. Используется двумерный алгоритм БПФ.

conv2(B, A)

Двумерная свертка матрицы B с матрицей A. Используется двумерный алгоритм БПФ.

xcorr(u, v)

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

Следующие функции определены в модуле Base.FFTW.

r2r(A, kind[, dims])

Выполняет многомерное преобразование с действительным входом/выходом (r2r) типа kind массива A, как определено в руководстве FFTW. kind указывает либо дискретное косинусное преобразование различных типов (FFTW.REDFT00, FFTW.REDFT01, FFTW.REDFT10, или FFTW.REDFT11 ), либо дискретное синусное преобразование различных типов (FFTW.RODFT00, FFTW.RODFT01, FFTW.RODFT10, или FFTW.RODFT11 ), либо преобразование DFT с действительным входом и выходным значением в формате halfcomplex (FFTW.R2HC и его обратное FFTW.HC2R ), либо дискретное преобразование Хартли (FFTW.DHT). Аргумент kind может быть массивом или кортежем для задания различных типов преобразований по различным измерениям A; kind[end] используется для любых неопределенных измерений. См. руководство FFTW для точных определений этих типов преобразований по адресу http://www.fftw.org/doc.

Необязательный аргумент dims указывает итерируемый подмножество измерений (например, целое число, диапазон, кортеж или массив) для преобразования вдоль. kind[i] — это тип преобразования для dims[i], а kind[end] используется для i > length(kind).

См. также plan_r2r() для предварительной оптимизации r2r-преобразований.

r2r!(A, kind[, dims])

То же, что и r2r(), но работает на месте с A, который должен быть массивом действительных или комплексных чисел с плавающей точкой.

plan_r2r(A, kind[, dims[, flags[, timelimit]]])

Предварительно спланировать оптимизированное преобразование r2r, аналогичное Base.plan_fft(), за исключением того, что преобразования (и первые три аргумента) соответствуют r2r() и r2r!(), соответственно.

plan_r2r!(A, kind[, dims[, flags[, timelimit]]])

Аналогично Base.plan_fft(), но соответствует r2r!().

Численное интегрирование

Хотя для численного интегрирования и решения обыкновенных дифференциальных уравнений доступны несколько внешних пакетов, мы также предоставляем некоторую встроенную поддержку интегрирования в Julia.

quadgk(f, a, b, c...; reltol=sqrt(eps), abstol=0, maxevals=10^7, order=7, norm=vecnorm)

Численно интегрировать функцию f(x) от a до b, и необязательно по дополнительным интервалам b до c и так далее. Ключевые параметры включают относительную погрешность reltol (по умолчанию sqrt(eps) в точности конечных точек), абсолютную погрешность abstol (по умолчанию 0), максимальное число вычислений функции maxevals (по умолчанию 10^7 ), и order правила интегрирования (по умолчанию 7).

Возвращает пару (I,E) оценок интеграла I и оценки верхней границы абсолютной ошибки E. Если maxevals не превышена, то E <= max(abstol, reltol*norm(I)) будет содержать результат. (Обратите внимание, что полезно указать положительную abstol в случаях, когда norm(I) может быть нулевым.)

Конечные точки a и т.д. также могут быть комплексными (в этом случае интегрирование выполняется по прямым отрезкам в комплексной плоскости). Если конечные точки BigFloat, то интегрирование будет выполняться также с BigFloat точностью.

Примечание

Рекомендуется увеличивать интервал интегрирования order примерно пропорционально точности, для гладких подынтегральных функций.

Более общо, точность задаётся точностью конечных точек интегрирования (приведенных к типам с плавающей точкой).

Подынтегральная функция f(x) может возвращать любой числовой скаляр, вектор или матрицу, или, в действительности, любой тип, поддерживающий +, -, умножение на вещественные значения и norm (то есть любой нормированное векторное пространство). В качестве альтернативы, можно указать другую норму, передав функцию, похожую на norm, в качестве ключевого аргумента norm (по умолчанию vecnorm).

Примечание

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

Алгоритм — это адаптивный метод интегрирования Гаусса-Кронирода: интеграл в каждом интервале оценивается с помощью правила Кронирода (2*order+1 точек), а ошибка оценивается с помощью вложенного правила Гаусса (order точек). Затем интервал с наибольшей ошибкой делится на два интервала, и процесс повторяется до достижения требуемой погрешности.

Эти правила квадратур наилучшим образом работают для гладких функций внутри каждого интервала, поэтому, если ваша функция имеет известную разрывность или другую особенность, лучше разбить интервал так, чтобы эта особенность оказалась в конечной точке. Например, если у f есть разрыв в x=0.7 и вы хотите интегрировать от 0 до 1, вы должны использовать quadgk(f, 0,0.7,1) для разделения интервала в точке разрыва. Подынтегральная функция никогда не вычисляется точно в конечных точках интервалов, поэтому можно интегрировать функции, расходящиеся в конечных точках, при условии, что сингулярность интегрируема (например, сингулярность типа log(x) или 1/sqrt(x)).

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