Математические объекты

Математические операторы

# Base.:- — Method

-(x)

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

См. также описание abs, flipsign.

Примеры

julia> -1
-1

julia> -(2)
-2

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

julia> -(true)  # продвигается до Int
-1

julia> -(0x003)
0xfffd

# Base.:+ — Function

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

При сложении даты (Date) и времени (Time) получается общее значение даты и времени (DateTime). Компоненты часов, минут, секунд и миллисекунд из значения Time объединяются с годом, месяцем и днем из Date, образуя новое значение DateTime. Если тип Time содержит ненулевые значения микро- или наносекунд, выдается ошибка InexactError.

+(x, y...)

Оператор сложения.

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

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

Примеры

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

julia> [1,2] + [3,4]
2-element Vector{Int64}:
 4
 6

julia> typemax(Int) + 1 < 0
true

# Base.:- — Method

-(x, y)

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

Примеры

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

# Base.:* — Method

*(x, y...)

Оператор умножения.

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

При записи без знака умножения, например 2pi, также вызывается *(2, pi). Обратите внимание, что эта операция имеет более высокий приоритет, чем литерал *. Также обратите внимание, что запись без знака вида «0x…» (целое число ноль, умноженное на переменную, имя которой начинается с x) запрещена, так как конфликтует с литералами целых чисел без знака: 0x01 isa UInt8.

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

Примеры

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

julia> [2 0; 0 3] * [1, 10]  # матрица * вектор
2-element Vector{Int64}:
  2
 30

julia> 1/2pi, 1/2*pi  # умножение без знака имеет более высокий приоритет
(0.15915494309189535, 1.5707963267948966)

julia> x = [1, 2]; x'x  # сопряженный вектор * вектор
5

# Base.:/ — Function

/(x, y)

Оператор правого деления: умножает x на величину, обратную y в правой части.

Выдает результат с плавающей запятой для целочисленных аргументов. См. описание ÷ для целочисленного деления или // для результатов типа Rational.

Примеры

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

# Base.:\ — Method

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

# Base.:^ — Method

^(x, y)

Оператор возведения в степень.

Если x и y — целые числа, возможно переполнение результата. Для ввода чисел в экспоненциальном представлении используйте литералы Float64, например 1.2e3, а не 1.2 * 10^3.

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

См. также описание exp2 и <<.

Примеры

julia> 3^5
243

julia> 3^-1  # использует Base.literal_pow
0.3333333333333333

julia> p = -1;

julia> 3^p
ERROR: DomainError with -1:
Cannot raise an integer x to a negative power -1.
[...]

julia> 3.0^p
0.3333333333333333

julia> 10^19 > 0  # целочисленное переполнение
false

julia> big(10)^19 == 1e19
true

# Base.fma — Function

fma(x, y, z)

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

# Base.muladd — Function

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 1.6

Для этих методов требуется версия Julia не ниже 1.6.

Примеры

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

# Base.inv — Method

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

Совместимость: Julia 1.2

Для inv(::Missing) требуется версия Julia не ниже 1.2.

# Base.div — Function

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

# Base.div — Method

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

Результат евклидова (целочисленного) деления. Вычисляет x / y с округлением до целого числа в соответствии с режимом округления r. Иными словами, величину

round(x / y, r)

безо всякого промежуточного округления.

Совместимость: Julia 1.4

Для метода с тремя аргументами, принимающего RoundingMode, требуется версия Julia не ниже 1.4.

См. также описание fld и cld, частных случаев этой функции.

Совместимость: Julia 1.9

Для RoundFromZero требуется версия Julia не ниже 1.9.

Примеры:

julia> div(4, 3, RoundToZero) # Совпадает с div(4, 3)
1
julia> div(4, 3, RoundDown) # Совпадает с fld(4, 3)
1
julia> div(4, 3, RoundUp) # Совпадает с cld(4, 3)
2
julia> div(5, 2, RoundNearest)
2
julia> div(5, 2, RoundNearestTiesAway)
3
julia> div(-5, 2, RoundNearest)
-2
julia> div(-5, 2, RoundNearestTiesAway)
-3
julia> div(-5, 2, RoundNearestTiesUp)
-2
julia> div(4, 3, RoundFromZero)
2
julia> div(-4, 3, RoundFromZero)
-2

# Base.fld — Function

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.

# Base.cld — Function

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

# Base.mod — Function

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

Находит y в диапазоне r, так что , где 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

Совместимость: Julia 1.3

Для этого метода требуется версия Julia не ниже 1.3.

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

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

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

При использовании значений с плавающей запятой может быть невозможно использовать данный тип для представления точного результата, поэтому могут возникать ошибки округления. В частности, если точный результат очень близок к y, он может быть округлен до 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

# Base.rem — Function

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

# Base.rem — Method

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

Вычисляет остаток целочисленного деления x на y с округлением результата деления в режиме r. Иными словами, величину

x - y * round(x / y, r)

безо всякого промежуточного округления.

При r == RoundNearest результат будет точным и находиться в интервале $[-

y

/ 2,

y

/ 2]$. См. также описание RoundNearest.

При r == RoundToZero (по умолчанию) результат будет точным и находиться в интервале $[0,

)$ при положительном x или $(-

, 0]$ в противном случае. См. также описание RoundToZero.

При r == RoundDown результат будет находиться в интервале при положительном y или ] в противном случае. Результат может быть неточным, если x и y имеют разные знаки, а abs(x) < abs(y). См. также описание RoundDown.
При r == RoundUp результат будет находиться в интервале ] при положительном y или в противном случае. Результат может быть неточным, если x и y имеют одинаковый знак, а abs(x) < abs(y). См. также описание RoundUp.
При r == RoundFromZero результат будет находиться в интервале ] при положительном y или в противном случае. Результат может быть неточным, если x и y имеют одинаковый знак, а abs(x) < abs(y). См. также описание RoundFromZero.

Совместимость: Julia 1.9

Для RoundFromZero требуется версия Julia не ниже 1.9.

Примеры:

julia> x = 9; y = 4;

julia> x % y  # то же, что и rem(x, y)
1

julia> x ÷ y  # то же, что и div(x, y)
2

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

# Base.Math.rem2pi — Function

rem2pi(x, r::RoundingMode)

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

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

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

При r == RoundNearest результат будет в интервале ]. Как правило, это будет самый точный результат. См. также описание RoundNearest.
При r == RoundToZero результат будет находиться в интервале ] при положительном x или ] в противном случае. См. также описание RoundToZero.
При r == RoundDown результат будет в интервале ]. См. также описание RoundDown.
При r == RoundUp результат будет в интервале ]. См. также описание RoundUp.

Примеры

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

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

# Base.Math.mod2pi — Function

mod2pi(x)

Остаток от целочисленного деления на 2π, возвращаемый в диапазоне .

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

В зависимости от формата входного значения ближайшее представимое значение для 2π может быть меньше 2π. Например, выражение mod2pi(2π) не возвратит 0, так как промежуточное значение 2*π имеет тип Float64, а 2*Float64(π) < 2*big(π). См. описание функции rem2pi, которая позволяет точнее контролировать данное поведение.

Примеры

julia> mod2pi(9*pi/4)
0.7853981633974481

# Base.divrem — Function

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)

# Base.fldmod — Function

fldmod(x, y)

Результат и остаток от целочисленного деления с округлением в меньшую сторону. Представляет собой оболочку для удобства для divrem(x, y, RoundDown). Эквивалентно (fld(x, y), mod(x, y)).

См. также описание fld, cld, fldmod1.

# Base.fld1 — Function

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

# Base.mod1 — Function

mod1(x, y)

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

При целочисленных аргументах и положительном значении y это равно mod(x, 1:y), что естественным образом подходит для индексов, начинающихся с единицы. С другой стороны, 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

# Base.fldmod1 — Function

fldmod1(x, y)

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

См. также описание fld1 и mod1.

# Base.:// — Function

//(num, den)

Деление двух целых или рациональных чисел, дающее результат типа Rational. В более общем случае // можно использовать для точного рационального деления других числовых типов с целочисленными или рациональными компонентами, например комплексных чисел с целочисленными компонентами.

Обратите внимание, что аргументы с плавающей запятой (AbstractFloat) не допускаются оператором // (даже если значения рациональные). Типы аргументов должны быть подтипами Integer, Rational или составными типами на их основе.

Примеры

julia> 3 // 5
3//5

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

julia> (1+2im) // (3+4im)
11//25 + 2//25*im

julia> 1.0 // 2
ERROR: MethodError: no method matching //(::Float64, ::Int64)
[...]

# Base.rationalize — Function

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

# Base.numerator — Function

numerator(x)

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

Примеры

julia> numerator(2//3)
2

julia> numerator(4)
4

# Base.denominator — Function

denominator(x)

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

Примеры

julia> denominator(2//3)
3

julia> denominator(4)
1

# Base.:<< — Function

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

# Base.:>> — Function

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

# Base.:>>> — Function

>>>(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. Подробные сведения и примеры см. в описании >>.

# Base.bitrotate — Function

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

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

Совместимость: Julia 1.5

Для этой функции требуется версия Julia не ниже 1.5.

См. также описание <<, 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"

# Base.:: — Function

: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}

# Base.range — Function

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

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

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

Дополнительные сведения о возвращаемом типе см. в расширенной справке. Кроме того, см. описание функции logrange для точек с логарифмическими интервалами.

Примеры

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.

Совместимость: Julia 1.1

Для использования stop в качестве позиционного аргумента требуется версия Julia не ниже 1.1.

Совместимость: Julia 1.7

Версии без именованных аргументов и с именованным аргументом start требуют версии Julia не ниже 1.7.

Совместимость: Julia 1.8

Для версий с единственным именованным аргументом stop или length требуется версия Julia не ниже 1.8.

Расширенная справка

Функция range выдает Base.OneTo, когда аргументы целочисленные и:

указан только аргумент length;
указан только аргумент stop.

Функция range выдает UnitRange, когда аргументы целочисленные и:

указаны только start и stop;
указаны только length и stop.

В случае указания step, даже со значением в единицу, UnitRange не выдается.

# Base.OneTo — Type

Base.OneTo(n)

Определяет диапазон AbstractUnitRange, действующий как 1:n, для которого системой типов гарантируется нижняя граница, равная единице.

# Base.StepRangeLen — Type

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

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

Совместимость: Julia 1.7

Для параметра 4-го типа L требуется версия Julia не ниже 1.7.

# Base.logrange — Function

logrange(start, stop, length)
logrange(start, stop; length)

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

Аналогично geomspace в Python. В отличие от PowerRange в Mathematica, вы указываете количество элементов, а не отношение. В отличие от logspace в Python и Matlab, аргументы start и stop всегда являются первым и последним элементами результата, а не степенями, примененными к некоторому основанию.

Примеры

julia> logrange(10, 4000, length=3)
3-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 10.0, 200.0, 4000.0

julia> ans[2] ≈ sqrt(10 * 4000)  # средний элемент — это геометрическое среднее
true

julia> range(10, 40, length=3)[2] ≈ (10 + 40)/2  # арифметическое среднее
true

julia> logrange(1f0, 32f0, 11)
11-element Base.LogRange{Float32, Float64}:
 1.0, 1.41421, 2.0, 2.82843, 4.0, 5.65685, 8.0, 11.3137, 16.0, 22.6274, 32.0

julia> logrange(1, 1000, length=4) ≈ 10 .^ (0:3)
true

Дополнительные сведения см. в описании типа LogRange.

Кроме того, см. описание функции range для точек с линейными интервалами.

Совместимость: Julia 1.11

Для этой функции требуется версия Julia не ниже 1.11.

# Base.LogRange — Type

LogRange{T}(start, stop, len) <: AbstractVector{T}

Диапазон, элементы которого расположены с логарифмическими интервалами между start и stop, причем интервал определяется аргументом len. Возвращается функцией logrange.

Как и в случае с LinRange, первый и последний элементы будут в точности совпадать с заданными, но промежуточные значения могут иметь небольшие ошибки с плавающей запятой. Они рассчитываются с использованием логарифмов конечных точек, которые сохраняются при создании объекта, причем часто с более высокой точностью, чем T.

Примеры

julia> logrange(1, 4, length=5)
5-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 1.0, 1.41421, 2.0, 2.82843, 4.0

julia> Base.LogRange{Float16}(1, 4, 5)
5-element Base.LogRange{Float16, Float64}:
 1.0, 1.414, 2.0, 2.828, 4.0

julia> logrange(1e-310, 1e-300, 11)[1:2:end]
6-element Vector{Float64}:
 1.0e-310
 9.999999999999974e-309
 9.999999999999981e-307
 9.999999999999988e-305
 9.999999999999994e-303
 1.0e-300

julia> prevfloat(1e-308, 5) == ans[2]
true

Обратите внимание, что целочисленный тип элементов T не допускается. Используйте, например, round.(Int, xs) или явные степени некоторого целочисленного основания:

julia> xs = logrange(1, 512, 4)
4-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 1.0, 8.0, 64.0, 512.0

julia> 2 .^ (0:3:9) |> println
[1, 8, 64, 512]

Совместимость: Julia 1.11

Для этого типа требуется версия Julia не ниже 1.11.

# Base.:== — Function

==(x, y)

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

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

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

Реализация

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

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

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

# Base.:!= — Function

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

Оператор сравнения «не равно». Всегда дает ответ, обратный ==.

Реализация

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

Примеры

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

!=(x)

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

Совместимость: Julia 1.2

Для этой функции требуется версия Julia не ниже 1.2.

# Base.:!== — Function

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

Всегда дает ответ, обратный ===.

Примеры

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

julia> a ≢ b
true

julia> a ≢ a
false

# Base.:< — Function

<(x, y)

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

Реализация

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

См. также описание isunordered.

Примеры

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

<(x)

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

Совместимость: Julia 1.2

Для этой функции требуется версия Julia не ниже 1.2.

# Base.:<= — Function

<=(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(<=)} и может использоваться для реализации специализированных методов.

Совместимость: Julia 1.2

Для этой функции требуется версия Julia не ниже 1.2.

# Base.:> — Function

>(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(>)} и может использоваться для реализации специализированных методов.

Совместимость: Julia 1.2

Для этой функции требуется версия Julia не ниже 1.2.

# Base.:>= — Function

>=(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(>=)} и может использоваться для реализации специализированных методов.

Совместимость: Julia 1.2

Для этой функции требуется версия Julia не ниже 1.2.

# Base.cmp — Function

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

# Base.:~ — Function

~(x)

Битовое «не».

См. также описание !, &, |.

Примеры

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

# Base.:& — Function

x & y

Битовое «и». Реализует троичную логику, возвращая missing, если один из операндов отсутствующий (missing), а другой является истинным (true). Используйте скобки для применения в форме функции: (&)(x, y).

См. также описание |, xor, &&.

Примеры

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

# Base.:| — Function

x | y

Битовое «или». Реализует троичную логику, возвращая missing, если один из операндов отсутствующий (missing), а другой является истинным (false).

См. также описание &, xor, ||.

Примеры

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

# Base.xor — Function

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

Битовое «исключающее или» для x и y. Реализует троичную логику, возвращая missing, если один из аргументов отсутствующий (missing).

Инфиксная операция a ⊻ b является синонимом xor(a,b), и вы можете вводить ⊻, используя автозавершение по клавише TAB для \xor или \veebar в REPL Julia.

Примеры

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

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

# Base.nand — Function

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

Битовое «и не» (nand) для x и y. Реализует троичную логику, возвращая missing, если один из аргументов отсутствующий (missing).

Инфиксная операция a ⊼ b является синонимом nand(a,b), и вы можете вводить ⊼, используя автозавершение по клавише TAB для \nand или \barwedge в REPL Julia.

Примеры

julia> nand(true, false)
true

julia> nand(true, true)
false

julia> nand(true, missing)
missing

julia> false ⊼ false
true

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

# Base.nor — Function

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

Битовое «или не» (nor) для x и y. Реализует троичную логику, возвращая missing, если один из аргументов отсутствующий (missing), а другой — нет (true).

Инфиксная операция a ⊽ b является синонимом nor(a,b), и вы можете вводить ⊽, используя автозавершение по клавише TAB для \nor или \barvee в REPL 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

# Base.:! — Function

!(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: |-| <  ⇒ |()-()| < "

Совместимость: Julia 1.9

Начиная с Julia 1.9 !f возвращает ComposedFunction вместо анонимной функции.

# && — Keyword

x && y

Вычисляемое по сокращенной схеме логическое «и».

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

Примеры

julia> x = 3;

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

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

# || — Keyword

x || y

Вычисляемое по сокращенной схеме логическое «или».

См. также описание |, xor, &&.

Примеры

julia> pi < 3 || ℯ < 3
true

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

Математические функции

# Base.isapprox — Function

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 ≈ 0 использовать x ≈ y). Ненулевое значение atol не может быть выбрано автоматически, так как это значение зависит от общего масштаба («единиц измерения») проблемы: например, в выражении x - y ≈ 0 погрешность atol=1e-9 будет до абсурда малой, если x представляет радиус Земли в метрах, или до абсурда большой, если x — это радиус атома водорода в метрах.

Совместимость: Julia 1.6

Для передачи именованного аргумента norm при сравнении числовых аргументов (не массивов) требуется версия Julia не ниже 1.6.

Примеры

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]) # использование `norm`
true

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

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

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

Совместимость: Julia 1.5

Для этого метода требуется версия Julia не ниже 1.5.

# Base.sin — Method

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

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

# Base.cos — Method

cos(x)

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

См. также описание cosd, cospi, sincos и cis.

# Base.Math.sincos — Method

sincos(x)

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

См. также описание cis, sincospi и sincosd.

# Base.tan — Method

tan(x)

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

# Base.Math.sind — Function

sind(x)

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

Совместимость: Julia 1.7

Для матричных аргументов требуется версия Julia не ниже 1.7.

# Base.Math.cosd — Function

cosd(x)

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

Совместимость: Julia 1.7

Для матричных аргументов требуется версия Julia не ниже 1.7.

# Base.Math.tand — Function

tand(x)

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

Совместимость: Julia 1.7

Для матричных аргументов требуется версия Julia не ниже 1.7.

# Base.Math.sincosd — Function

sincosd(x)

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

Совместимость: Julia 1.3

Для этой функции требуется версия Julia не ниже 1.3.

# Base.Math.sinpi — Function

sinpi(x)

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

См. также описание sind, cospi и sincospi.

# Base.Math.cospi — Function

cospi(x)

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

# Base.Math.tanpi — Function

tanpi(x)

Вычисляет с большей точностью, чем tan(pi*x), особенно для больших значений x.

Совместимость: Julia 1.10

Для этой функции требуется версия Julia не ниже 1.10.

См. также описание tand, sinpi, cospi и sincospi.

# Base.Math.sincospi — Function

sincospi(x)

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

Совместимость: Julia 1.6

Для этой функции требуется версия Julia не ниже 1.6.

См. также описание cispi, sincosd, sinpi.

# Base.sinh — Method

sinh(x)

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

# Base.cosh — Method

cosh(x)

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

# Base.tanh — Method

tanh(x)

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

См. также описание tan и atanh.

Примеры

julia> tanh.(-3:3f0)  # Здесь 3f0 является 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

# Base.asin — Method

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)

# Base.acos — Method

acos(x)

Вычисляет арккосинус x с выходным значением в радианах.

# Base.atan — Method

atan(y)
atan(y, x)

Вычисляет соответственно арктангенс y или y/x.

При наличии одного вещественного аргумента это будет угол в радианах между положительным направлением оси x и точкой (1, y). Возвращаемое значение будет лежать в интервале ].

При наличии двух аргументов это будет угол в радианах между положительным направлением оси x и точкой (x, y). Возвращаемое значение будет лежать в интервале ]. Это соответствует стандартной функции atan2. Обратите внимание, что согласно стандарту atan(0.0,x) определяется как , а atan(-0.0,x) — как при x < 0.

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

Примеры

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

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

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

# Base.Math.asind — Function

asind(x)

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

Совместимость: Julia 1.7

Для матричных аргументов требуется версия Julia не ниже 1.7.

# Base.Math.acosd — Function

acosd(x)

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

Совместимость: Julia 1.7

Для матричных аргументов требуется версия Julia не ниже 1.7.

# Base.Math.atand — Function

atand(y)
atand(y,x)

Вычисляет арктангенс соответственно y или y/x с выходным значением в градусах.

Совместимость: Julia 1.7

Метод с одним аргументом поддерживает в качестве аргумента квадратную матрицу начиная с версии Julia 1.7.

# Base.Math.sec — Method

sec(x)

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

# Base.Math.csc — Method

csc(x)

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

# Base.Math.cot — Method

cot(x)

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

# Base.Math.secd — Function

secd(x)

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

# Base.Math.cscd — Function

cscd(x)

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

# Base.Math.cotd — Function

cotd(x)

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

# Base.Math.asec — Method

asec(x)

Вычисляет арксеканс x с выходным значением в радианах.

# Base.Math.acsc — Method

acsc(x)

Вычисляет арккосеканс x с выходным значением в радианах.

# Base.Math.acot — Method

acot(x)

Вычисляет арккотангенс x с выходным значением в радианах.

# Base.Math.asecd — Function

asecd(x)

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

Совместимость: Julia 1.7

Для матричных аргументов требуется версия Julia не ниже 1.7.

# Base.Math.acscd — Function

acscd(x)

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

Совместимость: Julia 1.7

Для матричных аргументов требуется версия Julia не ниже 1.7.

# Base.Math.acotd — Function

acotd(x)

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

Совместимость: Julia 1.7

Для матричных аргументов требуется версия Julia не ниже 1.7.

# Base.Math.sech — Method

sech(x)

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

# Base.Math.csch — Method

csch(x)

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

# Base.Math.coth — Method

coth(x)

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

# Base.asinh — Method

asinh(x)

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

# Base.acosh — Method

acosh(x)

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

# Base.atanh — Method

atanh(x)

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

# Base.Math.asech — Method

asech(x)

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

# Base.Math.acsch — Method

acsch(x)

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

# Base.Math.acoth — Method

acoth(x)

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

# Base.Math.sinc — Function

sinc(x)

Вычисляет нормированную функцию sinc при и при .

См. также производную этой функции cosc.

# Base.Math.cosc — Function

cosc(x)

Вычисляет при и при . Это производная функции sinc(x).

См. также описание sinc.

# Base.Math.deg2rad — Function

deg2rad(x)

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

См. также описание rad2deg, sind и pi.

Примеры

julia> deg2rad(90)
1.5707963267948966

# Base.Math.rad2deg — Function

rad2deg(x)

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

См. также описание deg2rad.

Примеры

julia> rad2deg(pi)
180.0

# Base.Math.hypot — Function

hypot(x, y)

Вычисляет гипотенузу , избегая переполнения и выхода за нижнюю границу.

Данный код реализует алгоритм из статьи An Improved Algorithm for hypot(a,b) (Усовершенствованный алгоритм для hypot(a,b)) Карлоса Борхеса (Carlos F. Borges). Эта статья доступна на портале ArXiv по ссылке https://arxiv.org/abs/1904.09481.

hypot(x...)

Вычисляет гипотенузу , избегая переполнения и выхода за нижнюю границу.

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

Примеры

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # Возникает переполнение a^2
ERROR: DomainError with -2.914184810805068e18:
sqrt was called with a negative real argument but 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

# Base.log — Method

log(x)

Вычисляет натуральный логарифм x.

Выдает ошибку DomainError при отрицательных аргументах типа Real. Используйте комплексные аргументы для получения комплексных результатов. Имеет точку ветвления на отрицательной вещественной оси, поэтому -0.0im принимается как находящееся ниже оси.

См. также описание ℯ, log1p, log2 и log10.

Примеры

julia> log(2)
0.6931471805599453

julia> log(-3)
ERROR: DomainError with -3.0:
log was called with a negative real argument but 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(-3 + 0im)
1.0986122886681098 + 3.141592653589793im

julia> log(-3 - 0.0im)
1.0986122886681098 - 3.141592653589793im

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

# Base.log — Method

log(b,x)

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

Примеры

julia> log(4,8)
1.5

julia> log(4,2)
0.5

julia> log(-2, 3)
ERROR: DomainError with -2.0:
log was called with a negative real argument but 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 was called with a negative real argument but 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
[...]

Если b является степенью 2 или 10, следует использовать log2 или log10, так как эти функции, как правило, будут более быстрыми и точными. Пример:

julia> log(100,1000000)
2.9999999999999996
julia> log10(1000000)/2 3.0

# Base.log2 — Function

log2(x)

Compute the logarithm of x to base 2. Throws DomainError for negative Real arguments.

See also: exp2, ldexp, ispow2.

Примеры

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
ERROR: DomainError with -2.0:
log2 was called with a negative real argument but 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

# Base.log10 — Function

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 was called with a negative real argument but 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
[...]

# Base.log1p — Function

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 was called with a real argument < -1 but 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
[...]

# Base.Math.frexp — Function

frexp(val)

Возвращает (x,exp) такое, что абсолютная величина x лежит в интервале или равна нулю, а val равно .

См. также описание significand, exponent и ldexp.

Примеры

julia> frexp(6.0)
(0.75, 3)

julia> significand(6.0), exponent(6.0)  # вместо этого интервал [1, 2)
(1.5, 2)

julia> frexp(0.0), frexp(NaN), frexp(-Inf)  # экспонента даст ошибку
((0.0, 0), (NaN, 0), (-Inf, 0))

# Base.exp — Method

exp(x)

Вычисляет экспоненту x, т. е. .

См. также описание exp2, exp10 и cis.

Примеры

julia> exp(1.0)
2.718281828459045

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

# Base.exp2 — Function

exp2(x)

Вычисляет возведение 2 в степень x, т. е. .

См. также описание ldexp и <<.

Примеры

julia> exp2(5)
32.0

julia> 2^5
32

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

# Base.exp10 — Function

exp10(x)

Вычисляет возведение 10 в степень x, т. е. .

Примеры

julia> exp10(2)
100.0

julia> 10^2
100

# Base.Math.ldexp — Function

ldexp(x, n)

Вычисляет .

См. также описание frexp и exponent.

Примеры

julia> ldexp(5.0, 2)
20.0

# Base.Math.modf — Function

modf(x)

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

Примеры

julia> modf(3.5)
(0.5, 3.0)

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

# Base.expm1 — Function

expm1(x)

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

Примеры

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

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

# Base.round — Function

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

Округление до типа с плавающей запятой производится до целых чисел, представляемых этим типом (и Inf), а не до истинных целых чисел. При определении ближайшего значения Inf рассматривается как значение на одну единицу наименьшей точности (ulp) больше, чем floatmax(T), аналогично convert.

Примеры

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> round(Float16, typemax(UInt128))
Inf16

julia> floor(Float16, typemax(UInt128))
Float16(6.55e4)

При работе с двоичными числами с плавающей запятой округление до заданного числа знаков по основанию, отличному от 2, может быть неточным. Например, значение типа Float64, представленное числом 1.15, в действительности меньше 1,15, однако оно будет округлено до 1,2. Например:

julia> x = 1.15
1.15
julia> big(1.15) 1.149999999999999911182158029987476766109466552734375

julia> x < 115//100 true

julia> round(x, digits=1) 1.2

Расширения

To extend round to new numeric types, it is typically sufficient to define Base.round(x::NewType, r::RoundingMode).

# Base.Rounding.RoundingMode — Type

RoundingMode

A type used for controlling the rounding mode of floating point operations (via rounding/setrounding functions), or as optional arguments for rounding to the nearest integer (via the round function).

Currently supported rounding modes are:

RoundNearest (default)
RoundNearestTiesAway
RoundNearestTiesUp
RoundToZero
RoundFromZero
RoundUp
RoundDown

Совместимость: Julia 1.9

RoundFromZero requires at least Julia 1.9. Prior versions support RoundFromZero for BigFloats only.

# Base.Rounding.RoundNearest — Constant

RoundNearest

The default rounding mode. Rounds to the nearest integer, with ties (fractional values of 0.5) being rounded to the nearest even integer.

# Base.Rounding.RoundNearestTiesAway — Constant

RoundNearestTiesAway

Rounds to nearest integer, with ties rounded away from zero (C/C++ round behaviour).

# Base.Rounding.RoundNearestTiesUp — Constant

RoundNearestTiesUp

Rounds to nearest integer, with ties rounded toward positive infinity (Java/JavaScript round behaviour).

# Base.Rounding.RoundToZero — Constant

RoundToZero

round using this rounding mode is an alias for trunc.

# Base.Rounding.RoundFromZero — Constant

RoundFromZero

Rounds away from zero.

Совместимость: Julia 1.9

RoundFromZero requires at least Julia 1.9. Prior versions support RoundFromZero for BigFloats only.

Примеры

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

# Base.Rounding.RoundUp — Constant

RoundUp

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

# Base.Rounding.RoundDown — Constant

RoundDown

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

# Base.round — Method

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 для дробных значений 0,5. Первый 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

# Base.ceil — Function

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

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

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

Именованные аргументы digits, sigdigits и base действуют так же, как для round.

Чтобы новый тип поддерживал ceil, определите Base.round(x::NewType, ::RoundingMode{:Up}).

# Base.floor — Function

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

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

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

Именованные аргументы digits, sigdigits и base действуют так же, как для round.

Чтобы новый тип поддерживал floor, определите Base.round(x::NewType, ::RoundingMode{:Down}).

# Base.trunc — Function

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

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

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

Именованные аргументы digits, sigdigits и base действуют так же, как для round.

Чтобы новый тип поддерживал trunc, определите Base.round(x::NewType, ::RoundingMode{:ToZero}).

См. также описание %, floor, unsigned, unsafe_trunc.

Примеры

julia> trunc(2.22)
2.0

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

julia> trunc(Int, -2.22)
-2

# Base.unsafe_trunc — Function

unsafe_trunc(T, x)

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

Примеры

julia> unsafe_trunc(Int, -2.2)
-2

julia> unsafe_trunc(Int, NaN)
-9223372036854775808

# Base.min — Function

min(x, y, ...)

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

Примеры

julia> min(2, 5, 1)
1

julia> min(4, missing, 6)
missing

# Base.max — Function

max(x, y, ...)

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

Примеры

julia> max(2, 5, 1)
5

julia> max(5, missing, 6)
missing

# Base.minmax — Function

minmax(x, y)

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

См. также описание функции extrema, которая возвращает (minimum(x), maximum(x)).

Примеры

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

# Base.clamp — Function

clamp(x, lo, hi)

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

См. также описание clamp!, min и max.

Совместимость: Julia 1.3

Для использования missing в качестве первого аргумента требуется версия Julia не ниже 1.3.

Примеры

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)  # Пример, в котором 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.

Совместимость: Julia 1.6

Для этого метода требуется версия Julia не ниже 1.6.

# Base.clamp! — Function

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

Приводит каждое из значений массива array к указанному диапазону на месте. См. также описание clamp.

Совместимость: Julia 1.3

Для использования в array элементов missing требуется версия Julia не ниже 1.3.

Примеры

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

# Base.abs — Function

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])  # переполнение при typemin(Int8)
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

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

# Base.Checked — Module

Checked

Модуль Checked предоставляет арифметические функции для встроенных целочисленных типов со знаком и без знака, которые выдают ошибку при переполнении. Они называются checked_sub, checked_div и т. д. Кроме того, add_with_overflow, sub_with_overflow, mul_with_overflow возвращают как непроверенные результаты, так и логическое значение, указывающее на наличие переполнения.

# Base.Checked.checked_abs — Function

Base.checked_abs(x)

Вычисляет abs(x), проверяя наличие ошибок переполнения, если применимо. Например, целые числа со знаком со стандартным двоичным дополнительным кодом (например, Int) не могут представлять abs(typemin(Int)), из-за чего возникает переполнение.