## Class Complexd

• All Implemented Interfaces:
`Serializable`, `Comparable<Complexd>`, `Imaginaryd`

```@Immutable
public final class Complexd
extends Object
implements Imaginaryd, Comparable<Complexd>, Serializable```
Represent a complex number of the form `x + yi`. The x and y components are stored as `double`s. This class is immutable.
Serialized Form
• ### Field Summary

Fields
Modifier and Type Field Description
`static Complexd` `IDENTITY`
An immutable identity (1, 0) complex.
`static Complexd` `ZERO`
An immutable identity (0, 0) complex.
• ### Constructor Summary

Constructors
Constructor Description
```Complexd​(double x, double y)```
Constructs a new complex from the double components.
```Complexd​(float x, float y)```
Constructs a new complex from the float components.
• ### Method Summary

All Methods
Modifier and Type Method Description
`Complexd` ```add​(double x, double y)```
Adds the double components of another complex to this one.
`Complexd` ```add​(float x, float y)```
Adds the float components of another complex to this one.
`Complexd` `add​(Complexd c)`
Adds another complex to this one.
`double` `angleDeg()`
Returns the angle in degrees formed by the direction vector of this complex on the complex plane.
`double` `angleRad()`
Returns the angle in radians formed by the direction vector of this complex on the complex plane.
`int` `compareTo​(Complexd that)`
`Complexd` `conjugate()`
Returns the conjugate of this complex.
`Vector2d` `direction()`
Returns a unit vector pointing in the same direction as this complex on the complex plane.
`Complexd` `div​(double a)`
Divides the components of this complex by a double scalar.
`Complexd` ```div​(double x, double y)```
Divides this complex by the double components of another one.
`Complexd` `div​(float a)`
Divides the components of this complex by a float scalar.
`Complexd` ```div​(float x, float y)```
Divides this complex by the float components of another one.
`Complexd` `div​(Complexd c)`
Divides this complex by another one.
`double` ```dot​(double x, double y)```
Returns the dot product of this complex with the double components of another one.
`double` ```dot​(float x, float y)```
Returns the dot product of this complex with the float components of another one.
`double` `dot​(Complexd c)`
Returns the dot product of this complex with another one.
`boolean` `equals​(Object other)`
`static Complexd` ```from​(double x, double y)```
Creates a new complex from the double components.
`static Complexd` `fromAngleDeg​(double angle)`
Creates a new complex from the double angle in radians.
`static Complexd` `fromAngleDeg​(float angle)`
Creates a new complex from the float angle in degrees.
`static Complexd` `fromAngleRad​(double angle)`
Creates a new complex from the double angle in radians.
`static Complexd` `fromAngleRad​(float angle)`
Creates a new complex from the float angle in radians.
`static Complexd` `fromImaginary​(double y)`
Creates a new complex from the double imaginary components.
`static Complexd` `fromReal​(double x)`
Creates a new complex from the double real component.
`static Complexd` ```fromRotationTo​(Vector2d from, Vector2d to)```
Creates a new complex from the angle defined from the first to the second vector.
`static Complexd` ```fromRotationTo​(Vector3d from, Vector3d to)```
Creates a new complex from the angle defined from the first to the second vector.
`int` `hashCode()`
`Complexd` `invert()`
Returns the inverse of this complex.
`double` `length()`
Returns the length of this complex.
`double` `lengthSquared()`
Returns the square of the length of this complex.
`Complexd` `mul​(double a)`
Multiplies the components of this complex by a double scalar.
`Complexd` ```mul​(double x, double y)```
Multiplies the double components of another complex with this one.
`Complexd` `mul​(float a)`
Multiplies the components of this complex by a float scalar.
`Complexd` ```mul​(float x, float y)```
Multiplies the float components of another complex with this one.
`Complexd` `mul​(Complexd c)`
Multiplies another complex with this one.
`Complexd` `normalize()`
Normalizes this complex.
`Vector2d` ```rotate​(double x, double y)```
Rotates the double components of a vector by this complex.
`Vector2d` ```rotate​(float x, float y)```
Rotates the float components of a vector by this complex.
`Vector2d` `rotate​(Vector2d v)`
Rotates a vector by this complex.
`Complexd` ```sub​(double x, double y)```
Subtracts the double components of another complex from this one.
`Complexd` ```sub​(float x, float y)```
Subtracts the float components of another complex from this one.
`Complexd` `sub​(Complexd c)`
Subtracts another complex from this one.
`Complexd` `toDouble()`
`Complexf` `toFloat()`
`Quaterniond` `toQuaternion()`
Converts this complex to a quaternion by using (0, 0, 1) as a rotation axis.
`Quaterniond` ```toQuaternion​(double x, double y, double z)```
Converts this complex to a quaternion by using the provided double components vector as a rotation axis.
`Quaterniond` ```toQuaternion​(float x, float y, float z)```
Converts this complex to a quaternion by using the provided float components vector as a rotation axis.
`Quaterniond` `toQuaternion​(Vector3d axis)`
Converts this complex to a quaternion by using the provided vector as a rotation axis.
`String` `toString()`
`double` `x()`
Gets the x (real) component of this complex.
`double` `y()`
Gets the y (imaginary) component of this complex.
• ### Methods inherited from class java.lang.Object

`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`
• ### Field Detail

• #### ZERO

`public static final Complexd ZERO`
An immutable identity (0, 0) complex.
• #### IDENTITY

`public static final Complexd IDENTITY`
An immutable identity (1, 0) complex.
• ### Constructor Detail

• #### Complexd

```public Complexd​(float x,
float y)```
Constructs a new complex from the float components.
Parameters:
`x` - The x (real) component
`y` - The y (imaginary) component
• #### Complexd

```public Complexd​(double x,
double y)```
Constructs a new complex from the double components.
Parameters:
`x` - The x (real) component
`y` - The y (imaginary) component
• ### Method Detail

• #### x

`public double x()`
Gets the x (real) component of this complex.
Returns:
The x (real) component
• #### y

`public double y()`
Gets the y (imaginary) component of this complex.
Returns:
The y (imaginary) component

`public Complexd add​(Complexd c)`
Adds another complex to this one.
Parameters:
`c` - The complex to add
Returns:
A new complex, which is the sum of both

```public Complexd add​(float x,
float y)```
Adds the float components of another complex to this one.
Parameters:
`x` - The x (real) component of the complex to add
`y` - The y (imaginary) component of the complex to add
Returns:
A new complex, which is the sum of both

```public Complexd add​(double x,
double y)```
Adds the double components of another complex to this one.
Parameters:
`x` - The x (real) component of the complex to add
`y` - The y (imaginary) component of the complex to add
Returns:
A new complex, which is the sum of both
• #### sub

`public Complexd sub​(Complexd c)`
Subtracts another complex from this one.
Parameters:
`c` - The complex to subtract
Returns:
A new complex, which is the difference of both
• #### sub

```public Complexd sub​(float x,
float y)```
Subtracts the float components of another complex from this one.
Parameters:
`x` - The x (real) component of the complex to subtract
`y` - The y (imaginary) component of the complex to subtract
Returns:
A new complex, which is the difference of both
• #### sub

```public Complexd sub​(double x,
double y)```
Subtracts the double components of another complex from this one.
Parameters:
`x` - The x (real) component of the complex to subtract
`y` - The y (imaginary) component of the complex to subtract
Returns:
A new complex, which is the difference of both
• #### mul

`public Complexd mul​(float a)`
Multiplies the components of this complex by a float scalar.
Parameters:
`a` - The multiplication scalar
Returns:
A new complex, which has each component multiplied by the scalar
• #### mul

`public Complexd mul​(double a)`
Multiplies the components of this complex by a double scalar.
Specified by:
`mul` in interface `Imaginaryd`
Parameters:
`a` - The multiplication scalar
Returns:
A new complex, which has each component multiplied by the scalar
• #### mul

`public Complexd mul​(Complexd c)`
Multiplies another complex with this one.
Parameters:
`c` - The complex to multiply with
Returns:
A new complex, which is the product of both
• #### mul

```public Complexd mul​(float x,
float y)```
Multiplies the float components of another complex with this one.
Parameters:
`x` - The x (real) component of the complex to multiply with
`y` - The y (imaginary) component of the complex to multiply with
Returns:
A new complex, which is the product of both
• #### mul

```public Complexd mul​(double x,
double y)```
Multiplies the double components of another complex with this one.
Parameters:
`x` - The x (real) component of the complex to multiply with
`y` - The y (imaginary) component of the complex to multiply with
Returns:
A new complex, which is the product of both
• #### div

`public Complexd div​(float a)`
Divides the components of this complex by a float scalar.
Parameters:
`a` - The division scalar
Returns:
A new complex, which has each component divided by the scalar
• #### div

`public Complexd div​(double a)`
Divides the components of this complex by a double scalar.
Specified by:
`div` in interface `Imaginaryd`
Parameters:
`a` - The division scalar
Returns:
A new complex, which has each component divided by the scalar
• #### div

`public Complexd div​(Complexd c)`
Divides this complex by another one.
Parameters:
`c` - The complex to divide with
Returns:
The quotient of the two complexes
• #### div

```public Complexd div​(float x,
float y)```
Divides this complex by the float components of another one.
Parameters:
`x` - The x (real) component of the complex to divide with
`y` - The y (imaginary) component of the complex to divide with
Returns:
The quotient of the two complexes
• #### div

```public Complexd div​(double x,
double y)```
Divides this complex by the double components of another one.
Parameters:
`x` - The x (real) component of the complex to divide with
`y` - The y (imaginary) component of the complex to divide with
Returns:
The quotient of the two complexes
• #### dot

`public double dot​(Complexd c)`
Returns the dot product of this complex with another one.
Parameters:
`c` - The complex to calculate the dot product with
Returns:
The dot product of the two complexes
• #### dot

```public double dot​(float x,
float y)```
Returns the dot product of this complex with the float components of another one.
Parameters:
`x` - The x (real) component of the complex to calculate the dot product with
`y` - The y (imaginary) component of the complex to calculate the dot product with
Returns:
The dot product of the two complexes
• #### dot

```public double dot​(double x,
double y)```
Returns the dot product of this complex with the double components of another one.
Parameters:
`x` - The x (real) component of the complex to calculate the dot product with
`y` - The y (imaginary) component of the complex to calculate the dot product with
Returns:
The dot product of the two complexes
• #### rotate

`public Vector2d rotate​(Vector2d v)`
Rotates a vector by this complex.
Parameters:
`v` - The vector to rotate
Returns:
The rotated vector
• #### rotate

```public Vector2d rotate​(float x,
float y)```
Rotates the float components of a vector by this complex.
Parameters:
`x` - The x component of the vector
`y` - The y component of the vector
Returns:
The rotated vector
• #### rotate

```public Vector2d rotate​(double x,
double y)```
Rotates the double components of a vector by this complex.
Parameters:
`x` - The x component of the vector
`y` - The y component of the vector
Returns:
The rotated vector
• #### direction

`public Vector2d direction()`
Returns a unit vector pointing in the same direction as this complex on the complex plane.
Returns:
The vector representing the direction this complex is pointing to

`public double angleRad()`
Returns the angle in radians formed by the direction vector of this complex on the complex plane.
Returns:
The angle in radians of the direction vector of this complex
• #### angleDeg

`public double angleDeg()`
Returns the angle in degrees formed by the direction vector of this complex on the complex plane.
Returns:
The angle in degrees of the direction vector of this complex
• #### conjugate

`public Complexd conjugate()`
Returns the conjugate of this complex.
Conjugation of a complex `a` is an operation returning complex `a'` such that `a' * a = a * a' = |a|2` where `|a|2` is squared length of `a`.
Specified by:
`conjugate` in interface `Imaginaryd`
Returns:
A new complex, which is the conjugate of this one
• #### invert

`public Complexd invert()`
Returns the inverse of this complex.
Inversion of a complex `a` returns complex `a-1 = a' / |a|2` where `a'` is `conjugation` of `a`, and `|a|2` is squared length of `a`.
For any complexes `a, b, c`, such that `a * b = c` equations `a-1 * c = b` and `c * b-1 = a` are true.
Specified by:
`invert` in interface `Imaginaryd`
Returns:
A new complex, which is the inverse of this one
• #### lengthSquared

`public double lengthSquared()`
Returns the square of the length of this complex.
Specified by:
`lengthSquared` in interface `Imaginaryd`
Returns:
The square of the length
• #### length

`public double length()`
Returns the length of this complex.
Specified by:
`length` in interface `Imaginaryd`
Returns:
The length
• #### normalize

`public Complexd normalize()`
Normalizes this complex.
Specified by:
`normalize` in interface `Imaginaryd`
Returns:
A new complex of unit length
• #### toQuaternion

`public Quaterniond toQuaternion()`
Converts this complex to a quaternion by using (0, 0, 1) as a rotation axis.
Returns:
A quaternion of this rotation around the unit z
• #### toQuaternion

`public Quaterniond toQuaternion​(Vector3d axis)`
Converts this complex to a quaternion by using the provided vector as a rotation axis.
Parameters:
`axis` - The rotation axis
Returns:
A quaternion of this rotation around the given axis
• #### toQuaternion

```public Quaterniond toQuaternion​(float x,
float y,
float z)```
Converts this complex to a quaternion by using the provided float components vector as a rotation axis.
Parameters:
`x` - The x component of the axis vector
`y` - The y component of the axis vector
`z` - The z component of the axis vector
Returns:
A quaternion of this rotation around the given axis
• #### toQuaternion

```public Quaterniond toQuaternion​(double x,
double y,
double z)```
Converts this complex to a quaternion by using the provided double components vector as a rotation axis.
Parameters:
`x` - The x component of the axis vector
`y` - The y component of the axis vector
`z` - The z component of the axis vector
Returns:
A quaternion of this rotation around the given axis
• #### toFloat

`public Complexf toFloat()`
Specified by:
`toFloat` in interface `Imaginaryd`
• #### toDouble

`public Complexd toDouble()`
Specified by:
`toDouble` in interface `Imaginaryd`
• #### equals

`public boolean equals​(Object other)`
Overrides:
`equals` in class `Object`
• #### hashCode

`public int hashCode()`
Overrides:
`hashCode` in class `Object`
• #### compareTo

`public int compareTo​(Complexd that)`
Specified by:
`compareTo` in interface `Comparable<Complexd>`
• #### toString

`public String toString()`
Overrides:
`toString` in class `Object`
• #### fromReal

`public static Complexd fromReal​(double x)`
Creates a new complex from the double real component.

The `ZERO` constant is re-used when `x` is 0.

Parameters:
`x` - The x (real) component
Returns:
The complex created from the double real component
• #### fromImaginary

`public static Complexd fromImaginary​(double y)`
Creates a new complex from the double imaginary components.

The `ZERO` constant is re-used when `y` is 0.

Parameters:
`y` - The y (imaginary) component
Returns:
The complex created from the double imaginary component
• #### from

```public static Complexd from​(double x,
double y)```
Creates a new complex from the double components.

The `ZERO` constant is re-used when both `x` and `z` are 0.

Parameters:
`x` - The x (real) component
`y` - The y (imaginary) component
Returns:
The complex created from the double components
• #### fromRotationTo

```public static Complexd fromRotationTo​(Vector2d from,
Vector2d to)```
Creates a new complex from the angle defined from the first to the second vector.
Parameters:
`from` - The first vector
`to` - The second vector
Returns:
The complex defined by the angle between the vectors
• #### fromRotationTo

```public static Complexd fromRotationTo​(Vector3d from,
Vector3d to)```
Creates a new complex from the angle defined from the first to the second vector.
Parameters:
`from` - The first vector
`to` - The second vector
Returns:
The complex defined by the angle between the vectors
• #### fromAngleDeg

`public static Complexd fromAngleDeg​(float angle)`
Creates a new complex from the float angle in degrees.
Parameters:
`angle` - The angle in degrees
Returns:
The complex defined by the angle

`public static Complexd fromAngleRad​(float angle)`
Creates a new complex from the float angle in radians.
Parameters:
`angle` - The angle in radians
Returns:
The complex defined by the angle
• #### fromAngleDeg

`public static Complexd fromAngleDeg​(double angle)`
Creates a new complex from the double angle in radians.
Parameters:
`angle` - The angle in radians
Returns:
The complex defined by the angle
`public static Complexd fromAngleRad​(double angle)`
`angle` - The angle in radians