Числа

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 Array{Int64,1}:
 0
 1

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

julia> digits(10, base = 2, pad = 6)
6-element Array{Int64,1}:
 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 Array{Int64,1}:
 0
 1
 0
 1

julia> digits!([2,2,2,2,2,2], 10, base = 2)
6-element Array{Int64,1}:
 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

tryparse(type, str; base)

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

big(x)

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

signed(T::Integer)

Преобразовать целое число с типом bitstype в число со знаком того же размера.

Примеры

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

signed(x)

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

unsigned(T::Integer)

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

Примеры

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

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

complex(r, [i])

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

Примеры

julia> complex(7)
7 + 0im

julia> complex([1, 2, 3])
3-element Array{Complex{Int64},1}:
 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-кодов последовательности шестнадцатеричных цифр возвращает массив байтов, соответствующий двоичному представлению: каждая пара смежных шестнадцатеричных цифр в s даёт значение одного байта в результирующем векторе.

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

Примеры

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

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

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

julia> hex2bytes(a)
3-element Array{UInt8,1}:
 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 Array{UInt8,1}:
 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)

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

Примеры

julia> zero(1)
0

julia> zero(big"2.0")
0.0

julia> zero(rand(2,2))
2×2 Array{Float64,2}:
 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. Если такое число не существует (например, если 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. Если такое число не существует (например, если x равно -Inf или NaN ), то возвращается x.

isinteger(x) -> Bool

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

Примеры

julia> isinteger(4.0)
true

isreal(x) -> Bool

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

Примеры

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)

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