Implement hyperbolic functions(sinh, cosh, tanh)

Author: tompng

lib/bigdecimal/math.rb

@@ -14,6 +14,9 @@
 #   acos(x, prec)
 #   atan(x, prec)
 #   atan2(y, x, prec)
+#   sinh (x, prec)
+#   cosh (x, prec)
+#   tanh (x, prec)
 #   PI  (prec)
 #   E   (prec) == exp(1.0,prec)
 #
@@ -352,6 +355,72 @@ def atan2(y, x, prec)
     neg ? -v : v
   end
 
+  # call-seq:
+  #   sinh(decimal, numeric) -> BigDecimal
+  #
+  # Computes the hyperbolic sine of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.sinh(BigDecimal('1'), 16).to_s
+  #   #=> "0.117520119364380145688238185059562e1"
+  #
+  def sinh(x, prec)
+    raise ArgumentError, "Zero or negative precision for sinh" if prec <= 0
+    return BigDecimal::NAN if x.nan?
+    return x if x.infinite?
+
+    prec += BigDecimal.double_fig
+    prec -= x.exponent if x.exponent < 0
+    e = BigMath.exp(x, prec)
+    (e - BigDecimal(1).div(e, prec)) / 2
+  end
+
+  # call-seq:
+  #   cosh(decimal, numeric) -> BigDecimal
+  #
+  # Computes the hyperbolic cosine of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.cosh(BigDecimal('1'), 16).to_s
+  #   #=> "0.154308063481524377847790562075708e1"
+  #
+  def cosh(x, prec)
+    raise ArgumentError, "Zero or negative precision for cosh" if prec <= 0
+    return BigDecimal::NAN if x.nan?
+    return BigDecimal::INFINITY if x.infinite?
+
+    prec += BigDecimal.double_fig
+    e = BigMath.exp(x, prec)
+    (e + BigDecimal(1).div(e, prec)) / 2
+  end
+
+  # call-seq:
+  #   tanh(decimal, numeric) -> BigDecimal
+  #
+  # Computes the hyperbolic tangent of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.tanh(BigDecimal('1'), 16).to_s
+  #   #=> "0.7615941559557648881194582826048e0"
+  #
+  def tanh(x, prec)
+    raise ArgumentError, "Zero or negative precision for tanh" if prec <= 0
+    return BigDecimal::NAN if x.nan?
+    return BigDecimal(x.infinite?) if x.infinite?
+
+    prec += BigDecimal.double_fig
+    prec2 = prec + [-x.exponent, 0].max
+    e = BigMath.exp(x, prec2)
+    einv = BigDecimal(1).div(e, prec2)
+    (e - einv).div(e + einv, prec)
+  end
+
   # call-seq:
   #   PI(numeric) -> BigDecimal
   #

test/bigdecimal/test_bigmath.rb

@@ -191,6 +191,33 @@ def test_atan2
     end
   end
 
+  def test_hyperbolic
+    [-1, 0, 0.5, 1, 10].each do |x|
+      assert_in_delta(Math.sinh(x), sinh(BigDecimal(x.to_s), N))
+      assert_in_delta(Math.cosh(x), cosh(BigDecimal(x.to_s), N))
+      assert_in_delta(Math.tanh(x), tanh(BigDecimal(x.to_s), N))
+    end
+    [MINF, BigDecimal(0), PINF].each do |x|
+      assert_equal(Math.sinh(x.to_f), sinh(x, N).to_f)
+      assert_equal(Math.cosh(x.to_f), cosh(x, N).to_f)
+      assert_equal(Math.tanh(x.to_f), tanh(x, N).to_f)
+    end
+
+    x = BigDecimal("0.3")
+    assert_in_delta(tanh(x, 100), sinh(x, 100) / cosh(x, 100), BigDecimal("1e-100"))
+
+    e = E(116)
+    assert_in_delta((e - 1 / e) / 2, sinh(BigDecimal(1), 100), BigDecimal("1e-100"))
+    assert_in_delta((e + 1 / e) / 2, cosh(BigDecimal(1), 100), BigDecimal("1e-100"))
+    assert_in_delta((e - 1 / e) / (e + 1 / e), tanh(BigDecimal(1), 100), BigDecimal("1e-100"))
+
+    ["1e-30", "0.2", "10", "100"].each do |x|
+      assert_relative_precision {|n| sinh(BigDecimal(x), n)}
+      assert_relative_precision {|n| cosh(BigDecimal(x), n)}
+      assert_relative_precision {|n| tanh(BigDecimal(x), n)}
+    end
+  end
+
   def test_log
     assert_equal(0, BigMath.log(BigDecimal("1.0"), 10))
     assert_in_epsilon(Math.log(10)*1000, BigMath.log(BigDecimal("1e1000"), 10))