Implement BigMath.atan2(y, x, prec)

Author: tompng

lib/bigdecimal/math.rb

@@ -9,11 +9,12 @@
 #   cos (x, prec)
 #   tan (x, prec)
 #   atan(x, prec)
+#   atan2(y, x, prec)
 #   PI  (prec)
 #   E   (prec) == exp(1.0,prec)
 #
 # where:
-#   x    ... BigDecimal number to be computed.
+#   x, y ... BigDecimal number to be computed.
 #   prec ... Number of digits to be obtained.
 #++
 #
@@ -197,6 +198,36 @@ def atan(x, prec)
     y
   end
 
+  # call-seq:
+  #   atan2(decimal, decimal, numeric) -> BigDecimal
+  #
+  # Computes the arctangent of y and x to the specified number of digits of
+  # precision, +numeric+.
+  #
+  #   BigMath.atan(BigDecimal('-1'), 16).to_s
+  #   #=> "-0.785398163397448309615660845819878471907514682065e0"
+  #
+  def atan2(y, x, prec)
+    if x.infinite? || y.infinite?
+      one = BigDecimal(1)
+      zero = BigDecimal(0)
+      x = x.infinite? ? (x > 0 ? one : -one) : zero
+      y = y.infinite? ? (y > 0 ? one : -one) : y.sign * zero
+    end
+
+    return x.sign >= 0 ? BigDecimal(0) : y.sign * PI(prec) if y.zero?
+
+    y = -y if neg = y < 0
+    xlarge = y.abs < x.abs
+    divprec = prec + BigDecimal.double_fig
+    if x > 0
+      v = xlarge ? atan(y.div(x, divprec), prec) : PI(prec) / 2 - atan(x.div(y, divprec), prec)
+    else
+      v = xlarge ? PI(prec) - atan(-y.div(x, divprec), prec) : PI(prec) / 2 + atan(x.div(-y, divprec), prec)
+    end
+    neg ? -v : v
+  end
+
   # call-seq:
   #   PI(numeric) -> BigDecimal
   #

test/bigdecimal/test_bigmath.rb

@@ -107,6 +107,25 @@ def test_atan
     assert_relative_precision {|n| atan(BigDecimal("1e30"), n)}
   end
 
+  def test_atan2
+    zero = BigDecimal(0)
+    one = BigDecimal(1)
+    assert_equal(0, atan2(zero, zero, N))
+    assert_equal(0, atan2(zero, one, N))
+    [MINF, -one, -zero, zero, one, PINF].repeated_permutation(2) do |y, x|
+      assert_in_delta(Math::atan2(y.to_f, x.to_f), atan2(y, x, N))
+    end
+    assert_in_delta(PI(100), atan2(zero, -one, 100), BigDecimal("1e-100"))
+    assert_in_delta(PI(100) / 2, atan2(one, zero, 100), BigDecimal("1e-100"))
+    assert_in_delta(-PI(100) / 2, atan2(-one, zero, 100), BigDecimal("1e-100"))
+    assert_in_delta(PI(100) / 3, atan2(BigDecimal(3), SQRT3, 100), BigDecimal("1e-100"))
+    assert_in_delta(PI(100) / 6, atan2(SQRT3, BigDecimal(3), 100), BigDecimal("1e-100"))
+    ['-1e20', '-2', '-1e-30', '1e-30', '2', '1e20'].repeated_permutation(2) do |y, x|
+      assert_in_delta(Math.atan2(y.to_f, x.to_f), atan2(BigDecimal(y), BigDecimal(x), N))
+      assert_relative_precision {|n| atan2(BigDecimal(y), 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))