defmodule Complex do
  @moduledoc """
  *Complex* is a library that brings complex number support to Elixir.

  Each complex number is represented as a `%Complex{}` struct, that holds
  the real and imaginary parts. There are functions for the creation and
  manipulation of complex numbers.

  This module implements mathematical functions such as `add/2`, `subtract/2`,
  `divide/2`, and `multiply/2` that subtitute the `+`, `-`, `/` and `*` operators.

  Operator overloading is provided through `Complex.Kernel`

  ### Examples

      iex> Complex.new(3, 4)
      %Complex{im: 4.0, re: 3.0}

      iex> Complex.new(0, 1)
      %Complex{im: 1.0, re: 0.0}
  """

  @vsn 2

  import Kernel, except: [abs: 1]

  math_fun_supported? = fn fun, arity ->
    Code.ensure_loaded?(:math) and
      try do
        args =
          case {fun, arity} do
            {:atan, 1} -> [3.14]
            {:atanh, 1} -> [0.9]
            {_, 1} -> [1.0]
            {_, 2} -> [1.0, 1.0]
          end

        _ = apply(:math, fun, args)
        true
      rescue
        UndefinedFunctionError ->
          false
      end
  end

  @typedoc """
  A complex number represented as a `%Complex{}` struct.
  """
  @type t :: %Complex{re: number, im: number}
  defstruct re: 0, im: 0

  @type non_finite_number :: :infinity | :neg_infinity | :nan

  @non_finite_numbers [:infinity, :neg_infinity, :nan]

  @sin_pi :math.sin(:math.pi())
  @cos_pi_on_2 :math.cos(:math.pi() / 2)

  defguardp is_non_finite_number(x) when x in @non_finite_numbers

  defimpl Inspect do
    def inspect(val, _opts),
      do: Complex.to_string(val)
  end

  defimpl String.Chars do
    def to_string(%Complex{} = z), do: Complex.to_string(z)
  end

  @doc """
  Conveniency function that is used to implement the `String.Chars` and `Inspect` protocols.
  """
  @spec to_string(t) :: String.t()
  def to_string(%Complex{re: re, im: im}) do
    "#{to_string_real(re)}#{to_string_component(im)}i"
  end

  defp to_string_real(n) do
    case to_string_component(n) do
      "-" <> _ = s -> s
      "+" <> s -> s
    end
  end

  defp to_string_component(:infinity), do: "+Inf"
  defp to_string_component(:neg_infinity), do: "-Inf"
  defp to_string_component(:nan), do: "+NaN"

  defp to_string_component(n) when n == 0, do: "+0.0"

  defp to_string_component(n) do
    abs_s = Kernel.to_string(abs(n))

    if n >= 0 do
      "+#{abs_s}"
    else
      "-#{abs_s}"
    end
  end

  @doc """
  Returns a new complex with specified real and imaginary components. The
  imaginary part defaults to zero so a real number can be created with `new/1`.

  ### See also

  `from_polar/2`

  ### Examples

      iex> Complex.new(3, 4)
      %Complex{im: 4.0, re: 3.0}

      iex> Complex.new(2)
      %Complex{im: 0.0, re: 2.0}

      iex> Complex.new(:infinity)
      %Complex{im: 0.0, re: :infinity}

      iex> Complex.new(:nan, :neg_infinity)
      %Complex{im: :neg_infinity, re: :nan}
  """
  @spec new(number | non_finite_number, number | non_finite_number) :: t
  def new(re, im \\ 0)

  def new(re, im) do
    re_f = as_float(re)
    im_f = as_float(im)

    %Complex{re: re_f, im: im_f}
  end

  @doc """
  Parses a complex number from a string.  The values of the real and imaginary
  parts must be represented by a float, including decimal and at least one
  trailing digit (e.g. 1.2, 0.4).

  ### See also

  `new/2`

  ### Examples

      iex> Complex.parse("1.1+2.2i")
      {%Complex{im: 2.2, re: 1.1}, ""}

      iex> Complex.parse("1+2i")
      {%Complex{im: 2.0, re: 1.0}, ""}

      iex> Complex.parse("2-3i")
      {%Complex{im: -3.0, re: 2.0}, ""}

      iex> Complex.parse("-1.0-3.i")
      {%Complex{im: -3.0, re: -1.0}, ""}

      iex> Complex.parse("-1.0+3.i 2.2+3.3i")
      {%Complex{im: 3.0, re: -1.0}, " 2.2+3.3i"}

      iex> Complex.parse("1e-4-3e-3i")
      {%Complex{im: -3.0e-3, re: 1.0e-4}, ""}

      iex> Complex.parse("2i")
      {%Complex{im: 2.0, re: 0.0}, ""}

      iex> Complex.parse("-3.0i")
      {%Complex{im: -3.0, re: 0.0}, ""}

      iex> Complex.parse("NaN+Infi")
      {%Complex{im: :infinity, re: :nan}, ""}

      iex> Complex.parse("-Inf+NaNi")
      {%Complex{im: :nan, re: :neg_infinity}, ""}

      iex> Complex.parse("Inf-NaNi")
      {%Complex{im: :nan, re: :infinity}, ""}

      iex> Complex.parse("Inf")
      {%Complex{im: 0.0, re: :infinity}, ""}
  """
  @spec parse(String.t()) :: {t, String.t()} | :error
  def parse(str) do
    with {real_part, sign_multiplier, tail} <- parse_real(str),
         {imag_part, tail} <- parse_imag(tail) do
      {new(real_part, multiply(sign_multiplier, imag_part)), tail}
    else
      {:imag_non_finite, {imag_part, tail}} ->
        {new(0, imag_part), tail}

      {:real_non_finite, {real_part, tail}} ->
        {new(real_part, 0), tail}

      _ ->
        case parse_imag(str) do
          :error -> :error
          {val, tail} -> {new(0, val), tail}
        end
    end
  end

  defp parse_real("Inf+" <> tail), do: {:infinity, 1, tail}
  defp parse_real("+Inf+" <> tail), do: {:infinity, 1, tail}
  defp parse_real("Inf-" <> tail), do: {:infinity, -1, tail}
  defp parse_real("+Inf-" <> tail), do: {:infinity, -1, tail}
  defp parse_real("-Inf+" <> tail), do: {:neg_infinity, 1, tail}
  defp parse_real("-Inf-" <> tail), do: {:neg_infinity, -1, tail}
  defp parse_real("NaN+" <> tail), do: {:nan, 1, tail}
  defp parse_real("+NaN+" <> tail), do: {:nan, 1, tail}
  defp parse_real("-NaN+" <> tail), do: {:nan, 1, tail}
  defp parse_real("NaN-" <> tail), do: {:nan, -1, tail}
  defp parse_real("+NaN-" <> tail), do: {:nan, -1, tail}
  defp parse_real("-NaN-" <> tail), do: {:nan, -1, tail}

  defp parse_real("Infi" <> tail), do: {:imag_non_finite, {:infinity, tail}}
  defp parse_real("-Infi" <> tail), do: {:imag_non_finite, {:neg_infinity, tail}}
  defp parse_real("NaNi" <> tail), do: {:imag_non_finite, {:nan, tail}}

  defp parse_real("Inf" <> tail), do: {:real_non_finite, {:infinity, tail}}
  defp parse_real("-Inf" <> tail), do: {:real_non_finite, {:neg_infinity, tail}}
  defp parse_real("NaN" <> tail), do: {:real_non_finite, {:nan, tail}}

  defp parse_real(str) do
    case Float.parse(str) do
      {val, ".+" <> tail} -> {val, 1, tail}
      {val, ".-" <> tail} -> {val, -1, tail}
      {val, "+" <> tail} -> {val, 1, tail}
      {val, "-" <> tail} -> {val, -1, tail}
      _ -> :error
    end
  end

  defp parse_imag("i" <> tail), do: {1, tail}
  defp parse_imag("Infi" <> tail), do: {:infinity, tail}
  defp parse_imag("+Infi" <> tail), do: {:infinity, tail}
  defp parse_imag("-Infi" <> tail), do: {:neg_infinity, tail}
  defp parse_imag("NaNi" <> tail), do: {:nan, tail}
  defp parse_imag("+NaNi" <> tail), do: {:nan, tail}
  defp parse_imag("-NaNi" <> tail), do: {:nan, tail}

  defp parse_imag(str) do
    case Float.parse(str) do
      {val, ".i" <> tail} -> {val, tail}
      {val, "i" <> tail} -> {val, tail}
      _ -> :error
    end
  end

  @doc ~S"""
  Turns a representation in polar coordinates $r\phase\phi$, into
  the complex number $z = r.cos(\phi) + r.sin(\phi) i$

  ### See also

  `new/2`

  ### Examples

      iex> Complex.from_polar(1, :math.pi/2)
      %Complex{im: 1.0, re: 6.123233995736766e-17}

      iex> polar = Complex.to_polar(%Complex{re: 6, im: 20})
      iex> Complex.from_polar(polar)
      %Complex{im: 20.0, re: 6.0}

  """
  @spec from_polar({number | non_finite_number, number | non_finite_number}) :: t
  def from_polar({r, phi}), do: from_polar(r, phi)

  @spec from_polar(number | non_finite_number, number | non_finite_number) :: t
  def from_polar(r, phi) when phi == 0, do: new(r, 0)

  def from_polar(r, phi) do
    s = sin(phi)
    c = cos(phi)

    # treat pure imaginary and pure real cases
    cond do
      s == @sin_pi and (r == :infinity or r == :neg_infinity) ->
        new(multiply(r, c), 0)

      c == @cos_pi_on_2 and (r == :infinity or r == :neg_infinity) ->
        new(0, multiply(r, s))

      c == -@cos_pi_on_2 and (r == :infinity or r == :neg_infinity) ->
        new(0, multiply(r, s))

      :otherwise ->
        multiply(r, new(c, s))
    end
  end

  @doc """
  Returns the phase angle of the supplied complex, in radians.

  ### See also

  `new/2`, `from_polar/2`

  ### Examples

      iex> Complex.phase(Complex.from_polar(1,:math.pi/2))
      1.5707963267948966

  """
  @spec phase(t | number | non_finite_number) :: float | non_finite_number
  def phase(z)

  def phase(:nan), do: :nan
  def phase(:infinity), do: 0
  def phase(:neg_infinity), do: :math.pi()

  def phase(%Complex{re: :nan, im: im}) when is_number(im), do: :nan
  def phase(%Complex{re: :infinity, im: im}) when is_number(im), do: 0
  def phase(%Complex{re: :neg_infinity, im: im}) when is_number(im), do: :math.pi()

  def phase(%Complex{re: :infinity, im: :infinity}), do: :math.pi() / 4
  def phase(%Complex{re: :infinity, im: :neg_infinity}), do: -:math.pi() / 4
  def phase(%Complex{re: :neg_infinity, im: :infinity}), do: 3 * :math.pi() / 4
  def phase(%Complex{re: :neg_infinity, im: :neg_infinity}), do: 5 * :math.pi() / 4

  def phase(%Complex{re: :infinity}), do: :nan
  def phase(%Complex{re: :neg_infinity}), do: :nan

  def phase(%Complex{im: :infinity}), do: :math.pi() / 2
  def phase(%Complex{im: :neg_infinity}), do: -:math.pi() / 2
  def phase(%Complex{im: :nan}), do: :nan

  def phase(n) when n < 0, do: :math.pi()
  def phase(n) when is_number(n), do: 0

  def phase(z = %Complex{}) do
    atan2(z.im, z.re)
  end

  @doc """
  Returns the polar coordinates of the supplied complex.  That is, the
  returned tuple {r,phi} is the magnitude and phase (in radians) of z.

  ### See also

  `from_polar/2`

  ### Examples

      iex> Complex.to_polar(Complex.from_polar(1,:math.pi/2))
      {1.0, 1.5707963267948966}

  """
  @spec to_polar(t | number | non_finite_number) ::
          {float | non_finite_number, float | non_finite_number}
  def to_polar(t)

  def to_polar(z = %Complex{}) do
    {abs(z), phase(z)}
  end

  def to_polar(n) when n < 0, do: {n, :math.pi()}
  def to_polar(n) when is_number(n), do: {n, 0}

  def to_polar(:infinity), do: {:infinity, 0}
  def to_polar(:neg_infinity), do: {:infinity, :math.pi()}
  def to_polar(:nan), do: {:nan, :nan}

  @doc """
  Returns a new complex that is the sum of the provided complex numbers.  Also
  supports a mix of complex and number.

  ### See also

  `div/2`, `multiply/2`, `subtract/2`

  ### Examples

      iex> Complex.add(Complex.from_polar(1, :math.pi/2), Complex.from_polar(1, :math.pi/2))
      %Complex{im: 2.0, re: 1.2246467991473532e-16}

      iex> Complex.add(Complex.new(4, 4), 1)
      %Complex{im: 4.0, re: 5.0}

      iex> Complex.add(2, Complex.new(4, 3))
      %Complex{im: 3.0, re: 6.0}

      iex> Complex.add(2, 3)
      5

      iex> Complex.add(2.0, 2)
      4.0

  """
  @spec add(t | number | non_finite_number, t | number | non_finite_number) ::
          t | number | non_finite_number

  def add(z, %Complex{re: re, im: im}) when z in [:infinity, :neg_infinity, :nan],
    do: Complex.new(add(z, re), im)

  def add(%Complex{re: re, im: im}, z) when z in [:infinity, :neg_infinity, :nan],
    do: Complex.new(add(z, re), im)

  def add(:nan, _), do: :nan
  def add(_, :nan), do: :nan

  def add(:infinity, :neg_infinity), do: :nan
  def add(:neg_infinity, :infinity), do: :nan
  def add(:infinity, _), do: :infinity
  def add(_, :infinity), do: :infinity

  def add(:neg_infinity, _), do: :neg_infinity
  def add(_, :neg_infinity), do: :neg_infinity

  def add(left, right) when is_number(left) and is_number(right), do: left + right

  def add(left, right) do
    %Complex{re: re_left, im: im_left} = as_complex(left)
    %Complex{re: re_right, im: im_right} = as_complex(right)
    new(add(re_left, re_right), add(im_left, im_right))
  end

  @doc """
  Returns a new complex that is the difference of the provided complex numbers.
  Also supports a mix of complex and number.

  ### See also

  `add/2`, `div/2`, `multiply/2`

  ### Examples

      iex> Complex.subtract(Complex.new(1,2), Complex.new(3,4))
      %Complex{im: -2.0, re: -2.0}

      iex> Complex.subtract(Complex.new(1, 2), 3)
      %Complex{im: 2.0, re: -2.0}

      iex> Complex.subtract(10, Complex.new(1, 2))
      %Complex{im: -2.0, re: 9.0}

  """
  @spec subtract(t | number | non_finite_number, t | number | non_finite_number) ::
          t | number | non_finite_number

  def subtract(z, %Complex{re: re, im: im}) when z in [:infinity, :neg_infinity, :nan],
    do: Complex.new(subtract(z, re), negate(im))

  def subtract(%Complex{re: re, im: im}, z) when z in [:infinity, :neg_infinity, :nan],
    do: Complex.new(subtract(re, z), im)

  def subtract(:nan, _), do: :nan
  def subtract(_, :nan), do: :nan
  def subtract(:infinity, :infinity), do: :nan
  def subtract(:neg_infinity, :neg_infinity), do: :nan

  def subtract(:infinity, _), do: :infinity
  def subtract(_, :infinity), do: :neg_infinity
  def subtract(:neg_infinity, _), do: :neg_infinity
  def subtract(_, :neg_infinity), do: :infinity

  def subtract(left, right) when is_number(left) and is_number(right), do: left - right

  def subtract(left, right) do
    %Complex{re: re_left, im: im_left} = as_complex(left)
    %Complex{re: re_right, im: im_right} = as_complex(right)
    new(subtract(re_left, re_right), subtract(im_left, im_right))
  end

  @doc """
  Returns a new complex that is the product of the provided complex numbers.
  Also supports a mix of complex and number.

  ### See also

  `add/2`, `div/2`, `subtract/2`

  ### Examples

      iex> Complex.multiply(Complex.new(1,2), Complex.new(3,4))
      %Complex{im: 10.0, re: -5.0}

      iex> Complex.multiply(Complex.new(0, 1), Complex.new(0, 1))
      %Complex{im: 0.0, re: -1.0}

      iex> Complex.multiply(Complex.new(1, 2), 3)
      %Complex{im: 6.0, re: 3.0}

      iex> Complex.multiply(3, Complex.new(1, 2))
      %Complex{im: 6.0, re: 3.0}

      iex> Complex.multiply(-2, Complex.new(:infinity, :neg_infinity))
      %Complex{im: :nan, re: :nan}

  """
  @spec multiply(t | number | non_finite_number, t | number | non_finite_number) ::
          t | number | non_finite_number

  def multiply(x, c = %Complex{re: _re, im: _im}) when is_non_finite_number(x) or is_number(x) do
    z = new(x, 0)
    multiply(z, c)
  end

  def multiply(c = %Complex{re: _re, im: _im}, x) when is_non_finite_number(x) or is_number(x) do
    z = new(x, 0)
    multiply(c, z)
  end

  def multiply(:infinity, right) when is_number(right) and right > 0, do: :infinity
  def multiply(:infinity, right) when right == 0, do: :nan
  def multiply(:infinity, right) when is_number(right) and right < 0, do: :neg_infinity
  def multiply(left, :infinity) when is_number(left) and left > 0, do: :infinity
  def multiply(left, :infinity) when left == 0, do: :nan
  def multiply(left, :infinity) when is_number(left) and left < 0, do: :neg_infinity

  def multiply(:neg_infinity, right) when is_number(right) and right > 0, do: :neg_infinity
  def multiply(:neg_infinity, right) when right == 0, do: :nan
  def multiply(:neg_infinity, right) when is_number(right) and right < 0, do: :infinity
  def multiply(left, :neg_infinity) when is_number(left) and left > 0, do: :neg_infinity
  def multiply(left, :neg_infinity) when left == 0, do: :nan
  def multiply(left, :neg_infinity) when is_number(left) and left < 0, do: :infinity

  def multiply(:nan, _), do: :nan
  def multiply(_, :nan), do: :nan

  def multiply(:neg_infinity, :neg_infinity), do: :infinity
  def multiply(:neg_infinity, :infinity), do: :neg_infinity
  def multiply(:infinity, :neg_infinity), do: :neg_infinity
  def multiply(:infinity, :infinity), do: :infinity

  def multiply(left, right) when is_number(left) and is_number(right), do: left * right

  def multiply(left, right) do
    %Complex{re: r1, im: i1} = as_complex(left)
    %Complex{re: r2, im: i2} = as_complex(right)
    new(subtract(multiply(r1, r2), multiply(i1, i2)), add(multiply(i1, r2), multiply(r1, i2)))
  end

  @doc """
  Returns a new complex that is the square of the provided complex number.

  ### See also

  `multiply/2`

  ### Examples

      iex> Complex.square(Complex.new(2.0, 0.0))
      %Complex{im: 0.0, re: 4.0}

      iex> Complex.square(Complex.new(0, 1))
      %Complex{im: 0.0, re: -1.0}

  """
  @spec square(t | number | non_finite_number) :: t | number | non_finite_number
  def square(z), do: multiply(z, z)

  @doc """
  Returns a new complex that is the ratio (division) of the provided complex
  numbers.

  ### See also

  `add/2`, `multiply/2`, `subtract/2`

  ### Examples

      iex> Complex.divide(Complex.from_polar(1, :math.pi/2), Complex.from_polar(1, :math.pi/2))
      %Complex{im: 0.0, re: 1.0}

  """
  @spec divide(t | number | non_finite_number, t | number | non_finite_number) ::
          t | number | non_finite_number

  def divide(x, y) when is_non_finite_number(x) and is_non_finite_number(y), do: :nan
  def divide(x, y) when is_non_finite_number(x) and is_number(y) and y >= 0, do: x
  def divide(x, y) when x == 0 and y == 0, do: :nan
  def divide(:nan, a) when is_number(a), do: :nan
  def divide(a, :nan) when is_number(a), do: :nan
  def divide(:infinity, y) when is_number(y) and y < 0, do: :neg_infinity
  def divide(:neg_infinity, y) when is_number(y) and y < 0, do: :infinity
  def divide(a, :infinity) when is_number(a), do: 0
  def divide(a, :neg_infinity) when is_number(a), do: 0

  def divide(x, y) when is_number(x) and is_number(y), do: x / y

  def divide(n, b) when is_number(n) and b in [:infinity, :neg_infinity] do
    0
  end

  def divide(n, %Complex{re: re_r, im: im_r})
      when is_number(n) and re_r in [:infinity, :neg_infinity] and im_r == 0 do
    new(0, 0)
  end

  def divide(%Complex{re: re, im: im}, b)
      when is_number(re) and is_number(im) and b in [:infinity, :neg_infinity] do
    new(0, 0)
  end

  def divide(%Complex{re: re, im: im}, %Complex{re: re_r, im: im_r})
      when is_number(re) and is_number(im) and re_r in [:infinity, :neg_infinity] and im_r == 0 do
    new(0, 0)
  end

  def divide(x, y) do
    %Complex{re: r1, im: i1} = as_complex(x)
    %Complex{re: r2, im: i2} = as_complex(y)

    num_re = add(multiply(r1, r2), multiply(i1, i2))
    num_im = subtract(multiply(i1, r2), multiply(r1, i2))
    den = add(square(r2), square(i2))

    new(divide(num_re, den), divide(num_im, den))
  end

  @doc """
  Returns the magnitude (length) of the provided complex number.

  ### See also

  `new/2`, `phase/1`

  ### Examples

      iex> Complex.abs(Complex.from_polar(1, :math.pi/2))
      1.0

  """
  @spec abs(t | number | non_finite_number) :: number | non_finite_number
  def abs(z)

  def abs(:nan), do: :nan
  def abs(:infinity), do: :infinity
  def abs(:neg_infinity), do: :infinity

  def abs(n) when is_number(n), do: Kernel.abs(n)

  def abs(%Complex{re: :nan, im: :nan}), do: :nan

  def abs(%Complex{re: r, im: i}) when is_non_finite_number(r) or is_non_finite_number(i),
    do: :infinity

  def abs(%Complex{re: r, im: i}) do
    # optimized by checking special cases (sqrt is expensive)
    x = Kernel.abs(r)
    y = Kernel.abs(i)

    cond do
      x == 0.0 -> y
      y == 0.0 -> x
      x > y -> x * :math.sqrt(1.0 + y / x * (y / x))
      true -> y * :math.sqrt(1.0 + x / y * (x / y))
    end
  end

  @doc """
  Returns the square of the magnitude of the provided complex number.

  The square of the magnitude is faster to compute---no square roots!

  ### See also

  `new/2`, `abs/1`

  ### Examples

      iex> Complex.abs_squared(Complex.from_polar(1, :math.pi/2))
      1.0

      iex> Complex.abs_squared(Complex.from_polar(2, :math.pi/2))
      4.0

  """
  @spec abs_squared(t | number | non_finite_number) :: number
  def abs_squared(z)

  def abs_squared(:nan), do: :nan
  def abs_squared(:infinity), do: :infinity
  def abs_squared(:neg_infinity), do: :infinity

  def abs_squared(n) when is_number(n), do: n * n

  def abs_squared(%Complex{re: :nan, im: :nan}), do: :nan

  def abs_squared(%Complex{re: r, im: i}) when is_non_finite_number(r) or is_non_finite_number(i),
    do: :infinity

  def abs_squared(%Complex{re: r, im: i}) do
    r * r + i * i
  end

  @doc """
  Returns the real part of the provided complex number.

  ### See also

  `imag/1`

  ### Examples

      iex> Complex.real(Complex.new(1, 2))
      1.0

      iex> Complex.real(1)
      1
  """
  @spec real(t | number | non_finite_number) :: number | non_finite_number
  def real(z)

  def real(n) when is_number(n) or is_non_finite_number(n), do: n

  def real(%Complex{re: r, im: _i}), do: r

  @doc """
  Returns the imaginary part of the provided complex number.
  If a real number is provided, 0 is returned.

  ### See also

  `real/1`

  ### Examples

      iex> Complex.imag(Complex.new(1, 2))
      2.0

      iex> Complex.imag(1)
      0
  """

  @spec imag(t | number | non_finite_number) :: number | non_finite_number
  def imag(z)

  def imag(n) when is_number(n), do: n * 0
  def imag(n) when is_non_finite_number(n), do: 0

  def imag(%Complex{re: _r, im: i}), do: i

  @doc """
  Returns a new complex that is the complex conjugate of the provided complex
  number.

  If $z = a + bi$, $conjugate(z) = z^* = a - bi$

  ### See also

  `abs/2`, `phase/1`

  ### Examples

      iex> Complex.conjugate(Complex.new(1,2))
      %Complex{im: -2.0, re: 1.0}

  """
  @spec conjugate(t | number | non_finite_number) :: t | number | non_finite_number
  def conjugate(z)

  def conjugate(n) when is_number(n) or is_non_finite_number(n), do: n

  def conjugate(%Complex{re: r, im: :neg_infinity}), do: new(r, :infinity)
  def conjugate(%Complex{re: r, im: :infinity}), do: new(r, :neg_infinity)
  def conjugate(%Complex{re: r, im: :nan}), do: new(r, :nan)

  def conjugate(%Complex{re: r, im: i}) do
    new(r, -i)
  end

  @doc """
  Returns a new complex that is the complex square root of the provided
  complex number.

  ### See also

  `abs/1`, `cbrt/1`, `phase/1`

  ### Examples

      iex> Complex.sqrt(Complex.from_polar(2,:math.pi))
      %Complex{im: 1.4142135623730951, re: 8.659560562354933e-17}

  """
  @spec sqrt(t | number | non_finite_number) :: t | number | non_finite_number
  def sqrt(z)
  def sqrt(:infinity), do: :infinity
  def sqrt(:neg_infinity), do: :nan
  def sqrt(:nan), do: :nan
  def sqrt(n) when is_number(n), do: :math.sqrt(n)

  def sqrt(%Complex{re: :nan}), do: Complex.new(:nan, :nan)
  def sqrt(%Complex{im: :nan}), do: Complex.new(:nan, :nan)
  def sqrt(%Complex{im: :infinity}), do: Complex.new(:infinity, :infinity)
  def sqrt(%Complex{im: :neg_infinity}), do: Complex.new(:infinity, :neg_infinity)
  def sqrt(%Complex{re: :infinity}), do: Complex.new(:infinity)
  def sqrt(%Complex{re: :neg_infinity}), do: Complex.new(0, :infinity)

  def sqrt(%Complex{re: r, im: i}) do
    if r == 0.0 and i == 0.0 do
      new(r, i)
    else
      x = Kernel.abs(r)
      y = Kernel.abs(i)

      w =
        if x >= y do
          :math.sqrt(x) * :math.sqrt(0.5 * (1.0 + :math.sqrt(1.0 + y / x * (y / x))))
        else
          :math.sqrt(y) * :math.sqrt(0.5 * (x / y + :math.sqrt(1.0 + x / y * (x / y))))
        end

      if r >= 0.0 do
        new(w, i / (2 * w))
      else
        i2 =
          if i >= 0.0 do
            w
          else
            -w
          end

        new(i / (2 * i2), i2)
      end
    end
  end

  @doc """
  Returns a new number that is the complex cube root of the provided
  number.

  Returns the principal branch of the cube root for complex inputs.

  ### See also

  `abs/1`, `phase/1`, `sqrt/1`

  ### Examples

      iex> Complex.cbrt(-8)
      -2.0

  When a negative number is given as a complex input,
  the output now changes. Instead of still giving a
  negative number, we now get a number with phase
  $\\frac{\\pi}{3}$

      iex> z = Complex.cbrt(Complex.new(-8, 0))
      %Complex{re: 1.0000000000000002, im: 1.7320508075688772}
      iex> Complex.abs(z)
      2.0
      iex> Complex.phase(z)
      1.0471975511965976
      iex> :math.pi() / 3
      1.0471975511965976

  """
  @spec cbrt(t | number | non_finite_number) :: t | float() | non_finite_number
  def cbrt(z)
  def cbrt(:infinity), do: :infinity
  def cbrt(:neg_infinity), do: :neg_infinity
  def cbrt(:nan), do: :nan
  def cbrt(n) when is_number(n) and n >= 0, do: :math.pow(n, 1 / 3)
  def cbrt(n) when is_number(n), do: -1 * cbrt(abs(n))

  def cbrt(z) do
    r = abs(z)
    theta = phase(z)

    from_polar(cbrt(r), theta / 3)
  end

  @doc """
  Returns a new complex that is the complex exponential of the provided
  complex number: $exp(z) = e^z$.

  ### See also

  `log/1`

  ### Examples

      iex> Complex.exp(Complex.from_polar(2,:math.pi))
      %Complex{im: 3.3147584285483636e-17, re: 0.1353352832366127}

  """
  @spec exp(t | number | non_finite_number) :: t | number | non_finite_number
  def exp(z)

  def exp(:infinity), do: :infinity
  def exp(:neg_infinity), do: 0
  def exp(:nan), do: :nan
  def exp(n) when is_number(n), do: :math.exp(n)

  def exp(%Complex{re: :neg_infinity, im: _}), do: new(0, 0)
  def exp(%Complex{re: :infinity, im: :nan}), do: new(:infinity, :nan)

  def exp(%Complex{re: :infinity, im: im}) when is_number(im) do
    re =
      case :math.cos(im) do
        x when x > 0 -> :infinity
        x when x < 0 -> :neg_infinity
        _ -> :nan
      end

    im =
      case :math.sin(im) do
        x when x > 0 -> :infinity
        x when x < 0 -> :neg_infinity
        _ -> :nan
      end

    new(re, im)
  end

  def exp(%Complex{re: _, im: :neg_infinity}), do: new(:nan, :nan)
  def exp(%Complex{re: _, im: :infinity}), do: new(:nan, :nan)
  def exp(%Complex{re: :nan, im: _}), do: new(:nan, :nan)
  def exp(%Complex{re: _, im: :nan}), do: new(:nan, :nan)

  def exp(z = %Complex{}) do
    rho = :math.exp(z.re)
    theta = z.im
    new(rho * :math.cos(theta), rho * :math.sin(theta))
  end

  @doc """
  Returns a new complex that is the complex natural log of the provided
  complex number, $log(z) = log_e(z)$.

  ### See also

  `exp/1`

  ### Examples

      iex> Complex.log(Complex.from_polar(2,:math.pi))
      %Complex{im: 3.141592653589793, re: 0.6931471805599453}

  """
  @spec log(t | number | non_finite_number) :: t | number | non_finite_number
  def log(z)
  def log(:infinity), do: :infinity
  def log(:neg_infinity), do: new(:infinity, :math.pi())
  def log(:nan), do: :nan
  def log(n) when is_number(n) and n == 0, do: :neg_infinity
  def log(n) when is_number(n) and n < 0, do: :nan
  def log(n) when is_number(n), do: :math.log(n)

  def log(z = %Complex{}) do
    new(log(abs(z)), atan2(z.im, z.re))
  end

  @deprecated "Use log/1 instead"
  def ln(x), do: log(x)

  @doc """
  Returns a new complex that is the complex log base 10 of the provided
  complex number.

  ### See also

  `log/1`

  ### Examples

      iex> Complex.log10(Complex.from_polar(2,:math.pi))
      %Complex{im: 1.3643763538418412, re: 0.30102999566398114}

  """
  @spec log10(t | number | non_finite_number) :: t | number | non_finite_number
  def log10(z)

  def log10(:infinity), do: :infinity

  def log10(:neg_infinity) do
    new(:infinity, :math.pi() / :math.log(10))
  end

  def log10(:nan), do: :nan
  def log10(n) when is_number(n) and n == 0, do: :neg_infinity
  def log10(n) when is_number(n) and n < 0, do: :nan

  def log10(n) when is_number(n), do: :math.log10(n)

  def log10(%Complex{re: :infinity, im: im}) when is_number(im) do
    new(:infinity, 0)
  end

  def log10(%Complex{re: :neg_infinity, im: im}) when is_number(im) do
    new(:infinity, :math.pi() / :math.log(10))
  end

  def log10(%Complex{im: :infinity, re: re}) when is_number(re) do
    new(:infinity, :math.pi() / (2 * :math.log(10)))
  end

  def log10(%Complex{im: :neg_infinity, re: re}) when is_number(re) do
    new(:infinity, -:math.pi() / (2 * :math.log(10)))
  end

  def log10(%Complex{re: :infinity, im: :infinity}) do
    new(:infinity, :math.pi() / (4 * :math.log(10)))
  end

  def log10(%Complex{re: :infinity, im: :neg_infinity}) do
    new(:infinity, -:math.pi() / (4 * :math.log(10)))
  end

  def log10(%Complex{re: :neg_infinity, im: :neg_infinity}) do
    new(:infinity, -3 * :math.pi() / (4 * :math.log(10)))
  end

  def log10(%Complex{re: :neg_infinity, im: :infinity}) do
    new(:infinity, 3 * :math.pi() / (4 * :math.log(10)))
  end

  def log10(z = %Complex{}) do
    divide(log(z), new(:math.log(10.0), 0.0))
  end

  @doc """
  Returns a new complex that is the complex log base 2 of the provided
  complex number.

  ### See also

  `log/1`, `log10/1`

  ### Examples

      iex> Complex.log2(Complex.from_polar(2,:math.pi))
      %Complex{im: 4.532360141827194, re: 1.0}

  """
  @spec log2(t | number | non_finite_number) :: t | number | non_finite_number
  def log2(z)

  def log2(:infinity), do: :infinity
  def log2(:neg_infinity), do: divide(log(:neg_infinity), :math.log(2))
  def log2(:nan), do: :nan
  def log2(n) when is_number(n) and n == 0, do: :neg_infinity
  def log2(n) when is_number(n) and n < 0, do: :nan

  def log2(n) when is_number(n), do: :math.log2(n)

  def log2(%Complex{re: :infinity, im: im}) when is_number(im) do
    new(:infinity, 0)
  end

  def log2(%Complex{re: :neg_infinity, im: im}) when is_number(im) do
    new(:infinity, :math.pi() / :math.log(2))
  end

  def log2(%Complex{im: :infinity, re: re}) when is_number(re) do
    new(:infinity, :math.pi() / (2 * :math.log(2)))
  end

  def log2(%Complex{im: :neg_infinity, re: re}) when is_number(re) do
    new(:infinity, -:math.pi() / (2 * :math.log(2)))
  end

  def log2(%Complex{re: :infinity, im: :infinity}) do
    new(:infinity, :math.pi() / (4 * :math.log(2)))
  end

  def log2(%Complex{re: :infinity, im: :neg_infinity}) do
    new(:infinity, -:math.pi() / (4 * :math.log(2)))
  end

  def log2(%Complex{re: :neg_infinity, im: :neg_infinity}) do
    new(:infinity, -3 * :math.pi() / (4 * :math.log(2)))
  end

  def log2(%Complex{re: :neg_infinity, im: :infinity}) do
    new(:infinity, 3 * :math.pi() / (4 * :math.log(2)))
  end

  def log2(z = %Complex{}) do
    divide(log(z), new(:math.log(2.0), 0.0))
  end

  @doc """
  Returns a new complex that is the provided parameter a raised to the
  complex power b.

  ### See also

  `log/1`, `log10/1`

  ### Examples

      iex> Complex.pow(Complex.from_polar(2,:math.pi), Complex.new(0, 1))
      %Complex{im: 0.027612020368333014, re: 0.03324182700885666}

  """
  @spec pow(t | non_finite_number | number, t | non_finite_number | number) ::
          t | non_finite_number | number

  def pow(%Complex{re: re, im: im}, :infinity) when re == 0 and im == 0, do: new(0, 0)

  def pow(%Complex{re: re, im: im}, %Complex{re: :infinity, im: im_r})
      when re == 0 and im == 0 and im_r == 0,
      do: new(0, 0)

  def pow(z, %Complex{}) when is_non_finite_number(z), do: new(:nan, :nan)
  def pow(%Complex{}, z) when is_non_finite_number(z), do: new(:nan, :nan)
  def pow(%Complex{re: z}, _) when is_non_finite_number(z), do: new(:nan, :nan)
  def pow(%Complex{im: z}, _) when is_non_finite_number(z), do: new(:nan, :nan)
  def pow(_, %Complex{re: z}) when is_non_finite_number(z), do: new(:nan, :nan)
  def pow(_, %Complex{im: z}) when is_non_finite_number(z), do: new(:nan, :nan)
  def pow(:nan, _), do: :nan
  def pow(_, :nan), do: :nan

  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 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 pow(:neg_infinity, y) when y == 0, do: 1
  def pow(:neg_infinity, y) when is_number(y) and y < 0, do: 0

  def pow(x, :infinity) when x == 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: new(:infinity, 0)
  def pow(_, :neg_infinity), do: 0
  def pow(_, :infinity), do: :infinity

  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 pow(x, y) do
    x = as_complex(x)
    y = as_complex(y)

    cond do
      x.re == 0.0 and x.im == 0.0 ->
        if y.re == 0.0 and y.im == 0.0 do
          new(1.0, 0.0)
        else
          new(0.0, 0.0)
        end

      y.re == 1.0 and y.im == 0.0 ->
        x

      y.re == -1.0 and y.im == 0.0 ->
        divide(new(1.0, 0.0), x)

      true ->
        rho = abs(x)
        theta = phase(x)
        s = multiply(pow(rho, y.re), exp(multiply(negate(y.im), theta)))
        r = add(multiply(y.re, theta), multiply(y.im, log(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.

  ### See also

  `cos/1`, `tan/1`

  ### Examples

      iex> Complex.sin(Complex.from_polar(2,:math.pi))
      %Complex{im: -1.0192657827055095e-16, re: -0.9092974268256817}

  """
  @spec sin(t | number | non_finite_number) :: t | number | non_finite_number
  def sin(z)

  def sin(n) when is_number(n), do: :math.sin(n)
  def sin(n) when is_non_finite_number(n), do: :nan

  def sin(%Complex{re: re, im: im}) when is_non_finite_number(re) and is_number(im),
    do: Complex.new(:nan, :nan)

  def sin(%Complex{im: :nan}), do: Complex.new(:nan, :nan)
  def sin(%Complex{re: :nan}), do: Complex.new(:nan, :nan)

  def sin(%Complex{re: re, im: im}) when is_number(re) and is_non_finite_number(im) do
    Complex.new(multiply(re, im), im)
  end

  def sin(%Complex{re: re, im: im}) when is_non_finite_number(re) and is_non_finite_number(im) do
    Complex.new(:nan, :nan)
  end

  def sin(z = %Complex{}) do
    new(
      :math.sin(z.re) * :math.cosh(z.im),
      :math.cos(z.re) * :math.sinh(z.im)
    )
  end

  @doc """
  Returns a new complex that is the "negation" of the provided parameter.
  That is, the real and imaginary parts are negated.

  ### See also

  `new/2`

  ### Examples

      iex> Complex.negate(Complex.new(3,5))
      %Complex{im: -5.0, re: -3.0}

  """
  @spec negate(t | number | non_finite_number) :: t | number | non_finite_number
  def negate(z)

  def negate(:nan), do: :nan
  def negate(:neg_infinity), do: :infinity
  def negate(:infinity), do: :neg_infinity
  def negate(n) when is_number(n), do: -n

  def negate(z = %Complex{}) do
    new(negate(z.re), negate(z.im))
  end

  # TO-DO: support non_finite_numbers in inverse trig functions

  @doc """
  Returns a new complex that is the inverse sine (i.e., arcsine) of the
  provided parameter.

  ### See also

  `sin/1`

  ### Examples

      iex> Complex.asin(Complex.from_polar(2,:math.pi))
      %Complex{im: 1.3169578969248164, re: -1.5707963267948966}

  """
  @spec asin(t | number | non_finite_number) :: t | number | non_finite_number
  def asin(z)

  def asin(n) when is_number(n), do: :math.asin(n)

  def asin(n) when is_non_finite_number(n), do: :nan

  def asin(%Complex{re: re, im: im}) when is_non_finite_number(re) or is_non_finite_number(im),
    do: new(:nan, :nan)

  def asin(z = %Complex{}) do
    i = new(0.0, 1.0)
    # result = -i*log(i*z + sqrt(1.0-z*z))
    # result = -i*log(t1 + sqrt(t2))
    t1 = multiply(i, z)
    t2 = subtract(new(1.0, 0.0), multiply(z, z))
    multiply(negate(i), log(add(t1, sqrt(t2))))
  end

  @doc """
  Returns a new complex that is the cosine of the provided parameter.

  ### See also

  `sin/1`, `tan/1`

  ### Examples

      iex> Complex.cos(Complex.from_polar(2,:math.pi))
      %Complex{im: 2.2271363664699914e-16, re: -0.4161468365471424}

  """
  @spec cos(t | number | non_finite_number) :: t | number | non_finite_number
  def cos(z)

  def cos(n) when is_number(n), do: :math.cos(n)

  def cos(n) when is_non_finite_number(n), do: :nan

  def cos(%Complex{re: re, im: im}) when is_non_finite_number(re) and is_number(im),
    do: Complex.new(:nan, :nan)

  def cos(%Complex{im: :nan}), do: Complex.new(:nan, :nan)
  def cos(%Complex{re: :nan}), do: Complex.new(:nan, :nan)

  def cos(%Complex{re: re, im: im}) when is_number(re) and is_non_finite_number(im) do
    Complex.new(:infinity, -1 |> multiply(im) |> multiply(re))
  end

  def cos(%Complex{re: re, im: im}) when is_non_finite_number(re) and is_non_finite_number(im) do
    Complex.new(:nan, :nan)
  end

  def cos(z = %Complex{}) do
    new(
      :math.cos(z.re) * :math.cosh(z.im),
      -:math.sin(z.re) * :math.sinh(z.im)
    )
  end

  @doc """
  Returns a new complex that is the inverse cosine (i.e., arccosine) of the
  provided parameter.

  ### See also

  `cos/1`

  ### Examples

      iex> Complex.acos(Complex.from_polar(2,:math.pi))
      %Complex{im: 1.3169578969248164, re: -3.141592653589793}

  """
  @spec acos(t | number | non_finite_number) :: t | number | non_finite_number
  def acos(z)

  def acos(n) when is_number(n), do: :math.acos(n)

  def acos(n) when is_non_finite_number(n), do: :nan

  def acos(%Complex{re: re, im: im}) when is_non_finite_number(re) or is_non_finite_number(im),
    do: new(:nan, :nan)

  def acos(z = %Complex{}) do
    i = new(0.0, 1.0)
    one = new(1.0, 0.0)
    # result = -i*log(z + sqrt(z*z-1.0))
    # result = -i*log(z + sqrt(t1))
    t1 = subtract(multiply(z, z), one)
    multiply(negate(i), log(add(z, sqrt(t1))))
  end

  @doc """
  Returns a new complex that is the tangent of the provided parameter.

  ### See also

  `sin/1`, `cos/1`

  ### Examples

      iex> Complex.tan(Complex.from_polar(2,:math.pi))
      %Complex{im: 1.4143199004457915e-15, re: 2.185039863261519}

  """
  @spec tan(t | number | non_finite_number) :: t | number | non_finite_number
  def tan(z)

  def tan(n) when is_number(n), do: :math.tan(n)

  def tan(z) do
    divide(sin(z), cos(z))
  end

  @doc """
  Returns a new complex that is the inverse tangent (i.e., arctangent) of the
  provided parameter.

  ### See also

  `tan/1`, `atan2/2`

  ### Examples

      iex> Complex.atan(Complex.from_polar(2,:math.pi))
      %Complex{im: 0.0, re: -1.1071487177940904}

      iex> Complex.tan(Complex.atan(Complex.new(2,3)))
      %Complex{im: 2.9999999999999996, re: 2.0}

  """
  @spec atan(t | number | non_finite_number) :: t | number | non_finite_number
  def atan(z)

  def atan(:infinity), do: :math.pi() / 2
  def atan(:neg_infinity), do: -:math.pi() / 2
  def atan(:nan), do: :nan

  def atan(n) when is_number(n), do: :math.atan(n)

  def atan(z = %Complex{}) do
    i = new(0.0, 1.0)
    # result = 0.5*i*(log(1-i*z)-log(1+i*z))
    t1 = multiply(new(0.5, 0.0), i)
    t2 = subtract(new(1.0, 0.0), multiply(i, z))
    t3 = add(new(1.0, 0.0), multiply(i, z))
    multiply(t1, subtract(log(t2), log(t3)))
  end

  @doc """
  $atan2(b, a)$ returns the phase of the complex number $a + bi$.

  ### See also

  `tan/1`, `atan/1`

  ### Examples

      iex> phase = Complex.atan2(2, 2)
      iex> phase == :math.pi() / 4
      true

      iex> phase = Complex.atan2(2, Complex.new(0))
      iex> phase == Complex.new(:math.pi() / 2, 0)
      true

  """
  def atan2(b, a) when is_number(a) and is_number(b), do: :math.atan2(b, a)
  def atan2(:infinity, :infinity), do: :math.pi() / 4
  def atan2(:infinity, :neg_infinity), do: 3 * :math.pi() / 4
  def atan2(:infinity, :nan), do: :nan
  def atan2(:infinity, a) when is_number(a), do: :math.pi() / 2
  def atan2(:neg_infinity, :infinity), do: -:math.pi() / 4
  def atan2(:neg_infinity, :neg_infinity), do: -3 * :math.pi() / 4
  def atan2(:neg_infinity, :nan), do: :nan
  def atan2(:neg_infinity, a) when is_number(a), do: -:math.pi() / 2
  def atan2(:nan, a) when is_number(a) or is_non_finite_number(a), do: :nan
  def atan2(a, :nan) when is_number(a) or is_non_finite_number(a), do: :nan
  def atan2(:nan, :nan), do: :nan
  def atan2(a, :infinity) when is_number(a), do: 0
  def atan2(a, :neg_infinity) when is_number(a), do: :math.pi()

  def atan2(b, a) do
    a = as_complex(a)
    b = as_complex(b)

    if b.im != 0 or a.im != 0 do
      raise ArithmeticError, "Complex.atan2 only accepts real numbers as arguments"
    end

    b.re
    |> atan2(a.re)
    |> Complex.new()
  end

  @doc """
  Returns a new complex that is the cotangent of the provided parameter.

  ### See also

  `sin/1`, `cos/1`, `tan/1`

  ### Examples

      iex> Complex.cot(Complex.from_polar(2,:math.pi))
      %Complex{im: -2.962299212953233e-16, re: 0.45765755436028577}

  """
  @spec cot(t | number | non_finite_number) :: t | number | non_finite_number
  def cot(z)

  def cot(n) when is_number(n), do: 1 / :math.tan(n)

  def cot(z) do
    divide(cos(z), sin(z))
  end

  @doc """
  Returns a new complex that is the inverse cotangent (i.e., arccotangent) of
  the provided parameter.

  ### See also

  `cot/1`

  ### Examples

      iex> Complex.acot(Complex.from_polar(2,:math.pi))
      %Complex{im: -9.71445146547012e-17, re: -0.46364760900080615}

      iex> Complex.cot(Complex.acot(Complex.new(2,3)))
      %Complex{im: 2.9999999999999996, re: 1.9999999999999993}

  """
  @spec acot(t | number | non_finite_number) :: t | number | non_finite_number
  def acot(z)

  def acot(n) when is_number(n), do: :math.atan(1 / n)

  def acot(:infinity), do: 0
  def acot(:neg_infinity), do: :math.pi()
  def acot(:nan), do: :nan

  def acot(z) do
    i = new(0.0, 1.0)
    # result = 0.5*i*(log(1-i/z)-log(1+i/z))
    t1 = multiply(new(0.5, 0.0), i)
    t2 = subtract(new(1.0, 0.0), divide(i, z))
    t3 = add(new(1.0, 0.0), divide(i, z))
    multiply(t1, subtract(log(t2), log(t3)))
  end

  @doc """
  Returns a new complex that is the secant of the provided parameter.

  ### See also

  `sin/1`, `cos/1`, `tan/1`

  ### Examples

      iex> Complex.sec(Complex.from_polar(2,:math.pi))
      %Complex{im: -1.2860374461837126e-15, re: -2.402997961722381}

  """
  @spec sec(t | number | non_finite_number) :: t | number | non_finite_number
  def sec(z) do
    divide(1, cos(z))
  end

  @doc """
  Returns a new complex that is the inverse secant (i.e., arcsecant) of
  the provided parameter.

  ### See also

  `sec/1`

  ### Examples

      iex> Complex.asec(Complex.from_polar(2,:math.pi))
      %Complex{im: -0.0, re: 2.0943951023931957}

      iex> Complex.sec(Complex.asec(Complex.new(2,3)))
      %Complex{im: 2.9999999999999982, re: 1.9999999999999987}

  """
  @spec asec(t) :: t
  @spec asec(number) :: number
  def asec(z)

  def asec(n) when is_number(n) do
    :math.acos(1 / n)
  end

  def asec(:infinity), do: :math.pi() / 2
  def asec(:neg_infinity), do: 3 * :math.pi() / 2
  def asec(:nan), do: :nan

  def asec(z = %Complex{}) do
    i = new(0.0, 1.0)
    # result = -i*log(i*sqrt(1-1/(z*z))+1/z)
    # result = -i*log(i*sqrt(1-t2)+t1)
    t1 = divide(1, z)
    t2 = square(t1)
    # result = -i*log(i*sqrt(t3)+t1)
    # result = -i*log(t4+t1)
    t3 = subtract(1, t2)
    t4 = multiply(i, sqrt(t3))
    multiply(negate(i), log(add(t4, t1)))
  end

  @doc """
  Returns a new complex that is the cosecant of the provided parameter.

  ### See also

  `sec/1`, `sin/1`, `cos/1`, `tan/1`

  ### Examples

      iex> Complex.csc(Complex.from_polar(2,:math.pi))
      %Complex{im: 1.2327514463765779e-16, re: -1.0997501702946164}

  """
  @spec csc(t) :: t
  @spec csc(number) :: number
  def csc(z) do
    divide(1, sin(z))
  end

  @doc """
  Returns a new complex that is the inverse cosecant (i.e., arccosecant) of
  the provided parameter.

  ### See also

  `sec/1`

  ### Examples

      iex> Complex.acsc(Complex.from_polar(2,:math.pi))
      %Complex{im: 0.0, re: -0.5235987755982988}

      iex> Complex.csc(Complex.acsc(Complex.new(2,3)))
      %Complex{im: 3.0, re: 1.9999999999999993}

  """
  @spec acsc(t | number | non_finite_number) :: t | number | non_finite_number
  def acsc(z)

  def acsc(n) when is_number(n), do: :math.asin(1 / n)
  def acsc(:infinity), do: 0
  def acsc(:neg_infinity), do: -:math.pi()
  def acsc(:nan), do: :nan

  def acsc(z = %Complex{}) do
    i = new(0.0, 1.0)
    one = new(1.0, 0.0)
    # result = -i*log(sqrt(1-1/(z*z))+i/z)
    # result = -i*log(sqrt(1-t2)+t1)
    t1 = divide(i, z)
    t2 = divide(one, multiply(z, z))
    # result = -i*log(sqrt(t3)+t1)
    # result = -i*log(t4+t1)
    t3 = subtract(one, t2)
    t4 = sqrt(t3)
    multiply(negate(i), log(add(t4, t1)))
  end

  @doc """
  Returns a new complex that is the hyperbolic sine of the provided parameter.

  ### See also

  `cosh/1`, `tanh/1`

  ### Examples

      iex> Complex.sinh(Complex.from_polar(2,:math.pi))
      %Complex{im: 9.214721821703068e-16, re: -3.626860407847019}

  """
  @spec sinh(t) :: t
  @spec sinh(number) :: number
  def sinh(z)

  def sinh(n) when is_non_finite_number(n), do: n

  def sinh(n) when is_number(n), do: :math.sinh(n)

  def sinh(z = %Complex{}) do
    %Complex{re: re, im: im} =
      z
      |> exp()
      |> subtract(exp(negate(z)))

    new(divide(re, 2), divide(im, 2))
  end

  @doc """
  Returns a new complex that is the inverse hyperbolic sine (i.e., arcsinh) of
  the provided parameter.

  ### See also

  `sinh/1`

  ### Examples

      iex> Complex.asinh(Complex.from_polar(2,:math.pi))
      %Complex{im: 1.0953573965284052e-16, re: -1.4436354751788099}

      iex> Complex.sinh(Complex.asinh(Complex.new(2,3)))
      %Complex{im: 3.0, re: 2.0000000000000004}

  """
  @spec asinh(t | number | non_finite_number) :: t | number | non_finite_number
  def asinh(z)

  if math_fun_supported?.(:asinh, 1) do
    def asinh(n) when is_number(n) do
      :math.asinh(n)
    end
  else
    def asinh(n) when is_number(n) do
      :math.log(n + :math.sqrt(1 + n * n))
    end
  end

  def asinh(:infinity), do: :infinity
  def asinh(:neg_infinity), do: :neg_infinity
  def asinh(:nan), do: :nan

  def asinh(z) do
    # result = log(z+sqrt(z*z+1))
    # result = log(z+sqrt(t1))
    # result = log(t2)
    t1 = add(multiply(z, z), 1)
    t2 = add(z, sqrt(t1))
    log(t2)
  end

  @doc """
  Returns a new complex that is the hyperbolic cosine of the provided
  parameter.

  ### See also

  `sinh/1`, `tanh/1`

  ### Examples

      iex> Complex.cosh(Complex.from_polar(2,:math.pi))
      %Complex{im: -8.883245978848233e-16, re: 3.7621956910836314}

  """
  @spec cosh(t | number | non_finite_number) :: t | number | non_finite_number

  def cosh(:infinity), do: :infinity
  def cosh(:neg_infinity), do: :infinity
  def cosh(:nan), do: :nan
  def cosh(n) when is_number(n), do: :math.cosh(n)

  def cosh(z) do
    %Complex{re: re, im: im} =
      z
      |> exp()
      |> add(exp(negate(z)))

    new(divide(re, 2), divide(im, 2))
  end

  @doc """
  Returns a new complex that is the inverse hyperbolic cosine (i.e., arccosh)
  of the provided parameter.

  ### See also

  `cosh/1`

  ### Examples

      iex> Complex.acosh(Complex.from_polar(2,:math.pi))
      %Complex{im: -3.141592653589793, re: -1.3169578969248164}

  """
  @spec acosh(t | number | non_finite_number) :: t | number | non_finite_number
  def acosh(z)

  if math_fun_supported?.(:acosh, 1) do
    def acosh(n) when is_number(n), do: :math.acosh(n)
  else
    def acosh(n) when is_number(n) do
      :math.log(n + :math.sqrt(n * n - 1))
    end
  end

  def acosh(:infinity), do: :infinity

  def acosh(:neg_infinity),
    do: raise(ArithmeticError, "Complex.acosh(:neg_infinity) is undefined")

  def acosh(:nan), do: :nan

  def acosh(z) do
    # result = log(z+sqrt(z*z-1))
    # result = log(z+sqrt(t1))
    # result = log(t2)
    t1 = subtract(multiply(z, z), 1)
    t2 = add(z, sqrt(t1))
    log(t2)
  end

  @doc """
  Returns a new complex that is the hyperbolic tangent of the provided
  parameter.

  ### See also

  `sinh/1`, `cosh/1`

  ### Examples

      iex> Complex.tanh(Complex.from_polar(2,:math.pi))
      %Complex{im: 1.7304461302709575e-17, re: -0.9640275800758169}

  """
  @spec tanh(t | number | non_finite_number) :: t | number | non_finite_number
  def tanh(z)

  def tanh(n) when is_number(n), do: :math.tanh(n)

  def tanh(z) do
    divide(sinh(z), cosh(z))
  end

  @doc """
  Returns a new complex that is the inverse hyperbolic tangent (i.e., arctanh)
  of the provided parameter.

  ### See also

  `tanh/1`

  ### Examples

      iex> Complex.atanh(Complex.from_polar(2,:math.pi))
      %Complex{im: 1.5707963267948966, re: -0.5493061443340549}

      iex> Complex.tanh(Complex.atanh(Complex.new(2,3)))
      %Complex{im: 3.0, re: 1.9999999999999993}

  """
  @spec atanh(t | number | non_finite_number) :: t | number | non_finite_number
  def atanh(z)

  if math_fun_supported?.(:atanh, 1) do
    def atanh(n) when is_number(n), do: :math.atanh(n)
  else
    def atanh(n) when is_number(n) do
      0.5 * :math.log((1 + n) / (1 - n))
    end
  end

  def atanh(z) do
    one = new(1.0, 0.0)
    p5 = new(0.5, 0.0)
    # result = 0.5*(log((1+z)/(1-z)))
    # result = 0.5*(log(t2/t1))
    # result = 0.5*(log(t3))
    t1 = subtract(one, z)
    t2 = add(one, z)
    t3 = divide(t2, t1)
    multiply(p5, log(t3))
  end

  @doc """
  Returns a new complex that is the hyperbolic secant of the provided
  parameter.

  ### See also

  `sinh/1`, `cosh/1`, `tanh/1`

  ### Examples

      iex> Complex.sech(Complex.from_polar(2,:math.pi))
      %Complex{im: 6.27608655779184e-17, re: 0.26580222883407967}

  """
  @spec sech(t | number | non_finite_number) :: t | number | non_finite_number
  def sech(z) do
    divide(1, cosh(z))
  end

  @doc """
  Returns a new complex that is the inverse hyperbolic secant (i.e., arcsech)
  of the provided parameter.

  ### See also

  `sech/1`

  ### Examples

      iex> Complex.asech(Complex.from_polar(2,:math.pi))
      %Complex{im: -2.0943951023931953, re: 0.0}

      iex> Complex.sech(Complex.asech(Complex.new(2,3)))
      %Complex{im: 2.999999999999999, re: 2.0}

  """
  @spec asech(t | number | non_finite_number) :: t | number | non_finite_number
  def asech(z) do
    # result = log(1/z+sqrt(1/z+1)*sqrt(1/z-1))
    # result = log(t1+sqrt(t1+1)*sqrt(t1-1))
    # result = log(t1+t2*t3)
    t1 = divide(1, z)
    t2 = sqrt(add(t1, 1))
    t3 = sqrt(subtract(t1, 1))
    log(add(t1, multiply(t2, t3)))
  end

  @doc """
  Returns a new complex that is the hyperbolic cosecant of the provided
  parameter.

  ### See also

  `sinh/1`, `cosh/1`, `tanh/1`

  ### Examples

      iex> Complex.csch(Complex.from_polar(2,:math.pi))
      %Complex{im: -7.00520014334671e-17, re: -0.2757205647717832}

  """
  @spec csch(t | number | non_finite_number) :: t | number | non_finite_number
  def csch(z), do: divide(1, sinh(z))

  @doc """
  Returns a new complex that is the inverse hyperbolic cosecant (i.e., arccsch)
  of the provided parameter.

  ### See also

  `csch/1`

  ### Examples

      iex> Complex.acsch(Complex.from_polar(2,:math.pi))
      %Complex{im: -5.4767869826420256e-17, re: -0.48121182505960336}

      iex> Complex.csch(Complex.acsch(Complex.new(2,3)))
      %Complex{im: 3.0000000000000018, re: 1.9999999999999984}

  """
  @spec acsch(t | number | non_finite_number) :: t | number | non_finite_number
  def acsch(z) do
    # result = log(1/z+sqrt(1/(z*z)+1))
    # result = log(t1+sqrt(t2+1))
    # result = log(t1+t3)
    t1 = divide(1, z)
    t2 = divide(1, multiply(z, z))
    t3 = sqrt(add(t2, 1))
    log(add(t1, t3))
  end

  @doc """
  Returns a new complex that is the hyperbolic cotangent of the provided
  parameter.

  ### See also

  `sinh/1`, `cosh/1`, `tanh/1`

  ### Examples

      iex> Complex.coth(Complex.from_polar(2,:math.pi))
      %Complex{im: -1.8619978115303644e-17, re: -1.037314720727548}

  """
  @spec coth(t | number | non_finite_number) :: t | number | non_finite_number
  def coth(z) do
    divide(cosh(z), sinh(z))
  end

  @doc """
  Returns a new complex that is the inverse hyperbolic cotangent (i.e., arccoth)
  of the provided parameter.

  ### See also

  `coth/1`

  ### Examples

      iex> Complex.acoth(Complex.from_polar(2,:math.pi))
      %Complex{im: -8.164311994315688e-17, re: -0.5493061443340548}

      iex> Complex.coth(Complex.acoth(Complex.new(2,3)))
      %Complex{im: 2.999999999999998, re: 2.000000000000001}

  """
  @spec acoth(t | number | non_finite_number) :: t | number | non_finite_number
  def acoth(z) do
    # result = 0.5*(log(1+1/z)-log(1-1/z))
    # result = 0.5*(log(1+t1)-log(1-t1))
    # result = 0.5*(log(t2)-log(t3))
    t1 = divide(1, z)
    t2 = add(1, t1)
    t3 = subtract(1, t1)
    multiply(0.5, subtract(log(t2), log(t3)))
  end

  @doc ~S"""
  Calculates $erf(z)$ of the argument, as defined by:

  $$erf(z) = \frac{2}{\sqrt{\pi}} \int_{0}^{z} e^{-t^2}$$

  ### Examples

      iex> x = Complex.erf(0.5)
      iex> Float.round(x, 5)
      0.52050

      iex> z = Complex.erf(Complex.new(-0.5))
      iex> z.im
      0.0
      iex> Float.round(z.re, 5)
      -0.52050

      iex> Complex.erf(Complex.new(1, 1))
      ** (ArithmeticError) erf not implemented for non-real numbers

  """
  @spec erf(t | number | non_finite_number) :: t | number | non_finite_number

  if math_fun_supported?.(:erf, 1) do
    def erf(x) when is_number(x) do
      :math.erf(x)
    end
  else
    def erf(x) when is_number(x) do
      x = x |> max(-4.0) |> min(4.0)
      x2 = x * x

      alpha =
        0.0
        |> muladd(x2, -2.72614225801306e-10)
        |> muladd(x2, 2.77068142495902e-08)
        |> muladd(x2, -2.10102402082508e-06)
        |> muladd(x2, -5.69250639462346e-05)
        |> muladd(x2, -7.34990630326855e-04)
        |> muladd(x2, -2.95459980854025e-03)
        |> muladd(x2, -1.60960333262415e-02)

      beta =
        0.0
        |> muladd(x2, -1.45660718464996e-05)
        |> muladd(x2, -2.13374055278905e-04)
        |> muladd(x2, -1.68282697438203e-03)
        |> muladd(x2, -7.37332916720468e-03)
        |> muladd(x2, -1.42647390514189e-02)

      min(x * alpha / beta, 1.0)
    end
  end

  def erf(:infinity), do: 1
  def erf(:neg_infinity), do: -1
  def erf(:nan), do: :nan

  def erf(%Complex{re: re, im: im}) do
    if im != 0 do
      raise ArithmeticError, "erf not implemented for non-real numbers"
    end

    Complex.new(erf(re))
  end

  @doc ~S"""
  Calculates $erfc(z)$ of the argument, as defined by:

  $$erfc(z) = 1 - erf(z)$$

  ### Examples

      iex> x = Complex.erfc(0.5)
      iex> Float.round(x, 5)
      0.47950

      iex> z = Complex.erfc(Complex.new(-0.5))
      iex> z.im
      0.0
      iex> Float.round(z.re, 5)
      1.52050

      iex> Complex.erfc(Complex.new(1, 1))
      ** (ArithmeticError) erfc not implemented for non-real numbers

  """
  @spec erfc(t | number | non_finite_number) :: t | number | non_finite_number
  def erfc(z)

  if math_fun_supported?.(:erfc, 1) do
    def erfc(z) when is_number(z), do: :math.erfc(z)
  end

  def erfc(z) do
    if is_struct(z, Complex) and z.im != 0 do
      raise ArithmeticError, "erfc not implemented for non-real numbers"
    end

    subtract(1, erf(z))
  end

  @doc ~S"""
  Calculates $erf^-1(z)$ of the argument, as defined by:

  $$erf(erf^-1(z)) = z$$

  ### Examples

      iex> Complex.erf_inv(0.5204998778130465)
      0.5000000069276399

      iex> Complex.erf_inv(Complex.new(-0.5204998778130465))
      %Complex{im: 0.0, re: -0.5000000069276399}

      iex> Complex.erf_inv(Complex.new(1, 1))
      ** (ArithmeticError) erf_inv not implemented for non-real numbers

  """
  @spec erf_inv(t | number | non_finite_number) :: t | number | non_finite_number
  def erf_inv(z) when is_number(z) do
    cond do
      z == 1 ->
        :infinity

      z == -1 ->
        :neg_infinity

      z == 0 ->
        0

      :otherwise ->
        w = -:math.log((1 - z) * (1 + z))
        erf_inv_p(w) * z
    end
  end

  def erf_inv(n) when is_non_finite_number(n), do: :nan

  def erf_inv(%Complex{re: re, im: im}) do
    if im != 0 do
      raise ArithmeticError, "erf_inv not implemented for non-real numbers"
    end

    Complex.new(erf_inv(re))
  end

  defp erf_inv_p(w) when w < 5 do
    w = w - 2.5

    2.81022636e-08
    |> muladd(w, 3.43273939e-07)
    |> muladd(w, -3.5233877e-06)
    |> muladd(w, -4.39150654e-06)
    |> muladd(w, 0.00021858087)
    |> muladd(w, -0.00125372503)
    |> muladd(w, -0.00417768164)
    |> muladd(w, 0.246640727)
    |> muladd(w, 1.50140941)
  end

  defp erf_inv_p(w) do
    w = :math.sqrt(w) - 3

    -0.000200214257
    |> muladd(w, 0.000100950558)
    |> muladd(w, 0.00134934322)
    |> muladd(w, -0.00367342844)
    |> muladd(w, 0.00573950773)
    |> muladd(w, -0.0076224613)
    |> muladd(w, 0.00943887047)
    |> muladd(w, 1.00167406)
    |> muladd(w, 2.83297682)
  end

  defp muladd(acc, t, n) do
    acc * t + n
  end

  defp as_complex(%Complex{} = x), do: x
  defp as_complex(x) when is_number(x), do: new(x)
  defp as_complex(x) when x in @non_finite_numbers, do: new(x)

  defp as_float(:infinity), do: :infinity
  defp as_float(:neg_infinity), do: :neg_infinity
  defp as_float(:nan), do: :nan
  defp as_float(n), do: 1.0 * n
end