Математика

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

Base.:-Метод

-(x)

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

Base.:+Функция

+(x, y...)

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

Base.:-Метод

-(x, y)

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

Base.:*Метод

*(x, y...)

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

Base.:/Функция

/(x, y)

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

Base.:\Метод

\(x, y)

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

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

julia> A = [1 2; 3 4]; x = [5, 6];

julia> A \ x
2-element Array{Float64,1}:
 -4.0
  4.5

julia> inv(A) * x
2-element Array{Float64,1}:
 -4.0
  4.5

Base.:^Метод

^(x, y)

Оператор возведения в степень. Если x — матрица, вычисляет возведение матрицы в степень.

Если y — целочисленная константа (например, 2 в x^2 или -3 в x^-3), код Julia x^y преобразуется компилятором в Base.literal_pow(^, x, Val{y}), чтобы обеспечить специализацию компиляции на значении показателя степени. (В качестве стандартного решения используется Base.literal_pow(^, x, Val{y}) = ^(x,y), где обычно ^ == Base.^, если ^ не определено в вызывающем пространстве имён.)

julia> 3^5
243

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> A^3
2×2 Array{Int64,2}:
 37   54
 81  118

Base.fmaФункция

fma(x, y, z)

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

Base.muladdФункция

muladd(x, y, z)

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

Пример

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

Base.divФункция

div(x, y)
÷(x, y)

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

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

Base.fldФункция

fld(x, y)

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

julia> fld(7.3,5.5)
1.0

Base.cldФункция

cld(x, y)

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

julia> cld(5.5,2.2)
3.0

Base.modФункция

mod(x, y)
rem(x, y, RoundDown)

Остаток от деления по Евклиду. Остаток от x по модулю y, или, эквивалентно, остаток от x после деления с отбрасыванием дробной части на y, т.е.

x - y*fld(x,y)

без промежуточного округления.

Результат будет иметь тот же знак, что и y, и величину меньше abs(y) (с некоторыми исключениями, см. примечание ниже).

julia> mod(8, 3)
2

julia> mod(9, 3)
0

julia> mod(8.9, 3)
2.9000000000000004

julia> mod(eps(), 3)
2.220446049250313e-16

julia> mod(-eps(), 3)
3.0

rem(x::Integer, T::Type{<:Integer}) -> T
mod(x::Integer, T::Type{<:Integer}) -> T
%(x::Integer, T::Type{<:Integer}) -> T

Найти y::T такое, что x ≡ y (mod n), где n — число целых чисел, представимых в T, а y — целое число в [typemin(T),typemax(T)]. Если T может представлять любое целое число (например, T == BigInt), то эта операция соответствует преобразованию в T.

julia> 129 % Int8
-127

Base.remФункция

rem(x, y)
%(x, y)

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

julia> x = 15; y = 4;

julia> x % y
3

julia> x == div(x, y) * y + rem(x, y)
true

Base.Math.rem2piФункция

rem2pi(x, r::RoundingMode)

Вычислить остаток от x после целочисленного деления на 2π, с округлением частного в соответствии с режимом округления r. Другими словами, величина

x - 2π*round(x/(2π),r)

без промежуточного округления. Внутренне использует точное приближение 2π, и поэтому даст более точный результат, чем rem(x,2π,r)

• если r == RoundNearest, то результат находится в интервале $[-π, π]$. Это обычно наиболее точный результат.

• если r == RoundToZero, то результат находится в интервале $[0, 2π]$, если x положительно, или $[-2π, 0]$ в противном случае.

• если r == RoundDown, то результат находится в интервале $[0, 2π]$.

• если r == RoundUp, то результат находится в интервале $[-2π, 0]$.

Пример

julia> rem2pi(7pi/4, RoundNearest)
-0.7853981633974485

julia> rem2pi(7pi/4, RoundDown)
5.497787143782138

Base.Math.mod2piФункция

mod2pi(x)

Остаток после деления на 2π, возвращаемый в диапазоне $[0,2π)$.

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

Пример

julia> mod2pi(9*pi/4)
0.7853981633974481

Base.divremФункция

divrem(x, y)

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

julia> divrem(3,7)
(0, 3)

julia> divrem(7,3)
(2, 1)

Base.fldmodФункция

fldmod(x, y)

Квота с отбрасыванием дробной части и остаток после деления. Эквивалентно (fld(x,y), mod(x,y)).

Base.fld1Функция

fld1(x, y)

Деление с отбрасыванием дробной части, возвращающее значение, соответствующее mod1(x,y)

См. также: mod1.

julia> x = 15; y = 4;

julia> fld1(x, y)
4

julia> x == fld(x, y) * y + mod(x, y)
true

julia> x == (fld1(x, y) - 1) * y + mod1(x, y)
true

Base.mod1Функция

mod1(x, y)

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

julia> mod1(4, 2)
2

julia> mod1(4, 3)
1

Base.fldmod1Функция

fldmod1(x, y)

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

См. также: fld1, mod1.

Base.://Функция

//(num, den)

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

julia> 3 // 5
3//5

julia> (3 // 5) // (2 // 1)
3//10

Base.rationalizeФункция

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

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

julia> rationalize(5.6)
28//5

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

julia> typeof(numerator(a))
BigInt

Base.numeratorФункция

numerator(x)

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

julia> numerator(2//3)
2

julia> numerator(4)
4

Base.denominatorФункция

denominator(x)

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

julia> denominator(2//3)
3

julia> denominator(4)
1

Base.:<<Функция

<<(x, n)

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

julia> Int8(3) << 2
12

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

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

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

<<(B::BitVector, n) -> BitVector

Оператор левого сдвига битов, B << n. Для n >= 0, результатом является B со сдвинутыми элементами на n позиций назад, заполняя false значениями. Если n < 0, элементы сдвигаются вперед. Эквивалентно B >> -n.

Примеры

julia> B = BitVector([true, false, true, false, false])
5-element BitArray{1}:
  true
 false
  true
 false
 false

julia> B << 1
5-element BitArray{1}:
 false
  true
 false
 false
 false

julia> B << -1
5-element BitArray{1}:
 false
  true
 false
  true
 false

Base.:>>Функция

>>(x, n)

Оператор правого сдвига битов, x >> n. Для n >= 0, результатом является x сдвинутый вправо на n бит, где n >= 0, заполняя 0 если x >= 0, 1 если 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"

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

>>(B::BitVector, n) -> BitVector

Оператор правого сдвига битов, B >> n. Для n >= 0, результатом является B со сдвинутыми элементами на n позиций вперед, заполняя false значениями. Если n < 0, элементы сдвигаются назад. Эквивалентно B << -n.

Пример

julia> B = BitVector([true, false, true, false, false])
5-element BitArray{1}:
  true
 false
  true
 false
 false

julia> B >> 1
5-element BitArray{1}:
 false
  true
 false
  true
 false

julia> B >> -1
5-element BitArray{1}:
 false
  true
 false
 false
 false

Base.:>>>Функция

>>>(x, n)

Оператор беззнакового правого сдвига битов, x >>> n. Для n >= 0, результатом является x сдвинутый вправо на n бит, где n >= 0, заполняя 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 обрабатываются как имеющие бесконечный размер, поэтому заполнение не требуется, и это эквивалентно >>.

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

>>>(B::BitVector, n) -> BitVector

Оператор беззнакового правого сдвига битов, B >>> n. Эквивалентно B >> n. См. >> для деталей и примеров.

Base.colonФункция

colon(start, [step], stop)

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

julia> colon(1, 2, 5)
1:2:5

:(start, [step], stop)

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

Base.rangeФункция

range(start, [step], length)

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

Base.OneToТип

Base.OneTo(n)

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

Base.StepRangeLenТип

StepRangeLen{T,R,S}(ref::R, step::S, len, [offset=1])

Диапазон r, где r[i] производит значения типа T, параметризованный ссылкой на значение, step, и длиной. По умолчанию ref — это начальное значение r[1], но альтернативно вы можете указать его как значение r[offset] для другого индекса 1 <= offset <= len. В сочетании с TwicePrecision это можно использовать для реализации диапазонов, свободных от погрешностей округления.

Base.:==Функция

==(x, y)

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

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

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

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

Base.:!=Функция

!=(x, y)
≠(x,y)

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

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

Base.:!==Функция

!==(x, y)
≢(x,y)

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

julia> a = [1, 2]; b = [1, 2];

julia> a ≢ b
true

julia> a ≢ a
false

Base.:<Функция

<(x, y)

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

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

Base.:<=Функция

<=(x, y)
≤(x,y)

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

julia> 'a' <= 'b'
true

julia> 7 ≤ 7 ≤ 9
true

julia> "abc" ≤ "abc"
true

julia> 5 <= 3
false

Base.:>Функция

>(x, y)

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

julia> 'a' > 'b'
false

julia> 7 > 3 > 1
true

julia> "abc" > "abd"
false

julia> 5 > 3
true

Base.:>=Функция

>=(x, y)
≥(x,y)

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

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

Base.cmpФункция

cmp(x,y)

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

julia> cmp(1, 2)
-1

julia> cmp(2, 1)
1

julia> cmp(2+im, 3-im)
ERROR: MethodError: no method matching isless(::Complex{Int64}, ::Complex{Int64})
[...]

Base.:~Функция

~(x)

Битовая инверсия.

Примеры

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

Base.:&Функция

&(x, y)

Битовая конъюнкция.

Примеры

julia> 4 & 10
0

julia> 4 & 12
4

Base.:|Функция

|(x, y)

Битовая дизъюнкция.

Примеры

julia> 4 | 10
14

julia> 4 | 1
5

Base.xorФункция

xor(x, y)
⊻(x, y)

Битовая исключающая дизъюнкция x и y. Инфиксная операция a ⊻ b — синоним для xor(a,b), а ⊻ можно ввести, набрав \xor или \veebar в REPL Julia.

julia> [true; true; false] .⊻ [true; false; false]
3-element BitArray{1}:
 false
  true
 false

Base.:!Функция

!(x)

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

julia> !true
false

julia> !false
true

julia> .![true false true]
1×3 BitArray{2}:
 false  true  false

!f::Function

Отрицание предикатной функции: если аргументом ! является функция, она возвращает функцию, вычисляющую логическое отрицание f. Пример:

julia> str = "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
"∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"

julia> filter(isalpha, str)
"εδxyδfxfyε"

julia> filter(!isalpha, str)
"∀  > 0, ∃  > 0: |-| <  ⇒ |()-()| < "

&&Ключевое слово

x && y

Краткое логическое И.

||Ключевое слово

x || y

Краткое логическое ИЛИ.

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

Base.isapproxФункция

isapprox(x, y; rtol::Real=sqrt(eps), atol::Real=0, nans::Bool=false, norm::Function)

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

Для вещественных или комплексных значений с плавающей точкой значение 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).

julia> 0.1 ≈ (0.1 - 1e-10)
true

julia> isapprox(10, 11; atol = 2)
true

julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0])
true

Base.sinФункция

sin(x)

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

Base.cosФункция

cos(x)

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

Base.tanФункция

tan(x)

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

Base.Math.sindФункция

sind(x)

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

Base.Math.cosdФункция

cosd(x)

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

Base.Math.tandФункция

tand(x)

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

Base.Math.sinpiФункция

sinpi(x)

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

Base.Math.cospiФункция

cospi(x)

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

Base.sinhФункция

sinh(x)

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

Base.coshФункция

cosh(x)

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

Base.tanhФункция

tanh(x)

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

Base.asinФункция

asin(x)

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

Base.acosФункция

acos(x)

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

Base.atanФункция

atan(x)

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

Base.Math.atan2Функция

atan2(y, x)

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

Base.Math.asindФункция

asind(x)

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

Base.Math.acosdФункция

acosd(x)

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

Base.Math.atandФункция

atand(x)

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

Base.Math.secФункция

sec(x)

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

Base.Math.cscФункция

csc(x)

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

Base.Math.cotФункция

cot(x)

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

Base.Math.secdФункция

secd(x)

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

Base.Math.cscdФункция

cscd(x)

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

Base.Math.cotdФункция

cotd(x)

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

Base.Math.asecФункция

asec(x)

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

Base.Math.acscФункция

acsc(x)

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

Base.Math.acotФункция

acot(x)

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

Base.Math.asecdФункция

asecd(x)

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

Base.Math.acscdФункция

acscd(x)

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

Base.Math.acotdФункция

acotd(x)

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

Base.Math.sechФункция

sech(x)

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

Base.Math.cschФункция

csch(x)

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

Base.Math.cothФункция

coth(x)

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

Base.asinhФункция

asinh(x)

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

Base.acoshФункция

acosh(x)

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

Base.atanhФункция

atanh(x)

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

Base.Math.asechФункция

asech(x)

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

Base.Math.acschФункция

acsch(x)

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

Base.Math.acothФункция

acoth(x)

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

Base.Math.sincФункция

sinc(x)

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

Base.Math.coscФункция

cosc(x)

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

Base.Math.deg2radФункция

deg2rad(x)

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

julia> deg2rad(90)
1.5707963267948966

Base.Math.rad2degФункция

rad2deg(x)

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

julia> rad2deg(pi)
180.0

Base.Math.hypotФункция

hypot(x, y)

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

Примеры

julia> a = 10^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # a^2 overflows
ERROR: DomainError:
sqrt will only return a complex result if called with a complex argument. Try sqrt(complex(x)).
Stacktrace:
 [1] sqrt(::Int64) at ./math.jl:434

hypot(x...)

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

Base.logМетод

log(x)

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

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

Base.logМетод

log(b,x)

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

julia> log(4,8)
1.5

julia> log(4,2)
0.5

julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0

Base.log2Функция

log2(x)

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

Пример

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

Base.log10Функция

log10(x)

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

Пример

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

Base.log1pФункция

log1p(x)

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

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

Примеры

julia> log1p(-0.5)
-0.6931471805599453

julia> log1p(0)
0.0

Base.Math.frexpФункция

frexp(val)

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

Base.expФункция

exp(x)

Вычислить экспоненту по основанию натурального логарифма от x, другими словами $e^x$.

Base.exp2Функция

exp2(x)

Вычислить $2^x$.

julia> exp2(5)
32.0

Base.exp10Функция

exp10(x)

Вычислить $10^x$.

Примеры

julia> exp10(2)
100.0

julia> exp10(0.2)
1.5848931924611136

Base.Math.ldexpФункция

ldexp(x, n)

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

Пример

julia> ldexp(5., 2)
20.0

Base.Math.modfФункция

modf(x)

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

Пример

julia> modf(3.5)
(0.5, 3.0)

Base.expm1Функция

expm1(x)

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

Base.roundМетод

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

julia> x = 1.15
1.15

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

julia> x < 115//100
true

julia> round(x, 1)
1.2

Base.Rounding.RoundingModeТип

RoundingMode

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

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

• RoundNearest (по умолчанию)

• RoundNearestTiesAway

• RoundNearestTiesUp

• RoundToZero

• RoundFromZero (BigFloat только)

• RoundUp

• RoundDown

Base.Rounding.RoundNearestКонстанта

RoundNearest

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

Base.Rounding.RoundNearestTiesAwayКонстанта

RoundNearestTiesAway

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

Base.Rounding.RoundNearestTiesUpКонстанта

RoundNearestTiesUp

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

Base.Rounding.RoundToZeroКонстанта

RoundToZero

Использование этого режима округления является псевдонимом для trunc.

Base.Rounding.RoundUpКонстанта

RoundUp

Использование этого режима округления является псевдонимом для ceil.

Base.Rounding.RoundDownКонстанта

RoundDown

Использование этого режима округления является псевдонимом для floor.

Base.roundМетод

round(z, RoundingModeReal, RoundingModeImaginary)

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

Base.ceilФункция

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

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

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

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

Base.floorФункция

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

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

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

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

Base.truncФункция

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

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

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

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

Base.unsafe_truncФункция

unsafe_trunc(T, x)

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

Base.signifФункция

signif(x, digits, [base])

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

Base.minФункция

min(x, y, ...)

Возвращает минимум из аргументов. См. также функцию minimum для получения минимального элемента из коллекции.

julia> min(2, 5, 1)
1

Base.maxФункция

max(x, y, ...)

Возвращает максимум из аргументов. См. также функцию maximum для получения максимального элемента из коллекции.

julia> max(2, 5, 1)
5

Base.minmaxФункция

minmax(x, y)

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

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

Base.Math.clampФункция

clamp(x, lo, hi)

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

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

Base.Math.clamp!Функция

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

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

Base.absФункция

abs(x)

Модуль x.

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

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs(typemin(Int64))
-9223372036854775808

Base.Checked.checked_absФункция

Base.checked_abs(x)

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

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

Base.Checked.checked_negФункция

Base.checked_neg(x)

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

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

Base.Checked.checked_addФункция

Base.checked_add(x, y)

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

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

Base.Checked.checked_subФункция

Base.checked_sub(x, y)

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

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

Base.Checked.checked_mulФункция

Base.checked_mul(x, y)

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

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

Base.Checked.checked_divФункция

Base.checked_div(x, y)

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

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

Base.Checked.checked_remФункция

Base.checked_rem(x, y)

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

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

Base.Checked.checked_fldФункция

Base.checked_fld(x, y)

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

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

Base.Checked.checked_modФункция

Base.checked_mod(x, y)

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

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

Base.Checked.checked_cldФункция

Base.checked_cld(x, y)

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

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

Base.Checked.add_with_overflowФункция

Base.add_with_overflow(x, y) -> (r, f)

Вычисляет r = x+y, с флагом f указывающим, произошло ли переполнение.

Base.Checked.sub_with_overflowФункция

Base.sub_with_overflow(x, y) -> (r, f)

Вычисляет r = x-y, с флагом f указывающим, произошло ли переполнение.

Base.Checked.mul_with_overflowФункция

Base.mul_with_overflow(x, y) -> (r, f)

Вычисляет r = x*y, с флагом f указывающим, произошло ли переполнение.

Base.abs2Функция

abs2(x)

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

julia> abs2(-3)
9

Base.copysignФункция

copysign(x, y) -> z

Возвращает z, имеющий модуль x и тот же знак, что и y.

Примеры

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

Base.signФункция

sign(x)

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

Base.signbitФункция

signbit(x)

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

Примеры

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true

Base.flipsignФункция

flipsign(x, y)

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

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5

Base.sqrtФункция

sqrt(x)

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

Base.isqrtФункция

isqrt(n::Integer)

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

julia> isqrt(5)
2

Base.Math.cbrtФункция

cbrt(x::Real)

Возвращает кубический корень из x, т.е. $x^{1/3}$. Отрицательные значения принимаются (возвращает отрицательный вещественный корень, когда $x < 0$).

Префиксный оператор ∛ эквивалентен cbrt.

julia> cbrt(big(27))
3.000000000000000000000000000000000000000000000000000000000000000000000000000000

Base.realМетод

real(z)

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

julia> real(1 + 3im)
1

Base.imagФункция

imag(z)

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

julia> imag(1 + 3im)
3

Base.reimФункция

reim(z)

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

julia> reim(1 + 3im)
(1, 3)

Base.conjФункция

conj(z)

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

julia> conj(1 + 3im)
1 - 3im

conj(v::RowVector)

Возвращает ConjArray ленивую визуализацию входных данных, где каждый элемент сопряжён.

Пример

julia> v = [1+im, 1-im].'
1×2 RowVector{Complex{Int64},Array{Complex{Int64},1}}:
 1+1im  1-1im

julia> conj(v)
1×2 RowVector{Complex{Int64},ConjArray{Complex{Int64},1,Array{Complex{Int64},1}}}:
 1-1im  1+1im

Base.angleФункция

angle(z)

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

Base.cisФункция

cis(z)

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

Base.binomialФункция

binomial(n, k)

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

Пример

julia> binomial(5, 3)
10

julia> factorial(5) ÷ (factorial(5-3) * factorial(3))
10

Base.factorialФункция

factorial(n)

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

julia> factorial(6)
720

julia> factorial(21)
ERROR: OverflowError()
[...]

julia> factorial(21.0)
5.109094217170944e19

julia> factorial(big(21))
51090942171709440000

Base.gcdФункция

gcd(x,y)

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

Примеры

julia> gcd(6,9)
3

julia> gcd(6,-9)
3

Base.lcmФункция

lcm(x,y)

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

Примеры

julia> lcm(2,3)
6

julia> lcm(-2,3)
6

Base.gcdxФункция

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)

Base.ispow2Функция

ispow2(n::Integer) -> Bool

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

Примеры

julia> ispow2(4)
true

julia> ispow2(5)
false

Base.nextpow2Функция

nextpow2(n::Integer)

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

Примеры

julia> nextpow2(16)
16

julia> nextpow2(17)
32

Base.prevpow2Функция

prevpow2(n::Integer)

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

Примеры

julia> prevpow2(5)
4

julia> prevpow2(0)
0

Base.nextpowФункция

nextpow(a, x)

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

Примеры

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16

См. также prevpow.

Base.prevpowФункция

prevpow(a, x)

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

Примеры

julia> prevpow(2, 7)
4

julia> prevpow(2, 9)
8

julia> prevpow(5, 20)
5

julia> prevpow(4, 16)
16

См. также nextpow.

Base.nextprodФункция

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

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

Пример

julia> nextprod([2, 3], 105)
108

julia> 2^2 * 3^3
108

Base.invmodФункция

invmod(x,m)

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

Примеры

julia> invmod(2,5)
3

julia> invmod(2,3)
2

julia> invmod(5,6)
5

Base.powermodФункция

powermod(x::Integer, p::Integer, m)

Вычисление $x^p \pmod m$.

Примеры

julia> powermod(2, 6, 5)
4

julia> mod(2^6, 5)
4

julia> powermod(5, 2, 20)
5

julia> powermod(5, 2, 19)
6

julia> powermod(5, 3, 19)
11

Base.Math.gammaФункция

gamma(x)

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

Base.Math.lgammaФункция

lgamma(x)

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

Base.Math.lfactФункция

lfact(x)

Вычисление логарифмического факториала неотрицательного целого числа x. Эквивалентно lgamma от x + 1, но lgamma расширяет эту функцию до нецелых x.

Base.Math.betaФункция

beta(x, y)

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

Base.Math.lbetaФункция

lbeta(x, y)

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

Base.ndigitsФункция

ndigits(n::Integer, b::Integer=10)

Вычисление количества цифр в целом n в системе счисления b. Основание b не должно быть в [-1, 0, 1].

Примеры

julia> ndigits(12345)
5

julia> ndigits(1022, 16)
3

julia> base(16, 1022)
"3fe"

Base.widemulФункция

widemul(x, y)

Умножить x и y, получив результат более крупного типа.

julia> widemul(Float32(3.), 4.)
1.200000000000000000000000000000000000000000000000000000000000000000000000000000e+01

Base.Math.@evalpolyМакрос

@evalpoly(z, c...)

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

julia> @evalpoly(3, 1, 0, 1)
10

julia> @evalpoly(2, 1, 0, 1)
5

julia> @evalpoly(2, 1, 1, 1)
7

Статистика

Base.meanФункция

mean(f::Function, v)

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

julia> mean(√, [1, 2, 3])
1.3820881233139908

julia> mean([√1, √2, √3])
1.3820881233139908

mean(v[, region])

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

Base.mean!Функция

mean!(r, v)

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

Base.stdФункция

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

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

Base.stdmФункция

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

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

Base.varФункция

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

Вычислить выборочную дисперсию вектора или массива v, по желанию по измерениям в region. Алгоритм вернёт оценку дисперсии генеративного распределения в предположении, что каждый элемент v является независимо и одинаково распределённой выборкой из этого генеративного распределения. Это вычисление эквивалентно вычислению sum(abs2, v - mean(v)) / (length(v) - 1). Если corrected равно true, тогда сумма масштабируется с n-1, в то время как сумма масштабируется с n если corrected равно false, где n = length(x). Может быть предоставлено среднее значение mean по региону.

Base.varmФункция

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

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

Base.middleФункция

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

Base.medianФункция

median(v[, region])

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

Base.median!Функция

median!(v)

Аналогично median, но может перезаписать входной вектор.

Base.quantileФункция

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 из Hyndman и Fan (1996) и совпадает с поведением функции R по умолчанию.

• Hyndman, R.J и Fan, Y. (1996) "Выборка квантилей в статистических пакетах", The American Statistician, том 50, № 4, стр. 361-365

Base.quantile!Функция

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 Hyndman и Fan (1996) и совпадает с настройкой по умолчанию R.

• Hyndman, R.J и Fan, Y. (1996) "Выборка квантилей в статистических пакетах", The American Statistician, том 50, № 4, стр. 361-365

Base.covФункция

cov(x[, corrected=true])

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

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

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

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

Вычислить ковариацию между векторами x и y. Если corrected равно true (по умолчанию), вычисляется $\frac{1}{n-1}\sum_{i=1}^n (x_i-\bar x) (y_i-\bar y)^*$, где $*$ обозначает комплексно сопряжённое значение и n = length(x) = length(y). Если corrected равно false, вычисляется $rac{1}{n}sum_{i=1}^n (x_i-\bar x) (y_i-\bar y)^*$.

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

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

Base.corФункция

cor(x)

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

cor(X[, vardim=1])

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

cor(x, y)

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

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

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

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

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

Base.DFT.fftФункция

fft(A [, dims])

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

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

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

Base.DFT.fft!Функция

fft!(A [, dims])

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

Base.DFT.ifftФункция

ifft(A [, dims])

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

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

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

Base.DFT.ifft!Функция

ifft!(A [, dims])

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

Base.DFT.bfftФункция

bfft(A [, dims])

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

Base.DFT.bfft!Функция

bfft!(A [, dims])

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

Base.DFT.plan_fftФункция

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 и так далее.

Base.DFT.plan_ifftФункция

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

Аналогично plan_fft, но создаёт план, выполняющий обратные преобразования ifft.

Base.DFT.plan_bfftФункция

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

Аналогично plan_fft, но создаёт план, выполняющий ненормализованное обратное преобразование bfft.

Base.DFT.plan_fft!Функция

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

Аналогично plan_fft, но работает «на месте» с A.

Base.DFT.plan_ifft!Функция

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

Аналогично plan_ifft, но работает «на месте» с A.

Base.DFT.plan_bfft!Функция

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

Аналогично plan_bfft, но работает «на месте» с A.

Base.DFT.rfftФункция

rfft(A [, dims])

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

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

Base.DFT.irfftФункция

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

Base.DFT.brfftФункция

brfft(A, d [, dims])

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

Base.DFT.plan_rfftФункция

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

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

Base.DFT.plan_brfftФункция

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

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

Base.DFT.plan_irfftФункция

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

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

Base.DFT.FFTW.dctФункция

dct(A [, dims])

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

Base.DFT.FFTW.dct!Функция

dct!(A [, dims])

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

Base.DFT.FFTW.idctФункция

idct(A [, dims])

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

Base.DFT.FFTW.idct!Функция

idct!(A [, dims])

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

Base.DFT.FFTW.plan_dctФункция

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

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

Base.DFT.FFTW.plan_dct!Функция

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

Аналогично plan_dct, но работает непосредственно с A.

Base.DFT.FFTW.plan_idctФункция

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

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

Base.DFT.FFTW.plan_idct!Функция

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

Аналогично plan_idct, но работает непосредственно с A.

Base.DFT.fftshiftМетод

fftshift(x)

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

Base.DFT.fftshiftМетод

fftshift(x,dim)

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

Base.DFT.ifftshiftФункция

ifftshift(x, [dim])

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

Base.DSP.filtФункция

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

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

Base.DSP.filt!Функция

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

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

Base.DSP.deconvФункция

deconv(b,a) -> c

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

Base.DSP.convФункция

conv(u,v)

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

Base.DSP.conv2Функция

conv2(u,v,A)

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

conv2(B,A)

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

Base.DSP.xcorrФункция

xcorr(u,v)

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

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

Base.DFT.FFTW.r2rФункция

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 ), либо вещественное преобразование БПФ с выходом в формате 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.

Base.DFT.FFTW.r2r!Функция

r2r!(A, kind [, dims])

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

Base.DFT.FFTW.plan_r2rФункция

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

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

Base.DFT.FFTW.plan_r2r!Функция

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

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