ruby-decimal 0.1.0 → 0.2.0

data/History.txt

@@ -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

@@ -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

@@ -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.