Числа

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

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

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, за исключением того, что вывод записывается in-place в 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.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 если строка не является корректным целым числом.

BigFloats и BigInts

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

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.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 Mode rounding.

Base.MPFR.BigFloatМетод

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

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

Base.GMP.BigIntМетод

BigInt(x)

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

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

Примеры

julia> parse(BigInt, "42")
42

julia> big"313"
313

Base.@big_strМакрос

@big_str str
@big_str(str)

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

Примеры

julia> big"123_456"
123456

julia> big"7891.5"
7.8915e+03