Числа

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, даст рациональный результат, когда 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

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} соответственно.

Rational{T<:Integer} <: Real

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

Irrational{sym} <: AbstractIrrational

Числовой тип, представляющий точное иррациональное значение, обозначаемое символом sym.

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)).

Примеры

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

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

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

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)

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

Примеры

julia> bitstring(4)
"0000000000000000000000000000000000000000000000000000000000000100"

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

Преобразует целочисленный битовый тип в беззнаковый тип той же размерности.

Примеры

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

float(x)

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

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).

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(s::Union{AbstractString,AbstractVector{UInt8}})

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

Длина s должна быть чётной, а возвращаемый массив имеет половину длины s. См. также hex2bytes! для варианта с заменой на месте, и 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!(d::AbstractVector{UInt8}, s::Union{String,AbstractVector{UInt8}})

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

bytes2hex(a::AbstractArray{UInt8}) -> String
bytes2hex(io::IO, a::AbstractArray{UInt8})

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

Примеры

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 вместо этого.

Примеры

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 также может указать сам тип).

Примеры

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

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

Примеры

julia> im * im
-1 + 0im

π
pi

Константа пи.

Примеры

julia> pi
π = 3.1415926535897...

ℯ
e

Константа ℯ.

Примеры

julia> ℯ
ℯ = 2.7182818284590...

catalan

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

Примеры

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

γ
eulergamma

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

Примеры

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

φ
golden

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

Примеры

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

Inf, Inf64

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

Inf32

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

Inf16

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

NaN, NaN64

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

NaN32

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

NaN16

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

issubnormal(f) -> Bool

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

isfinite(f) -> Bool

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

Примеры

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

isinf(f) -> Bool

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

isnan(f) -> Bool

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

iszero(x)

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

Примеры

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(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, если операции с субнормальными значениями чисел с плавающей запятой ("denormals") подчиняются правилам IEEE арифметики, и true, если они могут быть преобразованы в нули.

set_zero_subnormals(yes::Bool) -> Bool

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

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

count_ones(x::Integer) -> Integer

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

Примеры

julia> count_ones(7)
3

count_zeros(x::Integer) -> Integer

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

Примеры

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

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::Integer) -> Bool

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

Примеры

julia> isodd(9)
true

julia> isodd(10)
false

iseven(x::Integer) -> 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) может не дать ожидаемого результата.

Примеры

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

См. также

• @big_str
• rounding и setrounding
• precision и setprecision

precision(num::AbstractFloat)

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

precision(BigFloat)

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

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

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

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

Изменение точности арифметики с произвольной точностью (в битах) на период выполнения 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