Математика

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

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, 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}:
  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, UnitRange). Требуется одно из length или stop . Если length, stop, и step все указаны, они должны совпадать.

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

Если step и stop заданы, а length нет, общая длина диапазона будет вычислена автоматически таким образом, чтобы элементы были step расположены (a 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), и ⊻ можно ввести, нажав Tab после \xor или \veebar в REPL Julia.

Примеры

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

julia> [true; true; false] .⊻ [true; false; false]
3-element 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. Используйте комплексные отрицательные аргументы для получения комплексных результатов.

Примеры

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

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

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

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

Примеры

julia> round(1.7)
2.0

julia> round(Int, 1.7)
2

julia> round(1.5)
2.0

julia> round(2.5)
2.0

julia> round(pi; digits=2)
3.14

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

julia> round(123.456; sigdigits=2)
120.0

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

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.RoundFromZeroКонстанта

RoundFromZero

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

Примеры

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

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.

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

Биномиальный коэффициент $\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

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

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

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

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

• Факториал на Wikipedia.

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