Документация Engee

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

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

Ниже показано дерево типов для всех подтипов 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.NumberType

Number

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

# Core.RealType

Real <: Number

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

# Core.AbstractFloatType

AbstractFloat <: Real

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

# Core.IntegerType

Integer <: Real

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

# Core.SignedType

Signed <: Integer

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

# Core.UnsignedType

Unsigned <: Integer

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

# Base.AbstractIrrationalType

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

Float16 <: AbstractFloat

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

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

# Core.Float32Type

Float32 <: AbstractFloat

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

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

# Core.Float64Type

Float64 <: AbstractFloat

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

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

# Base.MPFR.BigFloatType

BigFloat <: AbstractFloat

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

# Core.BoolType

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

Int8 <: Signed

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

# Core.UInt8Type

UInt8 <: Unsigned

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

# Core.Int16Type

Int16 <: Signed

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

# Core.UInt16Type

UInt16 <: Unsigned

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

# Core.Int32Type

Int32 <: Signed

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

# Core.UInt32Type

UInt32 <: Unsigned

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

# Core.Int64Type

Int64 <: Signed

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

# Core.UInt64Type

UInt64 <: Unsigned

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

# Core.Int128Type

Int128 <: Signed

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

# Core.UInt128Type

UInt128 <: Unsigned

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

# Base.GMP.BigIntType

BigInt <: Signed

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

# Base.ComplexType

Complex{T<:Real} <: Number

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

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

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

# Base.RationalType

Rational{T<:Integer} <: Real

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

# Base.IrrationalType

Irrational{sym} <: AbstractIrrational

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

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

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

# Base.digitsFunction

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

bitstring(n)

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

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

Примеры

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

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

# Base.parseMethod

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

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

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

# Base.tryparseFunction

tryparse(type, str; base)

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

# Base.bigFunction

big(x)

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

# Base.signedFunction

signed(T::Integer)

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

Примеры

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

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

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

# Base.unsignedFunction

unsigned(T::Integer)

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

Примеры

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

# Base.floatMethod

float(x)

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

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

Примеры

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

julia> float(typemax(Int32))
2.147483647e9

# Base.Math.significandFunction

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

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

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

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

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

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

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

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

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

im

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

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

Примеры

julia> im * im
-1 + 0im

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

# Base.MathConstants.piConstant

π
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.catalanConstant

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

γ
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.goldenConstant

φ
golden

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

Примеры

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

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

# Base.InfConstant

Inf, Inf64

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

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

Примеры

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

# Base.Inf64Constant

Inf, Inf64

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

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

Примеры

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

# Base.Inf32Constant

Inf32

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

# Base.Inf16Constant

Inf16

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

# Base.NaNConstant

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

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

NaN32

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

# Base.NaN16Constant

NaN16

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

# Base.issubnormalFunction

issubnormal(f) -> Bool

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

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

Примеры

julia> floatmin(Float32)
1.1754944f-38

julia> issubnormal(1.0f-37)
false

julia> issubnormal(1.0f-38)
true

# Base.isfiniteFunction

isfinite(f) -> Bool

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

Примеры

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

# Base.isinfFunction

isinf(f) -> Bool

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

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

# Base.isnanFunction

isnan(f) -> Bool

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

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

# Base.iszeroFunction

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

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

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

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

isinteger(x) -> Bool

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

Примеры

julia> isinteger(4.0)
true

# Base.isrealFunction

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

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

Float64(x [, mode::RoundingMode])

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

Примеры

julia> Float64(pi, RoundDown)
3.141592653589793

julia> Float64(pi, RoundUp)
3.1415926535897936

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

# Base.Rounding.roundingFunction

rounding(T)

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

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

# Base.Rounding.setroundingMethod

setrounding(T, mode)

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

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

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

# Base.Rounding.setroundingMethod

setrounding(f::Function, T, mode)

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

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

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

# Base.Rounding.get_zero_subnormalsFunction

get_zero_subnormals() -> Bool

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

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

# Base.Rounding.set_zero_subnormalsFunction

set_zero_subnormals(yes::Bool) -> Bool

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

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

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

Целые числа

# Base.count_onesFunction

count_ones(x::Integer) -> Integer

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

Примеры

julia> count_ones(7)
3

julia> count_ones(Int32(-1))
32

# Base.count_zerosFunction

count_zeros(x::Integer) -> Integer

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

Примеры

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

julia> count_zeros(-1)
0

# Base.leading_zerosFunction

leading_zeros(x::Integer) -> Integer

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

Примеры

julia> leading_zeros(Int32(1))
31

# Base.leading_onesFunction

leading_ones(x::Integer) -> Integer

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

Примеры

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

# Base.trailing_zerosFunction

trailing_zeros(x::Integer) -> Integer

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

Примеры

julia> trailing_zeros(2)
1

# Base.trailing_onesFunction

trailing_ones(x::Integer) -> Integer

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

Примеры

julia> trailing_ones(3)
2

# Base.isoddFunction

isodd(x::Number) -> Bool

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

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

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

Примеры

julia> isodd(9)
true

julia> isodd(10)
false

# Base.isevenFunction

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_strMacro

@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_strMacro

@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.BigFloatMethod

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

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

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

BigInt(x)

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

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

Примеры

julia> parse(BigInt, "42")
42

julia> big"313"
313

julia> BigInt(10)^19
10000000000000000000

# Core.@big_strMacro

@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
[...]