Математика

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

Base.:-Метод

-(x)

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

Примеры

julia> -1
-1

julia> -(2)
-2

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

Base.:+Функция

+(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.:-Метод

-(x, y)

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

Примеры

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

Base.:*Метод

*(x, y...)

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

Примеры

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

Base.:/Функция

/(x, y)

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

Примеры

julia> 1/2
0.5

julia> 4/2
2.0

julia> 4.5/2
2.25

Base.:\Метод

\(x, y)

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

Примеры

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

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

julia> A \ x
2-element Array{Float64,1}:
  6.5
 -7.0

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

Base.:^Метод

^(x, y)

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

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

julia> 3^5
243

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

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

Base.fmaФункция

fma(x, y, z)

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

Base.muladdФункция

muladd(x, y, z)

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

Примеры

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

Base.invМетод

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

Base.divФункция

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

Целочисленное частное от деления. Вычисляет x/y, усечённое до целого числа.

Примеры

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

Base.fldФункция

fld(x, y)

Наибольшее целое число, меньшее или равное x/y.

Примеры

julia> fld(7.3,5.5)
1.0

Base.cldФункция

cld(x, y)

Наименьшее целое число, большее или равное x/y.

Примеры

julia> cld(5.5,2.2)
3.0

Base.modФункция

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

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

См. также: mod1.

Примеры

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

julia> mod(3, 0:2)
0

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

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

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

julia> mod(8, 3)
2

julia> mod(9, 3)
0

julia> mod(8.9, 3)
2.9000000000000004

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

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

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

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

Примеры

julia> 129 % Int8
-127

Base.remФункция

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

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

Примеры

julia> x = 15; y = 4;

julia> x % y
3

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

Base.Math.rem2piФункция

rem2pi(x, r::RoundingMode)

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

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

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

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

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

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

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

Примеры

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

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

Base.Math.mod2piФункция

mod2pi(x)

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

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

Примеры

julia> mod2pi(9*pi/4)
0.7853981633974481

Base.divremФункция

divrem(x, y)

Целая часть и остаток от целочисленного деления. Эквивалентно (div(x,y), rem(x,y)) или (x÷y, x%y).

Примеры

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

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

Base.fldmodФункция

fldmod(x, y)

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

Base.fld1Функция

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Функция

mod1(x, y)

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

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

Примеры

julia> mod1(4, 2)
2

julia> mod1(4, 3)
1

Base.fldmod1Функция

fldmod1(x, y)

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

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

Base.://Функция

//(num, den)

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

Примеры

julia> 3 // 5
3//5

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

Base.rationalizeФункция

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Функция

numerator(x)

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

Примеры

julia> numerator(2//3)
2

julia> numerator(4)
4

Base.denominatorФункция

denominator(x)

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

Примеры

julia> denominator(2//3)
3

julia> denominator(4)
1

Base.:<<Функция

<<(x, n)

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

Примеры

julia> Int8(3) << 2
12

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

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

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

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

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

Примеры

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

julia> B << 1
5-element BitArray{1}:
 0
 1
 0
 0
 0

julia> B << -1
5-element BitArray{1}:
 0
 1
 0
 1
 0

Base.:>>Функция

>>(x, n)

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

Примеры

julia> Int8(13) >> 2
3

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

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

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

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

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

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

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

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

Примеры

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

julia> B >> 1
5-element BitArray{1}:
 0
 1
 0
 1
 0

julia> B >> -1
5-element BitArray{1}:
 0
 1
 0
 0
 0

Base.:>>>Функция

>>>(x, n)

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

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

Примеры

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

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

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

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

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

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

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

Base.::Функция

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

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

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

(:)(I::CartesianIndex, J::CartesianIndex)

Создайте CartesianIndices из двух CartesianIndex.

Примеры

julia> I = CartesianIndex(2,1);

julia> J = CartesianIndex(3,3);

julia> I:J
2×3 CartesianIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
 CartesianIndex(2, 1)  CartesianIndex(2, 2)  CartesianIndex(2, 3)
 CartesianIndex(3, 1)  CartesianIndex(3, 2)  CartesianIndex(3, 3)

Base.rangeФункция

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

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

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

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

stop может быть указано как позиционным, так и именованным аргументом.

Примеры

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

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

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

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

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

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

Base.OneToТип

Base.OneTo(n)

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

Base.StepRangeLenТип

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

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

Base.:==Функция

==(x, y)

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

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

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

Реализация

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

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

==(x)

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

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

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

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

Примеры

julia> "abc" == "abc"
true

julia> "abc" == "αβγ"
false

Base.:!=Функция

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

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

Реализация

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

Примеры

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

!=(x)

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

Base.:!==Функция

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

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

Примеры

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

julia> a ≢ b
true

julia> a ≢ a
false

Base.:<Функция

<(x, y)

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

Реализация

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

Примеры

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

<(x)

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

Base.:<=Функция

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

Base.:>Функция

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

Base.:>=Функция

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

Base.cmpФункция

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 в алфавитном порядке (технически, лексикографический порядок по кодам Unicode).

Примеры

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.:~Функция

~(x)

Битовая инверсия.

Примеры

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

Base.:&Функция

&(x, y)

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

Примеры

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

Base.:|Функция

|(x, y)

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

Примеры

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

Base.xorФункция

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

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

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

Примеры

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

julia> [true; true; false] .⊻ [true; false; false]
3-element BitArray{1}:
 0
 1
 0

Base.:!Функция

!(x)

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

Примеры

julia> !true
false

julia> !false
true

julia> !missing
missing

julia> .![true false true]
1×3 BitArray{2}:
 0  1  0

!f::Function

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

Примеры

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

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

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

&&Ключевое слово

x && y

Короткое замыкание логического И.

||Ключевое слово

x || y

Короткое замыкание логического ИЛИ.

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

Base.isapproxФункция

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

Нестрогое сравнение на равенство: true если norm(x-y) <= max(atol, rtol*max(norm(x), norm(y))). Значение по умолчанию для atol равно нулю, а значение по умолчанию для rtol зависит от типов x и y. Ключевое слово nans определяет, учитываются ли значения NaN как равные (по умолчанию — false).

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

x и y также могут быть массивами чисел, в этом случае norm по умолчанию устанавливается в обычную функцию norm в LinearAlgebra, но может быть изменено путём передачи ключевого аргумента norm::Function. (Для чисел, norm — то же самое, что и abs.) Когда x и y являются массивами, если norm(x-y) не является конечным (т.е. ±Inf или NaN), сравнение сводится к проверке, являются ли все элементы x и y приблизительно равными по компонентам.

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

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

Примеры

julia> 0.1 ≈ (0.1 - 1e-10)
true

julia> isapprox(10, 11; atol = 2)
true

julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0])
true

julia> 1e-10 ≈ 0
false

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

Base.sinМетод

sin(x)

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

Base.cosМетод

cos(x)

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

Base.Math.sincosМетод

sincos(x)

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

Base.tanМетод

tan(x)

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

Base.Math.sindФункция

sind(x)

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

Base.Math.cosdФункция

cosd(x)

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

Base.Math.tandФункция

tand(x)

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

Base.Math.sinpiФункция

sinpi(x)

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

Base.Math.cospiФункция

cospi(x)

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

Base.sinhМетод

sinh(x)

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

Base.coshМетод

cosh(x)

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

Base.tanhМетод

tanh(x)

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

Base.asinМетод

asin(x)

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

Base.acosМетод

acos(x)

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

Base.atanМетод

atan(y)
atan(y, x)

Вычислить обратный тангенс y или y/x, соответственно.

Для одного аргумента — это угол в радианах между положительной осью x и точкой (1, y), возвращающий значение в интервале $[-\pi/2, \pi/2]$.

Для двух аргументов — это угол в радианах между положительной осью x и точкой (x, y), возвращающий значение в интервале $[-\pi, \pi]$. Соответствует стандартной функции atan2.

Base.Math.asindФункция

asind(x)

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

Base.Math.acosdФункция

acosd(x)

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

Base.Math.atandФункция

atand(y)
atand(y,x)

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

Base.Math.secМетод

sec(x)

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

Base.Math.cscМетод

csc(x)

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

Base.Math.cotМетод

cot(x)

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

Base.Math.secdФункция

secd(x)

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

Base.Math.cscdФункция

cscd(x)

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

Base.Math.cotdФункция

cotd(x)

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

Base.Math.asecМетод

asec(x)

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

Base.Math.acscМетод

acsc(x)

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

Base.Math.acotМетод

acot(x)

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

Base.Math.asecdФункция

asecd(x)

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

Base.Math.acscdФункция

acscd(x)

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

Base.Math.acotdФункция

acotd(x)

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

Base.Math.sechМетод

sech(x)

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

Base.Math.cschМетод

csch(x)

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

Base.Math.cothМетод

coth(x)

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

Base.asinhМетод

asinh(x)

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

Base.acoshМетод

acosh(x)

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

Base.atanhМетод

atanh(x)

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

Base.Math.asechМетод

asech(x)

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

Base.Math.acschМетод

acsch(x)

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

Base.Math.acothМетод

acoth(x)

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

Base.Math.sincФункция

sinc(x)

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

Base.Math.coscФункция

cosc(x)

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

Base.Math.deg2radФункция

deg2rad(x)

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

Примеры

julia> deg2rad(90)
1.5707963267948966

Base.Math.rad2degФункция

rad2deg(x)

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

Примеры

julia> rad2deg(pi)
180.0

Base.Math.hypotФункция

hypot(x, y)

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

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

Примеры

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

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

julia> hypot(3, 4im)
5.0

hypot(x...)

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

Примеры

julia> hypot(-5.7)
5.7

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

Base.logМетод

log(x)

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

Примеры

julia> log(2)
0.6931471805599453

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

Base.logМетод

log(b,x)

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

Примеры

julia> log(4,8)
1.5

julia> log(4,2)
0.5

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

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

julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0

Base.log2Функция

log2(x)

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

Примеры

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
ERROR: DomainError with -2.0:
NaN result for non-NaN input.
Stacktrace:
 [1] nan_dom_err at ./math.jl:325 [inlined]
[...]

Base.log10Функция

log10(x)

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

Примеры

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

julia> log10(-2)
ERROR: DomainError with -2.0:
NaN result for non-NaN input.
Stacktrace:
 [1] nan_dom_err at ./math.jl:325 [inlined]
[...]

Base.log1pФункция

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Функция

frexp(val)

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

Base.expМетод

exp(x)

Вычислить экспоненту от x, то есть $e^x$.

Примеры

julia> exp(1.0)
2.718281828459045

Base.exp2Функция

exp2(x)

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

Примеры

julia> exp2(5)
32.0

Base.exp10Функция

exp10(x)

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

Примеры

julia> exp10(2)
100.0

exp10(x)

Вычислить $10^x$.

Примеры

julia> exp10(2)
100.0

julia> exp10(0.2)
1.5848931924611136

Base.Math.ldexpФункция

ldexp(x, n)

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

Примеры

julia> ldexp(5., 2)
20.0

Base.Math.modfФункция

modf(x)

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

Примеры

julia> modf(3.5)
(0.5, 3.0)

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

Base.expm1Функция

expm1(x)

Точно вычислить $e^x-1$.

Base.roundМетод

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

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

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

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

Примеры

julia> round(1.7)
2.0

julia> round(Int, 1.7)
2

julia> round(1.5)
2.0

julia> round(2.5)
2.0

julia> round(pi; digits=2)
3.14

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

julia> round(123.456; sigdigits=2)
120.0

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

julia> x = 1.15
1.15

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

julia> x < 115//100
true

julia> round(x, digits=1)
1.2

Расширения

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

Base.Rounding.RoundingModeТип

RoundingMode

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

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

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

Base.Rounding.RoundNearestКонстанта

RoundNearest

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

Base.Rounding.RoundNearestTiesAwayКонстанта

RoundNearestTiesAway

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

Base.Rounding.RoundNearestTiesUpКонстанта

RoundNearestTiesUp

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

Base.Rounding.RoundToZeroКонстанта

RoundToZero

Округление до ближайшего целого с использованием этого режима — это псевдоним для trunc.

Base.Rounding.RoundFromZeroКонстанта

RoundFromZero

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

Примеры

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

Base.Rounding.RoundUpКонстанта

RoundUp

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

Base.Rounding.RoundDownКонстанта

RoundDown

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

Base.roundМетод

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

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

Пример

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

Base.ceilФункция

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Функция

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Функция

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.

Base.unsafe_truncФункция

unsafe_trunc(T, x)

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

Base.minФункция

min(x, y, ...)

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

Примеры

julia> min(2, 5, 1)
1

Base.maxФункция

max(x, y, ...)

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

Примеры

julia> max(2, 5, 1)
5

Base.minmaxФункция

minmax(x, y)

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

Примеры

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

Base.Math.clampФункция

clamp(x, lo, hi)

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

Примеры

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

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

Base.Math.clamp!Функция

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

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

Base.absФункция

abs(x)

Модуль x.

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

Примеры

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs(typemin(Int64))
-9223372036854775808

Base.Checked.checked_absФункция

Base.checked_abs(x)

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

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

Base.Checked.checked_negФункция

Base.checked_neg(x)

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

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

Base.Checked.checked_addФункция

Base.checked_add(x, y)

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

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

Base.Checked.checked_subФункция

Base.checked_sub(x, y)

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

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

Base.Checked.checked_mulФункция

Base.checked_mul(x, y)

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

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

Base.Checked.checked_divФункция

Base.checked_div(x, y)

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

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

Base.Checked.checked_remФункция

Base.checked_rem(x, y)

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

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

Base.Checked.checked_fldФункция

Base.checked_fld(x, y)

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

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

Base.Checked.checked_modФункция

Base.checked_mod(x, y)

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

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

Base.Checked.checked_cldФункция

Base.checked_cld(x, y)

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

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

Base.Checked.add_with_overflowФункция

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

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

Base.Checked.sub_with_overflowФункция

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

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

Base.Checked.mul_with_overflowФункция

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

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

Base.abs2Функция

abs2(x)

Возвращает квадрат модуля x.

Примеры

julia> abs2(-3)
9

Base.copysignФункция

copysign(x, y) -> z

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

Примеры

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

Base.signФункция

sign(x)

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

Base.signbitФункция

signbit(x)

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

Примеры

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true

Base.flipsignФункция

flipsign(x, y)

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

Примеры

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5

Base.sqrtМетод

sqrt(x)

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

Примеры

julia> sqrt(big(81))
9.0

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

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

Base.isqrtФункция

isqrt(n::Integer)

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

julia> isqrt(5)
2

Base.Math.cbrtФункция

cbrt(x::Real)

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

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

Примеры

julia> cbrt(big(27))
3.0

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

Base.realМетод

real(z)

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

Примеры

julia> real(1 + 3im)
1

Base.imagФункция

imag(z)

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

Примеры

julia> imag(1 + 3im)
3

Base.reimФункция

reim(z)

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

Примеры

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

Base.conjФункция

conj(z)

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

Примеры

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

Base.angleФункция

angle(z)

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

Примеры

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

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

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

Base.cisФункция

cis(z)

Возвращает $\exp(iz)$.

Примеры

julia> cis(π) ≈ -1
true

Base.binomialФункция

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

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

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

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

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

Примеры

julia> binomial(5, 3)
10

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

julia> binomial(-5, 3)
-35

См. также

• factorial

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

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

Base.factorialФункция

factorial(n::Integer)

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

Примеры

julia> factorial(6)
720

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

julia> factorial(big(21))
51090942171709440000

См. также

• binomial

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

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

Base.gcdФункция

gcd(x,y)

Наибольший общий (положительный) делитель (или ноль, если x и y оба равны нулю).

Примеры

julia> gcd(6,9)
3

julia> gcd(6,-9)
3

Base.lcmФункция

lcm(x,y)

Наименьшее общее (неотрицательное) кратное.

Примеры

julia> lcm(2,3)
6

julia> lcm(-2,3)
6

Base.gcdxФункция

gcdx(x,y)

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

Примеры

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

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

Base.ispow2Функция

ispow2(n::Integer) -> Bool

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

Примеры

julia> ispow2(4)
true

julia> ispow2(5)
false

Base.nextpowФункция

nextpow(a, x)

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

Примеры

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16

См. также prevpow.

Base.prevpowФункция

prevpow(a, x)

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

Примеры

julia> prevpow(2, 7)
4

julia> prevpow(2, 9)
8

julia> prevpow(5, 20)
5

julia> prevpow(4, 16)
16

См. также nextpow.

Base.nextprodФункция

nextprod([k_1, k_2,...], n)

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

Примеры

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

julia> 2^2 * 3^3
108

Base.invmodФункция

invmod(x,m)

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

Примеры

julia> invmod(2,5)
3

julia> invmod(2,3)
2

julia> invmod(5,6)
5

Base.powermodФункция

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

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

Примеры

julia> powermod(2, 6, 5)
4

julia> mod(2^6, 5)
4

julia> powermod(5, 2, 20)
5

julia> powermod(5, 2, 19)
6

julia> powermod(5, 3, 19)
11

Base.ndigitsФункция

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

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

Примеры

julia> ndigits(12345)
5

julia> ndigits(1022, base=16)
3

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

julia> ndigits(123, pad=5)
5

Base.widemulФункция

widemul(x, y)

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

Примеры

julia> widemul(Float32(3.), 4.)
12.0

Base.Math.@evalpolyМакрос

@evalpoly(z, c...)

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

Примеры

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

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

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

Base.FastMath.@fastmathМакрос

@fastmath expr

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

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

Примеры

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672