-(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 — целочисленная константа (например, 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. Подробнее и примеры см. в >>.

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

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

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

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

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

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

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

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

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)

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

==(x, y)

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

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

Результат имеет тип Bool, за исключением случаев, когда один из операндов — missing, в этом случае возвращается missing (логика с тремя значениями). Для коллекций missing возвращается, если хотя бы один из операндов содержит значение missing и все значения, отличные от пропущенных, равны. Используйте isequal или ===, чтобы всегда получить результат Bool.

Реализация

Новые числовые типы должны реализовывать эту функцию для двух аргументов нового типа и обрабатывать сравнение с другими типами с помощью правил повышения, где это возможно.

isequal возвращается к ==, поэтому новые методы == будут использоваться типом Dict для сравнения ключей. Если ваш тип будет использоваться в качестве ключа словаря, он также должен реализовывать hash.

==(x)

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

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

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

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

Примеры

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.

Примеры

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), а ⊻ можно набрать, нажав Tab в Julia REPL после \xor или \veebar.

Примеры

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

julia> [true; true; false] .⊻ [true; false; false]
3-element 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

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) Карлоса Ф. Боржеса. Статья доступна онлайн в 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 если не указан T. Будет выброшено исключение InexactError, если значение не может быть представлено T, аналогично convert.

Если указан ключевой аргумент digits, выполняется округление до указанного числа цифр после десятичной точки (или перед ней, если значение отрицательно), в системе счисления base.

Если указан ключевой аргумент sigdigits, выполняется округление до указанного числа значащих цифр, в системе счисления base.

Аргумент RoundingMode r управляет направлением округления; по умолчанию используется RoundNearest, которое округляет до ближайшего целого числа, а при равенстве (дробные значения 0,5) округляется до ближайшего чётного целого. Обратите внимание, что round может давать неверные результаты, если глобальный режим округления изменён (см. rounding).

Примеры

julia> round(1.7)
2.0

julia> round(Int, 1.7)
2

julia> round(1.5)
2.0

julia> round(2.5)
2.0

julia> round(pi; digits=2)
3.14

julia> round(pi; digits=3, base=2)
3.125

julia> round(123.456; sigdigits=2)
120.0

julia> round(357.913; sigdigits=4, base=2)
352.0

julia> x = 1.15
1.15

julia> @sprintf "%.20f" x
"1.14999999999999991118"

julia> x < 115//100
true

julia> round(x, digits=1)
1.2

Расширения

Для расширения round на новые числовые типы, обычно достаточно определить Base.round(x::NewType, r::RoundingMode).

RoundingMode

Тип, используемый для управления режимом округления операций с плавающей точкой (через функции rounding/setrounding), или как необязательные аргументы для округления до ближайшего целого (через функцию round).

В настоящее время поддерживаются следующие режимы округления:

• RoundNearest (по умолчанию)
• RoundNearestTiesAway
• RoundNearestTiesUp
• RoundToZero
• RoundFromZero (BigFloat только)
• RoundUp
• RoundDown

RoundNearest

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

RoundNearestTiesAway

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

RoundNearestTiesUp

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

RoundToZero

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

RoundFromZero

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

Примеры

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

RoundUp

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

RoundDown

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

round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]])
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; digits=, base=10)
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; sigdigits=, base=10)

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

Пример

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

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

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

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

digits, sigdigits и base работают так же, как для round.

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

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

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

digits, sigdigits и base работают так же, как для round.

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

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

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

digits, sigdigits и base работают так же, как и для round.

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

lcm(x,y)

Наименьшее общее (неотрицательное) кратное. Аргументы могут быть целыми и рациональными числами.

Примеры

julia> lcm(2,3)
6

julia> lcm(-2,3)
6

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 p[k] x^{k-1}$ для коэффициентов p[1], p[2], ...; то есть коэффициенты заданы в порядке возрастания степени x. Циклы раскручиваются на этапе компиляции, если число коэффициентов известно статически, то есть, когда p является Tuple . Эта функция генерирует эффективный код, используя метод Хорнера, если x вещественное, или алгоритм, подобный алгоритму Гоертцеля ^[DK62], если x комплексное.

Пример

julia> evalpoly(2, (1, 2, 3))
17

@evalpoly(z, c...)

Вычисляет значение многочлена $\sum_k c[k] z^{k-1}$ для коэффициентов 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