Mathematics
Mathematical Operators
Base.:-
— Method-(x)
単項マイナス演算子。
例
julia> -1
-1
julia> -(2)
-2
julia> -[1 2; 3 4]
2×2 Matrix{Int64}:
-1 -2
-3 -4
julia> -(true) # Intに昇格
-1
julia> -(0x003)
0xfffd
Base.:+
— Functiondt::Date + t::Time -> DateTime
Date
と Time
の加算は DateTime
を生成します。Time
の時間、分、秒、およびミリ秒の部分は、Date
の年、月、日とともに使用されて新しい DateTime
を作成します。Time
型の非ゼロのマイクロ秒またはナノ秒は InexactError
を引き起こします。
+(x, y...)
加算演算子。
中置 x+y+z+...
はこの関数をすべての引数で呼び出します。すなわち、+(x, y, z, ...)
はデフォルトで (x+y) + z + ...
を左から始めて呼び出します。
大きな数を加算する際、デフォルトの Int
を含むほとんどの整数型ではオーバーフローが発生する可能性があることに注意してください。
例
julia> 1 + 20 + 4
25
julia> +(1, 20, 4)
25
julia> [1,2] + [3,4]
2-element Vector{Int64}:
4
6
julia> typemax(Int) + 1 < 0
true
Base.:-
— Method-(x, y)
減算演算子。
例
julia> 2 - 3
-1
julia> -(2, 4.5)
-2.5
Base.:*
— Method*(x, y...)
乗算演算子。
中置 x*y*z*...
はこの関数をすべての引数で呼び出します。すなわち *(x, y, z, ...)
であり、デフォルトでは (x*y) * z * ...
と左から始まります。
隣接記法 2pi
も *(2, pi)
を呼び出します。この操作はリテラル *
よりも優先順位が高いことに注意してください。また、隣接記法 "0x..."(変数名が x
で始まる変数の整数ゼロ倍)は、符号なし整数リテラルと衝突するため禁止されています:0x01 isa UInt8
。
大きな数を掛け算する際、デフォルトの Int
を含むほとんどの整数型でオーバーフローが発生する可能性があることに注意してください。
例
julia> 2 * 7 * 8
112
julia> *(2, 7, 8)
112
julia> [2 0; 0 3] * [1, 10] # 行列 * ベクトル
2-element Vector{Int64}:
2
30
julia> 1/2pi, 1/2*pi # 隣接記法は優先順位が高い
(0.15915494309189535, 1.5707963267948966)
julia> x = [1, 2]; x'x # 隣接ベクトル * ベクトル
5
Base.:/
— Function/(x, y)
右割り算演算子:y
の逆数を右側に持つx
の乗算。
整数引数に対して浮動小数点結果を返します。整数除算については÷
を、Rational
の結果については//
を参照してください。
例
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
Base.:\
— Method\(x, y)
左除算演算子:x
の逆数による y
の左側の乗算。整数引数に対して浮動小数点結果を返します。
例
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
Base.:^
— Method^(x, y)
累乗演算子。
x
と y
が整数の場合、結果がオーバーフローする可能性があります。科学的表記法で数値を入力するには、1.2 * 10^3
の代わりに 1.2e3
のような Float64
リテラルを使用してください。
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> 3^-1 # uses Base.literal_pow
0.3333333333333333
julia> p = -1;
julia> 3^p
ERROR: DomainError with -1:
Cannot raise an integer x to a negative power -1.
[...]
julia> 3.0^p
0.3333333333333333
julia> 10^19 > 0 # integer overflow
false
julia> big(10)^19 == 1e19
true
Base.fma
— Functionfma(x, y, z)
x*y+z
を計算しますが、中間結果x*y
の丸めを行いません。一部のシステムでは、x*y+z
よりもかなり高価です。fma
は特定のアルゴリズムでの精度を向上させるために使用されます。muladd
を参照してください。
Base.muladd
— Functionmuladd(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
Base.inv
— Methodinv(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
Base.div
— Functiondiv(x, y)
÷(x, y)
ユークリッド(整数)除算からの商。一般的には小数部分のない数学的操作 x/y に相当します。
例
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
Base.div
— Methoddiv(x, y, r::RoundingMode=RoundToZero)
ユークリッド(整数)除算からの商。x / y
を計算し、丸めモードr
に従って整数に丸めます。言い換えれば、量は
round(x / y, r)
中間的な丸めなしで。
他にfld
やcld
も参照してください。これらはこの関数の特別なケースです。
例:
julia> div(4, 3, RoundToZero) # div(4, 3)と一致
1
julia> div(4, 3, RoundDown) # fld(4, 3)と一致
1
julia> div(4, 3, RoundUp) # cld(4, 3)と一致
2
julia> div(5, 2, RoundNearest)
2
julia> div(5, 2, RoundNearestTiesAway)
3
julia> div(-5, 2, RoundNearest)
-2
julia> div(-5, 2, RoundNearestTiesAway)
-3
julia> div(-5, 2, RoundNearestTiesUp)
-2
julia> div(4, 3, RoundFromZero)
2
julia> div(-4, 3, RoundFromZero)
-2
Base.fld
— Functionfld(x, y)
x / y
以下の最大整数。div(x, y, RoundDown)
と同等です。
例
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
になります。
Base.cld
— Functioncld(x, y)
x / y
以上の最小の整数。div(x, y, RoundUp)
と同等です。
例
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
Base.mod
— Functionmod(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
で割った剰余、または同等に、y
での切り捨て除算の後のx
の余り、すなわち中間的な丸めなしで計算された場合の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
Base.rem
— Functionrem(x, y)
%(x, y)
ユークリッド除算からの余りで、x
と同じ符号を持ち、y
よりも小さい絶対値の値を返します。この値は常に正確です。
例
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
Base.rem
— Methodrem(x, y, r::RoundingMode=RoundToZero)
y
で整数除算した後のx
の余りを計算します。商は丸めモードr
に従って丸められます。言い換えれば、量は
x - y * round(x / y, r)
中間の丸めなしで計算されます。
r == RoundNearest
の場合、結果は正確で、区間$[-|y| / 2, |y| / 2]$にあります。詳細はRoundNearest
を参照してください。r == RoundToZero
(デフォルト)の場合、結果は正確で、x
が正の場合は区間$[0, |y|)$、それ以外の場合は$(-|y|, 0]$にあります。詳細はRoundToZero
を参照してください。r == RoundDown
の場合、結果はy
が正の場合は区間$[0, y)$、それ以外の場合は$(y, 0]$にあります。x
とy
の符号が異なり、abs(x) < abs(y)
の場合、結果は正確でない可能性があります。詳細はRoundDown
を参照してください。r == RoundUp
の場合、結果はy
が正の場合は区間$(-y, 0]$、それ以外の場合は$[0, -y)$にあります。x
とy
の符号が同じで、abs(x) < abs(y)
の場合、結果は正確でない可能性があります。詳細はRoundUp
を参照してください。r == RoundFromZero
の場合、結果はy
が正の場合は区間$(-y, 0]$、それ以外の場合は$[0, -y)$にあります。x
とy
の符号が同じで、abs(x) < abs(y)
の場合、結果は正確でない可能性があります。詳細はRoundFromZero
を参照してください。
例:
julia> x = 9; y = 4;
julia> x % y # rem(x, y)と同じ
1
julia> x ÷ y # div(x, y)と同じ
2
julia> x == div(x, y) * y + rem(x, y)
true
Base.Math.rem2pi
— Functionrem2pi(x, r::RoundingMode)
x
を2π
で整数除算した後の余りを計算します。商は丸めモード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
Base.Math.mod2pi
— Functionmod2pi(x)
2π
で割った後の剰余を計算し、範囲 $[0,2π)$ で返します。
この関数は、数値的に正確な 2π
で割った後の剰余の浮動小数点表現を計算するため、浮動小数点数 2π
で割った x
の剰余を計算する mod(x,2π)
とは正確には同じではありません。
入力値の形式によっては、2π に最も近い表現可能な値が 2π より小さい場合があります。たとえば、式 mod2pi(2π)
は 0
を返しません。なぜなら、2*π
の中間値は Float64
であり、2*Float64(π) < 2*big(π)
だからです。この動作をより細かく制御するには、rem2pi
を参照してください。
例
julia> mod2pi(9*pi/4)
0.7853981633974481
Base.divrem
— Functiondivrem(x, y, r::RoundingMode=RoundToZero)
ユークリッド除算からの商と余り。(div(x, y, r), rem(x, y, r))
に相当します。同様に、r
のデフォルト値を使用した場合、この呼び出しは(x ÷ y, x % y)
に相当します。
例
julia> divrem(3, 7)
(0, 3)
julia> divrem(7, 3)
(2, 1)
Base.fldmod
— Functionfldmod(x, y)
除算後の切り捨てた商と剰余。divrem(x, y, RoundDown)
の便利なラッパー。(fld(x, y), mod(x, y))
に相当します。
Base.fld1
— Functionfld1(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
Base.mod1
— Functionmod1(x, y)
床除算の後の剰余を返し、正の y
に対して範囲 $(0, y]$ で、負の y
に対して範囲 $[y,0)$ で mod(r, y) == mod(x, y)
となる値 r
を返します。
整数引数と正の 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
Base.fldmod1
— FunctionBase.://
— Function//(num, den)
2つの整数または有理数を割り算し、Rational
結果を返します。より一般的には、//
は整数または有理数の成分を持つ他の数値型、例えば整数成分を持つ複素数の正確な有理数除算に使用できます。
浮動小数点数(AbstractFloat
)の引数は //
では許可されていません(たとえ値が有理数であっても)。引数は Integer
、Rational
、またはそれらの合成型のサブタイプでなければなりません。
例
julia> 3 // 5
3//5
julia> (3 // 5) // (2 // 1)
3//10
julia> (1+2im) // (3+4im)
11//25 + 2//25*im
julia> 1.0 // 2
ERROR: MethodError: no method matching //(::Float64, ::Int64)
[...]
Base.rationalize
— Functionrationalize([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
Base.numerator
— Functionnumerator(x)
x
の有理数表現の分子。
例
julia> numerator(2//3)
2
julia> numerator(4)
4
Base.denominator
— Functiondenominator(x)
x
の有理数表現の分母。
例
julia> denominator(2//3)
3
julia> denominator(4)
1
Base.:<<
— Function<<(x, n)
左ビットシフト演算子、x << n
。n >= 0
の場合、結果は n
ビットだけ左にシフトされた x
で、0
で埋められます。これは x * 2^n
と同等です。n < 0
の場合、これは x >> -n
と同等です。
例
julia> Int8(3) << 2
12
julia> bitstring(Int8(3))
"00000011"
julia> bitstring(Int8(12))
"00001100"
<<(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
Base.:>>
— Function>>(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
Base.:>>>
— Function>>>(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"
>>>(B::BitVector, n) -> BitVector
符号なし右ビットシフト演算子、B >>> n
。B >> n
と同等です。詳細と例については>>
を参照してください。
Base.bitrotate
— Functionbitrotate(x::Base.BitInteger, k::Integer)
bitrotate(x, k)
はビット単位の回転を実装します。これは、x
のビットを左に k
回回転させた値を返します。k
の負の値は右に回転します。
julia> bitrotate(UInt8(114), 2)
0xc9
julia> bitstring(bitrotate(0b01110010, 2))
"11001001"
julia> bitstring(bitrotate(0b01110010, -2))
"10011100"
julia> bitstring(bitrotate(0b01110010, 8))
"01110010"
Base.::
— Function: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}
Base.range
— Functionrange(start, stop, length)
range(start, stop; length, step)
range(start; length, stop, step)
range(;start, length, stop, step)
引数から均等に間隔を空けた要素を持つ特化型配列(AbstractRange
)を構築します。数学的には、範囲は start
、step
、stop
、length
のいずれか3つによって一意に決まります。範囲の有効な呼び出しは次のとおりです。
start
、step
、stop
、length
のいずれか3つを指定してrange
を呼び出します。start
、stop
、length
のいずれか2つを指定してrange
を呼び出します。この場合、step
は1であると仮定されます。両方の引数が整数の場合、UnitRange
が返されます。stop
またはlength
のいずれか1つを指定してrange
を呼び出します。この場合、start
とstep
は1であると仮定されます。
返される型に関する詳細は拡張ヘルプを参照してください。また、対数間隔の点については logrange
も参照してください。
例
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
のみが提供されている
step
が提供されている場合、たとえ1として指定されていても UnitRange
は生成されません。
Base.OneTo
— TypeBase.OneTo(n)
1:n
のように振る舞うAbstractUnitRange
を定義しますが、追加の特徴として下限が1であることが(型システムによって)保証されています。
Base.StepRangeLen
— TypeStepRangeLen( 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
は自動的に推論されます)。これは、ref
値、step
、および len
によってパラメータ化されています。デフォルトでは ref
は開始値 r[1]
ですが、代わりに他のインデックス 1 <= offset <= len
の r[offset]
の値として供給することもできます。構文 a:b
または a:b:c
は、a
、b
、または c
のいずれかが浮動小数点数である場合、StepRangeLen
を作成します。
Base.logrange
— Functionlogrange(start, stop, length)
logrange(start, stop; length)
与えられた端点の間に対数的に間隔を空けた要素を持つ特化した配列を構築します。つまり、連続する要素の比は一定で、長さから計算されます。
これはPythonのgeomspace
に似ています。MathematicaのPowerRange
とは異なり、比ではなく要素の数を指定します。PythonやMatlabのlogspace
とは異なり、start
とstop
の引数は常に結果の最初と最後の要素であり、いくつかの基数に適用されるべきべき乗ではありません。
例
julia> logrange(10, 4000, length=3)
3-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
10.0, 200.0, 4000.0
julia> ans[2] ≈ sqrt(10 * 4000) # 中間要素は幾何平均
true
julia> range(10, 40, length=3)[2] ≈ (10 + 40)/2 # 算術平均
true
julia> logrange(1f0, 32f0, 11)
11-element Base.LogRange{Float32, Float64}:
1.0, 1.41421, 2.0, 2.82843, 4.0, 5.65685, 8.0, 11.3137, 16.0, 22.6274, 32.0
julia> logrange(1, 1000, length=4) ≈ 10 .^ (0:3)
true
詳細についてはLogRange
型を参照してください。
線形間隔の点についてはrange
も参照してください。
Base.LogRange
— TypeLogRange{T}(start, stop, len) <: AbstractVector{T}
start
と stop
の間に対数的に間隔を持つ要素を持つ範囲で、間隔は len
によって制御されます。logrange
によって返されます。
LinRange
と同様に、最初と最後の要素は提供されたものと正確に一致しますが、中間の値には小さな浮動小数点誤差がある場合があります。これらは、構築時に保存される端点の対数を使用して計算され、しばしば T
よりも高い精度で保存されます。
例
julia> logrange(1, 4, length=5)
5-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
1.0, 1.41421, 2.0, 2.82843, 4.0
julia> Base.LogRange{Float16}(1, 4, 5)
5-element Base.LogRange{Float16, Float64}:
1.0, 1.414, 2.0, 2.828, 4.0
julia> logrange(1e-310, 1e-300, 11)[1:2:end]
6-element Vector{Float64}:
1.0e-310
9.999999999999974e-309
9.999999999999981e-307
9.999999999999988e-305
9.999999999999994e-303
1.0e-300
julia> prevfloat(1e-308, 5) == ans[2]
true
整数の eltype T
は許可されていません。たとえば、round.(Int, xs)
を使用するか、いくつかの整数基数の明示的な累乗を使用してください:
julia> xs = logrange(1, 512, 4)
4-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
1.0, 8.0, 64.0, 512.0
julia> 2 .^ (0:3:9) |> println
[1, 8, 64, 512]
```
Base.:==
— Function==(x, y)
汎用等価演算子。===
にフォールバックします。等価性の概念を持つすべての型に対して実装されるべきです。これは、インスタンスが表す抽象的な値に基づいています。たとえば、すべての数値型は型を無視して数値で比較されます。文字列はエンコーディングを無視して文字のシーケンスとして比較されます。同じ型のコレクションは一般的にキーセットを比較し、それらが==
であれば、各キーの値を比較し、すべてのペアが==
であればtrueを返します。他のプロパティは通常考慮されません(例えば、正確な型など)。
この演算子は浮動小数点数に対してIEEEのセマンティクスに従います:0.0 == -0.0
およびNaN != NaN
。
結果はBool
型ですが、オペランドの一方がmissing
である場合はmissing
が返されます(三値論理)。コレクションは一般的にall
に似た三値論理を実装し、いずれかのオペランドにmissing値が含まれている場合はmissingを返し、他のすべてのペアが等しい場合にのみ等しいと見なします。常にBool
型の結果を得るには、isequal
または===
を使用してください。
実装
新しい数値型は、この関数を新しい型の2つの引数に対して実装し、可能な限り昇格ルールを介して他の型との比較を処理するべきです。
isequal
は==
にフォールバックするため、==
の新しいメソッドはDict
型によってキーを比較するために使用されます。あなたの型が辞書のキーとして使用される場合、それはしたがってhash
も実装するべきです。
もしある型が==
、isequal
、およびisless
を定義している場合、それは比較の一貫性を確保するために<
も実装するべきです。
Base.:!=
— Function!=(x, y)
≠(x,y)
不等比較演算子。常に ==
の逆の答えを返します。
実装
新しい型は一般的にこれを実装せず、代わりにフォールバック定義 !=(x,y) = !(x==y)
に依存すべきです。
例
julia> 3 != 2
true
julia> "foo" ≠ "foo"
false
!=(x)
引数を x
と比較する関数を作成します !=
を使用して、すなわち y -> y != x
に相当する関数です。返される関数は Base.Fix2{typeof(!=)}
型であり、特化したメソッドを実装するために使用できます。
Base.:!==
— Function!==(x, y)
≢(x,y)
常に ===
の逆の答えを返します。
例
julia> a = [1, 2]; b = [1, 2];
julia> a ≢ b
true
julia> a ≢ a
false
Base.:<
— Function<(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(<)}
型であり、特化したメソッドを実装するために使用できます。
Base.:<=
— Function<=(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(<=)}
型であり、特化したメソッドを実装するために使用できます。
Base.:>
— Function>(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(>)}
型であり、特化したメソッドを実装するために使用できます。
Base.:>=
— Function>=(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(>=)}
型であり、特化したメソッドを実装するために使用できます。
Base.cmp
— Functioncmp(x,y)
x
がy
より小さい場合は-1、等しい場合は0、大きい場合は1を返します。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)
x
がy
より小さい場合は-1、等しい場合は0、大きい場合は1を返します。最初の引数は使用する小なり比較関数を指定します。
cmp(a::AbstractString, b::AbstractString) -> Int
2つの文字列を比較します。両方の文字列が同じ長さで、各インデックスの文字が両方の文字列で同じであれば 0
を返します。a
が b
の接頭辞である場合、または a
がアルファベット順で b
の前に来る場合は -1
を返します。b
が a
の接頭辞である場合、または b
がアルファベット順で a
の前に来る場合は 1
を返します(技術的には、Unicode コードポイントによる辞書順です)。
例
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
Base.:~
— FunctionBase.:&
— Functionx & y
ビット単位のAND。 三値論理を実装しており、片方のオペランドがmissing
で、もう片方がtrue
の場合はmissing
を返します。関数適用形式のために括弧を追加します: (&)(x, y)
。
例
julia> 4 & 10
0
julia> 4 & 12
4
julia> true & missing
missing
julia> false & missing
false
Base.:|
— Functionx | y
ビット単位の論理和。 三値論理を実装しており、片方のオペランドがmissing
で、もう片方がfalse
の場合はmissing
を返します。
例
julia> 4 | 10
14
julia> 4 | 1
5
julia> true | missing
true
julia> false | missing
missing
Base.xor
— Functionxor(x, y)
⊻(x, y)
x
と y
のビット単位の排他的論理和。引数の一方が missing
の場合、missing
を返す 三値論理 を実装しています。
中置演算 a ⊻ b
は xor(a,b)
の同義語であり、⊻
は Julia REPL で \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
Base.nand
— Functionnand(x, y)
⊼(x, y)
x
と y
のビット単位の nand (not and)。引数の一方が missing
の場合は missing
を返す 三値論理 を実装しています。
中置演算 a ⊼ b
は nand(a,b)
の同義語であり、⊼
は Julia REPL で \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
Base.nor
— Functionnor(x, y)
⊽(x, y)
x
と y
のビット単位のノル(not or)。三値論理を実装しており、引数の一方が missing
で他方が true
でない場合は missing
を返します。
中置演算子 a ⊽ b
は nor(a,b)
の同義語であり、⊽
は Julia REPL で \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
Base.:!
— Function!(x)
ブールの否定。 missing
が x
が 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: |-| < ⇒ |()-()| < "
Julia 1.9以降、!f
は匿名関数の代わりに ComposedFunction
を返します。
&&
— Keywordx && y
ショートサーキットブールAND。
関連項目としては、&
、三項演算子 ? :
、および制御フローに関するマニュアルのセクションがあります。
例
julia> x = 3;
julia> x > 1 && x < 10 && x isa Int
true
julia> x < 0 && error("expected positive x")
false
||
— Keywordx || y
ショートサーキットブールOR。
例
julia> pi < 3 || ℯ < 3
true
julia> false || true || println("neither is true!")
true
Mathematical Functions
Base.isapprox
— Functionisapprox(x, y; atol::Real=0, rtol::Real=atol>0 ? 0 : √eps, nans::Bool=false[, norm::Function])
不正確な等価比較。2つの数は、相対距離または絶対距離が許容範囲内である場合に等しいと比較されます:isapprox
はnorm(x-y) <= max(atol, rtol*max(norm(x), norm(y)))
が成り立つ場合にtrue
を返します。デフォルトのatol
(絶対許容誤差)はゼロで、デフォルトのrtol
(相対許容誤差)はx
とy
の型に依存します。キーワード引数nans
は、NaN値が等しいと見なされるかどうかを決定します(デフォルトはfalseです)。
実数または複素数の浮動小数点値の場合、atol > 0
が指定されていない場合、rtol
はx
またはy
の型のeps
の平方根にデフォルト設定され、どちらか大きい方(最も精度が低い)になります。これは、約半分の有効桁の等価性を要求することに相当します。それ以外の場合、例えば整数引数の場合やatol > 0
が指定されている場合、rtol
はゼロにデフォルト設定されます。
norm
キーワードは、数値の(x,y)
の場合はabs
に、配列の場合はLinearAlgebra.norm
にデフォルト設定されます(代替のnorm
の選択が時々便利です)。x
とy
が配列の場合、norm(x-y)
が有限でない場合(すなわち±Inf
またはNaN
)、比較はx
とy
のすべての要素が成分ごとにほぼ等しいかどうかを確認することに戻ります。
二項演算子≈
は、デフォルトの引数を持つisapprox
と同等であり、x ≉ y
は!isapprox(x,y)
と同等です。
x ≈ 0
(すなわち、デフォルトの許容誤差でゼロと比較すること)は、デフォルトのatol
が0
であるため、x == 0
と同等です。このような場合、適切なatol
を指定するか(またはnorm(x) ≤ atol
を使用するか)、コードを再配置する必要があります(例えば、x - y ≈ 0
ではなくx ≈ y
を使用する)。非ゼロのatol
を自動的に選択することはできません。なぜなら、それは問題の全体的なスケーリング(「単位」)に依存するからです:例えば、x - y ≈ 0
において、atol=1e-9
はx
がメートル単位の地球の半径である場合には非常に小さな許容誤差ですが、x
がメートル単位の水素原子の半径である場合には非常に大きな許容誤差です。
例
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
と同じです。
Base.sin
— Methodsin(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
Base.cos
— MethodBase.Math.sincos
— MethodBase.tan
— Methodtan(x)
x
がラジアンであるときのx
のタンジェントを計算します。
Base.Math.sind
— FunctionBase.Math.cosd
— FunctionBase.Math.tand
— FunctionBase.Math.sincosd
— FunctionBase.Math.sinpi
— FunctionBase.Math.cospi
— Functioncospi(x)
\[\cos(\pi x)\]
を、特に大きな$x$に対して、cos(pi*x)
よりも正確に計算します。
Base.Math.tanpi
— Functiontanpi(x)
\[\tan(\pi x)\]
をtan(pi*x)
よりも正確に計算します。特に大きなx
に対して。
Base.Math.sincospi
— FunctionBase.sinh
— Methodsinh(x)
x
の双曲線正弦を計算します。
Base.cosh
— Methodcosh(x)
x
の双曲線コサインを計算します。
Base.tanh
— Methodtanh(x)
x
の双曲線正接を計算します。
例
julia> tanh.(-3:3f0) # ここで 3f0 は 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
Base.asin
— Methodasin(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)
Base.acos
— Methodacos(x)
x
の逆余弦を計算します。出力はラジアンで表示されます。
Base.atan
— Methodatan(y)
atan(y, x)
y
または y/x
の逆タンジェントを計算します。
1つの実引数の場合、これは正の x 軸と点 (1, y) の間のラジアンでの角度であり、$[-\pi/2, \pi/2]$ の範囲の値を返します。
2つの引数の場合、これは正の x 軸と点 (x, y) の間のラジアンでの角度であり、$[-\pi, \pi]$ の範囲の値を返します。これは標準の atan2
関数に対応します。慣例として atan(0.0,x)
は $\pi$ と定義され、atan(-0.0,x)
は x < 0
の場合に $-\pi$ と定義されます。
度数法については atand
を参照してください。
例
julia> rad2deg(atan(-1/√3))
-30.000000000000004
julia> rad2deg(atan(-1, √3))
-30.000000000000004
julia> rad2deg(atan(1, -√3))
150.0
Base.Math.asind
— FunctionBase.Math.acosd
— FunctionBase.Math.atand
— FunctionBase.Math.sec
— Methodsec(x)
x
がラジアンであるとき、x
のセカントを計算します。
Base.Math.csc
— Methodcsc(x)
x
がラジアンであるとき、x
の余弦を計算します。
Base.Math.cot
— Methodcot(x)
x
がラジアンであるとき、x
のコタンジェントを計算します。
Base.Math.secd
— Functionsecd(x)
x
が度数であるときのx
のセカントを計算します。
Base.Math.cscd
— Functioncscd(x)
x
が度数であるときのx
の余弦の逆数を計算します。
Base.Math.cotd
— Functioncotd(x)
x
が度数であるとき、x
のコタンジェントを計算します。
Base.Math.asec
— Methodasec(x)
x
の逆セカントを計算します。出力はラジアンで表示されます。
Base.Math.acsc
— Methodacsc(x)
x
の逆コセカントを計算します。出力はラジアンで表示されます。
Base.Math.acot
— Methodacot(x)
x
の逆コタンジェントを計算します。出力はラジアンで表されます。
Base.Math.asecd
— FunctionBase.Math.acscd
— FunctionBase.Math.acotd
— FunctionBase.Math.sech
— Methodsech(x)
x
の双曲線セカントを計算します。
Base.Math.csch
— Methodcsch(x)
x
の双曲線余割のコセカントを計算します。
Base.Math.coth
— Methodcoth(x)
x
の双曲線コタンジェントを計算します。
Base.asinh
— Methodasinh(x)
x
の逆双曲線正弦を計算します。
Base.acosh
— Methodacosh(x)
x
の逆双曲線コサインを計算します。
Base.atanh
— Methodatanh(x)
x
の逆双曲線タンジェントを計算します。
Base.Math.asech
— Methodasech(x)
x
の逆双曲線セカントを計算します。
Base.Math.acsch
— Methodacsch(x)
x
の逆双曲線余割を計算します。
Base.Math.acoth
— Methodacoth(x)
x
の逆双曲線コタンジェントを計算します。
Base.Math.sinc
— Functionsinc(x)
正規化されたsinc関数 $\operatorname{sinc}(x) = \sin(\pi x) / (\pi x)$ を計算します。ただし、$x \neq 0$ の場合、$x = 0$ の場合は $1$ です。
他に cosc
とその導関数も参照してください。
Base.Math.cosc
— Functioncosc(x)
\[x \neq 0\]
の場合は $\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)$ を計算し、$x = 0$ の場合は $0$ を返します。これは sinc(x)
の導関数です。
詳細は sinc
を参照してください。
Base.Math.deg2rad
— FunctionBase.Math.rad2deg
— FunctionBase.Math.hypot
— Functionhypot(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はオーバーフローします
ERROR: DomainError with -2.914184810805068e18:
sqrtは負の実引数で呼び出されましたが、複素引数で呼び出された場合にのみ複素結果を返します。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
Base.log
— Methodlog(x)
x
の自然対数を計算します。
負のReal
引数に対してはDomainError
をスローします。複素数引数を使用して複素数結果を得てください。負の実軸に沿って分岐切断があり、-0.0im
は軸の下にあると見なされます。
他にℯ
、log1p
、log2
、log10
も参照してください。
例
julia> log(2)
0.6931471805599453
julia> log(-3)
ERROR: DomainError with -3.0:
logは負の実引数で呼び出されましたが、複素引数で呼び出された場合にのみ複素結果を返します。log(Complex(x))を試してください。
Stacktrace:
[1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]
julia> log(-3 + 0im)
1.0986122886681098 + 3.141592653589793im
julia> log(-3 - 0.0im)
1.0986122886681098 - 3.141592653589793im
julia> log.(exp.(-1:1))
3-element Vector{Float64}:
-1.0
0.0
1.0
Base.log
— Methodlog(b,x)
x
の底b
の対数を計算します。負のReal
引数に対してはDomainError
をスローします。
例
julia> log(4,8)
1.5
julia> log(4,2)
0.5
julia> log(-2, 3)
ERROR: DomainError with -2.0:
logは負の実引数で呼び出されましたが、複素引数で呼び出された場合にのみ複素結果を返します。log(Complex(x))を試してください。
Stacktrace:
[1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]
julia> log(2, -3)
ERROR: DomainError with -3.0:
logは負の実引数で呼び出されましたが、複素引数で呼び出された場合にのみ複素結果を返します。log(Complex(x))を試してください。
Stacktrace:
[1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]
Base.log2
— Functionlog2(x)
x
の底2の対数を計算します。負のReal
引数に対してはDomainError
をスローします。
例
julia> log2(4)
2.0
julia> log2(10)
3.321928094887362
julia> log2(-2)
ERROR: DomainError with -2.0:
log2は負の実引数で呼び出されましたが、複素引数で呼び出された場合にのみ複素結果を返します。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
Base.log10
— Functionlog10(x)
x
の底10の対数を計算します。負のReal
引数に対してはDomainError
をスローします。
例
julia> log10(100)
2.0
julia> log10(2)
0.3010299956639812
julia> log10(-2)
ERROR: DomainError with -2.0:
log10は負の実引数で呼び出されましたが、複素引数で呼び出された場合にのみ複素結果を返します。log10(Complex(x))を試してください。
Stacktrace:
[1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]
Base.log1p
— Functionlog1p(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
[...]
Base.Math.frexp
— Functionfrexp(val)
x
が$[1/2, 1)$または0の範囲にあるように、(x,exp)
を返します。そして、val
は$x \times 2^{exp}$に等しくなります。
関連情報としては、significand
、exponent
、ldexp
があります。
例
julia> frexp(6.0)
(0.75, 3)
julia> significand(6.0), exponent(6.0) # [1, 2)の範囲に代わり
(1.5, 2)
julia> frexp(0.0), frexp(NaN), frexp(-Inf) # 指数はエラーを返します
((0.0, 0), (NaN, 0), (-Inf, 0))
Base.exp
— Methodexp(x)
x
の自然基底指数を計算します。言い換えれば、$ℯ^x$です。
例
julia> exp(1.0)
2.718281828459045
julia> exp(im * pi) ≈ cis(pi)
true
Base.exp2
— Functionexp2(x)
x
の底2指数を計算します。言い換えれば、$2^x$です。
例
julia> exp2(5)
32.0
julia> 2^5
32
julia> exp2(63) > typemax(Int)
true
Base.exp10
— Functionexp10(x)
x
の10を底とする指数を計算します。言い換えれば、$10^x$です。
例
julia> exp10(2)
100.0
julia> 10^2
100
Base.Math.ldexp
— FunctionBase.Math.modf
— Functionmodf(x)
数の小数部分と整数部分のタプル (fpart, ipart)
を返します。両方の部分は引数と同じ符号を持ちます。
例
julia> modf(3.5)
(0.5, 3.0)
julia> modf(-3.5)
(-0.5, -3.0)
Base.expm1
— Functionexpm1(x)
正確に $e^x-1$ を計算します。これは、xの小さい値に対するexp(x)-1の直接評価に伴う精度の損失を回避します。
例
julia> expm1(1e-16)
1.0e-16
julia> exp(1e-16) - 1
0.0
Base.round
— Functionround([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の分数値)は最も近い偶数の整数に四捨五入されます。グローバルな四捨五入モードが変更されると、round
が不正確な結果を返す可能性があることに注意してください(rounding
を参照)。
浮動小数点型に四捨五入する場合、その型で表現可能な整数(および Inf)に四捨五入され、真の整数には四捨五入されません。Inf は「最も近い」を決定する目的で floatmax(T)
よりも1 ulp大きいものとして扱われます。これは convert
に似ています。
例
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> round(Float16, typemax(UInt128))
Inf16
julia> floor(Float16, typemax(UInt128))
Float16(6.55e4)
2以外の基数で指定された桁数に四捨五入することは、バイナリ浮動小数点数で操作する場合に不正確な場合があります。たとえば、1.15
で表される Float64
の値は実際には 1.15 よりも 小さい ですが、1.2 に四捨五入されます。例えば:
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)
を定義するだけで十分です。
Base.Rounding.RoundingMode
— TypeRoundingMode
浮動小数点演算の丸めモードを制御するために使用される型(rounding
/setrounding
関数を介して)、または最も近い整数に丸めるためのオプション引数として(round
関数を介して)。
現在サポートされている丸めモードは次のとおりです:
Base.Rounding.RoundNearest
— ConstantRoundNearest
デフォルトの丸めモードです。最も近い整数に丸められ、引き分け(0.5の分数値)は最も近い偶数に丸められます。
Base.Rounding.RoundNearestTiesAway
— ConstantRoundNearestTiesAway
最も近い整数に丸め、ゼロから離れる方向に丸めます(C/C++ round
の動作)。
Base.Rounding.RoundNearestTiesUp
— ConstantRoundNearestTiesUp
最も近い整数に丸めます。結びつきがある場合は、正の無限大に向かって丸めます(Java/JavaScript round
の動作)。
Base.Rounding.RoundToZero
— ConstantBase.Rounding.RoundFromZero
— ConstantRoundFromZero
ゼロから離れるように丸めます。
例
julia> BigFloat("1.0000000000000001", 5, RoundFromZero)
1.06
Base.Rounding.RoundUp
— ConstantBase.Rounding.RoundDown
— ConstantBase.round
— Methodround(z::Complex[, RoundingModeReal, [RoundingModeImaginary]])
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; digits=0, base=10)
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; sigdigits, base=10)
複素数 z
に対して同じ型の最も近い整数値を返します。指定された RoundingMode
を使用して、結びつきを解消します。最初の RoundingMode
は実数成分の丸めに使用され、2 番目は虚数成分の丸めに使用されます。
RoundingModeReal
と RoundingModeImaginary
はデフォルトで RoundNearest
に設定されており、これは最も近い整数に丸めます。結びつき(0.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
Base.ceil
— Functionceil([T,] x)
ceil(x; digits::Integer= [, base = 10])
ceil(x; sigdigits::Integer= [, base = 10])
ceil(x)
は、x
以上の同じ型の最も近い整数値を返します。
ceil(T, x)
は結果を型 T
に変換し、切り上げた値が T
として表現できない場合は InexactError
をスローします。
キーワード digits
、sigdigits
および base
は round
と同様に機能します。
新しい型の ceil
をサポートするには、Base.round(x::NewType, ::RoundingMode{:Up})
を定義します。
Base.floor
— Functionfloor([T,] x)
floor(x; digits::Integer= [, base = 10])
floor(x; sigdigits::Integer= [, base = 10])
floor(x)
は、x
以下の同じ型の最も近い整数値を返します。
floor(T, x)
は、結果を型 T
に変換し、切り捨てた値が T
で表現できない場合は InexactError
をスローします。
キーワード digits
、sigdigits
および base
は round
と同様に機能します。
新しい型に対して floor
をサポートするには、Base.round(x::NewType, ::RoundingMode{:Down})
を定義します。
Base.trunc
— Functiontrunc([T,] x)
trunc(x; digits::Integer= [, base = 10])
trunc(x; sigdigits::Integer= [, base = 10])
trunc(x)
は、x
の絶対値以下の同じ型の最も近い整数値を返します。
trunc(T, x)
は結果を型 T
に変換し、切り捨てた値が T
で表現できない場合は InexactError
をスローします。
キーワード digits
、sigdigits
および base
は round
と同様に機能します。
新しい型に対して trunc
をサポートするには、Base.round(x::NewType, ::RoundingMode{:ToZero})
を定義します。
関連項目: %
、floor
、unsigned
、unsafe_trunc
。
例
julia> trunc(2.22)
2.0
julia> trunc(-2.22, digits=1)
-2.2
julia> trunc(Int, -2.22)
-2
Base.unsafe_trunc
— Functionunsafe_trunc(T, x)
型 T
の絶対値が x
の絶対値以下である最も近い整数値を返します。値が T
で表現できない場合は、任意の値が返されます。詳細は trunc
を参照してください。
例
julia> unsafe_trunc(Int, -2.2)
-2
julia> unsafe_trunc(Int, NaN)
-9223372036854775808
Base.min
— Functionmin(x, y, ...)
引数の最小値をisless
に従って返します。引数のいずれかがmissing
である場合、missing
を返します。コレクションから最小要素を取得するには、minimum
関数も参照してください。
例
julia> min(2, 5, 1)
1
julia> min(4, missing, 6)
missing
Base.max
— Functionmax(x, y, ...)
引数の最大値をisless
に基づいて返します。引数のいずれかがmissing
である場合、missing
を返します。コレクションから最大要素を取得するには、maximum
関数も参照してください。
例
julia> max(2, 5, 1)
5
julia> max(5, missing, 6)
missing
Base.minmax
— Functionminmax(x, y)
返す (min(x,y), max(x,y))
。
また、extrema
[@ref]を参照してください。これは (minimum(x), maximum(x))
を返します。
例
julia> minmax('c','b')
('b', 'c')
Base.clamp
— Functionclamp(x, lo, hi)
lo <= x <= hi
の場合は x
を返します。x > hi
の場合は hi
を返します。x < lo
の場合は lo
を返します。引数は共通の型に昇格されます。
例
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) # 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
Base.clamp!
— Functionclamp!(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
Base.abs
— Functionabs(x)
x
の絶対値。
abs
が符号付き整数に適用されると、オーバーフローが発生する可能性があり、その結果、負の値が返されることがあります。このオーバーフローは、abs
が符号付き整数の最小表現可能値に適用される場合にのみ発生します。つまり、x == typemin(typeof(x))
のとき、abs(x) == x < 0
となり、期待される-x
ではありません。
例
julia> abs(-3)
3
julia> abs(1 + im)
1.4142135623730951
julia> abs.(Int8[-128 -127 -126 0 126 127]) # typemin(Int8)でオーバーフロー
1×6 Matrix{Int8}:
-128 127 126 0 126 127
julia> maximum(abs, [1, -2, 3, -4])
4
Base.Checked
— ModuleChecked
Checkedモジュールは、オーバーフローが発生したときにエラーをスローする組み込みの符号付きおよび符号なし整数型のための算術関数を提供します。これらはchecked_sub
、checked_div
などのように名付けられています。さらに、add_with_overflow
、sub_with_overflow
、mul_with_overflow
は、未チェックの結果とオーバーフローの存在を示すブール値の両方を返します。
Base.Checked.checked_abs
— FunctionBase.checked_abs(x)
abs(x)
を計算し、適用可能な場合はオーバーフローエラーをチェックします。たとえば、標準の二の補数符号付き整数(例:Int
)はabs(typemin(Int))
を表現できないため、オーバーフローが発生します。
オーバーフロー保護は、目に見えるパフォーマンスペナルティを課す可能性があります。
Base.Checked.checked_neg
— FunctionBase.checked_neg(x)
-x
を計算し、適用可能な場合はオーバーフローエラーをチェックします。たとえば、標準の二の補数符号付き整数(例:Int
)は-typemin(Int)
を表現できないため、オーバーフローが発生します。
オーバーフロー保護は、目に見えるパフォーマンスペナルティを課す可能性があります。
Base.Checked.checked_add
— FunctionBase.checked_add(x, y)
x+y
を計算し、適用可能な場合はオーバーフローエラーをチェックします。
オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。
Base.Checked.checked_sub
— FunctionBase.checked_sub(x, y)
x-y
を計算し、適用可能な場合はオーバーフローエラーをチェックします。
オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。
Base.Checked.checked_mul
— FunctionBase.checked_mul(x, y)
x*y
を計算し、適用可能な場合はオーバーフローエラーをチェックします。
オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。
Base.Checked.checked_div
— FunctionBase.checked_div(x, y)
div(x,y)
を計算し、適用可能な場合はオーバーフローエラーをチェックします。
オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。
Base.Checked.checked_rem
— FunctionBase.checked_rem(x, y)
x%y
を計算し、適用可能な場合はオーバーフローエラーをチェックします。
オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。
Base.Checked.checked_fld
— FunctionBase.checked_fld(x, y)
fld(x,y)
を計算し、適用可能な場合はオーバーフローエラーをチェックします。
オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。
Base.Checked.checked_mod
— FunctionBase.checked_mod(x, y)
mod(x,y)
を計算し、適用可能な場合はオーバーフローエラーをチェックします。
オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。
Base.Checked.checked_cld
— FunctionBase.checked_cld(x, y)
cld(x,y)
を計算し、適用可能な場合はオーバーフローエラーをチェックします。
オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。
Base.Checked.checked_pow
— FunctionBase.checked_pow(x, y)
^(x,y)
を計算し、適用可能な場合はオーバーフローエラーをチェックします。
オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。
Base.Checked.add_with_overflow
— FunctionBase.add_with_overflow(x, y) -> (r, f)
r = x+y
を計算し、フラグ f
はオーバーフローが発生したかどうかを示します。
Base.Checked.sub_with_overflow
— FunctionBase.sub_with_overflow(x, y) -> (r, f)
r = x-y
を計算し、フラグ f
はオーバーフローが発生したかどうかを示します。
Base.Checked.mul_with_overflow
— FunctionBase.mul_with_overflow(x, y) -> (r, f)
r = x*y
を計算し、オーバーフローが発生したかどうかを示すフラグ f
を返します。
Base.abs2
— Functionabs2(x)
x
の二乗絶対値。
これは、特にabs(x)
がhypot
を介して平方根を必要とする複素数の場合、abs(x)^2
よりも速くなることがあります。
例
julia> abs2(-3)
9
julia> abs2(3.0 + 4.0im)
25.0
julia> sum(abs2, [1+2im, 3+4im]) # LinearAlgebra.norm(x)^2
30
Base.copysign
— Functioncopysign(x, y) -> z
z
を返します。z
はx
の大きさを持ち、y
と同じ符号を持ちます。
例
julia> copysign(1, -2)
-1
julia> copysign(-1, 2)
1
Base.sign
— Functionsign(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
Base.signbit
— Functionsignbit(x)
x
の符号の値が負であればtrue
を返し、そうでなければfalse
を返します。
例
julia> signbit(-4)
true
julia> signbit(5)
false
julia> signbit(5.5)
false
julia> signbit(-4.1)
true
Base.flipsign
— Functionflipsign(x, y)
y
が負の場合、x
の符号を反転させて返します。例えば abs(x) = flipsign(x,x)
。
例
julia> flipsign(5, 3)
5
julia> flipsign(5, -3)
-5
Base.sqrt
— Methodsqrt(x)
返す $\sqrt{x}$。
負の Real
引数に対して DomainError
をスローします。代わりに複素数の負の引数を使用してください。sqrt
は負の実数軸に沿った分岐切断を持つことに注意してください。
接頭辞演算子 √
は 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> sqrt(-81 - 0.0im) # -0.0im は分岐切断の下にあります
0.0 - 9.0im
julia> .√(1:4)
4-element Vector{Float64}:
1.0
1.4142135623730951
1.7320508075688772
2.0
Base.isqrt
— Functionisqrt(n::Integer)
整数の平方根: m*m <= n
を満たす最大の整数 m
。
julia> isqrt(5)
2
Base.Math.cbrt
— Methodcbrt(x::Real)
x
の立方根を返します。すなわち、$x^{1/3}$です。負の値も受け付けます($x < 0$のときは負の実数の根を返します)。
接頭辞演算子∛
はcbrt
と同等です。
例
julia> cbrt(big(27))
3.0
julia> cbrt(big(-27))
-3.0
Base.real
— Functionreal(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
がゼロ次元の場合はスカラーではなく0次元の配列が返されます。
例
julia> real([1, 2im, 3 + 4im])
3-element Vector{Int64}:
1
0
3
julia> real(fill(2 - im))
0-dimensional Array{Int64, 0}:
2
Base.imag
— Functionimag(A::AbstractArray)
配列 A
の各エントリの虚部を含む配列を返します。
imag.(A)
と同等ですが、A
がゼロ次元の場合はスカラーではなく、0次元の配列が返されます。
例
julia> imag([1, 2im, 3 + 4im])
3-element Vector{Int64}:
0
2
4
julia> imag(fill(2 - im))
0-dimensional Array{Int64, 0}:
-1
Base.reim
— Functionreim(z)
複素数 z
の実部と虚部のタプルを返します。
例
julia> reim(1 + 3im)
(1, 3)
reim(A::AbstractArray)
A
の各エントリの実部と虚部をそれぞれ含む2つの配列のタプルを返します。
(real.(A), imag.(A))
と同等ですが、eltype(A) <: Real
の場合、実部を表すためにA
はコピーされずに返され、A
がゼロ次元の場合はスカラーの代わりに0次元の配列が返されます。
例
julia> reim([1, 2im, 3 + 4im])
([1, 0, 3], [0, 2, 4])
julia> reim(fill(2 - im))
(fill(2), fill(-1))
Base.conj
— Functionconj(A::AbstractArray)
配列 A
の各エントリの複素共役を含む配列を返します。
conj.(A)
と同等ですが、eltype(A) <: Real
の場合は A
がコピーされずに返され、A
がゼロ次元の場合はスカラーではなく0次元の配列が返されます。
例
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
Base.angle
— Functionangle(z)
複素数 z
の位相角をラジアンで計算します。
-pi ≤ angle(z) ≤ pi
の数を返し、したがって負の実軸に沿って不連続です。
例
julia> rad2deg(angle(1 + im))
45.0
julia> rad2deg(angle(1 - im))
-45.0
julia> rad2deg(angle(-1 + 1e-20im))
180.0
julia> rad2deg(angle(-1 - 1e-20im))
-180.0
Base.cis
— Functioncis(x)
オイラーの公式を使用した exp(im*x)
のより効率的な方法: $\cos(x) + i \sin(x) = \exp(i x)$。
関連項目としては cispi
, sincos
, exp
, angle
があります。
例
julia> cis(π) ≈ -1
true
Base.cispi
— Functioncispi(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
Base.binomial
— Functionbinomial(n::Integer, k::Integer)
二項係数 $\binom{n}{k}$ は、$(1+x)^n$ の多項式展開における $k$ 番目の項の係数です。
\[n\]
が非負の場合、これは $n$ 個のアイテムから k
個を選ぶ方法の数です:
\[\binom{n}{k} = \frac{n!}{k! (n-k)!}\]
ここで $n!$ は factorial
関数です。
\[n\]
が負の場合、これは次の恒等式に基づいて定義されます:
\[\binom{n}{k} = (-1)^k \binom{k-n-1}{k}\]
詳細は factorial
を参照してください。
例
julia> binomial(5, 3)
10
julia> factorial(5) ÷ (factorial(5-3) * factorial(3))
10
julia> binomial(-5, 3)
-35
外部リンク
- 二項係数 の Wikipedia。
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 のような外部パッケージで利用可能です。
外部リンク
- 二項係数 - Wikipedia.
Base.factorial
— Functionfactorial(n::Integer)
n
の階乗。n
がInteger
の場合、階乗は整数として計算されます(少なくとも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
外部リンク
- Factorial on Wikipedia.
```
Base.gcd
— Functiongcd(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
Base.lcm
— Functionlcm(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
Base.gcdx
— Functiongcdx(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)
Base.ispow2
— Functionispow2(n::Number) -> Bool
n
が整数の2の累乗であるかどうかをテストします。
関連情報としては 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
Base.nextpow
— Functionnextpow(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
Base.prevpow
— Functionprevpow(a, x)
x
以下の最大のa^n
、ここでn
は非負整数です。a
は1より大きく、x
は1未満であってはなりません。
例
julia> prevpow(2, 7)
4
julia> prevpow(2, 9)
8
julia> prevpow(5, 20)
5
julia> prevpow(4, 16)
16
Base.nextprod
— Functionnextprod(factors::Union{Tuple,AbstractVector}, n)
n
以上の次の整数で、factors
の因子$k_i$に対して整数$p_1$, $p_2$などを用いて$\prod k_i^{p_i}$と書くことができる。
例
julia> nextprod((2, 3), 105)
108
julia> 2^2 * 3^3
108
Base.invmod
— Functioninvmod(n::Integer, m::Integer)
m
を法としたn
の逆元を取ります:$n y = 1 \pmod m$となるy
で、$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
invmod(n::Integer, T) where {T <: Base.BitInteger}
invmod(n::T) where {T <: Base.BitInteger}
整数環の型 T
における n
の剰余逆数を計算します。すなわち、2^N
で割った剰余であり、ここで N = 8*sizeof(T)
(例えば、Int32
の場合は N = 32
)です。言い換えれば、これらのメソッドは次の等式を満たします:
n * invmod(n) == 1
(n * invmod(n, T)) % T == 1
(n % T) * invmod(n, T) == 1
ここでの *
は整数環 T
における剰余乗算です。
整数型によって暗黙的に示される剰余を明示的な値として指定することは、剰余が定義上その型で表現できるには大きすぎるため、しばしば不便です。
剰余逆数は、https://arxiv.org/pdf/2204.04342.pdf で説明されているアルゴリズムを使用して、一般的なケースよりもはるかに効率的に計算されます。
Base.powermod
— Functionpowermod(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
Base.ndigits
— Functionndigits(n::Integer; base::Integer=10, pad::Integer=1)
整数 n
を基数 base
で表記したときの桁数を計算します(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
— FunctionBase.add_sum(x, y)
sum
で使用される還元演算子。+
との主な違いは、小さい整数がInt
/UInt
に昇格されることです。
Base.widemul
— Functionwidemul(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
Base.Math.evalpoly
— Functionevalpoly(x, p)
多項式 $\sum_k x^{k-1} p[k]$ を評価します。係数 p[1]
, p[2]
, ... が与えられ、x
の冪に対して昇順に並んでいます。係数の数が静的に知られている場合、すなわち p
が Tuple
の場合、ループはコンパイル時に展開されます。この関数は、x
が実数の場合はホーナー法を使用して効率的なコードを生成し、x
が複素数の場合はゴーツェルのような [DK62] アルゴリズムを使用します。
例
julia> evalpoly(2, (1, 2, 3))
17
Base.Math.@evalpoly
— Macro@evalpoly(z, c...)
多項式 $\sum_k z^{k-1} c[k]$ を係数 c[1]
, c[2]
, ... に対して評価します。すなわち、係数は z
の冪の昇順で与えられます。このマクロは、ホーナー法または、複素数 z
の場合はより効率的なゴーツェル類似アルゴリズムを使用する効率的なインラインコードに展開されます。
詳細は evalpoly
を参照してください。
例
julia> @evalpoly(3, 1, 0, 1)
10
julia> @evalpoly(2, 1, 0, 1)
5
julia> @evalpoly(2, 1, 1, 1)
7
Base.FastMath.@fastmath
— Macro@fastmath expr
式の変換されたバージョンを実行します。これは、厳密なIEEEセマンティクスに違反する可能性のある関数を呼び出します。これにより、可能な限り高速な操作が可能になりますが、結果は未定義です – これを行う際は注意が必要で、数値結果が変わる可能性があります。
これは、LLVM Fast-Mathフラグを設定し、clangの-ffast-math
オプションに対応します。詳細については、パフォーマンス注釈に関するノートを参照してください。
例
julia> @fastmath 1+2
3
julia> @fastmath(sin(3))
0.1411200080598672
Customizable binary operators
いくつかのUnicode文字を使用して、新しい二項演算子を定義することができ、これにより中置記法をサポートします。たとえば、⊗(x,y) = kron(x,y)
は、⊗
(テンソル積)関数をクロネッカー積として定義し、中置構文を使用して二項演算子として呼び出すことができます:C = A ⊗ B
、および通常の接頭辞構文C = ⊗(A,B)
でも呼び出すことができます。
他のこのような拡張をサポートする文字には \odot ⊙
と \oplus ⊕
が含まれます。
完全なリストはパーサーコードにあります: https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm
*
(優先順位の観点から)で解析されるものには、* / ÷ % & ⋅ ∘ × |\\| ∩ ∧ ⊗ ⊘ ⊙ ⊚ ⊛ ⊠ ⊡ ⊓ ∗ ∙ ∤ ⅋ ≀ ⊼ ⋄ ⋆ ⋇ ⋉ ⋊ ⋋ ⋌ ⋏ ⋒ ⟑ ⦸ ⦼ ⦾ ⦿ ⧶ ⧷ ⨇ ⨰ ⨱ ⨲ ⨳ ⨴ ⨵ ⨶ ⨷ ⨸ ⨻ ⨼ ⨽ ⩀ ⩃ ⩄ ⩋ ⩍ ⩎ ⩑ ⩓ ⩕ ⩘ ⩚ ⩜ ⩞ ⩟ ⩠ ⫛ ⊍ ▷ ⨝ ⟕ ⟖ ⟗
が含まれ、+
のように解析されるものには、+ - |\|| ⊕ ⊖ ⊞ ⊟ |++| ∪ ∨ ⊔ ± ∓ ∔ ∸ ≏ ⊎ ⊻ ⊽ ⋎ ⋓ ⟇ ⧺ ⧻ ⨈ ⨢ ⨣ ⨤ ⨥ ⨦ ⨧ ⨨ ⨩ ⨪ ⨫ ⨬ ⨭ ⨮ ⨹ ⨺ ⩁ ⩂ ⩅ ⩊ ⩌ ⩏ ⩐ ⩒ ⩔ ⩖ ⩗ ⩛ ⩝ ⩡ ⩢ ⩣
が含まれます。矢印、比較、累乗に関連する多くの他のものもあります。
- DK62Donald Knuth, Art of Computer Programming, Volume 2: Seminumerical Algorithms, Sec. 4.6.4.