java.lang.Object
- org.spongepowered.math.imaginary.Complexf

All Implemented Interfaces:

Serializable, Comparable<Complexf>, Imaginaryf
```
@Immutable
public final class Complexf
extends Object
implements Imaginaryf, Comparable<Complexf>, Serializable
```
Represent a complex number of the form x + yi. The x and y components are stored as floats. This class is immutable.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type Field Description

static Complexf IDENTITY
An immutable identity (1, 0) complex.

static Complexf ZERO
An immutable identity (0, 0) complex.

Constructor Summary

Constructors
Constructor	Description
`Complexf(double x, double y)`	Constructs a new complex from the double components.
`Complexf(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
`Complexf`	`add(double x, double y)`	Adds the double components of another complex to this one.
`Complexf`	`add(float x, float y)`	Adds the float components of another complex to this one.
`Complexf`	`add(Complexf c)`	Adds another complex to this one.
`float`	`angleDeg()`	Returns the angle in degrees formed by the direction vector of this complex on the complex plane.
`float`	`angleRad()`	Returns the angle in radians formed by the direction vector of this complex on the complex plane.
`int`	`compareTo(Complexf that)`
`Complexf`	`conjugate()`	Returns the conjugate of this complex.
`Vector2f`	`direction()`	Returns a unit vector pointing in the same direction as this complex on the complex plane.
`Complexf`	`div(double a)`	Divides the components of this complex by a double scalar.
`Complexf`	`div(double x, double y)`	Divides this complex by the double components of another one.
`Complexf`	`div(float a)`	Divides the components of this complex by a float scalar.
`Complexf`	`div(float x, float y)`	Divides this complex by the float components of another one.
`Complexf`	`div(Complexf c)`	Divides this complex by another one.
`float`	`dot(double x, double y)`	Returns the dot product of this complex with the double components of another one.
`float`	`dot(float x, float y)`	Returns the dot product of this complex with the float components of another one.
`float`	`dot(Complexf c)`	Returns the dot product of this complex with another one.
`boolean`	`equals(Object other)`
`static Complexf`	`from(float x, float y)`	Creates a new complex from the float components.
`static Complexf`	`fromAngleDeg(double angle)`	Creates a new complex from the double angle in degrees.
`static Complexf`	`fromAngleDeg(float angle)`	Creates a new complex from the float angle in radians.
`static Complexf`	`fromAngleRad(double angle)`	Creates a new complex from the double angle in radians.
`static Complexf`	`fromAngleRad(float angle)`	Creates a new complex from the float angle in radians.
`static Complexf`	`fromImaginary(float y)`	Creates a new complex from the float imaginary components.
`static Complexf`	`fromReal(float x)`	Creates a new complex from the float real component.
`static Complexf`	`fromRotationTo(Vector2f from, Vector2f to)`	Creates a new complex from the angle defined from the first to the second vector.
`static Complexf`	`fromRotationTo(Vector3f from, Vector3f to)`	Creates a new complex from the angle defined from the first to the second vector.
`int`	`hashCode()`
`Complexf`	`invert()`	Returns the inverse of this complex.
`float`	`length()`	Returns the length of this complex.
`float`	`lengthSquared()`	Returns the square of the length of this complex.
`Complexf`	`mul(double a)`	Multiplies the components of this complex by a double scalar.
`Complexf`	`mul(double x, double y)`	Multiplies the double components of another complex with this one.
`Complexf`	`mul(float a)`	Multiplies the components of this complex by a float scalar.
`Complexf`	`mul(float x, float y)`	Multiplies the float components of another complex with this one.
`Complexf`	`mul(Complexf c)`	Multiplies another complex with this one.
`Complexf`	`normalize()`	Normalizes this complex.
`Vector2f`	`rotate(double x, double y)`	Rotates the double components of a vector by this complex.
`Vector2f`	`rotate(float x, float y)`	Rotates the float components of a vector by this complex.
`Vector2f`	`rotate(Vector2f v)`	Rotates a vector by this complex.
`Complexf`	`sub(double x, double y)`	Subtracts the double components of another complex from this one.
`Complexf`	`sub(float x, float y)`	Subtracts the float components of another complex from this one.
`Complexf`	`sub(Complexf c)`	Subtracts another complex from this one.
`Complexd`	`toDouble()`
`Complexf`	`toFloat()`
`Quaternionf`	`toQuaternion()`	Converts this complex to a quaternion by using (0, 0, 1) as a rotation axis.
`Quaternionf`	`toQuaternion(double x, double y, double z)`	Converts this complex to a quaternion by using the provided double components vector as a rotation axis.
`Quaternionf`	`toQuaternion(float x, float y, float z)`	Converts this complex to a quaternion by using the provided float components vector as a rotation axis.
`Quaternionf`	`toQuaternion(Vector3f axis)`	Converts this complex to a quaternion by using the provided vector as a rotation axis.
`String`	`toString()`
`float`	`x()`	Gets the x (real) component of this complex.
`float`	`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 Complexf ZERO
```
    An immutable identity (0, 0) complex.
  - IDENTITY
```
public static final Complexf IDENTITY
```
    An immutable identity (1, 0) complex.
- Constructor Detail
  - Complexf
```
public Complexf(double x,
                double y)
```
    Constructs a new complex from the double components.
    
    Parameters:
    
    x - The x (real) component
    
    y - The y (imaginary) component
  - Complexf
```
public Complexf(float x,
                float y)
```
    Constructs a new complex from the float components.
    
    Parameters:
    
    x - The x (real) component
    
    y - The y (imaginary) component
- Method Detail
  - x
```
public float x()
```
    Gets the x (real) component of this complex.
    
    Returns:
    
    The x (real) component
  - y
```
public float y()
```
    Gets the y (imaginary) component of this complex.
    
    Returns:
    
    The y (imaginary) component
  - add
```
public Complexf add(Complexf 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 Complexf 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
  - add
```
public Complexf 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
  - sub
```
public Complexf sub(Complexf 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 Complexf 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
  - sub
```
public Complexf 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
  - mul
```
public Complexf mul(double a)
```
    Multiplies the components of this complex by a double scalar.
    
    Parameters:
    
    a - The multiplication scalar
    
    Returns:
    
    A new complex, which has each component multiplied by the scalar
  - mul
```
public Complexf mul(float a)
```
    Multiplies the components of this complex by a float scalar.
    
    Specified by:
    
    mul in interface Imaginaryf
    
    Parameters:
    
    a - The multiplication scalar
    
    Returns:
    
    A new complex, which has each component multiplied by the scalar
  - mul
```
public Complexf mul(Complexf 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 Complexf 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
  - mul
```
public Complexf 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
  - div
```
public Complexf div(double a)
```
    Divides the components of this complex by a double scalar.
    
    Parameters:
    
    a - The division scalar
    
    Returns:
    
    A new complex, which has each component divided by the scalar
  - div
```
public Complexf div(float a)
```
    Divides the components of this complex by a float scalar.
    
    Specified by:
    
    div in interface Imaginaryf
    
    Parameters:
    
    a - The division scalar
    
    Returns:
    
    A new complex, which has each component divided by the scalar
  - div
```
public Complexf div(Complexf c)
```
    Divides this complex by another one.
    
    Parameters:
    
    c - The complex to divide with
    
    Returns:
    
    The quotient of the two complexes
  - div
```
public Complexf 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
  - div
```
public Complexf 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
  - dot
```
public float dot(Complexf 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 float 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
  - dot
```
public float 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
  - rotate
```
public Vector2f rotate(Vector2f v)
```
    Rotates a vector by this complex.
    
    Parameters:
    
    v - The vector to rotate
    
    Returns:
    
    The rotated vector
  - rotate
```
public Vector2f 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
  - rotate
```
public Vector2f 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
  - direction
```
public Vector2f 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 float 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 float 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 Complexf 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 Imaginaryf
    
    Returns:
    
    A new complex, which is the conjugate of this one
  - invert
```
public Complexf 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 Imaginaryf
    
    Returns:
    
    A new complex, which is the inverse of this one
  - lengthSquared
```
public float lengthSquared()
```
    Returns the square of the length of this complex.
    
    Specified by:
    
    lengthSquared in interface Imaginaryf
    
    Returns:
    
    The square of the length
  - length
```
public float length()
```
    Returns the length of this complex.
    
    Specified by:
    
    length in interface Imaginaryf
    
    Returns:
    
    The length
  - normalize
```
public Complexf normalize()
```
    Normalizes this complex.
    
    Specified by:
    
    normalize in interface Imaginaryf
    
    Returns:
    
    A new complex of unit length
  - toQuaternion
```
public Quaternionf 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 Quaternionf toQuaternion(Vector3f 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 Quaternionf 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
  - toQuaternion
```
public Quaternionf 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
  - toFloat
```
public Complexf toFloat()
```
    Specified by:
    
    toFloat in interface Imaginaryf
  - toDouble
```
public Complexd toDouble()
```
    Specified by:
    
    toDouble in interface Imaginaryf
  - equals
```
public boolean equals(Object other)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - compareTo
```
public int compareTo(Complexf that)
```
    Specified by:
    
    compareTo in interface Comparable<Complexf>
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - fromReal
```
public static Complexf fromReal(float x)
```
    Creates a new complex from the float real component.
    The ZERO constant is re-used when x is 0.
    
    Parameters:
    
    x - The x (real) component
    
    Returns:
    
    The complex created from the float real component
  - fromImaginary
```
public static Complexf fromImaginary(float y)
```
    Creates a new complex from the float imaginary components.
    The ZERO constant is re-used when y is 0.
    
    Parameters:
    
    y - The y (imaginary) component
    
    Returns:
    
    The complex created from the float imaginary component
  - from
```
public static Complexf from(float x,
                            float y)
```
    Creates a new complex from the float 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 float components
  - fromRotationTo
```
public static Complexf fromRotationTo(Vector2f from,
                                      Vector2f 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 Complexf fromRotationTo(Vector3f from,
                                      Vector3f 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 Complexf fromAngleDeg(double angle)
```
    Creates a new complex from the double angle in degrees.
    
    Parameters:
    
    angle - The angle in degrees
    
    Returns:
    
    The complex defined by the angle
  - fromAngleRad
```
public static Complexf 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
  - fromAngleDeg
```
public static Complexf fromAngleDeg(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
  - fromAngleRad
```
public static Complexf 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

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

Class Complexf

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ZERO

IDENTITY

Constructor Detail

Complexf

Complexf

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