Числовые объекты

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

Ниже показано дерево типов для всех подтипов Number в Base. Помечены абстрактные типы, остальные типы являются конкретными.

Number  (Abstract Type)
├─ Complex
└─ Real  (Abstract Type)
   ├─ AbstractFloat  (Abstract Type)
   │  ├─ Float16
   │  ├─ Float32
   │  ├─ Float64
   │  └─ BigFloat
   ├─ Integer  (Abstract Type)
   │  ├─ Bool
   │  ├─ Signed  (Abstract Type)
   │  │  ├─ Int8
   │  │  ├─ Int16
   │  │  ├─ Int32
   │  │  ├─ Int64
   │  │  ├─ Int128
   │  │  └─ BigInt
   │  └─ Unsigned  (Abstract Type)
   │     ├─ UInt8
   │     ├─ UInt16
   │     ├─ UInt32
   │     ├─ UInt64
   │     └─ UInt128
   ├─ Rational
   └─ AbstractIrrational  (Abstract Type)
      └─ Irrational

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

# Core.Number — Type

Number

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

# Core.Real — Type

Real <: Number

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

# Core.AbstractFloat — Type

AbstractFloat <: Real

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

# Core.Integer — Type

Integer <: Real

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

# Core.Signed — Type

Signed <: Integer

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

# Core.Unsigned — Type

Unsigned <: Integer

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

# Base.AbstractIrrational — Type

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.

Конкретные числовые типы

# Core.Float16 — Type

Float16 <: AbstractFloat

16-разрядный тип числа с плавающей запятой (стандарт IEEE 754).

Двоичный формат: 1 знак, 5 экспонент, 10 дробных бит.

# Core.Float32 — Type

Float32 <: AbstractFloat

32-разрядный тип числа с плавающей запятой (стандарт IEEE 754).

Двоичный формат: 1 знак, 8 экспонент, 23 дробных бита.

# Core.Float64 — Type

Float64 <: AbstractFloat

64-разрядный тип числа с плавающей запятой (стандарт IEEE 754).

Двоичный формат: 1 знак, 11 экспонент, 52 дробных бита.

# Base.MPFR.BigFloat — Type

BigFloat <: AbstractFloat

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

# Core.Bool — Type

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.

# Core.Int8 — Type

Int8 <: Signed

8-разрядный целочисленный тип со знаком.

# Core.UInt8 — Type

UInt8 <: Unsigned

8-разрядный целочисленный тип без знака.

# Core.Int16 — Type

Int16 <: Signed

16-разрядный целочисленный тип со знаком.

# Core.UInt16 — Type

UInt16 <: Unsigned

16-разрядный целочисленный тип без знака.

# Core.Int32 — Type

Int32 <: Signed

32-разрядный целочисленный тип со знаком.

# Core.UInt32 — Type

UInt32 <: Unsigned

32-разрядный целочисленный тип без знака.

# Core.Int64 — Type

Int64 <: Signed

64-разрядный целочисленный тип со знаком.

# Core.UInt64 — Type

UInt64 <: Unsigned

64-разрядный целочисленный тип без знака.

# Core.Int128 — Type

Int128 <: Signed

128-разрядный целочисленный тип со знаком.

# Core.UInt128 — Type

UInt128 <: Unsigned

128-разрядный целочисленный тип без знака.

# Base.GMP.BigInt — Type

BigInt <: Signed

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

# Base.Complex — Type

Complex{T<:Real} <: Number

Тип комплексного числа с действительной и мнимой частью типа T.

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

См. также описание Real, complex, real.

# Base.Rational — Type

Rational{T<:Integer} <: Real

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

# Base.Irrational — Type

Irrational{sym} <: AbstractIrrational

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

См. также описание AbstractIrrational.

Форматы данных

# Base.digits — Function

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

# Base.digits! — Function

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

# Base.bitstring — Function

bitstring(n)

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

См. также описание функций count_ones, count_zeros и digits.

Примеры

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

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

# Base.parse — Method

parse(type, str; base)

Выполняет анализ строки как числа. Для типов Integer можно задать базу (по умолчанию используется значение 10). Для типов с плавающей запятой строка анализируется как десятичное число с плавающей запятой. Типы Complex анализируются из десятичных строк формы "R±Iim" как Complex(R,I) запрашиваемого типа; "i" или "j" также можно использовать вместо "im", а также допускаются "R" или "Iim". Если строка не содержит допустимое число, возникает ошибка.

Совместимость: Julia 1.1

Для parse(Bool, str) требуется версия не ниже Julia 1.1.

Примеры

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.parse — Method

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

Выполняет анализ строкового триплета платформы обратно в объект Platform.

# Base.tryparse — Function

tryparse(type, str; base)

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

# Base.big — Function

big(x)

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

# Base.signed — Function

signed(T::Integer)

Выполняет преобразование целочисленного типа битов до типа со знаком того же размера.

Примеры

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

signed(x)

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

См. также описание unsigned, sign, signbit.

# Base.unsigned — Function

unsigned(T::Integer)

Выполняет преобразование целочисленного типа битов до типа без знака того же размера.

Примеры

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

# Base.float — Method

float(x)

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

См. также описание complex, oftype, convert.

Примеры

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

julia> float(typemax(Int32))
2.147483647e9

# Base.Math.significand — Function

significand(x)

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

# Base.Math.exponent — Function

exponent(x) -> Int

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

Примеры

julia> exponent(8)
3

julia> exponent(64//1)
6

julia> exponent(6.5)
2

julia> exponent(16.0)
4

julia> exponent(3.142e-4)
-12

# Base.complex — Method

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

# Base.bswap — Function

bswap(n)

Выполняет инверсию порядка байтов в n.

(См. также ntoh и hton, где приведены инструкции по преобразованию текущего собственного порядка байтов и порядка «сначала старший байт».)

Примеры

julia> a = bswap(0x10203040)
0x40302010

julia> bswap(a)
0x10203040

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

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

# Base.hex2bytes — Function

hex2bytes(itr)

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

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

Совместимость: Julia 1.7

Для вызова hex2bytes с итераторами, производящими значения UInt8, требуется версия не ниже Julia 1.7. В более ранних версиях можно collect итератор перед вызовом hex2bytes.

Примеры

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

# Base.hex2bytes! — Function

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

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

Совместимость: Julia 1.7

Для вызова hex2bytes! с итераторами, производящими UInt8, требуется версия не ниже 1.7. В более ранних версиях можно вместо этого выбрать итерируемый перед вызовом.

# Base.bytes2hex — Function

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

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

Совместимость: Julia 1.7

Для вызова bytes2hex с произвольными итераторами, производящими значения UInt8, требуется версия не ниже Julia 1.7. В более ранних версиях можно collect итератор перед вызовом bytes2hex.

Примеры

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

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

julia> bytes2hex(b)
"3039"

Общие числовые функции и константы

# Base.one — Function

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

# Base.oneunit — Function

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 — Function

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

# Base.im — Constant

im

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

См. также описание imag, angle, complex.

Примеры

julia> im * im
-1 + 0im

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

# Base.MathConstants.pi — Constant

π
pi

Константа «пи».

Символ Юникод π можно ввести, написав \pi, а затем нажав кнопку TAB в REPL Julia, а также в различных редакторах.

См. также описание sinpi, sincospi, deg2rad.

Примеры

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

# Base.MathConstants.ℯ — Constant

ℯ
e

Константа ℯ.

Символ Юникод ℯ можно ввести, написав \euler, а затем нажав кнопку TAB в REPL Julia, а также в различных редакторах.

См. также описание exp, cis, cispi.

Примеры

julia> ℯ
ℯ = 2.7182818284590...

julia> log(ℯ)
1

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

# Base.MathConstants.catalan — Constant

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

# Base.MathConstants.eulergamma — Constant

γ
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

# Base.MathConstants.golden — Constant

φ
golden

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

Примеры

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

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

# Base.Inf — Constant

Inf, Inf64

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

См. также описание isfinite, typemax, NaN, Inf32.

Примеры

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

# Base.Inf64 — Constant

Inf, Inf64

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

См. также описание isfinite, typemax, NaN, Inf32.

Примеры

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

# Base.Inf32 — Constant

Inf32

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

# Base.Inf16 — Constant

Inf16

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

# Base.NaN — Constant

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)

# Base.NaN64 — Constant

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)

# Base.NaN32 — Constant

NaN32

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

# Base.NaN16 — Constant

NaN16

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

# Base.issubnormal — Function

issubnormal(f) -> Bool

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

Число с плавающей запятой IEEE является поднормальным, когда биты экспоненты равны нулю и его значащее число не равно нулю.

Примеры

julia> floatmin(Float32)
1.1754944f-38

julia> issubnormal(1.0f-37)
false

julia> issubnormal(1.0f-38)
true

# Base.isfinite — Function

isfinite(f) -> Bool

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

Примеры

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

# Base.isinf — Function

isinf(f) -> Bool

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

См. также описание Inf, iszero, isfinite, isnan.

# Base.isnan — Function

isnan(f) -> Bool

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

См. также описание iszero, isone, isinf, ismissing.

# Base.iszero — Function

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

# Base.isone — Function

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 — Function

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.

# Base.prevfloat — Function

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 — Function

isinteger(x) -> Bool

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

Примеры

julia> isinteger(4.0)
true

# Base.isreal — Function

isreal(x) -> Bool

Проверяет, являются ли x или все его элементы равными в числовом плане некоторым действительным числам, включая бесконечности и типы «не число». isreal(x) является верным, если isequal(x, real(x)) является верным.

Примеры

julia> isreal(5.)
true

julia> isreal(1 - 3im)
false

julia> isreal(Inf + 0im)
true

julia> isreal([4.; complex(0,1)])
false

# Core.Float32 — Method

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 — Method

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 — Function

rounding(T)

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

См. RoundingMode, где приведено описание доступных режимов.

# Base.Rounding.setrounding — Method

setrounding(T, mode)

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

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

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

# Base.Rounding.setrounding — Method

setrounding(f::Function, T, mode)

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

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

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

# Base.Rounding.get_zero_subnormals — Function

get_zero_subnormals() -> Bool

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

Эта функция влияет только на текущий поток.

# Base.Rounding.set_zero_subnormals — Function

set_zero_subnormals(yes::Bool) -> Bool

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

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

Эта функция влияет только на текущий поток.

Целые числа

# Base.count_ones — Function

count_ones(x::Integer) -> Integer

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

Примеры

julia> count_ones(7)
3

julia> count_ones(Int32(-1))
32

# Base.count_zeros — Function

count_zeros(x::Integer) -> Integer

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

Примеры

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

julia> count_zeros(-1)
0

# Base.leading_zeros — Function

leading_zeros(x::Integer) -> Integer

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

Примеры

julia> leading_zeros(Int32(1))
31

# Base.leading_ones — Function

leading_ones(x::Integer) -> Integer

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

Примеры

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

# Base.trailing_zeros — Function

trailing_zeros(x::Integer) -> Integer

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

Примеры

julia> trailing_zeros(2)
1

# Base.trailing_ones — Function

trailing_ones(x::Integer) -> Integer

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

Примеры

julia> trailing_ones(3)
2

# Base.isodd — Function

isodd(x::Number) -> Bool

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

Совместимость: Julia 1.7

Для аргументов, отличных от Integer, требуется версия не ниже Julia 1.7.

Примеры

julia> isodd(9)
true

julia> isodd(10)
false

# Base.iseven — Function

iseven(x::Number) -> Bool

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

Совместимость: Julia 1.7

Для аргументов, отличных от Integer, требуется версия не ниже Julia 1.7.

Примеры

julia> iseven(9)
false

julia> iseven(10)
true

# Core.@int128_str — Macro

@int128_str str

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

Примеры

julia> int128"123456789123"
123456789123

julia> int128"123456789123.4"
ERROR: LoadError: ArgumentError: invalid base 10 digit '.' in "123456789123.4"
[...]

# Core.@uint128_str — Macro

@uint128_str str

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

Примеры

julia> uint128"123456789123"
0x00000000000000000000001cbe991a83

julia> uint128"-123456789123"
ERROR: LoadError: ArgumentError: invalid base 10 digit '-' in "-123456789123"
[...]

Числовые типы BigFloats и BigInts

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

# Base.MPFR.BigFloat — Method

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 1.1

Для precision как аргумента ключевого слова требуется версия не ниже Julia 1.1. В Julia 1.0 precision является вторым позиционным аргументом (BigFloat(x, precision)).

Примеры

julia> BigFloat(2.1) # 2.1 здесь является Float64
2.100000000000000088817841970012523233890533447265625

julia> BigFloat("2.1") # самый близкий BigFloat для 2.1
2.099999999999999999999999999999999999999999999999999999999999999999999999999986

julia> BigFloat("2.1", RoundUp)
2.100000000000000000000000000000000000000000000000000000000000000000000000000021

julia> BigFloat("2.1", RoundUp, precision=128)
2.100000000000000000000000000000000000007

# Base.precision — Function

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

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

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

Совместимость: Julia 1.8

Для base ключевого слова требуется версия не ниже Julia 1.8.

# Base.MPFR.setprecision — Function

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

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

Совместимость: Julia 1.8

Для base ключевого слова требуется версия не ниже Julia 1.8.

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.

Совместимость: Julia 1.8

Для base ключевого слова требуется версия не ниже Julia 1.8.

# Base.GMP.BigInt — Method

BigInt(x)

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

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

Примеры

julia> parse(BigInt, "42")
42

julia> big"313"
313

julia> BigInt(10)^19
10000000000000000000

# Core.@big_str — Macro

@big_str str

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

Примеры

julia> big"123_456"
123456

julia> big"7891.5"
7891.5

julia> big"_"
ERROR: ArgumentError: invalid number format _ for BigInt or BigFloat
[...]