# Complex Math

Most mathematical operations on real numbers have a compatible implementation on complex numbers. Compatible in this case means that the result for an argument that happens to be real, matches the result of the real version of the function as long as the function has a defined result for the argument. There is a lot more to it. One way to derive compatible complex versions of such functions is to perform Taylor series expansion and then use those with complex arguments.

#### Principal square root

Similar to real numbers, the square root of a complex number is a complex number that, when multiplied to itself yields the orginal number. In the real number case, what we call the square root is actually the principal square root. E.g. the square root of 16 is 4. The other (non-principal) value that, when multiplied with itself yields 16 is -4. In the complex number space, there are also two solutions to the equation `s * s = z`. the principal square root of a complex number is the one that has the highest real component.

``````    Complex z = new Complex(3, -5);
System.out.println(z);
System.out.println(ComplexMath.sqrt(z));``````

Outputs:

```Complex [re=3.0, im=-5.0]
Complex [re=2.101303392521568, im=-1.1897377641407583]
```

The other complex number that, when squared, yields the same result can be obtained by rotating by π, or by negating (multiplying by `-1.0`). Ignoring rounding errors (due to the limited precision of the internal representation of π) the results of negating or rotating by π are identical. As the internal representation stores the real and imaginary components, negating is both faster and more accurate:

``````    System.out.println(ComplexMath.sqrt(z).rotate(Math.PI));
System.out.println(ComplexMath.sqrt(z).times(-1));``````

Outputs

```Complex [re=-2.101303392521568, im=1.1897377641407585]
Complex [re=-2.101303392521568, im=1.1897377641407583]
```

#### Principal cube root

Unlike the real number space, the cube root of a complex number actually has three candidate values. The one with the highest real component is the principal cube root. The others can be obtained by rotating over `2 * π / 3` and `4 * π / 3` :

``````    System.out.println(ComplexMath.cbrt(z));
System.out.println(ComplexMath.cbrt(z).rotate(2 * Math.PI / 3));
System.out.println(ComplexMath.cbrt(z).rotate(4 * Math.PI / 3));``````

Outputs

```Complex [re=3.0, im=-5.0]
Complex [re=1.6947703899454605, im=-0.6061065307696287]
Complex [re=-0.32248154192657685, im=1.7707674766592425]
Complex [re=-1.3722888480188837, im=-1.1646609458896129]
```

#### Exponential function

The exponential function raises Eulers constant `e` (about 2.7182818284590452354) to a specified power. The normal implementation takes a real argument. The implementation in `ComplexMath` takes a `Complex` argument:

``````        Complex z = new Complex(3, -5);
System.out.println(z);
System.out.println(ComplexMath.exp(z));``````

Outputs:

```Complex [re=3.0, im=-5.0]
Complex [re=5.697507299833739, im=19.26050892528742]
```

#### Natural logarithm

The inverse of the exponential function is the natural logarithm. In the java `Math` library, the natural logarithm function is named `log`. We find this utterly confusing and elected to name the equivalent function for complex numbers `ln`:

``````    Complex z = new Complex(3, -5);
System.out.println(z);
System.out.println(ComplexMath.ln(z));``````

Outputs:

```Complex [re=3.0, im=-5.0]
Complex [re=1.7631802623080808, im=-1.0303768265243125]
```

#### Sine, cosine, tangent

The trigonometric functions sine, cosine and tangent have counterparts in the complex domain:

``````    Complex z = new Complex(3, -5);
System.out.println(z);
System.out.println(ComplexMath.sin(z));
System.out.println(ComplexMath.cos(z));
System.out.println(ComplexMath.tan(z));``````

Unlike these functions for real values; the results of sine and cosine are not limited to `[-1, +1]`:

```Complex [re=3.0, im=-5.0]
Complex [re=10.472508533940392, im=73.46062169567367]
Complex [re=-73.46729221264526, im=10.471557674805572]
Complex [re=-2.5368676207676027E-5, im=-0.9999128201513536]
```

#### Inverse sine, inverse cosine, inverse tangent

The inverse functions are named `asin`, `acos` and `atan` (in literature these are sometimes named `arcsin`, `arccos` and `arctan`):

``````    Complex z = new Complex(3, -5);
System.out.println(z);
System.out.println(ComplexMath.asin(z));
System.out.println(ComplexMath.acos(z));
System.out.println(ComplexMath.atan(z));``````

Outputs:

```Complex [re=3.0, im=-5.0]
Complex [re=0.5339990695941685, im=-2.4598315216234345]
Complex [re=1.036797257200728, im=2.4598315216234345]
Complex [re=1.4808695768986575, im=-0.14694666622552974]
```

#### Hyperbolic sine, hyperbolic cosine, hyperbolic tangent

These hyperbolic functions are named `sinh`, `cosh` and `tanh`:

``````    Complex z = new Complex(3, -5);
System.out.println(z);
System.out.println(ComplexMath.sinh(z));
System.out.println(ComplexMath.cosh(z));
System.out.println(ComplexMath.tanh(z));``````

Outputs:

```Complex [re=3.0, im=-5.0]
Complex [re=2.841692295606352, im=9.654125476854839]
Complex [re=2.855815004227387, im=9.606383448432581]
Complex [re=1.0041647106948153, im=0.002708235836224072]
```

#### Inverse hyperbolic sine, inverse hyperbolic cosine, inverse hyperbolic tangent

Even though the inverse hyperbolic functions are not implemented in the java `Math` library we elected to add the complex versions to our `ComplexMath` library:

``````    Complex z = new Complex(3, -5);
System.out.println(z);
System.out.println(ComplexMath.asinh(z));
System.out.println(ComplexMath.acosh(z));
System.out.println(ComplexMath.atanh(z));``````

Outputs:

```Complex [re=3.0, im=-5.0]
Complex [re=2.4529137425028096, im=-1.0238217465117878]
Complex [re=2.4598315216234345, im=-1.036797257200728]
Complex [re=0.08656905917945844, im=-1.4236790442393028]
```