数値

標準の数値型

抽象数値型

Core.Number ── 型

Number

任意の数値型を表す抽象上位型です。

Core.Real ── 型

Real <: Number

任意の実数型を表す抽象上位型です。

Core.AbstractFloat ── 型

AbstractFloat <: Real

任意の浮動小数点数型を表す抽象上位型です。

Core.Integer ── 型

Integer <: Real

任意の整数型を表す抽象上位型です。

Core.Signed ── 型

Signed <: Integer

任意の符号付き整数型を表す抽象上位型です。

Core.Unsigned ── 型

Unsigned <: Integer

任意の符号無し整数型を表す抽象上位型です。

Base.AbstractIrrational ── 型

AbstractIrrational <: Real

無理数を正確に表現する数値型を表す抽象上位型です。この型の値と他の数値の算術演算を行うと、この型の値は適切な精度へ自動的に丸められます。

部分型 MyIrrational <: AbstractIrrational が最低でも実装すべきメソッドは次の通りです:

  • ==(::MyIrrational, ::MyIrrational)
  • hash(x::MyIrrational, h::UInt)
  • convert(::Type{F}, x::MyIrrational) where {F <: Union{BigFloat, Float32, Float64}}

AbstractIrrational の部分型が有理数になる可能性がある (例えば √n を表す平方根型では n が完全平方数のとき有理数となる) なら、その型は isinteger, iszero, isone および Real との == も実装するべきです (これらのメソッドの AbstractIrrational に対するデフォルトの実装が false を返すため)。さらに、有理数を表すときはその値の Rational と同じハッシュを返す hash を定義する必要があります。

具象数値型

Core.Float16 ── 型

Float16 <: AbstractFloat

IEEE 754 規格に従う 16 ビットの浮動小数点数型です。

バイナリフォーマット: 符号 1 ビット, 指数 5 ビット, 小数 10 ビット

Core.Float32 ── 型

Float32 <: AbstractFloat

IEEE 754 規格に従う 32 ビットの浮動小数点数型です。

バイナリフォーマット: 符号 1 ビット, 指数 8 ビット, 小数 23 ビット

Core.Float64 ── 型

Float64 <: AbstractFloat

IEEE 754 規格に従う 64 ビットの浮動小数点数型です。

バイナリフォーマット: 符号 1 ビット, 指数 11 ビット, 小数 52 ビット

Base.MPFR.BigFloat ── 型

BigFloat <: AbstractFloat

任意精度の浮動小数点数型です。

Core.Bool ── 型

Bool <: Integer

真偽値型です。truefalse のどちらかを保持します。

Bool は数値の一種です: false は数値的には 0 に等しく、true は数値的に 1 に等しくなります。また、false は乗算において “強いゼロ” (strong zero) として振る舞います:

julia> false == 0
true

julia> true == 1
true

julia> 0 * NaN
NaN

julia> false * NaN
0.0

Core.Int8 ── 型

Int8 <: Signed

8 ビットの符号付き整数型です。

Core.UInt8 ── 型

UInt8 <: Unsigned

8 ビットの符号無し整数です。

Core.Int16 ── 型

Int16 <: Signed

16 ビットの符号付き整数型です。

Core.UInt16 ── 型

UInt16 <: Unsigned

16 ビットの符号無し整数型です。

Core.Int32 ── 型

Int32 <: Signed

32 ビットの符号付き整数型です。

Core.UInt32 ── 型

UInt32 <: Unsigned

32 ビットの符号無し整数型です。

Core.Int64 ── 型

Int64 <: Signed

64 ビットの符号付き整数型です。

Core.UInt64 ── 型

UInt64 <: Unsigned

64 ビットの符号無し整数型です。

Core.Int128 ── 型

Int128 <: Signed

128 ビットの符号付き整数型です。

Core.UInt128 ── 型

UInt128 <: Unsigned

128 ビットの符号無し整数型です。

Base.GMP.BigInt ── 型

BigInt <: Signed

任意精度の整数型です。

Base.Complex ── 型

Complex{T<:Real} <: Number

T 型の実部と虚部を持つ複素数型です。

ComplexF16, ComplexF32, ComplexF64 はそれぞれ Complex{Float16}, Complex{Float32}, Complex{Float64} の別名です。

Base.Rational ── 型

Rational{T<:Integer} <: Real

T 型の分母と分子を持つ有理数型です。有理数型ではオーバーフローのチェックが行われます。

Base.Irrational ── 型

Irrational{sym} <: AbstractIrrational

シンボル sym が表す無理数を正確に表す数値型です。

データフォーマット

Base.digits ── 関数

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

nbase 進法で表したときの各桁を表す、要素型 T の配列を返します。T のデフォルト値は Int で、base のデフォルト値は 10 です。キーワード引数 pad を指定すると、最低でもその桁までゼロ埋めされます。上位の桁が後ろに格納され、n == sum([digits[k]*base^(k-1) for k=1:length(digits)]) が成り立ちます。

julia> digits(10, base = 10)
2-element Array{Int64,1}:
 0
 1

julia> digits(10, base = 2)
4-element Array{Int64,1}:
 0
 1
 0
 1

julia> digits(10, base = 2, pad = 6)
6-element Array{Int64,1}:
 0
 1
 0
 1
 0
 0

Base.digits! ── 関数

digits!(array, n::Integer; base::Integer = 10)

nbase 進法で表したときの各桁で配列を埋めます。上位の桁が配列の後ろに格納されます。配列の長さが足りなければ、下位の桁から配列の長さが足りなくなるまで配列が埋められます。配列が必要より長ければ、桁が存在しない部分はゼロ埋めされます。

julia> digits!([2,2,2,2], 10, base = 2)
4-element Array{Int64,1}:
 0
 1
 0
 1

julia> digits!([2,2,2,2,2,2], 10, base = 2)
6-element Array{Int64,1}:
 0
 1
 0
 1
 0
 0

Base.bitstring ── 関数

bitstring(n)

数値のビット表現を示す文字列を返します。

julia> bitstring(4)
"0000000000000000000000000000000000000000000000000000000000000100"

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

Base.parse ── 関数

parse(type, str; base)

文字列を数値としてパースします。Integer 型に対しては base で底を指定できます (デフォルトの底は 10 です)。浮動小数点数型に対しては、文字列が小数点付きの浮動小数点数としてパースされます。Complex 型を指定すると、"R±Iim" の形をした小数点付きの文字列が指定された型を持つ Complex(R,I) としてパースされます。"im" の部分には "i" または "j" も指定でき、"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

Base.tryparse ── 関数

tryparse(type, str; base)

parse と同様に str が表す type 型の数値を返しますが、str が指定した型の正当な数値を表さないときに nothing を返します。

Base.big ── 関数

big(x)

数値を最大の精度を持つ表現 (通常は BigIntBigFloat) に変換します。浮動小数点数に関する注意点は BigFloat を参照してください。

Base.signed ── 関数

signed(T::Integer)

整数のビット型を同じサイズの符号付き整数型に変換します。

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

整数を符号付き整数に変換します。引数が符号無し整数なら、オーバーフローをチェックせずに符号付き整数に変換します。

Base.unsigned ── 関数

unsigned(T::Integer)

整数のビット型を同じサイズの符号無し型に変換します。

julia> unsigned(Int16)
UInt16
julia> unsigned(UInt64)
UInt64

Base.float ── メソッド

float(x)

数値 x または配列 x の要素を浮動小数点数型に変換します。

Base.Math.significand ── 関数

significand(x)

浮動小数点数 x の仮数部 (マンティッサ) を浮動小数点数として返します。x がゼロでない有限の値なら、返り値は同じ型の \([1,2)\) に含まれる値となります。x がゼロならゼロが返ります。

julia> significand(15.2)/15.2
0.125

julia> significand(15.2)*8
15.2

Base.Math.exponent ── 関数

exponent(x) -> Int

正規化された浮動小数点数の指数部を取得します。

Base.complex ── メソッド

complex(r, [i])

実数 r または実数の配列 r の要素を複素数に変換します。i のデフォルト値は 0 です。

julia> complex(7)
7 + 0im

julia> complex([1, 2, 3])
3-element Array{Complex{Int64},1}:
 1 + 0im
 2 + 0im
 3 + 0im

Base.bswap ── 関数

bswap(n)

n のバイトオーダーを逆転させます。

ネイティブのバイトオーダーとビッグエンディアンのオーダーの間で変換行うときは ntohhton が利用できます。

julia> a = bswap(0x10203040)
0x40302010

julia> bswap(a)
0x10203040

julia> string(1, base = 2)
"1"

julia> string(bswap(1), base = 2)
"100000000000000000000000000000000000000000000000000000000"

Base.hex2bytes ── 関数

hex2bytes(s::Union{AbstractString,AbstractVector{UInt8}})

十六進数列を表す ASCII コードからなる文字列または配列を受け取り、そのバイナリ表現に対応するバイト列を Vector{UInt8} として返します。s に含まれる隣り合う十六進数の一組が返り値のベクトルにおける一バイトを表します。

s の長さは偶数である必要があり、その長さの半分が返り値の配列の長さとなります。インプレースバージョンの hex2bytes! や逆の変換を行う bytes2hex も参照してください。

julia> s = string(12345, base = 16)
"3039"

julia> hex2bytes(s)
2-element Array{UInt8,1}:
 0x30
 0x39

julia> a = b"01abEF"
6-element Base.CodeUnits{UInt8,String}:
 0x30
 0x31
 0x61
 0x62
 0x45
 0x46

julia> hex2bytes(a)
3-element Array{UInt8,1}:
 0x01
 0xab
 0xef

Base.hex2bytes! ── 関数

hex2bytes!(d::AbstractVector{UInt8}, s::Union{String,AbstractVector{UInt8}})

十六進数列を表す ASCII コードからなる文字列または配列を受け取り、それをバイナリ表現に対応するバイト列に変換します。基本的に hex2bytes と同様ですが、出力は d へインプレースに書き込まれます。s の長さは d の長さのちょうど二倍である必要があります。

Base.bytes2hex ── 関数

bytes2hex(a::AbstractArray{UInt8}) -> String
bytes2hex(io::IO, a::AbstractArray{UInt8})

バイトの配列 a を文字列を使った十六進表記に変換します。bytes2hex(a) では String が返り、bytes2hex(io, a) では変換結果の文字列が io に書き込まれます。十六進の文字は全て小文字です。

julia> a = string(12345, base = 16)
"3039"

julia> b = hex2bytes(a)
2-element Array{UInt8,1}:
 0x30
 0x39

julia> bytes2hex(b)
"3039"

一般的な数値関数と定数

Base.one ── 関数

one(x)
one(T::Type)

x に対する乗算の単位元、つまり one(x)*x == x*one(x) == x が成り立つような値を返します。引数に型 T を与えると、T 型の任意の値に対する乗算の単位元が返ります。

可能なら、one(x)x と同じ型の値を返し、one(T)T 型の値を返します。しかし乗算の単位元は次元を持ってはいけないので、次元を持つ量 (例えば日数) を表す型ではこれは不可能です。そのような場合 one(x)x と同じ精度 (行列なら加えて同じ形状) を持つ “単位値” を返します。

x が次元を持つ場合に x と同じ型 (あるいは T 型) の量が必要なら、one ではなく oneunit を使ってください。

julia> one(3.7)
1.0

julia> one(Int)
1

julia> import Dates; one(Dates.Day(1))
1

Base.oneunit ── 関数

oneunit(x::T)
oneunit(T::Type)

T(one(x)) を返します。T は引数の持つ型あるいは引数として与えられた型を表します。この関数は次元を持つ量に対して one と異なる振る舞いをします: one(x) は次元を持たない (乗算の単位元である) のに対して、oneunit(x) は次元を持ちます (x と同じ型あるいは T 型です)。

julia> oneunit(3.7)
1.0

julia> import Dates; oneunit(Dates.Day)
1 day

Base.zero ── 関数

zero(x)
zero(T::Type)

x の型における加算の単位元を返します。x に型自身を指定することもできます。

julia> zero(1)
0

julia> zero(big"2.0")
0.0

julia> zero(rand(2,2))
2×2 Array{Float64,2}:
 0.0  0.0
 0.0  0.0

Base.im ── 定数

im

虚数単位です。

julia> im * im
-1 + 0im

Base.MathConstants.pi ── 定数

π
pi

定数 \(\pi\) です。

julia> pi
π = 3.1415926535897...

Base.MathConstants.ℯ ── 定数

ℯ
e

定数 \(e\) です。

julia> 
 = 2.7182818284590...

Base.MathConstants.catalan ── 定数

catalan

カタランの定数です。

julia> Base.MathConstants.catalan
catalan = 0.9159655941772...

Base.MathConstants.eulergamma ── 定数

γ
eulergamma

オイラーの定数です。

julia> Base.MathConstants.eulergamma
γ = 0.5772156649015...

Base.MathConstants.golden ── 定数

φ
golden

黄金比です。

julia> Base.MathConstants.golden
φ = 1.6180339887498...

Base.Inf ── 定数

Inf, Inf64

Float64 型の正の無限大です。

Base.Inf32 ── 定数

Inf32

Float32 型の正の無限大です。

Base.Inf16 ── 定数

Inf16

Float16 型の正の無限大です。

Base.NaN ── 定数

NaN, NaN64

Float64 型の非数 (not-a-number) です。

Base.NaN32 ── 定数

NaN32

Float32 型の非数 (not-a-number) です。

Base.NaN16 ── 定数

NaN16

Float16 型の非数 (not-a-number) です。

Base.issubnormal ── 関数

issubnormal(f) -> Bool

浮動小数点数が非正規化数かどうかを判定します。

Base.isfinite ── 関数

isfinite(f) -> Bool

数値が有限かどうかを判定します。

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

Base.isinf ── 関数

isinf(f) -> Bool

数値が無限かどうかを判定します。

Base.isnan ── 関数

isnan(f) -> Bool

数値が NaN かどうかを判定します。NaN は無限の値とも有限の値とも決められない数 (非数, not a number) を表します。

Base.iszero ── 関数

iszero(x)

x == zero(x) なら true を返します。x が配列なら、x の全ての要素がゼロかどうかが判定されます。

julia> iszero(0.0)
true

julia> iszero([1, 9, 0])
false

julia> iszero([false, 0, 0])
true

Base.isone ── 関数

isone(x)

x == one(x) なら true を返します。x が配列なら、x が恒等行列かどうかが判定されます。

julia> isone(1.0)
true

julia> isone([1 0; 0 2])
false

julia> isone([1 0; 0 true])
true

Base.nextfloat ── 関数

nextfloat(x::AbstractFloat, n::Integer)

n >= 0 なら xnextfloatn 回適用した結果を返し、n < 0 なら prevfloat-n 回適用した結果を返します。

nextfloat(x::AbstractFloat)

x < y を満たす x と同じ型の浮動小数点数 y の中で最小のものを返します。そのような y が存在しない場合 (例えば xInf あるいは NaN のとき) には x を返します。

Base.prevfloat ── 関数

prevfloat(x::AbstractFloat, n::Integer)

n >= 0 なら xprevfloatn 回適用した結果を返し、n < 0 なら nextfloat-n 回適用した結果を返します。

prevfloat(x::AbstractFloat)

x < y を満たす x と同じ型の浮動小数点数 y の中で最大のものを返します。そのような y が存在しない場合 (例えば x-Inf あるいは NaN のとき) には x を返します。

Base.isinteger ── 関数

isinteger(x) -> Bool

x が数値的に何らかの整数と等しいかどうかを判定します。

julia> isinteger(4.0)
true

Base.isreal ── 関数

isreal(x) -> Bool

x または x の全ての要素が数値的に何らかの実数と等しいかどうかを判定します。ここで “実数” には無限と NaN を含みます。isreal(x)isequal(x, real(x)) のとき true を返します。

julia> isreal(5.)
true

julia> isreal(Inf + 0im)
true

julia> isreal([4.; complex(0,1)])
false

Core.Float32 ── メソッド

Float32(x [, mode::RoundingMode])

x から Float32 を作成します。x を正確に表せないときは mode を丸めモードとした丸めが行われます。

julia> Float32(1/3, RoundDown)
0.3333333f0

julia> Float32(1/3, RoundUp)
0.33333334f0

利用可能な丸めモードについては RoundingMode を参照してください。

Core.Float64 ── メソッド

Float64(x [, mode::RoundingMode])

x から Float64 を作成します。x を正確に表せないときは mode を丸めモードとした丸めが行われます。

julia> Float64(pi, RoundDown)
3.141592653589793

julia> Float64(pi, RoundUp)
3.1415926535897936

利用可能な丸めモードについては RoundingMode を参照してください。

Base.Rounding.rounding ── 関数

rounding(T)

浮動小数点数型 T に対する現在の丸めモードを取得します。この値は基礎算術演算 (+, -, *, /, sqrt) と型変換における丸めモードとして使われます。

利用可能な丸めモードについては RoundingMode を参照してください。

Base.Rounding.setrounding ── メソッド

setrounding(T, mode)

浮動小数点数型 T に対する丸めモードを設定します。この値は基礎算術演算 (+, -, *, /, sqrt) と型変換における丸めモードとして使われます。デフォルトの丸めモード (RoundNearest) を変更すると、基礎算術演算以外の数値関数が不正確あるいは無効な値を返す可能性があります。

現在この関数は T == BigFloat に対してだけサポートされます。

注意

この関数はスレッドセーフではありません。実行すると、実行中の全てのスレッドが影響を受けます。また、設定を利用する処理が一つのスレッドで行われている最中に別のスレッドから設定を並列に変更したときの振る舞いは未定義です。

Base.Rounding.setrounding ── メソッド

setrounding(f::Function, T, mode)

f を実行する間だけ浮動小数点数型 T の丸めモードを変更します。論理的には次のコードと等価です:

old = rounding(T)
setrounding(T, mode)
f()
setrounding(T, old)

利用可能な丸めモードについては RoundingMode を参照してください。

Base.Rounding.get_zero_subnormals ── 関数

get_zero_subnormals() -> Bool

非正規 (subnormal, denormal) な浮動小数点数の絡む演算が IEEE 算術の規則に従うなら false を返し、そうでなくゼロに変換される可能性があるなら true を返します。

注意

この関数は現在のスレッドだけに影響します。

Base.Rounding.set_zero_subnormals ── 関数

set_zero_subnormals(yes::Bool) -> Bool

yesfalse なら、この関数の呼び出し以降に行われる非正規な浮動小数点数の絡む演算が IEEE 算術の規則に従うようになります。そうでなく yestrue なら、浮動小数点数の演算において非正規化数の入力および出力をゼロに変換することが許可されます (ただし必須にはなりません)。正常に設定できれば true を返しますが、yes == true でハードウェアが非正規化数をゼロにする機能をサポートしていなかったときは false を返します。

一部のハードウェアでは set_zero_subnormals(true) とすると高速になりますが、そうすると (x-y==0) == (x==y) といった恒等式は成り立たなくなります。

注意

この関数は現在のスレッドだけに影響します。

整数

Base.count_ones ── 関数

count_ones(x::Integer) -> Integer

x のバイナリ表現に含まれる 1 の個数を返します。

julia> count_ones(7)
3

Base.count_zeros ── 関数

count_zeros(x::Integer) -> Integer

x のバイナリ表現に含まれる 0 の個数を返します。

julia> count_zeros(Int32(2 ^ 16 - 1))
16

Base.leading_zeros ── 関数

leading_zeros(x::Integer) -> Integer

x のバイナリ表現の先頭に含まれる 0 の個数を返します。

julia> leading_zeros(Int32(1))
31

Base.leading_ones ── 関数

leading_ones(x::Integer) -> Integer

x のバイナリ表現の先頭に含まれる 1 の個数を返します。

julia> leading_ones(UInt32(2 ^ 32 - 2))
31

Base.trailing_zeros ── 関数

trailing_zeros(x::Integer) -> Integer

x のバイナリ表現の末尾に含まれる 0 の個数を返します。

julia> trailing_zeros(2)
1

Base.trailing_ones ── 関数

trailing_ones(x::Integer) -> Integer

x のバイナリ表現の末尾に含まれる 1 の個数を返します。

julia> trailing_ones(3)
2

Base.isodd ── 関数

isodd(x::Integer) -> Bool

x が奇数 (2 で割り切れない) なら true を返し、それ以外のとき false を返します。

julia> isodd(9)
true

julia> isodd(10)
false

Base.iseven ── 関数

iseven(x::Integer) -> Bool

x が偶数 (2 で割り切れる) なら true を返し、それ以外のとき false を返します。

julia> iseven(9)
false

julia> iseven(10)
true

[email protected]_str ── マクロ

@int128_str str
@int128_str(str)

文字列 strInt128 としてパースします。str が正当な整数を表さなければ ArgumentError を送出します。

[email protected]_str ── マクロ

@uint128_str str
@uint128_str(str)

文字列 strUInt128 としてパースします。str が正当な整数を表さなければ ArgumentError を送出します。

BigFloatBigInt

BigFloat 型と BigInt 型はそれぞれ任意精度の浮動小数点数と整数の算術を実装します。BigFloat では GNU MPFR が使われ、BigInt では GNU Multiple Precision Arithmetic Library (GMP) が使われます。

Base.MPFR.BigFloat ── メソッド

BigFloat(x::Union{Real, AbstractString}
         [, rounding::RoundingMode=rounding(BigFloat)];
         [precision::Integer=precision(BigFloat)])

x から精度 precision の任意精度浮動小数点数を作成します。引数 rounding には変換が正確に行えないときに丸めるべき方向を指定します。roundingprecision を指定しなければ現在のグローバルの値が使われます。

BigFloat(x::Real)convert(BigFloat,x) と基本的に等価です。ただし x が最初から BigFloat のとき convert(BigFloat,x)x を返すのに対して、BigFloat(x::Real) は現在のグローバルの精度が設定された BigFloat 値を返す点が異なります。

BigFloat(x::AbstractString)parse(x) と等価です。このメソッドが利便性のために提供されているのは、十進のリテラルがパース時に Float64 に変換されてしまうためです。例えば BigFloat(2.1) は意図通りの値を生成しません。

julia> BigFloat(2.1) # この 2.1 は Float64
2.100000000000000088817841970012523233890533447265625

julia> BigFloat("2.1") # 2.1 に最も近い BigFloat
2.099999999999999999999999999999999999999999999999999999999999999999999999999986

julia> BigFloat("2.1", RoundUp)
2.100000000000000000000000000000000000000000000000000000000000000000000000000021

julia> BigFloat("2.1", RoundUp, precision=128)
2.100000000000000000000000000000000000007
Julia 1.1

キーワード引数 precision は Julia 1.1 以降でサポートされます。Julia 1.0 では precision が二つ目の位置引数なので、BigFloat(x, precision) としてください。

参照:

Base.precision ── 関数

precision(num::AbstractFloat)

浮動小数点数の精度を取得します。精度は仮数部の実効ビット数として定義されます。

Base.precision ── メソッド

precision(BigFloat)

現在 BigFloat 型の算術が使用する精度 (ビット数) を取得します。

Base.MPFR.setprecision ── 関数

setprecision([T=BigFloat,] precision::Int)

T 型の算術で使用する精度 (ビット数) を設定します。

注意

この関数はスレッドセーフではありません。実行すると、実行中の全てのスレッドが影響を受けます。また、設定を利用する処理が一つのスレッドで行われている最中に別のスレッドから設定を並列に変更したときの振る舞いは未定義です。

setprecision(f::Function, [T=BigFloat,] precision::Integer)

T 型の算術の精度 (ビット数) を f を実行している間だけ変更します。次のコードと論理的に等価です:

old = precision(BigFloat)
setprecision(BigFloat, precision)
f()
setprecision(BigFloat, old)

通常は setprecision(T, precision) do ... end として使われます。

注意: nextfloat()prevfloat()setprecision が設定した精度を使いません。

Base.GMP.BigInt ── メソッド

BigInt(x)

任意精度整数を作成します。x には Int 型および Int に変換できる任意の型の値を利用できます。この型に対する通常の数学演算子が定義され、結果は BigInt に昇格されます。

parsebig 文字列リテラルを使えば文字列からインスタンスを作成できます。

julia> parse(BigInt, "42")
42

julia> big"313"
313

julia> BigInt(10)^19
10000000000000000000

[email protected]_str ── マクロ

@big_str str
@big_str(str)

文字列をパースして BigInt あるいは BigFloat を作成します。文字列が数値として正当でなければ ArgumentError を送出します。整数では文字列の中に区切り文字として _ を入れて構いません。

julia> big"123_456"
123456

julia> big"7891.5"
7891.5
日本語 Julia 書籍 (Amazon アソシエイト)
1 から始める Julia プログラミング
Julia プログラミングクックブック―言語仕様からデータ分析、機械学習、数値計算まで
スタンフォード ベクトル・行列からはじめる最適化数学