Mathematics

-(x)

単項マイナス演算子。

参照: abs, flipsign。

例

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

dt::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

-(x, y)

減算演算子。

例

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

*(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

/(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

\(x, y)

左除算演算子：yを左側のxの逆数で乗算します。整数引数に対して浮動小数点結果を返します。

例

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

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

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

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

^(x, y)

累乗演算子。

x と y が整数の場合、結果がオーバーフローする可能性があります。科学的表記法で数値を入力するには、1.2 * 10^3 の代わりに Float64(@ref) リテラルのように 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 は正の値です。

他にも exp2、<< を参照してください。

例

julia> 3^5
243

julia> 3^-1  # Base.literal_pow を使用
0.3333333333333333

julia> p = -1;

julia> 3^p
ERROR: DomainError with -1:
整数 x を負の指数 -1 で累乗することはできません。
[...]

julia> 3.0^p
0.3333333333333333

julia> 10^19 > 0  # 整数オーバーフロー
false

julia> big(10)^19 == 1e19
true

fma(x, y, z)

x*y+zを計算しますが、中間結果x*yの丸めを行いません。一部のシステムでは、これはx*y+zよりもかなり高価です。fmaは特定のアルゴリズムでの精度を向上させるために使用されます。muladdを参照してください。

muladd(x, y, z)

結合乗算加算: x*y+z を計算しますが、加算と乗算を互いに、または周囲の操作と統合してパフォーマンスを向上させることができます。たとえば、ハードウェアが効率的にサポートしている場合、これは fma として実装されることがあります。結果は異なるマシンで異なる場合があり、定数伝播やその他の最適化により同じマシンでも異なる場合があります。詳細は fma を参照してください。

例

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

muladd(A, y, z)

行列-行列または行列-ベクトルの乗算のための結合乗算加算、A*y .+ z。結果は常にA*yと同じサイズですが、zは小さいか、スカラーである可能性があります。

例

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

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

inv(x)

xの乗法逆数を返します。すなわち、x*inv(x)またはinv(x)*xは、丸め誤差を考慮してone(x)（乗法単位元）を返します。

xが数値である場合、これは本質的にone(x)/xと同じですが、いくつかの型に対してはinv(x)の方がわずかに効率的である場合があります。

例

julia> inv(2)
0.5

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

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

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

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

ユークリッド（整数）除算からの商。一般的には、分数部分のない数学的操作 x/y に相当します。

参照: cld, fld, rem, divrem.

例

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

julia> 5.0 ÷ 2
2.0

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

div(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

div(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になります。

fld(x, y)

x / y 以下の最大整数。div(x, y, RoundDown) と同等です。

他にも div、cld、fld1 を参照してください。

例

julia> fld(7.3, 5.5)
1.0

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

fld(x, y) は浮動小数点数の真の値に基づいて厳密に正しい切り下げ丸めを実装しているため、直感に反する状況が発生することがあります。例えば：

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

ここで起こっているのは、0.1 として書かれた浮動小数点数の真の値が数値的な値 1/10 よりもわずかに大きい一方で、6.0 は数値 6 を正確に表しているということです。したがって、6.0 / 0.1 の真の値は 60 よりもわずかに小さいです。除算を行うと、これは正確に 60.0 に丸められますが、fld(6.0, 0.1) は常に真の値の床を取るため、結果は 59.0 になります。

cld(x, y)

x / y以上の最小の整数。div(x, y, RoundUp)と同等です。

他にもdiv、fldを参照してください。

例

julia> cld(5.5, 2.2)
3.0

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

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

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

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

範囲 r の中で y を見つけます。ここで x ≡ y (mod n)、n = length(r) です。すなわち、y = mod(x - first(r), n) + first(r) です。

他にも mod1 を参照してください。

例

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

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

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

ユークリッド除算からの余りで、x と同じ符号を持ち、y よりも小さい絶対値の値を返します。この値は常に正確です。

参照: div, mod, mod1, divrem.

例

julia> x = 15; y = 4;

julia> x % y
3

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

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

rem(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

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を参照してください。

例

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

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

mod2pi(x)

2π で割った後の剰余を計算し、範囲 $[0,2π)$ で返します。

この関数は、数値的に正確な 2π で割った後の剰余の浮動小数点表現を計算するため、浮動小数点数 2π で割った x の剰余を計算する mod(x,2π) とは正確には同じではありません。

例

julia> mod2pi(9*pi/4)
0.7853981633974481

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

ユークリッド除算からの商と余り。(div(x, y, r), rem(x, y, r))と同等です。同様に、rのデフォルト値を使用した場合、この呼び出しは(x ÷ y, x % y)と同等です。

参照: fldmod, cld。

例

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

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

fldmod(x, y)

除算後の切り捨てた商と剰余。divrem(x, y, RoundDown)の便利なラッパー。(fld(x, y), mod(x, y))と同等です。

参照: fld, cld, fldmod1.

fld1(x, y)

フロア除算で、mod1(x,y) と一致する値を返します。

関連項目として mod1、fldmod1 を参照してください。

例

julia> x = 15; y = 4;

julia> fld1(x, y)
4

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

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

mod1(x, y)

床除算の後の剰余、正の 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

fldmod1(x, y)

返す (fld1(x,y), mod1(x,y))。

参照してください fld1, mod1。

//(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)
[...]

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

浮動小数点数 x を指定された整数型の成分を持つ Rational 数として近似します。結果は x から tol 以上の差はありません。

例

julia> rationalize(5.6)
28//5

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

julia> typeof(numerator(a))
BigInt

numerator(x)

xの有理数表現の分子。

例

julia> numerator(2//3)
2

julia> numerator(4)
4

denominator(x)

xの有理数表現の分母。

例

julia> denominator(2//3)
3

julia> denominator(4)
1

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

左ビットシフト演算子、B << n。n >= 0 の場合、結果は B の要素が n ポジション後ろにシフトされ、false 値で埋められます。n < 0 の場合、要素は前方にシフトされます。B >> -n と同等です。

例

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

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

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

<<(x, n)

左ビットシフト演算子、x << n。n >= 0 の場合、結果は x を n ビット左にシフトし、0 で埋めたものです。これは x * 2^n と同等です。n < 0 の場合、これは x >> -n と同等です。

例

julia> Int8(3) << 2
12

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

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

他にも >>、>>>、exp2、ldexp を参照してください。

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

右ビットシフト演算子、B >> n。n >= 0 の場合、結果は B の要素が n ポジション前方にシフトされ、false 値で埋められます。n < 0 の場合、要素は後方にシフトされます。B << -n と同等です。

例

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

julia> B >> 1
5-element BitVector:
 0
 1
 0
 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 と同等です。

例

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。B >> nと同等です。詳細と例については>>を参照してください。

>>>(x, n)

符号なし右ビットシフト演算子、x >>> n。n >= 0 の場合、結果は x を n ビット右にシフトし、0 で埋めます。n < 0 の場合、これは x << -n と同等です。

Unsigned 整数型に対しては、これは >> と同等です。Signed 整数型に対しては、これは signed(unsigned(x) >> n) と同等です。

例

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

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

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

BigInt は無限のサイズを持つかのように扱われるため、埋める必要はなく、これは >> と同等です。

他に >>、<< も参照してください。

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

bitrotate(x, k) はビット単位の回転を実装します。これは、x のビットを左に k 回回転させた値を返します。k の負の値は右に回転します。

関連項目: <<, circshift, BitArray.

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

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

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

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

:expr

式 expr を引用し、expr の抽象構文木 (AST) を返します。AST は Expr、Symbol、またはリテラル値の型である可能性があります。構文 :identifier は Symbol に評価されます。

参照: Expr, Symbol, Meta.parse

例

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

julia> sym = :some_identifier
:some_identifier

julia> value = :0xff
0xff

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

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

引数から均等に間隔を空けた要素と最適化されたストレージを持つ特化型配列（AbstractRange）を構築します。数学的には、範囲は start、step、stop、length のいずれか3つによって一意に決定されます。範囲の有効な呼び出しは次のとおりです。

• start、step、stop、length のいずれか3つを指定して range を呼び出します。
• start、stop、length のいずれか2つを指定して range を呼び出します。この場合、step は正の1であると仮定されます。両方の引数が整数の場合、UnitRange が返されます。
• stop または length のいずれか1つを指定して 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。

返される型に関する詳細はExtended Helpを参照してください。また、対数間隔の点については 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 コンストラクタを参照してください。

Extended Help

range は、引数が整数である場合に Base.OneTo を生成します。

• length のみが提供されている場合
• stop のみが提供されている場合

range は、引数が整数である場合に UnitRange を生成します。

• start と stop のみが提供されている場合
• length と stop のみが提供されている場合

step が指定されている場合、たとえそれが1として指定されていても、UnitRange は生成されません。

Base.OneTo(n)

1:nのように振る舞うAbstractUnitRangeを定義しますが、下限が1であることが型システムによって保証されているという追加の区別があります。

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

範囲 r は r[i] が型 T の値を生成します（最初の形式では、T は自動的に推論されます）。これは、ref 値、step、および len の長さによってパラメータ化されています。デフォルトでは ref は開始値 r[1] ですが、代わりに他のインデックス 1 <= offset <= len の r[offset] の値として指定することもできます。a:b または a:b:c の構文は、a、b、または c のいずれかが浮動小数点数である場合、StepRangeLen を作成します。

logrange(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も参照してください。

LogRange{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]

==(x, y)

汎用等価演算子。===にフォールバックします。等価性の概念を持つすべての型に対して実装されるべきです。例えば、すべての数値型は型を無視して数値として比較されます。文字列はエンコーディングを無視して文字のシーケンスとして比較されます。同じ型のコレクションは一般的にキーセットを比較し、それらが==であれば、各キーの値を比較し、すべてのペアが==であればtrueを返します。他のプロパティは通常考慮されません（例えば、正確な型など）。

この演算子は浮動小数点数に対してIEEEのセマンティクスに従います：0.0 == -0.0およびNaN != NaN。

結果はBool型ですが、オペランドの一方がmissingである場合はmissingが返されます（三値論理）。コレクションは一般的にallに似た三値論理を実装し、いずれかのオペランドにmissing値が含まれている場合はmissingを返し、他のすべてのペアが等しい場合にのみ等しいと見なします。常にBoolの結果を得るにはisequalまたは===を使用してください。

実装

新しい数値型は、この関数を新しい型の2つの引数に対して実装し、可能な限り昇格ルールを介して他の型との比較を処理するべきです。

等価性とハッシュは密接に関連しています；isequalと見なされる2つの値は必ず同じhashを持ち、デフォルトではisequalは==にフォールバックします。型が==および/またはisequalの動作をカスタマイズする場合、hashも同様に実装され、isequalとhashが一致することを保証する必要があります。Set、Dict、および多くの他の内部実装は、この不変条件が成り立つことを前提としています。

もしある型が==、isequal、および[isless](@ref）を定義している場合、比較の一貫性を確保するために<も実装するべきです。

!=(x)

引数を x と比較する関数を作成します != を使用して、すなわち y -> y != x に相当する関数です。返される関数は Base.Fix2{typeof(!=)} 型であり、特化したメソッドを実装するために使用できます。

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

不等比較演算子。常に == の逆の答えを返します。

実装

新しい型は一般的にこれを実装せず、代わりにフォールバック定義 !=(x,y) = !(x==y) に依存すべきです。

例

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

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

常に === の反対の答えを返します。

例

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

julia> a ≢ b
true

julia> a ≢ a
false

<(x)

引数を<を使用してxと比較する関数を作成します。つまり、y -> y < xに相当する関数です。返される関数はBase.Fix2{typeof(<)}型であり、特化したメソッドを実装するために使用できます。

<(x, y)

小なり比較演算子。isless にフォールバックします。浮動小数点の NaN 値の動作のため、この演算子は部分順序を実装します。

実装

標準的な部分順序を持つ新しい型は、新しい型の二つの引数に対してこの関数を実装する必要があります。標準的な全順序を持つ型は、代わりに isless を実装する必要があります。

isunordered も参照してください。

例

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

<=(x)

引数を x と比較する関数を作成します <= を使用して、すなわち y -> y <= x に相当する関数です。返される関数は Base.Fix2{typeof(<=)} 型であり、特化したメソッドを実装するために使用できます。

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

小なりまたは等しい比較演算子。(x < y) | (x == y) にフォールバックします。

例

julia> 'a' <= 'b'
true

julia> 7 ≤ 7 ≤ 9
true

julia> "abc" ≤ "abc"
true

julia> 5 <= 3
false

>(x)

引数を x と比較する関数を作成します。これは > を使用し、すなわち y -> y > x に相当する関数です。返される関数は Base.Fix2{typeof(>)} 型であり、特化したメソッドを実装するために使用できます。

>(x, y)

大なり比較演算子。y < x にフォールバックします。

実装

一般的に、新しい型はこの関数の代わりに < を実装し、フォールバック定義 >(x, y) = y < x に依存すべきです。

例

julia> 'a' > 'b'
false

julia> 7 > 3 > 1
true

julia> "abc" > "abd"
false

julia> 5 > 3
true

>=(x)

引数を x と比較する関数を作成します >= を使用して、すなわち y -> y >= x に相当する関数です。返される関数は Base.Fix2{typeof(>=)} 型であり、特化したメソッドを実装するために使用できます。

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

大なりイコール比較演算子。y <= x にフォールバックします。

例

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

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

cmp(<, x, y)

xがyより小さい場合は-1、等しい場合は0、大きい場合は1を返します。最初の引数は使用する小なり比較関数を指定します。

cmp(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})
[...]

~(x)

ビット単位の否定。

参照: !, &, |。

例

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

x & y

ビット単位のAND。 三値論理を実装しており、一方のオペランドがmissingで他方がtrueの場合はmissingを返します。関数適用形式のために括弧を追加します: (&)(x, y)。

参照: |, xor, &&。

例

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

x | y

ビット単位の論理和。片方のオペランドが missing で、もう片方が false の場合は missing を返す 三値論理 を実装しています。

関連: &, xor, ||.

例

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

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

x と y のビット単位の排他的論理和。引数のいずれかが missing の場合、missing を返す 三値論理 を実装しています。

中置演算 a ⊻ b は xor(a,b) の同義語であり、⊻ は Julia REPL で \xor または \veebar をタブ補完することで入力できます。

例

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

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

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

x と y のビット単位の 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

nor(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

!f::Function

述語関数の否定: ! の引数が関数であるとき、それは f のブール否定を計算する合成関数を返します。

関連情報として ∘ を参照してください。

例

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

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

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

!(x)

ブールの否定。xがmissingの場合、missingを返す三値論理を実装しています。

ビット単位の否定については、~も参照してください。

例

julia> !true
false

julia> !false
true

julia> !missing
missing

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

x && y

ショートサーキットブールAND。

これは x ? y : false と同等です：x が false の場合は false を返し、x が true の場合は y を評価した結果を返します。y が式である場合、x が true のときのみ評価されることに注意してください。これを「ショートサーキット」動作と呼びます。

また、y はブール値である必要はありません。これは、(condition) && (statement) が任意の statement に対して if condition; statement; end の短縮形として使用できることを意味します。

他にも &、三項演算子 ? :、および 制御フロー に関するマニュアルのセクションを参照してください。

例

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"

x || y

ショートサーキットブールOR。

これは x ? true : y と同等です：x が true の場合は true を返し、x が false の場合は y を評価した結果を返します。y が式である場合、x が false のときのみ評価されることに注意してください。これを「ショートサーキット」動作と呼びます。

また、y はブール値である必要はありません。これは、(condition) || (statement) が任意の statement に対して if !(condition); statement; end の短縮形として使用できることを意味します。

参照： |, xor, &&。

例

julia> pi < 3 || ℯ < 3
true

julia> false || true || println("どちらも真ではありません！")
true

julia> pi < 3 || "ブールではない"
"ブールではない"

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の場合、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

sin(x::T) where {T <: Number} -> float(T)

xの正弦を計算します。xはラジアンで指定されます。

isinf(x)の場合はDomainErrorをスローし、isnan(x)の場合はT(NaN)を返します。

他にsind、sinpi、sincos、cis、asinも参照してください。

例

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

julia> sind(45)
0.7071067811865476

julia> sinpi(1/4)
0.7071067811865475

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

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

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

cos(x::T) where {T <: Number} -> float(T)

xがラジアンである場合のコサインを計算します。

isinf(x)の場合はDomainErrorをスローし、isnan(x)の場合はT(NaN)を返します。

他にcosd、cospi、sincos、cisも参照してください。

sincos(x::T) where T -> Tuple{float(T),float(T)}

xがラジアンであるとき、xのサインとコサインを同時に計算し、タプル(sine, cosine)を返します。

isinf(x)の場合はDomainErrorをスローし、isnan(x)の場合は(T(NaN), T(NaN))を返します。

他にcis、sincospi、sincosdも参照してください。

tan(x::T) where {T <: Number} -> float(T)

xのタンジェントを計算します。xはラジアンである必要があります。

isinf(x)の場合はDomainErrorをスローし、isnan(x)の場合はT(NaN)を返します。

他にtanhも参照してください。

sind(x::T) where T -> float(T)

xのサインを計算します。xは度数で指定されます。xが行列の場合、xは正方行列である必要があります。

isinf(x)の場合はDomainErrorをスローし、isnan(x)の場合はT(NaN)を返します。

cosd(x::T) where T -> float(T)

xが度数である場合のコサインを計算します。xが行列の場合、xは正方行列である必要があります。

isinf(x)の場合はDomainErrorをスローし、isnan(x)の場合はT(NaN)を返します。

tand(x::T) where T -> float(T)

xのタンジェントを計算します。xは度数で指定されます。xが行列の場合、xは正方行列である必要があります。

isinf(x)の場合はDomainErrorをスローし、isnan(x)の場合はT(NaN)を返します。

sincosd(x::T) where T -> Tuple{float(T),float(T)}

同時に x のサインとコサインを計算します。ここで x は度数法であり、タプル (sine, cosine) を返します。

isinf(x) の場合は DomainError をスローし、isnan(x) の場合は (T(NaN), T(NaN)) のタプルを返します。

sinpi(x::T) where T -> float(T)

\[\sin(\pi x)\]

をsin(pi*x)よりも正確に計算します。特に大きなxに対して。

isinf(x)の場合はDomainErrorを投げ、isnan(x)の場合はT(NaN)を返します。

他にsind、cospi、sincospiも参照してください。

cospi(x::T) where T -> float(T)

\[\cos(\pi x)\]

をcos(pi*x)よりも正確に計算します。特に大きなxに対して。

isinf(x)の場合はDomainErrorを投げ、isnan(x)の場合はT(NaN)を返します。

関連: cispi, sincosd, cospi.

tanpi(x::T) where T -> float(T)

\[\tan(\pi x)\]

をtan(pi*x)よりも正確に計算します。特に大きなxに対して。

isinf(x)の場合はDomainErrorを投げ、isnan(x)の場合はT(NaN)を返します。

関連情報としてtand、sinpi、cospi、sincospiを参照してください。

sincospi(x::T) where T -> Tuple{float(T),float(T)}

同時に sinpi(x) と cospi(x) を計算します（x がラジアンのときの π*x の正弦と余弦）、タプル (sine, cosine) を返します。

isinf(x) の場合は DomainError を投げ、isnan(x) の場合は (T(NaN), T(NaN)) のタプルを返します。

関連: cispi, sincosd, sinpi.

sinh(x)

xの双曲線正弦を計算します。

関連情報はsinを参照してください。

cosh(x)

xの双曲線コサインを計算します。

関連情報としてcosを参照してください。

tanh(x)

xの双曲線正接を計算します。

関連項目としては tan、atanh があります。

例

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

asin(x::T) where {T <: Number} -> float(T)

xの逆正弦を計算します。出力はラジアンで表されます。

isnan(x)の場合はT(NaN)を返します。

出力が度数の場合は、asindを参照してください。

例

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

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

acos(x::T) where {T <: Number} -> float(T)

xの逆余弦を計算し、出力はラジアンで返します。

isnan(x)の場合はT(NaN)を返します。

atan(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

asind(x)

xの逆正弦を計算します。出力は度単位です。xが行列の場合、xは正方行列である必要があります。

acosd(x)

xの逆余弦を計算します。出力は度数で表されます。xが行列の場合、xは正方行列である必要があります。

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は、単一引数バージョンではT、二引数バージョンではpromote_type(T,S)です。

sec(x::T) where {T <: Number} -> float(T)

xのセカントを計算します。xはラジアンで指定されます。

isinf(x)の場合はDomainErrorをスローし、isnan(x)の場合はT(NaN)を返します。

csc(x::T) where {T <: Number} -> float(T)

xのコセカントを計算します。xはラジアンで指定されます。

isinf(x)の場合はDomainErrorをスローし、isnan(x)の場合はT(NaN)を返します。

cot(x::T) where {T <: Number} -> float(T)

xのコタンジェントを計算します。xはラジアンで指定されます。

isinf(x)の場合はDomainErrorをスローし、isnan(x)の場合はT(NaN)を返します。

secd(x::T) where {T <: Number} -> float(T)

xのセカントを計算します。xは度数で指定されます。

isinf(x)の場合はDomainErrorを投げ、isnan(x)の場合はT(NaN)を返します。

cscd(x::T) where {T <: Number} -> float(T)

xの余弦の逆数を計算します。xは度数法で指定されます。

isinf(x)の場合はDomainErrorを投げ、isnan(x)の場合はT(NaN)を返します。

cotd(x::T) where {T <: Number} -> float(T)

xが度数であるとき、xのコタンジェントを計算します。

isinf(x)の場合はDomainErrorを投げ、isnan(x)の場合はT(NaN)を返します。

asec(x::T) where {T <: Number} -> float(T)

xの逆セカントを計算します。出力はラジアンで表されます。

acsc(x::T) where {T <: Number} -> float(T)

xの逆コセカントを計算します。出力はラジアンで表されます。

acot(x::T) where {T <: Number} -> float(T)

xの逆コタンジェントを計算します。出力はラジアンで表されます。

asecd(x)

xの逆セカントを計算します。出力は度数で表されます。xが行列の場合、xは正方行列である必要があります。

acscd(x)

xの逆余弦の計算を行い、出力は度数で返されます。xが行列の場合、xは正方行列である必要があります。

acotd(x)

xの逆コタンジェントを計算します。出力は度数法です。xが行列の場合、xは正方行列である必要があります。

sech(x::T) where {T <: Number} -> float(T)

xの双曲線セカントを計算します。

isnan(x)の場合はT(NaN)を返します。

csch(x::T) where {T <: Number} -> float(T)

xの双曲線余割の計算を行います。

isnan(x)の場合はT(NaN)を返します。

coth(x::T) where {T <: Number} -> float(T)

xの双曲線コタンジェントを計算します。

isnan(x)の場合はT(NaN)を返します。

asinh(x)

xの逆双曲線正弦を計算します。

acosh(x)

xの逆双曲線コサインを計算します。

atanh(x)

xの逆双曲線タンジェントを計算します。

asech(x::T) where {T <: Number} -> float(T)

xの逆双曲線セカントを計算します。

acsch(x::T) where {T <: Number} -> float(T)

xの逆双曲線余割を計算します。

acoth(x::T) where {T <: Number} -> float(T)

xの逆双曲線コタンジェントを計算します。

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 およびその導関数も参照してください。

cosc(x::T) where {T <: Number} -> float(T)

\[x \neq 0\]

の場合は $\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)$ を計算し、$x = 0$ の場合は $0$ を返します。これは sinc(x) の導関数です。

isnan(x) の場合は T(NaN) を返します。

詳細は sinc を参照してください。

deg2rad(x)

xを度からラジアンに変換します。

関連情報としては rad2deg, sind, pi があります。

例

julia> deg2rad(90)
1.5707963267948966

rad2deg(x)

xをラジアンから度に変換します。

関連情報としてdeg2radを参照してください。

例

julia> rad2deg(pi)
180.0

hypot(x, y)

オーバーフローとアンダーフローを避けて、斜辺 $\sqrt{|x|^2+|y|^2}$ を計算します。

このコードは、Carlos F. Borgesによる「hypot(a,b)の改善されたアルゴリズム」に記載されたアルゴリズムの実装です。この記事は、リンク https://arxiv.org/abs/1904.09481 でarXivにオンラインで入手できます。

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

log(x)

xの自然対数を計算します。

負のReal引数に対してDomainErrorをスローします。Complex引数を使用してComplex結果を得ることができます。

他にℯ、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

log(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
[...]

julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0

log2(x)

xの底2の対数を計算します。負のReal引数に対してはDomainErrorをスローします。

関連: exp2, ldexp, ispow2.

例

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
ERROR: DomainError with -2.0:
log2は負の実引数で呼び出されましたが、複素引数で呼び出された場合にのみ複素結果を返します。log2(Complex(x))を試してください。
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

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

log10(x)

xの10を底とする対数を計算します。負のReal引数に対してはDomainErrorをスローします。

例

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

julia> log10(-2)
ERROR: DomainError with -2.0:
log10は負の実引数で呼び出されましたが、複素引数で呼び出された場合にのみ複素結果を返します。log10(Complex(x))を試してください。
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

log1p(x)

1+xの正確な自然対数。-1未満のReal引数に対してDomainErrorをスローします。

例

julia> log1p(-0.5)
-0.6931471805599453

julia> log1p(0)
0.0

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

frexp(val)

戻り値は (x,exp) であり、x は区間 $[1/2, 1)$ または 0 の大きさを持ち、val は $x \times 2^{exp}$ に等しいです。

関連情報として 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))

exp(x)

xの自然基底指数を計算します。言い換えれば、$ℯ^x$です。

exp2、exp10、およびcisも参照してください。

例

julia> exp(1.0)
2.718281828459045

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

exp2(x)

xの底2指数を計算します。言い換えれば、$2^x$です。

関連情報としては、ldexp、<<があります。

例

julia> exp2(5)
32.0

julia> 2^5
32

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

exp10(x)

xの10を底とする指数を計算します。言い換えれば、$10^x$です。

例

julia> exp10(2)
100.0

julia> 10^2
100

ldexp(x, n)

\[x \times 2^n\]

を計算します。

関連情報として frexp, exponent を参照してください。

例

julia> ldexp(5.0, 2)
20.0

modf(x)

数の小数部分と整数部分のタプル (fpart, ipart) を返します。両方の部分は引数と同じ符号を持ちます。

例

julia> modf(3.5)
(0.5, 3.0)

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

expm1(x)

\[e^x-1\]

を正確に計算します。これは、xの小さい値に対してexp(x)-1を直接評価する際に関わる精度の損失を回避します。

例

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

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

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

数値 x を四捨五入します。

キーワード引数なしで、x は整数値に四捨五入され、T が提供されていない場合は x と同じ型の値が返されます。値が T で表現できない場合、InexactError がスローされます。これは convert に似ています。

digits キーワード引数が提供されると、小数点以下（または負の場合は小数点前）の指定された桁数に四捨五入されます。基数は base です。

sigdigits キーワード引数が提供されると、指定された有効桁数に四捨五入されます。基数は base です。

RoundingMode r は四捨五入の方向を制御します。デフォルトは RoundNearest で、最も近い整数に四捨五入され、0.5 の分数値は最も近い偶数の整数に四捨五入されます。グローバルな四捨五入モードが変更されると、round が不正確な結果を返す可能性があることに注意してください（[rounding](@ref）を参照）。

浮動小数点型に四捨五入する場合、その型で表現可能な整数（および 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)

julia> x = 1.15
1.15

julia> big(1.15)
1.149999999999999911182158029987476766109466552734375

julia> x < 115//100
true

julia> round(x, digits=1)
1.2

Extensions

round を新しい数値型に拡張するには、通常 Base.round(x::NewType, r::RoundingMode) を定義するだけで十分です。

RoundingMode

浮動小数点演算の丸めモードを制御するために使用される型（rounding/setrounding 関数を介して）、または最も近い整数に丸めるためのオプション引数として（round 関数を介して）。

現在サポートされている丸めモードは次のとおりです：

• RoundNearest（デフォルト）
• RoundNearestTiesAway
• RoundNearestTiesUp
• RoundToZero
• RoundFromZero
• RoundUp
• RoundDown

RoundNearest

デフォルトの丸めモードです。最も近い整数に丸められ、引き分け（0.5の分数値）は最も近い偶数に丸められます。

RoundNearestTiesAway

ゼロから離れるように丸められた、最も近い整数に丸めます（C/C++ round の動作）。

RoundNearestTiesUp

最も近い整数に丸めます。結びつきがある場合は、正の無限大に向かって丸められます（Java/JavaScript round の動作）。

RoundToZero

round この丸めモードを使用することは、trunc のエイリアスです。

RoundFromZero

ゼロから離れるように丸めます。

例

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

RoundUp

round この丸めモードを使用することは、ceil のエイリアスです。

RoundDown

round この丸めモードを使用することは、floor のエイリアスです。

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

複素数 z に対して同じ型の最も近い整数値を返し、指定された RoundingMode を使用して結びつきを解消します。最初の 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

ceil([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}) を定義します。

floor([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}) を定義します。

trunc([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

unsafe_trunc(T, x)

絶対値が x の絶対値以下である T 型の最も近い整数値を返します。もしその値が T で表現できない場合は、任意の値が返されます。詳細は trunc を参照してください。

例

julia> unsafe_trunc(Int, -2.2)
-2

julia> unsafe_trunc(Int, NaN)
-9223372036854775808

min(x, y, ...)

引数の最小値を isless に基づいて返します。引数のいずれかが missing の場合、missing を返します。コレクションから最小要素を取得するには、minimum 関数も参照してください。

例

julia> min(2, 5, 1)
1

julia> min(4, missing, 6)
missing

max(x, y, ...)

引数の最大値を isless に基づいて返します。引数のいずれかが missing の場合、missing を返します。コレクションから最大要素を取得するには、maximum 関数も参照してください。

例

julia> max(2, 5, 1)
5

julia> max(5, missing, 6)
missing

minmax(x, y)

返す (min(x,y), max(x,y))。

extrema も参照してください。これは (minimum(x), maximum(x)) を返します。

例

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

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

xを範囲r内に収める。

clamp(x, T)::T

xをtypemin(T)とtypemax(T)の間に制限し、結果を型Tに変換します。

関連情報としてtruncを参照してください。

例

julia> clamp(200, Int8)
127

julia> clamp(-200, Int8)
-128

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

clamp(x, lo, hi)

lo <= x <= hi の場合は x を返します。x > hi の場合は hi を返します。x < lo の場合は lo を返します。引数は共通の型に昇格されます。

他にも clamp!, min, max を参照してください。

例

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

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

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

array内の値を指定された範囲に制限します（インプレース）。詳細はclampを参照してください。

例

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

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

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

abs(x)

xの絶対値。

absが符号付き整数に適用されると、オーバーフローが発生する可能性があり、その結果、負の値が返されることがあります。このオーバーフローは、absが符号付き整数の最小表現可能値に適用されるときのみ発生します。つまり、x == typemin(typeof(x))のとき、abs(x) == x < 0となり、期待される-xではありません。

参照: abs2, unsigned, sign。

例

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs.(Int8[-128 -127 -126 0 126 127])  # typemin(Int8)でオーバーフロー
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

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

Checked

Checkedモジュールは、オーバーフローが発生したときにエラーをスローする組み込みの符号付きおよび符号なし整数型のための算術関数を提供します。これらはchecked_sub、checked_divなどのように名付けられています。さらに、add_with_overflow、sub_with_overflow、mul_with_overflowは、チェックされていない結果とオーバーフローの存在を示すブール値の両方を返します。

Base.checked_abs(x)

abs(x)を計算し、適用可能な場合はオーバーフローエラーをチェックします。たとえば、標準の二の補数符号付き整数（例：Int）はabs(typemin(Int))を表現できないため、オーバーフローが発生します。

オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。

Base.checked_neg(x)

-xを計算し、適用可能な場合はオーバーフローエラーをチェックします。たとえば、標準の二の補数符号付き整数（例：Int）は-typemin(Int)を表現できないため、オーバーフローが発生します。

オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。

Base.checked_add(x, y)

x+yを計算し、適用可能な場合はオーバーフローエラーをチェックします。

オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。

Base.checked_sub(x, y)

x-yを計算し、適用可能な場合はオーバーフローエラーをチェックします。

オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。

Base.checked_mul(x, y)

x*yを計算し、適用可能な場合はオーバーフローエラーをチェックします。

オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。

Base.checked_div(x, y)

div(x,y)を計算し、適用可能な場合はオーバーフローエラーをチェックします。

オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。

Base.checked_rem(x, y)

x%yを計算し、適用可能な場合はオーバーフローエラーをチェックします。

オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。

Base.checked_fld(x, y)

fld(x,y)を計算し、適用可能な場合はオーバーフローエラーをチェックします。

オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。

Base.checked_mod(x, y)

mod(x,y)を計算し、適用可能な場合はオーバーフローエラーをチェックします。

オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。

Base.checked_cld(x, y)

cld(x,y)を計算し、適用可能な場合はオーバーフローエラーをチェックします。

オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。

Base.checked_pow(x, y)

^(x,y)を計算し、適用可能な場合はオーバーフローエラーをチェックします。

オーバーフロープロテクションは、目に見えるパフォーマンスペナルティを課す可能性があります。

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

r = x+y を計算し、フラグ f はオーバーフローが発生したかどうかを示します。

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

r = x-y を計算し、フラグ f はオーバーフローが発生したかどうかを示します。

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

r = x*y を計算し、フラグ f はオーバーフローが発生したかどうかを示します。

abs2(x)

xの二乗絶対値。

これは、特にabs(x)がhypotを介して平方根を必要とする複素数の場合、abs(x)^2よりも速くなることがあります。

他にもabs、conj、realを参照してください。

例

julia> abs2(-3)
9

julia> abs2(3.0 + 4.0im)
25.0

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

copysign(x, y) -> z

zを返します。zはxの大きさを持ち、yと同じ符号を持ちます。

例

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

sign(x)

x==0 の場合はゼロを返し、それ以外の場合は $x/|x|$ を返します（すなわち、実数 x に対して ±1）。

関連項目としては signbit, zero, copysign, flipsign があります。

例

julia> sign(-4.0)
-1.0

julia> sign(99)
1

julia> sign(-0.0)
-0.0

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

signbit(x)

xの符号の値が負であればtrueを返し、そうでなければfalseを返します。

関連情報としてsignおよびcopysignを参照してください。

例

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true

flipsign(x, y)

yが負の場合、xの符号を反転させた値を返します。例えば abs(x) = flipsign(x,x)。

例

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5

sqrt(x)

返す $\sqrt{x}$。

負の Real 引数に対して DomainError をスローします。代わりに Complex の負の引数を使用して Complex の結果を得てください。

接頭辞演算子 √ は 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

isqrt(n::Integer)

整数の平方根: m*m <= n を満たす最大の整数 m。

julia> isqrt(5)
2

cbrt(x::Real)

xの立方根を返します。すなわち、$x^{1/3}$です。負の値も受け付けます（$x < 0$のときは負の実数の根を返します）。

接頭辞演算子∛はcbrtと同等です。

例

julia> cbrt(big(27))
3.0

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

fourthroot(x)

xの4乗根を、sqrtを2回連続して適用することで返します。

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

real(T::Type)

型 T の値の実部を表す型を返します。例えば、T == Complex{R} の場合、R を返します。typeof(real(zero(T))) と同等です。

例

julia> real(Complex{Int})
Int64

julia> real(Float64)
Float64

real(z)

複素数 z の実部を返します。

関連: imag, reim, complex, isreal, Real.

例

julia> real(1 + 3im)
1

imag(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

imag(z)

複素数 z の虚部を返します。

参照: conj, reim, adjoint, angle。

例

julia> imag(1 + 3im)
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))

reim(z)

複素数 z の実部と虚部のタプルを返します。

例

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

conj(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

conj(z)

複素数 z の複素共役を計算します。

関連情報: angle, adjoint.

例

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

angle(z)

複素数 z の位相角をラジアンで計算します。

-pi ≤ angle(z) ≤ pi の数を返し、したがって負の実軸に沿って不連続です。

関連項目: atan, cis, rad2deg.

例

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

cis(x)

オイラーの公式を使用した exp(im*x) のより効率的な方法: $\cos(x) + i \sin(x) = \exp(i x)$。

関連項目としては cispi, sincos, exp, angle があります。

例

julia> cis(π) ≈ -1
true

cispi(x)

cis(pi*x)のより正確な方法（特に大きなxの場合）。

関連項目としては、cis、sincospi、exp、angleがあります。

例

julia> cispi(10000)
1.0 + 0.0im

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

binomial(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.

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 も参照してください。

例

julia> binomial(5, 3)
10

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

julia> binomial(-5, 3)
-35

外部リンク

• 二項係数 の Wikipedia。

factorial(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.

gcd(x, y...)

最大公約数（正の）またはすべての引数がゼロの場合はゼロ。引数は整数および有理数であることができます。

\[a\]

は $b$ の約数であるためには、整数 $m$ が存在して $ma=b$ である必要があります。

例

julia> gcd(6, 9)
3

julia> gcd(6, -9)
3

julia> gcd(6, 0)
6

julia> gcd(0, 0)
0

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

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

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

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

lcm(x, y...)

最小公倍数（正の）または引数のいずれかがゼロの場合はゼロ。引数は整数および有理数であることができます。

\[a\]

は $b$ の倍数であるとは、整数 $m$ が存在して $a=mb$ となる場合を指します。

例

julia> lcm(2, 3)
6

julia> lcm(-2, 3)
6

julia> lcm(0, 3)
0

julia> lcm(0, 0)
0

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

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

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

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

gcdx(a, b...)

a と b の最大公約数（正の）およびそのベズー係数を計算します。すなわち、$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, ...) を返します。

引数は整数および有理数である可能性があります。

例

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

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

julia> gcdx(15, 12, 20)
(1, 7, -7, -1)

ispow2(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

nextpow(a, x)

x以上の最小のa^nで、nは非負整数です。aは1より大きく、xは0より大きくなければなりません。

prevpowも参照してください。

例

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16

prevpow(a, x)

x 以下の最大の a^n で、n は非負整数です。a は 1 より大きく、x は 1 未満であってはなりません。

参照: nextpow, isqrt.

例

julia> prevpow(2, 7)
4

julia> prevpow(2, 9)
8

julia> prevpow(5, 20)
5

julia> prevpow(4, 16)
16

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

n以上の次の整数で、factorsの因子$k_i$に対して整数$p_1$, $p_2$などを用いて$\prod k_i^{p_i}$の形で表すことができる。

例

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

julia> 2^2 * 3^3
108

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 におけるモジュラー乗算です。n が偶数の場合、2^N と互いに素でないため、そのような逆数は存在しないため、エラーが発生します。

整数型によって暗黙的に示されるモジュラスを明示的な値として指定することは、型によって表現できるには大きすぎるため、しばしば不便です。

モジュラー逆数は、https://arxiv.org/pdf/2204.04342.pdf で説明されているアルゴリズムを使用して、一般的なケースよりもはるかに効率的に計算されます。

invmod(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

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

\[x^p \pmod m\]

を計算します。

例

julia> powermod(2, 6, 5)
4

julia> mod(2^6, 5)
4

julia> powermod(5, 2, 20)
5

julia> powermod(5, 2, 19)
6

julia> powermod(5, 3, 19)
11

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

整数 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(x, y)

sumで使用される還元演算子。+との主な違いは、小さい整数がInt/UIntに昇格されることです。

widemul(x, y)

x と y を掛け算し、結果をより大きな型で返します。

関連情報としては promote、Base.add_sum があります。

例

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

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

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

evalpoly(x, p)

多項式 $\sum_k x^{k-1} p[k]$ を評価します。係数 p[1], p[2], ... が与えられます。つまり、係数は x の冪の昇順で与えられます。係数の数が静的に知られている場合、すなわち p が Tuple の場合、ループはコンパイル時に展開されます。この関数は、x が実数の場合はホーナー法を使用して効率的なコードを生成し、x が複素数の場合はゴーツェルのような ^[DK62] アルゴリズムを使用します。

例

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

@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

@fastmath expr

厳密なIEEEセマンティクスに違反する可能性のある関数を呼び出す変換されたバージョンの式を実行します。これにより、可能な限り高速な操作が可能になりますが、結果は未定義です – これを行う際は注意が必要で、数値結果が変わる可能性があります。

これは、LLVM Fast-Mathフラグを設定し、clangの-ffast-mathオプションに対応します。詳細については、パフォーマンス注釈に関するノートを参照してください。

例

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672