Числа

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

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

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. Если такого числа не существует (например, если 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. Если такого числа не существует (например, если 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

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