數字

子類型 MyIrrational <: AbstractIrrational 應至少實作 ==(::MyIrrational, ::MyIrrational)、hash(x::MyIrrational, h::UInt) 和 convert(::Type{F}, x::MyIrrational) where {F <: Union{BigFloat,Float32,Float64}}。

如果子類型用於表示偶爾可能是有理數的值（例如表示整數 √n 的平方根類型，當 n 是完全平方數時，將給出有理數結果），則它也應實作 isinteger、iszero、isone 和 == 與 Real 值（因為所有這些對於 AbstractIrrational 類型預設為 false），以及定義 hash 等於對應的 Rational。

來源

具體數字類型

Core.Float16 — 類型

Float16 <: AbstractFloat

16 位元浮點數類型（IEEE 754 標準）。

二進制格式：1 個符號、5 個指數、10 個小數位元。

來源

Core.Float32 — 類型

Float32 <: AbstractFloat

32 位元浮點數類型（IEEE 754 標準）。

二進制格式：1 個符號、8 個指數、23 個小數位元。

來源

Core.Float64 — 類型

Float64 <: AbstractFloat

64 位元浮點數類型（IEEE 754 標準）。

二進制格式：1 個符號、11 個指數、52 個小數位元。

來源

Base.MPFR.BigFloat — 類型

BigFloat <: AbstractFloat

任意精度的浮點數類型。

來源

Core.Bool — 類型

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。

來源

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} 的別名。

另請參閱：Real、complex、real。

來源

Base.Rational — 類型

Rational{T<:Integer} <: Real

有理數類型，分子和分母類型為 T。會檢查有理數是否溢位。

來源

Base.Irrational — 類型

Irrational{sym} <: AbstractIrrational

數字類型，表示由符號 sym 表示的精確無理數值，例如 π、ℯ 和 γ。

另請參閱 AbstractIrrational。

來源

資料格式

Base.digits — 函數

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

來源

Base.digits! — 函數

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

來源

Base.bitstring — 函數

bitstring(n)

提供原始類型文字位元表示的字串。

另請參閱 count_ones、count_zeros、digits。

範例

julia> bitstring(Int32(4))
"00000000000000000000000000000100"

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

來源

Base.parse — 函數

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

來源

Base.tryparse — 函數

tryparse(type, str; base)

類似於 parse，但會傳回所要求類型的值，或 nothing（如果字串不包含有效的數字）。

來源

Base.big — 函數

big(x)

將數字轉換為最大精確度表示（通常為 BigInt 或 BigFloat）。請參閱 BigFloat 以取得有關浮點數的一些陷阱資訊。

來源

Base.signed — 函數

signed(T::Integer)

將整數位元類型轉換為相同大小的帶正負號類型。

範例

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

來源

signed(x)

將數字轉換為帶正負號整數。如果參數為無正負號，則會將其重新解釋為帶正負號，而不檢查是否溢位。

另請參閱：unsigned、sign、signbit。

來源

Base.unsigned — 函數

unsigned(T::Integer)

將整數位元類型轉換為相同大小的無正負號類型。

範例

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

來源

Base.float — 方法

float(x)

將數字或陣列轉換為浮點資料類型。

另請參閱：complex、oftype、convert。

範例

julia> float(1:1000)
1.0:1.0:1000.0

julia> float(typemax(Int32))
2.147483647e9

來源

Base.Math.significand — 函數

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)

來源

Base.Math.exponent — 函數

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

來源

Base.complex — 方法

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

來源

Base.bswap — 函數

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"

來源

Base.hex2bytes — 函數

hex2bytes(itr)

給定一個 ASCII 碼的可迭代 itr，用於十六進位數字的序列，傳回一個對應於二進位表示的 Vector{UInt8} 位元組：itr 中每個連續的十六進位數字對應到回傳向量中一個位元組的值。

itr 的長度必須為偶數，回傳的陣列長度為 itr 的一半。另請參閱 hex2bytes! 以取得就地版本，以及 bytes2hex 以取得反函數。

Julia 1.7

使用產生 UInt8 值的迭代器呼叫 hex2bytes 需要 Julia 1.7 或更新版本。在較早的版本中，您可以在呼叫 hex2bytes 之前 collect 迭代器。

範例

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

來源

Base.hex2bytes! — 函數

hex2bytes!(dest::AbstractVector{UInt8}, itr)

將表示十六進制字串的位元組可迭代物件 itr 轉換為其二進制表示形式，類似於 hex2bytes，但輸出會寫入 dest 中。dest 的長度必須是 itr 長度的二分之一。

Julia 1.7

呼叫 hex2bytes! 使用產生 UInt8 的可迭代物件需要版本 1.7。在較早的版本中，您可以在呼叫之前收集可迭代物件。

來源

Base.bytes2hex — 函數

bytes2hex(itr) -> String
bytes2hex(io::IO, itr)

將位元組的可迭代物件 itr 轉換為其十六進制字串表示形式，透過 bytes2hex(itr) 傳回 String 或透過 bytes2hex(io, itr) 將字串寫入 io 串流。十六進制字元都是小寫。

Julia 1.7

呼叫 bytes2hex 使用產生 UInt8 值的任意可迭代物件需要 Julia 1.7 或更新版本。在較早的版本中，您可以在呼叫 bytes2hex 之前 collect 可迭代物件。

範例

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

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

julia> bytes2hex(b)
"3039"

來源

一般數字函數和常數

Base.one — 函數

one(x)
one(T::type)

傳回 x 的乘法單位：一個值，使得 one(x)*x == x*one(x) == x。或者 one(T) 可以接受一個類型 T，這種情況下 one 傳回類型 T 的任何 x 的乘法單位。

如果可能，one(x) 傳回與 x 相同類型的值，而 one(T) 傳回類型為 T 的值。然而，對於表示有量綱的量（例如天數中的時間）的類型來說可能不是這樣，因為乘法單位必須是無量綱的。在這種情況下，one(x) 應該傳回與 x 相同精確度（以及對於矩陣而言，形狀）的單位值。

如果您想要一個與 x 相同類型或類型為 T 的量，即使 x 有量綱，請改用 oneunit。

另請參閱 identity 函數，以及 LinearAlgebra 中的 I，以取得單位矩陣。

範例

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 是無量綱的（乘法單位）而 oneunit 是有量綱的（與 x 類型相同，或類型為 T）。

範例

julia> oneunit(3.7)
1.0

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

來源

Base.zero — 函數

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

來源

Base.im — 常數

im

虛數單位。

另請參閱：imag、angle、complex。

範例

julia> im * im
-1 + 0im

julia> (2.0 + 3im)^2
-5.0 + 12.0im

來源

Base.MathConstants.pi — 常數

π
pi

常數 pi。

Unicode π 可透過在 Julia REPL 中輸入 \pi 然後按 Tab 鍵，以及在許多編輯器中輸入。

另請參閱：sinpi、sincospi、deg2rad。

範例

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

來源

Base.MathConstants.ℯ — 常數

ℯ
e

常數 ℯ。

Unicode ℯ 可透過在 Julia REPL 中輸入 \euler 然後按 Tab 鍵，以及在許多編輯器中輸入。

另請參閱：exp、cis、cispi。

範例

julia> ℯ
ℯ = 2.7182818284590...

julia> log(ℯ)
1

julia> ℯ^(im)π ≈ -1
true

來源

Base.MathConstants.catalan — 常數

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

來源

Base.MathConstants.eulergamma — 常數

γ
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

來源

Base.MathConstants.golden — 常數

φ
golden

黃金比例。

範例

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

julia> (2ans - 1)^2 ≈ 5
true

來源

Base.Inf — 常數

Inf, Inf64

Float64 類型的正無窮大。

另請參閱：isfinite、typemax、NaN、Inf32。

範例

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

來源

Base.Inf64 — 常數

Inf, Inf64

Float64 類型的正無窮大。

另請參閱：isfinite、typemax、NaN、Inf32。

範例

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

來源

Base.Inf32 — 常數

Inf32

Float32 類型的正無窮大。

來源

Base.Inf16 — 常數

Inf16

Float16 類型的正無窮大。

來源

Base.NaN — 常數

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)

來源

Base.NaN64 — 常數

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)

來源

Base.NaN32 — 常數

NaN32

類型為 Float32 的非數字值。

來源

Base.NaN16 — 常數

NaN16

類型為 Float16 的非數字值。

來源

Base.issubnormal — 函數

issubnormal(f) -> Bool

測試浮點數是否為次正規數。

當 IEEE 浮點數的指數位元為零且有效數字不為零時，則該數為次正規數。

範例

julia> floatmin(Float32)
1.1754944f-38

julia> issubnormal(1.0f-37)
false

julia> issubnormal(1.0f-38)
true

來源

Base.isfinite — 函數

isfinite(f) -> Bool

測試數字是否為有限數。

範例

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

來源

Base.isinf — 函數

isinf(f) -> Bool

測試數字是否為無限大。

另請參閱：Inf、iszero、isfinite、isnan。

來源

Base.isnan — 函數

isnan(f) -> Bool

測試數字值是否為 NaN，NaN 是既非無限大也非有限數的不確定值（「非數字」）。

另請參閱：iszero、isone、isinf、ismissing。

來源

Base.iszero — 函數

iszero(x)

如果 x == zero(x)，則傳回 true；如果 x 是陣列，則檢查 x 的所有元素是否都為零。

另請參閱：isone、isinteger、isfinite、isnan。

範例

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，則 nextfloat 對 x 的 n 次迭代應用結果，或如果 n < 0，則 prevfloat 的 -n 次應用。

來源

nextfloat(x::AbstractFloat)

傳回與 x 相同類型的最小浮點數 y，使得 x < y。如果沒有這樣的 y（例如如果 x 是 Inf 或 NaN），則傳回 x。

另請參閱：prevfloat、eps、issubnormal。

來源

Base.prevfloat — 函數

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

如果 n >= 0，則 prevfloat 對 x 的 n 次迭代應用結果，或如果 n < 0，則 nextfloat 的 -n 次應用。

來源

prevfloat(x::AbstractFloat)

傳回與 x 相同類型的最大浮點數 y，使得 y < x。如果沒有這樣的 y（例如如果 x 是 -Inf 或 NaN），則傳回 x。

來源

Base.isinteger — 函數

isinteger(x) -> Bool

測試 x 是否在數值上等於某個整數。

範例

julia> isinteger(4.0)
true

來源

Base.isreal — 函數

isreal(x) -> Bool

測試 x 或其所有元素是否在數值上等於某個實數，包括無窮大和 NaN。如果 isequal(x, real(x)) 為真，則 isreal(x) 為真。

範例

julia> isreal(5.)
true

julia> isreal(1 - 3im)
false

julia> isreal(Inf + 0im)
true

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

來源

Core.Float32 — 方法

Float32(x [, mode::RoundingMode])

從 x 建立一個 Float32。如果 x 無法精確表示，則 mode 會決定 x 如何四捨五入。

範例

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 會決定如何捨入 x。

範例

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)

變更浮點類型 T 的捨入模式，持續時間為 f。邏輯上等同於

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

請參閱 RoundingMode，以取得可用的捨入模式。

來源

Base.Rounding.get_zero_subnormals — 函數

get_zero_subnormals() -> Bool

如果次常浮點值（「次常數」）的運算遵循 IEEE 算術規則，則傳回 false；如果可能轉換為零，則傳回 true。

警告

此函數僅影響目前的執行緒。

來源

Base.Rounding.set_zero_subnormals — 函數

set_zero_subnormals(yes::Bool) -> Bool

如果 yes 為 false，後續浮點運算會遵循次常值（「次常數」）的 IEEE 算術規則。否則，浮點運算可以（但並非必要）將次常輸入或輸出轉換為零。傳回 true，除非 yes==true，但硬體不支援將次常數歸零。

set_zero_subnormals(true) 可以加快某些硬體上的某些運算速度。不過，它可能會破壞身分，例如 (x-y==0) == (x==y)。

警告

此函數僅影響目前的執行緒。

來源

整數

Base.count_ones — 函數

count_ones(x::Integer) -> Integer

x 二進位表示法中 1 的數量。

範例

julia> count_ones(7)
3

julia> count_ones(Int32(-1))
32

來源

Base.count_zeros — 函數

count_zeros(x::Integer) -> Integer

x 二進位表示法中 0 的數量。

範例

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

julia> count_zeros(-1)
0

來源

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 的二進制表示法中尾隨的零的數量。

範例

julia> trailing_zeros(2)
1

來源

Base.trailing_ones — 函數

trailing_ones(x::Integer) -> Integer

x 的二進制表示法中尾隨的 1 的數量。

範例

julia> trailing_ones(3)
2

來源

Base.isodd — 函數

isodd(x::Number) -> Bool

如果 x 是奇整數（即不能被 2 整除的整數），則傳回 true，否則傳回 false。

Julia 1.7

非 Integer 參數需要 Julia 1.7 或更新版本。

範例

julia> isodd(9)
true

julia> isodd(10)
false

來源

Base.iseven — 函數

iseven(x::Number) -> Bool

如果 x 是偶整數（即能被 2 整除的整數），則傳回 true，否則傳回 false。

Julia 1.7

非 Integer 參數需要 Julia 1.7 或更新版本。

範例

julia> iseven(9)
false

julia> iseven(10)
true

來源

Core.@int128_str — 巨集

@int128_str str

將 str 解析為 Int128。如果字串不是有效的整數，則擲回 ArgumentError。

範例

julia> int128"123456789123"
123456789123

julia> int128"123456789123.4"
ERROR: LoadError: ArgumentError: invalid base 10 digit '.' in "123456789123.4"
[...]

來源

Core.@uint128_str — 巨集

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

Base.MPFR.BigFloat — 方法

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 1.1

precision 作為關鍵字參數至少需要 Julia 1.1。在 Julia 1.0 中，precision 是第二個位置參數 (BigFloat(x, precision))。

範例

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

來源

Base.precision — 函式

precision(num::AbstractFloat; base::Integer=2)
precision(T::Type; base::Integer=2)

取得浮點數的精度，其定義為有效數字的位元數，或浮點類型 T 的精度 (如果 T 是可變精度類型，例如 BigFloat，則為其目前的預設值)。

如果指定了 base，則它會傳回該進制中對應的最大有效數字位元數。

Julia 1.8

base 關鍵字至少需要 Julia 1.8。

來源

Base.MPFR.setprecision — 函式

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

設定用於 T 運算的精度（預設為位元）。如果指定了 base，則精度是給定 base 中至少 precision 位元的最小必要精度。

警告

此函數不是執行緒安全的。它會影響所有執行緒上執行的程式碼，但如果與使用設定的運算同時呼叫，其行為未定義。

Julia 1.8

base 關鍵字至少需要 Julia 1.8。

來源

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

在 f 的持續時間內變更 T 運算精度（在給定的 base 中）。它在邏輯上等於

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。

來源

Base.GMP.BigInt — 方法

BigInt(x)

建立一個任意精度的整數。x 可以是 Int（或任何可以轉換為 Int 的東西）。此類型定義了通常的數學運算子，而結果會提升為 BigInt。

可以透過 parse 或使用 big 字串文字，從字串建構實例。

範例

julia> parse(BigInt, "42")
42

julia> big"313"
313

julia> BigInt(10)^19
10000000000000000000

來源

Core.@big_str — 巨集

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

來源

數字

標準數字類型

抽象數字類型

具體數字類型

資料格式

一般數字函數和常數

整數

BigFloats 和 BigInts