要約
数値を表す抽象クラスです。Integer や Float などの数値クラスは Numeric のサブクラスとして実装されています。
演算や比較を行うメソッド（+, -, *, /, <=>）は Numeric のサブクラスで定義されます。Numeric で定義されているメソッドは、サブクラスで提供されているメソッド（+, -, *, /, %）を利用して定義されるものがほとんどです。つまり Numeric で定義されているメソッドは、Numeric のサブクラスとして新たに数値クラスを定義したときに、演算メソッド（+, -, *, /, %, <=>, coerce）だけを定義すれば、数値クラスのそのほかのメソッドが適切に定義されることを意図して提供されています。
+@, -@ は単項演算子 +, - を表しメソッド定義などではこの記法を利用します。
効率のため Numeric のメソッドと同じメソッドがサブクラスで再定義されている場合があります。
Numeric#coerce メソッドを使うことによって異なる数値クラス間で演算を行うこともできます。
数値関連のメソッドを実際に定義しているクラス一覧
ほとんどの数値関連のメソッドはサブクラスで再定義されています。これは、効率のためであったり上位抽象クラスで実装を定義できなかったりするためです。以下の表は 2.4.2 での一覧です。実際にどのメソッドがどのクラスに定義されているかはそれぞれのクラスを参照してください。
=> ruby 2.4.2p198 (2017-09-14 revision 59899) [x86_64-darwin15]
Numeric Integer Float Rational Complex
--------------------------------------------------------------------------------
% | o o o - -
& | - o - - -
* | - o o o o
** | - o o o o
+ | - o o o o
+@ | o - - - -
- | - o o o o
-@ | o o o o o
/ | - o o o o
< | - o o - -
Numeric Integer Float Rational Complex
--------------------------------------------------------------------------------
<< | - o - - -
<= | - o o - -
<=> | o o o o -
== | - o o o o
=== | - o o - -
> | - o o - -
>= | - o o - -
>> | - o - - -
[] | - o - - -
^ | - o - - -
Numeric Integer Float Rational Complex
--------------------------------------------------------------------------------
abs | o o o o o
abs2 | o - - - o
angle | o - o - o
arg | o - o - o
bit_length | - o - - -
ceil | o o o o -
chr | - o - - -
coerce | o o o o o
conj | o - - - o
conjugate | o - - - o
Numeric Integer Float Rational Complex
--------------------------------------------------------------------------------
denominator | o o o o o
digits | - o - - -
div | o o - - -
divmod | o o o - -
downto | - o - - -
eql? | o - o - o
even? | - o - - -
fdiv | o o o o o
finite? | o - o - o
floor | o o o o -
Numeric Integer Float Rational Complex
--------------------------------------------------------------------------------
gcd | - o - - -
gcdlcm | - o - - -
hash | - - o o o
i | o - - - -
imag | o - - - o
imaginary | o - - - o
infinite? | o - o - o
inspect | - o o o o
integer? | o o - - -
lcm | - o - - -
Numeric Integer Float Rational Complex
--------------------------------------------------------------------------------
magnitude | o o o o o
modulo | o o o - -
nan? | - - o - -
negative? | o - o o -
next | - o - - -
next_float | - - o - -
nonzero? | o - - - -
numerator | o o o o o
odd? | - o - - -
ord | - o - - -
Numeric Integer Float Rational Complex
--------------------------------------------------------------------------------
phase | o - o - o
polar | o - - - o
positive? | o - o o -
pred | - o - - -
prev_float | - - o - -
quo | o - o o o
rationalize | - o o o o
real | o - - - o
real? | o - - - o
rect | o - - - o
Numeric Integer Float Rational Complex
--------------------------------------------------------------------------------
rectangular | o - - - o
remainder | o o - - -
round | o o o o -
singleton_method_added | o - - - -
size | - o - - -
step | o - - - -
succ | - o - - -
times | - o - - -
to_c | o - - - o
to_f | - o o o o
Numeric Integer Float Rational Complex
--------------------------------------------------------------------------------
to_i | - o o o o
to_int | o o o - -
to_r | - o o o o
to_s | - o o o o
truncate | o o o o -
upto | - o - - -
zero? | o - o - -
| | - o - - -
~ | - o - - -
丸めメソッドの動作一覧
Numeric#ceil, Numeric#floor, Numeric#round, Numeric#truncate のふるまいの違いの表です。左の実数に対して各メソッドを呼ぶと表のような数を返します。
| 実数 | ceil | floor | round | truncate |
|---|---|---|---|---|
| 1.9 | 2 | 1 | 2 | 1 |
| 1.1 | 2 | 1 | 1 | 1 |
| -1.1 | -1 | -2 | -1 | -1 |
| -1.9 | -1 | -2 | -2 | -1 |
丸めメソッドの拡張例
切上げは ceil, floor を使用して以下のように定義できます。
if n > 0 then
n.ceil
else
n.floor
end
また、任意桁の切上げ、切捨て、四捨五入を行うメソッドは以下のように定義できます。
class Numeric
def roundup(d=0)
x = 10**d
if self > 0
self.quo(x).ceil * x
else
self.quo(x).floor * x
end
end
def rounddown(d=0)
x = 10**d
if self < 0
self.quo(x).ceil * x
else
self.quo(x).floor * x
end
end
def roundoff(d=0)
x = 10**d
if self < 0
(self.quo(x) - 0.5).ceil * x
else
(self.quo(x) + 0.5).floor * x
end
end
end
除法と商・剰余
Numeric には除法（除算；割り算；division）に関するメソッドがいくつもありますが、除法にはいくつか種類があるため、全貌が把握しづらくなっています。この節では除法の種類を説明し、各メソッドがどの除法に基づいているのかが分かるようにします。
まず用語についてですが、割られる数を被除数（dividend）、割る数を除数（divisor）、割った結果を商（quotient）と言います。
除法は大きく2つに分類できます。
そのうちの一つを、ここでは「普通の除法」と呼ぶことにします。普通の除法は、被除数を x、除数を y、商を q としたとき、x == q⋅y となるよう定義された除法です。
7 割る 2 を 3.5 とする除法は、普通の除法です。
普通の除法における商をここでは「普通の商」と呼ぶことにしましょう。
もう一つの除法は、商が必ず整数になるよう定義されるもので、これを「整除法」と言います。 7 割る 2 を 3 余り 1 とする除法は、整除法です。
整除法における商を特に「整商」と言います。
整除法では、被除数を x、除数を y、商を q としたとき、x と q⋅y が一致する（つまり割り切れる）とは限りません。その差 x − q⋅y を剰余（余り；remainder）と言います。整除法は商と剰余がセットで決まる除法なので「剰余付き除法」とも呼ばれます。
しばしば「整除法は整数の世界でしか成り立たない」と誤解されていますが、 2.5 メートルの紐から 0.75 メートルの紐が何本取れて何メートルの半端が出るか、という問題を考えれば、被除数や除数が整数でなくてもよいことが分かります。
例: Float の世界の整商と剰余p 2.5.divmod(0.75) # => [3, 0.25]
# 2.5 メートルの紐から 0.75 メートルの紐が 3 本取れて 0.25 メートル余る
ただし、複素数の世界では整商・剰余は考えないので、Complex に divmod などのメソッドは定義されていません。
以下では、まず普通の除法に基づくメソッドについて述べます。
普通の商を得るメソッドは Numeric#quo です。
quo の返り値のクラスは、被除数・除数のクラスによって異なります。例えば、被除数・除数の一方が Integer、他方が Float なら返り値は Float です。
普通の商を得るメソッドには、Numeric#fdiv もあります。これは商を Float で返します（被除数・除数の一方が Complex のときは Complex を返します）。
整数同士の除法の場合、quo は厳密値を Rational で返しますが、
fdiv では丸め誤差が生じうることに注意してください。
次に整除法に基づくメソッドについて述べます。
重要なことは、整除法の定義（言い換えれば整商・剰余の定義）がいくつもある、ということです。
しかし、どの定義にも共通していることが二つあります。
それは、被除数を x、除数を y としたときの整商を q、剰余を r とすると、第一に、
x == y * q + r（ただし q は整数）
が成り立つということです。第二に、剰余 r は「半端」ですから、r の絶対値は y の絶対値より小さくなくてはならないということです。
この二つを満たす整商・剰余の定義は何通りもありますが、 Ruby では、2通りの定義を採用し、剰余について Numeric#modulo メソッドと Numeric#remainder メソッドとして実装されています。
modulo は、
y > 0のとき0 <= r < yy < 0のときy < r <= 0
となるように定められた剰余です。定義からすぐ分かるとおり、剰余 r の符号は除数 y の符号と一致します。
modulo の別名は % で、普通はメソッド呼び出しの形ではなく二項演算子の形で用います。
modulo に対応する整商は Numeric#div です。これは、普通の商を Numeric#floor で整数化したものと一致します。
さきほどの例で出てきた Numeric#divmod は、
div と modulo の値を一度に配列で返すメソッドです。
一方、remainder は
x > 0のとき0 <= r < |y|x < 0のとき-|y| < r <= 0
となるように定められた剰余です。定義からすぐ分かるとおり、剰余 r の符号は被除数 x の符号と一致します。
remainder に対応する整商を得るメソッドはありませんが、
x.quo(y).truncate で得ることができます。
x と y の符号が同じとき、modulo と remainder は一致します。
商を得るメソッドには Numeric#/ もあります。普通はメソッド呼び出しの形ではなく、二項演算子として用います。これは被除数・除数のクラスによって挙動が異なります。例えば Integer 同士なら div と同じ、Integer や Rational と Float なら quo と同じ、といった具合です。被除数のクラスの / メソッドの説明をご覧ください。
Ruby 3.2 では整商を得るメソッドとして Integer#ceildiv が追加されました。
ceildiv は普通の商を正の無限大に向かって丸めた整商を返します。
n 個の物を m 個ずつまとめたとき、（半端をまとめたものも含めて）いくつのグループができるかは以下のようにして得られます。
p n.ceildiv(m)
ceildiv に対応した剰余を返すメソッドはありません。
目次
- インスタンスメソッド
継承しているメソッド
インスタンスメソッド
modulo(other) -> Numeric[permalink][rdoc][edit]self % other -> NumericRuby 1.9.3 から(Numeric) → Numeric-
selfをotherで割った余りrを返します。ここで、商
qと余りrは、self == other * q + r
と
other > 0のとき0 <= r < otherother < 0のときother < r <= 0qは整数
をみたす数です。
余り
rは、otherと同じ符号になります。商qは、Numeric#div（あるいは/）で求められます。moduloはメソッド%の呼び出しとして定義されています。Complex では未定義化されています。
- [PARAM]
other: -
selfに対する除数
p 13.modulo(4) # => 1 p (11.5).modulo(3.5) # => 1.0 p 13.modulo(-4) # => -3 p (-13).modulo(4) # => 3 p (-13).modulo(-4) # => -1 p (-11).modulo(3.5) # => 3.0[SEE_ALSO] Numeric#divmod, Numeric#remainder
+ self -> self[permalink][rdoc][edit]() → Numeric-
selfを返します。
例Numericオブジェクトに対する単項演算子+はこのメソッドの呼び出しになります。p(+ 10) # => 10 p(+ (-10)) # => -10 p(+ 0.1) # => 0.1 p(+ (3r)) # => (3/1) p(+ (1+3i)) # => (1+3i) - self -> Numeric[permalink][rdoc][edit]() → Numeric-
0からselfを引いた値を返します。selfが実数の場合、符号反転です。このメソッドは、二項演算子の
-で0 - selfとして定義されています。Numericオブジェクトに対する単項演算子-はこのメソッドの呼び出しになります。[SEE_ALSO] Integer#-@、Float#-@、Rational#-@、Complex#-@
self / other -> NumericRuby 3.0 から[permalink][rdoc][edit]-
selfをotherで割った値（＝商）を返します。Numericでは定義されておらず、サブクラスの実装によります。[SEE_ALSO] Integer#/, Float#/, Rational#/, Complex#/
self <=> other -> -1 | 0 | 1 | nil[permalink][rdoc][edit](Numeric other) → Integer-
selfをotherと比較し、selfがotherより大きければ1を、等しければ0を、小さければ-1を返します。比較できないときはnilを返します。Numericのサブクラスは必要に応じてこのメソッドを適切に再定義しなければなりません。Numericオブジェクトを左項とする比較演算子<=>はこのメソッドの呼び出しになります。- [PARAM]
other: - 比較対象
p 1 <=> 0 # => 1 p 1 <=> 1 # => 0 p 1 <=> 2 # => -1 p 1 <=> "0" # => nil - [PARAM]
abs -> Numeric[permalink][rdoc][edit]magnitude -> NumericRuby 1.9.3 から() → Numeric-
例selfの絶対値（absolute value）を返します。p 12.abs # => 12 p (-34.56).abs # => 34.56 p -34.56.abs # => 34.56 abs2 -> NumericRuby 1.9.3 から[permalink][rdoc][edit]() → Numeric-
実数に対する abs2 の例selfの絶対値（absolute value）の 2 乗を返します。
複素数に対する abs2 の例# 2 乗と結果は同じ p 2.abs2 # => 4 p -2.abs2 # => 4 p 2.0.abs2 # => 4.0 p -2.0.abs2 # => 4.0 p 0.5r.abs2 # => (1/4)# 虚部が 0 でないときは 2 乗と異なる p 2i.abs2 # => 4 p (-1+0.5i).abs2 # => 1.25Numericのサブクラスは必要に応じてこのメソッドを適切に再定義しなければなりません。 arg -> 0 | Math::PI[permalink][rdoc][edit]angle -> 0 | Math::PIRuby 1.9.3 からphase -> 0 | Math::PIRuby 1.9.3 から() → Numeric-
selfの複素数としての偏角（argument）を返します。
実数に対する arg の例selfが正の実数か0.0なら0、負の実数か-0.0なら Math::PI となります。（-0.0は Float#negative? では負とはみなされませんが、argは符号ビットに従います）。
複素数に対する arg の例p 1.arg # => 0 p 0.arg # => 0 p -1.arg # => 3.141592653589793 p -0.0.arg # => 3.141592653589793p 1i.arg # => 1.5707963267948966Numericのサブクラスは必要に応じてこのメソッドを適切に再定義しなければなりません。[SEE_ALSO] Complex#arg
ceil -> Integer[permalink][rdoc][edit]() → Integer(Integer digits) → (Integer | Numeric)-
selfと等しいかより大きな整数のうち最小のものを返します。Complex では未定義化されています。
例p 1.ceil # => 1 p 1.2.ceil # => 2 p (-1.2).ceil # => -1 p (-1.5).ceil # => -1[SEE_ALSO] Numeric#floor, Numeric#round, Numeric#truncate
coerce(other) -> [Numeric][permalink][rdoc][edit](Numeric) → [ Numeric, Numeric ]-
selfとotherが同じクラスになるよう、selfかotherを変換し[other, self]という配列にして返します。デフォルトでは
selfとotherを Float に変換して[other, self]という配列にして返します。Numericのサブクラスは必要に応じてこのメソッドを適切に再定義しなければなりません。以下は Rational の
例coerceのソースです。otherが自身の知らない数値クラスであった場合、superを呼んでいることに注意して下さい。# lib/rational.rb より def coerce(other) if other.kind_of?(Float) return other, self.to_f elsif other.kind_of?(Integer) return Rational.new!(other, 1), self else super end end数値クラスの算術演算子は通常自分と演算できないクラスをオペランドとして受け取ると
例coerceを使って自分とオペランドを変換した上で演算を行います。以下は Rational の+メソッドを一部省略したものです。引数が自身の知らない数値クラスである場合、引数の coerce によりselfを変換してから+演算子を呼んでいます。# lib/rational.rb より def + (a) if a.kind_of?(Rational) # 長いので省略 elsif a.kind_of?(Integer) # 長いので省略 elsif a.kind_of?(Float) Float(self) + a else x, y = a.coerce(self) x + y end end- [PARAM]
other: - オペランドを数値で指定します。
- [PARAM]
conj -> Numeric[permalink][rdoc][edit]conjugate -> Numeric() → Numeric-
selfを返します。Complex では
selfの共役複素数を返すよう再定義されています。
例Numericのサブクラスは必要に応じてこのメソッドを適切に再定義しなければなりません。p 10.conj # => 10 p 0.1.conj # => 0.1 p (2/3r).conj # => (2/3)[SEE_ALSO] Complex#conj
denominator -> IntegerRuby 1.9.3 から[permalink][rdoc][edit]() → Integer-
selfを Rational に変換したときの分母（denominator）を返します。[SEE_ALSO] Numeric#numerator、Integer#denominator、Float#denominator、Rational#denominator、Complex#denominator
div(other) -> Integer[permalink][rdoc][edit](Numeric) → Integer-
selfをotherで割った整数の商qを返します。ここで、商
qと余りrは、それぞれself == other * q + r
と
other > 0のとき:0 <= r < otherother < 0のとき:other < r <= 0qは整数
をみたす数です。商に対応する余りは Numeric#modulo で求められます。
divはメソッド/を呼びだし、floorを取ることで計算されます。メソッド
/の定義はサブクラスごとの定義を用います。Complex では未定義化されています。
- [PARAM]
other: -
selfに対する除数
p 3.div(2) # => 1 p (-3).div(2) # => -2 p (-3.0).div(2) # => -2 divmod(other) -> [Numeric][permalink][rdoc][edit](Numeric) → [ Numeric, Numeric ]-
selfをotherで割った商qと余りrを、[q, r]という 2 要素の配列にして返します。商qは常に整数ですが、余りrは整数であるとは限りません。ここで、商
qと余りrは、self == other * q + r
と
other > 0のとき:0 <= r < otherother < 0のとき:other < r <= 0qは整数
をみたす数です。
divmodが返す商は Numeric#div と同じです。また余りは、Numeric#modulo と同じです。このメソッドは、メソッド/と%によって定義されています。Complex では未定義化されています。
- [PARAM]
other: -
selfに対する除数
p 11.divmod(3) # => [3, 2] p (11.5).divmod(3.5) # => [3, 1.0] p 11.divmod(-3) # => [-4, -1] p 11.divmod(3.5) # => [3, 0.5] p (-11).divmod(3.5) # => [-4, 3.0][SEE_ALSO] Numeric#div, Numeric#modulo
eql?(other) -> bool[permalink][rdoc][edit](untyped) → bool-
selfとotherのクラスが等しくかつ==メソッドで比較して等しい場合にtrueを返します。そうでない場合にfalseを返します。Numericのサブクラスは、eql?で比較して等しい数値同士が同じハッシュ値を返すようにhashメソッドを適切に定義する必要があります。- [PARAM]
other: - 比較対象
p 1.eql?(1) # => true p 1.eql?(1.0) # => false p 1 == 1.0 # => true[SEE_ALSO] Object#equal?, Object#eql?, Object#==, Object#===
- [PARAM]
fdiv(other) -> Float | Complex[permalink][rdoc][edit](Numeric) → Numeric-
selfをotherで割った商を Float で返します。ただし Complex が関わる場合は例外です。その場合も成分はFloatになります。selfが Integer や Rational で、otherが虚部を持つ Complex の場合は、商を Float に変換できないため RangeError が発生します。Numericのサブクラスは必要に応じてこのメソッドを適切に再定義しなければなりません。- [PARAM]
other: -
selfに対する除数
p 1.fdiv(3) # => 0.3333333333333333 p (1+1i).fdiv 1 # => (1.0+1.0i) 1.fdiv(1+1i) # ~> RangeError: can't convert 0.5-0.5i into Float[SEE_ALSO] Numeric#quo
- [PARAM]
finite? -> boolRuby 2.4.0 から[permalink][rdoc][edit]() → bool-
例selfの絶対値が有限値ならtrueを、そうでないならfalseを返します。p 10.finite? # => true p 3r.finite? # => true p Float::INFINITY.finite? # => false p Float::INFINITY.is_a?(Numeric) # => true[SEE_ALSO] Numeric#infinite?
floor(ndigits = 0) -> Integer[permalink][rdoc][edit]() → Integer(Integer digits) → Numeric-
selfと等しいかより小さな整数のうち最大のものを返します。Complex では未定義化されています。
- [PARAM]
ndigits: -
10進数での小数点以下の有効桁数を整数で指定します。負の整数を指定した場合、小数点位置から左に少なくとも
n個の0が並びます。
p 1.floor # => 1 p 1.2.floor # => 1 p (-1.2).floor # => -2 p (-1.5).floor # => -2[SEE_ALSO] Numeric#ceil, Numeric#round, Numeric#truncate
[SEE_ALSO] Integer#floor
- [PARAM]
i -> ComplexRuby 1.9.3 から[permalink][rdoc][edit]() → Complex-
Complex(0, self)を返します。Complex では未定義化されています。
例p 10.i # => (0+10i) p -10.i # => (0-10i) p (0.1).i # => (0+0.1i) p (1/2r).i # => (0+(1/2)*i) imag -> 0[permalink][rdoc][edit]imaginary -> 0Ruby 1.9.3 から() → Numeric-
0を返します。Complex では
例selfの虚部を返すよう再定義されています。p 12.imag # => 0 p -12.imag # => 0 p 1.2.imag # => 0 p -1.2.imag # => 0Numericのサブクラスは必要に応じてこのメソッドを適切に再定義しなければなりません。[SEE_ALSO] Numeric#real、Complex#imag
infinite? -> nilRuby 2.4.0 から[permalink][rdoc][edit]() → Integer?-
nilを返します。Float と Complex では、
例selfの絶対値が負の無限大の場合に-1を、正の無限大の場合に1を、有限値の場合にnilを返すよう再定義されています。p 10.infinite? # => nil p (3r).infinite? # => nil[SEE_ALSO] Numeric#finite?、Float#infinite?、Complex#infinite?
integer? -> bool[permalink][rdoc][edit]() → bool-
falseを返します。Integer では
trueを返すよう再定義されています。数値として整数であるかを問うものではありません。
true を返す例Numericのサブクラスは必要に応じてこのメソッドを適切に再定義しなければなりません。
数学的には整数でも false を返す例p 1.integer? # => truep 1.0.integer? # => false p 1r.integer? # => false p (1+0i).integer? # => false[SEE_ALSO] Numeric#real?
negative? -> boolRuby 2.3.0 から[permalink][rdoc][edit]() → bool-
selfが負の数ならtrueを、そうでないならfalseを返します。一般の複素数には正・負の概念が無いので Complex では未定義化されています。
例p -1.negative? # => true p 0.negative? # => false p 1.negative? # => false[SEE_ALSO] Numeric#positive?
nonzero? -> self | nil[permalink][rdoc][edit]() → self?-
例selfが非ゼロならselfを、ゼロならnilを返します。p 10.nonzero? # => 10 p 0.nonzero? # => nil p 0.0.nonzero? # => nil p 0r.nonzero? # => nil非ゼロのときに
例selfを返すので、selfがゼロのときに他の処理をさせたければ以下のように書けます。a = %w[z Bb bB bb BB a aA Aa AA A] b = a.sort { |a, b| (a.downcase <=> b.downcase).nonzero? || a <=> b } p b # => ["A", "a", "AA", "Aa", "aA", "BB", "Bb", "bB", "bb", "z"][SEE_ALSO] Numeric#zero?
numerator -> IntegerRuby 1.9.3 から[permalink][rdoc][edit]() → Numeric-
selfを Rational に変換したときの分子（numerator）を返します。[SEE_ALSO] Numeric#denominator、Integer#numerator、Float#numerator、Rational#numerator、Complex#numerator
polar -> [Numeric, Numeric]Ruby 1.9.3 から[permalink][rdoc][edit]() → [ Numeric, Numeric ]-
例selfの複素数としての極形式（polar form）を[self.abs, self.arg]として返します。p 1.0.polar # => [1.0, 0] p 2.0.polar # => [2.0, 0] p -1.0.polar # => [1.0, 3.141592653589793] p -2.0.polar # => [2.0, 3.141592653589793]Numericのサブクラスは必要に応じてこのメソッドを適切に再定義しなければなりません。[SEE_ALSO] Complex#polar
positive? -> boolRuby 2.3.0 から[permalink][rdoc][edit]() → bool-
selfが正の数ならtrueを、そうでないならfalseを返します。一般の複素数には正・負の概念が無いので Complex では未定義化されています。
例p 1.positive? # => true p 0.positive? # => false p -1.positive? # => false[SEE_ALSO] Numeric#negative?
quo(other) -> Rational | Float | Complex[permalink][rdoc][edit](Numeric) → Numeric-
selfをotherで割った商（quotient）を返します。整商を得たい場合は Numeric#div を使ってください。Numeric#fdiv が結果を Float で返すメソッドなのに対して
quoはなるべく正確な数値を返すことを意図しています。具体的には有理数の範囲に収まる計算では Rational の値を返します。 Float や Complex が関わるときはそれらのクラスになります。Numericのサブクラスは必要に応じてこのメソッドを適切に再定義しなければなりません。- [PARAM]
other: -
selfに対する除数
p 1.quo(3) # => (1/3) p 1.0.quo(3) # => 0.3333333333333333 p 1.quo(3.0) # => 0.3333333333333333 p 1.quo(0.5) # => 2.0 p (1+1i).quo(1) # => (1+1i) p 1.quo(1+1i) # => ((1/2)-(1/2)*i)[SEE_ALSO] Numeric#fdiv
- [PARAM]
real -> Numeric[permalink][rdoc][edit]() → Numeric-
selfを返します。Complex では
selfの実部を返すよう再定義されています。
例Numericのサブクラスは必要に応じてこのメソッドを適切に再定義しなければなりません。p 10.real # => 10 p -10.real # => -10 p 0.1.real # => 0.1 p (2/3r).real # => (2/3)[SEE_ALSO] Numeric#imag、Complex#real
real? -> boolRuby 1.9.3 から[permalink][rdoc][edit]() → bool-
trueを返します。Complex では
falseを返すよう再定義されています。つまり、
selfが「実数を表すクラスのインスタンス」であればtrueを、そうでなければfalseを返すものです。「実数であるか」を返すものではありません（例参照）。
true を返す例Numericのサブクラスは必要に応じてこのメソッドを適切に再定義しなければなりません。
false を返す例# Integer, Float, Rational のインスタンスは `true` を返す p -10.real? # => true p 0.1.real? # => true p (2/3r).real? # => true# Complex のインスタンスはたとえ虚部がゼロでも `false` を返す p Complex(1, 0).real? # => false[SEE_ALSO] Numeric#integer?、Complex#real?
rect -> [Numeric, Numeric]Ruby 1.9.3 から[permalink][rdoc][edit]rectangular -> [Numeric, Numeric]() → [ Numeric, Numeric ]-
[self, 0]を返します。Complex では
[self.real, self.imag]を返すよう再定義されています。つまり
例selfの直交形式（rectangular form）を[実部, 虚部]の形で返すメソッドです。p 1.rect # => [1, 0] p -1.rect # => [-1, 0] p 1.0.rect # => [1.0, 0] p -1.0.rect # => [-1.0, 0]Numericのサブクラスは必要に応じてこのメソッドを適切に再定義しなければなりません。[SEE_ALSO] Complex#rect
remainder(other) -> Numeric[permalink][rdoc][edit](Numeric) → Numeric-
selfをotherで割った余りrを返します。ここで、商
qと余りrは、self == other * q + r
と
self > 0のとき0 <= r < |other|self < 0のとき-|other| < r <= 0qは整数
をみたす数です。
rの符号はselfと同じになります。商qを直接返すメソッドはありません。self.quo(other).truncateがそれに相当します。Complex では未定義化されています。
- [PARAM]
other: -
selfに対する除数
p 13.remainder(4) # => 1 p (11.5).remainder(3.5) # => 1.0 p 13.remainder(-4) # => 1 p (-13).remainder(4) # => -1 p (-13).remainder(-4) # => -1 p (-11).remainder(3.5) # => -0.5[SEE_ALSO] Numeric#divmod, Numeric#modulo
round -> Integer[permalink][rdoc][edit]() → Integer(Integer digits) → Numeric-
selfともっとも近い整数を返します。中央値
0.5,-0.5はそれぞれ1,-1に切り上げされます。いわゆる四捨五入ですが、偶数丸めではありません。Complex では未定義化されています。
例p 1.round # => 1 p 1.2.round # => 1 p (-1.2).round # => -1 p (-1.5).round # => -2[SEE_ALSO] Numeric#ceil, Numeric#floor, Numeric#truncate
step(limit, step = 1) {|n| ... } -> self[permalink][rdoc][edit]step(limit, step = 1) -> Enumeratorstep(limit, step = 1) -> Enumerator::ArithmeticSequencestep(by: 1, to: Float::INFINITY) {|n| ... } -> selfstep(by: 1, to: Float::INFINITY) -> Enumeratorstep(by: 1, to: Float::INFINITY) -> Enumerator::ArithmeticSequencestep(by:, to: -Float::INFINITY) {|n| ... } -> selfstep(by:, to: -Float::INFINITY) -> Enumeratorstep(by:, to: -Float::INFINITY) -> Enumerator::ArithmeticSequence(?Numeric limit, ?Numeric step) { (Numeric) → void } → self(?Numeric limit, ?Numeric step) → Enumerator[Numeric, self](?by: Numeric, ?to: Numeric) { (Numeric) → void } → self(?by: Numeric, ?to: Numeric) → Enumerator[Numeric, self]-
selfから始め、stepを足しながらlimitを越える前までブロックを繰り返します。stepは負の数も指定できます。また、limitやstepには Float なども指定できます。Complex では未定義化されています。
- [PARAM]
limit: -
ループの上限あるいは下限を数値で指定します。
stepに負の数が指定された場合は、下限として解釈されます。 - [PARAM]
step: - 各ステップの大きさを数値で指定します。負の数を指定することもできます。
- [PARAM]
to: -
引数
limitと同じですが、省略した場合はキーワード引数byが正の数ならFloat::INFINITYを、負の数なら-Float::INFINITYを指定したとみなされます。 - [PARAM]
by: -
引数
stepと同じです。 - [RETURN]
-
ブロックが与えられたときは
selfを返します。 - [RETURN]
- ブロックが与えられなかったときは Enumerator を返します。
- [RETURN]
-
特に
limit（またはto）とstepの両方がNumericまたはnilのときは Enumerator::ArithmeticSequence を返します。 - [EXCEPTION]
ArgumentError: -
stepに0を指定した場合に発生します。
2.step(5) { |n| p n } # => 2 # 3 # 4 # 5 1.1.step(1.5, 0.1) { |n| p n } # => 1.1 # 1.2000000000000002 # 1.3 # 1.4000000000000001 # 1.5 10.step(6, -1) { |n| p n } # => 10 # 9 # 8 # 7 # 6 3.step(by:2, to:10) { |n| p n } # => 3 # 5 # 7 # 9注：0.1 は 2 進法の浮動小数点数では正確な表現ができない（2 進法で 0.1 は 0.00011001100.... となる）ので、以下のようなループでは誤差が生じて意図した回数ループしないことがある。
例stepはこの誤差を考慮して実装されている。i = 1.1 while i <= 1.5 p i i += 0.1 end # => 1.1 # 1.2000000000000002 # 1.3000000000000003 # 1.4000000000000004 # 1.5 が表示されない[SEE_ALSO] Integer#downto
- [PARAM]
to_c -> ComplexRuby 1.9.3 から[permalink][rdoc][edit]() → Complex-
Complex(self, 0)を返します。Complex では
selfを返すよう再定義されています。つまり、
例selfを Complex に型変換するメソッドです。p 1.to_c # => (1+0i) p -1.to_c # => (-1+0i) p 1.0.to_c # => (1.0+0i) p (1/2r).to_c # => ((1/2)+0i)Numericのサブクラスは必要に応じてこのメソッドを適切に再定義しなければなりません。 to_int -> Integer[permalink][rdoc][edit]() → Integer-
例self.to_iと同じです。p (2+0i).to_int # => 2 p 3r.to_int # => 3 truncate -> Integer[permalink][rdoc][edit]() → Integer(Integer ndigits) → (Integer | Numeric)-
0からselfまでの整数で、selfにもっとも近い整数を返します。Complex では未定義化されています。
例p 1.truncate # => 1 p 1.2.truncate # => 1 p (-1.2).truncate # => -1 p (-1.5).truncate # => -1[SEE_ALSO] Numeric#ceil, Numeric#floor, Numeric#round
zero? -> bool[permalink][rdoc][edit]() → bool-
例selfがゼロならtrueを、そうでないならfalseを返します。p 10.zero? # => false p 0.zero? # => true p 0.0.zero? # => true[SEE_ALSO] Numeric#nonzero?
