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

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

# Base.:- — Method

-(x)

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

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

Примеры

julia> -1
-1

julia> -(2)
-2

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

# Base.:+ — Function

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

# Base.:- — Method

-(x, y)

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

Примеры

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

# Base.:* — Method

*(x, y...)

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

Примеры

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

# Base.:/ — Function

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

# 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 представляет собой целочисленный (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 положительное.

Примеры

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

# Base.fma — Function

fma(x, y, z)

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

# Base.muladd — Method

muladd(x, y, z)

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

Примеры

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

# Base.muladd — Method

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

Примеры

julia> 3 // 5
3//5

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

# 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 бит с заполнением нулями. Это эквивалентно 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 принимаются равными единице.

См. Расширенную справку для получения дополнительных сведений о возвращаемом типе.

Примеры

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

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

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

# Base.:== — Function

==(x, y)

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

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

Результат имеет тип Bool за исключением случаев, когда один из операндов отсутствующий (missing), и тогда возвращается значение missing (троичная логика). Для коллекций missing возвращается, если хотя бы один из операндов содержит значение 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.

Примеры

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

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

Вычисляет , если , и , если .

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

# Base.Math.cosc — Function

cosc(x)

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

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

См. также ℯ, 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

# 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 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
[...]

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

julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0

# Base.log2 — Function

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

# 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 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 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 равно .

Примеры

julia> frexp(12.8)
(0.8, 4)

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

Вычисляет .

Примеры

julia> ldexp(5., 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 — Method

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

Округление до заданного числа знаков по основанию, отличному от 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

Расширения

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

# Base.Rounding.RoundingMode — Type

RoundingMode

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

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

RoundNearest (по умолчанию)
RoundNearestTiesAway
RoundNearestTiesUp
RoundToZero
RoundFromZero
RoundUp
RoundDown

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

Для RoundFromZero требуется версия не ниже Julia 1.9. Предыдущие версии поддерживают RoundFromZero только для BigFloat.

# Base.Rounding.RoundNearest — Constant

RoundNearest

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

# Base.Rounding.RoundNearestTiesAway — Constant

RoundNearestTiesAway

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

# Base.Rounding.RoundNearestTiesUp — Constant

RoundNearestTiesUp

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

# Base.Rounding.RoundToZero — Constant

RoundToZero

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

# Base.Rounding.RoundFromZero — Constant

RoundFromZero

Округляет в сторону «от нуля».

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

Для RoundFromZero требуется версия не ниже Julia 1.9. Предыдущие версии поддерживают RoundFromZero только для BigFloat.

Примеры

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, если значение невозможно представить этим типом.

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

# 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, если значение невозможно представить этим типом.

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

# 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, если значение невозможно представить этим типом.

Именованные аргументы 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

# 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). См. также функцию minimum, которая получает наименьший элемент из коллекции.

Примеры

julia> min(2, 5, 1)
1

# Base.max — Function

max(x, y, ...)

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

Примеры

julia> max(2, 5, 1)
5

# Base.minmax — Function

minmax(x, y)

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

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

Примеры

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

# Base.Math.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.Math.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.checked_abs — Function

Base.checked_abs(x)

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