Числа

Number

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

Real <: Number

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

AbstractFloat <: Real

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

Integer <: Real

Абстрактный супертип для всех целых чисел (например, Signed, Unsigned и Bool).

См. также isinteger, trunc, div.

Примеры

julia> 42 isa Integer
true

julia> 1.0 isa Integer
false

julia> isinteger(1.0)
true

Signed <: Integer

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

Unsigned <: Integer

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

Встроенные целые числа без знака выводятся в шестнадцатеричном формате с префиксом 0x, и их можно вводить аналогичным образом.

Примеры

julia> typemax(UInt8)
0xff

julia> Int(0x00d)
13

julia> unsigned(true)
0x0000000000000001

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

16-битный тип чисел с плавающей точкой (стандарт IEEE 754). Бинарный формат: 1 бит знака, 5 бит экспоненты, 10 бит мантиссы.

Float32 <: AbstractFloat <: Real

32-битный тип чисел с плавающей точкой (стандарт IEEE 754). Бинарный формат: 1 бит знака, 8 бит экспоненты, 23 бита мантиссы.

Экспонента в научной записи должна вводиться строчными буквами f, например 2f3 === 2.0f0 * 10^3 === Float32(2_000). Для литералов массивов и выражений-список, тип элемента можно указать перед квадратными скобками: Float32[1,4,9] == Float32[i^2 for i in 1:3].

См. также Inf32, NaN32, Float16, exponent, frexp.

Float64 <: AbstractFloat <: Real

64-битный тип чисел с плавающей точкой (стандарт IEEE 754). Бинарный формат: 1 бит знака, 11 бит экспоненты, 52 бита мантиссы. См. bitstring, signbit, exponent, frexp и significand для доступа к различным битам.

Это значение по умолчанию для чисел с плавающей точкой, 1.0 isa Float64, и для многих операций, таких как 1/2, 2pi, log(2), range(0,90,length=4). В отличие от целых чисел, это значение по умолчанию не изменяется при Sys.WORD_SIZE.

Экспонента в научной записи может быть введена как e или E, например 2e3 === 2.0E3 === 2.0 * 10^3. Это предпочтительнее 10^n из-за переполнения целых чисел, в отличие от 2.0 * 10^19 < 0, что 2e19 > 0.

См. также Inf, NaN, floatmax, Float32, Complex.

BigFloat <: AbstractFloat

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

Bool <: Integer

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

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

julia> [true, false] == [1, 0]
true

julia> 42.0 + true
43.0

julia> 0 .* (NaN, Inf, -Inf)
(NaN, NaN, NaN)

julia> false .* (NaN, Inf, -Inf)
(0.0, 0.0, -0.0)

Ветвления через if и другие условные операторы принимают только Bool. В Julia нет "истинно"значений.

Сравнения обычно возвращают Bool, а широковещательные сравнения могут возвращать BitArray вместо Array{Bool}.

julia> [1 2 3 4 5] .< pi
1×5 BitMatrix:
 1  1  1  0  0

julia> map(>(pi), [1 2 3 4 5])
1×5 Matrix{Bool}:
 0  0  0  1  1

См. также trues, falses, ifelse.

Int8 <: Signed <: Integer

8-битный тип целых чисел со знаком.

Представляет числа n ∈ -128:127. Обратите внимание, что такие целые числа переполняются без предупреждения, поэтому typemax(Int8) + Int8(1) < 0.

См. также Int, widen, BigInt.

UInt8 <: Unsigned <: Integer

8-битный тип целых чисел без знака.

Выводится в шестнадцатеричном формате, например, 0x07 == 7.

Int16 <: Signed <: Integer

16-битный тип целых чисел со знаком.

Представляет числа n ∈ -32768:32767. Обратите внимание, что такие целые числа переполняются без предупреждения, поэтому typemax(Int16) + Int16(1) < 0.

См. также Int, widen, BigInt.

UInt16 <: Unsigned <: Integer

16-битный тип целых чисел без знака.

Выводится в шестнадцатеричном формате, например, 0x000f == 15.

Int32 <: Signed <: Integer

32-битный целое число со знаком.

Обратите внимание, что такие целые числа переполняются без предупреждения, поэтому typemax(Int32) + Int32(1) < 0.

См. также Int, widen, BigInt.

UInt32 <: Unsigned <: Integer

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

Выводится в шестнадцатеричном формате, поэтому 0x0000001f == 31.

Int64 <: Signed <: Integer

64-битный целое число со знаком.

Обратите внимание, что такие целые числа переполняются без предупреждения, поэтому typemax(Int64) + Int64(1) < 0.

См. также Int, widen, BigInt.

UInt64 <: Unsigned <: Integer

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

Выводится в шестнадцатеричном формате, поэтому 0x000000000000003f == 63.

Int128 <: Signed <: Integer

128-битный целое число со знаком.

Обратите внимание, что такие целые числа переполняются без предупреждения, поэтому typemax(Int128) + Int128(1) < 0.

См. также Int, widen, BigInt.

UInt128 <: Unsigned <: Integer

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

Выводится в шестнадцатеричном формате, поэтому 0x0000000000000000000000000000007f == 127.

Int

Тип целого числа размером Sys.WORD_SIZE бит со знаком, Int <: Signed <: Integer <: Real.

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

Обратите внимание, что целые числа переполняются без предупреждения, поэтому typemax(Int) + 1 < 0 и 10^19 < 0. Переполнение можно избежать, используя BigInt. Очень большие целочисленные литералы будут использовать более широкий тип, например 10_000_000_000_000_000_000 isa Int128.

Целочисленное деление — это div псевдоним ÷, в то время как /, применённый к целым числам, возвращает Float64.

См. также Int64, widen, typemax, bitstring.

UInt

Тип целого числа без знака размером Sys.WORD_SIZE бит, UInt <: Unsigned <: Integer.

Как и Int, псевдоним UInt может указывать на UInt32 или UInt64, в зависимости от значения Sys.WORD_SIZE на данном компьютере.

Выводится и анализируется в шестнадцатеричном формате: UInt(15) === 0x000000000000000f.

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, например, π, ℯ и γ.

См. также AbstractIrrational.

digits([T<:Integer], n::Integer; base::T = 10, pad::Integer = 1)

Возвращает массив с типом элементов T (по умолчанию Int) цифр n в заданной системе счисления, необязательно дополненный нулями до указанного размера. Более значимые цифры находятся в более высоких индексах, так что n == sum(digits[k]*base^(k-1) for k in eachindex(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{SimpleColor}, rgb::String)

Аналог tryparse(SimpleColor, rgb::String) (см.), но при ошибке возвращает ошибку вместо nothing.

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{SimpleColor}, rgb::String)

Попытка разобрать rgb как SimpleColor. Если rgb начинается с # и имеет длину 7, то оно преобразуется в RGBTuple-поддерживаемый SimpleColor. Если rgb начинается с a-z, rgb интерпретируется как имя цвета и преобразуется в Symbol-поддерживаемый SimpleColor.

В противном случае возвращается nothing.

Примеры

julia> tryparse(SimpleColor, "blue")
SimpleColor(blue)

julia> tryparse(SimpleColor, "#9558b2")
SimpleColor(#9558b2)

julia> tryparse(SimpleColor, "#nocolor")

tryparse(type, str; base)

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

big(x)

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

signed(T::Integer)

Преобразовать целое число bitstype в тип со знаком того же размера.

Примеры

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

signed(x)

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

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

unsigned(T::Integer)

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

Примеры

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.

См. также frexp, exponent.

Примеры

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::Real) -> Int

Возвращает наибольшее целое число y такое, что 2^y ≤ abs(x).

Выбрасывает DomainError при x равно нулю, бесконечности или NaN. Для любого другого числа с плавающей точкой, которое не является субнормальным, x, это соответствует битам экспоненты числа x.

См. также signbit, significand, frexp, issubnormal, log2, ldexp.

Примеры

julia> exponent(8)
3

julia> exponent(6.5)
2

julia> exponent(-1//4)
-2

julia> exponent(3.142e-4)
-12

julia> exponent(floatmin(Float32)), exponent(nextfloat(0.0f0))
(-126, -149)

julia> exponent(0.0)
ERROR: DomainError with 0.0:
Cannot be ±0.0.
[...]

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

Длина itr должна быть чётной, и возвращаемый массив имеет половину длины itr. См. также hex2bytes! для варианта in-place и 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

Постоянная пи.

Символ π можно ввести, набрав \pi и нажав клавишу табуляции в интерактивной оболочке Julia REPL и во многих редакторах.

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

Примеры

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

ℯ
e

Постоянная ℯ.

Символ ℯ можно ввести, набрав \euler и нажав клавишу табуляции в интерактивной оболочке 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

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), isnan(NaN)
(false, true, true)

julia> reinterpret(UInt32, NaN32)
0x7fc00000

julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
NaN32

julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
(false, true, true)

NaN, NaN64

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

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

Примеры

julia> 0/0
NaN

julia> Inf - Inf
NaN

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

julia> reinterpret(UInt32, NaN32)
0x7fc00000

julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
NaN32

julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
(false, true, true)

NaN32

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

См. также: NaN.

NaN16

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

См. также: NaN.

issubnormal(f) -> Bool

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

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

Подробнее о субнормальных числах.

Примеры

julia> floatmin(Float32)
1.1754944f-38

julia> issubnormal(1.0f-37)
false

julia> issubnormal(1.0f-38)
true

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(1 - 3im)
false

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

Разбор str как Int128. Выбрасывает ArgumentError если строка не является корректным целым числом.

Примеры

julia> int128"123456789123"
123456789123

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

@uint128_str str

Разбор str как UInt128. Выбрасывает ArgumentError если строка не является корректным целым числом.

Примеры

julia> uint128"123456789123"
0x00000000000000000000001cbe991a83

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

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)

Измените точность арифметических операций (в заданном 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

Распарсить строку в 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
[...]