Документация 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

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

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

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

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

Примеры

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 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
hex2bytes!(dest::AbstractVector{UInt8}, itr)

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

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

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

 
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"

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

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, а затем нажав клавишу TAB в REPL Julia, а также во многих других редакторах.

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

Примеры

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535
ℯ
e

Константа ℯ.

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

См. также описание 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)

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

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

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

См. также описание 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 или все его элементы равными в числовом плане некоторым вещественным числам, включая бесконечности и типы «не число». isreal(x) равно true, если isequal(x, real(x)) равно true.

Примеры

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 1.7

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

Примеры

julia> isodd(9)
true

julia> isodd(10)
false
iseven(x::Number) -> Bool

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

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

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

Примеры

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

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

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

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
precision(num::AbstractFloat; base::Integer=2)
precision(T::Type; base::Integer=2)

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

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

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

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

 
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.

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