Числа

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

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

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

Булевый тип.

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! для варианта 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

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::IEEEFloat, 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.GMP.BigIntМетод

BigInt(x)

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

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

Примеры

julia> parse(BigInt, "42")
42

julia> big"313"
313

Base.MPFR.BigFloatМетод

BigFloat(x)

Создание числа с плавающей запятой произвольной точности. x может быть Integer, Float64 или BigInt. Обычные математические операторы определены для этого типа, и результаты продвинуты до BigFloat.

Обратите внимание, что, поскольку десятичные литералы преобразуются в числа с плавающей запятой при разборе, BigFloat(2.1) может не давать ожидаемого результата. Вместо этого вы можете предпочесть инициализировать константы из строк с помощью parse, или с использованием литерала строки big.

julia> BigFloat(2.1)
2.100000000000000088817841970012523233890533447265625

julia> big"2.1"
2.099999999999999999999999999999999999999999999999999999999999999999999999999986

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

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

set_zero_subnormals(yes::Bool) -> Bool

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

Base.@int128_strМакрос

@int128_str str
@int128_str(str)

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

Base.@uint128_strМакрос

@uint128_str str
@uint128_str(str)

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

Вещественные числа большой точности

Тип BigFloat реализует арифметику с плавающей точкой произвольной точности с использованием библиотеки GNU MPFR.

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

Base.MPFR.BigFloatМетод

BigFloat(x, prec::Int)

Создать представление x как BigFloat с точностью prec.

Base.MPFR.BigFloatМетод

BigFloat(x, rounding::RoundingMode)

Создать представление x как BigFloat с текущей глобальной точностью и режимом округления rounding.

Base.MPFR.BigFloatМетод

BigFloat(x, prec::Int, rounding::RoundingMode)

Создать представление x как BigFloat с точностью prec и режимом округления rounding.

Base.MPFR.BigFloatМетод

BigFloat(x)

Создать число с плавающей точкой произвольной точности. x может быть Integer, Float64 или BigInt. Обычные математические операторы определены для этого типа, а результаты повышены до BigFloat.

Обратите внимание, что из-за того, что десятичные литералы преобразуются в числа с плавающей точкой при парсинге, BigFloat(2.1) может не дать ожидаемого результата. Вместо этого вы можете инициализировать константы из строк с помощью parse или с помощью литерала строки big.

julia> BigFloat(2.1)
2.100000000000000088817841970012523233890533447265625

julia> big"2.1"
2.099999999999999999999999999999999999999999999999999999999999999999999999999986

BigFloat(x::String)

Создайте представление строки x как BigFloat.

Base.@big_strМакрос

@big_str str
@big_str(str)

@big_str парсит строку в BigInt. Бросает ArgumentError, если строка не является допустимым целым числом. Удаляет все подчеркивания _ из строки.