Implement BigMath.tan

Calculate `tan(x, prec)` by `relative_precision_sin/relative_precision_cos`.

Author: tompng

lib/bigdecimal/math.rb

@@ -7,6 +7,7 @@
 #   sqrt(x, prec)
 #   sin (x, prec)
 #   cos (x, prec)
+#   tan (x, prec)
 #   atan(x, prec)
 #   PI  (prec)
 #   E   (prec) == exp(1.0,prec)
@@ -134,6 +135,43 @@ def cos(x, prec)
     y < -1 ? BigDecimal("-1") : y > 1 ? BigDecimal("1") : y
   end
 
+  # Calculate a relative precision value from a block that calculates with a fixed precision.
+  private def _ensure_relative_precision(prec)
+    fixed_point_precision = prec + BigDecimal.double_fig
+    loop do
+      value = yield fixed_point_precision
+      return value if !value.zero? && prec - value.exponent <= fixed_point_precision
+
+      if value.zero? || fixed_point_precision < -value.exponent
+        # Multiply precision by 3/2 if the calculated precision is not enough for estimating required precision
+        fixed_point_precision = fixed_point_precision * 3 / 2
+      else
+        fixed_point_precision = prec - value.exponent + BigDecimal.double_fig
+      end
+    end
+  end
+
+  # call-seq:
+  #   tan(decimal, numeric) -> BigDecimal
+  #
+  # Computes the tangent of +decimal+ to the specified number of digits of
+  # precision, +numeric+.
+  #
+  # If +decimal+ is Infinity or NaN, returns NaN.
+  #
+  #   BigMath.tan(BigMath.PI(16) / 3, 16).to_s
+  #   #=> "0.17320508075688772935274463415059e1"
+  #
+  def tan(x, prec)
+    return BigDecimal(0) if x.zero?
+
+    # BigMath calculates sin with relative precision only when x.abs is small
+    sin = x.abs < 3 ? sin(x, prec) : _ensure_relative_precision(prec) {|p| sin(x, p) }
+
+    cos = _ensure_relative_precision(prec) {|p| cos(x, p) }
+    sin.div(cos, prec + BigDecimal.double_fig)
+  end
+
   # call-seq:
   #   atan(decimal, numeric) -> BigDecimal
   #

test/bigdecimal/test_bigmath.rb

@@ -80,6 +80,28 @@ def test_cos
     assert_operator(cos(PI(30) * 2, 30), :<=, 1)
   end
 
+  def test_tan
+    assert_in_delta(0.0, tan(-PI(N), N))
+    assert_in_delta(0.0, tan(BigDecimal(0), N))
+    assert_in_delta(0.0, tan(PI(N), N))
+    assert_in_delta(1.0, tan(PI(N) / 4, N))
+    assert_in_delta(-1.0, tan(-PI(N) / 4, N))
+    assert_in_delta(-1.0, tan(PI(N) * 3 / 4, N))
+    assert_in_delta(1.0, tan(-PI(N) * 3 / 4, N))
+    assert_in_delta(0.0, tan(PI(N) * 100, N))
+    assert_in_delta(1.0, tan(PI(N) * 101 / 4, N))
+    assert_in_delta(-1.0, tan(PI(N) * 103 / 4, N))
+    assert_in_delta(BigDecimal("1").div(SQRT3, 100), tan(PI(100) / 6, 100), BigDecimal("1e-100"))
+    assert_in_delta(SQRT3, tan(PI(100) / 3, 100), BigDecimal("1e-100"))
+    assert_relative_precision {|n| tan(BigDecimal("0.5"), n) }
+    assert_relative_precision {|n| tan(BigDecimal("1e-30"), n) }
+    assert_relative_precision {|n| tan(BigDecimal("1.5"), n) }
+    assert_relative_precision {|n| tan(PI(100) / 2, n) }
+    assert_relative_precision {|n| tan(PI(200) * 101 / 2, n) }
+    assert_relative_precision {|n| tan(PI(100), n) }
+    assert_relative_precision {|n| tan(PI(200) * 100, n) }
+  end
+
   def test_atan
     assert_equal(0.0, atan(BigDecimal("0.0"), N))
     assert_in_delta(Math::PI/4, atan(BigDecimal("1.0"), N))