Математика

-(x)

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

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

Примеры

julia> -1
-1

julia> -(2)
-2

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

+(x, y...)

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

Примеры

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

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

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

-(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 - 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 положительно.

Примеры

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

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 как числа 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 бит, где n >= 0, заполняя пробелы 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 бит, где n >= 0, заполняя пробелы 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"

(:)(start::CartesianIndex, [step::CartesianIndex], stop::CartesianIndex)

Создаёт CartesianIndices из двух CartesianIndex и необязательного шага.

Примеры

julia> I = CartesianIndex(2,1);

julia> J = CartesianIndex(3,3);

julia> I:J
CartesianIndices((2:3, 1:3))

julia> I:CartesianIndex(1, 2):J
CartesianIndices((2:1:3, 1:2:3))

(:)(start, [step], stop)

Оператор диапазона. a:b строит диапазон от a до b с шагом 1 (a UnitRange) , и a:s:b аналогично, но использует шаг s (a StepRange).

: также используется в индексации для выбора целых измерений и для Symbol литералов, как в :hello.

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

Создаёт специализированный массив с равномерно распределёнными элементами и оптимизированным хранением (an 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 вычисляется автоматически), параметризованный значением ссылки, step, и длиной. По умолчанию ref — это начальное значение r[1], но его можно также указать как значение r[offset] для другого индекса 1 <= offset <= len. В сочетании с TwicePrecision это можно использовать для реализации диапазонов, свободных от ошибок округления.

==(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 вместо этого.

Примеры

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 в алфавитном порядке (технически, лексикографическом порядке по кодам Юникода).

Примеры

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

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

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

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

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

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

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

~(x)

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

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

Примеры

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

x & y

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

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

Примеры

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

x | y

Побитовое ИЛИ. Реализует логику с тремя значениями, возвращая missing, если один операнд missing, а другой false.

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

Примеры

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

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

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

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

Примеры

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

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

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

Побитовое НЕНЕ (НЕ И) x и y Реализует логику с тремя значениями, возвращая missing, если один из аргументов missing.

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

Примеры

julia> nand(true, false)
true

julia> nand(true, true)
false

julia> nand(true, missing)
missing

julia> false ⊼ false
true

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

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

Побитовое НОР (НЕ ИЛИ) x и y Реализует логику с тремя значениями, возвращая missing, если один из аргументов missing.

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

Примеры

julia> nor(true, false)
false

julia> nor(true, true)
false

julia> nor(true, missing)
false

julia> false ⊽ false
true

julia> [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].

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.

sincospi(x)

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

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

sinh(x)

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

cosh(x)

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

tanh(x)

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

asin(x)

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

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.

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.

Примеры

julia> deg2rad(90)
1.5707963267948966

rad2deg(x)

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

Примеры

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

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

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

Вычислить экспоненту по основанию 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$.

Примеры

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> @sprintf "%.20f" x
"1.14999999999999991118"

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 (BigFloat только)
• RoundUp
• RoundDown

RoundNearest

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

RoundNearestTiesAway

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

RoundNearestTiesUp

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

RoundToZero

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

RoundFromZero

Округляет от нуля. Этот режим округления может использоваться только с T == BigFloat входными данными для round.

Примеры

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=, base=10)
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; sigdigits=, base=10)

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

Пример

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

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.

Когда 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(typemin(Int64))
-9223372036854775808

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.

Примеры

julia> abs2(-3)
9

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.

Примеры

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

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

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

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