数学

数学演算子

Base.:- ── メソッド

-(x)

単項マイナス演算子です。

julia> -1
-1

julia> -(2)
-2

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

Base.:+ ── 関数

+(x, y...)

加算演算子です。x+y+z+... は、この関数を全ての値を引数として +(x, y, z, ...) と呼び出します。

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25
dt::Date + t::Time -> DateTime

DateTime の加算は DateTime を作成します。Time の時・分・秒・ミリ秒と Time の年・月・日を使って新しい DateTime が作成されます。Time 型の値がゼロでないマイクロ秒あるいはナノ秒を持っていると InexactError が発生します。

Base.:- ── メソッド

-(x, y)

減算演算子です。

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

Base.:* ── メソッド

*(x, y...)

乗算演算子です。x*y*z*... は、この関数を全ての値を引数として *(x, y, z, ...) と呼び出します。

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

Base.:/ ── 関数

/(x, y)

右除算演算子です: 右側にある y の逆数と x の積が計算されます。整数の引数に対して浮動小数点数を返します。

julia> 1/2
0.5

julia> 4/2
2.0

julia> 4.5/2
2.25

Base.:\ ── メソッド

\(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 Array{Float64,1}:
  6.5
 -7.0

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

Base.:^ ── メソッド

^(x, y)

べき乗演算子です。x が行列なら、行列のべき乗が計算されます。

xInt リテラル (例えば x^22x^-3-3) のときの x^y という Julia コードはコンパイラによって Base.literal_pow(^, x, Val(y)) に変換されるので、指数の値に関するコンパイル時の特殊化が可能です。デフォルトのフォールバックとして Base.literal_pow(^, x, Val(y)) = ^(x,y) が用意されており、呼び出し側の名前空間で ^ が定義されていない限り通常は ^ == Base.^ となります。

julia> 3^5
243

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

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

Base.fma ── 関数

fma(x, y, z)

途中で x*y を丸めずに x*y+z を計算します。一部のシステムでは fma(x, y, z)x*y+z より格段に遅いので注意してください。fma は特定のアルゴリズムで精度を向上させるために利用されます。muladd も参照してください。

Base.muladd ── 関数

muladd(x, y, z)

合併積和演算 (combined multiply-add) です: x*y+z を計算しますが、性能のために加算と乗算を周りの演算と組み合わせることを許可します。例えばハードウェアが高速な fma をサポートしているなら、muladdfma で実装されるかもしれません。この関数の結果はマシンによって異なる可能性があり、同じマシンであっても定数伝播などの最適化によって異なる可能性があります。fma も参照してください。

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

Base.inv ── メソッド

inv(x)

x の乗法逆元を返します。x*inv(x)inv(x)*x は (丸め誤差を無視すれば) 乗法単位元 one(x) に等しくなります。

数値型の x に対する inv(x)one(x)/x と本質的に同じです。しかし他の型の x に対する inv(x)one(x)/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
Julia 1.2

inv(::Missing) は Julia 1.2 以降でサポートされます。

Base.div ── 関数

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

ユークリッド除算の商です。つまり x/y を整数に切り捨てた値を計算します。

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

julia> 5.0 ÷ 2
2.0
div(x, y, r::RoundingMode=RoundToZero)

ユークリッド除算の商です1x/y を計算し、丸めモード r に従ってそれを整数に丸めます。言い換えると、途中で丸めを行わずに round(x/y,r) の値を計算します。

fldcld も参照してください。この二つは div を特殊化した関数です。

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

Base.fld ── 関数

fld(x, y)

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

div も参照してください。

julia> fld(7.3,5.5)
1.0

Base.cld ── 関数

cld(x, y)

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

div も参照してください。

julia> cld(5.5,2.2)
3.0

Base.mod ── 関数

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

n = length(r) に対して x ≡ y (mod n) が成り立つ r の要素 y を返します。つまり返り値は mod(x - first(r), n) + first(r) です。

mod1 も参照してください。

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

julia> mod(3, 0:2)
0
Julia 1.3

このメソッドは Julia 1.3 以降でサポートされます。

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

モジュロ y における x の簡約です。言い換えると、xy で床除算した後の余り x - y*fld(x,y) を途中で丸めずに計算した値です。

結果は y と同じ符号を持ち、abs(y) よりも小さい絶対値を持ちます (後述する例外もあります)。

情報

浮動小数点数が絡むと正確な計算結果が返り値の型で表せない場合があり、そのような場合には丸め誤差が生じます。特に正確な結果が y に非常に近いと、丸められて y が返る場合があります。

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
rem(x::Integer, T::Type{<:Integer}) -> T
mod(x::Integer, T::Type{<:Integer}) -> T
%(x::Integer, T::Type{<:Integer}) -> T

x ≡ y (mod n) を満たす y::T を計算します。ここで nT 型で表現可能な整数の個数で、y[typemin(T),typemax(T)] を満たす整数です。T が任意の整数を表せる (T == BigInt) なら、この操作は T 型への変換に対応します。

julia> 129 % Int8
-127

Base.rem ── 関数

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

ユークリッド除算の余りです。x と同じ符号で絶対値が abs(y) より小さい値を返します。返り値は必ず正確です。

julia> x = 15; y = 4;

julia> x % y
3

julia> x == div(x, y) * y + rem(x, y)
true
rem(x, y, r::RoundingMode=RoundToZero)

xy で割ったときの余りを計算します (商は整数)。商は丸めモード 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]\) となります。xy が異なる符号を持ち、かつ abs(x) < abs(y) が成り立つとき返り値は正確でなくなる可能性があります (参照: RoundDown)。

  • r == RoundUp だと、返り値の範囲は y が正なら \((-y,0]\) となり、それ以外のとき \([0,-y)\) となります。xy が同じ符号を持ち、かつ abs(x) < abs(y) が成り立つとき返り値は正確でなくなる可能性があります (参照: RoundUp)。

Base.Math.rem2pi ── 関数

rem2pi(x, r::RoundingMode)

x で割った余りを計算します (商は整数)。商は丸めモード r に従います。言い換えると、途中で丸めを行わずに次の値を計算します:

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

rem2pi は内部で \(2π\) の高精度な近似を使うので、rem(x,2π,r) よりも正確な値を計算できます。

  • r == RoundNearest だと、返り値の範囲は \([-π, π]\) となります。一般にこの丸めモードが最も正確な値を与えます (参照: RoundNearest)。

  • r == RoundToZero だと、返り値の範囲は x が正のとき \([0, 2π]\) となり、それ以外のとき \([-2π, 0]\) となります (参照: RoundToZero)。

  • r == RoundDown だと、返り値の範囲 \([0, 2π]\) となります (参照: RoundDown)。

  • r == RoundUp だと、返り値の範囲は \([-2π, 0]\) となります (参照: RoundUp)。

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

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

Base.Math.mod2pi ── 関数

mod2pi(x)

x で割った余りを返します。返り値の範囲は \([0,2π)\) です。

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

情報

入力された値のフォーマットによっては、\(2π\) に一番近い表現可能な値が \(2π\) より小さい可能性があります。例えば式 mod2pi(2π)0 を返しませんが、これは途中で計算される 2*πFloat64 であり、2*Float64(π) < 2*big(π) が成り立つためです。振る舞いを細かく調整するには rem2pi を使ってください。

julia> mod2pi(9*pi/4)
0.7853981633974481

Base.divrem ── 関数

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

ユークリッド除算における商と余りです。(div(x,y,r), rem(x,y,r)) と等価です。また r にデフォルトの値を使うとすれば (x÷y, x%y) とも等価になります。

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

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

Base.fldmod ── 関数

fldmod(x, y)

床除算の商と余りを計算します。divrem(x, y, RoundDown) を使いやすくしたラッパーであり、(fld(x,y), mod(x,y)) と等価です。

Base.fld1 ── 関数

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

Base.mod1 ── 関数

mod1(x, y)

床除算の余りです。mod(r, y) == mod(x, y) が成り立つような r を返します。ただし返り値の範囲は y が正のとき \((0,y]\) で、y が負のとき \([y,0)\) です。

参照 fld1, fldmod1

julia> mod1(4, 2)
2

julia> mod1(4, 3)
1

Base.fldmod1 ── 関数

fldmod1(x, y)

(fld1(x,y), mod1(x,y)) を返します。

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

Base.:// ── 関数

//(num, den)

二つの整数または有理数の除算を計算します。返り値は Rational です。

julia> 3 // 5
3//5

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

Base.rationalize ── 関数

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

T を要素型とする Rational で浮動小数点数 x を近似します。返り値と x の差は tol 以下となります。

julia> rationalize(5.6)
28//5

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

julia> typeof(numerator(a))
BigInt

Base.numerator ── 関数

numerator(x)

x を有理数として表したときの分子です。

julia> numerator(2//3)
2

julia> numerator(4)
4

Base.denominator ── 関数

denominator(x)

x を有理数として表したときの分母です。

julia> denominator(2//3)
3

julia> denominator(4)
1

Base.:<< ── 関数

<<(x, n)

左ビットシフト演算子 x << n です。n >= 0 に対する返り値は x を左に n ビットだけシフトし、新しくできる空間を 0 で埋めた値です。x << nx * 2^n と等価です。n < 0 に対する x << nx >> -n と等価です。

julia> Int8(3) << 2
12

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

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

>>, >>> も参照してください。

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

左ビットシフト演算子 B << n です。n >= 0 に対する返り値は B の要素を n 要素だけ後ろにシフトし、新しくできる空間を false で埋めた値です。n < 0 のときは要素が前方にシフトされます。B << nB >> -n と等価です。

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

julia> B << 1
5-element BitArray{1}:
 0
 1
 0
 0
 0

julia> B << -1
5-element BitArray{1}:
 0
 1
 0
 1
 0

Base.:>> ── 関数

>>(x, n)

右ビットシフト演算子 x >> n です。n >= 0 に対する返り値は x を右に n ビットだけシフトし、新しくできる空間を x >= 0 なら 0 で、x < 0 なら 1 で埋めた値です。このとき x の符号は保存されます。x >> nfld(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 要素だけ前方にシフトしたものです。n < 0 のときは要素が後方にシフトされます。B >> nB << -n と等価です。

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

julia> B >> 1
5-element BitArray{1}:
 0
 1
 0
 1
 0

julia> B >> -1
5-element BitArray{1}:
 0
 1
 0
 0
 0

Base.:>>> ── 関数

>>>(x, n)

符号無し右ビットシフト演算子 x >>> n です。n >= 0 に対する返り値は x を右に n ビットシフトし、新しくできる空間を 0 で埋めた値です。n < 0 のとき x << -n と等価になります。

Unsigned 整数型に対する x >>> nx >> n と等価です。Signed 整数型に対する x >>> nsigned(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 と等価です。詳細や例は >> を参照してください。

Base.bitrotate ── 関数

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

bitrotate(x, k) はビット単位の回転を実装します。x を構成するビットを左に向かって k 度回転させた値が返り値です。k が負だと左方向への回転が行われます。

Julia 1.5

この関数は Julia 1.5 以降でサポートされます。

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

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

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

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

Base.:: ── 関数

(:)(start, [step], stop)

区間演算子です。a:ba から b までのステップサイズ 1 の区間 (UnitRange) を構築し、a:s:ba から b までのステップサイズ s の区間 (StepRange) を構築します。

添え字アクセスで : を使うと次元全体を選択できます。また ::hello のように使うと Symbol リテラルとなります。

(:)(I::CartesianIndex, J::CartesianIndex)

二つの CartesianIndex から CartesianIndices を構築します。

Julia 1.1

このメソッドは Julia 1.1 以降でサポートされます。

julia> I = CartesianIndex(2,1);

julia> J = CartesianIndex(3,3);

julia> I:J
2×3 CartesianIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
 CartesianIndex(2, 1)  CartesianIndex(2, 2)  CartesianIndex(2, 3)
 CartesianIndex(3, 1)  CartesianIndex(3, 2)  CartesianIndex(3, 3)

Base.range ── 関数

range(start[, stop]; length, stop, step=1)

開始値を受け取り、長さ length あるいは終了値 stop の区間を構築します。step は省略可能であり、デフォルトは 1 です (この値を使うと UnitRange が構築されます)。

lengthstop が与えられ step が与えられないと、ステップサイズが区間を length 等分した値として自動的に計算されます。

stepstop が与えられ length が与えられないと、隣り合う要素がちょうど step だけ離れるように区間全体の長さが自動的に計算されます。

途中の値を有理数として計算する特別な処理が行われます。これによって生じるオーバーヘッドを避けるには LinRange コンストラクタを使ってください。

stop は位置引数とキーワード引数のどちらでも指定できます。

Julia 1.1

位置引数としての stop は Julia 1.1 以降でサポートされます。

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

Base.OneTo ── 型

Base.OneTo(n)

1:n のように振る舞う AbstractUnitRange を表す型です。型システムはこの区間が 1 から始まることを認識できます。

Base.StepRangeLen ── 型

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

r[i]T 型の値を生成するような区間です (二つ目の形式を使うと、T は自動的に推論されます)。参照される値 ref・ステップサイズ step・長さ len をパラメータとして持ちます。デフォルトでは ref は開始値 r[1] ですが、r[offset] の値を与えることもできます (1 <= offset <= len)。RSTwicePrecision を使うと丸め誤差のない区間が実装できます。

Base.:== ── 関数

==(x, y)

汎用的な等価演算子です。=== にフォールバックします。インスタンスが表す抽象的な値の間に等価性が定義される全ての型に対して実装されるべき関数です。例えば数値型に対する == は引数が表す数値として比較され、型は無視されます。また文字列は文字の列として比較され、エンコーディングは無視されます。コレクションに対する == は一般に要素に対して再帰的に比較を行いますが、他のプロパティ (配列の形状など) が考慮されることもあります。

浮動小数点数に対するこの演算子は IEEE の意味論に従います: 0.0 == -0.0 および NaN != NaN が成り立ちます。

返り値は Bool 型ですが、三値論理に従いオペランドの少なくとも一方が missing のときは missing となります。コレクションに対しては、オペランドの少なくとも一方が missing を含み、missing 以外の要素が全て等しいときに限って missing が返ります。どんなときでも Bool 型の結果が必要なら、isequal または === を使ってください。

実装

新しい数値型に対しては、その型同士の == を実装するべきです。他の型との比較が可能な場合には昇格規則を通して処理してください。

isequal== にフォールバックします。そのため == の新しいメソッドは Dict がキーを比較するときに利用されます。そのため、もし独自の型が辞書のキーとして使われる予定なら、その型は hash も実装するべきです。

==(x)

引数が x と等しいかどうかを == で判定する関数を作成します。つまり、この関数は y -> y == x と等価です。

返り値の関数は Base.Fix2{typeof(==)} という型を持ちます。この型に対して特殊化されたメソッドを実装することもできます。

==(a::AbstractString, b::AbstractString) -> Bool

二つの文字列が等しいかどうかを文字ごと (正確には符号位置ごと) に比較して判定します。

julia> "abc" == "abc"
true

julia> "abc" == "αβγ"
false

Base.:!= ── 関数

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

不等価演算子です。必ず == と逆の値を返します。

実装

一般に新しい型がこの関数を実装する必要はなく、フォールバックの定義 !=(x,y) = !(x==y) を利用できます。

julia> 3 != 2
true

julia> "foo"  "foo"
false
!=(x)

引数が x と等しくないかどうかを != で判定する関数を作成します。つまり、この関数は y -> y != x と等価です。返り値の関数は Base.Fix2{typeof(!=)} という型を持ち、この型に対するメソッドの特殊化が可能です。

Julia 1.2

この関数は Julia 1.2 以降でサポートされます。

Base.:!== ── 関数

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

必ず === と逆の値を返します。

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

julia> a  b
true

julia> a  a
false

Base.:< ── 関数

<(x, y)

小なり比較演算子です。isless にフォールバックします。浮動小数点数 NaN の振る舞いにより、この演算子が実装する順序は半順序です。

実装

正準な半順序を持つ新しい数値型に対しては、その型同士の < を実装するべきです。また正準な全順序を持つ型では isless を実装するべきです。

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false
<(x)

引数が x より小さいかどうかを < で判定する関数を作成します。つまり、この関数は y -> y < x と等価です。返り値の関数は Base.Fix2{typeof(<)} という型を持ち、この型に対するメソッドの特殊化が可能です。

Julia 1.2

このメソッドは Julia 1.2 以降でサポートされます。

Base.:<= ── 関数

<=(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(<=)} という型を持ち、この型に対するメソッドの特殊化が可能です。

Julia 1.2

このメソッドは Julia 1.2 以降でサポートされます。

Base.:> ── 関数

>(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(>)} という型を持ち、この型に対するメソッドの特殊化が可能です。

Julia 1.2

このメソッドは Julia 1.2 以降でサポートされます。

Base.:>= ── 関数

>=(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(>=)} という型を持ち、この型に対するメソッドの特殊化が可能です。

Julia 1.2

このメソッドは Julia 1.2 以降でサポートされます。

Base.cmp ── 関数

cmp(x,y)

xy より小さければ -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)

xy より小さければ -1 を、等しければ 0 を、大きければ 1 を返します。第一引数が小なり比較で使用する関数を指定します。

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

二つの文字列の比較です。両方の文字列が同じ長さを持ち、それぞれの添え字における文字が全て同じなら 0 を返し、ab の接頭語のとき、およびアルファベット順で ab より前にあるとき -1 を返し、ba の接頭語のとき、およびアルファベット順で ba より前にあるとき 1 を返します (正確に言うと、Unicode 符号位置の辞書式順序が使われます)。

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

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

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

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

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

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

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

Base.:~ ── 関数

~(x)

ビット単位の否定演算です。

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

Base.& ── 関数

x & y

ビット単位の論理積演算です。三値論理を実装するので、オペランドの片方が missing でもう一方が true なら missing を返します。関数適用の形で使うときは (&)(x, y) と括弧で囲ってください。

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

Base.:| ── 関数

x | y

ビット単位の論理和演算です。三値論理を実装するので、オペランドの片方が missing でもう一方が false なら missing を返します。

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

Base.xor ── 関数

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

ビット単位の排他論理和演算です。三値論理を実装するので、オペランドの片方が missing なら missing を返します。

中置記法 a ⊻ bxor(a,b) と等価です。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 BitArray{1}:
 0
 1
 0

Base.:! ── 関数

!(x)

真偽値に対する否定演算です。三値論理を実装するので、xmissing なら missing を返します。

julia> !true
false

julia> !false
true

julia> !missing
missing

julia> .![true false true]
1×3 BitArray{2}:
 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

真偽値に対する論理積演算です。短絡評価を行います。

|| ── キーワード

x || y

真偽値に対する論理和演算です。短絡評価を行います。

数学関数

Base.isapprox ── 関数

isapprox(x, y;
         rtol::Real=rtoldefault(x,y,atol),
         atol::Real=0,
         nans::Bool=false,
         norm::Function)

厳密でない等価比較です2norm(x-y) <= max(atol, rtol*max(norm(x), norm(y))) なら true を返します。デフォルトの atol はゼロであり、デフォルトの rtolxy の型から決まります。キーワード引数 nansNaN 同士が等しいとみなされるかどうかを制御します (デフォルトは false です)。

浮動小数点数を使った実数と複素数では、atol > 0 が指定されないときの rtolxyeps の中で大きい方 (精度が低い方の eps) の平方根となります。これは仮数の桁の半分が合っていれば等しいとみなすことに対応します。それ例外のとき、つまり atol > 0 が指定されたときおよび引数が整数のときは、rtol のデフォルト値はゼロです。

xy は数値の配列にもできます。この場合デフォルトの normLinearAlgebra.norm となりますが、キーワード引数 norm を渡せば変更できます (数値に対するデフォルトの normabs です)。xy が配列で norm(x-y) が有限でない (±Inf または NaN となる) なら、比較は xy の各要素がそれぞれ近似的に等しいかどうかを判定する処理にフォールバックします。

二項演算子 はデフォルトの引数を使った isapprox と等価であり、x ≉ y!isapprox(x,y) と等価です。

デフォルトの atol0 なので、x ≈ 0 (デフォルトの許容値を使ったゼロとの近似比較) は x == 0 と等価です。このような場合には適切な atol を使うか、norm(x) ≤ atol とするか、x - y ≈ 0 となっているコードを x ≈ y と組み替えてください。ゼロでない atol を使うときに設定すべき値は問題の尺度 (“単位”) によって変わるので、適切な atol の値を自動的に選択することはできません。例えば x がメートルで表した地球の半径 のときに x - y ≈ 0atol=1e-9 としたのでは小さすぎますが、x がメートルで表した水素原子の半径のときに atol=1e-9 では大きすぎます。

julia> 0.1  (0.1 - 1e-10)
true

julia> isapprox(10, 11; atol = 2)
true

julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0])
true

julia> 1e-10  0
false

julia> isapprox(1e-10, 0, atol=1e-8)
true
isapprox(x; kwargs...)
≈(x; kwargs...)

を使って引数が x と近似的に等しいかどうかを判定する関数を作成します。言い換えると、この関数は y -> y ≈ x と等価です。

サポートされるキーワード引数は isapprox と同様です。

Base.sin ── メソッド

sin(x)

x のサインを計算します。入力 x は弧度法で表されます。

Base.cos ── メソッド

cos(x)

x のコサインを計算します。入力 x は弧度法で表されます。

Base.Math.sincos ── メソッド

sincos(x)

x のサインとコサインを同時に計算します。入力 x は弧度法で表されます。

Base.tan ── メソッド

tan(x)

x のタンジェントを計算します。入力 x は弧度法で表されます。

Base.Math.sind ── 関数

sind(x)

x のサインを計算します。入力 x は度数法で表されます。

Base.Math.cosd ── 関数

cosd(x)

x のコサインを計算します。入力 x は度数法で表されます。

Base.Math.tand ── 関数

tand(x)

x のタンジェントを計算します。入力 x は度数法で表されます。

Base.Math.sinpi ── 関数

sinpi(x)

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

Base.Math.cospi ── 関数

cospi(x)

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

Base.sinh ── メソッド

sinh(x)

x のハイパボリックサインを計算します。

Base.cosh ── メソッド

cosh(x)

x のハイパボリックコサインを計算します。

Base.tanh ── メソッド

tanh(x)

x のハイパボリックタンジェントを計算します。

Base.asin ── メソッド

asin(x)

サインの逆関数を x に対して計算します。出力 x は弧度法で表されます。

Base.acos ── メソッド

acos(x)

コサインの逆関数を x に対して計算します。出力 x は弧度法で表されます。

Base.atan ── メソッド

atan(y)
atan(y, x)

タンジェントの逆関数をそれぞれ yy/x に対して計算します。

引数が一つの場合は、点 \((1, y)\) と原点を結んだ直線と \(x\) 軸正方向がなす角度が返ります。このときの返り値の範囲は \([-\pi/2, \pi/2]\) です。

引数が二つの場合は、点 \((x, y)\) と原点を結んだ直線と \(x\) 軸正方向のなす角度が返ります。このときの返り値の範囲は \([-\pi, \pi]\) です。これは C 標準ライブラリの atan2 関数に対応します。

Base.Math.asind ── 関数

asind(x)

サインの逆関数を x に対して計算します。出力 x は度数法で表されます。

Base.Math.acosd ── 関数

acosd(x)

コサインの逆関数を x に対して計算します。出力 x は度数法で表されます。

Base.Math.atand ── 関数

atand(y)
atand(y,x)

タンジェントの逆関数をそれぞれ xy/x に対して計算します。出力は度数法で表されます。

Base.Math.sec ── メソッド

sec(x)

x のセカントを計算します。入力 x は弧度法で表されます。

Base.Math.csc ── メソッド

csc(x)

x のコセカントを計算します。入力 x は弧度法で表されます。

Base.Math.cot ── メソッド

cot(x)

x のコタンジェントを計算します。入力 x は弧度法で表されます。

Base.Math.secd ── 関数

secd(x)

x のセカントを計算します。入力 x は度数法で表されます。

Base.Math.cscd ── 関数

cscd(x)

x のコセカントを計算します。入力 x は度数法で表されます。

Base.Math.cotd ── 関数

cotd(x)

x のコタンジェントを計算します。入力 x は度数法で表されます。

Base.Math.asec ── メソッド

asec(x)

セカントの逆関数を x に対して計算します。出力 x は弧度法で表されます。

Base.Math.acsc ── メソッド

acsc(x)

コセカントの逆関数を x に対して計算します。出力 x は弧度法で表されます。

Base.Math.acot ── メソッド

acot(x)

コタンジェントの逆関数を x に対して計算します。出力 x は弧度法で表されます。

Base.Math.asecd ── 関数

asecd(x)

セカントの逆関数を x に対して計算します。出力 x は度数法で表されます。

Base.Math.acscd ── 関数

acscd(x)

コセカントの逆関数を x に対して計算します。出力 x は度数法で表されます。

Base.Math.acotd ── 関数

acotd(x)

コタンジェントの逆関数を x に対して計算します。出力 x は度数法で表されます。

Base.Math.sech ── メソッド

sech(x)

x のハイパボリックセカントを計算します。

Base.Math.csch ── メソッド

csch(x)

x のハイパボリックコセカントを計算します。

Base.Math.coth ── メソッド

coth(x)

x のハイパボリックコタンジェントを計算します。

Base.asinh ── メソッド

asinh(x)

ハイパボリックサインの逆関数を x に対して計算します。

Base.acosh ── メソッド

acosh(x)

ハイパボリックコサインの逆関数を x に対して計算します。

Base.atanh ── メソッド

atanh(x)

ハイパボリックタンジェントの逆関数を x に対して計算します。

Base.Math.asech ── メソッド

asech(x)

ハイパボリックセカントの逆関数を x に対して計算します。

Base.Math.acsch ── メソッド

acsch(x)

ハイパボリックコセカントの逆関数を x に対して計算します。

Base.Math.acoth ── メソッド

acoth(x)

ハイパボリックコタンジェントの逆関数を x に対して計算します。

Base.Math.sinc ── 関数

sinc(x)

\(x = 0\) なら \(1\) を返し、\(x \neq 0\) なら \(\sin(\pi x) / (\pi x)\) を返します。

Base.Math.cosc ── 関数

cosc(x)

\(x = 0\) なら \(0\) を返し、\(x \neq 0\) なら \(\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)\) を返します。

Base.Math.deg2rad ── 関数

deg2rad(x)

x を度数法から弧度法に変換します。

julia> deg2rad(90)
1.5707963267948966

Base.Math.rad2deg ── 関数

rad2deg(x)

x を弧度法から度数法に変換します。

julia> rad2deg(pi)
180.0

Base.Math.hypot ── 関数

hypot(x, y)

オーバーフローとアンダーフローを避けながら \(\sqrt{|x|^2+|y|^2}\) を計算します。

この関数のコードは Carlos F. Borges による “An Improved Algorithm for hypot(a,b)” で示されるアルゴリズムを実装しています。この記事は ArXiv (https://arxiv.org/abs/1904.09481) で閲覧できます。

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> (a^2 + a^2) # a^2 がオーバーフローする。
ERROR: DomainError with -2.914184810805068e18:
sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
Stacktrace:
[...]

julia> hypot(3, 4im)
5.0
hypot(x...)

オーバーフローとアンダーフローを避けながら \(\sqrt{\sum |x_i|^2}\) を計算します。

julia> hypot(-5.7)
5.7

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

Base.log ── メソッド

log(x)

x の自然対数を計算します。引数が負の Real のときは DomainError を送出します。複素数の返り値を得るには、複素数型の負の値を渡してください。

julia> log(2)
0.6931471805599453

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

Base.log ── メソッド

log(b,x)

b を底とした x の対数を計算します。引数が負の Real のときは DomainError を送出します。

情報

b が 2 もしくは 10 のべきの場合は、log2 または log10 を使えば log より高速に正確な値を計算できます。例を示します:

julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0

julia> log(4,8)
1.5

julia> log(4,2)
0.5

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

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

Base.log2 ── 関数

log2(x)

2 を底とした x の対数を計算します。引数が負の Real のときは DomainError を送出します。

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
ERROR: DomainError with -2.0:
NaN result for non-NaN input.
Stacktrace:
 [1] nan_dom_err at ./math.jl:325 [inlined]
[...]

Base.log10 ── 関数

log10(x)

10 を底とした x の対数を計算します。引数が負の Real のときは DomainError を送出します。

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

julia> log10(-2)
ERROR: DomainError with -2.0:
NaN result for non-NaN input.
Stacktrace:
 [1] nan_dom_err at ./math.jl:325 [inlined]
[...]

Base.log1p ── 関数

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 will only return a complex result if called with a complex argument. Try log1p(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

Base.Math.frexp ── 関数

frexp(val)

\(x \times 2^{\text{exp}}\)val に等しいようなタプル (x,epr) を返します。ここで x の絶対値は区間 \([1/2, 1)\) に含まれるか \(0\) に等しい値です。

Base.exp ── メソッド

exp(x)

x に対する自然指数関数、つまり \(e^x\) を計算します。

julia> exp(1.0)
2.718281828459045

Base.exp2 ── 関数

exp2(x)

x に対する底が 2 の指数関数、つまり \(2^x\) を計算します。

julia> exp2(5)
32.0

Base.exp10 ── 関数

exp10(x)

x に対する底が 10 の指数関数、つまり \(10^x\) を計算します。

julia> exp10(2)
100.0

Base.Math.ldexp ── 関数

ldexp(x, n)

\(x \times 2^n\) を計算します。

julia> ldexp(5., 2)
20.0

Base.Math.modf ── 関数

modf(x)

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

julia> modf(3.5)
(0.5, 3.0)

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

Base.expm1 ── 関数

expm1(x)

正確に \(e^x-1\) を計算します。

Base.round ── メソッド

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 型で表せないと convert と同様に InexactError が発生します。

キーワード引数 digits が指定されると、小数点からその値だけ後ろに進んだ桁で丸められます (負の digits を指定すると小数点数から前に進んだ桁で切り捨てられます)。丸めでは底として base が使われます。

キーワード引数 sigdigits が与えられると、その値を有効数字の桁数として底が base の丸めが行われます。

RoundingMode 型の r は丸めの方向を制御します。デフォルトは RoundNearest であり、これは最も近い整数値に丸めることを基本として、同着 (小数部分が 0.5) のときは偶数を採用する方法です。グローバルの丸めモードが変更されると round が間違った値を返す可能性があることに注意してください (参照: rounding)。

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
情報

桁数を指定して行う 2 以外の底を使った丸めでは、バイナリの浮動小数点数を使うときに結果が不正確になることがあります。例えば数値リテラル 1.15 が表す Float64 型の値は 1.15 よりも小さいのですが、1.2 に丸められます:

julia> x = 1.15
1.15

julia> @sprintf "%.20f" x
"1.14999999999999991118"

julia> x < 115//100
true

julia> round(x, digits=1)
1.2

拡張

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

Base.Rounding.RoundingMode ── 型

RoundingMode

浮動小数点数が絡む演算における丸めモードを制御するときに使われる型です。rounding 関数と setrounding 関数の引数、および整数へ丸める関数 round の省略可能なキーワード引数として使われます。

現在サポートされる丸めモードは次の通りです:

Base.Rounding.RoundNearest ── 定数

RoundNearest

デフォルトの丸めモードです。最も近い整数値に丸めることを基本として、同着 (小数部分が 0.5) のときは偶数を採用します。

Base.Rounding.RoundNearestTiesAway ── 定数

RoundNearestTiesAway

最も近い整数値に丸めることを基本として、同着 (小数部分が 0.5) のときはゼロから遠い方を採用します (C/C++ の round の振る舞いです)。

Base.Rounding.RoundNearestTiesUp ── 定数

RoundNearestTiesUp

最も近い整数値に丸めることを基本として、同着 (小数部分が 0.5) のときは正の無限大に近い方を採用します (Java/JavaScript の round の振る舞いです)。

Base.Rounding.RoundToZero ── 定数

RoundToZero

ゼロに向かって丸めます。この丸めモードを使った roundtrunc の別名です。

Base.Rounding.RoundFromZero ── 定数

RoundFromZero

ゼロから遠ざかる方向に丸めます。この丸めモードは T == BigFloat とした round の呼び出しでのみ利用できます。

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

Base.Rounding.RoundUp ── 定数

RoundUp

小数部分を切り上げることで丸めます。この丸めモードを使った roundceil の別名です。

Base.Rounding.RoundDown ── 定数

RoundDown

小数部分を切り下げることで丸めます。この丸めモードを使った roundfloor の別名です。

Base.round ── メソッド

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

複素数 z と同じ型を持つ最も近い整数値を返します。RoundingMode で指定した丸めモードで丸めが行われます。一つ目の RoundingMode は実部に使われ、二つ目の RoundingMode は虚部に使われます。

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

Base.ceil ── 関数

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

ceil(x)x に最も近い x 以上の整数を x と同じ型で返します。

ceil(T, x) は処理結果を T 型に変換します。処理結果が T 型で表現できなければ InexactError が発生します。

キーワード引数 digits, sigdigits, baseround と同様です。

Base.floor ── 関数

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

floor(x)x に最も近い x 以下の整数を x と同じ型で返します。

floor(T, x) は処理結果を T 型に変換します。処理結果が T 型で表現できなければ InexactError が発生します。

キーワード引数 digits, sigdigits, baseround と同様です。

Base.trunc ── 関数

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

trunc(x) は絶対値が abs(x) 以下の x に最も近い整数を x と同じ T で返します。

trunc(T, x) は処理結果を T 型に変換します。処理結果が T 型で表現できなければ InexactError が発生します。

キーワード引数 digits, sigdigits, baseround と同様です。

Base.unsafe_trunc ── 関数

unsafe_trunc(T, x)

絶対値が abs(x) 以下の x に最も近い整数を x と同じ T で返します。処理結果が T 型で表現できないときは、任意の値が返る可能性があります。

Base.min ── 関数

min(x, y, ...)

引数の最小値を返します。コレクションから最小値を取得するには minimum を使ってください。

julia> min(2, 5, 1)
1

Base.max ── 関数

max(x, y, ...)

引数の最大値を返します。コレクションから最大値を取得するには maximum を使ってください。

julia> max(2, 5, 1)
5

Base.minmax ── 関数

minmax(x, y)

(min(x,y), max(x,y)) を返します。(minimum(x), maximum(x)) を返す extrema も参照してください。

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

Base.Math.clamp ── 関数

clamp(x, lo, hi)

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

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

julia> clamp.([11,8,5],10,6) # lo > hi となる例
3-element Array{Int64,1}:
  6
  6
 10
clamp(x, T)::T

xtypemin(T)typemax(T) の間に clamp し、結果を T 型に変換します。

julia> clamp(200, Int8)
127
julia> clamp(-200, Int8)
-128

Base.Math.clamp! ── 関数

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

array に含まれる値を lo から hi までの区間に収まるよう調整します。値はインプレースに書き換わります。clamp も参照してください。

Base.abs ── 関数

abs(x)

x の絶対値を計算します。

abs を符号付き整数に適用すると、オーバーフローが発生して負の値が返る場合があります。具体的に言うと、符号付き整数型が表せる最小の値の abs を取ったときにだけオーバーフローが起こります。つまり x == typemin(typeof(x)) だと abs(x) == x < 0 であり、-x と等しくなりません。

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs(typemin(Int64))
-9223372036854775808

Base.Checked.checked_abs ── 関数

Base.checked_abs(x)

必要ならオーバーフローのチェックを行いながら abs(x) を計算します。例えば 2 の補数を使った標準的な符号付き整数 (例えば Int) では abs(typemin(Int)) が表現できないので、オーバーフローが起きます。

オーバーフローの保護により知覚できる程度の性能劣化が起こる可能性があります。

Base.Checked.checked_neg ── 関数

Base.checked_neg(x)

必要ならオーバーフローのチェックを行いながら -x を計算します。例えば 2 の補数を使った標準的な符号付き整数 (例えば Int) は -typemin(Int) を表せないので、オーバーフローが起きます。

オーバーフローの保護により知覚できる程度の性能劣化が起こる可能性があります。

Base.Checked.checked_add ── 関数

Base.checked_add(x, y)

必要ならオーバーフローをチェックを行いながら x+y を計算します。

オーバーフローの保護により知覚できる程度の性能劣化が起こる可能性があります。

Base.Checked.checked_sub ── 関数

Base.checked_sub(x, y)

必要ならオーバーフローのチェックを行いながら x-y を計算します。

オーバーフローの保護により知覚できる程度の性能劣化が起こる可能性があります。

Base.Checked.checked_mul ── 関数

Base.checked_mul(x, y)

必要ならオーバーフローのチェックを行いながら x*y を計算します。

オーバーフローの保護により知覚できる程度の性能劣化が起こる可能性があります。

Base.Checked.checked_div ── 関数

Base.checked_div(x, y)

必要ならオーバーフローのチェックを行いながら div(x,y) を計算します。

オーバーフローの保護により知覚できる程度の性能劣化が起こる可能性があります。

Base.Checked.checked_rem ── 関数

Base.checked_rem(x, y)

必要ならオーバーフローのチェックを行いながら x%y を計算します。

オーバーフローの保護により知覚できる程度の性能劣化が起こる可能性があります。

Base.Checked.checked_fld ── 関数

Base.checked_fld(x, y)

必要ならオーバーフローのチェックを行いながら fld(x,y) を計算します。

オーバーフローの保護により知覚できる程度の性能劣化が起こる可能性があります。

Base.Checked.checked_mod ── 関数

Base.checked_mod(x, y)

必要ならオーバーフローのチェックを行いながら mod(x,y) を計算します。

オーバーフローの保護により知覚できる程度の性能劣化が起こる可能性があります。

Base.Checked.checked_cld ── 関数

Base.checked_cld(x, y)

必要ならオーバーフローのチェックを行いながら cld(x,y) を計算します。

オーバーフローの保護により知覚できる程度の性能劣化が起こる可能性があります。

Base.Checked.add_with_overflow ── 関数

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

r = x+y を計算します。f はオーバフローが起こったかを示す真偽値です。

Base.Checked.sub_with_overflow ── 関数

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

r = x-y を計算します。f はオーバフローが起こったかを示す真偽値です。

Base.Checked.mul_with_overflow ── 関数

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

r = x*y を計算します。f はオーバフローが起こったかを示す真偽値です。

Base.abs2 ── 関数

abs2(x)

x の絶対値の二乗を計算します。

julia> abs2(-3)
9

Base.copysign ── 関数

copysign(x, y) -> z

x と同じ絶対値と y と同じ符号を持つ値 z を返します。

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

Base.sign ── 関数

sign(x)

x == 0 なら 0 を返し、そうでなければ x/|x| を返します (つまりゼロでない実数に対する返り値は 1 または -1 です)。

Base.signbit ── 関数

signbit(x)

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

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true

Base.flipsign ── 関数

flipsign(x, y)

y が負なら、x の符号を反転した値を返します。例えば abs(x) = flipsign(x, x) が成り立ちます。

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5

Base.sqrt ── メソッド

sqrt(x)

\(\sqrt{x}\) を返します。引数が負の Real なら DomainError を送出します。そのような場合に値が必要なら複素数型の負の実数を渡してください。前置演算子 sqrt と等価です。

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

Base.isqrt ── 関数

isqrt(n::Integer)

整数平方根です: m*m <= n を満たす整数 m の中で最大のものを返します。

julia> isqrt(5)
2

Base.Math.cbrt ── 関数

cbrt(x::Real)

x の三乗根 \(x^{1/3}\) を返します。x は負でも構いません (\(x < 0\) のときは負の実根が返ります)。

前置演算子 cbrt と等価です。

julia> cbrt(big(27))
3.0

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

Base.real ── メソッド

real(z)

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

julia> real(1 + 3im)
1

Base.imag ── 関数

imag(z)

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

julia> imag(1 + 3im)
3

Base.reim ── 関数

reim(z)

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

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

Base.conj ── 関数

conj(z)

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

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

Base.angle ── 関数

angle(z)

複素数 z の偏角を弧度法で返します。

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

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

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

Base.cis ── 関数

cis(z)

\(\exp(iz)\) を返します。

julia> cis(π)  -1
true

Base.binomial ── 関数

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}\]

julia> binomial(5, 3)
10

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

julia> binomial(-5, 3)
-35

参照

外部リンク

Base.factorial ── 関数

factorial(n::Integer)

n の階乗です。nInteger なら、階乗が整数として計算されます (少なくとも 64 ビットまで昇格されます)。n が大きいとオーバーフローする可能性がありますが、factorial(big(n)) とすれば任意精度で正確に階乗を計算できます。

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

参照:

外部リンク:

Base.gcd ── 関数

gcd(x,y)

正の最大公約数です。xy が両方ゼロならゼロが返ります。引数には整数または有理数を指定できます。

Julia 1.4

有理数の引数は Julia 1.4 以降でサポートされます。

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

Base.lcm ── 関数

lcm(x,y)

非負の最小公倍数です。引数には整数または有理数を指定できます。

Julia 1.4

有理数の引数は Julia 1.4 以降でサポートされます。

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

Base.gcdx ── 関数

gcdx(x,y)

xy の正の最大公約数およびベズー係数を計算します。ベズー係数とは \(ux+vy = d = \gcd(x,y)\) を満たす \(u,v\) のことです。(d,u,v) を返します。

引数には整数または有理数を指定できます。

Julia 1.4

有理数の引数は Julia 1.4 以降でサポートされます。

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

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

ベズー係数は一意ではありませんgcdx は拡張されたユークリッドのアルゴリズムによって計算される最小のベズー係数を返します (参照: Knuth, TAoCP, 2/e, p. 325, Algorithm X.)。符号付き整数に対するベズー係数は \(|u| < |y/d|\)\(|v| < |x/d|\) が成り立つという意味で最小となり、uv の符号は d が正となるように選ばれます。符号無し整数に対しては uvtypemax に近い値になる可能性があり、そのとき等式は符号無し整数のモジュロ算術を通してのみ成立します。

Base.ispow2 ── 関数

ispow2(n::Integer) -> Bool

n が 2 のべきかどうかを判定します。

julia> ispow2(4)
true

julia> ispow2(5)
false

Base.nextpow ── 関数

nextpow(a, x)

x 以上で最小の a^n を返します (n は非負の整数)。a は 1 より大きい必要があり、x は 1 以上である必要があります。

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16

prevpow も参照してください。

Base.prevpow ── 関数

prevpow(a, x)

x 以下で最大の a^n を返します (n は非負の整数)。a は 1 より大きい必要があり、x は 1 以上である必要があります。

julia> prevpow(2, 7)
4

julia> prevpow(2, 9)
8

julia> prevpow(5, 20)
5

julia> prevpow(4, 16)
16

nextpow も参照してください。

Base.nextprod ── 関数

nextprod([k_1, k_2,...], n)

整数 \(p_1\), \(p_2\), ... を使って \(\prod k_i^{p_i}\) と表せる n 以上の整数で最小のものを返します。

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

julia> 2^2 * 3^3
108

Base.invmod ── 関数

invmod(x,m)

モジュロ m における x の逆元を計算します: つまり \(x y = 1 \pmod m\)\(\text{div}(x,y) = 0\) を満たす \(y\) です。\(m = 0\) または \(\gcd(x,m) \neq 1\) が成り立つとき定義されません。

julia> invmod(2,5)
3

julia> invmod(2,3)
2

julia> invmod(5,6)
5

Base.powermod ── 関数

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

Base.ndigits ── 関数

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

整数 nbase 進法で書いたときの桁数を計算します (base-1, 0, 1 のいずれかであってはいけません)。省略可能な引数 pad を与えると、その長さまでゼロ埋めされます (返り値は pad より小さくなりません)。

julia> ndigits(12345)
5

julia> ndigits(1022, base=16)
3

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

julia> ndigits(123, pad=5)
5

Base.widemul ── 関数

widemul(x, y)

xy の積を計算し、結果を大きい型として返します。

julia> widemul(Float32(3.), 4.)
12.0

Base.Math.evalpoly ── 関数

evalpoly(x, p)

係数が p[1], p[2], ... の多項式 \(\sum_k x^{k-1} p[k]\) を評価します。つまり、係数は x のべきに関して昇順に与えられます。係数の個数が静的に分かっている (pTuple) なら、ループはコンパイル時に展開されます。この関数は実数に対して Horner 法、複素数に対して Goertzel のアルゴリズム3に似た方法を使って高速なコードを生成します。

Julia 1.4

この関数は Julia 1.4 以降でサポートされます。

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

[email protected] ── マクロ

@evalpoly(z, c...)

係数が c[1], c[2], ... の多項式 \(\sum_k x^{k-1} c[k]\) を評価します。つまり、係数は x のべきに関して昇順に与えられます。このマクロは高速なインラインコードに展開され、そのとき実数 z に対しては Horner 法、複素数 z に対しては Goertzel のアルゴリズムに似たより高速なアルゴリズムが使われます。

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

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

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

[email protected] ── マクロ

@fastmath expr

与えられた式を変形してから実行します。そのとき IEEE の意味論に厳密には従わない可能性のある関数の呼び出しを許可します。これにより可能な中で最も高速な演算が可能になりますが、計算結果は未定義となります ──数値的な結果が変更される可能性があるので注意が必要です。

このマクロは Clang の -ffast-math オプションに対応し、LLVM Fast-Math フラグを設定します。詳細は性能のための注釈の章を参照してください。

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672

カスタマイズ可能な二項演算子

一部の Unicode 文字は中置記法をサポートする新しい二項演算子として定義できます。例えば ⊗(x,y) = kron(x,y) (\otimes) をクロネッカー積として定義します。こうして定義した二項演算子を呼び出すときは、C = ⊗(A,B) のような通常の前置記法に加えて C = A ⊗ B のような中置記法も利用できます。こういった拡張機能がサポートされる文字には他に \odot () や \opus () があります。完全なリストはパーサーのコードを参照してください。

* のようにパースされる (優先度が同じ) 文字には * / ÷ % & ⋅ ∘ × |\\| ∩ ∧ ⊗ ⊘ ⊙ ⊚ ⊛ ⊠ ⊡ ⊓ ∗ ∙ ∤ ⅋ ≀ ⊼ ⋄ ⋆ ⋇ ⋉ ⋊ ⋋ ⋌ ⋏ ⋒ ⟑ ⦸ ⦼ ⦾ ⦿ ⧶ ⧷ ⨇ ⨰ ⨱ ⨲ ⨳ ⨴ ⨵ ⨶ ⨷ ⨸ ⨻ ⨼ ⨽ ⩀ ⩃ ⩄ ⩋ ⩍ ⩎ ⩑ ⩓ ⩕ ⩘ ⩚ ⩜ ⩞ ⩟ ⩠ ⫛ ⊍ ▷ ⨝ ⟕ ⟖ ⟗ があり、+ のようにパースされる文字には + - |\|| ⊕ ⊖ ⊞ ⊟ |++| ∪ ∨ ⊔ ± ∓ ∔ ∸ ≏ ⊎ ⊻ ⊽ ⋎ ⋓ ⧺ ⧻ ⨈ ⨢ ⨣ ⨤ ⨥ ⨦ ⨧ ⨨ ⨩ ⨪ ⨫ ⨬ ⨭ ⨮ ⨹ ⨺ ⩁ ⩂ ⩅ ⩊ ⩌ ⩏ ⩐ ⩒ ⩔ ⩖ ⩗ ⩛ ⩝ ⩡ ⩢ ⩣ があります。他にも矢印・比較・べきに関連する文字があります。


  1. 訳注: 英語版では div(x, y, r::RoundingMode=RoundToZero) というメソッドのドキュメントはエクスポートされていない (ソースに書かれてはいるがウェブページに載っていない) が、このメソッドは重要だと思われるので追加した。rem(x, y, r::RoundingMode=RoundToZero) についても同様とした。[return]

  2. 訳注: 関数プロトタイプ中の rtol のデフォルト値がソースコードと違っていたので、同じ値に変更した。[return]

  3. Donald Knuth, Art of Computer Programming, Volume 2: Seminumerical Algorithms, Sec. 4.6.4.[return]

日本語 Julia 書籍 (Amazon アソシエイト)
1 から始める Julia プログラミング
Julia プログラミングクックブック―言語仕様からデータ分析、機械学習、数値計算まで
スタンフォード ベクトル・行列からはじめる最適化数学