數學

-(x)

一元減號運算子。

另請參閱：abs、flipsign。

範例

julia> -1
-1

julia> -(2)
-2

julia> -[1 2; 3 4]
2×2 Matrix{Int64}:
 -1  -2
 -3  -4

dt::Date + t::Time -> DateTime

Date 與 Time 相加會產生 DateTime。Time 的小時、分鐘、秒和毫秒部分會與 Date 的年、月和日一起使用以建立新的 DateTime。Time 型別中非零的微秒或奈秒將導致擲出 InexactError。

+(x, y...)

加法運算子。x+y+z+... 會使用所有引數呼叫此函式，亦即 +(x, y, z, ...)。

範例

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

-(x, y)

減法運算子。

範例

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

*(x, y...)

乘法運算子。x*y*z*... 會呼叫這個函式並傳入所有參數，也就是 *(x, y, z, ...)。

範例

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

/(x, y)

右除運算子：將 x 乘以 y 右側的倒數。對於整數參數，會傳回浮點數結果。

範例

julia> 1/2
0.5

julia> 4/2
2.0

julia> 4.5/2
2.25

A / B

矩陣右除：A / B 等於 (B' \ A')'，其中 \ 是左除運算子。對於方陣，結果 X 會符合 A == X*B。

另請參閱：rdiv!。

範例

julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

julia> X = A / B
2×3 Matrix{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

julia> isapprox(A, X*B)
true

julia> isapprox(X, A*pinv(B))
true

\(x, y)

左除運算子：將 y 乘以 x 左側的倒數。對於整數參數，會傳回浮點數結果。

範例

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

julia> A = [4 3; 2 1]; x = [5, 6];

julia> A \ x
2-element Vector{Float64}:
  6.5
 -7.0

julia> inv(A) * x
2-element Vector{Float64}:
  6.5
 -7.0

^(x, y)

指數運算子。如果 x 是矩陣，則會計算矩陣指數。

如果 y 是 Int 文字（例如 x^2 中的 2 或 x^-3 中的 -3），則 Julia 程式碼 x^y 會由編譯器轉換為 Base.literal_pow(^, x, Val(y))，以針對指數值進行編譯時間特化。（作為預設後備，我們有 Base.literal_pow(^, x, Val(y)) = ^(x,y)，其中通常 ^ == Base.^，除非在呼叫命名空間中已定義 ^。）如果 y 是負整數文字，則 Base.literal_pow 會預設將運算轉換為 inv(x)^-y，其中 -y 為正數。

範例

julia> 3^5
243

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> A^3
2×2 Matrix{Int64}:
 37   54
 81  118

fma(x, y, z)

計算 x*y+z，而不捨入中間結果 x*y。在某些系統上，這比 x*y+z 昂貴得多。fma 用於提高某些演算法的準確度。請參閱 muladd。

muladd(x, y, z)

組合乘加：計算 x*y+z，但允許加法和乘法彼此合併或與周圍運算合併以提升效能。例如，如果硬體有效支援，這可能會實作為 fma。結果可能因機器而異，也可能因常數傳遞或其他最佳化而導致在同一台機器上有所不同。請參閱 fma。

範例

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

muladd(A, y, z)

組合乘加，A*y .+ z，用於矩陣-矩陣或矩陣-向量乘法。結果始終與 A*y 相同大小，但 z 可能較小或為純量。

範例

julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; z=[0, 100];

julia> muladd(A, B, z)
2×2 Matrix{Float64}:
   3.0    3.0
 107.0  107.0

inv(x)

傳回 x 的乘法反元素，使得 x*inv(x) 或 inv(x)*x 產生 one(x)（乘法單位）至捨入誤差。

如果 x 是數字，這基本上與 one(x)/x 相同，但對於某些類型，inv(x) 可能略為更有效率。

範例

julia> inv(2)
0.5

julia> inv(1 + 2im)
0.2 - 0.4im

julia> inv(1 + 2im) * (1 + 2im)
1.0 + 0.0im

julia> inv(2//3)
3//2

div(x, y)
÷(x, y)

歐幾里德（整數）除法的商數。通常等於沒有小數部分的數學運算 x/y。

另請參閱：cld、fld、rem、divrem。

範例

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

julia> 5.0 ÷ 2
2.0

julia> div.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -1  -1  -1  0  0  0  0  0  1  1  1

fld(x, y)

小於或等於 x / y 的最大整數。等於 div(x, y, RoundDown)。

另請參閱 div、cld、fld1。

範例

julia> fld(7.3, 5.5)
1.0

julia> fld.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -2  -2  -1  -1  -1  0  0  0  1  1  1

由於 fld(x, y) 根據浮點數的真實值實作嚴格正確的向下取整，因此可能會出現直覺上不符合預期的狀況。例如

julia> fld(6.0, 0.1)
59.0
julia> 6.0 / 0.1
60.0
julia> 6.0 / big(0.1)
59.99999999999999666933092612453056361837965690217069245739573412231113406246995

這裡發生的情況是，寫成 0.1 的浮點數的真實值略大於數值 1/10，而 6.0 精確地表示數字 6。因此，6.0 / 0.1 的真實值略小於 60。在進行除法時，這會被取整為精確的 60.0，但 fld(6.0, 0.1) 始終取真實值的向下取整，因此結果為 59.0。

cld(x, y)

大於或等於 x / y 的最小整數。等於 div(x, y, RoundUp)。

另請參閱 div、fld。

範例

julia> cld(5.5, 2.2)
3.0

julia> cld.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -1  -1  -1  0  0  0  1  1  1  2  2

mod(x::Integer, r::AbstractUnitRange)

在範圍 r 中找出 y，使得 $x ≡ y (mod n)$，其中 n = length(r)，亦即 y = mod(x - first(r), n) + first(r)。

另請參閱 mod1。

範例

julia> mod(0, Base.OneTo(3))  # mod1(0, 3)
3

julia> mod(3, 0:2)  # mod(3, 3)
0

mod(x, y)
rem(x, y, RoundDown)

將 x 除以 y 的餘數，或等價地，將 x 除以 y 後取整數部分的餘數，即 x - y*fld(x,y)，如果在計算時不進行中間捨入。

結果將與 y 符號相同，且大小小於 abs(y)（有一些例外，請參閱以下註解）。

另請參閱：rem、div、fld、mod1、invmod。

julia> mod(8, 3)
2

julia> mod(9, 3)
0

julia> mod(8.9, 3)
2.9000000000000004

julia> mod(eps(), 3)
2.220446049250313e-16

julia> mod(-eps(), 3)
3.0

julia> mod.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 1  2  0  1  2  0  1  2  0  1  2

rem(x::Integer, T::Type{<:Integer}) -> T
mod(x::Integer, T::Type{<:Integer}) -> T
%(x::Integer, T::Type{<:Integer}) -> T

尋找 y::T 使得 x ≡ y (mod n)，其中 n 是 T 中可表示的整數數量，而 y 是 [typemin(T),typemax(T)] 中的整數。如果 T 可以表示任何整數（例如 T == BigInt），則此操作對應於轉換為 T。

範例

julia> x = 129 % Int8
-127

julia> typeof(x)
Int8

julia> x = 129 % BigInt
129

julia> typeof(x)
BigInt

rem(x, y)
%(x, y)

歐幾里得除法的餘數，傳回與 x 符號相同的數值，且大小小於 y。此值始終精確。

另請參閱：div、mod、mod1、divrem。

範例

julia> x = 15; y = 4;

julia> x % y
3

julia> x == div(x, y) * y + rem(x, y)
true

julia> rem.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -2  -1  0  -2  -1  0  1  2  0  1  2

rem2pi(x, r::RoundingMode)

計算整數除法後 x 的餘數，商數根據捨入模式 r 捨入。換句話說，數量

x - 2π*round(x/(2π),r)

沒有任何中間捨入。這在內部使用 2π 的高精度近似值，因此會比 rem(x,2π,r) 提供更準確的結果

• 如果 r == RoundNearest，則結果在區間 $[-π, π]$ 中。這通常是最準確的結果。另請參閱 RoundNearest。

• 如果 r == RoundToZero，則如果 x 為正，則結果在區間 $[0, 2π]$ 中，否則在 $[-2π, 0]$ 中。另請參閱 RoundToZero。

• 如果 r == RoundDown，則結果在區間 $[0, 2π]$ 中。另請參閱 RoundDown。

• 如果 r == RoundUp，則結果在區間 $[-2π, 0]$ 中。另請參閱 RoundUp。

範例

julia> rem2pi(7pi/4, RoundNearest)
-0.7853981633974485

julia> rem2pi(7pi/4, RoundDown)
5.497787143782138

mod2pi(x)

除以 2π 後的模數，返回範圍 $[0,2π)$。

此函數計算除以數值精確的 2π 後的模數的浮點表示式，因此與 mod(x,2π) 不完全相同，後者會計算 x 相對於浮點數 2π 除法的模數。

範例

julia> mod2pi(9*pi/4)
0.7853981633974481

divrem(x, y, r::RoundingMode=RoundToZero)

歐幾里得除法的商數和餘數。等同於 (div(x, y, r), rem(x, y, r))。等效地，使用 r 的預設值，此呼叫等同於 (x ÷ y, x % y)。

另請參閱：fldmod、cld。

範例

julia> divrem(3, 7)
(0, 3)

julia> divrem(7, 3)
(2, 1)

fldmod(x, y)

除法後的取整商數和模數。divrem(x, y, RoundDown) 的方便包裝器。等同於 (fld(x, y), mod(x, y))。

另請參閱：fld、cld、fldmod1。

fld1(x, y)

取整除法，傳回與 mod1(x,y) 一致的值

另請參閱 mod1、fldmod1。

範例

julia> x = 15; y = 4;

julia> fld1(x, y)
4

julia> x == fld(x, y) * y + mod(x, y)
true

julia> x == (fld1(x, y) - 1) * y + mod1(x, y)
true

mod1(x, y)

取整除法後的模數，傳回值 r 使得 mod(r, y) == mod(x, y)，對於正數 y，範圍為 $(0, y]$，對於負數 y，範圍為 $[y,0)$。

對於整數參數和正數 y，這等於 mod(x, 1:y)，因此對於以 1 為基礎的索引是自然的。相較之下，mod(x, y) == mod(x, 0:y-1) 對於有偏移量或步長的運算而言是自然的。

另請參閱 mod、fld1、fldmod1。

範例

julia> mod1(4, 2)
2

julia> mod1.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 1  2  3  1  2  3  1  2  3  1  2

julia> mod1.([-0.1, 0, 0.1, 1, 2, 2.9, 3, 3.1]', 3)
1×8 Matrix{Float64}:
 2.9  3.0  0.1  1.0  2.0  2.9  3.0  0.1

fldmod1(x, y)

傳回 (fld1(x,y), mod1(x,y))。

另請參閱 fld1、mod1。

//(num, den)

將兩個整數或有理數相除，提供一個 Rational 結果。

範例

julia> 3 // 5
3//5

julia> (3 // 5) // (2 // 1)
3//10

rationalize([T<:Integer=Int,] x; tol::Real=eps(x))

將浮點數 x 近似為具有給定整數類型組成的 Rational 數。結果與 x 的差異不會超過 tol。

範例

julia> rationalize(5.6)
28//5

julia> a = rationalize(BigInt, 10.3)
103//10

julia> typeof(numerator(a))
BigInt

numerator(x)

x 的有理數表示法的分子。

範例

julia> numerator(2//3)
2

julia> numerator(4)
4

denominator(x)

x 的有理數表示法的分母。

範例

julia> denominator(2//3)
3

julia> denominator(4)
1

<<(x, n)

左位元移位運算子，x << n。對於 n >= 0，結果是 x 左移 n 位元，並以 0 填滿。這等於 x * 2^n。對於 n < 0，這等於 x >> -n。

範例

julia> Int8(3) << 2
12

julia> bitstring(Int8(3))
"00000011"

julia> bitstring(Int8(12))
"00001100"

另請參閱 >>、>>>、exp2、ldexp。

<<(B::BitVector, n) -> BitVector

左位元移位運算子，B << n。對於 n >= 0，結果是 B，其元素向後移位 n 個位置，並以 false 值填滿。如果 n < 0，元素會向前移位。等於 B >> -n。

範例

julia> B = BitVector([true, false, true, false, false])
5-element BitVector:
 1
 0
 1
 0
 0

julia> B << 1
5-element BitVector:
 0
 1
 0
 0
 0

julia> B << -1
5-element BitVector:
 0
 1
 0
 1
 0

>>(x, n)

右位元移位算子，x >> n。對於 n >= 0，結果為 x 向右移位 n 位元，如果 x >= 0，則以 0 填滿，如果 x < 0，則以 1 填滿，保留 x 的符號。這等於 fld(x, 2^n)。對於 n < 0，這等於 x << -n。

範例

julia> Int8(13) >> 2
3

julia> bitstring(Int8(13))
"00001101"

julia> bitstring(Int8(3))
"00000011"

julia> Int8(-14) >> 2
-4

julia> bitstring(Int8(-14))
"11110010"

julia> bitstring(Int8(-4))
"11111100"

另請參閱 >>>、<<。

>>(B::BitVector, n) -> BitVector

右位元移位算子，B >> n。對於 n >= 0，結果為 B 的元素向前移位 n 個位置，以 false 值填滿。如果 n < 0，則元素向後移位。等於 B << -n。

範例

julia> B = BitVector([true, false, true, false, false])
5-element BitVector:
 1
 0
 1
 0
 0

julia> B >> 1
5-element BitVector:
 0
 1
 0
 1
 0

julia> B >> -1
5-element BitVector:
 0
 1
 0
 0
 0

>>>(x, n)

無符號右位元移位算子，x >>> n。對於 n >= 0，結果為 x 向右移位 n 位元，以 0 填滿。對於 n < 0，這等於 x << -n。

對於 Unsigned 整數類型，這等於 >>。對於 Signed 整數類型，這等於 signed(unsigned(x) >> n)。

範例

julia> Int8(-14) >>> 2
60

julia> bitstring(Int8(-14))
"11110010"

julia> bitstring(Int8(60))
"00111100"

BigInt 被視為具有無限大小，因此不需要填滿，這等於 >>。

另請參閱 >>、<<。

>>>(B::BitVector, n) -> BitVector

無符號右位元移位算子，B >>> n。等於 B >> n。有關詳細資料和範例，請參閱 >>。

bitrotate(x::Base.BitInteger, k::Integer)

bitrotate(x, k) 實作位元旋轉。它會傳回 x 的值，其位元向左旋轉 k 次。負值的 k 會向右旋轉。

另請參閱：<<、circshift、BitArray。

julia> bitrotate(UInt8(114), 2)
0xc9

julia> bitstring(bitrotate(0b01110010, 2))
"11001001"

julia> bitstring(bitrotate(0b01110010, -2))
"10011100"

julia> bitstring(bitrotate(0b01110010, 8))
"01110010"

:expr

引用表達式 expr，傳回 expr 的抽象語法樹 (AST)。AST 可能為 Expr、Symbol 或文字值。語法 :identifier 會評估為 Symbol。

另請參閱：Expr、Symbol、Meta.parse

範例

julia> expr = :(a = b + 2*x)
:(a = b + 2x)

julia> sym = :some_identifier
:some_identifier

julia> value = :0xff
0xff

julia> typeof((expr, sym, value))
Tuple{Expr, Symbol, UInt8}

range(start, stop, length)
range(start, stop; length, step)
range(start; length, stop, step)
range(;start, length, stop, step)

從引數建構一個具有均勻間隔元素和最佳化儲存空間的特殊陣列（一個 AbstractRange）。數學上，範圍由 start、step、stop 和 length 中的任意三個唯一決定。range 的有效呼叫方式為

• 使用 start、step、stop、length 中的任意三個呼叫 range。
• 使用 start、stop、length 中的兩個呼叫 range。在此情況下，step 將假設為一。如果兩個引數都是整數，則會傳回 UnitRange。
• 使用 stop 或 length 中的一個呼叫 range。start 和 step 將假設為一。

請參閱進階說明，以取得傳回類型的其他詳細資訊。

範例

julia> range(1, length=100)
1:100

julia> range(1, stop=100)
1:100

julia> range(1, step=5, length=100)
1:5:496

julia> range(1, step=5, stop=100)
1:5:96

julia> range(1, 10, length=101)
1.0:0.09:10.0

julia> range(1, 100, step=5)
1:5:96

julia> range(stop=10, length=5)
6:10

julia> range(stop=10, step=1, length=5)
6:1:10

julia> range(start=1, step=1, stop=10)
1:1:10

julia> range(; length = 10)
Base.OneTo(10)

julia> range(; stop = 6)
Base.OneTo(6)

julia> range(; stop = 6.5)
1.0:1.0:6.0

如果未指定 length，且 stop - start 不是 step 的整數倍數，則會產生在 stop 之前結束的範圍。

julia> range(1, 3.5, step=2)
1.0:2.0:3.0

特別小心以確保中間值合理地計算。若要避免此引發的開銷，請參閱 LinRange 建構函式。

延伸說明

當引數為整數時，range 會產生 Base.OneTo 且

• 僅提供 length
• 僅提供 stop

當引數為整數時，range 會產生 UnitRange 且

• 僅提供 start 和 stop
• 僅提供 length 和 stop

即使指定為 1，如果提供 step，則不會產生 UnitRange。

Base.OneTo(n)

定義一個 AbstractUnitRange，其行為類似於 1:n，但額外區別在於類型系統保證下限為 1。

StepRangeLen(         ref::R, step::S, len, [offset=1]) where {  R,S}
StepRangeLen{T,R,S}(  ref::R, step::S, len, [offset=1]) where {T,R,S}
StepRangeLen{T,R,S,L}(ref::R, step::S, len, [offset=1]) where {T,R,S,L}

一個範圍 r，其中 r[i] 產生類型為 T 的值（在第一個形式中，T 會自動推論），由 reference 值、step 和 length 參數化。預設 ref 為起始值 r[1]，但您也可以將其提供為 r[offset] 的值，以取得其他索引 1 <= offset <= len。語法 a:b 或 a:b:c（其中 a、b 或 c 任何一個都是浮點數）會建立一個 StepRangeLen。

==(x, y)

通用等號運算子。退回至 ===。應為所有具有等號概念的類型實作，根據實例所代表的抽象值。例如，所有數字類型都以數字值進行比較，忽略類型。字串則以字元序列進行比較，忽略編碼。對於集合，== 通常會遞迴呼叫所有內容，儘管也可能會考慮其他屬性（例如陣列的形狀）。

此運算子遵循浮點數的 IEEE 語意：0.0 == -0.0 且 NaN != NaN。

結果為 Bool 類型，除非其中一個運算元為 missing，這種情況下會傳回 missing（三值邏輯）。對於集合，如果至少一個運算元包含 missing 值，且所有非 missing 值都相等，則會傳回 missing。使用 isequal 或 === 始終取得 Bool 結果。

實作

新的數字類型應為新類型的兩個參數實作此函數，並在可能的情況下透過提升規則處理與其他類型的比較。

isequal 退回至 ==，因此 Dict 類型會使用新的 == 方法來比較金鑰。因此，如果您的類型將用作字典金鑰，它也應實作 hash。

如果某個類型定義了 ==、isequal 和 isless，則它也應實作 < 以確保比較的相容性。

!=(x, y)
≠(x,y)

不等於比較運算子。始終提供與 == 相反的答案。

實作

新類型通常不應該實作這個，而是依賴備用定義 !=(x,y) = !(x==y)。

範例

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

!=(x)

建立一個函式，使用 != 將其參數與 x 進行比較，也就是等同於 y -> y != x 的函式。傳回的函式類型為 Base.Fix2{typeof(!=)}，可用於實作特殊化方法。

!==(x, y)
≢(x,y)

總是提供與 === 相反的答案。

範例

julia> a = [1, 2]; b = [1, 2];

julia> a ≢ b
true

julia> a ≢ a
false

<(x, y)

小於比較運算子。備用為 isless。由於浮點 NaN 值的行為，這個運算子實作了一個偏序。

實作

具有正規偏序的新類型，應該為新類型的兩個參數實作這個函式。具有正規全序的類型，應該實作 isless。

另請參閱 isunordered。

範例

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

<(x)

建立一個函式，使用 < 將其參數與 x 進行比較，也就是等同於 y -> y < x 的函式。傳回的函式類型為 Base.Fix2{typeof(<)}，可用於實作特殊化方法。

<=(x, y)
≤(x,y)

小於或等於比較運算子。備用為 (x < y) | (x == y)。

範例

julia> 'a' <= 'b'
true

julia> 7 ≤ 7 ≤ 9
true

julia> "abc" ≤ "abc"
true

julia> 5 <= 3
false

<=(x)

建立一個函式，使用 <= 將其參數與 x 進行比較，也就是等同於 y -> y <= x 的函式。傳回的函式類型為 Base.Fix2{typeof(<=)}，可用於實作特殊化方法。

>(x, y)

大於比較運算子。回退到 y < x。

實作

一般而言，新類型應實作 < 而非此函數，並依賴回退定義 >(x, y) = y < x。

範例

julia> 'a' > 'b'
false

julia> 7 > 3 > 1
true

julia> "abc" > "abd"
false

julia> 5 > 3
true

>(x)

建立一個使用 > 將其引數與 x 進行比較之函數，亦即等同於 y -> y > x 之函數。傳回的函數類型為 Base.Fix2{typeof(>)}，可供實作特殊方法使用。

>=(x, y)
≥(x,y)

大於或等於比較運算子。回退到 y <= x。

範例

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

>=(x)

建立一個使用 >= 將其引數與 x 進行比較之函數，亦即等同於 y -> y >= x 之函數。傳回的函數類型為 Base.Fix2{typeof(>=)}，可供實作特殊方法使用。

cmp(x,y)

分別傳回 -1、0 或 1，表示 x 小於、等於或大於 y。使用 isless 實作的總序。

範例

julia> cmp(1, 2)
-1

julia> cmp(2, 1)
1

julia> cmp(2+im, 3-im)
ERROR: MethodError: no method matching isless(::Complex{Int64}, ::Complex{Int64})
[...]

cmp(<, x, y)

分別傳回 -1、0 或 1，表示 x 小於、等於或大於 y。第一個引數指定要使用的「小於」比較函數。

cmp(a::AbstractString, b::AbstractString) -> Int

比較兩個字串。如果兩個字串長度相同且每個索引處的字元都相同，則傳回 0。如果 a 是 b 的字首，或如果 a 在字母順序中出現在 b 之前，則傳回 -1。如果 b 是 a 的字首，或如果 b 在字母順序中出現在 a 之前（技術上來說，依據 Unicode 碼點的字典順序），則傳回 1。

範例

julia> cmp("abc", "abc")
0

julia> cmp("ab", "abc")
-1

julia> cmp("abc", "ab")
1

julia> cmp("ab", "ac")
-1

julia> cmp("ac", "ab")
1

julia> cmp("α", "a")
1

julia> cmp("b", "β")
-1

~(x)

按位非。

另請參閱：!、&、|。

範例

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

x & y

按位與。實作三值邏輯，如果其中一個運算元為 missing 而另一個為 true，則傳回 missing。為函數應用程式加上括號：(&)(x, y)。

另請參閱：|、xor、&&。

範例

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

x | y

按位或。實作三值邏輯，如果其中一個運算元為 missing 而另一個為 false，則傳回 missing。

另請參閱：&、xor、||。

範例

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

xor(x, y)
⊻(x, y)

x 和 y 的按位異或。實作三值邏輯，如果其中一個引數為 missing，則傳回 missing。

中綴運算式 a ⊻ b 是 xor(a,b) 的同義字，而且 ⊻ 可以透過在 Julia REPL 中按 Tab 鍵完成 \xor 或 \veebar 來輸入。

範例

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

julia> [true; true; false] .⊻ [true; false; false]
3-element BitVector:
 0
 1
 0

nand(x, y)
⊼(x, y)

x 和 y 的按位與非 (非與)。實作三值邏輯，如果其中一個引數為 missing，則傳回 missing。

中綴運算 a ⊼ b 是 nand(a,b) 的同義詞，而 ⊼ 可以透過在 Julia REPL 中按 Tab 補全 \nand 或 \barwedge 來輸入。

範例

julia> nand(true, false)
true

julia> nand(true, true)
false

julia> nand(true, missing)
missing

julia> false ⊼ false
true

julia> [true; true; false] .⊼ [true; false; false]
3-element BitVector:
 0
 1
 1

nor(x, y)
⊽(x, y)

x 和 y 的按位元 nor（非或）運算。實作 三值邏輯，如果其中一個參數為 missing 而另一個參數不是 true，則傳回 missing。

中綴運算 a ⊽ b 是 nor(a,b) 的同義詞，而 ⊽ 可以透過在 Julia REPL 中按 Tab 補全 \nor 或 \barvee 來輸入。

範例

julia> nor(true, false)
false

julia> nor(true, true)
false

julia> nor(true, missing)
false

julia> false ⊽ false
true

julia> false ⊽ missing
missing

julia> [true; true; false] .⊽ [true; false; false]
3-element BitVector:
 0
 0
 1

!(x)

布林非運算。實作 三值邏輯，如果 x 為 missing，則傳回 missing。

另請參閱 ~ 以取得按位元非運算。

範例

julia> !true
false

julia> !false
true

julia> !missing
missing

julia> .![true false true]
1×3 BitMatrix:
 0  1  0

!f::Function

謂詞函數否定：當 ! 的參數為函數時，它會傳回一個複合函數，用來計算 f 的布林否定。

另請參閱 ∘。

範例

julia> str = "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
"∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"

julia> filter(isletter, str)
"εδxyδfxfyε"

julia> filter(!isletter, str)
"∀  > 0, ∃  > 0: |-| <  ⇒ |()-()| < "

x && y

短路布林 AND 運算。

另請參閱 &、三元運算子 ? :，以及 控制流程 手冊章節。

範例

julia> x = 3;

julia> x > 1 && x < 10 && x isa Int
true

julia> x < 0 && error("expected positive x")
false

x || y

短路布林 OR 運算。

另請參閱：|、xor、&&。

範例

julia> pi < 3 || ℯ < 3
true

julia> false || true || println("neither is true!")
true

isapprox(x, y; atol::Real=0, rtol::Real=atol>0 ? 0 : √eps, nans::Bool=false[, norm::Function])

不精確相等比較。如果兩個數字的相對距離或絕對距離在容差範圍內，則認為這兩個數字相等：如果 norm(x-y) <= max(atol, rtol*max(norm(x), norm(y)))，則 isapprox 會傳回 true。預設的 atol（絕對容差）為零，而預設的 rtol（相對容差）則取決於 x 和 y 的類型。關鍵字參數 nans 決定是否將 NaN 值視為相等（預設為 false）。

對於實數或複數浮點值，如果未指定 atol > 0，則 rtol 預設為 x 或 y 類型的 eps 的平方根，取較大者（精確度最低）。這相當於要求約一半有效數字相等。否則，例如對於整數參數或提供 atol > 0，則 rtol 預設為零。

對於數值 (x,y)，norm 關鍵字預設為 abs，而對於陣列（有時使用其他 norm 選擇會比較有用），則預設為 LinearAlgebra.norm。當 x 和 y 是陣列時，如果 norm(x-y) 不是有限的（即 ±Inf 或 NaN），則比較會改為檢查 x 和 y 的所有元素是否在組成部分上近似相等。

二元運算子 ≈ 等同於使用預設參數的 isapprox，而 x ≉ y 等同於 !isapprox(x,y)。

請注意，x ≈ 0（即，使用預設容差與零比較）等於 x == 0，因為預設的 atol 為 0。在這種情況下，您應該提供適當的 atol（或使用 norm(x) ≤ atol）或重新排列您的程式碼（例如，使用 x ≈ y 而不是 x - y ≈ 0）。無法自動選擇非零的 atol，因為它取決於問題的整體縮放（「單位」）：例如，在 x - y ≈ 0 中，如果 x 是以公尺為單位的地球半徑，則 atol=1e-9 是個非常小的容差，但如果 x 是以公尺為單位的氫原子半徑，則 atol=1e-9 是個非常大的容差。

範例

julia> isapprox(0.1, 0.15; atol=0.05)
true

julia> isapprox(0.1, 0.15; rtol=0.34)
true

julia> isapprox(0.1, 0.15; rtol=0.33)
false

julia> 0.1 + 1e-10 ≈ 0.1
true

julia> 1e-10 ≈ 0
false

julia> isapprox(1e-10, 0, atol=1e-8)
true

julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0]) # using `norm`
true

isapprox(x; kwargs...) / ≈(x; kwargs...)

建立一個使用 ≈ 將其參數與 x 進行比較的函數，即等於 y -> y ≈ x 的函數。

這裡支援的關鍵字參數與 2 個參數的 isapprox 中的相同。

sin(x)

計算 x 的正弦，其中 x 以弧度表示。

另請參閱 sind、sinpi、sincos、cis、asin。

範例

julia> round.(sin.(range(0, 2pi, length=9)'), digits=3)
1×9 Matrix{Float64}:
 0.0  0.707  1.0  0.707  0.0  -0.707  -1.0  -0.707  -0.0

julia> sind(45)
0.7071067811865476

julia> sinpi(1/4)
0.7071067811865475

julia> round.(sincos(pi/6), digits=3)
(0.5, 0.866)

julia> round(cis(pi/6), digits=3)
0.866 + 0.5im

julia> round(exp(im*pi/6), digits=3)
0.866 + 0.5im

cos(x)

計算 x 的餘弦，其中 x 以弧度表示。

另請參閱 cosd、cospi、sincos、cis。

sincos(x)

同時計算 x 的正弦和餘弦，其中 x 以弧度為單位，傳回一個元組 (sine, cosine)。

另請參閱 cis、sincospi、sincosd。

tan(x)

計算 x 的正切，其中 x 以弧度為單位。

sind(x)

計算 x 的正弦，其中 x 以度為單位。如果 x 是矩陣，則 x 必須是方陣。

cosd(x)

計算 x 的餘弦，其中 x 以度為單位。如果 x 是矩陣，則 x 必須是方陣。

tand(x)

計算 x 的正切，其中 x 以度為單位。如果 x 是矩陣，則 x 必須是方陣。

sincosd(x)

同時計算 x 的正弦和餘弦，其中 x 以度為單位。

sinpi(x)

計算 $\sin(\pi x)$ 比 sin(pi*x) 更精確，特別是對於較大的 x。

另請參閱 sind、cospi、sincospi。

cospi(x)

計算 $\cos(\pi x)$ 比 cos(pi*x) 更精確，特別是對於較大的 x。

sincospi(x)

同時計算 sinpi(x) 和 cospi(x)（π*x 的正弦和餘弦，其中 x 以弧度為單位），傳回一個元組 (sine, cosine)。

另請參閱：cispi、sincosd、sinpi。

sinh(x)

計算 x 的雙曲正弦。

cosh(x)

計算 x 的雙曲餘弦。

tanh(x)

計算 x 的雙曲正切。

另請參閱 tan、atanh。

範例

julia> tanh.(-3:3f0)  # Here 3f0 isa Float32
7-element Vector{Float32}:
 -0.9950548
 -0.9640276
 -0.7615942
  0.0
  0.7615942
  0.9640276
  0.9950548

julia> tan.(im .* (1:3))
3-element Vector{ComplexF64}:
 0.0 + 0.7615941559557649im
 0.0 + 0.9640275800758169im
 0.0 + 0.9950547536867306im

asin(x)

計算 x 的反正弦，其中輸出以弧度為單位。

另請參閱 asind，以度為單位的輸出。

範例

julia> asin.((0, 1/2, 1))
(0.0, 0.5235987755982989, 1.5707963267948966)

julia> asind.((0, 1/2, 1))
(0.0, 30.000000000000004, 90.0)

acos(x)

計算 x 的反餘弦，輸出單位為弧度

atan(y)
atan(y, x)

分別計算 y 或 y/x 的反正切

對於一個參數，這是正 x 軸與點 (1, y) 之間的弧度角，傳回 $[-\pi/2, \pi/2]$ 區間內的數值。

對於兩個參數，這是正 x 軸與點 (x, y) 之間的弧度角，傳回 $[-\pi, \pi]$ 區間內的數值。這對應到標準的 atan2 函數。請注意，根據慣例，當 x < 0 時，atan(0.0,x) 定義為 $\pi$，而 atan(-0.0,x) 定義為 $-\pi$。

有關角度，請參閱 atand。

範例

julia> rad2deg(atan(-1/√3))
-30.000000000000004

julia> rad2deg(atan(-1, √3))
-30.000000000000004

julia> rad2deg(atan(1, -√3))
150.0

asind(x)

計算 x 的反正弦，輸出單位為角度。如果 x 是矩陣，則 x 必須是方陣。

acosd(x)

計算 x 的反餘弦，輸出單位為角度。如果 x 是矩陣，則 x 必須是方陣。

atand(y)
atand(y,x)

分別計算 y 或 y/x 的反正切，輸出單位為角度。

sec(x)

計算 x 的正割，其中 x 為弧度。

csc(x)

計算 x 的餘割，其中 x 為弧度。

cot(x)

計算 x 的餘切，其中 x 以弧度為單位。

secd(x)

計算 x 的正割，其中 x 以度為單位。

cscd(x)

計算 x 的餘割，其中 x 以度為單位。

cotd(x)

計算 x 的餘切，其中 x 以度為單位。

asec(x)

計算 x 的反正割，其中輸出以弧度為單位。

acsc(x)

計算 x 的反餘割，其中輸出以弧度為單位。

acot(x)

計算 x 的反餘切，其中輸出以弧度為單位。

asecd(x)

計算 x 的反正割，其中輸出以度為單位。如果 x 是矩陣，則 x 必須是方陣。

acscd(x)

計算 x 的反餘割，其中輸出以度為單位。如果 x 是矩陣，則 x 必須是方陣。

acotd(x)

計算 x 的反餘切，輸出以度為單位。如果 x 是矩陣，則 x 必須是方陣。

sech(x)

計算 x 的雙曲正割。

csch(x)

計算 x 的雙曲餘割。

coth(x)

計算 x 的雙曲餘切。

asinh(x)

計算 x 的反雙曲正弦。

acosh(x)

計算 x 的反雙曲餘弦。

atanh(x)

計算 x 的反雙曲正切。

asech(x)

計算 x 的反雙曲正割。

acsch(x)

計算 x 的反雙曲餘割。

acoth(x)

計算 x 的反雙曲餘切。

sinc(x)

計算 $\sin(\pi x) / (\pi x)$，如果 $x \neq 0$，則為 $1$，如果 $x = 0$。

另請參閱 cosc，其導數。

cosc(x)

計算 $\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)$ 如果 $x \neq 0$，以及 $0$ 如果 $x = 0$。這是 sinc(x) 的導數。

deg2rad(x)

將 x 從度數轉換為弧度。

另請參閱 rad2deg、sind、pi。

範例

julia> deg2rad(90)
1.5707963267948966

rad2deg(x)

將 x 從弧度轉換為度數。

另請參閱 deg2rad。

範例

julia> rad2deg(pi)
180.0

hypot(x, y)

計算斜邊 $\sqrt{|x|^2+|y|^2}$，避免溢位和下溢。

此程式碼實作了論文中所述的演算法：Carlos F. Borges 的 hypot(a,b) 改良演算法。這篇文章可在 arXiv 上的連結中線上取得：https://arxiv.org/abs/1904.09481

hypot(x...)

計算斜邊 $\sqrt{\sum |x_i|^2}$，避免溢位和下溢。

另請參閱 LinearAlgebra 標準函式庫中的 norm。

範例

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # a^2 overflows
ERROR: DomainError with -2.914184810805068e18:
sqrt was called with a negative real argument but will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
Stacktrace:
[...]

julia> hypot(3, 4im)
5.0

julia> hypot(-5.7)
5.7

julia> hypot(3, 4im, 12.0)
13.0

julia> using LinearAlgebra

julia> norm([a, a, a, a]) == hypot(a, a, a, a)
true

log(x)

計算 x 的自然對數。對負數 Real 參數擲回 DomainError。使用複數負數參數以取得複數結果。

另請參閱 ℯ、log1p、log2、log10。

範例

julia> log(2)
0.6931471805599453

julia> log(-3)
ERROR: DomainError with -3.0:
log was called with a negative real argument but will only return a complex result if called with a complex argument. Try log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log.(exp.(-1:1))
3-element Vector{Float64}:
 -1.0
  0.0
  1.0

log(b,x)

計算 b 底的 x 對數。對負的 Real 參數擲出 DomainError。

範例

julia> log(4,8)
1.5

julia> log(4,2)
0.5

julia> log(-2, 3)
ERROR: DomainError with -2.0:
log was called with a negative real argument but will only return a complex result if called with a complex argument. Try log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(2, -3)
ERROR: DomainError with -3.0:
log was called with a negative real argument but will only return a complex result if called with a complex argument. Try log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0

log2(x)

計算 x 以 2 為底的對數。對負的 Real 參數擲出 DomainError。

另請參閱：exp2、ldexp、ispow2。

範例

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
ERROR: DomainError with -2.0:
log2 was called with a negative real argument but will only return a complex result if called with a complex argument. Try log2(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

julia> log2.(2.0 .^ (-1:1))
3-element Vector{Float64}:
 -1.0
  0.0
  1.0

log10(x)

計算 x 以 10 為底的對數。對負的 Real 參數擲出 DomainError。

範例

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

julia> log10(-2)
ERROR: DomainError with -2.0:
log10 was called with a negative real argument but will only return a complex result if called with a complex argument. Try log10(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

log1p(x)

1+x 的準確自然對數。對小於 -1 的 Real 參數擲出 DomainError。

範例

julia> log1p(-0.5)
-0.6931471805599453

julia> log1p(0)
0.0

julia> log1p(-2)
ERROR: DomainError with -2.0:
log1p was called with a real argument < -1 but will only return a complex result if called with a complex argument. Try log1p(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

frexp(val)

傳回 (x,exp)，其中 x 的大小在區間 $[1/2, 1)$ 或 0 中，而 val 等於 $x \times 2^{exp}$。

範例

julia> frexp(12.8)
(0.8, 4)

exp(x)

計算 x 的自然底指數，換句話說，$ℯ^x$。

另請參閱 exp2、exp10 和 cis。

範例

julia> exp(1.0)
2.718281828459045

julia> exp(im * pi) ≈ cis(pi)
true

exp2(x)

計算 x 的 2 為底指數，換句話說，$2^x$。

另請參閱 ldexp、<<。

範例

julia> exp2(5)
32.0

julia> 2^5
32

julia> exp2(63) > typemax(Int)
true

exp10(x)

計算 x 的 10 為底指數，換句話說，$10^x$。

範例

julia> exp10(2)
100.0

julia> 10^2
100

ldexp(x, n)

計算 $x \times 2^n$。

範例

julia> ldexp(5., 2)
20.0

modf(x)

傳回一個數字的小數部分和整數部分的元組 (fpart, ipart)。兩部分的符號與參數相同。

範例

julia> modf(3.5)
(0.5, 3.0)

julia> modf(-3.5)
(-0.5, -3.0)

expm1(x)

精確計算 $e^x-1$。它避免了在 x 值較小時直接評估 exp(x)-1 所涉及的精度損失。

範例

julia> expm1(1e-16)
1.0e-16

julia> exp(1e-16) - 1
0.0

round([T,] x, [r::RoundingMode])
round(x, [r::RoundingMode]; digits::Integer=0, base = 10)
round(x, [r::RoundingMode]; sigdigits::Integer, base = 10)

將數字 x 四捨五入。

沒有關鍵字參數，x 會四捨五入為整數值，傳回類型為 T 的值，或如果沒有提供 T，則傳回與 x 相同類型的值。如果 T 無法表示該值，會擲出 InexactError，類似於 convert。

如果提供了 digits 關鍵字參數，它會根據 base 為底數，將小數點後（或負值時為前）的數字四捨五入到指定的位數。

如果提供了 sigdigits 關鍵字參數，它會根據 base 為底數，將數字四捨五入到指定的有效位數。

RoundingMode r 控制四捨五入的方向；預設為 RoundNearest，它會四捨五入到最接近的整數，而小數點為 0.5 的值會四捨五入到最接近的偶數整數。請注意，如果變更了全域四捨五入模式（請參閱 rounding），round 可能會產生不正確的結果。

範例

julia> round(1.7)
2.0

julia> round(Int, 1.7)
2

julia> round(1.5)
2.0

julia> round(2.5)
2.0

julia> round(pi; digits=2)
3.14

julia> round(pi; digits=3, base=2)
3.125

julia> round(123.456; sigdigits=2)
120.0

julia> round(357.913; sigdigits=4, base=2)
352.0

julia> x = 1.15
1.15

julia> big(1.15)
1.149999999999999911182158029987476766109466552734375

julia> x < 115//100
true

julia> round(x, digits=1)
1.2

擴充

若要將 round 擴充到新的數字類型，通常只需定義 Base.round(x::NewType, r::RoundingMode) 即可。

RoundingMode

用於控制浮點運算四捨五入模式的類型（透過 rounding/setrounding 函式），或作為四捨五入到最接近整數的選用參數（透過 round 函式）。

目前支援的四捨五入模式為

• RoundNearest（預設）
• RoundNearestTiesAway
• RoundNearestTiesUp
• RoundToZero
• RoundFromZero
• RoundUp
• RoundDown

RoundNearest

預設四捨五入模式。四捨五入到最接近的整數，而小數點為 0.5 的值會四捨五入到最接近的偶數整數。

RoundNearestTiesAway

四捨五入到最接近的整數，而小數點會遠離零四捨五入（C/C++ round 行為）。

RoundNearestTiesUp

四捨五入到最接近的整數，其中小數點後為 5 的四捨五入到正無限大（Java/JavaScript round 行為）。

RoundToZero

使用這種捨入模式的 round 是 trunc 的別名。

RoundFromZero

遠離零四捨五入。

範例

julia> BigFloat("1.0000000000000001", 5, RoundFromZero)
1.06

RoundUp

使用這種捨入模式的 round 是 ceil 的別名。

RoundDown

使用這種捨入模式的 round 是 floor 的別名。

round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]])
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; digits=0, base=10)
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; sigdigits, base=10)

傳回與複數值 z 相同類型的最近整數值，使用指定的 RoundingMode 處理小數點後為 5 的情況。第一個 RoundingMode 用於捨入實數部分，而第二個用於捨入虛數部分。

RoundingModeReal 和 RoundingModeImaginary 預設為 RoundNearest，它會四捨五入到最接近的整數，其中小數點後為 5 的四捨五入到最接近的偶數整數。

範例

julia> round(3.14 + 4.5im)
3.0 + 4.0im

julia> round(3.14 + 4.5im, RoundUp, RoundNearestTiesUp)
4.0 + 5.0im

julia> round(3.14159 + 4.512im; digits = 1)
3.1 + 4.5im

julia> round(3.14159 + 4.512im; sigdigits = 3)
3.14 + 4.51im

ceil([T,] x)
ceil(x; digits::Integer= [, base = 10])
ceil(x; sigdigits::Integer= [, base = 10])

ceil(x) 傳回大於或等於 x 的與 x 相同類型的最近整數值。

ceil(T, x) 將結果轉換為 T 類型，如果該值無法表示，則會擲出 InexactError。

關鍵字 digits、sigdigits 和 base 的運作方式與 round 相同。

floor([T,] x)
floor(x; digits::Integer= [, base = 10])
floor(x; sigdigits::Integer= [, base = 10])

floor(x) 傳回小於或等於 x 的與 x 相同類型的最近整數值。

floor(T, x) 將結果轉換為 T 類型，如果該值無法表示，則會擲出 InexactError。

關鍵字 digits、sigdigits 和 base 的運作方式與 round 相同。

trunc([T,] x)
trunc(x; digits::Integer= [, base = 10])
trunc(x; sigdigits::Integer= [, base = 10])

trunc(x) 傳回與 x 相同類型的最近整數值，其絕對值小於或等於 x 的絕對值。

trunc(T, x) 將結果轉換為 T 類型，如果該值無法表示，則會擲出 InexactError。

關鍵字 digits、sigdigits 和 base 的運作方式與 round 相同。

另請參閱：%、floor、unsigned、unsafe_trunc。

範例

julia> trunc(2.22)
2.0

julia> trunc(-2.22, digits=1)
-2.2

julia> trunc(Int, -2.22)
-2

unsafe_trunc(T, x)

傳回與 T 類型相同的最近整數值，其絕對值小於或等於 x 的絕對值。如果 T 無法表示該值，則會傳回任意值。另請參閱 trunc。

範例

julia> unsafe_trunc(Int, -2.2)
-2

julia> unsafe_trunc(Int, NaN)
-9223372036854775808

min(x, y, ...)

傳回參數的最小值（相對於 isless）。另請參閱 minimum 函數，以取得集合中的最小元素。

範例

julia> min(2, 5, 1)
1

max(x, y, ...)

傳回參數的最大值（相對於 isless）。另請參閱 maximum 函數，以取得集合中的最大元素。

範例

julia> max(2, 5, 1)
5

minmax(x, y)

傳回 (min(x,y), max(x,y))。

另請參閱 extrema，它會傳回 (minimum(x), maximum(x))。

範例

julia> minmax('c','b')
('b', 'c')

clamp(x, lo, hi)

如果 lo <= x <= hi，則傳回 x。如果 x > hi，則傳回 hi。如果 x < lo，則傳回 lo。參數會提升為共用類型。

另請參閱 clamp!、min、max。

範例

julia> clamp.([pi, 1.0, big(10)], 2.0, 9.0)
3-element Vector{BigFloat}:
 3.141592653589793238462643383279502884197169399375105820974944592307816406286198
 2.0
 9.0

julia> clamp.([11, 8, 5], 10, 6)  # an example where lo > hi
3-element Vector{Int64}:
  6
  6
 10

clamp(x, T)::T

將 x 限制在 typemin(T) 和 typemax(T) 之間，並將結果轉換為類型 T。

另請參閱 trunc。

範例

julia> clamp(200, Int8)
127

julia> clamp(-200, Int8)
-128

julia> trunc(Int, 4pi^2)
39

clamp(x::Integer, r::AbstractUnitRange)

將 x 限制在範圍 r 內。

clamp!(array::AbstractArray, lo, hi)

將 array 中的值限制在指定的範圍內，原址執行。另請參閱 clamp。

範例

julia> row = collect(-4:4)';

julia> clamp!(row, 0, Inf)
1×9 adjoint(::Vector{Int64}) with eltype Int64:
 0  0  0  0  0  1  2  3  4

julia> clamp.((-4:4)', 0, Inf)
1×9 Matrix{Float64}:
 0.0  0.0  0.0  0.0  0.0  1.0  2.0  3.0  4.0

abs(x)

x 的絕對值。

當 abs 套用於有號整數時，可能會發生溢位，導致傳回負值。此溢位僅在 abs 套用於有號整數的可表示最小值時發生。也就是說，當 x == typemin(typeof(x)) 時，abs(x) == x < 0，而非預期的 -x。

另請參閱：abs2、unsigned、sign。

範例

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs.(Int8[-128 -127 -126 0 126 127])  # overflow at typemin(Int8)
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

julia> maximum(abs, [1, -2, 3, -4])
4

Base.checked_abs(x)

計算 abs(x)，檢查適用的溢位錯誤。例如，標準的二補數有號整數（例如 Int）無法表示 abs(typemin(Int))，因此會導致溢位。

溢位防護可能會造成明顯的效能損失。

Base.checked_neg(x)

計算 -x，檢查適用的溢位錯誤。例如，標準的二補數有號整數（例如 Int）無法表示 -typemin(Int)，因此會導致溢位。

溢位防護可能會造成明顯的效能損失。

Base.checked_add(x, y)

計算 x+y，檢查適用的溢位錯誤。

溢位防護可能會造成明顯的效能損失。

Base.checked_sub(x, y)

計算 x-y，檢查適用的溢位錯誤。

溢位防護可能會造成明顯的效能損失。

Base.checked_mul(x, y)

計算 x*y，檢查適用的溢位錯誤。

溢位防護可能會造成明顯的效能損失。

Base.checked_div(x, y)

計算 div(x,y)，檢查適用的溢位錯誤。

溢位防護可能會造成明顯的效能損失。

Base.checked_rem(x, y)

計算 x%y，檢查適用的溢位錯誤。

溢位防護可能會造成明顯的效能損失。

Base.checked_fld(x, y)

計算 fld(x,y)，檢查適用的溢位錯誤。

溢位防護可能會造成明顯的效能損失。

Base.checked_mod(x, y)

計算 mod(x,y)，檢查適用的溢位錯誤。

溢位防護可能會造成明顯的效能損失。

Base.checked_cld(x, y)

計算 cld(x,y)，檢查適用的溢位錯誤。

溢位防護可能會造成明顯的效能損失。

Base.add_with_overflow(x, y) -> (r, f)

計算 r = x+y，旗標 f 指示是否發生溢位。

Base.sub_with_overflow(x, y) -> (r, f)

計算 r = x-y，旗標 f 指示是否發生溢位。

Base.mul_with_overflow(x, y) -> (r, f)

計算 r = x*y，旗標 f 指示是否發生溢位。

abs2(x)

x 的平方絕對值。

這可能比 abs(x)^2 更快，特別是對於複數，其中 abs(x) 需要透過 hypot 進行平方根。

另請參閱 abs、conj、real。

範例

julia> abs2(-3)
9

julia> abs2(3.0 + 4.0im)
25.0

julia> sum(abs2, [1+2im, 3+4im])  # LinearAlgebra.norm(x)^2
30

copysign(x, y) -> z

傳回大小為 x 且符號與 y 相同的 z。

範例

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

sign(x)

如果 x==0 則傳回零，否則傳回 $x/|x|$（即對於實數 x 傳回 ±1）。

另請參閱 signbit、zero、copysign、flipsign。

範例

julia> sign(-4.0)
-1.0

julia> sign(99)
1

julia> sign(-0.0)
-0.0

julia> sign(0 + im)
0.0 + 1.0im

signbit(x)

如果 x 的符號值為負，則傳回 true，否則傳回 false。

另請參閱 sign 和 copysign。

範例

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true

flipsign(x, y)

如果 y 為負，則傳回符號已翻轉的 x。例如 abs(x) = flipsign(x,x)。

範例

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5

sqrt(x)

傳回 $\sqrt{x}$。對於負的 Real 參數，會擲回 DomainError。請改用複數負參數。前置運算子 √ 等同於 sqrt。

另請參閱：hypot。

範例

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError with -81.0:
NaN result for non-NaN input.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

julia> sqrt(big(complex(-81)))
0.0 + 9.0im

julia> .√(1:4)
4-element Vector{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772
 2.0

isqrt(n::Integer)

整數平方根：最大的整數 m 使得 m*m <= n。

julia> isqrt(5)
2

cbrt(x::Real)

傳回 x 的立方根，即 $x^{1/3}$。接受負值（當 $x < 0$ 時傳回負實根）。

前置運算子 ∛ 等於 cbrt。

範例

julia> cbrt(big(27))
3.0

julia> cbrt(big(-27))
-3.0

real(z)

傳回複數 z 的實部。

另請參閱：imag、reim、complex、isreal、Real。

範例

julia> real(1 + 3im)
1

real(T::Type)

傳回表示類型 T 的實部的類型。例如：對於 T == Complex{R}，傳回 R。等於 typeof(real(zero(T)))。

範例

julia> real(Complex{Int})
Int64

julia> real(Float64)
Float64

real(A::AbstractArray)

傳回包含陣列 A 中每個條目的實部的陣列。

等於 real.(A)，但當 eltype(A) <: Real 時，會傳回 A 而不會複製，而且當 A 的維度為零時，會傳回零維陣列（而不是純量）。

範例

julia> real([1, 2im, 3 + 4im])
3-element Vector{Int64}:
 1
 0
 3

julia> real(fill(2 - im))
0-dimensional Array{Int64, 0}:
2

imag(z)

傳回複數 z 的虛部。

另請參閱：conj、reim、adjoint、angle。

範例

julia> imag(1 + 3im)
3

imag(A::AbstractArray)

傳回包含陣列 A 中每個條目的虛部的陣列。

等於 imag.(A)，但當 A 的維度為零時，會傳回零維陣列（而不是純量）。

範例

julia> imag([1, 2im, 3 + 4im])
3-element Vector{Int64}:
 0
 2
 4

julia> imag(fill(2 - im))
0-dimensional Array{Int64, 0}:
-1

reim(z)

傳回複數 z 的實部和虛部的元組。

範例

julia> reim(1 + 3im)
(1, 3)

reim(A::AbstractArray)

傳回兩個陣列的元組，分別包含 A 中每個條目的實部和虛部。

等同於 (real.(A), imag.(A))，但當 eltype(A) <: Real 時，會傳回 A 而不會複製來表示實部，且當 A 為零維度時，會傳回零維度陣列（而非純量）。

範例

julia> reim([1, 2im, 3 + 4im])
([1, 0, 3], [0, 2, 4])

julia> reim(fill(2 - im))
(fill(2), fill(-1))

conj(z)

計算複數 z 的共軛複數。

另請參閱：angle、adjoint。

範例

julia> conj(1 + 3im)
1 - 3im

conj(A::AbstractArray)

傳回包含陣列 A 中每個輸入共軛複數的陣列。

等同於 conj.(A)，但當 eltype(A) <: Real 時，會傳回 A 而不會複製，且當 A 為零維度時，會傳回零維度陣列（而非純量）。

範例

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

julia> conj(fill(2 - im))
0-dimensional Array{Complex{Int64}, 0}:
2 + 1im

angle(z)

計算複數 z 的弧度相位角。

另請參閱：atan、cis。

範例

julia> rad2deg(angle(1 + im))
45.0

julia> rad2deg(angle(1 - im))
-45.0

julia> rad2deg(angle(-1 - im))
-135.0

cis(x)

使用歐拉公式來計算 exp(im*x) 的更有效率方法：$cos(x) + i sin(x) = \exp(i x)$。

另請參閱 cispi、sincos、exp、angle。

範例

julia> cis(π) ≈ -1
true

cispi(x)

計算 cis(pi*x) 的更精確方法（尤其是對於較大的 x）。

另請參閱 cis、sincospi、exp、angle。

範例

julia> cispi(10000)
1.0 + 0.0im

julia> cispi(0.25 + 1im)
0.030556854645954562 + 0.03055685464595456im

binomial(n::Integer, k::Integer)

二項式係數 $\binom{n}{k}$，是 $(1+x)^n$ 多項式展開中第 $k$ 項的係數。

如果 $n$ 為非負數，則它表示從 n 個項目中選取 k 個項目的方法數量

\[\binom{n}{k} = \frac{n!}{k! (n-k)!}\]

其中 $n!$ 是 階乘 函數。

如果 $n$ 為負數，則它由恆等式定義

\[\binom{n}{k} = (-1)^k \binom{k-n-1}{k}\]

另請參閱 階乘。

範例

julia> binomial(5, 3)
10

julia> factorial(5) ÷ (factorial(5-3) * factorial(3))
10

julia> binomial(-5, 3)
-35

外部連結

• 二項式係數 在維基百科上。

binomial(x::Number, k::Integer)

廣義二項式係數，由多項式定義，對於 k ≥ 0

\[\frac{1}{k!} \prod_{j=0}^{k-1} (x - j)\]

當 k < 0 時，它回傳零。

對於整數 x 的情況，這等於一般的整數二項式係數

\[\binom{n}{k} = \frac{n!}{k! (n-k)!}\]

進一步推廣到非整數 k 在數學上是可能的，但涉及伽瑪函數和/或貝塔函數，這些函數未由 Julia 標準函式庫提供，但可在外部套件中取得，例如 SpecialFunctions.jl。

外部連結

• 二項式係數 在維基百科上。

factorial(n::Integer)

n 的階乘。如果 n 是 整數，則階乘會計算為整數（至少提升為 64 位元）。請注意，如果 n 不小，這可能會溢位，但您可以使用 factorial(big(n)) 以任意精度準確計算結果。

另請參閱 binomial。

範例

julia> factorial(6)
720

julia> factorial(21)
ERROR: OverflowError: 21 is too large to look up in the table; consider using `factorial(big(21))` instead
Stacktrace:
[...]

julia> factorial(big(21))
51090942171709440000

外部連結

• 階乘 在維基百科上。

gcd(x, y...)

最大公因數（正數）（或所有參數都為零時為零）。參數可以是整數和有理數。

範例

julia> gcd(6, 9)
3

julia> gcd(6, -9)
3

julia> gcd(6, 0)
6

julia> gcd(0, 0)
0

julia> gcd(1//3, 2//3)
1//3

julia> gcd(1//3, -2//3)
1//3

julia> gcd(1//3, 2)
1//3

julia> gcd(0, 0, 10, 15)
5

lcm(x, y...)

最小公倍數（或零，如果任何參數為零）。參數可以是整數和有理數。

範例

julia> lcm(2, 3)
6

julia> lcm(-2, 3)
6

julia> lcm(0, 3)
0

julia> lcm(0, 0)
0

julia> lcm(1//3, 2//3)
2//3

julia> lcm(1//3, -2//3)
2//3

julia> lcm(1//3, 2)
2//1

julia> lcm(1, 3, 5, 7)
105

gcdx(a, b)

計算 a 和 b 的最大公因數和貝祖係數，也就是滿足 $ua+vb = d = gcd(a, b)$ 的整數係數 u 和 v。 $gcdx(a, b)$ 回傳 $(d, u, v)$。

參數可以是整數和有理數。

範例

julia> gcdx(12, 42)
(6, -3, 1)

julia> gcdx(240, 46)
(2, -9, 47)

ispow2(n::Number) -> Bool

測試 n 是否為二的整數次方。

另請參閱 count_ones、prevpow、nextpow。

範例

julia> ispow2(4)
true

julia> ispow2(5)
false

julia> ispow2(4.5)
false

julia> ispow2(0.25)
true

julia> ispow2(1//8)
true

nextpow(a, x)

不小於 x 的最小 a^n，其中 n 為非負整數。a 必須大於 1，而 x 必須大於 0。

另請參閱 prevpow。

範例

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16

prevpow(a, x)

最大的 a^n 不大於 x，其中 n 是非負整數。 a 必須大於 1，而 x 不能小於 1。

另請參閱 nextpow、isqrt。

範例

julia> prevpow(2, 7)
4

julia> prevpow(2, 9)
8

julia> prevpow(5, 20)
5

julia> prevpow(4, 16)
16

nextprod(factors::Union{Tuple,AbstractVector}, n)

下一個大於或等於 n 的整數，可以寫成 $\prod k_i^{p_i}$，其中 $p_1$、$p_2$ 等是整數，而 $k_i$ 是 factors 中的因子。

範例

julia> nextprod((2, 3), 105)
108

julia> 2^2 * 3^3
108

invmod(n, m)

取 n 模 m 的倒數：y 使得 $n y = 1 \pmod m$，且 $div(y,m) = 0$。如果 $m = 0$ 或 $gcd(n,m) \neq 1$，這將拋出錯誤。

範例

julia> invmod(2, 5)
3

julia> invmod(2, 3)
2

julia> invmod(5, 6)
5

powermod(x::Integer, p::Integer, m)

計算 $x^p \pmod m$。

範例

julia> powermod(2, 6, 5)
4

julia> mod(2^6, 5)
4

julia> powermod(5, 2, 20)
5

julia> powermod(5, 2, 19)
6

julia> powermod(5, 3, 19)
11

ndigits(n::Integer; base::Integer=10, pad::Integer=1)

計算以進位 base 編寫的整數 n 中的數字個數（base 不能在 [-1, 0, 1] 中），可選擇使用零填充到指定大小（結果永遠不會小於 pad）。

另請參閱 digits、count_ones。

範例

julia> ndigits(0)
1

julia> ndigits(12345)
5

julia> ndigits(1022, base=16)
3

julia> string(1022, base=16)
"3fe"

julia> ndigits(123, pad=5)
5

julia> ndigits(-123)
3

Base.add_sum(x, y)

sum 中使用的簡約運算子。與 + 的主要區別在於小整數會提升為 Int/UInt。

widemul(x, y)

將 x 和 y 相乘，並將結果作為較大的類型給出。

另請參閱 promote、Base.add_sum。

範例

julia> widemul(Float32(3.0), 4.0) isa BigFloat
true

julia> typemax(Int8) * typemax(Int8)
1

julia> widemul(typemax(Int8), typemax(Int8))  # == 127^2
16129

evalpoly(x, p)

對係數 p[1]、p[2]、... 評估多項式 $\sum_k x^{k-1} p[k]$；亦即，係數按 x 的冪次序遞增給出。如果係數數量在編譯時已知，例如當 p 為 Tuple 時，迴圈會在編譯時展開。如果 x 為實數，此函數會使用 Horner 方法產生有效率的程式碼；如果 x 為複數，則會使用類似 Goertzel 的演算法^[DK62]。

範例

julia> evalpoly(2, (1, 2, 3))
17

@evalpoly(z, c...)

對係數 c[1]、c[2]、... 評估多項式 $\sum_k z^{k-1} c[k]$；亦即，係數按 z 的冪次序遞增給出。此巨集會擴充為有效率的內嵌程式碼，其中使用 Horner 方法或（對於複數 z）更有效率的類似 Goertzel 演算法。

另請參閱 evalpoly。

範例

julia> @evalpoly(3, 1, 0, 1)
10

julia> @evalpoly(2, 1, 0, 1)
5

julia> @evalpoly(2, 1, 1, 1)
7

@fastmath expr

執行表達式的轉換版本，其中會呼叫可能違反嚴格 IEEE 語義的函數。這允許最快的運算，但結果未定義 – 執行此操作時請小心，因為它可能會改變數值結果。

這設定了 LLVM 快速數學標記，並對應到 clang 中的 -ffast-math 選項。有關更多詳細資訊，請參閱 效能註解說明。

範例

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672