Математика

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

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

(:)(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)

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

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

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

Base.rangeФункция

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

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

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

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

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

Примеры

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

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

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

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

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

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

Base.OneToТип

Base.OneTo(n)

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

Base.StepRangeLenТип

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

Диапазон r, где r[i] производит значения типа T (во втором формате T выводится автоматически), параметризованный refым значением, step, и lenной длиной. По умолчанию 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 в интерактивной оболочке 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 равными (по умолчанию — нет).

Для вещественных или комплексных чисел с плавающей точкой, если 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, то есть $e^x$.

Примеры

julia> exp(1.0)
2.718281828459045

Base.exp2Функция

exp2(x)

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

Примеры

julia> exp2(5)
32.0

Base.exp10Функция

exp10(x)

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

Примеры

julia> exp10(2)
100.0

exp10(x)

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

Примеры

julia> exp10(2)
100.0

julia> exp10(0.2)
1.5848931924611136

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

ldexp(x, n)

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

Примеры

julia> ldexp(5., 2)
20.0

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

modf(x)

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

Примеры

julia> modf(3.5)
(0.5, 3.0)

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

Base.expm1Функция

expm1(x)

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

Base.roundМетод

round([T,] x, [r::RoundingMode])
round(x, [r::RoundingMode]; digits::Integer=0, base = 10)
round(x, [r::RoundingMode]; sigdigits::Integer, base = 10)

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

Без ключевых аргументов, x округляется до целого значения, возвращая значение типа T, или того же типа, что и x, если не указан 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

Использование данного режима округления является алиасом для 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
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