Complex (WOImageJ API)

java.lang.Object
- woSource.math.Complex

public class Complex
extends java.lang.Object

Constructor Summary

Constructors
Constructor and Description

Complex()

Complex(Complex c)

Complex(double real)

Complex(double real, double imag)

Constructors
Constructor and Description
`Complex()`
`Complex(Complex c)`
`Complex(double real)`
`Complex(double real, double imag)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`double`	`abs()`
`static double`	`abs(Complex a)`
`Complex`	`acos()`
`static Complex`	`acos(Complex a)`
`Complex`	`acosh()`
`static Complex`	`acosh(Complex a)`
`Complex`	`acot()`
`static Complex`	`acot(Complex a)`
`Complex`	`acoth()`
`static Complex`	`acoth(Complex a)`
`Complex`	`acovers()`
`static Complex`	`acovers(Complex a)`
`Complex`	`acsc()`
`static Complex`	`acsc(Complex a)`
`Complex`	`acsch()`
`static Complex`	`acsch(Complex a)`
`Complex`	`aexsec()`
`static Complex`	`aexsec(Complex a)`
`Complex`	`ahav()`
`static Complex`	`ahav(Complex a)`
`double`	`arg()`
`static double`	`arg(Complex a)`
`double`	`argDeg()`
`static double`	`argDeg(Complex a)`
`double`	`argRad()`
`static double`	`argRad(Complex a)`
`Complex`	`asec()`
`static Complex`	`asec(Complex a)`
`Complex`	`asech()`
`static Complex`	`asech(Complex a)`
`Complex`	`asin()`
`static Complex`	`asin(Complex a)`
`Complex`	`asinh()`
`static Complex`	`asinh(Complex a)`
`Complex`	`atan()`
`static Complex`	`atan(Complex a)`
`Complex`	`atanh()`
`static Complex`	`atanh(Complex a)`
`Complex`	`avers()`
`static Complex`	`avers(Complex a)`
`java.lang.Object`	`clone()`
`Complex`	`conjugate()`
`static Complex`	`conjugate(Complex a)`
`Complex`	`copy()`
`static Complex`	`copy(Complex a)`
`static Complex[]`	`copy(Complex[] a)`
`static Complex[][]`	`copy(Complex[][] a)`
`static Complex[][][]`	`copy(Complex[][][] a)`
`Complex`	`cos()`
`static Complex`	`cos(Complex aa)`
`Complex`	`cosh()`
`static Complex`	`cosh(Complex a)`
`Complex`	`cot()`
`static Complex`	`cot(Complex aa)`
`Complex`	`coth()`
`static Complex`	`coth(Complex a)`
`Complex`	`covers()`
`static Complex`	`covers(Complex aa)`
`Complex`	`csc()`
`static Complex`	`csc(Complex aa)`
`Complex`	`csch()`
`static Complex`	`csch(Complex a)`
`boolean`	`equals(Complex a)`
`boolean`	`equalsWithinLimits(Complex a, double fract)`
`Complex`	`exp()`
`static Complex`	`exp(Complex aa)`
`static Complex`	`exp(double aa)`
`static Complex`	`expMinusJayArg(double arg)`
`static Complex`	`expPlusJayArg(double arg)`
`Complex`	`exsec()`
`static Complex`	`exsec(Complex aa)`
`double`	`getImag()`
`static boolean`	`getInfOption()`
`static char`	`getjori()`
`double`	`getReal()`
`int`	`hashCode()`
`Complex`	`hav()`
`static Complex`	`hav(Complex aa)`
`static double`	`hypot(Complex aa, Complex bb)`
`Complex`	`inverse()`
`static Complex`	`inverse(Complex a)`
`boolean`	`isEqual(Complex a)`
`static boolean`	`isEqual(Complex a, Complex b)`
`static boolean`	`isEqualWithinLimits(Complex a, Complex b, double fract)`
`boolean`	`isEqualWithinLimits(Complex a, double fract)`
`boolean`	`isInfinite()`
`static boolean`	`isInfinite(Complex a)`
`boolean`	`isMinusInfinity()`
`static boolean`	`isMinusInfinity(Complex a)`
`boolean`	`isNaN()`
`static boolean`	`isNaN(Complex a)`
`boolean`	`isPlusInfinity()`
`static boolean`	`isPlusInfinity(Complex a)`
`boolean`	`isReal()`
`static boolean`	`isReal(Complex a)`
`static boolean`	`isReal(Complex[] a)`
`static boolean`	`isReal(Complex[] a, double lim)`
`static boolean`	`isReal(Complex a, double lim)`
`boolean`	`isReal(double lim)`
`static boolean`	`isRealPerCent(Complex[] a, double percent)`
`static boolean`	`isRealPerCent(Complex a, double percent)`
`boolean`	`isRealperCent(double percent)`
`boolean`	`isZero()`
`static boolean`	`isZero(Complex a)`
`Complex`	`log()`
`static Complex`	`log(Complex aa)`
`static Complex`	`mean(Complex[] aa)`
`Complex`	`minus(Complex a)`
`static Complex`	`minus(Complex a, Complex b)`
`static Complex`	`minus(Complex a, double b)`
`Complex`	`minus(double a)`
`static Complex`	`minus(double a, Complex b)`
`static Complex`	`minus(double a, double b)`
`void`	`minusEquals(Complex a)`
`void`	`minusEquals(double a)`
`static Complex`	`minusInfinity()`
`static Complex`	`minusJay()`
`static Complex`	`minusOne()`
`Complex`	`negate()`
`static Complex`	`negate(Complex a)`
`static Complex`	`nthRoot(Complex aa, int n)`
`Complex`	`nthRoot(int n)`
`static Complex[]`	`oneDarray(int n)`
`static Complex[]`	`oneDarray(int n, Complex constant)`
`static Complex[]`	`oneDarray(int n, double a, double b)`
`Complex`	`over(Complex a)`
`static Complex`	`over(Complex a, Complex b)`
`static Complex`	`over(Complex a, double b)`
`Complex`	`over(double a)`
`static Complex`	`over(double a, Complex b)`
`static Complex`	`over(double a, double b)`
`void`	`overEquals(Complex b)`
`void`	`overEquals(double a)`
`static Complex`	`parseComplex(java.lang.String ss)`
`static Complex`	`pi()`
`Complex`	`plus(Complex a)`
`static Complex`	`plus(Complex a, Complex b)`
`static Complex`	`plus(Complex a, double b)`
`Complex`	`plus(double a)`
`static Complex`	`plus(double a, Complex b)`
`static Complex`	`plus(double a, double b)`
`void`	`plusEquals(Complex a)`
`void`	`plusEquals(double a)`
`static Complex`	`plusInfinity()`
`static Complex`	`plusJay()`
`static Complex`	`plusOne()`
`void`	`polar(double mod, double arg)`
`void`	`polarDeg(double mod, double arg)`
`void`	`polarRad(double mod, double arg)`
`Complex`	`pow(Complex b)`
`static Complex`	`pow(Complex a, Complex b)`
`static Complex`	`pow(Complex a, double b)`
`static Complex`	`pow(Complex a, int n)`
`Complex`	`pow(double b)`
`static Complex`	`pow(double a, Complex b)`
`Complex`	`pow(int n)`
`void`	`print()`
`static void`	`print(Complex[] aa)`
`void`	`print(java.lang.String message)`
`static void`	`print(java.lang.String message, Complex[] aa)`
`void`	`println()`
`static void`	`println(Complex[] aa)`
`void`	`println(java.lang.String message)`
`static void`	`println(java.lang.String message, Complex[] aa)`
`static Complex`	`readComplex()`
`static Complex`	`readComplex(java.lang.String prompt)`
`static Complex`	`readComplex(java.lang.String prompt, Complex dflt)`
`static Complex`	`readComplex(java.lang.String prompt, java.lang.String dflt)`
`void`	`reset(double real, double imag)`
`Complex`	`sec()`
`static Complex`	`sec(Complex aa)`
`Complex`	`sech()`
`static Complex`	`sech(Complex a)`
`static void`	`seti()`
`void`	`setImag(double imag)`
`static void`	`setInfOption(boolean infOpt)`
`static void`	`setInfOption(int opt)`
`static void`	`setj()`
`void`	`setReal(double real)`
`Complex`	`sin()`
`static Complex`	`sin(Complex aa)`
`Complex`	`sinh()`
`static Complex`	`sinh(Complex a)`
`Complex`	`sqrt()`
`static Complex`	`sqrt(Complex aa)`
`Complex`	`square()`
`static Complex`	`square(Complex aa)`
`double`	`squareAbs()`
`static double`	`squareAbs(Complex a)`
`static void`	`swap(Complex aa, Complex bb)`
`Complex`	`tan()`
`static Complex`	`tan(Complex aa)`
`Complex`	`tanh()`
`static Complex`	`tanh(Complex a)`
`static Complex[][][]`	`threeDarray(int n, int m, int l)`
`static Complex[][][]`	`threeDarray(int n, int m, int l, Complex constant)`
`static Complex[][][]`	`threeDarray(int n, int m, int l, double a, double b)`
`Complex`	`times(Complex a)`
`static Complex`	`times(Complex a, Complex b)`
`static Complex`	`times(Complex a, double b)`
`Complex`	`times(double a)`
`static Complex`	`times(double a, Complex b)`
`static Complex`	`times(double a, double b)`
`void`	`timesEquals(Complex a)`
`void`	`timesEquals(double a)`
`java.lang.String`	`toString()`
`static java.lang.String`	`toString(Complex aa)`
`Complex`	`transposedMinus(double a)`
`Complex`	`transposedOver(double a)`
`static Complex[][]`	`twoDarray(int n, int m)`
`static Complex[][]`	`twoDarray(int n, int m, Complex constant)`
`static Complex[][]`	`twoDarray(int n, int m, double a, double b)`
`static Complex`	`twoPiJay()`
`static Complex`	`valueOf(java.lang.String ss)`
`Complex`	`vers()`
`static Complex`	`vers(Complex aa)`
`static Complex`	`zero()`

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

Constructor Detail

Complex
```
public Complex()
```

Complex

public Complex(double real,
               double imag)

Complex
```
public Complex(double real)
```

Complex
```
public Complex(Complex c)
```

Method Detail

setReal
```
public void setReal(double real)
```

setImag
```
public void setImag(double imag)
```

reset

public void reset(double real,
                  double imag)

polarRad

public void polarRad(double mod,
                     double arg)

polar

public void polar(double mod,
                  double arg)

polarDeg

public void polarDeg(double mod,
                     double arg)

getReal
```
public double getReal()
```

getImag
```
public double getImag()
```

readComplex

public static final Complex readComplex(java.lang.String prompt)

readComplex

public static final Complex readComplex(java.lang.String prompt,
                                        java.lang.String dflt)

readComplex

public static final Complex readComplex(java.lang.String prompt,
                                        Complex dflt)

readComplex

public static final Complex readComplex()

println

public void println(java.lang.String message)

println
```
public void println()
```

print

public void print(java.lang.String message)

print
```
public void print()
```

println

public static void println(java.lang.String message,
                           Complex[] aa)

println

public static void println(Complex[] aa)

print

public static void print(java.lang.String message,
                         Complex[] aa)

print

public static void print(Complex[] aa)

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

toString

public static java.lang.String toString(Complex aa)

setj
```
public static void setj()
```

seti
```
public static void seti()
```

getjori
```
public static char getjori()
```

parseComplex

public static Complex parseComplex(java.lang.String ss)

valueOf

public static Complex valueOf(java.lang.String ss)

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class java.lang.Object

swap

public static void swap(Complex aa,
                        Complex bb)

oneDarray

public static Complex[] oneDarray(int n)

oneDarray

public static Complex[] oneDarray(int n,
                                  double a,
                                  double b)

mean

public static Complex mean(Complex[] aa)

oneDarray

public static Complex[] oneDarray(int n,
                                  Complex constant)

twoDarray

public static Complex[][] twoDarray(int n,
                                    int m)

twoDarray

public static Complex[][] twoDarray(int n,
                                    int m,
                                    double a,
                                    double b)

twoDarray

public static Complex[][] twoDarray(int n,
                                    int m,
                                    Complex constant)

threeDarray

public static Complex[][][] threeDarray(int n,
                                        int m,
                                        int l)

threeDarray

public static Complex[][][] threeDarray(int n,
                                        int m,
                                        int l,
                                        double a,
                                        double b)

threeDarray

public static Complex[][][] threeDarray(int n,
                                        int m,
                                        int l,
                                        Complex constant)

copy

public static Complex copy(Complex a)

copy
```
public Complex copy()
```

copy

public static Complex[] copy(Complex[] a)

copy

public static Complex[][] copy(Complex[][] a)

copy

public static Complex[][][] copy(Complex[][][] a)

clone
```
public java.lang.Object clone()
```
Overrides:

clone in class java.lang.Object

plus

public static Complex plus(Complex a,
                           Complex b)

plus

public static Complex plus(Complex a,
                           double b)

plus

public static Complex plus(double a,
                           Complex b)

plus

public static Complex plus(double a,
                           double b)

plus
```
public Complex plus(Complex a)
```

plus
```
public Complex plus(double a)
```

plusEquals
```
public void plusEquals(Complex a)
```

plusEquals
```
public void plusEquals(double a)
```

minus

public static Complex minus(Complex a,
                            Complex b)

minus

public static Complex minus(Complex a,
                            double b)

minus

public static Complex minus(double a,
                            Complex b)

minus

public static Complex minus(double a,
                            double b)

minus
```
public Complex minus(Complex a)
```

minus
```
public Complex minus(double a)
```

transposedMinus

public Complex transposedMinus(double a)

minusEquals
```
public void minusEquals(Complex a)
```

minusEquals
```
public void minusEquals(double a)
```

setInfOption

public static void setInfOption(boolean infOpt)

setInfOption

public static void setInfOption(int opt)

getInfOption
```
public static boolean getInfOption()
```

times

public static Complex times(Complex a,
                            Complex b)

times

public static Complex times(Complex a,
                            double b)

times

public static Complex times(double a,
                            Complex b)

times

public static Complex times(double a,
                            double b)

times
```
public Complex times(Complex a)
```

times
```
public Complex times(double a)
```

timesEquals
```
public void timesEquals(Complex a)
```

timesEquals
```
public void timesEquals(double a)
```

over

public static Complex over(Complex a,
                           Complex b)

over

public static Complex over(Complex a,
                           double b)

over

public static Complex over(double a,
                           Complex b)

over

public static Complex over(double a,
                           double b)

over
```
public Complex over(Complex a)
```

over
```
public Complex over(double a)
```

transposedOver

public Complex transposedOver(double a)

overEquals
```
public void overEquals(Complex b)
```

overEquals
```
public void overEquals(double a)
```

inverse

public static Complex inverse(Complex a)

inverse
```
public Complex inverse()
```

negate

public static Complex negate(Complex a)

negate
```
public Complex negate()
```

abs
```
public static double abs(Complex a)
```

abs
```
public double abs()
```

squareAbs

public static double squareAbs(Complex a)

squareAbs
```
public double squareAbs()
```

arg
```
public static double arg(Complex a)
```

arg
```
public double arg()
```

argRad

public static double argRad(Complex a)

argRad
```
public double argRad()
```

argDeg

public static double argDeg(Complex a)

argDeg
```
public double argDeg()
```

conjugate

public static Complex conjugate(Complex a)

conjugate
```
public Complex conjugate()
```

hypot

public static double hypot(Complex aa,
                           Complex bb)

exp
```
public Complex exp()
```

exp

public static Complex exp(Complex aa)

exp
```
public static Complex exp(double aa)
```

expPlusJayArg

public static Complex expPlusJayArg(double arg)

expMinusJayArg

public static Complex expMinusJayArg(double arg)

log
```
public Complex log()
```

log

public static Complex log(Complex aa)

sqrt
```
public Complex sqrt()
```

sqrt

public static Complex sqrt(Complex aa)

nthRoot
```
public Complex nthRoot(int n)
```

nthRoot

public static Complex nthRoot(Complex aa,
                              int n)

square

public static Complex square(Complex aa)

square
```
public Complex square()
```

pow
```
public Complex pow(Complex b)
```

pow

public static Complex pow(Complex a,
                          Complex b)

pow
```
public Complex pow(double b)
```

pow

public static Complex pow(Complex a,
                          double b)

pow
```
public Complex pow(int n)
```

pow

public static Complex pow(Complex a,
                          int n)

pow

public static Complex pow(double a,
                          Complex b)

sin
```
public Complex sin()
```

sin

public static Complex sin(Complex aa)

cos
```
public Complex cos()
```

cos

public static Complex cos(Complex aa)

sec
```
public Complex sec()
```

sec

public static Complex sec(Complex aa)

csc
```
public Complex csc()
```

csc

public static Complex csc(Complex aa)

tan
```
public Complex tan()
```

tan

public static Complex tan(Complex aa)

cot
```
public Complex cot()
```

cot

public static Complex cot(Complex aa)

exsec
```
public Complex exsec()
```

exsec

public static Complex exsec(Complex aa)

vers
```
public Complex vers()
```

vers

public static Complex vers(Complex aa)

covers
```
public Complex covers()
```

covers

public static Complex covers(Complex aa)

hav
```
public Complex hav()
```

hav

public static Complex hav(Complex aa)

sinh
```
public Complex sinh()
```

sinh

public static Complex sinh(Complex a)

cosh
```
public Complex cosh()
```

cosh

public static Complex cosh(Complex a)

tanh
```
public Complex tanh()
```

tanh

public static Complex tanh(Complex a)

coth
```
public Complex coth()
```

coth

public static Complex coth(Complex a)

sech
```
public Complex sech()
```

sech

public static Complex sech(Complex a)

csch
```
public Complex csch()
```

csch

public static Complex csch(Complex a)

asin
```
public Complex asin()
```

asin

public static Complex asin(Complex a)

acos
```
public Complex acos()
```

acos

public static Complex acos(Complex a)

atan
```
public Complex atan()
```

atan

public static Complex atan(Complex a)

acot
```
public Complex acot()
```

acot

public static Complex acot(Complex a)

asec
```
public Complex asec()
```

asec

public static Complex asec(Complex a)

acsc
```
public Complex acsc()
```

acsc

public static Complex acsc(Complex a)

aexsec
```
public Complex aexsec()
```

aexsec

public static Complex aexsec(Complex a)

avers
```
public Complex avers()
```

avers

public static Complex avers(Complex a)

acovers
```
public Complex acovers()
```

acovers

public static Complex acovers(Complex a)

ahav
```
public Complex ahav()
```

ahav

public static Complex ahav(Complex a)

asinh
```
public Complex asinh()
```

asinh

public static Complex asinh(Complex a)

acosh
```
public Complex acosh()
```

acosh

public static Complex acosh(Complex a)

atanh
```
public Complex atanh()
```

atanh

public static Complex atanh(Complex a)

acoth
```
public Complex acoth()
```

acoth

public static Complex acoth(Complex a)

asech
```
public Complex asech()
```

asech

public static Complex asech(Complex a)

acsch
```
public Complex acsch()
```

acsch

public static Complex acsch(Complex a)

isReal

public static boolean isReal(Complex a)

isReal

public static boolean isReal(Complex[] a)

isReal
```
public boolean isReal()
```

isReal

public static boolean isReal(Complex a,
                             double lim)

isReal

public static boolean isReal(Complex[] a,
                             double lim)

isReal
```
public boolean isReal(double lim)
```

isRealPerCent

public static boolean isRealPerCent(Complex a,
                                    double percent)

isRealPerCent

public static boolean isRealPerCent(Complex[] a,
                                    double percent)

isRealperCent

public boolean isRealperCent(double percent)

isZero

public static boolean isZero(Complex a)

isZero
```
public boolean isZero()
```

isPlusInfinity
```
public boolean isPlusInfinity()
```

isPlusInfinity

public static boolean isPlusInfinity(Complex a)

isMinusInfinity
```
public boolean isMinusInfinity()
```

isMinusInfinity

public static boolean isMinusInfinity(Complex a)

isInfinite

public static boolean isInfinite(Complex a)

isInfinite
```
public boolean isInfinite()
```

isNaN

public static boolean isNaN(Complex a)

isNaN
```
public boolean isNaN()
```

equals
```
public boolean equals(Complex a)
```

isEqual
```
public boolean isEqual(Complex a)
```

isEqual

public static boolean isEqual(Complex a,
                              Complex b)

equalsWithinLimits

public boolean equalsWithinLimits(Complex a,
                                  double fract)

isEqualWithinLimits

public boolean isEqualWithinLimits(Complex a,
                                   double fract)

isEqualWithinLimits

public static boolean isEqualWithinLimits(Complex a,
                                          Complex b,
                                          double fract)

zero
```
public static Complex zero()
```

plusOne
```
public static Complex plusOne()
```

minusOne
```
public static Complex minusOne()
```

plusJay
```
public static Complex plusJay()
```

minusJay
```
public static Complex minusJay()
```

pi
```
public static Complex pi()
```

twoPiJay
```
public static Complex twoPiJay()
```

plusInfinity
```
public static Complex plusInfinity()
```

minusInfinity
```
public static Complex minusInfinity()
```

Class Complex

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Complex

Complex

Complex

Complex

Method Detail

setReal

setImag

reset

polarRad

polar

polarDeg

getReal

getImag

readComplex

readComplex

readComplex

readComplex

println

println

print

print

println

println

print

print

toString

toString

setj

seti

getjori

parseComplex

valueOf

hashCode

swap

oneDarray

oneDarray

mean

oneDarray

twoDarray

twoDarray

twoDarray

threeDarray

threeDarray

threeDarray

copy

copy

copy

copy

copy

clone

plus

plus

plus

plus

plus

plus

plusEquals

plusEquals

minus

minus

minus

minus

minus

minus

transposedMinus

minusEquals

minusEquals

setInfOption

setInfOption

getInfOption

times

times

times

times

times