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

class BigDecimal + Numeric + Comparable

クラスの継承リスト: 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 の取り扱いは将来のバージョンで若干変更される可能性があります。

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

[TODO]

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 を返したときに発生します。

_dump

[TODO]

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

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:

オペランドを数値で指定します。

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

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

exponent

[TODO]

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

n = a.exponent

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

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 の整数部分の切り捨て。

hash

[TODO]

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は現在の有効桁数(表示より若干大きいことがあります)、 最後はオブジェクトが取り得る最大桁数になります。

integer? -> bool

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

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

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 のとき真を返します。

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

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

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

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 がゼロなら - と同じです。

to_f

[TODO]

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

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_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"

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

zero?

[TODO]

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

c = a.zero?

zero? -> bool

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

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

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]