Математика

-(x)

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

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

Примеры

julia> -1
-1

julia> -(2)
-2

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

+(x, y...)

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

Примеры

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

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

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

-(x, y)

Оператор вычитания.

Примеры

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

*(x, y...)

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

Примеры

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

/(x, y)

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

Примеры

julia> 1/2
0.5

julia> 4/2
2.0

julia> 4.5/2
2.25

A / B

Правое деление матриц: A / B эквивалентно (B' \ A')', где \ — оператор левого деления. Для квадратных матриц результат X такой, что A == X*B.

См. также: rdiv!.

Примеры

julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

julia> X = A / B
2×3 Matrix{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

julia> isapprox(A, X*B)
true

julia> isapprox(X, A*pinv(B))
true

\(x, y)

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

Примеры

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

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

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

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

^(x, y)

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

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

Примеры

julia> 3^5
243

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

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

fma(x, y, z)

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

muladd(x, y, z)

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

Примеры

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

muladd(A, y, z)

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

Примеры

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

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

inv(x)

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

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

Примеры

julia> inv(2)
0.5

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

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

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

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

Целочисленное частное от деления. Обычно эквивалентно математической операции x/y без дробной части.

См. также: cld, fld, rem, divrem.

Примеры

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

julia> 5.0 ÷ 2
2.0

julia> div.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -1  -1  -1  0  0  0  0  0  1  1  1

fld(x, y)

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

См. также div, cld, fld1.

Примеры

julia> fld(7.3, 5.5)
1.0

julia> fld.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -2  -2  -1  -1  -1  0  0  0  1  1  1

Так как fld(x, y) реализует строго правильное округление вниз на основе истинного значения чисел с плавающей точкой, могут возникнуть неинтуитивные ситуации. Например:

julia> fld(6.0, 0.1)
59.0
julia> 6.0 / 0.1
60.0
julia> 6.0 / big(0.1)
59.99999999999999666933092612453056361837965690217069245739573412231113406246995

Здесь происходит то, что истинное значение числа с плавающей точкой, записанное как 0.1, немного больше числового значения 1/10, в то время как 6.0 точно представляет число 6. Поэтому истинное значение 6.0 / 0.1 немного меньше 60. При делении это округляется до точно 60.0, но fld(6.0, 0.1) всегда берёт целую часть от истинного значения, поэтому результат равен 59.0.

cld(x, y)

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

См. также div, fld.

Примеры

julia> cld(5.5, 2.2)
3.0

julia> cld.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -1  -1  -1  0  0  0  1  1  1  2  2

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

Находит y в диапазоне r, таком что $x ≡ y (mod n)$, где n = length(r), т.е. y = mod(x - first(r), n) + first(r).

См. также mod1.

Примеры

julia> mod(0, Base.OneTo(3))  # mod1(0, 3)
3

julia> mod(3, 0:2)  # mod(3, 3)
0

mod(x, y)
rem(x, y, RoundDown)

Уменьшение x по модулю y, или, эквивалентно, остаток от x после целочисленного деления на y, т.е. x - y*fld(x,y) , если вычисление производится без промежуточного округления.

Результат будет иметь тот же знак, что и y, и величину меньше, чем abs(y) (с некоторыми исключениями, см. примечание ниже).

См. также: rem, div, fld, mod1, invmod.

julia> mod(8, 3)
2

julia> mod(9, 3)
0

julia> mod(8.9, 3)
2.9000000000000004

julia> mod(eps(), 3)
2.220446049250313e-16

julia> mod(-eps(), 3)
3.0

julia> mod.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 1  2  0  1  2  0  1  2  0  1  2

rem(x::Integer, T::Type{<:Integer}) -> T
mod(x::Integer, T::Type{<:Integer}) -> T
%(x::Integer, T::Type{<:Integer}) -> T

Найти y::T такой, что x ≡ y (mod n), где n — количество целых чисел, представимых в T, и y — целое число в [typemin(T),typemax(T)]. Если T может представлять любое целое число (например, T == BigInt), то эта операция соответствует преобразованию в T.

Примеры

julia> x = 129 % Int8
-127

julia> typeof(x)
Int8

julia> x = 129 % BigInt
129

julia> typeof(x)
BigInt

rem(x, y)
%(x, y)

Остаток от евклидового деления, возвращающий значение со знаком, совпадающим со знаком x, и меньшим по абсолютной величине, чем y. Это значение всегда точно.

См. также: div, mod, mod1, divrem.

Примеры

julia> x = 15; y = 4;

julia> x % y
3

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

julia> rem.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -2  -1  0  -2  -1  0  1  2  0  1  2

rem2pi(x, r::RoundingMode)

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

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

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

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

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

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

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

Примеры

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

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

mod2pi(x)

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

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

Примеры

julia> mod2pi(9*pi/4)
0.7853981633974481

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

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

См. также: fldmod, cld.

Примеры

julia> divrem(3, 7)
(0, 3)

julia> divrem(7, 3)
(2, 1)

fldmod(x, y)

Целочисленная часть и остаток после деления. Удобная оболочка для divrem(x, y, RoundDown). Эквивалентно (fld(x, y), mod(x, y)).

См. также: fld, cld, fldmod1.

fld1(x, y)

Целочисленное деление, возвращающее значение, согласованное с mod1(x,y)

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

Примеры

julia> x = 15; y = 4;

julia> fld1(x, y)
4

julia> x == fld(x, y) * y + mod(x, y)
true

julia> x == (fld1(x, y) - 1) * y + mod1(x, y)
true

mod1(x, y)

Остаток после целочисленного деления, возвращающий значение r такое, что mod(r, y) == mod(x, y) в диапазоне $(0, y]$ для положительного y и в диапазоне $[y,0)$ для отрицательного y.

При целочисленных аргументах и положительном y, это равно mod(x, 1:y), и поэтому естественно для индексации с 1-го элемента. В сравнении, mod(x, y) == mod(x, 0:y-1) естественно для вычислений со смещениями или шагами.

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

Примеры

julia> mod1(4, 2)
2

julia> mod1.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 1  2  3  1  2  3  1  2  3  1  2

julia> mod1.([-0.1, 0, 0.1, 1, 2, 2.9, 3, 3.1]', 3)
1×8 Matrix{Float64}:
 2.9  3.0  0.1  1.0  2.0  2.9  3.0  0.1

fldmod1(x, y)

Возвращает (fld1(x,y), mod1(x,y)).

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

//(num, den)

Деление двух целых или рациональных чисел, дающее результат Rational.

Примеры

julia> 3 // 5
3//5

julia> (3 // 5) // (2 // 1)
3//10

rationalize([T<:Integer=Int,] x; tol::Real=eps(x))

Приблизить число с плавающей точкой x как рациональное число с компонентами заданного целого типа. Результат будет отличаться от x не более чем на tol.

Примеры

julia> rationalize(5.6)
28//5

julia> a = rationalize(BigInt, 10.3)
103//10

julia> typeof(numerator(a))
BigInt

numerator(x)

Числитель рационального представления x.

Примеры

julia> numerator(2//3)
2

julia> numerator(4)
4

denominator(x)

Знаменатель рационального представления x.

Примеры

julia> denominator(2//3)
3

julia> denominator(4)
1

<<(x, n)

Оператор сдвига влево, x << n. Для n >= 0, результат — x сдвинутый влево на n бит, заполненный 0. Это эквивалентно x * 2^n. Для n < 0, это эквивалентно x >> -n.

Примеры

julia> Int8(3) << 2
12

julia> bitstring(Int8(3))
"00000011"

julia> bitstring(Int8(12))
"00001100"

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

<<(B::BitVector, n) -> BitVector

Оператор сдвига влево, B << n. Для n >= 0, результат — B с элементами, сдвинутыми на n позиций назад, заполненными значениями false. Если n < 0, элементы сдвигаются вперёд. Эквивалентно B >> -n.

Примеры

julia> B = BitVector([true, false, true, false, false])
5-element BitVector:
 1
 0
 1
 0
 0

julia> B << 1
5-element BitVector:
 0
 1
 0
 0
 0

julia> B << -1
5-element BitVector:
 0
 1
 0
 1
 0

>>(x, n)

Оператор сдвига вправо, x >> n. Для n >= 0, результат — x сдвинутый вправо на n бит, заполненный 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 бит, заполненный 0. Для n < 0, это эквивалентно x << -n.

Для целочисленных типов Unsigned, это эквивалентно >>. Для целочисленных типов Signed, это эквивалентно signed(unsigned(x) >> n).

Примеры

julia> Int8(-14) >>> 2
60

julia> bitstring(Int8(-14))
"11110010"

julia> bitstring(Int8(60))
"00111100"

BigInt обрабатываются так, как будто имеют бесконечный размер, поэтому заполнение не требуется, и это эквивалентно >>.

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

>>>(B::BitVector, n) -> BitVector

Оператор беззнакового сдвига вправо, B >>> n. Эквивалентно B >> n. Подробнее и примеры см. в >>.

bitrotate(x::Base.BitInteger, k::Integer)

bitrotate(x, k) реализует циклический сдвиг бит. Возвращает значение x с его битами, циклически сдвинутыми влево на k раз. Отрицательное значение k будет вращать вправо.

См. также: <<, circshift, BitArray.

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

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

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

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

:expr

Процитировать выражение expr, вернув абстрактное синтаксическое дерево (AST) выражения expr. AST может быть типа Expr, Symbol, или литерального значения. Синтаксис :identifier оценивается как Symbol.

См. также: Expr, Symbol, Meta.parse

Примеры

julia> expr = :(a = b + 2*x)
:(a = b + 2x)

julia> sym = :some_identifier
:some_identifier

julia> value = :0xff
0xff

julia> typeof((expr, sym, value))
Tuple{Expr, Symbol, UInt8}

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

Построить специализированный массив с равномерно распределёнными элементами и оптимизированным хранением (a AbstractRange) из аргументов. Математически диапазон однозначно определяется любыми тремя из start, step, stop и length. Допустимые вызовы диапазона:

• Вызов range с любыми тремя из start, step, stop, length.
• Вызов range с двумя из start, stop, length. В этом случае step будет предполагаться равным единице. Если оба аргумента являются целыми числами, будет возвращён UnitRange.
• Вызов range с одним из stop или length. start и step будут предполагаться равными единице.

См. Дополнительную справку для получения дополнительной информации о возвращаемом типе.

Примеры

julia> range(1, length=100)
1:100

julia> range(1, stop=100)
1:100

julia> range(1, step=5, length=100)
1:5:496

julia> range(1, step=5, stop=100)
1:5:96

julia> range(1, 10, length=101)
1.0:0.09:10.0

julia> range(1, 100, step=5)
1:5:96

julia> range(stop=10, length=5)
6:10

julia> range(stop=10, step=1, length=5)
6:1:10

julia> range(start=1, step=1, stop=10)
1:1:10

julia> range(; length = 10)
Base.OneTo(10)

julia> range(; stop = 6)
Base.OneTo(6)

julia> range(; stop = 6.5)
1.0:1.0:6.0

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

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

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

Дополнительная справка

range будет возвращать Base.OneTo, когда аргументы являются целыми числами и

• Указан только length
• Указан только stop

range будет возвращать UnitRange, когда аргументы являются целыми числами и

• Указаны только start и stop
• Указаны только length и stop

Значение типа UnitRange не возвращается, если step указан, даже если он задан как таковой.

Base.OneTo(n)

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

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

Диапазон r, где r[i] производит значения типа T (в первом формате T выводится автоматически), параметризованный значением ссылки, шагом и длиной. По умолчанию ref — начальное значение r[1], но вы можете указать его как значение r[offset] для другого индекса 1 <= offset <= len. В сочетании с TwicePrecision это позволяет реализовать диапазоны без ошибок округления.

==(x, y)

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

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

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

Реализация

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

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

Если какой-либо тип определяет ==, isequal и isless, то он также должен реализовывать < для обеспечения согласованности сравнений.

!=(x, y)
≠(x,y)

Оператор сравнения неравенства. Всегда возвращает противоположный результат, чем ==.

Реализация

Новые типы, как правило, не должны реализовывать эту функцию и полагаться на определение по умолчанию !=(x,y) = !(x==y).

Примеры

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

!=(x)

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

!==(x, y)
≢(x,y)

Всегда возвращает противоположный результат, чем ===.

Примеры

julia> a = [1, 2]; b = [1, 2];

julia> a ≢ b
true

julia> a ≢ a
false

<(x, y)

Оператор сравнения меньше. Возвращает результат сравнения по isless. Из-за поведения значений NaN с плавающей точкой этот оператор реализует частичный порядок.

Реализация

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

Примеры

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

<(x)

Создать функцию, которая сравнивает свой аргумент с x используя <, то есть функцию, эквивалентную y -> y < x. Возвращаемая функция имеет тип Base.Fix2{typeof(<)}, который можно использовать для реализации специализированных методов.

<=(x, y)
≤(x,y)

Оператор сравнения меньше или равно. Возвращает результат сравнения по (x < y) | (x == y).

Примеры

julia> 'a' <= 'b'
true

julia> 7 ≤ 7 ≤ 9
true

julia> "abc" ≤ "abc"
true

julia> 5 <= 3
false

<=(x)

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

>(x, y)

Оператор сравнения больше. Возвращает результат сравнения по y < x.

Реализация

В целом, новые типы должны реализовывать < вместо этой функции и полагаться на определение по умолчанию >(x, y) = y < x.

Примеры

julia> 'a' > 'b'
false

julia> 7 > 3 > 1
true

julia> "abc" > "abd"
false

julia> 5 > 3
true

>(x)

Создать функцию, которая сравнивает свой аргумент с x используя >, то есть функцию, эквивалентную y -> y > x. Возвращаемая функция имеет тип Base.Fix2{typeof(>)}, который можно использовать для реализации специализированных методов.

>=(x, y)
≥(x,y)

Оператор сравнения больше или равно. Возвращает результат сравнения по y <= x.

Примеры

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

>=(x)

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

cmp(x,y)

Возвращает -1, 0 или 1 в зависимости от того, является ли x меньше, равно или больше y соответственно. Использует полный порядок, реализованный функцией isless.

Примеры

julia> cmp(1, 2)
-1

julia> cmp(2, 1)
1

julia> cmp(2+im, 3-im)
ERROR: MethodError: no method matching isless(::Complex{Int64}, ::Complex{Int64})
[...]

cmp(<, x, y)

Возвращает -1, 0 или 1 в зависимости от того, является ли x меньше, равно или больше y соответственно. Первый аргумент указывает функцию сравнения «меньше», которая должна быть использована.

cmp(a::AbstractString, b::AbstractString) -> Int

Сравнить две строки. Возвращает 0 если обе строки имеют одинаковую длину и символ в каждом индексе одинаков в обеих строках. Возвращает -1 если a является префиксом b, или если a предшествует b в алфавитном порядке. Возвращает 1 если b является префиксом a, или если b предшествует a в алфавитном порядке (технически, лексикографический порядок по кодам Юникода).

Примеры

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

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

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

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

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

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

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

~(x)

Битовое отрицание.

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

Примеры

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

x & y

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

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

Примеры

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

x | y

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

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

Примеры

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

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

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

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

Примеры

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

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

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

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

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

Примеры

julia> nand(true, false)
true

julia> nand(true, true)
false

julia> nand(true, missing)
missing

julia> false ⊼ false
true

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

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

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

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

Примеры

julia> nor(true, false)
false

julia> nor(true, true)
false

julia> nor(true, missing)
false

julia> false ⊽ false
true

julia> false ⊽ missing
missing

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

!(x)

Булево НЕ. Реализует трёхзначную логику, возвращая missing, если x равно missing.

См. также ~ для побитового НЕ.

Примеры

julia> !true
false

julia> !false
true

julia> !missing
missing

julia> .![true false true]
1×3 BitMatrix:
 0  1  0

!f::Function

Отрицание предикатной функции: если аргументом ! является функция, она возвращает составную функцию, которая вычисляет булево отрицание f.

См. также ∘.

Примеры

julia> str = "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
"∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"

julia> filter(isletter, str)
"εδxyδfxfyε"

julia> filter(!isletter, str)
"∀  > 0, ∃  > 0: |-| <  ⇒ |()-()| < "

x && y

Короткое булево И.

См. также &, тернарный оператор ? :, и раздел руководства по потоку управления.

Примеры

julia> x = 3;

julia> x > 1 && x < 10 && x isa Int
true

julia> x < 0 && error("expected positive x")
false

x || y

Короткое булево ИЛИ.

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

Примеры

julia> pi < 3 || ℯ < 3
true

julia> false || true || println("neither is true!")
true

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

Сравнение с точностью до приближения. Два числа считаются равными, если их относительное или абсолютное расстояние находится в пределах границ допуска: isapprox возвращает true если norm(x-y) <= max(atol, rtol*max(norm(x), norm(y))). По умолчанию atol равно нулю, а rtol зависит от типов x и y. Ключевой аргумент nans определяет, рассматриваются ли значения NaN как равные (по умолчанию — false).

Для вещественных или комплексных чисел с плавающей запятой, если atol > 0 не указан, rtol по умолчанию равен квадратному корню из eps типа x или y, в зависимости от того, какой из них больше (наименее точный). Это соответствует требованию равенства примерно половины значащих цифр. В противном случае, например, для целых аргументов или если указано atol > 0, rtol по умолчанию равно нулю.

Ключевое слово norm по умолчанию равно abs для числовых (x,y) и LinearAlgebra.norm для массивов (где иногда полезен альтернативный вариант norm). Когда x и y — массивы, если norm(x-y) не является конечным числом (то есть ±Inf или NaN ), сравнение сводится к проверке того, являются ли все элементы x и y примерно равными покомпонентно.

Бинарный оператор ≈ эквивалентен isapprox с аргументами по умолчанию, а x ≉ y эквивалентен !isapprox(x,y).

Обратите внимание, что x ≈ 0 (то есть сравнение с нулём с помощью пороговых значений по умолчанию) эквивалентно x == 0 , так как значение atol по умолчанию равно 0. В таких случаях вам следует либо указать соответствующее atol (или использовать norm(x) ≤ atol ), либо переписать свой код (например, использовать x ≈ y вместо x - y ≈ 0). Автоматически выбрать ненулевое значение atol невозможно, так как оно зависит от общего масштаба (единиц) вашей проблемы: например, в x - y ≈ 0, atol=1e-9 является абсурдно малым значением для допуска, если x — радиус Земли в метрах, но абсурдно большим для допуска, если x — радиус атома водорода в метрах.

Примеры

julia> isapprox(0.1, 0.15; atol=0.05)
true

julia> isapprox(0.1, 0.15; rtol=0.34)
true

julia> isapprox(0.1, 0.15; rtol=0.33)
false

julia> 0.1 + 1e-10 ≈ 0.1
true

julia> 1e-10 ≈ 0
false

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

julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0]) # using `norm`
true

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

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

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

sin(x)

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

См. также sind, sinpi, sincos, cis, asin.

Примеры

julia> round.(sin.(range(0, 2pi, length=9)'), digits=3)
1×9 Matrix{Float64}:
 0.0  0.707  1.0  0.707  0.0  -0.707  -1.0  -0.707  -0.0

julia> sind(45)
0.7071067811865476

julia> sinpi(1/4)
0.7071067811865476

julia> round.(sincos(pi/6), digits=3)
(0.5, 0.866)

julia> round(cis(pi/6), digits=3)
0.866 + 0.5im

julia> round(exp(im*pi/6), digits=3)
0.866 + 0.5im

cos(x)

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

См. также cosd, cospi, sincos, cis.

sincos(x)

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

См. также cis, sincospi, sincosd.

tan(x)

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

sind(x)

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

cosd(x)

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

tand(x)

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

sincosd(x)

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

sinpi(x)

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

См. также sind, cospi, sincospi.

cospi(x)

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

sincospi(x)

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

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

sinh(x)

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

cosh(x)

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

tanh(x)

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

См. также tan, atanh.

Примеры

julia> tanh.(-3:3f0)  # Here 3f0 isa Float32
7-element Vector{Float32}:
 -0.9950548
 -0.9640276
 -0.7615942
  0.0
  0.7615942
  0.9640276
  0.9950548

julia> tan.(im .* (1:3))
3-element Vector{ComplexF64}:
 0.0 + 0.7615941559557649im
 0.0 + 0.9640275800758169im
 0.0 + 0.9950547536867306im

asin(x)

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

См. также asind для результата в градусах.

Примеры

julia> asin.((0, 1/2, 1))
(0.0, 0.5235987755982989, 1.5707963267948966)

julia> asind.((0, 1/2, 1))
(0.0, 30.000000000000004, 90.0)

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.

См. также atand для градусов.

Примеры

julia> rad2deg(atan(-1/√3))
-30.000000000000004

julia> rad2deg(atan(-1, √3))
-30.000000000000004

julia> rad2deg(atan(1, -√3))
150.0

asind(x)

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

acosd(x)

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

atand(y)
atand(y,x)

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

sec(x)

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

csc(x)

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

cot(x)

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

secd(x)

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

cscd(x)

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

cotd(x)

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

asec(x)

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

acsc(x)

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

acot(x)

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

asecd(x)

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

acscd(x)

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

acotd(x)

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

sech(x)

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

csch(x)

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

coth(x)

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

asinh(x)

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

acosh(x)

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

atanh(x)

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

asech(x)

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

acsch(x)

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

acoth(x)

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

sinc(x)

Вычислите $\sin(\pi x) / (\pi x)$, если $x \neq 0$, и $1$, если $x = 0$.

См. также cosc, её производную.

cosc(x)

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

deg2rad(x)

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

См. также rad2deg, sind, pi.

Примеры

julia> deg2rad(90)
1.5707963267948966

rad2deg(x)

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

См. также deg2rad.

Примеры

julia> rad2deg(pi)
180.0

hypot(x, y)

Вычислить гипотенузу $\sqrt{|x|^2+|y|^2}$, избегая переполнения и подпотока.

Этот код является реализацией алгоритма, описанного в: Улучшенный алгоритм для hypot(a,b) Карлоса Ф. Боржеса Статья доступна онлайн на arXiv по ссылке https://arxiv.org/abs/1904.09481

hypot(x...)

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

См. также norm в LinearAlgebra стандартной библиотеке.

Примеры

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # a^2 overflows
ERROR: DomainError with -2.914184810805068e18:
sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
Stacktrace:
[...]

julia> hypot(3, 4im)
5.0

julia> hypot(-5.7)
5.7

julia> hypot(3, 4im, 12.0)
13.0

julia> using LinearAlgebra

julia> norm([a, a, a, a]) == hypot(a, a, a, a)
true

log(x)

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

См. также ℯ, log1p, log2, log10.

Примеры

julia> log(2)
0.6931471805599453

julia> log(-3)
ERROR: DomainError with -3.0:
log will only return a complex result if called with a complex argument. Try log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log.(exp.(-1:1))
3-element Vector{Float64}:
 -1.0
  0.0
  1.0

log(b,x)

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

Примеры

julia> log(4,8)
1.5

julia> log(4,2)
0.5

julia> log(-2, 3)
ERROR: DomainError with -2.0:
log will only return a complex result if called with a complex argument. Try log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(2, -3)
ERROR: DomainError with -3.0:
log will only return a complex result if called with a complex argument. Try log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0

log2(x)

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

См. также: exp2, ldexp, ispow2.

Примеры

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
ERROR: DomainError with -2.0:
log2 will only return a complex result if called with a complex argument. Try log2(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

julia> log2.(2.0 .^ (-1:1))
3-element Vector{Float64}:
 -1.0
  0.0
  1.0

log10(x)

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

Примеры

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

julia> log10(-2)
ERROR: DomainError with -2.0:
log10 will only return a complex result if called with a complex argument. Try log10(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

log1p(x)

Точное вычисление натурального логарифма 1+x. Бросает исключение DomainError для аргументов типа Real меньших чем -1.

Примеры

julia> log1p(-0.5)
-0.6931471805599453

julia> log1p(0)
0.0

julia> log1p(-2)
ERROR: DomainError with -2.0:
log1p will only return a complex result if called with a complex argument. Try log1p(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

frexp(val)

Возвращает (x,exp) такое, что x имеет величину в интервале $[1/2, 1)$ или 0, и val равно $x \times 2^{exp}$.

Примеры

julia> frexp(12.8)
(0.8, 4)

exp(x)

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

См. также exp2, exp10 и cis.

Примеры

julia> exp(1.0)
2.718281828459045

julia> exp(im * pi) ≈ cis(pi)
true

exp2(x)

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

См. также ldexp, <<.

Примеры

julia> exp2(5)
32.0

julia> 2^5
32

julia> exp2(63) > typemax(Int)
true

exp10(x)

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

Примеры

julia> exp10(2)
100.0

julia> 10^2
100

ldexp(x, n)

Вычислить $x \times 2^n$.

Примеры

julia> ldexp(5., 2)
20.0

modf(x)

Возвращает кортеж (fpart, ipart) дробной и целой частей числа. Обе части имеют тот же знак, что и аргумент.

Примеры

julia> modf(3.5)
(0.5, 3.0)

julia> modf(-3.5)
(-0.5, -3.0)

expm1(x)

Точно вычислить $e^x-1$. Это позволяет избежать потери точности, возникающей при непосредственном вычислении exp(x)-1 для малых значений x.

Примеры

julia> expm1(1e-16)
1.0e-16

julia> exp(1e-16) - 1
0.0

round([T,] x, [r::RoundingMode])
round(x, [r::RoundingMode]; digits::Integer=0, base = 10)
round(x, [r::RoundingMode]; sigdigits::Integer, base = 10)

Округляет число x.

Без ключевых аргументов, x округляется до целого значения, возвращая значение типа T, или того же типа, что и x если не указан T тип. Будет брошено исключение InexactError, если значение не может быть представлено в виде T, аналогично convert.

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

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

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

Примеры

julia> round(1.7)
2.0

julia> round(Int, 1.7)
2

julia> round(1.5)
2.0

julia> round(2.5)
2.0

julia> round(pi; digits=2)
3.14

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

julia> round(123.456; sigdigits=2)
120.0

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

julia> x = 1.15
1.15

julia> big(1.15)
1.149999999999999911182158029987476766109466552734375

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
• RoundUp
• RoundDown

RoundNearest

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

RoundNearestTiesAway

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

RoundNearestTiesUp

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

RoundToZero

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

RoundFromZero

Округляет от нуля.

Примеры

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

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

RoundingModeReal и RoundingModeImaginary по умолчанию равны RoundNearest, который округляет до ближайшего целого, причём в случае деления на 0,5 округляет до ближайшего чётного целого.

Пример

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

julia> round(3.14 + 4.5im, RoundUp, RoundNearestTiesUp)
4.0 + 5.0im

julia> round(3.14159 + 4.512im; digits = 1)
3.1 + 4.5im

julia> round(3.14159 + 4.512im; sigdigits = 3)
3.14 + 4.51im

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

Функция ceil(x) возвращает ближайшее целое значение того же типа, что и x, которое больше или равно 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.

Результат преобразуется в тип 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.

Результат преобразуется в тип T, при этом будет брошено исключение InexactError если значение не может быть представлено.

Ключевые слова digits, sigdigits и base работают так же, как и для round.

См. также: %, floor, unsigned, unsafe_trunc.

Примеры

julia> trunc(2.22)
2.0

julia> trunc(-2.22, digits=1)
-2.2

julia> trunc(Int, -2.22)
-2

unsafe_trunc(T, x)

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

Примеры

julia> unsafe_trunc(Int, -2.2)
-2

julia> unsafe_trunc(Int, NaN)
-9223372036854775808

min(x, y, ...)

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

Примеры

julia> min(2, 5, 1)
1

max(x, y, ...)

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

Примеры

julia> max(2, 5, 1)
5

minmax(x, y)

Возвращает (min(x,y), max(x,y)).

См. также extrema, которая возвращает (minimum(x), maximum(x)).

Примеры

julia> minmax('c','b')
('b', 'c')

clamp(x, lo, hi)

Возвращает x если lo <= x <= hi. Если x > hi, возвращает hi. Если x < lo, возвращает lo. Аргументы приводятся к общему типу.

См. также clamp!, min, max.

Примеры

julia> clamp.([pi, 1.0, big(10)], 2.0, 9.0)
3-element Vector{BigFloat}:
 3.141592653589793238462643383279502884197169399375105820974944592307816406286198
 2.0
 9.0

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

clamp(x, T)::T

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

См. также trunc.

Примеры

julia> clamp(200, Int8)
127

julia> clamp(-200, Int8)
-128

julia> trunc(Int, 4pi^2)
39

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

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

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

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

Примеры

julia> row = collect(-4:4)';

julia> clamp!(row, 0, Inf)
1×9 adjoint(::Vector{Int64}) with eltype Int64:
 0  0  0  0  0  1  2  3  4

julia> clamp.((-4:4)', 0, Inf)
1×9 Matrix{Float64}:
 0.0  0.0  0.0  0.0  0.0  1.0  2.0  3.0  4.0

abs(x)

Модуль x.

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

См. также: abs2, unsigned, sign.

Примеры

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs.(Int8[-128 -127 -126 0 126 127])  # overflow at typemin(Int8)
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

julia> maximum(abs, [1, -2, 3, -4])
4

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.

Это может быть быстрее, чем abs(x)^2, особенно для комплексных чисел, где abs(x) требует вычисления квадратного корня через hypot.

См. также abs, conj, real.

Примеры

julia> abs2(-3)
9

julia> abs2(3.0 + 4.0im)
25.0

julia> sum(abs2, [1+2im, 3+4im])  # LinearAlgebra.norm(x)^2
30

copysign(x, y) -> z

Возвращает z, имеющее модуль x и тот же знак, что и y.

Примеры

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

sign(x)

Возвращает ноль, если x==0, и $x/|x|$ в противном случае (т. е., ±1 для вещественных x).

См. также signbit, zero, copysign, flipsign.

Примеры

julia> sign(-4.0)
-1.0

julia> sign(99)
1

julia> sign(-0.0)
-0.0

julia> sign(0 + im)
0.0 + 1.0im

signbit(x)

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

См. также sign и copysign.

Примеры

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true

flipsign(x, y)

Возвращает x со сменой знака, если y отрицательно. Например, abs(x) = flipsign(x,x).

Примеры

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5

sqrt(x)

Возвращает $\sqrt{x}$. Бросает DomainError для отрицательных Real аргументов. Используйте комплексные отрицательные аргументы вместо этого. Префиксный оператор √ эквивалентен sqrt.

См. также: hypot.

Примеры

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError with -81.0:
NaN result for non-NaN input.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

julia> sqrt(big(complex(-81)))
0.0 + 9.0im

julia> .√(1:4)
4-element Vector{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772
 2.0

isqrt(n::Integer)

Целочисленное квадратный корень: наибольшее целое m такое, что m*m <= n.

julia> isqrt(5)
2

cbrt(x::Real)

Возвращает кубический корень из x, т. е. $x^{1/3}$. Отрицательные значения принимаются (возвращая отрицательный действительный корень, когда $x < 0$).

Префиксный оператор ∛ эквивалентен cbrt.

Примеры

julia> cbrt(big(27))
3.0

julia> cbrt(big(-27))
-3.0

real(z)

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

См. также: imag, reim, complex, isreal, Real.

Примеры

julia> real(1 + 3im)
1

real(T::Type)

Возвращает тип, представляющий вещественную часть значения типа T. Например, для T == Complex{R}, возвращает R. Эквивалентно typeof(real(zero(T))).

Примеры

julia> real(Complex{Int})
Int64

julia> real(Float64)
Float64

real(A::AbstractArray)

Возвращает массив, содержащий вещественную часть каждого элемента в массиве A.

Эквивалентно real.(A), за исключением того, что когда eltype(A) <: Real A возвращается без копирования, и что когда A имеет нулевые размеры, возвращается массив нулевых размеров (а не скаляр).

Примеры

julia> real([1, 2im, 3 + 4im])
3-element Vector{Int64}:
 1
 0
 3

julia> real(fill(2 - im))
0-dimensional Array{Int64, 0}:
2

imag(z)

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

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

Примеры

julia> imag(1 + 3im)
3

imag(A::AbstractArray)

Возвращает массив, содержащий мнимую часть каждого элемента в массиве A.

Эквивалентно imag.(A), за исключением того, что когда A имеет нулевые размеры, возвращается массив нулевых размеров (а не скаляр).

Примеры

julia> imag([1, 2im, 3 + 4im])
3-element Vector{Int64}:
 0
 2
 4

julia> imag(fill(2 - im))
0-dimensional Array{Int64, 0}:
-1

reim(z)

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

Примеры

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

reim(A::AbstractArray)

Возвращает кортеж из двух массивов, содержащих соответственно действительную и мнимую часть каждого элемента в A.

Эквивалентно (real.(A), imag.(A)), за исключением того, что когда eltype(A) <: Real A возвращается без копирования, чтобы представить действительную часть, и что когда A имеет нулевые размеры, возвращается массив нулевых размеров (а не скаляр).

Примеры

julia> reim([1, 2im, 3 + 4im])
([1, 0, 3], [0, 2, 4])

julia> reim(fill(2 - im))
(fill(2), fill(-1))

conj(z)

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

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

Примеры

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

conj(A::AbstractArray)

Возвращает массив, содержащий комплексно-сопряжённое значение каждого элемента в массиве A.

Эквивалентно conj.(A), за исключением того, что когда eltype(A) <: Real A возвращается без копирования, и что когда A имеет нулевые размеры, возвращается массив нулевых размеров (а не скаляр).

Примеры

julia> conj([1, 2im, 3 + 4im])
3-element Vector{Complex{Int64}}:
 1 + 0im
 0 - 2im
 3 - 4im

julia> conj(fill(2 - im))
0-dimensional Array{Complex{Int64}, 0}:
2 + 1im

angle(z)

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

См. также: atan, cis.

Примеры

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

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

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

cis(x)

Более эффективный метод для exp(im*x) с использованием формулы Эйлера: $cos(x) + i sin(x) = \exp(i x)$.

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

Примеры

julia> cis(π) ≈ -1
true

cispi(x)

Более точный метод для cis(pi*x) (особенно для больших x).

См. также cis, sincospi, exp, angle.

Примеры

julia> cispi(10000)
1.0 + 0.0im

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

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

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

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

\[\binom{n}{k} = \frac{n!}{k! (n-k)!}\]

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

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

\[\binom{n}{k} = (-1)^k \binom{k-n-1}{k}\]

См. также factorial.

Примеры

julia> binomial(5, 3)
10

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

julia> binomial(-5, 3)
-35

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

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

factorial(n::Integer)

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

См. также binomial.

Примеры

julia> factorial(6)
720

julia> factorial(21)
ERROR: OverflowError: 21 is too large to look up in the table; consider using `factorial(big(21))` instead
Stacktrace:
[...]

julia> factorial(big(21))
51090942171709440000

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

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

gcd(x, y...)

Наибольший общий (положительный) делитель (или ноль, если все аргументы равны нулю). Аргументы могут быть целыми и рациональными числами.

Примеры

julia> gcd(6, 9)
3

julia> gcd(6, -9)
3

julia> gcd(6, 0)
6

julia> gcd(0, 0)
0

julia> gcd(1//3, 2//3)
1//3

julia> gcd(1//3, -2//3)
1//3

julia> gcd(1//3, 2)
1//3

julia> gcd(0, 0, 10, 15)
5

lcm(x, y...)

Наименьшее общее (положительное) кратное (или ноль, если какой-либо аргумент равен нулю). Аргументы могут быть целыми и рациональными числами.

Примеры

julia> lcm(2, 3)
6

julia> lcm(-2, 3)
6

julia> lcm(0, 3)
0

julia> lcm(0, 0)
0

julia> lcm(1//3, 2//3)
2//3

julia> lcm(1//3, -2//3)
2//3

julia> lcm(1//3, 2)
2//1

julia> lcm(1, 3, 5, 7)
105

gcdx(a, b)

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

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

Примеры

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

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

ispow2(n::Number) -> Bool

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

См. также count_ones, prevpow, nextpow.

Примеры

julia> ispow2(4)
true

julia> ispow2(5)
false

julia> ispow2(4.5)
false

julia> ispow2(0.25)
true

julia> ispow2(1//8)
true

nextpow(a, x)

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

См. также prevpow.

Примеры

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16

prevpow(a, x)

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

См. также nextpow, isqrt.

Примеры

julia> prevpow(2, 7)
4

julia> prevpow(2, 9)
8

julia> prevpow(5, 20)
5

julia> prevpow(4, 16)
16

nextprod(factors::Union{Tuple,AbstractVector}, n)

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

Примеры

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

julia> 2^2 * 3^3
108

invmod(n, m)

Найти обратный элемент n по модулю m: y такой, что $n y = 1 \pmod m$, и $div(y,m) = 0$. Возбудит ошибку, если $m = 0$, или если $gcd(n,m) \neq 1$.

Примеры

julia> invmod(2, 5)
3

julia> invmod(2, 3)
2

julia> invmod(5, 6)
5

powermod(x::Integer, p::Integer, m)

Вычислить $x^p \pmod m$.

Примеры

julia> powermod(2, 6, 5)
4

julia> mod(2^6, 5)
4

julia> powermod(5, 2, 20)
5

julia> powermod(5, 2, 19)
6

julia> powermod(5, 3, 19)
11

ndigits(n::Integer; base::Integer=10, pad::Integer=1)

Вычислить количество цифр в целом n, записанном в системе счисления base (base не должно быть в [-1, 0, 1]), необязательно дополненных нулями до заданного размера (результат никогда не будет меньше pad).

См. также digits, count_ones.

Примеры

julia> ndigits(0)
1

julia> ndigits(12345)
5

julia> ndigits(1022, base=16)
3

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

julia> ndigits(123, pad=5)
5

julia> ndigits(-123)
3

Base.add_sum(x, y)

Оператор сокращения, используемый в sum. Основное отличие от + заключается в том, что небольшие целые числа повышаются до Int/UInt.

widemul(x, y)

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

См. также promote, Base.add_sum.

Примеры

julia> widemul(Float32(3.0), 4.0) isa BigFloat
true

julia> typemax(Int8) * typemax(Int8)
1

julia> widemul(typemax(Int8), typemax(Int8))  # == 127^2
16129

evalpoly(x, p)

Вычислить многочлен $\sum_k x^{k-1} p[k]$ для коэффициентов p[1], p[2], ...; то есть коэффициенты заданы в порядке возрастания степени x. Циклы развернуты во время компиляции, если количество коэффициентов известно статически, т.е. когда p является Tuple.

Эта функция генерирует эффективный код, используя метод Хорнера, если x является вещественным, или алгоритм, похожий на алгоритм Гоертцеля ^[DK62], если x является комплексным.

Пример

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

@evalpoly(z, c...)

Вычислить многочлен $\sum_k z^{k-1} c[k]$ для коэффициентов c[1], c[2], ...; то есть коэффициенты заданы в порядке возрастания степени z. Этот макрос расширяется до эффективного встроенного кода, который использует либо метод Хорнера, либо, для комплексного z, более эффективный алгоритм, похожий на алгоритм Гоертцеля.

См. также evalpoly.

Примеры

julia> @evalpoly(3, 1, 0, 1)
10

julia> @evalpoly(2, 1, 0, 1)
5

julia> @evalpoly(2, 1, 1, 1)
7

@fastmath expr

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

Это устанавливает флаги LLVM Fast-Math и соответствует опции -ffast-math в clang. См. примечания по аннотациям производительности для получения дополнительных сведений.

Примеры

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672