bigdecimal 3.1.8 → 3.3.1

data/ext/bigdecimal/bigdecimal.h

@@ -17,7 +17,7 @@
 # include <float.h>
 #endif
 
-#ifdef HAVE_INT64_T
+#if defined(HAVE_INT64_T) && !defined(BIGDECIMAL_USE_DECDIG_UINT16_T)
 # define DECDIG uint32_t
 # define DECDIG_DBL uint64_t
 # define DECDIG_DBL_SIGNED int64_t
@@ -167,7 +167,6 @@ enum rbd_rounding_mode {
  *  r = 0.xxxxxxxxx *BASE**exponent
  */
 typedef struct {
-    VALUE  obj;     /* Back pointer(VALUE) for Ruby object.     */
     size_t MaxPrec; /* Maximum precision size                   */
                     /* This is the actual size of frac[]        */
                     /*(frac[0] to frac[MaxPrec] are available). */
@@ -195,13 +194,7 @@ typedef struct {
  *  ------------------
  */
 
-VP_EXPORT Real *VpNewRbClass(size_t mx, char const *str, VALUE klass, bool strict_p, bool raise_exception);
-
-VP_EXPORT Real *VpCreateRbObject(size_t mx, const char *str, bool raise_exception);
-
 #define VpBaseFig() BIGDECIMAL_COMPONENT_FIGURES
-#define VpDblFig() BIGDECIMAL_DOUBLE_FIGURES
-#define VpBaseVal() BIGDECIMAL_BASE
 
 /* Zero,Inf,NaN (isinf(),isnan() used to check) */
 VP_EXPORT double VpGetDoubleNaN(void);
@@ -211,7 +204,7 @@ VP_EXPORT double VpGetDoubleNegZero(void);
 
 /* These 2 functions added at v1.1.7 */
 VP_EXPORT size_t VpGetPrecLimit(void);
-VP_EXPORT size_t VpSetPrecLimit(size_t n);
+VP_EXPORT void VpSetPrecLimit(size_t n);
 
 /* Round mode */
 VP_EXPORT int            VpIsRoundMode(unsigned short n);
@@ -219,16 +212,14 @@ VP_EXPORT unsigned short VpGetRoundMode(void);
 VP_EXPORT unsigned short VpSetRoundMode(unsigned short n);
 
 VP_EXPORT int VpException(unsigned short f,const char *str,int always);
-#if 0  /* unused */
-VP_EXPORT int VpIsNegDoubleZero(double v);
-#endif
 VP_EXPORT size_t VpNumOfChars(Real *vp,const char *pszFmt);
 VP_EXPORT size_t VpInit(DECDIG BaseVal);
-VP_EXPORT Real *VpAlloc(size_t mx, const char *szVal, int strict_p, int exc);
+VP_EXPORT Real *VpAlloc(const char *szVal, int strict_p, int exc);
 VP_EXPORT size_t VpAsgn(Real *c, Real *a, int isw);
 VP_EXPORT size_t VpAddSub(Real *c,Real *a,Real *b,int operation);
 VP_EXPORT size_t VpMult(Real *c,Real *a,Real *b);
 VP_EXPORT size_t VpDivd(Real *c,Real *r,Real *a,Real *b);
+VP_EXPORT int VpNmlz(Real *a);
 VP_EXPORT int VpComp(Real *a,Real *b);
 VP_EXPORT ssize_t VpExponent10(Real *a);
 VP_EXPORT void VpSzMantissa(Real *a, char *buf, size_t bufsize);
@@ -237,17 +228,10 @@ VP_EXPORT void VpToString(Real *a, char *buf, size_t bufsize, size_t fFmt, int f
 VP_EXPORT void VpToFString(Real *a, char *buf, size_t bufsize, size_t fFmt, int fPlus);
 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);
 VP_EXPORT int VpVtoD(double *d, SIGNED_VALUE *e, Real *m);
-VP_EXPORT void VpDtoV(Real *m,double d);
-#if 0  /* unused */
-VP_EXPORT void VpItoV(Real *m,S_INT ival);
-#endif
-VP_EXPORT int VpSqrt(Real *y,Real *x);
 VP_EXPORT int VpActiveRound(Real *y, Real *x, unsigned short f, ssize_t il);
 VP_EXPORT int VpMidRound(Real *y, unsigned short f, ssize_t nf);
 VP_EXPORT int VpLeftRound(Real *y, unsigned short f, ssize_t nf);
 VP_EXPORT void VpFrac(Real *y, Real *x);
-VP_EXPORT int VpPowerByInt(Real *y, Real *x, SIGNED_VALUE n);
-#define VpPower VpPowerByInt
 
 /* VP constants */
 VP_EXPORT Real *VpOne(void);
@@ -261,10 +245,6 @@ VP_EXPORT Real *VpOne(void);
 #define Max(a, b)  (((a)>(b))?(a):(b))
 #define Min(a, b)  (((a)>(b))?(b):(a))
 
-#define VpMaxPrec(a)   ((a)->MaxPrec)
-#define VpPrec(a)      ((a)->Prec)
-#define VpGetFlag(a)   ((a)->flag)
-
 /* Sign */
 
 /* VpGetSign(a) returns 1,-1 if a>0,a<0 respectively */
@@ -299,7 +279,6 @@ VP_EXPORT Real *VpOne(void);
 #define VpSetInf(a,s)   (void)(((s)>0)?VpSetPosInf(a):VpSetNegInf(a))
 #define VpHasVal(a)     (a->frac[0])
 #define VpIsOne(a)      ((a->Prec==1)&&(a->frac[0]==1)&&(a->exponent==1))
-#define VpExponent(a)   (a->exponent)
 #ifdef BIGDECIMAL_DEBUG
 int VpVarCheck(Real * v);
 #endif /* BIGDECIMAL_DEBUG */

data/ext/bigdecimal/bits.h

@@ -26,6 +26,9 @@
       ((b) > 0 ? (max) / (a) < (b) : (min) / (a) > (b)) : \
       ((b) > 0 ? (min) / (a) < (b) : (max) / (a) > (b)))
 
+#define ADD_OVERFLOW_SIGNED_INTEGER_P(a, b, min, max) ( \
+    ((a) > 0) == ((b) > 0) && ((a) > 0 ? (max) - (a) < (b) : (min) - (a) > (b)))
+
 #ifdef HAVE_UINT128_T
 # define bit_length(x) \
     (unsigned int) \

data/ext/bigdecimal/extconf.rb

@@ -24,27 +24,22 @@ have_header("math.h")
 have_header("stdbool.h")
 have_header("stdlib.h")
 
-have_header("x86intrin.h")
-have_func("_lzcnt_u32", "x86intrin.h")
-have_func("_lzcnt_u64", "x86intrin.h")
-
-have_header("intrin.h")
-have_func("__lzcnt", "intrin.h")
-have_func("__lzcnt64", "intrin.h")
-have_func("_BitScanReverse", "intrin.h")
-have_func("_BitScanReverse64", "intrin.h")
+if have_header("x86intrin.h")
+  have_func("_lzcnt_u32", "x86intrin.h")
+  have_func("_lzcnt_u64", "x86intrin.h")
+end
 
-have_func("labs", "stdlib.h")
-have_func("llabs", "stdlib.h")
-have_func("finite", "math.h")
-have_func("isfinite", "math.h")
+if have_header("intrin.h")
+  have_func("__lzcnt", "intrin.h")
+  have_func("__lzcnt64", "intrin.h")
+  have_func("_BitScanReverse", "intrin.h")
+  have_func("_BitScanReverse64", "intrin.h")
+end
 
 have_header("ruby/atomic.h")
 have_header("ruby/internal/has/builtin.h")
 have_header("ruby/internal/static_assert.h")
 
-have_func("rb_rational_num", "ruby.h")
-have_func("rb_rational_den", "ruby.h")
 have_func("rb_complex_real", "ruby.h")
 have_func("rb_complex_imag", "ruby.h")
 have_func("rb_opts_exception_p", "ruby.h")
@@ -57,6 +52,9 @@ else
   bigdecimal_rb = "$(srcdir)/../../lib/bigdecimal.rb"
 end
 
+$defs.push '-DBIGDECIMAL_USE_DECDIG_UINT16_T' if ENV['BIGDECIMAL_USE_DECDIG_UINT16_T'] == 'true'
+$defs.push '-DBIGDECIMAL_USE_VP_TEST_METHODS' if ENV['BIGDECIMAL_USE_VP_TEST_METHODS'] == 'true'
+
 create_makefile('bigdecimal') {|mf|
   mf << "BIGDECIMAL_RB = #{bigdecimal_rb}\n"
 }

data/ext/bigdecimal/missing.c

@@ -15,7 +15,8 @@
     _Pragma("GCC diagnostic push") \
     _Pragma("GCC diagnostic ignored \"-Wattributes\"") \
     __attribute__((__no_sanitize__(x))) y; \
-    _Pragma("GCC diagnostic pop")
+    _Pragma("GCC diagnostic pop") \
+    y
 #endif
 
 #undef strtod

data/ext/bigdecimal/missing.h

@@ -8,14 +8,6 @@ extern "C" {
 #endif
 #endif
 
-#ifdef HAVE_STDLIB_H
-# include <stdlib.h>
-#endif
-
-#ifdef HAVE_MATH_H
-# include <math.h>
-#endif
-
 #ifndef RB_UNUSED_VAR
 # if defined(_MSC_VER) && _MSC_VER >= 1911
 #  define RB_UNUSED_VAR(x) x [[maybe_unused]]
@@ -55,97 +47,13 @@ extern "C" {
 
 /* bool */
 
-#if defined(__bool_true_false_are_defined)
-# /* Take that. */
-
-#elif defined(HAVE_STDBOOL_H)
+#ifndef __bool_true_false_are_defined
 # include <stdbool.h>
-
-#else
-typedef unsigned char _Bool;
-# define bool _Bool
-# define true  ((_Bool)+1)
-# define false ((_Bool)-1)
-# define __bool_true_false_are_defined
-#endif
-
-/* abs */
-
-#ifndef HAVE_LABS
-static inline long
-labs(long const x)
-{
-    if (x < 0) return -x;
-    return x;
-}
-#endif
-
-#ifndef HAVE_LLABS
-static inline LONG_LONG
-llabs(LONG_LONG const x)
-{
-    if (x < 0) return -x;
-    return x;
-}
-#endif
-
-#ifdef vabs
-# undef vabs
-#endif
-#if SIZEOF_VALUE <= SIZEOF_INT
-# define vabs abs
-#elif SIZEOF_VALUE <= SIZEOF_LONG
-# define vabs labs
-#elif SIZEOF_VALUE <= SIZEOF_LONG_LONG
-# define vabs llabs
-#endif
-
-/* finite */
-
-#ifndef HAVE_FINITE
-static int
-finite(double)
-{
-    return !isnan(n) && !isinf(n);
-}
-#endif
-
-#ifndef isfinite
-# ifndef HAVE_ISFINITE
-#  define HAVE_ISFINITE 1
-#  define isfinite(x) finite(x)
-# endif
 #endif
 
 /* dtoa */
 char *BigDecimal_dtoa(double d_, int mode, int ndigits, int *decpt, int *sign, char **rve);
 
-/* rational */
-
-#ifndef HAVE_RB_RATIONAL_NUM
-static inline VALUE
-rb_rational_num(VALUE rat)
-{
-#ifdef RRATIONAL
-    return RRATIONAL(rat)->num;
-#else
-    return rb_funcall(rat, rb_intern("numerator"), 0);
-#endif
-}
-#endif
-
-#ifndef HAVE_RB_RATIONAL_DEN
-static inline VALUE
-rb_rational_den(VALUE rat)
-{
-#ifdef RRATIONAL
-    return RRATIONAL(rat)->den;
-#else
-    return rb_funcall(rat, rb_intern("denominator"), 0);
-#endif
-}
-#endif
-
 /* complex */
 
 #ifndef HAVE_RB_COMPLEX_REAL

data/lib/bigdecimal/math.rb

@@ -7,13 +7,13 @@ require 'bigdecimal'
 #   sqrt(x, prec)
 #   sin (x, prec)
 #   cos (x, prec)
-#   atan(x, prec)  Note: |x|<1, x=0.9999 may not converge.
+#   tan (x, prec)
+#   atan(x, prec)
 #   PI  (prec)
 #   E   (prec) == exp(1.0,prec)
 #
 # where:
 #   x    ... BigDecimal number to be computed.
-#            |x| must be small enough to get convergence.
 #   prec ... Number of digits to be obtained.
 #++
 #
@@ -25,8 +25,8 @@ require 'bigdecimal'
 #
 #   include BigMath
 #
-#   a = BigDecimal((PI(100)/2).to_s)
-#   puts sin(a,100) # => 0.99999999999999999999......e0
+#   a = BigDecimal((PI(49)/2).to_s)
+#   puts sin(a,100) # => 0.9999999999...9999999986e0
 #
 module BigMath
   module_function
@@ -37,13 +37,42 @@ module BigMath
   # Computes the square root of +decimal+ to the specified number of digits of
   # precision, +numeric+.
   #
-  #   BigMath.sqrt(BigDecimal('2'), 16).to_s
-  #   #=> "0.1414213562373095048801688724e1"
+  #   BigMath.sqrt(BigDecimal('2'), 32).to_s
+  #   #=> "0.14142135623730950488016887242097e1"
   #
   def sqrt(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :sqrt)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :sqrt)
     x.sqrt(prec)
   end
 
+
+  # Returns [sign, reduced_x] where reduced_x is in -pi/2..pi/2
+  # and satisfies sin(x) = sign * sin(reduced_x)
+  # If add_half_pi is true, adds pi/2 to x before reduction.
+  # Precision of pi is adjusted to ensure reduced_x has the required precision.
+  private_class_method def _sin_periodic_reduction(x, prec, add_half_pi: false) # :nodoc:
+    return [1, x] if -Math::PI/2 <= x && x <= Math::PI/2 && !add_half_pi
+
+    mod_prec = prec + BigDecimal.double_fig
+    pi_extra_prec = [x.exponent, 0].max + BigDecimal.double_fig
+    while true
+      pi = PI(mod_prec + pi_extra_prec)
+      half_pi = pi / 2
+      div, mod = (add_half_pi ? x + pi : x + half_pi).divmod(pi)
+      mod -= half_pi
+      if mod.zero? || mod_prec + mod.exponent <= 0
+        # mod is too small to estimate required pi precision
+        mod_prec = mod_prec * 3 / 2 + BigDecimal.double_fig
+      elsif mod_prec + mod.exponent < prec
+        # Estimate required precision of pi
+        mod_prec = prec - mod.exponent + BigDecimal.double_fig
+      else
+        return [div % 2 == 0 ? 1 : -1, mod.mult(1, prec)]
+      end
+    end
+  end
+
   # call-seq:
   #   sin(decimal, numeric) -> BigDecimal
   #
@@ -52,40 +81,33 @@ module BigMath
   #
   # If +decimal+ is Infinity or NaN, returns NaN.
   #
-  #   BigMath.sin(BigMath.PI(5)/4, 5).to_s
-  #   #=> "0.70710678118654752440082036563292800375e0"
+  #   BigMath.sin(BigMath.PI(5)/4, 32).to_s
+  #   #=> "0.70710807985947359435812921837984e0"
   #
   def sin(x, prec)
-    raise ArgumentError, "Zero or negative precision for sin" if prec <= 0
-    return BigDecimal("NaN") if x.infinite? || x.nan?
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :sin)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :sin)
+    return BigDecimal::Internal.nan_computation_result if x.infinite? || x.nan?
     n    = prec + BigDecimal.double_fig
     one  = BigDecimal("1")
     two  = BigDecimal("2")
-    x = -x if neg = x < 0
-    if x > (twopi = two * BigMath.PI(prec))
-      if x > 30
-        x %= twopi
-      else
-        x -= twopi while x > twopi
-      end
-    end
+    sign, x = _sin_periodic_reduction(x, n)
     x1   = x
     x2   = x.mult(x,n)
-    sign = 1
     y    = x
     d    = y
     i    = one
     z    = one
     while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
       m = BigDecimal.double_fig if m < BigDecimal.double_fig
-      sign = -sign
-      x1  = x2.mult(x1,n)
+      x1  = -x2.mult(x1,n)
       i  += two
       z  *= (i-one) * i
-      d   = sign * x1.div(z,m)
+      d   = x1.div(z,m)
       y  += d
     end
-    neg ? -y : y
+    y = BigDecimal("1") if y > 1
+    y.mult(sign, prec)
   end
 
   # call-seq:
@@ -96,40 +118,34 @@ module BigMath
   #
   # If +decimal+ is Infinity or NaN, returns NaN.
   #
-  #   BigMath.cos(BigMath.PI(4), 16).to_s
-  #   #=> "-0.999999999999999999999999999999856613163740061349e0"
+  #   BigMath.cos(BigMath.PI(16), 32).to_s
+  #   #=> "-0.99999999999999999999999999999997e0"
   #
   def cos(x, prec)
-    raise ArgumentError, "Zero or negative precision for cos" if prec <= 0
-    return BigDecimal("NaN") if x.infinite? || x.nan?
-    n    = prec + BigDecimal.double_fig
-    one  = BigDecimal("1")
-    two  = BigDecimal("2")
-    x = -x if x < 0
-    if x > (twopi = two * BigMath.PI(prec))
-      if x > 30
-        x %= twopi
-      else
-        x -= twopi while x > twopi
-      end
-    end
-    x1 = one
-    x2 = x.mult(x,n)
-    sign = 1
-    y = one
-    d = y
-    i = BigDecimal("0")
-    z = one
-    while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
-      m = BigDecimal.double_fig if m < BigDecimal.double_fig
-      sign = -sign
-      x1  = x2.mult(x1,n)
-      i  += two
-      z  *= (i-one) * i
-      d   = sign * x1.div(z,m)
-      y  += d
-    end
-    y
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :cos)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :cos)
+    return BigDecimal::Internal.nan_computation_result if x.infinite? || x.nan?
+    sign, x = _sin_periodic_reduction(x, prec + BigDecimal.double_fig, add_half_pi: true)
+    sign * sin(x, prec)
+  end
+
+  # call-seq:
+  #   tan(decimal, numeric) -> BigDecimal
+  #
+  # Computes the tangent of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is Infinity or NaN, returns NaN.
+  #
+  #   BigMath.tan(BigDecimal("0.0"), 4).to_s
+  #   #=> "0.0"
+  #
+  #   BigMath.tan(BigMath.PI(24) / 4, 32).to_s
+  #   #=> "0.99999999999999999999999830836025e0"
+  #
+  def tan(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :tan)
+    sin(x, prec + BigDecimal.double_fig).div(cos(x, prec + BigDecimal.double_fig), prec)
   end
 
   # call-seq:
@@ -140,19 +156,20 @@ module BigMath
   #
   # If +decimal+ is NaN, returns NaN.
   #
-  #   BigMath.atan(BigDecimal('-1'), 16).to_s
-  #   #=> "-0.785398163397448309615660845819878471907514682065e0"
+  #   BigMath.atan(BigDecimal('-1'), 32).to_s
+  #   #=> "-0.78539816339744830961566084581988e0"
   #
   def atan(x, prec)
-    raise ArgumentError, "Zero or negative precision for atan" if prec <= 0
-    return BigDecimal("NaN") if x.nan?
-    pi = PI(prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :atan)
+    x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :atan)
+    return BigDecimal::Internal.nan_computation_result if x.nan?
+    n = prec + BigDecimal.double_fig
+    pi = PI(n)
     x = -x if neg = x < 0
     return pi.div(neg ? -2 : 2, prec) if x.infinite?
-    return pi / (neg ? -4 : 4) if x.round(prec) == 1
-    x = BigDecimal("1").div(x, prec) if inv = x > 1
-    x = (-1 + sqrt(1 + x**2, prec))/x if dbl = x > 0.5
-    n    = prec + BigDecimal.double_fig
+    return pi.div(neg ? -4 : 4, prec) if x.round(prec) == 1
+    x = BigDecimal("1").div(x, n) if inv = x > 1
+    x = (-1 + sqrt(1 + x.mult(x, n), n)).div(x, n) if dbl = x > 0.5
     y = x
     d = y
     t = x
@@ -168,7 +185,7 @@ module BigMath
     y *= 2 if dbl
     y = pi / 2 - y if inv
     y = -y if neg
-    y
+    y.mult(1, prec)
   end
 
   # call-seq:
@@ -177,11 +194,11 @@ module BigMath
   # Computes the value of pi to the specified number of digits of precision,
   # +numeric+.
   #
-  #   BigMath.PI(10).to_s
-  #   #=> "0.3141592653589793238462643388813853786957412e1"
+  #   BigMath.PI(32).to_s
+  #   #=> "0.31415926535897932384626433832795e1"
   #
   def PI(prec)
-    raise ArgumentError, "Zero or negative precision for PI" if prec <= 0
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :PI)
     n      = prec + BigDecimal.double_fig
     zero   = BigDecimal("0")
     one    = BigDecimal("1")
@@ -213,7 +230,7 @@ module BigMath
       pi  = pi + d
       k   = k+two
     end
-    pi
+    pi.mult(1, prec)
   end
 
   # call-seq:
@@ -222,11 +239,11 @@ module BigMath
   # Computes e (the base of natural logarithms) to the specified number of
   # digits of precision, +numeric+.
   #
-  #   BigMath.E(10).to_s
-  #   #=> "0.271828182845904523536028752390026306410273e1"
+  #   BigMath.E(32).to_s
+  #   #=> "0.27182818284590452353602874713527e1"
   #
   def E(prec)
-    raise ArgumentError, "Zero or negative precision for E" if prec <= 0
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :E)
     BigMath.exp(1, prec)
   end
 end

data/lib/bigdecimal/util.rb

@@ -119,8 +119,11 @@ class Rational < Numeric
   #
   # Returns the value as a BigDecimal.
   #
-  # The required +precision+ parameter is used to determine the number of
-  # significant digits for the result.
+  # The +precision+ parameter is used to determine the number of
+  # significant digits for the result. When +precision+ is set to +0+,
+  # the number of digits to represent the float being converted is determined
+  # automatically.
+  # The default +precision+ is +0+.
   #
   #     require 'bigdecimal'
   #     require 'bigdecimal/util'
@@ -129,7 +132,7 @@ class Rational < Numeric
   #
   # See also Kernel.BigDecimal.
   #
-  def to_d(precision)
+  def to_d(precision=0)
     BigDecimal(self, precision)
   end
 end
@@ -141,29 +144,27 @@ class Complex < Numeric
   #     cmp.to_d(precision)  -> bigdecimal
   #
   # Returns the value as a BigDecimal.
+  # If the imaginary part is not +0+, an error is raised
   #
-  # The +precision+ parameter is required for a rational complex number.
-  # This parameter is used to determine the number of significant digits
-  # for the result.
+  # The +precision+ parameter is used to determine the number of
+  # significant digits for the result. When +precision+ is set to +0+,
+  # the number of digits to represent the float being converted is determined
+  # automatically.
+  # The default +precision+ is +0+.
   #
   #     require 'bigdecimal'
   #     require 'bigdecimal/util'
   #
   #     Complex(0.1234567, 0).to_d(4)   # => 0.1235e0
   #     Complex(Rational(22, 7), 0).to_d(3)   # => 0.314e1
+  #     Complex(1, 1).to_d   # raises ArgumentError
   #
   # See also Kernel.BigDecimal.
   #
-  def to_d(*args)
-    BigDecimal(self) unless self.imag.zero? # to raise eerror
+  def to_d(precision=0)
+    BigDecimal(self) unless self.imag.zero? # to raise error
 
-    if args.length == 0
-      case self.real
-      when Rational
-        BigDecimal(self.real) # to raise error
-      end
-    end
-    self.real.to_d(*args)
+    BigDecimal(self.real, precision)
   end
 end