Class: BigDecimal

Inherits:
Numeric
  • Object
show all
Defined in:
ext/bigdecimal/bigdecimal.c,
lib/bigdecimal.rb,
lib/bigdecimal.rb,
lib/bigdecimal/util.rb,
ext/bigdecimal/bigdecimal.c

Overview

BigDecimal provides arbitrary-precision floating point decimal arithmetic.

Introduction

Ruby provides built-in support for arbitrary precision integer arithmetic.

For example:

42**13 #=> 1265437718438866624512

BigDecimal provides similar support for very large or very accurate floating point numbers.

Decimal arithmetic is also useful for general calculation, because it provides the correct answers people expect–whereas normal binary floating point arithmetic often introduces subtle errors because of the conversion between base 10 and base 2.

For example, try:

sum = 0
10_000.times do
  sum = sum + 0.0001
end
print sum #=> 0.9999999999999062

and contrast with the output from:

require 'bigdecimal'

sum = BigDecimal("0")
10_000.times do
  sum = sum + BigDecimal("0.0001")
end
print sum #=> 0.1E1

Similarly:

(BigDecimal(“1.2”) - BigDecimal(“1.0”)) == BigDecimal(“0.2”) #=> true

(1.2 - 1.0) == 0.2 #=> false

A Note About Precision

For a calculation using a BigDecimal and another value, the precision of the result depends on the type of value:

  • If value is a Float, the precision is Float::DIG + 1.

  • If value is a Rational, the precision is larger than Float::DIG + 1.

  • If value is a BigDecimal, the precision is value‘s precision in the internal representation, which is platform-dependent.

  • If value is other object, the precision is determined by the result of BigDecimal(value).

Special features of accurate decimal arithmetic

Because BigDecimal is more accurate than normal binary floating point arithmetic, it requires some special values.

Infinity

BigDecimal sometimes needs to return infinity, for example if you divide a value by zero.

BigDecimal(“1.0”) / BigDecimal(“0.0”) #=> Infinity BigDecimal(“-1.0”) / BigDecimal(“0.0”) #=> -Infinity

You can represent infinite numbers to BigDecimal using the strings 'Infinity', '+Infinity' and '-Infinity' (case-sensitive)

Not a Number

When a computation results in an undefined value, the special value NaN (for ‘not a number’) is returned.

Example:

BigDecimal(“0.0”) / BigDecimal(“0.0”) #=> NaN

You can also create undefined values.

NaN is never considered to be the same as any other value, even NaN itself:

n = BigDecimal(‘NaN’) n == 0.0 #=> false n == n #=> false

Positive and negative zero

If a computation results in a value which is too small to be represented as a BigDecimal within the currently specified limits of precision, zero must be returned.

If the value which is too small to be represented is negative, a BigDecimal value of negative zero is returned.

BigDecimal(“1.0”) / BigDecimal(“-Infinity”) #=> -0.0

If the value is positive, a value of positive zero is returned.

BigDecimal(“1.0”) / BigDecimal(“Infinity”) #=> 0.0

(See BigDecimal.mode for how to specify limits of precision.)

Note that -0.0 and 0.0 are considered to be the same for the purposes of comparison.

Note also that in mathematics, there is no particular concept of negative or positive zero; true mathematical zero has no sign.

bigdecimal/util

When you require bigdecimal/util, the #to_d method will be available on BigDecimal and the native Integer, Float, Rational, String, Complex, and NilClass classes:

require ‘bigdecimal/util’

42.to_d                         # => 0.42e2
0.5.to_d                        # => 0.5e0
(2/3r).to_d(3)                  # => 0.667e0
"0.5".to_d                      # => 0.5e0
Complex(0.1234567, 0).to_d(4)   # => 0.1235e0
nil.to_d                        # => 0.0

Methods for Working with JSON

  • ::json_create: Returns a new BigDecimal object constructed from the given object.

  • #as_json: Returns a 2-element hash representing self.

  • #to_json: Returns a JSON string representing self.

These methods are provided by the JSON gem. To make these methods available:

require 'json/add/bigdecimal'

  • License

Copyright © 2002 by Shigeo Kobayashi <[email protected]>.

BigDecimal is released under the Ruby and 2-clause BSD licenses. See LICENSE.txt for details.

Maintained by mrkn <[email protected]> and ruby-core members.

Documented by zzak <[email protected]>, mathew <[email protected]>, and many other contributors.

Defined Under Namespace

Modules: Internal

Constant Summary collapse

VERSION =

The version of bigdecimal library

rb_str_new2(BIGDECIMAL_VERSION)
BASE =

Base value used in internal calculations. On a 32 bit system, BASE is 10000, indicating that calculation is done in groups of 4 digits. (If it were larger, BASE**2 wouldn’t fit in 32 bits, so you couldn’t guarantee that two groups could always be multiplied together without overflow.)

INT2FIX((SIGNED_VALUE)BASE)
EXCEPTION_ALL =

Determines whether overflow, underflow or zero divide result in an exception being thrown. See BigDecimal.mode.

0xff
EXCEPTION_NaN =

Determines what happens when the result of a computation is not a number (NaN). See BigDecimal.mode.

0x02
EXCEPTION_INFINITY =

Determines what happens when the result of a computation is infinity. See BigDecimal.mode.

0x01
EXCEPTION_UNDERFLOW =

Determines what happens when the result of a computation is an underflow (a result too small to be represented). See BigDecimal.mode.

0x04
EXCEPTION_OVERFLOW =

Determines what happens when the result of a computation is an overflow (a result too large to be represented). See BigDecimal.mode.

0x01
EXCEPTION_ZERODIVIDE =

Determines what happens when a division by zero is performed. See BigDecimal.mode.

0x10
ROUND_MODE =

Determines what happens when a result must be rounded in order to fit in the appropriate number of significant digits. See BigDecimal.mode.

0x100
ROUND_UP =

Indicates that values should be rounded away from zero. See BigDecimal.mode.

1
ROUND_DOWN =

Indicates that values should be rounded towards zero. See BigDecimal.mode.

2
ROUND_HALF_UP =

Indicates that digits >= 5 should be rounded up, others rounded down. See BigDecimal.mode.

3
ROUND_HALF_DOWN =

Indicates that digits >= 6 should be rounded up, others rounded down. See BigDecimal.mode.

4
ROUND_CEILING =

Round towards +Infinity. See BigDecimal.mode.

5
ROUND_FLOOR =

Round towards -Infinity. See BigDecimal.mode.

6
ROUND_HALF_EVEN =

Round towards the even neighbor. See BigDecimal.mode.

7
SIGN_NaN =

Indicates that a value is not a number. See BigDecimal.sign.

0
SIGN_POSITIVE_ZERO =

Indicates that a value is +0. See BigDecimal.sign.

1
SIGN_NEGATIVE_ZERO =

Indicates that a value is -0. See BigDecimal.sign.

-1
SIGN_POSITIVE_FINITE =

Indicates that a value is positive and finite. See BigDecimal.sign.

2
SIGN_NEGATIVE_FINITE =

Indicates that a value is negative and finite. See BigDecimal.sign.

-2
SIGN_POSITIVE_INFINITE =

Indicates that a value is positive and infinite. See BigDecimal.sign.

3
SIGN_NEGATIVE_INFINITE =

Indicates that a value is negative and infinite. See BigDecimal.sign.

-3
INFINITY =

BigDecimal@Infinity] value.

Positive infinity[rdoc-ref
NAN =

BigDecimal@Not+a+Number]‘ value.

'{Not a Number}[rdoc-ref

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

._load(str) ⇒ Object

Internal method used to provide marshalling support. See the Marshal module.



722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
 
# File 'ext/bigdecimal/bigdecimal.c', line 722

static VALUE
BigDecimal_load(VALUE self, VALUE str)
{
    BDVALUE v;
    unsigned char *pch;
    unsigned char ch;

    pch = (unsigned char *)StringValueCStr(str);
    /* First skip max prec. Don't trust the value. */
    while((*pch) != (unsigned char)'\0' && (ch = *pch++) != (unsigned char)':') {
        if(!ISDIGIT(ch)) {
            rb_raise(rb_eTypeError, "load failed: invalid character in the marshaled string");
        }
    }
    v = bdvalue_nonnullable(CreateFromString((char *)pch, self, true, true));
    return CheckGetValue(v);
}

.double_fig ⇒ Object

.interpret_loosely(string) ⇒ Object

Returns the BigDecimal converted loosely from string.



3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
 
# File 'ext/bigdecimal/bigdecimal.c', line 3061

static VALUE
BigDecimal_s_interpret_loosely(VALUE klass, VALUE str)
{
    char const *c_str = StringValueCStr(str);
    NULLABLE_BDVALUE v = CreateFromString(c_str, klass, false, true);
    if (v.bigdecimal_or_nil == Qnil)
        return Qnil;
    else
        return CheckGetValue(bdvalue_nonnullable(v));
}

.limit(digits) ⇒ Object

Limit the number of significant digits in newly created BigDecimal numbers to the specified value. Rounding is performed as necessary, as specified by BigDecimal.mode.

A limit of 0, the default, means no upper limit.

The limit specified by this method takes less priority over any limit specified to instance methods such as ceil, floor, truncate, or round.



3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
 
# File 'ext/bigdecimal/bigdecimal.c', line 3085

static VALUE
BigDecimal_limit(int argc, VALUE *argv, VALUE self)
{
    VALUE  nFig;
    VALUE  nCur = SIZET2NUM(VpGetPrecLimit());

    if (rb_scan_args(argc, argv, "01", &nFig) == 1) {
	int nf;
	if (NIL_P(nFig)) return nCur;
	nf = NUM2INT(nFig);
	if (nf < 0) {
	    rb_raise(rb_eArgError, "argument must be positive");
	}
	VpSetPrecLimit(nf);
    }
    return nCur;
}

.mode(mode, setting = nil) ⇒ Integer

Returns an integer representing the mode settings for exception handling and rounding.

These modes control exception handling:

  • BigDecimal::EXCEPTION_NaN.

  • BigDecimal::EXCEPTION_INFINITY.

  • BigDecimal::EXCEPTION_UNDERFLOW.

  • BigDecimal::EXCEPTION_OVERFLOW.

  • BigDecimal::EXCEPTION_ZERODIVIDE.

  • BigDecimal::EXCEPTION_ALL.

Values for setting for exception handling:

  • true: sets the given mode to true.

  • false: sets the given mode to false.

  • nil: does not modify the mode settings.

You can use method BigDecimal.save_exception_mode to temporarily change, and then automatically restore, exception modes.

For clarity, some examples below begin by setting all exception modes to false.

This mode controls the way rounding is to be performed:

  • BigDecimal::ROUND_MODE

You can use method BigDecimal.save_rounding_mode to temporarily change, and then automatically restore, the rounding mode.

NaNs

Mode BigDecimal::EXCEPTION_NaN controls behavior when a BigDecimal NaN is created.

Settings:

  • false (default): Returns BigDecimal('NaN').

  • true: Raises FloatDomainError.

Examples:

BigDecimal.mode(BigDecimal::EXCEPTION_ALL, false) # => 0
BigDecimal('NaN')                                 # => NaN
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, true)  # => 2
BigDecimal('NaN') # Raises FloatDomainError

Infinities

Mode BigDecimal::EXCEPTION_INFINITY controls behavior when a BigDecimal Infinity or -Infinity is created. Settings:

  • false (default): Returns BigDecimal('Infinity') or BigDecimal('-Infinity').

  • true: Raises FloatDomainError.

Examples:

BigDecimal.mode(BigDecimal::EXCEPTION_ALL, false)     # => 0
BigDecimal('Infinity')                                # => Infinity
BigDecimal('-Infinity')                               # => -Infinity
BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, true) # => 1
BigDecimal('Infinity')  # Raises FloatDomainError
BigDecimal('-Infinity') # Raises FloatDomainError

Underflow

Mode BigDecimal::EXCEPTION_UNDERFLOW controls behavior when a BigDecimal underflow occurs. Settings:

  • false (default): Returns BigDecimal('0') or BigDecimal('-Infinity').

  • true: Raises FloatDomainError.

Examples:

BigDecimal.mode(BigDecimal::EXCEPTION_ALL, false)      # => 0
def flow_under
  x = BigDecimal('0.1')
  100.times { x *= x }
end
flow_under                                             # => 100
BigDecimal.mode(BigDecimal::EXCEPTION_UNDERFLOW, true) # => 4
flow_under # Raises FloatDomainError

Overflow

Mode BigDecimal::EXCEPTION_OVERFLOW controls behavior when a BigDecimal overflow occurs. Settings:

  • false (default): Returns BigDecimal('Infinity') or BigDecimal('-Infinity').

  • true: Raises FloatDomainError.

Examples:

BigDecimal.mode(BigDecimal::EXCEPTION_ALL, false)     # => 0
def flow_over
  x = BigDecimal('10')
  100.times { x *= x }
end
flow_over                                             # => 100
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, true) # => 1
flow_over # Raises FloatDomainError

Zero Division

Mode BigDecimal::EXCEPTION_ZERODIVIDE controls behavior when a zero-division occurs. Settings:

  • false (default): Returns BigDecimal('Infinity') or BigDecimal('-Infinity').

  • true: Raises FloatDomainError.

Examples:

BigDecimal.mode(BigDecimal::EXCEPTION_ALL, false)       # => 0
one = BigDecimal('1')
zero = BigDecimal('0')
one / zero                                              # => Infinity
BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, true) # => 16
one / zero # Raises FloatDomainError

All Exceptions

Mode BigDecimal::EXCEPTION_ALL controls all of the above:

BigDecimal.mode(BigDecimal::EXCEPTION_ALL, false) # => 0
BigDecimal.mode(BigDecimal::EXCEPTION_ALL, true)  # => 23

Rounding

Mode BigDecimal::ROUND_MODE controls the way rounding is to be performed; its setting values are:

  • ROUND_UP: Round away from zero. Aliased as :up.

  • ROUND_DOWN: Round toward zero. Aliased as :down and :truncate.

  • ROUND_HALF_UP: Round toward the nearest neighbor; if the neighbors are equidistant, round away from zero. Aliased as :half_up and :default.

  • ROUND_HALF_DOWN: Round toward the nearest neighbor; if the neighbors are equidistant, round toward zero. Aliased as :half_down.

  • ROUND_HALF_EVEN (Banker’s rounding): Round toward the nearest neighbor; if the neighbors are equidistant, round toward the even neighbor. Aliased as :half_even and :banker.

  • ROUND_CEILING: Round toward positive infinity. Aliased as :ceiling and :ceil.

  • ROUND_FLOOR: Round toward negative infinity. Aliased as :floor:.

Returns:



974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
 
# File 'ext/bigdecimal/bigdecimal.c', line 974

static VALUE
BigDecimal_mode(int argc, VALUE *argv, VALUE self)
{
    VALUE which;
    VALUE val;
    unsigned long f,fo;

    rb_scan_args(argc, argv, "11", &which, &val);
    f = (unsigned long)NUM2INT(which);

    if (f & VP_EXCEPTION_ALL) {
	/* Exception mode setting */
	fo = VpGetException();
	if (val == Qnil) return INT2FIX(fo);
	if (val != Qfalse && val!=Qtrue) {
	    rb_raise(rb_eArgError, "second argument must be true or false");
	    return Qnil; /* Not reached */
	}
	if (f & VP_EXCEPTION_INFINITY) {
	    VpSetException((unsigned short)((val == Qtrue) ? (fo | VP_EXCEPTION_INFINITY) :
			(fo & (~VP_EXCEPTION_INFINITY))));
	}
	fo = VpGetException();
	if (f & VP_EXCEPTION_NaN) {
	    VpSetException((unsigned short)((val == Qtrue) ? (fo | VP_EXCEPTION_NaN) :
			(fo & (~VP_EXCEPTION_NaN))));
	}
	fo = VpGetException();
	if (f & VP_EXCEPTION_UNDERFLOW) {
	    VpSetException((unsigned short)((val == Qtrue) ? (fo | VP_EXCEPTION_UNDERFLOW) :
			(fo & (~VP_EXCEPTION_UNDERFLOW))));
	}
	fo = VpGetException();
	if(f & VP_EXCEPTION_ZERODIVIDE) {
	    VpSetException((unsigned short)((val == Qtrue) ? (fo | VP_EXCEPTION_ZERODIVIDE) :
			(fo & (~VP_EXCEPTION_ZERODIVIDE))));
	}
	fo = VpGetException();
	return INT2FIX(fo);
    }
    if (VP_ROUND_MODE == f) {
	/* Rounding mode setting */
	unsigned short sw;
	fo = VpGetRoundMode();
	if (NIL_P(val)) return INT2FIX(fo);
	sw = check_rounding_mode(val);
	fo = VpSetRoundMode(sw);
	return INT2FIX(fo);
    }
    rb_raise(rb_eTypeError, "first argument for BigDecimal.mode invalid");
    return Qnil;
}

.save_exception_mode { ... } ⇒ Object

Execute the provided block, but preserve the exception mode

BigDecimal.save_exception_mode do
  BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
  BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)

  BigDecimal(BigDecimal('Infinity'))
  BigDecimal(BigDecimal('-Infinity'))
  BigDecimal(BigDecimal('NaN'))
end

For use with the BigDecimal::EXCEPTION_*

See BigDecimal.mode

Yields:



3146
3147
3148
3149
3150
3151
3152
3153
3154
3155
 
# File 'ext/bigdecimal/bigdecimal.c', line 3146

static VALUE
BigDecimal_save_exception_mode(VALUE self)
{
    unsigned short const exception_mode = VpGetException();
    int state;
    VALUE ret = rb_protect(rb_yield, Qnil, &state);
    VpSetException(exception_mode);
    if (state) rb_jump_tag(state);
    return ret;
}

.save_limit { ... } ⇒ Object

Execute the provided block, but preserve the precision limit

BigDecimal.limit(100)
puts BigDecimal.limit
BigDecimal.save_limit do
    BigDecimal.limit(200)
    puts BigDecimal.limit
end
puts BigDecimal.limit

Yields:



3196
3197
3198
3199
3200
3201
3202
3203
3204
3205
 
# File 'ext/bigdecimal/bigdecimal.c', line 3196

static VALUE
BigDecimal_save_limit(VALUE self)
{
    size_t const limit = VpGetPrecLimit();
    int state;
    VALUE ret = rb_protect(rb_yield, Qnil, &state);
    VpSetPrecLimit(limit);
    if (state) rb_jump_tag(state);
    return ret;
}

.save_rounding_mode { ... } ⇒ Object

Execute the provided block, but preserve the rounding mode

BigDecimal.save_rounding_mode do
  BigDecimal.mode(BigDecimal::ROUND_MODE, :up)
  puts BigDecimal.mode(BigDecimal::ROUND_MODE)
end

For use with the BigDecimal::ROUND_*

See BigDecimal.mode

Yields:



3171
3172
3173
3174
3175
3176
3177
3178
3179
3180
 
# File 'ext/bigdecimal/bigdecimal.c', line 3171

static VALUE
BigDecimal_save_rounding_mode(VALUE self)
{
    unsigned short const round_mode = VpGetRoundMode();
    int state;
    VALUE ret = rb_protect(rb_yield, Qnil, &state);
    VpSetRoundMode(round_mode);
    if (state) rb_jump_tag(state);
    return ret;
}

Instance Method Details

#% ⇒ Object

%: a%b = a - (a.to_f/b).floor * b



1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
 
# File 'ext/bigdecimal/bigdecimal.c', line 1813

static VALUE
BigDecimal_mod(VALUE self, VALUE r) /* %: a%b = a - (a.to_f/b).floor * b */
{
    NULLABLE_BDVALUE div, mod;

    if (BigDecimal_DoDivmod(self, r, &div, &mod, false)) {
        return CheckGetValue(bdvalue_nonnullable(mod));
    }
    return DoSomeOne(self, r, '%');
}

#*(b) ⇒ Object

Multiply by the specified value.

The result precision will be the precision of the sum of each precision.

See BigDecimal#mult.



1607
1608
1609
1610
1611
1612
 
# File 'ext/bigdecimal/bigdecimal.c', line 1607

static VALUE
BigDecimal_mult(VALUE self, VALUE r)
{
    if (!is_coerceable_to_BigDecimal(r)) return DoSomeOne(self, r, '*');
    return BigDecimal_mult_with_coerce(self, r, 0);
}

#**(y) ⇒ Object

call-seq:

  self ** other -> bigdecimal

Returns the \BigDecimal value of +self+ raised to power +other+:

  b = BigDecimal('3.14')
  b ** 2              # => 0.98596e1
  b ** 2.0            # => 0.98596e1
  b ** Rational(2, 1) # => 0.98596e1

Related: BigDecimal#power.



77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/bigdecimal.rb', line 77

def **(y)
  case y
  when BigDecimal, Integer, Float, Rational
    power(y)
  when nil
    raise TypeError, 'wrong argument type NilClass'
  else
    x, y = y.coerce(self)
    x**y
  end
end

#+(value) ⇒ Object

Returns the BigDecimal sum of self and value:

b = BigDecimal('111111.111') # => 0.111111111e6
b + 2                        # => 0.111113111e6
b + 2.0                      # => 0.111113111e6
b + Rational(2, 1)           # => 0.111113111e6
b + Complex(2, 0)            # => (0.111113111e6+0i)

See the Note About Precision.



1315
1316
1317
1318
1319
1320
 
# File 'ext/bigdecimal/bigdecimal.c', line 1315

static VALUE
BigDecimal_add(VALUE self, VALUE r)
{
    if (!is_coerceable_to_BigDecimal(r)) return DoSomeOne(self, r, '+');
    return BigDecimal_addsub_with_coerce(self, r, 0, +1);
}

#+ ⇒ self

Returns self:

+BigDecimal(5)  # => 0.5e1
+BigDecimal(-5) # => -0.5e1

Returns:

  • (self) 


1284
1285
1286
1287
1288
 
# File 'ext/bigdecimal/bigdecimal.c', line 1284

static VALUE
BigDecimal_uplus(VALUE self)
{
    return self;
}

#-(value) ⇒ Object

Returns the BigDecimal difference of self and value:

b = BigDecimal('333333.333') # => 0.333333333e6
b - 2                        # => 0.333331333e6
b - 2.0                      # => 0.333331333e6
b - Rational(2, 1)           # => 0.333331333e6
b - Complex(2, 0)            # => (0.333331333e6+0i)

See the Note About Precision.



1369
1370
1371
1372
1373
1374
 
# File 'ext/bigdecimal/bigdecimal.c', line 1369

static VALUE
BigDecimal_sub(VALUE self, VALUE r)
{
    if (!is_coerceable_to_BigDecimal(r)) return DoSomeOne(self, r, '-');
    return BigDecimal_addsub_with_coerce(self, r, 0, -1);
}

#- ⇒ Object

Returns the BigDecimal negation of self:

b0 = BigDecimal('1.5')
b1 = -b0 # => -0.15e1
b2 = -b1 # => 0.15e1



1587
1588
1589
1590
1591
1592
1593
1594
1595
 
# File 'ext/bigdecimal/bigdecimal.c', line 1587

static VALUE
BigDecimal_neg(VALUE self)
{
    BDVALUE a = GetBDValueMust(self);
    BDVALUE c = NewZeroWrap(1, a.real->Prec * BASE_FIG);
    VpAsgn(c.real, a.real, -10);
    RB_GC_GUARD(a.bigdecimal);
    return CheckGetValue(c);
}

#/ ⇒ Object

For c = self/r: with round operation



1649
1650
1651
1652
1653
1654
1655
 
# File 'ext/bigdecimal/bigdecimal.c', line 1649

static VALUE
BigDecimal_div(VALUE self, VALUE r)
/* For c = self/r: with round operation */
{
    if (!is_coerceable_to_BigDecimal(r)) return DoSomeOne(self, r, '/');
    return BigDecimal_div2(self, r, INT2FIX(0));
}

#<(other) ⇒ Boolean

Returns true if self is less than other, false otherwise:

b = BigDecimal('1.5') # => 0.15e1
b < 2                 # => true
b < 2.0               # => true
b < Rational(2, 1)    # => true
b < 1.5               # => false

Raises an exception if the comparison cannot be made.

Returns:

  • (Boolean) 


1507
1508
1509
1510
1511
 
# File 'ext/bigdecimal/bigdecimal.c', line 1507

static VALUE
BigDecimal_lt(VALUE self, VALUE r)
{
    return BigDecimalCmp(self, r, '<');
}

#<=(other) ⇒ Boolean

Returns true if self is less or equal to than other, false otherwise:

b = BigDecimal('1.5') # => 0.15e1
b <= 2                # => true
b <= 2.0              # => true
b <= Rational(2, 1)   # => true
b <= 1.5              # => true
b < 1                 # => false

Raises an exception if the comparison cannot be made.

Returns:

  • (Boolean) 


1528
1529
1530
1531
1532
 
# File 'ext/bigdecimal/bigdecimal.c', line 1528

static VALUE
BigDecimal_le(VALUE self, VALUE r)
{
    return BigDecimalCmp(self, r, 'L');
}

#<=>(r) ⇒ Object

The comparison operator. a <=> b is 0 if a == b, 1 if a > b, -1 if a < b.



1471
1472
1473
1474
1475
 
# File 'ext/bigdecimal/bigdecimal.c', line 1471

static VALUE
BigDecimal_comp(VALUE self, VALUE r)
{
    return BigDecimalCmp(self, r, '*');
}

#==(r) ⇒ Object

Tests for value equality; returns true if the values are equal.

The == and === operators and the eql? method have the same implementation for BigDecimal.

Values may be coerced to perform the comparison:

BigDecimal('1.0') == 1.0  #=> true



1487
1488
1489
1490
1491
 
# File 'ext/bigdecimal/bigdecimal.c', line 1487

static VALUE
BigDecimal_eq(VALUE self, VALUE r)
{
    return BigDecimalCmp(self, r, '=');
}

#===(r) ⇒ Object

Tests for value equality; returns true if the values are equal.

The == and === operators and the eql? method have the same implementation for BigDecimal.

Values may be coerced to perform the comparison:

BigDecimal('1.0') == 1.0  #=> true



1487
1488
1489
1490
1491
 
# File 'ext/bigdecimal/bigdecimal.c', line 1487

static VALUE
BigDecimal_eq(VALUE self, VALUE r)
{
    return BigDecimalCmp(self, r, '=');
}

#>(other) ⇒ Boolean

Returns true if self is greater than other, false otherwise:

b = BigDecimal('1.5')
b > 1              # => true
b > 1.0            # => true
b > Rational(1, 1) # => true
b > 2              # => false

Raises an exception if the comparison cannot be made.

Returns:

  • (Boolean) 


1548
1549
1550
1551
1552
 
# File 'ext/bigdecimal/bigdecimal.c', line 1548

static VALUE
BigDecimal_gt(VALUE self, VALUE r)
{
    return BigDecimalCmp(self, r, '>');
}

#>=(other) ⇒ Boolean

Returns true if self is greater than or equal to other, false otherwise:

b = BigDecimal('1.5')
b >= 1              # => true
b >= 1.0            # => true
b >= Rational(1, 1) # => true
b >= 1.5            # => true
b > 2               # => false

Raises an exception if the comparison cannot be made.

Returns:

  • (Boolean) 


1569
1570
1571
1572
1573
 
# File 'ext/bigdecimal/bigdecimal.c', line 1569

static VALUE
BigDecimal_ge(VALUE self, VALUE r)
{
    return BigDecimalCmp(self, r, 'G');
}

#_decimal_shift(v) ⇒ Object

Returns self * 10**v without changing the precision.

This method is currently for internal use.

BigDecimal("0.123e10")._decimal_shift(20) #=> "0.123e30"
BigDecimal("0.123e10")._decimal_shift(-20) #=> "0.123e-10"



5
6
7
 
# File 'lib/bigdecimal.rb', line 5

def _decimal_shift(i) # :nodoc:
  to_java.move_point_right(i).to_d
end

#_dump ⇒ String

Returns a string representing the marshalling of self. See module Marshal.

inf = BigDecimal('Infinity') # => Infinity
dumped = inf._dump           # => "9:Infinity"
BigDecimal._load(dumped)     # => Infinity

Returns:



697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
 
# File 'ext/bigdecimal/bigdecimal.c', line 697

static VALUE
BigDecimal_dump(int argc, VALUE *argv, VALUE self)
{
    BDVALUE v;
    char *psz;
    VALUE dummy;
    volatile VALUE dump;
    size_t len;

    rb_scan_args(argc, argv, "01", &dummy);
    v = GetBDValueMust(self);
    dump = rb_str_new(0, VpNumOfChars(v.real, "E")+50);
    psz = RSTRING_PTR(dump);
    snprintf(psz, RSTRING_LEN(dump), "%"PRIuSIZE":", v.real->Prec*VpBaseFig());
    len = strlen(psz);
    VpToString(v.real, psz+len, RSTRING_LEN(dump)-len, 0, 0);
    rb_str_resize(dump, strlen(psz));

    RB_GC_GUARD(v.bigdecimal);
    return dump;
}

#abs ⇒ Object

Returns the BigDecimal absolute value of self:

BigDecimal('5').abs  # => 0.5e1
BigDecimal('-3').abs # => 0.3e1



2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
 
# File 'ext/bigdecimal/bigdecimal.c', line 2070

static VALUE
BigDecimal_abs(VALUE self)
{
    BDVALUE a = GetBDValueMust(self);
    BDVALUE c = NewZeroWrap(1, a.real->Prec * BASE_FIG);
    VpAsgn(c.real, a.real, 10);
    VpChangeSign(c.real, 1);
    RB_GC_GUARD(a.bigdecimal);
    return CheckGetValue(c);
}

#add(value, ndigits) ⇒ Object

Returns the BigDecimal sum of self and value with a precision of ndigits decimal digits.

When ndigits is less than the number of significant digits in the sum, the sum is rounded to that number of digits, according to the current rounding mode; see BigDecimal.mode.

Examples:

# Set the rounding mode.
BigDecimal.mode(BigDecimal::ROUND_MODE, :half_up)
b = BigDecimal('111111.111')
b.add(1, 0)               # => 0.111112111e6
b.add(1, 3)               # => 0.111e6
b.add(1, 6)               # => 0.111112e6
b.add(1, 15)              # => 0.111112111e6
b.add(1.0, 15)            # => 0.111112111e6
b.add(Rational(1, 1), 15) # => 0.111112111e6



2002
2003
2004
2005
2006
 
# File 'ext/bigdecimal/bigdecimal.c', line 2002

static VALUE
BigDecimal_add2(VALUE self, VALUE b, VALUE n)
{
    return BigDecimal_addsub_with_coerce(self, b, check_int_precision(n), +1);
}

#ceil(n) ⇒ Object

Return the smallest integer greater than or equal to the value, as a BigDecimal.

BigDecimal(‘3.14159’).ceil #=> 4 BigDecimal(‘-9.1’).ceil #=> -9

If n is specified and positive, the fractional part of the result has no more than that many digits.

If n is specified and negative, at least that many digits to the left of the decimal point will be 0 in the result.

BigDecimal(‘3.14159’).ceil(3) #=> 3.142 BigDecimal(‘13345.234’).ceil(-2) #=> 13400.0



2277
2278
2279
2280
2281
 
# File 'ext/bigdecimal/bigdecimal.c', line 2277

static VALUE
BigDecimal_ceil(int argc, VALUE *argv, VALUE self)
{
    return BigDecimal_truncate_floor_ceil(argc, argv, self, VP_ROUND_CEIL);
}

#clone ⇒ Object

:nodoc:



2561
2562
2563
2564
2565
 
# File 'ext/bigdecimal/bigdecimal.c', line 2561

static VALUE
BigDecimal_clone(VALUE self)
{
    return self;
}

#coerce(other) ⇒ Object

The coerce method provides support for Ruby type coercion. It is not enabled by default.

This means that binary operations like + * / or - can often be performed on a BigDecimal and an object of another type, if the other object can be coerced into a BigDecimal value.

e.g.

a = BigDecimal("1.0")
b = a / 2.0 #=> 0.5

Note that coercing a String to a BigDecimal is not supported by default; it requires a special compile-time option when building Ruby.



1265
1266
1267
1268
1269
1270
1271
 
# File 'ext/bigdecimal/bigdecimal.c', line 1265

static VALUE
BigDecimal_coerce(VALUE self, VALUE other)
{
    Real* pv = DATA_PTR(self);
    BDVALUE b = GetBDValueWithPrecMust(other, GetCoercePrec(pv, 0));
    return rb_assoc_new(CheckGetValue(b), self);
}

#div(*args) ⇒ Object

call-seq:

div(value)  -> integer
div(value, digits)  -> bigdecimal or integer

Divide by the specified value.

digits

If specified and less than the number of significant digits of the result, the result is rounded to that number of digits, according to BigDecimal.mode.

If digits is 0, the result is the same as for the / operator or #quo.

If digits is not specified, the result is an integer, by analogy with Float#div; see also BigDecimal#divmod.

See BigDecimal#/. See BigDecimal#quo.

Examples:

a = BigDecimal("4")
b = BigDecimal("3")

a.div(b, 3)  # => 0.133e1

a.div(b, 0)  # => 0.1333333333333333333e1
a / b        # => 0.1333333333333333333e1
a.quo(b)     # => 0.1333333333333333333e1

a.div(b)     # => 1



1967
1968
1969
1970
1971
1972
1973
1974
1975
 
# File 'ext/bigdecimal/bigdecimal.c', line 1967

static VALUE
BigDecimal_div3(int argc, VALUE *argv, VALUE self)
{
    VALUE b,n;

    rb_scan_args(argc, argv, "11", &b, &n);

    return BigDecimal_div2(self, b, n);
}

#divmod(value) ⇒ Object

Divides by the specified value, and returns the quotient and modulus as BigDecimal numbers. The quotient is rounded towards negative infinity.

For example:

require 'bigdecimal'

a = BigDecimal("42")
b = BigDecimal("9")

q, m = a.divmod(b)

c = q * b + m

a == c  #=> true

The quotient q is (a/b).floor, and the modulus is the amount that must be added to q * b to get a.



1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
 
# File 'ext/bigdecimal/bigdecimal.c', line 1864

static VALUE
BigDecimal_divmod(VALUE self, VALUE r)
{
    NULLABLE_BDVALUE div, mod;

    if (BigDecimal_DoDivmod(self, r, &div, &mod, false)) {
        return rb_assoc_new(CheckGetValue(bdvalue_nonnullable(div)), CheckGetValue(bdvalue_nonnullable(mod)));
    }
    return DoSomeOne(self,r,rb_intern("divmod"));
}

#dup ⇒ Object

:nodoc:



2561
2562
2563
2564
2565
 
# File 'ext/bigdecimal/bigdecimal.c', line 2561

static VALUE
BigDecimal_clone(VALUE self)
{
    return self;
}

#eql?(r) ⇒ Boolean

Tests for value equality; returns true if the values are equal.

The == and === operators and the eql? method have the same implementation for BigDecimal.

Values may be coerced to perform the comparison:

BigDecimal('1.0') == 1.0  #=> true

Returns:

  • (Boolean) 


1487
1488
1489
1490
1491
 
# File 'ext/bigdecimal/bigdecimal.c', line 1487

static VALUE
BigDecimal_eq(VALUE self, VALUE r)
{
    return BigDecimalCmp(self, r, '=');
}

#exponent ⇒ Object

Returns the exponent of the BigDecimal number, as an Integer.

If the number can be represented as 0.xxxxxx*10**n where xxxxxx is a string of digits with no leading zeros, then n is the exponent.



2450
2451
2452
2453
2454
2455
 
# File 'ext/bigdecimal/bigdecimal.c', line 2450

static VALUE
BigDecimal_exponent(VALUE self)
{
    ssize_t e = VpExponent10(GetSelfVpValue(self));
    return SSIZET2NUM(e);
}

#finite? ⇒ Boolean

Returns True if the value is finite (not NaN or infinite).

Returns:

  • (Boolean) 


1100
1101
1102
1103
1104
1105
1106
1107
 
# File 'ext/bigdecimal/bigdecimal.c', line 1100

static VALUE
BigDecimal_IsFinite(VALUE self)
{
    Real *p = GetSelfVpValue(self);
    if (VpIsNaN(p)) return Qfalse;
    if (VpIsInf(p)) return Qfalse;
    return Qtrue;
}

#fix ⇒ Object

Return the integer part of the number, as a BigDecimal.



2083
2084
2085
2086
2087
2088
2089
2090
2091
 
# File 'ext/bigdecimal/bigdecimal.c', line 2083

static VALUE
BigDecimal_fix(VALUE self)
{
    BDVALUE a = GetBDValueMust(self);
    BDVALUE c = NewZeroWrap(1, (a.real->Prec + 1) * BASE_FIG);
    VpActiveRound(c.real, a.real, VP_ROUND_DOWN, 0); /* 0: round off */
    RB_GC_GUARD(a.bigdecimal);
    return CheckGetValue(c);
}

#floor(n) ⇒ Object

Return the largest integer less than or equal to the value, as a BigDecimal.

BigDecimal(‘3.14159’).floor #=> 3 BigDecimal(‘-9.1’).floor #=> -10

If n is specified and positive, the fractional part of the result has no more than that many digits.

If n is specified and negative, at least that many digits to the left of the decimal point will be 0 in the result.

BigDecimal(‘3.14159’).floor(3) #=> 3.141 BigDecimal(‘13345.234’).floor(-2) #=> 13300.0



2254
2255
2256
2257
2258
 
# File 'ext/bigdecimal/bigdecimal.c', line 2254

static VALUE
BigDecimal_floor(int argc, VALUE *argv, VALUE self)
{
    return BigDecimal_truncate_floor_ceil(argc, argv, self, VP_ROUND_FLOOR);
}

#frac ⇒ Object

Return the fractional part of the number, as a BigDecimal.



2227
2228
2229
2230
2231
2232
2233
2234
2235
 
# File 'ext/bigdecimal/bigdecimal.c', line 2227

static VALUE
BigDecimal_frac(VALUE self)
{
    BDVALUE a = GetBDValueMust(self);
    BDVALUE c = NewZeroWrap(1, (a.real->Prec + 1) * BASE_FIG);
    VpFrac(c.real, a.real);
    RB_GC_GUARD(a.bigdecimal);
    return CheckGetValue(c);
}

#hash ⇒ Integer

Returns the integer hash value for self.

Two instances of BigDecimal have the same hash value if and only if they have equal:

  • Sign.

  • Fractional part.

  • Exponent.

Returns:



671
672
673
674
675
676
677
678
679
680
681
682
683
 
# File 'ext/bigdecimal/bigdecimal.c', line 671

static VALUE
BigDecimal_hash(VALUE self)
{
    BDVALUE v = GetBDValueMust(self);
    st_index_t hash = (st_index_t)v.real->sign;
    /* hash!=2: the case for 0(1),NaN(0) or +-Infinity(3) is sign itself */
    if(hash == 2 || hash == (st_index_t)-2) {
        hash ^= rb_memhash(v.real->frac, sizeof(DECDIG)*v.real->Prec);
        hash += v.real->exponent;
    }
    RB_GC_GUARD(v.bigdecimal);
    return ST2FIX(hash);
}

#infinite? ⇒ Boolean

Returns nil, -1, or 1 depending on whether the value is finite, -Infinity, or Infinity.

Returns:

  • (Boolean) 


1090
1091
1092
1093
1094
1095
1096
1097
 
# File 'ext/bigdecimal/bigdecimal.c', line 1090

static VALUE
BigDecimal_IsInfinite(VALUE self)
{
    Real *p = GetSelfVpValue(self);
    if (VpIsPosInf(p)) return INT2FIX(1);
    if (VpIsNegInf(p)) return INT2FIX(-1);
    return Qnil;
}

#inspect ⇒ Object

Returns a string representation of self.

BigDecimal("1234.5678").inspect
  #=> "0.12345678e4"



2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
 
# File 'ext/bigdecimal/bigdecimal.c', line 2462

static VALUE
BigDecimal_inspect(VALUE self)
{
    BDVALUE v;
    volatile VALUE str;
    size_t nc;

    v = GetBDValueMust(self);
    nc = VpNumOfChars(v.real, "E");

    str = rb_str_new(0, nc);
    VpToString(v.real, RSTRING_PTR(str), RSTRING_LEN(str), 0, 0);
    rb_str_resize(str, strlen(RSTRING_PTR(str)));

    RB_GC_GUARD(v.bigdecimal);
    return str;
}

#modulo ⇒ Object

%: a%b = a - (a.to_f/b).floor * b



1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
 
# File 'ext/bigdecimal/bigdecimal.c', line 1813

static VALUE
BigDecimal_mod(VALUE self, VALUE r) /* %: a%b = a - (a.to_f/b).floor * b */
{
    NULLABLE_BDVALUE div, mod;

    if (BigDecimal_DoDivmod(self, r, &div, &mod, false)) {
        return CheckGetValue(bdvalue_nonnullable(mod));
    }
    return DoSomeOne(self, r, '%');
}

#mult(other, ndigits) ⇒ Object

Returns the BigDecimal product of self and value with a precision of ndigits decimal digits.

When ndigits is less than the number of significant digits in the sum, the sum is rounded to that number of digits, according to the current rounding mode; see BigDecimal.mode.

Examples:

# Set the rounding mode.
BigDecimal.mode(BigDecimal::ROUND_MODE, :half_up)
b = BigDecimal('555555.555')
b.mult(3, 0)              # => 0.1666666665e7
b.mult(3, 3)              # => 0.167e7
b.mult(3, 6)              # => 0.166667e7
b.mult(3, 15)             # => 0.1666666665e7
b.mult(3.0, 0)            # => 0.1666666665e7
b.mult(Rational(3, 1), 0) # => 0.1666666665e7
b.mult(Complex(3, 0), 0)  # => (0.1666666665e7+0.0i)



2053
2054
2055
2056
2057
 
# File 'ext/bigdecimal/bigdecimal.c', line 2053

static VALUE
BigDecimal_mult2(VALUE self, VALUE b, VALUE n)
{
    return BigDecimal_mult_with_coerce(self, b, check_int_precision(n));
}

#n_significant_digits ⇒ Integer

Returns the number of decimal significant digits in self.

BigDecimal("0").n_significant_digits         # => 0
BigDecimal("1").n_significant_digits         # => 1
BigDecimal("1.1").n_significant_digits       # => 2
BigDecimal("3.1415").n_significant_digits    # => 5
BigDecimal("-1e20").n_significant_digits     # => 1
BigDecimal("1e-20").n_significant_digits     # => 1
BigDecimal("Infinity").n_significant_digits  # => 0
BigDecimal("-Infinity").n_significant_digits # => 0
BigDecimal("NaN").n_significant_digits       # => 0

Returns:



633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
 
# File 'ext/bigdecimal/bigdecimal.c', line 633

static VALUE
BigDecimal_n_significant_digits(VALUE self)
{
    BDVALUE v = GetBDValueMust(self);
    if (VpIsZero(v.real) || !VpIsDef(v.real)) {
        return INT2FIX(0);
    }

    ssize_t n = v.real->Prec;  /* The length of frac without trailing zeros. */
    for (n = v.real->Prec; n > 0 && v.real->frac[n-1] == 0; --n);
    if (n == 0) return INT2FIX(0);

    DECDIG x;
    int nlz = BASE_FIG;
    for (x = v.real->frac[0]; x > 0; x /= 10) --nlz;

    int ntz = 0;
    for (x = v.real->frac[n-1]; x > 0 && x % 10 == 0; x /= 10) ++ntz;

    RB_GC_GUARD(v.bigdecimal);
    ssize_t n_significant_digits = BASE_FIG*n - nlz - ntz;
    return SSIZET2NUM(n_significant_digits);
}

#nan? ⇒ Boolean

Returns True if the value is Not a Number.

Returns:

  • (Boolean) 


1079
1080
1081
1082
1083
1084
1085
 
# File 'ext/bigdecimal/bigdecimal.c', line 1079

static VALUE
BigDecimal_IsNaN(VALUE self)
{
    Real *p = GetSelfVpValue(self);
    if (VpIsNaN(p))  return Qtrue;
    return Qfalse;
}

#nonzero? ⇒ Boolean

Returns self if the value is non-zero, nil otherwise.

Returns:

  • (Boolean) 


1461
1462
1463
1464
1465
1466
 
# File 'ext/bigdecimal/bigdecimal.c', line 1461

static VALUE
BigDecimal_nonzero(VALUE self)
{
    Real *a = GetSelfVpValue(self);
    return VpIsZero(a) ? Qnil : self;
}

#power(y, prec = 0) ⇒ Object

call-seq:

power(n)
power(n, prec)

Returns the value raised to the power of n.

Also available as the operator **.



97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
 
# File 'lib/bigdecimal.rb', line 97

def power(y, prec = 0)
  prec = Internal.coerce_validate_prec(prec, :power, accept_zero: true)
  x = self
  y = Internal.coerce_to_bigdecimal(y, prec.nonzero? || n_significant_digits, :power)

  return Internal.nan_computation_result if x.nan? || y.nan?
  return BigDecimal(1) if y.zero?

  if y.infinite?
    if x < 0
      return BigDecimal(0) if x < -1 && y.negative?
      return BigDecimal(0) if x > -1 && y.positive?
      raise Math::DomainError, 'Result undefined for negative base raised to infinite power'
    elsif x < 1
      return y.positive? ? BigDecimal(0) : BigDecimal::Internal.infinity_computation_result
    elsif x == 1
      return BigDecimal(1)
    else
      return y.positive? ? BigDecimal::Internal.infinity_computation_result : BigDecimal(0)
    end
  end

  if x.infinite? && y < 0
    # Computation result will be +0 or -0. Avoid overflow.
    neg = x < 0 && y.frac.zero? && y % 2 == 1
    return neg ? -BigDecimal(0) : BigDecimal(0)
  end

  if x.zero?
    return BigDecimal(1) if y.zero?
    return BigDecimal(0) if y > 0
    if y.frac.zero? && y % 2 == 1 && x.sign == -1
      return -BigDecimal::Internal.infinity_computation_result
    else
      return BigDecimal::Internal.infinity_computation_result
    end
  elsif x < 0
    if y.frac.zero?
      if y % 2 == 0
        return (-x).power(y, prec)
      else
        return -(-x).power(y, prec)
      end
    else
      raise Math::DomainError, 'Computation results in complex number'
    end
  elsif x == 1
    return BigDecimal(1)
  end

  prec = BigDecimal.limit if prec.zero?
  frac_part = y.frac

  if frac_part.zero? && prec.zero?
    # Infinite precision calculation for `x ** int` and `x.power(int)`
    int_part = y.fix.to_i
    int_part = -int_part if (neg = int_part < 0)
    ans = BigDecimal(1)
    n = 1
    xn = x
    while true
      ans *= xn if int_part.allbits?(n)
      n <<= 1
      break if n > int_part
      xn *= xn
      # Detect overflow/underflow before consuming infinite memory
      if (xn.exponent.abs - 1) * int_part / n >= 0x7FFFFFFFFFFFFFFF
        return ((xn.exponent > 0) ^ neg ? BigDecimal::Internal.infinity_computation_result : BigDecimal(0)) * (int_part.even? || x > 0 ? 1 : -1)
      end
    end
    return neg ? BigDecimal(1) / ans : ans
  end

  prec = [x.n_significant_digits, y.n_significant_digits, BigDecimal.double_fig].max + BigDecimal.double_fig if prec.zero?

  if y < 0
    inv = x.power(-y, prec)
    return BigDecimal(0) if inv.infinite?
    return BigDecimal::Internal.infinity_computation_result if inv.zero?
    return BigDecimal(1).div(inv, prec)
  end

  prec2 = prec + BigDecimal.double_fig

  if frac_part.zero? && y.exponent < Math.log(prec) * 5 + 20
    # Use exponentiation by squaring if y is an integer and not too large
    pow_prec = prec2 + y.exponent
    n = 1
    xn = x
    ans = BigDecimal(1)
    int_part = y.fix.to_i
    while true
      ans = ans.mult(xn, pow_prec) if int_part.allbits?(n)
      n <<= 1
      break if n > int_part
      xn = xn.mult(xn, pow_prec)
    end
    ans.mult(1, prec)
  else
    if x > 1
      # To calculate exp(z, prec), z needs prec+max(z.exponent, 0) precision if z > 0.
      # Estimate (y*log(x)).exponent
      logx_exponent = x < 2 ? (x - 1).exponent : Math.log10(x.exponent).round
      ylogx_exponent = y.exponent + logx_exponent
      prec2 += [ylogx_exponent, 0].max
    end
    BigMath.exp(BigMath.log(x, prec2).mult(y, prec2), prec)
  end
end

#precision ⇒ Integer

Returns the number of decimal digits in self:

BigDecimal("0").precision         # => 0
BigDecimal("1").precision         # => 1
BigDecimal("1.1").precision       # => 2
BigDecimal("3.1415").precision    # => 5
BigDecimal("-1e20").precision     # => 21
BigDecimal("1e-20").precision     # => 20
BigDecimal("Infinity").precision  # => 0
BigDecimal("-Infinity").precision # => 0
BigDecimal("NaN").precision       # => 0

Returns:



567
568
569
570
571
572
573
 
# File 'ext/bigdecimal/bigdecimal.c', line 567

static VALUE
BigDecimal_precision(VALUE self)
{
    ssize_t precision;
    BigDecimal_count_precision_and_scale(self, &precision, NULL);
    return SSIZET2NUM(precision);
}

#precision_scale ⇒ Array

Returns a 2-length array; the first item is the result of BigDecimal#precision and the second one is of BigDecimal#scale.

See BigDecimal#precision. See BigDecimal#scale.

Returns:

  • (Array) 


609
610
611
612
613
614
615
 
# File 'ext/bigdecimal/bigdecimal.c', line 609

static VALUE
BigDecimal_precision_scale(VALUE self)
{
    ssize_t precision, scale;
    BigDecimal_count_precision_and_scale(self, &precision, &scale);
    return rb_assoc_new(SSIZET2NUM(precision), SSIZET2NUM(scale));
}

#precs ⇒ Array

Returns an Array of two Integer values that represent platform-dependent internal storage properties.

This method is deprecated and will be removed in the future. Instead, use BigDecimal#n_significant_digits for obtaining the number of significant digits in scientific notation, and BigDecimal#precision for obtaining the number of digits in decimal notation.

Returns:

  • (Array) 


416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
 
# File 'ext/bigdecimal/bigdecimal.c', line 416

static VALUE
BigDecimal_prec(VALUE self)
{
    BDVALUE v;
    VALUE obj;

    rb_category_warn(RB_WARN_CATEGORY_DEPRECATED,
                     "BigDecimal#precs is deprecated and will be removed in the future; "
                     "use BigDecimal#precision instead.");

    v = GetBDValueMust(self);
    obj = rb_assoc_new(SIZET2NUM(v.real->Prec*VpBaseFig()),
		       SIZET2NUM(v.real->MaxPrec*VpBaseFig()));

    RB_GC_GUARD(v.bigdecimal);
    return obj;
}

#quo(value) ⇒ Object #quo(value, digits) ⇒ Object

Divide by the specified value.

digits

If specified and less than the number of significant digits of the result, the result is rounded to the given number of digits, according to the rounding mode indicated by BigDecimal.mode.

If digits is 0 or omitted, the result is the same as for the / operator.

See BigDecimal#/. See BigDecimal#div.



1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
 
# File 'ext/bigdecimal/bigdecimal.c', line 1675

static VALUE
BigDecimal_quo(int argc, VALUE *argv, VALUE self)
{
    VALUE value, digits, result;
    SIGNED_VALUE n = -1;

    argc = rb_scan_args(argc, argv, "11", &value, &digits);
    if (argc > 1) {
        n = check_int_precision(digits);
    }

    if (n > 0) {
        result = BigDecimal_div2(self, value, digits);
    }
    else {
        result = BigDecimal_div(self, value);
    }

    return result;
}

#remainder ⇒ Object

remainder



1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
 
# File 'ext/bigdecimal/bigdecimal.c', line 1831

static VALUE
BigDecimal_remainder(VALUE self, VALUE r) /* remainder */
{
    NULLABLE_BDVALUE div, mod = { Qnil, NULL };

    if (BigDecimal_DoDivmod(self, r, &div, &mod, true)) {
        return CheckGetValue(bdvalue_nonnullable(mod));
    }
    return DoSomeOne(self, r, rb_intern("remainder"));
}

#round(n, mode) ⇒ Object

Round to the nearest integer (by default), returning the result as a BigDecimal if n is specified and positive, or as an Integer if it isn’t.

BigDecimal(‘3.14159’).round #=> 3 BigDecimal(‘8.7’).round #=> 9 BigDecimal(‘-9.9’).round #=> -10

BigDecimal(‘3.14159’).round(2).class.name #=> “BigDecimal” BigDecimal(‘3.14159’).round.class.name #=> “Integer” BigDecimal(‘3.14159’).round(0).class.name #=> “Integer”

If n is specified and positive, the fractional part of the result has no more than that many digits.

If n is specified and negative, at least that many digits to the left of the decimal point will be 0 in the result, and return value will be an Integer.

BigDecimal(‘3.14159’).round(3) #=> 3.142 BigDecimal(‘13345.234’).round(-2) #=> 13300

The value of the optional mode argument can be used to determine how rounding is performed; see BigDecimal.mode.



2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
 
# File 'ext/bigdecimal/bigdecimal.c', line 2119

static VALUE
BigDecimal_round(int argc, VALUE *argv, VALUE self)
{
    BDVALUE c, a;
    int    iLoc = 0;
    VALUE  vLoc;
    VALUE  vRound;
    int    round_to_int = 0;
    size_t mx;

    unsigned short sw = VpGetRoundMode();

    switch (rb_scan_args(argc, argv, "02", &vLoc, &vRound)) {
      case 0:
	iLoc = 0;
        round_to_int = 1;
	break;
      case 1:
        if (RB_TYPE_P(vLoc, T_HASH)) {
	    sw = check_rounding_mode_option(vLoc);
	}
	else {
	    iLoc = NUM2INT(vLoc);
            if (iLoc < 1) round_to_int = 1;
	}
	break;
      case 2:
	iLoc = NUM2INT(vLoc);
	if (RB_TYPE_P(vRound, T_HASH)) {
	    sw = check_rounding_mode_option(vRound);
	}
	else {
	    sw = check_rounding_mode(vRound);
	}
	break;
      default:
	break;
    }

    a = GetBDValueMust(self);
    mx = (a.real->Prec + 1) * BASE_FIG;
    c = NewZeroWrap(1, mx);

    VpActiveRound(c.real, a.real, sw, iLoc);

    RB_GC_GUARD(a.bigdecimal);

    if (round_to_int) {
        return BigDecimal_to_i(CheckGetValue(c));
    }
    return CheckGetValue(c);
}

#scale ⇒ Integer

Returns the number of decimal digits following the decimal digits in self.

BigDecimal("0").scale         # => 0
BigDecimal("1").scale         # => 0
BigDecimal("1.1").scale       # => 1
BigDecimal("3.1415").scale    # => 4
BigDecimal("-1e20").scale     # => 0
BigDecimal("1e-20").scale     # => 20
BigDecimal("Infinity").scale  # => 0
BigDecimal("-Infinity").scale # => 0
BigDecimal("NaN").scale       # => 0

Returns:



591
592
593
594
595
596
597
 
# File 'ext/bigdecimal/bigdecimal.c', line 591

static VALUE
BigDecimal_scale(VALUE self)
{
    ssize_t scale;
    BigDecimal_count_precision_and_scale(self, NULL, &scale);
    return SSIZET2NUM(scale);
}

#sign ⇒ Object

Returns the sign of the value.

Returns a positive value if > 0, a negative value if < 0. It behaves the same with zeros - it returns a positive value for a positive zero (BigDecimal(‘0’)) and a negative value for a negative zero (BigDecimal(‘-0’)).

The specific value returned indicates the type and sign of the BigDecimal, as follows:

BigDecimal::SIGN_NaN

value is Not a Number

BigDecimal::SIGN_POSITIVE_ZERO

value is +0

BigDecimal::SIGN_NEGATIVE_ZERO

value is -0

BigDecimal::SIGN_POSITIVE_INFINITE

value is +Infinity

BigDecimal::SIGN_NEGATIVE_INFINITE

value is -Infinity

BigDecimal::SIGN_POSITIVE_FINITE

value is positive

BigDecimal::SIGN_NEGATIVE_FINITE

value is negative



3121
3122
3123
3124
3125
3126
 
# File 'ext/bigdecimal/bigdecimal.c', line 3121

static VALUE
BigDecimal_sign(VALUE self)
{ /* sign */
    int s = GetSelfVpValue(self)->sign;
    return INT2FIX(s);
}

#split ⇒ Object

Splits a BigDecimal number into four parts, returned as an array of values.

The first value represents the sign of the BigDecimal, and is -1 or 1, or 0 if the BigDecimal is Not a Number.

The second value is a string representing the significant digits of the BigDecimal, with no leading zeros.

The third value is the base used for arithmetic (currently always 10) as an Integer.

The fourth value is an Integer exponent.

If the BigDecimal can be represented as 0.xxxxxx*10**n, then xxxxxx is the string of significant digits with no leading zeros, and n is the exponent.

From these values, you can translate a BigDecimal to a float as follows:

sign, significant_digits, base, exponent = a.split
f = sign * "0.#{significant_digits}".to_f * (base ** exponent)

(Note that the to_f method is provided as a more convenient way to translate a BigDecimal to a Float.)



2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
 
# File 'ext/bigdecimal/bigdecimal.c', line 2412

static VALUE
BigDecimal_split(VALUE self)
{
    BDVALUE v;
    VALUE obj,str;
    ssize_t e, s;
    char *psz1;

    v = GetBDValueMust(self);
    str = rb_str_new(0, VpNumOfChars(v.real, "E"));
    psz1 = RSTRING_PTR(str);
    VpSzMantissa(v.real, psz1, RSTRING_LEN(str));
    s = 1;
    if(psz1[0] == '-') {
	size_t len = strlen(psz1 + 1);

	memmove(psz1, psz1 + 1, len);
	psz1[len] = '\0';
        s = -1;
    }
    if (psz1[0] == 'N') s = 0; /* NaN */
    e = VpExponent10(v.real);
    obj = rb_ary_new2(4);
    rb_ary_push(obj, INT2FIX(s));
    rb_ary_push(obj, str);
    rb_str_resize(str, strlen(psz1));
    rb_ary_push(obj, INT2FIX(10));
    rb_ary_push(obj, SSIZET2NUM(e));

    RB_GC_GUARD(v.bigdecimal);
    return obj;
}

#sqrt(prec) ⇒ Object

Returns the square root of the value.

Result has at least prec significant digits.

Raises:

  • (FloatDomainError) 


211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/bigdecimal.rb', line 211

def sqrt(prec)
  prec = Internal.coerce_validate_prec(prec, :sqrt, accept_zero: true)
  return Internal.infinity_computation_result if infinite? == 1

  raise FloatDomainError, 'sqrt of negative value' if self < 0
  raise FloatDomainError, "sqrt of 'NaN'(Not a Number)" if nan?
  return self if zero?

  if prec == 0
    prec = BigDecimal.limit.nonzero? || n_significant_digits + BigDecimal.double_fig
  end

  ex = exponent / 2
  x = _decimal_shift(-2 * ex)
  y = BigDecimal(Math.sqrt(x.to_f), 0)
  precs = [prec + BigDecimal.double_fig]
  precs << 2 + precs.last / 2 while precs.last > BigDecimal.double_fig
  precs.reverse_each do |p|
    y = y.add(x.div(y, p), p).div(2, p)
  end
  y._decimal_shift(ex).mult(1, prec)
end

#sub(value, digits) ⇒ Object

Subtract the specified value.

e.g.

c = a.sub(b,n)
digits

If specified and less than the number of significant digits of the result, the result is rounded to that number of digits, according to BigDecimal.mode.



2021
2022
2023
2024
2025
 
# File 'ext/bigdecimal/bigdecimal.c', line 2021

static VALUE
BigDecimal_sub2(VALUE self, VALUE b, VALUE n)
{
    return BigDecimal_addsub_with_coerce(self, b, check_int_precision(n), -1);
}

#to_d ⇒ Object

call-seq:

a.to_d -> bigdecimal

Returns self.

require 'bigdecimal/util'

d = BigDecimal("3.14")
d.to_d                       # => 0.314e1



110
111
112
 
# File 'lib/bigdecimal/util.rb', line 110

def to_d
  self
end

#to_digits ⇒ Object

call-seq:

a.to_digits -> string

Converts a BigDecimal to a String of the form “nnnnnn.mmm”. This method is deprecated; use BigDecimal#to_s(“F”) instead.

require 'bigdecimal/util'

d = BigDecimal("3.14")
d.to_digits                  # => "3.14"



90
91
92
93
94
95
96
97
98
 
# File 'lib/bigdecimal/util.rb', line 90

def to_digits
  if self.nan? || self.infinite? || self.zero?
    self.to_s
  else
    i       = self.to_i.to_s
    _,f,_,z = self.frac.split
    i + "." + ("0"*(-z)) + f
  end
end

#to_f ⇒ Object

Returns a new Float object having approximately the same value as the BigDecimal number. Normal accuracy limits and built-in errors of binary Float arithmetic apply.



1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
 
# File 'ext/bigdecimal/bigdecimal.c', line 1161

static VALUE
BigDecimal_to_f(VALUE self)
{
    double d;
    SIGNED_VALUE e;
    char *buf;
    volatile VALUE str;
    BDVALUE v = GetBDValueMust(self);
    bool negative = BIGDECIMAL_NEGATIVE_P(v.real);

    if (VpVtoD(&d, &e, v.real) != 1)
	return rb_float_new(d);
    if (e > (SIGNED_VALUE)(DBL_MAX_10_EXP+BASE_FIG))
	goto overflow;
    if (e < (SIGNED_VALUE)(DBL_MIN_10_EXP-DBL_DIG))
	goto underflow;

    str = rb_str_new(0, VpNumOfChars(v.real, "E"));
    buf = RSTRING_PTR(str);
    VpToString(v.real, buf, RSTRING_LEN(str), 0, 0);

    RB_GC_GUARD(v.bigdecimal);

    errno = 0;
    d = strtod(buf, 0);
    if (errno == ERANGE) {
	if (d == 0.0) goto underflow;
	if (fabs(d) >= HUGE_VAL) goto overflow;
    }
    return rb_float_new(d);

overflow:
    VpException(VP_EXCEPTION_OVERFLOW, "BigDecimal to Float conversion", 0);
    if (negative)
	return rb_float_new(VpGetDoubleNegInf());
    else
	return rb_float_new(VpGetDoublePosInf());

underflow:
    VpException(VP_EXCEPTION_UNDERFLOW, "BigDecimal to Float conversion", 0);
    if (negative)
	return rb_float_new(-0.0);
    else
	return rb_float_new(0.0);
}

#to_i ⇒ Object

Returns the value as an Integer.

If the BigDecimal is infinity or NaN, raises FloatDomainError.



1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
 
# File 'ext/bigdecimal/bigdecimal.c', line 1122

static VALUE
BigDecimal_to_i(VALUE self)
{
    BDVALUE v;
    VALUE ret;

    v = GetBDValueMust(self);
    BigDecimal_check_num(v.real);

    if (v.real->exponent <= 0) return INT2FIX(0);
    if (v.real->exponent == 1) {
        ret = LONG2NUM((long)(VpGetSign(v.real) * (DECDIG_DBL_SIGNED)v.real->frac[0]));
    }
    else {
        VALUE fix = (ssize_t)v.real->Prec > v.real->exponent ? BigDecimal_fix(self) : self;
        VALUE digits = RARRAY_AREF(BigDecimal_split(fix), 1);
        ssize_t dpower = VpExponent10(v.real) - (ssize_t)RSTRING_LEN(digits);
        ret = rb_funcall(digits, rb_intern("to_i"), 0);

        if (BIGDECIMAL_NEGATIVE_P(v.real)) {
            ret = rb_funcall(ret, '*', 1, INT2FIX(-1));
        }
        if (dpower) {
            VALUE pow10 = rb_funcall(INT2FIX(10), rb_intern("**"), 1, SSIZET2NUM(dpower));
            // In Ruby < 3.4, int**int may return Float::INFINITY
            if (RB_TYPE_P(pow10, T_FLOAT)) rb_raise(rb_eFloatDomainError, "Infinity");

            ret = rb_funcall(ret, '*', 1, pow10);
        }
    }

    RB_GC_GUARD(v.bigdecimal);
    return ret;
}

#to_int ⇒ Object

Returns the value as an Integer.

If the BigDecimal is infinity or NaN, raises FloatDomainError.



1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
 
# File 'ext/bigdecimal/bigdecimal.c', line 1122

static VALUE
BigDecimal_to_i(VALUE self)
{
    BDVALUE v;
    VALUE ret;

    v = GetBDValueMust(self);
    BigDecimal_check_num(v.real);

    if (v.real->exponent <= 0) return INT2FIX(0);
    if (v.real->exponent == 1) {
        ret = LONG2NUM((long)(VpGetSign(v.real) * (DECDIG_DBL_SIGNED)v.real->frac[0]));
    }
    else {
        VALUE fix = (ssize_t)v.real->Prec > v.real->exponent ? BigDecimal_fix(self) : self;
        VALUE digits = RARRAY_AREF(BigDecimal_split(fix), 1);
        ssize_t dpower = VpExponent10(v.real) - (ssize_t)RSTRING_LEN(digits);
        ret = rb_funcall(digits, rb_intern("to_i"), 0);

        if (BIGDECIMAL_NEGATIVE_P(v.real)) {
            ret = rb_funcall(ret, '*', 1, INT2FIX(-1));
        }
        if (dpower) {
            VALUE pow10 = rb_funcall(INT2FIX(10), rb_intern("**"), 1, SSIZET2NUM(dpower));
            // In Ruby < 3.4, int**int may return Float::INFINITY
            if (RB_TYPE_P(pow10, T_FLOAT)) rb_raise(rb_eFloatDomainError, "Infinity");

            ret = rb_funcall(ret, '*', 1, pow10);
        }
    }

    RB_GC_GUARD(v.bigdecimal);
    return ret;
}

#to_r ⇒ Object

Converts a BigDecimal to a Rational.



1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
 
# File 'ext/bigdecimal/bigdecimal.c', line 1210

static VALUE
BigDecimal_to_r(VALUE self)
{
    BDVALUE v;
    ssize_t sign, power, denomi_power;
    VALUE a, digits, numerator;

    v = GetBDValueMust(self);
    BigDecimal_check_num(v.real);
    sign = VpGetSign(v.real);
    power = VpExponent10(v.real);
    RB_GC_GUARD(v.bigdecimal);

    a = BigDecimal_split(self);
    digits = RARRAY_AREF(a, 1);
    denomi_power = power - RSTRING_LEN(digits);
    numerator = rb_funcall(digits, rb_intern("to_i"), 0);

    if (sign < 0) {
	numerator = rb_funcall(numerator, '*', 1, INT2FIX(-1));
    }
    if (denomi_power < 0) {
	return rb_Rational(numerator,
			   rb_funcall(INT2FIX(10), rb_intern("**"), 1,
				      INT2FIX(-denomi_power)));
    }
    else {
	return rb_Rational1(rb_funcall(numerator, '*', 1,
				       rb_funcall(INT2FIX(10), rb_intern("**"), 1,
						  INT2FIX(denomi_power))));
    }
}

#to_s(s) ⇒ Object

Converts the value to a string.

The default format looks like 0.xxxxEnn.

The optional parameter s consists of either an integer; or an optional ‘+’ or ‘ ’, followed by an optional number, followed by an optional ‘E’ or ‘F’.

If there is a ‘+’ at the start of s, positive values are returned with a leading ‘+’.

A space at the start of s returns positive values with a leading space.

If s contains a number, a space is inserted after each group of that many digits, starting from ‘.’ and counting outwards.

If s ends with an ‘E’, scientific notation (0.xxxxEnn) is used.

If s ends with an ‘F’, conventional floating point notation is used.

Examples:

BigDecimal('-1234567890123.45678901234567890').to_s('5F')
  #=> '-123 45678 90123.45678 90123 45678 9'

BigDecimal('1234567890123.45678901234567890').to_s('+8F')
  #=> '+12345 67890123.45678901 23456789'

BigDecimal('1234567890123.45678901234567890').to_s(' F')
  #=> ' 1234567890123.4567890123456789'



2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
 
# File 'ext/bigdecimal/bigdecimal.c', line 2316

static VALUE
BigDecimal_to_s(int argc, VALUE *argv, VALUE self)
{
    int   fmt = 0;   /* 0: E format, 1: F format */
    int   fPlus = 0; /* 0: default, 1: set ' ' before digits, 2: set '+' before digits. */
    BDVALUE v;
    volatile VALUE str;
    char  *psz;
    char   ch;
    size_t nc, mc = 0;
    SIGNED_VALUE m;
    VALUE  f;

    v = GetBDValueMust(self);

    if (rb_scan_args(argc, argv, "01", &f) == 1) {
	if (RB_TYPE_P(f, T_STRING)) {
	    psz = StringValueCStr(f);
	    if (*psz == ' ') {
		fPlus = 1;
		psz++;
	    }
	    else if (*psz == '+') {
		fPlus = 2;
		psz++;
	    }
	    while ((ch = *psz++) != 0) {
		if (ISSPACE(ch)) {
		    continue;
		}
		if (!ISDIGIT(ch)) {
		    if (ch == 'F' || ch == 'f') {
			fmt = 1; /* F format */
		    }
		    break;
		}
		mc = mc*10 + ch - '0';
	    }
	}
	else {
	    m = NUM2INT(f);
	    if (m <= 0) {
		rb_raise(rb_eArgError, "argument must be positive");
	    }
	    mc = (size_t)m;
	}
    }
    if (fmt) {
	nc = VpNumOfChars(v.real, "F");
    }
    else {
	nc = VpNumOfChars(v.real, "E");
    }
    if (mc > 0) {
	nc += (nc + mc - 1) / mc + 1;
    }

    str = rb_usascii_str_new(0, nc);
    psz = RSTRING_PTR(str);

    if (fmt) {
	VpToFString(v.real, psz, RSTRING_LEN(str), mc, fPlus);
    }
    else {
	VpToString (v.real, psz, RSTRING_LEN(str), mc, fPlus);
    }
    rb_str_resize(str, strlen(psz));

    RB_GC_GUARD(v.bigdecimal);
    return str;
}

#truncate(n) ⇒ Object

Truncate to the nearest integer (by default), returning the result as a BigDecimal.

BigDecimal(‘3.14159’).truncate #=> 3 BigDecimal(‘8.7’).truncate #=> 8 BigDecimal(‘-9.9’).truncate #=> -9

If n is specified and positive, the fractional part of the result has no more than that many digits.

If n is specified and negative, at least that many digits to the left of the decimal point will be 0 in the result.

BigDecimal(‘3.14159’).truncate(3) #=> 3.141 BigDecimal(‘13345.234’).truncate(-2) #=> 13300.0



2219
2220
2221
2222
2223
 
# File 'ext/bigdecimal/bigdecimal.c', line 2219

static VALUE
BigDecimal_truncate(int argc, VALUE *argv, VALUE self)
{
    return BigDecimal_truncate_floor_ceil(argc, argv, self, VP_ROUND_DOWN);
}

#vpdivd(r, cprec) ⇒ Object 



3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271
 
# File 'ext/bigdecimal/bigdecimal.c', line 3259

VALUE
BigDecimal_vpdivd(VALUE self, VALUE r, VALUE cprec) {
    BDVALUE a,b,c,d;
    size_t cn = NUM2INT(cprec);
    a = GetBDValueMust(self);
    b = GetBDValueMust(r);
    c = NewZeroWrap(1, cn * BASE_FIG);
    d = NewZeroWrap(1, VPDIVD_REM_PREC(a.real, b.real, c.real) * BASE_FIG);
    VpDivd(c.real, d.real, a.real, b.real);
    RB_GC_GUARD(a.bigdecimal);
    RB_GC_GUARD(b.bigdecimal);
    return rb_assoc_new(c.bigdecimal, d.bigdecimal);
}

#vpmult(v) ⇒ Object 



3273
3274
3275
3276
3277
3278
3279
3280
3281
3282
3283
 
# File 'ext/bigdecimal/bigdecimal.c', line 3273

VALUE
BigDecimal_vpmult(VALUE self, VALUE v) {
    BDVALUE a,b,c;
    a = GetBDValueMust(self);
    b = GetBDValueMust(v);
    c = NewZeroWrap(1, VPMULT_RESULT_PREC(a.real, b.real) * BASE_FIG);
    VpMult(c.real, a.real, b.real);
    RB_GC_GUARD(a.bigdecimal);
    RB_GC_GUARD(b.bigdecimal);
    return c.bigdecimal;
}

#zero? ⇒ Boolean

Returns True if the value is zero.

Returns:

  • (Boolean) 


1453
1454
1455
1456
1457
1458
 
# File 'ext/bigdecimal/bigdecimal.c', line 1453

static VALUE
BigDecimal_zero(VALUE self)
{
    Real *a = GetSelfVpValue(self);
    return VpIsZero(a) ? Qtrue : Qfalse;
}