bigdecimal 2.0.3 → 3.1.1

data/ext/bigdecimal/bigdecimal.c

@@ -30,14 +30,11 @@
 #include <ieeefp.h>
 #endif
 
+#include "bits.h"
+#include "static_assert.h"
+
 /* #define ENABLE_NUMERIC_STRING */
 
-#define MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, min, max) ( \
-    (a) == 0 ? 0 : \
-    (a) == -1 ? (b) < -(max) : \
-    (a) > 0 ? \
-      ((b) > 0 ? (max) / (a) < (b) : (min) / (a) > (b)) : \
-      ((b) > 0 ? (min) / (a) < (b) : (max) / (a) > (b)))
 #define SIGNED_VALUE_MAX INTPTR_MAX
 #define SIGNED_VALUE_MIN INTPTR_MIN
 #define MUL_OVERFLOW_SIGNED_VALUE_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, SIGNED_VALUE_MIN, SIGNED_VALUE_MAX)
@@ -65,20 +62,22 @@ static ID id_eq;
 static ID id_half;
 
 /* MACRO's to guard objects from GC by keeping them in stack */
+#ifdef RBIMPL_ATTR_MAYBE_UNUSED
+#define ENTER(n) RBIMPL_ATTR_MAYBE_UNUSED() volatile VALUE vStack[n];int iStack=0
+#else
 #define ENTER(n) volatile VALUE RB_UNUSED_VAR(vStack[n]);int iStack=0
+#endif
 #define PUSH(x)  (vStack[iStack++] = (VALUE)(x))
 #define SAVE(p)  PUSH((p)->obj)
 #define GUARD_OBJ(p,y) ((p)=(y), SAVE(p))
 
-#define BASE_FIG  RMPD_COMPONENT_FIGURES
-#define BASE      RMPD_BASE
+#define BASE_FIG  BIGDECIMAL_COMPONENT_FIGURES
+#define BASE      BIGDECIMAL_BASE
 
 #define HALF_BASE (BASE/2)
 #define BASE1 (BASE/10)
 
-#ifndef DBLE_FIG
-#define DBLE_FIG rmpd_double_figures()    /* figure of double */
-#endif
+#define LOG10_2 0.3010299956639812
 
 #ifndef RRATIONAL_ZERO_P
 # define RRATIONAL_ZERO_P(x) (FIXNUM_P(rb_rational_num(x)) && \
@@ -103,54 +102,6 @@ static ID id_half;
 # define RB_OBJ_STRING(obj) StringValueCStr(obj)
 #endif
 
-#ifndef HAVE_RB_RATIONAL_NUM
-static inline VALUE
-rb_rational_num(VALUE rat)
-{
-#ifdef HAVE_TYPE_STRUCT_RRATIONAL
-    return RRATIONAL(rat)->num;
-#else
-    return rb_funcall(rat, rb_intern("numerator"), 0);
-#endif
-}
-#endif
-
-#ifndef HAVE_RB_RATIONAL_DEN
-static inline VALUE
-rb_rational_den(VALUE rat)
-{
-#ifdef HAVE_TYPE_STRUCT_RRATIONAL
-    return RRATIONAL(rat)->den;
-#else
-    return rb_funcall(rat, rb_intern("denominator"), 0);
-#endif
-}
-#endif
-
-#ifndef HAVE_RB_COMPLEX_REAL
-static inline VALUE
-rb_complex_real(VALUE cmp)
-{
-#ifdef HAVE_TYPE_STRUCT_RCOMPLEX
-  return RCOMPLEX(cmp)->real;
-#else
-  return rb_funcall(cmp, rb_intern("real"), 0);
-#endif
-}
-#endif
-
-#ifndef HAVE_RB_COMPLEX_IMAG
-static inline VALUE
-rb_complex_imag(VALUE cmp)
-{
-#ifdef HAVE_TYPE_STRUCT_RCOMPLEX
-  return RCOMPLEX(cmp)->imag;
-#else
-  return rb_funcall(cmp, rb_intern("imag"), 0);
-#endif
-}
-#endif
-
 #define BIGDECIMAL_POSITIVE_P(bd) ((bd)->sign > 0)
 #define BIGDECIMAL_NEGATIVE_P(bd) ((bd)->sign < 0)
 
@@ -164,7 +115,9 @@ rb_complex_imag(VALUE cmp)
  */
 static unsigned short VpGetException(void);
 static void  VpSetException(unsigned short f);
-static void  VpInternalRound(Real *c, size_t ixDigit, BDIGIT vPrev, BDIGIT v);
+static void VpCheckException(Real *p, bool always);
+static VALUE VpCheckGetValue(Real *p);
+static void  VpInternalRound(Real *c, size_t ixDigit, DECDIG vPrev, DECDIG v);
 static int   VpLimitRound(Real *c, size_t ixDigit);
 static Real *VpCopy(Real *pv, Real const* const x);
 
@@ -176,6 +129,12 @@ static int VPrint(FILE *fp,const char *cntl_chr,Real *a);
  *  **** BigDecimal part ****
  */
 
+static VALUE BigDecimal_nan(void);
+static VALUE BigDecimal_positive_infinity(void);
+static VALUE BigDecimal_negative_infinity(void);
+static VALUE BigDecimal_positive_zero(void);
+static VALUE BigDecimal_negative_zero(void);
+
 static void
 BigDecimal_delete(void *pv)
 {
@@ -186,14 +145,19 @@ static size_t
 BigDecimal_memsize(const void *ptr)
 {
     const Real *pv = ptr;
-    return (sizeof(*pv) + pv->MaxPrec * sizeof(BDIGIT));
+    return (sizeof(*pv) + pv->MaxPrec * sizeof(DECDIG));
 }
 
+#ifndef HAVE_RB_EXT_RACTOR_SAFE
+#   undef RUBY_TYPED_FROZEN_SHAREABLE
+#   define RUBY_TYPED_FROZEN_SHAREABLE 0
+#endif
+
 static const rb_data_type_t BigDecimal_data_type = {
     "BigDecimal",
     { 0, BigDecimal_delete, BigDecimal_memsize, },
 #ifdef RUBY_TYPED_FREE_IMMEDIATELY
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE
 #endif
 };
 
@@ -203,21 +167,6 @@ is_kind_of_BigDecimal(VALUE const v)
     return rb_typeddata_is_kind_of(v, &BigDecimal_data_type);
 }
 
-static VALUE
-ToValue(Real *p)
-{
-    if (VpIsNaN(p)) {
-        VpException(VP_EXCEPTION_NaN, "Computation results to 'NaN'(Not a Number)", 0);
-    }
-    else if (VpIsPosInf(p)) {
-        VpException(VP_EXCEPTION_INFINITY, "Computation results to 'Infinity'", 0);
-    }
-    else if (VpIsNegInf(p)) {
-        VpException(VP_EXCEPTION_INFINITY, "Computation results to '-Infinity'", 0);
-    }
-    return p->obj;
-}
-
 NORETURN(static void cannot_be_coerced_into_BigDecimal(VALUE, VALUE));
 
 static void
@@ -237,95 +186,67 @@ cannot_be_coerced_into_BigDecimal(VALUE exc_class, VALUE v)
 }
 
 static inline VALUE BigDecimal_div2(VALUE, VALUE, VALUE);
+static VALUE rb_inum_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception);
+static VALUE rb_float_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception);
+static VALUE rb_rational_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception);
+static VALUE rb_cstr_convert_to_BigDecimal(const char *c_str, size_t digs, int raise_exception);
+static VALUE rb_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception);
 
 static Real*
 GetVpValueWithPrec(VALUE v, long prec, int must)
 {
-    ENTER(1);
-    Real *pv;
-    VALUE num, bg;
-    char szD[128];
-    VALUE orig = Qundef;
-    double d;
+    const size_t digs = prec < 0 ? SIZE_MAX : (size_t)prec;
 
-again:
     switch(TYPE(v)) {
       case T_FLOAT:
-	if (prec < 0) goto unable_to_coerce_without_prec;
-	if (prec > (long)DBLE_FIG) goto SomeOneMayDoIt;
-	d = RFLOAT_VALUE(v);
-	if (!isfinite(d)) {
-	    pv = VpCreateRbObject(1, NULL);
-	    VpDtoV(pv, d);
-	    return pv;
-	}
-	if (d != 0.0) {
-	    v = rb_funcall(v, id_to_r, 0);
-	    goto again;
-	}
-	if (1/d < 0.0) {
-	    return VpCreateRbObject(prec, "-0");
-	}
-	return VpCreateRbObject(prec, "0");
+        v = rb_float_convert_to_BigDecimal(v, digs, must);
+        break;
 
       case T_RATIONAL:
-	if (prec < 0) goto unable_to_coerce_without_prec;
-
-	if (orig == Qundef ? (orig = v, 1) : orig != v) {
-	    num = rb_rational_num(v);
-	    pv = GetVpValueWithPrec(num, -1, must);
-	    if (pv == NULL) goto SomeOneMayDoIt;
-
-	    v = BigDecimal_div2(ToValue(pv), rb_rational_den(v), LONG2NUM(prec));
-	    goto again;
-	}
-
-	v = orig;
-	goto SomeOneMayDoIt;
+        v = rb_rational_convert_to_BigDecimal(v, digs, must);
+        break;
 
       case T_DATA:
-	if (is_kind_of_BigDecimal(v)) {
-	    pv = DATA_PTR(v);
-	    return pv;
-	}
-	else {
-	    goto SomeOneMayDoIt;
-	}
-	break;
+        if (!is_kind_of_BigDecimal(v)) {
+            goto SomeOneMayDoIt;
+        }
+        break;
 
-      case T_FIXNUM:
-	sprintf(szD, "%ld", FIX2LONG(v));
-	return VpCreateRbObject(VpBaseFig() * 2 + 1, szD);
+      case T_FIXNUM: {
+        char szD[128];
+        sprintf(szD, "%ld", FIX2LONG(v));
+        v = rb_cstr_convert_to_BigDecimal(szD, VpBaseFig() * 2 + 1, must);
+        break;
+      }
 
 #ifdef ENABLE_NUMERIC_STRING
-      case T_STRING:
-	StringValueCStr(v);
-	return VpCreateRbObject(RSTRING_LEN(v) + VpBaseFig() + 1,
-				RSTRING_PTR(v));
+      case T_STRING: {
+        const char *c_str = StringValueCStr(v);
+        v = rb_cstr_convert_to_BigDecimal(c_str, RSTRING_LEN(v) + VpBaseFig() + 1, must);
+        break;
+      }
 #endif /* ENABLE_NUMERIC_STRING */
 
-      case T_BIGNUM:
-	bg = rb_big2str(v, 10);
-	PUSH(bg);
-	return VpCreateRbObject(strlen(RSTRING_PTR(bg)) + VpBaseFig() + 1,
-				RSTRING_PTR(bg));
+      case T_BIGNUM: {
+	VALUE bg = rb_big2str(v, 10);
+        v = rb_cstr_convert_to_BigDecimal(RSTRING_PTR(bg), RSTRING_LEN(bg) + VpBaseFig() + 1, must);
+        RB_GC_GUARD(bg);
+        break;
+      }
+
       default:
 	goto SomeOneMayDoIt;
     }
 
+    Real *vp;
+    TypedData_Get_Struct(v, Real, &BigDecimal_data_type, vp);
+    return vp;
+
 SomeOneMayDoIt:
     if (must) {
 	cannot_be_coerced_into_BigDecimal(rb_eTypeError, v);
     }
     return NULL; /* NULL means to coerce */
-
-unable_to_coerce_without_prec:
-    if (must) {
-	rb_raise(rb_eArgError,
-		 "%"PRIsVALUE" can't be coerced into BigDecimal without a precision",
-		 RB_OBJ_CLASSNAME(v));
-    }
-    return NULL;
 }
 
 static Real*
@@ -335,11 +256,13 @@ GetVpValue(VALUE v, int must)
 }
 
 /* call-seq:
- * BigDecimal.double_fig
+ *   BigDecimal.double_fig -> integer
+ *
+ *  Returns the number of digits a Float object is allowed to have;
+ *  the result is system-dependent:
+ *
+ *    BigDecimal.double_fig # => 16
  *
- * The BigDecimal.double_fig class method returns the number of digits a
- * Float number is allowed to have. The result depends upon the CPU and OS
- * in use.
  */
 static VALUE
 BigDecimal_double_fig(VALUE self)
@@ -348,7 +271,7 @@ BigDecimal_double_fig(VALUE self)
 }
 
 /*  call-seq:
- *     big_decimal.precs  ->  array
+ *    precs -> array
  *
  *  Returns an Array of two Integer values that represent platform-dependent
  *  internal storage properties.
@@ -358,7 +281,6 @@ BigDecimal_double_fig(VALUE self)
  *  significant digits in scientific notation, and BigDecimal#precision for
  *  obtaining the number of digits in decimal notation.
  *
- *     BigDecimal('5').precs #=> [9, 18]
  */
 
 static VALUE
@@ -378,73 +300,202 @@ BigDecimal_prec(VALUE self)
     return obj;
 }
 
-/*
- * call-seq:
- *   big_decimal.precision  ->  intreger
- *
- * Returns the number of decimal digits in this number.
- *
- * Example:
- *
- *   BigDecimal("0").precision  # => 0
- *   BigDecimal("1").precision  # => 1
- *   BigDecimal("-1e20").precision  # => 21
- *   BigDecimal("1e-20").precision  # => 20
- *   BigDecimal("Infinity").precision  # => 0
- *   BigDecimal("-Infinity").precision  # => 0
- *   BigDecimal("NaN").precision  # => 0
- */
-static VALUE
-BigDecimal_precision(VALUE self)
+static void
+BigDecimal_count_precision_and_scale(VALUE self, ssize_t *out_precision, ssize_t *out_scale)
 {
     ENTER(1);
 
+    if (out_precision == NULL && out_scale == NULL)
+        return;
+
     Real *p;
     GUARD_OBJ(p, GetVpValue(self, 1));
+    if (VpIsZero(p) || !VpIsDef(p)) {
+      zero:
+        if (out_precision) *out_precision = 0;
+        if (out_scale) *out_scale = 0;
+        return;
+    }
+
+    DECDIG x;
+
+    ssize_t n = p->Prec; /* The length of frac without zeros. */
+    while (n > 0 && p->frac[n-1] == 0) --n;
+    if (n == 0) goto zero;
+
+    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;
 
     /*
-     * The most significant digit is frac[0], and the least significant digit is frac[Prec-1].
-     * When the exponent is zero, the decimal point is located just before frac[0].
+     * Calculate the precision and the scale
+     * -------------------------------------
+     *
+     * The most significant digit is frac[0], and the least significant digit
+     * is frac[Prec-1].  When the exponent is zero, the decimal point is
+     * located just before frac[0].
+     *
      * When the exponent is negative, the decimal point moves to leftward.
-     * Conversely, when the exponent is positive, the decimal point moves to rightward.
+     * In this case, the precision can be calculated by
+     *
+     *   precision = BASE_FIG * (-exponent + n) - ntz,
+     *
+     * and the scale is the same as precision.
+     *
+     *       0 . 0000 0000 | frac[0] ... frac[n-1] |
+     *         |<----------| exponent == -2        |
+     *         |---------------------------------->| precision
+     *         |---------------------------------->| scale
+     *
+     *
+     * Conversely, when the exponent is positive, the decimal point moves to
+     * rightward.  In this case, the scale equals to
+     *
+     *   BASE_FIG * (n - exponent) - ntz.
      *
-     *    | frac[0] frac[1] frac[2] . frac[3] frac[4] ... frac[Prec-1]
-     *    |------------------------> exponent == 3
+     * the precision equals to
+     *
+     *   scale + BASE_FIG * exponent - nlz.
+     *
+     *       | frac[0] frac[1] . frac[2] ... frac[n-1] |
+     *       |---------------->| exponent == 2         |
+     *       |                 |---------------------->| scale
+     *       |---------------------------------------->| precision
      */
 
     ssize_t ex = p->exponent;
-    ssize_t precision;
+
+    /* Count the number of decimal digits before frac[1]. */
+    ssize_t n_digits_head = BASE_FIG;
     if (ex < 0) {
-        precision = (-ex + 1) * BASE_FIG;  /* 1 is for p->frac[0] */
-        ex = 0;
+      n_digits_head += (-ex) * BASE_FIG;  /* The number of leading zeros before frac[0]. */
+      ex = 0;
     }
-    else if (p->Prec > 0) {
-        BDIGIT x = p->frac[0];
-        for (precision = 0; x > 0; x /= 10) {
-            ++precision;
-        }
+    else if (ex > 0) {
+      /* Count the number of decimal digits without the leading zeros in
+       * the most significant digit in the integral part.
+       */
+      n_digits_head -= nlz;  /* Make the number of digits */
     }
 
-    if (ex > (ssize_t)p->Prec) {
-        precision += (ex - 1) * BASE_FIG;
+    if (out_precision) {
+        ssize_t precision = n_digits_head;
+
+        /* Count the number of decimal digits after frac[0]. */
+        if (ex > (ssize_t)n) {
+          /* In this case the number is an integer with some trailing zeros. */
+          precision += (ex - 1) * BASE_FIG;
+        }
+        else if (n > 0) {
+          precision += (n - 1) * BASE_FIG;
+
+          if (ex < (ssize_t)n) {
+            precision -= ntz;
+          }
+        }
+
+        *out_precision = precision;
     }
-    else if (p->Prec > 0) {
-        ssize_t n = (ssize_t)p->Prec - 1;
-        while (n > 0 && p->frac[n] == 0) --n;
 
-        precision += n * BASE_FIG;
+    if (out_scale) {
+        ssize_t scale = 0;
 
-        if (ex < (ssize_t)p->Prec) {
-            BDIGIT x = p->frac[n];
-            for (; x > 0 && x % 10 == 0; x /= 10) {
-                --precision;
-            }
+        if (p->exponent < 0) {
+            scale = n_digits_head + (n - 1) * BASE_FIG - ntz;
         }
+        else if (n > p->exponent) {
+            scale = (n - p->exponent) * BASE_FIG - ntz;
+        }
+
+        *out_scale = scale;
     }
+}
 
+/*
+ *  call-seq:
+ *    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
+ *
+ */
+static VALUE
+BigDecimal_precision(VALUE self)
+{
+    ssize_t precision;
+    BigDecimal_count_precision_and_scale(self, &precision, NULL);
     return SSIZET2NUM(precision);
 }
 
+/*
+ *  call-seq:
+ *    scale -> integer
+ *
+ *  Returns the number of decimal digits following the decimal digits in +self+.
+ *
+ *    BigDecimal("0").scale         # => 0
+ *    BigDecimal("1").scale         # => 1
+ *    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
+ */
+static VALUE
+BigDecimal_scale(VALUE self)
+{
+    ssize_t scale;
+    BigDecimal_count_precision_and_scale(self, NULL, &scale);
+    return SSIZET2NUM(scale);
+}
+
+/*
+ *  call-seq:
+ *    precision_scale -> [integer, integer]
+ *
+ *  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.
+ */
+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));
+}
+
+/*
+ *  call-seq:
+ *    n_significant_digits -> integer
+ *
+ *  Returns the number of decimal significant digits in +self+.
+ *
+ *    BigDecimal("0").scale         # => 0
+ *    BigDecimal("1").scale         # => 1
+ *    BigDecimal("1.1").scale       # => 2
+ *    BigDecimal("3.1415").scale    # => 5
+ *    BigDecimal("-1e20").precision # => 1
+ *    BigDecimal("1e-20").precision # => 1
+ *    BigDecimal("Infinity").scale  # => 0
+ *    BigDecimal("-Infinity").scale # => 0
+ *    BigDecimal("NaN").scale       # => 0
+ */
 static VALUE
 BigDecimal_n_significant_digits(VALUE self)
 {
@@ -452,32 +503,38 @@ BigDecimal_n_significant_digits(VALUE self)
 
     Real *p;
     GUARD_OBJ(p, GetVpValue(self, 1));
-
-    ssize_t n = p->Prec;
-    while (n > 0 && p->frac[n-1] == 0) --n;
-    if (n <= 0) {
+    if (VpIsZero(p) || !VpIsDef(p)) {
         return INT2FIX(0);
     }
 
-    int nlz, ntz;
+    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);
 
-    BDIGIT x = p->frac[0];
-    for (nlz = BASE_FIG; x > 0; x /= 10) --nlz;
+    DECDIG x;
+    int nlz = BASE_FIG;
+    for (x = p->frac[0]; x > 0; x /= 10) --nlz;
 
-    x = p->frac[n-1];
-    for (ntz = 0; x > 0 && x % 10 == 0; x /= 10) ++ntz;
+    int ntz = 0;
+    for (x = p->frac[n-1]; x > 0 && x % 10 == 0; x /= 10) ++ntz;
 
-    ssize_t n_digits = BASE_FIG * n - nlz - ntz;
-    return SSIZET2NUM(n_digits);
+    ssize_t n_significant_digits = BASE_FIG*n - nlz - ntz;
+    return SSIZET2NUM(n_significant_digits);
 }
 
 /*
- * call-seq: hash
+ *  call-seq:
+ *    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:
  *
- * Creates a hash for this BigDecimal.
+ *  - Sign.
+ *  - Fractional part.
+ *  - Exponent.
  *
- * Two BigDecimals with equal sign,
- * fractional part and exponent have the same hash.
  */
 static VALUE
 BigDecimal_hash(VALUE self)
@@ -490,23 +547,23 @@ BigDecimal_hash(VALUE self)
     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(BDIGIT)*p->Prec);
-	hash += p->exponent;
+        hash ^= rb_memhash(p->frac, sizeof(DECDIG)*p->Prec);
+        hash += p->exponent;
     }
     return ST2FIX(hash);
 }
 
 /*
- * call-seq: _dump
+ *  call-seq:
+ *    _dump -> string
  *
- * Method used to provide marshalling support.
+ *  Returns a string representing the marshalling of +self+.
+ *  See module Marshal.
  *
- *      inf = BigDecimal('Infinity')
- *        #=> Infinity
- *      BigDecimal._load(inf._dump)
- *        #=> Infinity
+ *    inf = BigDecimal('Infinity') # => Infinity
+ *    dumped = inf._dump           # => "9:Infinity"
+ *    BigDecimal._load(dumped)     # => Infinity
  *
- * See the Marshal module.
  */
 static VALUE
 BigDecimal_dump(int argc, VALUE *argv, VALUE self)
@@ -548,12 +605,12 @@ BigDecimal_load(VALUE self, VALUE str)
         m = m*10 + (unsigned long)(ch-'0');
     }
     if (m > VpBaseFig()) m -= VpBaseFig();
-    GUARD_OBJ(pv, VpNewRbClass(m, (char *)pch, self));
+    GUARD_OBJ(pv, VpNewRbClass(m, (char *)pch, self, true, true));
     m /= VpBaseFig();
     if (m && pv->MaxPrec > m) {
 	pv->MaxPrec = m+1;
     }
-    return ToValue(pv);
+    return VpCheckGetValue(pv);
 }
 
 static unsigned short
@@ -640,42 +697,166 @@ check_rounding_mode(VALUE const v)
     return sw;
 }
 
-/* call-seq:
- * BigDecimal.mode(mode, value)
- *
- * Controls handling of arithmetic exceptions and rounding. If no value
- * is supplied, the current value is returned.
- *
- * Six values of the mode parameter control the handling of arithmetic
- * exceptions:
- *
- * BigDecimal::EXCEPTION_NaN
- * BigDecimal::EXCEPTION_INFINITY
- * BigDecimal::EXCEPTION_UNDERFLOW
- * BigDecimal::EXCEPTION_OVERFLOW
- * BigDecimal::EXCEPTION_ZERODIVIDE
- * BigDecimal::EXCEPTION_ALL
- *
- * For each mode parameter above, if the value set is false, computation
- * continues after an arithmetic exception of the appropriate type.
- * When computation continues, results are as follows:
- *
- * EXCEPTION_NaN:: NaN
- * EXCEPTION_INFINITY:: +Infinity or -Infinity
- * EXCEPTION_UNDERFLOW:: 0
- * EXCEPTION_OVERFLOW:: +Infinity or -Infinity
- * EXCEPTION_ZERODIVIDE:: +Infinity or -Infinity
- *
- * One value of the mode parameter controls the rounding of numeric values:
- * BigDecimal::ROUND_MODE. The values it can take are:
- *
- * ROUND_UP, :up:: round away from zero
- * ROUND_DOWN, :down, :truncate:: round towards zero (truncate)
- * ROUND_HALF_UP, :half_up, :default:: round towards the nearest neighbor, unless both neighbors are equidistant, in which case round away from zero. (default)
- * ROUND_HALF_DOWN, :half_down:: round towards the nearest neighbor, unless both neighbors are equidistant, in which case round towards zero.
- * ROUND_HALF_EVEN, :half_even, :banker:: round towards the nearest neighbor, unless both neighbors are equidistant, in which case round towards the even neighbor (Banker's rounding)
- * ROUND_CEILING, :ceiling, :ceil:: round towards positive infinity (ceil)
- * ROUND_FLOOR, :floor:: round towards negative infinity (floor)
+/*  call-seq:
+ *    BigDecimal.mode(mode, setting = nil) -> integer
+ *
+ *  Returns an integer representing the mode settings
+ *  for exception handling and rounding.
+ *
+ *  These modes control exception handling:
+ *
+ *  - \BigDecimal::EXCEPTION_NaN.
+ *  - \BigDecimal::EXCEPTION_INFINITY.
+ *  - \BigDecimal::EXCEPTION_UNDERFLOW.
+ *  - \BigDecimal::EXCEPTION_OVERFLOW.
+ *  - \BigDecimal::EXCEPTION_ZERODIVIDE.
+ *  - \BigDecimal::EXCEPTION_ALL.
+ *
+ *  Values for +setting+ for exception handling:
+ *
+ *  - +true+: sets the given +mode+ to +true+.
+ *  - +false+: sets the given +mode+ to +false+.
+ *  - +nil+: does not modify the mode settings.
+ *
+ *  You can use method BigDecimal.save_exception_mode
+ *  to temporarily change, and then automatically restore, exception modes.
+ *
+ *  For clarity, some examples below begin by setting all
+ *  exception modes to +false+.
+ *
+ *  This mode controls the way rounding is to be performed:
+ *
+ *  - \BigDecimal::ROUND_MODE
+ *
+ *  You can use method BigDecimal.save_rounding_mode
+ *  to temporarily change, and then automatically restore, the rounding mode.
+ *
+ *  <b>NaNs</b>
+ *
+ *  Mode \BigDecimal::EXCEPTION_NaN controls behavior
+ *  when a \BigDecimal NaN is created.
+ *
+ *  Settings:
+ *
+ *  - +false+ (default): Returns <tt>BigDecimal('NaN')</tt>.
+ *  - +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
+ *
+ *  <b>Infinities</b>
+ *
+ *  Mode \BigDecimal::EXCEPTION_INFINITY controls behavior
+ *  when a \BigDecimal Infinity or -Infinity is created.
+ *  Settings:
+ *
+ *  - +false+ (default): Returns <tt>BigDecimal('Infinity')</tt>
+ *    or <tt>BigDecimal('-Infinity')</tt>.
+ *  - +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
+ *
+ *  <b>Underflow</b>
+ *
+ *  Mode \BigDecimal::EXCEPTION_UNDERFLOW controls behavior
+ *  when a \BigDecimal underflow occurs.
+ *  Settings:
+ *
+ *  - +false+ (default): Returns <tt>BigDecimal('0')</tt>
+ *    or <tt>BigDecimal('-Infinity')</tt>.
+ *  - +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
+ *
+ *  <b>Overflow</b>
+ *
+ *  Mode \BigDecimal::EXCEPTION_OVERFLOW controls behavior
+ *  when a \BigDecimal overflow occurs.
+ *  Settings:
+ *
+ *  - +false+ (default): Returns <tt>BigDecimal('Infinity')</tt>
+ *    or <tt>BigDecimal('-Infinity')</tt>.
+ *  - +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
+ *
+ *  <b>Zero Division</b>
+ *
+ *  Mode \BigDecimal::EXCEPTION_ZERODIVIDE controls behavior
+ *  when a zero-division occurs.
+ *  Settings:
+ *
+ *  - +false+ (default): Returns <tt>BigDecimal('Infinity')</tt>
+ *    or <tt>BigDecimal('-Infinity')</tt>.
+ *  - +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
+ *
+ *  <b>All Exceptions</b>
+ *
+ *  Mode \BigDecimal::EXCEPTION_ALL controls all of the above:
+ *
+ *    BigDecimal.mode(BigDecimal::EXCEPTION_ALL, false) # => 0
+ *    BigDecimal.mode(BigDecimal::EXCEPTION_ALL, true)  # => 23
+ *
+ *  <b>Rounding</b>
+ *
+ *  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:+.
  *
  */
 static VALUE
@@ -763,25 +944,54 @@ GetPrecisionInt(VALUE v)
     return n;
 }
 
+static VALUE
+BigDecimal_wrap_struct(VALUE obj, Real *vp)
+{
+    assert(is_kind_of_BigDecimal(obj));
+    assert(vp != NULL);
+
+    if (vp->obj == obj && RTYPEDDATA_DATA(obj) == vp)
+        return obj;
+
+    assert(RTYPEDDATA_DATA(obj) == NULL);
+    assert(vp->obj == 0);
+
+    RTYPEDDATA_DATA(obj) = vp;
+    vp->obj = obj;
+    RB_OBJ_FREEZE(obj);
+    return obj;
+}
+
 VP_EXPORT Real *
-VpNewRbClass(size_t mx, const char *str, VALUE klass)
+VpNewRbClass(size_t mx, const char *str, VALUE klass, bool strict_p, bool raise_exception)
 {
     VALUE obj = TypedData_Wrap_Struct(klass, &BigDecimal_data_type, 0);
-    Real *pv = VpAlloc(mx, str, 1, 1);
-    RTYPEDDATA_DATA(obj) = pv;
-    pv->obj = obj;
-    RB_OBJ_FREEZE(obj);
+    Real *pv = VpAlloc(mx, str, strict_p, raise_exception);
+    if (!pv)
+        return NULL;
+    BigDecimal_wrap_struct(obj, pv);
     return pv;
 }
 
 VP_EXPORT Real *
-VpCreateRbObject(size_t mx, const char *str)
+VpCreateRbObject(size_t mx, const char *str, bool raise_exception)
 {
-    return VpNewRbClass(mx, str, rb_cBigDecimal);
+    return VpNewRbClass(mx, str, rb_cBigDecimal, true, raise_exception);
 }
 
-#define VpAllocReal(prec) (Real *)VpMemAlloc(offsetof(Real, frac) + (prec) * sizeof(BDIGIT))
-#define VpReallocReal(ptr, prec) (Real *)VpMemRealloc((ptr), offsetof(Real, frac) + (prec) * sizeof(BDIGIT))
+#define VpAllocReal(prec) (Real *)VpMemAlloc(offsetof(Real, frac) + (prec) * sizeof(DECDIG))
+
+static Real *
+VpReallocReal(Real *pv, size_t prec)
+{
+    VALUE obj = pv ? pv->obj : 0;
+    Real *new_pv = (Real *)VpMemRealloc(pv, offsetof(Real, frac) + prec * sizeof(DECDIG));
+    if (obj) {
+        new_pv->obj = 0;
+        BigDecimal_wrap_struct(obj, new_pv);
+    }
+    return new_pv;
+}
 
 static Real *
 VpCopy(Real *pv, Real const* const x)
@@ -794,7 +1004,7 @@ VpCopy(Real *pv, Real const* const x)
     pv->exponent = x->exponent;
     pv->sign = x->sign;
     pv->flag = x->flag;
-    MEMCPY(pv->frac, x->frac, BDIGIT, pv->MaxPrec);
+    MEMCPY(pv->frac, x->frac, DECDIG, pv->MaxPrec);
 
     return pv;
 }
@@ -833,15 +1043,7 @@ BigDecimal_IsFinite(VALUE self)
 static void
 BigDecimal_check_num(Real *p)
 {
-    if (VpIsNaN(p)) {
-	VpException(VP_EXCEPTION_NaN, "Computation results to 'NaN'(Not a Number)", 1);
-    }
-    else if (VpIsPosInf(p)) {
-	VpException(VP_EXCEPTION_INFINITY, "Computation results to 'Infinity'", 1);
-    }
-    else if (VpIsNegInf(p)) {
-	VpException(VP_EXCEPTION_INFINITY, "Computation results to '-Infinity'", 1);
-    }
+    VpCheckException(p, true);
 }
 
 static VALUE BigDecimal_split(VALUE self);
@@ -864,7 +1066,7 @@ BigDecimal_to_i(VALUE self)
     if (e <= 0) return INT2FIX(0);
     nf = VpBaseFig();
     if (e <= nf) {
-        return LONG2NUM((long)(VpGetSign(p) * (BDIGIT_DBL_SIGNED)p->frac[0]));
+        return LONG2NUM((long)(VpGetSign(p) * (DECDIG_DBL_SIGNED)p->frac[0]));
     }
     else {
 	VALUE a = BigDecimal_split(self);
@@ -998,8 +1200,8 @@ BigDecimal_coerce(VALUE self, VALUE other)
     Real *b;
 
     if (RB_TYPE_P(other, T_FLOAT)) {
-	GUARD_OBJ(b, GetVpValueWithPrec(other, DBLE_FIG, 1));
-	obj = rb_assoc_new(ToValue(b), self);
+	GUARD_OBJ(b, GetVpValueWithPrec(other, 0, 1));
+        obj = rb_assoc_new(VpCheckGetValue(b), self);
     }
     else {
 	if (RB_TYPE_P(other, T_RATIONAL)) {
@@ -1016,12 +1218,14 @@ BigDecimal_coerce(VALUE self, VALUE other)
 }
 
 /*
- * call-seq:
- *    +big_decimal  ->  big_decimal
+ *  call-seq:
+ *    +big_decimal -> self
+ *
+ *  Returns +self+:
  *
- * Return self.
+ *     +BigDecimal(5)  # => 0.5e1
+ *     +BigDecimal(-5) # => -0.5e1
  *
- *     +BigDecimal('5')  #=> 0.5e1
  */
 
 static VALUE
@@ -1031,22 +1235,21 @@ BigDecimal_uplus(VALUE self)
 }
 
  /*
-  * Document-method: BigDecimal#add
-  * Document-method: BigDecimal#+
+  *  call-seq:
+  *    self + value -> bigdecimal
   *
-  * call-seq:
-  * add(value, digits)
+  *  Returns the \BigDecimal sum of +self+ and +value+:
   *
-  * Add the specified 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)
   *
-  * e.g.
-  *   c = a.add(b,n)
-  *   c = a + b
+  *  See the {Note About Precision}[BigDecimal.html#class-BigDecimal-label-A+Note+About+Precision].
   *
-  * 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.
   */
+
 static VALUE
 BigDecimal_add(VALUE self, VALUE r)
 {
@@ -1056,7 +1259,7 @@ BigDecimal_add(VALUE self, VALUE r)
 
     GUARD_OBJ(a, GetVpValue(self, 1));
     if (RB_TYPE_P(r, T_FLOAT)) {
-	b = GetVpValueWithPrec(r, DBLE_FIG, 1);
+	b = GetVpValueWithPrec(r, 0, 1);
     }
     else if (RB_TYPE_P(r, T_RATIONAL)) {
 	b = GetVpValueWithPrec(r, a->Prec*VpBaseFig(), 1);
@@ -1073,11 +1276,11 @@ BigDecimal_add(VALUE self, VALUE r)
 
     mx = GetAddSubPrec(a, b);
     if (mx == (size_t)-1L) {
-	GUARD_OBJ(c,VpCreateRbObject(VpBaseFig() + 1, "0"));
+        GUARD_OBJ(c, VpCreateRbObject(VpBaseFig() + 1, "0", true));
 	VpAddSub(c, a, b, 1);
     }
     else {
-	GUARD_OBJ(c, VpCreateRbObject(mx * (VpBaseFig() + 1), "0"));
+        GUARD_OBJ(c, VpCreateRbObject(mx * (VpBaseFig() + 1), "0", true));
 	if(!mx) {
 	    VpSetInf(c, VpGetSign(a));
 	}
@@ -1085,24 +1288,21 @@ BigDecimal_add(VALUE self, VALUE r)
 	    VpAddSub(c, a, b, 1);
 	}
     }
-    return ToValue(c);
+    return VpCheckGetValue(c);
 }
 
- /* call-seq:
-  * a - b   -> bigdecimal
-  *
-  * Subtract the specified value.
+ /*  call-seq:
+  *    self - value -> bigdecimal
   *
-  * e.g.
-  *   c = a - b
+  *  Returns the \BigDecimal difference of +self+ and +value+:
   *
-  * The precision of the result value depends on the type of +b+.
+  *    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)
   *
-  * If +b+ is a Float, the precision of the result is Float::DIG+1.
-  *
-  * If +b+ is a BigDecimal, the precision of the result is +b+'s precision of
-  * internal representation from platform. So, it's return value is platform
-  * dependent.
+  *  See the {Note About Precision}[BigDecimal.html#class-BigDecimal-label-A+Note+About+Precision].
   *
   */
 static VALUE
@@ -1114,7 +1314,7 @@ BigDecimal_sub(VALUE self, VALUE r)
 
     GUARD_OBJ(a, GetVpValue(self,1));
     if (RB_TYPE_P(r, T_FLOAT)) {
-	b = GetVpValueWithPrec(r, DBLE_FIG, 1);
+	b = GetVpValueWithPrec(r, 0, 1);
     }
     else if (RB_TYPE_P(r, T_RATIONAL)) {
 	b = GetVpValueWithPrec(r, a->Prec*VpBaseFig(), 1);
@@ -1131,11 +1331,11 @@ BigDecimal_sub(VALUE self, VALUE r)
 
     mx = GetAddSubPrec(a,b);
     if (mx == (size_t)-1L) {
-	GUARD_OBJ(c,VpCreateRbObject(VpBaseFig() + 1, "0"));
+        GUARD_OBJ(c, VpCreateRbObject(VpBaseFig() + 1, "0", true));
 	VpAddSub(c, a, b, -1);
     }
     else {
-	GUARD_OBJ(c,VpCreateRbObject(mx *(VpBaseFig() + 1), "0"));
+        GUARD_OBJ(c,VpCreateRbObject(mx *(VpBaseFig() + 1), "0", true));
 	if (!mx) {
 	    VpSetInf(c,VpGetSign(a));
 	}
@@ -1143,7 +1343,7 @@ BigDecimal_sub(VALUE self, VALUE r)
 	    VpAddSub(c, a, b, -1);
 	}
     }
-    return ToValue(c);
+    return VpCheckGetValue(c);
 }
 
 static VALUE
@@ -1164,7 +1364,7 @@ BigDecimalCmp(VALUE self, VALUE r,char op)
 	break;
 
     case T_FLOAT:
-	GUARD_OBJ(b, GetVpValueWithPrec(r, DBLE_FIG, 0));
+	GUARD_OBJ(b, GetVpValueWithPrec(r, 0, 0));
 	break;
 
     case T_RATIONAL:
@@ -1281,12 +1481,19 @@ BigDecimal_eq(VALUE self, VALUE r)
     return BigDecimalCmp(self, r, '=');
 }
 
-/* call-seq:
- * a < b
+/*  call-seq:
+ *    self < other -> true or false
+ *
+ *  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
  *
- * Returns true if a is less than b.
+ *  Raises an exception if the comparison cannot be made.
  *
- * Values may be coerced to perform the comparison (see ==, BigDecimal#coerce).
  */
 static VALUE
 BigDecimal_lt(VALUE self, VALUE r)
@@ -1294,12 +1501,20 @@ BigDecimal_lt(VALUE self, VALUE r)
     return BigDecimalCmp(self, r, '<');
 }
 
-/* call-seq:
- * a <= b
+/*  call-seq:
+ *    self <= other -> true or false
  *
- * Returns true if a is less than or equal to b.
+ *  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.
  *
- * Values may be coerced to perform the comparison (see ==, BigDecimal#coerce).
  */
 static VALUE
 BigDecimal_le(VALUE self, VALUE r)
@@ -1307,12 +1522,19 @@ BigDecimal_le(VALUE self, VALUE r)
     return BigDecimalCmp(self, r, 'L');
 }
 
-/* call-seq:
- * a > b
+/*  call-seq:
+ *    self > other -> true or false
+ *
+ *  Returns +true+ if +self+ is greater than +other+, +false+ otherwise:
  *
- * Returns true if a is greater than b.
+ *    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.
  *
- * Values may be coerced to perform the comparison (see ==, BigDecimal#coerce).
  */
 static VALUE
 BigDecimal_gt(VALUE self, VALUE r)
@@ -1320,12 +1542,20 @@ BigDecimal_gt(VALUE self, VALUE r)
     return BigDecimalCmp(self, r, '>');
 }
 
-/* call-seq:
- * a >= b
+/*  call-seq:
+ *    self >= other -> true or false
+ *
+ *  Returns +true+ if +self+ is greater than or equal to +other+, +false+ otherwise:
  *
- * Returns true if a is greater than or equal to b.
+ *    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.
  *
- * Values may be coerced to perform the comparison (see ==, BigDecimal#coerce)
  */
 static VALUE
 BigDecimal_ge(VALUE self, VALUE r)
@@ -1335,11 +1565,14 @@ BigDecimal_ge(VALUE self, VALUE r)
 
 /*
  *  call-seq:
- *     -big_decimal  ->  big_decimal
+ *    -self -> bigdecimal
+ *
+ *  Returns the \BigDecimal negation of self:
  *
- *  Return the negation of self.
+ *    b0 = BigDecimal('1.5')
+ *    b1 = -b0 # => -0.15e1
+ *    b2 = -b1 # => 0.15e1
  *
- *    -BigDecimal('5')  #=> -0.5e1
  */
 
 static VALUE
@@ -1348,26 +1581,11 @@ BigDecimal_neg(VALUE self)
     ENTER(5);
     Real *c, *a;
     GUARD_OBJ(a, GetVpValue(self, 1));
-    GUARD_OBJ(c, VpCreateRbObject(a->Prec *(VpBaseFig() + 1), "0"));
+    GUARD_OBJ(c, VpCreateRbObject(a->Prec *(VpBaseFig() + 1), "0", true));
     VpAsgn(c, a, -1);
-    return ToValue(c);
+    return VpCheckGetValue(c);
 }
 
- /*
-  * Document-method: BigDecimal#mult
-  *
-  * call-seq: mult(value, digits)
-  *
-  * Multiply by the specified value.
-  *
-  * e.g.
-  *   c = a.mult(b,n)
-  *   c = a * b
-  *
-  * 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.
-  */
 static VALUE
 BigDecimal_mult(VALUE self, VALUE r)
 {
@@ -1377,7 +1595,7 @@ BigDecimal_mult(VALUE self, VALUE r)
 
     GUARD_OBJ(a, GetVpValue(self, 1));
     if (RB_TYPE_P(r, T_FLOAT)) {
-        b = GetVpValueWithPrec(r, DBLE_FIG, 1);
+        b = GetVpValueWithPrec(r, 0, 1);
     }
     else if (RB_TYPE_P(r, T_RATIONAL)) {
 	b = GetVpValueWithPrec(r, a->Prec*VpBaseFig(), 1);
@@ -1390,71 +1608,132 @@ BigDecimal_mult(VALUE self, VALUE r)
     SAVE(b);
 
     mx = a->Prec + b->Prec;
-    GUARD_OBJ(c, VpCreateRbObject(mx *(VpBaseFig() + 1), "0"));
+    GUARD_OBJ(c, VpCreateRbObject(mx *(VpBaseFig() + 1), "0", true));
     VpMult(c, a, b);
-    return ToValue(c);
+    return VpCheckGetValue(c);
 }
 
 static VALUE
-BigDecimal_divide(Real **c, Real **res, Real **div, VALUE self, VALUE r)
+BigDecimal_divide(VALUE self, VALUE r, Real **c, Real **res, Real **div)
 /* For c = self.div(r): with round operation */
 {
     ENTER(5);
-    Real *a, *b;
+    Real *a, *b, *d;
+    ssize_t a_prec, b_prec;
     size_t mx;
 
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    if (RB_TYPE_P(r, T_FLOAT)) {
-        b = GetVpValueWithPrec(r, DBLE_FIG, 1);
+    TypedData_Get_Struct(self, Real, &BigDecimal_data_type, a);
+    SAVE(a);
+
+    VALUE rr = r;
+    if (is_kind_of_BigDecimal(rr)) {
+        /* do nothing */
+    }
+    else if (RB_INTEGER_TYPE_P(r)) {
+        rr = rb_inum_convert_to_BigDecimal(r, 0, true);
+    }
+    else if (RB_TYPE_P(r, T_FLOAT)) {
+        rr = rb_float_convert_to_BigDecimal(r, 0, true);
     }
     else if (RB_TYPE_P(r, T_RATIONAL)) {
-	b = GetVpValueWithPrec(r, a->Prec*VpBaseFig(), 1);
-     }
-    else {
-	b = GetVpValue(r, 0);
+        rr = rb_rational_convert_to_BigDecimal(r, a->Prec*BASE_FIG, true);
     }
 
-    if (!b) return DoSomeOne(self, r, '/');
-    SAVE(b);
+    if (!is_kind_of_BigDecimal(rr)) {
+        return DoSomeOne(self, r, '/');
+    }
 
+    TypedData_Get_Struct(rr, Real, &BigDecimal_data_type, b);
+    SAVE(b);
     *div = b;
-    mx = a->Prec + vabs(a->exponent);
-    if (mx < b->Prec + vabs(b->exponent)) mx = b->Prec + vabs(b->exponent);
-    mx++; /* NOTE: An additional digit is needed for the compatibility to
-                   the version 1.2.1 and the former.  */
-    mx = (mx + 1) * VpBaseFig();
-    GUARD_OBJ((*c), VpCreateRbObject(mx, "#0"));
-    GUARD_OBJ((*res), VpCreateRbObject((mx+1) * 2 +(VpBaseFig() + 1), "#0"));
+
+    mx = (a->Prec > b->Prec) ? a->Prec : b->Prec;
+    mx *= BASE_FIG;
+
+    BigDecimal_count_precision_and_scale(self, &a_prec, NULL);
+    BigDecimal_count_precision_and_scale(rr, &b_prec, NULL);
+    mx = (a_prec > b_prec) ? a_prec : b_prec;
+
+    if (2*BIGDECIMAL_DOUBLE_FIGURES > mx)
+        mx = 2*BIGDECIMAL_DOUBLE_FIGURES;
+
+    GUARD_OBJ((*c), VpCreateRbObject(mx + 2*BASE_FIG, "#0", true));
+    GUARD_OBJ((*res), VpCreateRbObject(mx*2 + 2*BASE_FIG, "#0", true));
     VpDivd(*c, *res, a, b);
+
     return Qnil;
 }
 
+static VALUE BigDecimal_DoDivmod(VALUE self, VALUE r, Real **div, Real **mod);
+
 /* call-seq:
- *   a / b       -> bigdecimal
- *   quo(value)  -> bigdecimal
+ *   a / b   -> bigdecimal
  *
  * Divide by the specified value.
  *
+ * The result precision will be the precision of the larger operand,
+ * but its minimum is 2*Float::DIG.
+ *
  * See BigDecimal#div.
+ * See BigDecimal#quo.
  */
 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(&c, &res, &div, self, r);
-    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], (BDIGIT)(VpBaseVal() * (BDIGIT_DBL)res->frac[0] / div->frac[0]));
+    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);
+}
+
+static VALUE BigDecimal_round(int argc, VALUE *argv, VALUE self);
+
+/* call-seq:
+ *   quo(value)  -> bigdecimal
+ *   quo(value, digits)  -> bigdecimal
+ *
+ * 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.
+ */
+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 = GetPrecisionInt(digits);
+    }
+
+    if (n > 0) {
+        result = BigDecimal_div2(self, value, digits);
+    }
+    else {
+        result = BigDecimal_div(self, value);
     }
-    return ToValue(c);
+
+    return result;
 }
 
 /*
@@ -1467,77 +1746,104 @@ BigDecimal_DoDivmod(VALUE self, VALUE r, Real **div, Real **mod)
     ENTER(8);
     Real *c=NULL, *d=NULL, *res=NULL;
     Real *a, *b;
+    ssize_t a_prec, b_prec;
     size_t mx;
 
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    if (RB_TYPE_P(r, T_FLOAT)) {
-	b = GetVpValueWithPrec(r, DBLE_FIG, 1);
+    TypedData_Get_Struct(self, Real, &BigDecimal_data_type, a);
+    SAVE(a);
+
+    VALUE rr = r;
+    if (is_kind_of_BigDecimal(rr)) {
+        /* do nothing */
+    }
+    else if (RB_INTEGER_TYPE_P(r)) {
+        rr = rb_inum_convert_to_BigDecimal(r, 0, true);
+    }
+    else if (RB_TYPE_P(r, T_FLOAT)) {
+        rr = rb_float_convert_to_BigDecimal(r, 0, true);
     }
     else if (RB_TYPE_P(r, T_RATIONAL)) {
-	b = GetVpValueWithPrec(r, a->Prec*VpBaseFig(), 1);
+        rr = rb_rational_convert_to_BigDecimal(r, a->Prec*BASE_FIG, true);
     }
-    else {
-	b = GetVpValue(r, 0);
+
+    if (!is_kind_of_BigDecimal(rr)) {
+        return Qfalse;
     }
 
-    if (!b) return Qfalse;
+    TypedData_Get_Struct(rr, Real, &BigDecimal_data_type, b);
     SAVE(b);
 
     if (VpIsNaN(a) || VpIsNaN(b)) goto NaN;
     if (VpIsInf(a) && VpIsInf(b)) goto NaN;
     if (VpIsZero(b)) {
-	rb_raise(rb_eZeroDivError, "divided by 0");
+        rb_raise(rb_eZeroDivError, "divided by 0");
     }
     if (VpIsInf(a)) {
-	GUARD_OBJ(d, VpCreateRbObject(1, "0"));
-	VpSetInf(d, (SIGNED_VALUE)(VpGetSign(a) == VpGetSign(b) ? 1 : -1));
-	GUARD_OBJ(c, VpCreateRbObject(1, "NaN"));
-	*div = d;
-	*mod = c;
-	return Qtrue;
+        if (VpGetSign(a) == VpGetSign(b)) {
+            VALUE inf = BigDecimal_positive_infinity();
+            TypedData_Get_Struct(inf, Real, &BigDecimal_data_type, *div);
+        }
+        else {
+            VALUE inf = BigDecimal_negative_infinity();
+            TypedData_Get_Struct(inf, Real, &BigDecimal_data_type, *div);
+        }
+        VALUE nan = BigDecimal_nan();
+        TypedData_Get_Struct(nan, Real, &BigDecimal_data_type, *mod);
+        return Qtrue;
     }
     if (VpIsInf(b)) {
-	GUARD_OBJ(d, VpCreateRbObject(1, "0"));
-	*div = d;
-	*mod = a;
-	return Qtrue;
+        VALUE zero = BigDecimal_positive_zero();
+        TypedData_Get_Struct(zero, Real, &BigDecimal_data_type, *div);
+        *mod = a;
+        return Qtrue;
     }
     if (VpIsZero(a)) {
-	GUARD_OBJ(c, VpCreateRbObject(1, "0"));
-	GUARD_OBJ(d, VpCreateRbObject(1, "0"));
-	*div = d;
-	*mod = c;
-	return Qtrue;
-    }
-
-    mx = a->Prec + vabs(a->exponent);
-    if (mx<b->Prec + vabs(b->exponent)) mx = b->Prec + vabs(b->exponent);
-    mx = (mx + 1) * VpBaseFig();
-    GUARD_OBJ(c, VpCreateRbObject(mx, "0"));
-    GUARD_OBJ(res, VpCreateRbObject((mx+1) * 2 +(VpBaseFig() + 1), "#0"));
+        VALUE zero = BigDecimal_positive_zero();
+        TypedData_Get_Struct(zero, Real, &BigDecimal_data_type, *div);
+        TypedData_Get_Struct(zero, Real, &BigDecimal_data_type, *mod);
+        return Qtrue;
+    }
+
+    BigDecimal_count_precision_and_scale(self, &a_prec, NULL);
+    BigDecimal_count_precision_and_scale(rr, &b_prec, NULL);
+
+    mx = (a_prec > b_prec) ? a_prec : b_prec;
+    if (2*BIGDECIMAL_DOUBLE_FIGURES > mx)
+        mx = 2*BIGDECIMAL_DOUBLE_FIGURES;
+
+    GUARD_OBJ(c, VpCreateRbObject(mx + 2*BASE_FIG, "0", true));
+    GUARD_OBJ(res, VpCreateRbObject(mx*2 + 2*BASE_FIG, "#0", true));
     VpDivd(c, res, a, b);
-    mx = c->Prec * (VpBaseFig() + 1);
-    GUARD_OBJ(d, VpCreateRbObject(mx, "0"));
+
+    mx = c->Prec * BASE_FIG;
+    GUARD_OBJ(d, VpCreateRbObject(mx, "0", true));
     VpActiveRound(d, c, VP_ROUND_DOWN, 0);
+
     VpMult(res, d, b);
     VpAddSub(c, a, res, -1);
+
     if (!VpIsZero(c) && (VpGetSign(a) * VpGetSign(b) < 0)) {
-	VpAddSub(res, d, VpOne(), -1);
-	GUARD_OBJ(d, VpCreateRbObject(GetAddSubPrec(c, b)*(VpBaseFig() + 1), "0"));
-	VpAddSub(d, c, b, 1);
-	*div = res;
-	*mod = d;
-    } else {
-	*div = d;
-	*mod = c;
+        /* result adjustment for negative case */
+        res = VpReallocReal(res, d->MaxPrec);
+        res->MaxPrec = d->MaxPrec;
+        VpAddSub(res, d, VpOne(), -1);
+        GUARD_OBJ(d, VpCreateRbObject(GetAddSubPrec(c, b) * 2*BASE_FIG, "0", true));
+        VpAddSub(d, c, b, 1);
+        *div = res;
+        *mod = d;
+    }
+    else {
+        *div = d;
+        *mod = c;
     }
     return Qtrue;
 
-NaN:
-    GUARD_OBJ(c, VpCreateRbObject(1, "NaN"));
-    GUARD_OBJ(d, VpCreateRbObject(1, "NaN"));
-    *div = d;
-    *mod = c;
+  NaN:
+    {
+        VALUE nan = BigDecimal_nan();
+        TypedData_Get_Struct(nan, Real, &BigDecimal_data_type, *div);
+        TypedData_Get_Struct(nan, Real, &BigDecimal_data_type, *mod);
+    }
     return Qtrue;
 }
 
@@ -1557,7 +1863,7 @@ BigDecimal_mod(VALUE self, VALUE r) /* %: a%b = a - (a.to_f/b).floor * b */
 
     if (BigDecimal_DoDivmod(self, r, &div, &mod)) {
 	SAVE(div); SAVE(mod);
-	return ToValue(mod);
+        return VpCheckGetValue(mod);
     }
     return DoSomeOne(self, r, '%');
 }
@@ -1572,7 +1878,7 @@ BigDecimal_divremain(VALUE self, VALUE r, Real **dv, Real **rv)
 
     GUARD_OBJ(a, GetVpValue(self, 1));
     if (RB_TYPE_P(r, T_FLOAT)) {
-	b = GetVpValueWithPrec(r, DBLE_FIG, 1);
+	b = GetVpValueWithPrec(r, 0, 1);
     }
     else if (RB_TYPE_P(r, T_RATIONAL)) {
 	b = GetVpValueWithPrec(r, a->Prec*VpBaseFig(), 1);
@@ -1585,17 +1891,17 @@ BigDecimal_divremain(VALUE self, VALUE r, Real **dv, Real **rv)
     SAVE(b);
 
     mx = (a->MaxPrec + b->MaxPrec) *VpBaseFig();
-    GUARD_OBJ(c,   VpCreateRbObject(mx, "0"));
-    GUARD_OBJ(res, VpCreateRbObject((mx+1) * 2 + (VpBaseFig() + 1), "#0"));
-    GUARD_OBJ(rr,  VpCreateRbObject((mx+1) * 2 + (VpBaseFig() + 1), "#0"));
-    GUARD_OBJ(ff,  VpCreateRbObject((mx+1) * 2 + (VpBaseFig() + 1), "#0"));
+    GUARD_OBJ(c,   VpCreateRbObject(mx, "0", true));
+    GUARD_OBJ(res, VpCreateRbObject((mx+1) * 2 + (VpBaseFig() + 1), "#0", true));
+    GUARD_OBJ(rr,  VpCreateRbObject((mx+1) * 2 + (VpBaseFig() + 1), "#0", true));
+    GUARD_OBJ(ff,  VpCreateRbObject((mx+1) * 2 + (VpBaseFig() + 1), "#0", true));
 
     VpDivd(c, res, a, b);
 
     mx = c->Prec *(VpBaseFig() + 1);
 
-    GUARD_OBJ(d, VpCreateRbObject(mx, "0"));
-    GUARD_OBJ(f, VpCreateRbObject(mx, "0"));
+    GUARD_OBJ(d, VpCreateRbObject(mx, "0", true));
+    GUARD_OBJ(f, VpCreateRbObject(mx, "0", true));
 
     VpActiveRound(d, c, VP_ROUND_DOWN, 0); /* 0: round off */
 
@@ -1622,7 +1928,7 @@ BigDecimal_remainder(VALUE self, VALUE r) /* remainder */
     Real  *d, *rv = 0;
     f = BigDecimal_divremain(self, r, &d, &rv);
     if (!NIL_P(f)) return f;
-    return ToValue(rv);
+    return VpCheckGetValue(rv);
 }
 
 /* call-seq:
@@ -1655,13 +1961,14 @@ BigDecimal_divmod(VALUE self, VALUE r)
 
     if (BigDecimal_DoDivmod(self, r, &div, &mod)) {
 	SAVE(div); SAVE(mod);
-	return rb_assoc_new(ToValue(div), ToValue(mod));
+        return rb_assoc_new(VpCheckGetValue(div), VpCheckGetValue(mod));
     }
     return DoSomeOne(self,r,rb_intern("divmod"));
 }
 
 /*
- * See BigDecimal#quo
+ * Do the same manner as Float#div when n is nil.
+ * Do the same manner as BigDecimal#quo when n is 0.
  */
 static inline VALUE
 BigDecimal_div2(VALUE self, VALUE b, VALUE n)
@@ -1673,7 +1980,7 @@ BigDecimal_div2(VALUE self, VALUE b, VALUE n)
         Real *div = NULL;
         Real *mod;
         if (BigDecimal_DoDivmod(self, b, &div, &mod)) {
-            return BigDecimal_to_i(ToValue(div));
+            return BigDecimal_to_i(VpCheckGetValue(div));
         }
         return DoSomeOne(self, b, rb_intern("div"));
     }
@@ -1687,18 +1994,25 @@ BigDecimal_div2(VALUE self, VALUE b, VALUE n)
         Real *res = NULL;
         Real *av = NULL, *bv = NULL, *cv = NULL;
         size_t mx = ix + VpBaseFig()*2;
+        size_t b_prec = ix;
         size_t pl = VpSetPrecLimit(0);
 
-        GUARD_OBJ(cv, VpCreateRbObject(mx + VpBaseFig(), "0"));
+        GUARD_OBJ(cv, VpCreateRbObject(mx + VpBaseFig(), "0", true));
         GUARD_OBJ(av, GetVpValue(self, 1));
-        GUARD_OBJ(bv, GetVpValue(b, 1));
+        /* TODO: I want to refactor this precision control for a float value later
+         *       by introducing an implicit conversion function instead of
+         *       GetVpValueWithPrec.  */
+        if (RB_FLOAT_TYPE_P(b) && b_prec > BIGDECIMAL_DOUBLE_FIGURES) {
+            b_prec = BIGDECIMAL_DOUBLE_FIGURES;
+        }
+        GUARD_OBJ(bv, GetVpValueWithPrec(b, b_prec, 1));
         mx = av->Prec + bv->Prec + 2;
         if (mx <= cv->MaxPrec) mx = cv->MaxPrec + 1;
-        GUARD_OBJ(res, VpCreateRbObject((mx * 2  + 2)*VpBaseFig(), "#0"));
+        GUARD_OBJ(res, VpCreateRbObject((mx * 2  + 2)*VpBaseFig(), "#0", true));
         VpDivd(cv, res, av, bv);
         VpSetPrecLimit(pl);
         VpLeftRound(cv, VpGetRoundMode(), ix);
-        return ToValue(cv);
+        return VpCheckGetValue(cv);
     }
 }
 
@@ -1706,6 +2020,7 @@ BigDecimal_div2(VALUE self, VALUE b, VALUE n)
   * Document-method: BigDecimal#div
   *
   * call-seq:
+  *   div(value)  -> integer
   *   div(value, digits)  -> bigdecimal or integer
   *
   * Divide by the specified value.
@@ -1720,6 +2035,9 @@ BigDecimal_div2(VALUE self, VALUE b, VALUE n)
   *          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")
@@ -1743,6 +2061,31 @@ BigDecimal_div3(int argc, VALUE *argv, VALUE self)
     return BigDecimal_div2(self, b, n);
 }
 
+ /*
+  *  call-seq:
+  *    add(value, ndigits) -> new_bigdecimal
+  *
+  *  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
+  *
+  */
+
 static VALUE
 BigDecimal_add2(VALUE self, VALUE b, VALUE n)
 {
@@ -1756,7 +2099,7 @@ BigDecimal_add2(VALUE self, VALUE b, VALUE n)
 	VpSetPrecLimit(pl);
 	GUARD_OBJ(cv, GetVpValue(c, 1));
 	VpLeftRound(cv, VpGetRoundMode(), mx);
-	return ToValue(cv);
+        return VpCheckGetValue(cv);
     }
 }
 
@@ -1786,10 +2129,35 @@ BigDecimal_sub2(VALUE self, VALUE b, VALUE n)
 	VpSetPrecLimit(pl);
 	GUARD_OBJ(cv, GetVpValue(c, 1));
 	VpLeftRound(cv, VpGetRoundMode(), mx);
-	return ToValue(cv);
+        return VpCheckGetValue(cv);
     }
 }
 
+ /*
+  *  call-seq:
+  *    mult(other, ndigits) -> bigdecimal
+  *
+  *  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)
+  *
+  */
 
 static VALUE
 BigDecimal_mult2(VALUE self, VALUE b, VALUE n)
@@ -1804,18 +2172,19 @@ BigDecimal_mult2(VALUE self, VALUE b, VALUE n)
 	VpSetPrecLimit(pl);
 	GUARD_OBJ(cv, GetVpValue(c, 1));
 	VpLeftRound(cv, VpGetRoundMode(), mx);
-	return ToValue(cv);
+        return VpCheckGetValue(cv);
     }
 }
 
 /*
  *  call-seq:
- *     big_decimal.abs  ->  big_decimal
+ *    abs -> bigdecimal
+ *
+ *  Returns the \BigDecimal absolute value of +self+:
  *
- *  Returns the absolute value, as a BigDecimal.
+ *    BigDecimal('5').abs  # => 0.5e1
+ *    BigDecimal('-3').abs # => 0.3e1
  *
- *     BigDecimal('5').abs  #=> 0.5e1
- *     BigDecimal('-3').abs #=> 0.3e1
  */
 
 static VALUE
@@ -1827,10 +2196,10 @@ BigDecimal_abs(VALUE self)
 
     GUARD_OBJ(a, GetVpValue(self, 1));
     mx = a->Prec *(VpBaseFig() + 1);
-    GUARD_OBJ(c, VpCreateRbObject(mx, "0"));
+    GUARD_OBJ(c, VpCreateRbObject(mx, "0", true));
     VpAsgn(c, a, 1);
     VpChangeSign(c, 1);
-    return ToValue(c);
+    return VpCheckGetValue(c);
 }
 
 /* call-seq:
@@ -1852,9 +2221,9 @@ BigDecimal_sqrt(VALUE self, VALUE nFig)
 
     n = GetPrecisionInt(nFig) + VpDblFig() + BASE_FIG;
     if (mx <= n) mx = n;
-    GUARD_OBJ(c, VpCreateRbObject(mx, "0"));
+    GUARD_OBJ(c, VpCreateRbObject(mx, "0", true));
     VpSqrt(c, a);
-    return ToValue(c);
+    return VpCheckGetValue(c);
 }
 
 /* Return the integer part of the number, as a BigDecimal.
@@ -1868,9 +2237,9 @@ BigDecimal_fix(VALUE self)
 
     GUARD_OBJ(a, GetVpValue(self, 1));
     mx = a->Prec *(VpBaseFig() + 1);
-    GUARD_OBJ(c, VpCreateRbObject(mx, "0"));
+    GUARD_OBJ(c, VpCreateRbObject(mx, "0", true));
     VpActiveRound(c, a, VP_ROUND_DOWN, 0); /* 0: round off */
-    return ToValue(c);
+    return VpCheckGetValue(c);
 }
 
 /* call-seq:
@@ -1941,13 +2310,13 @@ BigDecimal_round(int argc, VALUE *argv, VALUE self)
     pl = VpSetPrecLimit(0);
     GUARD_OBJ(a, GetVpValue(self, 1));
     mx = a->Prec * (VpBaseFig() + 1);
-    GUARD_OBJ(c, VpCreateRbObject(mx, "0"));
+    GUARD_OBJ(c, VpCreateRbObject(mx, "0", true));
     VpSetPrecLimit(pl);
     VpActiveRound(c, a, sw, iLoc);
     if (round_to_int) {
-	return BigDecimal_to_i(ToValue(c));
+        return BigDecimal_to_i(VpCheckGetValue(c));
     }
-    return ToValue(c);
+    return VpCheckGetValue(c);
 }
 
 /* call-seq:
@@ -1987,13 +2356,13 @@ BigDecimal_truncate(int argc, VALUE *argv, VALUE self)
 
     GUARD_OBJ(a, GetVpValue(self, 1));
     mx = a->Prec * (VpBaseFig() + 1);
-    GUARD_OBJ(c, VpCreateRbObject(mx, "0"));
+    GUARD_OBJ(c, VpCreateRbObject(mx, "0", true));
     VpSetPrecLimit(pl);
     VpActiveRound(c, a, VP_ROUND_DOWN, iLoc); /* 0: truncate */
     if (argc == 0) {
-	return BigDecimal_to_i(ToValue(c));
+        return BigDecimal_to_i(VpCheckGetValue(c));
     }
-    return ToValue(c);
+    return VpCheckGetValue(c);
 }
 
 /* Return the fractional part of the number, as a BigDecimal.
@@ -2007,9 +2376,9 @@ BigDecimal_frac(VALUE self)
 
     GUARD_OBJ(a, GetVpValue(self, 1));
     mx = a->Prec * (VpBaseFig() + 1);
-    GUARD_OBJ(c, VpCreateRbObject(mx, "0"));
+    GUARD_OBJ(c, VpCreateRbObject(mx, "0", true));
     VpFrac(c, a);
-    return ToValue(c);
+    return VpCheckGetValue(c);
 }
 
 /* call-seq:
@@ -2047,16 +2416,16 @@ BigDecimal_floor(int argc, VALUE *argv, VALUE self)
 
     GUARD_OBJ(a, GetVpValue(self, 1));
     mx = a->Prec * (VpBaseFig() + 1);
-    GUARD_OBJ(c, VpCreateRbObject(mx, "0"));
+    GUARD_OBJ(c, VpCreateRbObject(mx, "0", true));
     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(ToValue(c));
+        return BigDecimal_to_i(VpCheckGetValue(c));
     }
-    return ToValue(c);
+    return VpCheckGetValue(c);
 }
 
 /* call-seq:
@@ -2093,13 +2462,13 @@ BigDecimal_ceil(int argc, VALUE *argv, VALUE self)
 
     GUARD_OBJ(a, GetVpValue(self, 1));
     mx = a->Prec * (VpBaseFig() + 1);
-    GUARD_OBJ(c, VpCreateRbObject(mx, "0"));
+    GUARD_OBJ(c, VpCreateRbObject(mx, "0", true));
     VpSetPrecLimit(pl);
     VpActiveRound(c, a, VP_ROUND_CEIL, iLoc);
     if (argc == 0) {
-	return BigDecimal_to_i(ToValue(c));
+        return BigDecimal_to_i(VpCheckGetValue(c));
     }
-    return ToValue(c);
+    return VpCheckGetValue(c);
 }
 
 /* call-seq:
@@ -2395,13 +2764,13 @@ is_even(VALUE x)
 }
 
 static VALUE
-rmpd_power_by_big_decimal(Real const* x, Real const* exp, ssize_t const n)
+bigdecimal_power_by_bigdecimal(Real const* x, Real const* exp, ssize_t const n)
 {
     VALUE log_x, multiplied, y;
     volatile VALUE obj = exp->obj;
 
     if (VpIsZero(exp)) {
-	return ToValue(VpCreateRbObject(n, "1"));
+        return VpCheckGetValue(VpCreateRbObject(n, "1", true));
     }
 
     log_x = BigMath_log(x->obj, SSIZET2NUM(n+1));
@@ -2439,10 +2808,10 @@ BigDecimal_power(int argc, VALUE*argv, VALUE self)
     n = NIL_P(prec) ? (ssize_t)(x->Prec*VpBaseFig()) : NUM2SSIZET(prec);
 
     if (VpIsNaN(x)) {
-	y = VpCreateRbObject(n, "0");
+        y = VpCreateRbObject(n, "0", true);
 	RB_GC_GUARD(y->obj);
 	VpSetNaN(y);
-	return ToValue(y);
+        return VpCheckGetValue(y);
     }
 
   retry:
@@ -2465,9 +2834,9 @@ BigDecimal_power(int argc, VALUE*argv, VALUE self)
 	    goto retry;
 	}
         if (NIL_P(prec)) {
-            n += DBLE_FIG;
+            n += BIGDECIMAL_DOUBLE_FIGURES;
         }
-        exp = GetVpValueWithPrec(vexp, DBLE_FIG, 1);
+        exp = GetVpValueWithPrec(vexp, 0, 1);
 	break;
 
       case T_RATIONAL:
@@ -2511,7 +2880,7 @@ BigDecimal_power(int argc, VALUE*argv, VALUE self)
 
     if (VpIsZero(x)) {
 	if (is_negative(vexp)) {
-	    y = VpCreateRbObject(n, "#0");
+            y = VpCreateRbObject(n, "#0", true);
 	    RB_GC_GUARD(y->obj);
 	    if (BIGDECIMAL_NEGATIVE_P(x)) {
 		if (is_integer(vexp)) {
@@ -2533,18 +2902,18 @@ BigDecimal_power(int argc, VALUE*argv, VALUE self)
 		/* (+0) ** (-num)  -> Infinity */
 		VpSetPosInf(y);
 	    }
-	    return ToValue(y);
+            return VpCheckGetValue(y);
 	}
 	else if (is_zero(vexp)) {
-	    return ToValue(VpCreateRbObject(n, "1"));
+            return VpCheckGetValue(VpCreateRbObject(n, "1", true));
 	}
 	else {
-	    return ToValue(VpCreateRbObject(n, "0"));
+            return VpCheckGetValue(VpCreateRbObject(n, "0", true));
 	}
     }
 
     if (is_zero(vexp)) {
-	return ToValue(VpCreateRbObject(n, "1"));
+        return VpCheckGetValue(VpCreateRbObject(n, "1", true));
     }
     else if (is_one(vexp)) {
 	return self;
@@ -2556,24 +2925,24 @@ BigDecimal_power(int argc, VALUE*argv, VALUE self)
 		if (is_integer(vexp)) {
 		    if (is_even(vexp)) {
 			/* (-Infinity) ** (-even_integer) -> +0 */
-			return ToValue(VpCreateRbObject(n, "0"));
+                        return VpCheckGetValue(VpCreateRbObject(n, "0", true));
 		    }
 		    else {
 			/* (-Infinity) ** (-odd_integer) -> -0 */
-			return ToValue(VpCreateRbObject(n, "-0"));
+                        return VpCheckGetValue(VpCreateRbObject(n, "-0", true));
 		    }
 		}
 		else {
 		    /* (-Infinity) ** (-non_integer) -> -0 */
-		    return ToValue(VpCreateRbObject(n, "-0"));
+                    return VpCheckGetValue(VpCreateRbObject(n, "-0", true));
 		}
 	    }
 	    else {
-		return ToValue(VpCreateRbObject(n, "0"));
+                return VpCheckGetValue(VpCreateRbObject(n, "0", true));
 	    }
 	}
 	else {
-	    y = VpCreateRbObject(n, "0");
+            y = VpCreateRbObject(n, "0", true);
 	    if (BIGDECIMAL_NEGATIVE_P(x)) {
 		if (is_integer(vexp)) {
 		    if (is_even(vexp)) {
@@ -2592,52 +2961,52 @@ BigDecimal_power(int argc, VALUE*argv, VALUE self)
 	    else {
 		VpSetPosInf(y);
 	    }
-	    return ToValue(y);
+            return VpCheckGetValue(y);
 	}
     }
 
     if (exp != NULL) {
-	return rmpd_power_by_big_decimal(x, exp, n);
+	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 ToValue(VpCreateRbObject(n, "1"));
+            return VpCheckGetValue(VpCreateRbObject(n, "1", true));
 	}
 	else if (RTEST(rb_funcall(abs_value, '<', 1, INT2FIX(1)))) {
 	    if (is_negative(vexp)) {
-		y = VpCreateRbObject(n, "0");
+                y = VpCreateRbObject(n, "0", true);
 		if (is_even(vexp)) {
 		    VpSetInf(y, VpGetSign(x));
 		}
 		else {
 		    VpSetInf(y, -VpGetSign(x));
 		}
-		return ToValue(y);
+                return VpCheckGetValue(y);
 	    }
 	    else if (BIGDECIMAL_NEGATIVE_P(x) && is_even(vexp)) {
-		return ToValue(VpCreateRbObject(n, "-0"));
+                return VpCheckGetValue(VpCreateRbObject(n, "-0", true));
 	    }
 	    else {
-		return ToValue(VpCreateRbObject(n, "0"));
+                return VpCheckGetValue(VpCreateRbObject(n, "0", true));
 	    }
 	}
 	else {
 	    if (is_positive(vexp)) {
-		y = VpCreateRbObject(n, "0");
+                y = VpCreateRbObject(n, "0", true);
 		if (is_even(vexp)) {
 		    VpSetInf(y, VpGetSign(x));
 		}
 		else {
 		    VpSetInf(y, -VpGetSign(x));
 		}
-		return ToValue(y);
+                return VpCheckGetValue(y);
 	    }
 	    else if (BIGDECIMAL_NEGATIVE_P(x) && is_even(vexp)) {
-		return ToValue(VpCreateRbObject(n, "-0"));
+                return VpCheckGetValue(VpCreateRbObject(n, "-0", true));
 	    }
 	    else {
-		return ToValue(VpCreateRbObject(n, "0"));
+                return VpCheckGetValue(VpCreateRbObject(n, "0", true));
 	    }
 	}
     }
@@ -2649,24 +3018,30 @@ BigDecimal_power(int argc, VALUE*argv, VALUE self)
 
     if (VpIsDef(x)) {
 	mp = x->Prec * (VpBaseFig() + 1);
-	GUARD_OBJ(y, VpCreateRbObject(mp * (ma + 1), "0"));
+        GUARD_OBJ(y, VpCreateRbObject(mp * (ma + 1), "0", true));
     }
     else {
-	GUARD_OBJ(y, VpCreateRbObject(1, "0"));
+        GUARD_OBJ(y, VpCreateRbObject(1, "0", true));
     }
-    VpPower(y, x, int_exp);
+    VpPowerByInt(y, x, int_exp);
     if (!NIL_P(prec) && VpIsDef(y)) {
 	VpMidRound(y, VpGetRoundMode(), n);
     }
-    return ToValue(y);
+    return VpCheckGetValue(y);
 }
 
-/* call-seq:
- *   a ** n  -> bigdecimal
+/*  call-seq:
+ *    self ** other -> bigdecimal
  *
- * Returns the value raised to the power of n.
+ *  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.
  *
- * See BigDecimal#power.
  */
 static VALUE
 BigDecimal_power_op(VALUE self, VALUE exp)
@@ -2720,182 +3095,483 @@ opts_exception_p(VALUE opts)
 }
 #endif
 
-static Real *
-VpNewVarArg(int argc, VALUE *argv)
+static VALUE
+check_exception(VALUE bd)
 {
-    size_t mf;
-    VALUE  opts = Qnil;
-    VALUE  nFig;
-    VALUE  iniValue;
-    double d;
-    int    exc;
+    assert(is_kind_of_BigDecimal(bd));
+
+    Real *vp;
+    TypedData_Get_Struct(bd, Real, &BigDecimal_data_type, vp);
+    VpCheckGetValue(vp); /* VpCheckGetValue performs exception check */
+
+    return bd;
+}
 
-    argc = rb_scan_args(argc, argv, "11:", &iniValue, &nFig, &opts);
-    exc = opts_exception_p(opts);
+static VALUE
+rb_uint64_convert_to_BigDecimal(uint64_t uval, RB_UNUSED_VAR(size_t digs), int raise_exception)
+{
+    VALUE obj = TypedData_Wrap_Struct(rb_cBigDecimal, &BigDecimal_data_type, 0);
 
-    if (argc == 1) {
-        mf = 0;
+    Real *vp;
+    if (uval == 0) {
+        vp = VpAllocReal(1);
+        vp->MaxPrec = 1;
+        vp->Prec = 1;
+        vp->exponent = 1;
+        VpSetZero(vp, 1);
+        vp->frac[0] = 0;
+    }
+    else if (uval < BASE) {
+        vp = VpAllocReal(1);
+        vp->MaxPrec = 1;
+        vp->Prec = 1;
+        vp->exponent = 1;
+        VpSetSign(vp, 1);
+        vp->frac[0] = (DECDIG)uval;
     }
     else {
-        /* expand GetPrecisionInt for exception suppression */
-        ssize_t n = NUM2INT(nFig);
-        if (n < 0) {
-            if (!exc) {
-                return NULL;
+        DECDIG buf[BIGDECIMAL_INT64_MAX_LENGTH] = {0,};
+        DECDIG r = uval % BASE;
+        size_t len = 0, ntz = 0;
+        if (r == 0) {
+            // Count and skip trailing zeros
+            for (; r == 0 && uval > 0; ++ntz) {
+                uval /= BASE;
+                r = uval % BASE;
             }
-            rb_raise(rb_eArgError, "negative precision");
         }
-        mf = (size_t)n;
-    }
-
-    if (SPECIAL_CONST_P(iniValue)) {
-        switch (iniValue) {
-          case Qnil:
-            if (!exc) return NULL;
-            rb_raise(rb_eTypeError, "can't convert nil into BigDecimal");
-          case Qtrue:
-            if (!exc) return NULL;
-            rb_raise(rb_eTypeError, "can't convert true into BigDecimal");
-          case Qfalse:
-            if (!exc) return NULL;
-            rb_raise(rb_eTypeError, "can't convert false into BigDecimal");
-          default:
-            break;
+        for (; uval > 0; ++len) {
+            // Store digits
+            buf[BIGDECIMAL_INT64_MAX_LENGTH - len - 1] = r;
+            uval /= BASE;
+            r = uval % BASE;
         }
+
+        const size_t exp = len + ntz;
+        vp = VpAllocReal(len);
+        vp->MaxPrec = len;
+        vp->Prec = len;
+        vp->exponent = exp;
+        VpSetSign(vp, 1);
+        MEMCPY(vp->frac, buf + BIGDECIMAL_INT64_MAX_LENGTH - len, DECDIG, len);
     }
 
-  retry:
-    switch (TYPE(iniValue)) {
-      case T_DATA:
-	if (is_kind_of_BigDecimal(iniValue)) {
-	    return DATA_PTR(iniValue);
-	}
-	break;
+    return BigDecimal_wrap_struct(obj, vp);
+}
 
-      case T_FIXNUM:
-	/* fall through */
-      case T_BIGNUM:
-	return GetVpValue(iniValue, 1);
+static VALUE
+rb_int64_convert_to_BigDecimal(int64_t ival, size_t digs, int raise_exception)
+{
+    const uint64_t uval = (ival < 0) ? (((uint64_t)-(ival+1))+1) : (uint64_t)ival;
+    VALUE bd = rb_uint64_convert_to_BigDecimal(uval, digs, raise_exception);
+    if (ival < 0) {
+        Real *vp;
+        TypedData_Get_Struct(bd, Real, &BigDecimal_data_type, vp);
+        VpSetSign(vp, -1);
+    }
+    return bd;
+}
 
-      case T_FLOAT:
-        d = RFLOAT_VALUE(iniValue);
-        if (!isfinite(d)) {
-            Real *pv = VpCreateRbObject(1, NULL);
-            VpDtoV(pv, d);
-            return pv;
+static VALUE
+rb_big_convert_to_BigDecimal(VALUE val, RB_UNUSED_VAR(size_t digs), int raise_exception)
+{
+    assert(RB_TYPE_P(val, T_BIGNUM));
+
+    int leading_zeros;
+    size_t size = rb_absint_size(val, &leading_zeros);
+    int sign = FIX2INT(rb_big_cmp(val, INT2FIX(0)));
+    if (sign < 0 && leading_zeros == 0) {
+        size += 1;
+    }
+    if (size <= sizeof(long)) {
+        if (sign < 0) {
+            return rb_int64_convert_to_BigDecimal(NUM2LONG(val), digs, raise_exception);
         }
-	if (mf > DBLE_FIG) {
-            if (!exc) {
-                return NULL;
-            }
-	    rb_raise(rb_eArgError, "precision too large.");
-	}
-	/* fall through */
-      case T_RATIONAL:
-	if (NIL_P(nFig)) {
-            if (!exc) {
-                return NULL;
-            }
-	    rb_raise(rb_eArgError,
-		     "can't omit precision for a %"PRIsVALUE".",
-		     RB_OBJ_CLASSNAME(iniValue));
-	}
-	return GetVpValueWithPrec(iniValue, mf, 1);
+        else {
+            return rb_uint64_convert_to_BigDecimal(NUM2ULONG(val), digs, raise_exception);
+        }
+    }
+#if defined(SIZEOF_LONG_LONG) && SIZEOF_LONG < SIZEOF_LONG_LONG
+    else if (size <= sizeof(LONG_LONG)) {
+        if (sign < 0) {
+            return rb_int64_convert_to_BigDecimal(NUM2LL(val), digs, raise_exception);
+        }
+        else {
+            return rb_uint64_convert_to_BigDecimal(NUM2ULL(val), digs, raise_exception);
+        }
+    }
+#endif
+    else {
+        VALUE str = rb_big2str(val, 10);
+        Real *vp = VpCreateRbObject(RSTRING_LEN(str) + BASE_FIG + 1,
+                                    RSTRING_PTR(str), true);
+        RB_GC_GUARD(str);
+        return check_exception(vp->obj);
+    }
+}
 
-      case T_COMPLEX:
-        {
-            VALUE im;
-            im = rb_complex_imag(iniValue);
-            if (!is_zero(im)) {
-                rb_raise(rb_eArgError,
-                         "Unable to make a BigDecimal from non-zero imaginary number");
-            }
-            iniValue = rb_complex_real(iniValue);
-            goto retry;
+static VALUE
+rb_inum_convert_to_BigDecimal(VALUE val, RB_UNUSED_VAR(size_t digs), int raise_exception)
+{
+    assert(RB_INTEGER_TYPE_P(val));
+    if (FIXNUM_P(val)) {
+        return rb_int64_convert_to_BigDecimal(FIX2LONG(val), digs, raise_exception);
+    }
+    else {
+        return rb_big_convert_to_BigDecimal(val, digs, raise_exception);
+    }
+}
+
+static VALUE
+rb_float_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
+{
+    assert(RB_FLOAT_TYPE_P(val));
+
+    double d = RFLOAT_VALUE(val);
+
+    if (isnan(d)) {
+        VALUE obj = BigDecimal_nan();
+        return check_exception(obj);
+    }
+    else if (isinf(d)) {
+        VALUE obj;
+        if (d > 0) {
+            obj = BigDecimal_positive_infinity();
+        }
+        else {
+            obj = BigDecimal_negative_infinity();
+        }
+        return check_exception(obj);
+    }
+    else if (d == 0.0) {
+        if (1/d < 0.0) {
+            return BigDecimal_negative_zero();
+        }
+        else {
+            return BigDecimal_positive_zero();
         }
+    }
+
+    if (digs == SIZE_MAX) {
+        if (!raise_exception)
+            return Qnil;
+        rb_raise(rb_eArgError,
+                 "can't omit precision for a %"PRIsVALUE".",
+                 CLASS_OF(val));
+    }
+    else if (digs > BIGDECIMAL_DOUBLE_FIGURES) {
+        if (!raise_exception)
+            return Qnil;
+        rb_raise(rb_eArgError, "precision too large.");
+    }
+
+    /* Use the same logic in flo_to_s to convert a float to a decimal string */
+    char buf[BIGDECIMAL_DOUBLE_FIGURES + BASE_FIG + 2 + 1];  /* sizeof(buf) == 28 in the typical case */
+    int decpt, negative_p;
+    char *e;
+    const int mode = digs == 0 ? 0 : 2;
+    char *p = BigDecimal_dtoa(d, mode, (int)digs, &decpt, &negative_p, &e);
+    int len10 = (int)(e - p);
+    if (len10 > BIGDECIMAL_DOUBLE_FIGURES) {
+        /* TODO: Presumably, rounding should be done here. */
+        len10 = BIGDECIMAL_DOUBLE_FIGURES;
+    }
+    memcpy(buf, p, len10);
+    xfree(p);
+
+    VALUE inum;
+    size_t RB_UNUSED_VAR(prec) = 0;
+    size_t exp = 0;
+    if (decpt > 0) {
+        if (decpt < len10) {
+            /*
+             *     len10 |---------------|
+             *           :       |-------| frac_len10 = len10 - decpt
+             *     decpt |-------|       |--| ntz10 = BASE_FIG - frac_len10 % BASE_FIG
+             *           :       :       :
+             *         00 dd dddd.dddd dd 00
+             *   prec |-----.----.----.-----| prec = exp + roomof(frac_len, BASE_FIG)
+             *   exp  |-----.----| exp = roomof(decpt, BASE_FIG)
+             */
+            const size_t frac_len10 = len10 - decpt;
+            const size_t ntz10 = BASE_FIG - frac_len10 % BASE_FIG;
+            memset(buf + len10, '0', ntz10);
+            buf[len10 + ntz10] = '\0';
+            inum = rb_cstr_to_inum(buf, 10, false);
+
+            exp = roomof(decpt, BASE_FIG);
+            prec = exp + roomof(frac_len10, BASE_FIG);
+        }
+        else {
+            /*
+             *      decpt |-----------------------|
+             *      len10 |----------|            :
+             *            :          |------------| exp10
+             *            :          :            :
+             *          00 dd dddd dd 00 0000 0000.0
+             *         :             :  :         :
+             *         :             |--| ntz10 = exp10 % BASE_FIG
+             *    prec |-----.----.-----|         :
+             *         :                |----.----| exp10 / BASE_FIG
+             *     exp |-----.----.-----.----.----|
+             */
+            const size_t exp10 = decpt - len10;
+            const size_t ntz10 = exp10 % BASE_FIG;
+
+            memset(buf + len10, '0', ntz10);
+            buf[len10 + ntz10] = '\0';
+            inum = rb_cstr_to_inum(buf, 10, false);
+
+            prec = roomof(len10 + ntz10, BASE_FIG);
+            exp = prec + exp10 / BASE_FIG;
+        }
+    }
+    else if (decpt == 0) {
+        /*
+         *   len10 |------------|
+         *         :            :
+         *        0.dddd dddd dd 00
+         *         :            :  :
+         *         :            |--| ntz10 = prec * BASE_FIG - len10
+         *    prec |----.----.-----| roomof(len10, BASE_FIG)
+         */
+        prec = roomof(len10, BASE_FIG);
+        const size_t ntz10 = prec * BASE_FIG - len10;
+
+        memset(buf + len10, '0', ntz10);
+        buf[len10 + ntz10] = '\0';
+        inum = rb_cstr_to_inum(buf, 10, false);
+    }
+    else {
+        /*
+         *           len10 |---------------|
+         *                 :               :
+         *   decpt |-------|               |--| ntz10 = prec * BASE_FIG - nlz10 - len10
+         *         :       :               :
+         *        0.0000 00 dd dddd dddd dd 00
+         *              :  :                  :
+         *        nlz10 |--|                  : decpt % BASE_FIG
+         *         prec |-----.----.----.-----| roomof(decpt + len10, BASE_FIG) - exp
+         *    exp  |----| decpt / BASE_FIG
+         */
+        decpt = -decpt;
+
+        const size_t nlz10 = decpt % BASE_FIG;
+        exp = decpt / BASE_FIG;
+        prec = roomof(decpt + len10, BASE_FIG) - exp;
+        const size_t ntz10 = prec * BASE_FIG - nlz10 - len10;
+
+        if (nlz10 > 0) {
+            memmove(buf + nlz10, buf, len10);
+            memset(buf, '0', nlz10);
+        }
+        memset(buf + nlz10 + len10, '0', ntz10);
+        buf[nlz10 + len10 + ntz10] = '\0';
+        inum = rb_cstr_to_inum(buf, 10, false);
+
+        exp = -exp;
+    }
+
+    VALUE bd = rb_inum_convert_to_BigDecimal(inum, SIZE_MAX, raise_exception);
+    Real *vp;
+    TypedData_Get_Struct(bd, Real, &BigDecimal_data_type, vp);
+    assert(vp->Prec == prec);
+    vp->exponent = exp;
+
+    if (negative_p) VpSetSign(vp, -1);
+    return bd;
+}
+
+static VALUE
+rb_rational_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
+{
+    assert(RB_TYPE_P(val, T_RATIONAL));
+
+    if (digs == SIZE_MAX) {
+        if (!raise_exception)
+            return Qnil;
+        rb_raise(rb_eArgError,
+                 "can't omit precision for a %"PRIsVALUE".",
+                 CLASS_OF(val));
+    }
+
+    VALUE num = rb_inum_convert_to_BigDecimal(rb_rational_num(val), 0, raise_exception);
+    VALUE d = BigDecimal_div2(num, rb_rational_den(val), SIZET2NUM(digs));
+    return d;
+}
+
+static VALUE
+rb_cstr_convert_to_BigDecimal(const char *c_str, size_t digs, int raise_exception)
+{
+    if (digs == SIZE_MAX)
+        digs = 0;
+
+    Real *vp = VpCreateRbObject(digs, c_str, raise_exception);
+    if (!vp)
+        return Qnil;
+    return VpCheckGetValue(vp);
+}
+
+static inline VALUE
+rb_str_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
+{
+    const char *c_str = StringValueCStr(val);
+    return rb_cstr_convert_to_BigDecimal(c_str, digs, raise_exception);
+}
+
+static VALUE
+rb_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
+{
+    switch (val) {
+      case Qnil:
+      case Qtrue:
+      case Qfalse:
+        if (raise_exception) {
+            const char *cname = NIL_P(val)    ? "nil"   :
+                                val == Qtrue  ? "true"  :
+                                val == Qfalse ? "false" :
+                                NULL;
+            rb_raise(rb_eTypeError,
+                       "can't convert %s into BigDecimal", cname);
+        }
+        return Qnil;
 
-      case T_STRING:
-	/* fall through */
       default:
-	break;
+        break;
+    }
+
+    if (is_kind_of_BigDecimal(val)) {
+        if (digs == SIZE_MAX)
+            return check_exception(val);
+
+        Real *vp;
+        TypedData_Get_Struct(val, Real, &BigDecimal_data_type, vp);
+
+        VALUE copy = TypedData_Wrap_Struct(rb_cBigDecimal, &BigDecimal_data_type, 0);
+        vp = VpCopy(NULL, vp);
+        /* TODO: rounding */
+        BigDecimal_wrap_struct(copy, vp);
+        return VpCheckGetValue(vp);
+    }
+    else if (RB_INTEGER_TYPE_P(val)) {
+        return rb_inum_convert_to_BigDecimal(val, digs, raise_exception);
+    }
+    else if (RB_FLOAT_TYPE_P(val)) {
+        return rb_float_convert_to_BigDecimal(val, digs, raise_exception);
     }
-    /* TODO: support to_d */
-    if (!exc) {
-        iniValue = rb_check_convert_type(iniValue, T_STRING, "String", "to_str");
-        if (NIL_P(iniValue)) return NULL;
+    else if (RB_TYPE_P(val, T_RATIONAL)) {
+        return rb_rational_convert_to_BigDecimal(val, digs, raise_exception);
     }
-    StringValueCStr(iniValue);
-    return VpAlloc(mf, RSTRING_PTR(iniValue), 1, exc);
+    else if (RB_TYPE_P(val, T_COMPLEX)) {
+        VALUE im = rb_complex_imag(val);
+        if (!is_zero(im)) {
+            /* TODO: handle raise_exception */
+            rb_raise(rb_eArgError,
+                     "Unable to make a BigDecimal from non-zero imaginary number");
+        }
+        return rb_convert_to_BigDecimal(rb_complex_real(val), digs, raise_exception);
+    }
+    else if (RB_TYPE_P(val, T_STRING)) {
+        return rb_str_convert_to_BigDecimal(val, digs, raise_exception);
+    }
+
+    /* TODO: chheck to_d */
+    /* TODO: chheck to_int */
+
+    VALUE str = rb_check_convert_type(val, T_STRING, "String", "to_str");
+    if (!RB_TYPE_P(str, T_STRING)) {
+        if (raise_exception) {
+            rb_raise(rb_eTypeError,
+                     "can't convert %"PRIsVALUE" into BigDecimal", rb_obj_class(val));
+        }
+        return Qnil;
+    }
+    return rb_str_convert_to_BigDecimal(str, digs, raise_exception);
 }
 
-/* call-seq:
- *   BigDecimal(initial, digits, exception: true)
+/*  call-seq:
+ *    BigDecimal(value, exception: true) -> bigdecimal
+ *    BigDecimal(value, ndigits, exception: true) -> bigdecimal
  *
- * Create a new BigDecimal object.
+ *   Returns the \BigDecimal converted from +value+
+ *   with a precision of +ndigits+ decimal digits.
  *
- * initial:: The initial value, as an Integer, a Float, a Rational,
- *           a BigDecimal, or a String.
+ *   When +ndigits+ is less than the number of significant digits
+ *   in the value, the result is rounded to that number of digits,
+ *   according to the current rounding mode; see BigDecimal.mode.
  *
- *           If it is a String, spaces are ignored and unrecognized characters
- *           terminate the value.
+ *  Returns +value+ converted to a \BigDecimal, depending on the type of +value+:
  *
- * digits:: The number of significant digits, as an Integer. If omitted or 0,
- *          the number of significant digits is determined from the initial
- *          value.
+ *  - Integer, Float, Rational, Complex, or BigDecimal: converted directly:
  *
- *          The actual number of significant digits used in computation is
- *          usually larger than the specified number.
+ *      # Integer, Complex, or BigDecimal value does not require ndigits; ignored if given.
+ *      BigDecimal(2)                     # => 0.2e1
+ *      BigDecimal(Complex(2, 0))         # => 0.2e1
+ *      BigDecimal(BigDecimal(2))         # => 0.2e1
+ *      # Float or Rational value requires ndigits.
+ *      BigDecimal(2.0, 0)                # => 0.2e1
+ *      BigDecimal(Rational(2, 1), 0)     # => 0.2e1
  *
- * exception:: Whether an exception should be raised on invalid arguments.
- *             +true+ by default, if passed +false+, just returns +nil+
- *             for invalid.
+ *  - String: converted by parsing if it contains an integer or floating-point literal;
+ *    leading and trailing whitespace is ignored:
  *
+ *      # String does not require ndigits; ignored if given.
+ *      BigDecimal('2')     # => 0.2e1
+ *      BigDecimal('2.0')   # => 0.2e1
+ *      BigDecimal('0.2e1') # => 0.2e1
+ *      BigDecimal(' 2.0 ') # => 0.2e1
  *
- * ==== Exceptions
+ *  - Other type that responds to method <tt>:to_str</tt>:
+ *    first converted to a string, then converted to a \BigDecimal, as above.
  *
- * TypeError:: If the +initial+ type is neither Integer, Float,
- *             Rational, nor BigDecimal, this exception is raised.
+ *  - Other type:
  *
- * TypeError:: If the +digits+ is not an Integer, this exception is raised.
+ *    - Raises an exception if keyword argument +exception+ is +true+.
+ *    - Returns +nil+ if keyword argument +exception+ is +true+.
  *
- * ArgumentError:: If +initial+ is a Float, and the +digits+ is larger than
- *                 Float::DIG + 1, this exception is raised.
+ *  Raises an exception if +value+ evaluates to a Float
+ *  and +digits+ is larger than Float::DIG + 1.
  *
- * ArgumentError:: If the +initial+ is a Float or Rational, and the +digits+
- *                 value is omitted, this exception is raised.
  */
 static VALUE
 f_BigDecimal(int argc, VALUE *argv, VALUE self)
 {
-    ENTER(1);
-    Real *pv;
-    VALUE obj;
-
-    if (argc > 0 && CLASS_OF(argv[0]) == rb_cBigDecimal) {
-        if (argc == 1 || (argc == 2 && RB_TYPE_P(argv[1], T_HASH))) return argv[0];
+    VALUE val, digs_v, opts = Qnil;
+    argc = rb_scan_args(argc, argv, "11:", &val, &digs_v, &opts);
+    int exception = opts_exception_p(opts);
+
+    size_t digs = SIZE_MAX; /* this means digs is omitted */
+    if (argc > 1) {
+        digs_v = rb_to_int(digs_v);
+        if (FIXNUM_P(digs_v)) {
+            long n = FIX2LONG(digs_v);
+            if (n < 0)
+                goto negative_digs;
+            digs = (size_t)n;
+        }
+        else {
+            if (RBIGNUM_NEGATIVE_P(digs_v)) {
+              negative_digs:
+                if (!exception)
+                    return Qnil;
+                rb_raise(rb_eArgError, "negative precision");
+            }
+            digs = NUM2SIZET(digs_v);
+        }
     }
-    obj = TypedData_Wrap_Struct(rb_cBigDecimal, &BigDecimal_data_type, 0);
-    pv = VpNewVarArg(argc, argv);
-    if (pv == NULL) return Qnil;
-    SAVE(pv);
-    if (ToValue(pv)) pv = VpCopy(NULL, pv);
-    RTYPEDDATA_DATA(obj) = pv;
-    RB_OBJ_FREEZE(obj);
-    return pv->obj = obj;
+
+    return rb_convert_to_BigDecimal(val, digs, exception);
 }
 
 static VALUE
 BigDecimal_s_interpret_loosely(VALUE klass, VALUE str)
 {
-    ENTER(1);
-    char const *c_str;
-    Real *pv;
-
-    c_str = StringValueCStr(str);
-    GUARD_OBJ(pv, VpAlloc(0, c_str, 0, 1));
-    pv->obj = TypedData_Wrap_Struct(klass, &BigDecimal_data_type, pv);
-    RB_OBJ_FREEZE(pv->obj);
-    return pv->obj;
+    char const *c_str = StringValueCStr(str);
+    Real *vp = VpNewRbClass(0, c_str, klass, false, true);
+    if (!vp)
+        return Qnil;
+    else
+        return VpCheckGetValue(vp);
 }
 
  /* call-seq:
@@ -3079,7 +3755,7 @@ BigMath_s_exp(VALUE klass, VALUE x, VALUE vprec)
 	infinite = isinf(flo);
 	nan = isnan(flo);
 	if (!infinite && !nan) {
-	    vx = GetVpValueWithPrec(x, DBLE_FIG, 0);
+	    vx = GetVpValueWithPrec(x, 0, 0);
 	}
 	break;
 
@@ -3092,29 +3768,29 @@ BigMath_s_exp(VALUE klass, VALUE x, VALUE vprec)
     }
     if (infinite) {
 	if (negative) {
-	    return ToValue(GetVpValueWithPrec(INT2FIX(0), prec, 1));
+            return VpCheckGetValue(GetVpValueWithPrec(INT2FIX(0), prec, 1));
 	}
 	else {
 	    Real* vy;
-	    vy = VpCreateRbObject(prec, "#0");
+            vy = VpCreateRbObject(prec, "#0", true);
 	    VpSetInf(vy, VP_SIGN_POSITIVE_INFINITE);
 	    RB_GC_GUARD(vy->obj);
-	    return ToValue(vy);
+            return VpCheckGetValue(vy);
 	}
     }
     else if (nan) {
 	Real* vy;
-	vy = VpCreateRbObject(prec, "#0");
+        vy = VpCreateRbObject(prec, "#0", true);
 	VpSetNaN(vy);
 	RB_GC_GUARD(vy->obj);
-	return ToValue(vy);
+        return VpCheckGetValue(vy);
     }
     else if (vx == NULL) {
 	cannot_be_coerced_into_BigDecimal(rb_eArgError, x);
     }
     x = vx->obj;
 
-    n = prec + rmpd_double_figures();
+    n = prec + BIGDECIMAL_DOUBLE_FIGURES;
     negative = BIGDECIMAL_NEGATIVE_P(vx);
     if (negative) {
         VALUE x_zero = INT2NUM(1);
@@ -3124,7 +3800,7 @@ BigMath_s_exp(VALUE klass, VALUE x, VALUE vprec)
 	VpSetSign(vx, 1);
     }
 
-    one = ToValue(VpCreateRbObject(1, "1"));
+    one = VpCheckGetValue(VpCreateRbObject(1, "1", true));
     y   = one;
     d   = y;
     i   = 1;
@@ -3139,8 +3815,8 @@ BigMath_s_exp(VALUE klass, VALUE x, VALUE vprec)
 	if (m <= 0) {
 	    break;
 	}
-	else if ((size_t)m < rmpd_double_figures()) {
-	    m = rmpd_double_figures();
+	else if ((size_t)m < BIGDECIMAL_DOUBLE_FIGURES) {
+	    m = BIGDECIMAL_DOUBLE_FIGURES;
 	}
 
 	d = BigDecimal_mult(d, x);                             /* d <- d * x */
@@ -3232,7 +3908,7 @@ get_vp_value:
 	infinite = isinf(flo);
 	nan = isnan(flo);
 	if (!zero && !negative && !infinite && !nan) {
-	    vx = GetVpValueWithPrec(x, DBLE_FIG, 1);
+	    vx = GetVpValueWithPrec(x, 0, 1);
 	}
 	break;
 
@@ -3252,17 +3928,17 @@ get_vp_value:
     }
     if (infinite && !negative) {
 	Real* vy;
-	vy = VpCreateRbObject(prec, "#0");
+        vy = VpCreateRbObject(prec, "#0", true);
 	RB_GC_GUARD(vy->obj);
 	VpSetInf(vy, VP_SIGN_POSITIVE_INFINITE);
-	return ToValue(vy);
+        return VpCheckGetValue(vy);
     }
     else if (nan) {
 	Real* vy;
-	vy = VpCreateRbObject(prec, "#0");
+        vy = VpCreateRbObject(prec, "#0", true);
 	RB_GC_GUARD(vy->obj);
 	VpSetNaN(vy);
-	return ToValue(vy);
+        return VpCheckGetValue(vy);
     }
     else if (zero || negative) {
 	rb_raise(rb_eMathDomainError,
@@ -3271,18 +3947,18 @@ get_vp_value:
     else if (vx == NULL) {
 	cannot_be_coerced_into_BigDecimal(rb_eArgError, x);
     }
-    x = ToValue(vx);
+    x = VpCheckGetValue(vx);
 
-    RB_GC_GUARD(one) = ToValue(VpCreateRbObject(1, "1"));
-    RB_GC_GUARD(two) = ToValue(VpCreateRbObject(1, "2"));
+    RB_GC_GUARD(one) = VpCheckGetValue(VpCreateRbObject(1, "1", true));
+    RB_GC_GUARD(two) = VpCheckGetValue(VpCreateRbObject(1, "2", true));
 
-    n = prec + rmpd_double_figures();
+    n = prec + BIGDECIMAL_DOUBLE_FIGURES;
     RB_GC_GUARD(vn) = SSIZET2NUM(n);
     expo = VpExponent10(vx);
     if (expo < 0 || expo >= 3) {
 	char buf[DECIMAL_SIZE_OF_BITS(SIZEOF_VALUE * CHAR_BIT) + 4];
 	snprintf(buf, sizeof(buf), "1E%"PRIdVALUE, -expo);
-	x = BigDecimal_mult2(x, ToValue(VpCreateRbObject(1, buf)), vn);
+        x = BigDecimal_mult2(x, VpCheckGetValue(VpCreateRbObject(1, buf, true)), vn);
     }
     else {
 	expo = 0;
@@ -3300,8 +3976,8 @@ get_vp_value:
 	if (m <= 0) {
 	    break;
 	}
-	else if ((size_t)m < rmpd_double_figures()) {
-	    m = rmpd_double_figures();
+	else if ((size_t)m < BIGDECIMAL_DOUBLE_FIGURES) {
+	    m = BIGDECIMAL_DOUBLE_FIGURES;
 	}
 
 	x = BigDecimal_mult2(x2, x, vn);
@@ -3314,7 +3990,7 @@ get_vp_value:
     if (expo != 0) {
 	VALUE log10, vexpo, dy;
 	log10 = BigMath_s_log(klass, INT2FIX(10), vprec);
-	vexpo = ToValue(GetVpValue(SSIZET2NUM(expo), 1));
+        vexpo = VpCheckGetValue(GetVpValue(SSIZET2NUM(expo), 1));
 	dy = BigDecimal_mult(log10, vexpo);
 	y = BigDecimal_add(y, dy);
     }
@@ -3322,6 +3998,46 @@ get_vp_value:
     return y;
 }
 
+static VALUE BIGDECIMAL_NAN = Qnil;
+
+static VALUE
+BigDecimal_nan(void)
+{
+    return BIGDECIMAL_NAN;
+}
+
+static VALUE BIGDECIMAL_POSITIVE_INFINITY = Qnil;
+
+static VALUE
+BigDecimal_positive_infinity(void)
+{
+    return BIGDECIMAL_POSITIVE_INFINITY;
+}
+
+static VALUE BIGDECIMAL_NEGATIVE_INFINITY = Qnil;
+
+static VALUE
+BigDecimal_negative_infinity(void)
+{
+    return BIGDECIMAL_NEGATIVE_INFINITY;
+}
+
+static VALUE BIGDECIMAL_POSITIVE_ZERO = Qnil;
+
+static VALUE
+BigDecimal_positive_zero(void)
+{
+    return BIGDECIMAL_POSITIVE_ZERO;
+}
+
+static VALUE BIGDECIMAL_NEGATIVE_ZERO = Qnil;
+
+static VALUE
+BigDecimal_negative_zero(void)
+{
+    return BIGDECIMAL_NEGATIVE_ZERO;
+}
+
 /* Document-class: BigDecimal
  * BigDecimal provides arbitrary-precision floating point decimal arithmetic.
  *
@@ -3365,6 +4081,18 @@ get_vp_value:
  *
  *	(1.2 - 1.0) == 0.2 #=> false
  *
+ * == A Note About Precision
+ *
+ * For a calculation using a \BigDecimal and another +value+,
+ * the precision of the result depends on the type of +value+:
+ *
+ * - If +value+ is a \Float,
+ *   the precision is Float::DIG + 1.
+ * - If +value+ is a \Rational, the precision is larger than Float::DIG + 1.
+ * - If +value+ is a \BigDecimal, the precision is +value+'s precision in the
+ *   internal representation, which is platform-dependent.
+ * - If +value+ is other object, the precision is determined by the result of +BigDecimal(value)+.
+ *
  * == Special features of accurate decimal arithmetic
  *
  * Because BigDecimal is more accurate than normal binary floating point
@@ -3450,6 +4178,9 @@ get_vp_value:
 void
 Init_bigdecimal(void)
 {
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+    rb_ext_ractor_safe(true);
+#endif
     VALUE arg;
 
     id_BigDecimal_exception_mode = rb_intern_const("BigDecimal.exception_mode");
@@ -3590,17 +4321,40 @@ Init_bigdecimal(void)
     /* -3: Indicates that a value is negative and infinite. See BigDecimal.sign. */
     rb_define_const(rb_cBigDecimal, "SIGN_NEGATIVE_INFINITE", INT2FIX(VP_SIGN_NEGATIVE_INFINITE));
 
-    arg = rb_str_new2("+Infinity");
+    /* Positive zero value. */
+    arg = rb_str_new2("+0");
+    BIGDECIMAL_POSITIVE_ZERO = f_BigDecimal(1, &arg, rb_cBigDecimal);
+    rb_gc_register_mark_object(BIGDECIMAL_POSITIVE_ZERO);
+
+    /* Negative zero value. */
+    arg = rb_str_new2("-0");
+    BIGDECIMAL_NEGATIVE_ZERO = f_BigDecimal(1, &arg, rb_cBigDecimal);
+    rb_gc_register_mark_object(BIGDECIMAL_NEGATIVE_ZERO);
+
     /* Positive infinity value. */
-    rb_define_const(rb_cBigDecimal, "INFINITY", f_BigDecimal(1, &arg, rb_cBigDecimal));
-    arg = rb_str_new2("NaN");
+    arg = rb_str_new2("+Infinity");
+    BIGDECIMAL_POSITIVE_INFINITY = f_BigDecimal(1, &arg, rb_cBigDecimal);
+    rb_gc_register_mark_object(BIGDECIMAL_POSITIVE_INFINITY);
+
+    /* Negative infinity value. */
+    arg = rb_str_new2("-Infinity");
+    BIGDECIMAL_NEGATIVE_INFINITY = f_BigDecimal(1, &arg, rb_cBigDecimal);
+    rb_gc_register_mark_object(BIGDECIMAL_NEGATIVE_INFINITY);
+
     /* 'Not a Number' value. */
-    rb_define_const(rb_cBigDecimal, "NAN", f_BigDecimal(1, &arg, rb_cBigDecimal));
+    arg = rb_str_new2("NaN");
+    BIGDECIMAL_NAN = f_BigDecimal(1, &arg, rb_cBigDecimal);
+    rb_gc_register_mark_object(BIGDECIMAL_NAN);
 
+    /* Special value constants */
+    rb_define_const(rb_cBigDecimal, "INFINITY", BIGDECIMAL_POSITIVE_INFINITY);
+    rb_define_const(rb_cBigDecimal, "NAN", BIGDECIMAL_NAN);
 
     /* instance methods */
     rb_define_method(rb_cBigDecimal, "precs", BigDecimal_prec, 0);
     rb_define_method(rb_cBigDecimal, "precision", BigDecimal_precision, 0);
+    rb_define_method(rb_cBigDecimal, "scale", BigDecimal_scale, 0);
+    rb_define_method(rb_cBigDecimal, "precision_scale", BigDecimal_precision_scale, 0);
     rb_define_method(rb_cBigDecimal, "n_significant_digits", BigDecimal_n_significant_digits, 0);
 
     rb_define_method(rb_cBigDecimal, "add", BigDecimal_add2, 2);
@@ -3619,7 +4373,7 @@ Init_bigdecimal(void)
     rb_define_method(rb_cBigDecimal, "-@", BigDecimal_neg, 0);
     rb_define_method(rb_cBigDecimal, "*", BigDecimal_mult, 1);
     rb_define_method(rb_cBigDecimal, "/", BigDecimal_div, 1);
-    rb_define_method(rb_cBigDecimal, "quo", BigDecimal_div, 1);
+    rb_define_method(rb_cBigDecimal, "quo", BigDecimal_quo, -1);
     rb_define_method(rb_cBigDecimal, "%", BigDecimal_mod, 1);
     rb_define_method(rb_cBigDecimal, "modulo", BigDecimal_mod, 1);
     rb_define_method(rb_cBigDecimal, "remainder", BigDecimal_remainder, 1);
@@ -3710,14 +4464,17 @@ enum op_sw {
 
 static int VpIsDefOP(Real *c, Real *a, Real *b, enum op_sw sw);
 static int AddExponent(Real *a, SIGNED_VALUE n);
-static BDIGIT VpAddAbs(Real *a,Real *b,Real *c);
-static BDIGIT VpSubAbs(Real *a,Real *b,Real *c);
-static size_t VpSetPTR(Real *a, Real *b, Real *c, size_t *a_pos, size_t *b_pos, size_t *c_pos, BDIGIT *av, BDIGIT *bv);
+static DECDIG VpAddAbs(Real *a,Real *b,Real *c);
+static DECDIG VpSubAbs(Real *a,Real *b,Real *c);
+static size_t VpSetPTR(Real *a, Real *b, Real *c, size_t *a_pos, size_t *b_pos, size_t *c_pos, DECDIG *av, DECDIG *bv);
 static int VpNmlz(Real *a);
 static void VpFormatSt(char *psz, size_t fFmt);
 static int VpRdup(Real *m, size_t ind_m);
 
 #ifdef BIGDECIMAL_DEBUG
+# ifdef HAVE_RB_EXT_RACTOR_SAFE
+#  error Need to make rewiting gnAlloc atomic
+# endif
 static int gnAlloc = 0; /* Memory allocation counter */
 #endif /* BIGDECIMAL_DEBUG */
 
@@ -3725,9 +4482,6 @@ VP_EXPORT void *
 VpMemAlloc(size_t mb)
 {
     void *p = xmalloc(mb);
-    if (!p) {
-	VpException(VP_EXCEPTION_MEMORY, "failed to allocate memory", 1);
-    }
     memset(p, 0, mb);
 #ifdef BIGDECIMAL_DEBUG
     gnAlloc++; /* Count allocation call */
@@ -3738,11 +4492,7 @@ VpMemAlloc(size_t mb)
 VP_EXPORT void *
 VpMemRealloc(void *ptr, size_t mb)
 {
-    void *p = xrealloc(ptr, mb);
-    if (!p) {
-	VpException(VP_EXCEPTION_MEMORY, "failed to allocate memory", 1);
-    }
-    return p;
+    return xrealloc(ptr, mb);
 }
 
 VP_EXPORT void
@@ -3768,7 +4518,7 @@ VpFree(Real *pv)
  * EXCEPTION Handling.
  */
 
-#define rmpd_set_thread_local_exception_mode(mode) \
+#define bigdecimal_set_thread_local_exception_mode(mode) \
     rb_thread_local_aset( \
 	rb_thread_current(), \
 	id_BigDecimal_exception_mode, \
@@ -3784,8 +4534,8 @@ VpGetException (void)
     );
 
     if (NIL_P(vmode)) {
-	rmpd_set_thread_local_exception_mode(RMPD_EXCEPTION_MODE_DEFAULT);
-	return RMPD_EXCEPTION_MODE_DEFAULT;
+	bigdecimal_set_thread_local_exception_mode(BIGDECIMAL_EXCEPTION_MODE_DEFAULT);
+	return BIGDECIMAL_EXCEPTION_MODE_DEFAULT;
     }
 
     return NUM2USHORT(vmode);
@@ -3794,20 +4544,41 @@ VpGetException (void)
 static void
 VpSetException(unsigned short f)
 {
-    rmpd_set_thread_local_exception_mode(f);
+    bigdecimal_set_thread_local_exception_mode(f);
+}
+
+static void
+VpCheckException(Real *p, bool always)
+{
+    if (VpIsNaN(p)) {
+        VpException(VP_EXCEPTION_NaN, "Computation results in 'NaN' (Not a Number)", always);
+    }
+    else if (VpIsPosInf(p)) {
+        VpException(VP_EXCEPTION_INFINITY, "Computation results in 'Infinity'", always);
+    }
+    else if (VpIsNegInf(p)) {
+        VpException(VP_EXCEPTION_INFINITY, "Computation results in '-Infinity'", always);
+    }
+}
+
+static VALUE
+VpCheckGetValue(Real *p)
+{
+    VpCheckException(p, false);
+    return p->obj;
 }
 
 /*
  * Precision limit.
  */
 
-#define rmpd_set_thread_local_precision_limit(limit) \
+#define bigdecimal_set_thread_local_precision_limit(limit) \
     rb_thread_local_aset( \
 	rb_thread_current(), \
 	id_BigDecimal_precision_limit, \
 	SIZET2NUM(limit) \
     )
-#define RMPD_PRECISION_LIMIT_DEFAULT ((size_t)0)
+#define BIGDECIMAL_PRECISION_LIMIT_DEFAULT ((size_t)0)
 
 /* These 2 functions added at v1.1.7 */
 VP_EXPORT size_t
@@ -3819,8 +4590,8 @@ VpGetPrecLimit(void)
     );
 
     if (NIL_P(vlimit)) {
-	rmpd_set_thread_local_precision_limit(RMPD_PRECISION_LIMIT_DEFAULT);
-	return RMPD_PRECISION_LIMIT_DEFAULT;
+	bigdecimal_set_thread_local_precision_limit(BIGDECIMAL_PRECISION_LIMIT_DEFAULT);
+	return BIGDECIMAL_PRECISION_LIMIT_DEFAULT;
     }
 
     return NUM2SIZET(vlimit);
@@ -3830,7 +4601,7 @@ VP_EXPORT size_t
 VpSetPrecLimit(size_t n)
 {
     size_t const s = VpGetPrecLimit();
-    rmpd_set_thread_local_precision_limit(n);
+    bigdecimal_set_thread_local_precision_limit(n);
     return s;
 }
 
@@ -3838,7 +4609,7 @@ VpSetPrecLimit(size_t n)
  * Rounding mode.
  */
 
-#define rmpd_set_thread_local_rounding_mode(mode) \
+#define bigdecimal_set_thread_local_rounding_mode(mode) \
     rb_thread_local_aset( \
 	rb_thread_current(), \
 	id_BigDecimal_rounding_mode, \
@@ -3854,8 +4625,8 @@ VpGetRoundMode(void)
     );
 
     if (NIL_P(vmode)) {
-	rmpd_set_thread_local_rounding_mode(RMPD_ROUNDING_MODE_DEFAULT);
-	return RMPD_ROUNDING_MODE_DEFAULT;
+	bigdecimal_set_thread_local_rounding_mode(BIGDECIMAL_ROUNDING_MODE_DEFAULT);
+	return BIGDECIMAL_ROUNDING_MODE_DEFAULT;
     }
 
     return NUM2USHORT(vmode);
@@ -3883,7 +4654,7 @@ VP_EXPORT unsigned short
 VpSetRoundMode(unsigned short n)
 {
     if (VpIsRoundMode(n)) {
-	rmpd_set_thread_local_rounding_mode(n);
+	bigdecimal_set_thread_local_rounding_mode(n);
 	return n;
     }
 
@@ -3960,7 +4731,7 @@ VpException(unsigned short f, const char *str,int always)
 {
     unsigned short const exception_mode = VpGetException();
 
-    if (f == VP_EXCEPTION_OP || f == VP_EXCEPTION_MEMORY) always = 1;
+    if (f == VP_EXCEPTION_OP) always = 1;
 
     if (always || (exception_mode & f)) {
 	switch(f) {
@@ -3972,7 +4743,6 @@ VpException(unsigned short f, const char *str,int always)
 	  case VP_EXCEPTION_OP:
 	    rb_raise(rb_eFloatDomainError, "%s", str);
 	    break;
-	  case VP_EXCEPTION_MEMORY:
 	  default:
 	    rb_fatal("%s", str);
 	}
@@ -4121,13 +4891,13 @@ VpNumOfChars(Real *vp,const char *pszFmt)
  *   that BASE is as large as possible satisfying the
  *   relation MaxVal <= BASE*(BASE+1). Where the value
  *   MaxVal is the largest value which can be represented
- *   by one BDIGIT word in the computer used.
+ *   by one DECDIG word in the computer used.
  *
  * [Returns]
- *   DBLE_FIG   ... OK
+ *   BIGDECIMAL_DOUBLE_FIGURES  ... OK
  */
 VP_EXPORT size_t
-VpInit(BDIGIT BaseVal)
+VpInit(DECDIG BaseVal)
 {
     /* Setup +/- Inf  NaN -0 */
     VpGetDoubleNegZero();
@@ -4142,16 +4912,16 @@ VpInit(BDIGIT BaseVal)
 
 #ifdef BIGDECIMAL_DEBUG
     if (gfDebug) {
-	printf("VpInit: BaseVal   = %"PRIuBDIGIT"\n", BaseVal);
-	printf("\tBASE      = %"PRIuBDIGIT"\n", BASE);
-	printf("\tHALF_BASE = %"PRIuBDIGIT"\n", HALF_BASE);
-	printf("\tBASE1     = %"PRIuBDIGIT"\n", BASE1);
-	printf("\tBASE_FIG  = %u\n", BASE_FIG);
-	printf("\tDBLE_FIG  = %d\n", DBLE_FIG);
+        printf("VpInit: BaseVal = %"PRIuDECDIG"\n", BaseVal);
+        printf("\tBASE      = %"PRIuDECDIG"\n", BASE);
+        printf("\tHALF_BASE = %"PRIuDECDIG"\n", HALF_BASE);
+        printf("\tBASE1     = %"PRIuDECDIG"\n", BASE1);
+        printf("\tBASE_FIG  = %u\n", BASE_FIG);
+        printf("\tBIGDECIMAL_DOUBLE_FIGURES = %d\n", BIGDECIMAL_DOUBLE_FIGURES);
     }
 #endif /* BIGDECIMAL_DEBUG */
 
-    return rmpd_double_figures();
+    return BIGDECIMAL_DOUBLE_FIGURES;
 }
 
 VP_EXPORT Real *
@@ -4199,7 +4969,7 @@ overflow:
 }
 
 Real *
-rmpd_parse_special_string(const char *str)
+bigdecimal_parse_special_string(const char *str)
 {
     static const struct {
         const char *str;
@@ -4294,14 +5064,13 @@ VpAlloc(size_t mx, const char *szVal, int strict_p, int exc)
         /* at least mx digits. */
         /* szVal==NULL ==> allocate zero value. */
         vp = VpAllocReal(mx);
-        /* xmalloc() always returns(or throw interruption) */
         vp->MaxPrec = mx;    /* set max precision */
         VpSetZero(vp, 1);    /* initialize vp to zero. */
         return vp;
     }
 
     /* Check on Inf & NaN */
-    if ((vp = rmpd_parse_special_string(szVal)) != NULL) {
+    if ((vp = bigdecimal_parse_special_string(szVal)) != NULL) {
         return vp;
     }
 
@@ -4470,7 +5239,6 @@ VpAlloc(size_t mx, const char *szVal, int strict_p, int exc)
     nalloc = Max(nalloc, mx);
     mx = nalloc;
     vp = VpAllocReal(mx);
-    /* xmalloc() always returns(or throw interruption) */
     vp->MaxPrec = mx;        /* set max precision */
     VpSetZero(vp, sign);
     VpCtoV(vp, psz, ni, psz + ipf, nf, psz + ipe, ne);
@@ -4509,7 +5277,7 @@ VpAsgn(Real *c, Real *a, int isw)
 	VpSetSign(c, isw * VpGetSign(a));    /* set sign */
 	n = (a->Prec < c->MaxPrec) ? (a->Prec) : (c->MaxPrec);
 	c->Prec = n;
-	memcpy(c->frac, a->frac, n * sizeof(BDIGIT));
+        memcpy(c->frac, a->frac, n * sizeof(DECDIG));
 	/* Needs round ? */
 	if (isw != 10) {
 	    /* Not in ActiveRound */
@@ -4540,7 +5308,7 @@ VpAddSub(Real *c, Real *a, Real *b, int operation)
     short sw, isw;
     Real *a_ptr, *b_ptr;
     size_t n, na, nb, i;
-    BDIGIT mrv;
+    DECDIG mrv;
 
 #ifdef BIGDECIMAL_DEBUG
     if (gfDebug) {
@@ -4668,7 +5436,7 @@ end_if:
  * a and b assuming abs(a)>abs(b).
  *   c = abs(a) + abs(b) ; where |a|>=|b|
  */
-static BDIGIT
+static DECDIG
 VpAddAbs(Real *a, Real *b, Real *c)
 {
     size_t word_shift;
@@ -4678,7 +5446,7 @@ VpAddAbs(Real *a, Real *b, Real *c)
     size_t a_pos;
     size_t b_pos, b_pos_with_word_shift;
     size_t c_pos;
-    BDIGIT av, bv, carry, mrv;
+    DECDIG av, bv, carry, mrv;
 
 #ifdef BIGDECIMAL_DEBUG
     if (gfDebug) {
@@ -4763,7 +5531,7 @@ Exit:
 /*
  * c = abs(a) - abs(b)
  */
-static BDIGIT
+static DECDIG
 VpSubAbs(Real *a, Real *b, Real *c)
 {
     size_t word_shift;
@@ -4773,7 +5541,7 @@ VpSubAbs(Real *a, Real *b, Real *c)
     size_t a_pos;
     size_t b_pos, b_pos_with_word_shift;
     size_t c_pos;
-    BDIGIT av, bv, borrow, mrv;
+    DECDIG av, bv, borrow, mrv;
 
 #ifdef BIGDECIMAL_DEBUG
     if (gfDebug) {
@@ -4880,7 +5648,7 @@ Exit:
  *      c_pos      =      |
  */
 static size_t
-VpSetPTR(Real *a, Real *b, Real *c, size_t *a_pos, size_t *b_pos, size_t *c_pos, BDIGIT *av, BDIGIT *bv)
+VpSetPTR(Real *a, Real *b, Real *c, size_t *a_pos, size_t *b_pos, size_t *c_pos, DECDIG *av, DECDIG *bv)
 {
     size_t left_word, right_word, word_shift;
 
@@ -4995,8 +5763,8 @@ VpMult(Real *c, Real *a, Real *b)
     size_t MxIndA, MxIndB, MxIndAB, MxIndC;
     size_t ind_c, i, ii, nc;
     size_t ind_as, ind_ae, ind_bs;
-    BDIGIT carry;
-    BDIGIT_DBL s;
+    DECDIG carry;
+    DECDIG_DBL s;
     Real *w;
 
 #ifdef BIGDECIMAL_DEBUG
@@ -5050,7 +5818,7 @@ VpMult(Real *c, Real *a, Real *b)
     VpSetSign(c, VpGetSign(a) * VpGetSign(b));    /* set sign  */
     carry = 0;
     nc = ind_c = MxIndAB;
-    memset(c->frac, 0, (nc + 1) * sizeof(BDIGIT));        /* Initialize c  */
+    memset(c->frac, 0, (nc + 1) * sizeof(DECDIG));        /* Initialize c  */
     c->Prec = nc + 1;        /* set precision */
     for (nc = 0; nc < MxIndAB; ++nc, --ind_c) {
 	if (nc < MxIndB) {    /* The left triangle of the Fig. */
@@ -5070,15 +5838,15 @@ VpMult(Real *c, Real *a, Real *b)
 	}
 
 	for (i = ind_as; i <= ind_ae; ++i) {
-	    s = (BDIGIT_DBL)a->frac[i] * b->frac[ind_bs--];
-	    carry = (BDIGIT)(s / BASE);
-	    s -= (BDIGIT_DBL)carry * BASE;
-	    c->frac[ind_c] += (BDIGIT)s;
-	    if (c->frac[ind_c] >= BASE) {
-		s = c->frac[ind_c] / BASE;
-		carry += (BDIGIT)s;
-		c->frac[ind_c] -= (BDIGIT)(s * BASE);
-	    }
+            s = (DECDIG_DBL)a->frac[i] * b->frac[ind_bs--];
+            carry = (DECDIG)(s / BASE);
+            s -= (DECDIG_DBL)carry * BASE;
+            c->frac[ind_c] += (DECDIG)s;
+            if (c->frac[ind_c] >= BASE) {
+                s = c->frac[ind_c] / BASE;
+                carry += (DECDIG)s;
+                c->frac[ind_c] -= (DECDIG)(s * BASE);
+            }
 	    if (carry) {
 		ii = ind_c;
 		while (ii-- > 0) {
@@ -5124,9 +5892,9 @@ VpDivd(Real *c, Real *r, Real *a, Real *b)
     size_t word_a, word_b, word_c, word_r;
     size_t i, n, ind_a, ind_b, ind_c, ind_r;
     size_t nLoop;
-    BDIGIT_DBL q, b1, b1p1, b1b2, b1b2p1, r1r2;
-    BDIGIT borrow, borrow1, borrow2;
-    BDIGIT_DBL qb;
+    DECDIG_DBL q, b1, b1p1, b1b2, b1b2p1, r1r2;
+    DECDIG borrow, borrow1, borrow2;
+    DECDIG_DBL qb;
 
 #ifdef BIGDECIMAL_DEBUG
     if (gfDebug) {
@@ -5198,7 +5966,7 @@ VpDivd(Real *c, Real *r, Real *a, Real *b)
 	    ++ind_c;
 	    continue;
 	}
-	r1r2 = (BDIGIT_DBL)r->frac[ind_c] * BASE + r->frac[ind_c + 1];
+        r1r2 = (DECDIG_DBL)r->frac[ind_c] * BASE + r->frac[ind_c + 1];
 	if (r1r2 == b1b2) {
 	    /* The first two word digits is the same */
 	    ind_b = 2;
@@ -5235,17 +6003,17 @@ VpDivd(Real *c, Real *r, Real *a, Real *b)
 	/* The first two word digits is not the same, */
 	/* then compare magnitude, and divide actually. */
 	if (r1r2 >= b1b2p1) {
-	    q = r1r2 / b1b2p1;  /* q == (BDIGIT)q  */
-	    c->frac[ind_c] += (BDIGIT)q;
-	    ind_r = b->Prec + ind_c - 1;
-	    goto sub_mult;
+            q = r1r2 / b1b2p1;  /* q == (DECDIG)q  */
+            c->frac[ind_c] += (DECDIG)q;
+            ind_r = b->Prec + ind_c - 1;
+            goto sub_mult;
 	}
 
 div_b1p1:
-	if (ind_c + 1 >= word_c) goto out_side;
-	q = r1r2 / b1p1;  /* q == (BDIGIT)q */
-	c->frac[ind_c + 1] += (BDIGIT)q;
-	ind_r = b->Prec + ind_c;
+        if (ind_c + 1 >= word_c) goto out_side;
+        q = r1r2 / b1p1;  /* q == (DECDIG)q */
+        c->frac[ind_c + 1] += (DECDIG)q;
+        ind_r = b->Prec + ind_c;
 
 sub_mult:
 	borrow1 = borrow2 = 0;
@@ -5257,16 +6025,16 @@ sub_mult:
 	    qb = q * b->frac[ind_b];
 	    if (qb < BASE) borrow1 = 0;
 	    else {
-		borrow1 = (BDIGIT)(qb / BASE);
-		qb -= (BDIGIT_DBL)borrow1 * BASE;	/* get qb < BASE */
+                borrow1 = (DECDIG)(qb / BASE);
+                qb -= (DECDIG_DBL)borrow1 * BASE;	/* get qb < BASE */
 	    }
 	    if(r->frac[ind_r] < qb) {
-		r->frac[ind_r] += (BDIGIT)(BASE - qb);
-		borrow2 = borrow2 + borrow1 + 1;
+                r->frac[ind_r] += (DECDIG)(BASE - qb);
+                borrow2 = borrow2 + borrow1 + 1;
 	    }
 	    else {
-		r->frac[ind_r] -= (BDIGIT)qb;
-		borrow2 += borrow1;
+                r->frac[ind_r] -= (DECDIG)qb;
+                borrow2 += borrow1;
 	    }
 	    if (borrow2) {
 		if(r->frac[ind_r - 1] < borrow2) {
@@ -5348,9 +6116,9 @@ VpNmlz(Real *a)
 	    i = 0;
 	    while (a->frac[i] == 0) ++i;        /* skip the first few zeros */
 	    if (i) {
-		a->Prec -= i;
-		if (!AddExponent(a, -(SIGNED_VALUE)i)) return 0;
-		memmove(&a->frac[0], &a->frac[i], a->Prec*sizeof(BDIGIT));
+                a->Prec -= i;
+                if (!AddExponent(a, -(SIGNED_VALUE)i)) return 0;
+                memmove(&a->frac[0], &a->frac[i], a->Prec*sizeof(DECDIG));
 	    }
 	    return 1;
 	}
@@ -5473,7 +6241,7 @@ static int
 VPrint(FILE *fp, const char *cntl_chr, Real *a)
 {
     size_t i, j, nc, nd, ZeroSup, sep = 10;
-    BDIGIT m, e, nn;
+    DECDIG m, e, nn;
 
     j = 0;
     nd = nc = 0;        /*  nd : number of digits in fraction part(every 10 digits, */
@@ -5508,7 +6276,7 @@ VPrint(FILE *fp, const char *cntl_chr, Real *a)
 		case '0': case 'z':
 		    ZeroSup = 0;
 		    ++j;
-		    sep = cntl_chr[j] == 'z' ? RMPD_COMPONENT_FIGURES : 10;
+		    sep = cntl_chr[j] == 'z' ? BIGDECIMAL_COMPONENT_FIGURES : 10;
 		    break;
 		}
 		for (i = 0; i < a->Prec; ++i) {
@@ -5617,7 +6385,7 @@ VP_EXPORT void
 VpSzMantissa(Real *a,char *psz)
 {
     size_t i, n, ZeroSup;
-    BDIGIT_DBL m, e, nn;
+    DECDIG_DBL m, e, nn;
 
     if (VpIsNaN(a)) {
 	sprintf(psz, SZ_NaN);
@@ -5700,7 +6468,7 @@ VpToString(Real *a, char *psz, size_t fFmt, int fPlus)
 /* fPlus = 0: default, 1: set ' ' before digits, 2: set '+' before digits. */
 {
     size_t i, n, ZeroSup;
-    BDIGIT shift, m, e, nn;
+    DECDIG shift, m, e, nn;
     char *pszSav = psz;
     ssize_t ex;
 
@@ -5748,7 +6516,7 @@ VpToFString(Real *a, char *psz, size_t fFmt, int fPlus)
 /* fPlus = 0: default, 1: set ' ' before digits, 2: set '+' before digits. */
 {
     size_t i, n;
-    BDIGIT m, e, nn;
+    DECDIG m, e, nn;
     char *pszSav = psz;
     ssize_t ex;
 
@@ -5823,7 +6591,7 @@ VpCtoV(Real *a, const char *int_chr, size_t ni, const char *frac, size_t nf, con
     me = ne;
     signe = 1;
     exponent_overflow = 0;
-    memset(a->frac, 0, ma * sizeof(BDIGIT));
+    memset(a->frac, 0, ma * sizeof(DECDIG));
     if (ne > 0) {
 	i = 0;
 	if (exp_chr[0] == '-') {
@@ -5960,7 +6728,7 @@ Final:
  * [Output]
  *   *d  ... fraction part of m(d = 0.xxxxxxx). where # of 'x's is fig.
  *   *e  ... exponent of m.
- * DBLE_FIG ... Number of digits in a double variable.
+ * BIGDECIMAL_DOUBLE_FIGURES ... Number of digits in a double variable.
  *
  *  m -> d*10**e, 0<d<BASE
  * [Returns]
@@ -6007,7 +6775,7 @@ VpVtoD(double *d, SIGNED_VALUE *e, Real *m)
 	goto Exit;
     }
     /* Normal number */
-    fig = (DBLE_FIG + BASE_FIG - 1) / BASE_FIG;
+    fig = roomof(BIGDECIMAL_DOUBLE_FIGURES, BASE_FIG);
     ind_m = 0;
     mm = Min(fig, m->Prec);
     *d = 0.0;
@@ -6024,7 +6792,7 @@ Exit:
     if (gfDebug) {
 	VPrint(stdout, " VpVtoD: m=%\n", m);
 	printf("   d=%e * 10 **%ld\n", *d, *e);
-	printf("   DBLE_FIG = %d\n", DBLE_FIG);
+	printf("   BIGDECIMAL_DOUBLE_FIGURES = %d\n", BIGDECIMAL_DOUBLE_FIGURES);
     }
 #endif /*BIGDECIMAL_DEBUG */
     return f;
@@ -6038,7 +6806,7 @@ VpDtoV(Real *m, double d)
 {
     size_t ind_m, mm;
     SIGNED_VALUE ne;
-    BDIGIT i;
+    DECDIG i;
     double  val, val2;
 
     if (isnan(d)) {
@@ -6073,12 +6841,12 @@ VpDtoV(Real *m, double d)
     /* Now val = 0.xxxxx*BASE**ne */
 
     mm = m->MaxPrec;
-    memset(m->frac, 0, mm * sizeof(BDIGIT));
+    memset(m->frac, 0, mm * sizeof(DECDIG));
     for (ind_m = 0; val > 0.0 && ind_m < mm; ind_m++) {
-	val *= (double)BASE;
-	i = (BDIGIT)val;
-	val -= (double)i;
-	m->frac[ind_m] = i;
+        val *= (double)BASE;
+        i = (DECDIG)val;
+        val -= (double)i;
+        m->frac[ind_m] = i;
     }
     if (ind_m >= mm) ind_m = mm - 1;
     VpSetSign(m, (d > 0.0) ? 1 : -1);
@@ -6086,7 +6854,7 @@ VpDtoV(Real *m, double d)
     m->exponent = ne;
 
     VpInternalRound(m, 0, (m->Prec > 0) ? m->frac[m->Prec-1] : 0,
-		    (BDIGIT)(val*(double)BASE));
+                    (DECDIG)(val*(double)BASE));
 
 Exit:
 #ifdef BIGDECIMAL_DEBUG
@@ -6225,7 +6993,7 @@ VpSqrt(Real *y, Real *x)
     }
     VpDtoV(y, sqrt(val));    /* y <- sqrt(val) */
     y->exponent += n;
-    n = (SIGNED_VALUE)((DBLE_FIG + BASE_FIG - 1) / BASE_FIG);
+    n = (SIGNED_VALUE)roomof(BIGDECIMAL_DOUBLE_FIGURES, BASE_FIG);
     y->MaxPrec = Min((size_t)n , y_prec);
     f->MaxPrec = y->MaxPrec + 1;
     n = (SIGNED_VALUE)(y_prec * BASE_FIG);
@@ -6282,8 +7050,8 @@ VpMidRound(Real *y, unsigned short f, ssize_t nf)
     /* exptoadd: number of digits needed to compensate negative nf */
     int fracf, fracf_1further;
     ssize_t n,i,ix,ioffset, exptoadd;
-    BDIGIT v, shifter;
-    BDIGIT div;
+    DECDIG v, shifter;
+    DECDIG div;
 
     nf += y->exponent * (ssize_t)BASE_FIG;
     exptoadd=0;
@@ -6305,8 +7073,8 @@ VpMidRound(Real *y, unsigned short f, ssize_t nf)
     n = (ssize_t)BASE_FIG - ioffset - 1;
     for (shifter = 1, i = 0; i < n; ++i) shifter *= 10;
 
-    /* so the representation used (in y->frac) is an array of BDIGIT, where
-       each BDIGIT contains a value between 0 and BASE-1, consisting of BASE_FIG
+    /* so the representation used (in y->frac) is an array of DECDIG, where
+       each DECDIG contains a value between 0 and BASE-1, consisting of BASE_FIG
        decimal places.
 
        (that numbers of decimal places are typed as ssize_t is somewhat confusing)
@@ -6314,10 +7082,10 @@ VpMidRound(Real *y, unsigned short f, ssize_t nf)
        nf is now position (in decimal places) of the digit from the start of
        the array.
 
-       ix is the position (in BDIGITS) of the BDIGIT containing the decimal digit,
+       ix is the position (in DECDIGs) of the DECDIG containing the decimal digit,
        from the start of the array.
 
-       v is the value of this BDIGIT
+       v is the value of this DECDIG
 
        ioffset is the number of extra decimal places along of this decimal digit
        within v.
@@ -6343,7 +7111,7 @@ VpMidRound(Real *y, unsigned short f, ssize_t nf)
        now fracf_1further is whether any of the remaining digits within v are non-zero
        */
 
-    /* now check all the remaining BDIGITS for zero-ness a whole BDIGIT at a time.
+    /* now check all the remaining DECDIGs for zero-ness a whole DECDIG at a time.
        if we spot any non-zeroness, that means that we found a positive digit under
        rounding position, and we also found a positive digit under one further than
        the rounding position, so both searches (to see if any such non-zero digit exists)
@@ -6362,7 +7130,7 @@ VpMidRound(Real *y, unsigned short f, ssize_t nf)
        now v = the first digit under the rounding position */
 
     /* drop digits after pointed digit */
-    memset(y->frac + ix + 1, 0, (y->Prec - (ix + 1)) * sizeof(BDIGIT));
+    memset(y->frac + ix + 1, 0, (y->Prec - (ix + 1)) * sizeof(DECDIG));
 
     switch (f) {
       case VP_ROUND_DOWN: /* Truncate */
@@ -6390,11 +7158,11 @@ VpMidRound(Real *y, unsigned short f, ssize_t nf)
 	    }
 	    else {
 		if (ioffset == 0) {
-		    /* v is the first decimal digit of its BDIGIT;
-		       need to grab the previous BDIGIT if present
-		       to check for evenness of the previous decimal
-		       digit (which is same as that of the BDIGIT since
-		       base 10 has a factor of 2) */
+                    /* v is the first decimal digit of its DECDIG;
+                       need to grab the previous DECDIG if present
+                       to check for evenness of the previous decimal
+                       digit (which is same as that of the DECDIG since
+                       base 10 has a factor of 2) */
 		    if (ix && (y->frac[ix-1] % 2)) ++div;
 		}
 		else {
@@ -6442,7 +7210,7 @@ VpLeftRound(Real *y, unsigned short f, ssize_t nf)
  * Round from the left hand side of the digits.
  */
 {
-    BDIGIT v;
+    DECDIG v;
     if (!VpHasVal(y)) return 0; /* Unable to round */
     v = y->frac[0];
     nf -= VpExponent(y) * (ssize_t)BASE_FIG;
@@ -6473,7 +7241,7 @@ VpLimitRound(Real *c, size_t ixDigit)
 /* If I understand correctly, this is only ever used to round off the final decimal
    digit of precision */
 static void
-VpInternalRound(Real *c, size_t ixDigit, BDIGIT vPrev, BDIGIT v)
+VpInternalRound(Real *c, size_t ixDigit, DECDIG vPrev, DECDIG v)
 {
     int f = 0;
 
@@ -6523,7 +7291,7 @@ VpInternalRound(Real *c, size_t ixDigit, BDIGIT vPrev, BDIGIT v)
 static int
 VpRdup(Real *m, size_t ind_m)
 {
-    BDIGIT carry;
+    DECDIG carry;
 
     if (!ind_m) ind_m = m->Prec;
 
@@ -6595,7 +7363,7 @@ Exit:
  *   y = x ** n
  */
 VP_EXPORT int
-VpPower(Real *y, Real *x, SIGNED_VALUE n)
+VpPowerByInt(Real *y, Real *x, SIGNED_VALUE n)
 {
     size_t s, ss;
     ssize_t sign;
@@ -6682,8 +7450,8 @@ VpPower(Real *y, Real *x, SIGNED_VALUE n)
 Exit:
 #ifdef BIGDECIMAL_DEBUG
     if (gfDebug) {
-	VPrint(stdout, "VpPower y=%\n", y);
-	VPrint(stdout, "VpPower x=%\n", x);
+	VPrint(stdout, "VpPowerByInt y=%\n", y);
+	VPrint(stdout, "VpPowerByInt x=%\n", x);
 	printf("  n=%"PRIdVALUE"\n", n);
     }
 #endif /* BIGDECIMAL_DEBUG */
@@ -6718,12 +7486,12 @@ VpVarCheck(Real * v)
     }
     for (i = 0; i < v->Prec; ++i) {
 	if (v->frac[i] >= BASE) {
-	    printf("ERROR(VpVarCheck): Illegal fraction\n");
-	    printf("       Frac[%"PRIuSIZE"]=%"PRIuBDIGIT"\n", i, v->frac[i]);
-	    printf("       Prec.   =%"PRIuSIZE"\n", v->Prec);
-	    printf("       Exp. =%"PRIdVALUE"\n", v->exponent);
-	    printf("       BASE =%"PRIuBDIGIT"\n", BASE);
-	    return 3;
+            printf("ERROR(VpVarCheck): Illegal fraction\n");
+            printf("       Frac[%"PRIuSIZE"]=%"PRIuDECDIG"\n", i, v->frac[i]);
+            printf("       Prec.   =%"PRIuSIZE"\n", v->Prec);
+            printf("       Exp. =%"PRIdVALUE"\n", v->exponent);
+            printf("       BASE =%"PRIuDECDIG"\n", BASE);
+            return 3;
 	}
     }
     return 0;