bigdecimal 3.1.8 → 4.1.2

data/ext/bigdecimal/bigdecimal.c

@@ -29,18 +29,29 @@
 #endif
 
 #include "bits.h"
+#include "ntt.h"
+#include "div.h"
 #include "static_assert.h"
 
-#define BIGDECIMAL_VERSION "3.1.8"
-
-/* #define ENABLE_NUMERIC_STRING */
+#define BIGDECIMAL_VERSION "4.1.2"
 
+/* Make sure VPMULT_BATCH_SIZE*BASE*BASE does not overflow DECDIG_DBL */
+#define VPMULT_BATCH_SIZE 16
+#define NTT_MULTIPLICATION_THRESHOLD 450
+#define NEWTON_RAPHSON_DIVISION_THRESHOLD 100
 #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)
+#define ADD_OVERFLOW_SIGNED_VALUE_P(a, b) ADD_OVERFLOW_SIGNED_INTEGER_P(a, b, SIGNED_VALUE_MIN, SIGNED_VALUE_MAX)
+
+/* max_value = 0.9999_9999_9999E[exponent], exponent <= SIGNED_VALUE_MAX */
+#define VP_EXPONENT_MAX (SIGNED_VALUE_MAX / BASE_FIG)
+/* min_value = 0.0001_0000_0000E[exponent], exponent-(BASE_FIG-1) >= SIGNED_VALUE_MIN */
+#define VP_EXPONENT_MIN ((SIGNED_VALUE_MIN + BASE_FIG - 1) / BASE_FIG)
+#define EXPONENT_MAX (VP_EXPONENT_MAX * BASE_FIG)
+#define EXPONENT_MIN (VP_EXPONENT_MIN * BASE_FIG - (BASE_FIG - 1))
 
 VALUE rb_cBigDecimal;
-VALUE rb_mBigMath;
 
 static ID id_BigDecimal_exception_mode;
 static ID id_BigDecimal_rounding_mode;
@@ -68,15 +79,18 @@ static struct {
     uint8_t mode;
 } rbd_rounding_modes[RBD_NUM_ROUNDING_MODES];
 
-/* 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))
+static inline BDVALUE
+bdvalue_nonnullable(NULLABLE_BDVALUE v)
+{
+    assert(v.real_or_null != NULL);
+    return (BDVALUE) { v.bigdecimal_or_nil, v.real_or_null };
+}
+
+static inline NULLABLE_BDVALUE
+bdvalue_nullable(BDVALUE v)
+{
+    return (NULLABLE_BDVALUE) { v.bigdecimal, v.real };
+}
 
 #define BASE_FIG  BIGDECIMAL_COMPONENT_FIGURES
 #define BASE      BIGDECIMAL_BASE
@@ -84,31 +98,6 @@ static struct {
 #define HALF_BASE (BASE/2)
 #define BASE1 (BASE/10)
 
-#define LOG10_2 0.3010299956639812
-
-#ifndef RRATIONAL_ZERO_P
-# define RRATIONAL_ZERO_P(x) (FIXNUM_P(rb_rational_num(x)) && \
-			      FIX2LONG(rb_rational_num(x)) == 0)
-#endif
-
-#ifndef RRATIONAL_NEGATIVE_P
-# define RRATIONAL_NEGATIVE_P(x) RTEST(rb_funcall((x), '<', 1, INT2FIX(0)))
-#endif
-
-#ifndef DECIMAL_SIZE_OF_BITS
-#define DECIMAL_SIZE_OF_BITS(n) (((n) * 3010 + 9998) / 9999)
-/* an approximation of ceil(n * log10(2)), upto 65536 at least */
-#endif
-
-#ifdef PRIsVALUE
-# define RB_OBJ_CLASSNAME(obj) rb_obj_class(obj)
-# define RB_OBJ_STRING(obj) (obj)
-#else
-# define PRIsVALUE "s"
-# define RB_OBJ_CLASSNAME(obj) rb_obj_classname(obj)
-# define RB_OBJ_STRING(obj) StringValueCStr(obj)
-#endif
-
 #ifndef MAYBE_UNUSED
 # define MAYBE_UNUSED(x) x
 #endif
@@ -145,6 +134,17 @@ check_allocation_count_nonzero(void)
 #   define check_allocation_count_nonzero() /* nothing */
 #endif /* BIGDECIMAL_DEBUG */
 
+/* VpMult VpDivd helpers */
+#define VPMULT_RESULT_PREC(a, b) (a->Prec + b->Prec)
+/* To calculate VpDivd with n-digits precision, quotient needs n+2*BASE_FIG-1 digits space */
+/* In the worst precision case 0001_1111_1111 / 9999 = 0000_0001_1112, there are 2*BASE_FIG-1 leading zeros */
+#define VPDIVD_QUO_DIGITS(required_digits) ((required_digits) + 2 * BASE_FIG - 1)
+/* Required r.MaxPrec for calculating VpDivd(c, r, a, b) */
+#define VPDIVD_REM_PREC(a, b, c) Max(a->Prec, b->Prec + c->MaxPrec - 1)
+
+static NULLABLE_BDVALUE
+CreateFromString(const char *str, VALUE klass, bool strict_p, bool raise_exception);
+
 PUREFUNC(static inline size_t rbd_struct_size(size_t const));
 
 static inline size_t
@@ -154,118 +154,6 @@ rbd_struct_size(size_t const internal_digits)
     return offsetof(Real, frac) + frac_len * sizeof(DECDIG);
 }
 
-static inline Real *
-rbd_allocate_struct(size_t const internal_digits)
-{
-    size_t const size = rbd_struct_size(internal_digits);
-    Real *real = ruby_xcalloc(1, size);
-    atomic_allocation_count_inc();
-    real->MaxPrec = internal_digits;
-    return real;
-}
-
-static size_t
-rbd_calculate_internal_digits(size_t const digits, bool limit_precision)
-{
-    size_t const len = roomof(digits, BASE_FIG);
-    if (limit_precision) {
-        size_t const prec_limit = VpGetPrecLimit();
-        if (prec_limit > 0) {
-            /* NOTE: 2 more digits for rounding and division */
-            size_t const max_len = roomof(prec_limit, BASE_FIG) + 2;
-            if (len > max_len)
-                return max_len;
-        }
-    }
-
-    return len;
-}
-
-static inline Real *
-rbd_allocate_struct_decimal_digits(size_t const decimal_digits, bool limit_precision)
-{
-    size_t const internal_digits = rbd_calculate_internal_digits(decimal_digits, limit_precision);
-    return rbd_allocate_struct(internal_digits);
-}
-
-static VALUE BigDecimal_wrap_struct(VALUE obj, Real *vp);
-
-static Real *
-rbd_reallocate_struct(Real *real, size_t const internal_digits)
-{
-    size_t const size = rbd_struct_size(internal_digits);
-    VALUE obj = real ? real->obj : 0;
-    Real *new_real = (Real *)ruby_xrealloc(real, size);
-    new_real->MaxPrec = internal_digits;
-    if (obj) {
-        new_real->obj = 0;
-        BigDecimal_wrap_struct(obj, new_real);
-    }
-    return new_real;
-}
-
-static void
-rbd_free_struct(Real *real)
-{
-    if (real != NULL) {
-        check_allocation_count_nonzero();
-        ruby_xfree(real);
-        atomic_allocation_count_dec_nounderflow();
-    }
-}
-
-#define NewZero rbd_allocate_struct_zero
-static Real *
-rbd_allocate_struct_zero(int sign, size_t const digits, bool limit_precision)
-{
-    Real *real = rbd_allocate_struct_decimal_digits(digits, limit_precision);
-    VpSetZero(real, sign);
-    return real;
-}
-
-MAYBE_UNUSED(static inline Real * rbd_allocate_struct_zero_limited(int sign, size_t const digits));
-#define NewZeroLimited rbd_allocate_struct_zero_limited
-static inline Real *
-rbd_allocate_struct_zero_limited(int sign, size_t const digits)
-{
-    return rbd_allocate_struct_zero(sign, digits, true);
-}
-
-MAYBE_UNUSED(static inline Real * rbd_allocate_struct_zero_nolimit(int sign, size_t const digits));
-#define NewZeroNolimit rbd_allocate_struct_zero_nolimit
-static inline Real *
-rbd_allocate_struct_zero_nolimit(int sign, size_t const digits)
-{
-    return rbd_allocate_struct_zero(sign, digits, false);
-}
-
-#define NewOne rbd_allocate_struct_one
-static Real *
-rbd_allocate_struct_one(int sign, size_t const digits, bool limit_precision)
-{
-    Real *real = rbd_allocate_struct_decimal_digits(digits, limit_precision);
-    VpSetOne(real);
-    if (sign < 0)
-        VpSetSign(real, VP_SIGN_NEGATIVE_FINITE);
-    return real;
-}
-
-MAYBE_UNUSED(static inline Real * rbd_allocate_struct_one_limited(int sign, size_t const digits));
-#define NewOneLimited rbd_allocate_struct_one_limited
-static inline Real *
-rbd_allocate_struct_one_limited(int sign, size_t const digits)
-{
-    return rbd_allocate_struct_one(sign, digits, true);
-}
-
-MAYBE_UNUSED(static inline Real * rbd_allocate_struct_one_nolimit(int sign, size_t const digits));
-#define NewOneNolimit rbd_allocate_struct_one_nolimit
-static inline Real *
-rbd_allocate_struct_one_nolimit(int sign, size_t const digits)
-{
-    return rbd_allocate_struct_one(sign, digits, false);
-}
-
 /*
  * ================== Ruby Interface part ==========================
  */
@@ -277,10 +165,9 @@ rbd_allocate_struct_one_nolimit(int sign, size_t const digits)
 static unsigned short VpGetException(void);
 static void  VpSetException(unsigned short f);
 static void VpCheckException(Real *p, bool always);
-static VALUE VpCheckGetValue(Real *p);
+static VALUE CheckGetValue(BDVALUE v);
 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);
 static int VPrint(FILE *fp,const char *cntl_chr,Real *a);
 
 /*
@@ -292,85 +179,81 @@ 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 VALUE BigDecimal_addsub_with_coerce(VALUE self, VALUE r, size_t prec, int operation);
+static VALUE BigDecimal_mult_with_coerce(VALUE self, VALUE r, size_t prec);
 
-static void
-BigDecimal_delete(void *pv)
-{
-    rbd_free_struct(pv);
-}
+#ifndef HAVE_RB_EXT_RACTOR_SAFE
+#   undef RUBY_TYPED_FROZEN_SHAREABLE
+#   define RUBY_TYPED_FROZEN_SHAREABLE 0
+#endif
+
+#ifdef RUBY_TYPED_EMBEDDABLE
+#  define HAVE_RUBY_TYPED_EMBEDDABLE 1
+#else
+# ifdef HAVE_CONST_RUBY_TYPED_EMBEDDABLE
+#  define RUBY_TYPED_EMBEDDABLE RUBY_TYPED_EMBEDDABLE
+#  define HAVE_RUBY_TYPED_EMBEDDABLE 1
+# else
+#  define RUBY_TYPED_EMBEDDABLE 0
+# endif
+#endif
 
 static size_t
 BigDecimal_memsize(const void *ptr)
 {
+#ifdef HAVE_RUBY_TYPED_EMBEDDABLE
+    return 0; // Entirely embedded
+#else
     const Real *pv = ptr;
     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 | RUBY_TYPED_FROZEN_SHAREABLE | RUBY_TYPED_WB_PROTECTED
-#endif
+    .wrap_struct_name = "BigDecimal",
+    .function = {
+        .dmark = 0,
+        .dfree = RUBY_DEFAULT_FREE,
+        .dsize = BigDecimal_memsize,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE,
 };
 
-static Real *
-rbd_allocate_struct_zero_wrap_klass(VALUE klass, int sign, size_t const digits, bool limit_precision)
-{
-    Real *real = rbd_allocate_struct_zero(sign, digits, limit_precision);
-    if (real != NULL) {
-        VALUE obj = TypedData_Wrap_Struct(klass, &BigDecimal_data_type, 0);
-        BigDecimal_wrap_struct(obj, real);
-    }
-    return real;
-}
-
-MAYBE_UNUSED(static inline Real * rbd_allocate_struct_zero_limited_wrap(int sign, size_t const digits));
-#define NewZeroWrapLimited rbd_allocate_struct_zero_limited_wrap
-static inline Real *
-rbd_allocate_struct_zero_limited_wrap(int sign, size_t const digits)
+static VALUE
+BigDecimal_allocate(size_t const internal_digits)
 {
-    return rbd_allocate_struct_zero_wrap_klass(rb_cBigDecimal, sign, digits, true);
+    const size_t size = rbd_struct_size(internal_digits);
+    VALUE bd = rb_data_typed_object_zalloc(rb_cBigDecimal, size, &BigDecimal_data_type);
+    Real *vp;
+    TypedData_Get_Struct(bd, Real, &BigDecimal_data_type, vp);
+    vp->MaxPrec = internal_digits;
+    RB_OBJ_FREEZE(bd);
+    return bd;
 }
 
-MAYBE_UNUSED(static inline Real * rbd_allocate_struct_zero_nolimit_wrap(int sign, size_t const digits));
-#define NewZeroWrapNolimit rbd_allocate_struct_zero_nolimit_wrap
-static inline Real *
-rbd_allocate_struct_zero_nolimit_wrap(int sign, size_t const digits)
+static VALUE
+BigDecimal_allocate_decimal_digits(size_t const decimal_digits)
 {
-    return rbd_allocate_struct_zero_wrap_klass(rb_cBigDecimal, sign, digits, false);
+    return BigDecimal_allocate(roomof(decimal_digits, BASE_FIG));
 }
 
 static Real *
-rbd_allocate_struct_one_wrap_klass(VALUE klass, int sign, size_t const digits, bool limit_precision)
-{
-    Real *real = rbd_allocate_struct_one(sign, digits, limit_precision);
-    if (real != NULL) {
-        VALUE obj = TypedData_Wrap_Struct(klass, &BigDecimal_data_type, 0);
-        BigDecimal_wrap_struct(obj, real);
-    }
-    return real;
-}
-
-MAYBE_UNUSED(static inline Real * rbd_allocate_struct_one_limited_wrap(int sign, size_t const digits));
-#define NewOneWrapLimited rbd_allocate_struct_one_limited_wrap
-static inline Real *
-rbd_allocate_struct_one_limited_wrap(int sign, size_t const digits)
+VpPtr(VALUE obj)
 {
-    return rbd_allocate_struct_one_wrap_klass(rb_cBigDecimal, sign, digits, true);
+    Real *vp;
+    TypedData_Get_Struct(obj, Real, &BigDecimal_data_type, vp);
+    return vp;
 }
 
-MAYBE_UNUSED(static inline Real * rbd_allocate_struct_one_nolimit_wrap(int sign, size_t const digits));
-#define NewOneWrapNolimit rbd_allocate_struct_one_nolimit_wrap
-static inline Real *
-rbd_allocate_struct_one_nolimit_wrap(int sign, size_t const digits)
+MAYBE_UNUSED(static inline BDVALUE rbd_allocate_struct_zero_wrap(int sign, size_t const digits));
+#define NewZeroWrap rbd_allocate_struct_zero_wrap
+static BDVALUE
+rbd_allocate_struct_zero_wrap(int sign, size_t const digits)
 {
-    return rbd_allocate_struct_one_wrap_klass(rb_cBigDecimal, sign, digits, false);
+    VALUE obj = BigDecimal_allocate_decimal_digits(digits);
+    Real *real = VpPtr(obj);
+    VpSetZero(real, sign);
+    return (BDVALUE) { obj, real };
 }
 
 static inline int
@@ -398,24 +281,22 @@ 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_inum_convert_to_BigDecimal(VALUE val);
 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_cstr_convert_to_BigDecimal(const char *c_str, 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)
+static NULLABLE_BDVALUE
+GetBDValueWithPrecInternal(VALUE v, size_t prec, int must)
 {
-    const size_t digs = prec < 0 ? SIZE_MAX : (size_t)prec;
-
     switch(TYPE(v)) {
       case T_FLOAT:
-        v = rb_float_convert_to_BigDecimal(v, digs, must);
+        v = rb_float_convert_to_BigDecimal(v, 0, true);
         break;
 
       case T_RATIONAL:
-        v = rb_rational_convert_to_BigDecimal(v, digs, must);
+        v = rb_rational_convert_to_BigDecimal(v, prec, true);
         break;
 
       case T_DATA:
@@ -424,25 +305,9 @@ GetVpValueWithPrec(VALUE v, long prec, int must)
         }
         break;
 
-      case T_FIXNUM: {
-        char szD[128];
-        snprintf(szD, 128, "%ld", FIX2LONG(v));
-        v = rb_cstr_convert_to_BigDecimal(szD, VpBaseFig() * 2 + 1, must);
-        break;
-      }
-
-#ifdef ENABLE_NUMERIC_STRING
-      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_FIXNUM:
       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);
+        v = rb_inum_convert_to_BigDecimal(v);
         break;
       }
 
@@ -450,21 +315,40 @@ GetVpValueWithPrec(VALUE v, long prec, int must)
 	goto SomeOneMayDoIt;
     }
 
-    Real *vp;
-    TypedData_Get_Struct(v, Real, &BigDecimal_data_type, vp);
-    return vp;
+    Real *vp = VpPtr(v);
+    return (NULLABLE_BDVALUE) { v, vp };
 
 SomeOneMayDoIt:
     if (must) {
 	cannot_be_coerced_into_BigDecimal(rb_eTypeError, v);
     }
-    return NULL; /* NULL means to coerce */
+    return (NULLABLE_BDVALUE) { Qnil, NULL }; /* NULL means to coerce */
+}
+
+static inline NULLABLE_BDVALUE
+GetBDValueWithPrec(VALUE v, size_t prec)
+{
+    return GetBDValueWithPrecInternal(v, prec, 0);
+}
+
+
+static inline BDVALUE
+GetBDValueWithPrecMust(VALUE v, size_t prec)
+{
+    return bdvalue_nonnullable(GetBDValueWithPrecInternal(v, prec, 1));
 }
 
+// self must be a receiver of BigDecimal instance method or a gc guarded BigDecimal object.
 static inline Real*
-GetVpValue(VALUE v, int must)
+GetSelfVpValue(VALUE self)
+{
+    return GetBDValueWithPrecMust(self, 0).real;
+}
+
+static inline BDVALUE
+GetBDValueMust(VALUE v)
 {
-    return GetVpValueWithPrec(v, -1, must);
+    return GetBDValueWithPrecMust(v, 0);
 }
 
 /* call-seq:
@@ -479,49 +363,14 @@ GetVpValue(VALUE v, int must)
 static inline VALUE
 BigDecimal_double_fig(VALUE self)
 {
-    return INT2FIX(VpDblFig());
-}
-
-/*  call-seq:
- *    precs -> array
- *
- *  Returns an Array of two Integer values that represent platform-dependent
- *  internal storage properties.
- *
- *  This method is deprecated and will be removed in the future.
- *  Instead, use BigDecimal#n_significant_digits for obtaining the number of
- *  significant digits in scientific notation, and BigDecimal#precision for
- *  obtaining the number of digits in decimal notation.
- *
- */
-
-static VALUE
-BigDecimal_prec(VALUE self)
-{
-    ENTER(1);
-    Real *p;
-    VALUE obj;
-
-    rb_category_warn(RB_WARN_CATEGORY_DEPRECATED,
-                     "BigDecimal#precs is deprecated and will be removed in the future; "
-                     "use BigDecimal#precision instead.");
-
-    GUARD_OBJ(p, GetVpValue(self, 1));
-    obj = rb_assoc_new(SIZET2NUM(p->Prec*VpBaseFig()),
-		       SIZET2NUM(p->MaxPrec*VpBaseFig()));
-    return obj;
+    return INT2FIX(BIGDECIMAL_DOUBLE_FIGURES);
 }
 
 static void
-BigDecimal_count_precision_and_scale(VALUE self, ssize_t *out_precision, ssize_t *out_scale)
+VpCountPrecisionAndScale(Real *p, 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;
@@ -625,6 +474,14 @@ BigDecimal_count_precision_and_scale(VALUE self, ssize_t *out_precision, ssize_t
     }
 }
 
+static void
+BigDecimal_count_precision_and_scale(VALUE self, ssize_t *out_precision, ssize_t *out_scale)
+{
+    BDVALUE v = GetBDValueMust(self);
+    VpCountPrecisionAndScale(v.real, out_precision, out_scale);
+    RB_GC_GUARD(v.bigdecimal);
+}
+
 /*
  *  call-seq:
  *    precision -> integer
@@ -660,8 +517,8 @@ BigDecimal_precision(VALUE self)
  *    BigDecimal("1").scale         # => 0
  *    BigDecimal("1.1").scale       # => 1
  *    BigDecimal("3.1415").scale    # => 4
- *    BigDecimal("-1e20").precision # => 0
- *    BigDecimal("1e-20").precision # => 20
+ *    BigDecimal("-1e20").scale     # => 0
+ *    BigDecimal("1e-20").scale     # => 20
  *    BigDecimal("Infinity").scale  # => 0
  *    BigDecimal("-Infinity").scale # => 0
  *    BigDecimal("NaN").scale       # => 0
@@ -711,25 +568,23 @@ BigDecimal_precision_scale(VALUE self)
 static VALUE
 BigDecimal_n_significant_digits(VALUE self)
 {
-    ENTER(1);
-
-    Real *p;
-    GUARD_OBJ(p, GetVpValue(self, 1));
-    if (VpIsZero(p) || !VpIsDef(p)) {
+    BDVALUE v = GetBDValueMust(self);
+    if (VpIsZero(v.real) || !VpIsDef(v.real)) {
         return INT2FIX(0);
     }
 
-    ssize_t n = p->Prec;  /* The length of frac without trailing zeros. */
-    for (n = p->Prec; n > 0 && p->frac[n-1] == 0; --n);
+    ssize_t n = v.real->Prec;  /* The length of frac without trailing zeros. */
+    for (n = v.real->Prec; n > 0 && v.real->frac[n-1] == 0; --n);
     if (n == 0) return INT2FIX(0);
 
     DECDIG x;
     int nlz = BASE_FIG;
-    for (x = p->frac[0]; x > 0; x /= 10) --nlz;
+    for (x = v.real->frac[0]; x > 0; x /= 10) --nlz;
 
     int ntz = 0;
-    for (x = p->frac[n-1]; x > 0 && x % 10 == 0; x /= 10) ++ntz;
+    for (x = v.real->frac[n-1]; x > 0 && x % 10 == 0; x /= 10) ++ntz;
 
+    RB_GC_GUARD(v.bigdecimal);
     ssize_t n_significant_digits = BASE_FIG*n - nlz - ntz;
     return SSIZET2NUM(n_significant_digits);
 }
@@ -751,17 +606,14 @@ BigDecimal_n_significant_digits(VALUE self)
 static VALUE
 BigDecimal_hash(VALUE self)
 {
-    ENTER(1);
-    Real *p;
-    st_index_t hash;
-
-    GUARD_OBJ(p, GetVpValue(self, 1));
-    hash = (st_index_t)p->sign;
+    BDVALUE v = GetBDValueMust(self);
+    st_index_t hash = (st_index_t)v.real->sign;
     /* hash!=2: the case for 0(1),NaN(0) or +-Infinity(3) is sign itself */
     if(hash == 2 || hash == (st_index_t)-2) {
-        hash ^= rb_memhash(p->frac, sizeof(DECDIG)*p->Prec);
-        hash += p->exponent;
+        hash ^= rb_memhash(v.real->frac, sizeof(DECDIG)*v.real->Prec);
+        hash += v.real->exponent;
     }
+    RB_GC_GUARD(v.bigdecimal);
     return ST2FIX(hash);
 }
 
@@ -780,21 +632,22 @@ BigDecimal_hash(VALUE self)
 static VALUE
 BigDecimal_dump(int argc, VALUE *argv, VALUE self)
 {
-    ENTER(5);
-    Real *vp;
+    BDVALUE v;
     char *psz;
     VALUE dummy;
     volatile VALUE dump;
     size_t len;
 
     rb_scan_args(argc, argv, "01", &dummy);
-    GUARD_OBJ(vp,GetVpValue(self, 1));
-    dump = rb_str_new(0, VpNumOfChars(vp, "E")+50);
+    v = GetBDValueMust(self);
+    dump = rb_str_new(0, VpNumOfChars(v.real, "E")+50);
     psz = RSTRING_PTR(dump);
-    snprintf(psz, RSTRING_LEN(dump), "%"PRIuSIZE":", VpMaxPrec(vp)*VpBaseFig());
+    snprintf(psz, RSTRING_LEN(dump), "%"PRIuSIZE":", v.real->Prec*VpBaseFig());
     len = strlen(psz);
-    VpToString(vp, psz+len, RSTRING_LEN(dump)-len, 0, 0);
+    VpToString(v.real, psz+len, RSTRING_LEN(dump)-len, 0, 0);
     rb_str_resize(dump, strlen(psz));
+
+    RB_GC_GUARD(v.bigdecimal);
     return dump;
 }
 
@@ -804,27 +657,19 @@ BigDecimal_dump(int argc, VALUE *argv, VALUE self)
 static VALUE
 BigDecimal_load(VALUE self, VALUE str)
 {
-    ENTER(2);
-    Real *pv;
+    BDVALUE v;
     unsigned char *pch;
     unsigned char ch;
-    unsigned long m=0;
 
     pch = (unsigned char *)StringValueCStr(str);
-    /* First get max prec */
+    /* First skip max prec. Don't trust the value. */
     while((*pch) != (unsigned char)'\0' && (ch = *pch++) != (unsigned char)':') {
         if(!ISDIGIT(ch)) {
             rb_raise(rb_eTypeError, "load failed: invalid character in the marshaled string");
         }
-        m = m*10 + (unsigned long)(ch-'0');
-    }
-    if (m > VpBaseFig()) m -= VpBaseFig();
-    GUARD_OBJ(pv, VpNewRbClass(m, (char *)pch, self, true, true));
-    m /= VpBaseFig();
-    if (m && pv->MaxPrec > m) {
-	pv->MaxPrec = m+1;
     }
-    return VpCheckGetValue(pv);
+    v = bdvalue_nonnullable(CreateFromString((char *)pch, self, true, true));
+    return CheckGetValue(v);
 }
 
 static unsigned short
@@ -1117,22 +962,10 @@ BigDecimal_mode(int argc, VALUE *argv, VALUE self)
 static size_t
 GetAddSubPrec(Real *a, Real *b)
 {
-    size_t mxs;
-    size_t mx = a->Prec;
-    SIGNED_VALUE d;
-
-    if (!VpIsDef(a) || !VpIsDef(b)) return (size_t)-1L;
-    if (mx < b->Prec) mx = b->Prec;
-    if (a->exponent != b->exponent) {
-	mxs = mx;
-	d = a->exponent - b->exponent;
-	if (d < 0) d = -d;
-	mx = mx + (size_t)d;
-	if (mx < mxs) {
-	    return VpException(VP_EXCEPTION_INFINITY, "Exponent overflow", 0);
-	}
-    }
-    return mx;
+    if (VpIsZero(a) || VpIsZero(b)) return Max(a->Prec, b->Prec);
+    ssize_t min_a = a->exponent - a->Prec;
+    ssize_t min_b = b->exponent - b->Prec;
+    return Max(a->exponent, b->exponent) - Min(min_a, min_b);
 }
 
 static inline SIGNED_VALUE
@@ -1152,62 +985,28 @@ check_int_precision(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, bool strict_p, bool raise_exception)
-{
-    VALUE obj = TypedData_Wrap_Struct(klass, &BigDecimal_data_type, 0);
-    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, bool raise_exception)
+static NULLABLE_BDVALUE
+CreateFromString(const char *str, VALUE klass, bool strict_p, bool raise_exception)
 {
-    return VpNewRbClass(mx, str, rb_cBigDecimal, true, raise_exception);
+    return VpAlloc(str, strict_p, raise_exception);
 }
 
-static Real *
-VpCopy(Real *pv, Real const* const x)
+void
+VpMemCopy(Real *pv, Real const* const x)
 {
-    assert(x != NULL);
-
-    pv = rbd_reallocate_struct(pv, x->MaxPrec);
     pv->MaxPrec = x->MaxPrec;
     pv->Prec = x->Prec;
     pv->exponent = x->exponent;
     pv->sign = x->sign;
     pv->flag = x->flag;
     MEMCPY(pv->frac, x->frac, DECDIG, pv->MaxPrec);
-
-    return pv;
 }
 
 /* Returns True if the value is Not a Number. */
 static VALUE
 BigDecimal_IsNaN(VALUE self)
 {
-    Real *p = GetVpValue(self, 1);
+    Real *p = GetSelfVpValue(self);
     if (VpIsNaN(p))  return Qtrue;
     return Qfalse;
 }
@@ -1218,7 +1017,7 @@ BigDecimal_IsNaN(VALUE self)
 static VALUE
 BigDecimal_IsInfinite(VALUE self)
 {
-    Real *p = GetVpValue(self, 1);
+    Real *p = GetSelfVpValue(self);
     if (VpIsPosInf(p)) return INT2FIX(1);
     if (VpIsNegInf(p)) return INT2FIX(-1);
     return Qnil;
@@ -1228,7 +1027,7 @@ BigDecimal_IsInfinite(VALUE self)
 static VALUE
 BigDecimal_IsFinite(VALUE self)
 {
-    Real *p = GetVpValue(self, 1);
+    Real *p = GetSelfVpValue(self);
     if (VpIsNaN(p)) return Qfalse;
     if (VpIsInf(p)) return Qfalse;
     return Qtrue;
@@ -1240,8 +1039,6 @@ BigDecimal_check_num(Real *p)
     VpCheckException(p, true);
 }
 
-static VALUE BigDecimal_split(VALUE self);
-
 /* Returns the value as an Integer.
  *
  * If the BigDecimal is infinity or NaN, raises FloatDomainError.
@@ -1249,44 +1046,36 @@ static VALUE BigDecimal_split(VALUE self);
 static VALUE
 BigDecimal_to_i(VALUE self)
 {
-    ENTER(5);
-    ssize_t e, nf;
-    Real *p;
+    BDVALUE v;
+    VALUE ret;
 
-    GUARD_OBJ(p, GetVpValue(self, 1));
-    BigDecimal_check_num(p);
+    v = GetBDValueMust(self);
+    BigDecimal_check_num(v.real);
 
-    e = VpExponent10(p);
-    if (e <= 0) return INT2FIX(0);
-    nf = VpBaseFig();
-    if (e <= nf) {
-        return LONG2NUM((long)(VpGetSign(p) * (DECDIG_DBL_SIGNED)p->frac[0]));
+    if (v.real->exponent <= 0) return INT2FIX(0);
+    if (v.real->exponent == 1) {
+        ret = LONG2NUM((long)(VpGetSign(v.real) * (DECDIG_DBL_SIGNED)v.real->frac[0]));
     }
     else {
-	VALUE a = BigDecimal_split(self);
-	VALUE digits = RARRAY_AREF(a, 1);
-	VALUE numerator = rb_funcall(digits, rb_intern("to_i"), 0);
-	VALUE ret;
-	ssize_t dpower = e - (ssize_t)RSTRING_LEN(digits);
-
-	if (BIGDECIMAL_NEGATIVE_P(p)) {
-	    numerator = rb_funcall(numerator, '*', 1, INT2FIX(-1));
-	}
-	if (dpower < 0) {
-	    ret = rb_funcall(numerator, rb_intern("div"), 1,
-			      rb_funcall(INT2FIX(10), rb_intern("**"), 1,
-					 INT2FIX(-dpower)));
-	}
-	else {
-	    ret = rb_funcall(numerator, '*', 1,
-			     rb_funcall(INT2FIX(10), rb_intern("**"), 1,
-					INT2FIX(dpower)));
-	}
-	if (RB_TYPE_P(ret, T_FLOAT)) {
-	    rb_raise(rb_eFloatDomainError, "Infinity");
-	}
-	return ret;
+        VALUE fix = (ssize_t)v.real->Prec > v.real->exponent ? BigDecimal_fix(self) : self;
+        VALUE digits = RARRAY_AREF(BigDecimal_split(fix), 1);
+        ssize_t dpower = VpExponent10(v.real) - (ssize_t)RSTRING_LEN(digits);
+        ret = rb_funcall(digits, rb_intern("to_i"), 0);
+
+        if (BIGDECIMAL_NEGATIVE_P(v.real)) {
+            ret = rb_funcall(ret, '*', 1, INT2FIX(-1));
+        }
+        if (dpower) {
+            VALUE pow10 = rb_funcall(INT2FIX(10), rb_intern("**"), 1, SSIZET2NUM(dpower));
+            // In Ruby < 3.4, int**int may return Float::INFINITY
+            if (RB_TYPE_P(pow10, T_FLOAT)) rb_raise(rb_eFloatDomainError, "Infinity");
+
+            ret = rb_funcall(ret, '*', 1, pow10);
+        }
     }
+
+    RB_GC_GUARD(v.bigdecimal);
+    return ret;
 }
 
 /* Returns a new Float object having approximately the same value as the
@@ -1296,24 +1085,26 @@ BigDecimal_to_i(VALUE self)
 static VALUE
 BigDecimal_to_f(VALUE self)
 {
-    ENTER(1);
-    Real *p;
     double d;
     SIGNED_VALUE e;
     char *buf;
     volatile VALUE str;
+    BDVALUE v = GetBDValueMust(self);
+    bool negative = BIGDECIMAL_NEGATIVE_P(v.real);
 
-    GUARD_OBJ(p, GetVpValue(self, 1));
-    if (VpVtoD(&d, &e, p) != 1)
+    if (VpVtoD(&d, &e, v.real) != 1)
 	return rb_float_new(d);
     if (e > (SIGNED_VALUE)(DBL_MAX_10_EXP+BASE_FIG))
 	goto overflow;
-    if (e < (SIGNED_VALUE)(DBL_MIN_10_EXP-BASE_FIG))
+    if (e < (SIGNED_VALUE)(DBL_MIN_10_EXP-DBL_DIG))
 	goto underflow;
 
-    str = rb_str_new(0, VpNumOfChars(p, "E"));
+    str = rb_str_new(0, VpNumOfChars(v.real, "E"));
     buf = RSTRING_PTR(str);
-    VpToString(p, buf, RSTRING_LEN(str), 0, 0);
+    VpToString(v.real, buf, RSTRING_LEN(str), 0, 0);
+
+    RB_GC_GUARD(v.bigdecimal);
+
     errno = 0;
     d = strtod(buf, 0);
     if (errno == ERANGE) {
@@ -1324,14 +1115,14 @@ BigDecimal_to_f(VALUE self)
 
 overflow:
     VpException(VP_EXCEPTION_OVERFLOW, "BigDecimal to Float conversion", 0);
-    if (BIGDECIMAL_NEGATIVE_P(p))
+    if (negative)
 	return rb_float_new(VpGetDoubleNegInf());
     else
 	return rb_float_new(VpGetDoublePosInf());
 
 underflow:
     VpException(VP_EXCEPTION_UNDERFLOW, "BigDecimal to Float conversion", 0);
-    if (BIGDECIMAL_NEGATIVE_P(p))
+    if (negative)
 	return rb_float_new(-0.0);
     else
 	return rb_float_new(0.0);
@@ -1343,15 +1134,16 @@ underflow:
 static VALUE
 BigDecimal_to_r(VALUE self)
 {
-    Real *p;
+    BDVALUE v;
     ssize_t sign, power, denomi_power;
     VALUE a, digits, numerator;
 
-    p = GetVpValue(self, 1);
-    BigDecimal_check_num(p);
+    v = GetBDValueMust(self);
+    BigDecimal_check_num(v.real);
+    sign = VpGetSign(v.real);
+    power = VpExponent10(v.real);
+    RB_GC_GUARD(v.bigdecimal);
 
-    sign = VpGetSign(p);
-    power = VpExponent10(p);
     a = BigDecimal_split(self);
     digits = RARRAY_AREF(a, 1);
     denomi_power = power - RSTRING_LEN(digits);
@@ -1372,6 +1164,14 @@ BigDecimal_to_r(VALUE self)
     }
 }
 
+static size_t
+GetCoercePrec(Real *a, size_t prec)
+{
+    if (prec == 0) prec = a->Prec * BASE_FIG;
+    if (prec < 2 * BIGDECIMAL_DOUBLE_FIGURES) prec = 2 * BIGDECIMAL_DOUBLE_FIGURES;
+    return prec;
+}
+
 /* The coerce method provides support for Ruby type coercion. It is not
  * enabled by default.
  *
@@ -1389,26 +1189,9 @@ BigDecimal_to_r(VALUE self)
 static VALUE
 BigDecimal_coerce(VALUE self, VALUE other)
 {
-    ENTER(2);
-    VALUE obj;
-    Real *b;
-
-    if (RB_TYPE_P(other, T_FLOAT)) {
-	GUARD_OBJ(b, GetVpValueWithPrec(other, 0, 1));
-        obj = rb_assoc_new(VpCheckGetValue(b), self);
-    }
-    else {
-	if (RB_TYPE_P(other, T_RATIONAL)) {
-	    Real* pv = DATA_PTR(self);
-	    GUARD_OBJ(b, GetVpValueWithPrec(other, pv->Prec*VpBaseFig(), 1));
-	}
-	else {
-	    GUARD_OBJ(b, GetVpValue(other, 1));
-	}
-	obj = rb_assoc_new(b->obj, self);
-    }
-
-    return obj;
+    Real* pv = VpPtr(self);
+    BDVALUE b = GetBDValueWithPrecMust(other, GetCoercePrec(pv, 0));
+    return rb_assoc_new(CheckGetValue(b), self);
 }
 
 /*
@@ -1428,6 +1211,15 @@ BigDecimal_uplus(VALUE self)
     return self;
 }
 
+static bool
+is_coerceable_to_BigDecimal(VALUE r)
+{
+    return is_kind_of_BigDecimal(r) ||
+           RB_INTEGER_TYPE_P(r) ||
+           RB_TYPE_P(r, T_FLOAT) ||
+           RB_TYPE_P(r, T_RATIONAL);
+}
+
  /*
   *  call-seq:
   *    self + value -> bigdecimal
@@ -1447,45 +1239,63 @@ BigDecimal_uplus(VALUE self)
 static VALUE
 BigDecimal_add(VALUE self, VALUE r)
 {
-    ENTER(5);
-    Real *c, *a, *b;
-    size_t mx;
+    if (!is_coerceable_to_BigDecimal(r)) return DoSomeOne(self, r, '+');
+    return BigDecimal_addsub_with_coerce(self, r, 0, +1);
+}
 
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    if (RB_TYPE_P(r, T_FLOAT)) {
-	b = GetVpValueWithPrec(r, 0, 1);
-    }
-    else if (RB_TYPE_P(r, T_RATIONAL)) {
-	b = GetVpValueWithPrec(r, a->Prec*VpBaseFig(), 1);
-    }
-    else {
-	b = GetVpValue(r, 0);
-    }
+static VALUE
+BigDecimal_addsub_with_coerce(VALUE self, VALUE r, size_t prec, int operation)
+{
+    BDVALUE a, b, c;
+    size_t mx;
 
-    if (!b) return DoSomeOne(self,r,'+');
-    SAVE(b);
+    a = GetBDValueMust(self);
+    b = GetBDValueWithPrecMust(r, GetCoercePrec(a.real, prec));
 
-    if (VpIsNaN(b)) return b->obj;
-    if (VpIsNaN(a)) return a->obj;
+    if (VpIsNaN(a.real)) return CheckGetValue(a);
+    if (VpIsNaN(b.real)) return CheckGetValue(b);
 
-    mx = GetAddSubPrec(a, b);
-    if (mx == (size_t)-1L) {
-        GUARD_OBJ(c, NewZeroWrapLimited(1, VpBaseFig() + 1));
-        VpAddSub(c, a, b, 1);
+    if (VpIsInf(a.real) || VpIsInf(b.real)) {
+        c = NewZeroWrap(1, BASE_FIG);
+        VpAddSub(c.real, a.real, b.real, operation);
     }
     else {
-        GUARD_OBJ(c, NewZeroWrapLimited(1, mx * (VpBaseFig() + 1)));
-        if (!mx) {
-            VpSetInf(c, VpGetSign(a));
-        }
-        else {
-            VpAddSub(c, a, b, 1);
+
+        // Optimization when exponent difference is large
+        // (1.234e+1000).add(5.678e-1000, 10) == (1.234e+1000).add(0.1e+990, 10) in every rounding mode
+        if (prec && !VpIsZero(a.real) && !VpIsZero(b.real)) {
+            size_t precRoom = roomof(prec, BASE_FIG);
+            if (a.real->exponent - (ssize_t)Max(a.real->Prec, precRoom) - 1 > b.real->exponent) {
+                BDVALUE b2 = NewZeroWrap(1, BASE_FIG);
+                VpSetOne(b2.real)
+                VpSetSign(b2.real, b.real->sign);
+                b2.real->exponent = a.real->exponent - (ssize_t)Max(a.real->Prec, precRoom) - 1;
+                b = b2;
+            } else if (b.real->exponent - (ssize_t)Max(b.real->Prec, precRoom) - 1 > a.real->exponent) {
+                BDVALUE a2 = NewZeroWrap(1, BASE_FIG);
+                VpSetOne(a2.real)
+                VpSetSign(a2.real, a.real->sign);
+                a2.real->exponent = b.real->exponent - (ssize_t)Max(b.real->Prec, precRoom) - 1;
+                a = a2;
+            }
         }
+
+        mx = GetAddSubPrec(a.real, b.real);
+        c = NewZeroWrap(1, (mx + 1) * BASE_FIG);
+        size_t pl = VpGetPrecLimit();
+        if (prec) VpSetPrecLimit(prec);
+        // Let VpAddSub round the result
+        VpAddSub(c.real, a.real, b.real, operation);
+        if (prec) VpSetPrecLimit(pl);
     }
-    return VpCheckGetValue(c);
+
+    RB_GC_GUARD(a.bigdecimal);
+    RB_GC_GUARD(b.bigdecimal);
+    return CheckGetValue(c);
 }
 
- /*  call-seq:
+ /*
+  *  call-seq:
   *    self - value -> bigdecimal
   *
   *  Returns the \BigDecimal difference of +self+ and +value+:
@@ -1502,73 +1312,18 @@ BigDecimal_add(VALUE self, VALUE r)
 static VALUE
 BigDecimal_sub(VALUE self, VALUE r)
 {
-    ENTER(5);
-    Real *c, *a, *b;
-    size_t mx;
-
-    GUARD_OBJ(a, GetVpValue(self,1));
-    if (RB_TYPE_P(r, T_FLOAT)) {
-	b = GetVpValueWithPrec(r, 0, 1);
-    }
-    else if (RB_TYPE_P(r, T_RATIONAL)) {
-	b = GetVpValueWithPrec(r, a->Prec*VpBaseFig(), 1);
-    }
-    else {
-	b = GetVpValue(r,0);
-    }
-
-    if (!b) return DoSomeOne(self,r,'-');
-    SAVE(b);
-
-    if (VpIsNaN(b)) return b->obj;
-    if (VpIsNaN(a)) return a->obj;
-
-    mx = GetAddSubPrec(a,b);
-    if (mx == (size_t)-1L) {
-        GUARD_OBJ(c, NewZeroWrapLimited(1, VpBaseFig() + 1));
-        VpAddSub(c, a, b, -1);
-    }
-    else {
-        GUARD_OBJ(c, NewZeroWrapLimited(1, mx *(VpBaseFig() + 1)));
-        if (!mx) {
-            VpSetInf(c,VpGetSign(a));
-        }
-        else {
-            VpAddSub(c, a, b, -1);
-        }
-    }
-    return VpCheckGetValue(c);
+    if (!is_coerceable_to_BigDecimal(r)) return DoSomeOne(self, r, '-');
+    return BigDecimal_addsub_with_coerce(self, r, 0, -1);
 }
 
 static VALUE
 BigDecimalCmp(VALUE self, VALUE r,char op)
 {
-    ENTER(5);
     SIGNED_VALUE e;
-    Real *a, *b=0;
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    switch (TYPE(r)) {
-    case T_DATA:
-	if (!is_kind_of_BigDecimal(r)) break;
-	/* fall through */
-    case T_FIXNUM:
-	/* fall through */
-    case T_BIGNUM:
-	GUARD_OBJ(b, GetVpValue(r, 0));
-	break;
-
-    case T_FLOAT:
-	GUARD_OBJ(b, GetVpValueWithPrec(r, 0, 0));
-	break;
+    BDVALUE a = GetBDValueMust(self);
+    NULLABLE_BDVALUE b = GetBDValueWithPrec(r, GetCoercePrec(a.real, 0));
 
-    case T_RATIONAL:
-	GUARD_OBJ(b, GetVpValueWithPrec(r, a->Prec*VpBaseFig(), 0));
-	break;
-
-    default:
-	break;
-    }
-    if (b == NULL) {
+    if (b.real_or_null == NULL) {
 	ID f = 0;
 
 	switch (op) {
@@ -1597,8 +1352,11 @@ BigDecimalCmp(VALUE self, VALUE r,char op)
 	}
 	return rb_num_coerce_relop(self, r, f);
     }
-    SAVE(b);
-    e = VpComp(a, b);
+    e = VpComp(a.real, b.real_or_null);
+
+    RB_GC_GUARD(a.bigdecimal);
+    RB_GC_GUARD(b.bigdecimal_or_nil);
+
     if (e == 999)
 	return (op == '*') ? Qnil : Qfalse;
     switch (op) {
@@ -1638,7 +1396,7 @@ BigDecimalCmp(VALUE self, VALUE r,char op)
 static VALUE
 BigDecimal_zero(VALUE self)
 {
-    Real *a = GetVpValue(self, 1);
+    Real *a = GetSelfVpValue(self);
     return VpIsZero(a) ? Qtrue : Qfalse;
 }
 
@@ -1646,7 +1404,7 @@ BigDecimal_zero(VALUE self)
 static VALUE
 BigDecimal_nonzero(VALUE self)
 {
-    Real *a = GetVpValue(self, 1);
+    Real *a = GetSelfVpValue(self);
     return VpIsZero(a) ? Qnil : self;
 }
 
@@ -1772,12 +1530,11 @@ BigDecimal_ge(VALUE self, VALUE r)
 static VALUE
 BigDecimal_neg(VALUE self)
 {
-    ENTER(5);
-    Real *c, *a;
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    GUARD_OBJ(c, NewZeroWrapLimited(1, a->Prec *(VpBaseFig() + 1)));
-    VpAsgn(c, a, -1);
-    return VpCheckGetValue(c);
+    BDVALUE a = GetBDValueMust(self);
+    BDVALUE c = NewZeroWrap(1, a.real->Prec * BASE_FIG);
+    VpAsgn(c.real, a.real, -10);
+    RB_GC_GUARD(a.bigdecimal);
+    return CheckGetValue(c);
 }
 
 /*
@@ -1790,84 +1547,36 @@ BigDecimal_neg(VALUE self)
  *
  * See BigDecimal#mult.
  */
-
 static VALUE
 BigDecimal_mult(VALUE self, VALUE r)
 {
-    ENTER(5);
-    Real *c, *a, *b;
-    size_t mx;
-
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    if (RB_TYPE_P(r, T_FLOAT)) {
-        b = GetVpValueWithPrec(r, 0, 1);
-    }
-    else if (RB_TYPE_P(r, T_RATIONAL)) {
-	b = GetVpValueWithPrec(r, a->Prec*VpBaseFig(), 1);
-    }
-    else {
-	b = GetVpValue(r,0);
-    }
-
-    if (!b) return DoSomeOne(self, r, '*');
-    SAVE(b);
-
-    mx = a->Prec + b->Prec;
-    GUARD_OBJ(c, NewZeroWrapLimited(1, mx * (VpBaseFig() + 1)));
-    VpMult(c, a, b);
-    return VpCheckGetValue(c);
+    if (!is_coerceable_to_BigDecimal(r)) return DoSomeOne(self, r, '*');
+    return BigDecimal_mult_with_coerce(self, r, 0);
 }
 
 static VALUE
-BigDecimal_divide(VALUE self, VALUE r, Real **c, Real **res, Real **div)
-/* For c = self.div(r): with round operation */
+BigDecimal_mult_with_coerce(VALUE self, VALUE r, size_t prec)
 {
-    ENTER(5);
-    Real *a, *b;
-    ssize_t a_prec, b_prec;
-    size_t mx;
+    BDVALUE a, b, c;
 
-    TypedData_Get_Struct(self, Real, &BigDecimal_data_type, a);
-    SAVE(a);
+    a = GetBDValueMust(self);
+    b = GetBDValueWithPrecMust(r, GetCoercePrec(a.real, prec));
 
-    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);
+    c = NewZeroWrap(1, VPMULT_RESULT_PREC(a.real, b.real) * BASE_FIG);
+    VpMult(c.real, a.real, b.real);
+    if (prec) {
+        VpLeftRound(c.real, VpGetRoundMode(), prec);
     }
-    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)) {
-        rr = rb_rational_convert_to_BigDecimal(r, a->Prec*BASE_FIG, true);
+    else {
+        VpLimitRound(c.real, 0);
     }
 
-    if (!is_kind_of_BigDecimal(rr)) {
-        return DoSomeOne(self, r, '/');
-    }
-
-    TypedData_Get_Struct(rr, Real, &BigDecimal_data_type, b);
-    SAVE(b);
-    *div = b;
-
-    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;
-    mx *= 2;
-
-    if (2*BIGDECIMAL_DOUBLE_FIGURES > mx)
-        mx = 2*BIGDECIMAL_DOUBLE_FIGURES;
-
-    GUARD_OBJ((*c), NewZeroWrapNolimit(1, mx + 2*BASE_FIG));
-    GUARD_OBJ((*res), NewZeroWrapNolimit(1, (mx + 1)*2 + 2*BASE_FIG));
-    VpDivd(*c, *res, a, b);
-
-    return Qnil;
+    RB_GC_GUARD(a.bigdecimal);
+    RB_GC_GUARD(b.bigdecimal);
+    return CheckGetValue(c);
 }
 
-static VALUE BigDecimal_DoDivmod(VALUE self, VALUE r, Real **div, Real **mod);
+static bool BigDecimal_DoDivmod(VALUE self, VALUE r, NULLABLE_BDVALUE *div, NULLABLE_BDVALUE *mod, bool truncate);
 
 /* call-seq:
  *   a / b   -> bigdecimal
@@ -1884,20 +1593,8 @@ static VALUE
 BigDecimal_div(VALUE self, VALUE r)
 /* For c = self/r: with round operation */
 {
-    ENTER(5);
-    Real *c=NULL, *res=NULL, *div = NULL;
-    r = BigDecimal_divide(self, r, &c, &res, &div);
-    if (!NIL_P(r)) return r; /* coerced by other */
-    SAVE(c); SAVE(res); SAVE(div);
-    /* a/b = c + r/b */
-    /* c xxxxx
-       r 00000yyyyy  ==> (y/b)*BASE >= HALF_BASE
-     */
-    /* Round */
-    if (VpHasVal(div)) { /* frac[0] must be zero for NaN,INF,Zero */
-        VpInternalRound(c, 0, c->frac[c->Prec-1], (DECDIG)(VpBaseVal() * (DECDIG_DBL)res->frac[0] / div->frac[0]));
-    }
-    return VpCheckGetValue(c);
+    if (!is_coerceable_to_BigDecimal(r)) return DoSomeOne(self, r, '/');
+    return BigDecimal_div2(self, r, INT2FIX(0));
 }
 
 static VALUE BigDecimal_round(int argc, VALUE *argv, VALUE self);
@@ -1942,119 +1639,115 @@ BigDecimal_quo(int argc, VALUE *argv, VALUE self)
 /*
  * %: mod = a%b = a - (a.to_f/b).floor * b
  * div = (a.to_f/b).floor
+ * In truncate mode, use truncate instead of floor.
  */
-static VALUE
-BigDecimal_DoDivmod(VALUE self, VALUE r, Real **div, Real **mod)
+static bool
+BigDecimal_DoDivmod(VALUE self, VALUE r, NULLABLE_BDVALUE *div, NULLABLE_BDVALUE *mod, bool truncate)
 {
-    ENTER(8);
-    Real *c=NULL, *d=NULL, *res=NULL;
-    Real *a, *b;
-    ssize_t a_prec, b_prec;
-    size_t mx;
+    BDVALUE a, b, dv, md, res;
+    NULLABLE_BDVALUE b2;
+    ssize_t a_exponent, b_exponent;
+    size_t mx, rx, pl;
 
-    TypedData_Get_Struct(self, Real, &BigDecimal_data_type, a);
-    SAVE(a);
+    a = GetBDValueMust(self);
 
-    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)) {
-        rr = rb_rational_convert_to_BigDecimal(r, a->Prec*BASE_FIG, true);
-    }
+    b2 = GetBDValueWithPrec(r, GetCoercePrec(a.real, 0));
+    if (!b2.real_or_null) return false;
+    b = bdvalue_nonnullable(b2);
 
-    if (!is_kind_of_BigDecimal(rr)) {
-        return Qfalse;
+    if (VpIsNaN(a.real) || VpIsNaN(b.real) || (VpIsInf(a.real) && VpIsInf(b.real))) {
+        VALUE nan = BigDecimal_nan();
+        *div = *mod = (NULLABLE_BDVALUE) { nan, VpPtr(nan) };
+        goto Done;
     }
-
-    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)) {
+    if (VpIsZero(b.real)) {
         rb_raise(rb_eZeroDivError, "divided by 0");
     }
-    if (VpIsInf(a)) {
-        if (VpGetSign(a) == VpGetSign(b)) {
+    if (VpIsInf(a.real)) {
+        if (VpGetSign(a.real) == VpGetSign(b.real)) {
             VALUE inf = BigDecimal_positive_infinity();
-            TypedData_Get_Struct(inf, Real, &BigDecimal_data_type, *div);
+            *div = (NULLABLE_BDVALUE) { inf, VpPtr(inf) };
         }
         else {
             VALUE inf = BigDecimal_negative_infinity();
-            TypedData_Get_Struct(inf, Real, &BigDecimal_data_type, *div);
+            *div = (NULLABLE_BDVALUE) { inf, VpPtr(inf) };
         }
         VALUE nan = BigDecimal_nan();
-        TypedData_Get_Struct(nan, Real, &BigDecimal_data_type, *mod);
-        return Qtrue;
-    }
-    if (VpIsInf(b)) {
-        VALUE zero = BigDecimal_positive_zero();
-        TypedData_Get_Struct(zero, Real, &BigDecimal_data_type, *div);
-        *mod = a;
-        return Qtrue;
+        *mod = (NULLABLE_BDVALUE) { nan, VpPtr(nan) };
+        goto Done;
     }
-    if (VpIsZero(a)) {
+    if (VpIsZero(a.real)) {
         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;
-    mx *= 2;
-
-    if (2*BIGDECIMAL_DOUBLE_FIGURES > mx)
-        mx = 2*BIGDECIMAL_DOUBLE_FIGURES;
-
-    GUARD_OBJ(c, NewZeroWrapLimited(1, mx + 2*BASE_FIG));
-    GUARD_OBJ(res, NewZeroWrapNolimit(1, mx*2 + 2*BASE_FIG));
-    VpDivd(c, res, a, b);
-
-    mx = c->Prec * BASE_FIG;
-    GUARD_OBJ(d, NewZeroWrapLimited(1, mx));
-    VpActiveRound(d, c, VP_ROUND_DOWN, 0);
-
-    VpMult(res, d, b);
-    VpAddSub(c, a, res, -1);
+        *div = (NULLABLE_BDVALUE) { zero, VpPtr(zero) };
+        *mod = bdvalue_nullable(a);
+        goto Done;
+    }
+    if (VpIsInf(b.real)) {
+        if (!truncate && VpGetSign(a.real) * VpGetSign(b.real) < 0) {
+            BDVALUE minus_one = NewZeroWrap(1, BASE_FIG);
+            VpSetOne(minus_one.real);
+            VpSetSign(minus_one.real, -1);
+            RB_GC_GUARD(minus_one.bigdecimal);
+            *div = bdvalue_nullable(minus_one);
+            *mod = bdvalue_nullable(b);
+        } else {
+            VALUE zero = BigDecimal_positive_zero();
+            *div = (NULLABLE_BDVALUE) { zero, VpPtr(zero) };
+            *mod = bdvalue_nullable(a);
+        }
+        goto Done;
+    }
+
+    a_exponent = VpExponent10(a.real);
+    b_exponent = VpExponent10(b.real);
+    mx = a_exponent > b_exponent ? a_exponent - b_exponent + 1 : 1;
+    dv = NewZeroWrap(1, VPDIVD_QUO_DIGITS(mx));
+
+    /* res is reused for VpDivd remainder and VpMult result */
+    rx = VPDIVD_REM_PREC(a.real, b.real, dv.real);
+    mx = VPMULT_RESULT_PREC(dv.real, b.real);
+    res = NewZeroWrap(1, Max(rx, mx) * BASE_FIG);
+    /* AddSub needs one more prec */
+    md = NewZeroWrap(1, (res.real->MaxPrec + 1) * BASE_FIG);
+
+    VpDivd(dv.real, res.real, a.real, b.real);
+    VpMidRound(dv.real, VP_ROUND_DOWN, 0);
+    VpMult(res.real, dv.real, b.real);
+    pl = VpGetPrecLimit();
+    VpSetPrecLimit(0);
+    VpAddSub(md.real, a.real, res.real, -1);
+    VpSetPrecLimit(pl);
 
-    if (!VpIsZero(c) && (VpGetSign(a) * VpGetSign(b) < 0)) {
+    if (!truncate && !VpIsZero(md.real) && (VpGetSign(a.real) * VpGetSign(b.real) < 0)) {
         /* result adjustment for negative case */
-        res = rbd_reallocate_struct(res, d->MaxPrec);
-        res->MaxPrec = d->MaxPrec;
-        VpAddSub(res, d, VpOne(), -1);
-        GUARD_OBJ(d, NewZeroWrapLimited(1, GetAddSubPrec(c, b) * 2*BASE_FIG));
-        VpAddSub(d, c, b, 1);
-        *div = res;
-        *mod = d;
+        BDVALUE dv2 = NewZeroWrap(1, (dv.real->MaxPrec + 1) * BASE_FIG);
+        BDVALUE md2 = NewZeroWrap(1, (GetAddSubPrec(md.real, b.real) + 1) * BASE_FIG);
+        VpSetPrecLimit(0);
+        VpAddSub(dv2.real, dv.real, VpOne(), -1);
+        VpAddSub(md2.real, md.real, b.real, 1);
+        VpSetPrecLimit(pl);
+        *div = bdvalue_nullable(dv2);
+        *mod = bdvalue_nullable(md2);
+        RB_GC_GUARD(dv2.bigdecimal);
+        RB_GC_GUARD(md2.bigdecimal);
     }
     else {
-        *div = d;
-        *mod = c;
+        *div = bdvalue_nullable(dv);
+        *mod = bdvalue_nullable(md);
     }
-    return Qtrue;
 
-  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;
+Done:
+    RB_GC_GUARD(a.bigdecimal);
+    RB_GC_GUARD(b.bigdecimal);
+    RB_GC_GUARD(dv.bigdecimal);
+    RB_GC_GUARD(md.bigdecimal);
+    RB_GC_GUARD(res.bigdecimal);
+    return true;
 }
 
 /* call-seq:
- * a % b
- * a.modulo(b)
+ *   a % b
+ *   a.modulo(b)
  *
  * Returns the modulus from dividing by b.
  *
@@ -2063,71 +1756,16 @@ BigDecimal_DoDivmod(VALUE self, VALUE r, Real **div, Real **mod)
 static VALUE
 BigDecimal_mod(VALUE self, VALUE r) /* %: a%b = a - (a.to_f/b).floor * b */
 {
-    ENTER(3);
-    Real *div = NULL, *mod = NULL;
+    NULLABLE_BDVALUE div, mod;
 
-    if (BigDecimal_DoDivmod(self, r, &div, &mod)) {
-	SAVE(div); SAVE(mod);
-        return VpCheckGetValue(mod);
+    if (BigDecimal_DoDivmod(self, r, &div, &mod, false)) {
+        return CheckGetValue(bdvalue_nonnullable(mod));
     }
     return DoSomeOne(self, r, '%');
 }
 
-static VALUE
-BigDecimal_divremain(VALUE self, VALUE r, Real **dv, Real **rv)
-{
-    ENTER(10);
-    size_t mx;
-    Real *a = NULL, *b = NULL, *c = NULL, *res = NULL, *d = NULL, *rr = NULL, *ff = NULL;
-    Real *f = NULL;
-
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    if (RB_TYPE_P(r, T_FLOAT)) {
-	b = GetVpValueWithPrec(r, 0, 1);
-    }
-    else if (RB_TYPE_P(r, T_RATIONAL)) {
-	b = GetVpValueWithPrec(r, a->Prec*VpBaseFig(), 1);
-    }
-    else {
-	b = GetVpValue(r, 0);
-    }
-
-    if (!b) return DoSomeOne(self, r, rb_intern("remainder"));
-    SAVE(b);
-
-    if (VpIsPosInf(b) || VpIsNegInf(b)) {
-       GUARD_OBJ(*dv, NewZeroWrapLimited(1, 1));
-       VpSetZero(*dv, 1);
-       *rv = a;
-       return Qnil;
-    }
-
-    mx = (a->MaxPrec + b->MaxPrec) *VpBaseFig();
-    GUARD_OBJ(c,   NewZeroWrapLimited(1, mx));
-    GUARD_OBJ(res, NewZeroWrapNolimit(1, (mx+1) * 2 + (VpBaseFig() + 1)));
-    GUARD_OBJ(rr,  NewZeroWrapNolimit(1, (mx+1) * 2 + (VpBaseFig() + 1)));
-    GUARD_OBJ(ff,  NewZeroWrapNolimit(1, (mx+1) * 2 + (VpBaseFig() + 1)));
-
-    VpDivd(c, res, a, b);
-
-    mx = c->Prec *(VpBaseFig() + 1);
-
-    GUARD_OBJ(d, NewZeroWrapLimited(1, mx));
-    GUARD_OBJ(f, NewZeroWrapLimited(1, mx));
-
-    VpActiveRound(d, c, VP_ROUND_DOWN, 0); /* 0: round off */
-
-    VpFrac(f, c);
-    VpMult(rr, f, b);
-    VpAddSub(ff, res, rr, 1);
-
-    *dv = d;
-    *rv = ff;
-    return Qnil;
-}
-
 /* call-seq:
- * remainder(value)
+ *   remainder(value)
  *
  * Returns the remainder from dividing by the value.
  *
@@ -2136,15 +1774,16 @@ BigDecimal_divremain(VALUE self, VALUE r, Real **dv, Real **rv)
 static VALUE
 BigDecimal_remainder(VALUE self, VALUE r) /* remainder */
 {
-    VALUE  f;
-    Real  *d, *rv = 0;
-    f = BigDecimal_divremain(self, r, &d, &rv);
-    if (!NIL_P(f)) return f;
-    return VpCheckGetValue(rv);
+    NULLABLE_BDVALUE div, mod = { Qnil, NULL };
+
+    if (BigDecimal_DoDivmod(self, r, &div, &mod, true)) {
+        return CheckGetValue(bdvalue_nonnullable(mod));
+    }
+    return DoSomeOne(self, r, rb_intern("remainder"));
 }
 
 /* call-seq:
- * divmod(value)
+ *   divmod(value)
  *
  * Divides by the specified value, and returns the quotient and modulus
  * as BigDecimal numbers. The quotient is rounded towards negative infinity.
@@ -2168,12 +1807,10 @@ BigDecimal_remainder(VALUE self, VALUE r) /* remainder */
 static VALUE
 BigDecimal_divmod(VALUE self, VALUE r)
 {
-    ENTER(5);
-    Real *div = NULL, *mod = NULL;
+    NULLABLE_BDVALUE div, mod;
 
-    if (BigDecimal_DoDivmod(self, r, &div, &mod)) {
-	SAVE(div); SAVE(mod);
-        return rb_assoc_new(VpCheckGetValue(div), VpCheckGetValue(mod));
+    if (BigDecimal_DoDivmod(self, r, &div, &mod, false)) {
+        return rb_assoc_new(BigDecimal_to_i(CheckGetValue(bdvalue_nonnullable(div))), CheckGetValue(bdvalue_nonnullable(mod)));
     }
     return DoSomeOne(self,r,rb_intern("divmod"));
 }
@@ -2185,47 +1822,54 @@ BigDecimal_divmod(VALUE self, VALUE r)
 static inline VALUE
 BigDecimal_div2(VALUE self, VALUE b, VALUE n)
 {
-    ENTER(5);
     SIGNED_VALUE ix;
+    BDVALUE av, bv, cv, res;
 
     if (NIL_P(n)) { /* div in Float sense */
-        Real *div = NULL;
-        Real *mod;
-        if (BigDecimal_DoDivmod(self, b, &div, &mod)) {
-            return BigDecimal_to_i(VpCheckGetValue(div));
+        NULLABLE_BDVALUE div;
+        NULLABLE_BDVALUE mod;
+        if (BigDecimal_DoDivmod(self, b, &div, &mod, false)) {
+            return BigDecimal_to_i(CheckGetValue(bdvalue_nonnullable(div)));
         }
         return DoSomeOne(self, b, rb_intern("div"));
     }
 
     /* div in BigDecimal sense */
     ix = check_int_precision(n);
+
+    av = GetBDValueMust(self);
+    bv = GetBDValueWithPrecMust(b, GetCoercePrec(av.real, ix));
+
     if (ix == 0) {
-        return BigDecimal_div(self, b);
+        ssize_t a_prec, b_prec, limit = VpGetPrecLimit();
+        VpCountPrecisionAndScale(av.real, &a_prec, NULL);
+        VpCountPrecisionAndScale(bv.real, &b_prec, NULL);
+        ix = ((a_prec > b_prec) ? a_prec : b_prec) + BIGDECIMAL_DOUBLE_FIGURES;
+        if (2 * BIGDECIMAL_DOUBLE_FIGURES > ix)
+            ix = 2 * BIGDECIMAL_DOUBLE_FIGURES;
+        if (limit && limit < ix) ix = limit;
     }
-    else {
-        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, NewZeroWrapLimited(1, mx + VpBaseFig()));
-        GUARD_OBJ(av, GetVpValue(self, 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, NewZeroWrapNolimit(1, (mx * 2  + 2)*VpBaseFig()));
-        VpDivd(cv, res, av, bv);
-        VpSetPrecLimit(pl);
-        VpLeftRound(cv, VpGetRoundMode(), ix);
-        return VpCheckGetValue(cv);
+
+    // Needs to calculate 1 extra digit for rounding.
+    cv = NewZeroWrap(1, VPDIVD_QUO_DIGITS(ix + 1));
+    res = NewZeroWrap(1, VPDIVD_REM_PREC(av.real, bv.real, cv.real) * BASE_FIG);
+    VpDivd(cv.real, res.real, av.real, bv.real);
+
+    if (!VpIsZero(res.real)) {
+        // Remainder value affects rounding result.
+        // ROUND_UP cv = 0.1e0 with idx=10 will be:
+        // 0.1e0 if remainder == 0
+        // 0.1000000001e0 if remainder != 0
+        size_t idx = roomof(ix, BASE_FIG);
+        while (cv.real->Prec <= idx) cv.real->frac[cv.real->Prec++] = 0;
+        if (cv.real->frac[idx] == 0 || cv.real->frac[idx] == HALF_BASE) cv.real->frac[idx]++;
     }
+    VpLeftRound(cv.real, VpGetRoundMode(), ix);
+
+    RB_GC_GUARD(av.bigdecimal);
+    RB_GC_GUARD(bv.bigdecimal);
+    RB_GC_GUARD(res.bigdecimal);
+    return CheckGetValue(cv);
 }
 
  /*
@@ -2301,22 +1945,11 @@ BigDecimal_div3(int argc, VALUE *argv, VALUE self)
 static VALUE
 BigDecimal_add2(VALUE self, VALUE b, VALUE n)
 {
-    ENTER(2);
-    Real *cv;
-    SIGNED_VALUE mx = check_int_precision(n);
-    if (mx == 0) return BigDecimal_add(self, b);
-    else {
-	size_t pl = VpSetPrecLimit(0);
-	VALUE   c = BigDecimal_add(self, b);
-	VpSetPrecLimit(pl);
-	GUARD_OBJ(cv, GetVpValue(c, 1));
-	VpLeftRound(cv, VpGetRoundMode(), mx);
-        return VpCheckGetValue(cv);
-    }
+    return BigDecimal_addsub_with_coerce(self, b, check_int_precision(n), +1);
 }
 
 /* call-seq:
- * sub(value, digits)  -> bigdecimal
+ *   sub(value, digits)  -> bigdecimal
  *
  * Subtract the specified value.
  *
@@ -2331,18 +1964,7 @@ BigDecimal_add2(VALUE self, VALUE b, VALUE n)
 static VALUE
 BigDecimal_sub2(VALUE self, VALUE b, VALUE n)
 {
-    ENTER(2);
-    Real *cv;
-    SIGNED_VALUE mx = check_int_precision(n);
-    if (mx == 0) return BigDecimal_sub(self, b);
-    else {
-	size_t pl = VpSetPrecLimit(0);
-	VALUE   c = BigDecimal_sub(self, b);
-	VpSetPrecLimit(pl);
-	GUARD_OBJ(cv, GetVpValue(c, 1));
-	VpLeftRound(cv, VpGetRoundMode(), mx);
-        return VpCheckGetValue(cv);
-    }
+    return BigDecimal_addsub_with_coerce(self, b, check_int_precision(n), -1);
 }
 
  /*
@@ -2374,18 +1996,7 @@ BigDecimal_sub2(VALUE self, VALUE b, VALUE n)
 static VALUE
 BigDecimal_mult2(VALUE self, VALUE b, VALUE n)
 {
-    ENTER(2);
-    Real *cv;
-    SIGNED_VALUE mx = check_int_precision(n);
-    if (mx == 0) return BigDecimal_mult(self, b);
-    else {
-	size_t pl = VpSetPrecLimit(0);
-	VALUE   c = BigDecimal_mult(self, b);
-	VpSetPrecLimit(pl);
-	GUARD_OBJ(cv, GetVpValue(c, 1));
-	VpLeftRound(cv, VpGetRoundMode(), mx);
-        return VpCheckGetValue(cv);
-    }
+    return BigDecimal_mult_with_coerce(self, b, check_int_precision(n));
 }
 
 /*
@@ -2402,41 +2013,12 @@ BigDecimal_mult2(VALUE self, VALUE b, VALUE n)
 static VALUE
 BigDecimal_abs(VALUE self)
 {
-    ENTER(5);
-    Real *c, *a;
-    size_t mx;
-
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    mx = a->Prec *(VpBaseFig() + 1);
-    GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
-    VpAsgn(c, a, 1);
-    VpChangeSign(c, 1);
-    return VpCheckGetValue(c);
-}
-
-/* call-seq:
- * sqrt(n)
- *
- * Returns the square root of the value.
- *
- * Result has at least n significant digits.
- */
-static VALUE
-BigDecimal_sqrt(VALUE self, VALUE nFig)
-{
-    ENTER(5);
-    Real *c, *a;
-    size_t mx, n;
-
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    mx = a->Prec * (VpBaseFig() + 1);
-
-    n = check_int_precision(nFig);
-    n += VpDblFig() + VpBaseFig();
-    if (mx <= n) mx = n;
-    GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
-    VpSqrt(c, a);
-    return VpCheckGetValue(c);
+    BDVALUE a = GetBDValueMust(self);
+    BDVALUE c = NewZeroWrap(1, a.real->Prec * BASE_FIG);
+    VpAsgn(c.real, a.real, 10);
+    VpChangeSign(c.real, 1);
+    RB_GC_GUARD(a.bigdecimal);
+    return CheckGetValue(c);
 }
 
 /* Return the integer part of the number, as a BigDecimal.
@@ -2444,22 +2026,18 @@ BigDecimal_sqrt(VALUE self, VALUE nFig)
 static VALUE
 BigDecimal_fix(VALUE self)
 {
-    ENTER(5);
-    Real *c, *a;
-    size_t mx;
-
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    mx = a->Prec *(VpBaseFig() + 1);
-    GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
-    VpActiveRound(c, a, VP_ROUND_DOWN, 0); /* 0: round off */
-    return VpCheckGetValue(c);
+    BDVALUE a = GetBDValueMust(self);
+    BDVALUE c = NewZeroWrap(1, (a.real->Prec + 1) * BASE_FIG);
+    VpActiveRound(c.real, a.real, VP_ROUND_DOWN, 0); /* 0: round off */
+    RB_GC_GUARD(a.bigdecimal);
+    return CheckGetValue(c);
 }
 
 /* call-seq:
- * round(n, mode)
+ *   round(n, mode)
  *
  * Round to the nearest integer (by default), returning the result as a
- * BigDecimal if n is specified, or as an Integer if it isn't.
+ * BigDecimal if n is specified and positive, or as an Integer if it isn't.
  *
  *	BigDecimal('3.14159').round #=> 3
  *	BigDecimal('8.7').round #=> 9
@@ -2467,6 +2045,7 @@ BigDecimal_fix(VALUE self)
  *
  *	BigDecimal('3.14159').round(2).class.name #=> "BigDecimal"
  *	BigDecimal('3.14159').round.class.name #=> "Integer"
+ *	BigDecimal('3.14159').round(0).class.name #=> "Integer"
  *
  * If n is specified and positive, the fractional part of the result has no
  * more than that many digits.
@@ -2483,13 +2062,12 @@ BigDecimal_fix(VALUE self)
 static VALUE
 BigDecimal_round(int argc, VALUE *argv, VALUE self)
 {
-    ENTER(5);
-    Real   *c, *a;
+    BDVALUE c, a;
     int    iLoc = 0;
     VALUE  vLoc;
     VALUE  vRound;
     int    round_to_int = 0;
-    size_t mx, pl;
+    size_t mx;
 
     unsigned short sw = VpGetRoundMode();
 
@@ -2520,20 +2098,50 @@ BigDecimal_round(int argc, VALUE *argv, VALUE self)
 	break;
     }
 
-    pl = VpSetPrecLimit(0);
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    mx = a->Prec * (VpBaseFig() + 1);
-    GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
-    VpSetPrecLimit(pl);
-    VpActiveRound(c, a, sw, iLoc);
+    a = GetBDValueMust(self);
+    mx = (a.real->Prec + 1) * BASE_FIG;
+    c = NewZeroWrap(1, mx);
+
+    VpActiveRound(c.real, a.real, sw, iLoc);
+
+    RB_GC_GUARD(a.bigdecimal);
+
     if (round_to_int) {
-        return BigDecimal_to_i(VpCheckGetValue(c));
+        return BigDecimal_to_i(CheckGetValue(c));
     }
-    return VpCheckGetValue(c);
+    return CheckGetValue(c);
+}
+
+static VALUE
+BigDecimal_truncate_floor_ceil(int argc, VALUE *argv, VALUE self, unsigned short rounding_mode)
+{
+    BDVALUE c, a;
+    int iLoc;
+    VALUE vLoc;
+    size_t mx;
+
+    if (rb_scan_args(argc, argv, "01", &vLoc) == 0) {
+        iLoc = 0;
+    }
+    else {
+        iLoc = NUM2INT(vLoc);
+    }
+
+    a = GetBDValueMust(self);
+    mx = (a.real->Prec + 1) * BASE_FIG;
+    c = NewZeroWrap(1, mx);
+    VpActiveRound(c.real, a.real, rounding_mode, iLoc);
+
+    RB_GC_GUARD(a.bigdecimal);
+
+    if (argc == 0) {
+        return BigDecimal_to_i(CheckGetValue(c));
+    }
+    return CheckGetValue(c);
 }
 
 /* call-seq:
- * truncate(n)
+ *   truncate(n)
  *
  * Truncate to the nearest integer (by default), returning the result as a
  * BigDecimal.
@@ -2554,28 +2162,7 @@ BigDecimal_round(int argc, VALUE *argv, VALUE self)
 static VALUE
 BigDecimal_truncate(int argc, VALUE *argv, VALUE self)
 {
-    ENTER(5);
-    Real *c, *a;
-    int iLoc;
-    VALUE vLoc;
-    size_t mx, pl = VpSetPrecLimit(0);
-
-    if (rb_scan_args(argc, argv, "01", &vLoc) == 0) {
-	iLoc = 0;
-    }
-    else {
-	iLoc = NUM2INT(vLoc);
-    }
-
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    mx = a->Prec * (VpBaseFig() + 1);
-    GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
-    VpSetPrecLimit(pl);
-    VpActiveRound(c, a, VP_ROUND_DOWN, iLoc); /* 0: truncate */
-    if (argc == 0) {
-        return BigDecimal_to_i(VpCheckGetValue(c));
-    }
-    return VpCheckGetValue(c);
+    return BigDecimal_truncate_floor_ceil(argc, argv, self, VP_ROUND_DOWN);
 }
 
 /* Return the fractional part of the number, as a BigDecimal.
@@ -2583,19 +2170,15 @@ BigDecimal_truncate(int argc, VALUE *argv, VALUE self)
 static VALUE
 BigDecimal_frac(VALUE self)
 {
-    ENTER(5);
-    Real *c, *a;
-    size_t mx;
-
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    mx = a->Prec * (VpBaseFig() + 1);
-    GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
-    VpFrac(c, a);
-    return VpCheckGetValue(c);
+    BDVALUE a = GetBDValueMust(self);
+    BDVALUE c = NewZeroWrap(1, (a.real->Prec + 1) * BASE_FIG);
+    VpFrac(c.real, a.real);
+    RB_GC_GUARD(a.bigdecimal);
+    return CheckGetValue(c);
 }
 
 /* call-seq:
- * floor(n)
+ *   floor(n)
  *
  * Return the largest integer less than or equal to the value, as a BigDecimal.
  *
@@ -2614,35 +2197,11 @@ BigDecimal_frac(VALUE self)
 static VALUE
 BigDecimal_floor(int argc, VALUE *argv, VALUE self)
 {
-    ENTER(5);
-    Real *c, *a;
-    int iLoc;
-    VALUE vLoc;
-    size_t mx, pl = VpSetPrecLimit(0);
-
-    if (rb_scan_args(argc, argv, "01", &vLoc)==0) {
-	iLoc = 0;
-    }
-    else {
-	iLoc = NUM2INT(vLoc);
-    }
-
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    mx = a->Prec * (VpBaseFig() + 1);
-    GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
-    VpSetPrecLimit(pl);
-    VpActiveRound(c, a, VP_ROUND_FLOOR, iLoc);
-#ifdef BIGDECIMAL_DEBUG
-    VPrint(stderr, "floor: c=%\n", c);
-#endif
-    if (argc == 0) {
-        return BigDecimal_to_i(VpCheckGetValue(c));
-    }
-    return VpCheckGetValue(c);
+    return BigDecimal_truncate_floor_ceil(argc, argv, self, VP_ROUND_FLOOR);
 }
 
 /* call-seq:
- * ceil(n)
+ *   ceil(n)
  *
  * Return the smallest integer greater than or equal to the value, as a BigDecimal.
  *
@@ -2661,31 +2220,11 @@ BigDecimal_floor(int argc, VALUE *argv, VALUE self)
 static VALUE
 BigDecimal_ceil(int argc, VALUE *argv, VALUE self)
 {
-    ENTER(5);
-    Real *c, *a;
-    int iLoc;
-    VALUE vLoc;
-    size_t mx, pl = VpSetPrecLimit(0);
-
-    if (rb_scan_args(argc, argv, "01", &vLoc) == 0) {
-	iLoc = 0;
-    } else {
-	iLoc = NUM2INT(vLoc);
-    }
-
-    GUARD_OBJ(a, GetVpValue(self, 1));
-    mx = a->Prec * (VpBaseFig() + 1);
-    GUARD_OBJ(c, NewZeroWrapLimited(1, mx));
-    VpSetPrecLimit(pl);
-    VpActiveRound(c, a, VP_ROUND_CEIL, iLoc);
-    if (argc == 0) {
-        return BigDecimal_to_i(VpCheckGetValue(c));
-    }
-    return VpCheckGetValue(c);
+    return BigDecimal_truncate_floor_ceil(argc, argv, self, VP_ROUND_CEIL);
 }
 
 /* call-seq:
- * to_s(s)
+ *   to_s(s)
  *
  * Converts the value to a string.
  *
@@ -2702,7 +2241,7 @@ BigDecimal_ceil(int argc, VALUE *argv, VALUE self)
  * If s contains a number, a space is inserted after each group of that many
  * digits, starting from '.' and counting outwards.
  *
- * If s ends with an 'E', engineering notation (0.xxxxEnn) is used.
+ * If s ends with an 'E', scientific notation (0.xxxxEnn) is used.
  *
  * If s ends with an 'F', conventional floating point notation is used.
  *
@@ -2720,10 +2259,9 @@ BigDecimal_ceil(int argc, VALUE *argv, VALUE self)
 static VALUE
 BigDecimal_to_s(int argc, VALUE *argv, VALUE self)
 {
-    ENTER(5);
     int   fmt = 0;   /* 0: E format, 1: F format */
     int   fPlus = 0; /* 0: default, 1: set ' ' before digits, 2: set '+' before digits. */
-    Real  *vp;
+    BDVALUE v;
     volatile VALUE str;
     char  *psz;
     char   ch;
@@ -2731,7 +2269,7 @@ BigDecimal_to_s(int argc, VALUE *argv, VALUE self)
     SIGNED_VALUE m;
     VALUE  f;
 
-    GUARD_OBJ(vp, GetVpValue(self, 1));
+    v = GetBDValueMust(self);
 
     if (rb_scan_args(argc, argv, "01", &f) == 1) {
 	if (RB_TYPE_P(f, T_STRING)) {
@@ -2766,10 +2304,10 @@ BigDecimal_to_s(int argc, VALUE *argv, VALUE self)
 	}
     }
     if (fmt) {
-	nc = VpNumOfChars(vp, "F");
+	nc = VpNumOfChars(v.real, "F");
     }
     else {
-	nc = VpNumOfChars(vp, "E");
+	nc = VpNumOfChars(v.real, "E");
     }
     if (mc > 0) {
 	nc += (nc + mc - 1) / mc + 1;
@@ -2779,12 +2317,14 @@ BigDecimal_to_s(int argc, VALUE *argv, VALUE self)
     psz = RSTRING_PTR(str);
 
     if (fmt) {
-	VpToFString(vp, psz, RSTRING_LEN(str), mc, fPlus);
+	VpToFString(v.real, psz, RSTRING_LEN(str), mc, fPlus);
     }
     else {
-	VpToString (vp, psz, RSTRING_LEN(str), mc, fPlus);
+	VpToString (v.real, psz, RSTRING_LEN(str), mc, fPlus);
     }
     rb_str_resize(str, strlen(psz));
+
+    RB_GC_GUARD(v.bigdecimal);
     return str;
 }
 
@@ -2801,471 +2341,163 @@ BigDecimal_to_s(int argc, VALUE *argv, VALUE self)
  *
  * The fourth value is an Integer exponent.
  *
- * If the BigDecimal can be represented as 0.xxxxxx*10**n, then xxxxxx is the
- * string of significant digits with no leading zeros, and n is the exponent.
- *
- * From these values, you can translate a BigDecimal to a float as follows:
- *
- *   sign, significant_digits, base, exponent = a.split
- *   f = sign * "0.#{significant_digits}".to_f * (base ** exponent)
- *
- * (Note that the to_f method is provided as a more convenient way to translate
- * a BigDecimal to a Float.)
- */
-static VALUE
-BigDecimal_split(VALUE self)
-{
-    ENTER(5);
-    Real *vp;
-    VALUE obj,str;
-    ssize_t e, s;
-    char *psz1;
-
-    GUARD_OBJ(vp, GetVpValue(self, 1));
-    str = rb_str_new(0, VpNumOfChars(vp, "E"));
-    psz1 = RSTRING_PTR(str);
-    VpSzMantissa(vp, psz1, RSTRING_LEN(str));
-    s = 1;
-    if(psz1[0] == '-') {
-	size_t len = strlen(psz1 + 1);
-
-	memmove(psz1, psz1 + 1, len);
-	psz1[len] = '\0';
-        s = -1;
-    }
-    if (psz1[0] == 'N') s = 0; /* NaN */
-    e = VpExponent10(vp);
-    obj = rb_ary_new2(4);
-    rb_ary_push(obj, INT2FIX(s));
-    rb_ary_push(obj, str);
-    rb_str_resize(str, strlen(psz1));
-    rb_ary_push(obj, INT2FIX(10));
-    rb_ary_push(obj, SSIZET2NUM(e));
-    return obj;
-}
-
-/* Returns the exponent of the BigDecimal number, as an Integer.
- *
- * If the number can be represented as 0.xxxxxx*10**n where xxxxxx is a string
- * of digits with no leading zeros, then n is the exponent.
- */
-static VALUE
-BigDecimal_exponent(VALUE self)
-{
-    ssize_t e = VpExponent10(GetVpValue(self, 1));
-    return SSIZET2NUM(e);
-}
-
-/* Returns a string representation of self.
- *
- *   BigDecimal("1234.5678").inspect
- *     #=> "0.12345678e4"
- */
-static VALUE
-BigDecimal_inspect(VALUE self)
-{
-    ENTER(5);
-    Real *vp;
-    volatile VALUE str;
-    size_t nc;
-
-    GUARD_OBJ(vp, GetVpValue(self, 1));
-    nc = VpNumOfChars(vp, "E");
-
-    str = rb_str_new(0, nc);
-    VpToString(vp, RSTRING_PTR(str), RSTRING_LEN(str), 0, 0);
-    rb_str_resize(str, strlen(RSTRING_PTR(str)));
-    return str;
-}
-
-static VALUE BigMath_s_exp(VALUE, VALUE, VALUE);
-static VALUE BigMath_s_log(VALUE, VALUE, VALUE);
-
-#define BigMath_exp(x, n) BigMath_s_exp(rb_mBigMath, (x), (n))
-#define BigMath_log(x, n) BigMath_s_log(rb_mBigMath, (x), (n))
-
-inline static int
-is_integer(VALUE x)
-{
-    return (RB_TYPE_P(x, T_FIXNUM) || RB_TYPE_P(x, T_BIGNUM));
-}
-
-inline static int
-is_negative(VALUE x)
-{
-    if (FIXNUM_P(x)) {
-	return FIX2LONG(x) < 0;
-    }
-    else if (RB_TYPE_P(x, T_BIGNUM)) {
-	return FIX2INT(rb_big_cmp(x, INT2FIX(0))) < 0;
-    }
-    else if (RB_TYPE_P(x, T_FLOAT)) {
-	return RFLOAT_VALUE(x) < 0.0;
-    }
-    return RTEST(rb_funcall(x, '<', 1, INT2FIX(0)));
-}
-
-#define is_positive(x) (!is_negative(x))
-
-inline static int
-is_zero(VALUE x)
-{
-    VALUE num;
-
-    switch (TYPE(x)) {
-      case T_FIXNUM:
-	return FIX2LONG(x) == 0;
-
-      case T_BIGNUM:
-	return Qfalse;
-
-      case T_RATIONAL:
-	num = rb_rational_num(x);
-	return FIXNUM_P(num) && FIX2LONG(num) == 0;
-
-      default:
-	break;
-    }
-
-    return RTEST(rb_funcall(x, id_eq, 1, INT2FIX(0)));
-}
-
-inline static int
-is_one(VALUE x)
-{
-    VALUE num, den;
-
-    switch (TYPE(x)) {
-      case T_FIXNUM:
-	return FIX2LONG(x) == 1;
-
-      case T_BIGNUM:
-	return Qfalse;
-
-      case T_RATIONAL:
-	num = rb_rational_num(x);
-	den = rb_rational_den(x);
-	return FIXNUM_P(den) && FIX2LONG(den) == 1 &&
-	       FIXNUM_P(num) && FIX2LONG(num) == 1;
-
-      default:
-	break;
-    }
-
-    return RTEST(rb_funcall(x, id_eq, 1, INT2FIX(1)));
-}
-
-inline static int
-is_even(VALUE x)
-{
-    switch (TYPE(x)) {
-      case T_FIXNUM:
-	return (FIX2LONG(x) % 2) == 0;
-
-      case T_BIGNUM:
-        {
-            unsigned long l;
-            rb_big_pack(x, &l, 1);
-            return l % 2 == 0;
-        }
-
-      default:
-	break;
-    }
-
-    return 0;
-}
-
-static VALUE
-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 VpCheckGetValue(NewOneWrapLimited(1, n));
-    }
-
-    log_x = BigMath_log(x->obj, SSIZET2NUM(n+1));
-    multiplied = BigDecimal_mult2(exp->obj, log_x, SSIZET2NUM(n+1));
-    y = BigMath_exp(multiplied, SSIZET2NUM(n));
-    RB_GC_GUARD(obj);
-
-    return y;
-}
-
-/* call-seq:
- * power(n)
- * power(n, prec)
- *
- * Returns the value raised to the power of n.
- *
- * Note that n must be an Integer.
- *
- * Also available as the operator **.
- */
-static VALUE
-BigDecimal_power(int argc, VALUE*argv, VALUE self)
-{
-    ENTER(5);
-    VALUE vexp, prec;
-    Real* exp = NULL;
-    Real *x, *y;
-    ssize_t mp, ma, n;
-    SIGNED_VALUE int_exp;
-    double d;
-
-    rb_scan_args(argc, argv, "11", &vexp, &prec);
-
-    GUARD_OBJ(x, GetVpValue(self, 1));
-    n = NIL_P(prec) ? (ssize_t)(x->Prec*VpBaseFig()) : NUM2SSIZET(prec);
-
-    if (VpIsNaN(x)) {
-        y = NewZeroWrapLimited(1, n);
-        VpSetNaN(y);
-        RB_GC_GUARD(y->obj);
-        return VpCheckGetValue(y);
-    }
-
-  retry:
-    switch (TYPE(vexp)) {
-      case T_FIXNUM:
-	break;
-
-      case T_BIGNUM:
-	break;
-
-      case T_FLOAT:
-	d = RFLOAT_VALUE(vexp);
-	if (d == round(d)) {
-	    if (FIXABLE(d)) {
-		vexp = LONG2FIX((long)d);
-	    }
-	    else {
-		vexp = rb_dbl2big(d);
-	    }
-	    goto retry;
-	}
-        if (NIL_P(prec)) {
-            n += BIGDECIMAL_DOUBLE_FIGURES;
-        }
-        exp = GetVpValueWithPrec(vexp, 0, 1);
-	break;
-
-      case T_RATIONAL:
-	if (is_zero(rb_rational_num(vexp))) {
-	    if (is_positive(vexp)) {
-		vexp = INT2FIX(0);
-		goto retry;
-	    }
-	}
-	else if (is_one(rb_rational_den(vexp))) {
-	    vexp = rb_rational_num(vexp);
-	    goto retry;
-	}
-	exp = GetVpValueWithPrec(vexp, n, 1);
-        if (NIL_P(prec)) {
-            n += n;
-        }
-	break;
-
-      case T_DATA:
-	if (is_kind_of_BigDecimal(vexp)) {
-	    VALUE zero = INT2FIX(0);
-	    VALUE rounded = BigDecimal_round(1, &zero, vexp);
-	    if (RTEST(BigDecimal_eq(vexp, rounded))) {
-		vexp = BigDecimal_to_i(vexp);
-		goto retry;
-	    }
-            if (NIL_P(prec)) {
-                GUARD_OBJ(y, GetVpValue(vexp, 1));
-                n += y->Prec*VpBaseFig();
-            }
-	    exp = DATA_PTR(vexp);
-	    break;
-	}
-	/* fall through */
-      default:
-	rb_raise(rb_eTypeError,
-		 "wrong argument type %"PRIsVALUE" (expected scalar Numeric)",
-		 RB_OBJ_CLASSNAME(vexp));
-    }
-
-    if (VpIsZero(x)) {
-        if (is_negative(vexp)) {
-            y = NewZeroWrapNolimit(1, n);
-            if (BIGDECIMAL_NEGATIVE_P(x)) {
-                if (is_integer(vexp)) {
-                    if (is_even(vexp)) {
-                        /* (-0) ** (-even_integer)  -> Infinity */
-                        VpSetPosInf(y);
-                    }
-                    else {
-                        /* (-0) ** (-odd_integer)  -> -Infinity */
-                        VpSetNegInf(y);
-                    }
-                }
-                else {
-                    /* (-0) ** (-non_integer)  -> Infinity */
-                    VpSetPosInf(y);
-                }
-            }
-            else {
-                /* (+0) ** (-num)  -> Infinity */
-                VpSetPosInf(y);
-            }
-            RB_GC_GUARD(y->obj);
-            return VpCheckGetValue(y);
-        }
-        else if (is_zero(vexp)) {
-            return VpCheckGetValue(NewOneWrapLimited(1, n));
-        }
-        else {
-            return VpCheckGetValue(NewZeroWrapLimited(1, n));
-        }
-    }
-
-    if (is_zero(vexp)) {
-        return VpCheckGetValue(NewOneWrapLimited(1, n));
-    }
-    else if (is_one(vexp)) {
-        return self;
-    }
-
-    if (VpIsInf(x)) {
-        if (is_negative(vexp)) {
-            if (BIGDECIMAL_NEGATIVE_P(x)) {
-                if (is_integer(vexp)) {
-                    if (is_even(vexp)) {
-                        /* (-Infinity) ** (-even_integer) -> +0 */
-                        return VpCheckGetValue(NewZeroWrapLimited(1, n));
-                    }
-                    else {
-                        /* (-Infinity) ** (-odd_integer) -> -0 */
-                        return VpCheckGetValue(NewZeroWrapLimited(-1, n));
-                    }
-                }
-                else {
-                    /* (-Infinity) ** (-non_integer) -> -0 */
-                    return VpCheckGetValue(NewZeroWrapLimited(-1, n));
-                }
-            }
-            else {
-                return VpCheckGetValue(NewZeroWrapLimited(1, n));
-            }
-        }
-        else {
-            y = NewZeroWrapLimited(1, n);
-            if (BIGDECIMAL_NEGATIVE_P(x)) {
-                if (is_integer(vexp)) {
-                    if (is_even(vexp)) {
-                        VpSetPosInf(y);
-                    }
-                    else {
-                        VpSetNegInf(y);
-                    }
-                }
-                else {
-                    /* TODO: support complex */
-                    rb_raise(rb_eMathDomainError,
-                            "a non-integral exponent for a negative base");
-                }
-            }
-            else {
-                VpSetPosInf(y);
-            }
-            return VpCheckGetValue(y);
-        }
-    }
-
-    if (exp != NULL) {
-        return bigdecimal_power_by_bigdecimal(x, exp, n);
-    }
-    else if (RB_TYPE_P(vexp, T_BIGNUM)) {
-        VALUE abs_value = BigDecimal_abs(self);
-        if (is_one(abs_value)) {
-            return VpCheckGetValue(NewOneWrapLimited(1, n));
-        }
-        else if (RTEST(rb_funcall(abs_value, '<', 1, INT2FIX(1)))) {
-            if (is_negative(vexp)) {
-                y = NewZeroWrapLimited(1, n);
-                VpSetInf(y, (is_even(vexp) ? 1 : -1) * VpGetSign(x));
-                return VpCheckGetValue(y);
-            }
-            else if (BIGDECIMAL_NEGATIVE_P(x) && is_even(vexp)) {
-                return VpCheckGetValue(NewZeroWrapLimited(-1, n));
-            }
-            else {
-                return VpCheckGetValue(NewZeroWrapLimited(1, n));
-            }
-        }
-        else {
-            if (is_positive(vexp)) {
-                y = NewZeroWrapLimited(1, n);
-                VpSetInf(y, (is_even(vexp) ? 1 : -1) * VpGetSign(x));
-                return VpCheckGetValue(y);
-            }
-            else if (BIGDECIMAL_NEGATIVE_P(x) && is_even(vexp)) {
-                return VpCheckGetValue(NewZeroWrapLimited(-1, n));
-            }
-            else {
-                return VpCheckGetValue(NewZeroWrapLimited(1, n));
-            }
-        }
-    }
+ * If the BigDecimal can be represented as 0.xxxxxx*10**n, then xxxxxx is the
+ * string of significant digits with no leading zeros, and n is the exponent.
+ *
+ * From these values, you can translate a BigDecimal to a float as follows:
+ *
+ *   sign, significant_digits, base, exponent = a.split
+ *   f = sign * "0.#{significant_digits}".to_f * (base ** exponent)
+ *
+ * (Note that the to_f method is provided as a more convenient way to translate
+ * a BigDecimal to a Float.)
+ */
+static VALUE
+BigDecimal_split(VALUE self)
+{
+    BDVALUE v;
+    VALUE obj,str;
+    ssize_t e, s;
+    char *psz1;
 
-    int_exp = FIX2LONG(vexp);
-    ma = int_exp;
-    if (ma <  0) ma = -ma;
-    if (ma == 0) ma = 1;
+    v = GetBDValueMust(self);
+    str = rb_str_new(0, VpNumOfChars(v.real, "E"));
+    psz1 = RSTRING_PTR(str);
+    VpSzMantissa(v.real, psz1, RSTRING_LEN(str));
+    s = 1;
+    if(psz1[0] == '-') {
+	size_t len = strlen(psz1 + 1);
 
-    if (VpIsDef(x)) {
-        mp = x->Prec * (VpBaseFig() + 1);
-        GUARD_OBJ(y, NewZeroWrapLimited(1, mp * (ma + 1)));
-    }
-    else {
-        GUARD_OBJ(y, NewZeroWrapLimited(1, 1));
-    }
-    VpPowerByInt(y, x, int_exp);
-    if (!NIL_P(prec) && VpIsDef(y)) {
-        VpMidRound(y, VpGetRoundMode(), n);
+	memmove(psz1, psz1 + 1, len);
+	psz1[len] = '\0';
+        s = -1;
     }
-    return VpCheckGetValue(y);
+    if (psz1[0] == 'N') s = 0; /* NaN */
+    e = VpExponent10(v.real);
+    obj = rb_ary_new2(4);
+    rb_ary_push(obj, INT2FIX(s));
+    rb_ary_push(obj, str);
+    rb_str_resize(str, strlen(psz1));
+    rb_ary_push(obj, INT2FIX(10));
+    rb_ary_push(obj, SSIZET2NUM(e));
+
+    RB_GC_GUARD(v.bigdecimal);
+    return obj;
 }
 
-/*  call-seq:
- *    self ** other -> bigdecimal
- *
- *  Returns the \BigDecimal value of +self+ raised to power +other+:
- *
- *    b = BigDecimal('3.14')
- *    b ** 2              # => 0.98596e1
- *    b ** 2.0            # => 0.98596e1
- *    b ** Rational(2, 1) # => 0.98596e1
+/* Returns the exponent of the BigDecimal number, as an Integer.
  *
- *  Related: BigDecimal#power.
+ * If the number can be represented as 0.xxxxxx*10**n where xxxxxx is a string
+ * of digits with no leading zeros, then n is the exponent.
+ */
+static VALUE
+BigDecimal_exponent(VALUE self)
+{
+    ssize_t e = VpExponent10(GetSelfVpValue(self));
+    return SSIZET2NUM(e);
+}
+
+/* Returns a string representation of self.
  *
+ *   BigDecimal("1234.5678").inspect
+ *     #=> "0.12345678e4"
  */
 static VALUE
-BigDecimal_power_op(VALUE self, VALUE exp)
+BigDecimal_inspect(VALUE self)
 {
-    return BigDecimal_power(1, &exp, self);
+    BDVALUE v;
+    volatile VALUE str;
+    size_t nc;
+
+    v = GetBDValueMust(self);
+    nc = VpNumOfChars(v.real, "E");
+
+    str = rb_str_new(0, nc);
+    VpToString(v.real, RSTRING_PTR(str), RSTRING_LEN(str), 0, 0);
+    rb_str_resize(str, strlen(RSTRING_PTR(str)));
+
+    RB_GC_GUARD(v.bigdecimal);
+    return str;
 }
 
-/* :nodoc:
+/* Returns self * 10**v without changing the precision.
+ *   This method is currently for internal use.
  *
- * private method for dup and clone the provided BigDecimal +other+
+ *   BigDecimal("0.123e10")._decimal_shift(20) #=> "0.123e30"
+ *   BigDecimal("0.123e10")._decimal_shift(-20) #=> "0.123e-10"
  */
 static VALUE
-BigDecimal_initialize_copy(VALUE self, VALUE other)
+BigDecimal_decimal_shift(VALUE self, VALUE v)
+{
+    BDVALUE a, c;
+    ssize_t shift, exponentShift;
+    bool shiftDown;
+    size_t prec;
+    DECDIG ex, iex;
+
+    a = GetBDValueMust(self);
+    shift = NUM2SSIZET(rb_to_int(v));
+
+    if (VpIsZero(a.real) || VpIsNaN(a.real) || VpIsInf(a.real) || shift == 0) return CheckGetValue(a);
+
+    exponentShift = shift > 0 ? shift / BASE_FIG : (shift + 1) / BASE_FIG - 1;
+    shift -= exponentShift * BASE_FIG;
+    ex = 1;
+    for (int i = 0; i < shift; i++) ex *= 10;
+    shiftDown = a.real->frac[0] * (DECDIG_DBL)ex >= BASE;
+    iex = BASE / ex;
+
+    prec = a.real->Prec + shiftDown;
+    c = NewZeroWrap(1, prec * BASE_FIG);
+    if (shift == 0) {
+        VpAsgn(c.real, a.real, 10);
+    } else if (shiftDown) {
+        DECDIG carry = 0;
+        exponentShift++;
+        for (size_t i = 0; i < a.real->Prec; i++) {
+            DECDIG v = a.real->frac[i];
+            c.real->frac[i] = carry * ex + v / iex;
+            carry = v % iex;
+        }
+        c.real->frac[a.real->Prec] = carry * ex;
+    } else {
+        DECDIG carry = 0;
+        for (ssize_t i = a.real->Prec - 1; i >= 0; i--) {
+            DECDIG v = a.real->frac[i];
+            c.real->frac[i] = v % iex * ex + carry;
+            carry = v / iex;
+        }
+    }
+    while (c.real->frac[prec - 1] == 0) prec--;
+    c.real->Prec = prec;
+    c.real->sign = a.real->sign;
+    c.real->exponent = a.real->exponent;
+    AddExponent(c.real, exponentShift);
+    RB_GC_GUARD(a.bigdecimal);
+    return CheckGetValue(c);
+}
+
+inline static int
+is_zero(VALUE x)
 {
-    Real *pv = rb_check_typeddata(self, &BigDecimal_data_type);
-    Real *x = rb_check_typeddata(other, &BigDecimal_data_type);
+    VALUE num;
+
+    switch (TYPE(x)) {
+      case T_FIXNUM:
+	return FIX2LONG(x) == 0;
+
+      case T_BIGNUM:
+	return Qfalse;
+
+      case T_RATIONAL:
+	num = rb_rational_num(x);
+	return FIXNUM_P(num) && FIX2LONG(num) == 0;
 
-    if (self != other) {
-	DATA_PTR(self) = VpCopy(pv, x);
+      default:
+	break;
     }
-    return self;
+
+    return RTEST(rb_funcall(x, id_eq, 1, INT2FIX(0)));
 }
 
 /* :nodoc: */
@@ -3304,30 +2536,27 @@ check_exception(VALUE bd)
 {
     assert(is_kind_of_BigDecimal(bd));
 
-    Real *vp;
-    TypedData_Get_Struct(bd, Real, &BigDecimal_data_type, vp);
-    VpCheckGetValue(vp); /* VpCheckGetValue performs exception check */
+    VpCheckException(VpPtr(bd), false);
 
     return bd;
 }
 
 static VALUE
-rb_uint64_convert_to_BigDecimal(uint64_t uval, RB_UNUSED_VAR(size_t digs), int raise_exception)
+rb_uint64_convert_to_BigDecimal(uint64_t uval)
 {
-    VALUE obj = TypedData_Wrap_Struct(rb_cBigDecimal, &BigDecimal_data_type, 0);
-
+    VALUE bd;
     Real *vp;
     if (uval == 0) {
-        vp = rbd_allocate_struct(1);
-        vp->MaxPrec = 1;
+        bd = BigDecimal_allocate(1);
+        vp = VpPtr(bd);
         vp->Prec = 1;
         vp->exponent = 1;
         VpSetZero(vp, 1);
         vp->frac[0] = 0;
     }
     else if (uval < BASE) {
-        vp = rbd_allocate_struct(1);
-        vp->MaxPrec = 1;
+        bd = BigDecimal_allocate(1);
+        vp = VpPtr(bd);
         vp->Prec = 1;
         vp->exponent = 1;
         VpSetSign(vp, 1);
@@ -3352,32 +2581,31 @@ rb_uint64_convert_to_BigDecimal(uint64_t uval, RB_UNUSED_VAR(size_t digs), int r
         }
 
         const size_t exp = len + ntz;
-        vp = rbd_allocate_struct(len);
-        vp->MaxPrec = len;
+        bd = BigDecimal_allocate(len);
+        vp = VpPtr(bd);
         vp->Prec = len;
         vp->exponent = exp;
         VpSetSign(vp, 1);
         MEMCPY(vp->frac, buf + BIGDECIMAL_INT64_MAX_LENGTH - len, DECDIG, len);
     }
 
-    return BigDecimal_wrap_struct(obj, vp);
+    return bd;
 }
 
 static VALUE
-rb_int64_convert_to_BigDecimal(int64_t ival, size_t digs, int raise_exception)
+rb_int64_convert_to_BigDecimal(int64_t ival)
 {
     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);
+    VALUE bd = rb_uint64_convert_to_BigDecimal(uval);
     if (ival < 0) {
-        Real *vp;
-        TypedData_Get_Struct(bd, Real, &BigDecimal_data_type, vp);
+        Real *vp = VpPtr(bd);
         VpSetSign(vp, -1);
     }
     return bd;
 }
 
 static VALUE
-rb_big_convert_to_BigDecimal(VALUE val, RB_UNUSED_VAR(size_t digs), int raise_exception)
+rb_big_convert_to_BigDecimal(VALUE val)
 {
     assert(RB_TYPE_P(val, T_BIGNUM));
 
@@ -3389,40 +2617,44 @@ rb_big_convert_to_BigDecimal(VALUE val, RB_UNUSED_VAR(size_t digs), int raise_ex
     }
     if (size <= sizeof(long)) {
         if (sign < 0) {
-            return rb_int64_convert_to_BigDecimal(NUM2LONG(val), digs, raise_exception);
+            return rb_int64_convert_to_BigDecimal(NUM2LONG(val));
         }
         else {
-            return rb_uint64_convert_to_BigDecimal(NUM2ULONG(val), digs, raise_exception);
+            return rb_uint64_convert_to_BigDecimal(NUM2ULONG(val));
         }
     }
 #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);
+            return rb_int64_convert_to_BigDecimal(NUM2LL(val));
         }
         else {
-            return rb_uint64_convert_to_BigDecimal(NUM2ULL(val), digs, raise_exception);
+            return rb_uint64_convert_to_BigDecimal(NUM2ULL(val));
         }
     }
 #endif
     else {
         VALUE str = rb_big2str(val, 10);
-        Real *vp = VpCreateRbObject(RSTRING_LEN(str) + BASE_FIG + 1,
-                                    RSTRING_PTR(str), true);
+        BDVALUE v = bdvalue_nonnullable(CreateFromString(
+            RSTRING_PTR(str),
+            rb_cBigDecimal,
+            true,
+            true
+        ));
         RB_GC_GUARD(str);
-        return check_exception(vp->obj);
+        return CheckGetValue(v);
     }
 }
 
 static VALUE
-rb_inum_convert_to_BigDecimal(VALUE val, RB_UNUSED_VAR(size_t digs), int raise_exception)
+rb_inum_convert_to_BigDecimal(VALUE val)
 {
     assert(RB_INTEGER_TYPE_P(val));
     if (FIXNUM_P(val)) {
-        return rb_int64_convert_to_BigDecimal(FIX2LONG(val), digs, raise_exception);
+        return rb_int64_convert_to_BigDecimal(FIX2LONG(val));
     }
     else {
-        return rb_big_convert_to_BigDecimal(val, digs, raise_exception);
+        return rb_big_convert_to_BigDecimal(val);
     }
 }
 
@@ -3457,11 +2689,7 @@ rb_float_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
     }
 
     if (digs == SIZE_MAX) {
-        if (!raise_exception)
-            return Qnil;
-        rb_raise(rb_eArgError,
-                 "can't omit precision for a %"PRIsVALUE".",
-                 CLASS_OF(val));
+        digs = 0;
     }
     else if (digs > BIGDECIMAL_DOUBLE_FIGURES) {
         if (!raise_exception)
@@ -3481,7 +2709,7 @@ rb_float_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
         len10 = BIGDECIMAL_DOUBLE_FIGURES;
     }
     memcpy(buf, p, len10);
-    xfree(p);
+    free(p);
 
     VALUE inum;
     size_t RB_UNUSED_VAR(prec) = 0;
@@ -3576,9 +2804,8 @@ rb_float_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
         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);
+    VALUE bd = rb_inum_convert_to_BigDecimal(inum);
+    Real *vp = VpPtr(bd);
     assert(vp->Prec == prec);
     vp->exponent = exp;
 
@@ -3599,28 +2826,24 @@ rb_rational_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
                  CLASS_OF(val));
     }
 
-    VALUE num = rb_inum_convert_to_BigDecimal(rb_rational_num(val), 0, raise_exception);
+    VALUE num = rb_inum_convert_to_BigDecimal(rb_rational_num(val));
     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)
+rb_cstr_convert_to_BigDecimal(const char *c_str, int raise_exception)
 {
-    if (digs == SIZE_MAX)
-        digs = 0;
-
-    Real *vp = VpCreateRbObject(digs, c_str, raise_exception);
-    if (!vp)
-        return Qnil;
-    return VpCheckGetValue(vp);
+    NULLABLE_BDVALUE v = CreateFromString(c_str, rb_cBigDecimal, true, raise_exception);
+    if (v.bigdecimal_or_nil == Qnil) return Qnil;
+    return CheckGetValue(bdvalue_nonnullable(v));
 }
 
 static inline VALUE
-rb_str_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
+rb_str_convert_to_BigDecimal(VALUE val, int raise_exception)
 {
     const char *c_str = StringValueCStr(val);
-    return rb_cstr_convert_to_BigDecimal(c_str, digs, raise_exception);
+    return rb_cstr_convert_to_BigDecimal(c_str, raise_exception);
 }
 
 static VALUE
@@ -3648,17 +2871,20 @@ rb_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
         if (digs == SIZE_MAX)
             return check_exception(val);
 
-        Real *vp;
-        TypedData_Get_Struct(val, Real, &BigDecimal_data_type, vp);
+        Real *vp = VpPtr(val);
+
+        VALUE copy = BigDecimal_allocate(vp->MaxPrec);
+        Real *vp_copy = VpPtr(copy);
+
+        VpMemCopy(vp_copy, vp);
+
+        RB_GC_GUARD(val);
 
-        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);
+        return check_exception(copy);
     }
     else if (RB_INTEGER_TYPE_P(val)) {
-        return rb_inum_convert_to_BigDecimal(val, digs, raise_exception);
+        return rb_inum_convert_to_BigDecimal(val);
     }
     else if (RB_FLOAT_TYPE_P(val)) {
         return rb_float_convert_to_BigDecimal(val, digs, raise_exception);
@@ -3676,7 +2902,7 @@ rb_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
         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);
+        return rb_str_convert_to_BigDecimal(val, raise_exception);
     }
 
     /* TODO: chheck to_d */
@@ -3690,7 +2916,7 @@ rb_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
         }
         return Qnil;
     }
-    return rb_str_convert_to_BigDecimal(str, digs, raise_exception);
+    return rb_str_convert_to_BigDecimal(str, raise_exception);
 }
 
 /*  call-seq:
@@ -3711,12 +2937,12 @@ rb_convert_to_BigDecimal(VALUE val, size_t digs, int raise_exception)
  *
  *  - Integer, Float, Rational, Complex, or BigDecimal: converted directly:
  *
- *      # Integer, Complex, or BigDecimal value does not require ndigits; ignored if given.
+ *      # Integer, Complex, Float, 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(2.0)                   # => 0.2e1
+ *      # Rational value requires ndigits.
  *      BigDecimal(Rational(2, 1), 0)     # => 0.2e1
  *
  *  - String: converted by parsing if it contains an integer or floating-point literal;
@@ -3780,15 +3006,16 @@ static VALUE
 BigDecimal_s_interpret_loosely(VALUE klass, VALUE str)
 {
     char const *c_str = StringValueCStr(str);
-    Real *vp = VpNewRbClass(0, c_str, klass, false, true);
-    if (!vp)
+    NULLABLE_BDVALUE v = CreateFromString(c_str, klass, false, true);
+    if (v.bigdecimal_or_nil == Qnil)
         return Qnil;
     else
-        return VpCheckGetValue(vp);
+        return CheckGetValue(bdvalue_nonnullable(v));
 }
 
- /* call-seq:
-  * BigDecimal.limit(digits)
+ /*
+  * call-seq:
+  *   BigDecimal.limit(digits)
   *
   * Limit the number of significant digits in newly created BigDecimal
   * numbers to the specified value. Rounding is performed as necessary,
@@ -3838,7 +3065,7 @@ BigDecimal_limit(int argc, VALUE *argv, VALUE self)
 static VALUE
 BigDecimal_sign(VALUE self)
 { /* sign */
-    int s = GetVpValue(self, 1)->sign;
+    int s = GetSelfVpValue(self)->sign;
     return INT2FIX(s);
 }
 
@@ -3921,301 +3148,6 @@ BigDecimal_save_limit(VALUE self)
     return ret;
 }
 
-/* call-seq:
- * BigMath.exp(decimal, numeric)    -> BigDecimal
- *
- * Computes the value of e (the base of natural logarithms) raised to the
- * power of +decimal+, to the specified number of digits of precision.
- *
- * If +decimal+ is infinity, returns Infinity.
- *
- * If +decimal+ is NaN, returns NaN.
- */
-static VALUE
-BigMath_s_exp(VALUE klass, VALUE x, VALUE vprec)
-{
-    ssize_t prec, n, i;
-    Real* vx = NULL;
-    VALUE one, d, y;
-    int negative = 0;
-    int infinite = 0;
-    int nan = 0;
-    double flo;
-
-    prec = NUM2SSIZET(vprec);
-    if (prec <= 0) {
-	rb_raise(rb_eArgError, "Zero or negative precision for exp");
-    }
-
-    /* TODO: the following switch statement is almost same as one in the
-     *       BigDecimalCmp function. */
-    switch (TYPE(x)) {
-      case T_DATA:
-	if (!is_kind_of_BigDecimal(x)) break;
-	vx = DATA_PTR(x);
-	negative = BIGDECIMAL_NEGATIVE_P(vx);
-	infinite = VpIsPosInf(vx) || VpIsNegInf(vx);
-	nan = VpIsNaN(vx);
-	break;
-
-      case T_FIXNUM:
-	/* fall through */
-      case T_BIGNUM:
-	vx = GetVpValue(x, 0);
-	break;
-
-      case T_FLOAT:
-	flo = RFLOAT_VALUE(x);
-	negative = flo < 0;
-	infinite = isinf(flo);
-	nan = isnan(flo);
-	if (!infinite && !nan) {
-	    vx = GetVpValueWithPrec(x, 0, 0);
-	}
-	break;
-
-      case T_RATIONAL:
-	vx = GetVpValueWithPrec(x, prec, 0);
-	break;
-
-      default:
-	break;
-    }
-    if (infinite) {
-	if (negative) {
-            return VpCheckGetValue(GetVpValueWithPrec(INT2FIX(0), prec, 1));
-	}
-	else {
-	    Real* vy = NewZeroWrapNolimit(1, prec);
-	    VpSetInf(vy, VP_SIGN_POSITIVE_INFINITE);
-	    RB_GC_GUARD(vy->obj);
-            return VpCheckGetValue(vy);
-	}
-    }
-    else if (nan) {
-        Real* vy = NewZeroWrapNolimit(1, prec);
-        VpSetNaN(vy);
-        RB_GC_GUARD(vy->obj);
-        return VpCheckGetValue(vy);
-    }
-    else if (vx == NULL) {
-	cannot_be_coerced_into_BigDecimal(rb_eArgError, x);
-    }
-    x = vx->obj;
-
-    n = prec + BIGDECIMAL_DOUBLE_FIGURES;
-    negative = BIGDECIMAL_NEGATIVE_P(vx);
-    if (negative) {
-        VALUE x_zero = INT2NUM(1);
-        VALUE x_copy = f_BigDecimal(1, &x_zero, klass);
-        x = BigDecimal_initialize_copy(x_copy, x);
-        vx = DATA_PTR(x);
-	VpSetSign(vx, 1);
-    }
-
-    one = VpCheckGetValue(NewOneWrapLimited(1, 1));
-    y   = one;
-    d   = y;
-    i   = 1;
-
-    while (!VpIsZero((Real*)DATA_PTR(d))) {
-	SIGNED_VALUE const ey = VpExponent10(DATA_PTR(y));
-	SIGNED_VALUE const ed = VpExponent10(DATA_PTR(d));
-	ssize_t m = n - vabs(ey - ed);
-
-	rb_thread_check_ints();
-
-	if (m <= 0) {
-	    break;
-	}
-	else if ((size_t)m < BIGDECIMAL_DOUBLE_FIGURES) {
-	    m = BIGDECIMAL_DOUBLE_FIGURES;
-	}
-
-	d = BigDecimal_mult(d, x);                             /* d <- d * x */
-	d = BigDecimal_div2(d, SSIZET2NUM(i), SSIZET2NUM(m));  /* d <- d / i */
-	y = BigDecimal_add(y, d);                              /* y <- y + d  */
-	++i;                                                   /* i  <- i + 1 */
-    }
-
-    if (negative) {
-	return BigDecimal_div2(one, y, vprec);
-    }
-    else {
-	vprec = SSIZET2NUM(prec - VpExponent10(DATA_PTR(y)));
-	return BigDecimal_round(1, &vprec, y);
-    }
-
-    RB_GC_GUARD(one);
-    RB_GC_GUARD(x);
-    RB_GC_GUARD(y);
-    RB_GC_GUARD(d);
-}
-
-/* call-seq:
- * BigMath.log(decimal, numeric)    -> BigDecimal
- *
- * Computes the natural logarithm of +decimal+ to the specified number of
- * digits of precision, +numeric+.
- *
- * If +decimal+ is zero or negative, raises Math::DomainError.
- *
- * If +decimal+ is positive infinity, returns Infinity.
- *
- * If +decimal+ is NaN, returns NaN.
- */
-static VALUE
-BigMath_s_log(VALUE klass, VALUE x, VALUE vprec)
-{
-    ssize_t prec, n, i;
-    SIGNED_VALUE expo;
-    Real* vx = NULL;
-    VALUE vn, one, two, w, x2, y, d;
-    int zero = 0;
-    int negative = 0;
-    int infinite = 0;
-    int nan = 0;
-    double flo;
-    long fix;
-
-    if (!is_integer(vprec)) {
-	rb_raise(rb_eArgError, "precision must be an Integer");
-    }
-
-    prec = NUM2SSIZET(vprec);
-    if (prec <= 0) {
-	rb_raise(rb_eArgError, "Zero or negative precision for exp");
-    }
-
-    /* TODO: the following switch statement is almost same as one in the
-     *       BigDecimalCmp function. */
-    switch (TYPE(x)) {
-      case T_DATA:
-	  if (!is_kind_of_BigDecimal(x)) break;
-	  vx = DATA_PTR(x);
-	  zero = VpIsZero(vx);
-	  negative = BIGDECIMAL_NEGATIVE_P(vx);
-	  infinite = VpIsPosInf(vx) || VpIsNegInf(vx);
-	  nan = VpIsNaN(vx);
-	  break;
-
-      case T_FIXNUM:
-	fix = FIX2LONG(x);
-	zero = fix == 0;
-	negative = fix < 0;
-	goto get_vp_value;
-
-      case T_BIGNUM:
-        i = FIX2INT(rb_big_cmp(x, INT2FIX(0)));
-	zero = i == 0;
-	negative = i < 0;
-get_vp_value:
-	if (zero || negative) break;
-	vx = GetVpValue(x, 0);
-	break;
-
-      case T_FLOAT:
-	flo = RFLOAT_VALUE(x);
-	zero = flo == 0;
-	negative = flo < 0;
-	infinite = isinf(flo);
-	nan = isnan(flo);
-	if (!zero && !negative && !infinite && !nan) {
-	    vx = GetVpValueWithPrec(x, 0, 1);
-	}
-	break;
-
-      case T_RATIONAL:
-	zero = RRATIONAL_ZERO_P(x);
-	negative = RRATIONAL_NEGATIVE_P(x);
-	if (zero || negative) break;
-	vx = GetVpValueWithPrec(x, prec, 1);
-	break;
-
-      case T_COMPLEX:
-	rb_raise(rb_eMathDomainError,
-		 "Complex argument for BigMath.log");
-
-      default:
-	break;
-    }
-    if (infinite && !negative) {
-        Real *vy = NewZeroWrapNolimit(1, prec);
-	RB_GC_GUARD(vy->obj);
-	VpSetInf(vy, VP_SIGN_POSITIVE_INFINITE);
-        return VpCheckGetValue(vy);
-    }
-    else if (nan) {
-	Real* vy = NewZeroWrapNolimit(1, prec);
-	RB_GC_GUARD(vy->obj);
-	VpSetNaN(vy);
-        return VpCheckGetValue(vy);
-    }
-    else if (zero || negative) {
-	rb_raise(rb_eMathDomainError,
-		 "Zero or negative argument for log");
-    }
-    else if (vx == NULL) {
-	cannot_be_coerced_into_BigDecimal(rb_eArgError, x);
-    }
-    x = VpCheckGetValue(vx);
-
-    one = VpCheckGetValue(NewOneWrapLimited(1, 1));
-    two = VpCheckGetValue(VpCreateRbObject(1, "2", true));
-
-    n = prec + BIGDECIMAL_DOUBLE_FIGURES;
-    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, VpCheckGetValue(VpCreateRbObject(1, buf, true)), vn);
-    }
-    else {
-	expo = 0;
-    }
-    w = BigDecimal_sub(x, one);
-    x = BigDecimal_div2(w, BigDecimal_add(x, one), vn);
-    x2 = BigDecimal_mult2(x, x, vn);
-    y = x;
-    d = y;
-    i = 1;
-    while (!VpIsZero((Real*)DATA_PTR(d))) {
-	SIGNED_VALUE const ey = VpExponent10(DATA_PTR(y));
-	SIGNED_VALUE const ed = VpExponent10(DATA_PTR(d));
-	ssize_t m = n - vabs(ey - ed);
-	if (m <= 0) {
-	    break;
-	}
-	else if ((size_t)m < BIGDECIMAL_DOUBLE_FIGURES) {
-	    m = BIGDECIMAL_DOUBLE_FIGURES;
-	}
-
-	x = BigDecimal_mult2(x2, x, vn);
-	i += 2;
-	d = BigDecimal_div2(x, SSIZET2NUM(i), SSIZET2NUM(m));
-	y = BigDecimal_add(y, d);
-    }
-
-    y = BigDecimal_mult(y, two);
-    if (expo != 0) {
-	VALUE log10, vexpo, dy;
-	log10 = BigMath_s_log(klass, INT2FIX(10), vprec);
-        vexpo = VpCheckGetValue(GetVpValue(SSIZET2NUM(expo), 1));
-	dy = BigDecimal_mult(log10, vexpo);
-	y = BigDecimal_add(y, dy);
-    }
-
-    RB_GC_GUARD(one);
-    RB_GC_GUARD(two);
-    RB_GC_GUARD(vn);
-    RB_GC_GUARD(x2);
-    RB_GC_GUARD(y);
-    RB_GC_GUARD(d);
-
-    return y;
-}
-
 static VALUE BIGDECIMAL_NAN = Qnil;
 
 static VALUE
@@ -4267,6 +3199,71 @@ BigDecimal_literal(const char *str)
 
 #define BIGDECIMAL_LITERAL(var, val) (BIGDECIMAL_ ## var = BigDecimal_literal(#val))
 
+#ifdef BIGDECIMAL_USE_VP_TEST_METHODS
+VALUE
+BigDecimal_vpdivd_generic(VALUE self, VALUE r, VALUE cprec, void (*vpdivd_func)(Real*, Real*, Real*, Real*)) {
+    BDVALUE a, b, c, d;
+    size_t cn = NUM2INT(cprec);
+    a = GetBDValueMust(self);
+    b = GetBDValueMust(r);
+    c = NewZeroWrap(1, cn * BASE_FIG);
+    d = NewZeroWrap(1, VPDIVD_REM_PREC(a.real, b.real, c.real) * BASE_FIG);
+    vpdivd_func(c.real, d.real, a.real, b.real);
+    RB_GC_GUARD(a.bigdecimal);
+    RB_GC_GUARD(b.bigdecimal);
+    return rb_assoc_new(c.bigdecimal, d.bigdecimal);
+}
+
+void
+VpDivdNormal(Real *c, Real *r, Real *a, Real *b) {
+    VpDivd(c, r, a, b);
+}
+
+VALUE
+BigDecimal_vpdivd(VALUE self, VALUE r, VALUE cprec) {
+  return BigDecimal_vpdivd_generic(self, r, cprec, VpDivdNormal);
+}
+
+VALUE
+BigDecimal_vpdivd_newton(VALUE self, VALUE r, VALUE cprec) {
+    return BigDecimal_vpdivd_generic(self, r, cprec, VpDivdNewton);
+}
+
+VALUE
+BigDecimal_newton_raphson_inverse(VALUE self, VALUE prec) {
+    return newton_raphson_inverse(self, NUM2SIZET(prec));
+}
+
+VALUE
+BigDecimal_vpmult(VALUE self, VALUE v) {
+    BDVALUE a,b,c;
+    a = GetBDValueMust(self);
+    b = GetBDValueMust(v);
+    c = NewZeroWrap(1, VPMULT_RESULT_PREC(a.real, b.real) * BASE_FIG);
+    VpMult(c.real, a.real, b.real);
+    RB_GC_GUARD(a.bigdecimal);
+    RB_GC_GUARD(b.bigdecimal);
+    return c.bigdecimal;
+}
+
+VALUE
+BigDecimal_nttmult(VALUE self, VALUE v) {
+    BDVALUE a,b,c;
+    a = GetBDValueMust(self);
+    b = GetBDValueMust(v);
+    c = NewZeroWrap(1, VPMULT_RESULT_PREC(a.real, b.real) * BASE_FIG);
+    ntt_multiply(a.real->Prec, b.real->Prec, a.real->frac, b.real->frac, c.real->frac);
+    VpSetSign(c.real, a.real->sign * b.real->sign);
+    c.real->exponent = a.real->exponent + b.real->exponent;
+    c.real->Prec = a.real->Prec + b.real->Prec;
+    VpNmlz(c.real);
+    RB_GC_GUARD(a.bigdecimal);
+    RB_GC_GUARD(b.bigdecimal);
+    return c.bigdecimal;
+}
+
+#endif /* BIGDECIMAL_USE_VP_TEST_METHODS */
+
 /* Document-class: BigDecimal
  * BigDecimal provides arbitrary-precision floating point decimal arithmetic.
  *
@@ -4383,14 +3380,16 @@ BigDecimal_literal(const char *str)
  *
  * When you require +bigdecimal/util+, the #to_d method will be
  * available on BigDecimal and the native Integer, Float, Rational,
- * and String classes:
+ * String, Complex, and NilClass classes:
  *
  *	require 'bigdecimal/util'
  *
- *      42.to_d         # => 0.42e2
- *      0.5.to_d        # => 0.5e0
- *      (2/3r).to_d(3)  # => 0.667e0
- *      "0.5".to_d      # => 0.5e0
+ *      42.to_d                         # => 0.42e2
+ *      0.5.to_d                        # => 0.5e0
+ *      (2/3r).to_d(3)                  # => 0.667e0
+ *      "0.5".to_d                      # => 0.5e0
+ *      Complex(0.1234567, 0).to_d(4)   # => 0.1235e0
+ *      nil.to_d                        # => 0.0
  *
  * == Methods for Working with \JSON
  *
@@ -4464,7 +3463,7 @@ Init_bigdecimal(void)
      * guarantee that two groups could always be multiplied together without
      * overflow.)
      */
-    rb_define_const(rb_cBigDecimal, "BASE", INT2FIX((SIGNED_VALUE)VpBaseVal()));
+    rb_define_const(rb_cBigDecimal, "BASE", INT2FIX((SIGNED_VALUE)BASE));
 
     /* Exceptions */
 
@@ -4575,7 +3574,6 @@ Init_bigdecimal(void)
     rb_define_const(rb_cBigDecimal, "NAN", BIGDECIMAL_LITERAL(NAN, 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);
@@ -4606,14 +3604,11 @@ Init_bigdecimal(void)
     rb_define_method(rb_cBigDecimal, "dup", BigDecimal_clone, 0);
     rb_define_method(rb_cBigDecimal, "to_f", BigDecimal_to_f, 0);
     rb_define_method(rb_cBigDecimal, "abs", BigDecimal_abs, 0);
-    rb_define_method(rb_cBigDecimal, "sqrt", BigDecimal_sqrt, 1);
     rb_define_method(rb_cBigDecimal, "fix", BigDecimal_fix, 0);
     rb_define_method(rb_cBigDecimal, "round", BigDecimal_round, -1);
     rb_define_method(rb_cBigDecimal, "frac", BigDecimal_frac, 0);
     rb_define_method(rb_cBigDecimal, "floor", BigDecimal_floor, -1);
     rb_define_method(rb_cBigDecimal, "ceil", BigDecimal_ceil, -1);
-    rb_define_method(rb_cBigDecimal, "power", BigDecimal_power, -1);
-    rb_define_method(rb_cBigDecimal, "**", BigDecimal_power_op, 1);
     rb_define_method(rb_cBigDecimal, "<=>", BigDecimal_comp, 1);
     rb_define_method(rb_cBigDecimal, "==", BigDecimal_eq, 1);
     rb_define_method(rb_cBigDecimal, "===", BigDecimal_eq, 1);
@@ -4632,11 +3627,16 @@ Init_bigdecimal(void)
     rb_define_method(rb_cBigDecimal, "infinite?", BigDecimal_IsInfinite, 0);
     rb_define_method(rb_cBigDecimal, "finite?",   BigDecimal_IsFinite, 0);
     rb_define_method(rb_cBigDecimal, "truncate",  BigDecimal_truncate, -1);
+    rb_define_method(rb_cBigDecimal, "_decimal_shift",  BigDecimal_decimal_shift, 1);
     rb_define_method(rb_cBigDecimal, "_dump", BigDecimal_dump, -1);
 
-    rb_mBigMath = rb_define_module("BigMath");
-    rb_define_singleton_method(rb_mBigMath, "exp", BigMath_s_exp, 2);
-    rb_define_singleton_method(rb_mBigMath, "log", BigMath_s_log, 2);
+#ifdef BIGDECIMAL_USE_VP_TEST_METHODS
+    rb_define_method(rb_cBigDecimal, "vpdivd", BigDecimal_vpdivd, 2);
+    rb_define_method(rb_cBigDecimal, "vpdivd_newton", BigDecimal_vpdivd_newton, 2);
+    rb_define_method(rb_cBigDecimal, "newton_raphson_inverse", BigDecimal_newton_raphson_inverse, 1);
+    rb_define_method(rb_cBigDecimal, "vpmult", BigDecimal_vpmult, 1);
+    rb_define_method(rb_cBigDecimal, "nttmult", BigDecimal_nttmult, 1);
+#endif /* BIGDECIMAL_USE_VP_TEST_METHODS */
 
 #define ROUNDING_MODE(i, name, value) \
     id_##name = rb_intern_const(#name); \
@@ -4676,19 +3676,9 @@ Init_bigdecimal(void)
  */
 #ifdef BIGDECIMAL_DEBUG
 static int gfDebug = 1;         /* Debug switch */
-#if 0
-static int gfCheckVal = 1;      /* Value checking flag in VpNmlz()  */
-#endif
 #endif /* BIGDECIMAL_DEBUG */
 
-static Real *VpConstOne;    /* constant 1.0 */
-static Real *VpConstPt5;    /* constant 0.5 */
-#define maxnr 100UL    /* Maximum iterations for calculating sqrt. */
-                /* used in VpSqrt() */
-
-/* ETC */
-#define MemCmp(x,y,z) memcmp(x,y,z)
-#define StrCmp(x,y)   strcmp(x,y)
+static VALUE VpConstOne; /* constant 1.0 */
 
 enum op_sw {
     OP_SW_ADD = 1,  /* + */
@@ -4698,11 +3688,9 @@ 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 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);
 
@@ -4761,10 +3749,10 @@ VpCheckException(Real *p, bool always)
 }
 
 static VALUE
-VpCheckGetValue(Real *p)
+CheckGetValue(BDVALUE v)
 {
-    VpCheckException(p, false);
-    return p->obj;
+    VpCheckException(v.real, false);
+    return v.bigdecimal;
 }
 
 /*
@@ -4796,12 +3784,10 @@ VpGetPrecLimit(void)
     return NUM2SIZET(vlimit);
 }
 
-VP_EXPORT size_t
+VP_EXPORT void
 VpSetPrecLimit(size_t n)
 {
-    size_t const s = VpGetPrecLimit();
     bigdecimal_set_thread_local_precision_limit(n);
-    return s;
 }
 
 /*
@@ -4916,15 +3902,6 @@ VpGetDoubleNegZero(void) /* Returns the value of -0 */
     return nzero;
 }
 
-#if 0  /* unused */
-VP_EXPORT int
-VpIsNegDoubleZero(double v)
-{
-    double z = VpGetDoubleNegZero();
-    return MemCmp(&v,&z,sizeof(v))==0;
-}
-#endif
-
 VP_EXPORT int
 VpException(unsigned short f, const char *str,int always)
 {
@@ -5076,7 +4053,7 @@ VpNumOfChars(Real *vp,const char *pszFmt)
       case 'E':
 	/* fall through */
       default:
-	nc = BASE_FIG*(vp->Prec + 2)+6; /* 3: sign + exponent chars */
+	nc = BASE_FIG * vp->Prec + 25; /* "-0."(3) + digits_chars + "e-"(2) + 64bit_exponent_chars(19) + null(1) */
     }
     return nc;
 }
@@ -5102,35 +4079,21 @@ VpInit(DECDIG BaseVal)
     VpGetDoubleNegZero();
 
     /* Const 1.0 */
-    VpConstOne = NewOneNolimit(1, 1);
-
-    /* Const 0.5 */
-    VpConstPt5 = NewOneNolimit(1, 1);
-    VpConstPt5->exponent = 0;
-    VpConstPt5->frac[0] = 5*BASE1;
+    rb_global_variable(&VpConstOne);
+    VpConstOne = NewZeroWrap(1, 1).bigdecimal;
+    VpSetOne(VpPtr(VpConstOne));
 
 #ifdef BIGDECIMAL_DEBUG
     gnAlloc = 0;
 #endif /* BIGDECIMAL_DEBUG */
 
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-        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 BIGDECIMAL_DOUBLE_FIGURES;
 }
 
 VP_EXPORT Real *
 VpOne(void)
 {
-    return VpConstOne;
+    return VpPtr(VpConstOne);
 }
 
 /* If exponent overflows,then raise exception or returns 0 */
@@ -5139,24 +4102,14 @@ AddExponent(Real *a, SIGNED_VALUE n)
 {
     SIGNED_VALUE e = a->exponent;
     SIGNED_VALUE m = e+n;
-    SIGNED_VALUE eb, mb;
-    if (e > 0) {
-	if (n > 0) {
-            if (MUL_OVERFLOW_SIGNED_VALUE_P(m, (SIGNED_VALUE)BASE_FIG) ||
-                MUL_OVERFLOW_SIGNED_VALUE_P(e, (SIGNED_VALUE)BASE_FIG))
-                goto overflow;
-	    mb = m*(SIGNED_VALUE)BASE_FIG;
-	    eb = e*(SIGNED_VALUE)BASE_FIG;
-	    if (eb - mb > 0) goto overflow;
-	}
-    }
-    else if (n < 0) {
-        if (MUL_OVERFLOW_SIGNED_VALUE_P(m, (SIGNED_VALUE)BASE_FIG) ||
-            MUL_OVERFLOW_SIGNED_VALUE_P(e, (SIGNED_VALUE)BASE_FIG))
-            goto underflow;
-	mb = m*(SIGNED_VALUE)BASE_FIG;
-	eb = e*(SIGNED_VALUE)BASE_FIG;
-	if (mb - eb > 0) goto underflow;
+    if (e > 0 && n > 0) {
+        if (n > VP_EXPONENT_MAX - e) goto overflow;
+    } else if (e < 0 && n < 0) {
+        if (n < VP_EXPONENT_MIN - e) goto underflow;
+    } else if (m > VP_EXPONENT_MAX) {
+        goto overflow;
+    } else if (m < VP_EXPONENT_MIN) {
+        goto underflow;
     }
     a->exponent = m;
     return 1;
@@ -5171,7 +4124,7 @@ overflow:
     return VpException(VP_EXCEPTION_OVERFLOW, "Exponent overflow", 0);
 }
 
-Real *
+NULLABLE_BDVALUE
 bigdecimal_parse_special_string(const char *str)
 {
     static const struct {
@@ -5196,120 +4149,61 @@ bigdecimal_parse_special_string(const char *str)
         p = str + table[i].len;
         while (*p && ISSPACE(*p)) ++p;
         if (*p == '\0') {
-            Real *vp = rbd_allocate_struct(1);
-            vp->MaxPrec = 1;
+            VALUE obj = BigDecimal_allocate(1);
+            Real *vp = VpPtr(obj);
             switch (table[i].sign) {
               default:
-                UNREACHABLE; break;
+                UNREACHABLE;
+                return (NULLABLE_BDVALUE) { Qnil, NULL };
               case VP_SIGN_POSITIVE_INFINITE:
                 VpSetPosInf(vp);
-                return vp;
+                break;
               case VP_SIGN_NEGATIVE_INFINITE:
                 VpSetNegInf(vp);
-                return vp;
+                break;
               case VP_SIGN_NaN:
                 VpSetNaN(vp);
-                return vp;
+                break;
             }
+            return (NULLABLE_BDVALUE) { obj, vp };
         }
     }
 
-    return NULL;
-}
-
-struct VpCtoV_args {
-  Real *a;
-  const char *int_chr;
-  size_t ni;
-  const char *frac;
-  size_t nf;
-  const char *exp_chr;
-  size_t ne;
-};
-
-static VALUE
-call_VpCtoV(VALUE arg)
-{
-  struct VpCtoV_args *x = (struct VpCtoV_args *)arg;
-  return (VALUE)VpCtoV(x->a, x->int_chr, x->ni, x->frac, x->nf, x->exp_chr, x->ne);
-}
-
-static int
-protected_VpCtoV(Real *a, const char *int_chr, size_t ni, const char *frac, size_t nf, const char *exp_chr, size_t ne, int free_on_error)
-{
-  struct VpCtoV_args args;
-  int state = 0;
-
-  args.a = a;
-  args.int_chr = int_chr;
-  args.ni = ni;
-  args.frac = frac;
-  args.nf = nf;
-  args.exp_chr = exp_chr;
-  args.ne = ne;
-
-  VALUE result = rb_protect(call_VpCtoV, (VALUE)&args, &state);
-  if (state) {
-    if (free_on_error) {
-      rbd_free_struct(a);
-    }
-    rb_jump_tag(state);
-  }
-
-  return (int)result;
+    return (NULLABLE_BDVALUE) { Qnil, NULL };
 }
 
 /*
  * Allocates variable.
  * [Input]
- *   mx ... The number of decimal digits to be allocated, if zero then mx is determined by szVal.
- *          The mx will be the number of significant digits can to be stored.
- *   szVal ... The value assigned(char). If szVal==NULL, then zero is assumed.
- *             If szVal[0]=='#' then MaxPrec is not affected by the precision limit
- *             so that the full precision specified by szVal is allocated.
+ *   szVal ... The value assigned(char).
  *
  * [Returns]
- *   Pointer to the newly allocated variable, or
- *   NULL be returned if memory allocation is failed,or any error.
+ *   NULLABLE_BDVALUE to the newly allocated variable.
+ *   Null is returned if memory allocation failed, or any error occured.
  */
-VP_EXPORT Real *
-VpAlloc(size_t mx, const char *szVal, int strict_p, int exc)
+VP_EXPORT NULLABLE_BDVALUE
+VpAlloc(const char *szVal, int strict_p, int exc)
 {
     const char *orig_szVal = szVal;
-    size_t i, j, ni, ipf, nf, ipe, ne, dot_seen, exp_seen, nalloc;
-    size_t len;
+    size_t i, j, ni, ipf, nf, ipe, ne, exp_seen, nalloc;
     char v, *psz;
     int  sign=1;
-    Real *vp = NULL;
     VALUE buf;
 
-    if (szVal == NULL) {
-      return_zero:
-        /* necessary to be able to store */
-        /* at least mx digits. */
-        /* szVal==NULL ==> allocate zero value. */
-        vp = rbd_allocate_struct(mx);
-        vp->MaxPrec = rbd_calculate_internal_digits(mx, false);  /* Must false */
-        VpSetZero(vp, 1);    /* initialize vp to zero. */
-        return vp;
-    }
-
     /* Skipping leading spaces */
     while (ISSPACE(*szVal)) szVal++;
 
     /* Check on Inf & NaN */
-    if ((vp = bigdecimal_parse_special_string(szVal)) != NULL) {
-        return vp;
+    NULLABLE_BDVALUE special_bd = bigdecimal_parse_special_string(szVal);
+    if (special_bd.real_or_null != NULL) {
+        return special_bd;
     }
 
-    /* Processing the leading one `#` */
-    if (*szVal != '#') {
-        len = rbd_calculate_internal_digits(mx, true);
-    }
-    else {
-        len = rbd_calculate_internal_digits(mx, false);
-        ++szVal;
-    }
+    /* Skip leading `#`.
+     * It used to be a mark to indicate that an extra MaxPrec should be allocated,
+     * but now it has no effect.
+     */
+    if (*szVal == '#') ++szVal;
 
     /* Scanning digits */
 
@@ -5362,13 +4256,11 @@ VpAlloc(size_t mx, const char *szVal, int strict_p, int exc)
     ne  = 0; /* number of digits in the exponential part */
     ipf = 0; /* index of the beginning of the fractional part */
     ipe = 0; /* index of the beginning of the exponential part */
-    dot_seen = 0;
     exp_seen = 0;
 
     if (v != '\0') {
         /* Scanning fractional part */
         if ((psz[i] = szVal[j]) == '.') {
-            dot_seen = 1;
             ++i;
             ++j;
             ipf = i;
@@ -5384,9 +4276,6 @@ VpAlloc(size_t mx, const char *szVal, int strict_p, int exc)
                     }
                     if (!strict_p) {
                         v = psz[i] = '\0';
-                        if (nf == 0) {
-                            dot_seen = 0;
-                        }
                         break;
                     }
                     goto invalid_value;
@@ -5457,14 +4346,15 @@ VpAlloc(size_t mx, const char *szVal, int strict_p, int exc)
 
     psz[i] = '\0';
 
-    if (strict_p && (((ni == 0 || dot_seen) && nf == 0) || (exp_seen && ne == 0))) {
+    if (strict_p && ((ni == 0 && nf == 0) || (exp_seen && ne == 0))) {
         VALUE str;
       invalid_value:
         if (!strict_p) {
-            goto return_zero;
+            BDVALUE res = rbd_allocate_struct_zero_wrap(1, 1);
+            return (NULLABLE_BDVALUE) { res.bigdecimal, res.real };
         }
         if (!exc) {
-            return NULL;
+            return (NULLABLE_BDVALUE) { Qnil, NULL };
         }
         str = rb_str_new2(orig_szVal);
         rb_raise(rb_eArgError, "invalid value for BigDecimal(): \"%"PRIsVALUE"\"", str);
@@ -5472,15 +4362,12 @@ VpAlloc(size_t mx, const char *szVal, int strict_p, int exc)
 
     nalloc = (ni + nf + BASE_FIG - 1) / BASE_FIG + 1;    /* set effective allocation  */
     /* units for szVal[]  */
-    if (len == 0) len = 1;
-    nalloc = Max(nalloc, len);
-    len = nalloc;
-    vp = rbd_allocate_struct(len);
-    vp->MaxPrec = len;        /* set max precision */
+    VALUE obj = BigDecimal_allocate(nalloc);
+    Real *vp = VpPtr(obj);
     VpSetZero(vp, sign);
-    protected_VpCtoV(vp, psz, ni, psz + ipf, nf, psz + ipe, ne, true);
+    VpCtoV(vp, psz, ni, psz + ipf, nf, psz + ipe, ne);
     rb_str_resize(buf, 0);
-    return vp;
+    return (NULLABLE_BDVALUE) { obj, vp };
 }
 
 /*
@@ -5516,7 +4403,7 @@ VpAsgn(Real *c, Real *a, int isw)
 	c->Prec = n;
         memcpy(c->frac, a->frac, n * sizeof(DECDIG));
 	/* Needs round ? */
-	if (isw != 10) {
+	if (isw != 10 && isw != -10) {
 	    /* Not in ActiveRound */
 	    if(c->Prec < a->Prec) {
 		VpInternalRound(c, n, (n>0) ? a->frac[n-1] : 0, a->frac[n]);
@@ -5542,19 +4429,11 @@ VpAsgn(Real *c, Real *a, int isw)
 VP_EXPORT size_t
 VpAddSub(Real *c, Real *a, Real *b, int operation)
 {
-    short sw, isw;
+    short sw, isw, sign;
     Real *a_ptr, *b_ptr;
     size_t n, na, nb, i;
     DECDIG mrv;
 
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VPrint(stdout, "VpAddSub(enter) a=% \n", a);
-	VPrint(stdout, "     b=% \n", b);
-	printf(" operation=%d\n", operation);
-    }
-#endif /* BIGDECIMAL_DEBUG */
-
     if (!VpIsDefOP(c, a, b, (operation > 0) ? OP_SW_ADD : OP_SW_SUB)) return 0; /* No significant digits */
 
     /* check if a or b is zero  */
@@ -5643,28 +4522,21 @@ end_if:
     if (isw) {            /* addition */
 	VpSetSign(c, 1);
 	mrv = VpAddAbs(a_ptr, b_ptr, c);
-	VpSetSign(c, isw / 2);
+	sign = isw / 2;
     }
     else {            /* subtraction */
 	VpSetSign(c, 1);
 	mrv = VpSubAbs(a_ptr, b_ptr, c);
-	if (a_ptr == a) {
-	    VpSetSign(c,VpGetSign(a));
-	}
-	else {
-	    VpSetSign(c, VpGetSign(a_ptr) * sw);
-	}
+	sign = a_ptr == a ? VpGetSign(a) : VpGetSign(a_ptr) * sw;
     }
-    VpInternalRound(c, 0, (c->Prec > 0) ? c->frac[c->Prec-1] : 0, mrv);
-
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VPrint(stdout, "VpAddSub(result) c=% \n", c);
-	VPrint(stdout, "     a=% \n", a);
-	VPrint(stdout, "     b=% \n", b);
-	printf(" operation=%d\n", operation);
+    if (VpIsInf(c)) {
+	VpSetInf(c, sign);
     }
-#endif /* BIGDECIMAL_DEBUG */
+    else {
+	VpSetSign(c, sign);
+	VpInternalRound(c, 0, (c->Prec > 0) ? c->frac[c->Prec-1] : 0, mrv);
+    }
+
     return c->Prec * BASE_FIG;
 }
 
@@ -5685,13 +4557,6 @@ VpAddAbs(Real *a, Real *b, Real *c)
     size_t c_pos;
     DECDIG av, bv, carry, mrv;
 
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VPrint(stdout, "VpAddAbs called: a = %\n", a);
-	VPrint(stdout, "     b = %\n", b);
-    }
-#endif /* BIGDECIMAL_DEBUG */
-
     word_shift = VpSetPTR(a, b, c, &ap, &bp, &cp, &av, &bv);
     a_pos = ap;
     b_pos = bp;
@@ -5757,11 +4622,6 @@ Assign_a:
 
 Exit:
 
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VPrint(stdout, "VpAddAbs exit: c=% \n", c);
-    }
-#endif /* BIGDECIMAL_DEBUG */
     return mrv;
 }
 
@@ -5780,13 +4640,6 @@ VpSubAbs(Real *a, Real *b, Real *c)
     size_t c_pos;
     DECDIG av, bv, borrow, mrv;
 
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VPrint(stdout, "VpSubAbs called: a = %\n", a);
-	VPrint(stdout, "     b = %\n", b);
-    }
-#endif /* BIGDECIMAL_DEBUG */
-
     word_shift = VpSetPTR(a, b, c, &ap, &bp, &cp, &av, &bv);
     a_pos = ap;
     b_pos = bp;
@@ -5862,11 +4715,6 @@ Assign_a:
     mrv = 0;
 
 Exit:
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VPrint(stdout, "VpSubAbs exit: c=% \n", c);
-    }
-#endif /* BIGDECIMAL_DEBUG */
     return mrv;
 }
 
@@ -5991,25 +4839,12 @@ VpSetPTR(Real *a, Real *b, Real *c, size_t *a_pos, size_t *b_pos, size_t *c_pos,
  *        a0 a1 .... an    * b0
  *      +_____________________________
  *     c0 c1 c2  ......  cl
- *     nc      <---|
- *     MaxAB |--------------------|
  */
 VP_EXPORT size_t
 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;
-    DECDIG carry;
-    DECDIG_DBL s;
-    Real *w;
-
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VPrint(stdout, "VpMult(Enter): a=% \n", a);
-	VPrint(stdout, "      b=% \n", b);
-    }
-#endif /* BIGDECIMAL_DEBUG */
+    ssize_t a_batch_max, b_batch_max;
+    DECDIG_DBL batch[VPMULT_BATCH_SIZE * 2 - 1];
 
     if (!VpIsDefOP(c, a, b, OP_SW_MULT)) return 0; /* No significant digit */
 
@@ -6020,108 +4855,82 @@ VpMult(Real *c, Real *a, Real *b)
     }
 
     if (VpIsOne(a)) {
-	VpAsgn(c, b, VpGetSign(a));
+	VpAsgn(c, b, 10 * VpGetSign(a));
 	goto Exit;
     }
     if (VpIsOne(b)) {
-	VpAsgn(c, a, VpGetSign(b));
+	VpAsgn(c, a, 10 * VpGetSign(b));
 	goto Exit;
     }
     if (b->Prec > a->Prec) {
 	/* Adjust so that digits(a)>digits(b) */
-	w = a;
+	Real *w = a;
 	a = b;
 	b = w;
     }
-    w = NULL;
-    MxIndA = a->Prec - 1;
-    MxIndB = b->Prec - 1;
-    MxIndC = c->MaxPrec - 1;
-    MxIndAB = a->Prec + b->Prec - 1;
-
-    if (MxIndC < MxIndAB) {    /* The Max. prec. of c < Prec(a)+Prec(b) */
-	w = c;
-        c = NewZeroNolimit(1, (size_t)((MxIndAB + 1) * BASE_FIG));
-	MxIndC = MxIndAB;
-    }
 
     /* set LHSV c info */
 
     c->exponent = a->exponent;    /* set exponent */
-    if (!AddExponent(c, b->exponent)) {
-        if (w) rbd_free_struct(c);
-        return 0;
-    }
     VpSetSign(c, VpGetSign(a) * VpGetSign(b));    /* set sign  */
-    carry = 0;
-    nc = ind_c = MxIndAB;
-    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. */
-	    ind_as = MxIndA - nc;
-	    ind_ae = MxIndA;
-	    ind_bs = MxIndB;
-	}
-	else if (nc <= MxIndA) {    /* The middle rectangular of the Fig. */
-	    ind_as = MxIndA - nc;
-	    ind_ae = MxIndA - (nc - MxIndB);
-	    ind_bs = MxIndB;
-	}
-	else /* if (nc > MxIndA) */ {    /*  The right triangle of the Fig. */
-	    ind_as = 0;
-	    ind_ae = MxIndAB - nc - 1;
-	    ind_bs = MxIndB - (nc - MxIndA);
-	}
+    if (!AddExponent(c, b->exponent)) return 0;
+
+    if (b->Prec >= NTT_MULTIPLICATION_THRESHOLD) {
+        ntt_multiply(a->Prec, b->Prec, a->frac, b->frac, c->frac);
+        c->Prec = a->Prec + b->Prec;
+        goto Cleanup;
+    }
+
+    c->Prec = a->Prec + b->Prec; /* set precision */
+    memset(c->frac, 0, c->Prec * sizeof(DECDIG)); /* Initialize c  */
+
+    // Process VPMULT_BATCH_SIZE decdigits at a time to reduce the number of carry operations.
+    a_batch_max = (a->Prec - 1) / VPMULT_BATCH_SIZE;
+    b_batch_max = (b->Prec - 1) / VPMULT_BATCH_SIZE;
+    for (ssize_t ibatch = a_batch_max; ibatch >= 0; ibatch--) {
+        int isize = ibatch == a_batch_max ? (a->Prec - 1) % VPMULT_BATCH_SIZE + 1 : VPMULT_BATCH_SIZE;
+        for (ssize_t jbatch = b_batch_max; jbatch >= 0; jbatch--) {
+            int jsize = jbatch == b_batch_max ? (b->Prec - 1) % VPMULT_BATCH_SIZE + 1 : VPMULT_BATCH_SIZE;
+            memset(batch, 0, (isize + jsize - 1) * sizeof(DECDIG_DBL));
+
+            // Perform multiplication without carry calculation.
+            // BASE * BASE * VPMULT_BATCH_SIZE < 2**64 should be satisfied so that
+            // DECDIG_DBL can hold the intermediate sum without overflow.
+            for (int i = 0; i < isize; i++) {
+                for (int j = 0; j < jsize; j++) {
+                    batch[i + j] += (DECDIG_DBL)a->frac[ibatch * VPMULT_BATCH_SIZE + i] * b->frac[jbatch * VPMULT_BATCH_SIZE + j];
+                }
+            }
 
-	for (i = ind_as; i <= ind_ae; ++i) {
-            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);
+            // Add the batch result to c with carry calculation.
+            DECDIG_DBL carry = 0;
+            for (int k = isize + jsize - 2; k >= 0; k--) {
+                size_t l = (ibatch + jbatch) * VPMULT_BATCH_SIZE + k + 1;
+                DECDIG_DBL s = c->frac[l] + batch[k] + carry;
+                c->frac[l] = (DECDIG)(s % BASE);
+                carry = (DECDIG_DBL)(s / BASE);
             }
-	    if (carry) {
-		ii = ind_c;
-		while (ii-- > 0) {
-		    c->frac[ii] += carry;
-		    if (c->frac[ii] >= BASE) {
-			carry = c->frac[ii] / BASE;
-			c->frac[ii] -= (carry * BASE);
-		    }
-		    else {
-			break;
-		    }
-		}
-	    }
-	}
-    }
-    if (w != NULL) {        /* free work variable */
-        VpNmlz(c);
-        VpAsgn(w, c, 1);
-        rbd_free_struct(c);
-        c = w;
-    }
-    else {
-	VpLimitRound(c,0);
+
+            // Adding carry may exceed BASE, but it won't cause overflow of DECDIG.
+            // Exceeded value will be resolved in the carry operation of next (ibatch + jbatch - 1) batch.
+            // WARNING: This safety strongly relies on the current nested loop execution order.
+            c->frac[(ibatch + jbatch) * VPMULT_BATCH_SIZE] += (DECDIG)carry;
+        }
     }
 
+Cleanup:
+    VpNmlz(c);
+
 Exit:
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VPrint(stdout, "VpMult(c=a*b): c=% \n", c);
-	VPrint(stdout, "      a=% \n", a);
-	VPrint(stdout, "      b=% \n", b);
-    }
-#endif /*BIGDECIMAL_DEBUG */
     return c->Prec*BASE_FIG;
 }
 
 /*
  *   c = a / b,  remainder = r
+ *   XXXX_YYYY_ZZZZ / 0001 = XXXX_YYYY_ZZZZ
+ *   XXXX_YYYY_ZZZZ / 1111 = 000X_000Y_000Z
+ *   00XX_XXYY_YYZZ / 1000 = 0000_0XXX_XYYY
+ *   0001_0000_0000 / 9999 = 0000_0001_0001
  */
 VP_EXPORT size_t
 VpDivd(Real *c, Real *r, Real *a, Real *b)
@@ -6130,16 +4939,9 @@ VpDivd(Real *c, Real *r, Real *a, Real *b)
     size_t i, n, ind_a, ind_b, ind_c, ind_r;
     size_t nLoop;
     DECDIG_DBL q, b1, b1p1, b1b2, b1b2p1, r1r2;
-    DECDIG borrow, borrow1, borrow2;
+    DECDIG borrow1, borrow2;
     DECDIG_DBL qb;
 
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VPrint(stdout, " VpDivd(c=a/b)  a=% \n", a);
-	VPrint(stdout, "    b=% \n", b);
-    }
-#endif /*BIGDECIMAL_DEBUG */
-
     VpSetNaN(r);
     if (!VpIsDefOP(c, a, b, OP_SW_DIV)) goto Exit;
     if (VpIsZero(a) && VpIsZero(b)) {
@@ -6156,30 +4958,22 @@ VpDivd(Real *c, Real *r, Real *a, Real *b)
 	VpSetZero(r, VpGetSign(a) * VpGetSign(b));
 	goto Exit;
     }
-    if (VpIsOne(b)) {
-	/* divide by one  */
-	VpAsgn(c, a, VpGetSign(b));
-	VpSetZero(r, VpGetSign(a));
-	goto Exit;
-    }
 
     word_a = a->Prec;
     word_b = b->Prec;
     word_c = c->MaxPrec;
     word_r = r->MaxPrec;
 
-    if (word_a >= word_r) goto space_error;
+    if (word_a > word_r || word_b + word_c - 2 >= word_r) goto space_error;
 
-    ind_r = 1;
-    r->frac[0] = 0;
-    while (ind_r <= word_a) {
-	r->frac[ind_r] = a->frac[ind_r - 1];
-	++ind_r;
+    if (word_c >= NEWTON_RAPHSON_DIVISION_THRESHOLD && word_b >= NEWTON_RAPHSON_DIVISION_THRESHOLD) {
+        VpDivdNewton(c, r, a, b);
+        goto Exit;
     }
-    while (ind_r < word_r) r->frac[ind_r++] = 0;
 
-    ind_c = 0;
-    while (ind_c < word_c) c->frac[ind_c++] = 0;
+    for (i = 0; i < word_a; ++i) r->frac[i] = a->frac[i];
+    for (i = word_a; i < word_r; ++i) r->frac[i] = 0;
+    for (i = 0; i < word_c; ++i) c->frac[i] = 0;
 
     /* initial procedure */
     b1 = b1p1 = b->frac[0];
@@ -6194,15 +4988,14 @@ VpDivd(Real *c, Real *r, Real *a, Real *b)
 
     /* */
     /* loop start */
-    ind_c = word_r - 1;
-    nLoop = Min(word_c,ind_c);
-    ind_c = 1;
+    nLoop = Min(word_c, word_r);
+    ind_c = 0;
     while (ind_c < nLoop) {
 	if (r->frac[ind_c] == 0) {
 	    ++ind_c;
 	    continue;
 	}
-        r1r2 = (DECDIG_DBL)r->frac[ind_c] * BASE + r->frac[ind_c + 1];
+        r1r2 = (DECDIG_DBL)r->frac[ind_c] * BASE + (ind_c + 1 < word_r ? r->frac[ind_c + 1] : 0);
 	if (r1r2 == b1b2) {
 	    /* The first two word digits is the same */
 	    ind_b = 2;
@@ -6215,26 +5008,11 @@ VpDivd(Real *c, Real *r, Real *a, Real *b)
 	    }
 	    /* The first few word digits of r and b is the same and */
 	    /* the first different word digit of w is greater than that */
-	    /* of b, so quotient is 1 and just subtract b from r. */
-	    borrow = 0;        /* quotient=1, then just r-b */
-	    ind_b = b->Prec - 1;
-	    ind_r = ind_c + ind_b;
-	    if (ind_r >= word_r) goto space_error;
-	    n = ind_b;
-	    for (i = 0; i <= n; ++i) {
-		if (r->frac[ind_r] < b->frac[ind_b] + borrow) {
-		    r->frac[ind_r] += (BASE - (b->frac[ind_b] + borrow));
-		    borrow = 1;
-		}
-		else {
-		    r->frac[ind_r] = r->frac[ind_r] - b->frac[ind_b] - borrow;
-		    borrow = 0;
-		}
-		--ind_r;
-		--ind_b;
-	    }
+	    /* of b, so quotient is 1. */
+	    q = 1;
 	    ++c->frac[ind_c];
-	    goto carry;
+	    ind_r = b->Prec + ind_c - 1;
+	    goto sub_mult;
 	}
 	/* The first two word digits is not the same, */
 	/* then compare magnitude, and divide actually. */
@@ -6287,49 +5065,26 @@ sub_mult:
 	}
 
 	r->frac[ind_r] -= borrow2;
-carry:
-	ind_r = ind_c;
-	while (c->frac[ind_r] >= BASE) {
-	    c->frac[ind_r] -= BASE;
-	    --ind_r;
-	    ++c->frac[ind_r];
-	}
     }
     /* End of operation, now final arrangement */
 out_side:
     c->Prec = word_c;
     c->exponent = a->exponent;
-    if (!AddExponent(c, 2)) return 0;
+    VpSetSign(c, VpGetSign(a) * VpGetSign(b));
+    if (!AddExponent(c, 1)) return 0;
     if (!AddExponent(c, -(b->exponent))) return 0;
 
-    VpSetSign(c, VpGetSign(a) * VpGetSign(b));
     VpNmlz(c);            /* normalize c */
     r->Prec = word_r;
     r->exponent = a->exponent;
-    if (!AddExponent(r, 1)) return 0;
     VpSetSign(r, VpGetSign(a));
     VpNmlz(r);            /* normalize r(remainder) */
     goto Exit;
 
 space_error:
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	printf("   word_a=%"PRIuSIZE"\n", word_a);
-	printf("   word_b=%"PRIuSIZE"\n", word_b);
-	printf("   word_c=%"PRIuSIZE"\n", word_c);
-	printf("   word_r=%"PRIuSIZE"\n", word_r);
-	printf("   ind_r =%"PRIuSIZE"\n", ind_r);
-    }
-#endif /* BIGDECIMAL_DEBUG */
     rb_bug("ERROR(VpDivd): space for remainder too small.");
 
 Exit:
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VPrint(stdout, " VpDivd(c=a/b), c=% \n", c);
-	VPrint(stdout, "    r=% \n", r);
-    }
-#endif /* BIGDECIMAL_DEBUG */
     return c->Prec * BASE_FIG;
 }
 
@@ -6452,13 +5207,6 @@ Exit:
     if      (val >  1) val =  1;
     else if (val < -1) val = -1;
 
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VPrint(stdout, " VpComp a=%\n", a);
-	VPrint(stdout, "  b=%\n", b);
-	printf("  ans=%d\n", val);
-    }
-#endif /* BIGDECIMAL_DEBUG */
     return (int)val;
 }
 
@@ -6576,25 +5324,29 @@ VPrint(FILE *fp, const char *cntl_chr, Real *a)
 static void
 VpFormatSt(char *psz, size_t fFmt)
 {
-    size_t ie, i, nf = 0;
-    char ch;
+    size_t iend, idig = 0, iexp = 0, nspaces;
+    char *p;
 
     if (fFmt == 0) return;
 
-    ie = strlen(psz);
-    for (i = 0; i < ie; ++i) {
-	ch = psz[i];
-	if (!ch) break;
-	if (ISSPACE(ch) || ch=='-' || ch=='+') continue;
-	if (ch == '.') { nf = 0; continue; }
-	if (ch == 'E' || ch == 'e') break;
-
-	if (++nf > fFmt) {
-	    memmove(psz + i + 1, psz + i, ie - i + 1);
-	    ++ie;
-	    nf = 0;
-	    psz[i] = ' ';
-	}
+    iend = strlen(psz);
+
+    if ((p = strchr(psz, '.'))) {
+        idig = (p - psz) + 1;
+    }
+    if ((p = strchr(psz, 'E')) || (p = strchr(psz, 'e'))) {
+        iexp = p - psz;
+    }
+    if (idig == 0 || idig > iexp) return;
+
+    nspaces = (iexp - idig - 1) / fFmt;
+    p = psz + iend + 1;
+    for (size_t i = nspaces; i > 0; i--) {
+        char *src = psz + idig + i * fFmt;
+        char *dst = psz + idig + i * (fFmt + 1);
+        memmove(dst, src, p - src);
+        dst[-1] = ' ';
+        p = src;
     }
 }
 
@@ -6644,8 +5396,8 @@ VpSzMantissa(Real *a, char *buf, size_t buflen)
             while (m) {
                 nn = e / m;
                 if (!ZeroSup || nn) {
-                    snprintf(buf, buflen, "%lu", (unsigned long)nn); /* The leading zero(s) */
-                    buf += strlen(buf);
+                    *buf = (char)('0' + nn);
+                    buf++;
                     /* as 0.00xx will be ignored. */
                     ZeroSup = 0; /* Set to print succeeding zeros */
                 }
@@ -6697,10 +5449,22 @@ VpToSpecialString(Real *a, char *buf, size_t buflen, int fPlus)
     return 0;
 }
 
+#define ULLTOA_BUFFER_SIZE 20
+static size_t Vp_ulltoa(unsigned long long number, char *buf)
+{
+    static const char digits[] = "0123456789";
+    char* tmp = buf;
+
+    do *tmp-- = digits[number % 10]; while (number /= 10);
+    return buf - tmp;
+}
+
 VP_EXPORT void
 VpToString(Real *a, char *buf, size_t buflen, size_t fFmt, int fPlus)
 /* fPlus = 0: default, 1: set ' ' before digits, 2: set '+' before digits. */
 {
+    char ulltoa_buf[ULLTOA_BUFFER_SIZE];
+    char *ulltoa_buf_end = ulltoa_buf + ULLTOA_BUFFER_SIZE;
     size_t i, n, ZeroSup;
     DECDIG shift, m, e, nn;
     char *p = buf;
@@ -6740,10 +5504,9 @@ VpToString(Real *a, char *buf, size_t buflen, size_t fFmt, int fPlus)
         while (m) {
             nn = e / m;
             if (!ZeroSup || nn) {
-                /* The reading zero(s) */
-                size_t n = (size_t)snprintf(p, plen, "%lu", (unsigned long)nn);
-                if (n > plen) goto overflow;
-                ADVANCE(n);
+                *p = (char)('0' + nn);
+                ADVANCE(1);
+
                 /* as 0.00xx will be ignored. */
                 ZeroSup = 0;    /* Set to print succeeding zeros */
             }
@@ -6762,7 +5525,22 @@ VpToString(Real *a, char *buf, size_t buflen, size_t fFmt, int fPlus)
         *(--p) = '\0';
         ++plen;
     }
-    snprintf(p, plen, "e%"PRIdSIZE, ex);
+    *p = 'e';
+    ADVANCE(1);
+
+    if (ex < 0) {
+        *p = '-';
+        ADVANCE(1);
+        ex = -ex;
+    }
+
+    size_t ex_n = Vp_ulltoa(ex, ulltoa_buf_end - 1);
+    if (ex_n > plen) goto overflow;
+    MEMCPY(p, ulltoa_buf_end - ex_n, char, ex_n);
+    ADVANCE(ex_n);
+    *p = '\0';
+    ADVANCE(1);
+
     if (fFmt) VpFormatSt(buf, fFmt);
 
   overflow:
@@ -6876,7 +5654,7 @@ VP_EXPORT int
 VpCtoV(Real *a, const char *int_chr, size_t ni, const char *frac, size_t nf, const char *exp_chr, size_t ne)
 {
     size_t i, j, ind_a, ma, mi, me;
-    SIGNED_VALUE e, es, eb, ef;
+    SIGNED_VALUE e;
     int  sign, signe, exponent_overflow;
 
     /* get exponent part */
@@ -6899,23 +5677,13 @@ VpCtoV(Real *a, const char *int_chr, size_t ni, const char *frac, size_t nf, con
 	    ++me;
 	}
 	while (i < me) {
-            if (MUL_OVERFLOW_SIGNED_VALUE_P(e, (SIGNED_VALUE)BASE_FIG)) {
-                es = e;
-                goto exp_overflow;
-            }
-	    es = e * (SIGNED_VALUE)BASE_FIG;
-            if (MUL_OVERFLOW_SIGNED_VALUE_P(e, 10) ||
-                SIGNED_VALUE_MAX - (exp_chr[i] - '0') < e * 10)
-                goto exp_overflow;
-	    e = e * 10 + exp_chr[i] - '0';
-            if (MUL_OVERFLOW_SIGNED_VALUE_P(e, (SIGNED_VALUE)BASE_FIG))
-                goto exp_overflow;
-	    if (es > (SIGNED_VALUE)(e * BASE_FIG)) {
-              exp_overflow:
+	    int dig = exp_chr[i] - '0';
+	    if (MUL_OVERFLOW_SIGNED_VALUE_P(e, 10) ||
+		ADD_OVERFLOW_SIGNED_VALUE_P(e * 10, signe * dig)) {
 		exponent_overflow = 1;
-		e = es; /* keep sign */
 		break;
 	    }
+	    e = e * 10 + signe * dig;
 	    ++i;
 	}
     }
@@ -6934,34 +5702,32 @@ VpCtoV(Real *a, const char *int_chr, size_t ni, const char *frac, size_t nf, con
 	    ++mi;
 	}
     }
+    /* skip leading zeros in integer part */
+    while (i < mi && int_chr[i] == '0') {
+        ++i;
+        --ni;
+    }
 
-    e = signe * e;        /* e: The value of exponent part. */
-    e = e + ni;        /* set actual exponent size. */
-
-    if (e > 0) signe = 1;
-    else       signe = -1;
+    /* set actual exponent size. */
+    if (ADD_OVERFLOW_SIGNED_VALUE_P(e, (SIGNED_VALUE)ni)) {
+	exponent_overflow = 1;
+    } else {
+	e += ni;
+    }
 
     /* Adjust the exponent so that it is the multiple of BASE_FIG. */
-    j = 0;
-    ef = 1;
-    while (ef) {
-	if (e >= 0) eb =  e;
-	else        eb = -e;
-	ef = eb / (SIGNED_VALUE)BASE_FIG;
-	ef = eb - ef * (SIGNED_VALUE)BASE_FIG;
-	if (ef) {
-	    ++j;        /* Means to add one more preceding zero */
-	    ++e;
-	}
+    j = (BASE_FIG - e % BASE_FIG) % BASE_FIG;
+    if (ADD_OVERFLOW_SIGNED_VALUE_P(e, (SIGNED_VALUE)j)) {
+        exponent_overflow = 1;
+    } else {
+        e += j;
     }
 
-    eb = e / (SIGNED_VALUE)BASE_FIG;
-
-    if (exponent_overflow) {
+    if (exponent_overflow || e < EXPONENT_MIN || e > EXPONENT_MAX) {
 	int zero = 1;
 	for (     ; i < mi && zero; i++) zero = int_chr[i] == '0';
 	for (i = 0; i < nf && zero; i++) zero = frac[i] == '0';
-	if (!zero && signe > 0) {
+	if (!zero && e > 0) {
 	    VpSetInf(a, sign);
 	    VpException(VP_EXCEPTION_INFINITY, "exponent overflow",0);
 	}
@@ -7011,7 +5777,7 @@ Final:
 	++j;
     }
     a->Prec = ind_a + 1;
-    a->exponent = eb;
+    a->exponent = e / (SIGNED_VALUE)BASE_FIG;
     VpSetSign(a, sign);
     VpNmlz(a);
     return 1;
@@ -7083,254 +5849,9 @@ VpVtoD(double *d, SIGNED_VALUE *e, Real *m)
     *d *= VpGetSign(m);
 
 Exit:
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VPrint(stdout, " VpVtoD: m=%\n", m);
-	printf("   d=%e * 10 **%ld\n", *d, *e);
-	printf("   BIGDECIMAL_DOUBLE_FIGURES = %d\n", BIGDECIMAL_DOUBLE_FIGURES);
-    }
-#endif /*BIGDECIMAL_DEBUG */
     return f;
 }
 
-/*
- * m <- d
- */
-VP_EXPORT void
-VpDtoV(Real *m, double d)
-{
-    size_t ind_m, mm;
-    SIGNED_VALUE ne;
-    DECDIG i;
-    double  val, val2;
-
-    if (isnan(d)) {
-	VpSetNaN(m);
-	goto Exit;
-    }
-    if (isinf(d)) {
-	if (d > 0.0) VpSetPosInf(m);
-	else VpSetNegInf(m);
-	goto Exit;
-    }
-
-    if (d == 0.0) {
-	VpSetZero(m, 1);
-	goto Exit;
-    }
-    val = (d > 0.) ? d : -d;
-    ne = 0;
-    if (val >= 1.0) {
-	while (val >= 1.0) {
-	    val /= (double)BASE;
-	    ++ne;
-	}
-    }
-    else {
-	val2 = 1.0 / (double)BASE;
-	while (val < val2) {
-	    val *= (double)BASE;
-	    --ne;
-	}
-    }
-    /* Now val = 0.xxxxx*BASE**ne */
-
-    mm = m->MaxPrec;
-    memset(m->frac, 0, mm * sizeof(DECDIG));
-    for (ind_m = 0; val > 0.0 && ind_m < mm; ind_m++) {
-        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);
-    m->Prec = ind_m + 1;
-    m->exponent = ne;
-
-    VpInternalRound(m, 0, (m->Prec > 0) ? m->frac[m->Prec-1] : 0,
-                    (DECDIG)(val*(double)BASE));
-
-Exit:
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	printf("VpDtoV d=%30.30e\n", d);
-	VPrint(stdout, "  m=%\n", m);
-    }
-#endif /* BIGDECIMAL_DEBUG */
-    return;
-}
-
-/*
- *  m <- ival
- */
-#if 0  /* unused */
-VP_EXPORT void
-VpItoV(Real *m, SIGNED_VALUE ival)
-{
-    size_t mm, ind_m;
-    size_t val, v1, v2, v;
-    int isign;
-    SIGNED_VALUE ne;
-
-    if (ival == 0) {
-	VpSetZero(m, 1);
-	goto Exit;
-    }
-    isign = 1;
-    val = ival;
-    if (ival < 0) {
-	isign = -1;
-	val  =(size_t)(-ival);
-    }
-    ne = 0;
-    ind_m = 0;
-    mm = m->MaxPrec;
-    while (ind_m < mm) {
-	m->frac[ind_m] = 0;
-	++ind_m;
-    }
-    ind_m = 0;
-    while (val > 0) {
-	if (val) {
-	    v1 = val;
-	    v2 = 1;
-	    while (v1 >= BASE) {
-		v1 /= BASE;
-		v2 *= BASE;
-	    }
-	    val = val - v2 * v1;
-	    v = v1;
-	}
-	else {
-	    v = 0;
-	}
-	m->frac[ind_m] = v;
-	++ind_m;
-	++ne;
-    }
-    m->Prec = ind_m - 1;
-    m->exponent = ne;
-    VpSetSign(m, isign);
-    VpNmlz(m);
-
-Exit:
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	printf(" VpItoV i=%d\n", ival);
-	VPrint(stdout, "  m=%\n", m);
-    }
-#endif /* BIGDECIMAL_DEBUG */
-    return;
-}
-#endif
-
-/*
- * y = SQRT(x),  y*y - x =>0
- */
-VP_EXPORT int
-VpSqrt(Real *y, Real *x)
-{
-    Real *f = NULL;
-    Real *r = NULL;
-    size_t y_prec;
-    SIGNED_VALUE n, e;
-    ssize_t nr;
-    double val;
-
-    /* Zero or +Infinity ? */
-    if (VpIsZero(x) || VpIsPosInf(x)) {
-	VpAsgn(y,x,1);
-	goto Exit;
-    }
-
-    /* Negative ? */
-    if (BIGDECIMAL_NEGATIVE_P(x)) {
-	VpSetNaN(y);
-	return VpException(VP_EXCEPTION_OP, "sqrt of negative value", 0);
-    }
-
-    /* NaN ? */
-    if (VpIsNaN(x)) {
-	VpSetNaN(y);
-	return VpException(VP_EXCEPTION_OP, "sqrt of 'NaN'(Not a Number)", 0);
-    }
-
-    /* One ? */
-    if (VpIsOne(x)) {
-	VpSetOne(y);
-	goto Exit;
-    }
-
-    n = (SIGNED_VALUE)y->MaxPrec;
-    if (x->MaxPrec > (size_t)n) n = (ssize_t)x->MaxPrec;
-
-    /* allocate temporally variables  */
-    /* TODO: reconsider MaxPrec of f and r */
-    f = NewOneNolimit(1, y->MaxPrec * (BASE_FIG + 2));
-    r = NewOneNolimit(1, (n + n) * (BASE_FIG + 2));
-
-    nr = 0;
-    y_prec = y->MaxPrec;
-
-    VpVtoD(&val, &e, x);    /* val <- x  */
-    e /= (SIGNED_VALUE)BASE_FIG;
-    n = e / 2;
-    if (e - n * 2 != 0) {
-	val /= BASE;
-	n = (e + 1) / 2;
-    }
-    VpDtoV(y, sqrt(val));    /* y <- sqrt(val) */
-    y->exponent += n;
-    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);
-    if (n > (SIGNED_VALUE)maxnr) n = (SIGNED_VALUE)maxnr;
-
-    /*
-     * Perform: y_{n+1} = (y_n - x/y_n) / 2
-     */
-    do {
-        y->MaxPrec *= 2;
-        if (y->MaxPrec > y_prec) y->MaxPrec = y_prec;
-        f->MaxPrec = y->MaxPrec;
-        VpDivd(f, r, x, y);        /* f = x/y    */
-        VpAddSub(r, f, y, -1);     /* r = f - y  */
-        VpMult(f, VpConstPt5, r);  /* f = 0.5*r  */
-        if (VpIsZero(f))
-            goto converge;
-        VpAddSub(r, f, y, 1);      /* r = y + f  */
-        VpAsgn(y, r, 1);           /* y = r      */
-    } while (++nr < n);
-
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	printf("ERROR(VpSqrt): did not converge within %ld iterations.\n", nr);
-    }
-#endif /* BIGDECIMAL_DEBUG */
-    y->MaxPrec = y_prec;
-
-converge:
-    VpChangeSign(y, 1);
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VpMult(r, y, y);
-	VpAddSub(f, x, r, -1);
-	printf("VpSqrt: iterations = %"PRIdSIZE"\n", nr);
-	VPrint(stdout, "  y =% \n", y);
-	VPrint(stdout, "  x =% \n", x);
-	VPrint(stdout, "  x-y*y = % \n", f);
-    }
-#endif /* BIGDECIMAL_DEBUG */
-    y->MaxPrec = y_prec;
-
-Exit:
-    rbd_free_struct(f);
-    rbd_free_struct(r);
-    return 1;
-}
-
 /*
  * Round relatively from the decimal point.
  *    f: rounding mode
@@ -7507,7 +6028,7 @@ VpLeftRound(Real *y, unsigned short f, ssize_t nf)
     DECDIG v;
     if (!VpHasVal(y)) return 0; /* Unable to round */
     v = y->frac[0];
-    nf -= VpExponent(y) * (ssize_t)BASE_FIG;
+    nf -= y->exponent * (ssize_t)BASE_FIG;
     while ((v /= 10) != 0) nf--;
     nf += (ssize_t)BASE_FIG-1;
     return VpMidRound(y, f, nf);
@@ -7614,7 +6135,7 @@ VpFrac(Real *y, Real *x)
     size_t my, ind_y, ind_x;
 
     if (!VpHasVal(x)) {
-	VpAsgn(y, x, 1);
+	VpAsgn(y, x, 10);
 	goto Exit;
     }
 
@@ -7623,7 +6144,7 @@ VpFrac(Real *y, Real *x)
 	goto Exit;
     }
     else if (x->exponent <= 0) {
-	VpAsgn(y, x, 1);
+	VpAsgn(y, x, 10);
 	goto Exit;
     }
 
@@ -7644,117 +6165,9 @@ VpFrac(Real *y, Real *x)
     VpNmlz(y);
 
 Exit:
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VPrint(stdout, "VpFrac y=%\n", y);
-	VPrint(stdout, "    x=%\n", x);
-    }
-#endif /* BIGDECIMAL_DEBUG */
     return;
 }
 
-/*
- *   y = x ** n
- */
-VP_EXPORT int
-VpPowerByInt(Real *y, Real *x, SIGNED_VALUE n)
-{
-    size_t s, ss;
-    ssize_t sign;
-    Real *w1 = NULL;
-    Real *w2 = NULL;
-
-    if (VpIsZero(x)) {
-	if (n == 0) {
-	    VpSetOne(y);
-	    goto Exit;
-	}
-	sign = VpGetSign(x);
-	if (n < 0) {
-	    n = -n;
-	    if (sign < 0) sign = (n % 2) ? -1 : 1;
-	    VpSetInf(y, sign);
-	}
-	else {
-	    if (sign < 0) sign = (n % 2) ? -1 : 1;
-	    VpSetZero(y,sign);
-	}
-	goto Exit;
-    }
-    if (VpIsNaN(x)) {
-	VpSetNaN(y);
-	goto Exit;
-    }
-    if (VpIsInf(x)) {
-	if (n == 0) {
-	    VpSetOne(y);
-	    goto Exit;
-	}
-	if (n > 0) {
-	    VpSetInf(y, (n % 2 == 0 || VpIsPosInf(x)) ? 1 : -1);
-	    goto Exit;
-	}
-	VpSetZero(y, (n % 2 == 0 || VpIsPosInf(x)) ? 1 : -1);
-	goto Exit;
-    }
-
-    if (x->exponent == 1 && x->Prec == 1 && x->frac[0] == 1) {
-	/* abs(x) = 1 */
-	VpSetOne(y);
-	if (BIGDECIMAL_POSITIVE_P(x)) goto Exit;
-	if ((n % 2) == 0) goto Exit;
-	VpSetSign(y, -1);
-	goto Exit;
-    }
-
-    if (n > 0) sign = 1;
-    else if (n < 0) {
-	sign = -1;
-	n = -n;
-    }
-    else {
-	VpSetOne(y);
-	goto Exit;
-    }
-
-    /* Allocate working variables  */
-    /* TODO: reconsider MaxPrec of w1 and w2 */
-    w1 = NewZeroNolimit(1, (y->MaxPrec + 2) * BASE_FIG);
-    w2 = NewZeroNolimit(1, (w1->MaxPrec * 2 + 1) * BASE_FIG);
-
-    /* calculation start */
-
-    VpAsgn(y, x, 1);
-    --n;
-    while (n > 0) {
-	VpAsgn(w1, x, 1);
-	s = 1;
-	while (ss = s, (s += s) <= (size_t)n) {
-	    VpMult(w2, w1, w1);
-	    VpAsgn(w1, w2, 1);
-	}
-	n -= (SIGNED_VALUE)ss;
-	VpMult(w2, y, w1);
-	VpAsgn(y, w2, 1);
-    }
-    if (sign < 0) {
-	VpDivd(w1, w2, VpConstOne, y);
-	VpAsgn(y, w1, 1);
-    }
-
-Exit:
-#ifdef BIGDECIMAL_DEBUG
-    if (gfDebug) {
-	VPrint(stdout, "VpPowerByInt y=%\n", y);
-	VPrint(stdout, "VpPowerByInt x=%\n", x);
-	printf("  n=%"PRIdVALUE"\n", n);
-    }
-#endif /* BIGDECIMAL_DEBUG */
-    rbd_free_struct(w2);
-    rbd_free_struct(w1);
-    return 1;
-}
-
 #ifdef BIGDECIMAL_DEBUG
 int
 VpVarCheck(Real * v)