Документация Engee

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

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

# Base.:- — Method

-(x)

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

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

Примеры

julia> -1
-1

julia> -(2)
-2

julia> -[1 2; 3 4]
2×2 Matrix{Int64}:
 -1  -2
 -3  -4
dt::Date + t::Time -> DateTime

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

+(x, y...)

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

Примеры

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

# Base.:- — Method

-(x, y)

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

Примеры

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5
*(x, y...)

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

Примеры

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112
/(x, y)

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

Примеры

julia> 1/2
0.5

julia> 4/2
2.0

julia> 4.5/2
2.25
A / B

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

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

Примеры

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

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

julia> isapprox(A, X*B)
true

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

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

Примеры

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

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

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

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

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

Если y представляет собой целочисленный (Int) литерал (например, 2 в выражении x^2 или -3 в x^-3), то выражение 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
fma(x, y, z)

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

muladd(x, y, z)

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

Примеры

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7
muladd(A, y, z)

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

Совместимость: Julia 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
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.

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

Результат евклидова (целочисленного) деления. Как правило, эквивалентен результату математической операции x/y без дробной части.

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

Примеры

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

julia> 5.0 ÷ 2
2.0

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

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

См. также описание функций div, cld и fld1.

Примеры

julia> fld(7.3, 5.5)
1.0

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

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

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

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

cld(x, y)

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

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

Примеры

julia> cld(5.5, 2.2)
3.0

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

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

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

См. также описание div, mod, mod1, divrem.

Примеры

julia> x = 15; y = 4;

julia> x % y
3

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

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

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

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

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

  • Если r == RoundNearest, результат будет в интервале ]. Как правило, это будет самый точный результат. См. также описание RoundNearest.

  • Если r == RoundToZero, результат будет в интервале ], если значение x положительное, или ] в противном случае. См. также описание RoundToZero.

  • Если r == RoundDown, результат будет в интервале ]. См. также описание RoundDown.

  • Если r == RoundUp, результат будет в интервале ]. См. также описание RoundUp.

Примеры

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

julia> rem2pi(7pi/4, RoundDown)
5.497787143782138
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
divrem(x, y, r::RoundingMode=RoundToZero)

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

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

Примеры

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

julia> divrem(7, 3)
(2, 1)
fldmod(x, y)

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

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

fld1(x, y)

Деление с округлением в меньшую сторону, которое возвращает значение, соответствующее mod1(x,y)

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

Примеры

julia> x = 15; y = 4;

julia> fld1(x, y)
4

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

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

Остаток от целочисленного деления с округлением в меньшую сторону, возвращающий значение r, так что mod(r, y) == mod(x, y) В диапазоне ] для положительного 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
fldmod1(x, y)

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

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

//(num, den)

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

Примеры

julia> 3 // 5
3//5

julia> (3 // 5) // (2 // 1)
3//10
rationalize([T<:Integer=Int,] x; tol::Real=eps(x))

Выдает приближенное значение числа с плавающий запятой x как рационального (Rational) числа с компонентами указанного целочисленного типа. Результат отличается от x не больше, чем на tol.

Примеры

julia> rationalize(5.6)
28//5

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

julia> typeof(numerator(a))
BigInt
numerator(x)

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

Примеры

julia> numerator(2//3)
2

julia> numerator(4)
4
denominator(x)

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

Примеры

julia> denominator(2//3)
3

julia> denominator(4)
1
<<(x, n)

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

Примеры

julia> Int8(3) << 2
12

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

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

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

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

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

Примеры

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

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

julia> B << -1
5-element BitVector:
 0
 1
 0
 1
 0
>>(x, n)

Оператор сдвига битов вправо, x >> n. Для n >= 0 результатом будет x со сдвигом вправо на n бит, и с заполнением 0 при x >= 0 или 1 при x < 0 с сохранением знака x. Это эквивалентно fld(x, 2^n). Для n < 0 эквивалентен x << -n.

Примеры

julia> Int8(13) >> 2
3

julia> bitstring(Int8(13))
"00001101"

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

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

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

julia> bitstring(Int8(-4))
"11111100"

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

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

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

Примеры

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

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

julia> B >> -1
5-element BitVector:
 0
 1
 0
 0
 0
>>>(x, n)

Оператор сдвига битов вправо без знака, x >>> n. Для n >= 0 результатом будет x со сдвигом вправо на n бит, и с заполнением 0. При n < 0 это эквивалентно x << -n.

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

Примеры

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

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

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

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

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

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

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

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

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

Совместимость: 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"
:expr

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

См. также описание Expr, Symbol, Meta.parse

Примеры

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

julia> sym = :some_identifier
:some_identifier

julia> value = :0xff
0xff

julia> typeof((expr, sym, value))
Tuple{Expr, Symbol, UInt8}
range(start, stop, length)
range(start, stop; length, step)
range(start; length, stop, step)
range(;start, length, stop, step)

Создает на основе аргументов особый массив с равноудаленными друг от друга элементами и оптимизированным хранением (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(n)

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

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.

 
==(x, y)

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

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

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

Реализация

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

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

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

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

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

Реализация

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

Примеры

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false
!=(x)

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

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

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

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

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

Примеры

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

julia> a ≢ b
true

julia> a ≢ a
false
<(x, y)

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

Реализация

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

Примеры

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false
<(x)

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

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

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

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

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

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

 
cmp(x,y)

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

Примеры

julia> cmp(1, 2)
-1

julia> cmp(2, 1)
1

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

Примеры

julia> ~4
-5

julia> ~10
-11

julia> ~true
false
x & y

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

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

Примеры

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false
x | y

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

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

Примеры

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing
xor(x, y)
⊻(x, y)

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

Инфиксная операция a ⊻ b является синонимом xor(a,b), и вы можете вводить ⊻, используя автозавершение по клавише TAB для \xor или \veebar в 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
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
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
!(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, а не анонимную функцию.

 
x && y

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

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

Примеры

julia> x = 3;

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

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

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

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

Примеры

julia> pi < 3 || ℯ < 3
true

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

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

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

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

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

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

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

Обратите внимание, что выражение x ≈ 0 (т. е. сравнение с нулем с допусками по умолчанию) эквивалентно x == 0, так как значение atol по умолчанию — 0. В таких случаях следует либо указать нужное значение atol (или использовать norm(x) ≤ atol), либо скорректировать код (например, вместо x - y ≈ 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.

 
sin(x)

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

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

Примеры

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

julia> sind(45)
0.7071067811865476

julia> sinpi(1/4)
0.7071067811865476

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

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

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

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

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

sincos(x)

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

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

tan(x)

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

sind(x)

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

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

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

 
cosd(x)

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

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

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

 
tand(x)

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

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

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

 
sincosd(x)

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

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

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

 
sinpi(x)

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

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

cospi(x)

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

sincospi(x)

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

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

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

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

sinh(x)

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

cosh(x)

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

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
asin(x)

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

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

Примеры

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

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

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

atan(y)
atan(y, x)

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

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

При наличии двух аргументов это будет угол в радианах между положительным направлением оси 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
asind(x)

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

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

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

 
acosd(x)

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

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

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

 
atand(y)
atand(y,x)

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

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

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

 
sec(x)

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

csc(x)

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

cot(x)

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

secd(x)

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

cscd(x)

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

cotd(x)

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

asec(x)

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

acsc(x)

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

acot(x)

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

asecd(x)

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

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

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

 
acscd(x)

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

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

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

 
acotd(x)

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

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

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

 
sech(x)

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

csch(x)

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

coth(x)

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

asinh(x)

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

acosh(x)

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

atanh(x)

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

asech(x)

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

acsch(x)

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

acoth(x)

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

sinc(x)

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

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

cosc(x)

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

deg2rad(x)

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

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

Примеры

julia> deg2rad(90)
1.5707963267948966
rad2deg(x)

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

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

Примеры

julia> rad2deg(pi)
180.0
hypot(x, y)

Вычисляет гипотенузу , избегая переполнения и антипереполнения.

Данный код реализует алгоритм из статьи 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
log(x)

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

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

Примеры

julia> log(2)
0.6931471805599453

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

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

Вычисляет логарифм 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
 
log2(x)

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

См. также описание exp2, ldexp, ispow2.

Примеры

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

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

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

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

Примеры

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

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

Точный натуральный логарифм 1+x. Выдает ошибку DomainError при аргументах типа Real со значением меньше --1.

Примеры

julia> log1p(-0.5)
-0.6931471805599453

julia> log1p(0)
0.0

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

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

Примеры

julia> frexp(12.8)
(0.8, 4)
exp(x)

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

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

Примеры

julia> exp(1.0)
2.718281828459045

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

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

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

Примеры

julia> exp2(5)
32.0

julia> 2^5
32

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

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

Примеры

julia> exp10(2)
100.0

julia> 10^2
100
ldexp(x, n)

Вычисляет .

Примеры

julia> ldexp(5., 2)
20.0
modf(x)

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

Примеры

julia> modf(3.5)
(0.5, 3.0)

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

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

Примеры

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

julia> exp(1e-16) - 1
0.0
round([T,] x, [r::RoundingMode])
round(x, [r::RoundingMode]; digits::Integer=0, base = 10)
round(x, [r::RoundingMode]; sigdigits::Integer, base = 10)

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

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

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

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

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

Примеры

julia> round(1.7)
2.0

julia> round(Int, 1.7)
2

julia> round(1.5)
2.0

julia> round(2.5)
2.0

julia> round(pi; digits=2)
3.14

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

julia> round(123.456; sigdigits=2)
120.0

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

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

RoundingMode

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

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

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

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

 
RoundNearest

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

RoundNearestTiesAway

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

RoundNearestTiesUp

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

RoundToZero

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

RoundFromZero

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

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

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

Примеры

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

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

RoundDown

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

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

Возвращает ближайшее к z целочисленное значение того же типа, что у комплексного значения z, используя заданные режимы округления RoundingMode для дробных значений 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
ceil([T,] x)
ceil(x; digits::Integer= [, base = 10])
ceil(x; sigdigits::Integer= [, base = 10])

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

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

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

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

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

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

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

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

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

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

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

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

Примеры

julia> trunc(2.22)
2.0

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

julia> trunc(Int, -2.22)
-2
unsafe_trunc(T, x)

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

Примеры

julia> unsafe_trunc(Int, -2.2)
-2

julia> unsafe_trunc(Int, NaN)
-9223372036854775808
min(x, y, ...)

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

Примеры

julia> min(2, 5, 1)
1
max(x, y, ...)

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

Примеры

julia> max(2, 5, 1)
5
minmax(x, y)

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

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

Примеры

julia> minmax('c','b')
('b', 'c')
clamp(x, lo, hi)

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

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

Совместимость: Julia 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.

 
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
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_abs(x)

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

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_neg(x)

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

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_add(x, y)

Вычисляет x+y, проверяя наличие ошибок переполнения, если применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_sub(x, y)

Вычисляет x-y, проверяя наличие ошибок переполнения, если применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_mul(x, y)

Вычисляет x*y, проверяя наличие ошибок переполнения, если применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_div(x, y)

Вычисляет div(x,y), проверяя наличие ошибок переполнения, если применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_rem(x, y)

Вычисляет x%y, проверяя наличие ошибок переполнения, если применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_fld(x, y)

Вычисляет fld(x,y), проверяя наличие ошибок переполнения, если применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_mod(x, y)

Вычисляет mod(x,y), проверяя наличие ошибок переполнения, если применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.checked_cld(x, y)

Вычисляет cld(x,y), проверяя наличие ошибок переполнения, если применимо.

Защита от переполнения может привести к заметному снижению производительности.

Base.add_with_overflow(x, y) -> (r, f)

Вычисляет r = x+y, а флаг f показывает, возникло ли переполнение.

Base.sub_with_overflow(x, y) -> (r, f)

Вычисляет r = x-y, а флаг f показывает, возникло ли переполнение.

Base.mul_with_overflow(x, y) -> (r, f)

Вычисляет r = x*y, а флаг f показывает, возникло ли переполнение.

abs2(x)

Абсолютное значение x, возведенное в квадрат.

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

См. также описание функций abs, conj и real.

Примеры

julia> abs2(-3)
9

julia> abs2(3.0 + 4.0im)
25.0

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

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

Примеры

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1
sign(x)

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

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

Примеры

julia> sign(-4.0)
-1.0

julia> sign(99)
1

julia> sign(-0.0)
-0.0

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

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

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

Примеры

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true
flipsign(x, y)

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

Примеры

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5
sqrt(x)

Возвращает . Выдает ошибку DomainError при отрицательных аргументах типа Real. Используйте вместо этого комплексные отрицательные аргументы. Префиксный оператор √ эквивалентен sqrt.

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

Примеры

julia> sqrt(big(81))
9.0

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

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

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

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

julia> isqrt(5)
2
cbrt(x::Real)

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

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

Примеры

julia> cbrt(big(27))
3.0

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

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

См. также описание imag, reim, complex, isreal, Real.

Примеры

julia> real(1 + 3im)
1
real(T::Type)

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

Примеры

julia> real(Complex{Int})
Int64

julia> real(Float64)
Float64
real(A::AbstractArray)

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

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

Примеры

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

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

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

См. также описание conj, reim, adjoint, angle.

Примеры

julia> imag(1 + 3im)
3
imag(A::AbstractArray)

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

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

Примеры

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

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

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

Примеры

julia> reim(1 + 3im)
(1, 3)
reim(A::AbstractArray)

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

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

Примеры

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

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

Вычисляет сопряженное комплексное число для комплексного числа z.

См. также описание angle, adjoint.

Примеры

julia> conj(1 + 3im)
1 - 3im
conj(A::AbstractArray)

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

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

Примеры

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

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

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

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

Примеры

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

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

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

Более эффективный метод для exp(im*x), использующий формулу Эйлера: .

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

Примеры

julia> cis(π) ≈ -1
true
cispi(x)

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

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

Примеры

julia> cispi(10000)
1.0 + 0.0im

julia> cispi(0.25 + 1im)
0.030556854645954562 + 0.030556854645954562im
Совместимость: Julia 1.6

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

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

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

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

где  — это функция factorial.

Если значение отрицательное, коэффициент определяется в виде тождества.

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

Примеры

julia> binomial(5, 3)
10

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

julia> binomial(-5, 3)
-35

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

factorial(n::Integer)

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

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

Примеры

julia> factorial(6)
720

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

julia> factorial(big(21))
51090942171709440000

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

gcd(x, y...)

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

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

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

Примеры

julia> gcd(6, 9)
3

julia> gcd(6, -9)
3

julia> gcd(6, 0)
6

julia> gcd(0, 0)
0

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

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

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

julia> gcd(0, 0, 10, 15)
5
lcm(x, y...)

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

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

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

Примеры

julia> lcm(2, 3)
6

julia> lcm(-2, 3)
6

julia> lcm(0, 3)
0

julia> lcm(0, 0)
0

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

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

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

julia> lcm(1, 3, 5, 7)
105
gcdx(a, b)

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

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

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

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

Примеры

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

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

Коэффициенты Безу не являются единственно возможными. Функция gcdx возвращает наименьшие коэффициенты Безу, вычисляемые с помощью расширенного алгоритма Евклида (см. Кнут Д. Искусство программирования. Изд. 2. С. 325. Алгоритм X). Для целых чисел со знаком эти коэффициенты u и v являются наименьшими в том смысле, что и . Кроме того, знаки u и v выбираются так, чтобы значение d было положительным. Для целых чисел без знака коэффициенты u и v могут иметь значения, близкие к их typemax, и тогда тождество будет верным только при арифметике по модулю для этих целых чисел без знака.

 
ispow2(n::Number) -> Bool

Проверяет, является ли число n результатом возведения 2 в целочисленную степень.

См. также описание функций count_ones, prevpow и nextpow.

Примеры

julia> ispow2(4)
true

julia> ispow2(5)
false

julia> ispow2(4.5)
false

julia> ispow2(0.25)
true

julia> ispow2(1//8)
true
Совместимость: Julia 1.6

Поддержка аргументов, не являющихся Integer, была добавлена в версии Julia 1.6.

 
nextpow(a, x)

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

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

Примеры

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16
prevpow(a, x)

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

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

Примеры

julia> prevpow(2, 7)
4

julia> prevpow(2, 9)
8

julia> prevpow(5, 20)
5

julia> prevpow(4, 16)
16
nextprod(factors::Union{Tuple,AbstractVector}, n)

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

Примеры

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

julia> 2^2 * 3^3
108
Совместимость: Julia 1.6

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

 
invmod(n, m)

Принимает значение, обратное n по модулю m, y так что и . Выдает ошибку, если или если .

Примеры

julia> invmod(2, 5)
3

julia> invmod(2, 3)
2

julia> invmod(5, 6)
5
powermod(x::Integer, p::Integer, m)

Вычисляет .

Примеры

julia> powermod(2, 6, 5)
4

julia> mod(2^6, 5)
4

julia> powermod(5, 2, 20)
5

julia> powermod(5, 2, 19)
6

julia> powermod(5, 3, 19)
11
ndigits(n::Integer; base::Integer=10, pad::Integer=1)

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

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

Примеры

julia> ndigits(0)
1

julia> ndigits(12345)
5

julia> ndigits(1022, base=16)
3

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

julia> ndigits(123, pad=5)
5

julia> ndigits(-123)
3
Base.add_sum(x, y)

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

widemul(x, y)

Перемножает x и y, выдавая результат с типом большего размера.

См. также описание promote и Base.add_sum.

Примеры

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

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

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

Вычисляет многочлен ] с коэффициентами p[1], p[2], …​; указанными в порядке возрастания по степени x. Циклы раскрываются во время компиляции, если число коэффициентов статически известное, т. е. когда p — это кортеж (Tuple). Функция создает эффективно работающий код с использованием метода Горнера при вещественном значении x или алгоритма, подобного алгоритму Гёрцеля link:Дональд Кнут. Искусство программирования. Том 2. Получисленные алгоритмы. Раздел 4.6.4.[^DK62], если значение x комплексное.

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

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

Пример

julia> evalpoly(2, (1, 2, 3))
17
@evalpoly(z, c...)

Вычисляет многочлен ] с коэффициентами c[1], c[2], …​; указанными в порядке возрастания по степени z. Этот макрос раскрывается в эффективный inline-код, использующий либо метод Горнера, либо, при комплексном значении z, более эффективный алгоритм, подобный алгоритму Гёрцеля.

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

Примеры

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

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

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

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

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

Примеры

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672

Настраиваемые двоичные операторы

Некоторые символы Unicode можно использовать для определения новых двоичных операторов, поддерживающих инфиксную нотацию. Например, ⊗(x,y) = kron(x,y) определяет функцию ⊗ (otimes) как произведение Кронекера, и ее можно вызвать как бинарный оператор, используя инфиксный синтаксис: C = A ⊗ B, а также с обычным префиксным синтаксисом C = ⊗(A,B).

К другим символам, поддерживающим такие расширения, относятся \odot ⊙ и \oplus ⊕.

Полный список находится в коде анализатора: https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm

К тем символам, которые анализируются как * (с точки зрения приоритетности), относятся * / ÷ % & ⋅ ∘ × |\| ∩ ∧ ⊗ ⊘ ⊙ ⊚ ⊛ ⊠ ⊡ ⊓ ∗ ∙ ∤ ⅋ ≀ ⊼ ⋄ ⋆ ⋇ ⋉ ⋊ ⋋ ⋌ ⋏ ⋒ ⟑ ⦸ ⦼ ⦾ ⦿ ⧶ ⧷ ⨇ ⨰ ⨱ ⨲ ⨳ ⨴ ⨵ ⨶ ⨷ ⨸ ⨻ ⨼ ⨽ ⩀ ⩃ ⩄ ⩋ ⩍ ⩎ ⩑ ⩓ ⩕ ⩘ ⩚ ⩜ ⩞ ⩟ ⩠ ⫛ ⊍ ▷ ⨝ ⟕ ⟖ ⟗, а к тем, которые анализируются как +, относятся + - |\|| ⊕ ⊖ ⊞ ⊟ |++| ∪ ∨ ⊔ ± ∓ ∔ ∸ ≏ ⊎ ⊻ ⊽ ⋎ ⋓ ⧺ ⧻ ⨈ ⨢ ⨣ ⨤ ⨥ ⨦ ⨧ ⨨ ⨩ ⨪ ⨫ ⨬ ⨭ ⨮ ⨹ ⨺ ⩁ ⩂ ⩅ ⩊ ⩌ ⩏ ⩐ ⩒ ⩔ ⩖ ⩗ ⩛ ⩝ ⩡ ⩢ ⩣ Есть также много других символов, связанных со стрелками, сравнениями и степенями.