Class: BigDecimal
- Inherits:
-
Numeric
- Object
- Numeric
- BigDecimal
- Defined in:
- ext/bigdecimal/bigdecimal.c,
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 isvalue
‘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, and String 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
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.
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)VpBaseVal())
- 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
-
._load(str) ⇒ Object
Internal method used to provide marshalling support.
- .double_fig ⇒ Object
-
.interpret_loosely(string) ⇒ Object
Returns the
BigDecimal
converted loosely fromstring
. -
.limit(*args) ⇒ Object
BigDecimal.limit(digits).
-
.mode(mode, setting = nil) ⇒ Integer
Returns an integer representing the mode settings for exception handling and rounding.
-
.save_exception_mode { ... } ⇒ Object
Execute the provided block, but preserve the exception mode.
-
.save_limit { ... } ⇒ Object
Execute the provided block, but preserve the precision limit.
-
.save_rounding_mode { ... } ⇒ Object
Execute the provided block, but preserve the rounding mode.
Instance Method Summary collapse
-
#% ⇒ Object
%: a%b = a - (a.to_f/b).floor * b.
-
#*(b) ⇒ Object
Multiply by the specified value.
-
#**(other) ⇒ Object
Returns the BigDecimal value of
self
raised to powerother
:. -
#+(value) ⇒ Object
Returns the BigDecimal sum of
self
andvalue
:. -
#+ ⇒ self
Returns
self
:. -
#-(value) ⇒ Object
Returns the BigDecimal difference of
self
andvalue
:. -
#- ⇒ Object
Returns the BigDecimal negation of self:.
-
#/ ⇒ Object
For c = self/r: with round operation.
-
#<(other) ⇒ Boolean
Returns
true
ifself
is less thanother
,false
otherwise:. -
#<=(other) ⇒ Boolean
Returns
true
ifself
is less or equal to thanother
,false
otherwise:. -
#<=>(r) ⇒ Object
The comparison operator.
-
#==(r) ⇒ Object
Tests for value equality; returns true if the values are equal.
-
#===(r) ⇒ Object
Tests for value equality; returns true if the values are equal.
-
#>(other) ⇒ Boolean
Returns
true
ifself
is greater thanother
,false
otherwise:. -
#>=(other) ⇒ Boolean
Returns
true
ifself
is greater than or equal toother
,false
otherwise:. -
#_dump ⇒ String
Returns a string representing the marshalling of
self
. -
#abs ⇒ Object
Returns the BigDecimal absolute value of
self
:. -
#add(value, ndigits) ⇒ Object
Returns the BigDecimal sum of
self
andvalue
with a precision ofndigits
decimal digits. -
#ceil(*args) ⇒ Object
ceil(n).
-
#clone ⇒ Object
:nodoc:.
-
#coerce(other) ⇒ Object
The coerce method provides support for Ruby type coercion.
-
#div(*args) ⇒ Object
call-seq: div(value) -> integer div(value, digits) -> bigdecimal or integer.
-
#divmod(r) ⇒ Object
divmod(value).
-
#dup ⇒ Object
:nodoc:.
-
#eql?(r) ⇒ Boolean
Tests for value equality; returns true if the values are equal.
-
#exponent ⇒ Object
Returns the exponent of the BigDecimal number, as an Integer.
-
#finite? ⇒ Boolean
Returns True if the value is finite (not NaN or infinite).
-
#fix ⇒ Object
Return the integer part of the number, as a BigDecimal.
-
#floor(*args) ⇒ Object
floor(n).
-
#frac ⇒ Object
Return the fractional part of the number, as a BigDecimal.
-
#hash ⇒ Integer
Returns the integer hash value for
self
. -
#infinite? ⇒ Boolean
Returns nil, -1, or 1 depending on whether the value is finite, -Infinity, or Infinity.
-
#inspect ⇒ Object
Returns a string representation of self.
-
#modulo ⇒ Object
%: a%b = a - (a.to_f/b).floor * b.
-
#mult(other, ndigits) ⇒ Object
Returns the BigDecimal product of
self
andvalue
with a precision ofndigits
decimal digits. -
#n_significant_digits ⇒ Integer
Returns the number of decimal significant digits in
self
. -
#nan? ⇒ Boolean
Returns True if the value is Not a Number.
-
#nonzero? ⇒ Boolean
Returns self if the value is non-zero, nil otherwise.
-
#power(*args) ⇒ Object
power(n) power(n, prec).
-
#precision ⇒ Integer
Returns the number of decimal digits in
self
:. -
#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.
-
#precs ⇒ Array
Returns an Array of two Integer values that represent platform-dependent internal storage properties.
-
#quo(*args) ⇒ Object
Divide by the specified value.
-
#remainder ⇒ Object
remainder.
-
#round(*args) ⇒ Object
round(n, mode).
-
#scale ⇒ Integer
Returns the number of decimal digits following the decimal digits in
self
. -
#sign ⇒ Object
Returns the sign of the value.
-
#split ⇒ Object
Splits a BigDecimal number into four parts, returned as an array of values.
-
#sqrt(nFig) ⇒ Object
sqrt(n).
-
#sub(b, n) ⇒ Object
sub(value, digits) -> bigdecimal.
-
#to_d ⇒ Object
call-seq: a.to_d -> bigdecimal.
-
#to_digits ⇒ Object
call-seq: a.to_digits -> string.
-
#to_f ⇒ Object
Returns a new Float object having approximately the same value as the BigDecimal number.
-
#to_i ⇒ Object
Returns the value as an Integer.
-
#to_int ⇒ Object
Returns the value as an Integer.
-
#to_r ⇒ Object
Converts a BigDecimal to a Rational.
-
#to_s(*args) ⇒ Object
to_s(s).
-
#truncate(*args) ⇒ Object
truncate(n).
-
#zero? ⇒ Boolean
Returns True if the value is zero.
Class Method Details
._load(str) ⇒ Object
Internal method used to provide marshalling support. See the Marshal module.
804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 |
# File 'ext/bigdecimal/bigdecimal.c', line 804
static VALUE
BigDecimal_load(VALUE self, VALUE str)
{
ENTER(2);
Real *pv;
unsigned char *pch;
unsigned char ch;
unsigned long m=0;
pch = (unsigned char *)StringValueCStr(str);
/* First get max prec */
while((*pch) != (unsigned char)'\0' && (ch = *pch++) != (unsigned char)':') {
if(!ISDIGIT(ch)) {
rb_raise(rb_eTypeError, "load failed: invalid character in the marshaled string");
}
m = m*10 + (unsigned long)(ch-'0');
}
if (m > VpBaseFig()) m -= VpBaseFig();
GUARD_OBJ(pv, VpNewRbClass(m, (char *)pch, self, true, true));
m /= VpBaseFig();
if (m && pv->MaxPrec > m) {
pv->MaxPrec = m+1;
}
return VpCheckGetValue(pv);
}
|
.double_fig ⇒ Object
.interpret_loosely(string) ⇒ Object
Returns the BigDecimal
converted loosely from string
.
3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 |
# File 'ext/bigdecimal/bigdecimal.c', line 3779
static VALUE
BigDecimal_s_interpret_loosely(VALUE klass, VALUE str)
{
char const *c_str = StringValueCStr(str);
Real *vp = VpNewRbClass(0, c_str, klass, false, true);
if (!vp)
return Qnil;
else
return VpCheckGetValue(vp);
}
|
.limit(*args) ⇒ Object
BigDecimal.limit(digits)
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.
3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 |
# File 'ext/bigdecimal/bigdecimal.c', line 3802
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 givenmode
totrue
. -
false
: sets the givenmode
tofalse
. -
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): ReturnsBigDecimal('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): ReturnsBigDecimal('Infinity')
orBigDecimal('-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): ReturnsBigDecimal('0')
orBigDecimal('-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): ReturnsBigDecimal('Infinity')
orBigDecimal('-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): ReturnsBigDecimal('Infinity')
orBigDecimal('-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:
.
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 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 |
# File 'ext/bigdecimal/bigdecimal.c', line 1064
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
3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 |
# File 'ext/bigdecimal/bigdecimal.c', line 3863
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
3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 |
# File 'ext/bigdecimal/bigdecimal.c', line 3913
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
3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 |
# File 'ext/bigdecimal/bigdecimal.c', line 3888
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
2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 |
# File 'ext/bigdecimal/bigdecimal.c', line 2063
static VALUE
BigDecimal_mod(VALUE self, VALUE r) /* %: a%b = a - (a.to_f/b).floor * b */
{
ENTER(3);
Real *div = NULL, *mod = NULL;
if (BigDecimal_DoDivmod(self, r, &div, &mod)) {
SAVE(div); SAVE(mod);
return VpCheckGetValue(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.
1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 |
# File 'ext/bigdecimal/bigdecimal.c', line 1794
static VALUE
BigDecimal_mult(VALUE self, VALUE r)
{
ENTER(5);
Real *c, *a, *b;
size_t mx;
GUARD_OBJ(a, GetVpValue(self, 1));
if (RB_TYPE_P(r, T_FLOAT)) {
b = GetVpValueWithPrec(r, 0, 1);
}
else if (RB_TYPE_P(r, T_RATIONAL)) {
b = GetVpValueWithPrec(r, a->Prec*VpBaseFig(), 1);
}
else {
b = GetVpValue(r,0);
}
if (!b) return DoSomeOne(self, r, '*');
SAVE(b);
mx = a->Prec + b->Prec;
GUARD_OBJ(c, NewZeroWrapLimited(1, mx * (VpBaseFig() + 1)));
VpMult(c, a, b);
return VpCheckGetValue(c);
}
|
#**(other) ⇒ Object
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.
3249 3250 3251 3252 3253 |
# File 'ext/bigdecimal/bigdecimal.c', line 3249
static VALUE
BigDecimal_power_op(VALUE self, VALUE exp)
{
return BigDecimal_power(1, &exp, self);
}
|
#+(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.
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 |
# File 'ext/bigdecimal/bigdecimal.c', line 1447
static VALUE
BigDecimal_add(VALUE self, VALUE r)
{
ENTER(5);
Real *c, *a, *b;
size_t mx;
GUARD_OBJ(a, GetVpValue(self, 1));
if (RB_TYPE_P(r, T_FLOAT)) {
b = GetVpValueWithPrec(r, 0, 1);
}
else if (RB_TYPE_P(r, T_RATIONAL)) {
b = GetVpValueWithPrec(r, a->Prec*VpBaseFig(), 1);
}
else {
b = GetVpValue(r, 0);
}
if (!b) return DoSomeOne(self,r,'+');
SAVE(b);
if (VpIsNaN(b)) return b->obj;
if (VpIsNaN(a)) return a->obj;
mx = GetAddSubPrec(a, b);
if (mx == (size_t)-1L) {
GUARD_OBJ(c, NewZeroWrapLimited(1, VpBaseFig() + 1));
VpAddSub(c, a, b, 1);
}
else {
GUARD_OBJ(c, NewZeroWrapLimited(1, mx * (VpBaseFig() + 1)));
if (!mx) {
VpSetInf(c, VpGetSign(a));
}
else {
VpAddSub(c, a, b, 1);
}
}
return VpCheckGetValue(c);
}
|
#+ ⇒ self
Returns self
:
+BigDecimal(5) # => 0.5e1
+BigDecimal(-5) # => -0.5e1
1425 1426 1427 1428 1429 |
# File 'ext/bigdecimal/bigdecimal.c', line 1425
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.
1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 |
# File 'ext/bigdecimal/bigdecimal.c', line 1502
static VALUE
BigDecimal_sub(VALUE self, VALUE r)
{
ENTER(5);
Real *c, *a, *b;
size_t mx;
GUARD_OBJ(a, GetVpValue(self,1));
if (RB_TYPE_P(r, T_FLOAT)) {
b = GetVpValueWithPrec(r, 0, 1);
}
else if (RB_TYPE_P(r, T_RATIONAL)) {
b = GetVpValueWithPrec(r, a->Prec*VpBaseFig(), 1);
}
else {
b = GetVpValue(r,0);
}
if (!b) return DoSomeOne(self,r,'-');
SAVE(b);
if (VpIsNaN(b)) return b->obj;
if (VpIsNaN(a)) return a->obj;
mx = GetAddSubPrec(a,b);
if (mx == (size_t)-1L) {
GUARD_OBJ(c, NewZeroWrapLimited(1, VpBaseFig() + 1));
VpAddSub(c, a, b, -1);
}
else {
GUARD_OBJ(c, NewZeroWrapLimited(1, mx *(VpBaseFig() + 1)));
if (!mx) {
VpSetInf(c,VpGetSign(a));
}
else {
VpAddSub(c, a, b, -1);
}
}
return VpCheckGetValue(c);
}
|
#- ⇒ Object
Returns the BigDecimal negation of self:
b0 = BigDecimal('1.5')
b1 = -b0 # => -0.15e1
b2 = -b1 # => 0.15e1
1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 |
# File 'ext/bigdecimal/bigdecimal.c', line 1772
static VALUE
BigDecimal_neg(VALUE self)
{
ENTER(5);
Real *c, *a;
GUARD_OBJ(a, GetVpValue(self, 1));
GUARD_OBJ(c, NewZeroWrapLimited(1, a->Prec *(VpBaseFig() + 1)));
VpAsgn(c, a, -1);
return VpCheckGetValue(c);
}
|
#/ ⇒ Object
For c = self/r: with round operation
1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 |
# File 'ext/bigdecimal/bigdecimal.c', line 1883
static VALUE
BigDecimal_div(VALUE self, VALUE r)
/* For c = self/r: with round operation */
{
ENTER(5);
Real *c=NULL, *res=NULL, *div = NULL;
r = BigDecimal_divide(self, r, &c, &res, &div);
if (!NIL_P(r)) return r; /* coerced by other */
SAVE(c); SAVE(res); SAVE(div);
/* a/b = c + r/b */
/* c xxxxx
r 00000yyyyy ==> (y/b)*BASE >= HALF_BASE
*/
/* Round */
if (VpHasVal(div)) { /* frac[0] must be zero for NaN,INF,Zero */
VpInternalRound(c, 0, c->frac[c->Prec-1], (DECDIG)(VpBaseVal() * (DECDIG_DBL)res->frac[0] / div->frac[0]));
}
return VpCheckGetValue(c);
}
|
#<(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.
1692 1693 1694 1695 1696 |
# File 'ext/bigdecimal/bigdecimal.c', line 1692
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.
1713 1714 1715 1716 1717 |
# File 'ext/bigdecimal/bigdecimal.c', line 1713
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.
1656 1657 1658 1659 1660 |
# File 'ext/bigdecimal/bigdecimal.c', line 1656
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
1672 1673 1674 1675 1676 |
# File 'ext/bigdecimal/bigdecimal.c', line 1672
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
1672 1673 1674 1675 1676 |
# File 'ext/bigdecimal/bigdecimal.c', line 1672
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.
1733 1734 1735 1736 1737 |
# File 'ext/bigdecimal/bigdecimal.c', line 1733
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.
1754 1755 1756 1757 1758 |
# File 'ext/bigdecimal/bigdecimal.c', line 1754
static VALUE
BigDecimal_ge(VALUE self, VALUE r)
{
return BigDecimalCmp(self, r, 'G');
}
|
#_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
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 |
# File 'ext/bigdecimal/bigdecimal.c', line 780
static VALUE
BigDecimal_dump(int argc, VALUE *argv, VALUE self)
{
ENTER(5);
Real *vp;
char *psz;
VALUE dummy;
volatile VALUE dump;
size_t len;
rb_scan_args(argc, argv, "01", &dummy);
GUARD_OBJ(vp,GetVpValue(self, 1));
dump = rb_str_new(0, VpNumOfChars(vp, "E")+50);
psz = RSTRING_PTR(dump);
snprintf(psz, RSTRING_LEN(dump), "%"PRIuSIZE":", VpMaxPrec(vp)*VpBaseFig());
len = strlen(psz);
VpToString(vp, psz+len, RSTRING_LEN(dump)-len, 0, 0);
rb_str_resize(dump, strlen(psz));
return dump;
}
|
#abs ⇒ Object
Returns the BigDecimal absolute value of self
:
BigDecimal('5').abs # => 0.5e1
BigDecimal('-3').abs # => 0.3e1
2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 |
# File 'ext/bigdecimal/bigdecimal.c', line 2402
static VALUE
BigDecimal_abs(VALUE self)
{
ENTER(5);
Real *c, *a;
size_t mx;
GUARD_OBJ(a, GetVpValue(self, 1));
mx = a->Prec *(VpBaseFig() + 1);
GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
VpAsgn(c, a, 1);
VpChangeSign(c, 1);
return VpCheckGetValue(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
2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 |
# File 'ext/bigdecimal/bigdecimal.c', line 2301
static VALUE
BigDecimal_add2(VALUE self, VALUE b, VALUE n)
{
ENTER(2);
Real *cv;
SIGNED_VALUE mx = check_int_precision(n);
if (mx == 0) return BigDecimal_add(self, b);
else {
size_t pl = VpSetPrecLimit(0);
VALUE c = BigDecimal_add(self, b);
VpSetPrecLimit(pl);
GUARD_OBJ(cv, GetVpValue(c, 1));
VpLeftRound(cv, VpGetRoundMode(), mx);
return VpCheckGetValue(cv);
}
}
|
#ceil(*args) ⇒ Object
ceil(n)
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
2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 |
# File 'ext/bigdecimal/bigdecimal.c', line 2661
static VALUE
BigDecimal_ceil(int argc, VALUE *argv, VALUE self)
{
ENTER(5);
Real *c, *a;
int iLoc;
VALUE vLoc;
size_t mx, pl = VpSetPrecLimit(0);
if (rb_scan_args(argc, argv, "01", &vLoc) == 0) {
iLoc = 0;
} else {
iLoc = NUM2INT(vLoc);
}
GUARD_OBJ(a, GetVpValue(self, 1));
mx = a->Prec * (VpBaseFig() + 1);
GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
VpSetPrecLimit(pl);
VpActiveRound(c, a, VP_ROUND_CEIL, iLoc);
if (argc == 0) {
return BigDecimal_to_i(VpCheckGetValue(c));
}
return VpCheckGetValue(c);
}
|
#clone ⇒ Object
:nodoc:
3272 3273 3274 3275 3276 |
# File 'ext/bigdecimal/bigdecimal.c', line 3272
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.
1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 |
# File 'ext/bigdecimal/bigdecimal.c', line 1389
static VALUE
BigDecimal_coerce(VALUE self, VALUE other)
{
ENTER(2);
VALUE obj;
Real *b;
if (RB_TYPE_P(other, T_FLOAT)) {
GUARD_OBJ(b, GetVpValueWithPrec(other, 0, 1));
obj = rb_assoc_new(VpCheckGetValue(b), self);
}
else {
if (RB_TYPE_P(other, T_RATIONAL)) {
Real* pv = DATA_PTR(self);
GUARD_OBJ(b, GetVpValueWithPrec(other, pv->Prec*VpBaseFig(), 1));
}
else {
GUARD_OBJ(b, GetVpValue(other, 1));
}
obj = rb_assoc_new(b->obj, self);
}
return obj;
}
|
#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
2266 2267 2268 2269 2270 2271 2272 2273 2274 |
# File 'ext/bigdecimal/bigdecimal.c', line 2266
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(r) ⇒ Object
divmod(value)
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.
2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 |
# File 'ext/bigdecimal/bigdecimal.c', line 2168
static VALUE
BigDecimal_divmod(VALUE self, VALUE r)
{
ENTER(5);
Real *div = NULL, *mod = NULL;
if (BigDecimal_DoDivmod(self, r, &div, &mod)) {
SAVE(div); SAVE(mod);
return rb_assoc_new(VpCheckGetValue(div), VpCheckGetValue(mod));
}
return DoSomeOne(self,r,rb_intern("divmod"));
}
|
#dup ⇒ Object
:nodoc:
3272 3273 3274 3275 3276 |
# File 'ext/bigdecimal/bigdecimal.c', line 3272
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
1672 1673 1674 1675 1676 |
# File 'ext/bigdecimal/bigdecimal.c', line 1672
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.
2852 2853 2854 2855 2856 2857 |
# File 'ext/bigdecimal/bigdecimal.c', line 2852
static VALUE
BigDecimal_exponent(VALUE self)
{
ssize_t e = VpExponent10(GetVpValue(self, 1));
return SSIZET2NUM(e);
}
|
#finite? ⇒ Boolean
Returns True if the value is finite (not NaN or infinite).
1228 1229 1230 1231 1232 1233 1234 1235 |
# File 'ext/bigdecimal/bigdecimal.c', line 1228
static VALUE
BigDecimal_IsFinite(VALUE self)
{
Real *p = GetVpValue(self, 1);
if (VpIsNaN(p)) return Qfalse;
if (VpIsInf(p)) return Qfalse;
return Qtrue;
}
|
#fix ⇒ Object
Return the integer part of the number, as a BigDecimal.
2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 |
# File 'ext/bigdecimal/bigdecimal.c', line 2444
static VALUE
BigDecimal_fix(VALUE self)
{
ENTER(5);
Real *c, *a;
size_t mx;
GUARD_OBJ(a, GetVpValue(self, 1));
mx = a->Prec *(VpBaseFig() + 1);
GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
VpActiveRound(c, a, VP_ROUND_DOWN, 0); /* 0: round off */
return VpCheckGetValue(c);
}
|
#floor(*args) ⇒ Object
floor(n)
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
2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 |
# File 'ext/bigdecimal/bigdecimal.c', line 2614
static VALUE
BigDecimal_floor(int argc, VALUE *argv, VALUE self)
{
ENTER(5);
Real *c, *a;
int iLoc;
VALUE vLoc;
size_t mx, pl = VpSetPrecLimit(0);
if (rb_scan_args(argc, argv, "01", &vLoc)==0) {
iLoc = 0;
}
else {
iLoc = NUM2INT(vLoc);
}
GUARD_OBJ(a, GetVpValue(self, 1));
mx = a->Prec * (VpBaseFig() + 1);
GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
VpSetPrecLimit(pl);
VpActiveRound(c, a, VP_ROUND_FLOOR, iLoc);
#ifdef BIGDECIMAL_DEBUG
VPrint(stderr, "floor: c=%\n", c);
#endif
if (argc == 0) {
return BigDecimal_to_i(VpCheckGetValue(c));
}
return VpCheckGetValue(c);
}
|
#frac ⇒ Object
Return the fractional part of the number, as a BigDecimal.
2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 |
# File 'ext/bigdecimal/bigdecimal.c', line 2583
static VALUE
BigDecimal_frac(VALUE self)
{
ENTER(5);
Real *c, *a;
size_t mx;
GUARD_OBJ(a, GetVpValue(self, 1));
mx = a->Prec * (VpBaseFig() + 1);
GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
VpFrac(c, a);
return VpCheckGetValue(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.
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 |
# File 'ext/bigdecimal/bigdecimal.c', line 751
static VALUE
BigDecimal_hash(VALUE self)
{
ENTER(1);
Real *p;
st_index_t hash;
GUARD_OBJ(p, GetVpValue(self, 1));
hash = (st_index_t)p->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(p->frac, sizeof(DECDIG)*p->Prec);
hash += p->exponent;
}
return ST2FIX(hash);
}
|
#infinite? ⇒ Boolean
Returns nil, -1, or 1 depending on whether the value is finite, -Infinity, or Infinity.
1218 1219 1220 1221 1222 1223 1224 1225 |
# File 'ext/bigdecimal/bigdecimal.c', line 1218
static VALUE
BigDecimal_IsInfinite(VALUE self)
{
Real *p = GetVpValue(self, 1);
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"
2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 |
# File 'ext/bigdecimal/bigdecimal.c', line 2864
static VALUE
BigDecimal_inspect(VALUE self)
{
ENTER(5);
Real *vp;
volatile VALUE str;
size_t nc;
GUARD_OBJ(vp, GetVpValue(self, 1));
nc = VpNumOfChars(vp, "E");
str = rb_str_new(0, nc);
VpToString(vp, RSTRING_PTR(str), RSTRING_LEN(str), 0, 0);
rb_str_resize(str, strlen(RSTRING_PTR(str)));
return str;
}
|
#modulo ⇒ Object
%: a%b = a - (a.to_f/b).floor * b
2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 |
# File 'ext/bigdecimal/bigdecimal.c', line 2063
static VALUE
BigDecimal_mod(VALUE self, VALUE r) /* %: a%b = a - (a.to_f/b).floor * b */
{
ENTER(3);
Real *div = NULL, *mod = NULL;
if (BigDecimal_DoDivmod(self, r, &div, &mod)) {
SAVE(div); SAVE(mod);
return VpCheckGetValue(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)
2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 |
# File 'ext/bigdecimal/bigdecimal.c', line 2374
static VALUE
BigDecimal_mult2(VALUE self, VALUE b, VALUE n)
{
ENTER(2);
Real *cv;
SIGNED_VALUE mx = check_int_precision(n);
if (mx == 0) return BigDecimal_mult(self, b);
else {
size_t pl = VpSetPrecLimit(0);
VALUE c = BigDecimal_mult(self, b);
VpSetPrecLimit(pl);
GUARD_OBJ(cv, GetVpValue(c, 1));
VpLeftRound(cv, VpGetRoundMode(), mx);
return VpCheckGetValue(cv);
}
}
|
#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
711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 |
# File 'ext/bigdecimal/bigdecimal.c', line 711
static VALUE
BigDecimal_n_significant_digits(VALUE self)
{
ENTER(1);
Real *p;
GUARD_OBJ(p, GetVpValue(self, 1));
if (VpIsZero(p) || !VpIsDef(p)) {
return INT2FIX(0);
}
ssize_t n = p->Prec; /* The length of frac without trailing zeros. */
for (n = p->Prec; n > 0 && p->frac[n-1] == 0; --n);
if (n == 0) return INT2FIX(0);
DECDIG x;
int nlz = BASE_FIG;
for (x = p->frac[0]; x > 0; x /= 10) --nlz;
int ntz = 0;
for (x = p->frac[n-1]; x > 0 && x % 10 == 0; x /= 10) ++ntz;
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.
1207 1208 1209 1210 1211 1212 1213 |
# File 'ext/bigdecimal/bigdecimal.c', line 1207
static VALUE
BigDecimal_IsNaN(VALUE self)
{
Real *p = GetVpValue(self, 1);
if (VpIsNaN(p)) return Qtrue;
return Qfalse;
}
|
#nonzero? ⇒ Boolean
Returns self if the value is non-zero, nil otherwise.
1646 1647 1648 1649 1650 1651 |
# File 'ext/bigdecimal/bigdecimal.c', line 1646
static VALUE
BigDecimal_nonzero(VALUE self)
{
Real *a = GetVpValue(self, 1);
return VpIsZero(a) ? Qnil : self;
}
|
#power(*args) ⇒ Object
power(n) power(n, prec)
Returns the value raised to the power of n.
Note that n must be an Integer.
Also available as the operator **.
3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 |
# File 'ext/bigdecimal/bigdecimal.c', line 3007
static VALUE
BigDecimal_power(int argc, VALUE*argv, VALUE self)
{
ENTER(5);
VALUE vexp, prec;
Real* exp = NULL;
Real *x, *y;
ssize_t mp, ma, n;
SIGNED_VALUE int_exp;
double d;
rb_scan_args(argc, argv, "11", &vexp, &prec);
GUARD_OBJ(x, GetVpValue(self, 1));
n = NIL_P(prec) ? (ssize_t)(x->Prec*VpBaseFig()) : NUM2SSIZET(prec);
if (VpIsNaN(x)) {
y = NewZeroWrapLimited(1, n);
VpSetNaN(y);
RB_GC_GUARD(y->obj);
return VpCheckGetValue(y);
}
retry:
switch (TYPE(vexp)) {
case T_FIXNUM:
break;
case T_BIGNUM:
break;
case T_FLOAT:
d = RFLOAT_VALUE(vexp);
if (d == round(d)) {
if (FIXABLE(d)) {
vexp = LONG2FIX((long)d);
}
else {
vexp = rb_dbl2big(d);
}
goto retry;
}
if (NIL_P(prec)) {
n += BIGDECIMAL_DOUBLE_FIGURES;
}
exp = GetVpValueWithPrec(vexp, 0, 1);
break;
case T_RATIONAL:
if (is_zero(rb_rational_num(vexp))) {
if (is_positive(vexp)) {
vexp = INT2FIX(0);
goto retry;
}
}
else if (is_one(rb_rational_den(vexp))) {
vexp = rb_rational_num(vexp);
goto retry;
}
exp = GetVpValueWithPrec(vexp, n, 1);
if (NIL_P(prec)) {
n += n;
}
break;
case T_DATA:
if (is_kind_of_BigDecimal(vexp)) {
VALUE zero = INT2FIX(0);
VALUE rounded = BigDecimal_round(1, &zero, vexp);
if (RTEST(BigDecimal_eq(vexp, rounded))) {
vexp = BigDecimal_to_i(vexp);
goto retry;
}
if (NIL_P(prec)) {
GUARD_OBJ(y, GetVpValue(vexp, 1));
n += y->Prec*VpBaseFig();
}
exp = DATA_PTR(vexp);
break;
}
/* fall through */
default:
rb_raise(rb_eTypeError,
"wrong argument type %"PRIsVALUE" (expected scalar Numeric)",
RB_OBJ_CLASSNAME(vexp));
}
if (VpIsZero(x)) {
if (is_negative(vexp)) {
y = NewZeroWrapNolimit(1, n);
if (BIGDECIMAL_NEGATIVE_P(x)) {
if (is_integer(vexp)) {
if (is_even(vexp)) {
/* (-0) ** (-even_integer) -> Infinity */
VpSetPosInf(y);
}
else {
/* (-0) ** (-odd_integer) -> -Infinity */
VpSetNegInf(y);
}
}
else {
/* (-0) ** (-non_integer) -> Infinity */
VpSetPosInf(y);
}
}
else {
/* (+0) ** (-num) -> Infinity */
VpSetPosInf(y);
}
RB_GC_GUARD(y->obj);
return VpCheckGetValue(y);
}
else if (is_zero(vexp)) {
return VpCheckGetValue(NewOneWrapLimited(1, n));
}
else {
return VpCheckGetValue(NewZeroWrapLimited(1, n));
}
}
if (is_zero(vexp)) {
return VpCheckGetValue(NewOneWrapLimited(1, n));
}
else if (is_one(vexp)) {
return self;
}
if (VpIsInf(x)) {
if (is_negative(vexp)) {
if (BIGDECIMAL_NEGATIVE_P(x)) {
if (is_integer(vexp)) {
if (is_even(vexp)) {
/* (-Infinity) ** (-even_integer) -> +0 */
return VpCheckGetValue(NewZeroWrapLimited(1, n));
}
else {
/* (-Infinity) ** (-odd_integer) -> -0 */
return VpCheckGetValue(NewZeroWrapLimited(-1, n));
}
}
else {
/* (-Infinity) ** (-non_integer) -> -0 */
return VpCheckGetValue(NewZeroWrapLimited(-1, n));
}
}
else {
return VpCheckGetValue(NewZeroWrapLimited(1, n));
}
}
else {
y = NewZeroWrapLimited(1, n);
if (BIGDECIMAL_NEGATIVE_P(x)) {
if (is_integer(vexp)) {
if (is_even(vexp)) {
VpSetPosInf(y);
}
else {
VpSetNegInf(y);
}
}
else {
/* TODO: support complex */
rb_raise(rb_eMathDomainError,
"a non-integral exponent for a negative base");
}
}
else {
VpSetPosInf(y);
}
return VpCheckGetValue(y);
}
}
if (exp != NULL) {
return bigdecimal_power_by_bigdecimal(x, exp, n);
}
else if (RB_TYPE_P(vexp, T_BIGNUM)) {
VALUE abs_value = BigDecimal_abs(self);
if (is_one(abs_value)) {
return VpCheckGetValue(NewOneWrapLimited(1, n));
}
else if (RTEST(rb_funcall(abs_value, '<', 1, INT2FIX(1)))) {
if (is_negative(vexp)) {
y = NewZeroWrapLimited(1, n);
VpSetInf(y, (is_even(vexp) ? 1 : -1) * VpGetSign(x));
return VpCheckGetValue(y);
}
else if (BIGDECIMAL_NEGATIVE_P(x) && is_even(vexp)) {
return VpCheckGetValue(NewZeroWrapLimited(-1, n));
}
else {
return VpCheckGetValue(NewZeroWrapLimited(1, n));
}
}
else {
if (is_positive(vexp)) {
y = NewZeroWrapLimited(1, n);
VpSetInf(y, (is_even(vexp) ? 1 : -1) * VpGetSign(x));
return VpCheckGetValue(y);
}
else if (BIGDECIMAL_NEGATIVE_P(x) && is_even(vexp)) {
return VpCheckGetValue(NewZeroWrapLimited(-1, n));
}
else {
return VpCheckGetValue(NewZeroWrapLimited(1, n));
}
}
}
int_exp = FIX2LONG(vexp);
ma = int_exp;
if (ma < 0) ma = -ma;
if (ma == 0) ma = 1;
if (VpIsDef(x)) {
mp = x->Prec * (VpBaseFig() + 1);
GUARD_OBJ(y, NewZeroWrapLimited(1, mp * (ma + 1)));
}
else {
GUARD_OBJ(y, NewZeroWrapLimited(1, 1));
}
VpPowerByInt(y, x, int_exp);
if (!NIL_P(prec) && VpIsDef(y)) {
VpMidRound(y, VpGetRoundMode(), n);
}
return VpCheckGetValue(y);
}
|
#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
645 646 647 648 649 650 651 |
# File 'ext/bigdecimal/bigdecimal.c', line 645
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.
687 688 689 690 691 692 693 |
# File 'ext/bigdecimal/bigdecimal.c', line 687
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.
498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 |
# File 'ext/bigdecimal/bigdecimal.c', line 498
static VALUE
BigDecimal_prec(VALUE self)
{
ENTER(1);
Real *p;
VALUE obj;
rb_category_warn(RB_WARN_CATEGORY_DEPRECATED,
"BigDecimal#precs is deprecated and will be removed in the future; "
"use BigDecimal#precision instead.");
GUARD_OBJ(p, GetVpValue(self, 1));
obj = rb_assoc_new(SIZET2NUM(p->Prec*VpBaseFig()),
SIZET2NUM(p->MaxPrec*VpBaseFig()));
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.
1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 |
# File 'ext/bigdecimal/bigdecimal.c', line 1921
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
2136 2137 2138 2139 2140 2141 2142 2143 2144 |
# File 'ext/bigdecimal/bigdecimal.c', line 2136
static VALUE
BigDecimal_remainder(VALUE self, VALUE r) /* remainder */
{
VALUE f;
Real *d, *rv = 0;
f = BigDecimal_divremain(self, r, &d, &rv);
if (!NIL_P(f)) return f;
return VpCheckGetValue(rv);
}
|
#round(*args) ⇒ Object
round(n, mode)
Round to the nearest integer (by default), returning the result as a BigDecimal if n is specified, 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”
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.
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 |
# File 'ext/bigdecimal/bigdecimal.c', line 2483
static VALUE
BigDecimal_round(int argc, VALUE *argv, VALUE self)
{
ENTER(5);
Real *c, *a;
int iLoc = 0;
VALUE vLoc;
VALUE vRound;
int round_to_int = 0;
size_t mx, pl;
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;
}
pl = VpSetPrecLimit(0);
GUARD_OBJ(a, GetVpValue(self, 1));
mx = a->Prec * (VpBaseFig() + 1);
GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
VpSetPrecLimit(pl);
VpActiveRound(c, a, sw, iLoc);
if (round_to_int) {
return BigDecimal_to_i(VpCheckGetValue(c));
}
return VpCheckGetValue(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").precision # => 0
BigDecimal("1e-20").precision # => 20
BigDecimal("Infinity").scale # => 0
BigDecimal("-Infinity").scale # => 0
BigDecimal("NaN").scale # => 0
669 670 671 672 673 674 675 |
# File 'ext/bigdecimal/bigdecimal.c', line 669
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
3838 3839 3840 3841 3842 3843 |
# File 'ext/bigdecimal/bigdecimal.c', line 3838
static VALUE
BigDecimal_sign(VALUE self)
{ /* sign */
int s = GetVpValue(self, 1)->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.)
2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 |
# File 'ext/bigdecimal/bigdecimal.c', line 2815
static VALUE
BigDecimal_split(VALUE self)
{
ENTER(5);
Real *vp;
VALUE obj,str;
ssize_t e, s;
char *psz1;
GUARD_OBJ(vp, GetVpValue(self, 1));
str = rb_str_new(0, VpNumOfChars(vp, "E"));
psz1 = RSTRING_PTR(str);
VpSzMantissa(vp, 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(vp);
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));
return obj;
}
|
#sqrt(nFig) ⇒ Object
sqrt(n)
Returns the square root of the value.
Result has at least n significant digits.
2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 |
# File 'ext/bigdecimal/bigdecimal.c', line 2424
static VALUE
BigDecimal_sqrt(VALUE self, VALUE nFig)
{
ENTER(5);
Real *c, *a;
size_t mx, n;
GUARD_OBJ(a, GetVpValue(self, 1));
mx = a->Prec * (VpBaseFig() + 1);
n = check_int_precision(nFig);
n += VpDblFig() + VpBaseFig();
if (mx <= n) mx = n;
GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
VpSqrt(c, a);
return VpCheckGetValue(c);
}
|
#sub(b, n) ⇒ Object
sub(value, digits) -> bigdecimal
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.
2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 |
# File 'ext/bigdecimal/bigdecimal.c', line 2331
static VALUE
BigDecimal_sub2(VALUE self, VALUE b, VALUE n)
{
ENTER(2);
Real *cv;
SIGNED_VALUE mx = check_int_precision(n);
if (mx == 0) return BigDecimal_sub(self, b);
else {
size_t pl = VpSetPrecLimit(0);
VALUE c = BigDecimal_sub(self, b);
VpSetPrecLimit(pl);
GUARD_OBJ(cv, GetVpValue(c, 1));
VpLeftRound(cv, VpGetRoundMode(), mx);
return VpCheckGetValue(cv);
}
}
|
#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.
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 |
# File 'ext/bigdecimal/bigdecimal.c', line 1296
static VALUE
BigDecimal_to_f(VALUE self)
{
ENTER(1);
Real *p;
double d;
SIGNED_VALUE e;
char *buf;
volatile VALUE str;
GUARD_OBJ(p, GetVpValue(self, 1));
if (VpVtoD(&d, &e, p) != 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-BASE_FIG))
goto underflow;
str = rb_str_new(0, VpNumOfChars(p, "E"));
buf = RSTRING_PTR(str);
VpToString(p, buf, RSTRING_LEN(str), 0, 0);
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 (BIGDECIMAL_NEGATIVE_P(p))
return rb_float_new(VpGetDoubleNegInf());
else
return rb_float_new(VpGetDoublePosInf());
underflow:
VpException(VP_EXCEPTION_UNDERFLOW, "BigDecimal to Float conversion", 0);
if (BIGDECIMAL_NEGATIVE_P(p))
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.
1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 |
# File 'ext/bigdecimal/bigdecimal.c', line 1249
static VALUE
BigDecimal_to_i(VALUE self)
{
ENTER(5);
ssize_t e, nf;
Real *p;
GUARD_OBJ(p, GetVpValue(self, 1));
BigDecimal_check_num(p);
e = VpExponent10(p);
if (e <= 0) return INT2FIX(0);
nf = VpBaseFig();
if (e <= nf) {
return LONG2NUM((long)(VpGetSign(p) * (DECDIG_DBL_SIGNED)p->frac[0]));
}
else {
VALUE a = BigDecimal_split(self);
VALUE digits = RARRAY_AREF(a, 1);
VALUE numerator = rb_funcall(digits, rb_intern("to_i"), 0);
VALUE ret;
ssize_t dpower = e - (ssize_t)RSTRING_LEN(digits);
if (BIGDECIMAL_NEGATIVE_P(p)) {
numerator = rb_funcall(numerator, '*', 1, INT2FIX(-1));
}
if (dpower < 0) {
ret = rb_funcall(numerator, rb_intern("div"), 1,
rb_funcall(INT2FIX(10), rb_intern("**"), 1,
INT2FIX(-dpower)));
}
else {
ret = rb_funcall(numerator, '*', 1,
rb_funcall(INT2FIX(10), rb_intern("**"), 1,
INT2FIX(dpower)));
}
if (RB_TYPE_P(ret, T_FLOAT)) {
rb_raise(rb_eFloatDomainError, "Infinity");
}
return ret;
}
}
|
#to_int ⇒ Object
Returns the value as an Integer.
If the BigDecimal is infinity or NaN, raises FloatDomainError.
1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 |
# File 'ext/bigdecimal/bigdecimal.c', line 1249
static VALUE
BigDecimal_to_i(VALUE self)
{
ENTER(5);
ssize_t e, nf;
Real *p;
GUARD_OBJ(p, GetVpValue(self, 1));
BigDecimal_check_num(p);
e = VpExponent10(p);
if (e <= 0) return INT2FIX(0);
nf = VpBaseFig();
if (e <= nf) {
return LONG2NUM((long)(VpGetSign(p) * (DECDIG_DBL_SIGNED)p->frac[0]));
}
else {
VALUE a = BigDecimal_split(self);
VALUE digits = RARRAY_AREF(a, 1);
VALUE numerator = rb_funcall(digits, rb_intern("to_i"), 0);
VALUE ret;
ssize_t dpower = e - (ssize_t)RSTRING_LEN(digits);
if (BIGDECIMAL_NEGATIVE_P(p)) {
numerator = rb_funcall(numerator, '*', 1, INT2FIX(-1));
}
if (dpower < 0) {
ret = rb_funcall(numerator, rb_intern("div"), 1,
rb_funcall(INT2FIX(10), rb_intern("**"), 1,
INT2FIX(-dpower)));
}
else {
ret = rb_funcall(numerator, '*', 1,
rb_funcall(INT2FIX(10), rb_intern("**"), 1,
INT2FIX(dpower)));
}
if (RB_TYPE_P(ret, T_FLOAT)) {
rb_raise(rb_eFloatDomainError, "Infinity");
}
return ret;
}
}
|
#to_r ⇒ Object
Converts a BigDecimal to a Rational.
1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 |
# File 'ext/bigdecimal/bigdecimal.c', line 1343
static VALUE
BigDecimal_to_r(VALUE self)
{
Real *p;
ssize_t sign, power, denomi_power;
VALUE a, digits, numerator;
p = GetVpValue(self, 1);
BigDecimal_check_num(p);
sign = VpGetSign(p);
power = VpExponent10(p);
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(*args) ⇒ Object
to_s(s)
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’, engineering 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'
2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 |
# File 'ext/bigdecimal/bigdecimal.c', line 2720
static VALUE
BigDecimal_to_s(int argc, VALUE *argv, VALUE self)
{
ENTER(5);
int fmt = 0; /* 0: E format, 1: F format */
int fPlus = 0; /* 0: default, 1: set ' ' before digits, 2: set '+' before digits. */
Real *vp;
volatile VALUE str;
char *psz;
char ch;
size_t nc, mc = 0;
SIGNED_VALUE m;
VALUE f;
GUARD_OBJ(vp, GetVpValue(self, 1));
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(vp, "F");
}
else {
nc = VpNumOfChars(vp, "E");
}
if (mc > 0) {
nc += (nc + mc - 1) / mc + 1;
}
str = rb_usascii_str_new(0, nc);
psz = RSTRING_PTR(str);
if (fmt) {
VpToFString(vp, psz, RSTRING_LEN(str), mc, fPlus);
}
else {
VpToString (vp, psz, RSTRING_LEN(str), mc, fPlus);
}
rb_str_resize(str, strlen(psz));
return str;
}
|
#truncate(*args) ⇒ Object
truncate(n)
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
2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 |
# File 'ext/bigdecimal/bigdecimal.c', line 2554
static VALUE
BigDecimal_truncate(int argc, VALUE *argv, VALUE self)
{
ENTER(5);
Real *c, *a;
int iLoc;
VALUE vLoc;
size_t mx, pl = VpSetPrecLimit(0);
if (rb_scan_args(argc, argv, "01", &vLoc) == 0) {
iLoc = 0;
}
else {
iLoc = NUM2INT(vLoc);
}
GUARD_OBJ(a, GetVpValue(self, 1));
mx = a->Prec * (VpBaseFig() + 1);
GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
VpSetPrecLimit(pl);
VpActiveRound(c, a, VP_ROUND_DOWN, iLoc); /* 0: truncate */
if (argc == 0) {
return BigDecimal_to_i(VpCheckGetValue(c));
}
return VpCheckGetValue(c);
}
|
#zero? ⇒ Boolean
Returns True if the value is zero.
1638 1639 1640 1641 1642 1643 |
# File 'ext/bigdecimal/bigdecimal.c', line 1638
static VALUE
BigDecimal_zero(VALUE self)
{
Real *a = GetVpValue(self, 1);
return VpIsZero(a) ? Qtrue : Qfalse;
}
|