Ruby 1.8.7 リファレンスマニュアル > ライブラリ一覧 > bigdecimalライブラリ > BigDecimalクラス

class BigDecimal + Numeric + Comparable + Object

クラスの継承リスト: BigDecimal < Numeric < Comparable < Object < Kernel

要約

特異メソッド

_load(str)

[TODO]

double_fig

[TODO]

Ruby の Float クラスが保持できる有効数字の数を返します。

p BigDecimal::double_fig  # ==> 20 (depends on the CPU etc.)

double_figは以下の C プログラムの結果と同じです。

double v = 1.0;
int double_fig = 0;
while (v + 1.0 > 1.0) {
   ++double_fig;
   v /= 10;
}

induced_from(x)

[TODO]

limit([n])

[TODO]

生成されるBigDecimalオブジェクトの最大桁数をn桁に制限します。戻り値は設定する前の値です。設定値のデフォルト値は0で、桁数無制限という意味です。 n を指定しない、または n が nil の場合は、現状の最大桁数が返ります。計算を続行する間に、数字の桁数が無制限に増えてしまうような場合 limit で予め桁数を制限できます。この場合 BigDecimal.mode で指定された丸め処理が実行されます。ただし、インスタンスメソッド (BigDecimal#truncate / BigDecimal#round / BigDecimal#ceil / BigDecimal#floor / BigDecimal#add/ BigDecimal#sub / BigDecimal#mult / BigDecimal#div) の桁数制限は limit より優先されます。

mf = BigDecimal::limit(n)

mode(s [, v])

[TODO]

BigDecimalの実行結果を制御します。第2引数を省略、または nil を指定すると現状の設定値が戻ります。以下の使用方法が定義されています。

例外処理

計算結果が非数(NaN)やゼロによる除算になったときの処理を定義することができます。

f = BigDecimal::mode(BigDecimal::EXCEPTION_NaN,flag)
f = BigDecimal::mode(BigDecimal::EXCEPTION_INFINITY,flag)
f = BigDecimal::mode(BigDecimal::EXCEPTION_UNDERFLOW,flag)
f = BigDecimal::mode(BigDecimal::EXCEPTION_OVERFLOW,flag)
f = BigDecimal::mode(BigDecimal::EXCEPTION_ZERODIVIDE,flag)
f = BigDecimal::mode(BigDecimal::EXCEPTION_ALL,flag)

BigDecimal::EXCEPTION_NaN は結果が NaN になったときの指定です。
BigDecimal::EXCEPTION_INFINITY は結果が無限大(±Infinity)になったときの指定です。
BigDecimal::EXCEPTION_UNDERFLOW は指数部がアンダーフローするときの指定です。
BigDecimal::EXCEPTION_OVERFLOW は指数部がオーバーフローするときの指定です。
BigDecimal::EXCEPTION_ZERODIVIDE はゼロによる割り算を実行したときの指定です。
BigDecimal::EXCEPTION_ALL は、可能な全てに対して一括して設定するときに使用します。

flag が true のときは、指定した状態になったときに例外を発行するようになります。 flag が false(デフォルト)なら、例外は発行されません。計算結果は以下のようになります。

BigDecimal::EXCEPTION_NaN のとき、非数(NaN)
BigDecimal::EXCEPTION_INFINITY のとき、無限(+ or -Infinity)
BigDecimal::EXCEPTION_UNDERFLOW のとき、ゼロ
BigDecimal::EXCEPTION_OVERFLOW のとき、+Infinity か -Infinity
BigDecimal::EXCEPTION_ZERODIVIDE のとき、+Infinity か -Infinity

BigDecimal::EXCEPTION_INFINITY、BigDecimal::EXCEPTION_OVERFLOW、 BigDecimal::EXCEPTION_ZERODIVIDE は今のところ同じです。戻り値は、設定後の値です。「値」の意味は、例えば BigDecimal::EXCEPTION_NaN と「値」の & がゼロ以外ならば BigDecimal::EXCEPTION_NaNが設定されているという意味です。

丸め処理指定

計算途中の丸め操作の指定ができます。

f = BigDecimal::mode(BigDecimal::ROUND_MODE,flag)

の形式で指定します。ここで、flag は以下(括弧内は対応するインスタンスメソッド)の一つを指定します。

BigDecimal::ROUND_UP 全て切り上げます。
BigDecimal::ROUND_DOWN 全て切り捨てます(truncate)。
BigDecimal::ROUND_HALF_UP 四捨五入します(デフォルト)。
BigDecimal::ROUND_HALF_DOWN 五捨六入します。
BigDecimal::ROUND_HALF_EVEN 四捨六入します。5の時は上位1桁が奇数の時のみ繰り上げます(Banker's rounding)。
BigDecimal::ROUND_CEILING 数値の大きい方に繰り上げます(ceil)。
BigDecimal::ROUND_FLOOR 数値の小さい方に繰り下げます(floor)。

戻り値は指定後の flag の値です。第2引数に nil を指定すると、現状の設定値が返ります。 mode メソッドでは丸め操作の位置をユーザが指定することはできません。丸め操作と位置を自分で制御したい場合は BigDecimal::limit や truncate/round/ceil/floor、 add/sub/mult/div といったインスタンスメソッドを使用して下さい。

new(s [, n])

[TODO]

新しい BigDecimal オブジェクトを生成します。 s は数字を表現する初期値を文字列で指定します。スペースは無視されます。また、判断できない文字が出現した時点で文字列は終了したものとみなされます。 n は必要な有効桁数(a の最大有効桁数)を整数で指定します。 n が 0 または省略されたときは、n の値は s の有効桁数とみなされます。 s の有効桁数より n が小さいときも n=0 のときと同じです。 a の最大有効桁数は n より若干大い値が採用されます。最大有効桁数は以下のような割り算を実行するとき等に意味を持ちます。

BigDecimal("1")    / BigDecimal("3")    # => 0.3333333333 33E0
BigDecimal("1",10) / BigDecimal("3",10) # => 0.3333333333 3333333333 33333333E0

ただし、個々の演算における最大有効桁数 n の取り扱いは将来のバージョンで若干変更される可能性があります。

new -> Object

Objectクラスのインスタンスを生成して返します。

some = Object.new
p some #=> #<Object:0x2b696d8>

ver

[TODO]

インスタンスメソッド

self % n

[TODO]

詳細は Float#% を参照して下さい。

self * other

[TODO]

乗算 (c = a * b)。

c の精度は (a の精度) + (b の精度) 程度です。詳しくは「計算精度について」を参照してください。

self ** n

[TODO]

a の n 乗を計算します。n は整数。

c = a ** n

結果として c の有効桁は a の n 倍以上になるので注意。

self + other

[TODO]

加算 (c = a + b)。

c の精度については「計算精度について」を参照してください。

+

[TODO]

+ -> self

単項演算子の + です。 self を返します。

self - other

[TODO]

減算 (c = a - b)、または符号反転 (c = -a)。

c の精度については「計算精度について」を参照してください。

-

[TODO]

- -> Numeric

単項演算子の - です。 self の符号を反転させたものを返します。

このメソッドは、二項演算子 - で 0 - self によって定義されています。

self / other

[TODO]

除算 (c = a / b)。

c の精度については「計算精度について」を参照してください。

self < other

[TODO]

self < other -> bool

比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が負の整数を返した場合に、true を返します。それ以外の整数を返した場合に、false を返します。

[PARAM] other:: 自身と比較したいオブジェクトを指定します。
[EXCEPTION] ArgumentError:: <=> が nil を返したときに発生します。

self <= other

[TODO]

self <= other -> bool

比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が負の整数か 0 を返した場合に、true を返します。それ以外の整数を返した場合に、false を返します。

[PARAM] other:: 自身と比較したいオブジェクトを指定します。
[EXCEPTION] ArgumentError:: <=> が nil を返したときに発生します。

self <=> other

[TODO]

a == b なら 0、a > b なら 1、a < b なら -1 になります。

c = a <=> b

self <=> other -> -1 | 0 | 1 | nil

自身が other より大きい場合に 1 を、等しい場合に 0 を、小さい場合には -1 をそれぞれ返します。自身と other が比較できない場合には nil を返します。

Numeric のサブクラスは、上の動作を満たすようこのメソッドを適切に再定義しなければなりません。

[PARAM] other:: 自身と比較したい数値を指定します。

1 <=> 0   #=> 1
1 <=> 1   #=> 0
1 <=> 2   #=> -1
1 <=> "0" #=> nil

self == other

[TODO]

self == other -> bool | nil

比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が 0 を返した時に、true を返します。それ以外を返した場合は、false を返します。

<=> が nil を返した場合は、 nil を返します。

[PARAM] other:: 自身と比較したいオブジェクトを指定します。

self == other -> bool

オブジェクトと other が等しければ真を返します。

このメソッドは各クラスの性質に合わせて再定義すべきです。多くの場合、オブジェクトの内容が等しければ真を返すように（同値性を判定するように）再定義されることが期待されています。

デフォルトでは equal? と同じオブジェクトの同一性判定になっています。

[PARAM] other:: 比較するオブジェクトです。

p("foo" == "bar") #=> false
p("foo" == "foo") #=> true

p(4 == 4) #=> true
p(4 == 4.0) #=> true

[SEE_ALSO] Object#equal?,Object#eql?

self === other

[TODO]

self === other -> bool

メソッド Object#== の別名です。 case 式で使用されます。このメソッドは case 式での振る舞いを考慮して、各クラスの性質に合わせて再定義すべきです。

一般的に所属性のチェックを実現するため適宜再定義されます。

when 節の式をレシーバーとして === を呼び出すことに注意してください。

また Enumerable#grep でも使用されます。

[PARAM] other:: 比較するオブジェクトです。

age = 12
result =
case age
when 0 .. 2
  "baby"
when 3 .. 6
  "little child"
when 7 .. 12
  "child"
when 13 .. 18
  "youth"
else
  "adult"
end

puts result #=> "child"

def check arg
  case arg
  when /ruby(?!\s*on\s*rails)/i
    "hit! #{arg}"
  when String
    "Instance of String class. But don't hit."
  else
    "unknown"
  end
end

puts check([]) #=> unknown
puts check("mash-up in Ruby on Rails") #=> instance of String class. But not hit...
puts check("<Ruby's world>") #=> hit! <Ruby's world>

[SEE_ALSO] Object#==, Range#===, Module#===, Enumerable#grep

self =~ other -> false

右辺に正規表現オブジェクトを置いた正規表現マッチ obj =~ /RE/ をサポートするためのメソッドです。常に false を返します。

この定義により、=~ が再定義されたオブジェクトでは正常にマッチを行い、それ以外のものは false を返すようになります。

[PARAM] other:: 任意のオブジェクトです。結果に影響しません。

obj = 'regexp'
p(obj =~ /re/) #=> 0

obj = nil
p(obj =~ /re/) #=> false

[SEE_ALSO] String#=~

self > other

[TODO]

self > other -> bool

比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が正の整数を返した場合に、true を返します。それ以外の整数を返した場合に、false を返します。

[PARAM] other:: 自身と比較したいオブジェクトを指定します。
[EXCEPTION] ArgumentError:: <=> が nil を返したときに発生します。

self >= other

[TODO]

self >= other -> bool

比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が正の整数か 0 を返した場合に、true を返します。それ以外の整数を返した場合に、false を返します。

[PARAM] other:: 自身と比較したいオブジェクトを指定します。
[EXCEPTION] ArgumentError:: <=> が nil を返したときに発生します。

__id__ -> Integer

object_id -> Integer

id -> Integer

各オブジェクトに対して一意な整数を返します。あるオブジェクトに対してどのような整数が割り当てられるかは不定です。

Rubyでは、(Garbage Collectされていない)アクティブなオブジェクト間で重複しない整数(object_id)が各オブジェクトにひとつずつ割り当てられています。このメソッドはその値を返します。

TrueClass, FalseClass, NilClass, Symbol, Fixnum クラスのインスタンスなど Immutable（変更不可）なオブジェクトの一部は同じ内容ならば必ず同じ object_id になります。

これは、Immutable ならば複数の場所から参照されても`破壊的操作'による問題が発生しないので、同じ内容のインスタンスを複数生成しないという内部実装が理由です。

Symbol#to_iで得られる整数と object_id は別物です。

id メソッドの再定義に備えて別名 __id__ が用意されており、ライブラリでは後者の利用が推奨されます。また __id__ を再定義すべきではありません。

id は obsolete なので、object_id か __id__ を使用してください。

p "ruby".object_id #=> 22759500
p "ruby".object_id #=> 22759400

p [].object_id #=> 22759360
p [].object_id #=> 22759340

p :ruby.object_id #=> 103538
p :ruby.object_id #=> 103538

p 11.object_id #=> 23
p 11.object_id #=> 23

p true.object_id #=> 2
p true.object_id #=> 2

[SEE_ALSO] Object#equal?,Symbol

send(name, *args) -> object

send(name, *args) { .... } -> object

__send__(name, *args) -> object

__send__(name, *args) { .... } -> object

オブジェクトのメソッド name を args を引数にして呼び出し、メソッドの実行結果を返します。

ブロック付きで呼ばれたときはブロックもそのまま引き渡します。

send が再定義された場合に備えて別名 __send__ も用意されており、ライブラリではこちらを使うべきです。また __send__ は再定義すべきではありません。

send, __send__ は、メソッドの呼び出し制限にかかわらず任意のメソッドを呼び出せます。クラス／メソッドの定義/呼び出し制限も参照してください。

[PARAM] name:: 文字列かSymbol で指定するメソッド名です。
[PARAM] args:: 呼び出すメソッドに渡す引数です。

p -365.send(:abs) #=> 365
p "ruby".send(:sub,/./,"R") #=> "Ruby"


class Foo
  def foo() "foo" end
  def bar() "bar" end
  def baz() "baz" end
end

# 任意のキーとメソッド(の名前)の関係をハッシュに保持しておく
# レシーバの情報がここにはないことに注意
methods = {1 => :foo,
  2 => :bar,
  3 => :baz}

# キーを使って関連するメソッドを呼び出す
# レシーバは任意(Foo クラスのインスタンスである必要もない)
p Foo.new.send(methods[1])      # => "foo"
p Foo.new.send(methods[2])      # => "bar"
p Foo.new.send(methods[3])      # => "baz"

[SEE_ALSO] Object#method, Kernel.#eval, Proc, Method

_dump

[TODO]

_dump(limit) -> String

Marshal.#dump において出力するオブジェクトがメソッド _dump を定義している場合には、そのメソッドの結果が書き出されます。

バージョン1.8.0以降ではObject#marshal_dump, Object#marshal_loadの使用が推奨されます。 Marshal.dump するオブジェクトが _dump と marshal_dump の両方のメソッドを持つ場合は marshal_dump が優先されます。

メソッド _dump は引数として再帰を制限するレベル limit を受け取り、オブジェクトを文字列化したものを返します。

インスタンスがメソッド _dump を持つクラスは必ず同じフォーマットを読み戻すクラスメソッド _load を定義する必要があります。_load はオブジェクトを表現した文字列を受け取り、それをオブジェクトに戻したものを返す必要があります。

[PARAM] limit:: 再帰の制限レベルを表す整数です。
[RETURN]: オブジェクトを文字列化したものを返すように定義すべきです。

class Foo
  def initialize(arg)
    @foo = arg
  end
  def _dump(limit)
    Marshal.dump(@foo, limit)
  end
  def self._load(obj)
    p obj
    Foo.new(Marshal.load(obj))
  end
end
foo = Foo.new(['foo', 'bar'])
p foo                      #=> #<Foo:0xbaf234 @foo=["foo", "bar"]>
dms = Marshal.dump(foo)
p dms                      #=> "\004\bu:\bFoo\023\004\b[\a\"\bfoo\"\bbar"
result = Marshal.load(dms) #=> "\004\b[\a\"\bfoo\"\bbar" # self._load の引数
p result                   #=> #<Foo:0xbaf07c @foo=["foo", "bar"]>

インスタンス変数の情報は普通マーシャルデータに含まれるので、上例のように _dump を定義する必要はありません(ただし _dump を定義するとインスタンス変数の情報は dump されなくなります)。 _dump/_load はより高度な制御を行いたい場合や拡張ライブラリで定義したクラスのインスタンスがインスタンス変数以外に情報を保持する場合に利用します。(例えば、クラス Time は、_dump/_load を定義しています)

[SEE_ALSO] Object#marshal_dump,Object#marshal_load

abs

[TODO]

a の絶対値

c = a.abs

abs -> Numeric

自身が 0 以上ならば self を、そうでない場合は -self を返します。

add(b, n)

[TODO]

以下のように使用します。

c = a.add(b, n)

c = a + b を最大で n 桁まで計算します。 a + b の精度が n より大きいときは BigDecimal.mode で指定された方法で丸められます。 n がゼロなら + と同じです。

between?(min, max) -> bool

比較演算子 <=> をもとに self が min と max の範囲内(min, max を含みます)にあるかを判断します。

以下のコードと同じです。

self >= min and self <= max

[PARAM] min:: 範囲の下端を表すオブジェクトを指定します。
[PARAM] max:: 範囲の上端を表すオブジェクトを指定します。
[EXCEPTION] ArgumentError:: self <=> min か、self <=> max が nil を返したときに発生します。

3.between?(1, 5)               #=> true
6.between?(1, 5)               #=> false
'cat'.between?('ant', 'dog')   #=> true
'gnu'.between?('ant', 'dog')   #=> false

ceil([n])

[TODO]

a 以上の整数のうち、最も小さい整数を計算し、その値 (BigDecimal 値)を返します。

c = BigDecimal("1.23456").ceil   # => 2
c = BigDecimal("-1.23456").ceil  # => -1

以下のように引数を与えて、小数点以下 n+1 位の数字を操作することもできます。 n >= 0 なら、小数点以下 n + 1 位の数字を操作します (小数点以下を、最大 n 桁にします)。 n が負のときは小数点以上 n 桁目を操作します (小数点位置から左に少なくとも n 個の 0 が並びます)。

c = BigDecimal("1.23456").ceil(4)    # => 1.2346
c = BigDecimal("15.23456").ceil(-1)  # => 20.0

ceil -> Integer

自身と等しいかより大きな整数のうち最小のものを返します。

1.ceil        #=> 1
1.2.ceil      #=> 2
(-1.2).ceil   #=> -1
(-1.5).ceil   #=> -1

[SEE_ALSO] Numeric#floor, Numeric#round, Numeric#truncate

class -> Class

type -> Class

レシーバのクラスを返します。

p "ruby".class #=> String
p 999999999999999.class #=> Bignum
p ARGV.class #=> Array
p self.class #=> Object
p Class.class #=> Class
p Kernel.class #=> Module

[SEE_ALSO] Class#superclass,Object#kind_of?,Object#instance_of?

clone -> object

dup -> object

オブジェクトの複製を作成して返します。

dup はオブジェクトの内容, taint 情報をコピーし、 clone はそれに加えて freeze, 特異メソッドなどの情報も含めた完全な複製を作成します。

clone や dup は浅い(shallow)コピーであることに注意してください。後述。

[EXCEPTION] TypeError:: TrueClass, FalseClass, NilClass, Symbol, そして Numeric クラスのインスタンスなど一部のオブジェクトを複製しようとすると発生します。

obj = "string"
obj.taint
def obj.fuga
end
obj.freeze

p(obj.equal?(obj))          #=> true
p(obj == obj)               #=> true
p(obj.tainted?)             #=> true
p(obj.frozen?)              #=> true
p(obj.respond_to?(:fuga))   #=> true

obj_c = obj.clone

p(obj.equal?(obj_c))        #=> false
p(obj == obj_c)             #=> true
p(obj_c.tainted?)           #=> true
p(obj_c.frozen?)            #=> true
p(obj_c.respond_to?(:fuga)) #=> true

obj_d = obj.dup

p(obj.equal?(obj_d))        #=> false
p(obj == obj_d)             #=> true
p(obj_d.tainted?)           #=> true
p(obj_d.frozen?)            #=> false
p(obj_d.respond_to?(:fuga)) #=> false

[SEE_ALSO] Object#initialize_copy

深いコピーと浅いコピー

clone や dup はオブジェクト自身を複製するだけで、オブジェクトの指している先(たとえば配列の要素など)までは複製しません。これを浅いコピー(shallow copy)といいます。

深い(deep)コピーが必要な場合には、 Marshalモジュールを利用して

Marshal.load(Marshal.dump(obj))

このように複製を作成する方法があります。ただしMarshal出来ないオブジェクトが含まれている場合には使えません。

obj = ["a","b","c"]

obj_d = obj.dup
obj_d[0] << "PLUS"

p obj   #=> ["aPLUS", "b", "c"]
p obj_d #=> ["aPLUS", "b", "c"]

obj_m = Marshal.load(Marshal.dump(obj))
obj_m[1] << "PLUS"

p obj   #=> ["aPLUS", "b", "c"]
p obj_m #=> ["aPLUS", "bPLUS", "c"]

coerce

[TODO]

coerce(other) -> [Numeric]

自身と other が同じクラスになるよう、自身か 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 により自身を変換してから + 演算子を呼んでいます。

# 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:: オペランドを数値で指定します。

display(out = $stdout) -> nil

オブジェクトを out に出力します。

以下のように定義されています。

class Object
  def display(out = $stdout)
    out.print self.to_s
    nil
  end
end

[PARAM] out:: 出力先のIOオブジェクトです。指定しない場合は標準出力に出力されます。
[RETURN]: nil を返します。

Object.new.display #=> #<Object:0xbb0210>

[SEE_ALSO] $stdout

div(b [, n])

[TODO]

以下のように使用します。

c = a.div(b,n)

c = a / b を最大で n 桁まで計算します。 a / b の精度が n より大きいときは BigDecimal.mode で指定された方法で丸められます。 n がゼロなら BigDecimal#/ と同じです。 n が省略されたときは Float#div と同様に結果が BigDecimal になります。

div(other) -> Integer

self を other で割った整数の商 q を返します。

ここで、商 q と余り r は、それぞれ

self == other * q + r

と

other > 0 のとき: 0 <= r < other
other < 0 のとき: other < r <= 0
q は整数

をみたす数です。商に対応する余りは Numeric#modulo で求められます。 div はメソッド / の呼び出しとして定義されています。

[PARAM] other:: 自身を割る数を指定します。

p 3.div(2) # => 1
p (-3).div(2) # => -2
p (-3.0).div(2) # => -2

divmod(n)

[TODO]

詳細は Float#divmod を参照して下さい。

divmod(other) -> [Numeric]

self を other で割った商 q と余り r を、 [q, r] という 2 要素の配列にして返します。商 q は常に整数ですが、余り r は整数であるとは限りません。

ここで、商 q と余り r は、

self == other * q + r

と

other > 0 のとき: 0 <= r < other
other < 0 のとき: other < r <= 0
q は整数

をみたす数です。 divmod が返す商は Numeric#div と同じです。また余りは、Numeric#modulo と同じです。このメソッドは、メソッド / と % によって定義されています。

[PARAM] other:: 自身を割る数を指定します。

11.divmod(3)         #=> [3, 2]
(11.5).divmod(3.5)   #=> [3, 1.0]
11.divmod(-3)        #=> [-4, -1]
11.divmod(3.5)       #=> [3, 0.5]
(-11).divmod(3.5)    #=> [-4, 3.0]

[SEE_ALSO] Numeric#div, Numeric#modulo

to_enum(method = :each, *args) -> Enumerable::Enumerator

enum_for(method = :each, *args) -> Enumerable::Enumerator

Enumerable::Enumerator.new(self, method, *args) を返します。

[PARAM] method:: メソッド名の文字列かシンボルです。
[PARAM] args:: 呼び出すメソッドに渡される引数です。
[EXCEPTION] NameError:: 存在しないメソッド名を指定すると発生します。

str = "xyz"

enum = str.enum_for(:each_byte)
p(a = enum.map{|b| '%02x' % b }) #=> ["78", "79", "7a"]

# protects an array from being modified
a = [1, 2, 3]
p(a.to_enum) #=> #<Enumerable::Enumerator:0xbaf7ac>

[SEE_ALSO] Enumerable::Enumerator

eql?

[TODO]

eql?(other) -> bool

自身と 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#===

eql?(other) -> bool

オブジェクトと other が等しければ真を返します。Hash で二つのキーが等しいかどうかを判定するのに使われます。

このメソッドは各クラスの性質に合わせて再定義すべきです。多くの場合、 == と同様に同値性の判定をするように再定義されていますが、適切にキー判定ができるようにより厳しくなっている場合もあります。

デフォルトでは equal? と同じオブジェクトの同一性判定になっています。

このメソッドを再定義した時には Object#hash メソッドも再定義しなければなりません。

[PARAM] other:: 比較するオブジェクトです。

p("foo".eql?("bar")) #=> false
p("foo".eql?("foo")) #=> true

p(4.eql?(4)) #=> true
p(4.eql?(4.0)) #=> false

[SEE_ALSO] Object#hash,Object#equal?,Object#==

equal?(other) -> bool

other が self 自身の時、真を返します。

二つのオブジェクトが同一のものかどうか調べる時に使用します。このメソッドを再定義してはいけません。

お互いのObject#object_idが一致するかどうかを調べます。

[PARAM] other:: 比較するオブジェクトです。

p("foo".equal?("bar")) #=> false
p("foo".equal?("foo")) #=> false

p(4.equal?(4)) #=> true
p(4.equal?(4.0)) #=> false

p(:foo.equal? :foo) #=> true

[SEE_ALSO] Object#object_id,Object#==,Object#eql?,Symbol

exponent

[TODO]

指数部を整数値で返します。

n = a.exponent

は a の値が 0.xxxxxxx*10**n を意味します。

extend(*modules) -> self

引数で指定したモジュールのインスタンスメソッドを self の特異メソッドとして追加します。

Module#include は、クラス(のインスタンス)に機能を追加しますが、extend は、ある特定のオブジェクトだけにモジュールの機能を追加したいときに使用します。

引数に複数のモジュールを指定した場合、最後の引数から逆順に extend を行います。

[PARAM] modules:: モジュールを任意個指定します（クラスは不可）。
[RETURN]: self を返します。

module Foo
  def a
    'ok Foo'
  end
end

module Bar
  def b
    'ok Bar'
  end
end

obj = Object.new
obj.extend Foo, Bar
p obj.a #=> "ok Foo"
p obj.b #=> "ok Bar"

class Klass
  include Foo
  extend Bar
end

p Klass.new.a #=> "ok Foo"
p Klass.b     #=> "ok Bar"

extend の機能は、「特異クラスに対する Module#include」と言い替えることもできます。ただしその場合、フック用のメソッドが Module#extended ではなく Module#included になるという違いがあります。

# obj.extend Foo, Bar とほぼ同じ
class << obj
  include Foo, Bar
end

[SEE_ALSO] Module#extend_object,Module#include,Module#extended

quo(other) -> Float

fdiv(other) -> Float

self を other で割った実数の商を返します。

Numeric のサブクラスは、このメソッドを適切に再定義しなければなりません。

[PARAM] other:: 自身を割る数を指定します。

p 1.quo(3)      # => 0.3333333333333333

require 'rational'
p 1.quo(3)      # => Rational(1, 3)

finite?

[TODO]

a.finite? は a が∞または NaN でないとき真を返します。

fix

[TODO]

self の小数点以下の切り捨て。

floor([n])

[TODO]

a 以下の最大整数 (BigDecimal 値) を返します。

c = BigDecimal("1.23456").floor      # => 1
c = BigDecimal("-1.23456").floor     # => -2

以下のように引数 n を与えることもできます。 n >= 0 なら、小数点以下 n + 1 位の数字を操作します (小数点以下を、最大 n 桁にします)。 n が負のときは小数点以上 n 桁目を操作します (小数点位置から左に少なくとも n 個の 0 が並びます)。

c = BigDecimal("1.23456").floor(4)   # => 1.2345
c = BigDecimal("15.23456").floor(-1) # => 10.0

floor -> Integer

自身と等しいかより小さな整数のうち最大のものを返します。

1.floor        #=> 1
1.2.floor      #=> 1
(-1.2).floor   #=> -2
(-1.5).floor   #=> -2

[SEE_ALSO] Numeric#ceil, Numeric#round, Numeric#truncate

frac

[TODO]

self の整数部分の切り捨て。

freeze -> self

オブジェクトを凍結（内容の変更を禁止）します。

凍結されたオブジェクトの変更は例外 TypeError を発生させます。いったん凍結されたオブジェクトを元に戻す方法はありません。

凍結されるのはオブジェクトであり、変数ではありません。代入などで変数の指すオブジェクトが変化してしまうことは freeze では防げません。 freeze が防ぐのは、 `破壊的な操作' と呼ばれるもの一般です。変数への参照自体を凍結したい場合は、グローバル変数なら Kernel.#trace_var が使えます。

[RETURN]: self を返します。

a1 = "foo".freeze
a1 = "bar"
p a1 #=> "bar"

a2 = "foo".freeze
a2.replace("bar")# can't modify frozen string (TypeError)

凍結を解除することはできませんが、Object#dup を使えばほぼ同じ内容の凍結されていないオブジェクトを得ることはできます。

a = [1].freeze
p a.frozen?     #=> true

a[0] = "foo"
p a             # can't modify frozen array (TypeError)

b = a.dup
p b             #=> [1]
p b.frozen?     #=> false

b[0] = "foo"
p b             #=> ["foo"]

[SEE_ALSO] Object#frozen?,Object#dup,Kernel.#trace_var

frozen? -> bool

オブジェクトが凍結（内容の変更を禁止）されているときに真を返します。

obj = "someone"
p obj.frozen? #=> false
obj.freeze
p obj.frozen? #=> true

[SEE_ALSO] Object#freeze

hash

[TODO]

hash -> Fixnum

オブジェクトのハッシュ値を返します。Hash クラスでオブジェクトを格納するのに用いられています。

メソッド hash は Object#eql? と組み合わせて Hash クラスで利用されます。その際

A.eql?(B) ならば A.hash == B.hash

の関係を必ず満たしていなければいけません。eql? を再定義した時には必ずこちらも合わせて再定義してください。

デフォルトでは、Object#object_id と同じ値を返します。ただし、Fixnum, Symbol, String だけは組込みのハッシュ関数が使用されます(これを変えることはできません)。

hash を再定義する場合は、一様に分布する任意の整数を返すようにします。

[RETURN]: ハッシュ値を返します。Fixnumに収まらない場合は切り捨てられます。

p self.hash #=> 21658870
p 0.hash #=> 1
p 0.0.hash #=> 0
p nil.hash #=> 4

p "ruby".hash #=> -241670986
p "ruby".hash #=> -241670986
p :ruby.hash #=> 103538
p :ruby.hash #=> 103538

[SEE_ALSO] Object#eql?,Object#__id__

infinite?

[TODO]

a.infinite? は a が+∞のとき 1 、-∞のときは -1、それ以外のときは nil を返します。

inspect

[TODO]

デバッグ出力に使用されます。

p a = BigDecimal::new("3.14",10)

とすると、[0x112344:'0.314E1',4(12)] のように出力されます。最初の16進数はオブジェクトのアドレス、次の '0.314E1' は値、次の4は現在の有効桁数(表示より若干大きいことがあります)、最後はオブジェクトが取り得る最大桁数になります。

inspect -> String

オブジェクトを人間が読める形式に変換した文字列を返します。

組み込み関数 Kernel.#p は、このメソッドの結果を使用してオブジェクトを表示します。

puts Class.new.inspect #=> #<Class:0xbafd88>
puts Time.now.inspect #=> 2007-10-15 21:01:37 +0900

[SEE_ALSO] Kernel.#p

instance_eval(expr, filename = "(eval)", lineno = 1) -> object

instance_eval {|obj| ... } -> object

オブジェクトのコンテキストで文字列 expr またはオブジェクト自身をブロックパラメータとするブロックを評価してその結果を返します。

オブジェクトのコンテキストで評価するとは評価中の self をそのオブジェクトにして実行するということです。また、文字列 expr やブロック中でメソッドを定義すればそのオブジェクトの特異メソッドが定義されます。

ただし、ローカル変数だけは、文字列 expr の評価では instance_eval の外側のスコープと、ブロックの評価ではそのブロックの外側のスコープと、共有します。

メソッド定義の中で instance_eval でメソッドを定義した場合は、囲むメソッドが実行されたときに初めて instance_eval 内のメソッドが定義されます。これはメソッド定義のネストと同じです。クラス／メソッドの定義/メソッド定義のネストを参照してください。

[PARAM] expr:: 評価する文字列です。
[PARAM] filename:: 文字列を指定します。ファイル filename に文字列 expr が書かれているかのように実行されます。スタックトレースの表示などを差し替えることができます。
[PARAM] lineno:: 文字列を指定します。行番号 lineno から文字列 expr が書かれているかのように実行されます。スタックトレースの表示などを差し替えることができます。

例:

class Foo
  def initialize data
    @key = data
  end
private
  def do_fuga
    p 'secret'
  end
end

some = Foo.new 'XXX'
some.instance_eval{p @key} #=> "XXX"
some.instance_eval{do_fuga } #=> "secret" # private メソッドも呼び出せる

some.instance_eval 'raise' # ..:10: (eval):1:  (RuntimeError)
messg = 'unknown'
some.instance_eval 'raise messg','file.rb',999 # file.rb:999: unknown (RuntimeError)

[SEE_ALSO] Module#module_eval, Kernel.#eval

instance_exec(*args) {|*vars| ... } -> object

与えられたブロックをレシーバのコンテキストで実行します。

ブロック実行中は、 self がレシーバのコンテキストになるのでレシーバの持つインスタンス変数にアクセスすることができます。

[PARAM] args:: ブロックパラメータに渡す値です。

class KlassWithSecret
  def initialize
    @secret = 99
  end
end
k = KlassWithSecret.new
# 以下で x には 5 が渡される
k.instance_exec(5) {|x| @secret + x }   #=> 104

[SEE_ALSO] Module#class_exec, Module#module_exec, Object#instance_eval

instance_of?(klass) -> bool

オブジェクトがクラス klass の直接のインスタンスである時真を返します。

obj.instance_of?(c) が成立する時には、常に obj.kind_of?(c) も成立します。

[PARAM] klass:: Classかそのサブクラスのインスタンスです。

class C < Object
end
class S < C
end

obj = S.new
p obj.instance_of?(S)       # true
p obj.instance_of?(C)       # false

[SEE_ALSO] Object#kind_of?,Object#class

instance_variable_defined?(var) -> bool

インスタンス変数 var が定義されていたら真を返します。

[PARAM] var:: インスタンス変数名を文字列か Symbol で指定します。

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
p fred.instance_variable_defined?(:@a)    #=> true
p fred.instance_variable_defined?("@b")   #=> true
p fred.instance_variable_defined?("@c")   #=> false

[SEE_ALSO] Object#instance_variable_get,Object#instance_variable_set,Object#instance_variables

instance_variable_get(var) -> object|nil

オブジェクトのインスタンス変数の値を取得して返します。

インスタンス変数が定義されていなければ nil を返します。

[PARAM] var:: インスタンス変数名を文字列か Symbol で指定します。

class Foo
  def initialize
    @foo = 1
  end
end

obj = Foo.new
p obj.instance_variable_get("@foo")     #=> 1
p obj.instance_variable_get(:@foo)      #=> 1
p obj.instance_variable_get(:@bar)      #=> nil

[SEE_ALSO] Object#instance_variable_set,Object#instance_variables,Object#instance_variable_defined?

instance_variable_set(var, value) -> object

オブジェクトのインスタンス変数 var に値 value を設定します。

インスタンス変数が定義されていなければ新たに定義されます。

[PARAM] var:: インスタンス変数名を文字列か Symbol で指定します。
[PARAM] value:: 設定する値です。
[RETURN]: value を返します。

obj = Object.new
p obj.instance_variable_set("@foo", 1)  #=> 1
p obj.instance_variable_set(:@foo, 2)   #=> 2
p obj.instance_variable_get(:@foo)      #=> 2

[SEE_ALSO] Object#instance_variable_get,Object#instance_variables,Object#instance_variable_defined?

instance_variables -> [String]

オブジェクトのインスタンス変数名を文字列の配列として返します。

obj = Object.new
obj.instance_eval { @foo, @bar = nil }
p obj.instance_variables

#=> ["@foo", "@bar"]

[SEE_ALSO] Object#instance_variable_get,Kernel.#local_variables,Kernel.#global_variables,Module.constants,Module#constants,Module#class_variables

integer? -> bool

self が整数の時、真を返します。そうでない場合に false を返します。

Numeric のサブクラスは、このメソッドを適切に再定義しなければなりません。

is_a?(mod) -> bool

kind_of?(mod) -> bool

オブジェクトが指定されたクラス mod かそのサブクラスのインスタンスであるとき真を返します。

また、オブジェクトがモジュール mod をインクルードしたクラスかそのサブクラスのインスタンスである場合にも真を返します。上記のいずれでもない場合に false を返します。

[PARAM] mod:: クラスやモジュールなど、Moduleかそのサブクラスのインスタンスです。

module M
end
class C < Object
  include M
end
class S < C
end

obj = S.new
p obj.is_a?(S)       # true
p obj.is_a?(C)       # true
p obj.is_a?(Object)  # true
p obj.is_a?(M)       # true
p obj.is_a?(Hash)    # false

[SEE_ALSO] Object#instance_of?,Module#===,Object#class

marshal_dump -> object

Marshal.#dump を制御するメソッドです。

Marshal.dump(some) において、出力するオブジェクト some がメソッド marshal_dump を持つ場合には、その返り値がダンプされたものが Marshal.dump(some) の返り値となります。

marshal_dump/marshal_load の仕組みは Ruby 1.8.0 から導入されました。これから書くプログラムでは _dump/_load ではなく marshal_dump/marshal_load を使うべきです。

[RETURN]: 任意のオブジェクトで marshal_load の引数に利用できます。

class Foo
  def initialize(arg)
    @foo = arg
  end
  def marshal_dump
    @foo
  end
  def marshal_load(obj)
    p obj
    @foo = obj
  end
end
foo = Foo.new(['foo', 'bar'])
p foo                      #=> #<Foo:0xbaf3b0 @foo=["foo", "bar"]>
dms = Marshal.dump(foo)
p dms                      #=> "\004\bU:\bFoo[\a\"\bfoo\"\bbar"
result = Marshal.load(dms) #=> ["foo", "bar"] # marshal_load の引数
p result                   #=> #<Foo:0xbaf2ac @foo=["foo", "bar"]>

インスタンス変数の情報は普通マーシャルデータに含まれるので、上例のように marshal_dump を定義する必要はありません (ただし marshal_dump を定義するとインスタンス変数の情報はダンプされなくなるので、marshal_dump/marshal_load で扱う必要があります)。 marshal_dump/marshal_load はより高度な制御を行いたい場合や拡張ライブラリで定義したクラスのインスタンスがインスタンス変数以外に情報を保持する場合に利用します。

特に、marshal_dump/marshal_load を定義したオブジェクトは特異メソッドが定義されていてもマーシャルできるようになります (特異メソッドの情報が自動的に dump されるようになるわけではなく、 marshal_dump/marshal_load によりそれを実現する余地があるということです)。

[SEE_ALSO] Object#marshal_load, Marshal

marshal_load(obj) -> object

Marshal.#load を制御するメソッドです。

some のダンプ結果（Marshal.dump(some)）をロードする（Marshal.load(Marshal.dump(some))）には some がメソッド marshal_load を持っていなければなりません。このとき、marshal_dump の返り値が marshal_load の引数に利用されます。 marshal_load 時の self は、生成されたばかり（Class#allocate されたばかり）の状態です。

marshal_dump/marshal_load の仕組みは Ruby 1.8.0 から導入されました。これから書くプログラムでは _dump/_load ではなく marshal_dump/marshal_load を使うべきです。

[PARAM] obj:: marshal_dump の返り値のコピーです。
[RETURN]: 返り値は無視されます。

[SEE_ALSO] Object#marshal_dump, Marshal

method(name) -> Method

オブジェクトのメソッド name をオブジェクト化した Method オブジェクトを返します。

[PARAM] name:: メソッド名をSymbol またはStringで指定します。
[EXCEPTION] NameError:: 定義されていないメソッド名を引数として与えると発生します。

me = -365.method(:abs)
p me #=> #<Method: Fixnum#abs>
p me.call #=> 365

[SEE_ALSO] Module#instance_method,Method,Object#__send__,Kernel.#eval

method_missing(name, *args) -> object

呼びだされたメソッドが定義されていなかった時、Rubyインタプリタがこのメソッドを呼び出します。

呼び出しに失敗したメソッドの名前 (Symbol) が name にその時の引数が第二引数以降に渡されます。

デフォルトではこのメソッドは例外 NameError を発生させます。

[PARAM] name:: 未定義メソッドの名前（シンボル）です。
[PARAM] args:: 未定義メソッドに渡された引数です。
[RETURN]: ユーザー定義の method_missing メソッドの返り値が未定義メソッドの返り値であるかのように見えます。

class Foo
  def initialize(data)
    @data = data
  end
  def method_missing(name, lang)
    if name.to_s =~ /\Afind_(\d+)_in\z/
      if @data[lang]
        p @data[lang][$1.to_i]
      else
        raise "#{lang} unknown"
      end
    else
      super
    end
  end
end

dic = Foo.new({:English => %w(zero one two), :Esperanto => %w(nulo unu du)})
dic.find_2_in :Esperanto #=> "du"

methods(include_inherited = true) -> [String]

そのオブジェクトに対して呼び出せるメソッド名の一覧を返します。このメソッドは public メソッドおよび protected メソッドの名前を返します。

ただし特別に、引数が偽の時は Object#singleton_methods(false) と同じになっています。

[PARAM] include_inherited:: 引数が偽の時は Object#singleton_methods(false) と同じになります。

#例1:

class Parent
  private;   def private_parent()   end
  protected; def protected_parent() end
  public;    def public_parent()    end
end

class Foo < Parent
  private;   def private_foo()   end
  protected; def protected_foo() end
  public;    def public_foo()    end
end

obj = Foo.new
class <<obj
    private;   def private_singleton()   end
    protected; def protected_singleton() end
    public;    def public_singleton()    end
end

# あるオブジェクトの応答できるメソッドの一覧を得る。
p obj.methods(false)
p obj.public_methods(false)
p obj.private_methods(false)
p obj.protected_methods(false)

#実行結果

["public_singleton", "protected_singleton"]
["public_foo", "public_singleton"]
["private_foo", "private_singleton"]
["protected_foo", "protected_singleton"]

#例2:

# あるオブジェクトの応答できるメソッドの一覧を得る。
# 自身のクラスの親クラスのインスタンスメソッドも含めるために true を指定して
# いるが、Object のインスタンスメソッドは一覧から排除している。
p obj.methods(true)           - Object.instance_methods(true)
p obj.public_methods(true)    - Object.public_instance_methods(true)
p obj.private_methods(true)   - Object.private_instance_methods(true)
p obj.protected_methods(true) - Object.protected_instance_methods(true)

#実行結果

["public_foo", "public_parent", "protected_singleton", "public_singleton", "protected_foo", "protected_parent"]
["public_foo", "public_parent", "public_singleton"]
["private_singleton", "private_foo", "private_parent"]
["protected_singleton", "protected_foo", "protected_parent"]

[SEE_ALSO] Module#instance_methods,Object#singleton_methods

modulo(n)

[TODO]

詳細は Float#modulo を参照して下さい。

modulo(other) -> Numeric

self を other で割った余り r を返します。

ここで、商 q と余り r は、

self == other * q + r

と

other > 0 のとき 0 <= r < other
other < 0 のとき other < r <= 0
q は整数

をみたす数です。余り r は、other と同じ符号になります。商 q は、Numeric#div (あるいは「/」)で求められます。 modulo はメソッド % の呼び出しとして定義されています。

[PARAM] other:: 自身を割る数を指定します。

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

mult(b, n)

[TODO]

以下のように使用します。

c = a.mult(b,n)

c = a * b を最大で n 桁まで計算します。 a * b の精度が n より大きいときは BigDecimal.mode で指定された方法で丸められます。 n がゼロなら * と同じです。

nan?

[TODO]

a.nan? は a が NaN のとき真を返します。

nil? -> bool

レシーバが nil であれば真を返します。

p false.nil? #=> false
p nil.nil? #=> true

[SEE_ALSO] NilClass

nonzero?

[TODO]

a が 0 なら nil、0 以外なら a そのものが返ります。

c = a.nonzero?

nonzero? -> self | nil

自身がゼロの時 nil を返し、非ゼロの時 self を返します。

p 10.nonzero?              #=> 10
p 0.nonzero?               #=> nil
p 0.0.nonzero?             #=> nil

require 'rational'
p Rational(0, 2).nonzero?  #=> nil

power(n)

[TODO]

メソッド演算子 ** と同じで、a の n 乗を計算します。n は整数。

c = a.power(n)

結果として c の有効桁は a の n 倍以上になるので注意。

precs

[TODO]

a の有効数字 (n) と最大有効数字 (m) の配列を返します。

n, m = a.precs

private_methods(include_inherited = true) -> [String]

そのオブジェクトが理解できる private メソッド名の一覧を返します。

[PARAM] include_inherited:: 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。

[SEE_ALSO] Module#private_instance_methods,Object#methods,Object#singleton_methods

protected_methods(include_inherited = true) -> [String]

そのオブジェクトが理解できる protected メソッド名の一覧を返します。

[PARAM] include_inherited:: 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。

[SEE_ALSO] Module#protected_instance_methods,Object#methods,Object#singleton_methods

public_methods(include_inherited = true) -> [String]

そのオブジェクトが理解できる public メソッド名の一覧を返します。

[PARAM] include_inherited:: 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。

[SEE_ALSO] Module#public_instance_methods,Object#methods,Object#singleton_methods

quo(n)

[TODO]

詳細は Float#quo を参照して下さい。

remainder(n)

[TODO]

詳細は Float#remainder を参照して下さい。

remainder(other) -> Numeric

self を other で割った余り r を返します。

ここで、商 q と余り r は、

self == other * q + r

と

self > 0 のとき 0 <= r < |other|
self < 0 のとき -|other| < r <= 0
q は整数

をみたす数です。r の符号は self と同じになります。商 q を直接返すメソッドはありません。self.quo(other).truncate がそれに相当します。

[PARAM] other:: 自身を割る数を指定します。

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

respond_to?(name, include_private = false) -> bool

オブジェクトがメソッド name を持つとき真を返します。

オブジェクトがメソッド name を持つというのは、オブジェクトがメソッド name に応答することができることをいいます。

[PARAM] name:: Symbol または文字列で指定するメソッド名です。
[PARAM] include_private:: private メソッドを確認の対象に含めるかを true か false で指定します。省略した場合は false(含めない) を指定した事になります。

class F
  def hello
    "Bonjour"
  end
end

class D
private
  def hello
    "Guten Tag"
  end
end
list = [F.new,D.new]

list.each{|it| puts it.hello if it.respond_to?(:hello)}
#=> Bonjour

list.each{|it| it.instance_eval("puts hello if it.respond_to?(:hello, true)")}
#=> Bonjour
#   Guten Tag

[SEE_ALSO] Module#method_defined?

round(n [, b])

[TODO]

クラスメソッド BigDecimal.mode(BigDecimal::ROUND_MODE,flag) で指定した BigDecimal::ROUND_MODE に従って丸め操作を実行します。 BigDecimal.mode(BigDecimal::ROUND_MODE,flag) で何も指定せず、かつ、引数を指定しない場合は「小数点以下第一位の数を四捨五入して整数(BigDecimal 値)」にします。

c = BigDecimal("1.23456").round   # => 1
c = BigDecimal("-1.23456").round  # => -1

以下のように引数を与えて、小数点以下 n+1 位の数字を操作することもできます。 n が正の時は、小数点以下 n+1 位の数字を丸めます(小数点以下を、最大 n 桁にします)。 n が負のときは小数点以上 n 桁目を丸めます(小数点位置から左に少なくとも n 個の 0 が並びます)。

c = BigDecimal("1.23456").round(4)    # => 1.2346
c = BigDecimal("15.23456").round(-1)  # => 20.0

2番目の引数を指定すると、BigDecimal#mode の指定を無視して、指定された方法で丸め操作を実行します。

c = BigDecimal("1.23456").round(3,BigDecimal::ROUND_HALF_EVEN)   # => 1.234
c = BigDecimal("1.23356").round(3,BigDecimal::ROUND_HALF_EVEN)   # => 1.234

round -> Integer

自身ともっとも近い整数を返します。

中央値 0.5, -0.5 はそれぞれ 1,-1 に切り上げされます。いわゆる四捨五入ですが、偶数丸めではありません。

1.round        #=> 1
1.2.round      #=> 1
(-1.2).round   #=> -1
(-1.5).round   #=> -2

[SEE_ALSO] Numeric#ceil, Numeric#floor, Numeric#truncate

sign

[TODO]

値が正 (sign > 0)、負 (sign < 0)、その他 (sign == 0) であるかの情報を返します。

n = a.sign

としたとき n の値は a が以下のときを意味します。 () の中の数字は、実際の値です (「内部構造」を参照)。

n = BigDecimal::SIGN_NaN(0)                 # a は NaN
n = BigDecimal::SIGN_POSITIVE_ZERO(1)       # a は +0
n = BigDecimal::SIGN_NEGATIVE_ZERO(-1)      # a は -0
n = BigDecimal::SIGN_POSITIVE_FINITE(2)     # a は正の値
n = BigDecimal::SIGN_NEGATIVE_FINITE(-2)    # a は負の値
n = BigDecimal::SIGN_POSITIVE_INFINITE(3)   # a は+Infinity
n = BigDecimal::SIGN_NEGATIVE_INFINITE(-3)  # a は-Infinity

singleton_methods(inherited_too = true) -> [String]

そのオブジェクトに対して定義されている特異メソッド名 (public あるいは protected メソッド) の一覧を返します。

クラスメソッド(Classのインスタンスの特異メソッド)に関しては引数が真のとき、スーパークラスのクラスメソッドも対象になります。

singleton_methods(false) は、Object#methods(false) と同じです。

[PARAM] inherited_too:: 引数が真のとき、スーパークラスのクラスメソッドも対象になります。これが意味を持つのは self がクラスオブジェクトであるときだけです。

#例1:

Parent = Class.new

class <<Parent
  private;   def private_class_parent() end
  protected; def protected_class_parent() end
  public;    def public_class_parent() end
end

Foo = Class.new(Parent)

class <<Foo
  private;   def private_class_foo() end
  protected; def protected_class_foo() end
  public;    def public_class_foo() end
end

module Bar
  private;   def private_bar()   end
  protected; def protected_bar() end
  public;    def public_bar()    end
end

obj = Foo.new
class <<obj
  include Bar
  private;   def private_self()   end
  protected; def protected_self() end
  public;    def public_self()    end
end

# あるオブジェクトの特異メソッドの一覧を得る。
p obj.singleton_methods(false)
p obj.methods(false)
p Foo.singleton_methods(false)

#実行結果

["public_self", "protected_self"]
["public_self", "protected_self"]
["public_class_foo", "protected_class_foo"]


#例2:

# あるオブジェクトの特異メソッドの一覧を得る。
# 親クラスのクラスメソッドも含まれるよう true を指定したが、
# Object のクラスメソッドは一覧から排除している。

p obj.singleton_methods(true)
p Foo.singleton_methods(true) - Object.singleton_methods(true)

#実行結果

["public_bar", "public_self", "protected_bar", "protected_self"]
["public_class_foo", "public_class_parent", "protected_class_foo", "protected_class_parent"]

[SEE_ALSO] Object#methods,Object#extend

split

[TODO]

BigDecimal 値を 0.xxxxxxx*10**n と表現したときに、符号 (NaNのときは 0、それ以外は+1か-1になります)、仮数部分の文字列("xxxxxxx")と、基数(10)、更に指数 n を配列で返します。

a = BigDecimal::new("3.14159265")
f, x, y, z = a.split

とすると、f =+ 1、x = "314159265"、y = 10、z = 1 になります。従って、

s = "0."+x
b = f*(s.to_f)*(y**z)

で Float に変換することができます。

sqrt(n)

[TODO]

a の有効桁 n 桁の平方根 (n の平方根ではありません) をニュートン法で計算します。

c = a.sqrt(n)

step(limit, step = 1) {|n| ... } -> self

step(limit, step = 1) -> Enumerable::Enumerator

self からはじめ step を足しながら limit を越える前までブロックを繰り返します。step は負の数も指定できます。また、limit や step には Float なども指定できます。

[PARAM] limit:: ループの上限あるいは下限を数値で指定します。step に負の数が指定された場合は、下限として解釈されます。
[PARAM] step:: 各ステップの大きさを数値で指定します。負の数を指定することもできます。
[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.2
   1.3
   1.4
   1.5

10.step(6, -1){|n| p n}
10
9
8
7
6

注：浮動小数点数の 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.2
   1.3
   1.4   <- 1.5 が表示されない

[SEE_ALSO] Integer#downto

sub(b, n)

[TODO]

のように使用します。

c = a.sub(b,n)

c = a - b を最大で n 桁まで計算します。 a - b の精度が n より大きいときは BigDecimal.mode で指定された方法で丸められます。 n がゼロなら - と同じです。

taint -> self

オブジェクトの「汚染マーク」をセットします。

環境変数（ENVで得られる文字列）など一部のオブジェクトは最初から汚染されています。オブジェクトの汚染に関してはセキュリティモデルを参照してください。

$SAFE = 1

some = "puts '@&%&(#!'"
p some.tainted? #=> false
eval(some) #=> @&%&(#!

some.taint
p some.tainted? #=> true
eval(some) # Insecure operation - eval (SecurityError)

some.untaint
p some.tainted? #=> false
eval(some) #=> @&%&(#!

p ENV['OS'].tainted? #=> true

[SEE_ALSO] Object#tainted?,Object#untaint,Object#freeze

tainted? -> bool

オブジェクトの「汚染マーク」がセットされている時真を返します。

オブジェクトの汚染に関してはセキュリティモデルを参照してください。

p String.new.tainted? #=> false
p ENV['OS'].tainted? #=> true

[SEE_ALSO] Object#taint,Object#untaint

tap {|x| ... } -> self

self を引数としてブロックを評価し、self を返します。

メソッドチェインの途中で直ちに操作結果を表示するためにメソッドチェインに "入り込む" ことが、このメソッドの主目的です。

(1..10)                    .tap {|x| puts "original: #{x.inspect}"}.
   to_a                    .tap {|x| puts "array: #{x.inspect}"}.
   select {|x| x % 2 == 0} .tap {|x| puts "evens: #{x.inspect}"}.
   map { |x| x * x }       .tap {|x| puts "squares: #{x.inspect}"}

to_a -> Array

オブジェクトを配列に変換した結果を返します。

配列に変換できない(to_ary を持たない)オブジェクトは、自身のみを含む長さ 1 の配列に変換されます。このメソッドは、将来 Object のメソッドからは取り除かれます。なので to_a を使用する場合、

すべてのオブジェクトに to_a が定義されているという期待はしない。
ユーザー定義のクラスには必要に応じて自分で定義する

などということが必要です。

p( {'a'=>1}.to_a )  # [["a", 1]]
p ['array'].to_a    # ["array"]
p 1.to_a            # [1]       (warning: default `to_a' will be obsolete)
p nil.to_a          # []

[SEE_ALSO] Object#to_ary,Kernel.#Array

to_ary -> Array

オブジェクトの Array への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

説明のためここに記載してありますが、このメソッドは実際には Object クラスには定義されていません。必要に応じてサブクラスで定義すべきものです。

このメソッドを定義する条件は、

配列が使われるすべての場面で代置可能であるような、
配列そのものとみなせるようなもの

という厳しいものになっています。

class Foo
 def to_ary
   [3,4]
 end
end

it = Foo.new
p([1,2] + it) #=> [1, 2, 3, 4]

[SEE_ALSO] Object#to_a,Kernel.#Array

to_f

[TODO]

Float オブジェクトに変換します。よりきめ細かい値が必要ならば BigDecimal#split メソッドを利用してください。

to_hash -> Hash

オブジェクトの Hash への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

このメソッドを定義する条件は、

ハッシュが使われるすべての場面で代置可能であるような、
ハッシュそのものとみなせるようなもの

という厳しいものになっています。

class Foo
 def to_hash
   {'as' => 24}
 end
end

it = Foo.new
p({:as => 12}.merge(it)) #=> {"as"=>24, :as=>12}

to_i

[TODO]

小数点以下を切り捨てて整数に変換します。

i = a.to_i

i は値に応じて Fixnum か Bignum になります。 a が Infinity や NaN のとき、i は nil になります。

to_int

[TODO]

to_int -> Integer

self.to_i と同じです。

to_int -> Integer

オブジェクトの Integer への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

このメソッドを定義する条件は、

整数が使われるすべての場面で代置可能であるような、
整数そのものとみなせるようなもの

という厳しいものになっています。

class Foo
 def to_int
   666
 end
end

it = Foo.new
p(9**9 & it) #=> 8

[SEE_ALSO] Kernel.#Integer

to_io -> IO

オブジェクトの IO への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

このメソッドを定義する条件は、

IOオブジェクトが使われるすべての場面で代置可能であるような、
IOオブジェクトそのものとみなせるようなもの

という厳しいものになっています。

to_proc -> Proc

オブジェクトの Proc への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

def doing
  yield
end

class Foo
 def to_proc
   Proc.new{p 'ok'}
 end
end

it = Foo.new
doing(&it) #=> "ok"

to_regexp -> Regexp

オブジェクトの Regexp への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

このメソッドを定義する条件は、

正規表現が使われるすべての場面で代置可能であるような、
正規表現そのものとみなせるようなもの

という厳しいものになっています。

class Foo
 def to_regexp
   /[\d]+/
 end
end

it = Foo.new
p Regexp.union(/^at/, it) #=> /(?-mix:^at)|(?-mix:[\d]+)/

to_s([n])

[TODO]

文字列に変換します (デフォルトは "0.xxxxxEn" の形になります)。

BigDecimal("1.23456").to_s  #  ==> "0.123456E1"

引数 n に正の整数が指定されたときは、小数点で分けられる左右部分を、それぞれ n 桁毎に空白で区切ります。

BigDecimal("0.1234567890123456789").to_s(10)   # => "0.1234567890 123456789E0"

引数 n に正の整数を表す文字列を指定することもできます。

BigDecimal("0.1234567890123456789").to_s("10") # => "0.1234567890 123456789E0"

文字列の最初に '+' (または ' ') を付けると、値が正の場合、先頭に '+' (または ' ')が付きます。負の場合は常に '-' が付きます。

BigDecimal("0.1234567890123456789").to_s(" 10") # => " 0.1234567890 123456789E0"
BigDecimal("0.1234567890123456789").to_s("+10") # => "+0.1234567890 123456789E0"
BigDecimal("-0.1234567890123456789").to_s("10") # => "-0.1234567890 123456789E0"

さらに文字列の最後に E (または e) か F (または f) を指定することで、以下のように表示形式を変更することができます。

BigDecimal("1234567890.123456789").to_s("E")  # => "0.1234567890123456789E10"
BigDecimal("1234567890.123456789").to_s("F")  # => "1234567890.123456789"
BigDecimal("1234567890.123456789").to_s("5E") # => "0.12345 67890 12345 6789E10"
BigDecimal("1234567890.123456789").to_s("5F") # => "12345 67890.12345 6789"

to_s -> String

オブジェクトの文字列表現を返します。

Kernel.#print や Kernel.#sprintf は文字列以外のオブジェクトが引数に渡された場合このメソッドを使って文字列に変換します。

class Foo
  def initialize num
    @num = num
  end
end
it = Foo.new(40)

puts it #=> #<Foo:0x2b69110>

class Foo
 def to_s
   "Class:Foo Number:#{@num}"
 end
end

puts it #=> Class:Foo Number:40

[SEE_ALSO] Object#to_str,Kernel.#String

to_str -> String

オブジェクトの String への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

このメソッドを定義する条件は、

文字列が使われるすべての場面で代置可能であるような、
文字列そのものとみなせるようなもの

という厳しいものになっています。

class Foo
 def to_str
   'Edition'
 end
end

it = Foo.new
p('Second' + it) #=> "SecondEdition"

[SEE_ALSO] Object#to_s,Kernel.#String

truncate

[TODO]

小数点以下の数を切り捨てて整数 (BigDecimal 値)にします。以下のように引数を与えて、小数点以下 n+1 位の数字を操作することもできます。 n が正の時は、小数点以下 n+1 位の数字を切り捨てます (小数点以下を、最大 n 桁にします)。 n が負のときは小数点以上 n 桁目を操作します (小数点位置から左に少なくとも n 個の 0 が並びます)。

c = BigDecimal("1.23456").truncate(4)    # => 1.2345
c = BigDecimal("15.23456").truncate(-1)  # => 10.0

truncate -> Integer

自身と 0 との間にある整数で、自身にもっとも近い整数を返します。

1.truncate        #=> 1
1.2.truncate      #=> 1
(-1.2).truncate   #=> -1
(-1.5).truncate   #=> -1

[SEE_ALSO] Numeric#ceil, Numeric#floor, Numeric#round

untaint -> self

オブジェクトの「汚染マーク」を取り除きます。

汚染マークを取り除くことによる危険性はプログラマが責任を負う必要があります。

オブジェクトの汚染に関してはセキュリティモデルを参照してください。

[EXCEPTION] SecurityError:: セキュリティレベルが3以上の時にこのメソッドを使用すると発生します。

[SEE_ALSO] Object#taint,Object#tainted?

zero?

[TODO]

a が 0 なら true を返します。

c = a.zero?

zero? -> bool

自身がゼロの時、真を返します。そうでない場合は false を返します。

p 10.zero?              #=> false
p 0.zero?               #=> true
p 0.0.zero?             #=> true

privateメソッド

initialize(*args, &block) -> object

ユーザ定義クラスのオブジェクト初期化メソッド。

このメソッドは Class#new から新しく生成されたオブジェクトの初期化のために呼び出されます。他の言語のコンストラクタに相当します。デフォルトの動作ではなにもしません。

initialize には Class#new に与えられた引数がそのまま渡されます。

サブクラスではこのメソッドを必要に応じて再定義されることが期待されています。

initialize という名前のメソッドは自動的に private に設定されます。

[PARAM] args:: 初期化時の引数です。
[PARAM] block:: 初期化時のブロック引数です。必須ではありません。

class Foo
  def initialize name
    puts "initialize Foo"
    @name = name
  end
end

class Bar < Foo
  def initialize name, pass
    puts "initialize Bar"
    super name
    @pass = pass
  end
end

it = Bar.new('myname','0500')
p it
#=> initialize Bar
#   initialize Foo
#   #<Bar:0x2b68f08 @name="myname", @pass="0500">

[SEE_ALSO] Class#new

initialize_copy(obj) -> object

(拡張ライブラリによる) ユーザ定義クラスのオブジェクトコピーの初期化メソッド。

このメソッドは self を obj の内容で置き換えます。ただし、self のインスタンス変数や特異メソッドは変化しません。 Object#clone, Object#dupの内部で使われています。

initialize_copy は、Ruby インタプリタが知り得ない情報をコピーするために使用(定義)されます。例えば C 言語でクラスを実装する場合、情報をインスタンス変数に保持させない場合がありますが、そういった内部情報を initialize_copy でコピーするよう定義しておくことで、dup や clone を再定義する必要がなくなります。

デフォルトの Object#initialize_copy は、 freeze チェックおよび型のチェックを行い self を返すだけのメソッドです。

initialize_copy という名前のメソッドは自動的に private に設定されます。

[EXCEPTION] TypeError:: レシーバが freeze されているか、obj のクラスがレシーバのクラスと異なる場合に発生します。

[SEE_ALSO] Object#clone,Object#dup

以下に例として、dup や clone がこのメソッドをどのように利用しているかを示します。

obj.dup は、新たに生成したオブジェクトに対して initialize_copy を呼び

obj2 = obj.class.allocate
obj2.initialize_copy(obj)

obj2 に対してさらに obj の汚染状態、インスタンス変数、ファイナライザをコピーすることで複製を作ります。 obj.clone は、さらに特異メソッドのコピーも行います。

obj = Object.new
class <<obj
  attr_accessor :foo
  def bar
    :bar
  end
end

def check(obj)
  puts "instance variables: #{obj.inspect}"
  puts "tainted?: #{obj.tainted?}"
  print "singleton methods: "
  begin
    p obj.bar
  rescue NameError
    p $!
  end
end

obj.foo = 1
obj.taint

check Object.new.send(:initialize_copy, obj)
        #=> instance variables: #<Object:0x4019c9d4>
        #   tainted?: false
        #   singleton methods: #<NoMethodError: ...>
check obj.dup
        #=> instance variables: #<Object:0x4019c9c0 @foo=1>
        #   tainted?: true
        #   singleton methods: #<NoMethodError: ...>
check obj.clone
        #=> instance variables: #<Object:0x4019c880 @foo=1>
        #   tainted?: true
        #   singleton methods: :bar

remove_instance_variable(name) -> object

オブジェクトからインスタンス変数 name を取り除き、そのインスタンス変数に設定されていた値を返します。

[PARAM] name:: 削除するインスタンス変数の名前をシンボルか文字列で指定します。
[EXCEPTION] NameError:: オブジェクトがインスタンス変数 name を持たない場合に発生します。

class Foo
  def foo
    @foo = 1
    p remove_instance_variable(:@foo) #=> 1
    p remove_instance_variable(:@foo) # instance variable @foo not defined (NameError)
  end
end
Foo.new.foo

[SEE_ALSO] Module#remove_class_variable,Module#remove_const

singleton_method_added(name) -> object

特異メソッドが追加された時にインタプリタから呼び出されます。

通常のメソッドの追加に対するフックには Module#method_addedを使います。

[PARAM] name:: 追加されたメソッド名が Symbol で渡されます。

class Foo
  def singleton_method_added(name)
    puts "singleton method \"#{name}\" was added"
  end
end

obj = Foo.new
def obj.foo
end

#=> singleton method "foo" was added

[SEE_ALSO] Module#method_added,Object#singleton_method_removed,Object#singleton_method_undefined

singleton_method_removed(name) -> object

特異メソッドが Module#remove_method により削除された時にインタプリタから呼び出されます。

通常のメソッドの削除に対するフックには Module#method_removedを使います。

[PARAM] name:: 削除されたメソッド名が Symbol で渡されます。

class Foo
  def singleton_method_removed(name)
    puts "singleton method \"#{name}\" was removed"
  end
end

obj = Foo.new
def obj.foo
end

class << obj
  remove_method :foo
end

#=> singleton method "foo" was removed

[SEE_ALSO] Module#method_removed,Object#singleton_method_added,Object#singleton_method_undefined

singleton_method_undefined(name) -> object

特異メソッドが Module#undef_method または undef により未定義にされた時にインタプリタから呼び出されます。

通常のメソッドの未定義に対するフックには Module#method_undefined を使います。

[PARAM] name:: 未定義にされたメソッド名が Symbol で渡されます。

class Foo
  def singleton_method_undefined(name)
    puts "singleton method \"#{name}\" was undefined"
  end
end

obj = Foo.new
def obj.foo
end
def obj.bar
end

class << obj
  undef_method :foo
end
obj.instance_eval {undef bar}

#=> singleton method "foo" was undefined
#   singleton method "bar" was undefined

[SEE_ALSO] Module#method_undefined,Object#singleton_method_added,Object#singleton_method_removed , クラス／メソッドの定義/undef

定数

BASE: [TODO]
EXCEPTION_ALL: [TODO]
EXCEPTION_INFINITY: [TODO]
EXCEPTION_NaN: [TODO]
EXCEPTION_OVERFLOW: [TODO]
EXCEPTION_UNDERFLOW: [TODO]
EXCEPTION_ZERODIVIDE: [TODO]
ROUND_CEILING: [TODO]
ROUND_DOWN: [TODO]
ROUND_FLOOR: [TODO]
ROUND_HALF_DOWN: [TODO]
ROUND_HALF_EVEN: [TODO]
ROUND_HALF_UP: [TODO]
ROUND_MODE: [TODO]
ROUND_UP: [TODO]
SIGN_NEGATIVE_FINITE: [TODO]
SIGN_NEGATIVE_INFINITE: [TODO]
SIGN_NEGATIVE_ZERO: [TODO]
SIGN_NaN: [TODO]
SIGN_POSITIVE_FINITE: [TODO]
SIGN_POSITIVE_INFINITE: [TODO]
SIGN_POSITIVE_ZERO: [TODO]

class BigDecimal

Ruby 1.8.7 リファレンスマニュアル
- はじめに
- コマンド
- Rubyの起動
- 環境変数
- Ruby言語仕様
- 組み込みライブラリ
- 標準添付ライブラリ
  - CUI
    - curses
    - expect
    - io/console
    - pty
    - readline
    - shell
  - 文字コード
    - iconv
    - kconv
    - nkf
  - コマンドライン
    - getoptlong
    - optparse
  - データベース
    - dbm
    - gdbm
    - pstore
    - sdbm
  - 日付・時間
    - date
    - time
  - デザインパターン
  - 開発
    - benchmark
    - coverage
    - debug
    - irb
    - minitest/mock
    - minitest/spec
    - minitest/unit
    - mkmf
    - pp
    - profile
    - profiler
    - rake
    - rbconfig
    - test/unit
    - tracer
  - ファイル
    - fileutils
    - find
    - pathname
    - tempfile
    - tmpdir
    - un
  - ファイルフォーマット
    - csv
    - json
    - psych
    - rdoc
    - rexml
    - rss
    - syck
    - yaml
    - zlib
  - GC
    - weakref
  - GUI
    - tk
  - 入出力
    - fcntl
    - io/nonblock
    - io/wait
    - open3
    - scanf
  - 数学
    - bigdecimal
    - cmath
    - complex
    - mathn
    - matrix
    - prime
    - rational
    - set
    - tsort
  - ネットワーク
    - cgi
    - drb
    - gserver
    - ipaddr
    - net/ftp
    - net/http
    - net/https
    - net/imap
    - net/pop
    - net/protocol
    - net/smtp
    - net/telnet
    - open-uri
    - openssl
    - resolv
    - resolv-replace
    - socket
    - uri
    - webrick
    - xmlrpc
  - テキスト
    - digest
    - erb
    - ripper
    - shellwords
    - stringio
    - strscan
  - スレッド
    - monitor
    - mutex_m
    - sync
    - thread
    - thwait
    - timeout
  - Unix
    - etc
    - syslog
  - Windows
  - その他
    - abbrev
    - base64
    - continuation
    - dl
    - e2mmap
    - English
    - fiber
    - logger
    - objspace
    - ostruct
    - prettyprint
    - racc/parser
    - rinda/rinda
    - rinda/tuplespace
    - rubygems
    - securerandom
    - ubygems
- pack テンプレート文字列
- sprintf フォーマット
- Ruby用語集
- Rubyで使われる記号の意味
- 疑似BNFによるRubyの文法
- バージョン情報 / このリファレンスについて