RubyGems - ruby-decimal - Versions diffs - 0.1.0 → 0.2.0 - Mend

ruby-decimal 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

data/History.txt CHANGED Viewed

@@ -1,3 +1,9 @@
 == 0.1.0 2009-06-19
-* Initial release
+* Initial release 0.1.0
+== 0.2.0 2009-06-21
+* Release 0.2.0
+  New functions implemented: exp(), ln(), log10(), power().

data/README.txt CHANGED Viewed

@@ -9,6 +9,10 @@ define a nice feature-set and API for Decimal and have a good test suite for its
 specification. Then an efficient implementation could be written, for example
 by using a C extension wrapper around the decNumber library.
+The documentation for this package is available at http://ruby-decimal.rubyforge.org/
+The code is at http://github.com/jgoizueta/ruby-decimal/
 == Standars compliance.
 Decimal pretends to be conformant to the General Decimal Arithmetic Specification
@@ -248,7 +252,7 @@ Note that the conversion we've defined depends on the context precision:
   Decimal.local_context(:precision=>12) { puts Decimal(0.1) } -> 0.100000000000
-== Available functionality
+== More Information
 Consult the documentation for the classes Decimal and Decimal::Context.
@@ -301,6 +305,5 @@ EXPAND+
 = Roadmap
+* Version 0.3.0: Implement the remaining of GDA functions
 * Complete documentation (README sections on special values & exceptions, etc. and method descriptions.)
-* Version 0.2.0: Implement GDAS exp(), power(), ln() log10() and also the Ruby-style operator **.
-* Version 0.3.0:

data/lib/decimal/decimal.rb CHANGED Viewed

@@ -37,6 +37,16 @@ class Decimal
     attr_reader :base_conversions
   end
+  #--
+  # Some functions use the next methods instead of 10, 10**x, etc.
+  # This has been done for two reasons:
+  # * Much of the code of Decimal is generic enough to work for non-decimal floating-point numbers.
+  #   In the future a binary (or arbitrary radix) class could be derived from Decimal.
+  # * The radix power operations could be optimized (specinally for binary)
+  # But note that some code (e.g. powers & logarithms, auxiliar funtions) use algorithms
+  # that assume radix=10.
+  #++
   # Numerical base of Decimal.
   def self.radix
     10
@@ -146,8 +156,12 @@ class Decimal
   # This occurs and signals inexact whenever the result of an operation is
   # not exact (that is, it needed to be rounded and any discarded digits
   # were non-zero), or if an overflow or underflow condition occurs.  The
-  # result in all cases is unchanged.
+  # result in all cases is unchanged unless the context has exact precision,
+  # in which case the result is Nan
   class Inexact < Exception
+    def self.handle(context, *args)
+      Decimal.nan if context.exact?
+    end
   end
   # Overflow Exception.
@@ -308,6 +322,13 @@ class Decimal
     attr_accessor :rounding, :emin, :emax, :flags, :traps, :ignored_flags, :capitals, :clamp
+    # TODO: consider the convenience of adding accessors of this kind:
+    # def rounding(new_rounding=nil)
+    #   old_rounding = @rounding
+    #   @rounding = new_rounding unless new_rounding.nil?
+    #   old_rounding
+    # end
     # Ignore all flags if they are raised
     def ignore_all_flags
       #@ignored_flags << EXCEPTIONS
@@ -450,42 +471,42 @@ class Decimal
     # Addition of two decimal numbers
     def add(x,y)
-      Decimal._convert(x).add(y,self)
+      _convert(x).add(y,self)
     end
     # Subtraction of two decimal numbers
     def subtract(x,y)
-      Decimal._convert(x).subtract(y,self)
+      _convert(x).subtract(y,self)
     end
     # Multiplication of two decimal numbers
     def multiply(x,y)
-      Decimal._convert(x).multiply(y,self)
+      _convert(x).multiply(y,self)
     end
     # Division of two decimal numbers
     def divide(x,y)
-      Decimal._convert(x).divide(y,self)
+      _convert(x).divide(y,self)
     end
     # Absolute value of a decimal number
     def abs(x)
-      Decimal._convert(x).abs(self)
+      _convert(x).abs(self)
     end
     # Unary prefix plus operator
     def plus(x)
-      Decimal._convert(x).plus(self)
+      _convert(x).plus(self)
     end
     # Unary prefix minus operator
     def minus(x)
-      Decimal._convert(x)._neg(self)
+      _convert(x)._neg(self)
     end
     # Converts a number to a string
     def to_string(x, eng=false)
-      Decimal._convert(x)._fix(self).to_s(eng, self)
+      _convert(x)._fix(self).to_s(eng, self)
     end
     # Converts a number to a string, using scientific notation
@@ -502,106 +523,125 @@ class Decimal
     # by removing trailing 0s and incrementing the exponent.
     # (formerly called normalize in GDAS)
     def reduce(x)
-      Decimal._convert(x).reduce(self)
+      _convert(x).reduce(self)
     end
     # Adjusted exponent of x returned as a Decimal value.
     def logb(x)
-      Decimal._convert(x).logb(self)
+      _convert(x).logb(self)
     end
     # Adds the second value to the exponent of the first: x*(radix**y)
     #
     # y must be an integer
     def scaleb(x, y)
-      Decimal._convert(x).scaleb(y,self)
+      _convert(x).scaleb(y,self)
+    end
+    # Power. See Decimal#power()
+    def power(x,y,modulo=nil)
+      _convert(x).power(y,modulo,self)
+    end
+    # Returns the base 10 logarithm
+    def log10(x)
+      _convert(x).log10(self)
+    end
+    # Exponential function: e**x
+    def exp(x)
+      _convert(x).exp(self)
     end
+    # Returns the natural (base e) logarithm
+    def ln(x)
+      _convert(x).ln(self)
+    end
     # Exponent in relation to the significand as an integer
     # normalized to precision digits. (minimum exponent)
     def normalized_integral_exponent(x)
-      x = Decimal._convert(x)
+      x = _convert(x)
       x.integral_exponent - (precision - x.number_of_digits)
     end
     # Significand normalized to precision digits
     # x == normalized_integral_significand(x) * radix**(normalized_integral_exponent)
     def normalized_integral_significand(x)
-      x = Decimal._convert(x)
+      x = _convert(x)
       x.integral_significand*(Decimal.int_radix_power(precision - x.number_of_digits))
     end
     # Returns both the (signed) normalized integral significand and the corresponding exponent
     def to_normalized_int_scale(x)
-      x = Decimal._convert(x)
+      x = _convert(x)
       [x.sign*normalized_integral_significand(x), normalized_integral_exponent(x)]
     end
     # Is a normal number?
     def normal?(x)
-      Decimal._convert(x).normal?(self)
+      _convert(x).normal?(self)
     end
     # Is a subnormal number?
     def subnormal?(x)
-      Decimal._convert(x).subnormal?(self)
+      _convert(x).subnormal?(self)
     end
     # Classifies a number as one of
     # 'sNaN', 'NaN', '-Infinity', '-Normal', '-Subnormal', '-Zero',
     #  '+Zero', '+Subnormal', '+Normal', '+Infinity'
     def number_class(x)
-      Decimal._convert(x).number_class(self)
+      _convert(x).number_class(self)
     end
     # Square root of a decimal number
     def sqrt(x)
-      Decimal._convert(x).sqrt(self)
+      _convert(x).sqrt(self)
     end
     # Ruby-style integer division: (x/y).floor
     def div(x,y)
-      Decimal._convert(x).div(y,self)
+      _convert(x).div(y,self)
     end
     # Ruby-style modulo: x - y*div(x,y)
     def modulo(x,y)
-      Decimal._convert(x).modulo(y,self)
+      _convert(x).modulo(y,self)
     end
     # Ruby-style integer division and modulo: (x/y).floor, x - y*(x/y).floor
     def divmod(x,y)
-      Decimal._convert(x).divmod(y,self)
+      _convert(x).divmod(y,self)
     end
     # General Decimal Arithmetic Specification integer division: (x/y).truncate
     def divide_int(x,y)
-      Decimal._convert(x).divide_int(y,self)
+      _convert(x).divide_int(y,self)
     end
     # General Decimal Arithmetic Specification remainder: x - y*divide_int(x,y)
     def remainder(x,y)
-      Decimal._convert(x).remainder(y,self)
+      _convert(x).remainder(y,self)
     end
     # General Decimal Arithmetic Specification remainder-near
     #  x - y*round_half_even(x/y)
     def remainder_near(x,y)
-      Decimal._convert(x).remainder_near(y,self)
+      _convert(x).remainder_near(y,self)
     end
     # General Decimal Arithmetic Specification integer division and remainder:
     #  (x/y).truncate, x - y*(x/y).truncate
     def divrem(x,y)
-      Decimal._convert(x).divrem(y,self)
+      _convert(x).divrem(y,self)
     end
     # Fused multiply-add.
     #
     # Computes (x*y+z) with no rounding of the intermediate product x*y.
     def fma(x,y,z)
-      Decimal._convert(x).fma(y,z,self)
+      _convert(x).fma(y,z,self)
     end
     # Compares like <=> but returns a Decimal value.
@@ -610,33 +650,33 @@ class Decimal
     # * +1 if x > y
     # * NaN if x or y is NaN
     def compare(x,y)
-      Decimal._convert(x).compare(y, self)
+      _convert(x).compare(y, self)
     end
     # Returns a copy of x with the sign set to +
     def copy_abs(x)
-      Decimal._convert(x).copy_abs
+      _convert(x).copy_abs
     end
     # Returns a copy of x with the sign inverted
     def copy_negate(x)
-      Decimal._convert(x).copy_negate
+      _convert(x).copy_negate
     end
     # Returns a copy of x with the sign of y
     def copy_sign(x,y)
-      Decimal._convert(x).copy_sign(y)
+      _convert(x).copy_sign(y)
     end
     # Rescale x so that the exponent is exp, either by padding with zeros
     # or by truncating digits.
     def rescale(x, exp, watch_exp=true)
-      Decimal._convert(x).rescale(exp, self, watch_exp)
+      _convert(x).rescale(exp, self, watch_exp)
     end
     # Quantize x so its exponent is the same as that of y.
     def quantize(x, y, watch_exp=true)
-      Decimal._convert(x).quantize(y, self, watch_exp)
+      _convert(x).quantize(y, self, watch_exp)
     end
     # Return true if x and y have the same exponent.
@@ -646,7 +686,7 @@ class Decimal
     # * return true if both operands are NaNs
     # * otherwise, return false.
     def same_quantum?(x,y)
-      Decimal._convert(x).same_quantum?(y)
+      _convert(x).same_quantum?(y)
     end
     # Rounds to a nearby integer.
@@ -654,7 +694,7 @@ class Decimal
     # See also: Decimal#to_integral_value(), which does exactly the same as
     # this method except that it doesn't raise Inexact or Rounded.
     def to_integral_exact(x)
-      Decimal._convert(x).to_integral_exact(self)
+      _convert(x).to_integral_exact(self)
     end
     # Rounds to a nearby integerwithout raising inexact, rounded.
@@ -662,17 +702,17 @@ class Decimal
     # See also: Decimal#to_integral_exact(), which does exactly the same as
     # this method except that it may raise Inexact or Rounded.
     def to_integral_value(x)
-      Decimal._convert(x).to_integral_value(self)
+      _convert(x).to_integral_value(self)
     end
     # Returns the largest representable number smaller than x.
     def next_minus(x)
-      Decimal._convert(x).next_minus(self)
+      _convert(x).next_minus(self)
     end
     # Returns the smallest representable number larger than x.
     def next_plus(x)
-      Decimal._convert(x).next_plus(self)
+      _convert(x).next_plus(self)
     end
     # Returns the number closest to x, in the direction towards y.
@@ -683,7 +723,7 @@ class Decimal
     # numerically equal, then the result is a copy of x with the
     # sign set to be the same as the sign of y.
     def next_toward(x, y)
-      Decimal._convert(x).next_toward(y, self)
+      _convert(x).next_toward(y, self)
     end
     def to_s
@@ -763,6 +803,11 @@ class Decimal
     end
     private
+    def _convert(x)
+      AuxiliarFunctions._convert(x)
+    end
     def update_precision
       if @exact || @precision==0
         @exact = true
@@ -874,6 +919,13 @@ class Decimal
     keep = context.dup
     Decimal.context = define_context(*args)
     result = yield Decimal.context
+    # TODO: consider the convenience of copying the flags from Decimal.context to keep
+    # This way a local context does not affect the settings of the previous context,
+    # but flags are transferred.
+    # (this could be done always or be controlled by some option)
+    #   keep.flags = Decimal.context.flags
+    # Another alternative to consider: logically or the flags:
+    #   keep.flags ||= Decimal.context.flags # (this requires implementing || in Flags)
     Decimal.context = keep
     result
   end
@@ -958,7 +1010,7 @@ class Decimal
   #   and the left hand is another numeric type
   # * Decimal#_bin_op() used internally to define binary operators and use the Ruby coerce protocol:
   #   if the right-hand operand is of known type it is converted with Decimal; otherwise use coerce
-  # * Decimal._convert() converts known types to Decimal with Decimal() or raises an exception.
+  # * _convert() converts known types to Decimal with Decimal() or raises an exception.
   # * Decimal() casts known types and text representations of numbers to Decimal using the constructor.
   # * Decimal#initialize performs the actual type conversion
   #
@@ -1212,11 +1264,16 @@ class Decimal
     _bin_op :%, :modulo, other, context
   end
+  # Power
+  def **(other, context=nil)
+    _bin_op :**, :power, other, context
+  end
   # Addition
   def add(other, context=nil)
     context = Decimal.define_context(context)
-    other = Decimal._convert(other)
+    other = _convert(other)
     if self.special? || other.special?
       ans = _check_nans(context,other)
@@ -1252,7 +1309,7 @@ class Decimal
       return self._rescale(exp, context.rounding)._fix(context)
     end
-    op1, op2 = Decimal._normalize(self, other, context.precision)
+    op1, op2 = _normalize(self, other, context.precision)
     result_sign = result_coeff = result_exp = nil
     if op1.sign != op2.sign
@@ -1267,9 +1324,6 @@ class Decimal
       result_sign = +1
     end
-    #puts "op1=#{op1.inspect} op2=#{op2.inspect}"
     if op2.sign == +1
       result_coeff = op1.integral_significand + op2.integral_significand
     else
@@ -1278,8 +1332,6 @@ class Decimal
     result_exp = op1.integral_exponent
-    #puts "->#{Decimal([result_sign, result_coeff, result_exp]).inspect}"
     return Decimal([result_sign, result_coeff, result_exp])._fix(context)
   end
@@ -1289,7 +1341,7 @@ class Decimal
   def subtract(other, context=nil)
     context = Decimal.define_context(context)
-    other = Decimal._convert(other)
+    other = _convert(other)
     if self.special? || other.special?
       ans = _check_nans(context,other)
@@ -1301,7 +1353,7 @@ class Decimal
   # Multiplication
   def multiply(other, context=nil)
     context = Decimal.define_context(context)
-    other = Decimal._convert(other)
+    other = _convert(other)
     resultsign = self.sign * other.sign
     if self.special? || other.special?
       ans = _check_nans(context,other)
@@ -1330,7 +1382,7 @@ class Decimal
   # Division
   def divide(other, context=nil)
     context = Decimal.define_context(context)
-    other = Decimal._convert(other)
+    other = _convert(other)
     resultsign = self.sign * other.sign
     if self.special? || other.special?
       ans = _check_nans(context,other)
@@ -1414,6 +1466,8 @@ class Decimal
       end
     end
+    return context.exception(InvalidOperation, 'Exact next minus') if context.exact?
     result = nil
     Decimal.local_context(context) do |local|
       local.rounding = :floor
@@ -1429,6 +1483,7 @@ class Decimal
   # Smallest representable number larger than itself
   def next_plus(context=nil)
     context = Decimal.define_context(context)
     if special?
       ans = _check_nans(context)
       return ans if ans
@@ -1443,6 +1498,8 @@ class Decimal
       end
     end
+    return context.exception(InvalidOperation, 'Exact next plus') if context.exact?
     result = nil
     Decimal.local_context(context) do |local|
       local.rounding = :ceiling
@@ -1459,10 +1516,12 @@ class Decimal
   # Returns the number closest to self, in the direction towards other.
   def next_toward(other, context=nil)
     context = Decimal.define_context(context)
-    other = Decimal._convert(other)
+    other = _convert(other)
     ans = _check_nans(context,other)
     return ans if ans
+    return context.exception(InvalidOperation, 'Exact next_toward') if context.exact?
     comparison = self <=> other
     return self.copy_sign(other) if comparison == 0
@@ -1549,7 +1608,7 @@ class Decimal
   #  (x/y).truncate, x - y*(x/y).truncate
   def divrem(other, context=nil)
     context = Decimal.define_context(context)
-    other = Decimal._convert(other)
+    other = _convert(other)
     ans = _check_nans(context,other)
     return [ans,ans] if ans
@@ -1582,7 +1641,7 @@ class Decimal
   # Ruby-style integer division and modulo: (x/y).floor, x - y*(x/y).floor
   def divmod(other, context=nil)
     context = Decimal.define_context(context)
-    other = Decimal._convert(other)
+    other = _convert(other)
     ans = _check_nans(context,other)
     return [ans,ans] if ans
@@ -1616,7 +1675,7 @@ class Decimal
   # General Decimal Arithmetic Specification integer division: (x/y).truncate
   def divide_int(other, context=nil)
     context = Decimal.define_context(context)
-    other = Decimal._convert(other)
+    other = _convert(other)
     ans = _check_nans(context,other)
     return ans if ans
@@ -1641,7 +1700,7 @@ class Decimal
   # Ruby-style integer division: (x/y).floor
   def div(other, context=nil)
     context = Decimal.define_context(context)
-    other = Decimal._convert(other)
+    other = _convert(other)
     ans = _check_nans(context,other)
     return [ans,ans] if ans
@@ -1667,7 +1726,7 @@ class Decimal
   # Ruby-style modulo: x - y*div(x,y)
   def modulo(other, context=nil)
     context = Decimal.define_context(context)
-    other = Decimal._convert(other)
+    other = _convert(other)
     ans = _check_nans(context,other)
     return ans if ans
@@ -1690,7 +1749,7 @@ class Decimal
   # General Decimal Arithmetic Specification remainder: x - y*divide_int(x,y)
   def remainder(other, context=nil)
     context = Decimal.define_context(context)
-    other = Decimal._convert(other)
+    other = _convert(other)
     ans = _check_nans(context,other)
     return ans if ans
@@ -1714,7 +1773,7 @@ class Decimal
   #  x - y*round_half_even(x/y)
   def remainder_near(other, context=nil)
     context = Decimal.define_context(context)
-    other = Decimal._convert(other)
+    other = _convert(other)
     ans = _check_nans(context,other)
     return ans if ans
@@ -1819,7 +1878,7 @@ class Decimal
   def scaleb(other, context=nil)
     context = Decimal.define_context(context)
-    other = Decimal._convert(other)
+    other = _convert(other)
     ans = _check_nans(context, other)
     return ans if ans
     return context.exception(InvalidOperation) if other.infinite? || other.integral_exponent != 0
@@ -1843,7 +1902,11 @@ class Decimal
   # Ruby-style to integer conversion.
   def to_i
     if special?
-      return nil if nan?
+      if nan?
+        #return Decimal.context.exception(InvalidContext)
+        Decimal.context.exception InvalidContext
+        return nil
+      end
       raise Error, "Cannot convert infinity to Integer"
     end
     if @exp >= 0
@@ -2011,7 +2074,7 @@ class Decimal
   # Compares like <=> but returns a Decimal value.
   def compare(other, context=nil)
-    other = Decimal._convert(other)
+    other = _convert(other)
     if self.special? || other.special?
       ans = _check_nans(context, other)
@@ -2052,14 +2115,15 @@ class Decimal
     @coeff.to_s.size
   end
-  # Significand as an integer
+  # Significand as an integer, unsigned
   def integral_significand
     @coeff
   end
   # Exponent of the significand as an integer
   def integral_exponent
-    fractional_exponent - number_of_digits
+    # fractional_exponent - number_of_digits
+    @exp
   end
   # Sign of the number: +1 for plus / -1 for minus.
@@ -2076,262 +2140,635 @@ class Decimal
     end
   end
-  # Returns copy with sign inverted
-  def _neg(context=nil)
-    if special?
-      ans = _check_nans(context)
-      return ans if ans
-    end
-    if zero?
-      ans = copy_abs
-    else
-      ans = copy_negate
-    end
-    context = Decimal.define_context(context)
-    ans._fix(context)
+  # Returns a copy of with the sign set to +
+  def copy_abs
+    Decimal.new([+1,@coeff,@exp])
   end
-  # Returns a copy with precision adjusted
-  def _pos(context=nil)
-    if special?
-      ans = _check_nans(context)
-      return ans if ans
-    end
-    if zero?
-      ans = copy_abs
-    else
-      ans = Decimal.new(self)
-    end
-    context = Decimal.define_context(context)
-    ans._fix(context)
+  # Returns a copy of with the sign inverted
+  def copy_negate
+    Decimal.new([-@sign,@coeff,@exp])
   end
-  # Returns a copy with positive sign
-  def _abs(round=true, context=nil)
-    return copy_abs if not round
-    if special?
-      ans = _check_nans(context)
-      return ans if ans
-    end
-    if sign>0
-      ans = _neg(context)
-    else
-      ans = _pos(context)
-    end
-    ans
+  # Returns a copy of with the sign of other
+  def copy_sign(other)
+    Decimal.new([other.sign, @coeff, @exp])
   end
-  # Round if it is necessary to keep within precision.
-  def _fix(context)
-    return self if context.exact?
-    if special?
-      if nan?
-        return _fix_nan(context)
+  # Returns true if the value is an integer
+  def integral?
+    if finite?
+      if @exp>=0 || @coeff==0
+        true
       else
-        return Decimal.new(self)
+        if @exp <= -number_of_digits
+          false
+        else
+          m = Decimal.int_radix_power(-@exp)
+          (@coeff % m) == 0
+        end
       end
+    else
+      false
     end
+  end
-    etiny = context.etiny
-    etop  = context.etop
-    if zero?
-      exp_max = context.clamp? ? etop : context.emax
-      new_exp = [[@exp, etiny].max, exp_max].min
-      if new_exp!=@exp
-        context.exception Clamped
-        return Decimal.new([sign,0,new_exp])
+  # returns true if is an even integer
+  def even?
+    # integral? && ((to_i%2)==0)
+    if finite?
+      if @exp>0 || @coeff==0
+        true
       else
-        return Decimal.new(self)
+        if @exp <= -number_of_digits
+          false
+        else
+          m = Decimal.int_radix_power(-@exp)
+          if (@coeff % m) == 0
+            # ((@coeff / m) % 2) == 0
+            ((@coeff / m) & 1) == 0
+          else
+            false
+          end
+        end
       end
+    else
+      false
     end
+  end
-    nd = number_of_digits
-    exp_min = nd + @exp - context.precision
-    if exp_min > etop
-      context.exception Inexact
-      context.exception Rounded
-      return context.exception(Overflow, 'above Emax', sign)
-    end
-    self_is_subnormal = exp_min < etiny
-    if self_is_subnormal
-      context.exception Subnormal
-      exp_min = etiny
-    end
-    if @exp < exp_min
-      #puts "_fix(#{self}) rounded; e=#{@exp} em=#{exp_min}"
-      context.exception Rounded
-      # dig is the digits number from 0 (MS) to number_of_digits-1 (LS)
-      # dg = numberof_digits-dig is from 1 (LS) to number_of_digits (MS)
-      dg = exp_min - @exp # dig = number_of_digits + exp - exp_min
-      if dg > number_of_digits # dig<0
-        d = Decimal.new([sign,1,exp_min-1])
-        dg = number_of_digits # dig = 0
+  # returns true if is an odd integer
+  def odd?
+    # integral? && ((to_i%2)==1)
+    # integral? && !even?
+    if finite?
+      if @exp>0 || @coeff==0
+        false
       else
-        d = Decimal.new(self)
-      end
-      changed = d._round(context.rounding, dg)
-      coeff = Decimal.int_div_radix_power(d.integral_significand, dg)
-      coeff += 1 if changed==1
-      ans = Decimal.new([sign, coeff, exp_min])
-      if changed!=0
-        context.exception Inexact
-        if self_is_subnormal
-          context.exception Underflow
-          if ans.zero?
-            context.exception Clamped
-          end
-        elsif ans.number_of_digits == context.precision+1
-          if ans.integral_exponent< etop
-            ans = Decimal.new([ans.sign, Decimal.int_div_radix_power(ans.integral_significand,1), ans.integral_exponent+1])
+        if @exp <= -number_of_digits
+          false
+        else
+          m = Decimal.int_radix_power(-@exp)
+          if (@coeff % m) == 0
+            # ((@coeff / m) % 2) == 1
+            ((@coeff / m) & 1) == 1
           else
-            ans = context.exception(Overflow, 'above Emax', d.sign)
+            false
           end
         end
       end
-      return ans
+    else
+      false
     end
+  end
-    if context.clamp? &&  @exp>etop
-      context.exception Clamped
-      self_padded = Decimal.int_mult_radix_power(@coeff, @exp-etop)
-      return Decimal.new([sign,self_padded,etop])
+  # Rescale so that the exponent is exp, either by padding with zeros
+  # or by truncating digits.
+  def rescale(exp, context=nil, watch_exp=true)
+    context = Decimal.define_context(context)
+    exp = _convert(exp)
+    if self.special? || exp.special?
+      ans = _check_nans(context, exp)
+      return ans if ans
+      if exp.infinite? || self.infinite?
+        return Decimal.new(self) if exp.infinite? && self.infinite?
+        return context.exception(InvalidOperation, 'rescale with one INF')
+      end
     end
-    return Decimal.new(self)
+    return context.exception(InvalidOperation,"exponent of rescale is not integral") unless exp.integral?
+    exp = exp.to_i
+    _watched_rescale(exp, context, watch_exp)
   end
+  # Quantize so its exponent is the same as that of y.
+  def quantize(exp, context=nil, watch_exp=true)
+    exp = _convert(exp)
+    context = Decimal.define_context(context)
+    if self.special? || exp.special?
+      ans = _check_nans(context, exp)
+      return ans if ans
+      if exp.infinite? || self.infinite?
+        return Decimal.new(self) if exp.infinite? && self.infinite?
+        return context.exception(InvalidOperation, 'quantize with one INF')
+      end
+    end
+    exp = exp.integral_exponent
+    _watched_rescale(exp, context, watch_exp)
+  end
-  ROUND_ARITHMETIC = true
-  # Round to i digits using the specified method
-  def _round(rounding, i)
-    send("_round_#{rounding}", i)
+  # Return true if has the same exponent as other.
+  #
+  # If either operand is a special value, the following rules are used:
+  # * return true if both operands are infinities
+  # * return true if both operands are NaNs
+  # * otherwise, return false.
+  def same_quantum?(other)
+    other = _convert(other)
+    if self.special? || other.special?
+      return (self.nan? && other.nan?) || (self.infinite? && other.infinite?)
+    end
+    return self.integral_exponent == other.integral_exponent
   end
-  # Round down (toward 0, truncate) to i digits
-  def _round_down(i)
-    if ROUND_ARITHMETIC
-      (@coeff % Decimal.int_radix_power(i))==0 ? 0 : -1
-    else
-      d = @coeff.to_s
-      p = d.size - i
-      d[p..-1].match(/\A0+\Z/) ? 0 : -1
+  # Rounds to a nearby integer. May raise Inexact or Rounded.
+  def to_integral_exact(context=nil)
+    context = Decimal.define_context(context)
+    if special?
+      ans = _check_nans(context)
+      return ans if ans
+      return Decimal.new(self)
     end
+    return Decimal.new(self) if @exp >= 0
+    return Decimal.new([@sign, 0, 0]) if zero?
+    context.exception Rounded
+    ans = _rescale(0, context.rounding)
+    context.exception Inexact if ans != self
+    return ans
   end
-  # Round up (away from 0) to i digits
-  def _round_up(i)
-    -_round_down(i)
+  # Rounds to a nearby integer. Doesn't raise Inexact or Rounded.
+  def to_integral_value(context=nil)
+    context = Decimal.define_context(context)
+    if special?
+      ans = _check_nans(context)
+      return ans if ans
+      return Decimal.new(self)
+    end
+    return Decimal.new(self) if @exp >= 0
+    return _rescale(0, context.rounding)
   end
-  # Round to closest i-digit number with ties down (rounds 5 toward 0)
-  def _round_half_down(i)
-    if ROUND_ARITHMETIC
-      m = Decimal.int_radix_power(i)
-      if (m>1) && ((@coeff%m) == m/2)
-        -1
-      else
-        _round_half_up(i)
-      end
+  # General rounding.
+  #
+  # With an integer argument this acts like Float#round: the parameter specifies the number
+  # of fractional digits (or digits to the left of the decimal point if negative).
+  #
+  # Options can be passed as a Hash instead; valid options are:
+  # * :rounding method for rounding (see Context#new())
+  # The precision can be specified as:
+  # * :places number of fractional digits as above.
+  # * :exponent specifies the exponent corresponding to the
+  #   digit to be rounded (exponent == -places)
+  # * :precision or :significan_digits is the number of digits
+  # * :power 10^exponent, value of the digit to be rounded,
+  #   should be passed as a type convertible to Decimal.
+  # * :index 0-based index of the digit to be rounded
+  # * :rindex right 0-based index of the digit to be rounded
+  #
+  # The default is :places=>0 (round to integer).
+  #
+  # Example: ways of specifiying the rounding position
+  #   number:     1   2   3   4  .  5    6    7    8
+  #   :places    -3  -2  -1   0     1    2    3    4
+  #   :exponent   3   2   1   0    -1   -2   -3   -4
+  #   :precision  1   2   3   4     5    6    7    8
+  #   :power    1E3 1E2  10   1   0.1 1E-2 1E-3 1E-4
+  #   :index      0   1   2   3     4    5    6    7
+  #   :index      7   6   5   4     3    2    1    0
+  def round(opt={})
+    opt = { :places=>opt } if opt.kind_of?(Integer)
+    r = opt[:rounding] || :half_up
+    as_int = false
+    if v=(opt[:precision] || opt[:significant_digits])
+      prec = v
+    elsif v=(opt[:places])
+      prec = adjusted_exponent + 1 + v
+    elsif v=(opt[:exponent])
+      prec = adjusted_exponent + 1 - v
+    elsif v=(opt[:power])
+      prec = adjusted_exponent + 1 - Decimal(v).adjusted_exponent
+    elsif v=(opt[:index])
+      prec = i+1
+    elsif v=(opt[:rindex])
+      prec = number_of_digits - v
     else
-      d = @coeff.to_s
-      p = d.size - i
-      d[p..-1].match(/^5d*$/) ? -1 : _round_half_up(i)
+      prec = adjusted_exponent + 1
+      as_int = true
     end
+    result = plus(:rounding=>r, :precision=>prec)
+    return as_int ? result.to_i : result
+  end
+  # General ceiling operation (as for Float) with same options for precision
+  # as Decimal#round()
+  def ceil(opt={})
+    opt[:rounding] = :ceiling
+    round opt
   end
-  # Round to closest i-digit number with ties up (rounds 5 away from 0)
-  def _round_half_up(i)
-    if ROUND_ARITHMETIC
-      m = Decimal.int_radix_power(i)
-      if (m>1) && ((@coeff%m) >= m/2)
-        1
-      else
-        (@coeff % m)==0 ? 0 : -1
+  # General floor operation (as for Float) with same options for precision
+  # as Decimal#round()
+  def floor(opt={})
+    opt[:rounding] = :floor
+    round opt
+  end
+  # General truncate operation (as for Float) with same options for precision
+  # as Decimal#round()
+  def truncate(opt={})
+    opt[:rounding] = :down
+    round opt
+  end
+  # Fused multiply-add.
+  #
+  # Computes (self*other+third) with no rounding of the intermediate product self*other.
+  def fma(other, third, context=nil)
+    context = Decimal.define_context(context)
+    other = _convert(other)
+    third = _convert(third)
+    if self.special? || other.special?
+      return context.exception(InvalidOperation, 'sNaN', self) if self.snan?
+      return context.exception(InvalidOperation, 'sNaN', other) if other.snan?
+      if self.nan?
+        product = self
+      elsif other.nan?
+        product = other
+      elsif self.infinite?
+        return context.exception(InvalidOperation, 'INF * 0 in fma') if other.zero?
+        product = Decimal.infinity(self.sign*other.sign)
+      elsif other.infinite?
+        return context.exception(InvalidOperation, '0 * INF  in fma') if self.zero?
+        product = Decimal.infinity(self.sign*other.sign)
       end
     else
-      d = @coeff.to_s
-      p = d.size - i
-      if '56789'.include?(d[p,1])
-        1
+      product = Decimal.new([self.sign*other.sign,self.integral_significand*other.integral_significand, self.integral_exponent+other.integral_exponent])
+    end
+    return product.add(third, context)
+  end
+  # Raises to the power of x, to modulo if given.
+  #
+  # With two arguments, compute self**other.  If self is negative then other
+  # must be integral.  The result will be inexact unless other is
+  # integral and the result is finite and can be expressed exactly
+  # in 'precision' digits.
+  #
+  # With three arguments, compute (self**other) % modulo.  For the
+  # three argument form, the following restrictions on the
+  # arguments hold:
+  #
+  #  - all three arguments must be integral
+  #  - other must be nonnegative
+  #  - at least one of self or other must be nonzero
+  #  - modulo must be nonzero and have at most 'precision' digits
+  #
+  # The result of a.power(b, modulo) is identical to the result
+  # that would be obtained by computing (a**b) % modulo with
+  # unbounded precision, but is computed more efficiently.  It is
+  # always exact.
+  def power(other, modulo=nil, context=nil)
+    if context.nil? && (modulo.is_a?(Context) || modulo.is_a?(Hash))
+      context = modulo
+      modulo = nil
+    end
+    return self.power_modulo(other, modulo, context) if modulo
+    context = Decimal.define_context(context)
+    other = _convert(other)
+    ans = _check_nans(context, other)
+    return ans if ans
+    # 0**0 = NaN (!), x**0 = 1 for nonzero x (including +/-Infinity)
+    if other.zero?
+      if self.zero?
+        return context.exception(InvalidOperation, '0 ** 0')
       else
-        d[p..-1].match(/^0+$/) ? 0 : -1
+        return Decimal(1)
       end
     end
-  end
+    # result has sign -1 iff self.sign is -1 and other is an odd integer
+    result_sign = +1
+    _self = self
+    if _self.sign == -1
+      if other.integral?
+        result_sign = -1 if !other.even?
+      else
+        # -ve**noninteger = NaN
+        # (-0)**noninteger = 0**noninteger
+        unless self.zero?
+          return context.exception(InvalidOperation, 'x ** y with x negative and y not an integer')
+        end
+      end
+      # negate self, without doing any unwanted rounding
+      _self = self.copy_negate
+    end
+    # 0**(+ve or Inf)= 0; 0**(-ve or -Inf) = Infinity
+    if _self.zero?
+      return (other.sign == +1) ? Decimal(result_sign, 0, 0) : Decimal.infinity(result_sign)
+    end
+    # Inf**(+ve or Inf) = Inf; Inf**(-ve or -Inf) = 0
+    if _self.infinite?
+      return (other.sign == +1) ? Decimal.infinity(result_sign) : Decimal(result_sign, 0, 0)
+    end
+    # 1**other = 1, but the choice of exponent and the flags
+    # depend on the exponent of self, and on whether other is a
+    # positive integer, a negative integer, or neither
+    if _self == Decimal(1)
+      return _self if context.exact?
+      if other.integral?
+        # exp = max(self._exp*max(int(other), 0),
+        # 1-context.prec) but evaluating int(other) directly
+        # is dangerous until we know other is small (other
+        # could be 1e999999999)
+        if other.sign == -1
+          multiplier = 0
+        elsif other > context.precision
+          multiplier = context.precision
+        else
+          multiplier = other.to_i
+        end
-  # Round to closest i-digit number with ties (5) to an even digit
-  def _round_half_even(i)
-    if ROUND_ARITHMETIC
-      m = Decimal.int_radix_power(i)
-      if (m>1) && ((@coeff%m) == m/2 && ((@coeff/m)%2)==0)
-        -1
+        exp = _self.integral_exponent * multiplier
+        if exp < 1-context.precision
+          exp = 1-context.precision
+          context.exception Rounded
+        end
       else
-        _round_half_up(i)
+        context.exception Rounded
+        context.exception Inexact
+        exp = 1-context.precision
+      end
+      return Decimal(result_sign, Decimal.int_radix_power(-exp), exp)
+    end
+    # compute adjusted exponent of self
+    self_adj = _self.adjusted_exponent
+    # self ** infinity is infinity if self > 1, 0 if self < 1
+    # self ** -infinity is infinity if self < 1, 0 if self > 1
+    if other.infinite?
+      if (other.sign == +1) == (self_adj < 0)
+        return Decimal(result_sign, 0, 0)
+      else
+        return Decimal.infinity(result_sign)
+      end
+    end
+    # from here on, the result always goes through the call
+    # to _fix at the end of this function.
+    ans = nil
+    # crude test to catch cases of extreme overflow/underflow.  If
+    # log10(self)*other >= 10**bound and bound >= len(str(Emax))
+    # then 10**bound >= 10**len(str(Emax)) >= Emax+1 and hence
+    # self**other >= 10**(Emax+1), so overflow occurs.  The test
+    # for underflow is similar.
+    bound = _self._log10_exp_bound + other.adjusted_exponent
+    if (self_adj >= 0) == (other.sign == +1)
+      # self > 1 and other +ve, or self < 1 and other -ve
+      # possibility of overflow
+      if bound >= context.emax.to_s.length
+        ans = Decimal(result_sign, 1, context.emax+1)
       end
     else
-      d = @coeff.to_s
-      p = d.size - i
+      # self > 1 and other -ve, or self < 1 and other +ve
+      # possibility of underflow to 0
+      etiny = context.etiny
+      if bound >= (-etiny).to_s.length
+        ans = Decimal(result_sign, 1, etiny-1)
+      end
+    end
-      if d[p..-1].match(/\A#{radix/2}0*\Z/) && (p==0 || ((d[p-1,1].to_i%2)==0))
-        -1
+    # try for an exact result with precision +1
+    if ans.nil?
+      if context.exact?
+        if other.adjusted_exponent < 100
+          test_precision = _self.number_of_digits*other.to_i+1
+        else
+          test_precision = _self.number_of_digits+1
+        end
       else
-        _round_half_up(i)
+        test_precision = context.precision + 1
       end
+      ans = _self._power_exact(other, test_precision)
+      if !ans.nil? && (result_sign == -1)
+        ans = Decimal(-1, ans.integral_significand, ans.integral_exponent)
+      end
+    end
+    # usual case: inexact result, x**y computed directly as exp(y*log(x))
+    if !ans.nil?
+      return ans if context.exact?
+    else
+      return context.exception(Inexact, "Inexact power") if context.exact?
+      p = context.precision
+      xc = _self.integral_significand
+      xe = _self.integral_exponent
+      yc = other.integral_significand
+      ye = other.integral_exponent
+      yc = -yc if other.sign == -1
+      # compute correctly rounded result:  start with precision +3,
+      # then increase precision until result is unambiguously roundable
+      extra = 3
+      coeff, exp = nil, nil
+      loop do
+        coeff, exp = _dpower(xc, xe, yc, ye, p+extra)
+        #break if (coeff % Decimal.int_mult_radix_power(5,coeff.to_s.length-p-1)) != 0
+        break if (coeff % (5*10**(coeff.to_s.length-p-1))) != 0
+        extra += 3
+      end
+      ans = Decimal(result_sign, coeff, exp)
     end
-  end
-  # Round up (not away from 0 if negative) to i digits
-  def _round_ceiling(i)
-    sign<0 ? _round_down(i) : -_round_down(i)
+    # the specification says that for non-integer other we need to
+    # raise Inexact, even when the result is actually exact.  In
+    # the same way, we need to raise Underflow here if the result
+    # is subnormal.  (The call to _fix will take care of raising
+    # Rounded and Subnormal, as usual.)
+    if !other.integral?
+      context.exception Inexact
+      # pad with zeros up to length context.precision+1 if necessary
+      if ans.number_of_digits <= context.precision
+        expdiff = context.precision+1 - ans.number_of_digits
+        ans = Decimal(ans.sign, Decimal.int_mult_radix_power(ans.integral_significand, expdiff), ans.integral_exponent-expdiff)
+      end
+      context.exception Underflow if ans.adjusted_exponent < context.emin
+    end
+    # unlike exp, ln and log10, the power function respects the
+    # rounding mode; no need to use ROUND_HALF_EVEN here
+    ans._fix(context)
   end
-  # Round down (not toward 0 if negative) to i digits
-  def _round_floor(i)
-    sign>0 ? _round_down(i) : -_round_down(i)
-  end
+  # Returns the base 10 logarithm
+  def log10(context=nil)
+    context = Decimal.define_context(context)
-  # Round down unless digit i-1 is 0 or 5
-  def _round_up05(i)
-    if ROUND_ARITHMETIC
-      dg = (@coeff%Decimal.int_radix_power(i+1))/Decimal.int_radix_power(i)
+    # log10(NaN) = NaN
+    ans = _check_nans(context)
+    return ans if ans
+    # log10(0.0) == -Infinity
+    return Decimal.infinity(-1) if self.zero?
+    # log10(Infinity) = Infinity
+    return Decimal.infinity if self.infinite? && self.sign == +1
+    # log10(negative or -Infinity) raises InvalidOperation
+    return context.exception(InvalidOperation, 'log10 of a negative value') if self.sign == -1
+    digits = self.digits
+    # log10(10**n) = n
+    if digits.first == 1 && digits[1..-1].all?{|d| d==0}
+      # answer may need rounding
+      ans = Decimal(self.integral_exponent + digits.size - 1)
+      return ans if context.exact?
     else
-      d = @coeff.to_s
-      p = d.size - i
-      dg = (p>0) ? d[p-1,1].to_i : 0
+      # result is irrational, so necessarily inexact
+      return context.exception(Inexact, "Inexact power") if context.exact?
+      c = self.integral_significand
+      e = self.integral_exponent
+      p = context.precision
+      # correctly rounded result: repeatedly increase precision
+      # until result is unambiguously roundable
+      places = p-self._log10_exp_bound+2
+      coeff = nil
+      loop do
+        coeff = _dlog10(c, e, places)
+        # assert coeff.abs.to_s.length-p >= 1
+        break if (coeff % (5*10**(coeff.abs.to_s.length-p-1)))!=0
+        places += 3
+      end
+      ans = Decimal(coeff<0 ? -1 : +1, coeff.abs, -places)
     end
-    if [0,Decimal.radix/2].include?(dg)
-      -_round_down(i)
-    else
-      _round_down(i)
+    Decimal.context(context, :rounding=>:half_even) do |local_context|
+      ans = ans._fix(local_context)
+      context.flags = local_context.flags
     end
+    return ans
   end
-  # adjust payload of a NaN to the context
-  def _fix_nan(context)
-    if  !context.exact?
-      payload = @coeff
-      payload = nil if payload==0
+  # Exponential function
+  def exp(context=nil)
+    context = Decimal.define_context(context)
-      max_payload_len = context.maximum_nan_diagnostic_digits
+    # exp(NaN) = NaN
+    ans = _check_nans(context)
+    return ans if ans
-      if number_of_digits > max_payload_len
-          payload = payload.to_s[-max_payload_len..-1].to_i
-          return Decimal([@sign, payload, @exp])
+    # exp(-Infinity) = 0
+    return Decimal.zero if self.infinite? && (self.sign == -1)
+    # exp(0) = 1
+    return Decimal(1) if self.zero?
+    # exp(Infinity) = Infinity
+    return Decimal(self) if self.infinite?
+    # the result is now guaranteed to be inexact (the true
+    # mathematical result is transcendental). There's no need to
+    # raise Rounded and Inexact here---they'll always be raised as
+    # a result of the call to _fix.
+    return context.exception(Inexact, 'Inexact exp') if context.exact?
+    p = context.precision
+    adj = self.adjusted_exponent
+    # we only need to do any computation for quite a small range
+    # of adjusted exponents---for example, -29 <= adj <= 10 for
+    # the default context.  For smaller exponent the result is
+    # indistinguishable from 1 at the given precision, while for
+    # larger exponent the result either overflows or underflows.
+    if self.sign == +1 and adj > ((context.emax+1)*3).to_s.length
+      # overflow
+      ans = Decimal(+1, 1, context.emax+1)
+    elsif self.sign == -1 and adj > ((-context.etiny+1)*3).to_s.length
+      # underflow to 0
+      ans = Decimal(+1, 1, context.etiny-1)
+    elsif self.sign == +1 and adj < -p
+      # p+1 digits; final round will raise correct flags
+      ans = Decimal(+1, Decimal.int_radix_power(p)+1, -p)
+    elsif self.sign == -1 and adj < -p-1
+      # p+1 digits; final round will raise correct flags
+      ans = Decimal(+1, Decimal.int_radix_power(p+1)-1, -p-1)
+    else
+      # general case
+      c = self.integral_significand
+      e = self.integral_exponent
+      c = -c if self.sign == -1
+      # compute correctly rounded result: increase precision by
+      # 3 digits at a time until we get an unambiguously
+      # roundable result
+      extra = 3
+      coeff = exp = nil
+      loop do
+        coeff, exp = _dexp(c, e, p+extra)
+        break if (coeff % (5*10**(coeff.to_s.length-p-1)))!=0
+        extra += 3
       end
+      ans = Decimal(+1, coeff, exp)
     end
-    Decimal(self)
+    # at this stage, ans should round correctly with *any*
+    # rounding mode, not just with ROUND_HALF_EVEN
+    Decimal.context(context, :rounding=>:half_even) do |local_context|
+      ans = ans._fix(local_context)
+      context.flags = local_context.flags
+    end
+    return ans
+  end
+  # Returns the natural (base e) logarithm
+  def ln(context=nil)
+    context = Decimal.define_context(context)
+    # ln(NaN) = NaN
+    ans = _check_nans(context)
+    return ans if ans
+    # ln(0.0) == -Infinity
+    return Decimal.infinity(-1) if self.zero?
+    # ln(Infinity) = Infinity
+    return Decimal.infinity if self.infinite? && self.sign == +1
+    # ln(1.0) == 0.0
+    return Decimal.zero if self == Decimal(1)
+    # ln(negative) raises InvalidOperation
+    return context.exception(InvalidOperation, 'ln of a negative value') if self.sign==-1
+    # result is irrational, so necessarily inexact
+    return context.exception(Inexact, 'Inexact exp') if context.exact?
+    c = self.integral_significand
+    e = self.integral_exponent
+    p = context.precision
+    # correctly rounded result: repeatedly increase precision by 3
+    # until we get an unambiguously roundable result
+    places = p - self._ln_exp_bound + 2 # at least p+3 places
+    coeff = nil
+    loop do
+      coeff = _dlog(c, e, places)
+      # assert coeff.to_s.length-p >= 1
+      break if (coeff % (5*10**(coeff.abs.to_s.length-p-1))) != 0
+      places += 3
+    end
+    ans = Decimal((coeff<0) ? -1 : +1, coeff.abs, -places)
+    Decimal.context(context, :rounding=>:half_even) do |local_context|
+      ans = ans._fix(local_context)
+      context.flags = local_context.flags
+    end
+    return ans
   end
+  # Auxiliar Methods
   # Check if the number or other is NaN, signal if sNaN or return NaN;
   # return nil if none is NaN.
   def _check_nans(context=nil, other=nil)
@@ -2377,113 +2814,23 @@ class Decimal
   end
-  # Normalizes op1, op2 to have the same exp and length of coefficient. Used for addition.
-  def Decimal._normalize(op1, op2, prec=0)
-    #puts "N: #{op1.inspect} #{op2.inspect} p=#{prec}"
-    if op1.integral_exponent < op2.integral_exponent
-      swap = true
-      tmp,other = op2,op1
-    else
-      swap = false
-      tmp,other = op1,op2
+  def _watched_rescale(exp, context, watch_exp)
+    if !watch_exp
+      ans = _rescale(exp, context.rounding)
+      context.exception(Rounded) if ans.integral_exponent > self.integral_exponent
+      context.exception(Inexact) if ans != self
+      return ans
     end
-    tmp_len = tmp.number_of_digits
-    other_len = other.number_of_digits
-    exp = tmp.integral_exponent + [-1, tmp_len - prec - 2].min
-    #puts "exp=#{exp}"
-    if (other_len+other.integral_exponent-1 < exp) && prec>0
-      other = Decimal.new([other.sign, 1, exp])
-      #puts "other = #{other.inspect}"
+    if exp < context.etiny || exp > context.emax
+      return context.exception(InvalidOperation, "target operation out of bounds in quantize/rescale")
     end
-    tmp = Decimal.new([tmp.sign, int_mult_radix_power(tmp.integral_significand, tmp.integral_exponent-other.integral_exponent), other.integral_exponent])
-    #puts "tmp=#{tmp.inspect}"
-    return swap ? [other, tmp] : [tmp, other]
-  end
-  # Returns a copy of with the sign set to +
-  def copy_abs
-    Decimal.new([+1,@coeff,@exp])
-  end
+    return Decimal.new([@sign, 0, exp])._fix(context) if zero?
-  # Returns a copy of with the sign inverted
-  def copy_negate
-    Decimal.new([-@sign,@coeff,@exp])
-  end
-  # Returns a copy of with the sign of other
-  def copy_sign(other)
-    Decimal.new([other.sign, @coeff, @exp])
-  end
-  # Returns true if the value is an integer
-  def integral?
-    if finite?
-      if @exp>=0 || @coeff==0
-        true
-      else
-        if @exp <= -number_of_digits
-          false
-        else
-          m = Decimal.int_radix_power(-@exp)
-          (@coeff % m) == 0
-        end
-      end
-    else
-      false
-    end
-  end
-  # Rescale so that the exponent is exp, either by padding with zeros
-  # or by truncating digits.
-  def rescale(exp, context=nil, watch_exp=true)
-    context = Decimal.define_context(context)
-    exp = Decimal._convert(exp)
-    if self.special? || exp.special?
-      ans = _check_nans(context, exp)
-      return ans if ans
-      if exp.infinite? || self.infinite?
-        return Decimal.new(self) if exp.infinite? && self.infinite?
-        return context.exception(InvalidOperation, 'rescale with one INF')
-      end
-    end
-    return context.exception(InvalidOperation,"exponent of rescale is not integral") unless exp.integral?
-    exp = exp.to_i
-    _watched_rescale(exp, context, watch_exp)
-  end
-  # Quantize so its exponent is the same as that of y.
-  def quantize(exp, context=nil, watch_exp=true)
-    exp = Decimal._convert(exp)
-    context = Decimal.define_context(context)
-    if self.special? || exp.special?
-      ans = _check_nans(context, exp)
-      return ans if ans
-      if exp.infinite? || self.infinite?
-        return Decimal.new(self) if exp.infinite? && self.infinite?
-        return context.exception(InvalidOperation, 'quantize with one INF')
-      end
-    end
-    exp = exp.integral_exponent
-    _watched_rescale(exp, context, watch_exp)
-  end
-  def _watched_rescale(exp, context, watch_exp)
-    if !watch_exp
-      ans = _rescale(exp, context.rounding)
-      context.exception(Rounded) if ans.integral_exponent > self.integral_exponent
-      context.exception(Inexact) if ans != self
-      return ans
-    end
-    if exp < context.etiny || exp > context.emax
-      return context.exception(InvalidOperation, "target operation out of bounds in quantize/rescale")
-    end
-    return Decimal.new([@sign, 0, exp])._fix(context) if zero?
-    self_adjusted = adjusted_exponent
-    return context.exception(InvalidOperation,"exponent of quantize/rescale result too large for current context") if self_adjusted > context.emax
-    return context.exception(InvalidOperation,"quantize/rescale has too many digits for current context") if (self_adjusted - exp + 1 > context.precision) && !context.exact?
+    self_adjusted = adjusted_exponent
+    return context.exception(InvalidOperation,"exponent of quantize/rescale result too large for current context") if self_adjusted > context.emax
+    return context.exception(InvalidOperation,"quantize/rescale has too many digits for current context") if (self_adjusted - exp + 1 > context.precision) && !context.exact?
     ans = _rescale(exp, context.rounding)
     return context.exception(InvalidOperation,"exponent of rescale result too large for current context") if ans.adjusted_exponent > context.emax
@@ -2496,147 +2843,153 @@ class Decimal
     return ans._fix(context)
   end
-  # Return true if has the same exponent as other.
-  #
-  # If either operand is a special value, the following rules are used:
-  # * return true if both operands are infinities
-  # * return true if both operands are NaNs
-  # * otherwise, return false.
-  def same_quantum?(other)
-    other = Decimal._convert(other)
-    if self.special? || other.special?
-      return (self.nan? && other.nan?) || (self.infinite? && other.infinite?)
+  # Returns copy with sign inverted
+  def _neg(context=nil)
+    if special?
+      ans = _check_nans(context)
+      return ans if ans
     end
-    return self.integral_exponent == other.integral_exponent
+    if zero?
+      ans = copy_abs
+    else
+      ans = copy_negate
+    end
+    context = Decimal.define_context(context)
+    ans._fix(context)
   end
-  # Rounds to a nearby integer. May raise Inexact or Rounded.
-  def to_integral_exact(context=nil)
-    context = Decimal.define_context(context)
+  # Returns a copy with precision adjusted
+  def _pos(context=nil)
     if special?
       ans = _check_nans(context)
       return ans if ans
-      return Decimal.new(self)
     end
-    return Decimal.new(self) if @exp >= 0
-    return Decimal.new([@sign, 0, 0]) if zero?
-    context.exception Rounded
-    ans = _rescale(0, context.rounding)
-    context.exception Inexact if ans != self
-    return ans
+    if zero?
+      ans = copy_abs
+    else
+      ans = Decimal.new(self)
+    end
+    context = Decimal.define_context(context)
+    ans._fix(context)
   end
-  # Rounds to a nearby integer. Doesn't raise Inexact or Rounded.
-  def to_integral_value(context=nil)
-    context = Decimal.define_context(context)
+  # Returns a copy with positive sign
+  def _abs(round=true, context=nil)
+    return copy_abs if not round
     if special?
       ans = _check_nans(context)
       return ans if ans
-      return Decimal.new(self)
     end
-    return Decimal.new(self) if @exp >= 0
-    return _rescale(0, context.rounding)
-  end
-  # General rounding.
-  #
-  # With an integer argument this acts like Float#round: the parameter specifies the number
-  # of fractional digits (or digits to the left of the decimal point if negative).
-  #
-  # Options can be passed as a Hash instead; valid options are:
-  # * :rounding method for rounding (see Context#new())
-  # The precision can be specified as:
-  # * :places number of fractional digits as above.
-  # * :exponent specifies the exponent corresponding to the
-  #   digit to be rounded (exponent == -places)
-  # * :precision or :significan_digits is the number of digits
-  # * :power 10^exponent, value of the digit to be rounded,
-  #   should be passed as a type convertible to Decimal.
-  # * :index 0-based index of the digit to be rounded
-  # * :rindex right 0-based index of the digit to be rounded
-  #
-  # The default is :places=>0 (round to integer).
-  #
-  # Example: ways of specifiying the rounding position
-  #   number:     1   2   3   4  .  5    6    7    8
-  #   :places    -3  -2  -1   0     1    2    3    4
-  #   :exponent   3   2   1   0    -1   -2   -3   -4
-  #   :precision  1   2   3   4     5    6    7    8
-  #   :power    1E3 1E2  10   1   0.1 1E-2 1E-3 1E-4
-  #   :index      0   1   2   3     4    5    6    7
-  #   :index      7   6   5   4     3    2    1    0
-  def round(opt={})
-    opt = { :places=>opt } if opt.kind_of?(Integer)
-    r = opt[:rounding] || :half_up
-    as_int = false
-    if v=(opt[:precision] || opt[:significant_digits])
-      prec = v
-    elsif v=(opt[:places])
-      prec = adjusted_exponent + 1 + v
-    elsif v=(opt[:exponent])
-      prec = adjusted_exponent + 1 - v
-    elsif v=(opt[:power])
-      prec = adjusted_exponent + 1 - Decimal(v).adjusted_exponent
-    elsif v=(opt[:index])
-      prec = i+1
-    elsif v=(opt[:rindex])
-      prec = number_of_digits - v
+    if sign>0
+      ans = _neg(context)
     else
-      prec = adjusted_exponent + 1
-      as_int = true
+      ans = _pos(context)
     end
-    result = plus(:rounding=>r, :precision=>prec)
-    return as_int ? result.to_i : result
+    ans
   end
-  # General ceiling operation (as for Float) with same options for precision
-  # as Decimal#round()
-  def ceil(opt={})
-    opt[:rounding] = :ceiling
-    round opt
-  end
+  # Round if it is necessary to keep within precision.
+  def _fix(context)
+    return self if context.exact?
-  # General floor operation (as for Float) with same options for precision
-  # as Decimal#round()
-  def floor(opt={})
-    opt[:rounding] = :floor
-    round opt
-  end
+    if special?
+      if nan?
+        return _fix_nan(context)
+      else
+        return Decimal.new(self)
+      end
+    end
+    etiny = context.etiny
+    etop  = context.etop
+    if zero?
+      exp_max = context.clamp? ? etop : context.emax
+      new_exp = [[@exp, etiny].max, exp_max].min
+      if new_exp!=@exp
+        context.exception Clamped
+        return Decimal.new([sign,0,new_exp])
+      else
+        return Decimal.new(self)
+      end
+    end
+    nd = number_of_digits
+    exp_min = nd + @exp - context.precision
+    if exp_min > etop
+      context.exception Inexact
+      context.exception Rounded
+      return context.exception(Overflow, 'above Emax', sign)
+    end
+    self_is_subnormal = exp_min < etiny
+    if self_is_subnormal
+      context.exception Subnormal
+      exp_min = etiny
+    end
+    if @exp < exp_min
+      context.exception Rounded
+      # dig is the digits number from 0 (MS) to number_of_digits-1 (LS)
+      # dg = numberof_digits-dig is from 1 (LS) to number_of_digits (MS)
+      dg = exp_min - @exp # dig = number_of_digits + exp - exp_min
+      if dg > number_of_digits # dig<0
+        d = Decimal.new([sign,1,exp_min-1])
+        dg = number_of_digits # dig = 0
+      else
+        d = Decimal.new(self)
+      end
+      changed = d._round(context.rounding, dg)
+      coeff = Decimal.int_div_radix_power(d.integral_significand, dg)
+      coeff += 1 if changed==1
+      ans = Decimal.new([sign, coeff, exp_min])
+      if changed!=0
+        context.exception Inexact
+        if self_is_subnormal
+          context.exception Underflow
+          if ans.zero?
+            context.exception Clamped
+          end
+        elsif ans.number_of_digits == context.precision+1
+          if ans.integral_exponent< etop
+            ans = Decimal.new([ans.sign, Decimal.int_div_radix_power(ans.integral_significand,1), ans.integral_exponent+1])
+          else
+            ans = context.exception(Overflow, 'above Emax', d.sign)
+          end
+        end
+      end
+      return ans
+    end
+    if context.clamp? &&  @exp>etop
+      context.exception Clamped
+      self_padded = Decimal.int_mult_radix_power(@coeff, @exp-etop)
+      return Decimal.new([sign,self_padded,etop])
+    end
+    return Decimal.new(self)
-  # General truncate operation (as for Float) with same options for precision
-  # as Decimal#round()
-  def truncate(opt={})
-    opt[:rounding] = :down
-    round opt
   end
-  # Fused multiply-add.
-  #
-  # Computes (self*other+third) with no rounding of the intermediate product self*other.
-  def fma(other, third, context=nil)
-    context = Decimal.define_context(context)
-    other = Decimal._convert(other)
-    third = Decimal._convert(third)
-    if self.special? || other.special?
-      return context.exception(InvalidOperation, 'sNaN', self) if self.snan?
-      return context.exception(InvalidOperation, 'sNaN', other) if other.snan?
-      if self.nan?
-        product = self
-      elsif other.nan?
-        product = other
-      elsif self.infinite?
-        return context.exception(InvalidOperation, 'INF * 0 in fma') if other.zero?
-        product = Decimal.infinity(self.sign*other.sign)
-      elsif other.infinite?
-        return context.exception(InvalidOperation, '0 * INF  in fma') if self.zero?
-        product = Decimal.infinity(self.sign*other.sign)
+  # adjust payload of a NaN to the context
+  def _fix_nan(context)
+    if  !context.exact?
+      payload = @coeff
+      payload = nil if payload==0
+      max_payload_len = context.maximum_nan_diagnostic_digits
+      if number_of_digits > max_payload_len
+          payload = payload.to_s[-max_payload_len..-1].to_i
+          return Decimal([@sign, payload, @exp])
       end
-    else
-      product = Decimal.new([self.sign*other.sign,self.integral_significand*other.integral_significand, self.integral_exponent+other.integral_exponent])
     end
-    return product.add(third, context)
+    Decimal(self)
   end
+  protected
   def _divide_truncate(other, context)
     context = Decimal.define_context(context)
     sign = self.sign * other.sign
@@ -2715,28 +3068,869 @@ class Decimal
   end
-  # Convert a numeric value to decimal (internal use)
-  def Decimal._convert(x, error=true)
-    case x
-    when Decimal
-      x
-    when *Decimal.context.coercible_types
-      Decimal.new(x)
+  # Power-modulo: self._power_modulo(other, modulo) == (self**other) % modulo
+  # This is equivalent to Python's 3-argument version of pow()
+  def _power_modulo(other, modulo, context=nil)
+    context = Decimal.define_context(context)
+    other = _convert(other)
+    modulo = _convert(third)
+    if self.nan? || other.nan? || modulo.nan?
+      return context.exception(InvalidOperation, 'sNaN', self) if self.snan?
+      return context.exception(InvalidOperation, 'sNaN', other) if other.snan?
+      return context.exception(InvalidOperation, 'sNaN', modulo) if other.modulo?
+      return self._fix_nan(context) if self.nan?
+      return other._fix_nan(context) if other.nan?
+      return modulo._fix_nan(context) # if modulo.nan?
+    end
+    if !(self.integral? && other.integral? && modulo.integral?)
+      return context.exception(InvalidOperation, '3-argument power not allowed unless all arguments are integers.')
+    end
+    if other < 0
+      return context.exception(InvalidOperation, '3-argument power cannot have a negative 2nd argument.')
+    end
+    if modulo.zero?
+      return context.exception(InvalidOperation, '3-argument power cannot have a 0 3rd argument.')
+    end
+    if modulo.adjusted_exponent >= context.precision
+      return context.exception(InvalidOperation, 'insufficient precision: power 3rd argument must not have more than precision digits')
+    end
+    if other.zero? && self.zero?
+      return context.exception(InvalidOperation, "0**0 not defined")
+    end
+    sign = other.even? ? +1 : -1
+    modulo = modulo.to_i.abs
+    base = (self.integral_significand % modulo * (Decimal.int_radix_power(self.integral_exponent) % modulo)) % modulo
+    other.integral_exponent.times do
+      base = (base**Decimal.radix) % modulo
+    end
+    base = (base**other.integral_significand) % modulo
+    Decimal(sign, base, 0)
+  end
+  # Attempt to compute self**other exactly
+  # Given Decimals self and other and an integer p, attempt to
+  # compute an exact result for the power self**other, with p
+  # digits of precision.  Return nil if self**other is not
+  # exactly representable in p digits.
+  #
+  # Assumes that elimination of special cases has already been
+  # performed: self and other must both be nonspecial; self must
+  # be positive and not numerically equal to 1; other must be
+  # nonzero.  For efficiency, other.integral_exponent should not be too large,
+  # so that 10**other.integral.exponent.abs is a feasible calculation.
+  def _power_exact(other, p)
+    # In the comments below, we write x for the value of self and
+    # y for the value of other.  Write x = xc*10**xe and y =
+    # yc*10**ye.
+    # The main purpose of this method is to identify the *failure*
+    # of x**y to be exactly representable with as little effort as
+    # possible.  So we look for cheap and easy tests that
+    # eliminate the possibility of x**y being exact.  Only if all
+    # these tests are passed do we go on to actually compute x**y.
+    # Here's the main idea.  First normalize both x and y.  We
+    # express y as a rational m/n, with m and n relatively prime
+    # and n>0.  Then for x**y to be exactly representable (at
+    # *any* precision), xc must be the nth power of a positive
+    # integer and xe must be divisible by n.  If m is negative
+    # then additionally xc must be a power of either 2 or 5, hence
+    # a power of 2**n or 5**n.
+    #
+    # There's a limit to how small |y| can be: if y=m/n as above
+    # then:
+    #
+    #  (1) if xc != 1 then for the result to be representable we
+    #      need xc**(1/n) >= 2, and hence also xc**|y| >= 2.  So
+    #      if |y| <= 1/nbits(xc) then xc < 2**nbits(xc) <=
+    #      2**(1/|y|), hence xc**|y| < 2 and the result is not
+    #      representable.
+    #
+    #  (2) if xe != 0, |xe|*(1/n) >= 1, so |xe|*|y| >= 1.  Hence if
+    #      |y| < 1/|xe| then the result is not representable.
+    #
+    # Note that since x is not equal to 1, at least one of (1) and
+    # (2) must apply.  Now |y| < 1/nbits(xc) iff |yc|*nbits(xc) <
+    # 10**-ye iff len(str(|yc|*nbits(xc)) <= -ye.
+    #
+    # There's also a limit to how large y can be, at least if it's
+    # positive: the normalized result will have coefficient xc**y,
+    # so if it's representable then xc**y < 10**p, and y <
+    # p/log10(xc).  Hence if y*log10(xc) >= p then the result is
+    # not exactly representable.
+    # if len(str(abs(yc*xe)) <= -ye then abs(yc*xe) < 10**-ye,
+    # so |y| < 1/xe and the result is not representable.
+    # Similarly, len(str(abs(yc)*xc_bits)) <= -ye implies |y|
+    # < 1/nbits(xc).
+    xc = self.integral_significand
+    xe = self.integral_exponent
+    while (xc % Decimal.radix) == 0
+      xc /= Decimal.radix
+      xe += 1
+    end
+    yc = other.integral_significand
+    ye = other.integral_exponent
+    while (yc % Decimal.radix) == 0
+      yc /= Decimal.radix
+      ye += 1
+    end
+    # case where xc == 1: result is 10**(xe*y), with xe*y
+    # required to be an integer
+    if xc == 1
+      if ye >= 0
+        exponent = xe*yc*Decimal.int_radix_power(ye)
+      else
+        exponent, remainder = (xe*yc).divmod(Decimal.int_radix_power(-ye))
+        return nil if remainder!=0
+      end
+      exponent = -exponent if other.sign == -1
+      # if other is a nonnegative integer, use ideal exponent
+      if other.integral? and (other.sign == +1)
+        ideal_exponent = self.integral_exponent*other.to_i
+        zeros = [exponent-ideal_exponent, p-1].min
+      else
+        zeros = 0
+      end
+      return Decimal(+1, Decimal.int_radix_power(zeros), exponent-zeros)
+    end
+    # case where y is negative: xc must be either a power
+    # of 2 or a power of 5.
+    if other.sign == -1
+      last_digit = (xc % 10)
+      if [2,4,6,8].include?(last_digit)
+        # quick test for power of 2
+        return nil if xc & -xc != xc
+        # now xc is a power of 2; e is its exponent
+        e = _nbits(xc)-1
+        # find e*y and xe*y; both must be integers
+        if ye >= 0
+          y_as_int = yc*Decimal.int_radix_power(ye)
+          e = e*y_as_int
+          xe = xe*y_as_int
+        else
+          ten_pow = Decimal.int_radix_power(-ye)
+          e, remainder = (e*yc).divmod(ten_pow)
+          return nil if remainder!=0
+          xe, remainder = (xe*yc).divmod(ten_pow)
+          return nil if remainder!=0
+        end
+        return nil if e*65 >= p*93 # 93/65 > log(10)/log(5)
+        xc = 5**e
+      elsif last_digit == 5
+        # e >= log_5(xc) if xc is a power of 5; we have
+        # equality all the way up to xc=5**2658
+        e = _nbits(xc)*28/65
+        xc, remainder = (5**e).divmod(xc)
+        return nil if remainder!=0
+        while (xc % 5) == 0
+          xc /= 5
+          e -= 1
+        end
+        if ye >= 0
+          y_as_integer = Decimal.int_mult_radix_power(yc,ye)
+          e = e*y_as_integer
+          xe = xe*y_as_integer
+        else
+          ten_pow = Decimal.int_radix_power(-ye)
+          e, remainder = (e*yc).divmod(ten_pow)
+          return nil if remainder
+          xe, remainder = (xe*yc).divmod(ten_pow)
+          return nil if remainder
+        end
+        return nil if e*3 >= p*10 # 10/3 > log(10)/log(2)
+        xc = 2**e
+      else
+        return nil
+      end
+      return nil if xc >= Decimal.int_radix_power(p)
+      xe = -e-xe
+      return Decimal(+1, xc, xe)
+    end
+    # now y is positive; find m and n such that y = m/n
+    if ye >= 0
+      m, n = yc*10**ye, 1
     else
-      raise TypeError, "Unable to convert #{x.class} to Decimal" if error
-      nil
+      return nil if (xe != 0) and ((yc*xe).abs.to_s.length <= -ye)
+      xc_bits = _nbits(xc)
+      return nil if (xc != 1) and ((yc.abs*xc_bits).to_s.length <= -ye)
+      m, n = yc, Decimal.int_radix_power(-ye)
+      while ((m % 2) == 0) && ((n % 2) == 0)
+        m /= 2
+        n /= 2
+      end
+      while ((m % 5) == 0) && ((n % 5) == 0)
+        m /= 5
+        n /= 5
+      end
+    end
+    # compute nth root of xc*10**xe
+    if n > 1
+      # if 1 < xc < 2**n then xc isn't an nth power
+      return nil if xc != 1 and xc_bits <= n
+      xe, rem = xe.divmod(n)
+      return nil if rem != 0
+      # compute nth root of xc using Newton's method
+      a = 1 << -(-_nbits(xc)/n) # initial estimate
+      q = r = nil
+      loop do
+        q, r = xc.divmod(a**(n-1))
+        break if a <= q
+        a = (a*(n-1) + q)/n
+      end
+      return nil if !((a == q) and (r == 0))
+      xc = a
+    end
+    # now xc*10**xe is the nth root of the original xc*10**xe
+    # compute mth power of xc*10**xe
+    # if m > p*100/_log10_lb(xc) then m > p/log10(xc), hence xc**m >
+    # 10**p and the result is not representable.
+    return nil if (xc > 1) and (m > p*100/_log10_lb(xc))
+    xc = xc**m
+    xe *= m
+    return nil if xc > 10**p
+    # by this point the result *is* exactly representable
+    # adjust the exponent to get as close as possible to the ideal
+    # exponent, if necessary
+    str_xc = xc.to_s
+    if other.integral? && other.sign == +1
+      ideal_exponent = self.integral_exponent*other.to_i
+      zeros = [xe-ideal_exponent, p-str_xc.length].min
+    else
+      zeros = 0
+    end
+    return Decimal(+1, Decimal.int_mult_radix_power(xc, zeros), xe-zeros)
+  end
+  ROUND_ARITHMETIC = true
+  # Round to i digits using the specified method
+  def _round(rounding, i)
+    send("_round_#{rounding}", i)
+  end
+  # Round down (toward 0, truncate) to i digits
+  def _round_down(i)
+    if ROUND_ARITHMETIC
+      (@coeff % Decimal.int_radix_power(i))==0 ? 0 : -1
+    else
+      d = @coeff.to_s
+      p = d.size - i
+      d[p..-1].match(/\A0+\Z/) ? 0 : -1
+    end
+  end
+  # Round up (away from 0) to i digits
+  def _round_up(i)
+    -_round_down(i)
+  end
+  # Round to closest i-digit number with ties down (rounds 5 toward 0)
+  def _round_half_down(i)
+    if ROUND_ARITHMETIC
+      m = Decimal.int_radix_power(i)
+      if (m>1) && ((@coeff%m) == m/2)
+        -1
+      else
+        _round_half_up(i)
+      end
+    else
+      d = @coeff.to_s
+      p = d.size - i
+      d[p..-1].match(/^5d*$/) ? -1 : _round_half_up(i)
+    end
+  end
+  # Round to closest i-digit number with ties up (rounds 5 away from 0)
+  def _round_half_up(i)
+    if ROUND_ARITHMETIC
+      m = Decimal.int_radix_power(i)
+      if (m>1) && ((@coeff % m) >= m/2)
+        1
+      else
+        (@coeff % m)==0 ? 0 : -1
+      end
+    else
+      d = @coeff.to_s
+      p = d.size - i
+      if '56789'.include?(d[p,1])
+        1
+      else
+        d[p..-1].match(/^0+$/) ? 0 : -1
+      end
+    end
+  end
+  # Round to closest i-digit number with ties (5) to an even digit
+  def _round_half_even(i)
+    if ROUND_ARITHMETIC
+      m = Decimal.int_radix_power(i)
+      if (m>1) && ((@coeff%m) == m/2 && ((@coeff/m)%2)==0)
+        -1
+      else
+        _round_half_up(i)
+      end
+    else
+      d = @coeff.to_s
+      p = d.size - i
+      if d[p..-1].match(/\A#{Decimal.radix/2}0*\Z/) && (p==0 || ((d[p-1,1].to_i%2)==0))
+        -1
+      else
+        _round_half_up(i)
+      end
     end
   end
-  # Parse numeric text literals (internal use)
-  def _parser(txt)
-    md = /^\s*([-+])?(?:(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:[eE]([-+]?\d+))?|Inf(?:inity)?|(s)?NaN(\d*))\s*$/i.match(txt)
-    if md
-      OpenStruct.new :sign=>md[1], :int=>md[2], :frac=>md[3], :onlyfrac=>md[4], :exp=>md[5],
-                     :signal=>md[6], :diag=>md[7]
+  # Round up (not away from 0 if negative) to i digits
+  def _round_ceiling(i)
+    sign<0 ? _round_down(i) : -_round_down(i)
+  end
+  # Round down (not toward 0 if negative) to i digits
+  def _round_floor(i)
+    sign>0 ? _round_down(i) : -_round_down(i)
+  end
+  # Round down unless digit i-1 is 0 or 5
+  def _round_up05(i)
+    if ROUND_ARITHMETIC
+      dg = (@coeff%Decimal.int_radix_power(i+1))/Decimal.int_radix_power(i)
+    else
+      d = @coeff.to_s
+      p = d.size - i
+      dg = (p>0) ? d[p-1,1].to_i : 0
+    end
+    if [0,Decimal.radix/2].include?(dg)
+      -_round_down(i)
+    else
+      _round_down(i)
     end
   end
+  # Compute a lower bound for the adjusted exponent of self.log10()
+  # In other words, find r such that self.log10() >= 10**r.
+  # Assumes that self is finite and positive and that self != 1.
+  def _log10_exp_bound
+    # For x >= 10 or x < 0.1 we only need a bound on the integer
+    # part of log10(self), and this comes directly from the
+    # exponent of x.  For 0.1 <= x <= 10 we use the inequalities
+    # 1-1/x <= log(x) <= x-1. If x > 1 we have |log10(x)| >
+    # (1-1/x)/2.31 > 0.  If x < 1 then |log10(x)| > (1-x)/2.31 > 0
+    adj = self.integral_exponent + number_of_digits - 1
+    return adj.to_s.length - 1 if adj >= 1 # self >= 10
+    return (-1-adj).to_s.length-1 if adj <= -2 # self < 0.1
+    c = self.integral_significand
+    e = self.integral_exponent
+    if adj == 0
+      # 1 < self < 10
+      num = (c - Decimal.int_radix_power(-e)).to_s
+      den = (231*c).to_s
+      return num.length - den.length - ((num < den) ? 1 : 0) + 2
+    end
+    # adj == -1, 0.1 <= self < 1
+    num = (Decimal.int_radix_power(-e)-c).to_s
+    return num.length + e - ((num < "231") ? 1 : 0) - 1
+  end
+  # Compute a lower bound for the adjusted exponent of self.ln().
+  # In other words, compute r such that self.ln() >= 10**r.  Assumes
+  # that self is finite and positive and that self != 1.
+  def _ln_exp_bound
+    # for 0.1 <= x <= 10 we use the inequalities 1-1/x <= ln(x) <= x-1
+    adj = self.integral_exponent + number_of_digits - 1
+    if adj >= 1
+      # argument >= 10; we use 23/10 = 2.3 as a lower bound for ln(10)
+      return (adj*23/10).to_s.length - 1
+    end
+    if adj <= -2
+      # argument <= 0.1
+      return ((-1-adj)*23/10).to_s.length - 1
+    end
+    c = self.integral_significand
+    e = self.integral_exponent
+    if adj == 0
+      # 1 < self < 10
+      num = (c-(10**-e)).to_s
+      den = c.to_s
+      return num.length - den.length - ((num < den) ? 1 : 0)
+    end
+    # adj == -1, 0.1 <= self < 1
+    return e + (10**-e - c).to_s.length - 1
+ end
+  module AuxiliarFunctions #:nodoc:
+    module_function
+    # Convert a numeric value to decimal (internal use)
+    def _convert(x, error=true)
+      case x
+      when Decimal
+        x
+      when *Decimal.context.coercible_types
+        Decimal.new(x)
+      else
+        raise TypeError, "Unable to convert #{x.class} to Decimal" if error
+        nil
+      end
+    end
+    # Parse numeric text literals (internal use)
+    def _parser(txt)
+      md = /^\s*([-+])?(?:(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:[eE]([-+]?\d+))?|Inf(?:inity)?|(s)?NaN(\d*))\s*$/i.match(txt)
+      if md
+        OpenStruct.new :sign=>md[1], :int=>md[2], :frac=>md[3], :onlyfrac=>md[4], :exp=>md[5],
+                       :signal=>md[6], :diag=>md[7]
+      end
+    end
+    # Normalizes op1, op2 to have the same exp and length of coefficient. Used for addition.
+    def _normalize(op1, op2, prec=0)
+      if op1.integral_exponent < op2.integral_exponent
+        swap = true
+        tmp,other = op2,op1
+      else
+        swap = false
+        tmp,other = op1,op2
+      end
+      tmp_len = tmp.number_of_digits
+      other_len = other.number_of_digits
+      exp = tmp.integral_exponent + [-1, tmp_len - prec - 2].min
+      if (other_len+other.integral_exponent-1 < exp) && prec>0
+        other = Decimal.new([other.sign, 1, exp])
+      end
+      tmp = Decimal.new(tmp.sign,
+                        Decimal.int_mult_radix_power(tmp.integral_significand, tmp.integral_exponent-other.integral_exponent),
+                        other.integral_exponent)
+      return swap ? [other, tmp] : [tmp, other]
+    end
+    # Number of bits in binary representation of the positive integer n, or 0 if n == 0.
+    #--
+    # This function from Tim Peters was taken from here:
+    # http://mail.python.org/pipermail/python-list/1999-July/007758.html
+    # The correction being in the function definition is for speed, and
+    # the whole function is not resolved with math.log because of avoiding
+    # the use of floats.
+    #++
+    def _nbits(n, correction = {                      #:nodoc:
+            '0'=> 4, '1'=> 3, '2'=> 2, '3'=> 2,
+            '4'=> 1, '5'=> 1, '6'=> 1, '7'=> 1,
+            '8'=> 0, '9'=> 0, 'a'=> 0, 'b'=> 0,
+            'c'=> 0, 'd'=> 0, 'e'=> 0, 'f'=> 0})
+      raise  TypeError, "The argument to _nbits should be nonnegative." if n < 0
+      hex_n = "%x" % n
+      4*hex_n.length - correction[hex_n[0,1]]
+    end
+    # Given integers xc, xe, yc and ye representing Decimals x = xc*10**xe and
+    # y = yc*10**ye, compute x**y.  Returns a pair of integers (c, e) such that:
+    #
+    #   10**(p-1) <= c <= 10**p, and
+    #   (c-1)*10**e < x**y < (c+1)*10**e
+    #
+    # in other words, c*10**e is an approximation to x**y with p digits
+    # of precision, and with an error in c of at most 1.  (This is
+    # almost, but not quite, the same as the error being < 1ulp: when c
+    # == 10**(p-1) we can only guarantee error < 10ulp.)
+    #
+    # We assume that: x is positive and not equal to 1, and y is nonzero.
+    def _dpower(xc, xe, yc, ye, p)
+      # Find b such that 10**(b-1) <= |y| <= 10**b
+      b = yc.abs.to_s.length + ye
+      # log(x) = lxc*10**(-p-b-1), to p+b+1 places after the decimal point
+      lxc = _dlog(xc, xe, p+b+1)
+      # compute product y*log(x) = yc*lxc*10**(-p-b-1+ye) = pc*10**(-p-1)
+      shift = ye-b
+      if shift >= 0
+          pc = lxc*yc*10**shift
+      else
+          pc = _div_nearest(lxc*yc, 10**-shift)
+      end
+      if pc == 0
+          # we prefer a result that isn't exactly 1; this makes it
+          # easier to compute a correctly rounded result in __pow__
+          if (xc.to_s.length + xe >= 1) == (yc > 0) # if x**y > 1:
+              coeff, exp = 10**(p-1)+1, 1-p
+          else
+              coeff, exp = 10**p-1, -p
+          end
+      else
+          coeff, exp = _dexp(pc, -(p+1), p+1)
+          coeff = _div_nearest(coeff, 10)
+          exp += 1
+      end
+      return coeff, exp
+    end
+    # Compute an approximation to exp(c*10**e), with p decimal places of precision.
+    # Returns integers d, f such that:
+    #
+    #   10**(p-1) <= d <= 10**p, and
+    #   (d-1)*10**f < exp(c*10**e) < (d+1)*10**f
+    #
+    # In other words, d*10**f is an approximation to exp(c*10**e) with p
+    # digits of precision, and with an error in d of at most 1.  This is
+    # almost, but not quite, the same as the error being < 1ulp: when d
+    # = 10**(p-1) the error could be up to 10 ulp.
+    def _dexp(c, e, p)
+        # we'll call iexp with M = 10**(p+2), giving p+3 digits of precision
+        p += 2
+        # compute log(10) with extra precision = adjusted exponent of c*10**e
+        extra = [0, e + c.to_s.length - 1].max
+        q = p + extra
+        # compute quotient c*10**e/(log(10)) = c*10**(e+q)/(log(10)*10**q),
+        # rounding down
+        shift = e+q
+        if shift >= 0
+            cshift = c*10**shift
+        else
+            cshift = c/10**-shift
+        end
+        quot, rem = cshift.divmod(_log10_digits(q))
+        # reduce remainder back to original precision
+        rem = _div_nearest(rem, 10**extra)
+        # error in result of _iexp < 120;  error after division < 0.62
+        return _div_nearest(_iexp(rem, 10**p), 1000), quot - p + 3
+    end
+    # Closest integer to a/b, a and b positive integers; rounds to even
+    # in the case of a tie.
+    def _div_nearest(a, b)
+      q, r = a.divmod(b)
+      q + (((2*r + (q&1)) > b) ? 1 : 0)
+    end
+    # Closest integer to the square root of the positive integer n.  a is
+    # an initial approximation to the square root.  Any positive integer
+    # will do for a, but the closer a is to the square root of n the
+    # faster convergence will be.
+    def _sqrt_nearest(n, a)
+        if n <= 0 or a <= 0
+            raise ArgumentError, "Both arguments to _sqrt_nearest should be positive."
+        end
+        b=0
+        while a != b
+            b, a = a, a--n/a>>1 # ??
+        end
+        return a
+    end
+    # Given an integer x and a nonnegative integer shift, return closest
+    # integer to x / 2**shift; use round-to-even in case of a tie.
+    def _rshift_nearest(x, shift)
+        b, q = (1 << shift), (x >> shift)
+        return q + (((2*(x & (b-1)) + (q&1)) > b) ? 1 : 0)
+        #return q + (2*(x & (b-1)) + (((q&1) > b) ? 1 : 0))
+    end
+    # Integer approximation to M*log(x/M), with absolute error boundable
+    # in terms only of x/M.
+    #
+    # Given positive integers x and M, return an integer approximation to
+    # M * log(x/M).  For L = 8 and 0.1 <= x/M <= 10 the difference
+    # between the approximation and the exact result is at most 22.  For
+    # L = 8 and 1.0 <= x/M <= 10.0 the difference is at most 15.  In
+    # both cases these are upper bounds on the error; it will usually be
+    # much smaller.
+    def _ilog(x, m, l = 8)
+      # The basic algorithm is the following: let log1p be the function
+      # log1p(x) = log(1+x).  Then log(x/M) = log1p((x-M)/M).  We use
+      # the reduction
+      #
+      #    log1p(y) = 2*log1p(y/(1+sqrt(1+y)))
+      #
+      # repeatedly until the argument to log1p is small (< 2**-L in
+      # absolute value).  For small y we can use the Taylor series
+      # expansion
+      #
+      #    log1p(y) ~ y - y**2/2 + y**3/3 - ... - (-y)**T/T
+      #
+      # truncating at T such that y**T is small enough.  The whole
+      # computation is carried out in a form of fixed-point arithmetic,
+      # with a real number z being represented by an integer
+      # approximation to z*M.  To avoid loss of precision, the y below
+      # is actually an integer approximation to 2**R*y*M, where R is the
+      # number of reductions performed so far.
+      y = x-m
+      # argument reduction; R = number of reductions performed
+      r = 0
+      # while (r <= l && y.abs << l-r >= m ||
+      #        r > l and y.abs>> r-l >= m)
+      while (((r <= l) && ((y.abs << (l-r)) >= m)) ||
+             ((r > l) && ((y.abs>>(r-l)) >= m)))
+          y = _div_nearest((m*y) << 1,
+                           m + _sqrt_nearest(m*(m+_rshift_nearest(y, r)), m))
+          r += 1
+      end
+      # Taylor series with T terms
+      t = -(-10*m.to_s.length/(3*l)).to_i
+      yshift = _rshift_nearest(y, r)
+      w = _div_nearest(m, t)
+      # (1...t).reverse_each do |k| # Ruby 1.9
+      (1...t).to_a.reverse.each do |k|
+         w = _div_nearest(m, k) - _div_nearest(yshift*w, m)
+      end
+      return _div_nearest(w*y, m)
+    end
+    # Given integers c, e and p with c > 0, p >= 0, compute an integer
+    # approximation to 10**p * log10(c*10**e), with an absolute error of
+    # at most 1.  Assumes that c*10**e is not exactly 1.
+    def _dlog10(c, e, p)
+       # increase precision by 2; compensate for this by dividing
+      # final result by 100
+      p += 2
+      # write c*10**e as d*10**f with either:
+      #   f >= 0 and 1 <= d <= 10, or
+      #   f <= 0 and 0.1 <= d <= 1.
+      # Thus for c*10**e close to 1, f = 0
+      l = c.to_s.length
+      f = e+l - ((e+l >= 1) ? 1 : 0)
+      if p > 0
+        m = 10**p
+        k = e+p-f
+        if k >= 0
+          c *= 10**k
+        else
+          c = _div_nearest(c, 10**-k)
+        end
+        log_d = _ilog(c, m) # error < 5 + 22 = 27
+        log_10 = _log10_digits(p) # error < 1
+        log_d = _div_nearest(log_d*m, log_10)
+        log_tenpower = f*m # exact
+      else
+        log_d = 0  # error < 2.31
+        log_tenpower = _div_nearest(f, 10**-p) # error < 0.5
+      end
+      return _div_nearest(log_tenpower+log_d, 100)
+    end
+    # Compute a lower bound for 100*log10(c) for a positive integer c.
+    def _log10_lb(c, correction = {
+            '1'=> 100, '2'=> 70, '3'=> 53, '4'=> 40, '5'=> 31,
+            '6'=> 23, '7'=> 16, '8'=> 10, '9'=> 5})
+        raise ArgumentError, "The argument to _log10_lb should be nonnegative." if c <= 0
+        str_c = c.to_s
+        return 100*str_c.length - correction[str_c[0,1]]
+    end
+    # Given integers c, e and p with c > 0, compute an integer
+    # approximation to 10**p * log(c*10**e), with an absolute error of
+    # at most 1.  Assumes that c*10**e is not exactly 1.
+    def _dlog(c, e, p)
+        # Increase precision by 2. The precision increase is compensated
+        # for at the end with a division by 100.
+        p += 2
+        # rewrite c*10**e as d*10**f with either f >= 0 and 1 <= d <= 10,
+        # or f <= 0 and 0.1 <= d <= 1.  Then we can compute 10**p * log(c*10**e)
+        # as 10**p * log(d) + 10**p*f * log(10).
+        l = c.to_s.length
+        f = e+l - ((e+l >= 1) ? 1 : 0)
+        # compute approximation to 10**p*log(d), with error < 27
+        if p > 0
+            k = e+p-f
+            if k >= 0
+                c *= 10**k
+            else
+                c = _div_nearest(c, 10**-k)  # error of <= 0.5 in c
+            end
+            # _ilog magnifies existing error in c by a factor of at most 10
+            log_d = _ilog(c, 10**p) # error < 5 + 22 = 27
+        else
+            # p <= 0: just approximate the whole thing by 0; error < 2.31
+            log_d = 0
+        end
+        # compute approximation to f*10**p*log(10), with error < 11.
+        if f
+            extra = f.abs.to_s.length - 1
+            if p + extra >= 0
+                # error in f * _log10_digits(p+extra) < |f| * 1 = |f|
+                # after division, error < |f|/10**extra + 0.5 < 10 + 0.5 < 11
+                f_log_ten = _div_nearest(f*_log10_digits(p+extra), 10**extra)
+            else
+                f_log_ten = 0
+            end
+        else
+            f_log_ten = 0
+        end
+        # error in sum < 11+27 = 38; error after division < 0.38 + 0.5 < 1
+        return _div_nearest(f_log_ten + log_d, 100)
+    end
+    # Given integers x and M, M > 0, such that x/M is small in absolute
+    # value, compute an integer approximation to M*exp(x/M).  For 0 <=
+    # x/M <= 2.4, the absolute error in the result is bounded by 60 (and
+    # is usually much smaller).
+    def _iexp(x, m, l=8)
+        # Algorithm: to compute exp(z) for a real number z, first divide z
+        # by a suitable power R of 2 so that |z/2**R| < 2**-L.  Then
+        # compute expm1(z/2**R) = exp(z/2**R) - 1 using the usual Taylor
+        # series
+        #
+        #     expm1(x) = x + x**2/2! + x**3/3! + ...
+        #
+        # Now use the identity
+        #
+        #     expm1(2x) = expm1(x)*(expm1(x)+2)
+        #
+        # R times to compute the sequence expm1(z/2**R),
+        # expm1(z/2**(R-1)), ... , exp(z/2), exp(z).
+        # Find R such that x/2**R/M <= 2**-L
+        r = _nbits((x<<l)/m)
+        # Taylor series.  (2**L)**T > M
+        t = -(-10*m.to_s.length/(3*l)).to_i
+        y = _div_nearest(x, t)
+        mshift = m<<r
+        (1...t).to_a.reverse.each do |i|
+            y = _div_nearest(x*(mshift + y), mshift * i)
+        end
+        # Expansion
+        (0...r).to_a.reverse.each do |k|
+            mshift = m<<(k+2)
+            y = _div_nearest(y*(y+mshift), mshift)
+        end
+        return m+y
+    end
+    # We'll memoize the digits of log(10):
+    @log10_digits = "23025850929940456840179914546843642076011014886"
+    class <<self
+      attr_accessor :log10_digits
+    end
+    # Given an integer p >= 0, return floor(10**p)*log(10).
+    def _log10_digits(p)
+      # digits are stored as a string, for quick conversion to
+      # integer in the case that we've already computed enough
+      # digits; the stored digits should always be correct
+      # (truncated, not rounded to nearest).
+      raise ArgumentError, "p should be nonnegative" if p<0
+      if p >= AuxiliarFunctions.log10_digits.length
+          digits = nil
+          # compute p+3, p+6, p+9, ... digits; continue until at
+          # least one of the extra digits is nonzero
+          extra = 3
+          loop do
+            # compute p+extra digits, correct to within 1ulp
+            m = 10**(p+extra+2)
+            digits = _div_nearest(_ilog(10*m, m), 100).to_s
+            break if digits[-extra..-1] != '0'*extra
+            extra += 3
+          end
+          # keep all reliable digits so far; remove trailing zeros
+          # and next nonzero digit
+          AuxiliarFunctions.log10_digits = digits.sub(/0*$/,'')[0...-1]
+      end
+      return (AuxiliarFunctions.log10_digits[0...p+1]).to_i
+    end
+    # Compute an approximation to exp(c*10**e), with p decimal places of
+    # precision.
+    #
+    # Returns integers d, f such that:
+    #
+    #   10**(p-1) <= d <= 10**p, and
+    #   (d-1)*10**f < exp(c*10**e) < (d+1)*10**f
+    #
+    # In other words, d*10**f is an approximation to exp(c*10**e) with p
+    # digits of precision, and with an error in d of at most 1.  This is
+    # almost, but not quite, the same as the error being < 1ulp: when d
+    # = 10**(p-1) the error could be up to 10 ulp.
+    def dexp(c, e, p)
+      # we'll call iexp with M = 10**(p+2), giving p+3 digits of precision
+      p += 2
+      # compute log(10) with extra precision = adjusted exponent of c*10**e
+      extra = [0, e + c.to_s.length - 1].max
+      q = p + extra
+      # compute quotient c*10**e/(log(10)) = c*10**(e+q)/(log(10)*10**q),
+      # rounding down
+      shift = e+q
+      if shift >= 0
+          cshift = c*10**shift
+      else
+          cshift = c/10**-shift
+      end
+      quot, rem = cshift.divmod(_log10_digits(q))
+      # reduce remainder back to original precision
+      rem = _div_nearest(rem, 10**extra)
+      # error in result of _iexp < 120;  error after division < 0.62
+      return _div_nearest(_iexp(rem, 10**p), 1000), quot - p + 3
+    end
+  end # AuxiliarFunctions
+  # This is for using auxiliar functions from Decimal instance method
+  # without the "AuxiliarFunctions." prefix
+  include AuxiliarFunctions
+  # If we need to use them from Decimal class methods, we can avoid
+  # the use of the prefix with:
+  # extend AuxiliarFunctions
 end
 # Decimal constructor. See Decimal#new for the parameters.