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 <shigeo@tinyforest.gr.jp>.

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

Maintained by mrkn <mrkn@mrkn.jp> and ruby-core members.

Documented by zzak <zachary@zacharyscott.net>, mathew <meta@pobox.com>, 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.



657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
 
# File 'ext/bigdecimal/bigdecimal.c', line 657

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.



3005
3006
3007
3008
3009
3010
3011
3012
3013
3014
 
# File 'ext/bigdecimal/bigdecimal.c', line 3005

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.



3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
 
# File 'ext/bigdecimal/bigdecimal.c', line 3029

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:



909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
 
# File 'ext/bigdecimal/bigdecimal.c', line 909

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:



3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
 
# File 'ext/bigdecimal/bigdecimal.c', line 3090

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:



3140
3141
3142
3143
3144
3145
3146
3147
3148
3149
 
# File 'ext/bigdecimal/bigdecimal.c', line 3140

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:



3115
3116
3117
3118
3119
3120
3121
3122
3123
3124
 
# File 'ext/bigdecimal/bigdecimal.c', line 3115

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



1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
 
# File 'ext/bigdecimal/bigdecimal.c', line 1756

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.



1550
1551
1552
1553
1554
1555
 
# File 'ext/bigdecimal/bigdecimal.c', line 1550

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.



127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/bigdecimal.rb', line 127

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.



1239
1240
1241
1242
1243
1244
 
# File 'ext/bigdecimal/bigdecimal.c', line 1239

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) 


1208
1209
1210
1211
1212
 
# File 'ext/bigdecimal/bigdecimal.c', line 1208

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.



1312
1313
1314
1315
1316
1317
 
# File 'ext/bigdecimal/bigdecimal.c', line 1312

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



1530
1531
1532
1533
1534
1535
1536
1537
1538
 
# File 'ext/bigdecimal/bigdecimal.c', line 1530

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



1592
1593
1594
1595
1596
1597
1598
 
# File 'ext/bigdecimal/bigdecimal.c', line 1592

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) 


1450
1451
1452
1453
1454
 
# File 'ext/bigdecimal/bigdecimal.c', line 1450

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) 


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

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.



1414
1415
1416
1417
1418
 
# File 'ext/bigdecimal/bigdecimal.c', line 1414

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



1430
1431
1432
1433
1434
 
# File 'ext/bigdecimal/bigdecimal.c', line 1430

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



1430
1431
1432
1433
1434
 
# File 'ext/bigdecimal/bigdecimal.c', line 1430

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) 


1491
1492
1493
1494
1495
 
# File 'ext/bigdecimal/bigdecimal.c', line 1491

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) 


1512
1513
1514
1515
1516
 
# File 'ext/bigdecimal/bigdecimal.c', line 1512

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:



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

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



2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
 
# File 'ext/bigdecimal/bigdecimal.c', line 2013

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



1945
1946
1947
1948
1949
 
# File 'ext/bigdecimal/bigdecimal.c', line 1945

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



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

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

#clone ⇒ Object

:nodoc:



2504
2505
2506
2507
2508
 
# File 'ext/bigdecimal/bigdecimal.c', line 2504

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.



1189
1190
1191
1192
1193
1194
1195
 
# File 'ext/bigdecimal/bigdecimal.c', line 1189

static VALUE
BigDecimal_coerce(VALUE self, VALUE other)
{
    Real* pv = VpPtr(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



1910
1911
1912
1913
1914
1915
1916
1917
1918
 
# File 'ext/bigdecimal/bigdecimal.c', line 1910

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.



1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
 
# File 'ext/bigdecimal/bigdecimal.c', line 1807

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

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

#dup ⇒ Object

:nodoc:



2504
2505
2506
2507
2508
 
# File 'ext/bigdecimal/bigdecimal.c', line 2504

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) 


1430
1431
1432
1433
1434
 
# File 'ext/bigdecimal/bigdecimal.c', line 1430

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.



2393
2394
2395
2396
2397
2398
 
# File 'ext/bigdecimal/bigdecimal.c', line 2393

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) 


1027
1028
1029
1030
1031
1032
1033
1034
 
# File 'ext/bigdecimal/bigdecimal.c', line 1027

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.



2026
2027
2028
2029
2030
2031
2032
2033
2034
 
# File 'ext/bigdecimal/bigdecimal.c', line 2026

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



2197
2198
2199
2200
2201
 
# File 'ext/bigdecimal/bigdecimal.c', line 2197

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.



2170
2171
2172
2173
2174
2175
2176
2177
2178
 
# File 'ext/bigdecimal/bigdecimal.c', line 2170

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:



606
607
608
609
610
611
612
613
614
615
616
617
618
 
# File 'ext/bigdecimal/bigdecimal.c', line 606

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) 


1017
1018
1019
1020
1021
1022
1023
1024
 
# File 'ext/bigdecimal/bigdecimal.c', line 1017

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"



2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
 
# File 'ext/bigdecimal/bigdecimal.c', line 2405

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



1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
 
# File 'ext/bigdecimal/bigdecimal.c', line 1756

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)



1996
1997
1998
1999
2000
 
# File 'ext/bigdecimal/bigdecimal.c', line 1996

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:



568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
 
# File 'ext/bigdecimal/bigdecimal.c', line 568

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) 


1006
1007
1008
1009
1010
1011
1012
 
# File 'ext/bigdecimal/bigdecimal.c', line 1006

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

#newton_raphson_inverse(prec) ⇒ Object 



3232
3233
3234
3235
 
# File 'ext/bigdecimal/bigdecimal.c', line 3232

VALUE
BigDecimal_newton_raphson_inverse(VALUE self, VALUE prec) {
    return newton_raphson_inverse(self, NUM2SIZET(prec));
}

#nonzero? ⇒ Boolean

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

Returns:

  • (Boolean) 


1404
1405
1406
1407
1408
1409
 
# File 'ext/bigdecimal/bigdecimal.c', line 1404

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

#nttmult(v) ⇒ Object 



3249
3250
3251
3252
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263
 
# File 'ext/bigdecimal/bigdecimal.c', line 3249

VALUE
BigDecimal_nttmult(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);
    ntt_multiply(a.real->Prec, b.real->Prec, a.real->frac, b.real->frac, c.real->frac);
    VpSetSign(c.real, a.real->sign * b.real->sign);
    c.real->exponent = a.real->exponent + b.real->exponent;
    c.real->Prec = a.real->Prec + b.real->Prec;
    VpNmlz(c.real);
    RB_GC_GUARD(a.bigdecimal);
    RB_GC_GUARD(b.bigdecimal);
    return c.bigdecimal;
}

#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 **.



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
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
 
# File 'lib/bigdecimal.rb', line 147

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

  limit = BigDecimal.limit
  frac_part = y.frac

  if frac_part.zero? && prec.zero? && limit.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

  result_prec = prec.nonzero? || [x.n_significant_digits, y.n_significant_digits, BigDecimal.double_fig].max + BigDecimal.double_fig
  result_prec = [result_prec, limit].min if prec.zero? && limit.nonzero?

  prec2 = result_prec + BigDecimal::Internal::EXTRA_PREC

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

  if frac_part.zero? && y.exponent < Math.log(result_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, result_prec)
  else
    if x > 1 && x.finite?
      # 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), result_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:



502
503
504
505
506
507
508
 
# File 'ext/bigdecimal/bigdecimal.c', line 502

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) 


544
545
546
547
548
549
550
 
# File 'ext/bigdecimal/bigdecimal.c', line 544

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));
}

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



1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
 
# File 'ext/bigdecimal/bigdecimal.c', line 1618

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



1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
 
# File 'ext/bigdecimal/bigdecimal.c', line 1774

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.



2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
 
# File 'ext/bigdecimal/bigdecimal.c', line 2062

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:



526
527
528
529
530
531
532
 
# File 'ext/bigdecimal/bigdecimal.c', line 526

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



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

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.)



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 2355

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) 


262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
 
# File 'lib/bigdecimal.rb', line 262

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
    limit = BigDecimal.limit
    prec = n_significant_digits + BigDecimal.double_fig
    prec = [limit, prec].min if limit.nonzero?
  end

  ex = exponent / 2
  x = _decimal_shift(-2 * ex)
  y = BigDecimal(Math.sqrt(x.to_f), 0)
  Internal.newton_loop(prec + BigDecimal::Internal::EXTRA_PREC) 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.



1964
1965
1966
1967
1968
 
# File 'ext/bigdecimal/bigdecimal.c', line 1964

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.



1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
 
# File 'ext/bigdecimal/bigdecimal.c', line 1085

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.



1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
 
# File 'ext/bigdecimal/bigdecimal.c', line 1046

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.



1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
 
# File 'ext/bigdecimal/bigdecimal.c', line 1046

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.



1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
 
# File 'ext/bigdecimal/bigdecimal.c', line 1134

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'



2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
 
# File 'ext/bigdecimal/bigdecimal.c', line 2259

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



2162
2163
2164
2165
2166
 
# File 'ext/bigdecimal/bigdecimal.c', line 2162

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 



3222
3223
3224
3225
 
# File 'ext/bigdecimal/bigdecimal.c', line 3222

VALUE
BigDecimal_vpdivd(VALUE self, VALUE r, VALUE cprec) {
  return BigDecimal_vpdivd_generic(self, r, cprec, VpDivdNormal);
}

#vpdivd_newton(r, cprec) ⇒ Object 



3227
3228
3229
3230
 
# File 'ext/bigdecimal/bigdecimal.c', line 3227

VALUE
BigDecimal_vpdivd_newton(VALUE self, VALUE r, VALUE cprec) {
    return BigDecimal_vpdivd_generic(self, r, cprec, VpDivdNewton);
}

#vpmult(v) ⇒ Object 



3237
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247
 
# File 'ext/bigdecimal/bigdecimal.c', line 3237

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) 


1396
1397
1398
1399
1400
1401
 
# File 'ext/bigdecimal/bigdecimal.c', line 1396

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