Mathematics
Mathematical Operators
Base.:+ — Function
+(x, y...)加算演算子。
中置演算子 x+y+z+... は、すべての引数を使ってこの関数を呼び出します。つまり、+(x, y, z, ...) です。デフォルトでは、左から順に (x+y) + z + ... を呼び出します。
大きな数を加算すると、デフォルトの Int を含むほとんどの整数型でオーバーフローが発生する可能性があることに注意してください。
Examples
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
truedt::Date + t::Time -> DateTimeDateにTimeを加算すると、DateTimeが生成されます。Timeの時、分、秒、ミリ秒の各部分と、Dateの年、月、日の各部分を使って、新しいDateTimeを作成します。Time型のマイクロ秒またはナノ秒がゼロ以外の場合、InexactErrorがスローされます。
Base.:* — Method
*(x, y...)乗算演算子。
中置演算子 x*y*z*... は、すべての引数を使ってこの関数を呼び出します。つまり、*(x, y, z, ...) です。デフォルトでは、左から順に (x*y) * z * ... を呼び出します。
2pi のような隣接記法も *(2, pi) を呼び出します。この演算は、リテラル * より優先順位が高いことに注意してください。また、「0x...」の隣接記法(整数の 0 と、名前が x で始まる変数の積)は、符号なし整数リテラルと衝突するため使用できません。0x01 isa UInt8
大きな数を乗算すると、デフォルトの Int を含む、ほとんどの整数型でオーバーフローが発生する可能性があります。
Examples
julia> 2 * 7 * 8
112
julia> *(2, 7, 8)
112
julia> [2 0; 0 3] * [1, 10] # matrix * vector
2-element Vector{Int64}:
2
30
julia> 1/2pi, 1/2*pi # juxtaposition has higher precedence
(0.15915494309189535, 1.5707963267948966)
julia> x = [1, 2]; x'x # adjoint vector * vector
5Base.:/ — Function
/(x, y)右除算演算子:x に、y の逆元を右から乗算します。
整数を引数に指定すると、浮動小数点数の結果を返します。整数除算については ÷ を、Rational の結果については // を参照してください。
Examples
julia> 1/2
0.5
julia> 4/2
2.0
julia> 4.5/2
2.25A / B行列の右除算:A / B は、(B' \ A')' と等価です。ここで、\ は左除算演算子です。正方行列の場合、結果 X は A == X*B を満たします。
関連項目:rdiv!。
Examples
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))
trueBase.:^ — Method
^(x, y)べき乗演算子。
x と y が整数の場合、結果がオーバーフローすることがあります。科学表記で数値を入力するには、1.2 * 10^3 ではなく、Float64 のリテラル(1.2e3 など)を使用してください。
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 は正の値です。
Examples
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
trueBase.muladd — Function
muladd(x, y, z)積和演算:x*y+zを計算しますが、性能向上のため、加算と乗算を相互に、または周囲の演算と融合できるようにします。たとえば、ハードウェアが効率的にサポートしている場合、fmaとして実装されることがあります。結果はマシンによって異なる場合があり、定数伝播などの最適化によって、同じマシン上でも異なる場合があります。fmaを参照してください。
Examples
julia> muladd(3, 2, 1)
7
julia> 3 * 2 + 1
7muladd(A, y, z)行列と行列、または行列とベクトルの乗算に対する、積和演算 A*y .+ z です。結果のサイズは常に A*y と同じですが、z はそれより小さい場合や、スカラーの場合があります。
Examples
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.0Base.div — Method
div(x, y, r::RoundingMode=RoundToZero)ユークリッド(整数)除算による商です。x / yを、丸めモードrに従って整数に丸めて計算します。つまり、次の量を
round(x / y, r)中間丸めを行わずに計算します。
この関数の特殊なケースであるfldおよびcldも参照してください。
Examples:
julia> div(4, 3, RoundToZero) # Matches div(4, 3)
1
julia> div(4, 3, RoundDown) # Matches fld(4, 3)
1
julia> div(4, 3, RoundUp) # Matches 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)
-2div(x, y)は、浮動小数点数の真の値に基づいて厳密に正しい切り捨てを行うため、直感に反する結果になることがあります。たとえば、次のようになります。
julia> div(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に丸められますが、div(6.0, 0.1, RoundToZero)は常に真の値を切り捨てるため、結果は59.0になります。
Base.fld — Function
fld(x, y)x / y 以下の最大の整数。div(x, y, RoundDown) と同等です。
Examples
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 1fld(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.mod — Function
rem(x::Integer, T::Type{<:Integer})::T
mod(x::Integer, T::Type{<:Integer})::T
%(x::Integer, T::Type{<:Integer})::Ty が [typemin(T),typemax(T)] の整数であるとき、x ≡ y (mod n) を満たす y::T を求めます。ここで、n は T で表現可能な整数の個数です。T が任意の整数を表現できる場合(例:T == BigInt)、この演算は T への変換に相当します。
Examples
julia> x = 129 % Int8
-127
julia> typeof(x)
Int8
julia> x = 129 % BigInt
129
julia> typeof(x)
BigIntmod(x, y)
rem(x, y, RoundDown)xをyで割った余り。言い換えると、xをyで切り下げ除算したときの余りであり、中間丸めを行わずに計算した場合はx - y*fld(x,y)となります。
isfinite(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 2mod(x::Integer, r::AbstractUnitRange)範囲 r 内で、x ≡ y (mod n) を満たす y を求めます。ここで n = length(r)、つまり y = mod(x - first(r), n) + first(r) です。
mod1 も参照してください。
Examples
julia> mod(0, Base.OneTo(3)) # mod1(0, 3)
3
julia> mod(3, 0:2) # mod(3, 3)
0Base.rem — Method
rem(x, y, r::RoundingMode=RoundToZero)xをyで整数除算したときの余りを、丸めモード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も参照してください。
Examples:
julia> x = 9; y = 4;
julia> x % y # same as rem(x, y)
1
julia> x ÷ y # same as div(x, y)
2
julia> x == div(x, y) * y + rem(x, y)
trueBase.Math.rem2pi — Function
rem2pi(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も参照してください。
Examples
julia> rem2pi(7pi/4, RoundNearest)
-0.7853981633974485
julia> rem2pi(7pi/4, RoundDown)
5.497787143782138Base.Math.mod2pi — Function
mod2pi(x)2πで割った余りを、$[0,2π)$の範囲で返します。
この関数は、数値的に正確な2πで割った余りを浮動小数点数で表現して計算します。そのため、xを浮動小数点数2πで割った余りを計算するmod(x,2π)とは、厳密には異なります。
入力値の形式によっては、2πに最も近い表現可能な値が2πより小さくなることがあります。たとえば、式mod2pi(2π)は0を返しません。中間値2*πがFloat64であり、2*Float64(π) < 2*big(π)だからです。この動作をより細かく制御する方法については、rem2piを参照してください。
Examples
julia> mod2pi(9*pi/4)
0.7853981633974481Base.divrem — Function
divrem(x, y, r::RoundingMode=RoundToZero)ユークリッド除法による商と余り。(div(x, y, r), rem(x, y, r))と同等です。rのデフォルト値を使う場合、この呼び出しは(x ÷ y, x % y)と同等です。
Examples
julia> divrem(3, 7)
(0, 3)
julia> divrem(7, 3)
(2, 1)Base.fldmod — Function
fldmod(x, y)除算後の切り捨て商と剰余。divrem(x, y, RoundDown)の便利なラッパーです。(fld(x, y), mod(x, y))と同等です。
Base.mod1 — Function
mod1(x, y)床関数による除算の後の剰余を返します。返される値 r は、mod(r, y) == mod(x, y) となり、$(0, y]$ の範囲に入ります(y が正の場合)。$[y,0)$ の範囲に入ります(y が負の場合)。
整数の引数と正の y を指定した場合、これは mod(x, 1:y) と等しくなるため、1 始まりのインデックス付けに適しています。一方、mod(x, y) == mod(x, 0:y-1) は、オフセットやストライドを使った計算に適しています。
Examples
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.1Base.fldmod1 — Function
Base.:// — Function
//(num, den)2つの整数または有理数を除算し、Rationalの結果を返します。より一般には、//を使うと、整数成分または有理数成分を持つ複素数など、ほかの数値型についても正確な有理数除算を行えます。
浮動小数点数(AbstractFloat)は、値が有理数であっても、//では引数として使用できないことに注意してください。引数はInteger、Rational、またはそれらから構成される型のサブタイプである必要があります。
Examples
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 — Function
rationalize([T<:Integer=Int,] x; tol::Real=eps(x))浮動小数点数 x を、指定された整数型の成分を持つ Rational 数として近似します。結果と x との差は、tol 以下です。
Examples
julia> rationalize(5.6)
28//5
julia> a = rationalize(BigInt, 10.3)
103//10
julia> typeof(numerator(a))
BigIntBase.numerator — Function
numerator(x)x の有理数表現における分子。
Examples
julia> numerator(2//3)
2
julia> numerator(4)
4Base.denominator — Function
denominator(x)x の有理数表現の分母。
Examples
julia> denominator(2//3)
3
julia> denominator(4)
1Base.:<< — Function
<<(B::BitVector, n)::BitVector左ビットシフト演算子、B << n。n >= 0の場合、結果はBとなり、要素はn個分後方にシフトされ、空いた部分はfalseの値で埋められます。n < 0の場合、要素は前方にシフトされます。B >> -nと同等です。
Examples
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ビット左にシフトし、0で埋めたものです。これはx * 2^nと同等です。n < 0の場合、これはx >> -nと同等です。
Examples
julia> Int8(3) << 2
12
julia> bitstring(Int8(3))
"00000011"
julia> bitstring(Int8(12))
"00001100"Base.:>> — Function
>>(B::BitVector, n)::BitVector右ビットシフト演算子、B >> n。n >= 0の場合、結果はn個分前方にシフトされ、空いた要素にはfalse値が入ったBとなります。n < 0の場合、要素は後方にシフトされます。B << -nと同等です。
Examples
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 ビット右にシフトした値です。x >= 0 の場合は 0 で、x < 0 の場合は 1 で埋め、x の符号を保持します。これは fld(x, 2^n) と等価です。n < 0 の場合、これは x << -n と等価です。
Examples
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"Base.:>>> — Function
>>>(B::BitVector, n)::BitVector符号なし右ビットシフト演算子、B >>> n。B >> nと同等です。詳細と例については、>>を参照してください。
>>>(x, n)符号なし右ビットシフト演算子 x >>> n。n >= 0の場合、結果はxをnビット右にシフトし、0で埋めたものです。n < 0の場合、これはx << -nと同等です。
Unsigned整数型の場合、これは>>と同等です。Signed整数型の場合、これはsigned(unsigned(x) >> n)と同等です。
Examples
julia> Int8(-14) >>> 2
60
julia> bitstring(Int8(-14))
"11110010"
julia> bitstring(Int8(60))
"00111100"Base.bitrotate — Function
bitrotate(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.:(:) — Method
(:)(start, [step], stop)範囲演算子。a:b は、a から b まで、ステップ幅を +1 とする範囲を構築します。結果は次のとおりです。
aとbが整数の場合はUnitRangeaとbが文字の場合はStepRangeaおよび/またはbが浮動小数点数の場合はStepRangeLen
a:s:b も同様ですが、ステップ幅は s(StepRange または StepRangeLen)です。より細かく制御するには、range も参照してください。
降順の範囲を作成するには、reverse(a:b) または負のステップ幅を使用します(例:b:-1:a)。それ以外の場合、b < a では空の範囲が構築され、a:a-1 に正規化されます。
演算子 : は、インデックス指定で次元全体を選択する場合にも使用します。たとえば、A[:, 1] のようにします。
: は、コードの quote にも使用します。たとえば、:(x + y) isa Expr や :x isa Symbol です。:2 isa Int 以降、インデックス指定では範囲を作成しません。v[:2] == v[2] != v[begin:2]。
Base.:(:) — Method
(:)(start::CartesianIndex, [step::CartesianIndex], stop::CartesianIndex)2つのCartesianIndexと省略可能なステップからCartesianIndicesを構築します。
Examples
julia> I = CartesianIndex(2,1);
julia> J = CartesianIndex(3,3);
julia> I:J
CartesianIndices((2:3, 1:3))
julia> I:CartesianIndex(1, 2):J
CartesianIndices((2:1:3, 1:2:3))Base.range — Function
range(start, stop, length)
range(start, stop; length, step)
range(start; length, stop, step)
range(;start, length, stop, step)引数から、要素が等間隔に並び、効率的なストレージを使用する特殊な配列(AbstractRange)を構築します。数学的には、start、step、stop、lengthのうち任意の3つがあれば、範囲は一意に定まります。rangeの有効な呼び出し方は次のとおりです。
start、step、stop、lengthのうち任意の3つを指定して、rangeを呼び出します。start、stop、lengthのうち2つを指定して、rangeを呼び出します。この場合、stepは正の1とみなされます。両方の引数が整数の場合は、UnitRangeが返されます。stopまたはlengthのいずれかを指定して、rangeを呼び出します。startとstepは正の1とみなされます。
降順の範囲を作成するには、負のステップ幅を指定します。例:range(5, 1; step = -1) => [5,4,3,2,1]。それ以外の場合、stopの値がstartの値より小さく、stepの既定値が+1であれば、空の範囲が作成されます。空の範囲は、stopがstartより1小さくなるよう正規化されます。例:range(5, 1) == 5:4。
返される型の詳細については、拡張ヘルプを参照してください。対数間隔の点については、lograngeも参照してください。
Examples
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.0lengthが指定されておらず、stop - startがstepの整数倍でない場合、stopより前に終わる範囲が生成されます。
julia> range(1, 3.5, step=2)
1.0:2.0:3.0中間値が有理数として計算されるよう、特別な配慮がなされています。この処理によるオーバーヘッドを避けるには、LinRangeコンストラクターを参照してください。
Extended Help
引数が整数で、次のいずれかの場合、rangeはBase.OneToを生成します。
lengthのみが指定されているstopのみが指定されている
引数が整数で、次のいずれかの場合、rangeはUnitRangeを生成します。
startとstopのみが指定されているlengthとstopのみが指定されている
stepが指定されている場合、値として1を指定していても、UnitRangeは生成されません。
Base.OneTo — Type
Base.OneTo(n)AbstractUnitRangeを定義します。これは1:nと同様に動作しますが、下限が1であることが型システムによって保証される点が異なります。
Base.StepRangeLen — Type
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] ですが、別のインデックス 1 <= offset <= len に対する値として r[offset] を指定することもできます。a:b または a:b:c の構文では、a、b、c のいずれかが浮動小数点数の場合、StepRangeLen が作成されます。
Base.logrange — Function
logrange(start, stop, length)
logrange(start, stop; length)指定された両端の間に、要素が対数間隔で並ぶ特殊な配列を構築します。つまり、隣り合う要素の比は一定で、その値は配列の長さから計算されます。
Python の geomspace に似ています。Mathematica の PowerRange とは異なり、比ではなく要素数を指定します。また、Python や Matlab の logspace とは異なり、引数 start と stop は、何らかの底に適用する指数ではなく、常に結果の最初と最後の要素を表します。
Examples
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) # middle element is the geometric mean
true
julia> range(10, 40, length=3)[2] ≈ (10 + 40)/2 # arithmetic mean
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 — Type
LogRange{T}(start, stop, len) <: AbstractVector{T}要素がstartからstopまで対数間隔で並ぶ範囲です。間隔はlenで指定します。lograngeによって返されます。
LinRangeと同様に、最初と最後の要素は指定した値と完全に一致しますが、中間の値には小さな浮動小数点誤差が生じる場合があります。これらの値は端点の対数を使って計算されます。対数は構築時に保存され、Tより高精度であることもよくあります。
Examples
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 が返されます(three-valued logic)。コレクションは通常、all に似た三値論理を実装します。オペランドに missing 値が含まれていて、その他のすべての組が等しい場合は missing を返します。常に Bool の結果を得るには、isequal または === を使用してください。
Implementation
新しい数値型では、その型の引数を2つ取るこの関数を実装し、可能であれば昇格規則に従って他の型との比較も処理する必要があります。
等価性とハッシュは密接に関係しています。isequal と見なされる2つの値は、同じ hash を持たなければなりません。また、デフォルトでは isequal は == にフォールバックします。型が == や isequal の動作をカスタマイズする場合は、hash も同様に実装し、isequal と hash が一致するようにする必要があります。Sets、Dicts、およびその他多くの内部実装は、この不変条件が成り立つことを前提としています。
Base.:!= — Function
!=(x)引数を x と比較する関数を、!= を使って作成します。つまり、y -> y != x と同等の関数を作成します。返される関数の型は Base.Fix2{typeof(!=)} であり、これを使って特化メソッドを実装できます。
!=(x, y)
≠(x,y)等しくないことを比較する演算子です。常に==とは逆の結果を返します。
Implementation
新しい型では通常、この演算子を実装せず、フォールバック定義!=(x,y) = !(x==y)に依存してください。
Examples
julia> 3 != 2
true
julia> "foo" ≠ "foo"
falseBase.:< — Function
<(x)引数を x と比較する関数を、< を使って作成します。つまり、y -> y < x と同等の関数です。返される関数の型は Base.Fix2{typeof(<)} で、これを使って特化メソッドを実装できます。
<(x, y)小なり比較演算子。islessにフォールバックします。浮動小数点数のNaN値の性質上、この演算子が実装するのは半順序です。
Implementation
標準的な半順序を持つ新しい型では、その型の2つの引数を取るこの関数を実装してください。標準的な全順序を持つ型では、代わりにislessを実装してください。
isunorderedも参照してください。
Examples
julia> 'a' < 'b'
true
julia> "abc" < "abd"
true
julia> 5 < 3
falseBase.:> — Function
>(x)引数を x と比較する関数を、> を使って作成します。つまり、y -> y > x と同等の関数です。返される関数の型は Base.Fix2{typeof(>)} で、これを使って特化したメソッドを実装できます。
>(x, y)より大きい比較演算子。y < xにフォールバックします。
Implementation
一般に、新しい型ではこの関数ではなく<を実装し、フォールバック定義>(x, y) = y < xを利用してください。
Examples
julia> 'a' > 'b'
false
julia> 7 > 3 > 1
true
julia> "abc" > "abd"
false
julia> 5 > 3
trueBase.:>= — Function
>=(x)引数を x と比較する関数を、>= を使って作成します。つまり、y -> y >= x と同等の関数です。返される関数の型は Base.Fix2{typeof(>=)} で、これを使って特化メソッドを実装できます。
>=(x, y)
≥(x,y)以上であることを示す比較演算子。y <= x にフォールバックします。
Implementation
新しい型では、この関数ではなく <= の実装を優先し、フォールバック定義 >=(x, y) = y <= x を利用してください。
さらに、多くの場合は < と == だけを実装し、<= と >= の両方のフォールバック定義を利用すれば十分です。
Examples
julia> 'a' >= 'b'
false
julia> 7 ≥ 7 ≥ 3
true
julia> "abc" ≥ "abc"
true
julia> 5 >= 3
trueBase.cmp — Function
cmp(a::AbstractString, b::AbstractString)::Int2つの文字列を比較します。両方の文字列の長さが同じで、各インデックスの文字も同じ場合は、0を返します。aがbの接頭辞である場合、またはaがアルファベット順でbより前に来る場合は、-1を返します。bがaの接頭辞である場合、またはbがアルファベット順(厳密にはUnicodeコードポイント順)でaより前に来る場合は、1を返します。
Examples
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", "β")
-1cmp(<, x, y)x が y より小さいか、等しいか、大きいかに応じて、それぞれ -1、0、1 を返します。第1引数には、使用する小なり比較関数を指定します。
cmp(x,y)x が y より小さい場合は -1、等しい場合は 0、大きい場合は 1 を返します。isless が実装する全順序を使用します。
Examples
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})
[...]Base.xor — Function
xor(x, y)
⊻(x, y)x と y のビット単位の排他的論理和です。three-valued logic を実装しており、引数のいずれかが missing の場合は missing を返します。
中置演算子 a ⊻ b は xor(a,b) の別名です。また、Julia REPL で \xor または \veebar をタブ補完すると、⊻ を入力できます。
Examples
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
0Base.nand — Function
nand(x, y)
⊼(x, y)x と y のビット単位の NAND(否定論理積)です。three-valued logic を実装しており、引数のいずれかが missing の場合は missing を返します。
中置演算子 a ⊼ b は nand(a,b) の別名です。また、Julia REPL で \nand または \barwedge を入力してタブ補完すると、⊼ を入力できます。
Examples
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
1Base.nor — Function
nor(x, y)
⊽(x, y)x と y のビット単位の NOR(NOT OR)です。three-valued logic を実装しており、引数の一方が missing で、もう一方が true でない場合に missing を返します。
中置演算子 a ⊽ b は nor(a,b) の別名です。Julia REPL で \nor または \barvee をタブ補完すると、⊽ を入力できます。
Examples
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
1Base.:! — Function
!f::Function述語関数の否定:! の引数が関数の場合、f の真偽を反転する合成関数を返します。
関連項目:∘。
Examples
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 を返します。
!(x)ブール値の否定。three-valued logicを実装し、xがmissingの場合にmissingを返します。
ビット単位の否定については、~も参照してください。
Examples
julia> !true
false
julia> !false
true
julia> !missing
missing
julia> .![true false true]
1×3 BitMatrix:
0 1 0&& — Keyword
x && y短絡評価を行う論理 AND。
これは x ? y : false と同等です。x が false の場合は false を返し、そうでない場合は x が true であれば y の評価結果を返します。y が式の場合、x が true のときにのみ評価されます。この動作を「短絡評価」と呼びます。
また、y はブール値である必要はありません。そのため、任意の statement に対して、(condition) && (statement) を if condition; statement; end の略記として使用できます。
&、三項演算子 ? :、および control flow のマニュアルの節も参照してください。
Examples
julia> x = 3;
julia> x > 1 && x < 10 && x isa Int
true
julia> x < 0 && error("expected positive x")
false
julia> x > 0 && "not a boolean"
"not a boolean"|| — Keyword
x || y短絡評価を行う論理和。
これは x ? true : y と同等です。x が true の場合は true を返し、そうでない場合は x が false の場合に y を評価した結果を返します。y が式の場合、x が false のときにのみ評価される点に注意してください。これは「短絡評価」と呼ばれる動作です。
また、y はブール値である必要はありません。そのため、任意の statement に対して、(condition) || (statement) を if !(condition); statement; end の略記として使えます。
Examples
julia> pi < 3 || ℯ < 3
true
julia> false || true || println("neither is true!")
true
julia> pi < 3 || "not a boolean"
"not a boolean"Mathematical Functions
Base.isapprox — Function
isapprox(x; kwargs...) / ≈(x; kwargs...)引数を x と比較する関数を、≈ を使って作成します。つまり、y -> y ≈ x と同等の関数です。
ここでサポートされるキーワード引数は、2 引数の isapprox と同じです。
isapprox(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 では、x がメートル単位の radius of the Earth なら、atol=1e-9 は途方もなく小さい許容誤差ですが、x がメートル単位の radius of a Hydrogen atom なら、途方もなく大きい許容誤差になります。
Examples
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`
trueBase.sin — Method
sin(x::T) where {T <: Number} -> float(T)x の正弦を計算します。x はラジアン単位です。
isinf(x) の場合は DomainError をスローし、isnan(x) の場合は T(NaN) を返します。
関連項目: sind、sinpi、sincos、cis、asin。
Examples
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.5imBase.Math.sincos — Method
sincos(x::T) where T -> Tuple{float(T),float(T)}x の正弦と余弦を同時に計算します。x はラジアン単位で、タプル (sine, cosine) を返します。
isinf(x) の場合は DomainError をスローし、isnan(x) の場合は (T(NaN), T(NaN)) を返します。
Base.tan — Method
tan(x::T) where {T <: Number} -> float(T)x の正接を計算します。x はラジアン単位です。
isinf(x) の場合は DomainError をスローし、isnan(x) の場合は T(NaN) を返します。
関連項目: tanh。
Base.Math.sind — Function
sind(x::T) where T -> float(T)xの正弦を計算します。xは度数法で表されます。xが行列の場合、xは正方行列である必要があります。
DomainErrorをスローします(isinf(x)の場合)。isnan(x)の場合は、T(NaN)を返します。
Base.Math.cosd — Function
cosd(x::T) where T -> float(T)xの余弦を計算します。xは度数法で指定します。xが行列の場合、xは正方行列である必要があります。
isinf(x)の場合はDomainErrorをスローし、isnan(x)の場合はT(NaN)を返します。
Base.Math.tand — Function
tand(x::T) where T -> float(T)x の正接を計算します。x は度単位です。x が行列の場合、x は正方行列である必要があります。
isinf(x) の場合は DomainError をスローし、isnan(x) の場合は T(NaN) を返します。
Base.Math.sincosd — Function
sincosd(x::T) where T -> Tuple{float(T),float(T)}x の正弦と余弦を同時に計算し、x が度数法で表されている場合は、タプル (sine, cosine) を返します。
isinf(x) の場合は DomainError をスローし、isnan(x) の場合は (T(NaN), T(NaN)) タプルを返します。
Base.Math.sinpi — Function
sinpi(x::T) where T -> float(T)特に大きなxでは、sin(pi*x)よりも正確に$\sin(\pi x)$を計算します。
isinf(x)の場合はDomainErrorをスローし、isnan(x)の場合はT(NaN)を返します。
Base.Math.cospi — Function
cospi(x::T) where T -> float(T)特に大きなxについては、cos(pi*x)よりも正確に$\cos(\pi x)$を計算します。
isinf(x)の場合はDomainErrorをスローし、isnan(x)の場合はT(NaN)を返します。
Base.Math.tanpi — Function
tanpi(x::T) where T -> float(T)$\tan(\pi x)$を、特に大きなxについて、tan(pi*x)よりも高い精度で計算します。
isinf(x)の場合はDomainErrorをスローし、isnan(x)の場合はT(NaN)を返します。
Base.Math.sincospi — Function
sincospi(x::T) where T -> Tuple{float(T),float(T)}π*x(ラジアン単位では x)の正弦と余弦である sinpi(x) と cospi(x) を同時に計算し、タプル (sine, cosine) を返します。
isinf(x) の場合は DomainError をスローし、isnan(x) の場合は (T(NaN), T(NaN)) タプルを返します。
Base.tanh — Method
tanh(x)x の双曲線正接を計算します。
Examples
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.9950547536867306imBase.atan — Method
atan(y)
atan(y, x)それぞれ、y または y/x の逆正接を計算します。
実数の引数が1つの場合、正の x 軸と点 (1, y) のなす角をラジアンで返します。戻り値は区間 $[-\pi/2, \pi/2]$ に含まれます。
引数が2つの場合、正の x 軸と点 (x, y) のなす角をラジアンで返します。戻り値は区間 $[-\pi, \pi]$ に含まれます。これは標準的な atan2 関数に相当します。慣例として、x < 0 の場合、atan(0.0,x) は $\pi$、atan(-0.0,x) は $-\pi$ と定義されることに注意してください。
度数法については atand も参照してください。
Examples
julia> rad2deg(atan(-1/√3))
-30.000000000000004
julia> rad2deg(atan(-1, √3))
-30.000000000000004
julia> rad2deg(atan(1, -√3))
150.0Base.Math.asind — Function
Base.Math.acosd — Function
Base.Math.atand — Function
atand(y::T) where T -> float(T)
atand(y::T, x::S) where {T,S} -> promote_type(T,S)
atand(y::AbstractMatrix{T}) where T -> AbstractMatrix{Complex{float(T)}}y または y/x の逆正接を計算します。出力は度単位です。
isnan(y) または isnan(x) の場合は、NaN を返します。返される NaN は、引数が1つの形式では T、引数が2つの形式では promote_type(T,S) です。
Base.Math.sec — Method
sec(x::T) where {T <: Number} -> float(T)x の正割を計算します。x はラジアン単位です。
isinf(x) の場合は DomainError をスローし、isnan(x) の場合は T(NaN) を返します。
Base.Math.csc — Method
csc(x::T) where {T <: Number} -> float(T)x の余割を計算します。x はラジアン単位です。
isinf(x) の場合は DomainError をスローし、そうでなければ T(NaN) を返します。isnan(x)
Base.Math.cot — Method
cot(x::T) where {T <: Number} -> float(T)x の余接を計算します。x はラジアン単位です。
DomainError をスローします(isinf(x) の場合)。isnan(x) の場合は T(NaN) を返します。
Base.Math.secd — Function
secd(x::T) where {T <: Number} -> float(T)x の正割を計算します。x は度単位です。
isinf(x) の場合は DomainError をスローし、isnan(x) の場合は T(NaN) を返します。
Base.Math.cscd — Function
cscd(x::T) where {T <: Number} -> float(T)x の余割を計算します。x は度数法で表されています。
isinf(x) の場合は DomainError をスローし、isnan(x) の場合は T(NaN) を返します。
Base.Math.cotd — Function
cotd(x::T) where {T <: Number} -> float(T)x の余接を計算します。x は度数法で表されます。
isinf(x) の場合は DomainError をスローし、isnan(x) の場合は T(NaN) を返します。
Base.Math.asec — Method
asec(x::T) where {T <: Number} -> float(T)x の逆正割を計算します。出力はラジアン単位です。
Base.Math.acsc — Method
acsc(x::T) where {T <: Number} -> float(T)x の逆余割を、ラジアン単位で求めます。
Base.Math.acot — Method
acot(x::T) where {T <: Number} -> float(T)x の逆余接を計算します。結果はラジアン単位です。
Base.Math.asecd — Function
Base.Math.acscd — Function
Base.Math.acotd — Function
Base.Math.sech — Method
sech(x::T) where {T <: Number} -> float(T)x の双曲線正割を計算します。
isnan(x) の場合は、T(NaN) を返します。
Base.Math.csch — Method
csch(x::T) where {T <: Number} -> float(T)x の双曲線余割を計算します。
isnan(x) の場合は、T(NaN) を返します。
Base.Math.coth — Method
coth(x::T) where {T <: Number} -> float(T)x の双曲線余接を計算します。
isnan(x) の場合は、T(NaN) を返します。
Base.asinh — Method
asinh(x)x の逆双曲線正弦を計算します。
Base.acosh — Method
acosh(x)x の逆双曲線余弦を計算します。
Base.atanh — Method
atanh(x)x の逆双曲線正接を計算します。
Base.Math.asech — Method
asech(x::T) where {T <: Number} -> float(T)x の逆双曲線正割を計算します。
Base.Math.acsch — Method
acsch(x::T) where {T <: Number} -> float(T)x の逆双曲線余割を計算します。
Base.Math.acoth — Method
acoth(x::T) where {T <: Number} -> float(T)x の逆双曲線余接を計算します。
Base.Math.sinc — Function
sinc(x::T) where {T <: Number} -> float(T)正規化 sinc 関数 $\operatorname{sinc}(x) = \sin(\pi x) / (\pi x)$ を $x \neq 0$ の場合に、また $1$ を $x = 0$ の場合に計算します。
isnan(x) の場合は T(NaN) を返します。
その導関数については cosc も参照してください。
Base.Math.cosc — Function
cosc(x::T) where {T <: Number} -> float(T)sinc(x) の導関数を求めます。$x \neq 0$ の場合は $\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)$、$x = 0$ の場合は $0$ です。
isnan(x) の場合は T(NaN) を返します。
関連項目: sinc。
Base.Math.deg2rad — Function
Base.Math.rad2deg — Function
Base.Math.hypot — Function
hypot(x, y)オーバーフローやアンダーフローを避けて、斜辺 $\sqrt{|x|^2+|y|^2}$ を計算します。
このコードは、Carlos F. Borges による「An Improved Algorithm for hypot(a,b)」で説明されているアルゴリズムを実装したものです。論文は arXiv で公開されています。リンクはこちらです。 https://arxiv.org/abs/1904.09481
hypot(x...)オーバーフローやアンダーフローを避けて、斜辺 $\sqrt{\sum |x_i|^2}$ を計算します。
標準ライブラリの norm も参照してください。LinearAlgebra
Examples
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)
trueBase.log — Method
log(x)x の自然対数を計算します。
負の Real 引数には DomainError をスローします。Complex 引数を使うと、Complex の結果が得られます。
Examples
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(-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.0Base.log — Method
log(b,x)b を底として x の対数を計算します。負の Real 引数に対しては、DomainError をスローします。
Examples
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
[...]Base.log2 — Function
log2(x)x の 2 を底とする対数を計算します。負の Real 引数に対しては、DomainError をスローします。
Examples
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.0Base.log10 — Function
log10(x)x の常用対数を計算します。引数が負の場合は DomainError を Real します。
Examples
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
[...]Base.log1p — Function
log1p(x)1+x の高精度な自然対数。-1 未満の Real 引数に対しては DomainError をスローします。
Examples
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 — Function
frexp(val)x の大きさが $[1/2, 1)$ の範囲内または 0 であり、val が $x \times 2^{exp}$ と等しくなるように、(x,exp) を返します。
関連項目: significand、exponent、ldexp。
Examples
julia> frexp(6.0)
(0.75, 3)
julia> significand(6.0), exponent(6.0) # interval [1, 2) instead
(1.5, 2)
julia> frexp(0.0), frexp(NaN), frexp(-Inf) # exponent would give an error
((0.0, 0), (NaN, 0), (-Inf, 0))Base.exp10 — Function
exp10(x)x の常用対数の指数関数を計算します。つまり、$10^x$ です。
Examples
julia> exp10(2)
100.0
julia> 10^2
100Base.Math.ldexp — Function
Base.Math.modf — Function
modf(x)数値の小数部と整数部を含むタプル (fpart, ipart) を返します。どちらの部分も、引数と同じ符号になります。
Examples
julia> modf(3.5)
(0.5, 3.0)
julia> modf(-3.5)
(-0.5, -3.0)Base.expm1 — Function
expm1(x)$e^x-1$ を高精度で計算します。x が小さい場合に exp(x) - 1 を直接計算すると生じる精度の損失を避けられます。
Examples
julia> expm1(1e-16)
1.0e-16
julia> exp(1e-16) - 1
0.0Base.round — Function
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 で、小数点以下の指定した桁数に丸めます(digits が負の場合は、小数点より前の桁数に丸めます)。
キーワード引数 sigdigits を指定すると、基数 base で、指定した有効桁数に丸めます。
RoundingMode r は丸めの方向を制御します。デフォルトは RoundNearest で、最も近い整数に丸めます。ちょうど中間の値(小数部が 0.5 の値)は、最も近い偶数の整数に丸められます。グローバルな丸めモードを変更すると、round が誤った結果を返す場合があることに注意してください(rounding を参照)。
浮動小数点型に丸める場合、真の整数ではなく、その型で表現可能な整数(および Inf)に丸めます。「最も近い値」を判定する際、Inf は floatmax(T) より 1 ulp 大きい値として扱われます。これは convert と同様です。
Examples
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 以外の基数で指定した桁数に丸める場合、2 進浮動小数点数を扱うと結果が正確でないことがあります。たとえば、Float64 の値は 1.15 で表されますが、実際には 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.2Extensions
round を新しい数値型に拡張するには、通常、Base.round(x::NewType, r::RoundingMode) を定義するだけで十分です。
Base.Rounding.RoundingMode — Type
RoundingMode浮動小数点演算の丸めモードを制御する型です(rounding/setrounding関数で使用)。また、最も近い整数への丸めを行う関数(round関数)の省略可能な引数としても使用します。
現在サポートされている丸めモードは次のとおりです。
Base.Rounding.RoundNearest — Constant
RoundNearestデフォルトの丸めモードです。最も近い整数に丸め、ちょうど中間の値(小数部分が 0.5 の値)は、最も近い偶数の整数に丸めます。
Base.Rounding.RoundNearestTiesAway — Constant
RoundNearestTiesAway最も近い整数に丸めます。ちょうど中間の場合はゼロから遠ざかる方向に丸めます(C/C++ の round の動作)。
Base.Rounding.RoundNearestTiesUp — Constant
RoundNearestTiesUp最も近い整数に丸めます。ちょうど中間の場合は、正の無限大方向に丸めます(Java/JavaScript round の動作)。
Base.Rounding.RoundToZero — Constant
Base.Rounding.RoundFromZero — Constant
RoundFromZeroゼロから遠ざかる方向に丸めます。
Examples
julia> BigFloat("1.0000000000000001", 5, RoundFromZero)
1.06Base.Rounding.RoundUp — Constant
Base.Rounding.RoundDown — Constant
Base.round — Method
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]])
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; digits=0, base=10)
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; sigdigits, base=10)複素数値 z と同じ型で、z に最も近い整数値を返します。等距離の候補がある場合は、指定された RoundingMode に従って決定します。1 つ目の RoundingMode は実部の丸めに、2 つ目は虚部の丸めに使用されます。
RoundingModeReal と RoundingModeImaginary のデフォルトは RoundNearest です。これは最も近い整数に丸め、等距離の候補がある場合(小数部分が 0.5 の場合)は最も近い偶数に丸めます。
Examples
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.51imBase.ceil — Function
ceil([T,] x)
ceil(x; digits::Integer= [, base = 10])
ceil(x; sigdigits::Integer= [, base = 10])ceil(x) は、x 以上となる、x と同じ型の最も近い整数値を返します。
ceil(T, x) は、結果を T 型に変換します。切り上げた値を T として表現できない場合は、InexactError をスローします。
キーワード digits、sigdigits、base の動作は、round と同じです。
新しい型で ceil をサポートするには、Base.round(x::NewType, ::RoundingMode{:Up}) を定義します。
Base.floor — Function
floor([T,] x)
floor(x; digits::Integer= [, base = 10])
floor(x; sigdigits::Integer= [, base = 10])floor(x) は、x 以下の値のうち、x と同じ型で最も近い整数値を返します。
floor(T, x) は、結果を T 型に変換します。床関数を適用した値を表現できない場合は、InexactError をスローします(T)。
キーワード digits、sigdigits、base の動作は、round と同じです。
新しい型で floor をサポートするには、Base.round(x::NewType, ::RoundingMode{:Down}) を定義します。
Base.trunc — Function
trunc([T,] x)
trunc(x; digits::Integer= [, base = 10])
trunc(x; sigdigits::Integer= [, base = 10])trunc(x) は、x の絶対値以下で、絶対値が最も大きい整数値を、x と同じ型で返します。
trunc(T, x) は、結果を T 型に変換します。切り捨てた値を T で表現できない場合は、InexactError をスローします。
キーワード digits、sigdigits、base の動作は、round と同じです。
新しい型で trunc をサポートするには、Base.round(x::NewType, ::RoundingMode{:ToZero}) を定義します。
関連項目: %、floor、unsigned、unsafe_trunc。
Examples
julia> trunc(2.22)
2.0
julia> trunc(-2.22, digits=1)
-2.2
julia> trunc(Int, -2.22)
-2Base.unsafe_trunc — Function
unsafe_trunc(T, x)T型で、絶対値がxの絶対値以下となる最も近い整数値を返します。値をTで表現できない場合、任意の値が返されます。truncも参照してください。
Examples
julia> unsafe_trunc(Int, -2.2)
-2
julia> unsafe_trunc(Int, NaN) isa Int
trueBase.minmax — Function
minmax(x, y)(min(x,y), max(x,y))を返します。
extremaも参照してください。(minimum(x), maximum(x))を返します。
Examples
julia> minmax('c','b')
('b', 'c')Base.clamp — Function
clamp(x, T)::Txをtypemin(T)とtypemax(T)の間に収め、その結果を型Tに変換します。
関連項目:trunc。
Examples
julia> clamp(200, Int8)
127
julia> clamp(-200, Int8)
-128
julia> trunc(Int, 4pi^2)
39clamp(x, lo, hi)x を lo <= x <= hi の場合に返します。x > hi の場合は hi を返します。x < lo の場合は lo を返します。引数は共通の型に昇格されます。
Examples
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
10Base.clamp! — Function
clamp!(array::AbstractArray, lo, hi)arrayの値を、指定した範囲内にその場で制限します。clampも参照してください。
Examples
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.0Base.abs — Function
abs(x)xの絶対値。
absを符号付き整数に適用すると、オーバーフローが発生し、負の値が返されることがあります。このオーバーフローは、符号付き整数で表現可能な最小値にabsを適用した場合にのみ発生します。つまり、x == typemin(typeof(x))の場合はabs(x) == x < 0となり、予想される-xにはなりません。
Examples
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])
4Base.Checked — Module
CheckedChecked モジュールは、組み込みの符号付きおよび符号なし整数型向けに、オーバーフローが発生するとエラーをスローする算術関数を提供します。これらの関数の名前は、checked_sub、checked_div などです。また、add_with_overflow、sub_with_overflow、mul_with_overflow は、オーバーフローの有無を示すブール値と、オーバーフロー検査を行わない場合の結果の両方を返します。
Base.Checked.checked_abs — Function
Base.checked_abs(x)abs(x)を計算し、該当する場合はオーバーフローエラーをチェックします。たとえば、標準的な2の補数表現の符号付き整数(例:Int)ではabs(typemin(Int))を表現できないため、オーバーフローが発生します。
オーバーフロー保護によって、パフォーマンスが目に見えて低下する場合があります。
Base.Checked.checked_neg — Function
Base.checked_neg(x)-x を計算し、該当する場合はオーバーフローエラーを検出します。たとえば、標準的な2の補数表現の符号付き整数(例:Int)では -typemin(Int) を表現できないため、オーバーフローが発生します。
オーバーフロー保護によって、パフォーマンスが目に見えて低下する場合があります。
Base.Checked.checked_add — Function
Base.checked_add(x, y)x+yを計算します。該当する場合は、オーバーフローエラーが発生しないか確認します。
オーバーフロー保護によって、パフォーマンスが目に見えて低下する場合があります。
Base.Checked.checked_sub — Function
Base.checked_sub(x, y)x-y を計算します。該当する場合は、オーバーフローエラーが発生しないか確認します。
オーバーフロー保護によって、パフォーマンスが目に見えて低下する場合があります。
Base.Checked.checked_mul — Function
Base.checked_mul(x, y)x*yを計算します。該当する場合は、オーバーフローエラーをチェックします。
オーバーフロー保護によって、パフォーマンスが目に見えて低下することがあります。
Base.Checked.checked_div — Function
Base.checked_div(x, y)div(x,y) を計算し、該当する場合はオーバーフローエラーをチェックします。
オーバーフロー保護によって、パフォーマンスが目に見えて低下する場合があります。
Base.Checked.checked_rem — Function
Base.checked_rem(x, y)x%yを計算します。該当する場合は、オーバーフローエラーもチェックします。
オーバーフロー保護によって、パフォーマンスが目に見えて低下する場合があります。
Base.Checked.checked_fld — Function
Base.checked_fld(x, y)fld(x,y) を計算します。該当する場合は、オーバーフローエラーが発生しないか確認します。
オーバーフロー保護によって、パフォーマンスが目に見えて低下することがあります。
Base.Checked.checked_mod — Function
Base.checked_mod(x, y)mod(x,y)を計算します。該当する場合は、オーバーフローエラーをチェックします。
オーバーフロー保護によって、パフォーマンスが目に見えて低下する場合があります。
Base.Checked.checked_cld — Function
Base.checked_cld(x, y)cld(x,y)を計算し、該当する場合はオーバーフローエラーをチェックします。
オーバーフロー保護によって、パフォーマンスが目に見えて低下する場合があります。
Base.Checked.checked_pow — Function
Base.checked_pow(x, y)^(x,y)を計算します。該当する場合は、オーバーフローエラーが発生しないか確認します。
オーバーフロー保護によって、パフォーマンスが目に見えて低下する場合があります。
Base.Checked.add_with_overflow — Function
Base.add_with_overflow(x, y) -> (r, f)r = x+yを計算します。フラグfは、オーバーフローが発生したかどうかを示します。
Base.Checked.sub_with_overflow — Function
Base.sub_with_overflow(x, y) -> (r, f)r = x-yを計算します。フラグfは、オーバーフローが発生したかどうかを示します。
Base.Checked.mul_with_overflow — Function
Base.mul_with_overflow(x, y) -> (r, f)r = x*yを計算します。フラグfは、オーバーフローが発生したかどうかを示します。
Base.copysign — Function
copysign(x, y) -> zzを返します。これは、xと同じ大きさで、yと同じ符号を持ちます。
Examples
julia> copysign(1, -2)
-1
julia> copysign(-1, 2)
1Base.signbit — Function
signbit(x)x の符号の値が負の場合は true を返し、それ以外の場合は false を返します。
Examples
julia> signbit(-4)
true
julia> signbit(5)
false
julia> signbit(5.5)
false
julia> signbit(-4.1)
trueBase.flipsign — Function
flipsign(x, y)y が負の場合は、x の符号を反転してください。たとえば、abs(x) = flipsign(x,x) です。
Examples
julia> flipsign(5, 3)
5
julia> flipsign(5, -3)
-5Base.sqrt — Method
sqrt(x)$\sqrt{x}$を返します。
負のReal引数を指定すると、DomainErrorをスローします。代わりにComplexの負の引数を指定すると、Complexの結果が得られます。
前置演算子√は、sqrtと同等です。
関連項目: hypot。
Examples
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 is below the branch cut
0.0 - 9.0im
julia> .√(1:4)
4-element Vector{Float64}:
1.0
1.4142135623730951
1.7320508075688772
2.0Base.isqrt — Function
isqrt(n::Integer)整数平方根:m を超えない最大の整数 m*m <= n。
julia> isqrt(5)
2Base.Math.cbrt — Method
cbrt(x::Real)x の立方根を返します。つまり、$x^{1/3}$ です。負の値も受け付けます($x < 0$ の場合は、負の実数の立方根を返します)。
前置演算子 ∛ は、cbrt と同等です。
Examples
julia> cbrt(big(27))
3.0
julia> cbrt(big(-27))
-3.0Base.Math.fourthroot — Method
fourthroot(x)xの4乗根を、sqrtを2回続けて適用して返します。
Base.real — Function
real(A::AbstractArray)配列 A の各要素の実部を含む配列を返します。
real.(A) と同等ですが、eltype(A) <: Real A の場合はコピーせずに返し、A の次元数が 0 の場合はスカラーではなく 0 次元配列を返します。
Examples
julia> real([1, 2im, 3 + 4im])
3-element Vector{Int64}:
1
0
3
julia> real(fill(2 - im))
0-dimensional Array{Int64, 0}:
2real(T::Type)型 T の値の実部を表す型を返します。たとえば、T == Complex{R} の場合は R を返します。typeof(real(zero(T))) と同等です。
Examples
julia> real(Complex{Int})
Int64
julia> real(Float64)
Float64Base.reim — Function
reim(A::AbstractArray)A の各要素について、実部と虚部をそれぞれ含む2つの配列をタプルで返します。
(real.(A), imag.(A)) と同等ですが、eltype(A) <: Real の場合は、実部を表すためにコピーせず A を返します。また、A の次元数が0の場合は、スカラーではなく0次元配列を返します。
Examples
julia> reim([1, 2im, 3 + 4im])
([1, 0, 3], [0, 2, 4])
julia> reim(fill(2 - im))
(fill(2), fill(-1))reim(z)複素数zの実部と虚部をタプルとして返します。
Examples
julia> reim(1 + 3im)
(1, 3)Base.conj — Function
conj(A::AbstractArray)配列 A の各要素の複素共役を含む配列を返します。
conj.(A) と同等ですが、eltype(A) <: Real の場合は A がコピーされずに返され、また A の次元数がゼロの場合は、スカラーではなく0次元配列が返されます。
Examples
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 + 1imBase.angle — Function
angle(z)複素数 z の偏角をラジアンで計算します。
数値 -pi ≤ angle(z) ≤ pi を返すため、負の実軸上で不連続です。
Examples
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.0Base.binomial — Function
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などの外部パッケージで利用できます。
External links
- WikipediaのBinomial coefficient。
binomial(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 も参照してください。
Examples
julia> binomial(5, 3)
10
julia> factorial(5) ÷ (factorial(5-3) * factorial(3))
10
julia> binomial(-5, 3)
-35External links
- Wikipedia の Binomial coefficient。
Base.factorial — Function
factorial(n::Integer)n の階乗。n が Integer の場合、階乗は整数(少なくとも64ビットに拡張)として計算されます。n が小さくない場合、オーバーフローする可能性があります。ただし、factorial(big(n)) を使えば、任意精度で正確な結果を計算できます。
binomial も参照してください。
Examples
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))
51090942171709440000External links
- Wikipedia の Factorial。
Base.gcd — Function
gcd(x, y...)最大公約数(正の値)。すべての引数がゼロの場合はゼロを返します。引数には整数と有理数を指定できます。
$a$ が $b$ の約数であるとは、$ma=b$ を満たす整数 $m$ が存在することをいいます。
Examples
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)
5Base.lcm — Function
lcm(x, y...)最小公倍数(正の値)。ただし、引数のいずれかがゼロの場合はゼロです。引数には整数と有理数を指定できます。
$a$ が $b$ の倍数であるとは、ある整数 $m$ が存在し、$a=mb$ が成り立つことをいいます。
Examples
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)
105Base.gcdx — Function
gcdx(a, b...)a と b の最大公約数(正の値)と、ベズー係数を計算します。ベズー係数とは、$u*a + v*b = d = gcd(a, b)$ を満たす整数係数 u と v のことです。$gcdx(a, b)$ は $(d, u, v)$ を返します。
引数が2つより多い場合、つまり gcdx(a, b, c, ...) の場合、ベズー係数は再帰的に計算され、$u*a + v*b + w*c + ... = d = gcd(a, b, c, ...)$ に対する解 (d, u, v, w, ...) を返します。
引数には整数と有理数を指定できます。
Examples
julia> gcdx(12, 42)
(6, -3, 1)
julia> gcdx(240, 46)
(2, -9, 47)
julia> gcdx(15, 12, 20)
(1, 7, -7, -1)Base.ispow2 — Function
ispow2(n::Number)::Booln が 2 の整数乗かどうかを判定します。
関連項目: count_ones、prevpow、nextpow。
Examples
julia> ispow2(4)
true
julia> ispow2(5)
false
julia> ispow2(4.5)
false
julia> ispow2(0.25)
true
julia> ispow2(1//8)
trueBase.nextpow — Function
nextpow(a, x)n が非負整数であるとき、x 以上となる最小の a^n。a は 1 より大きく、x は 0 より大きくなければなりません。
prevpow を参照してください。
Examples
julia> nextpow(2, 7)
8
julia> nextpow(2, 9)
16
julia> nextpow(5, 20)
25
julia> nextpow(4, 16)
16Base.prevpow — Function
prevpow(a, x)x 以下の最大の a^n。ここで、n は非負の整数です。a は 1 より大きく、x は 1 未満であってはなりません。
Examples
julia> prevpow(2, 7)
4
julia> prevpow(2, 9)
8
julia> prevpow(5, 20)
5
julia> prevpow(4, 16)
16Base.nextprod — Function
nextprod(factors::Union{Tuple,AbstractVector}, n)n以上で、$p_1$、$p_2$などの整数について、因子$k_i$をfactorsに含めたときに、$\prod k_i^{p_i}$と表せる最小の整数。
Examples
julia> nextprod((2, 3), 105)
108
julia> 2^2 * 3^3
108Base.invmod — Function
invmod(n::Integer, T) where {T <: Base.BitInteger}
invmod(n::T) where {T <: Base.BitInteger}型 T の整数環において、n のモジュラー逆元を計算します。つまり、N = 8*sizeof(T) の場合、法は 2^N です(たとえば、Int32 の場合は N = 32)。言い換えると、これらのメソッドは次の恒等式を満たします。
n * invmod(n) == 1
(n * invmod(n, T)) % T == 1
(n % T) * invmod(n, T) == 1ここでの * は、整数環におけるモジュラー乗算、すなわち T であることに注意してください。n が偶数の場合、2^N と互いに素ではなく、逆元が存在しないため、エラーが発生します。
整数型が暗黙に定める法を明示的な値として指定するのは、多くの場合不便です。法は定義上、その型では表現できないほど大きいためです。
モジュラー逆元は、https://arxiv.org/pdf/2204.04342.pdf. で説明されているアルゴリズムを使うことで、一般の場合よりもはるかに効率よく計算されます。
invmod(n::Integer, m::Integer)n の m を法とする逆元を求めます。y は $n y = 1 \pmod m$ を満たし、$div(y,m) = 0$ となります。$m = 0$ の場合、または $gcd(n,m) \neq 1$ の場合はエラーが発生します。
Examples
julia> invmod(2, 5)
3
julia> invmod(2, 3)
2
julia> invmod(5, 6)
5Base.powermod — Function
powermod(x::Integer, p::Integer, m)$x^p \pmod m$を計算します。
Examples
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)
11Base.ndigits — Function
ndigits(n::Integer; base::Integer=10, pad::Integer=1)整数 n を base 進数で表したときの桁数を計算します(base は [-1, 0, 1] に含まれていてはなりません)。必要に応じて、指定した桁数になるようゼロで埋めることもできます(結果が pad 未満になることはありません)。
関連項目: digits、count_ones。
Examples
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)
3Base.add_sum — Function
Base.add_sum(x, y)sumで使用される縮約演算子です。+との主な違いは、小さな整数がInt/UIntに昇格される点です。
Base.widemul — Function
widemul(x, y)x と y を乗算し、より大きな型で結果を返します。
関連項目: promote、Base.add_sum。
Examples
julia> widemul(Float32(3.0), 4.0) isa BigFloat
true
julia> typemax(Int8) * typemax(Int8)
1
julia> widemul(typemax(Int8), typemax(Int8)) # == 127^2
16129Base.Math.evalpoly — Function
evalpoly(x, p)係数 p[1], p[2], ... に対して、多項式 $\sum_k x^{k-1} p[k]$ の値を計算します。係数は x の次数の昇順で指定します。係数の数が静的にわかる場合、すなわち p が Tuple である場合は、コンパイル時にループが展開されます。この関数は、x が実数の場合は Horner 法を、x が複素数の場合は Goertzel 法に似たアルゴリズム [DK62] を用いて、効率的なコードを生成します。
Examples
julia> evalpoly(2, (1, 2, 3))
17Base.Math.@evalpoly — Macro
@evalpoly(z, c...)係数 c[1]、c[2]、... に対して、多項式 $\sum_k z^{k-1} c[k]$ を評価します。つまり、係数は z のべきの昇順で与えられます。このマクロは、ホーナー法、または複素数の z の場合は、より効率的な Goertzel に似たアルゴリズムを使うインラインコードに展開されます。
関連項目: evalpoly。
Examples
julia> @evalpoly(3, 1, 0, 1)
10
julia> @evalpoly(2, 1, 0, 1)
5
julia> @evalpoly(2, 1, 1, 1)
7Base.FastMath.@fastmath — Macro
@fastmath expr式を変換したうえで実行します。この変換では、厳密な IEEE セマンティクスに違反する可能性のある関数が呼び出されます。これにより最速の処理が可能になりますが、結果は未定義です。数値結果が変わる可能性があるため、使用には注意してください。
これは LLVM Fast-Math flags を設定するもので、clang の -ffast-math オプションに相当します。詳しくは the notes on performance annotations を参照してください。
Examples
julia> @fastmath 1+2
3
julia> @fastmath(sin(3))
0.1411200080598672Customizable binary operators
一部の Unicode 文字を使うと、中置記法に対応した新しい二項演算子を定義できます。たとえば、⊗(x,y) = kron(x,y) は ⊗(otimes)関数をクロネッカー積として定義します。この関数は、C = A ⊗ B のように二項演算子として中置記法で呼び出せるほか、通常の前置記法 C = ⊗(A,B) でも呼び出せます。
このような拡張に対応するほかの文字には、\odot ⊙ や \oplus ⊕ があります。
* と同じ優先順位で解析されるものには * / ÷ % & ⋅ ∘ × |\\| ∩ ∧ ⊗ ⊘ ⊙ ⊚ ⊛ ⊠ ⊡ ⊓ ∗ ∙ ∤ ⅋ ≀ ⊼ ⋄ ⋆ ⋇ ⋉ ⋊ ⋋ ⋌ ⋏ ⋒ ⟑ ⦸ ⦼ ⦾ ⦿ ⧶ ⧷ ⨇ ⨰ ⨱ ⨲ ⨳ ⨴ ⨵ ⨶ ⨷ ⨸ ⨻ ⨼ ⨽ ⩀ ⩃ ⩄ ⩋ ⩍ ⩎ ⩑ ⩓ ⩕ ⩘ ⩚ ⩜ ⩞ ⩟ ⩠ ⫛ ⊍ ▷ ⨝ ⟕ ⟖ ⟗ があり、+ と同じ優先順位で解析されるものには + - |\|| ⊕ ⊖ ⊞ ⊟ |++| ∪ ∨ ⊔ ± ∓ ∔ ∸ ≏ ⊎ ⊻ ⊽ ⋎ ⋓ ⟇ ⧺ ⧻ ⨈ ⨢ ⨣ ⨤ ⨥ ⨦ ⨧ ⨨ ⨩ ⨪ ⨫ ⨬ ⨭ ⨮ ⨹ ⨺ ⩁ ⩂ ⩅ ⩊ ⩌ ⩏ ⩐ ⩒ ⩔ ⩖ ⩗ ⩛ ⩝ ⩡ ⩢ ⩣ があります。矢印、比較、累乗に関連するものはほかにも多数あります。
- DK62Donald Knuth, Art of Computer Programming, Volume 2: Seminumerical Algorithms, Sec. 4.6.4.