Математика

-(x)

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

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

Примеры

julia> -1
-1

julia> -(2)
-2

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

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

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

+(x, y...)

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

Примеры

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

-(x, y)

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

Примеры

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

*(x, y...)

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

Примеры

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

/(x, y)

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

Примеры

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 — целочисленный литерал (например, 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 положительно.

Примеры

julia> 3^5
243

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

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

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

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

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.

Примеры

julia> 3 // 5
3//5

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

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

Приблизить число с плавающей точкой x как рациональное число с компонентами указанного целочисленного типа. Результат будет отличаться от 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 будут предполагаться равными единице.

См. Дополнительную справку для получения дополнительных сведений о возвращаемом типе.

Примеры

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], но альтернативно вы можете предоставить его как значение r[offset] для некоторого другого индекса 1 <= offset <= len. Синтаксис a:b или a:b:c, где любое из a, b, или c - числа с плавающей точкой, создает StepRangeLen.

==(x, y)

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

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

Результат имеет тип Bool, за исключением случаев, когда один из операндов равен missing, в этом случае возвращается missing (логика с тремя значениями). Для коллекций, 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 в Julia REPL после ввода \xor или \veebar.

Примеры

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 в Julia REPL после ввода \nand или \barwedge.

Примеры

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 в Julia REPL после ввода \nor или \barvee.

Примеры

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 равными (по умолчанию 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]) # 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)

Вычислите $\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).

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 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. Используйте комплексные отрицательные аргументы для получения комплексных результатов.

См. также ℯ, 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.(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}$.

Примеры

julia> frexp(12.8)
(0.8, 4)

exp(x)

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

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

Примеры

julia> exp(1.0)
2.718281828459045

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

exp2(x)

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

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

Примеры

julia> exp2(5)
32.0

julia> 2^5
32

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

exp10(x)

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

Примеры

julia> exp10(2)
100.0

julia> 10^2
100

ldexp(x, n)

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

Примеры

julia> ldexp(5., 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).

Примеры

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> 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

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

RoundFromZero

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

Примеры

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

RoundUp

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

RoundDown

Округление с использованием этого режима является алиасом для 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, если значение не может быть представлено.

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

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

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

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

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

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

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

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

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

См. также: %, 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). См. также функцию minimum для получения минимального элемента из коллекции.

Примеры

julia> min(2, 5, 1)
1

max(x, y, ...)

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

Примеры

julia> max(2, 5, 1)
5

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.

При применении к знаковым целым числам может произойти переполнение, что приведёт к возвращению отрицательного значения. Это переполнение происходит только при применении к минимально представимому значению знакового целого числа. То есть, когда 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

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.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.

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

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

Примеры

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

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

julia> rad2deg(angle(-1 - im))
-135.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, m)

Найдите обратное значение 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

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