java.lang.Object
- org.ojalgo.scalar.ComplexNumber

All Implemented Interfaces:

java.lang.Comparable<ComplexNumber>, Field<Scalar<ComplexNumber>>, Group, Group.Additive<Scalar<ComplexNumber>>, Group.Multiplicative<Scalar<ComplexNumber>>, NormedVectorSpace<Scalar<ComplexNumber>,ComplexNumber>, Operation, Operation.Addition<Scalar<ComplexNumber>>, Operation.Division<Scalar<ComplexNumber>>, Operation.Multiplication<Scalar<ComplexNumber>>, Operation.Subtraction<Scalar<ComplexNumber>>, Ring<Scalar<ComplexNumber>>, ScalarOperation, ScalarOperation.Addition<Scalar<ComplexNumber>,ComplexNumber>, ScalarOperation.Division<Scalar<ComplexNumber>,ComplexNumber>, ScalarOperation.Multiplication<Scalar<ComplexNumber>,ComplexNumber>, ScalarOperation.Subtraction<Scalar<ComplexNumber>,ComplexNumber>, VectorSpace<Scalar<ComplexNumber>,ComplexNumber>, Scalar<ComplexNumber>, SelfDeclaringScalar<ComplexNumber>, Access1D<java.lang.Double>, Access2D<java.lang.Double>, Access2D.Collectable<java.lang.Double,Mutate2D>, AccessScalar<ComplexNumber>, Structure1D, Structure2D, Transformation2D<java.lang.Double>, Tensor<ComplexNumber,Scalar<ComplexNumber>>, NumberContext.Enforceable<ComplexNumber>, NumberDefinition
```
public final class ComplexNumber
extends java.lang.Object
implements SelfDeclaringScalar<ComplexNumber>, Access2D<java.lang.Double>, Transformation2D<java.lang.Double>, Access2D.Collectable<java.lang.Double,Mutate2D>
```
ComplexNumber is an immutable complex number class. It only implements the most basic complex number operations. ComplexFunction implements some of the more complicated ones.

See Also:

ComplexFunction

Nested Class Summary
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Access2D
  Access2D.Aggregatable<N extends java.lang.Comparable<N>>, Access2D.Collectable<N extends java.lang.Comparable<N>,R extends Mutate2D>, Access2D.ColumnView<N extends java.lang.Comparable<N>>, Access2D.ElementView<N extends java.lang.Comparable<N>>, Access2D.RowView<N extends java.lang.Comparable<N>>, Access2D.SelectionView<N extends java.lang.Comparable<N>>, Access2D.Sliceable<N extends java.lang.Comparable<N>>, Access2D.Visitable<N extends java.lang.Comparable<N>>
- Nested classes/interfaces inherited from interface org.ojalgo.algebra.Group
  Group.Additive<T>, Group.Multiplicative<T>
- Nested classes/interfaces inherited from interface org.ojalgo.algebra.Operation
  Operation.Addition<T>, Operation.Division<T>, Operation.Multiplication<T>, Operation.Subtraction<T>
- Nested classes/interfaces inherited from interface org.ojalgo.scalar.Scalar
  Scalar.Factory<N extends java.lang.Comparable<N>>
- Nested classes/interfaces inherited from interface org.ojalgo.algebra.ScalarOperation
  ScalarOperation.Addition<T,N extends java.lang.Comparable<N>>, ScalarOperation.Division<T,N extends java.lang.Comparable<N>>, ScalarOperation.Multiplication<T,N extends java.lang.Comparable<N>>, ScalarOperation.Subtraction<T,N extends java.lang.Comparable<N>>
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure1D
  Structure1D.BasicMapper<T>, Structure1D.IndexMapper<T>, Structure1D.IntIndex, Structure1D.Logical<S extends Structure1D,B extends Structure1D.Logical<S,B>>, Structure1D.LongIndex, Structure1D.LoopCallback
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure2D
  Structure2D.IntRowColumn, Structure2D.Logical<S extends Structure2D,B extends Structure2D.Logical<S,B>>, Structure2D.LongRowColumn, Structure2D.ReducibleTo1D<R extends Structure1D>, Structure2D.Reshapable, Structure2D.RowColumnKey<R,C>, Structure2D.RowColumnMapper<R,C>

Field Summary

Fields
Modifier and Type	Field	Description
`private static double`	`ARGUMENT_TOLERANCE`
`static Scalar.Factory<ComplexNumber>`	`FACTORY`
`double`	`i`
`static ComplexNumber`	`I`	Complex number `i`, Z = (0.0 + 1.0i), satisfies i² = -1;
`static ComplexNumber`	`INFINITY`	Complex number Z = (+∞ + 0.0i)
`private static java.lang.String`	`LEFT`
`private static java.lang.String`	`MINUS`
`private boolean`	`myRealForSure`
`private double`	`myRealValue`
`static ComplexNumber`	`N`	Complex number `-i`, Z = (0.0 - 1.0i)
`static ComplexNumber`	`NaN`	Complex number Z = (NaN + NaNi)
`static ComplexNumber`	`NEG`	Complex number Z = (-1.0 + 0.0i)
`static ComplexNumber`	`ONE`	Complex number Z = (1.0 + 0.0i)
`private static java.lang.String`	`PLUS`
`private static java.lang.String`	`RIGHT`
`static ComplexNumber`	`TWO`	Complex number Z = (2.0 + 0.0i)
`static ComplexNumber`	`ZERO`	Complex number Z = (0.0 + 0.0i)

Constructor Summary

Constructors
Modifier	Constructor	Description
	`ComplexNumber()`	Complex number constructor, returns `ZERO`
`private`	`ComplexNumber(double real)`
`(package private)`	`ComplexNumber(double real, double imaginary)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`ComplexNumber`	`add(double arg)`	Performs the binary operation '+' with a real number
`ComplexNumber`	`add(ComplexNumber arg)`	Performs the binary operation '+' with a complex number.
`int`	`compareTo(ComplexNumber other)`	First compares the real values.
`ComplexNumber`	`conjugate()`	Returns the conjugate of this complex number.
`long`	`count()`	count() == countRows() * countColumns()
`long`	`countColumns()`	Only need to implement if the structure may contain more than Integer.MAX_VALUE elements.
`long`	`countRows()`	Only need to implement if the structure may contain more than Integer.MAX_VALUE elements.
`ComplexNumber`	`divide(double arg)`	Performs the binary operation '/' with a real number.
`ComplexNumber`	`divide(ComplexNumber arg)`	Performs the binary operation '/' with a complex number.
`double`	`doubleValue()`
`double`	`doubleValue(int index)`
`double`	`doubleValue(int row, int col)`	Extracts one element of this matrix as a double.
`ComplexNumber`	`enforce(NumberContext context)`	Will call NumberContext.enforce(double) on the real and imaginary parts separately.
`boolean`	`equals(java.lang.Object obj)`
`float`	`floatValue()`
`ComplexNumber`	`get()`
`java.lang.Double`	`get(long index)`
`java.lang.Double`	`get(long row, long col)`
`double`	`getArgument()`
`int`	`getColDim()`
`double`	`getImaginary()`
`double`	`getModulus()`
`double`	`getReal()`
`int`	`getRowDim()`
`int`	`hashCode()`
`int`	`intValue()`
`ComplexNumber`	`invert()`	Performs the unary operation '1/x'
`boolean`	`isAbsolute()`
`static boolean`	`isAbsolute(ComplexNumber value)`
`static boolean`	`isInfinite(ComplexNumber value)`	Test if `value` is infinite.
`static boolean`	`isNaN(ComplexNumber value)`	Test if `value` is NaN.
`boolean`	`isReal()`
`static boolean`	`isReal(ComplexNumber value)`	Test if `value` is real.
`boolean`	`isSmall(double comparedTo)`
`static boolean`	`isSmall(double comparedTo, ComplexNumber value)`
`boolean`	`isZero()`	Tests if this scalar value is exactly zero.
`long`	`longValue()`
`static ComplexNumber`	`makePolar(double norm, double phase)`	Static factory method returning a complex number from polar coordinates
`static ComplexNumber`	`makeRotation(double angle)`
`ComplexNumber`	`multiply(double arg)`	Performs the binary operation '*' with a real number.
`ComplexNumber`	`multiply(ComplexNumber arg)`	Performs the binary operation '*' with a complex number.
`double`	`multiplyIm(double argRe, double argIm)`	The imaginary part of the complex number resulting when multiplying this with a complex number whose real and imaginary parts are argRe and argIm.
`double`	`multiplyRe(double argRe, double argIm)`	The real part of the complex number resulting when multiplying this with a complex number whose real and imaginary parts are argRe and argIm.
`ComplexNumber`	`negate()`	Performs the unary operation '-'.
`static ComplexNumber`	`newUnitRoot(int nbRoots)`
`static ComplexNumber[]`	`newUnitRoots(int nbRoots)`
`double`	`norm()`	Returns the norm of this complex number.
`static ComplexNumber`	`of(double real, double imaginary)`	Static factory method returning a complex number from cartesian coordinates.
`double`	`phase()`	Returns the phase of this complex number.
`ComplexNumber`	`power(int power)`	Multiply by itself `power` times.
`ComplexNumber`	`signum()`	`this == this.signum().multiply(this.norm())`
`ComplexNumber`	`subtract(double arg)`	Performs the binary operation '-' with a real number.
`ComplexNumber`	`subtract(ComplexNumber arg)`	Performs the binary operation '-' with a complex number.
`void`	`supplyTo(Mutate2D receiver)`
`java.math.BigDecimal`	`toBigDecimal()`
`MatrixStore<java.lang.Double>`	`toMultiplicationMatrix()`
`MatrixStore<java.lang.Double>`	`toMultiplicationVector()`
`MatrixStore<java.lang.Double>`	`toRotationMatrix()`
`java.lang.String`	`toString()`
`java.lang.String`	`toString(NumberContext context)`
`<T extends Mutate2D.ModifiableReceiver<java.lang.Double>> void`	`transform(T transformable)`
`(package private) <T extends Mutate2D.ModifiableReceiver<java.lang.Double>> void`	`transformWhenUnit(T transformable)`
`static ComplexNumber`	`valueOf(double value)`	Static factory method returning a complex number from a real value
`static ComplexNumber`	`valueOf(java.lang.Comparable<?> number)`	Static factory method returning a complex number from arbitrary number

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.ojalgo.structure.Access1D
asCollectable1D, asKeyed1D, asList, axpy, dot, select, supplyTo, toList, toRawCopy1D

Methods inherited from interface org.ojalgo.structure.Access2D
asCollectable2D, asKeyed2D, byteValue, byteValue, byteValue, byteValue, columns, columns, columns, doubleValue, doubleValue, elements, floatValue, floatValue, floatValue, floatValue, intValue, intValue, intValue, intValue, longValue, longValue, longValue, longValue, nonzeros, rows, rows, rows, select, select, shortValue, shortValue, shortValue, shortValue, toRawCopy2D

Methods inherited from interface org.ojalgo.structure.Access2D.Collectable
collect

Methods inherited from interface org.ojalgo.type.NumberDefinition
booleanValue, byteValue, shortValue

Methods inherited from interface org.ojalgo.scalar.Scalar
add, dimensions, divide, multiply, rank, subtract, toPlainString

Methods inherited from interface org.ojalgo.scalar.SelfDeclaringScalar
add, divide, multiply, subtract

Methods inherited from interface org.ojalgo.structure.Structure2D
firstInColumn, firstInRow, getMaxDim, getMinDim, isEmpty, isFat, isScalar, isSquare, isTall, isVector, limitOfColumn, limitOfRow, size

Methods inherited from interface org.ojalgo.tensor.Tensor
components, isSameShape

- Field Detail
  - FACTORY
```
public static final Scalar.Factory<ComplexNumber> FACTORY
```
  - I
```
public static final ComplexNumber I
```
    Complex number i, Z = (0.0 + 1.0i), satisfies i² = -1;
  - INFINITY
```
public static final ComplexNumber INFINITY
```
    Complex number Z = (+∞ + 0.0i)
  - N
```
public static final ComplexNumber N
```
    Complex number -i, Z = (0.0 - 1.0i)
  - NaN
```
public static final ComplexNumber NaN
```
    Complex number Z = (NaN + NaNi)
  - NEG
```
public static final ComplexNumber NEG
```
    Complex number Z = (-1.0 + 0.0i)
  - ONE
```
public static final ComplexNumber ONE
```
    Complex number Z = (1.0 + 0.0i)
  - TWO
```
public static final ComplexNumber TWO
```
    Complex number Z = (2.0 + 0.0i)
  - ZERO
```
public static final ComplexNumber ZERO
```
    Complex number Z = (0.0 + 0.0i)
  - ARGUMENT_TOLERANCE
```
private static final double ARGUMENT_TOLERANCE
```
  - LEFT
```
private static final java.lang.String LEFT
```
    See Also:
    
    Constant Field Values
  - MINUS
```
private static final java.lang.String MINUS
```
    See Also:
    
    Constant Field Values
  - PLUS
```
private static final java.lang.String PLUS
```
    See Also:
    
    Constant Field Values
  - RIGHT
```
private static final java.lang.String RIGHT
```
    See Also:
    
    Constant Field Values
  - i
```
public final double i
```
  - myRealForSure
```
private final boolean myRealForSure
```
  - myRealValue
```
private final double myRealValue
```
- Constructor Detail
  - ComplexNumber
```
public ComplexNumber()
```
    Complex number constructor, returns ZERO
  - ComplexNumber
```
private ComplexNumber(double real)
```
  - ComplexNumber
```
ComplexNumber(double real,
              double imaginary)
```
- Method Detail
  - isAbsolute
```
public static boolean isAbsolute(ComplexNumber value)
```
  - isInfinite
```
public static boolean isInfinite(ComplexNumber value)
```
    Test if value is infinite. A complex number is infinite if its real part and/or its imaginary part is infinite.
    
    Parameters:
    
    value - the complex number to test
    
    Returns:
    
    true if the specified value is infinite (real and/or imaginary part) otherwise false
  - isNaN
```
public static boolean isNaN(ComplexNumber value)
```
    Test if value is NaN. A complex number is NaN if its real and/or its imaginary part is NaN.
    
    Parameters:
    
    value - the complex number to test
    
    Returns:
    
    true if the specified value is NaN (real and/or imaginary part) otherwise false
  - isReal
```
public static boolean isReal(ComplexNumber value)
```
    Test if value is real. A complex number Z is real if and only if Im(Z) = 0.0.
    
    Parameters:
    
    value - the complex number to test
    
    Returns:
    
    true if the imaginary part of the specified value is null otherwise false
  - isSmall
```
public static boolean isSmall(double comparedTo,
                              ComplexNumber value)
```
  - makePolar
```
public static ComplexNumber makePolar(double norm,
                                      double phase)
```
    Static factory method returning a complex number from polar coordinates
    
    Parameters:
    
    norm - the complex number's norm
    
    phase - the complex number's phase
    
    Returns:
    
    a complex number
  - makeRotation
```
public static ComplexNumber makeRotation(double angle)
```
  - newUnitRoot
```
public static ComplexNumber newUnitRoot(int nbRoots)
```
  - newUnitRoots
```
public static ComplexNumber[] newUnitRoots(int nbRoots)
```
  - of
```
public static ComplexNumber of(double real,
                               double imaginary)
```
    Static factory method returning a complex number from cartesian coordinates.
    
    Parameters:
    
    real - the complex number's real part
    
    imaginary - the complex number's imaginary part
    
    Returns:
    
    a complex number
  - valueOf
```
public static ComplexNumber valueOf(java.lang.Comparable<?> number)
```
    Static factory method returning a complex number from arbitrary number
    
    Parameters:
    
    number - a numeric value
    
    Returns:
    
    ZERO if number is null otherwise the double value of number
  - valueOf
```
public static ComplexNumber valueOf(double value)
```
    Static factory method returning a complex number from a real value
    
    Parameters:
    
    value - the complex number's real part
    
    Returns:
    
    a complex number Z = (value + 0.0i)
  - add
```
public ComplexNumber add(ComplexNumber arg)
```
    Performs the binary operation '+' with a complex number.
    
    Specified by:
    
    add in interface ScalarOperation.Addition<Scalar<ComplexNumber>,ComplexNumber>
    
    Specified by:
    
    add in interface SelfDeclaringScalar<ComplexNumber>
    
    Parameters:
    
    arg - the complex number to add
    
    Returns:
    
    a complex number Z = ((Re(this) + Re(arg)) + (Im(this) + Im(arg))i)
  - add
```
public ComplexNumber add(double arg)
```
    Performs the binary operation '+' with a real number
    
    Specified by:
    
    add in interface ScalarOperation.Addition<Scalar<ComplexNumber>,ComplexNumber>
    
    Specified by:
    
    add in interface SelfDeclaringScalar<ComplexNumber>
    
    Parameters:
    
    arg - the real number to add
    
    Returns:
    
    a complex number Z = ((Re(this) + arg) + Im(this)i)
  - compareTo
```
public int compareTo(ComplexNumber other)
```
    First compares the real values. Only if they are equal will compare the imaginary part.
    
    Specified by:
    
    compareTo in interface java.lang.Comparable<ComplexNumber>
  - conjugate
```
public ComplexNumber conjugate()
```
    Returns the conjugate of this complex number. A complex number conjugate is its reflexion about the real axis.
    
    Specified by:
    
    conjugate in interface SelfDeclaringScalar<ComplexNumber>
    
    Specified by:
    
    conjugate in interface VectorSpace<Scalar<ComplexNumber>,ComplexNumber>
    
    Returns:
    
    a complex number Z = (Re(this) - Im(this)i)
  - count
```
public long count()
```
    Description copied from interface: Structure2D
    
    count() == countRows() * countColumns()
    
    Specified by:
    
    count in interface Structure1D
    
    Specified by:
    
    count in interface Structure2D
  - countColumns
```
public long countColumns()
```
    Description copied from interface: Structure2D
    
    Only need to implement if the structure may contain more than Integer.MAX_VALUE elements.
    
    Specified by:
    
    countColumns in interface Structure2D
    
    Returns:
    
    The number of columns
  - countRows
```
public long countRows()
```
    Description copied from interface: Structure2D
    
    Only need to implement if the structure may contain more than Integer.MAX_VALUE elements.
    
    Specified by:
    
    countRows in interface Structure2D
    
    Returns:
    
    The number of rows
  - divide
```
public ComplexNumber divide(ComplexNumber arg)
```
    Performs the binary operation '/' with a complex number.
    
    Specified by:
    
    divide in interface ScalarOperation.Division<Scalar<ComplexNumber>,ComplexNumber>
    
    Specified by:
    
    divide in interface SelfDeclaringScalar<ComplexNumber>
    
    Parameters:
    
    arg - the complex number to divide by
    
    Returns:
    
    a complex number Z = this / arg
  - divide
```
public ComplexNumber divide(double arg)
```
    Performs the binary operation '/' with a real number.
    
    Specified by:
    
    divide in interface ScalarOperation.Division<Scalar<ComplexNumber>,ComplexNumber>
    
    Specified by:
    
    divide in interface SelfDeclaringScalar<ComplexNumber>
    
    Parameters:
    
    arg - the real number to divide by
    
    Returns:
    
    a complex number Z = ((Re(this) / arg) + (Im(this) / arg)i)
  - doubleValue
```
public double doubleValue()
```
    Specified by:
    
    doubleValue in interface NumberDefinition
  - doubleValue
```
public double doubleValue(int index)
```
    Specified by:
    
    doubleValue in interface Access1D<java.lang.Double>
    
    Specified by:
    
    doubleValue in interface Access2D<java.lang.Double>
  - doubleValue
```
public double doubleValue(int row,
                          int col)
```
    Description copied from interface: Access2D
    
    Extracts one element of this matrix as a double.
    
    Specified by:
    
    doubleValue in interface Access2D<java.lang.Double>
    
    Parameters:
    
    row - A row index.
    
    col - A column index.
    
    Returns:
    
    One matrix element
  - enforce
```
public ComplexNumber enforce(NumberContext context)
```
    Will call NumberContext.enforce(double) on the real and imaginary parts separately.
    
    Specified by:
    
    enforce in interface NumberContext.Enforceable<ComplexNumber>
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - floatValue
```
public float floatValue()
```
    Specified by:
    
    floatValue in interface NumberDefinition
  - get
```
public ComplexNumber get()
```
    Specified by:
    
    get in interface AccessScalar<ComplexNumber>
  - get
```
public java.lang.Double get(long index)
```
    Specified by:
    
    get in interface Access1D<java.lang.Double>
    
    Specified by:
    
    get in interface Access2D<java.lang.Double>
  - get
```
public java.lang.Double get(long row,
                            long col)
```
    Specified by:
    
    get in interface Access2D<java.lang.Double>
  - getArgument
```
public double getArgument()
```
  - getColDim
```
public int getColDim()
```
    Specified by:
    
    getColDim in interface Structure2D
    
    Returns:
    
    The number of columns
  - getImaginary
```
public double getImaginary()
```
  - getModulus
```
public double getModulus()
```
  - getReal
```
public double getReal()
```
  - getRowDim
```
public int getRowDim()
```
    Specified by:
    
    getRowDim in interface Structure2D
    
    Returns:
    
    The number of rows
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - intValue
```
public int intValue()
```
    Specified by:
    
    intValue in interface NumberDefinition
  - invert
```
public ComplexNumber invert()
```
    Performs the unary operation '1/x'
    
    Specified by:
    
    invert in interface Group.Multiplicative<Scalar<ComplexNumber>>
    
    Specified by:
    
    invert in interface SelfDeclaringScalar<ComplexNumber>
    
    Returns:
    
    the complex number Z inverse of this, satisfies Z * this = 1
  - isAbsolute
```
public boolean isAbsolute()
```
    Specified by:
    
    isAbsolute in interface Scalar<ComplexNumber>
    
    Returns:
    
    true if this is equal to its own norm, modulus or absolute value (non-negative real part and no imaginary part); otherwise false.
    
    See Also:
    
    Scalar.isAbsolute()
  - isReal
```
public boolean isReal()
```
  - isSmall
```
public boolean isSmall(double comparedTo)
```
    Specified by:
    
    isSmall in interface NormedVectorSpace<Scalar<ComplexNumber>,ComplexNumber>
    
    Parameters:
    
    comparedTo - What to compare with
    
    Returns:
    
    true if this is small compared to the magnitude of the input reference value.
  - isZero
```
public boolean isZero()
```
    Description copied from interface: Scalar
    Tests if this scalar value is exactly zero.
    Each implementation should test for zero as exactly as possible based on what's achievable with that specific scalar type. The purpose is NOT to have similar behavior between different implementations, but rather to leverage the full precision and capabilities of each type.
    
    For example:
    
    Primitive types (like double) should use exact equality comparison
    
    High-precision types (like Quadruple) should check both base and remainder components
    
    Arbitrary-precision types (like BigDecimal) should use their built-in zero detection
    
    Complex types should check both real and imaginary parts
    
    This method should NOT use tolerance-based comparisons or approximate zero detection, as those are better handled by context-aware methods like NormedVectorSpace.isSmall(double).
    Specified by:
    
    isZero in interface Scalar<ComplexNumber>
    
    Returns:
    
    true if this scalar represents exactly zero, false otherwise
    
    See Also:
    
    NormedVectorSpace.isSmall(double)
  - longValue
```
public long longValue()
```
    Specified by:
    
    longValue in interface NumberDefinition
  - multiply
```
public ComplexNumber multiply(ComplexNumber arg)
```
    Performs the binary operation '*' with a complex number.
    
    Specified by:
    
    multiply in interface ScalarOperation.Multiplication<Scalar<ComplexNumber>,ComplexNumber>
    
    Specified by:
    
    multiply in interface SelfDeclaringScalar<ComplexNumber>
    
    Parameters:
    
    arg - the complex number to multiply by
    
    Returns:
    
    a complex number Z = this * arg
  - multiply
```
public ComplexNumber multiply(double arg)
```
    Performs the binary operation '*' with a real number.
    
    Specified by:
    
    multiply in interface ScalarOperation.Multiplication<Scalar<ComplexNumber>,ComplexNumber>
    
    Specified by:
    
    multiply in interface SelfDeclaringScalar<ComplexNumber>
    
    Parameters:
    
    arg - the real number to multiply by
    
    Returns:
    
    a complex number Z = ((Re(this) * arg) + Im(this) * arg))
  - multiplyIm
```
public double multiplyIm(double argRe,
                         double argIm)
```
    The imaginary part of the complex number resulting when multiplying this with a complex number whose real and imaginary parts are argRe and argIm.
  - multiplyRe
```
public double multiplyRe(double argRe,
                         double argIm)
```
    The real part of the complex number resulting when multiplying this with a complex number whose real and imaginary parts are argRe and argIm.
  - negate
```
public ComplexNumber negate()
```
    Performs the unary operation '-'.
    
    Specified by:
    
    negate in interface Group.Additive<Scalar<ComplexNumber>>
    
    Specified by:
    
    negate in interface SelfDeclaringScalar<ComplexNumber>
    
    Returns:
    
    a complex number Z = -this
  - norm
```
public double norm()
```
    Returns the norm of this complex number. The norm of a complex number is defined by |Z| = (ZZ^*)^1/2.
    
    Specified by:
    
    norm in interface NormedVectorSpace<Scalar<ComplexNumber>,ComplexNumber>
    
    Returns:
    
    the norm of this complex number.
  - phase
```
public double phase()
```
    Returns the phase of this complex number. The phase of a complex number Z is the angle between the positive real axis and the straight line defined by origin and Z in complex plane.
    
    Returns:
    
    the phase of this complex number
  - power
```
public ComplexNumber power(int power)
```
    Description copied from interface: Operation.Multiplication
    
    Multiply by itself power times.
    
    Specified by:
    
    power in interface Operation.Multiplication<Scalar<ComplexNumber>>
    
    Specified by:
    
    power in interface SelfDeclaringScalar<ComplexNumber>
  - signum
```
public ComplexNumber signum()
```
    Description copied from interface: NormedVectorSpace
    
    this == this.signum().multiply(this.norm())
    
    Specified by:
    
    signum in interface NormedVectorSpace<Scalar<ComplexNumber>,ComplexNumber>
    
    Specified by:
    
    signum in interface SelfDeclaringScalar<ComplexNumber>
    
    Returns:
    
    A unit "vector"
  - subtract
```
public ComplexNumber subtract(ComplexNumber arg)
```
    Performs the binary operation '-' with a complex number.
    
    Specified by:
    
    subtract in interface ScalarOperation.Subtraction<Scalar<ComplexNumber>,ComplexNumber>
    
    Specified by:
    
    subtract in interface SelfDeclaringScalar<ComplexNumber>
    
    Parameters:
    
    arg - the complex number to subtract
    
    Returns:
    
    a complex number Z = this - arg
  - subtract
```
public ComplexNumber subtract(double arg)
```
    Performs the binary operation '-' with a real number.
    
    Specified by:
    
    subtract in interface ScalarOperation.Subtraction<Scalar<ComplexNumber>,ComplexNumber>
    
    Specified by:
    
    subtract in interface SelfDeclaringScalar<ComplexNumber>
    
    Parameters:
    
    arg - the real number to subtract
    
    Returns:
    
    a complex number Z = ((Re(this) - arg) + Im(this)i)
  - supplyTo
```
public void supplyTo(Mutate2D receiver)
```
    Specified by:
    
    supplyTo in interface Access2D.Collectable<java.lang.Double,Mutate2D>
  - toBigDecimal
```
public java.math.BigDecimal toBigDecimal()
```
    Specified by:
    
    toBigDecimal in interface Scalar<ComplexNumber>
  - toMultiplicationMatrix
```
public MatrixStore<java.lang.Double> toMultiplicationMatrix()
```
  - toMultiplicationVector
```
public MatrixStore<java.lang.Double> toMultiplicationVector()
```
  - toRotationMatrix
```
public MatrixStore<java.lang.Double> toRotationMatrix()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
    
    See Also:
    
    Object.toString()
  - toString
```
public java.lang.String toString(NumberContext context)
```
    Specified by:
    
    toString in interface Scalar<ComplexNumber>
  - transform
```
public <T extends Mutate2D.ModifiableReceiver<java.lang.Double>> void transform(T transformable)
```
    Specified by:
    
    transform in interface Transformation2D<java.lang.Double>
  - transformWhenUnit
```
<T extends Mutate2D.ModifiableReceiver<java.lang.Double>> void transformWhenUnit(T transformable)
```

Class ComplexNumber

Nested Class Summary

Nested classes/interfaces inherited from interface org.ojalgo.structure.Access2D

Nested classes/interfaces inherited from interface org.ojalgo.algebra.Group

Nested classes/interfaces inherited from interface org.ojalgo.algebra.Operation

Nested classes/interfaces inherited from interface org.ojalgo.scalar.Scalar

Nested classes/interfaces inherited from interface org.ojalgo.algebra.ScalarOperation

Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure1D

Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure2D

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.ojalgo.structure.Access1D

Methods inherited from interface org.ojalgo.structure.Access2D

Methods inherited from interface org.ojalgo.structure.Access2D.Collectable

Methods inherited from interface org.ojalgo.type.NumberDefinition

Methods inherited from interface org.ojalgo.scalar.Scalar

Methods inherited from interface org.ojalgo.scalar.SelfDeclaringScalar

Methods inherited from interface org.ojalgo.structure.Structure2D

Methods inherited from interface org.ojalgo.tensor.Tensor

Field Detail

FACTORY

I

INFINITY

N

NaN

NEG

ONE

TWO

ZERO

ARGUMENT_TOLERANCE

LEFT

MINUS

PLUS

RIGHT

i

myRealForSure

myRealValue

Constructor Detail

ComplexNumber

ComplexNumber

ComplexNumber

Method Detail

isAbsolute

isInfinite

isNaN

isReal

isSmall

makePolar

makeRotation

newUnitRoot

newUnitRoots

of

valueOf

valueOf

add

add

compareTo

conjugate

count

countColumns

countRows

divide

divide

doubleValue

doubleValue

doubleValue

enforce

equals

floatValue

get

get

get

getArgument

getColDim

getImaginary

getModulus

getReal

getRowDim