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

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

muladd(x, y, z)

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

Примеры

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

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

julia> mod(3, 0:2)
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.

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

Примеры

julia> mod1(4, 2)
2

julia> mod1(4, 3)
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
2×3 CartesianIndices{2, Tuple{UnitRange{Int64}, UnitRange{Int64}}}:
 CartesianIndex(2, 1)  CartesianIndex(2, 2)  CartesianIndex(2, 3)
 CartesianIndex(3, 1)  CartesianIndex(3, 2)  CartesianIndex(3, 3)

julia> I:CartesianIndex(1, 2):J
2×2 CartesianIndices{2, Tuple{StepRange{Int64, Int64}, StepRange{Int64, Int64}}}:
 CartesianIndex(2, 1)  CartesianIndex(2, 3)
 CartesianIndex(3, 1)  CartesianIndex(3, 3)

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

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

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

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.

Примеры

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

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

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

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

Base.OneTo(n)

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

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

Диапазон r, где r[i] производит значения типа T (в первой форме T выводится автоматически), параметризованный значением ссылки, шагом и длиной. По умолчанию ref — начальное значение step, но вы также можете указать его как значение 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), и ⊻ можно ввести, нажав Tab после ввода \xor или \veebar в REPL Julia.

Примеры

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), и ⊼ можно ввести, нажав Tab после ввода \nand или \barwedge в REPL Julia.

Примеры

julia> nand(true, false)
true

julia> nand(true, true)
false

julia> nand(true, missing)
missing

julia> false ⊼ false
true

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

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

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

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

Примеры

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 невозможно, потому что он зависит от общего масштаба (единиц) вашей задачи.

Примеры

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}$, избегая переполнения и подпотолка.

Примеры

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

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)

Вычислить экспоненту от 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> @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

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

RoundNearestTiesUp

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

imag(z)

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

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

Примеры

julia> imag(1 + 3im)
3

reim(z)

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

Примеры

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

conj(z)

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

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

Примеры

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

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(A::AbstractMatrix)

Вычисляет $\exp(i A)$ для квадратной матрицы $A$.

Примеры

julia> cis([π 0; 0 π]) ≈ -I
true

cis(z)

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

См. также cispi, angle.

Примеры

julia> cis(π) ≈ -1
true

cispi(z)

Вычисляет $\exp(i\pi x)$ более точно, чем cis(pi*x), особенно для больших значений x.

Примеры

julia> cispi(1)
-1.0 + 0.0im

julia> cispi(0.25 + 1im)
0.030556854645952924 + 0.030556854645952924im

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