java.lang.Object
- org.spongepowered.math.imaginary.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 doubles. This class is immutable.

See Also:

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 Static Methods Instance Methods Concrete 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
  - add
```
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
  - add
```
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
  - add
```
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
  - angleRad
```
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|² where |a|² 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|² where a' is conjugation of a, and |a|² 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
  - fromAngleRad
```
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
  - fromAngleRad
```
public static Complexd fromAngleRad(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

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

Class Complexd

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ZERO

IDENTITY

Constructor Detail

Complexd

Complexd

Method Detail

x

y

add

add

add

sub

sub

sub

mul

mul

mul

mul

mul

div

div

div

div

div

dot

dot

dot

rotate

rotate

rotate

direction

angleRad

angleDeg

conjugate

invert

lengthSquared

length

normalize

toQuaternion

toQuaternion

toQuaternion

toQuaternion

toFloat

toDouble

equals

hashCode

compareTo

toString

fromReal

fromImaginary

from

fromRotationTo

fromRotationTo

fromAngleDeg

fromAngleRad

fromAngleDeg

fromAngleRad