Числа

Number

Абстрактный супертип для всех числовых типов.

Real <: Number

Абстрактный супертип для всех вещественных чисел.

AbstractFloat <: Real

Абстрактный супертип для всех чисел с плавающей точкой.

Integer <: Real

Абстрактный супертип для всех целых чисел.

Signed <: Integer

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

Unsigned <: Integer

Абстрактный супертип для всех целых чисел без знака.

AbstractIrrational <: Real

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

Подтипы MyIrrational <: AbstractIrrational должны реализовывать по меньшей мере ==(::MyIrrational, ::MyIrrational), hash(x::MyIrrational, h::UInt), и convert(::Type{F}, x::MyIrrational) where {F <: Union{BigFloat,Float32,Float64}}.

Если подтип используется для представления значений, которые могут быть рациональными (например, тип квадратного корня, представляющий √n для целых чисел n, то он должен также реализовывать isinteger, iszero, isone, и == со значениями Real, так как все они по умолчанию имеют false для типов AbstractIrrational, а также определять hash равным значению соответствующего Rational.

Float16 <: AbstractFloat

16-битный тип чисел с плавающей точкой (стандарт IEEE 754).

Бинарный формат: 1 бит знака, 5 бит порядка, 10 бит мантиссы.

Float32 <: AbstractFloat

32-битный тип чисел с плавающей точкой (стандарт IEEE 754).

Бинарный формат: 1 бит знака, 8 бит порядка, 23 бита мантиссы.

Float64 <: AbstractFloat

64-битный тип чисел с плавающей точкой (стандарт IEEE 754).

Бинарный формат: 1 бит знака, 11 бит порядка, 52 бита мантиссы.

BigFloat <: AbstractFloat

Тип чисел с плавающей точкой произвольной точности.

Bool <: Integer

Логический тип, содержащий значения true и false.

Bool является типом числа: false численно равно 0, и true численно равно 1. Кроме того, false действует как мультипликативный "сильный ноль":

julia> false == 0
true

julia> true == 1
true

julia> 0 * NaN
NaN

julia> false * NaN
0.0

См. также: digits, iszero, NaN.

Int8 <: Signed

8-битный цельный тип со знаком.

UInt8 <: Unsigned

8-битный цельный тип без знака.

Int16 <: Signed

16-битный цельный тип со знаком.

UInt16 <: Unsigned

16-битный цельный тип без знака.

Int32 <: Signed

32-битный цельный тип со знаком.

UInt32 <: Unsigned

32-битный цельный тип без знака.

Int64 <: Signed

64-битный цельный тип со знаком.

UInt64 <: Unsigned

64-битный цельный тип без знака.

Int128 <: Signed

128-битный цельный тип со знаком.

UInt128 <: Unsigned

128-битный цельный тип без знака.

BigInt <: Signed

Целый тип произвольной точности.

Complex{T<:Real} <: Number

Тип комплексного числа с вещественной и мнимой частью типа T.

ComplexF16, ComplexF32 и ComplexF64 являются псевдонимами для Complex{Float16}, Complex{Float32} и Complex{Float64} соответственно.

См. также: Real, complex, real.

Rational{T<:Integer} <: Real

Тип рационального числа с числителем и знаменателем типа T. Рациональные числа проверяются на переполнение.

Irrational{sym} <: AbstractIrrational

Тип данных, представляющий точное иррациональное значение, обозначаемое символом sym, например, π, ℯ и γ.

См. также [@irrational], AbstractIrrational.

digits([T<:Integer], n::Integer; base::T = 10, pad::Integer = 1)

Возвращает массив с типом элементов T (по умолчанию Int) цифр числа n в заданной системе счисления, необязательно дополненный нулями до заданного размера. Более значащие цифры находятся в индексах с более высокими значениями, так что n == sum(digits[k]*base^(k-1) for k=1:length(digits)).

См. также ndigits, digits!, а для системы счисления 2 также bitstring, count_ones.

Примеры

julia> digits(10)
2-element Vector{Int64}:
 0
 1

julia> digits(10, base = 2)
4-element Vector{Int64}:
 0
 1
 0
 1

julia> digits(-256, base = 10, pad = 5)
5-element Vector{Int64}:
 -6
 -5
 -2
  0
  0

julia> n = rand(-999:999);

julia> n == evalpoly(13, digits(n, base = 13))
true

digits!(array, n::Integer; base::Integer = 10)

Заполняет массив цифр числа n в заданной системе счисления. Более значащие цифры находятся в индексах с более высокими значениями. Если длина массива недостаточна, наименее значащие цифры заполняются до длины массива. Если длина массива избыточна, избыточная часть заполняется нулями.

Примеры

julia> digits!([2,2,2,2], 10, base = 2)
4-element Vector{Int64}:
 0
 1
 0
 1

julia> digits!([2,2,2,2,2,2], 10, base = 2)
6-element Vector{Int64}:
 0
 1
 0
 1
 0
 0

bitstring(n)

Строка, представляющая буквальное двоичное представление числа.

См. также count_ones, count_zeros, digits.

Примеры

julia> bitstring(Int32(4))
"00000000000000000000000000000100"

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

parse(type, str; base)

Разбор строки как числа. Для типов Integer, можно указать систему счисления (по умолчанию 10). Для чисел с плавающей точкой строка анализируется как десятичное число с плавающей точкой. Типы Complex анализируются из десятичных строк вида "R±Iim" как Complex(R,I) запрошенного типа; "i" или "j" также могут быть использованы вместо "im", и "R" или "Iim" также допустимы. Если строка не содержит допустимого числа, возникает ошибка.

Примеры

julia> parse(Int, "1234")
1234

julia> parse(Int, "1234", base = 5)
194

julia> parse(Int, "afc", base = 16)
2812

julia> parse(Float64, "1.2e-3")
0.0012

julia> parse(Complex{Float64}, "3.2e-1 + 4.5im")
0.32 + 4.5im

parse(::Type{Platform}, triplet::AbstractString)

Анализирует строку платформного триплета обратно в объект Platform.

tryparse(type, str; base)

Подобно parse, но возвращает либо значение запрошенного типа, либо nothing, если строка не содержит допустимого числа.

big(x)

Преобразование числа в представление с максимальной точностью (обычно BigInt или BigFloat). См. BigFloat для получения информации о некоторых подводных камнях с числами с плавающей точкой.

signed(T::Integer)

Преобразование целого типа данных со знаком к соответствующему типу без знака того же размера.

Примеры

julia> signed(UInt16)
Int16
julia> signed(UInt64)
Int64

signed(x)

Преобразование числа в целое число со знаком. Если аргумент является беззнаковым, он интерпретируется как со знаком без проверки на переполнение.

См. также: unsigned, sign, signbit.

unsigned(T::Integer)

Преобразование целого типа данных со знаком к соответствующему типу без знака того же размера.

Примеры

julia> unsigned(Int16)
UInt16
julia> unsigned(UInt64)
UInt64

float(x)

Преобразование числа или массива к типу данных с плавающей точкой.

См. также: complex, oftype, convert.

Примеры

julia> float(1:1000)
1.0:1.0:1000.0

julia> float(typemax(Int32))
2.147483647e9

significand(x)

Извлечение significand(s) (также известная как мантисса) в двоичном представлении числа с плавающей точкой. Если x — ненулевое конечное число, результат будет числом того же типа на интервале $[1,2)$. В противном случае возвращается x.

Примеры

julia> significand(15.2)/15.2
0.125

julia> significand(15.2)*8
15.2

exponent(x::AbstractFloat) -> Int

Получение показателя степени нормализованного числа с плавающей точкой. Возвращает наибольшее целое число y такое, что 2^y ≤ abs(x).

Примеры

julia> exponent(6.5)
2

julia> exponent(16.0)
4

complex(r, [i])

Преобразование вещественных чисел или массивов в комплексные. i по умолчанию равен нулю.

Примеры

julia> complex(7)
7 + 0im

julia> complex([1, 2, 3])
3-element Vector{Complex{Int64}}:
 1 + 0im
 2 + 0im
 3 + 0im

bswap(n)

Инвертирует порядок байтов числа n.

(См. также ntoh и hton для преобразования между текущим порядком байтов и порядком байтов big-endian.)

Примеры

julia> a = bswap(0x10203040)
0x40302010

julia> bswap(a)
0x10203040

julia> string(1, base = 2)
"1"

julia> string(bswap(1), base = 2)
"100000000000000000000000000000000000000000000000000000000"

hex2bytes(itr)

Принимая на вход итерируемый itr ASCII-кодов последовательности шестнадцатеричных цифр, возвращает массив Vector{UInt8} байтов, соответствующих двоичному представлению: каждая пара шестнадцатеричных цифр в itr задаёт значение одного байта в возвращаемом векторе.

Длина itr должна быть чётной, а возвращаемый массив имеет половину длины itr. См. также hex2bytes! для версии in-place и bytes2hex для обратного преобразования.

Примеры

julia> s = string(12345, base = 16)
"3039"

julia> hex2bytes(s)
2-element Vector{UInt8}:
 0x30
 0x39

julia> a = b"01abEF"
6-element Base.CodeUnits{UInt8, String}:
 0x30
 0x31
 0x61
 0x62
 0x45
 0x46

julia> hex2bytes(a)
3-element Vector{UInt8}:
 0x01
 0xab
 0xef

hex2bytes!(dest::AbstractVector{UInt8}, itr)

Преобразовать итерируемый itr байтов, представляющих шестнадцатеричную строку, в её двоичное представление, аналогично hex2bytes, за исключением того, что вывод записывается на место в dest. Длина dest должна быть в два раза меньше длины itr.

bytes2hex(itr) -> String
bytes2hex(io::IO, itr)

Преобразовать итератор itr байтов в его шестнадцатеричное строковое представление, либо вернуть String с помощью bytes2hex(itr), или записать строку в поток io с помощью bytes2hex(io, itr). Все шестнадцатеричные символы – строчные.

Примеры

julia> a = string(12345, base = 16)
"3039"

julia> b = hex2bytes(a)
2-element Vector{UInt8}:
 0x30
 0x39

julia> bytes2hex(b)
"3039"

one(x)
one(T::type)

Возвращает мультипликативную единицу для x: значение, такое что one(x)*x == x*one(x) == x. В качестве альтернативы, one(T) может принимать тип T, в этом случае one возвращает мультипликативную единицу для любого x типа T.

Если возможно, one(x) возвращает значение того же типа, что и x, и one(T) возвращает значение типа T. Однако это может не быть так для типов, представляющих величины с размерностью (например, время в днях), поскольку мультипликативная единица должна быть безразмерной. В этом случае one(x) должна возвращать значение единицы с той же точностью (и формой, для матриц), что и x.

Если вам нужно количество, которое имеет тот же тип, что и x, или тип T, даже если x имеет размерность, используйте oneunit вместо этого.

См. также функцию identity и I в LinearAlgebra для единичной матрицы.

Примеры

julia> one(3.7)
1.0

julia> one(Int)
1

julia> import Dates; one(Dates.Day(1))
1

oneunit(x::T)
oneunit(T::Type)

Возвращает T(one(x)), где T – это либо тип аргумента, либо (если передаётся тип) сам аргумент. Это отличается от one для величин с размерностью: one безразмерна (мультипликативная единица), а oneunit имеет размерность (того же типа, что и x, или типа T).

Примеры

julia> oneunit(3.7)
1.0

julia> import Dates; oneunit(Dates.Day)
1 day

zero(x)
zero(::Type)

Получить аддитивную единицу для типа x (x также может указать сам тип).

См. также iszero, one, oneunit, oftype.

Примеры

julia> zero(1)
0

julia> zero(big"2.0")
0.0

julia> zero(rand(2,2))
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

im

Мнимая единица.

См. также: imag, angle, complex.

Примеры

julia> im * im
-1 + 0im

julia> (2.0 + 3im)^2
-5.0 + 12.0im

π
pi

Постоянная пи.

Unicode π можно ввести, набрав \pi, а затем нажав Tab в REPL Julia и во многих редакторах.

См. также: sinpi, sincospi, deg2rad.

Примеры

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

ℯ
e

Постоянная ℯ.

Unicode ℯ можно ввести, набрав \euler и нажав Tab в REPL Julia, и во многих редакторах.

См. также: exp, cis, cispi.

Примеры

julia> ℯ
ℯ = 2.7182818284590...

julia> log(ℯ)
1

julia> ℯ^(im)π ≈ -1
true

catalan

Постоянная Каталана.

Примеры

julia> Base.MathConstants.catalan
catalan = 0.9159655941772...

julia> sum(log(x)/(1+x^2) for x in 1:0.01:10^6) * 0.01
0.9159466120554123

γ
eulergamma

Постоянная Эйлера.

Примеры

julia> Base.MathConstants.eulergamma
γ = 0.5772156649015...

julia> dx = 10^-6;

julia> sum(-exp(-x) * log(x) for x in dx:dx:100) * dx
0.5772078382499134

φ
golden

Золотое сечение.

Примеры

julia> Base.MathConstants.golden
φ = 1.6180339887498...

julia> (2ans - 1)^2 ≈ 5
true

Inf, Inf64

Положительная бесконечность типа Float64.

См. также: isfinite, typemax, NaN, Inf32.

Примеры

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

Inf32

Положительная бесконечность типа Float32.

Inf16

Положительная бесконечность типа Float16.

NaN, NaN64

Значение «не число» типа Float64.

См. также: isnan, missing, NaN32, Inf.

Примеры

julia> 0/0
NaN

julia> Inf - Inf
NaN

julia> NaN == NaN, isequal(NaN, NaN), NaN === NaN
(false, true, true)

NaN32

Значение «не число» типа Float32.

NaN16

Значение «не число» типа Float16.

issubnormal(f) -> Bool

Проверить, является ли число с плавающей запятой субнормальным.

isfinite(f) -> Bool

Проверить, является ли число конечным.

Примеры

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

isinf(f) -> Bool

Проверить, является ли число бесконечным.

См. также: Inf, iszero, isfinite, isnan.

isnan(f) -> Bool

Проверить, является ли значение числа NaN (не число), неопределённое значение, которое не является ни бесконечностью, ни конечным числом.

См. также: iszero, isone, isinf, ismissing.

iszero(x)

Возвращает true, если x == zero(x); если x является массивом, проверяет, являются ли все элементы x равными нулю.

См. также: isone, isinteger, isfinite, isnan.

Примеры

julia> iszero(0.0)
true

julia> iszero([1, 9, 0])
false

julia> iszero([false, 0, 0])
true

isone(x)

Возвращает true если x == one(x); если x является массивом, проверяет, является ли x единичной матрицей.

Примеры

julia> isone(1.0)
true

julia> isone([1 0; 0 2])
false

julia> isone([1 0; 0 true])
true

nextfloat(x::AbstractFloat, n::Integer)

Результат n итерационных применений nextfloat к x, если n >= 0, или -n применений prevfloat, если n < 0.

nextfloat(x::AbstractFloat)

Возвращает наименьшее число с плавающей точкой y того же типа, что и x, такое, что x < y. Если такого y не существует (например, если x равно Inf или NaN), то возвращает x.

См. также: prevfloat, eps, issubnormal.

prevfloat(x::AbstractFloat, n::Integer)

Результат n итерационных применений prevfloat к x, если n >= 0, или -n применений nextfloat, если n < 0.

prevfloat(x::AbstractFloat)

Возвращает наибольшее число с плавающей точкой y того же типа, что и x, такое, что y < x. Если такого y не существует (например, если x равно -Inf или NaN ), то возвращает x.

isinteger(x) -> Bool

Проверить, является ли x численно равным целому числу.

Примеры

julia> isinteger(4.0)
true

isreal(x) -> Bool

Проверить, является ли x или все его элементы численно равными некоторому действительному числу, включая бесконечности и NaN. isreal(x) истинно, если isequal(x, real(x)) истинно.

Примеры

julia> isreal(5.)
true

julia> isreal(Inf + 0im)
true

julia> isreal([4.; complex(0,1)])
false

Float32(x [, mode::RoundingMode])

Создать Float32 из x. Если x не точно представимо, то mode определяет, как x округляется.

Примеры

julia> Float32(1/3, RoundDown)
0.3333333f0

julia> Float32(1/3, RoundUp)
0.33333334f0

См. RoundingMode для доступных режимов округления.

Float64(x [, mode::RoundingMode])

Создать Float64 из x. Если x не точно представимо, то mode определяет, как x округляется.

Примеры

julia> Float64(pi, RoundDown)
3.141592653589793

julia> Float64(pi, RoundUp)
3.1415926535897936

См. RoundingMode для доступных режимов округления.

rounding(T)

Получить текущий режим округления чисел с плавающей запятой для типа T, управляющий округлением основных арифметических функций (+, -, *, / и sqrt) и преобразованием типов.

См. RoundingMode для доступных режимов.

setrounding(T, mode)

Установить режим округления для типа чисел с плавающей запятой T, управляющий округлением основных арифметических функций (+, -, *, / и sqrt) и преобразованием типов. Другие числовые функции могут давать неверные или недопустимые значения при использовании режимов округления, отличных от стандартного режима RoundNearest.

Обратите внимание, что в настоящее время это поддерживается только для T == BigFloat.

setrounding(f::Function, T, mode)

Изменить режим округления типа чисел с плавающей запятой T на время f. Логически эквивалентно:

old = rounding(T)
setrounding(T, mode)
f()
setrounding(T, old)

См. RoundingMode для доступных режимов округления.

get_zero_subnormals() -> Bool

Возвращает false, если операции с субнормальными числами с плавающей точкой («денормы») подчиняются правилам IEEE-арифметики, и true, если они могут быть преобразованы в нули.

set_zero_subnormals(yes::Bool) -> Bool

Если yes равно false, последующие операции с плавающей точкой следуют правилам IEEE-арифметики для субнормальных значений («денормы»). В противном случае операции с плавающей точкой могут (но не обязаны) преобразовывать субнормальные входные или выходные значения в ноль. Возвращает true, если yes==true, но аппаратное обеспечение не поддерживает обнуление субнормальных чисел.

set_zero_subnormals(true) может ускорить некоторые вычисления на некоторых аппаратных платформах. Однако это может нарушить тождества, такие как (x-y==0) == (x==y).

count_ones(x::Integer) -> Integer

Количество единиц в двоичном представлении x.

Примеры

julia> count_ones(7)
3

julia> count_ones(Int32(-1))
32

count_zeros(x::Integer) -> Integer

Количество нулей в двоичном представлении x.

Примеры

julia> count_zeros(Int32(2 ^ 16 - 1))
16

julia> count_zeros(-1)
0

leading_zeros(x::Integer) -> Integer

Количество нулей, стоящих в начале двоичного представления x.

Примеры

julia> leading_zeros(Int32(1))
31

leading_ones(x::Integer) -> Integer

Количество единиц, стоящих в начале двоичного представления x.

Примеры

julia> leading_ones(UInt32(2 ^ 32 - 2))
31

trailing_zeros(x::Integer) -> Integer

Количество нулей, стоящих в конце двоичного представления x.

Примеры

julia> trailing_zeros(2)
1

trailing_ones(x::Integer) -> Integer

Количество единиц, стоящих в конце двоичного представления x.

Примеры

julia> trailing_ones(3)
2

isodd(x::Number) -> Bool

Возвращает true, если x — нечётное целое число (то есть целое число, не делимое на 2), и false в противном случае.

Примеры

julia> isodd(9)
true

julia> isodd(10)
false

iseven(x::Number) -> Bool

Возвращает true, если x — чётное целое число (то есть целое число, делимое на 2), и false в противном случае.

Примеры

julia> iseven(9)
false

julia> iseven(10)
true

@int128_str str
@int128_str(str)

@int128_str анализирует строку и преобразует её в Int128. Выбрасывает ArgumentError, если строка не является корректным целым числом.

@uint128_str str
@uint128_str(str)

@uint128_str анализирует строку и преобразует её в UInt128. Выбрасывает ArgumentError, если строка не является корректным целым числом.

BigFloat(x::Union{Real, AbstractString} [, rounding::RoundingMode=rounding(BigFloat)]; [precision::Integer=precision(BigFloat)])

Создаёт число с плавающей точкой произвольной точности из x, с точностью precision. Аргумент rounding определяет направление округления результата, если преобразование невозможно выполнить точно. Если не указано, эти значения устанавливаются текущими глобальными значениями.

BigFloat(x::Real) — то же самое, что convert(BigFloat,x), за исключением случая, когда x уже является BigFloat, в этом случае возвращается значение с точностью, установленной текущим глобальным значением; convert всегда вернёт x.

BigFloat(x::AbstractString) идентичен parse. Это предоставлено для удобства, так как десятичные литералы преобразуются в Float64 при разборе, поэтому BigFloat(2.1) может не дать ожидаемого результата.

См. также:

• @big_str
• rounding и setrounding
• precision и setprecision

Примеры

julia> BigFloat(2.1) # 2.1 here is a Float64
2.100000000000000088817841970012523233890533447265625

julia> BigFloat("2.1") # the closest BigFloat to 2.1
2.099999999999999999999999999999999999999999999999999999999999999999999999999986

julia> BigFloat("2.1", RoundUp)
2.100000000000000000000000000000000000000000000000000000000000000000000000000021

julia> BigFloat("2.1", RoundUp, precision=128)
2.100000000000000000000000000000000000007

precision(num::AbstractFloat)

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

precision(BigFloat)

Возвращает точность (в битах), используемую в настоящее время для арифметики с BigFloat.

setprecision([T=BigFloat,] precision::Int)

Устанавливает точность (в битах), используемую для арифметики с T.

setprecision(f::Function, [T=BigFloat,] precision::Integer)

Изменяет точность арифметики T (в битах) на время выполнения f. Логически эквивалентно:

old = precision(BigFloat)
setprecision(BigFloat, precision)
f()
setprecision(BigFloat, old)

Часто используется в виде setprecision(T, precision) do ... end

Примечание: nextfloat(), prevfloat() не используют точность, указанную setprecision.

BigInt(x)

Создаёт целое число произвольной точности. x может быть Int (или чем-либо, что может быть преобразовано в Int). Обычные математические операторы определены для этого типа, и результаты преобразуются в BigInt.

Экземпляры могут быть созданы из строк с помощью parse или с использованием big литералов строк.

Примеры

julia> parse(BigInt, "42")
42

julia> big"313"
313

julia> BigInt(10)^19
10000000000000000000

@big_str str
@big_str(str)

Разбор строки в BigInt или BigFloat и выброс исключения ArgumentError, если строка не является допустимым числом. Для целых чисел _ допускается в строке в качестве разделителя.

Примеры

julia> big"123_456"
123456

julia> big"7891.5"
7891.5