ComplexNumber (ojAlgo 47.2.0 API)

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

All Implemented Interfaces:

Serializable, 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>, Access1D<Double>, Access2D<Double>, Access2D.Collectable<Double,Mutate2D.Receiver<Double>>, AccessScalar<ComplexNumber>, Structure1D, Structure2D, Transformation2D<Double>, NumberContext.Enforceable<ComplexNumber>

Direct Known Subclasses:

ComplexNumber.Normalised
```
public class ComplexNumber
extends Number
implements Scalar<ComplexNumber>, NumberContext.Enforceable<ComplexNumber>, Access2D<Double>, Transformation2D<Double>, Access2D.Collectable<Double,Mutate2D.Receiver<Double>>
```
ComplexNumber is an immutable complex number class. It only implements the most basic complex number operations. ComplexFunction implements some of the more complicated ones.

Author:

apete

See Also:

ComplexFunction, Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class ComplexNumber.Normalised
- Nested classes/interfaces inherited from interface org.ojalgo.scalar.Scalar
  Scalar.Factory<N extends Number>
- Nested classes/interfaces inherited from interface org.ojalgo.algebra.ScalarOperation
  ScalarOperation.Addition<T,N extends Number>, ScalarOperation.Division<T,N extends Number>, ScalarOperation.Multiplication<T,N extends Number>, ScalarOperation.Subtraction<T,N extends Number>
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Access2D
  Access2D.Aggregatable<N extends Number>, Access2D.Collectable<N extends Number,R extends Mutate2D.Receiver<N>>, Access2D.Elements, Access2D.ElementView<N extends Number>, Access2D.IndexOf, Access2D.Sliceable<N extends Number>, Access2D.Visitable<N extends Number>
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure2D
  Structure2D.IntRowColumn, Structure2D.Logical<S extends Structure2D,B extends Structure2D.Logical<S,?>>, Structure2D.LongRowColumn, Structure2D.ReducibleTo1D<R extends Structure1D>, Structure2D.RowColumnCallback, Structure2D.RowColumnKey<R,C>, Structure2D.RowColumnMapper<R,C>
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure1D
  Structure1D.BasicMapper<T>, Structure1D.IndexCallback, Structure1D.IndexMapper<T>, Structure1D.IntIndex, Structure1D.LongIndex, Structure1D.LoopCallback

Nested Classes
Modifier and Type	Class and Description
`static class`	`ComplexNumber.Normalised`

Field Summary

Fields
Modifier and Type	Field and Description
`static Scalar.Factory<ComplexNumber>`	`FACTORY`
`double`	`i`
`static ComplexNumber`	`I` Complex number `i`, satisfies i² = -1;
`static ComplexNumber`	`INFINITY` Complex number Z = (+∞ + 0.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)
`static ComplexNumber`	`TWO` Complex number Z = (2.0 + 0.0i)
`static ComplexNumber`	`ZERO` Complex number Z = (0.0 + 0.0i)

Constructor Summary

Constructors
Constructor and Description

ComplexNumber()
Complex number constructor, returns ZERO

Constructors
Constructor and Description
`ComplexNumber()` Complex number constructor, returns `ZERO`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ComplexNumber`	`add(ComplexNumber arg)` Performs the binary operation '+' with a complex number.
`ComplexNumber`	`add(double arg)` Performs the binary operation '+' with a real number
`int`	`compareTo(ComplexNumber reference)` Compares the specified `reference` and this.
`ComplexNumber`	`conjugate()` Returns the conjugate of this complex number.
`long`	`count()` count() == countRows() * countColumns()
`long`	`countColumns()`
`long`	`countRows()`
`ComplexNumber`	`divide(ComplexNumber arg)` Performs the binary operation '/' with a complex number.
`ComplexNumber`	`divide(double arg)` Performs the binary operation '/' with a real number.
`double`	`doubleValue()`
`double`	`doubleValue(long index)`
`double`	`doubleValue(long row, long 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(Object obj)`
`float`	`floatValue()`
`ComplexNumber`	`get()`
`Double`	`get(long index)`
`Double`	`get(long row, long col)`
`double`	`getArgument()`
`double`	`getImaginary()`
`double`	`getModulus()`
`double`	`getReal()`
`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)`
`long`	`longValue()`
`static ComplexNumber`	`makePolar(double norm, double phase)` Static factory method returning a complex number from polar coordinates
`static ComplexNumber.Normalised`	`makeRotation(double angle)`
`ComplexNumber`	`multiply(ComplexNumber arg)` Performs the binary operation '*' with a complex number.
`ComplexNumber`	`multiply(double arg)` Performs the binary operation '*' with a real number.
`ComplexNumber`	`negate()` Performs the unary operation '-'.
`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.Normalised`	`signum()` `this == this.signum().multiply(this.norm())`
`ComplexNumber`	`subtract(ComplexNumber arg)` Performs the binary operation '-' with a complex number.
`ComplexNumber`	`subtract(double arg)` Performs the binary operation '-' with a real number.
`void`	`supplyTo(Mutate2D.Receiver<Double> receiver)`
`BigDecimal`	`toBigDecimal()`
`MatrixStore<Double>`	`toMultiplicationMatrix()`
`MatrixStore<Double>`	`toMultiplicationVector()`
`MatrixStore<Double>`	`toRotationMatrix()`
`String`	`toString()`
`String`	`toString(NumberContext context)`
`<T extends Mutate2D.ModifiableReceiver<Double> & Access2D<Double>> void`	`transform(T transformable)`
`static ComplexNumber`	`valueOf(double value)` Static factory method returning a complex number from a real value
`static ComplexNumber`	`valueOf(Number number)` Static factory method returning a complex number from arbitrary number

Methods inherited from class java.lang.Number
byteValue, shortValue

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

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

Methods inherited from interface org.ojalgo.structure.AccessScalar
byteValue, shortValue

Methods inherited from interface org.ojalgo.structure.Access2D
asCollectable2D, asPrimitive2D, byteValue, byteValue, columns, elements, equals, floatValue, floatValue, intValue, intValue, longValue, longValue, newPrimitiveColumnCollectable, newPrimitiveRowCollectable, rows, shortValue, shortValue, toRawCopy2D, toString, wrap, wrap

Methods inherited from interface org.ojalgo.structure.Access1D
asCollectable1D, asPrimitive1D, axpy, dot, equals, hashCode, nonzeros, supplyTo, toRawCopy1D, toString, wrap, wrap, wrap

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

Methods inherited from interface org.ojalgo.structure.Structure2D
column, column, column, column, column, count, index, index, isEmpty, isFat, isScalar, isSquare, isTall, isVector, loopAll, loopColumn, loopColumn, loopDiagonal, loopMatching, loopRow, loopRow, mapperOf, row, row, row, row, row

Methods inherited from interface org.ojalgo.structure.Structure1D
index, loopAll, loopMatching, loopRange, mapper, size

- Field Detail
  - FACTORY
```
public static final Scalar.Factory<ComplexNumber> FACTORY
```
  - I
```
public static final ComplexNumber I
```
    Complex number i, satisfies i² = -1;
  - INFINITY
```
public static final ComplexNumber INFINITY
```
    Complex number Z = (+∞ + 0.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)
  - i
```
public final double i
```
- Constructor Detail
  - ComplexNumber
```
public ComplexNumber()
```
    Complex number constructor, returns ZERO
- 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.Normalised makeRotation(double angle)
```
  - 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(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)
  - valueOf
```
public static ComplexNumber valueOf(Number 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
    
    See Also:
    
    Number, Number.doubleValue()
  - add
```
public ComplexNumber add(ComplexNumber arg)
```
    Performs the binary operation '+' with a complex number.
    
    Specified by:
    
    add in interface ScalarOperation.Addition<Scalar<ComplexNumber>,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>
    
    Parameters:
    
    arg - the real number to add
    
    Returns:
    
    a complex number Z = ((Re(this) + arg) + Im(this)i)
  - compareTo
```
public int compareTo(ComplexNumber reference)
```
    Compares the specified reference and this. The numerical comparison uses following order : |Z| -> Re(Z) -> Im(Z).
    
    Specified by:
    
    compareTo in interface Comparable<ComplexNumber>
    
    Parameters:
    
    reference - the complex number to compare with
    
    Returns:
    
    a negative value if reference is numerically greater than this, 0 if this and reference are numerically equal or a positive value if reference is numerically lesser than this.
  - 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 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
    
    Returns:
    
    The total number of elements in this structure.
  - countColumns
```
public long countColumns()
```
    Specified by:
    
    countColumns in interface Structure2D
    
    Returns:
    
    The number of columns
  - countRows
```
public long countRows()
```
    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>
    
    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>
    
    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 AccessScalar<ComplexNumber>
    
    Specified by:
    
    doubleValue in class Number
    
    See Also:
    
    Number.doubleValue()
  - doubleValue
```
public double doubleValue(long index)
```
    Specified by:
    
    doubleValue in interface Access1D<Double>
    
    Specified by:
    
    doubleValue in interface Access2D<Double>
  - doubleValue
```
public double doubleValue(long row,
                          long col)
```
    Description copied from interface: Access2D
    
    Extracts one element of this matrix as a double.
    
    Specified by:
    
    doubleValue in interface Access2D<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(Object obj)
```
    Overrides:
    
    equals in class Object
  - floatValue
```
public float floatValue()
```
    Specified by:
    
    floatValue in interface AccessScalar<ComplexNumber>
    
    Specified by:
    
    floatValue in class Number
    
    See Also:
    
    Number.floatValue()
  - get
```
public ComplexNumber get()
```
    Specified by:
    
    get in interface AccessScalar<ComplexNumber>
  - get
```
public Double get(long index)
```
    Specified by:
    
    get in interface Access1D<Double>
    
    Specified by:
    
    get in interface Access2D<Double>
  - get
```
public Double get(long row,
                  long col)
```
    Specified by:
    
    get in interface Access2D<Double>
  - getArgument
```
public double getArgument()
```
  - getImaginary
```
public double getImaginary()
```
  - getModulus
```
public double getModulus()
```
  - getReal
```
public double getReal()
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - intValue
```
public int intValue()
```
    Specified by:
    
    intValue in interface AccessScalar<ComplexNumber>
    
    Specified by:
    
    intValue in class Number
    
    See Also:
    
    Number.intValue()
  - invert
```
public ComplexNumber invert()
```
    Performs the unary operation '1/x'
    
    Specified by:
    
    invert in interface Group.Multiplicative<Scalar<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.
  - longValue
```
public long longValue()
```
    Specified by:
    
    longValue in interface AccessScalar<ComplexNumber>
    
    Specified by:
    
    longValue in class Number
    
    See Also:
    
    Number.longValue()
  - multiply
```
public ComplexNumber multiply(ComplexNumber arg)
```
    Performs the binary operation '*' with a complex number.
    
    Specified by:
    
    multiply in interface ScalarOperation.Multiplication<Scalar<ComplexNumber>,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>
    
    Parameters:
    
    arg - the real number to multiply by
    
    Returns:
    
    a complex number Z = ((Re(this) * arg) + Im(this) * arg))
  - negate
```
public ComplexNumber negate()
```
    Performs the unary operation '-'.
    
    Specified by:
    
    negate in interface Group.Additive<Scalar<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
  - signum
```
public ComplexNumber.Normalised signum()
```
    Description copied from interface: NormedVectorSpace
    
    this == this.signum().multiply(this.norm())
    
    Specified by:
    
    signum in interface NormedVectorSpace<Scalar<ComplexNumber>,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>
    
    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>
    
    Parameters:
    
    arg - the real number to subtract
    
    Returns:
    
    a complex number Z = ((Re(this) - arg) + Im(this)i)
  - supplyTo
```
public void supplyTo(Mutate2D.Receiver<Double> receiver)
```
    Specified by:
    
    supplyTo in interface Access2D.Collectable<Double,Mutate2D.Receiver<Double>>
  - toBigDecimal
```
public BigDecimal toBigDecimal()
```
    Specified by:
    
    toBigDecimal in interface Scalar<ComplexNumber>
  - toMultiplicationMatrix
```
public MatrixStore<Double> toMultiplicationMatrix()
```
  - toMultiplicationVector
```
public MatrixStore<Double> toMultiplicationVector()
```
  - toRotationMatrix
```
public MatrixStore<Double> toRotationMatrix()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
    
    See Also:
    
    Object.toString()
  - toString
```
public String toString(NumberContext context)
```
    Specified by:
    
    toString in interface Scalar<ComplexNumber>
  - transform
```
public <T extends Mutate2D.ModifiableReceiver<Double> & Access2D<Double>> void transform(T transformable)
```
    Specified by:
    
    transform in interface Transformation2D<Double>

Class ComplexNumber

Nested Class Summary

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.Access2D

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

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Number

Methods inherited from class java.lang.Object

Methods inherited from interface org.ojalgo.scalar.Scalar

Methods inherited from interface org.ojalgo.structure.AccessScalar

Methods inherited from interface org.ojalgo.structure.Access2D

Methods inherited from interface org.ojalgo.structure.Access1D

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

Methods inherited from interface org.ojalgo.structure.Structure2D

Methods inherited from interface org.ojalgo.structure.Structure1D

Field Detail

FACTORY

I

INFINITY

NaN

NEG

ONE

TWO

ZERO

i

Constructor Detail

ComplexNumber

Method Detail

isAbsolute

isInfinite

isNaN

isReal

isSmall

makePolar

makeRotation

of

valueOf

valueOf

add

add

compareTo

conjugate

count

countColumns

countRows

divide

divide

doubleValue

doubleValue

doubleValue

enforce

equals

floatValue

get

get

get

getArgument

getImaginary

getModulus

getReal

hashCode

intValue

invert

isAbsolute

isReal

isSmall

longValue

multiply

multiply

negate

norm

phase

signum

subtract

subtract

supplyTo