-(x)

Оператор унарного минуса.

Примеры

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

\(x, y)

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

Примеры

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

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

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

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

^(x, y)

Оператор возведения в степень. Если x является матрицей, вычисляет возведение матрицы в степень.

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

julia> 3^5
243

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

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

fma(x, y, z)

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

muladd(x, y, z)

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

Примеры

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

muladd(A, y, z)

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

Примеры

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

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

inv(x)

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

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

Примеры

julia> inv(2)
0.5

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

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

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

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

Результат целочисленного деления. Вычисляет x/y, усечённое до целого числа.

Примеры

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

julia> 5.0 ÷ 2
2.0

fld(x, y)

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

См. также: div

Примеры

julia> fld(7.3,5.5)
1.0

cld(x, y)

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

См. также: div

Примеры

julia> cld(5.5,2.2)
3.0

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) (с некоторыми исключениями, см. примечание ниже).

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

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. Это значение всегда точное.

Примеры

julia> x = 15; y = 4;

julia> x % y
3

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

rem2pi(x, r::RoundingMode)

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

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

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

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

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

• если r == RoundDown, то результат находится в интервале $[0, 2π]$. См. также RoundDown.

• если r == RoundUp, то результат находится в интервале $[-2π, 0]$. См. также RoundUp.

Примеры

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

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

mod2pi(x)

Остаток после деления на 2π, возвращаемый в диапазоне $[0,2π)$.

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

Примеры

julia> mod2pi(9*pi/4)
0.7853981633974481

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

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

Примеры

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

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 как рационального числа с компонентами указанного целого типа. Результат будет отличаться от 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"

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

<<(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, заполняя нулями. Для 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 приведет к сдвигу вправо.

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, [step], stop)

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

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

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

range(start[, stop]; length, stop, step=1)

На основе начального значения создать диапазон по длине или от start до stop, необязательно с заданным шагом (по умолчанию 1, UnitRange). Требуется одно из length или stop . Если length, stop, и step заданы, они должны совпадать.

Если length и stop заданы, а step нет, размер шага будет вычислен автоматически так, чтобы в диапазоне было length линейно расположенных элементов.

Если step и stop заданы, а length нет, общая длина диапазона будет вычислена автоматически, чтобы элементы были step расположены.

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

stop может быть указан как позиционным, так и именованным аргументом.

Примеры

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

Base.OneTo(n)

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

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

Диапазон r, где r[i] производит значения типа T (во втором варианте, T выводится автоматически), параметризованный ссылкой на значение, шагом и длиной. По умолчанию 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.

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

Примеры

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

Примеры

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

x | y

Битовое ИЛИ. Реализует трёхзначную логику, возвращая missing, если один из операндов missing а другой false.

Примеры

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

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

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

x || y

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

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

Сравнение на приблизительное равенство: 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> 0.1 ≈ (0.1 - 1e-10)
true

julia> isapprox(10, 11; atol = 2)
true

julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0])
true

julia> 1e-10 ≈ 0
false

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

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

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

Поддерживаемые ключевые аргументы здесь такие же, как и в двухаргументной функции isapprox.

sin(x)

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

cos(x)

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

sincos(x)

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

tan(x)

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

sind(x)

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

cosd(x)

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

tand(x)

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

sinpi(x)

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

cospi(x)

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

sincospi(x)

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

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, где результат в градусах.

acosd(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, где результат в градусах.

acscd(x)

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

acotd(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(x)

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

deg2rad(x)

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

Примеры

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

Примеры

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.

Примеры

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
ERROR: DomainError with -2.0:
NaN result for non-NaN input.
Stacktrace:
 [1] nan_dom_err at ./math.jl:325 [inlined]
[...]

log10(x)

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

Примеры

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

julia> log10(-2)
ERROR: DomainError with -2.0:
NaN result for non-NaN input.
Stacktrace:
 [1] nan_dom_err at ./math.jl:325 [inlined]
[...]

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

exp(x)

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

Примеры

julia> exp(1.0)
2.718281828459045

exp2(x)

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

Примеры

julia> exp2(5)
32.0

exp10(x)

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

Примеры

julia> exp10(2)
100.0

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

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, если тип не указан. Ошибка 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.

unsafe_trunc(T, x)

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

min(x, y, ...)

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

Примеры

julia> min(2, 5, 1)
1

max(x, y, ...)

Возвращает максимальное из аргументов. См. также функцию 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. Аргументы приводятся к общему типу.

Примеры

julia> clamp.([pi, 1.0, big(10.)], 2., 9.)
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.

Примеры

julia> clamp(200, Int8)
127
julia> clamp(-200, Int8)
-128

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

Ограничивает x в пределах диапазона r.

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

Ограничивает значения в array в указанном диапазоне, в режиме in-place. См. также clamp.

abs(x)

Модуль x.

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

Примеры

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

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

Примеры

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.

Примеры

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

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.

Примеры

julia> real(1 + 3im)
1

imag(z)

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

Примеры

julia> imag(1 + 3im)
3

reim(z)

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

Примеры

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

conj(z)

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

Примеры

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

angle(z)

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

Примеры

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

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

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

cis(z)

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

Примеры

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}\]

Примеры

julia> binomial(5, 3)
10

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

julia> binomial(-5, 3)
-35

См. также

• factorial

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

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

factorial(n::Integer)

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

Примеры

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

См. также

• binomial

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

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

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 целой степенью двойки.

Примеры

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.

Примеры

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16

См. также prevpow.

prevpow(a, x)

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

Примеры

julia> prevpow(2, 7)
4

julia> prevpow(2, 9)
8

julia> prevpow(5, 20)
5

julia> prevpow(4, 16)
16

См. также nextpow.

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

Примеры

julia> ndigits(12345)
5

julia> ndigits(1022, base=16)
3

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

julia> ndigits(123, pad=5)
5

widemul(x, y)

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

Примеры

julia> widemul(Float32(3.), 4.)
12.0

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, более эффективный алгоритм типа Гоертцеля.

Примеры

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