Mathematics

-(x)

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

Смотрите также: abs, flipsign.

Примеры

julia> -1
-1

julia> -(2)
-2

julia> -[1 2; 3 4]
2×2 Matrix{Int64}:
 -1  -2
 -3  -4

julia> -(true)  # преобразуется в Int
-1

julia> -(0x003)
0xfffd

dt::Date + t::Time -> DateTime

Сложение Date с Time приводит к получению DateTime. Часы, минуты, секунды и миллисекунды из Time используются вместе с годом, месяцем и днем из Date для создания нового DateTime. Ненулевые микросекунды или наносекунды в типе Time приведут к возникновению ошибки InexactError.

+(x, y...)

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

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

Обратите внимание, что переполнение возможно для большинства целочисленных типов, включая стандартный Int, при сложении больших чисел.

Примеры

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

julia> [1,2] + [3,4]
2-element Vector{Int64}:
 4
 6

julia> typemax(Int) + 1 < 0
true

-(x, y)

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

Примеры

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

*(x, y...)

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

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

Сложение, такое как 2pi, также вызывает *(2, pi). Обратите внимание, что эта операция имеет более высокий приоритет, чем литерал *. Также обратите внимание, что сложение "0x..." (целое ноль раз переменной, имя которой начинается с x) запрещено, так как оно конфликтует с литералами беззнаковых целых чисел: 0x01 isa UInt8.

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

Примеры

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

julia> [2 0; 0 3] * [1, 10]  # матрица * вектор
2-element Vector{Int64}:
  2
 30

julia> 1/2pi, 1/2*pi  # сложение имеет более высокий приоритет
(0.15915494309189535, 1.5707963267948966)

julia> x = [1, 2]; x'x  # сопряженный вектор * вектор
5

/(x, y)

Оператор правого деления: умножение x на обратное значение y справа.

Возвращает результаты с плавающей точкой для целочисленных аргументов. См. ÷ для целочисленного деления или // для результатов Rational.

Примеры

julia> 1/2
0.5

julia> 4/2
2.0

julia> 4.5/2
2.25

A / B

Правостороннее деление матриц: A / B эквивалентно (B' \ A')', где \ является оператором левостороннего деления. Для квадратных матриц результат X таков, что A == X*B.

Смотрите также: rdiv!.

Примеры

julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

julia> X = A / B
2×3 Matrix{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

julia> isapprox(A, X*B)
true

julia> isapprox(X, A*pinv(B))
true

\(x, y)

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

Примеры

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

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

julia> A \ x
2-element Vector{Float64}:
  6.5
 -7.0

julia> inv(A) * x
2-element Vector{Float64}:
  6.5
 -7.0

^(x, y)

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

Если x и y являются целыми числами, результат может переполниться. Чтобы вводить числа в научной нотации, используйте литералы Float64, такие как 1.2e3, а не 1.2 * 10^3.

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

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

Примеры

julia> 3^5
243

julia> 3^-1  # использует Base.literal_pow
0.3333333333333333

julia> p = -1;

julia> 3^p
ERROR: DomainError with -1:
Cannot raise an integer x to a negative power -1.
[...]

julia> 3.0^p
0.3333333333333333

julia> 10^19 > 0  # переполнение целого числа
false

julia> big(10)^19 == 1e19
true

fma(x, y, z)

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

muladd(x, y, z)

Смешанное умножение-сложение: вычисляет x*y+z, но позволяет объединять сложение и умножение друг с другом или с окружающими операциями для повышения производительности. Например, это может быть реализовано как fma, если аппаратное обеспечение поддерживает это эффективно. Результат может отличаться на разных машинах и также может отличаться на одной и той же машине из-за распространения констант или других оптимизаций. См. fma.

Примеры

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

muladd(A, y, z)

Скомбинированное умножение и сложение, A*y .+ z, для умножения матриц или векторов. Результат всегда имеет такой же размер, как A*y, но z может быть меньше или скаляром.

Примеры

julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; z=[0, 100];

julia> muladd(A, B, z)
2×2 Matrix{Float64}:
   3.0    3.0
 107.0  107.0

inv(x)

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

Если x — это число, то это по сути то же самое, что one(x)/x, но для некоторых типов inv(x) может быть немного более эффективным.

Примеры

julia> inv(2)
0.5

julia> inv(1 + 2im)
0.2 - 0.4im

julia> inv(1 + 2im) * (1 + 2im)
1.0 + 0.0im

julia> inv(2//3)
3//2

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

Частное от евклидового (целочисленного) деления. В общем эквивалентно математической операции x/y без дробной части.

См. также: cld, fld, rem, divrem.

Примеры

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

julia> 5.0 ÷ 2
2.0

julia> div.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -1  -1  -1  0  0  0  0  0  1  1  1

div(x, y, r::RoundingMode=RoundToZero)

Частное от евклидового (целочисленного) деления. Вычисляет x / y, округляя до целого числа в соответствии с режимом округления r. Другими словами, количество

round(x / y, r)

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

См. также fld и cld, которые являются особыми случаями этой функции.

Примеры:

julia> div(4, 3, RoundToZero) # Соответствует div(4, 3)
1
julia> div(4, 3, RoundDown) # Соответствует fld(4, 3)
1
julia> div(4, 3, RoundUp) # Соответствует cld(4, 3)
2
julia> div(5, 2, RoundNearest)
2
julia> div(5, 2, RoundNearestTiesAway)
3
julia> div(-5, 2, RoundNearest)
-2
julia> div(-5, 2, RoundNearestTiesAway)
-3
julia> div(-5, 2, RoundNearestTiesUp)
-2
julia> div(4, 3, RoundFromZero)
2
julia> div(-4, 3, RoundFromZero)
-2

fld(x, y)

Наибольшее целое число, меньшее или равное x / y. Эквивалентно div(x, y, RoundDown).

См. также div, cld, fld1.

Примеры

julia> fld(7.3, 5.5)
1.0

julia> fld.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -2  -2  -1  -1  -1  0  0  0  1  1  1

Поскольку fld(x, y) реализует строго корректное округление вниз на основе истинного значения чисел с плавающей запятой, могут возникать неинтуитивные ситуации. Например:

julia> fld(6.0, 0.1)
59.0
julia> 6.0 / 0.1
60.0
julia> 6.0 / big(0.1)
59.99999999999999666933092612453056361837965690217069245739573412231113406246995

Что здесь происходит, так это то, что истинное значение числа с плавающей запятой, записанного как 0.1, немного больше, чем числовое значение 1/10, в то время как 6.0 точно представляет число 6. Поэтому истинное значение 6.0 / 0.1 немного меньше 60. При делении это округляется до точно 60.0, но fld(6.0, 0.1) всегда берет пол, поэтому результат равен 59.0.

cld(x, y)

Наименьшее целое число, большее или равное x / y. Эквивалентно div(x, y, RoundUp).

См. также div, fld.

Примеры

julia> cld(5.5, 2.2)
3.0

julia> cld.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -1  -1  -1  0  0  0  1  1  1  2  2

mod(x::Integer, r::AbstractUnitRange)

Найдите y в диапазоне r, такой что $x ≡ y (mod n)$, где n = length(r), т.е. y = mod(x - first(r), n) + first(r).

Смотрите также mod1.

Примеры

julia> mod(0, Base.OneTo(3))  # mod1(0, 3)
3

julia> mod(3, 0:2)  # mod(3, 3)
0

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

Сокращение x по модулю y, или, эквивалентно, остаток от x после округленного деления на y, т.е. x - y*fld(x,y), если вычисляется без промежуточного округления.

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

См. также: rem, div, fld, mod1, invmod.

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

julia> mod.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 1  2  0  1  2  0  1  2  0  1  2

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> x = 129 % Int8
-127

julia> typeof(x)
Int8

julia> x = 129 % BigInt
129

julia> typeof(x)
BigInt

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

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

Смотрите также: div, mod, mod1, divrem.

Примеры

julia> x = 15; y = 4;

julia> x % y
3

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

julia> rem.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -2  -1  0  -2  -1  0  1  2  0  1  2

rem(x, y, r::RoundingMode=RoundToZero)

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

x - y * round(x / y, r)

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

• если r == RoundNearest, то результат точен и находится в интервале $[-|y| / 2, |y| / 2]$. См. также RoundNearest.
• если r == RoundToZero (по умолчанию), то результат точен и находится в интервале $[0, |y|)$, если x положительно, или $(-|y|, 0]$ в противном случае. См. также RoundToZero.
• если r == RoundDown, то результат находится в интервале $[0, y)$, если y положительно, или $(y, 0]$ в противном случае. Результат может быть неточным, если x и y имеют разные знаки, и abs(x) < abs(y). См. также RoundDown.
• если r == RoundUp, то результат находится в интервале $(-y, 0]$, если y положительно, или $[0, -y)$ в противном случае. Результат может быть неточным, если x и y имеют одинаковый знак, и abs(x) < abs(y). См. также RoundUp.
• если r == RoundFromZero, то результат находится в интервале $(-y, 0]$, если y положительно, или $[0, -y)$ в противном случае. Результат может быть неточным, если x и y имеют одинаковый знак, и abs(x) < abs(y). См. также RoundFromZero.

Примеры:

julia> x = 9; y = 4;

julia> x % y  # то же самое, что rem(x, y)
1

julia> x ÷ y  # то же самое, что div(x, y)
2

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

rem2pi(x, r::RoundingMode)

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

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

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

• если r == RoundNearest, то результат находится в интервале $[-π, π]$. Это будет, как правило, наиболее точный результат. См. также RoundNearest.
• если r == RoundToZero, то результат находится в интервале $[0, 2π]$, если x положительно, или $[-2π, 0]$ в противном случае. См. также RoundToZero.
• если r == RoundDown, то результат находится в интервале $[0, 2π]$. См. также RoundDown.
• если r == RoundUp, то результат находится в интервале $[-2π, 0]$. См. также RoundUp.

Примеры

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

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

mod2pi(x)

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

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

Примеры

julia> mod2pi(9*pi/4)
0.7853981633974481

divrem(x, y, r::RoundingMode=RoundToZero)

Частное и остаток от евклидова деления. Эквивалентно (div(x, y, r), rem(x, y, r)). Эквивалентно, с учетом значения по умолчанию для r, этот вызов эквивалентен (x ÷ y, x % y).

См. также: fldmod, cld.

Примеры

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

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

fldmod(x, y)

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

См. также: fld, cld, fldmod1.

fld1(x, y)

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

См. также mod1, fldmod1.

Примеры

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

mod1(x, y)

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

При целочисленных аргументах и положительном y это равно mod(x, 1:y), и, следовательно, естественно для индексации с 1. В сравнении, mod(x, y) == mod(x, 0:y-1) естественно для вычислений с смещениями или шагами.

См. также mod, fld1, fldmod1.

Примеры

julia> mod1(4, 2)
2

julia> mod1.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 1  2  3  1  2  3  1  2  3  1  2

julia> mod1.([-0.1, 0, 0.1, 1, 2, 2.9, 3, 3.1]', 3)
1×8 Matrix{Float64}:
 2.9  3.0  0.1  1.0  2.0  2.9  3.0  0.1

fldmod1(x, y)

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

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

//(num, den)

Разделите два целых числа или рациональных числа, получая результат типа Rational. Более общим образом, // может использоваться для точного рационального деления других числовых типов с целыми или рациональными компонентами, такими как комплексные числа с целыми компонентами.

Обратите внимание, что аргументы с плавающей запятой (AbstractFloat) не допускаются в // (даже если значения рациональны). Аргументы должны быть подтипами Integer, Rational или их составными типами.

Примеры

julia> 3 // 5
3//5

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

julia> (1+2im) // (3+4im)
11//25 + 2//25*im

julia> 1.0 // 2
ERROR: MethodError: no method matching //(::Float64, ::Int64)
[...]

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

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

Примеры

julia> rationalize(5.6)
28//5

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

julia> typeof(numerator(a))
BigInt

numerator(x)

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

Примеры

julia> numerator(2//3)
2

julia> numerator(4)
4

denominator(x)

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

Примеры

julia> denominator(2//3)
3

julia> denominator(4)
1

<<(x, n)

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

Примеры

julia> Int8(3) << 2
12

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

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

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

<<(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 BitVector:
 1
 0
 1
 0
 0

julia> B << 1
5-element BitVector:
 0
 1
 0
 0
 0

julia> B << -1
5-element BitVector:
 0
 1
 0
 1
 0

>>(x, n)

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

Примеры

julia> Int8(13) >> 2
3

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

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

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

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

julia> bitstring(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 BitVector:
 1
 0
 1
 0
 0

julia> B >> 1
5-element BitVector:
 0
 1
 0
 1
 0

julia> B >> -1
5-element BitVector:
 0
 1
 0
 0
 0

>>>(x, n)

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

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

Примеры

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

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

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

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

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

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

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

bitrotate(x::Base.BitInteger, k::Integer)

bitrotate(x, k) реализует побитовую ротацию. Он возвращает значение x с его битами, повернутыми влево k раз. Отрицательное значение k будет вращать вправо.

См. также: <<, circshift, BitArray.

julia> bitrotate(UInt8(114), 2)
0xc9

julia> bitstring(bitrotate(0b01110010, 2))
"11001001"

julia> bitstring(bitrotate(0b01110010, -2))
"10011100"

julia> bitstring(bitrotate(0b01110010, 8))
"01110010"

:expr

Цитирует выражение expr, возвращая абстрактное синтаксическое дерево (AST) expr. AST может быть типа Expr, Symbol или литеральным значением. Синтаксис :identifier оценивается как Symbol.

Смотрите также: Expr, Symbol, Meta.parse

Примеры

julia> expr = :(a = b + 2*x)
:(a = b + 2x)

julia> sym = :some_identifier
:some_identifier

julia> value = :0xff
0xff

julia> typeof((expr, sym, value))
Tuple{Expr, Symbol, UInt8}

range(start, stop, length)
range(start, stop; length, step)
range(start; length, stop, step)
range(;start, length, stop, step)

Создайте специализированный массив с равномерно распределенными элементами и оптимизированным хранением (ан AbstractRange) из аргументов. Математически диапазон уникально определяется любыми тремя из start, step, stop и length. Допустимые вызовы range:

• Вызовите range с любыми тремя из start, step, stop, length.
• Вызовите range с двумя из start, stop, length. В этом случае step будет считаться равным одному. Если оба аргумента являются целыми числами, будет возвращен UnitRange.
• Вызовите range с одним из stop или length. start и step будут считаться равными одному.

Смотрите Расширенную помощь для получения дополнительных сведений о возвращаемом типе. Также смотрите logrange для логарифмически распределенных точек.

Примеры

julia> range(1, length=100)
1:100

julia> range(1, stop=100)
1:100

julia> range(1, step=5, length=100)
1:5:496

julia> range(1, step=5, stop=100)
1:5:96

julia> range(1, 10, length=101)
1.0:0.09:10.0

julia> range(1, 100, step=5)
1:5:96

julia> range(stop=10, length=5)
6:10

julia> range(stop=10, step=1, length=5)
6:1:10

julia> range(start=1, step=1, stop=10)
1:1:10

julia> range(; length = 10)
Base.OneTo(10)

julia> range(; stop = 6)
Base.OneTo(6)

julia> range(; stop = 6.5)
1.0:1.0:6.0

Если length не указан и stop - start не является целым кратным step, будет создан диапазон, который заканчивается до stop.

julia> range(1, 3.5, step=2)
1.0:2.0:3.0

Особое внимание уделяется тому, чтобы промежуточные значения вычислялись рационально. Чтобы избежать этого вызванного накладного расхода, смотрите конструктор LinRange.

Расширенная помощь

range будет производить Base.OneTo, когда аргументы являются целыми числами и

• Предоставлен только length
• Предоставлен только stop

range будет производить UnitRange, когда аргументы являются целыми числами и

• Предоставлены только start и stop
• Предоставлены только length и stop

UnitRange не создается, если step предоставлен, даже если он указан как один.

Base.OneTo(n)

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

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

Диапазон r, где r[i] производит значения типа T (в первой форме T выводится автоматически), параметризованный значением ref, шагом step и длиной len. По умолчанию ref является начальным значением r[1], но вы также можете указать его как значение r[offset] для какого-либо другого индекса 1 <= offset <= len. Синтаксис a:b или a:b:c, где любое из a, b или c является числами с плавающей запятой, создает StepRangeLen.

logrange(start, stop, length)
logrange(start, stop; length)

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

Это похоже на geomspace в Python. В отличие от PowerRange в Mathematica, вы указываете количество элементов, а не отношение. В отличие от logspace в Python и Matlab, аргументы start и stop всегда являются первыми и последними элементами результата, а не степенями, примененными к некоторой базе.

Примеры

julia> logrange(10, 4000, length=3)
3-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 10.0, 200.0, 4000.0

julia> ans[2] ≈ sqrt(10 * 4000)  # средний элемент является геометрическим средним
true

julia> range(10, 40, length=3)[2] ≈ (10 + 40)/2  # арифметическое среднее
true

julia> logrange(1f0, 32f0, 11)
11-element Base.LogRange{Float32, Float64}:
 1.0, 1.41421, 2.0, 2.82843, 4.0, 5.65685, 8.0, 11.3137, 16.0, 22.6274, 32.0

julia> logrange(1, 1000, length=4) ≈ 10 .^ (0:3)
true

Смотрите тип LogRange для получения дополнительных сведений.

Смотрите также range для линейно распределенных точек.

LogRange{T}(start, stop, len) <: AbstractVector{T}

Диапазон, элементы которого расположены логарифмически между start и stop, с интервалом, контролируемым len. Возвращается функцией logrange.

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

Примеры

julia> logrange(1, 4, length=5)
5-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 1.0, 1.41421, 2.0, 2.82843, 4.0

julia> Base.LogRange{Float16}(1, 4, 5)
5-element Base.LogRange{Float16, Float64}:
 1.0, 1.414, 2.0, 2.828, 4.0

julia> logrange(1e-310, 1e-300, 11)[1:2:end]
6-element Vector{Float64}:
 1.0e-310
 9.999999999999974e-309
 9.999999999999981e-307
 9.999999999999988e-305
 9.999999999999994e-303
 1.0e-300

julia> prevfloat(1e-308, 5) == ans[2]
true

Обратите внимание, что целочисленный тип T не допускается. Используйте, например, round.(Int, xs), или явные степени некоторого целого основания:

julia> xs = logrange(1, 512, 4)
4-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 1.0, 8.0, 64.0, 512.0

julia> 2 .^ (0:3:9) |> println
[1, 8, 64, 512]

==(x, y)

Генерический оператор равенства. Падает обратно на ===. Должен быть реализован для всех типов с понятием равенства, основанным на абстрактном значении, которое представляет экземпляр. Например, все числовые типы сравниваются по числовому значению, игнорируя тип. Строки сравниваются как последовательности символов, игнорируя кодировку. Коллекции одного типа обычно сравнивают свои наборы ключей, и если они равны ==, то сравнивают значения для каждого из этих ключей, возвращая true, если все такие пары равны ==. Другие свойства обычно не принимаются во внимание (такие как точный тип).

Этот оператор следует семантике IEEE для чисел с плавающей запятой: 0.0 == -0.0 и NaN != NaN.

Результат имеет тип Bool, за исключением случаев, когда один из операндов является missing, в этом случае возвращается missing (трехзначная логика). Коллекции обычно реализуют трехзначную логику, аналогичную all, возвращая missing, если какие-либо операнды содержат отсутствующие значения, и все остальные пары равны. Используйте isequal или ===, чтобы всегда получать результат типа Bool.

Реализация

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

isequal падает обратно на ==, поэтому новые методы == будут использоваться типом Dict для сравнения ключей. Если ваш тип будет использоваться в качестве ключа словаря, он также должен реализовать hash.

Если какой-либо тип определяет ==, isequal и isless, то он также должен реализовать <, чтобы обеспечить согласованность сравнений.

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

Оператор сравнения "не равно". Всегда дает противоположный ответ по сравнению с ==.

Реализация

Новые типы обычно не должны реализовывать это и полагаться на запасное определение !=(x,y) = !(x==y) вместо этого.

Примеры

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

!=(x)

Создайте функцию, которая сравнивает свой аргумент с x, используя !=, т.е. функцию, эквивалентную y -> y != x. Возвращаемая функция имеет тип Base.Fix2{typeof(!=)}, который можно использовать для реализации специализированных методов.

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

Всегда дает противоположный ответ по сравнению с ===.

Примеры

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

julia> a ≢ b
true

julia> a ≢ a
false

<(x, y)

Оператор сравнения "меньше чем". Падает обратно на isless. Из-за поведения значений NaN с плавающей запятой этот оператор реализует частичный порядок.

Реализация

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

См. также isunordered.

Примеры

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

<(x)

Создайте функцию, которая сравнивает свой аргумент с x, используя <, т.е. функцию, эквивалентную y -> y < x. Возвращаемая функция имеет тип Base.Fix2{typeof(<)}, который можно использовать для реализации специализированных методов.

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

Оператор сравнения "меньше или равно". Падает обратно на (x < y) | (x == y).

Примеры

julia> 'a' <= 'b'
true

julia> 7 ≤ 7 ≤ 9
true

julia> "abc" ≤ "abc"
true

julia> 5 <= 3
false

<=(x)

Создайте функцию, которая сравнивает свой аргумент с x, используя <=, т.е. функцию, эквивалентную y -> y <= x. Возвращаемая функция имеет тип Base.Fix2{typeof(<=)}, который можно использовать для реализации специализированных методов.

>(x, y)

Оператор сравнения "больше чем". Падает обратно на y < x.

Реализация

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

Примеры

julia> 'a' > 'b'
false

julia> 7 > 3 > 1
true

julia> "abc" > "abd"
false

julia> 5 > 3
true

>(x)

Создайте функцию, которая сравнивает свой аргумент с x, используя >, т.е. функцию, эквивалентную y -> y > x. Возвращаемая функция имеет тип Base.Fix2{typeof(>)}, который можно использовать для реализации специализированных методов.

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

Оператор сравнения "больше или равно". Падает обратно на y <= x.

Примеры

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

>=(x)

Создайте функцию, которая сравнивает свой аргумент с x, используя >=, т.е. функцию, эквивалентную y -> y >= x. Возвращаемая функция имеет тип Base.Fix2{typeof(>=)}, который можно использовать для реализации специализированных методов.

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})
[...]

cmp(<, x, y)

Возвращает -1, 0 или 1 в зависимости от того, меньше ли x, равно ли x или больше x, чем y, соответственно. Первый аргумент указывает функцию сравнения "меньше чем", которую следует использовать.

cmp(a::AbstractString, b::AbstractString) -> Int

Сравните две строки. Верните 0, если обе строки имеют одинаковую длину и символ на каждом индексе одинаков в обеих строках. Верните -1, если a является префиксом b, или если a предшествует b в алфавитном порядке. Верните 1, если b является префиксом a, или если b предшествует a в алфавитном порядке (технически, лексикографическом порядке по кодовым точкам Unicode).

Примеры

julia> cmp("abc", "abc")
0

julia> cmp("ab", "abc")
-1

julia> cmp("abc", "ab")
1

julia> cmp("ab", "ac")
-1

julia> cmp("ac", "ab")
1

julia> cmp("α", "a")
1

julia> cmp("b", "β")
-1

~(x)

Побитовая инверсия.

Смотрите также: !, &, |.

Примеры

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

x & y

Побитовая конъюнкция. Реализует трехзначную логику, возвращая missing, если один из операндов равен missing, а другой — true. Добавьте скобки для формы применения функции: (&)(x, y).

Смотрите также: |, xor, &&.

Примеры

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

x | y

Побитовая операция "или". Реализует трехзначную логику, возвращая missing, если один из операндов равен missing, а другой - false.

См. также: &, xor, ||.

Примеры

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

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

Побитовая исключающая или x и y. Реализует трехзначную логику, возвращая missing, если один из аргументов равен missing.

Инфиксная операция a ⊻ b является синонимом для xor(a,b), и ⊻ можно ввести, используя автозаполнение \xor или \veebar в Julia REPL.

Примеры

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

julia> [true; true; false] .⊻ [true; false; false]
3-element BitVector:
 0
 1
 0

nand(x, y)
⊼(x, y)

Побитовая операция nand (не и) для x и y. Реализует трехзначную логику, возвращая missing, если один из аргументов равен missing.

Инфиксная операция a ⊼ b является синонимом для nand(a,b), и ⊼ можно ввести, используя автозаполнение \nand или \barwedge в Julia REPL.

Примеры

julia> nand(true, false)
true

julia> nand(true, true)
false

julia> nand(true, missing)
missing

julia> false ⊼ false
true

julia> [true; true; false] .⊼ [true; false; false]
3-element BitVector:
 0
 1
 1

nor(x, y)
⊽(x, y)

Побитовая операция nor (не или) для x и y. Реализует трехзначную логику, возвращая missing, если один из аргументов равен missing, а другой не равен true.

Инфиксная операция a ⊽ b является синонимом для nor(a,b), и ⊽ можно ввести, используя автозаполнение \nor или \barvee в Julia REPL.

Примеры

julia> nor(true, false)
false

julia> nor(true, true)
false

julia> nor(true, missing)
false

julia> false ⊽ false
true

julia> false ⊽ missing
missing

julia> [true; true; false] .⊽ [true; false; false]
3-element BitVector:
 0
 0
 1

!(x)

Логическое отрицание. Реализует трехзначную логику, возвращая missing, если x равно missing.

Смотрите также ~ для побитового отрицания.

Примеры

julia> !true
false

julia> !false
true

julia> !missing
missing

julia> .![true false true]
1×3 BitMatrix:
 0  1  0

!f::Function

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

Смотрите также ∘.

Примеры

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

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

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

x && y

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

Смотрите также &, тернарный оператор ? : и раздел справки о управляющем потоке.

Примеры

julia> x = 3;

julia> x > 1 && x < 10 && x isa Int
true

julia> x < 0 && error("ожидалось положительное x")
false

x || y

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

См. также: |, xor, &&.

Примеры

julia> pi < 3 || ℯ < 3
true

julia> false || true || println("ни одно не истинно!")
true

isapprox(x, y; atol::Real=0, rtol::Real=atol>0 ? 0 : √eps, nans::Bool=false[, norm::Function])

Не точное сравнение на равенство. Два числа считаются равными, если их относительное расстояние или их абсолютное расстояние находятся в пределах допустимой погрешности: isapprox возвращает true, если norm(x-y) <= max(atol, rtol*max(norm(x), norm(y))). Значение по умолчанию для atol (абсолютная погрешность) равно нулю, а значение по умолчанию для rtol (относительная погрешность) зависит от типов x и y. Аргумент nans определяет, считаются ли значения NaN равными (по умолчанию false).

Для действительных или комплексных чисел с плавающей запятой, если atol > 0 не указан, rtol по умолчанию равен квадратному корню из eps типа x или y, в зависимости от того, какой из них больше (наименее точный). Это соответствует требованию равенства примерно половины значащих цифр. В противном случае, например, для целочисленных аргументов или если указан atol > 0, rtol по умолчанию равен нулю.

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

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

Обратите внимание, что x ≈ 0 (т.е. сравнение с нулем с допущениями по умолчанию) эквивалентно x == 0, поскольку значение по умолчанию для atol равно 0. В таких случаях вы должны либо указать соответствующий atol (или использовать norm(x) ≤ atol), либо изменить свой код (например, использовать x ≈ y, а не x - y ≈ 0). Невозможно автоматически выбрать ненулевое значение atol, поскольку оно зависит от общего масштаба («единиц») вашей задачи: например, в x - y ≈ 0, atol=1e-9 является абсурдно малой погрешностью, если x — это радиус Земли в метрах, но абсурдно большой погрешностью, если x — это радиус атома водорода в метрах.

Примеры

julia> isapprox(0.1, 0.15; atol=0.05)
true

julia> isapprox(0.1, 0.15; rtol=0.34)
true

julia> isapprox(0.1, 0.15; rtol=0.33)
false

julia> 0.1 + 1e-10 ≈ 0.1
true

julia> 1e-10 ≈ 0
false

julia> isapprox(1e-10, 0, atol=1e-8)
true

julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0]) # используя `norm`
true

isapprox(x; kwargs...) / ≈(x; kwargs...)

Создайте функцию, которая сравнивает свой аргумент с x, используя ≈, т.е. функцию, эквивалентную y -> y ≈ x.

Поддерживаемые именованные аргументы здесь такие же, как и в 2-аргументном isapprox.

sin(x)

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

Смотрите также sind, sinpi, sincos, cis, asin.

Примеры

julia> round.(sin.(range(0, 2pi, length=9)'), digits=3)
1×9 Matrix{Float64}:
 0.0  0.707  1.0  0.707  0.0  -0.707  -1.0  -0.707  -0.0

julia> sind(45)
0.7071067811865476

julia> sinpi(1/4)
0.7071067811865475

julia> round.(sincos(pi/6), digits=3)
(0.5, 0.866)

julia> round(cis(pi/6), digits=3)
0.866 + 0.5im

julia> round(exp(im*pi/6), digits=3)
0.866 + 0.5im

cos(x)

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

Смотрите также cosd, cospi, sincos, cis.

sincos(x)

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

Смотрите также cis, sincospi, sincosd.

tan(x)

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

sind(x)

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

cosd(x)

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

tand(x)

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

sincosd(x)

Одновременно вычисляет синус и косинус x, где x выражено в градусах.

sinpi(x)

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

Смотрите также sind, cospi, sincospi.

cospi(x)

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

tanpi(x)

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

Смотрите также tand, sinpi, cospi, sincospi.

sincospi(x)

Одновременно вычисляет sinpi(x) и cospi(x) (синус и косинус π*x, где x в радианах), возвращая кортеж (синус, косинус).

См. также: cispi, sincosd, sinpi.

sinh(x)

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

cosh(x)

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

tanh(x)

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

См. также tan, atanh.

Примеры

julia> tanh.(-3:3f0)  # Здесь 3f0 является Float32
7-элементный вектор{Float32}:
 -0.9950548
 -0.9640276
 -0.7615942
  0.0
  0.7615942
  0.9640276
  0.9950548

julia> tan.(im .* (1:3))
3-элементный вектор{ComplexF64}:
 0.0 + 0.7615941559557649im
 0.0 + 0.9640275800758169im
 0.0 + 0.9950547536867306im

asin(x)

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

Смотрите также asind для вывода в градусах.

Примеры

julia> asin.((0, 1/2, 1))
(0.0, 0.5235987755982989, 1.5707963267948966)

julia> asind.((0, 1/2, 1))
(0.0, 30.000000000000004, 90.0)

acos(x)

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

atan(y)
atan(y, x)

Вычисляет обратный тангенс y или y/x, соответственно.

Для одного действительного аргумента это угол в радианах между положительной x-осью и точкой (1, y), возвращая значение в интервале $[-\pi/2, \pi/2]$.

Для двух аргументов это угол в радианах между положительной x-осью и точкой (x, y), возвращая значение в интервале $[-\pi, \pi]$. Это соответствует стандартной функции atan2. Обратите внимание, что по соглашению atan(0.0,x) определяется как $\pi$, а atan(-0.0,x) определяется как $-\pi$, когда x < 0.

Смотрите также atand для градусов.

Примеры

julia> rad2deg(atan(-1/√3))
-30.000000000000004

julia> rad2deg(atan(-1, √3))
-30.000000000000004

julia> rad2deg(atan(1, -√3))
150.0

asind(x)

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

acosd(x)

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

atand(y)
atand(y,x)

Вычисляет обратный тангенс y или y/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, где вывод представлен в градусах. Если x является матрицей, x должен быть квадратной матрицей.

acscd(x)

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

acotd(x)

Вычисляет обратный котангенс x, где вывод представлен в градусах. Если 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)

Вычислите нормализованную функцию sinc $\operatorname{sinc}(x) = \sin(\pi x) / (\pi x)$, если $x \neq 0$, и $1$, если $x = 0$.

Смотрите также cosc, её производную.

cosc(x)

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

Смотрите также sinc.

deg2rad(x)

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

Смотрите также rad2deg, sind, pi.

Примеры

julia> deg2rad(90)
1.5707963267948966

rad2deg(x)

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

См. также deg2rad.

Примеры

julia> rad2deg(pi)
180.0

hypot(x, y)

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

Этот код является реализацией алгоритма, описанного в: Улучшенный алгоритм для hypot(a,b) Карлоса Ф. Боргеса. Статья доступна онлайн на arXiv по ссылке https://arxiv.org/abs/1904.09481

hypot(x...)

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

Смотрите также norm в стандартной библиотеке LinearAlgebra.

Примеры

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # a^2 переполняется
ERROR: DomainError with -2.914184810805068e18:
sqrt был вызван с отрицательным действительным аргументом, но вернет комплексный результат только в случае вызова с комплексным аргументом. Попробуйте sqrt(Complex(x)).
Stacktrace:
[...]

julia> hypot(3, 4im)
5.0

julia> hypot(-5.7)
5.7

julia> hypot(3, 4im, 12.0)
13.0

julia> using LinearAlgebra

julia> norm([a, a, a, a]) == hypot(a, a, a, a)
true

log(x)

Вычисляет натуральный логарифм x.

Вызывает DomainError для отрицательных Real аргументов. Используйте комплексные аргументы, чтобы получить комплексные результаты. Имеет разрыв вдоль отрицательной действительной оси, для которой -0.0im принимается за находящееся ниже оси.

См. также ℯ, log1p, log2, log10.

Примеры

julia> log(2)
0.6931471805599453

julia> log(-3)
ERROR: DomainError with -3.0:
log был вызван с отрицательным действительным аргументом, но вернет только комплексный результат, если будет вызван с комплексным аргументом. Попробуйте log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(-3 + 0im)
1.0986122886681098 + 3.141592653589793im

julia> log(-3 - 0.0im)
1.0986122886681098 - 3.141592653589793im

julia> log.(exp.(-1:1))
3-element Vector{Float64}:
 -1.0
  0.0
  1.0

log(b,x)

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

Примеры

julia> log(4,8)
1.5

julia> log(4,2)
0.5

julia> log(-2, 3)
ERROR: DomainError with -2.0:
log был вызван с отрицательным действительным аргументом, но вернет только комплексный результат, если будет вызван с комплексным аргументом. Попробуйте log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(2, -3)
ERROR: DomainError with -3.0:
log был вызван с отрицательным действительным аргументом, но вернет только комплексный результат, если будет вызван с комплексным аргументом. Попробуйте log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0

log2(x)

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

См. также: exp2, ldexp, ispow2.

Примеры

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
ERROR: DomainError with -2.0:
log2 был вызван с отрицательным действительным аргументом, но вернет только комплексный результат, если будет вызван с комплексным аргументом. Попробуйте log2(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

julia> log2.(2.0 .^ (-1:1))
3-element Vector{Float64}:
 -1.0
  0.0
  1.0

log10(x)

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

Примеры

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

julia> log10(-2)
ERROR: DomainError with -2.0:
log10 был вызван с отрицательным действительным аргументом, но вернет комплексный результат только в случае вызова с комплексным аргументом. Попробуйте log10(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

log1p(x)

Точный натуральный логарифм 1+x. Вызывает DomainError для аргументов Real, меньших -1.

Примеры

julia> log1p(-0.5)
-0.6931471805599453

julia> log1p(0)
0.0

julia> log1p(-2)
ERROR: DomainError with -2.0:
log1p был вызван с действительным аргументом < -1, но вернет комплексный результат только в случае вызова с комплексным аргументом. Попробуйте log1p(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

frexp(val)

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

Смотрите также significand, exponent, ldexp.

Примеры

julia> frexp(6.0)
(0.75, 3)

julia> significand(6.0), exponent(6.0)  # интервал [1, 2) вместо
(1.5, 2)

julia> frexp(0.0), frexp(NaN), frexp(-Inf)  # экспонента вызовет ошибку
((0.0, 0), (NaN, 0), (-Inf, 0))

exp(x)

Вычислите натуральный экспоненциальный базис x, другими словами $ℯ^x$.

Смотрите также exp2, exp10 и cis.

Примеры

julia> exp(1.0)
2.718281828459045

julia> exp(im * pi) ≈ cis(pi)
true

exp2(x)

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

Смотрите также ldexp, <<.

Примеры

julia> exp2(5)
32.0

julia> 2^5
32

julia> exp2(63) > typemax(Int)
true

exp10(x)

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

Примеры

julia> exp10(2)
100.0

julia> 10^2
100

ldexp(x, n)

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

Смотрите также frexp, exponent.

Примеры

julia> ldexp(5.0, 2)
20.0

modf(x)

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

Примеры

julia> modf(3.5)
(0.5, 3.0)

julia> modf(-3.5)
(-0.5, -3.0)

expm1(x)

Точно вычисляет $e^x-1$. Это позволяет избежать потери точности, связанной с прямым вычислением exp(x)-1 для малых значений x.

Примеры

julia> expm1(1e-16)
1.0e-16

julia> exp(1e-16) - 1
0.0

round([T,] x, [r::RoundingMode])
round(x, [r::RoundingMode]; digits::Integer=0, base = 10)
round(x, [r::RoundingMode]; sigdigits::Integer, base = 10)

Округляет число x.

Без именованных аргументов x округляется до целого значения, возвращая значение типа T, или того же типа, что и x, если T не указано. Исключение InexactError будет выброшено, если значение не может быть представлено типом T, аналогично convert.

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

Если указан именованный аргумент sigdigits, округление происходит до указанного количества значащих цифр, в системе счисления base.

Режим округления RoundingMode r управляет направлением округления; по умолчанию используется RoundNearest, который округляет до ближайшего целого числа, при равенстве (дробные значения 0.5) округляется до ближайшего четного целого числа. Обратите внимание, что round может давать неверные результаты, если глобальный режим округления изменен (см. rounding).

При округлении до типа с плавающей запятой, округление происходит до целых чисел, представимых этим типом (и Inf), а не до истинных целых чисел. Inf рассматривается как одно ulp больше, чем floatmax(T) для целей определения "ближайшего", аналогично convert.

Примеры

julia> round(1.7)
2.0

julia> round(Int, 1.7)
2

julia> round(1.5)
2.0

julia> round(2.5)
2.0

julia> round(pi; digits=2)
3.14

julia> round(pi; digits=3, base=2)
3.125

julia> round(123.456; sigdigits=2)
120.0

julia> round(357.913; sigdigits=4, base=2)
352.0

julia> round(Float16, typemax(UInt128))
Inf16

julia> floor(Float16, typemax(UInt128))
Float16(6.55e4)

julia> x = 1.15
1.15

julia> big(1.15)
1.149999999999999911182158029987476766109466552734375

julia> x < 115//100
true

julia> round(x, digits=1)
1.2

Расширения

Чтобы расширить round для новых числовых типов, обычно достаточно определить Base.round(x::NewType, r::RoundingMode).

RoundingMode

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

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

• RoundNearest (по умолчанию)
• RoundNearestTiesAway
• RoundNearestTiesUp
• RoundToZero
• RoundFromZero
• RoundUp
• RoundDown

RoundNearest

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

RoundNearestTiesAway

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

RoundNearestTiesUp

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

ОкруглениеКНулю

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

RoundFromZero

Округляет от нуля.

Примеры

julia> BigFloat("1.0000000000000001", 5, RoundFromZero)
1.06

ОкруглениеВверх

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

ОкруглениеВниз

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

round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]])
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; digits=0, base=10)
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; sigdigits, base=10)

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

RoundingModeReal и RoundingModeImaginary по умолчанию равны RoundNearest, который округляет до ближайшего целого числа, при этом ничьи (дробные значения 0.5) округляются до ближайшего четного целого числа.

Примеры

julia> round(3.14 + 4.5im)
3.0 + 4.0im

julia> round(3.14 + 4.5im, RoundUp, RoundNearestTiesUp)
4.0 + 5.0im

julia> round(3.14159 + 4.512im; digits = 1)
3.1 + 4.5im

julia> round(3.14159 + 4.512im; sigdigits = 3)
3.14 + 4.51im

ceil([T,] x)
ceil(x; digits::Integer= [, base = 10])
ceil(x; sigdigits::Integer= [, base = 10])

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

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

Ключевые слова digits, sigdigits и base работают так же, как для round.

Чтобы поддержать ceil для нового типа, определите Base.round(x::NewType, ::RoundingMode{:Up}).

floor([T,] x)
floor(x; digits::Integer= [, base = 10])
floor(x; sigdigits::Integer= [, base = 10])

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

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

Ключевые слова digits, sigdigits и base работают так же, как для round.

Чтобы поддержать floor для нового типа, определите Base.round(x::NewType, ::RoundingMode{:Down}).

trunc([T,] x)
trunc(x; digits::Integer= [, base = 10])
trunc(x; sigdigits::Integer= [, base = 10])

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

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

Ключевые слова digits, sigdigits и base работают так же, как для round.

Чтобы поддержать trunc для нового типа, определите Base.round(x::NewType, ::RoundingMode{:ToZero}).

См. также: %, floor, unsigned, unsafe_trunc.

Примеры

julia> trunc(2.22)
2.0

julia> trunc(-2.22, digits=1)
-2.2

julia> trunc(Int, -2.22)
-2

unsafe_trunc(T, x)

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

Примеры

julia> unsafe_trunc(Int, -2.2)
-2

julia> unsafe_trunc(Int, NaN)
-9223372036854775808

min(x, y, ...)

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

Примеры

julia> min(2, 5, 1)
1

julia> min(4, missing, 6)
missing

max(x, y, ...)

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

Примеры

julia> max(2, 5, 1)
5

julia> max(5, missing, 6)
missing

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 > hi, возвращает hi. Если x < lo, возвращает lo. Аргументы приводятся к общему типу.

См. также clamp!, min, max.

Примеры

julia> clamp.([pi, 1.0, big(10)], 2.0, 9.0)
3-element Vector{BigFloat}:
 3.141592653589793238462643383279502884197169399375105820974944592307816406286198
 2.0
 9.0

julia> clamp.([11, 8, 5], 10, 6)  # пример, где lo > hi
3-element Vector{Int64}:
  6
  6
 10

clamp(x, T)::T

Ограничивает x между typemin(T) и typemax(T) и преобразует результат в тип T.

См. также trunc.

Примеры

julia> clamp(200, Int8)
127

julia> clamp(-200, Int8)
-128

julia> trunc(Int, 4pi^2)
39

clamp(x::Integer, r::AbstractUnitRange)

Ограничьте x так, чтобы он находился в пределах диапазона r.

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

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

Примеры

julia> row = collect(-4:4)';

julia> clamp!(row, 0, Inf)
1×9 adjoint(::Vector{Int64}) with eltype Int64:
 0  0  0  0  0  1  2  3  4

julia> clamp.((-4:4)', 0, Inf)
1×9 Matrix{Float64}:
 0.0  0.0  0.0  0.0  0.0  1.0  2.0  3.0  4.0

abs(x)

Абсолютное значение x.

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

См. также: abs2, unsigned, sign.

Примеры

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs.(Int8[-128 -127 -126 0 126 127])  # переполнение при typemin(Int8)
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

julia> maximum(abs, [1, -2, 3, -4])
4

Проверено

Модуль Checked предоставляет арифметические функции для встроенных знаковых и беззнаковых целочисленных типов, которые вызывают ошибку при переполнении. Они называются как checked_sub, checked_div и т.д. В дополнение, add_with_overflow, sub_with_overflow, mul_with_overflow возвращают как непроверенные результаты, так и логическое значение, указывающее на наличие переполнения.

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), проверяя на наличие ошибок переполнения, где это применимо.

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

Base.checked_pow(x, y)

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

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

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

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

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

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

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

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

abs2(x)

Квадрат абсолютного значения x.

Это может быть быстрее, чем abs(x)^2, особенно для комплексных чисел, где abs(x) требует извлечения квадратного корня через hypot.

См. также abs, conj, real.

Примеры

julia> abs2(-3)
9

julia> abs2(3.0 + 4.0im)
25.0

julia> sum(abs2, [1+2im, 3+4im])  # LinearAlgebra.norm(x)^2
30

copysign(x, y) -> z

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

Примеры

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

sign(x)

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

См. также signbit, zero, copysign, flipsign.

Примеры

julia> sign(-4.0)
-1.0

julia> sign(99)
1

julia> sign(-0.0)
-0.0

julia> sign(0 + im)
0.0 + 1.0im

signbit(x)

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

Смотрите также sign и copysign.

Примеры

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true

flipsign(x, y)

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

Примеры

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5

sqrt(x)

Возвращает $\sqrt{x}$.

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

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

Смотрите также: hypot.

Примеры

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError with -81.0:
NaN result for non-NaN input.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

julia> sqrt(big(complex(-81)))
0.0 + 9.0im

julia> sqrt(-81 - 0.0im)  # -0.0im находится ниже разрыва
0.0 - 9.0im

julia> .√(1:4)
4-element Vector{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772
 2.0

isqrt(n::Integer)

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

julia> isqrt(5)
2

cbrt(x::Real)

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

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

Примеры

julia> cbrt(big(27))
3.0

julia> cbrt(big(-27))
-3.0

real(z)

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

Смотрите также: imag, reim, complex, isreal, Real.

Примеры

julia> real(1 + 3im)
1

real(T::Type)

Возвращает тип, который представляет действительную часть значения типа T. Например: для T == Complex{R} возвращает R. Эквивалентно typeof(real(zero(T))).

Примеры

julia> real(Complex{Int})
Int64

julia> real(Float64)
Float64

real(A::AbstractArray)

Возвращает массив, содержащий действительную часть каждого элемента массива A.

Эквивалентно real.(A), за исключением того, что когда eltype(A) <: Real, A возвращается без копирования, и что когда A имеет нулевую размерность, возвращается 0-мерный массив (вместо скаляра).

Примеры

julia> real([1, 2im, 3 + 4im])
3-element Vector{Int64}:
 1
 0
 3

julia> real(fill(2 - im))
0-dimensional Array{Int64, 0}:
2

imag(z)

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

Смотрите также: conj, reim, adjoint, angle.

Примеры

julia> imag(1 + 3im)
3

imag(A::AbstractArray)

Возвращает массив, содержащий мнимую часть каждого элемента массива A.

Эквивалентно imag.(A), за исключением того, что когда A имеет нулевую размерность, возвращается массив с нулевой размерностью (вместо скаляра).

Примеры

julia> imag([1, 2im, 3 + 4im])
3-element Vector{Int64}:
 0
 2
 4

julia> imag(fill(2 - im))
0-dimensional Array{Int64, 0}:
-1

reim(z)

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

Примеры

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

reim(A::AbstractArray)

Возвращает кортеж из двух массивов, содержащих соответственно действительную и мнимую части каждого элемента в A.

Эквивалентно (real.(A), imag.(A)), за исключением того, что когда eltype(A) <: Real, A возвращается без копирования для представления действительной части, и что когда A имеет нулевые размеры, возвращается 0-мерный массив (вместо скаляра).

Примеры

julia> reim([1, 2im, 3 + 4im])
([1, 0, 3], [0, 2, 4])

julia> reim(fill(2 - im))
(fill(2), fill(-1))

conj(z)

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

Смотрите также: angle, adjoint.

Примеры

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

conj(A::AbstractArray)

Возвращает массив, содержащий комплексное сопряжение каждого элемента массива A.

Эквивалентно conj.(A), за исключением того, что когда eltype(A) <: Real, A возвращается без копирования, и что когда A имеет нулевую размерность, возвращается массив с нулевой размерностью (вместо скаляра).

Примеры

julia> conj([1, 2im, 3 + 4im])
3-element Vector{Complex{Int64}}:
 1 + 0im
 0 - 2im
 3 - 4im

julia> conj(fill(2 - im))
0-dimensional Array{Complex{Int64}, 0}:
2 + 1im

angle(z)

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

Возвращает число -pi ≤ angle(z) ≤ pi, и, следовательно, является разрывным вдоль отрицательной действительной оси.

См. также: atan, cis, rad2deg.

Примеры

julia> rad2deg(angle(1 + im))
45.0

julia> rad2deg(angle(1 - im))
-45.0

julia> rad2deg(angle(-1 + 1e-20im))
180.0

julia> rad2deg(angle(-1 - 1e-20im))
-180.0

cis(x)

Более эффективный метод для exp(im*x) с использованием формулы Эйлера: $\cos(x) + i \sin(x) = \exp(i x)$.

Смотрите также cispi, sincos, exp, angle.

Примеры

julia> cis(π) ≈ -1
true

cispi(x)

Более точный метод для cis(pi*x) (особенно для больших x).

См. также cis, sincospi, exp, angle.

Примеры

julia> cispi(10000)
1.0 + 0.0im

julia> cispi(0.25 + 1im)
0.030556854645954562 + 0.03055685464595456im

binomial(n::Integer, k::Integer)

Биномиальный коэффициент $\binom{n}{k}$ является коэффициентом $k$-го члена в полиномиальном разложении $(1+x)^n$.

Если $n$ неотрицательное, то это количество способов выбрать k из n элементов:

\[\binom{n}{k} = \frac{n!}{k! (n-k)!}\]

где $n!$ — это функция factorial.

Если $n$ отрицательное, то он определяется через тождество

\[\binom{n}{k} = (-1)^k \binom{k-n-1}{k}\]

См. также factorial.

Примеры

julia> binomial(5, 3)
10

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

julia> binomial(-5, 3)
-35

Внешние ссылки

• Биномиальный коэффициент на Wikipedia.

binomial(x::Number, k::Integer)

Обобщенный биномиальный коэффициент, определенный для k ≥ 0 полиномом

\[\frac{1}{k!} \prod_{j=0}^{k-1} (x - j)\]

Когда k < 0, он возвращает ноль.

В случае целого x это эквивалентно обычному целому биномиальному коэффициенту

\[\binom{n}{k} = \frac{n!}{k! (n-k)!}\]

Дальнейшие обобщения для нецелого k математически возможны, но включают функцию Гамма и/или функцию бета, которые не предоставляются стандартной библиотекой Julia, но доступны в внешних пакетах, таких как SpecialFunctions.jl.

Внешние ссылки

• Биномиальный коэффициент на Википедии.

factorial(n::Integer)

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

Смотрите также binomial.

Примеры

julia> factorial(6)
720

julia> factorial(21)
ERROR: OverflowError: 21 is too large to look up in the table; consider using `factorial(big(21))` instead
Stacktrace:
[...]

julia> factorial(big(21))
51090942171709440000

Внешние ссылки

• Факториал на Википедии.

gcd(x, y...)

Наибольший общий (положительный) делитель (или ноль, если все аргументы равны нулю). Аргументы могут быть целыми и рациональными числами.

Примеры

julia> gcd(6, 9)
3

julia> gcd(6, -9)
3

julia> gcd(6, 0)
6

julia> gcd(0, 0)
0

julia> gcd(1//3, 2//3)
1//3

julia> gcd(1//3, -2//3)
1//3

julia> gcd(1//3, 2)
1//3

julia> gcd(0, 0, 10, 15)
5

lcm(x, y...)

Наименьшее общее (положительное) кратное (или ноль, если любой аргумент равен нулю). Аргументы могут быть целыми и рациональными числами.

Примеры

julia> lcm(2, 3)
6

julia> lcm(-2, 3)
6

julia> lcm(0, 3)
0

julia> lcm(0, 0)
0

julia> lcm(1//3, 2//3)
2//3

julia> lcm(1//3, -2//3)
2//3

julia> lcm(1//3, 2)
2//1

julia> lcm(1, 3, 5, 7)
105

gcdx(a, b)

Вычисляет наибольший общий (положительный) делитель a и b и их коэффициенты Безу, т.е. целочисленные коэффициенты u и v, которые удовлетворяют $ua+vb = d = gcd(a, b)$. $gcdx(a, b)$ возвращает $(d, u, v)$.

Аргументы могут быть целыми и рациональными числами.

Примеры

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

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

ispow2(n::Number) -> Bool

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

Смотрите также count_ones, prevpow, nextpow.

Примеры

julia> ispow2(4)
true

julia> ispow2(5)
false

julia> ispow2(4.5)
false

julia> ispow2(0.25)
true

julia> ispow2(1//8)
true

nextpow(a, x)

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

Смотрите также prevpow.

Примеры

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16

prevpow(a, x)

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

См. также nextpow, isqrt.

Примеры

julia> prevpow(2, 7)
4

julia> prevpow(2, 9)
8

julia> prevpow(5, 20)
5

julia> prevpow(4, 16)
16

nextprod(factors::Union{Tuple,AbstractVector}, n)

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

Примеры

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

julia> 2^2 * 3^3
108

invmod(n::Integer, m::Integer)

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

Примеры

julia> invmod(2, 5)
3

julia> invmod(2, 3)
2

julia> invmod(5, 6)
5

invmod(n::Integer, T) where {T <: Base.BitInteger}
invmod(n::T) where {T <: Base.BitInteger}

Вычисляет обратный элемент по модулю n в кольце целых чисел типа T, т.е. по модулю 2^N, где N = 8*sizeof(T) (например, N = 32 для Int32). Другими словами, эти методы удовлетворяют следующим тождествам:

n * invmod(n) == 1
(n * invmod(n, T)) % T == 1
(n % T) * invmod(n, T) == 1

Обратите внимание, что * здесь является модульным умножением в кольце целых чисел T.

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

Обратный элемент по модулю вычисляется гораздо более эффективно, чем в общем случае, с использованием алгоритма, описанного в https://arxiv.org/pdf/2204.04342.pdf.

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

ndigits(n::Integer; base::Integer=10, pad::Integer=1)

Вычисляет количество цифр в целом числе n, записанном в системе счисления с основанием base (base не должен быть в [-1, 0, 1]), с возможным дополнением нулями до указанного размера (результат никогда не будет меньше pad).

См. также digits, count_ones.

Примеры

julia> ndigits(0)
1

julia> ndigits(12345)
5

julia> ndigits(1022, base=16)
3

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

julia> ndigits(123, pad=5)
5

julia> ndigits(-123)
3

Base.add_sum(x, y)

Оператор редукции, используемый в sum. Основное отличие от + заключается в том, что маленькие целые числа преобразуются в Int/UInt.

widemul(x, y)

Умножает x и y, возвращая результат в виде большего типа.

Смотрите также promote, Base.add_sum.

Примеры

julia> widemul(Float32(3.0), 4.0) isa BigFloat
true

julia> typemax(Int8) * typemax(Int8)
1

julia> widemul(typemax(Int8), typemax(Int8))  # == 127^2
16129

evalpoly(x, p)

Оцените многочлен $\sum_k x^{k-1} p[k]$ для коэффициентов p[1], p[2], ...; то есть коэффициенты даны в порядке возрастания по степени x. Циклы разворачиваются на этапе компиляции, если количество коэффициентов статически известно, т.е. когда p является Tuple. Эта функция генерирует эффективный код, используя метод Хорнера, если x является действительным, или используя алгоритм, похожий на алгоритм Гертцеля ^[DK62], если x является комплексным.

Примеры

julia> evalpoly(2, (1, 2, 3))
17

@evalpoly(z, c...)

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

См. также evalpoly.

Примеры

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

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

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

@fastmath expr

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

Это устанавливает флаги быстрого математического LLVM и соответствует опции -ffast-math в clang. См. заметки о аннотациях производительности для получения дополнительной информации.

Примеры

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672