Implement inverse hyperbolic functions(asinh, acosh, atanh)

Author: tompng

lib/bigdecimal/math.rb

@@ -17,6 +17,9 @@
 #   sinh (x, prec)
 #   cosh (x, prec)
 #   tanh (x, prec)
+#   asinh(x, prec)
+#   acosh(x, prec)
+#   atanh(x, prec)
 #   PI  (prec)
 #   E   (prec) == exp(1.0,prec)
 #
@@ -424,6 +427,68 @@ def tanh(x, prec)
     (e - einv).div(e + einv, prec)
   end
 
+  # call-seq:
+  #   asinh(decimal, numeric) -> BigDecimal
+  #
+  # Computes the inverse hyperbolic sine of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.asinh(BigDecimal('1'), 16).to_s
+  #   #=> "0.881373587019543025232609324892919887466177636058e0"
+  #
+  def asinh(x, prec)
+    raise ArgumentError, "Zero or negative precision for tanh" if prec <= 0
+    return x if x.nan? || x.infinite?
+    return -asinh(-x, prec) if x < 0
+
+    sqrt_prec = prec + [-x.exponent, 0].max
+    BigMath.log(x + sqrt(x**2 + 1, sqrt_prec), prec)
+  end
+
+  # call-seq:
+  #   acosh(decimal, numeric) -> BigDecimal
+  #
+  # Computes the inverse hyperbolic cosine of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.acosh(BigDecimal('2'), 16).to_s
+  #   #=> "0.1316957896924816708625046347239934461496535769096e1"
+  #
+  def acosh(x, prec)
+    raise ArgumentError, "Zero or negative precision for tanh" if prec <= 0
+    raise Math::DomainError, "Out of domain argument for acosh" if x < 1
+    return BigDecimal::INFINITY if x.infinite?
+    return BigDecimal::NAN if x.nan?
+
+    BigMath.log(x + sqrt(x**2 - 1, prec), prec)
+  end
+
+  # call-seq:
+  #   atanh(decimal, numeric) -> BigDecimal
+  #
+  # Computes the inverse hyperbolic tangent of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is NaN, returns NaN.
+  #
+  #   BigMath.atanh(BigDecimal('0.5'), 16).to_s
+  #   #=> "0.549306144334054845697622618461262852323745278910789847469990412e0"
+  #
+  def atanh(x, prec)
+    raise ArgumentError, "Zero or negative precision for tanh" if prec <= 0
+    raise Math::DomainError, "Out of domain argument for atanh" if x < -1 || x > 1
+    return BigDecimal::NAN if x.nan?
+    return BigDecimal::INFINITY if x == 1
+    return -BigDecimal::INFINITY if x == -1
+
+    prec += BigDecimal.double_fig
+    (BigMath.log(x + 1, prec) - BigMath.log(1 - x, prec)).div(2, prec)
+  end
+
   # call-seq:
   #   PI(numeric) -> BigDecimal
   #

test/bigdecimal/test_bigmath.rb

@@ -224,6 +224,52 @@ def test_hyperbolic
     end
   end
 
+  def test_asinh
+    [-3, 0.5, 10].each do |x|
+      assert_in_delta(Math.asinh(x), asinh(BigDecimal(x.to_s), N))
+    end
+    assert_equal(0, asinh(BigDecimal(0), N))
+    assert_equal(PINF, asinh(PINF, N))
+    assert_equal(MINF, asinh(MINF, N))
+
+    x = BigDecimal(1) / 7
+    assert_in_delta(x, sinh(asinh(x, 100), 100), BigDecimal("1e-100"))
+
+    ["1e-30", "0.2", "10", "100"].each do |x|
+      assert_relative_precision {|n| asinh(BigDecimal(x), n)}
+    end
+  end
+
+  def test_acosh
+    [1.5, 2, 10].each do |x|
+      assert_in_delta(Math.acosh(x), acosh(BigDecimal(x.to_s), N))
+    end
+    assert_equal(0, acosh(BigDecimal(1), N))
+    assert_equal(PINF, acosh(PINF, N))
+
+    x = BigDecimal(8) / 7
+    assert_in_delta(x, cosh(acosh(x, 100), 100), BigDecimal("1e-100"))
+
+    ["1." + "0" * 30 + "1", "1.5", "2", "100"].each do |x|
+      assert_relative_precision {|n| acosh(BigDecimal(x), n)}
+    end
+  end
+
+  def test_atanh
+    [-0.5, 0.1, 0.9].each do |x|
+      assert_in_delta(Math.atanh(x), atanh(BigDecimal(x.to_s), N))
+    end
+    assert_equal(0, atanh(BigDecimal(0), N))
+    assert_equal(PINF, atanh(BigDecimal(1), N))
+
+    x = BigDecimal(1) / 7
+    assert_in_delta(x, tanh(atanh(x, 100), 100), BigDecimal("1e-100"))
+
+    ["1e-30", "0.5", "0.9" + "9" * 30].each do |x|
+      assert_relative_precision {|n| atanh(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))