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)

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

例

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

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

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

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

^(x, y)

累乗演算子。

x と y が整数の場合、結果がオーバーフローする可能性があります。科学的表記法で数値を入力するには、1.2 * 10^3 の代わりに 1.2e3 のような Float64 リテラルを使用してください。

y が Int リテラル（例えば x^2 の 2 や x^-3 の -3）である場合、Julia コード x^y はコンパイラによって Base.literal_pow(^, x, Val(y)) に変換され、指数の値に対するコンパイル時の特殊化が可能になります。（デフォルトのフォールバックとして、Base.literal_pow(^, x, Val(y)) = ^(x,y) があり、通常 ^ == Base.^ ですが、呼び出し名前空間で ^ が定義されている場合は除きます。）y が負の整数リテラルである場合、デフォルトでは Base.literal_pow は操作を inv(x)^-y に変換します。ここで -y は正の値です。

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

例

julia> 3^5
243

julia> 3^-1  # uses Base.literal_pow
0.3333333333333333

julia> p = -1;

julia> 3^p
ERROR: DomainError with -1:
Cannot raise an integer x to a negative power -1.
[...]

julia> 3.0^p
0.3333333333333333

julia> 10^19 > 0  # integer overflow
false

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

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

fld(x, y)

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

関連項目: div, cld, fld1。

例

julia> fld(7.3, 5.5)
1.0

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

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

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

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

cld(x, y)

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

関連項目としてはdiv、fldがあります。

例

julia> cld(5.5, 2.2)
3.0

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

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

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

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

例

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

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

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

xをyで割った剰余、または同等に、yでの切り捨て除算の後のxの余り、すなわち中間的な丸めなしで計算された場合のx - y*fld(x,y)です。

結果はyと同じ符号を持ち、abs(y)よりも小さい大きさになります（いくつかの例外があります。以下の注釈を参照してください）。

参照: rem, div, fld, mod1, invmod。

julia> mod(8, 3)
2

julia> mod(9, 3)
0

julia> mod(8.9, 3)
2.9000000000000004

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

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

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

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

y::T を見つけるには、x ≡ y (mod n) を満たす必要があります。ここで、n は T で表現可能な整数の数であり、y は [typemin(T),typemax(T)] の範囲内の整数です。もし T が任意の整数を表現できる場合（例: T == BigInt）、この操作は T への変換に対応します。

例

julia> x = 129 % Int8
-127

julia> typeof(x)
Int8

julia> x = 129 % BigInt
129

julia> typeof(x)
BigInt

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

<<(x, n)

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

例

julia> Int8(3) << 2
12

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

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

関連項目は >>、>>>、exp2、ldexp です。

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

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

例

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

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

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

>>(x, n)

右ビットシフト演算子、x >> n。n >= 0 の場合、結果は x を n ビット右にシフトしたもので、x >= 0 の場合は 0 で埋め、x < 0 の場合は 1 で埋めて、x の符号を保持します。これは fld(x, 2^n) と同等です。n < 0 の場合、これは x << -n と同等です。

例

julia> Int8(13) >> 2
3

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

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

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

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

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

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

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

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

例

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

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

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

>>>(x, n)

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

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

例

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

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

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

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

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

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

符号なし右ビットシフト演算子、B >>> n。B >> nと同等です。詳細と例については>>を参照してください。

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

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

参照: <<, circshift, BitArray.

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

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

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

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

:expr

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

参照: Expr, Symbol, Meta.parse

例

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

julia> sym = :some_identifier
:some_identifier

julia> value = :0xff
0xff

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

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

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

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

返される型に関する詳細は拡張ヘルプを参照してください。また、対数間隔の点については logrange も参照してください。

例

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

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

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

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

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

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

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

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

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

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

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

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

length が指定されておらず、stop - start が step の整数倍でない場合、stop より前で終了する範囲が生成されます。

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

中間値が合理的に計算されるように特別な配慮がなされています。この誘発されたオーバーヘッドを避けるために、LinRange コンストラクタを参照してください。

拡張ヘルプ

range は引数が整数の場合、次の条件で Base.OneTo を生成します。

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

range は引数が整数の場合、次の条件で UnitRange を生成します。

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

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

Base.OneTo(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は==にフォールバックするため、==の新しいメソッドはDict型によってキーを比較するために使用されます。あなたの型が辞書のキーとして使用される場合、それはしたがってhashも実装するべきです。

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

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

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

実装

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

例

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

!=(x)

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

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

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

例

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

julia> a ≢ b
true

julia> a ≢ a
false

<(x, y)

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

実装

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

関連情報として isunordered も参照してください。

例

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

<(x)

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

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

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

例

julia> 'a' <= 'b'
true

julia> 7 ≤ 7 ≤ 9
true

julia> "abc" ≤ "abc"
true

julia> 5 <= 3
false

<=(x)

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

>(x, y)

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

実装

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

例

julia> 'a' > 'b'
false

julia> 7 > 3 > 1
true

julia> "abc" > "abd"
false

julia> 5 > 3
true

>(x)

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

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

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

例

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

>=(x)

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

cmp(x,y)

xがyより小さい場合は-1、等しい場合は0、大きい場合は1を返します。islessによって実装された全順序を使用します。

例

julia> cmp(1, 2)
-1

julia> cmp(2, 1)
1

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

cmp(<, x, y)

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

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

2つの文字列を比較します。両方の文字列が同じ長さで、各インデックスの文字が両方の文字列で同じであれば 0 を返します。a が b の接頭辞である場合、または a がアルファベット順で b の前に来る場合は -1 を返します。b が a の接頭辞である場合、または b がアルファベット順で a の前に来る場合は 1 を返します（技術的には、Unicode コードポイントによる辞書順です）。

例

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

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

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

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

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

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

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

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

!(x)

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

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

例

julia> !true
false

julia> !false
true

julia> !missing
missing

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

!f::Function

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

関連項目 ∘。

例

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

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

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

x && y

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

関連項目としては、&、三項演算子 ? :、および制御フローに関するマニュアルのセクションがあります。

例

julia> x = 3;

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

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

x || y

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

参照: |, xor, &&。

例

julia> pi < 3 || ℯ < 3
true

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

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

不正確な等価比較。2つの数は、相対距離または絶対距離が許容範囲内である場合に等しいと比較されます：isapproxはnorm(x-y) <= max(atol, rtol*max(norm(x), norm(y)))が成り立つ場合にtrueを返します。デフォルトのatol（絶対許容誤差）はゼロで、デフォルトのrtol（相対許容誤差）はxとyの型に依存します。キーワード引数nansは、NaN値が等しいと見なされるかどうかを決定します（デフォルトはfalseです）。

実数または複素数の浮動小数点値の場合、atol > 0が指定されていない場合、rtolはxまたはyの型のepsの平方根にデフォルト設定され、どちらか大きい方（最も精度が低い）になります。これは、約半分の有効桁の等価性を要求することに相当します。それ以外の場合、例えば整数引数の場合やatol > 0が指定されている場合、rtolはゼロにデフォルト設定されます。

normキーワードは、数値の(x,y)の場合はabsに、配列の場合はLinearAlgebra.normにデフォルト設定されます（代替のnormの選択が時々便利です）。xとyが配列の場合、norm(x-y)が有限でない場合（すなわち±InfまたはNaN）、比較はxとyのすべての要素が成分ごとにほぼ等しいかどうかを確認することに戻ります。

二項演算子≈は、デフォルトの引数を持つisapproxと同等であり、x ≉ yは!isapprox(x,y)と同等です。

x ≈ 0（すなわち、デフォルトの許容誤差でゼロと比較すること）は、デフォルトのatolが0であるため、x == 0と同等です。このような場合、適切なatolを指定するか（またはnorm(x) ≤ atolを使用するか）、コードを再配置する必要があります（例えば、x - y ≈ 0ではなくx ≈ yを使用する）。非ゼロのatolを自動的に選択することはできません。なぜなら、それは問題の全体的なスケーリング（「単位」）に依存するからです：例えば、x - y ≈ 0において、atol=1e-9はxがメートル単位の地球の半径である場合には非常に小さな許容誤差ですが、xがメートル単位の水素原子の半径である場合には非常に大きな許容誤差です。

例

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

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

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

julia> 0.1 + 1e-10 ≈ 0.1
true

julia> 1e-10 ≈ 0
false

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

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

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

引数を x と比較する関数を作成します。つまり、y -> y ≈ x に相当する関数です。

ここでサポートされるキーワード引数は、2引数の isapprox と同じです。

sin(x)

xがラジアンであるときのxの正弦を計算します。

関連情報としては、sind、sinpi、sincos、cis、asinがあります。

例

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

julia> sind(45)
0.7071067811865476

julia> sinpi(1/4)
0.7071067811865475

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

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

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

cos(x)

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

関連情報としては、cosd、cospi、sincos、cisがあります。

sincos(x)

xがラジアンであるとき、xの正弦と余弦を同時に計算し、タプル(正弦, 余弦)を返します。

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

tan(x)

xがラジアンであるときのxのタンジェントを計算します。

sind(x)

xが度数であるときのsind(x)の計算。xが行列の場合、xは正方行列である必要があります。

cosd(x)

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

tand(x)

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

sincosd(x)

xが度数であるとき、xの正弦と余弦を同時に計算します。

sinpi(x)

\[\sin(\pi x)\]

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

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

cospi(x)

\[\cos(\pi x)\]

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

tanpi(x)

\[\tan(\pi x)\]

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

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

sincospi(x)

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

参照: cispi, sincosd, sinpi.

sinh(x)

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

cosh(x)

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

tanh(x)

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

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

例

julia> tanh.(-3:3f0)  # ここで 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)

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

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

例

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

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

acos(x)

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

atan(y)
atan(y, x)

y または y/x の逆タンジェントを計算します。

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

yまたはy/xの逆タンジェントを計算します。出力は度単位です。

sec(x)

xがラジアンであるとき、xのセカントを計算します。

csc(x)

xがラジアンであるとき、xの余弦を計算します。

cot(x)

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

secd(x)

xが度数であるときのxのセカントを計算します。

cscd(x)

xが度数であるときのxの余弦の逆数を計算します。

cotd(x)

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

asec(x)

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

acsc(x)

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

acot(x)

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

asecd(x)

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

acscd(x)

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

acotd(x)

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

sech(x)

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

csch(x)

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

coth(x)

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

asinh(x)

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

acosh(x)

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

atanh(x)

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

asech(x)

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

acsch(x)

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

acoth(x)

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

sinc(x)

正規化されたsinc関数 $\operatorname{sinc}(x) = \sin(\pi x) / (\pi x)$ を計算します。ただし、$x \neq 0$ の場合、$x = 0$ の場合は $1$ です。

他に cosc とその導関数も参照してください。

cosc(x)

\[x \neq 0\]

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

詳細は 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)の改善されたアルゴリズム」に記載されたアルゴリズムの実装です。この記事は、次のリンクでarXivでオンラインで入手できます: https://arxiv.org/abs/1904.09481

hypot(x...)

直角三角形の斜辺を計算します $\sqrt{\sum |x_i|^2}$ オーバーフローとアンダーフローを避けながら。

標準ライブラリのLinearAlgebraにあるnormも参照してください。

例

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # a^2はオーバーフローします
ERROR: DomainError with -2.914184810805068e18:
sqrtは負の実引数で呼び出されましたが、複素引数で呼び出された場合にのみ複素結果を返します。sqrt(Complex(x))を試してください。
Stacktrace:
[...]

julia> hypot(3, 4im)
5.0

julia> hypot(-5.7)
5.7

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

julia> using LinearAlgebra

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

log(x)

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

負のReal引数に対してはDomainErrorをスローします。複素数引数を使用して複素数結果を得てください。負の実軸に沿って分岐切断があり、-0.0imは軸の下にあると見なされます。

他にℯ、log1p、log2、log10も参照してください。

例

julia> log(2)
0.6931471805599453

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

julia> log(-3 + 0im)
1.0986122886681098 + 3.141592653589793im

julia> log(-3 - 0.0im)
1.0986122886681098 - 3.141592653589793im

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

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が$[1/2, 1)$または0の範囲にあるように、(x,exp)を返します。そして、valは$x \times 2^{exp}$に等しくなります。

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

例

julia> frexp(6.0)
(0.75, 3)

julia> significand(6.0), exponent(6.0)  # [1, 2)の範囲に代わり
(1.5, 2)

julia> frexp(0.0), frexp(NaN), frexp(-Inf)  # 指数はエラーを返します
((0.0, 0), (NaN, 0), (-Inf, 0))

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 の型の値が返されます。T が提供されていない場合は、x と同じ型の値が返されます。値が T で表現できない場合、InexactError がスローされます。これは convert に似ています。

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

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

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

浮動小数点型に四捨五入する場合、その型で表現可能な整数（および Inf）に四捨五入され、真の整数には四捨五入されません。Inf は「最も近い」を決定する目的で floatmax(T) よりも1 ulp大きいものとして扱われます。これは convert に似ています。

例

julia> round(1.7)
2.0

julia> round(Int, 1.7)
2

julia> round(1.5)
2.0

julia> round(2.5)
2.0

julia> round(pi; digits=2)
3.14

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

julia> round(123.456; sigdigits=2)
120.0

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

julia> round(Float16, typemax(UInt128))
Inf16

julia> floor(Float16, typemax(UInt128))
Float16(6.55e4)

julia> x = 1.15
1.15

julia> big(1.15)
1.149999999999999911182158029987476766109466552734375

julia> x < 115//100
true

julia> round(x, digits=1)
1.2

拡張

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

RoundingMode

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

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

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

RoundNearest

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

RoundNearestTiesAway

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

RoundNearestTiesUp

最も近い整数に丸めます。結びつきがある場合は、正の無限大に向かって丸めます（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)

型 T の絶対値が x の絶対値以下である最も近い整数値を返します。値が 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[@ref]を参照してください。これは (minimum(x), maximum(x)) を返します。

例

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

clamp(x, lo, hi)

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

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

例

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

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

clamp(x, T)::T

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

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

例

julia> clamp(200, Int8)
127

julia> clamp(-200, Int8)
-128

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

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

xを範囲r内に収めます。

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

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

例

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

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

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

abs(x)

xの絶対値。

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

参照: abs2, unsigned, sign。

例

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs.(Int8[-128 -127 -126 0 126 127])  # 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 をスローします。代わりに複素数の負の引数を使用してください。sqrt は負の実数軸に沿った分岐切断を持つことに注意してください。

接頭辞演算子 √ は sqrt と同等です。

関連項目: hypot。

例

julia> sqrt(big(81))
9.0

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

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

julia> sqrt(-81 - 0.0im)  # -0.0im は分岐切断の下にあります
0.0 - 9.0im

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

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

real(z)

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

関連項目: imag, reim, complex, isreal, Real。

例

julia> real(1 + 3im)
1

real(T::Type)

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

例

julia> real(Complex{Int})
Int64

julia> real(Float64)
Float64

real(A::AbstractArray)

配列 A の各エントリの実部を含む配列を返します。

real.(A) と同等ですが、eltype(A) <: Real の場合は A がコピーされずに返され、A がゼロ次元の場合はスカラーではなく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

imag(z)

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

参照: conj, reim, adjoint, angle。

例

julia> imag(1 + 3im)
3

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

reim(z)

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

例

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

reim(A::AbstractArray)

Aの各エントリの実部と虚部をそれぞれ含む2つの配列のタプルを返します。

(real.(A), imag.(A))と同等ですが、eltype(A) <: Realの場合、実部を表すためにAはコピーされずに返され、Aがゼロ次元の場合はスカラーの代わりに0次元の配列が返されます。

例

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

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

conj(z)

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

関連情報: angle, adjoint.

例

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

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

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(n::Integer, k::Integer)

二項係数 $\binom{n}{k}$ は、$(1+x)^n$ の多項式展開における $k$ 番目の項の係数です。

\[n\]

が非負の場合、これは $n$ 個のアイテムから k 個を選ぶ方法の数です：

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

ここで $n!$ は factorial 関数です。

\[n\]

が負の場合、これは次の恒等式に基づいて定義されます：

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

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

例

julia> binomial(5, 3)
10

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

julia> binomial(-5, 3)
-35

外部リンク

• 二項係数 の Wikipedia。

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

一般化された二項係数は、k ≥ 0 の場合に多項式によって定義されます。

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

k < 0 の場合はゼロを返します。

整数 x の場合、これは通常の整数二項係数に相当します。

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

非整数 k に対するさらなる一般化は数学的に可能ですが、ガンマ関数やベータ関数を含むため、Julia標準ライブラリには含まれておらず、SpecialFunctions.jl のような外部パッケージで利用可能です。

外部リンク

• 二項係数 - Wikipedia.

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...)

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

例

julia> gcd(6, 9)
3

julia> gcd(6, -9)
3

julia> gcd(6, 0)
6

julia> gcd(0, 0)
0

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

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

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

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

lcm(x, y...)

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

例

julia> lcm(2, 3)
6

julia> lcm(-2, 3)
6

julia> lcm(0, 3)
0

julia> lcm(0, 0)
0

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

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

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

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

gcdx(a, b)

a と b の最大公約数（正の）およびそのベズー係数、すなわち $ua+vb = d = gcd(a, b)$ を満たす整数係数 u と v を計算します。gcdx(a, b) は $(d, u, v)$ を返します。

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

例

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

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

ispow2(n::Number) -> Bool

nが整数の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, m::Integer)

mを法としたnの逆元を取ります：$n y = 1 \pmod m$となるyで、$div(y,m) = 0$です。m = 0の場合、または$gcd(n,m) \neq 1$の場合はエラーが発生します。

例

julia> invmod(2, 5)
3

julia> invmod(2, 3)
2

julia> invmod(5, 6)
5

invmod(n::Integer, T) where {T <: Base.BitInteger}
invmod(n::T) where {T <: Base.BitInteger}

整数環の型 T における n の剰余逆数を計算します。すなわち、2^N で割った剰余であり、ここで N = 8*sizeof(T)（例えば、Int32 の場合は N = 32）です。言い換えれば、これらのメソッドは次の等式を満たします：

n * invmod(n) == 1
(n * invmod(n, T)) % T == 1
(n % T) * invmod(n, T) == 1

ここでの * は整数環 T における剰余乗算です。

整数型によって暗黙的に示される剰余を明示的な値として指定することは、剰余が定義上その型で表現できるには大きすぎるため、しばしば不便です。

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

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