Numbers

Число

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

Real <: Number

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

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

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

Беззнаковый <: Целое

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

Встроенные беззнаковые целые числа выводятся в шестнадцатеричном формате с префиксом 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

Тип числа с плавающей запятой с двойной точностью (стандарт 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) запрашиваемого типа; вместо "im" также можно использовать "i" или "j", а "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)

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

Примеры

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.

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

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, а затем нажав tab в 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

константа Каталана

# Примеры

jldoctest 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

φ
золотое

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

# Примеры

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

!!! примечание Всегда используйте isnan или isequal для проверки на NaN. Использование x === NaN может дать неожиданные результаты:

```julia-repl
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)

!!! примечание Всегда используйте isnan или isequal для проверки на NaN. Использование x === NaN может дать неожиданные результаты:

```julia-repl
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 здесь это 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

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 цифр в заданной системе счисления.

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

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

!!! предупреждение Использование @big_str для создания значений BigFloat может не привести к поведению, которое можно было бы наивно ожидать: как макрос, @big_str подчиняется глобальной точности (setprecision) и режиму округления (setrounding) так, как они были на время загрузки. Таким образом, функция, такая как () -> precision(big"0.3"), возвращает константу, значение которой зависит от значения точности в момент, когда функция была определена, а не от точности в момент, когда функция вызывается.