From 61e58f7dc480f9833b6b2e4c71d58e016536ce76 Mon Sep 17 00:00:00 2001 From: mrkn Date: Wed, 13 Dec 2017 15:28:30 +0000 Subject: bigdecimal: version 1.3.3 Import bigdecimal version 1.3.3. The full commit log is here: https://github.com/ruby/bigdecimal/compare/v1.3.2...v1.3.3 git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@61213 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- ext/bigdecimal/bigdecimal.c | 124 +++++--- ext/bigdecimal/bigdecimal.gemspec | 8 +- ext/bigdecimal/bigdecimal.h | 6 + ext/bigdecimal/extconf.rb | 16 + ext/bigdecimal/lib/bigdecimal/math.rb | 4 +- ext/bigdecimal/lib/bigdecimal/util.rb | 4 +- test/bigdecimal/test_bigdecimal.rb | 523 +++++++++++++++++--------------- test/bigdecimal/test_bigdecimal_util.rb | 4 +- 8 files changed, 398 insertions(+), 291 deletions(-) diff --git a/ext/bigdecimal/bigdecimal.c b/ext/bigdecimal/bigdecimal.c index e9e6af7784..fcc29a0865 100644 --- a/ext/bigdecimal/bigdecimal.c +++ b/ext/bigdecimal/bigdecimal.c @@ -141,12 +141,16 @@ rb_rational_den(VALUE rat) static VALUE BigDecimal_version(VALUE self) { - /* - * 1.0.0: Ruby 1.8.0 - * 1.0.1: Ruby 1.8.1 - * 1.1.0: Ruby 1.9.3 - */ - return rb_str_new2("1.1.0"); + /* + * 1.0.0: Ruby 1.8.0 + * 1.0.1: Ruby 1.8.1 + * 1.1.0: Ruby 1.9.3 + */ +#ifndef RUBY_BIGDECIMAL_VERSION +# error RUBY_BIGDECIMAL_VERSION is not defined +#endif + rb_warning("BigDecimal.ver is deprecated; use BigDecimal::VERSION instead."); + return rb_str_new2(RUBY_BIGDECIMAL_VERSION); } /* @@ -393,7 +397,7 @@ BigDecimal_hash(VALUE self) * * Method used to provide marshalling support. * - * inf = BigDecimal.new('Infinity') + * inf = BigDecimal('Infinity') * #=> Infinity * BigDecimal._load(inf._dump) * #=> Infinity @@ -646,12 +650,12 @@ GetAddSubPrec(Real *a, Real *b) } static SIGNED_VALUE -GetPositiveInt(VALUE v) +GetPrecisionInt(VALUE v) { SIGNED_VALUE n; n = NUM2INT(v); if (n < 0) { - rb_raise(rb_eArgError, "argument must be positive"); + rb_raise(rb_eArgError, "negative precision"); } return n; } @@ -876,7 +880,7 @@ BigDecimal_to_r(VALUE self) * be coerced into a BigDecimal value. * * e.g. - * a = BigDecimal.new("1.0") + * a = BigDecimal("1.0") * b = a / 2.0 #=> 0.5 * * Note that coercing a String to a BigDecimal is not supported by default; @@ -1165,7 +1169,7 @@ BigDecimal_comp(VALUE self, VALUE r) * * Values may be coerced to perform the comparison: * - * BigDecimal.new('1.0') == 1.0 #=> true + * BigDecimal('1.0') == 1.0 #=> true */ static VALUE BigDecimal_eq(VALUE self, VALUE r) @@ -1527,8 +1531,8 @@ BigDecimal_remainder(VALUE self, VALUE r) /* remainder */ * * require 'bigdecimal' * - * a = BigDecimal.new("42") - * b = BigDecimal.new("9") + * a = BigDecimal("42") + * b = BigDecimal("9") * * q, m = a.divmod(b) * @@ -1571,7 +1575,7 @@ BigDecimal_div2(VALUE self, VALUE b, VALUE n) } /* div in BigDecimal sense */ - ix = GetPositiveInt(n); + ix = GetPrecisionInt(n); if (ix == 0) { return BigDecimal_div(self, b); } @@ -1640,7 +1644,7 @@ BigDecimal_add2(VALUE self, VALUE b, VALUE n) { ENTER(2); Real *cv; - SIGNED_VALUE mx = GetPositiveInt(n); + SIGNED_VALUE mx = GetPrecisionInt(n); if (mx == 0) return BigDecimal_add(self, b); else { size_t pl = VpSetPrecLimit(0); @@ -1670,7 +1674,7 @@ BigDecimal_sub2(VALUE self, VALUE b, VALUE n) { ENTER(2); Real *cv; - SIGNED_VALUE mx = GetPositiveInt(n); + SIGNED_VALUE mx = GetPrecisionInt(n); if (mx == 0) return BigDecimal_sub(self, b); else { size_t pl = VpSetPrecLimit(0); @@ -1688,7 +1692,7 @@ BigDecimal_mult2(VALUE self, VALUE b, VALUE n) { ENTER(2); Real *cv; - SIGNED_VALUE mx = GetPositiveInt(n); + SIGNED_VALUE mx = GetPrecisionInt(n); if (mx == 0) return BigDecimal_mult(self, b); else { size_t pl = VpSetPrecLimit(0); @@ -1742,7 +1746,7 @@ BigDecimal_sqrt(VALUE self, VALUE nFig) GUARD_OBJ(a, GetVpValue(self, 1)); mx = a->Prec * (VpBaseFig() + 1); - n = GetPositiveInt(nFig) + VpDblFig() + BASE_FIG; + n = GetPrecisionInt(nFig) + VpDblFig() + BASE_FIG; if (mx <= n) mx = n; GUARD_OBJ(c, VpCreateRbObject(mx, "0")); VpSqrt(c, a); @@ -2012,26 +2016,27 @@ BigDecimal_ceil(int argc, VALUE *argv, VALUE self) * * Examples: * - * BigDecimal.new('-123.45678901234567890').to_s('5F') + * BigDecimal('-123.45678901234567890').to_s('5F') * #=> '-123.45678 90123 45678 9' * - * BigDecimal.new('123.45678901234567890').to_s('+8F') + * BigDecimal('123.45678901234567890').to_s('+8F') * #=> '+123.45678901 23456789' * - * BigDecimal.new('123.45678901234567890').to_s(' F') + * BigDecimal('123.45678901234567890').to_s(' F') * #=> ' 123.4567890123456789' */ static VALUE BigDecimal_to_s(int argc, VALUE *argv, VALUE self) { ENTER(5); - int fmt = 0; /* 0:E format */ - int fPlus = 0; /* =0:default,=1: set ' ' before digits ,set '+' before digits. */ + 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)); @@ -2062,7 +2067,11 @@ BigDecimal_to_s(int argc, VALUE *argv, VALUE self) } } else { - mc = (size_t)GetPositiveInt(f); + m = NUM2INT(f); + if (m <= 0) { + rb_raise(rb_eArgError, "argument must be positive"); + } + mc = (size_t)m; } } if (fmt) { @@ -2159,7 +2168,7 @@ BigDecimal_exponent(VALUE self) /* Returns debugging information about the value as a string of comma-separated * values in angle brackets with a leading #: * - * BigDecimal.new("1234.5678").inspect + * BigDecimal("1234.5678").inspect * #=> "0.12345678e4" * * The first part is the address, the second is the value as a string, and @@ -2590,6 +2599,13 @@ static Real *BigDecimal_new(int argc, VALUE *argv); * ArgumentError:: If the +initial+ is a Float or Rational, and the +digits+ * value is omitted, this exception is raised. */ +static VALUE +BigDecimal_s_new(int argc, VALUE *argv, VALUE self) +{ + rb_warning("BigDecimal.new is deprecated"); + return rb_call_super(argc, argv); +} + static VALUE BigDecimal_initialize(int argc, VALUE *argv, VALUE self) { @@ -2626,6 +2642,20 @@ BigDecimal_initialize_copy(VALUE self, VALUE other) return self; } +static VALUE +BigDecimal_clone(VALUE self) +{ + rb_warning("BigDecimal#clone is deprecated."); + return rb_call_super(0, NULL); +} + +static VALUE +BigDecimal_dup(VALUE self) +{ + rb_warning("BigDecimal#dup is deprecated."); + return rb_call_super(0, NULL); +} + static Real * BigDecimal_new(int argc, VALUE *argv) { @@ -2638,7 +2668,7 @@ BigDecimal_new(int argc, VALUE *argv) mf = 0; } else { - mf = GetPositiveInt(nFig); + mf = GetPrecisionInt(nFig); } switch (TYPE(iniValue)) { @@ -2758,9 +2788,9 @@ BigDecimal_sign(VALUE self) * BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false) * BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) * - * BigDecimal.new(BigDecimal('Infinity')) - * BigDecimal.new(BigDecimal('-Infinity')) - * BigDecimal(BigDecimal.new('NaN')) + * BigDecimal(BigDecimal('Infinity')) + * BigDecimal(BigDecimal('-Infinity')) + * BigDecimal(BigDecimal('NaN')) * end * * For use with the BigDecimal::EXCEPTION_* @@ -3147,15 +3177,15 @@ get_vp_value: * * require 'bigdecimal' * - * sum = BigDecimal.new("0") + * sum = BigDecimal("0") * 10_000.times do - * sum = sum + BigDecimal.new("0.0001") + * sum = sum + BigDecimal("0.0001") * end * print sum #=> 0.1E1 * * Similarly: * - * (BigDecimal.new("1.2") - BigDecimal("1.0")) == BigDecimal("0.2") #=> true + * (BigDecimal("1.2") - BigDecimal("1.0")) == BigDecimal("0.2") #=> true * * (1.2 - 1.0) == 0.2 #=> false * @@ -3169,8 +3199,8 @@ get_vp_value: * BigDecimal sometimes needs to return infinity, for example if you divide * a value by zero. * - * BigDecimal.new("1.0") / BigDecimal.new("0.0") #=> Infinity - * BigDecimal.new("-1.0") / BigDecimal.new("0.0") #=> -Infinity + * 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 @@ -3183,13 +3213,13 @@ get_vp_value: * * Example: * - * BigDecimal.new("0.0") / BigDecimal.new("0.0") #=> NaN + * 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.new('NaN') + * n = BigDecimal('NaN') * n == 0.0 #=> false * n == n #=> false * @@ -3202,11 +3232,11 @@ get_vp_value: * If the value which is too small to be represented is negative, a BigDecimal * value of negative zero is returned. * - * BigDecimal.new("1.0") / BigDecimal.new("-Infinity") #=> -0.0 + * BigDecimal("1.0") / BigDecimal("-Infinity") #=> -0.0 * * If the value is positive, a value of positive zero is returned. * - * BigDecimal.new("1.0") / BigDecimal.new("Infinity") #=> 0.0 + * BigDecimal("1.0") / BigDecimal("Infinity") #=> 0.0 * * (See BigDecimal.mode for how to specify limits of precision.) * @@ -3261,6 +3291,7 @@ Init_bigdecimal(void) rb_define_global_function("BigDecimal", BigDecimal_global_new, -1); /* Class methods */ + rb_define_singleton_method(rb_cBigDecimal, "new", BigDecimal_s_new, -1); rb_define_singleton_method(rb_cBigDecimal, "mode", BigDecimal_mode, -1); rb_define_singleton_method(rb_cBigDecimal, "limit", BigDecimal_limit, -1); rb_define_singleton_method(rb_cBigDecimal, "double_fig", BigDecimal_double_fig, 0); @@ -3273,6 +3304,14 @@ Init_bigdecimal(void) /* Constants definition */ +#ifndef RUBY_BIGDECIMAL_VERSION +# error RUBY_BIGDECIMAL_VERSION is not defined +#endif + /* + * The version of bigdecimal library + */ + rb_define_const(rb_cBigDecimal, "VERSION", rb_str_new2(RUBY_BIGDECIMAL_VERSION)); + /* * Base value used in internal calculations. On a 32 bit system, BASE * is 10000, indicating that calculation is done in groups of 4 digits. @@ -3409,7 +3448,8 @@ Init_bigdecimal(void) rb_define_method(rb_cBigDecimal, "modulo", BigDecimal_mod, 1); rb_define_method(rb_cBigDecimal, "remainder", BigDecimal_remainder, 1); rb_define_method(rb_cBigDecimal, "divmod", BigDecimal_divmod, 1); - /* rb_define_method(rb_cBigDecimal, "dup", BigDecimal_dup, 0); */ + rb_define_method(rb_cBigDecimal, "clone", BigDecimal_clone, 0); + rb_define_method(rb_cBigDecimal, "dup", BigDecimal_dup, 0); rb_define_method(rb_cBigDecimal, "to_f", BigDecimal_to_f, 0); rb_define_method(rb_cBigDecimal, "abs", BigDecimal_abs, 0); rb_define_method(rb_cBigDecimal, "sqrt", BigDecimal_sqrt, 1); @@ -5348,7 +5388,7 @@ VpSzMantissa(Real *a,char *psz) VP_EXPORT int VpToSpecialString(Real *a,char *psz,int fPlus) - /* fPlus =0:default, =1: set ' ' before digits , =2: set '+' before digits. */ +/* fPlus = 0: default, 1: set ' ' before digits, 2: set '+' before digits. */ { if (VpIsNaN(a)) { sprintf(psz,SZ_NaN); @@ -5383,7 +5423,7 @@ VpToSpecialString(Real *a,char *psz,int fPlus) VP_EXPORT void VpToString(Real *a, char *psz, size_t fFmt, int fPlus) -/* fPlus =0:default, =1: set ' ' before digits , =2:set '+' before digits. */ +/* fPlus = 0: default, 1: set ' ' before digits, 2: set '+' before digits. */ { size_t i, n, ZeroSup; BDIGIT shift, m, e, nn; @@ -5431,7 +5471,7 @@ VpToString(Real *a, char *psz, size_t fFmt, int fPlus) VP_EXPORT void VpToFString(Real *a, char *psz, size_t fFmt, int fPlus) -/* fPlus =0:default,=1: set ' ' before digits ,set '+' before digits. */ +/* fPlus = 0: default, 1: set ' ' before digits, 2: set '+' before digits. */ { size_t i, n; BDIGIT m, e, nn; diff --git a/ext/bigdecimal/bigdecimal.gemspec b/ext/bigdecimal/bigdecimal.gemspec index 4efe438fbd..c1f7da493b 100644 --- a/ext/bigdecimal/bigdecimal.gemspec +++ b/ext/bigdecimal/bigdecimal.gemspec @@ -1,9 +1,10 @@ # coding: utf-8 -_VERSION = '1.3.2' + +bigdecimal_version = '1.3.3' Gem::Specification.new do |s| s.name = "bigdecimal" - s.version = _VERSION + s.version = bigdecimal_version s.authors = ["Kenta Murata", "Zachary Scott", "Shigeo Kobayashi"] s.email = ["mrkn@mrkn.jp"] @@ -31,7 +32,8 @@ Gem::Specification.new do |s| ] s.add_development_dependency "rake", "~> 10.0" - s.add_development_dependency "rake-compiler", "~> 0.9" + s.add_development_dependency "rake-compiler", ">= 0.9" + s.add_development_dependency "rake-compiler-dock", ">= 0.6.1" s.add_development_dependency "minitest", "~> 4.7.5" s.add_development_dependency "pry" end diff --git a/ext/bigdecimal/bigdecimal.h b/ext/bigdecimal/bigdecimal.h index 6182ae2374..e53a752aa5 100644 --- a/ext/bigdecimal/bigdecimal.h +++ b/ext/bigdecimal/bigdecimal.h @@ -142,6 +142,12 @@ rb_sym2str(VALUE sym) } #endif +#ifndef ST2FIX +# undef RB_ST2FIX +# define RB_ST2FIX(h) LONG2FIX((long)(h)) +# define ST2FIX(h) RB_ST2FIX(h) +#endif + #ifdef vabs # undef vabs #endif diff --git a/ext/bigdecimal/extconf.rb b/ext/bigdecimal/extconf.rb index dccf2d2d83..4bef91eafe 100644 --- a/ext/bigdecimal/extconf.rb +++ b/ext/bigdecimal/extconf.rb @@ -1,6 +1,22 @@ # frozen_string_literal: false require 'mkmf' +case +when File.file?(File.expand_path('../bigdecimal.gemspec', __FILE__)) + gemspec_path = File.expand_path('../bigdecimal.gemspec', __FILE__) +when File.file?(File.expand_path('../../../bigdecimal.gemspec', __FILE__)) + gemspec_path = File.expand_path('../../../bigdecimal.gemspec', __FILE__) +else + $stderr.puts "Unable to find bigdecimal.gemspec" + abort +end + +bigdecimal_version = + IO.readlines(gemspec_path) + .grep(/\Abigdecimal_version\s+=\s+/)[0][/\'([\d\.]+)\'/, 1] + +$defs << %Q[-DRUBY_BIGDECIMAL_VERSION=\\"#{bigdecimal_version}\\"] + alias __have_macro__ have_macro have_func("labs", "stdlib.h") diff --git a/ext/bigdecimal/lib/bigdecimal/math.rb b/ext/bigdecimal/lib/bigdecimal/math.rb index ef1a02b38f..0b9d0648bb 100644 --- a/ext/bigdecimal/lib/bigdecimal/math.rb +++ b/ext/bigdecimal/lib/bigdecimal/math.rb @@ -37,7 +37,7 @@ module BigMath # Computes the square root of +decimal+ to the specified number of digits of # precision, +numeric+. # - # BigMath.sqrt(BigDecimal.new('2'), 16).to_s + # BigMath.sqrt(BigDecimal('2'), 16).to_s # #=> "0.1414213562373095048801688724e1" # def sqrt(x, prec) @@ -140,7 +140,7 @@ module BigMath # # If +decimal+ is NaN, returns NaN. # - # BigMath.atan(BigDecimal.new('-1'), 16).to_s + # BigMath.atan(BigDecimal('-1'), 16).to_s # #=> "-0.785398163397448309615660845819878471907514682065e0" # def atan(x, prec) diff --git a/ext/bigdecimal/lib/bigdecimal/util.rb b/ext/bigdecimal/lib/bigdecimal/util.rb index d32eaf561a..911fa6fe3a 100644 --- a/ext/bigdecimal/lib/bigdecimal/util.rb +++ b/ext/bigdecimal/lib/bigdecimal/util.rb @@ -83,7 +83,7 @@ class BigDecimal < Numeric # # require 'bigdecimal/util' # - # d = BigDecimal.new("3.14") + # d = BigDecimal("3.14") # d.to_digits # => "3.14" # def to_digits @@ -103,7 +103,7 @@ class BigDecimal < Numeric # # require 'bigdecimal/util' # - # d = BigDecimal.new("3.14") + # d = BigDecimal("3.14") # d.to_d # => 0.314e1 # def to_d diff --git a/test/bigdecimal/test_bigdecimal.rb b/test/bigdecimal/test_bigdecimal.rb index 7b2bc76f2a..6d0430dfc7 100644 --- a/test/bigdecimal/test_bigdecimal.rb +++ b/test/bigdecimal/test_bigdecimal.rb @@ -2,6 +2,8 @@ require_relative "testbase" require 'bigdecimal/math' +require 'thread' + class TestBigDecimal < Test::Unit::TestCase include TestBigDecimalBase @@ -127,61 +129,73 @@ class TestBigDecimal < Test::Unit::TestCase }.join end + def test_s_ver + assert_warning(/BigDecimal\.ver is deprecated; use BigDecimal::VERSION instead/) do + BigDecimal.ver + end + end + + def test_s_new + assert_warning(/BigDecimal.new is deprecated/) do + BigDecimal.new("1") + end + end + def test_new - assert_equal(1, BigDecimal.new("1")) - assert_equal(1, BigDecimal.new("1", 1)) - assert_equal(1, BigDecimal.new(" 1 ")) - assert_equal(111, BigDecimal.new("1_1_1_")) - assert_equal(10**(-1), BigDecimal.new("1E-1"), '#4825') + assert_equal(1, BigDecimal("1")) + assert_equal(1, BigDecimal("1", 1)) + assert_equal(1, BigDecimal(" 1 ")) + assert_equal(111, BigDecimal("1_1_1_")) + assert_equal(10**(-1), BigDecimal("1E-1"), '#4825') - assert_raise(ArgumentError, /"_1_1_1"/) { BigDecimal.new("_1_1_1") } + assert_raise(ArgumentError, /"_1_1_1"/) { BigDecimal("_1_1_1") } BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false) BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - assert_positive_infinite(BigDecimal.new("Infinity")) - assert_negative_infinite(BigDecimal.new("-Infinity")) - assert_nan(BigDecimal.new("NaN")) - assert_positive_infinite(BigDecimal.new("1E1111111111111111111")) + assert_positive_infinite(BigDecimal("Infinity")) + assert_negative_infinite(BigDecimal("-Infinity")) + assert_nan(BigDecimal("NaN")) + assert_positive_infinite(BigDecimal("1E1111111111111111111")) end def test_new_with_integer - assert_equal(BigDecimal("1"), BigDecimal.new(1)) - assert_equal(BigDecimal("-1"), BigDecimal.new(-1)) - assert_equal(BigDecimal((2**100).to_s), BigDecimal.new(2**100)) - assert_equal(BigDecimal((-2**100).to_s), BigDecimal.new(-2**100)) + assert_equal(BigDecimal("1"), BigDecimal(1)) + assert_equal(BigDecimal("-1"), BigDecimal(-1)) + assert_equal(BigDecimal((2**100).to_s), BigDecimal(2**100)) + assert_equal(BigDecimal((-2**100).to_s), BigDecimal(-2**100)) end def test_new_with_rational - assert_equal(BigDecimal("0.333333333333333333333"), BigDecimal.new(1.quo(3), 21)) - assert_equal(BigDecimal("-0.333333333333333333333"), BigDecimal.new(-1.quo(3), 21)) - assert_raise(ArgumentError) { BigDecimal.new(1.quo(3)) } + assert_equal(BigDecimal("0.333333333333333333333"), BigDecimal(1.quo(3), 21)) + assert_equal(BigDecimal("-0.333333333333333333333"), BigDecimal(-1.quo(3), 21)) + assert_raise(ArgumentError) { BigDecimal(1.quo(3)) } end def test_new_with_float assert_equal(BigDecimal("0.1235"), BigDecimal(0.1234567, 4)) assert_equal(BigDecimal("-0.1235"), BigDecimal(-0.1234567, 4)) - assert_raise(ArgumentError) { BigDecimal.new(0.1) } - assert_raise(ArgumentError) { BigDecimal.new(0.1, Float::DIG + 2) } - assert_nothing_raised { BigDecimal.new(0.1, Float::DIG + 1) } + assert_raise(ArgumentError) { BigDecimal(0.1) } + assert_raise(ArgumentError) { BigDecimal(0.1, Float::DIG + 2) } + assert_nothing_raised { BigDecimal(0.1, Float::DIG + 1) } end def test_new_with_big_decimal - assert_equal(BigDecimal(1), BigDecimal.new(BigDecimal(1))) - assert_equal(BigDecimal('+0'), BigDecimal.new(BigDecimal('+0'))) - assert_equal(BigDecimal('-0'), BigDecimal.new(BigDecimal('-0'))) + assert_equal(BigDecimal(1), BigDecimal(BigDecimal(1))) + assert_equal(BigDecimal('+0'), BigDecimal(BigDecimal('+0'))) + assert_equal(BigDecimal('-0'), BigDecimal(BigDecimal('-0'))) BigDecimal.save_exception_mode do BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false) BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - assert_positive_infinite(BigDecimal.new(BigDecimal('Infinity'))) - assert_negative_infinite(BigDecimal.new(BigDecimal('-Infinity'))) - assert_nan(BigDecimal(BigDecimal.new('NaN'))) + assert_positive_infinite(BigDecimal(BigDecimal('Infinity'))) + assert_negative_infinite(BigDecimal(BigDecimal('-Infinity'))) + assert_nan(BigDecimal(BigDecimal('NaN'))) end end def test_new_with_tainted_string Thread.new { $SAFE = 1 - BigDecimal.new('1'.taint) + BigDecimal('1'.taint) }.join end @@ -283,16 +297,16 @@ class TestBigDecimal < Test::Unit::TestCase end def test_exception_nan - _test_mode(BigDecimal::EXCEPTION_NaN) { BigDecimal.new("NaN") } + _test_mode(BigDecimal::EXCEPTION_NaN) { BigDecimal("NaN") } end def test_exception_infinity - _test_mode(BigDecimal::EXCEPTION_INFINITY) { BigDecimal.new("Infinity") } + _test_mode(BigDecimal::EXCEPTION_INFINITY) { BigDecimal("Infinity") } end def test_exception_underflow _test_mode(BigDecimal::EXCEPTION_UNDERFLOW) do - x = BigDecimal.new("0.1") + x = BigDecimal("0.1") 100.times do x *= x end @@ -301,7 +315,7 @@ class TestBigDecimal < Test::Unit::TestCase def test_exception_overflow _test_mode(BigDecimal::EXCEPTION_OVERFLOW) do - x = BigDecimal.new("10") + x = BigDecimal("10") 100.times do x *= x end @@ -310,17 +324,17 @@ class TestBigDecimal < Test::Unit::TestCase def test_exception_zerodivide BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false) - _test_mode(BigDecimal::EXCEPTION_ZERODIVIDE) { 1 / BigDecimal.new("0") } - _test_mode(BigDecimal::EXCEPTION_ZERODIVIDE) { -1 / BigDecimal.new("0") } + _test_mode(BigDecimal::EXCEPTION_ZERODIVIDE) { 1 / BigDecimal("0") } + _test_mode(BigDecimal::EXCEPTION_ZERODIVIDE) { -1 / BigDecimal("0") } end def test_round_up - n4 = BigDecimal.new("4") # n4 / 9 = 0.44444... - n5 = BigDecimal.new("5") # n5 / 9 = 0.55555... - n6 = BigDecimal.new("6") # n6 / 9 = 0.66666... + n4 = BigDecimal("4") # n4 / 9 = 0.44444... + n5 = BigDecimal("5") # n5 / 9 = 0.55555... + n6 = BigDecimal("6") # n6 / 9 = 0.66666... m4, m5, m6 = -n4, -n5, -n6 - n2h = BigDecimal.new("2.5") - n3h = BigDecimal.new("3.5") + n2h = BigDecimal("2.5") + n3h = BigDecimal("3.5") m2h, m3h = -n2h, -n3h BigDecimal.mode(BigDecimal::ROUND_MODE, BigDecimal::ROUND_UP) @@ -412,25 +426,25 @@ class TestBigDecimal < Test::Unit::TestCase BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false) BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - assert_equal(true, BigDecimal.new("0").zero?) - assert_equal(true, BigDecimal.new("-0").zero?) - assert_equal(false, BigDecimal.new("1").zero?) - assert_equal(true, BigDecimal.new("0E200000000000000").zero?) - assert_equal(false, BigDecimal.new("Infinity").zero?) - assert_equal(false, BigDecimal.new("-Infinity").zero?) - assert_equal(false, BigDecimal.new("NaN").zero?) + assert_equal(true, BigDecimal("0").zero?) + assert_equal(true, BigDecimal("-0").zero?) + assert_equal(false, BigDecimal("1").zero?) + assert_equal(true, BigDecimal("0E200000000000000").zero?) + assert_equal(false, BigDecimal("Infinity").zero?) + assert_equal(false, BigDecimal("-Infinity").zero?) + assert_equal(false, BigDecimal("NaN").zero?) end def test_nonzero_p BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false) BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - assert_equal(nil, BigDecimal.new("0").nonzero?) - assert_equal(nil, BigDecimal.new("-0").nonzero?) - assert_equal(BigDecimal.new("1"), BigDecimal.new("1").nonzero?) - assert_positive_infinite(BigDecimal.new("Infinity").nonzero?) - assert_negative_infinite(BigDecimal.new("-Infinity").nonzero?) - assert_nan(BigDecimal.new("NaN").nonzero?) + assert_equal(nil, BigDecimal("0").nonzero?) + assert_equal(nil, BigDecimal("-0").nonzero?) + assert_equal(BigDecimal("1"), BigDecimal("1").nonzero?) + assert_positive_infinite(BigDecimal("Infinity").nonzero?) + assert_negative_infinite(BigDecimal("-Infinity").nonzero?) + assert_nan(BigDecimal("NaN").nonzero?) end def test_double_fig @@ -438,8 +452,8 @@ class TestBigDecimal < Test::Unit::TestCase end def test_cmp - n1 = BigDecimal.new("1") - n2 = BigDecimal.new("2") + n1 = BigDecimal("1") + n2 = BigDecimal("2") assert_equal( 0, n1 <=> n1) assert_equal( 1, n2 <=> n1) assert_equal(-1, n1 <=> n2) @@ -452,16 +466,16 @@ class TestBigDecimal < Test::Unit::TestCase assert_operator(n2, :>=, n1) assert_operator(n1, :>=, n1) - assert_operator(BigDecimal.new("-0"), :==, BigDecimal.new("0")) - assert_operator(BigDecimal.new("0"), :<, BigDecimal.new("1")) - assert_operator(BigDecimal.new("1"), :>, BigDecimal.new("0")) - assert_operator(BigDecimal.new("1"), :>, BigDecimal.new("-1")) - assert_operator(BigDecimal.new("-1"), :<, BigDecimal.new("1")) - assert_operator(BigDecimal.new((2**100).to_s), :>, BigDecimal.new("1")) - assert_operator(BigDecimal.new("1"), :<, BigDecimal.new((2**100).to_s)) + assert_operator(BigDecimal("-0"), :==, BigDecimal("0")) + assert_operator(BigDecimal("0"), :<, BigDecimal("1")) + assert_operator(BigDecimal("1"), :>, BigDecimal("0")) + assert_operator(BigDecimal("1"), :>, BigDecimal("-1")) + assert_operator(BigDecimal("-1"), :<, BigDecimal("1")) + assert_operator(BigDecimal((2**100).to_s), :>, BigDecimal("1")) + assert_operator(BigDecimal("1"), :<, BigDecimal((2**100).to_s)) BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false) - inf = BigDecimal.new("Infinity") + inf = BigDecimal("Infinity") assert_operator(inf, :>, 1) assert_operator(1, :<, inf) @@ -484,25 +498,25 @@ class TestBigDecimal < Test::Unit::TestCase end def test_cmp_nan - n1 = BigDecimal.new("1") + n1 = BigDecimal("1") BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - assert_equal(nil, BigDecimal.new("NaN") <=> n1) - assert_equal(false, BigDecimal.new("NaN") > n1) - assert_equal(nil, BigDecimal.new("NaN") <=> BigDecimal.new("NaN")) - assert_equal(false, BigDecimal.new("NaN") == BigDecimal.new("NaN")) + assert_equal(nil, BigDecimal("NaN") <=> n1) + assert_equal(false, BigDecimal("NaN") > n1) + assert_equal(nil, BigDecimal("NaN") <=> BigDecimal("NaN")) + assert_equal(false, BigDecimal("NaN") == BigDecimal("NaN")) end def test_cmp_failing_coercion - n1 = BigDecimal.new("1") + n1 = BigDecimal("1") assert_equal(nil, n1 <=> nil) assert_raise(ArgumentError){n1 > nil} end def test_cmp_coerce - n1 = BigDecimal.new("1") - n2 = BigDecimal.new("2") - o1 = Object.new; def o1.coerce(x); [x, BigDecimal.new("1")]; end - o2 = Object.new; def o2.coerce(x); [x, BigDecimal.new("2")]; end + n1 = BigDecimal("1") + n2 = BigDecimal("2") + o1 = Object.new; def o1.coerce(x); [x, BigDecimal("1")]; end + o2 = Object.new; def o2.coerce(x); [x, BigDecimal("2")]; end assert_equal( 0, n1 <=> o1) assert_equal( 1, n2 <=> o1) assert_equal(-1, n1 <=> o2) @@ -522,16 +536,16 @@ class TestBigDecimal < Test::Unit::TestCase end def test_cmp_bignum - assert_operator(BigDecimal.new((2**100).to_s), :==, 2**100) + assert_operator(BigDecimal((2**100).to_s), :==, 2**100) end def test_cmp_data d = Time.now; def d.coerce(x); [x, x]; end - assert_operator(BigDecimal.new((2**100).to_s), :==, d) + assert_operator(BigDecimal((2**100).to_s), :==, d) end def test_precs - a = BigDecimal.new("1").precs + a = BigDecimal("1").precs assert_instance_of(Array, a) assert_equal(2, a.size) assert_kind_of(Integer, a[0]) @@ -540,14 +554,13 @@ class TestBigDecimal < Test::Unit::TestCase def test_hash a = [] - b = BigDecimal.new("1") + b = BigDecimal("1") 10.times { a << b *= 10 } h = {} a.each_with_index {|x, i| h[x] = i } a.each_with_index do |x, i| assert_equal(i, h[x]) end - assert_instance_of(String, b.hash.to_s) end def test_marshal @@ -563,7 +576,7 @@ class TestBigDecimal < Test::Unit::TestCase BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false) BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, false) - x = BigDecimal.new("0") + x = BigDecimal("0") assert_equal(true, x.finite?) assert_equal(nil, x.infinite?) assert_equal(false, x.nan?) @@ -587,15 +600,15 @@ class TestBigDecimal < Test::Unit::TestCase BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false) BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - x = BigDecimal.new("0") + x = BigDecimal("0") assert_kind_of(Integer, x.to_i) assert_equal(0, x.to_i) assert_raise(FloatDomainError){( 1 / x).to_i} assert_raise(FloatDomainError){(-1 / x).to_i} assert_raise(FloatDomainError) {( 0 / x).to_i} - x = BigDecimal.new("1") + x = BigDecimal("1") assert_equal(1, x.to_i) - x = BigDecimal.new((2**100).to_s) + x = BigDecimal((2**100).to_s) assert_equal(2**100, x.to_i) end @@ -604,18 +617,18 @@ class TestBigDecimal < Test::Unit::TestCase BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, false) - x = BigDecimal.new("0") + x = BigDecimal("0") assert_instance_of(Float, x.to_f) assert_equal(0.0, x.to_f) assert_equal( 1.0 / 0.0, ( 1 / x).to_f) assert_equal(-1.0 / 0.0, (-1 / x).to_f) assert_nan(( 0 / x).to_f) - x = BigDecimal.new("1") + x = BigDecimal("1") assert_equal(1.0, x.to_f) - x = BigDecimal.new((2**100).to_s) + x = BigDecimal((2**100).to_s) assert_equal((2**100).to_f, x.to_f) - x = BigDecimal.new("1" + "0" * 10000) - assert_equal(0, BigDecimal.new("-0").to_f) + x = BigDecimal("1" + "0" * 10000) + assert_equal(0, BigDecimal("-0").to_f) BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, true) assert_raise(FloatDomainError) { x.to_f } @@ -663,23 +676,23 @@ class TestBigDecimal < Test::Unit::TestCase BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false) BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - x = BigDecimal.new("0") + x = BigDecimal("0") assert_kind_of(Rational, x.to_r) assert_equal(0, x.to_r) assert_raise(FloatDomainError) {( 1 / x).to_r} assert_raise(FloatDomainError) {(-1 / x).to_r} assert_raise(FloatDomainError) {( 0 / x).to_r} - assert_equal(1, BigDecimal.new("1").to_r) - assert_equal(Rational(3, 2), BigDecimal.new("1.5").to_r) - assert_equal((2**100).to_r, BigDecimal.new((2**100).to_s).to_r) + assert_equal(1, BigDecimal("1").to_r) + assert_equal(Rational(3, 2), BigDecimal("1.5").to_r) + assert_equal((2**100).to_r, BigDecimal((2**100).to_s).to_r) end def test_coerce - a, b = BigDecimal.new("1").coerce(1.0) + a, b = BigDecimal("1").coerce(1.0) assert_instance_of(BigDecimal, a) assert_instance_of(BigDecimal, b) - assert_equal(2, 1 + BigDecimal.new("1"), '[ruby-core:25697]') + assert_equal(2, 1 + BigDecimal("1"), '[ruby-core:25697]') a, b = BigDecimal("1").coerce(1.quo(10)) assert_equal(BigDecimal("0.1"), a, '[ruby-core:34318]') @@ -688,12 +701,12 @@ class TestBigDecimal < Test::Unit::TestCase assert_equal(BigDecimal("0." + "3"*a.precs[0]), a) assert_nothing_raised(TypeError, '#7176') do - BigDecimal.new('1') + Rational(1) + BigDecimal('1') + Rational(1) end end def test_uplus - x = BigDecimal.new("1") + x = BigDecimal("1") assert_equal(x, x.send(:+@)) end @@ -701,26 +714,26 @@ class TestBigDecimal < Test::Unit::TestCase BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false) BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - assert_equal(BigDecimal.new("-1"), BigDecimal.new("1").send(:-@)) - assert_equal(BigDecimal.new("-0"), BigDecimal.new("0").send(:-@)) - assert_equal(BigDecimal.new("0"), BigDecimal.new("-0").send(:-@)) - assert_equal(BigDecimal.new("-Infinity"), BigDecimal.new("Infinity").send(:-@)) - assert_equal(BigDecimal.new("Infinity"), BigDecimal.new("-Infinity").send(:-@)) - assert_equal(true, BigDecimal.new("NaN").send(:-@).nan?) + assert_equal(BigDecimal("-1"), BigDecimal("1").send(:-@)) + assert_equal(BigDecimal("-0"), BigDecimal("0").send(:-@)) + assert_equal(BigDecimal("0"), BigDecimal("-0").send(:-@)) + assert_equal(BigDecimal("-Infinity"), BigDecimal("Infinity").send(:-@)) + assert_equal(BigDecimal("Infinity"), BigDecimal("-Infinity").send(:-@)) + assert_equal(true, BigDecimal("NaN").send(:-@).nan?) end def test_add - x = BigDecimal.new("1") - assert_equal(BigDecimal.new("2"), x + x) - assert_equal(1, BigDecimal.new("0") + 1) + x = BigDecimal("1") + assert_equal(BigDecimal("2"), x + x) + assert_equal(1, BigDecimal("0") + 1) assert_equal(1, x + 0) - assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal.new("0") + 0).sign) - assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal.new("-0") + 0).sign) - assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, (BigDecimal.new("-0") + BigDecimal.new("-0")).sign) + assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal("0") + 0).sign) + assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal("-0") + 0).sign) + assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, (BigDecimal("-0") + BigDecimal("-0")).sign) - x = BigDecimal.new((2**100).to_s) - assert_equal(BigDecimal.new((2**100+1).to_s), x + 1) + x = BigDecimal((2**100).to_s) + assert_equal(BigDecimal((2**100+1).to_s), x + 1) BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false) inf = BigDecimal("Infinity") @@ -732,17 +745,17 @@ class TestBigDecimal < Test::Unit::TestCase end def test_sub - x = BigDecimal.new("1") - assert_equal(BigDecimal.new("0"), x - x) - assert_equal(-1, BigDecimal.new("0") - 1) + x = BigDecimal("1") + assert_equal(BigDecimal("0"), x - x) + assert_equal(-1, BigDecimal("0") - 1) assert_equal(1, x - 0) - assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal.new("0") - 0).sign) - assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, (BigDecimal.new("-0") - 0).sign) - assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal.new("-0") - BigDecimal.new("-0")).sign) + assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal("0") - 0).sign) + assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, (BigDecimal("-0") - 0).sign) + assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal("-0") - BigDecimal("-0")).sign) - x = BigDecimal.new((2**100).to_s) - assert_equal(BigDecimal.new((2**100-1).to_s), x - 1) + x = BigDecimal((2**100).to_s) + assert_equal(BigDecimal((2**100-1).to_s), x - 1) BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false) inf = BigDecimal("Infinity") @@ -754,19 +767,19 @@ class TestBigDecimal < Test::Unit::TestCase end def test_sub_with_float - assert_kind_of(BigDecimal, BigDecimal.new("3") - 1.0) + assert_kind_of(BigDecimal, BigDecimal("3") - 1.0) end def test_sub_with_rational - assert_kind_of(BigDecimal, BigDecimal.new("3") - 1.quo(3)) + assert_kind_of(BigDecimal, BigDecimal("3") - 1.quo(3)) end def test_mult - x = BigDecimal.new((2**100).to_s) - assert_equal(BigDecimal.new((2**100 * 3).to_s), (x * 3).to_i) + x = BigDecimal((2**100).to_s) + assert_equal(BigDecimal((2**100 * 3).to_s), (x * 3).to_i) assert_equal(x, (x * 1).to_i) assert_equal(x, (BigDecimal("1") * x).to_i) - assert_equal(BigDecimal.new((2**200).to_s), (x * x).to_i) + assert_equal(BigDecimal((2**200).to_s), (x * x).to_i) BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false) inf = BigDecimal("Infinity") @@ -778,11 +791,11 @@ class TestBigDecimal < Test::Unit::TestCase end def test_mult_with_float - assert_kind_of(BigDecimal, BigDecimal.new("3") * 1.5) + assert_kind_of(BigDecimal, BigDecimal("3") * 1.5) end def test_mult_with_rational - assert_kind_of(BigDecimal, BigDecimal.new("3") * 1.quo(3)) + assert_kind_of(BigDecimal, BigDecimal("3") * 1.quo(3)) end def test_mult_with_nil @@ -792,39 +805,39 @@ class TestBigDecimal < Test::Unit::TestCase end def test_div - x = BigDecimal.new((2**100).to_s) - assert_equal(BigDecimal.new((2**100 / 3).to_s), (x / 3).to_i) - assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal.new("0") / 1).sign) - assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, (BigDecimal.new("-0") / 1).sign) - assert_equal(2, BigDecimal.new("2") / 1) - assert_equal(-2, BigDecimal.new("2") / -1) + x = BigDecimal((2**100).to_s) + assert_equal(BigDecimal((2**100 / 3).to_s), (x / 3).to_i) + assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal("0") / 1).sign) + assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, (BigDecimal("-0") / 1).sign) + assert_equal(2, BigDecimal("2") / 1) + assert_equal(-2, BigDecimal("2") / -1) assert_equal(BigDecimal('1486.868686869'), BigDecimal('1472.0') / BigDecimal('0.99'), '[ruby-core:59365] [#9316]') assert_equal(4.124045235, BigDecimal('0.9932') / (700 * BigDecimal('0.344045') / BigDecimal('1000.0')), '[#9305]') BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false) - assert_positive_zero(BigDecimal.new("1.0") / BigDecimal.new("Infinity")) - assert_negative_zero(BigDecimal.new("-1.0") / BigDecimal.new("Infinity")) - assert_negative_zero(BigDecimal.new("1.0") / BigDecimal.new("-Infinity")) - assert_positive_zero(BigDecimal.new("-1.0") / BigDecimal.new("-Infinity")) + assert_positive_zero(BigDecimal("1.0") / BigDecimal("Infinity")) + assert_negative_zero(BigDecimal("-1.0") / BigDecimal("Infinity")) + assert_negative_zero(BigDecimal("1.0") / BigDecimal("-Infinity")) + assert_positive_zero(BigDecimal("-1.0") / BigDecimal("-Infinity")) BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, true) BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, false) - assert_raise_with_message(FloatDomainError, "Computation results to 'Infinity'") { BigDecimal.new("1") / 0 } - assert_raise_with_message(FloatDomainError, "Computation results to '-Infinity'") { BigDecimal.new("-1") / 0 } + assert_raise_with_message(FloatDomainError, "Computation results to 'Infinity'") { BigDecimal("1") / 0 } + assert_raise_with_message(FloatDomainError, "Computation results to '-Infinity'") { BigDecimal("-1") / 0 } end def test_div_with_float - assert_kind_of(BigDecimal, BigDecimal.new("3") / 1.5) + assert_kind_of(BigDecimal, BigDecimal("3") / 1.5) end def test_div_with_rational - assert_kind_of(BigDecimal, BigDecimal.new("3") / 1.quo(3)) + assert_kind_of(BigDecimal, BigDecimal("3") / 1.quo(3)) end def test_mod - x = BigDecimal.new((2**100).to_s) + x = BigDecimal((2**100).to_s) assert_equal(1, x % 3) assert_equal(2, (-x) % 3) assert_equal(-2, x % -3) @@ -832,15 +845,15 @@ class TestBigDecimal < Test::Unit::TestCase end def test_mod_with_float - assert_kind_of(BigDecimal, BigDecimal.new("3") % 1.5) + assert_kind_of(BigDecimal, BigDecimal("3") % 1.5) end def test_mod_with_rational - assert_kind_of(BigDecimal, BigDecimal.new("3") % 1.quo(3)) + assert_kind_of(BigDecimal, BigDecimal("3") % 1.quo(3)) end def test_remainder - x = BigDecimal.new((2**100).to_s) + x = BigDecimal((2**100).to_s) assert_equal(1, x.remainder(3)) assert_equal(-1, (-x).remainder(3)) assert_equal(1, x.remainder(-3)) @@ -848,47 +861,47 @@ class TestBigDecimal < Test::Unit::TestCase end def test_remainder_with_float - assert_kind_of(BigDecimal, BigDecimal.new("3").remainder(1.5)) + assert_kind_of(BigDecimal, BigDecimal("3").remainder(1.5)) end def test_remainder_with_rational - assert_kind_of(BigDecimal, BigDecimal.new("3").remainder(1.quo(3))) + assert_kind_of(BigDecimal, BigDecimal("3").remainder(1.quo(3))) end def test_divmod - x = BigDecimal.new((2**100).to_s) + x = BigDecimal((2**100).to_s) assert_equal([(x / 3).floor, 1], x.divmod(3)) assert_equal([(-x / 3).floor, 2], (-x).divmod(3)) - assert_equal([0, 0], BigDecimal.new("0").divmod(2)) + assert_equal([0, 0], BigDecimal("0").divmod(2)) BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - assert_raise(ZeroDivisionError){BigDecimal.new("0").divmod(0)} + assert_raise(ZeroDivisionError){BigDecimal("0").divmod(0)} end def test_add_bigdecimal - x = BigDecimal.new((2**100).to_s) + x = BigDecimal((2**100).to_s) assert_equal(3000000000000000000000000000000, x.add(x, 1)) assert_equal(2500000000000000000000000000000, x.add(x, 2)) assert_equal(2540000000000000000000000000000, x.add(x, 3)) end def test_sub_bigdecimal - x = BigDecimal.new((2**100).to_s) + x = BigDecimal((2**100).to_s) assert_equal(1000000000000000000000000000000, x.sub(1, 1)) assert_equal(1300000000000000000000000000000, x.sub(1, 2)) assert_equal(1270000000000000000000000000000, x.sub(1, 3)) end def test_mult_bigdecimal - x = BigDecimal.new((2**100).to_s) + x = BigDecimal((2**100).to_s) assert_equal(4000000000000000000000000000000, x.mult(3, 1)) assert_equal(3800000000000000000000000000000, x.mult(3, 2)) assert_equal(3800000000000000000000000000000, x.mult(3, 3)) end def test_div_bigdecimal - x = BigDecimal.new((2**100).to_s) + x = BigDecimal((2**100).to_s) assert_equal(422550200076076467165567735125, x.div(3)) assert_equal(400000000000000000000000000000, x.div(3, 1)) assert_equal(420000000000000000000000000000, x.div(3, 2)) @@ -900,49 +913,49 @@ class TestBigDecimal < Test::Unit::TestCase end def test_abs_bigdecimal - x = BigDecimal.new((2**100).to_s) + x = BigDecimal((2**100).to_s) assert_equal(1267650600228229401496703205376, x.abs) - x = BigDecimal.new("-" + (2**100).to_s) + x = BigDecimal("-" + (2**100).to_s) assert_equal(1267650600228229401496703205376, x.abs) - x = BigDecimal.new("0") + x = BigDecimal("0") assert_equal(0, x.abs) - x = BigDecimal.new("-0") + x = BigDecimal("-0") assert_equal(0, x.abs) BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false) - x = BigDecimal.new("Infinity") - assert_equal(BigDecimal.new("Infinity"), x.abs) - x = BigDecimal.new("-Infinity") - assert_equal(BigDecimal.new("Infinity"), x.abs) + x = BigDecimal("Infinity") + assert_equal(BigDecimal("Infinity"), x.abs) + x = BigDecimal("-Infinity") + assert_equal(BigDecimal("Infinity"), x.abs) BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - x = BigDecimal.new("NaN") + x = BigDecimal("NaN") assert_nan(x.abs) end def test_sqrt_bigdecimal - x = BigDecimal.new("0.09") + x = BigDecimal("0.09") assert_in_delta(0.3, x.sqrt(1), 0.001) - x = BigDecimal.new((2**100).to_s) + x = BigDecimal((2**100).to_s) y = BigDecimal("1125899906842624") e = y.exponent assert_equal(true, (x.sqrt(100) - y).abs < BigDecimal("1E#{e-100}")) assert_equal(true, (x.sqrt(200) - y).abs < BigDecimal("1E#{e-200}")) assert_equal(true, (x.sqrt(300) - y).abs < BigDecimal("1E#{e-300}")) - x = BigDecimal.new("-" + (2**100).to_s) + x = BigDecimal("-" + (2**100).to_s) assert_raise_with_message(FloatDomainError, "sqrt of negative value") { x.sqrt(1) } - x = BigDecimal.new((2**200).to_s) + x = BigDecimal((2**200).to_s) assert_equal(2**100, x.sqrt(1)) BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false) BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - assert_raise_with_message(FloatDomainError, "sqrt of 'NaN'(Not a Number)") { BigDecimal.new("NaN").sqrt(1) } - assert_raise_with_message(FloatDomainError, "sqrt of negative value") { BigDecimal.new("-Infinity").sqrt(1) } + assert_raise_with_message(FloatDomainError, "sqrt of 'NaN'(Not a Number)") { BigDecimal("NaN").sqrt(1) } + assert_raise_with_message(FloatDomainError, "sqrt of negative value") { BigDecimal("-Infinity").sqrt(1) } - assert_equal(0, BigDecimal.new("0").sqrt(1)) - assert_equal(0, BigDecimal.new("-0").sqrt(1)) - assert_equal(1, BigDecimal.new("1").sqrt(1)) - assert_positive_infinite(BigDecimal.new("Infinity").sqrt(1)) + assert_equal(0, BigDecimal("0").sqrt(1)) + assert_equal(0, BigDecimal("-0").sqrt(1)) + assert_equal(1, BigDecimal("1").sqrt(1)) + assert_positive_infinite(BigDecimal("Infinity").sqrt(1)) end def test_sqrt_5266 @@ -960,26 +973,26 @@ class TestBigDecimal < Test::Unit::TestCase end def test_fix - x = BigDecimal.new("1.1") + x = BigDecimal("1.1") assert_equal(1, x.fix) assert_kind_of(BigDecimal, x.fix) end def test_frac - x = BigDecimal.new("1.1") + x = BigDecimal("1.1") assert_equal(0.1, x.frac) - assert_equal(0.1, BigDecimal.new("0.1").frac) + assert_equal(0.1, BigDecimal("0.1").frac) BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - assert_nan(BigDecimal.new("NaN").frac) + assert_nan(BigDecimal("NaN").frac) end def test_round - assert_equal(3, BigDecimal.new("3.14159").round) - assert_equal(9, BigDecimal.new("8.7").round) - assert_equal(3.142, BigDecimal.new("3.14159").round(3)) - assert_equal(13300.0, BigDecimal.new("13345.234").round(-2)) + assert_equal(3, BigDecimal("3.14159").round) + assert_equal(9, BigDecimal("8.7").round) + assert_equal(3.142, BigDecimal("3.14159").round(3)) + assert_equal(13300.0, BigDecimal("13345.234").round(-2)) - x = BigDecimal.new("111.111") + x = BigDecimal("111.111") assert_equal(111 , x.round) assert_equal(111.1 , x.round(1)) assert_equal(111.11 , x.round(2)) @@ -990,7 +1003,7 @@ class TestBigDecimal < Test::Unit::TestCase assert_equal( 0 , x.round(-3)) assert_equal( 0 , x.round(-4)) - x = BigDecimal.new("2.5") + x = BigDecimal("2.5") assert_equal(3, x.round(0, BigDecimal::ROUND_UP)) assert_equal(2, x.round(0, BigDecimal::ROUND_DOWN)) assert_equal(3, x.round(0, BigDecimal::ROUND_HALF_UP)) @@ -1000,19 +1013,28 @@ class TestBigDecimal < Test::Unit::TestCase assert_equal(2, x.round(0, BigDecimal::ROUND_FLOOR)) assert_raise(ArgumentError) { x.round(0, 256) } + x = BigDecimal("-2.5") + assert_equal(-3, x.round(0, BigDecimal::ROUND_UP)) + assert_equal(-2, x.round(0, BigDecimal::ROUND_DOWN)) + assert_equal(-3, x.round(0, BigDecimal::ROUND_HALF_UP)) + assert_equal(-2, x.round(0, BigDecimal::ROUND_HALF_DOWN)) + assert_equal(-2, x.round(0, BigDecimal::ROUND_HALF_EVEN)) + assert_equal(-2, x.round(0, BigDecimal::ROUND_CEILING)) + assert_equal(-3, x.round(0, BigDecimal::ROUND_FLOOR)) + ROUNDING_MODE_MAP.each do |const, sym| assert_equal(x.round(0, const), x.round(0, sym)) end bug3803 = '[ruby-core:32136]' 15.times do |n| - x = BigDecimal.new("5#{'0'*n}1") + x = BigDecimal("5#{'0'*n}1") assert_equal(10**(n+2), x.round(-(n+2), BigDecimal::ROUND_HALF_DOWN), bug3803) assert_equal(10**(n+2), x.round(-(n+2), BigDecimal::ROUND_HALF_EVEN), bug3803) - x = BigDecimal.new("0.5#{'0'*n}1") + x = BigDecimal("0.5#{'0'*n}1") assert_equal(1, x.round(0, BigDecimal::ROUND_HALF_DOWN), bug3803) assert_equal(1, x.round(0, BigDecimal::ROUND_HALF_EVEN), bug3803) - x = BigDecimal.new("-0.5#{'0'*n}1") + x = BigDecimal("-0.5#{'0'*n}1") assert_equal(-1, x.round(0, BigDecimal::ROUND_HALF_DOWN), bug3803) assert_equal(-1, x.round(0, BigDecimal::ROUND_HALF_EVEN), bug3803) end @@ -1082,7 +1104,7 @@ class TestBigDecimal < Test::Unit::TestCase end def test_round_half_nil - x = BigDecimal.new("2.5") + x = BigDecimal("2.5") BigDecimal.save_rounding_mode do BigDecimal.mode(BigDecimal::ROUND_MODE, BigDecimal::ROUND_UP) @@ -1126,61 +1148,66 @@ class TestBigDecimal < Test::Unit::TestCase end def test_truncate - assert_equal(3, BigDecimal.new("3.14159").truncate) - assert_equal(8, BigDecimal.new("8.7").truncate) - assert_equal(3.141, BigDecimal.new("3.14159").truncate(3)) - assert_equal(13300.0, BigDecimal.new("13345.234").truncate(-2)) + assert_equal(3, BigDecimal("3.14159").truncate) + assert_equal(8, BigDecimal("8.7").truncate) + assert_equal(3.141, BigDecimal("3.14159").truncate(3)) + assert_equal(13300.0, BigDecimal("13345.234").truncate(-2)) + + assert_equal(-3, BigDecimal("-3.14159").truncate) + assert_equal(-8, BigDecimal("-8.7").truncate) + assert_equal(-3.141, BigDecimal("-3.14159").truncate(3)) + assert_equal(-13300.0, BigDecimal("-13345.234").truncate(-2)) end def test_floor - assert_equal(3, BigDecimal.new("3.14159").floor) - assert_equal(-10, BigDecimal.new("-9.1").floor) - assert_equal(3.141, BigDecimal.new("3.14159").floor(3)) - assert_equal(13300.0, BigDecimal.new("13345.234").floor(-2)) + assert_equal(3, BigDecimal("3.14159").floor) + assert_equal(-10, BigDecimal("-9.1").floor) + assert_equal(3.141, BigDecimal("3.14159").floor(3)) + assert_equal(13300.0, BigDecimal("13345.234").floor(-2)) end def test_ceil - assert_equal(4, BigDecimal.new("3.14159").ceil) - assert_equal(-9, BigDecimal.new("-9.1").ceil) - assert_equal(3.142, BigDecimal.new("3.14159").ceil(3)) - assert_equal(13400.0, BigDecimal.new("13345.234").ceil(-2)) + assert_equal(4, BigDecimal("3.14159").ceil) + assert_equal(-9, BigDecimal("-9.1").ceil) + assert_equal(3.142, BigDecimal("3.14159").ceil(3)) + assert_equal(13400.0, BigDecimal("13345.234").ceil(-2)) end def test_to_s - assert_equal('-123.45678 90123 45678 9', BigDecimal.new('-123.45678901234567890').to_s('5F')) - assert_equal('+123.45678901 23456789', BigDecimal.new('123.45678901234567890').to_s('+8F')) - assert_equal(' 123.4567890123456789', BigDecimal.new('123.45678901234567890').to_s(' F')) - assert_equal('0.1234567890123456789e3', BigDecimal.new('123.45678901234567890').to_s) - assert_equal('0.12345 67890 12345 6789e3', BigDecimal.new('123.45678901234567890').to_s(5)) + assert_equal('-123.45678 90123 45678 9', BigDecimal('-123.45678901234567890').to_s('5F')) + assert_equal('+123.45678901 23456789', BigDecimal('123.45678901234567890').to_s('+8F')) + assert_equal(' 123.4567890123456789', BigDecimal('123.45678901234567890').to_s(' F')) + assert_equal('0.1234567890123456789e3', BigDecimal('123.45678901234567890').to_s) + assert_equal('0.12345 67890 12345 6789e3', BigDecimal('123.45678901234567890').to_s(5)) end def test_split - x = BigDecimal.new('-123.45678901234567890') + x = BigDecimal('-123.45678901234567890') assert_equal([-1, "1234567890123456789", 10, 3], x.split) - assert_equal([1, "0", 10, 0], BigDecimal.new("0").split) - assert_equal([-1, "0", 10, 0], BigDecimal.new("-0").split) + assert_equal([1, "0", 10, 0], BigDecimal("0").split) + assert_equal([-1, "0", 10, 0], BigDecimal("-0").split) BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false) BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - assert_equal([0, "NaN", 10, 0], BigDecimal.new("NaN").split) - assert_equal([1, "Infinity", 10, 0], BigDecimal.new("Infinity").split) - assert_equal([-1, "Infinity", 10, 0], BigDecimal.new("-Infinity").split) + assert_equal([0, "NaN", 10, 0], BigDecimal("NaN").split) + assert_equal([1, "Infinity", 10, 0], BigDecimal("Infinity").split) + assert_equal([-1, "Infinity", 10, 0], BigDecimal("-Infinity").split) end def test_exponent - x = BigDecimal.new('-123.45678901234567890') + x = BigDecimal('-123.45678901234567890') assert_equal(3, x.exponent) end def test_inspect - assert_equal("0.123456789012e0", BigDecimal.new("0.123456789012").inspect) - assert_equal("0.123456789012e4", BigDecimal.new("1234.56789012").inspect) - assert_equal("0.123456789012e-4", BigDecimal.new("0.0000123456789012").inspect) + assert_equal("0.123456789012e0", BigDecimal("0.123456789012").inspect) + assert_equal("0.123456789012e4", BigDecimal("1234.56789012").inspect) + assert_equal("0.123456789012e-4", BigDecimal("0.0000123456789012").inspect) end def test_power assert_nothing_raised(TypeError, '[ruby-core:47632]') do - 1000.times { BigDecimal.new('1001.10')**0.75 } + 1000.times { BigDecimal('1001.10')**0.75 } end end @@ -1379,7 +1406,7 @@ class TestBigDecimal < Test::Unit::TestCase def test_limit BigDecimal.limit(1) - x = BigDecimal.new("3") + x = BigDecimal("3") assert_equal(90, x ** 4) # OK? must it be 80? # 3 * 3 * 3 * 3 = 10 * 3 * 3 = 30 * 3 = 90 ??? assert_raise(ArgumentError) { BigDecimal.limit(-1) } @@ -1409,19 +1436,19 @@ class TestBigDecimal < Test::Unit::TestCase BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, false) - assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, BigDecimal.new("0").sign) - assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, BigDecimal.new("-0").sign) - assert_equal(BigDecimal::SIGN_POSITIVE_FINITE, BigDecimal.new("1").sign) - assert_equal(BigDecimal::SIGN_NEGATIVE_FINITE, BigDecimal.new("-1").sign) - assert_equal(BigDecimal::SIGN_POSITIVE_INFINITE, (BigDecimal.new("1") / 0).sign) - assert_equal(BigDecimal::SIGN_NEGATIVE_INFINITE, (BigDecimal.new("-1") / 0).sign) - assert_equal(BigDecimal::SIGN_NaN, (BigDecimal.new("0") / 0).sign) + assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, BigDecimal("0").sign) + assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, BigDecimal("-0").sign) + assert_equal(BigDecimal::SIGN_POSITIVE_FINITE, BigDecimal("1").sign) + assert_equal(BigDecimal::SIGN_NEGATIVE_FINITE, BigDecimal("-1").sign) + assert_equal(BigDecimal::SIGN_POSITIVE_INFINITE, (BigDecimal("1") / 0).sign) + assert_equal(BigDecimal::SIGN_NEGATIVE_INFINITE, (BigDecimal("-1") / 0).sign) + assert_equal(BigDecimal::SIGN_NaN, (BigDecimal("0") / 0).sign) end def test_inf BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false) BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - inf = BigDecimal.new("Infinity") + inf = BigDecimal("Infinity") assert_equal(inf, inf + inf) assert_nan((inf + (-inf))) @@ -1448,14 +1475,14 @@ class TestBigDecimal < Test::Unit::TestCase def test_to_special_string BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false) BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false) - nan = BigDecimal.new("NaN") + nan = BigDecimal("NaN") assert_equal("NaN", nan.to_s) - inf = BigDecimal.new("Infinity") + inf = BigDecimal("Infinity") assert_equal("Infinity", inf.to_s) assert_equal(" Infinity", inf.to_s(" ")) assert_equal("+Infinity", inf.to_s("+")) assert_equal("-Infinity", (-inf).to_s) - pzero = BigDecimal.new("0") + pzero = BigDecimal("0") assert_equal("0.0", pzero.to_s) assert_equal(" 0.0", pzero.to_s(" ")) assert_equal("+0.0", pzero.to_s("+")) @@ -1471,15 +1498,15 @@ class TestBigDecimal < Test::Unit::TestCase end def test_ctov - assert_equal(0.1, BigDecimal.new("1E-1")) - assert_equal(10, BigDecimal.new("1E+1")) - assert_equal(1, BigDecimal.new("+1")) + assert_equal(0.1, BigDecimal("1E-1")) + assert_equal(10, BigDecimal("1E+1")) + assert_equal(1, BigDecimal("+1")) BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false) - assert_equal(BigDecimal::SIGN_POSITIVE_INFINITE, BigDecimal.new("1E1" + "0" * 10000).sign) - assert_equal(BigDecimal::SIGN_NEGATIVE_INFINITE, BigDecimal.new("-1E1" + "0" * 10000).sign) - assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, BigDecimal.new("1E-1" + "0" * 10000).sign) - assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, BigDecimal.new("-1E-1" + "0" * 10000).sign) + assert_equal(BigDecimal::SIGN_POSITIVE_INFINITE, BigDecimal("1E1" + "0" * 10000).sign) + assert_equal(BigDecimal::SIGN_NEGATIVE_INFINITE, BigDecimal("-1E1" + "0" * 10000).sign) + assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, BigDecimal("1E-1" + "0" * 10000).sign) + assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, BigDecimal("-1E-1" + "0" * 10000).sign) end def test_split_under_gc_stress @@ -1488,7 +1515,7 @@ class TestBigDecimal < Test::Unit::TestCase assert_in_out_err(%w[-rbigdecimal --disable-gems], <<-EOS, expect, [], bug3258) GC.stress = true 10.upto(20) do |i| - p BigDecimal.new("1"+"0"*i).split + p BigDecimal("1"+"0"*i).split end EOS end @@ -1496,7 +1523,7 @@ class TestBigDecimal < Test::Unit::TestCase def test_coerce_under_gc_stress assert_in_out_err(%w[-rbigdecimal --disable-gems], <<-EOS, [], []) expect = ":too_long_to_embed_as_string can't be coerced into BigDecimal" - b = BigDecimal.new("1") + b = BigDecimal("1") GC.stress = true 10.times do begin @@ -1749,21 +1776,37 @@ class TestBigDecimal < Test::Unit::TestCase EOS end + def test_clone + assert_warning(/BigDecimal#clone is deprecated/) do + BigDecimal(0).clone + end + end + def test_dup - [1, -1, 2**100, -2**100].each do |i| - x = BigDecimal(i) - assert_equal(x, x.dup) + assert_warning(/BigDecimal#dup is deprecated/) do + [1, -1, 2**100, -2**100].each do |i| + x = BigDecimal(i) + assert_equal(x, x.dup) + end end end def test_dup_subclass - c = Class.new(BigDecimal) - x = c.new(1) - y = x.dup - assert_equal(1, y) - assert_kind_of(c, y) + assert_warning(/BigDecimal#dup is deprecated/) do + c = Class.new(BigDecimal) + x = c.new(1) + y = x.dup + assert_equal(1, y) + assert_kind_of(c, y) + end end + def test_to_d + bug6093 = '[ruby-core:42969]' + code = "exit(BigDecimal('10.0') == 10.0.to_d)" + assert_ruby_status(%w[-rbigdecimal -rbigdecimal/util -rmathn -], code, bug6093) + end if RUBY_VERSION < '2.5' # mathn was removed from Ruby 2.5 + def test_bug6406 assert_in_out_err(%w[-rbigdecimal --disable-gems], <<-EOS, [], []) Thread.current.keys.to_s @@ -1784,7 +1827,7 @@ class TestBigDecimal < Test::Unit::TestCase end def test_no_memory_leak_initialize - assert_no_memory_leak("BigDecimal.new") + assert_no_memory_leak("BigDecimal()") end def test_no_memory_leak_global_new diff --git a/test/bigdecimal/test_bigdecimal_util.rb b/test/bigdecimal/test_bigdecimal_util.rb index 35adddddef..fd457f6bf5 100644 --- a/test/bigdecimal/test_bigdecimal_util.rb +++ b/test/bigdecimal/test_bigdecimal_util.rb @@ -50,11 +50,11 @@ class TestBigDecimalUtil < Test::Unit::TestCase end def test_String_to_d - assert_equal("2.5".to_d, BigDecimal.new('2.5')) + assert_equal("2.5".to_d, BigDecimal('2.5')) end def test_invalid_String_to_d - assert_equal("invalid".to_d, BigDecimal.new('0.0')) + assert_equal("invalid".to_d, BigDecimal('0.0')) end end -- cgit v1.2.3