Математика

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

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

Если step и stop заданы, а length нет, общая длина диапазона будет вычислена автоматически так, чтобы элементы располагались с шагом step (диапазон 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)

Определите диапазон, который ведет себя как 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 выводится автоматически), параметризованный значением ссылки, шагом и длиной. По умолчанию 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 в алфавитном порядке (в техническом смысле — лексикографическом порядке по кодам Юникода).

Примеры

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), а ⊻ можно набрать, нажав Tab после \xor или \veebar в интерактивной оболочке Julia.

Примеры

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

julia> [true; true; false] .⊻ [true; false; false]
3-element 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}$, избегая переполнения и потери точности.

Примеры

julia> a = 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:
[...]

hypot(x...)

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

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)

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

Примеры

julia> exp2(5)
32.0

Base.exp10Функция

exp10(x)

Вычислите экспоненту по основанию 10 от x, то есть $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