Числа

Number

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

Real <: Number

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

AbstractFloat <: Real

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

Integer <: Real

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

Signed <: Integer

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

Unsigned <: Integer

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

AbstractIrrational <: Real

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

Float16 <: AbstractFloat

Тип чисел с плавающей точкой 16-битной точности.

Float32 <: AbstractFloat

Тип чисел с плавающей точкой 32-битной точности.

Float64 <: AbstractFloat

Тип чисел с плавающей точкой 64-битной точности.

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

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

unsigned(x) -> Unsigned

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

Примеры

julia> unsigned(-2)
0xfffffffffffffffe

julia> unsigned(2)
0x0000000000000002

julia> signed(unsigned(-2))
-2

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-кодов последовательности шестнадцатеричных цифр, возвращает Vector{UInt8} байтов, соответствующих двоичному представлению: каждая последующая пара шестнадцатеричных цифр в 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. Если такого 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 если операции над поднормальными значениями чисел с плавающей запятой ("денормали") подчиняются правилам 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

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

@big_str str
@big_str(str)

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

Примеры

julia> big"123_456"
123456

julia> big"7891.5"
7891.5