Числа

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

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

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

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, если строка не является корректным целым числом.

BigFloats и BigInts

Типы 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

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