Rename Complex.power as Complex.pow (#24)

* Rename Complex.power as Complex.pow

See elixir-nx/nx#982.

* Deprecate Complex.power

Author: Benjamin-Philip

lib/complex.ex

@@ -986,42 +986,42 @@ defmodule Complex do
 
   ### Examples
 
-      iex> Complex.power(Complex.from_polar(2,:math.pi), Complex.new(0, 1))
+      iex> Complex.pow(Complex.from_polar(2,:math.pi), Complex.new(0, 1))
       %Complex{im: 0.027612020368333014, re: 0.03324182700885666}
 
   """
-  @spec power(t | non_finite_number | number, t | non_finite_number | number) ::
+  @spec pow(t | non_finite_number | number, t | non_finite_number | number) ::
           t | non_finite_number | number
 
-  def power(:nan, _), do: :nan
-  def power(_, :nan), do: :nan
+  def pow(:nan, _), do: :nan
+  def pow(_, :nan), do: :nan
 
-  def power(:infinity, y) when is_number(y) and y > 0, do: :infinity
-  def power(:infinity, y) when y == 0, do: 1
-  def power(:infinity, y) when is_number(y) and y < 0, do: 0
+  def pow(:infinity, y) when is_number(y) and y > 0, do: :infinity
+  def pow(:infinity, y) when y == 0, do: 1
+  def pow(:infinity, y) when is_number(y) and y < 0, do: 0
 
-  def power(:neg_infinity, y) when is_number(y) and y > 0 do
+  def pow(:neg_infinity, y) when is_number(y) and y > 0 do
     if rem(y, 2) == 0 do
       :infinity
     else
       :neg_infinity
     end
   end
 
-  def power(:neg_infinity, y) when y == 0, do: 1
-  def power(:neg_infinity, y) when is_number(y) and y < 0, do: 0
+  def pow(:neg_infinity, y) when y == 0, do: 1
+  def pow(:neg_infinity, y) when is_number(y) and y < 0, do: 0
 
-  def power(x, :infinity) when x == 0, do: 0
-  def power(%Complex{re: re, im: im}, :infinity) when re == 0 and im == 0, do: 0
-  def power(x, :neg_infinity) when x == 0, do: :infinity
-  def power(%Complex{re: re, im: im}, :neg_infinity) when re == 0 and im == 0, do: :infinity
-  def power(_, :neg_infinity), do: 0
-  def power(_, :infinity), do: :infinity
+  def pow(x, :infinity) when x == 0, do: 0
+  def pow(%Complex{re: re, im: im}, :infinity) when re == 0 and im == 0, do: 0
+  def pow(x, :neg_infinity) when x == 0, do: :infinity
+  def pow(%Complex{re: re, im: im}, :neg_infinity) when re == 0 and im == 0, do: :infinity
+  def pow(_, :neg_infinity), do: 0
+  def pow(_, :infinity), do: :infinity
 
-  def power(x, y) when is_integer(x) and is_integer(y) and y >= 0, do: Integer.pow(x, y)
-  def power(x, y) when is_number(x) and is_number(y), do: :math.pow(x, y)
+  def pow(x, y) when is_integer(x) and is_integer(y) and y >= 0, do: Integer.pow(x, y)
+  def pow(x, y) when is_number(x) and is_number(y), do: :math.pow(x, y)
 
-  def power(x, y) do
+  def pow(x, y) do
     x = as_complex(x)
     y = as_complex(y)
 
@@ -1042,12 +1042,15 @@ defmodule Complex do
       true ->
         rho = abs(x)
         theta = phase(x)
-        s = multiply(power(rho, y.re), exp(multiply(negate(y.im), theta)))
+        s = multiply(pow(rho, y.re), exp(multiply(negate(y.im), theta)))
         r = add(multiply(y.re, theta), multiply(y.im, ln(rho)))
         new(multiply(s, cos(r)), multiply(s, sin(r)))
     end
   end
 
+  @deprecated "Use pow/2 instead"
+  def power(x, y), do: pow(x, y)
+
   @doc """
   Returns a new complex that is the sine of the provided parameter.
 

lib/complex/kernel.ex

@@ -26,5 +26,5 @@ defmodule Complex.Kernel do
   def a * b, do: Complex.multiply(a, b)
   def a / b, do: Complex.divide(a, b)
 
-  def unquote(@pow_atom)(a, b), do: Complex.power(a, b)
+  def unquote(@pow_atom)(a, b), do: Complex.pow(a, b)
 end

test/complex_test.exs

@@ -373,7 +373,7 @@ defmodule ComplexTest do
     assert_close Complex.ln(a), %Complex{re: 0.8047189562170503, im: 1.1071487177940904}
     assert_close Complex.log10(a), %Complex{re: 0.3494850021680094, im: 0.480828578784234}
     assert_close Complex.log2(a), %Complex{re: 1.1609640474436813, im: 1.5972779646881088}
-    assert_close Complex.power(a, b), %Complex{re: 0.129009594074467, im: 0.03392409290517014}
+    assert_close Complex.pow(a, b), %Complex{re: 0.129009594074467, im: 0.03392409290517014}
   end
 
   test "Exp and logs (no upcasts)" do
@@ -383,7 +383,7 @@ defmodule ComplexTest do
     assert_close Complex.ln(a), :math.log(a)
     assert_close Complex.log10(a), :math.log10(a)
     assert_close Complex.log2(a), :math.log2(a)
-    assert_close Complex.power(a, b), :math.pow(a, b)
+    assert_close Complex.pow(a, b), :math.pow(a, b)
 
     assert Complex.ln(0) == :neg_infinity
     assert Complex.log10(0) == :neg_infinity
@@ -402,31 +402,31 @@ defmodule ComplexTest do
     assert Complex.log2(:nan) == :nan
   end
 
-  test "power (non-finite)" do
-    assert Complex.power(:nan, :rand.uniform()) == :nan
-    assert Complex.power(:rand.uniform(), :nan) == :nan
-
-    assert Complex.power(:infinity, 2) == :infinity
-    assert Complex.power(:infinity, 0) == 1
-    assert Complex.power(:infinity, 0.0) == 1
-    assert Complex.power(:infinity, -2) == 0
-
-    assert Complex.power(:neg_infinity, 2) == :infinity
-    assert Complex.power(:neg_infinity, 3) == :neg_infinity
-    assert Complex.power(:neg_infinity, 0) == 1
-    assert Complex.power(:neg_infinity, 0.0) == 1
-    assert Complex.power(:neg_infinity, -2) == 0
-
-    assert Complex.power(10, :infinity) == :infinity
-    assert Complex.power(:infinity, :infinity) == :infinity
-    assert Complex.power(:neg_infinity, :infinity) == :infinity
-    assert Complex.power(10, :neg_infinity) == 0
-    assert Complex.power(:infinity, :neg_infinity) == 0
-    assert Complex.power(:neg_infinity, :neg_infinity) == 0
-    assert Complex.power(0, :neg_infinity) == :infinity
-    assert Complex.power(0, :infinity) == 0
-    assert Complex.power(Complex.new(0, 0), :neg_infinity) == :infinity
-    assert Complex.power(Complex.new(0, 0), :infinity) == 0
+  test "pow (non-finite)" do
+    assert Complex.pow(:nan, :rand.uniform()) == :nan
+    assert Complex.pow(:rand.uniform(), :nan) == :nan
+
+    assert Complex.pow(:infinity, 2) == :infinity
+    assert Complex.pow(:infinity, 0) == 1
+    assert Complex.pow(:infinity, 0.0) == 1
+    assert Complex.pow(:infinity, -2) == 0
+
+    assert Complex.pow(:neg_infinity, 2) == :infinity
+    assert Complex.pow(:neg_infinity, 3) == :neg_infinity
+    assert Complex.pow(:neg_infinity, 0) == 1
+    assert Complex.pow(:neg_infinity, 0.0) == 1
+    assert Complex.pow(:neg_infinity, -2) == 0
+
+    assert Complex.pow(10, :infinity) == :infinity
+    assert Complex.pow(:infinity, :infinity) == :infinity
+    assert Complex.pow(:neg_infinity, :infinity) == :infinity
+    assert Complex.pow(10, :neg_infinity) == 0
+    assert Complex.pow(:infinity, :neg_infinity) == 0
+    assert Complex.pow(:neg_infinity, :neg_infinity) == 0
+    assert Complex.pow(0, :neg_infinity) == :infinity
+    assert Complex.pow(0, :infinity) == 0
+    assert Complex.pow(Complex.new(0, 0), :neg_infinity) == :infinity
+    assert Complex.pow(Complex.new(0, 0), :infinity) == 0
   end
 
   test "ln, log10, log2 (non-finite)" do