数学

-(x)

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

例

julia> -1
-1

julia> -(2)
-2

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

+(x, y...)

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

例

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

dt::Date + t::Time -> DateTime

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

-(x, y)

減算演算子です。

例

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

*(x, y...)

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

例

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

/(x, y)

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

例

julia> 1/2
0.5

julia> 4/2
2.0

julia> 4.5/2
2.25

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

^(x, y)

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

x が Int リテラル (例えば x^2 の 2 や x^-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

fma(x, y, z)

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

muladd(x, y, z)

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

例

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

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

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)

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

fld と cld も参照してください。この二つは 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

fld(x, y)

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

div も参照してください。

例

julia> fld(7.3,5.5)
1.0

cld(x, y)

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

div も参照してください。

例

julia> cld(5.5,2.2)
3.0

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

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

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

結果は y と同じ符号を持ち、abs(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 を計算します。ここで n は T 型で表現可能な整数の個数で、y は [typemin(T),typemax(T)] を満たす整数です。T が任意の整数を表せる (T == BigInt) なら、この操作は T 型への変換に対応します。

例

julia> 129 % Int8
-127

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)

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

x - y*round(x/y,r)

• r == RoundNearest だと、返り値の範囲は \([-|y|/2, |y|/2]\) となります。このとき返り値は必ず正確です (参照: RoundNearest)。

• r == RoundToZero (デフォルト) だと、返り値の範囲は x が正のとき \([0, |y|)\) となり、それ以外のとき \((-|y|, 0]\) となります。このとき返り値は必ず正確です (参照: RoundToZero)。

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

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

rem2pi(x, r::RoundingMode)

x を 2π で割った余りを計算します (商は整数)。商は丸めモード 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

mod2pi(x)

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

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

例

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) とも等価になります。

例

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)) と等価です。

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)

床除算の余りです。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

fldmod1(x, y)

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

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

//(num, den)

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

例

julia> 3 // 5
3//5

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

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

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

例

julia> Int8(3) << 2
12

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

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

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

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

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

>>(x, n)

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

>>>(x, n)

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

Unsigned 整数型に対する x >>> n は x >> n と等価です。Signed 整数型に対する x >>> n は 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 が負だと左方向への回転が行われます。

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

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

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

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

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

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

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

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

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

例

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)

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

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

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

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

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

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

例

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(n)

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

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)。R や S に TwicePrecision を使うと丸め誤差のない区間が実装できます。

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

!=(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 を実装するべきです。

例

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

二つの文字列の比較です。両方の文字列が同じ長さを持ち、それぞれの添え字における文字が全て同じなら 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

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

例

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

x | y

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

例

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

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

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

中置記法 a ⊻ b は xor(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

!(x)

真偽値に対する否定演算です。三値論理を実装するので、x が missing なら 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

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

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

厳密でない等価比較です²。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 の中で大きい方 (精度が低い方の eps) の平方根となります。これは仮数の桁の半分が合っていれば等しいとみなすことに対応します。それ例外のとき、つまり atol > 0 が指定されたときおよび引数が整数のときは、rtol のデフォルト値はゼロです。

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

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

デフォルトの atol は 0 なので、x ≈ 0 (デフォルトの許容値を使ったゼロとの近似比較) は x == 0 と等価です。このような場合には適切な atol を使うか、norm(x) ≤ atol とするか、x - y ≈ 0 となっているコードを x ≈ y と組み替えてください。ゼロでない atol を使うときに設定すべき値は問題の尺度 ("単位") によって変わるので、適切な atol の値を自動的に選択することはできません。例えば x がメートルで表した地球の半径 のときに x - y ≈ 0 を atol=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 と同様です。

sin(x)

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

cos(x)

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

sincos(x)

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

tan(x)

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

sind(x)

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

cosd(x)

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

tand(x)

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

sinpi(x)

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

cospi(x)

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

sinh(x)

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

cosh(x)

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

tanh(x)

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

asin(x)

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

acos(x)

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

atan(y)
atan(y, x)

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

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

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

asind(x)

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

acosd(x)

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

atand(y)
atand(y,x)

タンジェントの逆関数をそれぞれ x と 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 に対して計算します。出力 x は弧度法で表されます。

acsc(x)

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

acot(x)

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

asecd(x)

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

acscd(x)

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

acotd(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)

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

cosc(x)

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

deg2rad(x)

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

例

julia> deg2rad(90)
1.5707963267948966

rad2deg(x)

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

例

julia> rad2deg(pi)
180.0

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

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

log(b,x)

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

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

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

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

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

frexp(val)

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

exp(x)

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

例

julia> exp(1.0)
2.718281828459045

exp2(x)

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

例

julia> exp2(5)
32.0

exp10(x)

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

例

julia> exp10(2)
100.0

ldexp(x, n)

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

例

julia> ldexp(5., 2)
20.0

modf(x)

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

例

julia> modf(3.5)
(0.5, 3.0)

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

expm1(x)

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

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

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) を定義すれば通常は十分です。

RoundingMode

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

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

• RoundNearest (デフォルト)
• RoundNearestTiesAway
• RoundNearestTiesUp
• RoundToZero
• RoundFromZero (BigFloat のみ)
• RoundUp
• RoundDown

RoundNearest

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

RoundNearestTiesAway

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

RoundNearestTiesUp

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

RoundToZero

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

RoundFromZero

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

例

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=, base=10)
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; sigdigits=, base=10)

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

例

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

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, base は round と同様です。

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, base は round と同様です。

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, base は round と同様です。

unsafe_trunc(T, x)

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

min(x, y, ...)

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

例

julia> min(2, 5, 1)
1

max(x, y, ...)

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

例

julia> max(2, 5, 1)
5

minmax(x, y)

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

例

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

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

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

例

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

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

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

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_abs(x)

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

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

Base.checked_neg(x)

必要ならオーバーフローのチェックを行いながら -x を計算します。例えば 2 の補数を使った標準的な符号付き整数 (例えば 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.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 の絶対値の二乗を計算します。

例

julia> abs2(-3)
9

copysign(x, y) -> z

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

例

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

sign(x)

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

signbit(x)

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

例

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 と等価です。

例

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

isqrt(n::Integer)

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

julia> isqrt(5)
2