Complex

java.lang.Object
- org.mathIT.numbers.Complex

```
public class Complex
extends Object
```
This class enables the creation of objects representing complex numbers, as well the implementation of mathematical functions of complex numbers by static methods. A complex number z ∈ ℂ is uniquely determined by z = x + iy, where x and y are real numbers and i = √-1. In the class Complex, a complex number z is internally represented by a double-array of length 2, where z[0] = x = Re z, and z[1] = y = Im z. In the sequel this representation is called array representation of complex numbers. It is the purpose of the static methods to provide this fast representation directly without generating complex number objects.

Version:

1.1

Author:

Andreas de Vries

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`ACCURACY` Accuracy up to which equality of double values are computed in methods of this class.
`static Complex`	`I` Constant i ∈ ℂ.
`static Complex`	`ONE` Constant 1 ∈ ℂ.
`static Complex`	`ZERO` Constant 0 ∈ ℂ.

Constructor Summary

Constructors
Constructor and Description
`Complex(double[] z)` Creates a complex number z = z[0] + iz[1] from the "array representation," i.e., with real part z[0] and imaginary part z[1].
`Complex(double x, double y)` Creates a complex number z = x + iy with real part x and imaginary part y.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`double`	`abs()` Returns the absolute value, or complex modulus, \|z\| of z ∈ ℂ of this complex number z.
`static double`	`abs(Complex z)` Returns the absolute value, or complex modulus, \|z\| of z ∈ ℂ of the complex number z.
`static double`	`abs(double[] z)` Returns the absolute value, or complex modulus, \|z\| of z ∈ ℂ.
`Complex`	`add(Complex z)` Returns the sum of this number and the complex number z.
`static double[]`	`add(double[] x, double[] y)` Returns the sum of two complex numbers x and y.
`double`	`arg()` Returns the argument of this complex number z.
`static double`	`arg(Complex z)` Returns the argument of the complex number z.
`static double`	`arg(double[] z)` Returns the argument of the complex number z.
`static Complex`	`cos(Complex z)` Returns the cosine of this complex number.
`static double[]`	`cos(double[] z)` Returns the cosine of a complex number z.
`Complex`	`divide(Complex z)` divides this complex numbers by z.
`static double[]`	`divide(double[] x, double[] y)` divides two complex numbers x and y.
`static Complex`	`divide(double x, Complex y)` divides a real number x by a complex number y.
`static double[]`	`divide(double x, double[] y)` divides a real number x by a complex number y.
`static Complex`	`exp(Complex z)` The exponential function of the complex number z.
`static double[]`	`exp(double[] z)` The exponential function of a complex number z.
`static Complex`	`gamma(Complex z)` The Euler gamma function Γ(z) of a complex number z.
`static double[]`	`gamma(double[] z)` The Euler gamma function Γ(z) of a complex number z.
`double`	`getIm()` Returns the imaginary part Imz of this complex number z.
`double`	`getRe()` Returns the real part Rez of this complex number z.
`static Complex`	`ln(Complex z)` Logarithm of this complex number z.
`static double[]`	`ln(double[] z)` Logarithm of a complex number z.
`static double[]`	`lnCos(double[] z)` Returns the natural logarithm of the cosine of a complex number z.
`static Complex`	`lnGamma(Complex z)` Logarithm of the Euler gamma function of a complex number z.
`static double[]`	`lnGamma(double[] z)` Logarithm of the Euler gamma function of a complex number z.
`static Complex`	`lnSin(Complex z)` Returns the natural logarithm of the sine of a complex number z.
`static double[]`	`lnSin(double[] z)` Returns the natural logarithm of the sine of a complex number z.
`Complex`	`minus(Complex z)` subtracts z from this complex number.
`Complex`	`multiply(Complex z)` Returns the product of this complex number and the complex number z.
`static Complex`	`multiply(Complex x, Complex y)` The product of two complex numbers.
`Complex`	`multiply(double x)` The product of a real number x with this complex number.
`static double[]`	`multiply(double[] x, double[] y)` The product of two complex numbers.
`static double[]`	`multiply(double x, double[] z)` The product of a real number x and a complex number z.
`Complex`	`plus(Complex z)` Returns the sum of this number and the complex number z.
`Complex`	`pow(Complex s)` Returns z^s where z is this complex number, and s is a complex number.
`static double[]`	`power(double[] z, double[] s)` Returns z^s for two complex numbers z, s.
`static Complex`	`power(double x, Complex s)` Returns x^s for a real number x and a complex number s.
`static double[]`	`power(double x, double[] s)` Returns x^s for a real number x and a complex number s.
`Complex`	`reciprocal()` Returns the reciprocal of this number.
`static double[]`	`reciprocal(double[] y)` Returns the reciprocal of a complex number y.
`Complex`	`sin()` Returns the sine of this complex number.
`static Complex`	`sin(Complex z)` Returns the sine of a complex number z.
`static double[]`	`sin(double[] z)` Returns the sine of a complex number z.
`static Complex`	`sqrt(Complex z)` Returns the square root of a complex number z.
`static double[]`	`sqrt(double[] z)` Returns the square root of a complex number z.
`Complex`	`subtract(Complex z)` subtracts z from this complex number.
`static double[]`	`subtract(double[] x, double[] y)` subtracts two complex numbers x and y.
`String`	`toString()` Returns a string representation of this complex number in a "readable" standard format.
`static String`	`toString(Complex z)` Returns a string representation of the complex number z in a "readable" standard format.
`static String`	`toString(Complex z, DecimalFormat digit)` Returns a string representation of this complex number in a "readable" standard format.
`static String`	`toString(double[] z)` displays a complex number to a "readable" standard format.
`static String`	`toString(double[] z, DecimalFormat digit)` displays a complex number to the "readable" format `digit`.

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

Field Detail
- ACCURACY
```
public static final double ACCURACY
```
  Accuracy up to which equality of double values are computed in methods of this class. Its current value is 1.0E-10. It is used, for instance, in the methods gamma(Complex), lnGamma(Complex), or pow(Complex).
  
  See Also:
  
  Constant Field Values
- ZERO
```
public static final Complex ZERO
```
  Constant 0 ∈ ℂ.
- ONE
```
public static final Complex ONE
```
  Constant 1 ∈ ℂ.
- I
```
public static final Complex I
```
  Constant i ∈ ℂ.

Constructor Detail
- Complex
```
public Complex(double x,
               double y)
```
  Creates a complex number z = x + iy with real part x and imaginary part y.
  
  Parameters:
  
  x - the real part of the complex number
  
  y - the imaginary part of the complex number
- Complex
```
public Complex(double[] z)
```
  Creates a complex number z = z[0] + iz[1] from the "array representation," i.e., with real part z[0] and imaginary part z[1].
  
  Parameters:
  
  z - an array with z[0] representing the real part and z[1] representing the imaginary part of the complex number

Method Detail

getRe
```
public double getRe()
```
Returns the real part Rez of this complex number z. For z = x + iy it is defined as Rez = x.

Returns:

Rez

getIm
```
public double getIm()
```
Returns the imaginary part Imz of this complex number z. For z = x + iy it is defined as Imz = y.

Returns:

Imz

abs
```
public static double abs(double[] z)
```
Returns the absolute value, or complex modulus, |z| of z ∈ ℂ. For z = x + iy it is defined as |z| = √(x² + y²).

Parameters:

z - the complex number z in the array representation

Returns:

|z|

abs
```
public static double abs(Complex z)
```
Returns the absolute value, or complex modulus, |z| of z ∈ ℂ of the complex number z. For z = x + iy it is defined as |z| = √(x² + y²).

Parameters:

z - a complex number

Returns:

|z|

abs
```
public double abs()
```
Returns the absolute value, or complex modulus, |z| of z ∈ ℂ of this complex number z. For z = x + iy it is defined as |z| = √(x² + y²).

Returns:

|this|

add
```
public static double[] add(double[] x,
                           double[] y)
```
Returns the sum of two complex numbers x and y. For x = x₀ + ix₁ and y = y₀ + iy₁, we have
x + y = x₀ + y₀ + i (x₁ + y₁)

Parameters:

x - the first addend in the array representation

y - the second addend in the array representation

Returns:

the sum x + y

See Also:

add(Complex)

add
```
public Complex add(Complex z)
```
Returns the sum of this number and the complex number z. For x = x₀ + ix₁ and y = y₀ + iy₁, we have
x + y = x₀ + y₀ + i (x₁ + y₁)

Parameters:

z - the addend

Returns:

the sum this + z

See Also:

plus(Complex), add(double[],double[])

arg
```
public static double arg(double[] z)
```
Returns the argument of the complex number z. If z = x + iy, we have arg(z) = arctan(y/x).

Parameters:

z - a complex number

Returns:

the argument of z

See Also:

arg(Complex)

arg
```
public static double arg(Complex z)
```
Returns the argument of the complex number z. If z = x + iy, we have arg(z) = arctan(y/x).

Parameters:

z - a complex number

Returns:

the argument of z

See Also:

arg(), arg(double[])

arg
```
public double arg()
```
Returns the argument of this complex number z. If z = x + iy, we have arg(z) = arctan(y/x).

Returns:

the argument of this

See Also:

arg(Complex), arg(double[])

cos
```
public static double[] cos(double[] z)
```
Returns the cosine of a complex number z.

Parameters:

z - the argument

Returns:

the cosine

cos
```
public static Complex cos(Complex z)
```
Returns the cosine of this complex number.

Parameters:

z - the argument

Returns:

the cosine

divide
```
public static double[] divide(double x,
                              double[] y)
```
divides a real number x by a complex number y. This method is implemented avoiding overflows.

Parameters:

x - the dividend

y - the divisor

Returns:

the complex number x/y

See Also:

divide(double, Complex), divide(double[], double[])

divide
```
public static Complex divide(double x,
                             Complex y)
```
divides a real number x by a complex number y. This method is implemented avoiding overflows.

Parameters:

x - the dividend

y - the divisor

Returns:

x/y

See Also:

divide(double, double[])

divide
```
public static double[] divide(double[] x,
                              double[] y)
```
divides two complex numbers x and y. This method is implemented avoiding overflows.

Parameters:

x - dividend

y - divisor

Returns:

x/y

See Also:

divide(double, double[])

divide
```
public Complex divide(Complex z)
```
divides this complex numbers by z. This method is implemented avoiding overflows.

Parameters:

z - divisor

Returns:

this/z

See Also:

divide(double[], double[])

exp
```
public static double[] exp(double[] z)
```
The exponential function of a complex number z. The following formula holds for z = x + iy:
exp(z) = e^x (cosy + i sin y).

Parameters:

z - a complex number

Returns:

exp(z)

See Also:

ln(double[])

exp
```
public static Complex exp(Complex z)
```
The exponential function of the complex number z. The following formula holds for z = x + iy:
exp(z) = e^x (cosy + i sin y),
where z is this complex number.

Parameters:

z - the argument

Returns:

exp(z) where z is this complex number

See Also:

ln(Complex)

gamma

public static double[] gamma(double[] z)

The Euler gamma function Γ(z) of a complex number z. For Re z > 0, it is computed according to the method of Lanczos. Otherwise, the following formula of Weierstrass is applied, which holds for any z but converges more slowly.

Γ(z)

z e^γz

∞

n=1

[

(

1 +

)^-1

e^z/n

]

It is approximated up to a relative error of 10⁶ times the given accuracy. Here γ denotes the Euler-Mascheroni constant.

Parameters:: z - a complex number
Returns:: Γ(z)
See Also:: gamma(Complex), lnGamma(double[]), Numbers.gamma(double)

gamma

public static Complex gamma(Complex z)

Γ(z)

z e^γz

∞

n=1

[

(

1 +

)^-1

e^z/n

]

It is approximated up to a relative error of 10⁶ times the given accuracy. Here γ denotes the Euler-Mascheroni constant.

Parameters:: z - a complex number
Returns:: Γ(z)
See Also:: exp(double[]), Numbers.gamma(double)

lnCos
```
public static double[] lnCos(double[] z)
```
Returns the natural logarithm of the cosine of a complex number z.

Parameters:

z - the argument

Returns:

the natural logarithm of the cosine of z

ln
```
public static Complex ln(Complex z)
```
Logarithm of this complex number z. It is defined by ln z = ln |z| + i arg(z).

Parameters:

z - the argument

Returns:

ln z where z is this complex number

See Also:

abs(Complex), arg(Complex), exp(Complex), ln(double[])

ln
```
public static double[] ln(double[] z)
```
Logarithm of a complex number z. It is defined by ln z = ln |z| + i arg(z).

Parameters:

z - complex number

Returns:

ln z

See Also:

abs(double[]), arg(double[]), exp(double[]), ln(Complex)

lnGamma

public static double[] lnGamma(double[] z)

Logarithm of the Euler gamma function of a complex number z. For Re z > 0, it is computed according to the method of Lanczos. Otherwise, the following formula is applied, which holds for any z but converges more slowly.

ln Γ(z)

- ln z - γz

∞

n=1

[

- ln

(

1 +

)

]

Here γ denotes the Euler-Mascheroni constant.

Parameters:: z - a complex number
Returns:: ln Γ(z)
See Also:: lnGamma(Complex), gamma(double[])

lnGamma

public static Complex lnGamma(Complex z)

ln Γ(z)

- ln z - γz

∞

n=1

[

- ln

(

1 +

)

]

Here γ denotes the Euler-Mascheroni constant.

Parameters:: z - a complex number
Returns:: ln Γ(z)
See Also:: gamma(Complex), lnGamma(double[])

lnSin
```
public static Complex lnSin(Complex z)
```
Returns the natural logarithm of the sine of a complex number z.

Parameters:

z - a complex number in the array representation

Returns:

lnSin z

lnSin
```
public static double[] lnSin(double[] z)
```
Returns the natural logarithm of the sine of a complex number z.

Parameters:

z - a complex number in the array representation

Returns:

lnSin z

minus
```
public Complex minus(Complex z)
```
subtracts z from this complex number. We have this.subtract(z) = this - z = Re (this - y) + Im (this - z).

Parameters:

z - a complex number

Returns:

the difference this - z

See Also:

subtract(Complex)

multiply
```
public static double[] multiply(double x,
                                double[] z)
```
The product of a real number x and a complex number z.

Parameters:

x - a real number

z - a complex number in the array representation

Returns:

the product xz

multiply
```
public Complex multiply(double x)
```
The product of a real number x with this complex number.

Parameters:

x - a real number

Returns:

the product xz where z is this complex number

multiply
```
public static Complex multiply(Complex x,
                               Complex y)
```
The product of two complex numbers. For x = x₀ + ix₁ and y = y₀ + iy₁, we have
xy = x₀y₀ - x₁y₁ + i (x₁y₀ + x₀y₁)

Parameters:

x - the first factor in the array representation

y - the second factor in the array representation

Returns:

the product xy

multiply
```
public static double[] multiply(double[] x,
                                double[] y)
```
The product of two complex numbers. For x = x₀ + ix₁ and y = y₀ + iy₁, we have
xy = x₀y₀ - x₁y₁ + i (x₁y₀ + x₀y₁)

Parameters:

x - the first factor in the array representation

y - the second factor in the array representation

Returns:

the product xy

multiply
```
public Complex multiply(Complex z)
```
Returns the product of this complex number and the complex number z. For x = x₀ + ix₁ and y = y₀ + iy₁, we have
xy = x₀y₀ - x₁y₁ + i (x₁y₀ + x₀y₁)

Parameters:

z - a complex number

Returns:

the product this∙z

plus
```
public Complex plus(Complex z)
```
Returns the sum of this number and the complex number z. For x = x₀ + ix₁ and y = y₀ + iy₁, we have
x + y = x₀ + y₀ + i (x₁ + y₁)

Parameters:

z - the addend

Returns:

the sum this + z

See Also:

add(Complex)

power
```
public static Complex power(double x,
                            Complex s)
```
Returns x^s for a real number x and a complex number s. For s = s₀ + is₁, we have
x^s = x^s₀ [ cos( s₁ ln x ) + i sin( s₁ ln x ) ].

if x > 0, and

x^s = |x|^s₀ [ cos( s₁ ln |x| + s₀π) + i sin( s₁ ln |x| + s₀π) ].

Parameters:

x - a real number as the base

s - a complex number as the exponent

Returns:

z^s

See Also:

pow(Complex), power(double,double[])

power
```
public static double[] power(double x,
                             double[] s)
```
Returns x^s for a real number x and a complex number s. For s = s₀ + is₁, we have
x^s = x^s₀ [ cos( s₁ ln x ) + i sin( s₁ ln x ) ].

if x > 0, and

x^s = |x|^s₀ [ cos( s₁ ln |x| + s₀π) + i sin( s₁ ln |x| + s₀π) ].

Parameters:

x - a real number as the base

s - a complex number in the array representation as the exponent

Returns:

z^s

See Also:

power(double,double[]), pow(Complex)

pow
```
public Complex pow(Complex s)
```
Returns z^s where z is this complex number, and s is a complex number. For z = r e^iφ (that is, r = |z| and φ = arg z), and s = x + iy, we have
z^s = r^x e^-yφ [ cos( xφ + y ln r ) + i sin( xφ + y ln r ) ].

Parameters:

s - the exponent

Returns:

z^s where z is this complex number

See Also:

power(double[],double[])

power
```
public static double[] power(double[] z,
                             double[] s)
```
Returns z^s for two complex numbers z, s. For z = r e^iφ (that is, r = |z| and φ = arg z), and s = x + iy, we have
z^s = r^x e^-yφ [ cos( xφ + y ln r ) + i sin( xφ + y ln r ) ].

Parameters:

z - the base

s - the exponent

Returns:

z^s

See Also:

power(double,double[])

reciprocal
```
public static double[] reciprocal(double[] y)
```
Returns the reciprocal of a complex number y. This method is implemented avoiding overflows.

Parameters:

y - a complex number

Returns:

1/y

See Also:

divide(double, double[]), reciprocal()

reciprocal
```
public Complex reciprocal()
```
Returns the reciprocal of this number. This method is implemented avoiding overflows.

Returns:

1/this

See Also:

reciprocal(double[])

sin
```
public static double[] sin(double[] z)
```
Returns the sine of a complex number z.

Parameters:

z - a complex number in the array representation

Returns:

sin z

sin
```
public static Complex sin(Complex z)
```
Returns the sine of a complex number z.

Parameters:

z - a complex number

Returns:

sin z

sin
```
public Complex sin()
```
Returns the sine of this complex number.

Returns:

sin z

sqrt
```
public static double[] sqrt(double[] z)
```
Returns the square root of a complex number z.

Parameters:

z - a complex number in the array representation

Returns:

the suare root of z

sqrt
```
public static Complex sqrt(Complex z)
```
Returns the square root of a complex number z.

Parameters:

z - a complex number

Returns:

the suare root of z

subtract
```
public static double[] subtract(double[] x,
                                double[] y)
```
subtracts two complex numbers x and y. We have subtract(x, y) = x - y = Re (x - y) + Im (x - y).

Parameters:

x - a complex number in the array representation

y - a complex number in the array representation

Returns:

the difference x - y

subtract
```
public Complex subtract(Complex z)
```
subtracts z from this complex number. We have this.subtract(z) = this - z = Re (this - y) + Im (this - z).

Parameters:

z - a complex number

Returns:

the difference this - z

See Also:

minus(Complex), subtract(double[],double[])

toString
```
public String toString()
```
Returns a string representation of this complex number in a "readable" standard format.

Overrides:

toString in class Object

Returns:

a string representing z

See Also:

toString(double[],java.text.DecimalFormat)

toString
```
public static String toString(Complex z)
```
Returns a string representation of the complex number z in a "readable" standard format.

Parameters:

z - the complex number to be formatted

Returns:

a string representing z

See Also:

toString(double[])

toString
```
public static String toString(double[] z)
```
displays a complex number to a "readable" standard format.

Parameters:

z - the complex number to be formatted

Returns:

a string representing z

See Also:

toString(double[],java.text.DecimalFormat)

toString
```
public static String toString(Complex z,
                              DecimalFormat digit)
```
Returns a string representation of this complex number in a "readable" standard format.

Parameters:

z - the complex number to be formatted

digit - the decimal format in which z is to be displayed

Returns:

a string representing z in the specified decimal format

See Also:

toString(double[],java.text.DecimalFormat)

toString
```
public static String toString(double[] z,
                              DecimalFormat digit)
```
displays a complex number to the "readable" format digit. If the real or the imaginary part are too large or too small, scientific notation is used.

Parameters:

z - the complex number to be formatted

digit - the decimal format in which z is to be displayed

Returns:

a string representing z in the specified decimal format

See Also:

toString(double[])

Class Complex

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ACCURACY

ZERO

ONE

I

Constructor Detail

Complex

Complex

Method Detail

getRe

getIm

abs

abs

abs

add

add

arg

arg

arg

cos

cos

divide

divide

divide

divide

exp

exp

gamma

gamma

lnCos

ln

ln

lnGamma

lnGamma

lnSin

lnSin

minus

multiply

multiply

multiply

multiply

multiply

plus

power

power

pow

power

reciprocal

reciprocal

sin

sin

sin

sqrt

sqrt

subtract

subtract

toString

toString

toString

toString

toString