-(x)

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

Примеры

julia> -1
-1

julia> -(2)
-2

julia> -[1 2; 3 4]
2×2 Array{Int64,2}:
 -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 Array{Float64,1}:
  6.5
 -7.0

julia> inv(A) * x
2-element Array{Float64,1}:
  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.^, если ^ не определено в вызываемом пространстве имён.)

julia> 3^5
243

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

julia> A^3
2×2 Array{Int64,2}:
 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

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 как рационального числа 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"

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

<<(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 BitArray{1}:
 1
 0
 1
 0
 0

julia> B << 1
5-element BitArray{1}:
 0
 1
 0
 0
 0

julia> B << -1
5-element BitArray{1}:
 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 BitArray{1}:
 1
 0
 1
 0
 0

julia> B >> 1
5-element BitArray{1}:
 0
 1
 0
 1
 0

julia> B >> -1
5-element BitArray{1}:
 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 приведет к циклическому сдвигу вправо.

julia> bitrotate(UInt8(114), 2)
0xc9

julia> bitstring(bitrotate(0b01110010, 2))
"11001001"

julia> bitstring(bitrotate(0b01110010, -2))
"10011100"

julia> bitstring(bitrotate(0b01110010, 8))
"01110010"

(:)(I::CartesianIndex, J::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)

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

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

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

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

Исходя из начального значения, создаёт диапазон по длине или от start до stop, необязательно с заданным шагом (по умолчанию 1, a 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)

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

Возвращаемая функция имеет тип Base.Fix2{typeof(==)}, который может использоваться для реализации специализированных методов.

==(a::AbstractString, b::AbstractString) -> Bool

Проверяет, равны ли две строки посимвольно (технически, по коду Юникода).

Примеры

julia> "abc" == "abc"
true

julia> "abc" == "αβγ"
false

!=(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 в 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 BitArray{1}:
 0
 1
 0

!(x)

Булево отрицание. Реализует логику с тремя значениями, возвращая missing, если x является missing.

Примеры

julia> !true
false

julia> !false
true

julia> !missing
missing

julia> .![true false true]
1×3 BitArray{2}:
 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; rtol::Real=atol>0 ? 0 : √eps, atol::Real=0, 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 по умолчанию равно нулю.

x и y также могут быть массивами чисел, в этом случае norm по умолчанию соответствует обычной функции norm из LinearAlgebra, но может быть изменено передачей ключевого аргумента norm::Function. (Для чисел norm эквивалентно abs.) Когда 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 в радианах.

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.

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.

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) by Carlos F. Borges Статья доступна онлайн в ArXiv по ссылке https://arxiv.org/abs/1904.09481

Примеры

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

hypot(x...)

Вычислите гипотенузу $\sqrt{\sum |x_i|^2}$, избегая переполнения и потери точности.

Примеры

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

exp10(x)

Вычислите $10^x$.

Примеры

julia> exp10(2)
100.0

julia> exp10(0.2)
1.5848931924611136

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 Array{BigFloat,1}:
 3.141592653589793238462643383279502884197169399375105820974944592307816406286198
 2.0
 9.0

julia> clamp.([11,8,5],10,6) # an example where lo > hi
3-element Array{Int64,1}:
  6
  6
 10

clamp(x, T)::T

Ограничивает x между typemin(T) и typemax(T) и преобразует результат к типу T.

Примеры

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

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

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

binomial(n::Integer, k::Integer)

Биномиальный коэффициент $\binom{n}{k}$, являющийся коэффициентом $k$-го члена в многочленном разложении $(1+x)^n$.

Если $n$ неотрицательно, то это количество способов выбрать k из n элементов:

где $n!$ — функция factorial.

Если $n$ отрицательно, то он определяется по тождеству

Примеры

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)

Наибольший общий (положительный) делитель (или ноль, если 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

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

gcdx(x,y)

Вычисляет наибольший общий (положительный) делитель x и y и их коэффициенты Безу, то есть целые коэффициенты u и v, удовлетворяющие $ux+vy = d = gcd(x,y)$. $gcdx(x,y)$ возвращает $(d,u,v)$.

Аргументы могут быть целыми и рациональными числами.

Примеры

julia> gcdx(12, 42)
(6, -3, 1)

julia> gcdx(240, 46)
(2, -9, 47)

ispow2(n::Integer) -> Bool

Проверить, является ли n степенью двойки.

Примеры

julia> ispow2(4)
true

julia> ispow2(5)
false

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([k_1, k_2,...], n)

Следующее целое число, большее или равное n, которое можно записать как $\prod k_i^{p_i}$ для целых чисел $p_1$, $p_2$ и т. д.

Примеры

julia> nextprod([2, 3], 105)
108

julia> 2^2 * 3^3
108

invmod(x,m)

Найти обратное значение x по модулю m: y такое, что $x y = 1 \pmod m$, при $div(x,y) = 0$. Это не определено для $m = 0$ или если $gcd(x,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