Математика

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

Base.:-Метод

-(x)

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

Примеры

julia> -1
-1

julia> -(2)
-2

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

Base.:+Функция

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

Сложение Date с Time даёт DateTime. Части часа, минуты, секунды и миллисекунды Time используются вместе с годом, месяцем и днём Date для создания новой DateTime. Не нулевые микросекунды или наносекунды в типе Time приведут к исключению InexactError.

+(x, y...)

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

Примеры

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

Base.:-Метод

-(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 = [1 2; 3 4]; x = [5, 6];

julia> A \ x
2-element Array{Float64,1}:
 -4.0
  4.5

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

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, 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, то результат находится в интервале $[-π, π]$. Это обычно самый точный результат.

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

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

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

Примеры

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

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

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

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

julia> B >> 1
5-element BitArray{1}:
 false
  true
 false
  true
 false

julia> B >> -1
5-element BitArray{1}:
 false
  true
 false
 false
 false

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 (a UnitRange), а a:s:b аналогично, но использует шаг s (a StepRange).

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

Base.rangeФункция

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

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

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

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

Примеры

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

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

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

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

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

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

>=(x, y)
≥(x,y)

Оператор сравнения больше или равно. Возвращается к y <= x.

Примеры

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

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), а ⊻ можно ввести, выполнив автодополнение \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}:
 false
  true
 false

Base.:!Функция

!(x)

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

Примеры

julia> !true
false

julia> !false
true

julia> !missing
missing

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

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

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 log:
-2.0 will only return a complex result if called with a complex argument. Try -2.0(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Float64, ::Symbol) at ./math.jl:31
[...]

julia> log(2, -3)
ERROR: DomainError with log:
-3.0 will only return a complex result if called with a complex argument. Try -3.0(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Float64, ::Symbol) 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 log1p:
-2.0 will only return a complex result if called with a complex argument. Try -2.0(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Float64, ::Symbol) 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

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

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

RoundUp

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

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

RoundDown

round использование этого режима округления — псевдоним для 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 -8.1e+01:
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)

Биномиальный коэффициент $inom{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
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.)
1.2e+01

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