decimal 0.0.2 → 0.0.90.pre

data/ruby18compat.h

@@ -0,0 +1,55 @@
+/*
+ *  ruby18compat.h - write Ruby 1.8 compatible extention library
+ *		     with 1.9 style
+ *
+ *  This program is under public domain.
+ */
+
+#ifndef RBIGNUM_SIGN
+#define RBIGNUM_SIGN(x) RBIGNUM(x)->sign
+#endif
+
+#ifndef RBIGNUM_NEGATIVE_P
+#define RBIGNUM_NEGATIVE_P(x) (!RBIGNUM_SIGN(x))
+#endif
+
+#ifndef RUBY_CRITICAL
+#define RUBY_CRITICAL(statements) do {statements;} while (0)
+#endif
+
+#ifndef RB_NUM_COERCE_FUNCS_NEED_OPID
+#define rb_num_coerce_bin(x, y, id) rb_num_coerce_bin(x, y)
+#define rb_num_coerce_cmp(x, y, id) rb_num_coerce_cmp(x, y)
+#define rb_num_coerce_relop(x, y, id) rb_num_coerce_relop(x, y)
+#endif
+
+#ifndef HAVE_RB_BIG_DIV
+#define rb_big_div(x, y) (RARRAY_PTR(rb_big_divmod(x, y))[0])
+#endif
+
+#ifndef HAVE_RB_BIG_MODULO
+#define rb_big_modulo(x, y) (RARRAY_PTR(rb_big_divmod(x, y))[1])
+#endif
+
+#ifndef NAN
+#if BYTE_ORDER == LITTLE_ENDIAN
+static const unsigned char rb_nan[] = "\x00\x00\xc0\x7f";
+#else
+static const unsigned char rb_nan[] = "\x7f\xc0\x00\x00";
+#endif
+#define NAN (*(float *)rb_nan)
+#endif
+
+#ifndef INFINITY
+#if BYTE_ORDER == LITTLE_ENDIAN
+static const unsigned char rb_infinity[] = "\x00\x00\x80\x7f";
+#else
+static const unsigned char rb_infinity[] = "\x7f\x80\x00\x00";
+#endif
+#define INFINITY (*(float *)rb_infinity)
+#endif
+
+#ifndef HAVE_RB_USASCII_STR_NEW
+#define rb_usascii_str_new rb_str_new
+#define rb_usascii_str_new_cstr rb_str_new2
+#endif

data/test_decimal.rb

@@ -0,0 +1,546 @@
+require 'decimal'
+require 'test/unit'
+
+class TestDecimal < Test::Unit::TestCase
+  ONE = Decimal(1)
+  ZERO = Decimal(0)
+  INFINITY = Decimal::INFINITY 
+  NAN = Decimal::NAN
+
+  def assert_nan(a, *rest)
+    rest = ["not nan: #{a.inspect}"] if rest.empty?
+    assert(a.nan?, *rest)
+  end
+
+  def assert_infinity(a, *rest)
+    rest = ["not infinity: #{a.inspect}"] if rest.empty?
+    assert(a.infinite?, *rest)
+  end
+
+  def test_initialize
+    assert_nothing_raised {Decimal(1)}
+    assert_nothing_raised {Decimal(2**64)}
+    assert_nothing_raised {Decimal("1")}
+    assert_nothing_raised {Decimal("1.1")}
+    assert_nothing_raised {Decimal("1e10")}
+    assert_nothing_raised {Decimal("299_792_458")}
+    assert_nothing_raised {Decimal("2.99_792_458e8")}
+    assert_raise(ArgumentError) {Decimal(1.1)}
+  end
+
+  def test_stringize
+    assert_equal("1", ONE.to_s)
+    assert_equal("1", Decimal("1").to_s)
+    assert_equal("1.1", Decimal("1.1").to_s)
+    assert_equal("18446744073709551616", Decimal(2**64).to_s)
+    assert_equal("10000000000", Decimal("1e10").to_s)
+    assert_equal("299792458", Decimal("299_792_458").to_s)
+    assert_equal("299792458", Decimal("2.99_792_458e8").to_s)
+    assert_equal("Infinity", INFINITY.to_s)
+    assert_equal("-Infinity", (-INFINITY).to_s)
+    assert_equal("NaN", NAN.to_s)
+
+    assert_equal("Decimal(1)", ONE.inspect)
+    assert_equal("Decimal(1)", Decimal("1").inspect)
+    assert_equal("Decimal(1.1)", Decimal("1.1").inspect)
+    assert_equal("Decimal(18446744073709551616)", Decimal(2**64).inspect)
+    assert_equal("Decimal(10000000000)", Decimal("1e10").inspect)
+    assert_equal("Decimal(299792458)", Decimal("299_792_458").inspect)
+    assert_equal("Decimal(299792458)", Decimal("2.99_792_458e8").inspect)
+    assert_equal("Decimal(Infinity)", INFINITY.inspect)
+    assert_equal("Decimal(-Infinity)", (-INFINITY).inspect)
+    assert_equal("Decimal(NaN)", NAN.inspect)
+  end
+
+  def test_coerce
+    assert_equal([Decimal(2), ONE], ONE.coerce(2))
+    assert_equal([Decimal(2), ONE], ONE.coerce(Decimal(2)))
+    assert_raise(TypeError) {ONE.coerce(2.5)}
+  end
+
+  def test_uminus
+    assert_equal(Decimal(-1), -ONE)
+    assert_equal(Decimal(-(2**64)), -Decimal(2**64))
+    assert(Decimal("-0").eql?(-ZERO)) # should use Decimal#eql?,
+    assert(ZERO.eql?(-Decimal("-0"))) # because `-0 == 0`
+    assert(!ZERO.eql?(-ZERO))
+    assert(!Decimal("-0").eql?(-Decimal("-0")))
+    assert_not_equal(-NAN, -NAN)
+    assert_equal(Decimal(-1).divide(0), -INFINITY)
+    assert_equal(INFINITY, -(Decimal(-1).divide(0)))
+  end
+
+  def test_add
+    assert_equal(Decimal("1.1"), Decimal("0.1") + 1)
+    sum = 0
+    10.times {sum += Decimal("0.1")}
+    assert_equal(ONE, sum)
+    assert_raise(TypeError) {Decimal("0.1") + 1.0}
+  end
+
+  def test_sub
+    assert_equal(Decimal("0.1"), Decimal("1.1") - 1)
+    sum = 0
+    10.times {sum -= Decimal("0.1")}
+    assert_equal(Decimal(-1), sum)
+    assert_raise(TypeError) {Decimal("0.1") - 1.0}
+  end
+
+  def test_mul
+    assert_equal(ONE, Decimal("0.1") * 10)
+    sum = ONE
+    10.times {sum *= Decimal("0.1")}
+    assert_equal(Decimal("0.0000000001"), sum)
+    assert_raise(TypeError) {Decimal("0.1") * 1.0}
+  end
+
+  def test_div
+    assert_equal(Decimal("0.1"), ONE.divide(10, 1))
+    sum = Decimal(1 << 10)
+    10.times {sum = sum.divide(2)}
+    assert_equal(ONE, sum)
+    assert_raise(TypeError) {Decimal("0.1").divide(1.0)}
+  end
+
+  def test_idiv
+    assert_equal(2, Decimal("11.5").div(4))
+    assert_equal(-3, Decimal("11.5").div(-4))
+    assert_equal(-3, Decimal("-11.5").div(4))
+    assert_equal(2, Decimal("-11.5").div(-4))
+    assert_raise(TypeError) {Decimal(11).div(4.0)}
+    assert_nan(Decimal::NAN.div(1))
+    assert_nan(Decimal(1).div(Decimal::NAN))
+    assert_nan(Decimal::INFINITY.div(1))
+  end
+
+  def test_mod
+    assert_equal(0, Decimal(1) % 1)
+    assert_equal(Decimal("3.5"), Decimal("11.5") % 4)
+    assert_equal(Decimal("-0.5"), Decimal("11.5") % -4)
+    assert_equal(Decimal("0.5"), Decimal("-11.5") % 4)
+    assert_equal(Decimal("-3.5"), Decimal("-11.5") % -4)
+    assert_raise(TypeError) {Decimal(11) % 4.0}
+    assert_nan(Decimal::NAN % 1)
+    assert_nan(Decimal(1) % Decimal::NAN)
+    assert_nan(Decimal::INFINITY % 1)
+  end
+
+  def test_pow
+    assert_equal(1 << 10, Decimal(2) ** 10)
+    assert_equal(1, ONE ** 10)
+    assert_equal(Decimal("0.0000000001"), Decimal("0.1") ** 10)
+    assert_raise(TypeError) {ONE ** 10.0}
+  end
+
+  def test_eq
+    assert_equal(ONE, 1)
+    assert_equal(Decimal("1.0"), 1)
+    assert_equal(Decimal("100e-2"), 1)
+    assert_equal(Decimal("0.01e2"), 1)
+
+    assert(ONE.eql?(ONE))
+    assert((-ONE).eql?(-ONE))
+    assert(INFINITY.eql?(INFINITY))
+    assert((-INFINITY).eql?(-INFINITY))
+    assert(!ONE.eql?(Decimal("1.0")))
+
+    assert_not_equal(ONE, 2**32)
+    assert_not_equal(ONE, NAN)
+    assert_not_equal(ONE, nil)
+    assert_not_equal(ONE, 1.0)
+  end
+
+  def test_cmp
+    assert_equal(0, ONE <=> ONE)
+    assert_equal(1, ONE <=> ZERO)
+    assert_equal(-1, ZERO <=> ONE)
+    assert_equal(-1, ONE <=> Decimal(2))
+    assert_nil(ONE <=> nil)
+    assert_nil(ONE <=> NAN)
+    assert_nil(NAN <=> ONE)
+    assert_nil(ONE <=> 1.0)
+
+    assert_equal(0, ONE <=> 1)
+    assert_equal(1, ONE <=> 0)
+    assert_equal(-1, ONE <=> 2)
+
+    assert_equal(-1, ONE <=> 2**32)
+
+    assert_raise(ArgumentError) {ONE > nil}
+    assert_raise(ArgumentError) {ONE >= nil}
+    assert_raise(ArgumentError) {ONE < nil}
+    assert_raise(ArgumentError) {ONE <= nil}
+
+    assert_raise(ArgumentError) {ONE > 1.0}
+    assert_raise(ArgumentError) {ONE >= 1.0}
+    assert_raise(ArgumentError) {ONE < 1.0}
+    assert_raise(ArgumentError) {ONE <= 1.0}
+  end
+
+  def test_hash
+    assert_equal(ONE.hash, ONE.hash)
+    assert_equal(ZERO.hash, ZERO.hash)
+    assert_equal(NAN.hash, NAN.hash)
+    assert_equal(INFINITY.hash, INFINITY.hash)
+
+    assert_not_equal(ONE.hash, Decimal("1.0").hash)
+    assert_not_equal(ZERO.hash, Decimal("0.0").hash)
+  end
+
+  def test_abs
+    assert_equal(Decimal(-1).abs, ONE)
+    assert_equal(Decimal(-(2**64)).abs, 2**64)
+    assert(Decimal("-0").abs.eql?(ZERO))
+    assert_equal((-INFINITY).abs, INFINITY)
+    assert_not_equal(NAN.abs, NAN)
+  end
+
+  def test_divmod
+    assert_equal([2, Decimal("3.5")], Decimal("11.5").divmod(4))
+    assert_equal([-3, Decimal("-0.5")], Decimal("11.5").divmod(-4))
+    assert_equal([-3, Decimal("0.5")], Decimal("-11.5").divmod(4))
+    assert_equal([2, Decimal("-3.5")], Decimal("-11.5").divmod(-4))
+    assert_raise(TypeError) {Decimal(11).divmod(4.0)}
+    div, mod = Decimal::NAN.divmod(1)
+    assert_nan(div)
+    assert_nan(mod)
+    div, mod = Decimal(1).divmod(Decimal::NAN)
+    assert_nan(div)
+    assert_nan(mod)
+    div, mod = Decimal::INFINITY.divmod(1)
+    assert_nan(div)
+    assert_nan(mod)
+  end
+
+  def test_div
+    assert_equal(1, Decimal(1).div(1))
+    assert_equal(2, Decimal("11.5").div(4))
+    assert_equal(-3, Decimal("11.5").div(-4))
+    assert_equal(-3, Decimal("-11.5").div(4))
+    assert_equal(2, Decimal("-11.5").div(-4))
+  end
+
+  def test_remainder
+    assert_equal(0, Decimal(1).remainder(1))
+    assert_equal(Decimal("3.5"), Decimal("11.5").remainder(4))
+    assert_equal(Decimal("3.5"), Decimal("11.5").remainder(-4))
+    assert_equal(Decimal("-3.5"), Decimal("-11.5").remainder(4))
+    assert_equal(Decimal("-3.5"), Decimal("-11.5").remainder(-4))
+  end
+
+  def test_to_f
+    max, min = Float::MAX_10_EXP+10, Float::MIN_10_EXP-10
+    assert_equal(1.0/0.0, Decimal("1e#{max}").to_f)
+    assert_equal(-1.0/0.0, Decimal("-1e#{max}").to_f)
+    assert_equal("0.0", Decimal("1e#{min}").to_f.to_s)
+    assert_equal("-0.0", Decimal("-1e#{min}").to_f.to_s)
+  end
+
+  def test_zero_scale
+    a, b, c, d = Decimal(0), Decimal("0.0"), Decimal("-0"), Decimal("-0.0")
+    assert_equal("0.0", (a + b).to_s)
+    assert_equal("-0.0", (c + d).to_s)
+    assert_equal("0.0", (a + d).to_s)
+    assert_equal("1.0", (Decimal("0.0")+Decimal(1)).to_s)
+  end
+
+  # math part
+  
+  M = Decimal::Math
+  SCALE = Float::DIG * 2
+  PI = M.pi(SCALE*2)
+  def check(expected, actual)
+    expected = Decimal(expected).round(SCALE/2)
+    actual = Decimal(actual).round(SCALE/2)
+    assert_in_delta(expected, actual, Decimal("1e-#{SCALE/2}"))
+  end
+
+  def test_math_atan2
+    #assert_raise(Math::DomainError) { Math.atan2(0, 0) }
+    #assert_raise(Math::DomainError) { Math.atan2(Float::INFINITY, Float::INFINITY) }
+    #assert_raise(Math::DomainError) { Math.atan2(Float::INFINITY, -Float::INFINITY) }
+    #assert_raise(Math::DomainError) { Math.atan2(-Float::INFINITY, Float::INFINITY) }
+    #assert_raise(Math::DomainError) { Math.atan2(-Float::INFINITY, -Float::INFINITY) }
+    check(0, M.atan2(0, 1, SCALE))
+    check(PI.divide(4, SCALE, :down), M.atan2(1, 1, SCALE))
+    check(PI.divide(2, SCALE, :down), M.atan2(1, 0, SCALE))
+  end
+
+  def test_math_cos
+    check(1, M.cos(0, SCALE))
+    sqrt_2 = M.sqrt(2, SCALE)
+    pi_q = PI.divide(4, SCALE, :half_up)
+    check(ONE.divide(sqrt_2, SCALE, :half_up), M.cos(pi_q, SCALE))
+    check(0, M.cos(2 * pi_q, SCALE))
+    check(-1, M.cos(4 * pi_q, SCALE))
+    check(0, M.cos(6 * pi_q, SCALE))
+  end
+
+  def test_math_sin
+    check(0,  M.sin(0, SCALE))
+    sqrt_2 = M.sqrt(2, SCALE)
+    pi_q = PI.divide(4, SCALE, :half_up)
+    check(ONE.divide(sqrt_2, SCALE, :half_up), M.sin(pi_q, SCALE))
+    check(1,  M.sin(2 * pi_q, SCALE))
+    check(0,  M.sin(4 * pi_q, SCALE))
+    check(-1, M.sin(6 * pi_q, SCALE))
+  end
+
+  def test_math_tan
+    check(0, M.tan(0, SCALE))
+    pi_q = PI.divide(4, SCALE, :half_up)
+    check(1, M.tan(pi_q, SCALE))
+    assert(M.tan(2 * pi_q, SCALE).abs > Decimal("1e#{SCALE}"))
+    check(0, M.tan(4 * pi_q, SCALE))
+    assert(M.tan(6 * pi_q, SCALE).abs > Decimal("1e#{SCALE}"))
+  end
+
+  def test_math_acos
+    pi_q = PI.divide(4, SCALE, :half_up)
+    check(0 * pi_q, M.acos(1, SCALE))
+    sqrt_2 = M.sqrt(2, SCALE)
+    check(1 * pi_q, M.acos(ONE.divide(sqrt_2, SCALE, :half_up), SCALE))
+    check(2 * pi_q, M.acos(0, SCALE))
+    check(4 * pi_q, M.acos(-1, SCALE))
+    assert_raise(Errno::EDOM) {M.acos(+1 + Decimal("1e-#{SCALE*2}"), SCALE)} # XXX
+    assert_raise(Errno::EDOM) {M.acos(-1 - Decimal("1e-#{SCALE*2}"), SCALE)} # XXX
+    assert_raise(Errno::EDOM) {M.acos(2, SCALE)} # XXX
+  end
+
+  def test_math_asin
+    pi_q = PI.divide(4, SCALE, :half_up)
+    check(0 * pi_q, M.asin(0, SCALE))
+    sqrt_2 = M.sqrt(2, SCALE)
+    check(1 * pi_q, M.asin(ONE.divide(sqrt_2, SCALE, :half_up), SCALE))
+    check(2 * pi_q, M.asin(1, SCALE))
+    check(-2 * pi_q, M.asin(-1, SCALE))
+    assert_raise(Errno::EDOM) {M.asin(+1 + Decimal("1e-#{SCALE*2}"), SCALE)} # XXX
+    assert_raise(Errno::EDOM) {M.asin(-1 - Decimal("1e-#{SCALE*2}"), SCALE)} # XXX
+    assert_raise(Errno::EDOM) {M.asin(2, SCALE)} # XXX
+  end
+
+  def test_math_atan
+    pi_q = PI.divide(4, SCALE, :half_up)
+    check(0 * pi_q, M.atan(0, SCALE))
+    check(1 * pi_q, M.atan(1, SCALE))
+    check(2 * pi_q, M.atan(INFINITY, SCALE))
+    check(-1 * pi_q, M.atan(-1, SCALE))
+  end
+
+  E = M.e(SCALE*2)
+  E_INV = Decimal(1).divide(E, SCALE*2, :down)
+  def test_math_cosh
+    check(1, M.cosh(0, SCALE))
+    check((E ** 1 + E_INV ** 1).divide(2, SCALE, :down), M.cosh(1, SCALE))
+    check((E ** 2 + E_INV ** 2).divide(2, SCALE, :down), M.cosh(2, SCALE))
+  end
+
+  def test_math_sinh
+    check(0, M.sinh(0, SCALE))
+    check((E ** 1 - E_INV ** 1).divide(2, SCALE, :down), M.sinh(1, SCALE))
+    check((E ** 2 - E_INV ** 2).divide(2, SCALE, :down), M.sinh(2, SCALE))
+  end
+
+  def test_math_tanh
+    x, y = M.sinh(0, SCALE), M.cosh(0, SCALE)
+    check(x.divide(y, SCALE, :down), M.tanh(0, SCALE))
+    x, y = M.sinh(1, SCALE), M.cosh(1, SCALE)
+    check(x.divide(y, SCALE, :down), M.tanh(1, SCALE))
+    x, y = M.sinh(2, SCALE), M.cosh(2, SCALE)
+    check(x.divide(y, SCALE, :down), M.tanh(2, SCALE))
+  end
+
+  def test_math_acosh
+    check(0, M.acosh(1, SCALE))
+    check(1, M.acosh((E ** 1 + E_INV ** 1).divide(2, SCALE, :down), SCALE))
+    check(2, M.acosh((E ** 2 + E_INV ** 2).divide(2, SCALE, :down), SCALE))
+    assert_raise(Errno::EDOM) {M.acosh(1 - Decimal("1e-1000"), SCALE)} # XXX
+    assert_raise(Errno::EDOM) {M.acosh(0, SCALE)} # XXX
+  end
+
+  def test_math_asinh
+    check(0, M.asinh(0, SCALE))
+    check(1, M.asinh((E ** 1 - E_INV ** 1).divide(2, SCALE, :down), SCALE))
+    check(2, M.asinh((E ** 2 - E_INV ** 2).divide(2, SCALE, :down), SCALE))
+  end
+
+  def test_math_atanh
+    x, y = M.sinh(0, SCALE), M.cosh(0, SCALE)
+    check(0, M.atanh(x.divide(y, SCALE, :down), SCALE))
+    x, y = M.sinh(1, SCALE), M.cosh(1, SCALE)
+    check(1, M.atanh(x.divide(y, SCALE, :down), SCALE))
+    x, y = M.sinh(2, SCALE), M.cosh(2, SCALE)
+    check(2, M.atanh(x.divide(y, SCALE, :down), SCALE))
+    #assert_nothing_raised { assert_infinity(Math.atanh(1)) }
+    #assert_nothing_raised { assert_infinity(-Math.atanh(-1)) }
+    assert_raise(Errno::EDOM) {M.atanh(+1 + Decimal("1e-1000"), SCALE)}
+    assert_raise(Errno::EDOM) {M.atanh(-1 - Decimal("1e-1000"), SCALE)}
+  end
+
+  def test_math_exp_and_e
+    check(1, M.exp(0, SCALE))
+    check(M.sqrt(M.e(SCALE), SCALE), M.exp(Decimal("0.5"), SCALE))
+    check(M.e(SCALE), M.exp(1, SCALE))
+    check(M.e(SCALE) ** 2, M.exp(2, SCALE))
+  end
+
+  def test_math_log
+    check(0, M.log(1, SCALE))
+    check(1, M.log(M.e(SCALE), SCALE))
+    check(0, M.log(1, 10, SCALE))
+    check(1, M.log(10, 10, SCALE))
+    check(2, M.log(100, 10, SCALE))
+    assert_infinity(M.log(INFINITY, SCALE))
+    #assert_nothing_raised {assert_infinity(-M.log(+0, SCALE))} # really??
+    #assert_nothing_raised {assert_infinity(-M.log(-0, SCALE))} # (ditto)
+    assert_raise(Errno::EDOM) {M.log(-1, SCALE)} # XXX
+    assert_raise(TypeError) {M.log(1,:foo, SCALE)}
+  end
+
+  def test_math_log2
+    check(0, M.log2(1, SCALE))
+    check(1, M.log2(2, SCALE))
+    check(2, M.log2(4, SCALE))
+    assert_equal(INFINITY, M.log2(INFINITY, SCALE))
+    #assert_nothing_raised {assert_infinity(-M.log2(+0, SCALE))} # XXX
+    #assert_nothing_raised {assert_infinity(-M.log2(-0, SCALE))} # XXX
+    assert_raise(Errno::EDOM) {M.log2(-1, SCALE)} # XXX
+  end
+
+  def test_math_log10
+    check(0, M.log10(1, SCALE))
+    check(1, M.log10(10, SCALE))
+    check(2, M.log10(100, SCALE))
+    assert_equal(INFINITY, M.log10(INFINITY, SCALE))
+    #assert_nothing_raised {assert_infinity(-M.log10(+0, SCALE))} # XXX
+    #assert_nothing_raised {assert_infinity(-M.log10(-0, SCALE))} # XXX
+    assert_raise(Errno::EDOM) {M.log10(-1, SCALE)} # XXX
+  end
+
+  def test_math_pi
+    check("3.141592653589793238", M.pi(SCALE))
+  end
+
+  def test_math_sqrt
+    check(0, M.sqrt(0, SCALE))
+    check(1, M.sqrt(1, SCALE))
+    check(2, M.sqrt(4, SCALE))
+    assert_equal(INFINITY, M.sqrt(INFINITY, SCALE))
+    assert_equal("0.0", M.sqrt(Decimal("-0.0"), SCALE).to_s[0..2]) # insure it is +0.0, not -0.0
+    assert_raise(Errno::EDOM) {M.sqrt(-1, SCALE)} # XXX
+  end
+
+  def test_math_frexp10
+    check(0, M.frexp10(0).first)
+    assert_equal(0, M.frexp10(0).last)
+    check("0.1", M.frexp10(Decimal("0.1")).first)
+    assert_equal(0, M.frexp10(Decimal("0.1")).last)
+    check("0.1", M.frexp10(1).first)
+    assert_equal(1, M.frexp10(1).last)
+    check("0.1", M.frexp10(10).first)
+    assert_equal(2, M.frexp10(10).last)
+    check("0.1", M.frexp10(100).first)
+    assert_equal(3, M.frexp10(100).last)
+    check("0.123", M.frexp10(Decimal("12.3")).first)
+    assert_equal(2, M.frexp10(Decimal("12.3")).last)
+    check("-0.123", M.frexp10(Decimal("-12.3")).first)
+    assert_equal(2, M.frexp10(Decimal("-12.3")).last)
+  end
+
+  def test_math_ldexp10
+    check(0, M.ldexp10(0, 0))
+    check("0.1", M.ldexp10(Decimal("0.1"), 0))
+    check(1, M.ldexp10(Decimal("0.1"), 1))
+    check(10, M.ldexp10(Decimal("0.1"), 2))
+    check(100, M.ldexp10(Decimal("0.1"), 3))
+    check("0.123", M.ldexp10(Decimal("12.3"), -2))
+    check("-0.123", M.ldexp10(Decimal("-12.3"), -2))
+  end
+
+  def test_math_hypot
+    check(5, M.hypot(3, 4, SCALE))
+  end
+
+  def test_math_erf
+    check(0, M.erf(0, SCALE))
+    check(1, M.erf(Decimal::INFINITY, SCALE))
+    check("0.842700792949715", M.erf(1, SCALE))
+  end
+
+  def test_math_erfc
+    check(1, M.erfc(0, SCALE))
+    check(0, M.erfc(Decimal::INFINITY, SCALE))
+    check("0.157299207050285", M.erfc(1, SCALE))
+  end
+
+  SQRT_PI = M.sqrt(PI, SCALE*2)
+  def test_math_gamma
+    check((4 * SQRT_PI).divide(3, SCALE, :down),
+          M.gamma(Decimal("-1.5"), SCALE))
+    check(-2 * SQRT_PI, M.gamma(Decimal("-0.5"), SCALE))
+    check(SQRT_PI, M.gamma(Decimal("0.5"), SCALE))
+    check(1, M.gamma(1, SCALE))
+    check(SQRT_PI.divide(2, SCALE, :down), M.gamma(Decimal("1.5"), SCALE))
+    check(1, M.gamma(2, SCALE))
+    check((3 * SQRT_PI).divide(4, SCALE, :down),
+          M.gamma(Decimal("2.5"), SCALE))
+    check(2, M.gamma(3, SCALE))
+    check((15 * SQRT_PI).divide(8, SCALE, :down),
+          M.gamma(Decimal("3.5"), SCALE))
+    check(6, M.gamma(4, SCALE))
+
+    assert_raise(Errno::EDOM) {M.gamma(-Decimal::INFINITY, SCALE)} # XXX
+  end
+
+  def test_math_lgamma
+    g, s = M.lgamma(Decimal("-1.5"), SCALE)
+    check(M.log((4 * SQRT_PI).divide(3, SCALE, :down), SCALE), g)
+    assert_equal(1, s)
+
+    g, s = M.lgamma(Decimal("-0.5"), SCALE)
+    check(M.log(2 * SQRT_PI, SCALE), g)
+    assert_equal(-1, s)
+
+    g, s = M.lgamma(Decimal("0.5"), SCALE)
+    check(M.log(SQRT_PI, SCALE), g)
+    assert_equal(1, s)
+
+    assert_equal([0, 1], M.lgamma(1, SCALE))
+
+    g, s = M.lgamma(Decimal("1.5"), SCALE)
+    check(M.log(SQRT_PI.divide(2, SCALE, :down), SCALE), g)
+    assert_equal(1, s)
+
+    assert_equal([0, 1], M.lgamma(2, SCALE))
+
+    g, s = M.lgamma(Decimal("2.5"), SCALE)
+    check(M.log((3 * SQRT_PI).divide(4, SCALE, :down), SCALE), g)
+    assert_equal(1, s)
+
+    g, s = M.lgamma(3, SCALE)
+    check(M.log(2, SCALE), g)
+    assert_equal(1, s)
+
+    g, s = M.lgamma(Decimal("3.5"), SCALE)
+    check(M.log((15 * SQRT_PI).divide(8, SCALE, :down), SCALE), g)
+    assert_equal(1, s)
+
+    g, s = M.lgamma(4, SCALE)
+    check(M.log(6, SCALE), g)
+    assert_equal(1, s)
+
+    assert_raise(Errno::EDOM) {M.lgamma(-Decimal::INFINITY, SCALE)} # XXX
+  end
+
+  def test_math_cbrt
+    check(0, M.cbrt(0, SCALE))
+    check(1, M.cbrt(1, SCALE))
+    check(2, M.cbrt(8, SCALE))
+    assert_equal(INFINITY, M.cbrt(INFINITY, SCALE))
+    assert_equal(-INFINITY, M.cbrt(-INFINITY, SCALE)) 
+    assert_equal("0.0", M.cbrt(Decimal("0.0"), SCALE).to_s[0..2])
+    assert_equal("-0.0", M.cbrt(Decimal("-0.0"), SCALE).to_s[0..3]) # insure it is -0.0, not +0.0
+    check(-1, M.cbrt(-1, SCALE))
+    check(-2, M.cbrt(-8, SCALE))
+  end
+end