BaseComplexFloat (nd4j-api 0.0.3.5.5.3 API)

java.lang.Object
- org.nd4j.linalg.api.complex.BaseComplexFloat

All Implemented Interfaces:

IComplexFloat, IComplexNumber
```
public abstract class BaseComplexFloat
extends Object
implements IComplexFloat
```
Base complex float class

Author:

Adam Gibson

Field Summary

Fields
Modifier and Type Field and Description

protected float imag

protected float real

Fields
Modifier and Type	Field and Description
`protected float`	`imag`
`protected float`	`real`

Constructor Summary

Constructors
Constructor and Description
`BaseComplexFloat()`
`BaseComplexFloat(float real)`
`BaseComplexFloat(float real, float imag)`
`BaseComplexFloat(Float real, Float imag)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Float`	`absoluteValue()` Return the absolute value
`IComplexNumber`	`add(IComplexNumber c)` Add two complex numbers.
`IComplexNumber`	`add(Number c)` Add a realComponent number to a complex number.
`IComplexNumber`	`addi(IComplexNumber c)` Add two complex numbers in-place storing the result in this.
`IComplexNumber`	`addi(IComplexNumber c, IComplexNumber result)` Add two complex numbers in-place
`IComplexNumber`	`addi(Number c)` Add a realComponent number to complex number in-place, storing the result in this.
`IComplexNumber`	`addi(Number a, IComplexNumber result)` Add a realComponent number to a complex number in-place.
`IComplexDouble`	`asDouble()` Convert to a double
`IComplexFloat`	`asFloat()` Convert to a float
`Float`	`complexArgument()` Returns the argument of a complex number.
`IComplexNumber`	`conj()` The conjugate of this number
`IComplexFloat`	`conji()` The inplace conjugate of this number
`IComplexNumber`	`copy(IComplexNumber other)`
`IComplexNumber`	`div(float v)`
`IComplexNumber`	`div(IComplexNumber c)` Divide two complex numbers
`IComplexNumber`	`div(Number v)`
`IComplexFloat`	`divi(float v)`
`IComplexNumber`	`divi(IComplexNumber c)`
`IComplexNumber`	`divi(IComplexNumber c, IComplexNumber result)` Divide two complex numbers, in-place
`IComplexNumber`	`divi(Number v)`
`IComplexNumber`	`divi(Number v, IComplexNumber result)`
`boolean`	`eq(IComplexNumber c)`
`IComplexNumber`	`eqc(IComplexNumber num)` Equals returning a complex number
`boolean`	`equals(Object o)`
`IComplexNumber`	`gt(IComplexNumber num)` Greater than returning a complex number
`int`	`hashCode()`
`Float`	`imaginaryComponent()` The imaginary component of this number
`IComplexNumber`	`inv()`
`IComplexFloat`	`invi()`
`boolean`	`isImag()` Returns whether the number only has a imaginary component (0 for real)
`boolean`	`isReal()` Returns whether the number only has a real component (0 for imaginary)
`boolean`	`isZero()` Whether this number is wholly zero or not
`IComplexNumber`	`lt(IComplexNumber num)` Less than returning a complex number
`IComplexNumber`	`mul(IComplexNumber c)` Multiply two complex numbers
`IComplexNumber`	`mul(Number v)`
`IComplexNumber`	`muli(IComplexNumber c)`
`IComplexNumber`	`muli(IComplexNumber c, IComplexNumber result)` Multiply two complex numbers, inplace
`IComplexNumber`	`muli(Number v)`
`IComplexNumber`	`muli(Number v, IComplexNumber result)`
`boolean`	`ne(IComplexNumber c)`
`IComplexNumber`	`neg()` The negation of this complex number
`IComplexFloat`	`negi()` The inplace negation of this number
`IComplexNumber`	`neqc(IComplexNumber num)` Not Equals returning a complex number
`IComplexNumber`	`rdiv(IComplexNumber c)` Divide two complex numbers
`IComplexNumber`	`rdiv(Number v)`
`IComplexNumber`	`rdivi(IComplexNumber c)`
`IComplexNumber`	`rdivi(IComplexNumber c, IComplexNumber result)` Divide two complex numbers, in-place
`IComplexNumber`	`rdivi(Number v)`
`IComplexNumber`	`rdivi(Number v, IComplexNumber result)`
`Float`	`realComponent()` The real component of this number
`IComplexNumber`	`rsub(IComplexNumber c)` Subtract two complex numbers
`IComplexNumber`	`rsub(Number r)`
`IComplexNumber`	`rsubi(IComplexNumber c)` Reverse subtract a number
`IComplexNumber`	`rsubi(IComplexNumber a, IComplexNumber result)` Reverse subtraction
`IComplexNumber`	`rsubi(Number a)`
`IComplexNumber`	`rsubi(Number a, IComplexNumber result)`
`IComplexNumber`	`set(IComplexNumber set)` Set a complex number's components to be this ones
`IComplexNumber`	`set(Number real, Number imag)` Set the real and imaginary components
`IComplexFloat`	`sqrt()` The sqrt of this number
`IComplexNumber`	`sub(IComplexNumber c)` Subtract two complex numbers
`IComplexNumber`	`sub(Number r)`
`IComplexNumber`	`subi(IComplexNumber c)`
`IComplexNumber`	`subi(IComplexNumber c, IComplexNumber result)` Subtract two complex numbers, in-place
`IComplexNumber`	`subi(Number a)`
`IComplexNumber`	`subi(Number a, IComplexNumber result)`
`String`	`toString()`

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

Methods inherited from interface org.nd4j.linalg.api.complex.IComplexNumber
dup

- Field Detail
  - real
```
protected float real
```
  - imag
```
protected float imag
```
- Constructor Detail
  - BaseComplexFloat
```
public BaseComplexFloat()
```
  - BaseComplexFloat
```
public BaseComplexFloat(Float real,
                        Float imag)
```
  - BaseComplexFloat
```
public BaseComplexFloat(float real,
                        float imag)
```
  - BaseComplexFloat
```
public BaseComplexFloat(float real)
```
- Method Detail
  - eqc
```
public IComplexNumber eqc(IComplexNumber num)
```
    Description copied from interface: IComplexNumber
    
    Equals returning a complex number
    
    Specified by:
    
    eqc in interface IComplexNumber
    
    Parameters:
    
    num - the number to compare
    
    Returns:
    
    1 if equal 0 otherwise
  - neqc
```
public IComplexNumber neqc(IComplexNumber num)
```
    Description copied from interface: IComplexNumber
    
    Not Equals returning a complex number
    
    Specified by:
    
    neqc in interface IComplexNumber
    
    Parameters:
    
    num - the number to compare
    
    Returns:
    
    1 if not equal 0 otherwise
  - gt
```
public IComplexNumber gt(IComplexNumber num)
```
    Description copied from interface: IComplexNumber
    
    Greater than returning a complex number
    
    Specified by:
    
    gt in interface IComplexNumber
    
    Parameters:
    
    num - the number to compare
    
    Returns:
    
    1 if greater than 0 otherwise
  - lt
```
public IComplexNumber lt(IComplexNumber num)
```
    Description copied from interface: IComplexNumber
    
    Less than returning a complex number
    
    Specified by:
    
    lt in interface IComplexNumber
    
    Parameters:
    
    num - the number to compare
    
    Returns:
    
    1 if less than 0 otherwise
  - rsubi
```
public IComplexNumber rsubi(IComplexNumber c)
```
    Description copied from interface: IComplexNumber
    
    Reverse subtract a number
    
    Specified by:
    
    rsubi in interface IComplexNumber
    
    Parameters:
    
    c - the complex number to reverse subtract
    
    Returns:
    
    the reverse subtracted number
  - set
```
public IComplexNumber set(IComplexNumber set)
```
    Description copied from interface: IComplexNumber
    
    Set a complex number's components to be this ones
    
    Specified by:
    
    set in interface IComplexNumber
    
    Parameters:
    
    set - the complex number to set
    
    Returns:
    
    a reference to this
  - rsubi
```
public IComplexNumber rsubi(IComplexNumber a,
                            IComplexNumber result)
```
    Description copied from interface: IComplexNumber
    
    Reverse subtraction
    
    Specified by:
    
    rsubi in interface IComplexNumber
    
    Parameters:
    
    a - the number to subtract
    
    result - the result to set
    
    Returns:
    
    the result
  - rsub
```
public IComplexNumber rsub(IComplexNumber c)
```
    Description copied from interface: IComplexNumber
    
    Subtract two complex numbers
    
    Specified by:
    
    rsub in interface IComplexNumber
  - rsubi
```
public IComplexNumber rsubi(Number a,
                            IComplexNumber result)
```
    Specified by:
    
    rsubi in interface IComplexNumber
  - rsubi
```
public IComplexNumber rsubi(Number a)
```
    Specified by:
    
    rsubi in interface IComplexNumber
  - rsub
```
public IComplexNumber rsub(Number r)
```
    Specified by:
    
    rsub in interface IComplexNumber
  - rdiv
```
public IComplexNumber rdiv(IComplexNumber c)
```
    Description copied from interface: IComplexNumber
    
    Divide two complex numbers
    
    Specified by:
    
    rdiv in interface IComplexNumber
  - rdivi
```
public IComplexNumber rdivi(IComplexNumber c,
                            IComplexNumber result)
```
    Description copied from interface: IComplexNumber
    
    Divide two complex numbers, in-place
    
    Specified by:
    
    rdivi in interface IComplexNumber
  - rdivi
```
public IComplexNumber rdivi(IComplexNumber c)
```
    Specified by:
    
    rdivi in interface IComplexNumber
  - rdivi
```
public IComplexNumber rdivi(Number v,
                            IComplexNumber result)
```
    Specified by:
    
    rdivi in interface IComplexNumber
  - rdivi
```
public IComplexNumber rdivi(Number v)
```
    Specified by:
    
    rdivi in interface IComplexNumber
  - rdiv
```
public IComplexNumber rdiv(Number v)
```
    Specified by:
    
    rdiv in interface IComplexNumber
  - asDouble
```
public IComplexDouble asDouble()
```
    Convert to a double
    
    Specified by:
    
    asDouble in interface IComplexNumber
    
    Returns:
    
    this complex number as a double
  - asFloat
```
public IComplexFloat asFloat()
```
    Convert to a float
    
    Specified by:
    
    asFloat in interface IComplexNumber
    
    Returns:
    
    this complex number as a float
  - conji
```
public IComplexFloat conji()
```
    Description copied from interface: IComplexNumber
    
    The inplace conjugate of this number
    
    Specified by:
    
    conji in interface IComplexNumber
    
    Returns:
  - conj
```
public IComplexNumber conj()
```
    Description copied from interface: IComplexNumber
    
    The conjugate of this number
    
    Specified by:
    
    conj in interface IComplexNumber
    
    Returns:
  - set
```
public IComplexNumber set(Number real,
                          Number imag)
```
    Description copied from interface: IComplexNumber
    
    Set the real and imaginary components
    
    Specified by:
    
    set in interface IComplexNumber
    
    Parameters:
    
    real - the real numbers
    
    imag - the imaginary components
    
    Returns:
    
    the imaginary components
  - copy
```
public IComplexNumber copy(IComplexNumber other)
```
    Specified by:
    
    copy in interface IComplexNumber
  - addi
```
public IComplexNumber addi(IComplexNumber c,
                           IComplexNumber result)
```
    Add two complex numbers in-place
    
    Specified by:
    
    addi in interface IComplexNumber
    
    Parameters:
    
    c -
    
    result -
  - addi
```
public IComplexNumber addi(IComplexNumber c)
```
    Add two complex numbers in-place storing the result in this.
    
    Specified by:
    
    addi in interface IComplexNumber
    
    Parameters:
    
    c -
  - add
```
public IComplexNumber add(IComplexNumber c)
```
    Add two complex numbers.
    
    Specified by:
    
    add in interface IComplexNumber
    
    Parameters:
    
    c -
  - addi
```
public IComplexNumber addi(Number a,
                           IComplexNumber result)
```
    Add a realComponent number to a complex number in-place.
    
    Specified by:
    
    addi in interface IComplexNumber
    
    Parameters:
    
    a -
    
    result -
  - addi
```
public IComplexNumber addi(Number c)
```
    Add a realComponent number to complex number in-place, storing the result in this.
    
    Specified by:
    
    addi in interface IComplexNumber
    
    Parameters:
    
    c -
  - add
```
public IComplexNumber add(Number c)
```
    Add a realComponent number to a complex number.
    
    Specified by:
    
    add in interface IComplexNumber
    
    Parameters:
    
    c -
  - subi
```
public IComplexNumber subi(IComplexNumber c,
                           IComplexNumber result)
```
    Subtract two complex numbers, in-place
    
    Specified by:
    
    subi in interface IComplexNumber
    
    Parameters:
    
    c -
    
    result -
  - subi
```
public IComplexNumber subi(IComplexNumber c)
```
    Specified by:
    
    subi in interface IComplexNumber
  - sub
```
public IComplexNumber sub(IComplexNumber c)
```
    Subtract two complex numbers
    
    Specified by:
    
    sub in interface IComplexNumber
    
    Parameters:
    
    c -
  - subi
```
public IComplexNumber subi(Number a,
                           IComplexNumber result)
```
    Specified by:
    
    subi in interface IComplexNumber
  - subi
```
public IComplexNumber subi(Number a)
```
    Specified by:
    
    subi in interface IComplexNumber
  - sub
```
public IComplexNumber sub(Number r)
```
    Specified by:
    
    sub in interface IComplexNumber
  - muli
```
public IComplexNumber muli(IComplexNumber c,
                           IComplexNumber result)
```
    Multiply two complex numbers, inplace
    
    Specified by:
    
    muli in interface IComplexNumber
    
    Parameters:
    
    c -
    
    result -
  - muli
```
public IComplexNumber muli(IComplexNumber c)
```
    Specified by:
    
    muli in interface IComplexNumber
  - mul
```
public IComplexNumber mul(IComplexNumber c)
```
    Multiply two complex numbers
    
    Specified by:
    
    mul in interface IComplexNumber
    
    Parameters:
    
    c -
  - mul
```
public IComplexNumber mul(Number v)
```
    Specified by:
    
    mul in interface IComplexNumber
  - muli
```
public IComplexNumber muli(Number v,
                           IComplexNumber result)
```
    Specified by:
    
    muli in interface IComplexNumber
  - muli
```
public IComplexNumber muli(Number v)
```
    Specified by:
    
    muli in interface IComplexNumber
  - div
```
public IComplexNumber div(IComplexNumber c)
```
    Divide two complex numbers
    
    Specified by:
    
    div in interface IComplexNumber
    
    Parameters:
    
    c -
  - divi
```
public IComplexNumber divi(IComplexNumber c,
                           IComplexNumber result)
```
    Divide two complex numbers, in-place
    
    Specified by:
    
    divi in interface IComplexNumber
    
    Parameters:
    
    c -
    
    result -
  - divi
```
public IComplexNumber divi(IComplexNumber c)
```
    Specified by:
    
    divi in interface IComplexNumber
  - divi
```
public IComplexNumber divi(Number v,
                           IComplexNumber result)
```
    Specified by:
    
    divi in interface IComplexNumber
  - divi
```
public IComplexNumber divi(Number v)
```
    Specified by:
    
    divi in interface IComplexNumber
  - div
```
public IComplexNumber div(Number v)
```
    Specified by:
    
    div in interface IComplexNumber
  - eq
```
public boolean eq(IComplexNumber c)
```
    Specified by:
    
    eq in interface IComplexNumber
  - ne
```
public boolean ne(IComplexNumber c)
```
    Specified by:
    
    ne in interface IComplexNumber
  - realComponent
```
public Float realComponent()
```
    Description copied from interface: IComplexNumber
    
    The real component of this number
    
    Specified by:
    
    realComponent in interface IComplexFloat
    
    Specified by:
    
    realComponent in interface IComplexNumber
    
    Returns:
    
    the real component of this number
  - imaginaryComponent
```
public Float imaginaryComponent()
```
    Description copied from interface: IComplexNumber
    
    The imaginary component of this number
    
    Specified by:
    
    imaginaryComponent in interface IComplexFloat
    
    Specified by:
    
    imaginaryComponent in interface IComplexNumber
    
    Returns:
    
    the real component of this number
  - divi
```
public IComplexFloat divi(float v)
```
    Specified by:
    
    divi in interface IComplexFloat
  - div
```
public IComplexNumber div(float v)
```
    Specified by:
    
    div in interface IComplexFloat
  - absoluteValue
```
public Float absoluteValue()
```
    Return the absolute value
    
    Specified by:
    
    absoluteValue in interface IComplexNumber
  - complexArgument
```
public Float complexArgument()
```
    Returns the argument of a complex number.
    
    Specified by:
    
    complexArgument in interface IComplexFloat
    
    Specified by:
    
    complexArgument in interface IComplexNumber
  - invi
```
public IComplexFloat invi()
```
    Specified by:
    
    invi in interface IComplexNumber
  - inv
```
public IComplexNumber inv()
```
    Specified by:
    
    inv in interface IComplexNumber
  - neg
```
public IComplexNumber neg()
```
    Description copied from interface: IComplexNumber
    
    The negation of this complex number
    
    Specified by:
    
    neg in interface IComplexNumber
    
    Returns:
  - negi
```
public IComplexFloat negi()
```
    Description copied from interface: IComplexNumber
    
    The inplace negation of this number
    
    Specified by:
    
    negi in interface IComplexNumber
    
    Returns:
  - sqrt
```
public IComplexFloat sqrt()
```
    Description copied from interface: IComplexNumber
    
    The sqrt of this number
    
    Specified by:
    
    sqrt in interface IComplexNumber
    
    Returns:
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - isZero
```
public boolean isZero()
```
    Description copied from interface: IComplexNumber
    
    Whether this number is wholly zero or not
    
    Specified by:
    
    isZero in interface IComplexNumber
    
    Returns:
    
    true if the number is wholly zero false otherwise
  - isReal
```
public boolean isReal()
```
    Description copied from interface: IComplexNumber
    
    Returns whether the number only has a real component (0 for imaginary)
    
    Specified by:
    
    isReal in interface IComplexNumber
    
    Returns:
    
    true if the number has only a real component or not
  - isImag
```
public boolean isImag()
```
    Description copied from interface: IComplexNumber
    
    Returns whether the number only has a imaginary component (0 for real)
    
    Specified by:
    
    isImag in interface IComplexNumber
    
    Returns:
    
    true if the number has only a real component or not
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class BaseComplexFloat

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.nd4j.linalg.api.complex.IComplexNumber

Field Detail

real

imag

Constructor Detail

BaseComplexFloat

BaseComplexFloat

BaseComplexFloat

BaseComplexFloat

Method Detail

eqc

neqc

gt

lt

rsubi

set

rsubi

rsub

rsubi

rsubi

rsub

rdiv

rdivi

rdivi

rdivi

rdivi

rdiv

asDouble

asFloat

conji

conj

set

copy

addi

addi

add

addi

addi

add

subi

subi

sub

subi

subi

sub

muli

muli

mul

mul

muli

muli

div

divi

divi

divi

divi

div

eq

ne

realComponent

imaginaryComponent

divi

div

absoluteValue

complexArgument

invi

inv

neg

negi

sqrt

equals

isZero

isReal

isImag

hashCode