Числа

Стандартные числовые типы

Абстрактные числовые типы

Core.NumberТип

Number

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

Core.RealТип

Real <: Number

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

Core.AbstractFloatТип

AbstractFloat <: Real

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

Core.IntegerТип

Integer <: Real

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

Core.SignedТип

Signed <: Integer

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

Core.UnsignedТип

Unsigned <: Integer

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

Base.AbstractIrrationalТип

AbstractIrrational <: Real

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

Конкретные числовые типы

Core.Float16Тип

Float16 <: AbstractFloat

Тип числа с плавающей запятой 16 бит.

Core.Float32Тип

Float32 <: AbstractFloat

Тип числа с плавающей запятой 32 бит.

Core.Float64Тип

Float64 <: AbstractFloat

Тип числа с плавающей запятой 64 бит.

Base.MPFR.BigFloatТип

BigFloat <: AbstractFloat

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

Core.BoolТип

Bool <: Integer

Булевый тип, содержащий значения true и false.

Core.Int8Тип

Int8 <: Signed

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

Core.UInt8Тип

UInt8 <: Unsigned

Целый тип без знака 8 бит.

Core.Int16Тип

Int16 <: Signed

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

Core.UInt16Тип

UInt16 <: Unsigned

Целый тип без знака 16 бит.

Core.Int32Тип

Int32 <: Signed

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

Core.UInt32Тип

UInt32 <: Unsigned

Целый тип без знака 32 бит.

Core.Int64Тип

Int64 <: Signed

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

Core.UInt64Тип

UInt64 <: Unsigned

Целый тип без знака 64 бит.

Core.Int128Тип

Int128 <: Signed

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

Core.UInt128Тип

UInt128 <: Unsigned

Целый тип без знака 128 бит.

Base.GMP.BigIntТип

BigInt <: Signed

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

Base.ComplexТип

Complex{T<:Real} <: Number

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

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

Base.RationalТип

Rational{T<:Integer} <: Real

Тип рационального числа, со знаменателем и числителем типа T.

Base.IrrationalТип

Irrational{sym} <: AbstractIrrational

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

Форматы данных

Base.digitsФункция

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

Base.digits!Функция

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

Base.bitstringФункция

bitstring(n)

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

Примеры

julia> bitstring(4)
"0000000000000000000000000000000000000000000000000000000000000100"

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

Base.parseФункция

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

Base.tryparseФункция

tryparse(type, str; base)

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

Base.bigФункция

big(x)

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

Base.signedФункция

signed(x)

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

Base.unsignedФункция

unsigned(x) -> Unsigned

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

Примеры

julia> unsigned(-2)
0xfffffffffffffffe

julia> unsigned(2)
0x0000000000000002

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

Base.floatМетод

float(x)

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

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

significand(x)

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

Примеры

julia> significand(15.2)/15.2
0.125

julia> significand(15.2)*8
15.2

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

exponent(x) -> Int

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

Base.complexМетод

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

Base.bswapФункция

bswap(n)

Обратить порядок байтов n.

Примеры

julia> a = bswap(0x10203040)
0x40302010

julia> bswap(a)
0x10203040

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

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

Base.hex2bytesФункция

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

Base.hex2bytes!Функция

hex2bytes!(d::AbstractVector{UInt8}, s::Union{String,AbstractVector{UInt8}})

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

Base.bytes2hexФункция

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"

Общие функции и константы для чисел

Base.oneФункция

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

Base.oneunitФункция

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

Base.zeroФункция

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

Base.imКонстанта

im

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

Примеры

julia> im * im
-1 + 0im

Base.MathConstants.piКонстанта

π
pi

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

Примеры

julia> pi
π = 3.1415926535897...

Base.MathConstants.ℯКонстанта

ℯ
e

Константа ℯ.

Примеры

julia> ℯ
ℯ = 2.7182818284590...

Base.MathConstants.catalanКонстанта

catalan

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

Примеры

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

Base.MathConstants.eulergammaКонстанта

γ
eulergamma

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

Примеры

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

Base.MathConstants.goldenКонстанта

φ
golden

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

Примеры

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

Base.InfКонстанта

Inf, Inf64

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

Base.Inf32Константа

Inf32

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

Base.Inf16Константа

Inf16

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

Base.NaNКонстанта

NaN, NaN64

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

Base.NaN32Константа

NaN32

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

Base.NaN16Константа

NaN16

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

Base.issubnormalФункция

issubnormal(f) -> Bool

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

Base.isfiniteФункция

isfinite(f) -> Bool

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

Примеры

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

Base.isinfФункция

isinf(f) -> Bool

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

Base.isnanФункция

isnan(f) -> Bool

Проверка, является ли число с плавающей точкой «не числом» (NaN).

Base.iszeroФункция

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

Base.isoneФункция

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

Base.nextfloatФункция

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.

Base.prevfloatФункция

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.

Base.isintegerФункция

isinteger(x) -> Bool

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

Примеры

julia> isinteger(4.0)
true

Base.isrealФункция

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

Core.Float32Метод

Float32(x [, mode::RoundingMode])

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

Примеры

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

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

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

Core.Float64Метод

Float64(x [, mode::RoundingMode])

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

Примеры

julia> Float64(pi, RoundDown)
3.141592653589793

julia> Float64(pi, RoundUp)
3.1415926535897936

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

Base.Rounding.roundingФункция

rounding(T)

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

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

Base.Rounding.setroundingМетод

setrounding(T, mode)

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

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

Base.Rounding.setroundingМетод

setrounding(f::Function, T, mode)

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

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

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

Base.Rounding.get_zero_subnormalsФункция

get_zero_subnormals() -> Bool

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

Base.Rounding.set_zero_subnormalsФункция

set_zero_subnormals(yes::Bool) -> Bool

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

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

Целые числа

Base.count_onesФункция

count_ones(x::Integer) -> Integer

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

Примеры

julia> count_ones(7)
3

Base.count_zerosФункция

count_zeros(x::Integer) -> Integer

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

Примеры

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

Base.leading_zerosФункция

leading_zeros(x::Integer) -> Integer

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

Примеры

julia> leading_zeros(Int32(1))
31

Base.leading_onesФункция

leading_ones(x::Integer) -> Integer

Количество единиц, предшествующих двоичному представлению x.

Примеры

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

Base.trailing_zerosФункция

trailing_zeros(x::Integer) -> Integer

Количество нулей, следующих за двоичным представлением x.

Примеры

julia> trailing_zeros(2)
1

Base.trailing_onesФункция

trailing_ones(x::Integer) -> Integer

Количество единиц, следующих за двоичным представлением x.

Примеры

julia> trailing_ones(3)
2

Base.isoddФункция

isodd(x::Integer) -> Bool

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

Примеры

julia> isodd(9)
true

julia> isodd(10)
false

Base.isevenФункция

iseven(x::Integer) -> Bool

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

Примеры

julia> iseven(9)
false

julia> iseven(10)
true

Core.@int128_strМакрос

@int128_str str
@int128_str(str)

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

Core.@uint128_strМакрос

@uint128_str str
@uint128_str(str)

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

Числа с плавающей точкой большой точности и большие целые числа

Типы BigFloat и BigInt реализуют арифметику с плавающей точкой и целыми числами произвольной точности соответственно. Для BigFloat используется библиотека GNU MPFR, а для BigInt - библиотека GNU Multiple Precision Arithmetic Library (GMP).

Base.MPFR.BigFloatМетод

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

Base.precisionФункция

precision(num::AbstractFloat)

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

Base.precisionМетод

precision(BigFloat)

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

Base.MPFR.setprecisionФункция

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

Base.GMP.BigIntМетод

BigInt(x)

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

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

Примеры

julia> parse(BigInt, "42")
42

julia> big"313"
313

Core.@big_strМакрос

@big_str str
@big_str(str)

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

Примеры

julia> big"123_456"
123456

julia> big"7891.5"
7891.5