数値計算

この章では #Script で行われる数値計算処理の手順を定義する。

原始型数値の演算

原始整数型の演算

原子整数型の値に対して数学的な意味での整数と同じように加算、減算、乗算、絶対値、反数 (加法における逆元)、および大小の比較を定義する。

二つの原始整数型の値 a, b に対して、b ≠ 0 のとき、a を b で割った整数商を次のように定義する:

有理数 q = a / b に対して、次の性質をすべて満たす整数 n を整数商とする。(このような整数 n はちょうど一つだけ存在する)
- |n| ≤ |q| < |n| + 1
- n × q ≥ 0

注意: この整数商の定義は、\ 演算子による商演算では用いられていない。

二つの原始整数型の値 a, b について、b ≥ 0 のとき、a の b 乗を求める冪演算は次のように定義する:

原始整数型の値 1 に a の値を b 回乗じ、それを結果とする。b が 0 の時の結果は 1 である。

原始整数型の値に対して、二進法表記におけるビットごとの論理積、包括的論理和、排他的論理和、ビットシフトを一般的な計算機科学での定義と同じように定義する。ただし、負数は 2 の補数によって表されるものとし、無限個の上位ビット '1' を持つものとする。

原始制限実数型の演算

原始制限実数型の値に対して、数学的な意味での実数と同じように加算、減算、乗算、除算、絶対値、反数 (加法における逆元)、大きさの比較を定義する。これらの演算の結果もまた原始制限実数型の値となる。

原始実数型の演算

原始実数型の値に対して、数学的な意味での実数と同じように加算、減算、乗算、除算、絶対値、反数 (加法における逆元)、大きさの比較を定義する。これらの演算の結果は、大きさの比較を除いて、元の値の精度にかかわらず数学的に正確な実数であり、原始実数型の値として表せなくともよい。

実数または原始実数型の値 a, b について、b ≠ 0 のとき、a を b で割った整数商を次のように定義する:

次の性質をすべて満たす整数 n を整数商とする。(このような整数 n は唯一つしか存在しない)
- |n| ≤ |a / b| < |n| + 1
- n × a / b ≥ 0

注意: この整数商の定義は、\ 演算子による商演算では用いられていない。

オーバーフローエラー

原始整数型および原始実数型によって表せる値の範囲は無制限であるが、現実に存在する計算機の処理能力は有限であり、その限界を超えてスクリプトを実行し続けることは不可能である。スクリプトを実行する実行環境は、計算機の性能の限界その他の原因のために原始型数値の演算や処理を完了することができない場合 (オーバーフローエラー)、スクリプトの実行を中止するか、あるいは演算や処理の結果として新しい OverflowError のインスタンスを投げてもよい。

`Number` オブジェクト

スクリプトで扱われる数値は、初期の Number の特殊なインスタンスによって表される。このような特殊なインスタンスは、Number オブジェクトと呼ぶ。

オブジェクト O が Number オブジェクトであるとは、O が以下の条件のいづれかを満たすことである:

O が Real オブジェクトである。
O が Complex オブジェクトである。
O が Infinity オブジェクトである。
O が NaN オブジェクトである。

後述の定義により、Number オブジェクトが表す値は不変となる。

Real オブジェクトと Complex オブジェクトを合わせて有限数オブジェクトといい、Infinity オブジェクトと NaN オブジェクトを合わせて非有限数オブジェクトという。

`Real` オブジェクト

オブジェクト O が Real オブジェクトであるとは、O が Integer オブジェクト、Rational オブジェクトまたは Float オブジェクトであることである。Real オブジェクトは、実数を表す。

`Integer` オブジェクト

オブジェクト O が Integer オブジェクトであるとは、O が次の条件を全て満たすことである:

O は初期の Integer のインスタンスであるか、初期の Integer.prototype と同じオブジェクトである。
O の全てのメンバ・内部メンバは不変である。
O は関数として呼出し可能でない。
O は $isImmutable という名前の内部メンバを持ち、その値は初期の Boolean.true である。
O は value という名前の内部メンバを持ち、その値は原子整数型の値である。

Integer オブジェクトは、その value 内部メンバの値に等しい整数を表している。

`Rational` オブジェクト

オブジェクト O が Rational オブジェクトであるとは、O が次の条件を全て満たすことである:

O は初期の Rational のインスタンスであるか、初期の Rational.prototype と同じオブジェクトである。
O の全てのメンバ・内部メンバは不変である。
O は関数として呼出し可能でない。
O は $isImmutable という名前の内部メンバを持ち、その値は初期の Boolean.true である。
O は nu および de という名前の不変のプロパティを持ち、その値はそれぞれ Integer オブジェクトである。

Rational オブジェクトは、有理数を表している。nu プロパティの表す整数がその分子を、de プロパティの表す整数がその分母を表す。この値は既約分数であり、分母は常に正でなければならない。

`Float` オブジェクト

オブジェクト O が Float オブジェクトであるとは、O が次の条件を全て満たすことである:

O は初期の Float のインスタンスであるか、初期の Float.prototype と同じオブジェクトである。
O の全てのメンバ・内部メンバは不変である。
O は関数として呼出し可能でない。
O は $isImmutable という名前の内部メンバを持ち、その値は初期の Boolean.true である。
O は value という名前の内部メンバを持ち、その値は原子実数型の値である。
O は absolutePrecision という名前の内部メンバを持ち、その値は原子制限実数型の値である。

Float オブジェクトは、その value 内部メンバの値に等しい実数を表している。また absolutePrecision 内部メンバの値は、Float オブジェクトが表す実数の精度を表している。 (Float オブジェクトの精度も参照)

`Complex` オブジェクト

オブジェクト O が Complex オブジェクトであるとは、O が次の条件を全て満たすことである:

O は初期の Complex のインスタンスであるか、初期の Complex.prototype と同じオブジェクトである。
O の全てのメンバ・内部メンバは不変である。
O は関数として呼出し可能でない。
O は $isImmutable という名前の内部メンバを持ち、その値は初期の Boolean.true である。
O は re および im という名前の不変のプロパティを持ち、その値はそれぞれ Real オブジェクトである。

Complex オブジェクトは、複素数を表している。re プロパティの表す実数がその実部を、im プロパティの表す実数がその虚部を表す。

`Infinity` オブジェクト

オブジェクト O が Infinity オブジェクトであるとは、O が次の条件を全て満たすことである:

O は初期の Infinity のインスタンスであるか、初期の Infinity.prototype と同じオブジェクトである。
O の全てのメンバ・内部メンバは不変である。
O は関数として呼出し可能でない。
O は $isImmutable という名前の内部メンバを持ち、その値は初期の Boolean.true である。
O は sign という名前の不変のプロパティを持つ。その値は次のいづれかである:
- 整数 1 を表す Integer オブジェクト
- 整数 −1 を表す Integer オブジェクト
- NaN オブジェクト

Infinity オブジェクトは、無限大を表している。sign プロパティの値が整数 1 を表す Integer オブジェクトならば正の無限大を、整数 −1 を表す Integer オブジェクトならば負の無限大を、NaN オブジェクトならば複素無限大 (符号が定まらない無限大) を表す。

`NaN` オブジェクト

オブジェクト O が NaN オブジェクトであるとは、O が次の条件を全て満たすことである:

O は初期の NaN のインスタンスであるか、初期の NaN.prototype と同じオブジェクトである。
O の全てのメンバ・内部メンバは不変である。
O は関数として呼出し可能でない。
O は $isImmutable という名前の内部メンバを持ち、その値は初期の Boolean.true である。

NaN オブジェクトは、計算結果が一つの通常の数値として表せないことを示す特殊なオブジェクトである。

`Float` オブジェクトの精度

Float オブジェクトは、値そのものとは別に、精度の情報を持つ。Float オブジェクトに対する計算結果の桁数は、元の値の精度で決まる。

精度には、絶対精度と相対精度がある。ある Float オブジェクトが表す実数 x について、その真の値との誤差の絶対値が多くとも d であると見積もられるとき、 x に対する絶対精度は −log₁₀(2 d) である。また、さらに x が 0 でないとき、x に対する相対精度は −log₁₀(2 d / |x|) である。ただし、d = 0 のとき、x に対する絶対精度は無限大であり、またさらに x が 0 でないとき、x に対する相対精度も無限大である。x が 0 のときは、相対精度は d にかかわらず未定義である。

従って、0 でない実数 x に対して、絶対精度 a と相対精度 r との関係は以下のようになる:

a が無限大であることと r が無限大であることは同値である。
a = r − log₁₀|x|

実数に関する計算結果が Float オブジェクトとして表されるとき、その value 内部メンバの値 v、および absolutePrecision 内部メンバの値 a は原則として以下の規則により決定する:

その計算の定義で定められた方法により絶対精度の値を算出し、それを a の値とする。ただし、精度に関する情報が与えられていなければ、a の値は無限大とする。
a が無限大であり、かつ計算結果の実数値を一つの原子実数型の値によって正確に表すことができないならば、現在の実行コンテクストのデフォルトの精度が計算結果の相対精度であると見なして、計算結果の絶対精度 a を再計算する。
計算結果の真の値に十分近い実数を表す原子実数型の値を用意し、それを v とする。このとき、計算結果の真の値と v の値との差の絶対値は 10^−a / 2 以下でなければならない (a が無限大ならば、結果の真の値と v の値は完全に一致しなければならない)。この条件を満たす原始実数型の値を用意できないならば、オーバーフローエラーとする。

結果が `Float` オブジェクトとなる場合の値の特例

一つの演算や計算が複数の別の演算や計算の組合せによって定義されていて、かつその結果が Float オブジェクトとなるとき、複数の演算・計算を個別に行うかわりに演算・計算を一度にまとめて行っても良い。これは、この仕様書における演算・計算の定義が厳密に一致する場合でも、実行時に異なる結果が得られることを許容するものである。

例えばある実行環境において、原始実数型の取りうる値として十進有限小数のみがサポートされている場合、値 3.0 に対する逆数演算の結果は有限小数でないため、結果の精度は無限大にはなりえない。従って式 0.3x * /3.0x の結果の精度も、無限大とはならない。しかしこのような実行環境であっても、除算を逆数演算を使わずに直接計算するように実装していれば、式 0.3x / 3.0x によって有限小数 0.1 を表す精度が無限大の結果を得ることができるかもしれない。

値の変換

有限数オブジェクトに関する値の変換を以下のように定める。

恒等変換

任意の有限数オブジェクトについて、変換前と変換後の種類が等しい恒等変換が存在する。恒等変換では、変換の結果は変換前の値そのものである。

拡大変換

有限数オブジェクトに関する値の拡大変換を次のように定める。

`Integer` から `Rational` への拡大変換

Integer オブジェクト I から Rational オブジェクトへの拡大変換の結果は、以下の条件を満たす Rational オブジェクトである:

変換後のオブジェクトの nu プロパティの値は I と同じ整数を表す Integer オブジェクトである。(もちろん I そのものであっても良い)
変換後のオブジェクトの de プロパティの値は整数 1 を表す Integer オブジェクトである。

`Integer` から `Float` への拡大変換

Integer オブジェクトから Float オブジェクトへの拡大変換の結果は、元の Integer オブジェクトが表す整数に等しい実数を表す Float オブジェクトであり、その絶対精度は無限大である。

`Rational` から `Float` への拡大変換

Rational オブジェクト R から Float オブジェクト F への拡大変換は、以下のように行う:

R の de プロパティの値が表す整数が 1 ならば、R の nu プロパティの値を Integer から Float に変換し、その結果を Rational から Float への変換結果 F とする。
さもなくば、R の表している有理数を実数とみなし、その実数の値を表す Float オブジェクトを変換結果　F とする。 (この Float オブジェクトの各内部メンバの値に関する制約は、Float オブジェクトの精度の規定の通りである。この拡大変換に関して結果の精度が指定されている場合は、 F の精度はその指定された精度を反映する。)

`Real` から `Complex` への拡大変換

Real オブジェクト R から Complex オブジェクトへの拡大変換の結果は、以下の条件を満たす Complex オブジェクトである:

そのオブジェクトの re プロパティの値は R である。
そのオブジェクトの im プロパティの値は整数 0 を表す Integer オブジェクトである。

縮小変換

有限数オブジェクトに関する値の縮小変換を次のように定める。

`Rational` から `Integer` への縮小変換

Rational オブジェクト R から Integer オブジェクト I への縮小変換は、以下のように行う:

R の nu プロパティの値が表す整数を n とし、R の de プロパティの値が表す整数を d とする。
n を d で割った整数商を v とする (→原始整数型の演算)。
整数 v を表す Integer オブジェクトを変換結果 I とする。

`Float` から `Integer` への縮小変換

Float オブジェクト F から Integer オブジェクト I への縮小変換は、以下のように行う:

F の表す実数値を 1 で割った整数商 (→原始実数型の演算) を求め、その結果を q とする。
整数 q を表す Integer オブジェクトを変換結果 I とする。

`Float` から `Rational` への縮小変換

Float オブジェクト F から Rational オブジェクト R への縮小変換は、以下のように行う:

F の絶対精度が無限大であり、かつ F の表す値が有理数である場合

F の表す実数に等しい有理数を表す Rational オブジェクトを変換結果 R とする。

F の絶対精度が無限大でないか、または F の表す値が無理数である場合

F の表す値が無理数で、かつ F の絶対精度が無限大ならば、F と同じ値を表し、相対精度が現在の実行コンテクストのデフォルトの精度であるような Float オブジェクトを改めて F とする。
F を Integer に縮小変換し、その結果を q とする。
F を左辺値、q を右辺値として減算を行い、その結果を r とする。(r は Float オブジェクトとなるはずである。)
実数の比較によって r = 0 ならば、q を Rational に拡大変換したものを変換結果 R とする。
さもなくば r に対して逆数演算を行い、その結果を s とする。
s は Float オブジェクトであるはずである。s を Rational に縮小変換し、その結果を t とする。
t に対して逆数演算を行い、その結果を u とする。
q と u に対して加算を行う。その結果は Rational オブジェクトとなるはずなので、それを変換結果 R とする。

`Complex` から `Real` への縮小変換

Complex オブジェクト C から Real オブジェクトへの縮小変換の結果は、C の re プロパティの値である。

演算

Number オブジェクトに対する演算は、Number オブジェクトのメソッドによって行う。

例えば、式 1 + 2 は式 (1).$add[2] と等価であって、これは 1 を表す Integer オブジェクトの $add メソッドを、2 を表す Integer オブジェクトを引数として、関数として呼出すことを表している。 $add メソッドは、関数として呼出されると渡された @this 値と引数とを足し合わせてその結果を返す。

このようなメソッドが実際にどのように定義されるかについて、実行環境はある程度の選択の余地がある。$add メソッドは、Integer オブジェクト自身のメンバであるかもしれないし、もしくは初期の Integer.prototype のメンバであるかもしれないし、あるいは Integer オブジェクト自身が持つ $get$$add ゲッターにより返されるオブジェクトであっても良い。

演算を行うメソッド

演算のために使われるメソッドが満たすべき条件は以下の通り:

全ての Number オブジェクトは、そのオブジェクトの種類に対して定義されている演算を行うためのメソッドを持たなければならない。ただし、初期の Number.prototype や初期の Integer.prototype などのプロパティがスクリプトの実行によって変更された場合は、この限りではない。
(前置演算子または後置演算子による) 単項演算のために使われるメソッドは、0 個のオブジェクトを引数として関数として呼出されると、渡された @this 値に対して演算を行い、結果を返す。引数が一つ以上渡されたときの動作は規定しない。
二項演算のために使われるメソッドは、一つのオブジェクトを引数として関数として呼出されると、渡された @this 値を左辺値、引数を右辺値として演算を行い、結果を返す。引数が一つも渡されなかったときもしくは二つ以上の引数が渡されたときの動作は規定しない。
演算が問題なく行われた場合、演算の結果を正常終了の結果として返さなければならない。
Integer オブジェクトのプロパティとして提供される演算のためのメソッドは、関数として呼び出されたときに @this 値が Integer オブジェクトでなければ、エラーとしても良い。エラーとする場合、新しい TypeError のインスタンスを投げなければならない。他の型の数値オブジェクトについても同様とする。
単項演算のためのメソッドの arity プロパティの初期値は、0 を表す Integer オブジェクトでなければならない。二項演算のためのメソッドの arity プロパティの初期値は、1 を表す Integer オブジェクトでなければならない。

省略記法

以下、Float オブジェクト f に対して、 ap(f) はその絶対精度を、rp(f) はその相対精度を表すものとする。

非有限数オブジェクトに関する演算結果を定義する表において、次の省略記法を使用する:

省略記法の定義
省略記法	意味
任意	`Number` オブジェクト
+∞	正の無限大を表す `Infinity` オブジェクト
−∞	負の無限大を表す `Infinity` オブジェクト
∞	複素無限大を表す `Infinity` オブジェクト
NaN	`NaN` オブジェクト
有限数	有限数オブジェクト
零 Complex	実部と虚部が共に実数の比較において 0 と等しい `Complex` オブジェクト
非零 Complex	零 Complex ではない `Complex` オブジェクト
Real	`Real` オブジェクト
零 Real	実数の比較において 0 と等しい `Real` オブジェクト
正 Real	実数の比較において 0 より大きい `Real` オブジェクト
負 Real	実数の比較において 0 より小さい `Real` オブジェクト

`Float` オブジェクトに関する演算

演算結果が Float オブジェクトとなるとき、そのオブジェクトの value および absolutePrecision 内部メンバの具体的な値は別項で定める通りとする (→Float オブジェクトの精度)。

恒等演算 `$plus`

恒等演算 $plus は前置単項演算子 + に対応する。

任意の Number オブジェクトに対する恒等演算の結果は、そのオブジェクトそのものである。

加算 `$add`

加算 $add は二項演算子 + に対応する。

左辺値または右辺値が非有限数オブジェクトであるときの加算結果は下表の通り:

非有限数の加算
左辺値	右辺値	結果
NaN	任意	NaN
任意	NaN	NaN
∞	∞/+∞/−∞	NaN
∞/+∞/−∞	∞	NaN
+∞	+∞	+∞
−∞	−∞	−∞
+∞	−∞	NaN
−∞	+∞	NaN
∞/+∞/−∞	Complex	∞
∞	Real	∞
+∞	Real	+∞
−∞	Real	−∞
Complex	∞/+∞/−∞	∞
Real	∞	∞
Real	+∞	+∞
Real	−∞	−∞

左辺値と右辺値が共に Integer オブジェクトのときの加算結果は、左辺値の表す値を v、右辺値の表す値を w として、整数 v + w の値を表す Integer オブジェクトである。

左辺値 a と右辺値 b が共に Rational オブジェクトのときの加算結果は、Rational[a.nu * b.de + a.de * b.nu, a.de * b.de] の結果に等しい。ただし、結果の Rational オブジェクトの表す有理数の分母が 1 ならば、代わりにその有理数の分子の値を表す Integer オブジェクトを結果としてもよい。

左辺値と右辺値の片方が Integer オブジェクトでもう片方が Rational オブジェクトのときの加算は、Integer オブジェクトを Rational に拡大変換した上で、Rational どうしの加算を行う。

左辺値 a と右辺値 b が共に Float オブジェクトのときの加算結果は、a と b の表す実数をそれぞれ v, w として、実数 v + w を表す Float オブジェクトである。結果の絶対精度は −log₁₀(10^−ap(a) + 10^−ap(b)) とする。

左辺値と右辺値の片方が Integer または Rational オブジェクト a でもう片方が Float オブジェクト b のときの加算結果は、a が表す整数または有理数を v、b の表す実数を w として、実数 v + w を表す Float オブジェクトである。結果の絶対精度は b の絶対精度に等しい。

左辺値 a と右辺値 b が共に Complex オブジェクトのときの加算結果は、Complex[a.re + b.re, a.im + b.im] の結果に等しい。

左辺値と右辺値の片方が Real オブジェクトでもう片方が Complex オブジェクトのときの加算は、Real オブジェクトを Complex に拡大変換した上で、Complex どうしの加算を行う。

インクリメント演算 `$increment`

インクリメント演算 $increment は前置単項演算子 ++ および後置単項演算子 ++ で使われる。

Number オブジェクト a に対するインクリメント演算の結果は、a + 1 の結果に等しい。

反数演算 `$minus`

反数演算 $minus は前置単項演算子 - に対応する。

Integer オブジェクト a に対する反数演算の結果は、 a の表す整数を v とすると、整数 −v を表す Integer オブジェクトである。

Rational オブジェクト a に対する反数演算の結果は、 Rational[-a.nu, a.de] の結果に等しい。ただし、結果の Rational オブジェクトの表す有理数の分母が 1 ならば、代わりにその有理数の分子の値を表す Integer オブジェクトを結果としてもよい。

Float オブジェクト a に対する反数演算の結果は、 a の表す実数を v として、実数 −v を表す Float オブジェクトである。結果の絶対精度は、a のそれに等しい。

Complex オブジェクト a に対する反数演算の結果は、 Complex[-a.re, -a.im] の結果に等しい。

正の無限大を表す Infinity オブジェクトに対する反数演算の結果は、負の無限大を表す Infinity オブジェクトである。負の無限大を表す Infinity オブジェクトに対する反数演算の結果は、正の無限大を表す Infinity オブジェクトである。複素無限大を表す Infinity オブジェクトに対する反数演算の結果は、複素無限大を表す Infinity オブジェクトである。

NaN オブジェクトに対する反数演算の結果は、NaN オブジェクトである。

減算 `$subtract`

減算 $subtract は二項演算子 - に対応する。

左辺値 a と右辺値 b が共に Number オブジェクトであるときの減算の結果は、a + (-b) の結果に等しい。

デクリメント演算 `$decrement`

デクリメント演算 $decrement は前置単項演算子 -- および後置単項演算子 -- で使われる。

Number オブジェクト a に対するデクリメント演算の結果は、a - 1 の結果に等しい。

乗算 `$multiply`

乗算 $multiply は二項演算子 * に対応する。

左辺値または右辺値が非有限数オブジェクトであるときの乗算結果は下表の通り:

非有限数の乗算
左辺値	右辺値	結果
NaN	任意	NaN
任意	NaN	NaN
∞	∞/+∞/−∞	∞
∞/+∞/−∞	∞	∞
+∞	+∞	+∞
−∞	−∞	+∞
+∞	−∞	−∞
−∞	+∞	−∞
∞/+∞/−∞	零 Complex	NaN
零 Complex	∞/+∞/−∞	NaN
∞/+∞/−∞	非零 Complex	∞
非零 Complex	∞/+∞/−∞	∞
∞/+∞/−∞	零 Real	NaN
零 Real	∞/+∞/−∞	NaN
∞	非零 Real	∞
非零 Real	∞	∞
+∞	正 Real	+∞
+∞	負 Real	−∞
正 Real	+∞	+∞
負 Real	+∞	−∞
−∞	正 Real	−∞
−∞	負 Real	+∞
正 Real	−∞	−∞
負 Real	−∞	+∞

左辺値と右辺値が共に Integer オブジェクトのときの乗算結果は、左辺値の表す値を v、右辺値の表す値を w として、整数 v × w を表す Integer オブジェクトである。

左辺値 a と右辺値 b が共に Rational オブジェクトのときの乗算結果は、Rational[a.nu * b.nu, a.de * b.de] の結果に等しい。ただし、結果の Rational オブジェクトの表す有理数の分母が 1 ならば、代わりにその有理数の分子の値を表す Integer オブジェクトを結果としてもよい。

左辺値と右辺値の片方が Integer オブジェクトでもう片方が Rational オブジェクトのときの乗算は、Integer オブジェクトを Rational に拡大変換した上で、Rational どうしの乗算を行う。

左辺値 a と右辺値 b が共に Float オブジェクトのときの乗算結果は、a と b の表す値をそれぞれ v, w として、実数 v × w を表す Float オブジェクトである。結果の精度は次のように算出する:

v ≠ 0 かつ w ≠ 0 のとき: 結果の相対精度は −log₁₀(10^−rp(a) + 10^−rp(b))
v = 0 かつ w ≠ 0 のとき: 結果の絶対精度は ap(a) − log₁₀|w|
w = 0 かつ v ≠ 0 のとき: 結果の絶対精度は ap(b) − log₁₀|v|
v = w = 0 のとき: 結果の絶対精度は ap(a) + ap(b) + log₁₀2

ただし、上記の場合分けにおける 0 との比較は、実数の比較によって行う。

左辺値と右辺値の片方が Integer または Rational オブジェクト a でもう片方が Float オブジェクト b のときの乗算結果は、a の表す整数または有理数を v、b の表す実数を w とすると、

v ≠ 0 かつ w ≠ 0 のとき: v × w を表す Float オブジェクト。相対精度は a の相対精度に等しい。
w = 0 かつ v ≠ 0 のとき: v × w を表す Float オブジェクト。絶対精度は ap(b) − log₁₀|v| とする。
a が Integer オブジェクトで、v = 0 のとき: 整数 0 を表す Integer オブジェクト。
a が Rational オブジェクトで、v = 0 のとき: 整数 0 を表す Integer オブジェクトまたは Rational オブジェクト。

ただし、上記の場合分けにおける 0 との比較は、実数の比較によって行う。

左辺値 a と右辺値 b が共に Complex オブジェクトのときの乗算結果は、Complex[a.re * b.re - a.im * b.im, a.re * b.im + a.im * b.re] の結果に等しい。

左辺値と右辺値の片方が Real オブジェクトでもう片方が Complex オブジェクトのときの乗算は、Real オブジェクトを Complex に拡大変換した上で、Complex どうしの乗算を行う。

結合演算 `$juxtapose`

結合演算 $juxtapose は結合演算子に対応する。

左辺値と右辺値が共に Number オブジェクトであるときの結合演算は、同じ左辺値・右辺値に対する乗算に等しい。

左辺値 a が Number オブジェクトで右辺値 b が関数オブジェクトであるときの結合演算の結果は、以下のような新しい関数オブジェクトである:

このオブジェクトのプロトタイプは b である。
このオブジェクトは、$prototype 内部メンバ以外にメンバ・内部メンバを持たない。
このオブジェクトが関数として呼出されると、以下の処理を行う:
1. この呼出しで渡されたのと同じ @this 値と引数で b を関数として呼出し、その結果に対して get-reference-value を行い、その結果を r とする。
2. r が正常終了でなければ、それを返す。
3. a を左辺値、r の値を右辺値として、結合演算を行い、その結果を返す。

逆数演算 `$reciprocal`

逆数演算 $reciprocal は前置単項演算子 / に対応する。

Rational オブジェクト a に対する逆数演算の結果は、 a.nu の表す値が 0 でなければ、 Rational[a.de, a.nu] の結果に等しい。ただし、結果の Rational オブジェクトの表す有理数の分母が 1 ならば、代わりにその有理数の分子の値を表す Integer オブジェクトを結果としてもよい。a.nu の表す値が 0 ならば、結果は複素無限大を表す Infinity オブジェクトである。

Integer オブジェクトに対する逆数演算は、そのオブジェクトを Rational に拡大変換し、その結果に対して上記の逆数演算を行う。

Float オブジェクト a に対する逆数演算の結果は次のように定める:

実数の比較によって a = 0 ならば、結果は複素無限大を表す Infinity オブジェクトである。
さもなくば結果は、a の表す実数を v として、1 / v を表す Float オブジェクトである。結果の相対精度は a のそれに等しい。

Complex オブジェクト a に対する逆数演算の結果は、Complex.conj[a] / Math.abs2[a] の結果に等しい。

Infinity オブジェクトに対する逆数演算の結果は、整数 0 を表す Integer オブジェクトである。

NaN オブジェクトに対する逆数演算の結果は、NaN オブジェクトである。

除算 `$divide`

除算 $divide は二項演算子 / に対応する。

左辺値 a と右辺値 b が共に Number オブジェクトであるときの除算の結果は、a * (/b) の結果に等しい。

商演算 `$quotient`

商演算 $quotient は二項演算子 \ に対応する。

左辺値と右辺値の少なくとも一方が NaN オブジェクトであるときの冪算結果は、NaN オブジェクトである。

左辺値 a と右辺値 b が共に Real オブジェクトであるときの商演算の結果は、Math.floor[a / b] の結果に等しい。

剰余演算 `$mod`

剰余演算 $mod は二項演算子 % に対応する。

左辺値と右辺値の少なくとも一方が NaN オブジェクトであるときの冪算結果は、NaN オブジェクトである。

左辺値 a と右辺値 b が共に Real オブジェクトであるときの剰余演算の結果は、a - b * (a \ b) の結果に等しい。

冪算 `$power`

冪算 $power は二項演算子 ^/** に対応する。

左辺値と右辺値が共に Number オブジェクトであり、それらの少なくとも一方が NaN オブジェクトであるときの冪算結果は、NaN オブジェクトである。

左辺値 a と右辺値 b が共に Integer オブジェクトであるときの冪算は、次のように定める:

b > 0 ならば、a^b の値を表す Integer オブジェクトをこの冪算の結果とする。
b < 0 ならば、/(a ^ -b) の結果をこの冪算の結果とする。
b = 0 かつ a ≠ 0 ならば、冪算結果は整数 1 を表す Integer オブジェクトである。
b = a = 0 ならば、冪算結果は NaN オブジェクトである。

左辺値 a が Integer オブジェクトで右辺値 b が Rational オブジェクトであるときの冪算は、次のように定める:

b.de 乗して a になるような整数が存在するならば、そのような整数を表す Integer オブジェクトを r として、r ^ b.nu の結果をこの冪算の結果とする。ただし、このような整数が複数存在する場合は、それらのうちもっとも大きいものを選択する。
さもなくば、a を Float に拡大変換し、 Float オブジェクトを左辺値、Rational オブジェクトを右辺値とする冪算を行う。

左辺値 a が Rational オブジェクトで右辺値 b が Integer オブジェクトであるときの冪算結果は、 a.nu ^ b / a.de ^ b の結果に等しい。

左辺値 a と右辺値 b が共に Rational オブジェクトであるときの冪算は、次のように定める:

a = b = 0 ならば、冪算結果は NaN オブジェクトである。
a.nu ^ b と a.de ^ b の結果がどちらも Integer オブジェクトまたは Rational オブジェクトならば、a.nu ^ b / a.de ^ b の結果をこの冪算の結果とする。
さもなくば、a を Float に拡大変換し、 Float オブジェクトを左辺値、Rational オブジェクトを右辺値とする冪算を行う。

左辺値 a が Integer オブジェクトまたは Rational オブジェクトで右辺値 b が Float オブジェクトのときの冪算は、次のように定める:

a = 0 かつ b > 0 ならば、冪算結果は 0 を表す Integer オブジェクトまたは Rational オブジェクトである。ただし、このとき a が Integer オブジェクトならば結果も Integer オブジェクトとする。
a < 0 であって、b の表す実数が整数であり、かつ b の絶対精度が無限大ならば、(-1)^Integer[b] * (-a)^b の結果をこの冪算の結果としてもよい。
a < 0 であって、b の表す実数が有理数であり、その有理数の分母が奇数であってかつ b の絶対精度が無限大ならば、 -(-a)^b の結果をこの冪算の結果としてもよい。
a = 0 かつ b < 0 ならば、冪算結果は複素無限大を表す Infinity オブジェクトである。
a = b = 0 であるか、または a < 0 で上記に当てはまらない場合は、冪算結果は NaN オブジェクトである。
さもなくば、Math.exp[b * Math.log[a]] の結果をこの冪算の結果とする。ただし、b の絶対精度が現在の実行コンテクストのデフォルトの精度よりも大きくかつ無限大でないときは、この冪算においてのみ現在の実行コンテクストのデフォルトの精度を b の絶対精度に変更して計算を行う。

ただし、上記の場合分けにおける 0 との比較は、実数の比較によって行う。

左辺値 a が Float オブジェクトで右辺値 b が Integer または Rational オブジェクトのときの冪算は、次のように定める:

a = 0 かつ b > 0 ならば、冪算結果は 0 を表す Float オブジェクトである。ただし、結果の絶対精度は b * ap(a) + (b − 1) log₁₀2 とする。
a < 0 であって、b の表す値が整数ならば、 (-1)^b * (-a)^b の結果をこの冪算の結果とする。
a < 0 であって、b の表す有理数の分母が奇数ならば、 -(-a)^b の結果をこの冪算の結果とする。
a = 0 かつ b < 0 ならば、冪算結果は複素無限大を表す Infinity オブジェクトである。
a = b = 0 であるか、または a < 0 で上記に当てはまらない場合は、冪算結果は NaN オブジェクトである。
さもなくば、Math.exp[b * Math.log[a]] の結果をこの冪算の結果とする。

ただし、上記の場合分けにおける 0 との比較は、実数の比較によって行う。

実装上の注意: 右辺値が整数のときは、左辺値の乗算の繰り返しおよび逆数演算によって左辺値の右辺値乗を求め、それを結果としてもよい。例えば、1.25^-3 を /(1.25 * 1.25 * 1.25) によって計算してもよい。

左辺値 a と右辺値 b が共に Float オブジェクトであるときの冪算は、次のように定める:

a = 0 かつ b > 0 ならば、冪算結果は 0 を表す Float オブジェクトである。ただし、結果の絶対精度は b * ap(a) + (b − 1) log₁₀2 とする。
a < 0 であって、b の表す実数が整数であり、かつ b の絶対精度が無限大ならば、(-1)^Integer[b] * (-a)^b の結果をこの冪算の結果としてもよい。
a < 0 であって、b の表す実数が有理数であり、その有理数の分母が奇数であってかつ b の絶対精度が無限大ならば、 -(-a)^b の結果をこの冪算の結果としてもよい。
a = 0 かつ b < 0 ならば、冪算結果は複素無限大を表す Infinity オブジェクトである。
a = b = 0 であるか、または a < 0 で上記に当てはまらない場合は、冪算結果は NaN オブジェクトである。
さもなくば、Math.exp[b * Math.log[a]] の結果をこの冪算の結果とする。ただし、a の絶対精度が無限大であって、 b の絶対精度が現在の実行コンテクストのデフォルトの精度よりも大きくかつ無限大でないときは、この冪算においてのみ現在の実行コンテクストのデフォルトの精度を b の絶対精度に変更して計算を行う。

ただし、上記の場合分けにおける 0 との比較は、実数の比較によって行う。

左辺値と右辺値が共に Real オブジェクトである冪算では、左辺値と右辺値が共に 0 ならば結果は常に NaN、左辺値が 0 で右辺値が負ならば結果は常に複素無限大となる。

左辺値 a と右辺値 b が共に Complex オブジェクトであるときの冪算は、次のように定める:

a.re = 0 かつ a.im = 0 ならば、
1. b.im が 0 を表す Integer オブジェクトまたは Rational オブジェクトならば、
  1. b.re > 0 ならば、
    1. a.re と a.im がどちらも Integer オブジェクトならば、冪算の結果は、実部・虚部が共に 0 を表す Integer オブジェクトであるような Complex オブジェクトである。
    2. a.re と a.im がどちらも Integer オブジェクトまたは Rational オブジェクトならば、冪算の結果は、実部・虚部が共に 0 を表す Integer オブジェクトまたは Rational オブジェクトであるような Complex オブジェクトである。
    3. さもなくば、冪算の結果は、実部・虚部が共に 0 を表す Float オブジェクトであるような Complex オブジェクトである。ただし、Float オブジェクトの絶対精度は実部・虚部どちらも b * ap(a) + (b − 1) log₁₀2 とする (ここで、ap(a) は a の実部の絶対精度と虚部の絶対精度の最小値である。Integer オブジェクトまたは Rational オブジェクトの絶対精度は無限大と見なす)。また、ここでさらに b.re が正の整数を表す Integer オブジェクトまたは Rational オブジェクトならば、代わりに乗算の繰り返しによって a の b 乗を求め、それを冪算の結果としても良い。
  2. b.re = 0 ならば、冪算の結果は NaN オブジェクトである。
  3. b.re < 0 ならば、冪算の結果は複素無限大を表す Infinity オブジェクトである。
2. さもなくば、a ^ b.re * Complex[cos[b.im], sin[b.im]] の結果を冪算の結果とする。
さもなくば、冪算の結果は Math.exp[b * Math.log[a]] の結果に等しい。ただし、以下に挙げる特別な場合に当てはまるときは、上記の定義の代わりに以下の定義を用いても良い:

a.re の表す値が負、b.re が 1/2 を表す Rational オブジェクトで、a.im および b.im が 0 に等しい Integer オブジェクトまたは Rational オブジェクトのとき

結果は 1i * (-a.re) ^ /2

a.re の表す値が負、b.re が 1/4 を表す Rational オブジェクトで、a.im および b.im が 0 に等しい Integer オブジェクトまたは Rational オブジェクトのとき

結果は (1 + 1i) * (-a.re / 4) ^ /4

a.im の表す値が正、b.re が 1/2 を表す Rational オブジェクトで、a.re および b.im が 0 に等しい Integer オブジェクトまたは Rational オブジェクトのとき

結果は (1 + 1i) * (a.im / 2) ^ /2

a.im の表す値が負、b.re が 1/2 を表す Rational オブジェクトで、a.re および b.im が 0 に等しい Integer オブジェクトまたは Rational オブジェクトのとき

結果は (1 - 1i) * (-a.im / 2) ^ /2

a.re、a.im、b.re、b.im がどれも Integer オブジェクトまたは Rational オブジェクトで、かつ a.re の表す値が負で、a.re と -a.im の値が等しく、b.re は 1/3 に、b.im は 0 に等しいとき

結果は (1 + 1i) * (-a.re / 2) ^ /3

a.re、a.im、b.re、b.im がどれも Integer オブジェクトまたは Rational オブジェクトで、かつ a.re の表す値が負で、a.re と a.im の値が等しく、b.re は 1/3 に、b.im は 0 に等しいとき

結果は (1 - 1i) * (-a.re / 2) ^ /3

b.re と b.im が共に Integer オブジェクトまたは Rational オブジェクトであって、かつ b.re の表す値が整数であり、 b.im の表す値が 0 に等しいとき (ただし、a.re、a.im、 b.re の値が全て 0 である場合を除く)

a の乗算の繰り返しおよび逆数演算によって a の b 乗を求めたもの。

b.re が Rational オブジェクトであり、かつ b.im が 0 を表す Integer オブジェクトまたは Rational オブジェクトであるとき

結果は (a ^ /b.re.de) ^ b.re.nu

ただし、上記の場合分けにおける 0 との比較および符号の判定は、実数の比較によって行う。

左辺値と右辺値の片方が Real オブジェクトでもう片方が Complex オブジェクトのときの冪算は、Real オブジェクトを Complex に拡大変換した上で、Complex どうしの冪算を行う。

左辺値が正の無限大を表す Infinity オブジェクトであるときの冪算は次のように定める:

右辺値が正の無限大を表す Infinity オブジェクトならば、結果は正の無限大を表す Infinity オブジェクトである。
右辺値が負の無限大を表す Infinity オブジェクトならば、結果は整数 0 を表す Integer オブジェクトである。
右辺値が複素無限大を表す Infinity オブジェクトならば、結果は NaN オブジェクトである。
右辺値が Real オブジェクト b ならば、
- b の値が 0 に等しいならば、結果は NaN オブジェクトである。
- b の値が正ならば、結果は正の無限大を表す Infinity オブジェクトである。
- b の値が負ならば、結果は整数 0 を表す Integer オブジェクトである。
右辺値が Complex オブジェクト b ならば、
- b の実部の値が 0 に等しいならば、結果は NaN オブジェクトである。
- b の実部の値が正ならば、結果は複素無限大を表す Infinity オブジェクトである。
- b の実部の値が負ならば、結果は整数 0 を表す Integer オブジェクトである。

ただし、上記の場合分けにおける 0 との比較および符号の判定は、実数の比較によって行う。

左辺値が負の無限大を表す Infinity オブジェクトであるときの冪算は次のように定める:

右辺値が正の無限大を表す Infinity オブジェクトならば、結果は複素無限大を表す Infinity オブジェクトである。
右辺値が負の無限大を表す Infinity オブジェクトならば、結果は整数 0 を表す Integer オブジェクトである。
右辺値が複素無限大を表す Infinity オブジェクトならば、結果は NaN オブジェクトである。
右辺値が Integer オブジェクトまたは Rational オブジェクト b ならば、
- b の表す値が整数ならば、結果は (-1)^b * @inf^b の結果に等しい。
- b の表す有理数の分母が奇数ならば、結果は -@inf^b の結果に等しい。
- これ以外の場合は、結果は NaN オブジェクトである。
右辺値が Float オブジェクト b ならば、
- b の表す値が整数であり、かつ b の絶対精度が無限大ならば、(-1)^b * @inf^b の結果をこの冪算の結果としても良い。
- b の表す値が有理数でその分母が奇数であり、かつ b の絶対精度が無限大ならば、-@inf^b の結果をこの冪算の結果としても良い。
- これ以外の場合は、結果は NaN オブジェクトである。
右辺値が Complex オブジェクト b ならば、結果は NaN オブジェクトである。

ただし、上記の場合分けにおける 0 との比較および符号の判定は、実数の比較によって行う。

左辺値が複素無限大を表す Infinity オブジェクトであるときの冪算は次のように定める:

右辺値が正の無限大を表す Infinity オブジェクトならば、結果は複素無限大を表す Infinity オブジェクトである。
右辺値が負の無限大を表す Infinity オブジェクトならば、結果は整数 0 を表す Integer オブジェクトである。
右辺値が複素無限大を表す Infinity オブジェクトならば、結果は NaN オブジェクトである。
右辺値が Real オブジェクト b ならば、
- b の値が 0 に等しいならば、結果は NaN オブジェクトである。
- b の値が正ならば、結果は複素無限大を表す Infinity オブジェクトである。
- b の値が負ならば、結果は整数 0 を表す Integer オブジェクトである。
右辺値が Complex オブジェクト b ならば、
- b の実部の値が 0 に等しいならば、結果は NaN オブジェクトである。
- b の実部の値が正ならば、結果は複素無限大を表す Infinity オブジェクトである。
- b の実部の値が負ならば、結果は整数 0 を表す Integer オブジェクトである。

ただし、上記の場合分けにおける 0 との比較および符号の判定は、実数の比較によって行う。

左辺値 a が有限数オブジェクトで、右辺値が正の無限大を表す Infinity オブジェクトであるときの冪算は次のように定める:

a が Real オブジェクトならば、
- 実数の比較によって a > 1 ならば、結果は正の無限大を表す Infinity オブジェクトである。
- 実数の比較によって a > −1 かつ a < 1 ならば、結果は整数 0 を表す Integer オブジェクトである。
- 実数の比較によって a < −1 ならば、結果は複素無限大を表す Infinity オブジェクトである。
- 実数の比較によって a = 1 または a = −1 ならば、結果は NaN オブジェクトである。
a が Complex オブジェクトならば、 (-Math.abs[a])^@inf の結果を冪算結果とする。

左辺値 a が有限数オブジェクトで、右辺値が負の無限大を表す Infinity オブジェクトであるときの冪算は次のように定める:

a が Real オブジェクトならば、
- 実数の比較によって a > 1 または a < −1 ならば、結果は整数 0 を表す Integer オブジェクトである。
- 実数の比較によって a > 0 かつ a < 1 ならば、結果は正の無限大を表す Infinity オブジェクトである。
- 実数の比較によって a ≤ 0 かつ a > −1 ならば、結果は複素無限大を表す Infinity オブジェクトである。
- 実数の比較によって a = 1 または a = −1 ならば、結果は NaN オブジェクトである。
a が Complex オブジェクトならば、 (-Math.abs[a])^(-@inf) の結果を冪算結果とする。

左辺値 a が有限数オブジェクトで、右辺値が複素無限大を表す Infinity オブジェクトであるときの冪算結果は、NaN オブジェクトである。

比較演算 `$less`

比較演算 $less は二項演算子 < に対応する。

左辺値 a と右辺値 b が共に Real オブジェクトであるときの比較演算 $less の結果は、a と b に対して実数の比較を行い、その結果が「<」ならば初期の Boolean.true、さもなくば初期の Boolean.false を結果とする。

正および負の無限大を表す Infinity オブジェクトに関する比較演算 $less の結果は下表の通り:

非有限数の比較 `$less`
左辺値	右辺値	結果
+∞	+∞	false
+∞	Real	false
+∞	−∞	false
−∞	+∞	true
−∞	Real	true
−∞	−∞	false
Real	+∞	true
Real	−∞	false

比較演算 `$greater`

比較演算 $greater は二項演算子 > に対応する。

左辺値 a と右辺値 b が共に Real オブジェクトであるときの比較演算 $greater の結果は、a と b に対して実数の比較を行い、その結果が「>」ならば初期の Boolean.true、さもなくば初期の Boolean.false を結果とする。

正および負の無限大を表す Infinity オブジェクトに関する比較演算 $greater の結果は下表の通り:

非有限数の比較 `$greater`
左辺値	右辺値	結果
+∞	+∞	false
+∞	Real	true
+∞	−∞	true
−∞	+∞	false
−∞	Real	false
−∞	−∞	false
Real	+∞	false
Real	−∞	true

比較演算 `$lessEqual`

比較演算 $lessEqual は二項演算子 <= に対応する。

左辺値 a と右辺値 b が共に Real オブジェクトであるときの比較演算 $lessEqual の結果は、a と b に対して実数の比較を行い、その結果が「<」または「=」ならば初期の Boolean.true、さもなくば初期の Boolean.false を結果とする。

正および負の無限大を表す Infinity オブジェクトに関する比較演算 $lessEqual の結果は下表の通り:

非有限数の比較 `$lessEqual`
左辺値	右辺値	結果
+∞	+∞	true
+∞	Real	false
+∞	−∞	false
−∞	+∞	true
−∞	Real	true
−∞	−∞	true
Real	+∞	true
Real	−∞	false

比較演算 `$greaterEqual`

比較演算 $greaterEqual は二項演算子 >= に対応する。

左辺値 a と右辺値 b が共に Real オブジェクトであるときの比較演算 $greaterEqual の結果は、a と b に対して実数の比較を行い、その結果が「>」または「=」ならば初期の Boolean.true、さもなくば初期の Boolean.false を結果とする。

正および負の無限大を表す Infinity オブジェクトに関する比較演算 $greaterEqual の結果は下表の通り:

非有限数の比較 `$greaterEqual`
左辺値	右辺値	結果
+∞	+∞	true
+∞	Real	true
+∞	−∞	true
−∞	+∞	false
−∞	Real	false
−∞	−∞	true
Real	+∞	false
Real	−∞	true

この仕様では、複素無限大を表す Infinity オブジェクトおよび NaN オブジェクトに関する比較演算 $less/$greater/$lessEqual/$greaterEqual は定義しない。

比較演算 `$equal`

比較演算 $equal は二項演算子 == に対応する。

左辺値または右辺値が非有限数オブジェクトであるときの比較演算 $equal の結果は、次の条件のどれかが満たされるならば初期の Boolean.true、さもなくば初期の Boolean.false である。

左辺値および右辺値がどちらも NaN オブジェクトである。
左辺値および右辺値がどちらも正の無限大を表す Infinity オブジェクトである。
左辺値および右辺値がどちらも負の無限大を表す Infinity オブジェクトである。
左辺値および右辺値がどちらも複素無限大を表す Infinity オブジェクトである。

#Script では、NaN どうしの比較は等しいと判断される。これは IEEE 754 浮動小数点演算規則による NaN の扱いとは異なる。またこの仕様では、演算子 == による NaN どうしの比較は定義されているが演算子 <= や >= による NaN の比較は定義していない。

左辺値 a と右辺値 b が共に Real オブジェクトであるときの比較演算 $equal の結果は、a と b に対して実数の比較を行い、その結果が「=」ならば Boolean.true、さもなくば Boolean.false を結果とする。

左辺値と右辺値が共に Complex オブジェクトであるときの比較演算 $equal の結果は、左辺値と右辺値の re プロパティどうしおよび im プロパティどうしの比較演算 $equal を行い、その結果が共に Boolean.true ならば Boolean.true、さもなくば Boolean.false を結果とする。

左辺値と右辺値の片方が Real オブジェクトでもう片方が Complex オブジェクトのときの比較演算 $equal は、Real オブジェクトを Complex に拡大変換した上で Complex どうしの比較演算 $equal を行う。

比較演算 `$unequal`

比較演算 $unequal は二項演算子 != に対応する。

左辺値と右辺値が共に Number オブジェクトであるときの比較演算 $unequal の結果は、それらの値に対して比較演算 $equal を行い、その結果が Boolean.false ならば Boolean.true、さもなくば Boolean.false を結果とする。

実数の比較

Real オブジェクトどうしの比較は次のように行い、「<」「=」「>」のうちのどれかを結果として返す:

左辺値と右辺値が共に Integer オブジェクトのときの比較は、左辺値の表す整数を v、右辺値の表す整数を w として、 v < w ならば「<」、 v = w ならば「=」、v > w ならば「>」を返す。

左辺値 a と右辺値 b が共に Rational オブジェクトのときの比較は、a.nu * b.de を左辺値、b.nu * a.de を右辺値とする Integer どうしの比較に等しい。

左辺値と右辺値の片方が Integer オブジェクトでもう片方が Rational オブジェクトのときの比較は、Integer オブジェクトを Rational に拡大変換した上で、Rational どうしの比較を行う。

左辺値 a と右辺値 b が共に Float オブジェクトのときの比較は、次のように行う:

a の絶対精度と b の絶対精度との最小値を p とする。
a と b の value 内部メンバの値をそれぞれ v, w とする。
|v − w| ≤ 10^−p / 2 ならば、「=」を返す。(p が無限大ならば、v = w のときのみ「=」を返す)
v < w ならば「<」、 v > w ならば「>」を返す。

左辺値 a が Rational オブジェクトで右辺値 b が Float オブジェクトのときの比較は、次のように行う:

ap(b) が無限大なら、a の表す有理数を v、 b の表す実数を w として、 v < w ならば「<」、 v = w ならば「=」、v > w ならば「>」を返す。
ap(b) が無限大でなければ、a を Float オブジェクトに拡大変換し、Float どうしの比較を行う。ただし拡大変換の際には、変換結果の絶対精度が b のそれに等しくなるようにする。

左辺値が Float オブジェクトで右辺値が Rational オブジェクトのときの比較は、左辺値と右辺値を入れ替えて比較を行い、その結果が「<」ならば「>」を、「=」ならば「=」を、「>」ならば「<」を結果とする。

左辺値と右辺値の片方が Integer オブジェクトでもう片方が Float オブジェクトのときの比較は、Integer オブジェクトを Rational オブジェクトに拡大変換した上で、 Rational オブジェクトと Float オブジェクトとの比較を行う。

実数の比較は Real オブジェクトの符号の判定に用いられることがある。Real オブジェクト a が実数の比較によって a = 0 であるとは、a を左辺値とし、0 を表す Integer オブジェクトを右辺値として実数の比較を行い、その結果が「=」となることである。a ≠ 0 等の場合も同様である (下表参照)。

実数の比較による符号の判定
条件	比較結果
`a` = 0	「=」
`a` ≠ 0	「<」または「>」
`a` < 0	「<」
`a` > 0	「>」
`a` ≤ 0	「=」または「<」
`a` ≥ 0	「=」または「>」

数値計算

原始型数値の演算

原始整数型の演算

原始制限実数型の演算

原始実数型の演算

オーバーフローエラー

Number オブジェクト

Real オブジェクト

Integer オブジェクト

Rational オブジェクト

Float オブジェクト

Complex オブジェクト

Infinity オブジェクト

NaN オブジェクト

Float オブジェクトの精度

結果が Float オブジェクトとなる場合の値の特例

値の変換

恒等変換

拡大変換

Integer から Rational への拡大変換

Integer から Float への拡大変換

Rational から Float への拡大変換

Real から Complex への拡大変換

縮小変換

Rational から Integer への縮小変換

Float から Integer への縮小変換

Float から Rational への縮小変換

Complex から Real への縮小変換

演算

演算を行うメソッド

省略記法

Float オブジェクトに関する演算

恒等演算 $plus

加算 $add

インクリメント演算 $increment

反数演算 $minus

減算 $subtract

デクリメント演算 $decrement

乗算 $multiply

結合演算 $juxtapose

逆数演算 $reciprocal

除算 $divide

商演算 $quotient

剰余演算 $mod

冪算 $power

比較演算 $less

比較演算 $greater

比較演算 $lessEqual

比較演算 $greaterEqual

比較演算 $equal

比較演算 $unequal

実数の比較

`Number` オブジェクト

`Real` オブジェクト

`Integer` オブジェクト

`Rational` オブジェクト

`Float` オブジェクト

`Complex` オブジェクト

`Infinity` オブジェクト

`NaN` オブジェクト

`Float` オブジェクトの精度

結果が `Float` オブジェクトとなる場合の値の特例

`Integer` から `Rational` への拡大変換

`Integer` から `Float` への拡大変換

`Rational` から `Float` への拡大変換

`Real` から `Complex` への拡大変換

`Rational` から `Integer` への縮小変換

`Float` から `Integer` への縮小変換

`Float` から `Rational` への縮小変換

`Complex` から `Real` への縮小変換

`Float` オブジェクトに関する演算

恒等演算 `$plus`

加算 `$add`

インクリメント演算 `$increment`

反数演算 `$minus`

減算 `$subtract`

デクリメント演算 `$decrement`

乗算 `$multiply`

結合演算 `$juxtapose`

逆数演算 `$reciprocal`

除算 `$divide`

商演算 `$quotient`

剰余演算 `$mod`

冪算 `$power`

比較演算 `$less`

比較演算 `$greater`

比較演算 `$lessEqual`

比較演算 `$greaterEqual`

比較演算 `$equal`

比較演算 `$unequal`