Числа

Number

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

Real <: Number

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

AbstractFloat <: Real

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

Integer <: Real

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

Signed <: Integer

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

Unsigned <: Integer

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

AbstractIrrational <: Real

Тип числа, представляющий точное иррациональное значение, которое автоматически округляется до правильной точности в арифметических операциях с другими числовыми величинами.

Подтипы MyIrrational <: AbstractIrrational должны реализовывать по крайней мере ==(::MyIrrational, ::MyIrrational), hash(x::MyIrrational, h::UInt), и convert(::Type{F}, x::MyIrrational) where {F <: Union{BigFloat,Float32,Float64}}.

Если подтип используется для представления значений, которые могут время от времени быть рациональными (например, тип квадратного корня, который представляет √n для целых чисел n, даст рациональный результат, когда n является полным квадратом), то он также должен реализовывать isinteger, iszero, isone, и == с значениями Real, (поскольку все эти значения по умолчанию false для типов AbstractIrrational), а также определять hash равным тому же, что и у соответствующего Rational.

Float16 <: AbstractFloat

Тип числа с плавающей точкой 16 бит (стандарт IEEE 754).

Бинарный формат: 1 бит знака, 5 бит экспоненты, 10 бит мантиссы.

Float32 <: AbstractFloat

Тип числа с плавающей точкой 32 бит (стандарт IEEE 754).

Бинарный формат: 1 бит знака, 8 бит экспоненты, 23 бита мантиссы.

Float64 <: AbstractFloat

Тип числа с плавающей точкой 64 бит (стандарт IEEE 754).

Бинарный формат: 1 бит знака, 11 бит экспоненты, 52 бита мантиссы.

BigFloat <: AbstractFloat

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

Bool <: Integer

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

Bool является видом числа: false численно равно 0 и true численно равно 1. Кроме того, false действует как мультипликативное "сильное ноль":

julia> false == 0
true

julia> true == 1
true

julia> 0 * NaN
NaN

julia> false * NaN
0.0

См. также: digits, iszero, NaN.

Int8 <: Signed

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

UInt8 <: Unsigned

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

Int16 <: Signed

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

UInt16 <: Unsigned

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

Int32 <: Signed

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

UInt32 <: Unsigned

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

Int64 <: Signed

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

UInt64 <: Unsigned

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

Int128 <: Signed

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

UInt128 <: Unsigned

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

BigInt <: Signed

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

Complex{T<:Real} <: Number

Тип комплексного числа с вещественной и мнимой частями типа T.

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

См. также: Real, complex, real.

Rational{T<:Integer} <: Real

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

Irrational{sym} <: AbstractIrrational

Тип данных, представляющий точное иррациональное значение, обозначаемое символом sym, например, π, ℯ и γ.

См. также [@irrational], AbstractIrrational.

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

См. также ndigits, digits!, а для системы счисления 2 также bitstring, count_ones.

Примеры

julia> digits(10)
2-element Vector{Int64}:
 0
 1

julia> digits(10, base = 2)
4-element Vector{Int64}:
 0
 1
 0
 1

julia> digits(-256, base = 10, pad = 5)
5-element Vector{Int64}:
 -6
 -5
 -2
  0
  0

julia> n = rand(-999:999);

julia> n == evalpoly(13, digits(n, base = 13))
true

digits!(array, n::Integer; base::Integer = 10)

Заполняет массив цифр n в заданной системе счисления. Более значимые цифры находятся в индексах с большими значениями. Если длина массива недостаточна, наименее значимые цифры заполняются до длины массива. Если длина массива избыточна, избыточная часть заполняется нулями.

Примеры

julia> digits!([2, 2, 2, 2], 10, base = 2)
4-element Vector{Int64}:
 0
 1
 0
 1

julia> digits!([2, 2, 2, 2, 2, 2], 10, base = 2)
6-element Vector{Int64}:
 0
 1
 0
 1
 0
 0

bitstring(n)

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

См. также count_ones, count_zeros, digits.

Примеры

julia> bitstring(Int32(4))
"00000000000000000000000000000100"

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

parse(::Type{Platform}, triplet::AbstractString)

Парсит строковое представление тройки платформы обратно в объект Platform.

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

tryparse(type, str; base)

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

big(x)

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

signed(T::Integer)

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

Примеры

julia> signed(UInt16)
Int16
julia> signed(UInt64)
Int64

signed(x)

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

См. также: unsigned, sign, signbit.

unsigned(T::Integer)

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

Примеры

julia> unsigned(Int16)
UInt16
julia> unsigned(UInt64)
UInt64

float(x)

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

См. также: complex, oftype, convert.

Примеры

julia> float(1:1000)
1.0:1.0:1000.0

julia> float(typemax(Int32))
2.147483647e9

significand(x)

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

Примеры

julia> significand(15.2)
1.9

julia> significand(-15.2)
-1.9

julia> significand(-15.2) * 2^3
-15.2

julia> significand(-Inf), significand(Inf), significand(NaN)
(-Inf, Inf, NaN)

exponent(x::AbstractFloat) -> Int

Получение показателя степени нормализованного числа с плавающей запятой. Возвращает наибольшее целое число y такое, что 2^y ≤ abs(x).

Примеры

julia> exponent(6.5)
2

julia> exponent(16.0)
4

complex(r, [i])

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

Примеры

julia> complex(7)
7 + 0im

julia> complex([1, 2, 3])
3-element Vector{Complex{Int64}}:
 1 + 0im
 2 + 0im
 3 + 0im

bswap(n)

Переворачивает порядок байтов n.

(См. также ntoh и hton для преобразования между текущим порядком байтов и порядком байтов big-endian.)

Примеры

julia> a = bswap(0x10203040)
0x40302010

julia> bswap(a)
0x10203040

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

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

hex2bytes(itr)

Принимая на вход итерируемый itr ASCII-кодов последовательности шестнадцатеричных цифр, возвращает Vector{UInt8} байтов, соответствующих двоичному представлению: каждая пара последовательных шестнадцатеричных цифр в itr задает значение одного байта в возвращаемом векторе.

Длина itr должна быть чётной, и возвращаемый массив имеет половину длины itr. См. также hex2bytes! для версии на месте и bytes2hex для обратного преобразования.

Примеры

julia> s = string(12345, base = 16)
"3039"

julia> hex2bytes(s)
2-element Vector{UInt8}:
 0x30
 0x39

julia> a = b"01abEF"
6-element Base.CodeUnits{UInt8, String}:
 0x30
 0x31
 0x61
 0x62
 0x45
 0x46

julia> hex2bytes(a)
3-element Vector{UInt8}:
 0x01
 0xab
 0xef

hex2bytes!(dest::AbstractVector{UInt8}, itr)

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

bytes2hex(itr) -> String
bytes2hex(io::IO, itr)

Преобразуйте итератор itr байтов в его шестнадцатеричное строковое представление, либо вернув строку через bytes2hex(itr), либо записав строку в поток io через bytes2hex(io, itr). Шестнадцатеричные символы представлены в нижнем регистре.

Примеры

julia> a = string(12345, base = 16)
"3039"

julia> b = hex2bytes(a)
2-element Vector{UInt8}:
 0x30
 0x39

julia> bytes2hex(b)
"3039"

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 вместо этого.

См. также функцию identity и I в LinearAlgebra для единичной матрицы.

Примеры

julia> one(3.7)
1.0

julia> one(Int)
1

julia> import Dates; one(Dates.Day(1))
1

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

zero(x)
zero(::Type)

Получение аддитивной единицы для типа x (x также может указать сам тип).

См. также iszero, one, oneunit, oftype.

Примеры

julia> zero(1)
0

julia> zero(big"2.0")
0.0

julia> zero(rand(2,2))
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

im

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

См. также: imag, angle, complex.

Примеры

julia> im * im
-1 + 0im

julia> (2.0 + 3im)^2
-5.0 + 12.0im

π
pi

Константа π.

Символ Unicode π можно ввести, набрав \pi и нажав Tab в Julia REPL и во многих редакторах.

См. также: sinpi, sincospi, deg2rad.

Примеры

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

ℯ
e

Константа ℯ.

Символ Unicode ℯ можно ввести, набрав \euler и нажав Tab в Julia REPL и во многих редакторах.

См. также: exp, cis, cispi.

Примеры

julia> ℯ
ℯ = 2.7182818284590...

julia> log(ℯ)
1

julia> ℯ^(im)π ≈ -1
true

catalan

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

Примеры

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

julia> sum(log(x)/(1+x^2) for x in 1:0.01:10^6) * 0.01
0.9159466120554123

γ
eulergamma

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

Примеры

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

julia> dx = 10^-6;

julia> sum(-exp(-x) * log(x) for x in dx:dx:100) * dx
0.5772078382499133

φ
golden

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

Примеры

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

julia> (2ans - 1)^2 ≈ 5
true

Inf, Inf64

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

См. также: isfinite, typemax, NaN, Inf32.

Примеры

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

Inf32

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

Inf16

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

NaN, NaN64

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

См. также: isnan, missing, NaN32, Inf.

Примеры

julia> 0/0
NaN

julia> Inf - Inf
NaN

julia> NaN == NaN, isequal(NaN, NaN), NaN === NaN
(false, true, true)

NaN32

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

NaN16

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

issubnormal(f) -> Bool

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

isfinite(f) -> Bool

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

Примеры

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

isinf(f) -> Bool

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

См. также: Inf, iszero, isfinite, isnan.

isnan(f) -> Bool

Проверить, является ли значение числа NaN (не число), неопределённым значением, которое не является ни бесконечностью, ни конечным числом.

См. также: iszero, isone, isinf, ismissing.

iszero(x)

Возвращает true, если x == zero(x); если x — массив, это проверяет, являются ли все элементы x нулём.

См. также: isone, isinteger, isfinite, isnan.

Примеры

julia> iszero(0.0)
true

julia> iszero([1, 9, 0])
false

julia> iszero([false, 0, 0])
true

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

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.

См. также: prevfloat, eps, issubnormal.

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.

isinteger(x) -> Bool

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

Примеры

julia> isinteger(4.0)
true

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

Float32(x [, mode::RoundingMode])

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

Примеры

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

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

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

Float64(x [, mode::RoundingMode])

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

Примеры

julia> Float64(pi, RoundDown)
3.141592653589793

julia> Float64(pi, RoundUp)
3.1415926535897936

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

rounding(T)

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

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

setrounding(T, mode)

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

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

setrounding(f::Function, T, mode)

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

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

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

get_zero_subnormals() -> Bool

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

set_zero_subnormals(yes::Bool) -> Bool

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

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

count_ones(x::Integer) -> Integer

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

Примеры

julia> count_ones(7)
3

julia> count_ones(Int32(-1))
32

count_zeros(x::Integer) -> Integer

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

Примеры

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

julia> count_zeros(-1)
0

leading_zeros(x::Integer) -> Integer

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

Примеры

julia> leading_zeros(Int32(1))
31

leading_ones(x::Integer) -> Integer

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

Примеры

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

trailing_zeros(x::Integer) -> Integer

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

Примеры

julia> trailing_zeros(2)
1

trailing_ones(x::Integer) -> Integer

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

Примеры

julia> trailing_ones(3)
2

isodd(x::Number) -> Bool

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

Примеры

julia> isodd(9)
true

julia> isodd(10)
false

iseven(x::Number) -> Bool

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

Примеры

julia> iseven(9)
false

julia> iseven(10)
true

@int128_str str
@int128_str(str)

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

@uint128_str str
@uint128_str(str)

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

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) может не давать ожидаемого результата.

См. также:

• @big_str
• rounding и setrounding
• precision и setprecision

Примеры

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

precision(num::AbstractFloat; base::Integer=2)
precision(T::Type; base::Integer=2)

Возвращает точность числа с плавающей запятой, определённую эффективным количеством битов в мантиссе, или точность типа числа с плавающей запятой T (его текущее значение по умолчанию, если T — тип с переменной точностью, например BigFloat).

Если base указан, то возвращается максимальное соответствующее количество значащих цифр в этой системе счисления.

setprecision([T=BigFloat,] precision::Int; base=2)

Устанавливает точность (в битах по умолчанию) для операций с T арифметики. Если base указан, то точность — минимальная, необходимая для обеспечения по крайней мере precision цифр в указанной base.

setprecision(f::Function, [T=BigFloat,] precision::Integer; base=2)

Изменяет точность арифметики T (в указанной base) на время f. Логически эквивалентно:

old = precision(BigFloat)
setprecision(BigFloat, precision)
f()
setprecision(BigFloat, old)

Часто используется как setprecision(T, precision) do ... end

Примечание: nextfloat(), prevfloat() не используют точность, упомянутую в setprecision.

BigInt(x)

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

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

Примеры

julia> parse(BigInt, "42")
42

julia> big"313"
313

julia> BigInt(10)^19
10000000000000000000

@big_str str
@big_str(str)

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

Примеры

julia> big"123_456"
123456

julia> big"7891.5"
7891.5