IComplexNumber (nd4j-api 0.0.3.1 API)

All Known Subinterfaces:

IComplexDouble, IComplexFloat

All Known Implementing Classes:

BaseComplexDouble, BaseComplexFloat
```
public interface IComplexNumber
```
Baseline interface for a complex number with realComponent and imaginary components. Based off of the jblas api by mikio braun

Author:

Adam Gibson

Method Summary

Methods
Modifier and Type	Method and Description
`Number`	`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
`Number`	`complexArgument()` Returns the argument of a complex number.
`IComplexNumber`	`conj()`
`IComplexNumber`	`conji()`
`IComplexNumber`	`copy(IComplexNumber other)`
`IComplexNumber`	`div(IComplexNumber c)` Divide two complex numbers
`IComplexNumber`	`div(Number 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)`
`IComplexNumber`	`dup()`
`boolean`	`eq(IComplexNumber c)`
`Number`	`imaginaryComponent()`
`IComplexNumber`	`inv()`
`IComplexNumber`	`invi()`
`boolean`	`isImag()`
`boolean`	`isReal()`
`boolean`	`isZero()`
`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()`
`IComplexNumber`	`negi()`
`Number`	`realComponent()`
`IComplexNumber`	`set(Number real, Number imag)`
`IComplexNumber`	`sqrt()`
`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)`

Method Detail

set

IComplexNumber set(Number real,
                 Number imag)

realComponent
```
Number realComponent()
```

imaginaryComponent
```
Number imaginaryComponent()
```

dup
```
IComplexNumber dup()
```

copy

IComplexNumber copy(IComplexNumber other)

addi

IComplexNumber addi(IComplexNumber c,
                  IComplexNumber result)

Add two complex numbers in-place

addi
```
IComplexNumber addi(IComplexNumber c)
```
Add two complex numbers in-place storing the result in this.

add
```
IComplexNumber add(IComplexNumber c)
```
Add two complex numbers.

addi

IComplexNumber addi(Number a,
                  IComplexNumber result)

Add a realComponent number to a complex number in-place.

addi
```
IComplexNumber addi(Number c)
```
Add a realComponent number to complex number in-place, storing the result in this.

add
```
IComplexNumber add(Number c)
```
Add a realComponent number to a complex number.

subi

IComplexNumber subi(IComplexNumber c,
                  IComplexNumber result)

Subtract two complex numbers, in-place

subi
```
IComplexNumber subi(IComplexNumber c)
```

sub
```
IComplexNumber sub(IComplexNumber c)
```
Subtract two complex numbers

subi

IComplexNumber subi(Number a,
                  IComplexNumber result)

subi
```
IComplexNumber subi(Number a)
```

sub
```
IComplexNumber sub(Number r)
```

muli

IComplexNumber muli(IComplexNumber c,
                  IComplexNumber result)

Multiply two complex numbers, inplace

muli
```
IComplexNumber muli(IComplexNumber c)
```

mul
```
IComplexNumber mul(IComplexNumber c)
```
Multiply two complex numbers

mul
```
IComplexNumber mul(Number v)
```

muli

IComplexNumber muli(Number v,
                  IComplexNumber result)

muli
```
IComplexNumber muli(Number v)
```

div
```
IComplexNumber div(IComplexNumber c)
```
Divide two complex numbers

divi

IComplexNumber divi(IComplexNumber c,
                  IComplexNumber result)

Divide two complex numbers, in-place

divi
```
IComplexNumber divi(IComplexNumber c)
```

divi

IComplexNumber divi(Number v,
                  IComplexNumber result)

divi
```
IComplexNumber divi(Number v)
```

div
```
IComplexNumber div(Number v)
```

absoluteValue
```
Number absoluteValue()
```
Return the absolute value

complexArgument
```
Number complexArgument()
```
Returns the argument of a complex number.

invi
```
IComplexNumber invi()
```

inv
```
IComplexNumber inv()
```

neg
```
IComplexNumber neg()
```

negi
```
IComplexNumber negi()
```

conji
```
IComplexNumber conji()
```

conj
```
IComplexNumber conj()
```

sqrt
```
IComplexNumber sqrt()
```

eq
```
boolean eq(IComplexNumber c)
```

ne
```
boolean ne(IComplexNumber c)
```

isZero
```
boolean isZero()
```

isReal
```
boolean isReal()
```

isImag
```
boolean isImag()
```

asFloat
```
IComplexFloat asFloat()
```
Convert to a float

Returns:
this complex number as a float

asDouble
```
IComplexDouble asDouble()
```
Convert to a double

Returns:
this complex number as a double

Interface IComplexNumber

Method Summary

Method Detail

set

realComponent

imaginaryComponent

dup

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

absoluteValue

complexArgument

invi

inv

neg

negi

conji

conj

sqrt

eq

ne

isZero

isReal

isImag

asFloat

asDouble