Математика

-(x)

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

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

Примеры

julia> -1
-1

julia> -(2)
-2

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

julia> -(true)  # promotes to 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]  # matrix * vector
2-element Vector{Int64}:
  2
 30

julia> 1/2pi, 1/2*pi  # juxtaposition has higher precedence
(0.15915494309189535, 1.5707963267948966)

julia> x = [1, 2]; x'x  # adjoint vector * vector
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  # uses 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  # integer overflow
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) # Matches div(4, 3)
1
julia> div(4, 3, RoundDown) # Matches fld(4, 3)
1
julia> div(4, 3, RoundUp) # Matches 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  # same as rem(x, y)
1

julia> x ÷ y  # same as 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 бит, заполняя 0. Это эквивалентно 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"

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

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

>>>(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 — это начальное значение r[1], но альтернативно вы можете указать его как значение для некоторого другого индекса 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)  # middle element is the geometric mean
true

julia> range(10, 40, length=3)[2] ≈ (10 + 40)/2  # arithmetic mean
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, если какой-либо из операндов содержит 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 меньше, равно или больше 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), и ⊻ можно ввести, нажав Tab, после ввода \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), и ⊼ можно ввести, нажав клавишу Tab после ввода \nand или \barwedge в интерактивной оболочке Julia.

Примеры

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), и ⊽ можно ввести, нажав клавишу Tab после ввода \nor или \barvee в интерактивной оболочке Julia.

Примеры

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("expected positive x")
false

x || y

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

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

Примеры

julia> pi < 3 || ℯ < 3
true

julia> false || true || println("neither is true!")
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 как равные (по умолчанию ложь).

Для вещественных или комплексных чисел с плавающей запятой, если 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]) # using `norm`
true

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

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

Ключевые слова, поддерживаемые здесь, такие же, как и в двухаргументной функции 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 в радианах, возвращая кортеж (sine, cosine).

См. также 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 в радианах), возвращая кортеж (sine, cosine).

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

sinh(x)

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

cosh(x)

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

tanh(x)

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

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

Примеры

julia> tanh.(-3:3f0)  # Here 3f0 isa Float32
7-element Vector{Float32}:
 -0.9950548
 -0.9640276
 -0.7615942
  0.0
  0.7615942
  0.9640276
  0.9950548

julia> tan.(im .* (1:3))
3-element Vector{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}$, избегая переполнения и потери точности.

Этот код — реализация алгоритма, описанного в: An Improved Algorithm for hypot(a,b) by Carlos F. Borges Статья доступна в 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 overflows
ERROR: DomainError with -2.914184810805068e18:
sqrt was called with a negative real argument but will only return a complex result if called with a complex argument. Try 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 was called with a negative real argument but will only return a complex result if called with a complex argument. Try 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)

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

Примеры

julia> log(4,8)
1.5

julia> log(4,2)
0.5

julia> log(-2, 3)
ERROR: DomainError with -2.0:
log was called with a negative real argument but will only return a complex result if called with a complex argument. Try log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(2, -3)
ERROR: DomainError with -3.0:
log was called with a negative real argument but will only return a complex result if called with a complex argument. Try 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 was called with a negative real argument but will only return a complex result if called with a complex argument. Try 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 was called with a negative real argument but will only return a complex result if called with a complex argument. Try 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 was called with a real argument < -1 but will only return a complex result if called with a complex argument. Try 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)  # interval [1, 2) instead
(1.5, 2)

julia> frexp(0.0), frexp(NaN), frexp(-Inf)  # exponent would give an error
((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 обрабатывается как на 1 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

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

RoundToZero

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

RoundFromZero

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

Примеры

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

RoundUp

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

RoundDown

Применение 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)  # an example where 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])  # overflow at typemin(Int8)
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

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

Checked

Модуль 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 is below the branch cut
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 имеет нулевые измерения, возвращается массив с нулевыми измерениями (а не скаляр).

Примеры

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

Примеры

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

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

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

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 Fast-Math, и соответствует параметру -ffast-math в clang. Подробнее см. примечания по аннотациям производительности.

Примеры

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672