Числа

Number

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

Real <: Number

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

AbstractFloat <: Real

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

Integer <: Real

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

Signed <: Integer

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

Unsigned <: Integer

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

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

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

Бинарный формат: 1 бит знака, 5 бит экспоненты, 10 бит мантиссы.

Float32 <: AbstractFloat

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

Бинарный формат: 1 бит знака, 8 бит экспоненты, 23 бита мантиссы.

Float64 <: AbstractFloat

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

Бинарный формат: 1 бит знака, 11 бит экспоненты, 52 бита мантиссы.

BigFloat <: AbstractFloat

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

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.

Int8 <: Signed

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

UInt8 <: Unsigned

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

Int16 <: Signed

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

UInt16 <: Unsigned

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

Int32 <: Signed

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

UInt32 <: Unsigned

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

Int64 <: Signed

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

UInt64 <: Unsigned

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

Int128 <: Signed

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

UInt128 <: Unsigned

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

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=1:length(digits)).

См. также ndigits, digits!, и для двоичной системы счисления также 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{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, 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.

Примеры

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

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! для варианта 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 байтов в его шестнадцатеричное строковое представление, либо вернув 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 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

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

Unicode π можно набрать, набрав \pi и нажав Tab в Julia REPL и во многих редакторах.

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

Примеры

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

ℯ
e

Константа ℯ.

Unicode ℯ можно набрать, набрав \euler и нажав Tab в 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), NaN === NaN
(false, true, true)

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)

NaN32

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

NaN16

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

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)

Изменить точность 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
[...]