Числа

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!, а для системы счисления 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, 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

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

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

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 считается субнормальным, когда биты порядка равны нулю, а мантисса не равна нулю.

Примеры

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

set_zero_subnormals(yes::Bool) -> Bool

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