Implement BigMath.log2 and BigMath.log10

Author: tompng

lib/bigdecimal/math.rb

@@ -20,6 +20,8 @@
 #   asinh(x, prec)
 #   acosh(x, prec)
 #   atanh(x, prec)
+#   log2 (x, prec)
+#   log10(x, prec)
 #   PI  (prec)
 #   E   (prec) == exp(1.0,prec)
 #
@@ -489,6 +491,56 @@ def atanh(x, prec)
     (BigMath.log(x + 1, prec) - BigMath.log(1 - x, prec)).div(2, prec)
   end
 
+  # call-seq:
+  #   BigMath.log2(decimal, numeric)    -> BigDecimal
+  #
+  # Computes the base 2 logarithm of +decimal+ to the specified number of
+  # digits of precision, +numeric+.
+  #
+  # If +decimal+ is zero or negative, raises Math::DomainError.
+  #
+  # If +decimal+ is positive infinity, returns Infinity.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.log2(BigDecimal('3'), 16).to_s
+  #   #=> "0.158496250072115618145373894394782e1"
+  #
+  def log2(x, prec)
+    raise ArgumentError, "Zero or negative precision for log2" if prec <= 0
+    return BigDecimal::NAN if x.nan?
+    return BigDecimal::INFINITY if x.infinite? == 1
+
+    prec2 = prec + BigDecimal.double_fig * 3 / 2
+    v = BigMath.log(x, prec2).div(BigMath.log(BigDecimal(2), prec2), prec2)
+    v.round(prec + BigDecimal.double_fig - (v.exponent < 0 ? v.exponent : 0), BigDecimal::ROUND_HALF_UP)
+  end
+
+  # call-seq:
+  #   BigMath.log10(decimal, numeric)    -> BigDecimal
+  #
+  # Computes the base 10 logarithm of +decimal+ to the specified number of
+  # digits of precision, +numeric+.
+  #
+  # If +decimal+ is zero or negative, raises Math::DomainError.
+  #
+  # If +decimal+ is positive infinity, returns Infinity.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.log10(BigDecimal('3'), 16).to_s
+  #   #=> "0.47712125471966243729502790325512e0"
+  #
+  def log10(x, prec)
+    raise ArgumentError, "Zero or negative precision for log10" if prec <= 0
+    return BigDecimal::NAN if x.nan?
+    return BigDecimal::INFINITY if x.infinite? == 1
+
+    prec2 = prec + BigDecimal.double_fig * 3 / 2
+    v = BigMath.log(x, prec2).div(BigMath.log(BigDecimal(10), prec2), prec2)
+    v.round(prec + BigDecimal.double_fig - (v.exponent < 0 ? v.exponent : 0), BigDecimal::ROUND_HALF_UP)
+  end
+
   # call-seq:
   #   PI(numeric) -> BigDecimal
   #

test/bigdecimal/test_bigmath.rb

@@ -292,4 +292,40 @@ def test_log
     end
     SRC
   end
+
+  def test_log2
+    assert_raise(Math::DomainError) { log2(BigDecimal("0"), N) }
+    assert_raise(Math::DomainError) { log2(BigDecimal("-1"), N) }
+    assert_raise(Math::DomainError) { log2(MINF, N) }
+    assert_equal(PINF, log2(PINF, N))
+    assert_in_epsilon(BigDecimal("1.5849625007211561814537389439478165087598144076924810604557526545410982277943585625222804749180882420909806624750592"),
+                      log2(BigDecimal("3"), 100), BigDecimal("1e-100"))
+    assert_relative_precision {|n| log2(BigDecimal("3"), n) }
+    assert_relative_precision {|n| log2(BigDecimal("3e20"), n) }
+    assert_relative_precision {|n| log2(BigDecimal("1e-20") + 1, n) }
+    [BigDecimal::ROUND_UP, BigDecimal::ROUND_DOWN].each do |round_mode|
+      BigDecimal.mode(BigDecimal::ROUND_MODE, round_mode)
+      [0, 1, 2, 11, 123].each do |n|
+        assert_equal(n, log2(BigDecimal(2**n), N))
+      end
+    end
+  end
+
+  def test_log10
+    assert_raise(Math::DomainError) { log10(BigDecimal("0"), N) }
+    assert_raise(Math::DomainError) { log10(BigDecimal("-1"), N) }
+    assert_raise(Math::DomainError) { log10(MINF, N) }
+    assert_equal(PINF, log10(PINF, N))
+    assert_in_epsilon(BigDecimal("0.4771212547196624372950279032551153092001288641906958648298656403052291527836611230429683556476163015104646927682520"),
+                      log10(BigDecimal("3"), 100), BigDecimal("1e-100"))
+    assert_relative_precision {|n| log10(BigDecimal("3"), n) }
+    assert_relative_precision {|n| log10(BigDecimal("3e20"), n) }
+    assert_relative_precision {|n| log10(BigDecimal("1e-20") + 1, n) }
+    [BigDecimal::ROUND_UP, BigDecimal::ROUND_DOWN].each do |round_mode|
+      BigDecimal.mode(BigDecimal::ROUND_MODE, round_mode)
+      [0, 1, 2, 11, 123].each do |n|
+        assert_equal(n, log10(BigDecimal(10**n), N))
+      end
+    end
+  end
 end