public class Complex extends Object implements FieldElement<Complex>, Serializable
Implementations of arithmetic operations handle NaN and
infinite values according to the rules for Double, i.e.
equals(java.lang.Object) is an equivalence relation for all instances that have
a NaN in either real or imaginary part, e.g. the following are
considered equal:
1 + NaNiNaN + iNaN + NaNi
Note that this contradicts the IEEE-754 standard for floating
point numbers (according to which the test x == x must fail if
x is NaN). The method
equals for primitive double in Precision
conforms with IEEE-754 while this class conforms with the standard behavior
for Java object types.
| Modifier and Type | Field and Description |
|---|---|
static Complex |
I
The square root of -1.
|
static Complex |
INF
A complex number representing "+INF + INFi"
|
static Complex |
NaN
A complex number representing "NaN + NaNi"
|
static Complex |
ONE
A complex number representing "1.0 + 0.0i"
|
static Complex |
ZERO
A complex number representing "0.0 + 0.0i"
|
| Constructor and Description |
|---|
Complex(double real)
Create a complex number given only the real part.
|
Complex(double real,
double imaginary)
Create a complex number given the real and imaginary parts.
|
| Modifier and Type | Method and Description |
|---|---|
double |
abs()
Return the absolute value of this complex number.
|
Complex |
acos()
Compute the
inverse cosine of this complex number.
|
Complex |
add(Complex addend)
Returns a
Complex whose value is
(this + addend). |
Complex |
add(double addend)
Returns a
Complex whose value is (this + addend),
with addend interpreted as a real number. |
Complex |
asin()
Compute the
inverse sine of this complex number.
|
Complex |
atan()
Compute the
inverse tangent of this complex number.
|
Complex |
conjugate()
Returns the conjugate of this complex number.
|
Complex |
cos()
Compute the
cosine of this complex number.
|
Complex |
cosh()
Compute the
hyperbolic cosine of this complex number.
|
protected Complex |
createComplex(double realPart,
double imaginaryPart)
Create a complex number given the real and imaginary parts.
|
Complex |
divide(Complex divisor)
Returns a
Complex whose value is
(this / divisor). |
Complex |
divide(double divisor)
Returns a
Complex whose value is (this / divisor),
with divisor interpreted as a real number. |
static boolean |
equals(Complex x,
Complex y)
Returns
true iff the values are equal as defined by
equals(x, y, 1). |
static boolean |
equals(Complex x,
Complex y,
double eps)
Returns
true if, both for the real part and for the imaginary
part, there is no double value strictly between the arguments or the
difference between them is within the range of allowed error
(inclusive). |
static boolean |
equals(Complex x,
Complex y,
int maxUlps)
Test for the floating-point equality between Complex objects.
|
boolean |
equals(Object other)
Test for equality with another object.
|
static boolean |
equalsWithRelativeTolerance(Complex x,
Complex y,
double eps)
Returns
true if, both for the real part and for the imaginary
part, there is no double value strictly between the arguments or the
relative difference between them is smaller or equal to the given
tolerance. |
Complex |
exp()
Compute the
exponential function of this complex number.
|
double |
getArgument()
Compute the argument of this complex number.
|
ComplexField |
getField()
Get the
Field to which the instance belongs. |
double |
getImaginary()
Access the imaginary part.
|
double |
getReal()
Access the real part.
|
int |
hashCode()
Get a hashCode for the complex number.
|
boolean |
isInfinite()
Checks whether either the real or imaginary part of this complex number
takes an infinite value (either
Double.POSITIVE_INFINITY or
Double.NEGATIVE_INFINITY) and neither part
is NaN. |
boolean |
isNaN()
Checks whether either or both parts of this complex number is
NaN. |
Complex |
log()
Compute the
natural logarithm of this complex number.
|
Complex |
multiply(Complex factor)
Returns a
Complex whose value is this * factor. |
Complex |
multiply(double factor)
Returns a
Complex whose value is this * factor, with factor
interpreted as a real number. |
Complex |
multiply(int factor)
Returns a
Complex whose value is this * factor, with factor
interpreted as a integer number. |
Complex |
negate()
Returns a
Complex whose value is (-this). |
List<Complex> |
nthRoot(int n)
Computes the n-th roots of this complex number.
|
Complex |
pow(Complex x)
Returns of value of this complex number raised to the power of
x. |
Complex |
pow(double x)
Returns of value of this complex number raised to the power of
x. |
protected Object |
readResolve()
Resolve the transient fields in a deserialized Complex Object.
|
Complex |
reciprocal()
Returns the multiplicative inverse of
this element. |
Complex |
sin()
Compute the
sine
of this complex number.
|
Complex |
sinh()
Compute the
hyperbolic sine of this complex number.
|
Complex |
sqrt()
Compute the
square root of this complex number.
|
Complex |
sqrt1z()
Compute the
square root of
1 - this2 for this complex
number. |
Complex |
subtract(Complex subtrahend)
Returns a
Complex whose value is
(this - subtrahend). |
Complex |
subtract(double subtrahend)
Returns a
Complex whose value is
(this - subtrahend). |
Complex |
tan()
Compute the
tangent of this complex number.
|
Complex |
tanh()
Compute the
hyperbolic tangent of this complex number.
|
String |
toString() |
static Complex |
valueOf(double realPart)
Create a complex number given only the real part.
|
static Complex |
valueOf(double realPart,
double imaginaryPart)
Create a complex number given the real and imaginary parts.
|
public static final Complex I
public static final Complex NaN
public static final Complex INF
public static final Complex ONE
public static final Complex ZERO
public Complex(double real)
real - Real part.public Complex(double real,
double imaginary)
real - Real part.imaginary - Imaginary part.public double abs()
NaN if either real or imaginary part is NaN
and Double.POSITIVE_INFINITY if neither part is NaN,
but at least one part is infinite.public Complex add(Complex addend) throws NullArgumentException
Complex whose value is
(this + addend).
Uses the definitional formula
(a + bi) + (c + di) = (a+c) + (b+d)i
this or addend has a NaN value in
either part, NaN is returned; otherwise Infinite
and NaN values are returned in the parts of the result
according to the rules for Double arithmetic.add in interface FieldElement<Complex>addend - Value to be added to this Complex.this + addend.NullArgumentException - if addend is null.public Complex add(double addend)
Complex whose value is (this + addend),
with addend interpreted as a real number.addend - Value to be added to this Complex.this + addend.add(Complex)public Complex conjugate()
a + bi is a - bi.
NaN is returned if either the real or imaginary
part of this Complex number equals Double.NaN.
If the imaginary part is infinite, and the real part is not
NaN, the returned value has infinite imaginary part
of the opposite sign, e.g. the conjugate of
1 + POSITIVE_INFINITY i is 1 - NEGATIVE_INFINITY i.
public Complex divide(Complex divisor) throws NullArgumentException
Complex whose value is
(this / divisor).
Implements the definitional formula
a + bi ac + bd + (bc - ad)i
----------- = -------------------------
c + di c2 + d2
but uses
prescaling of operands to limit the effects of overflows and
underflows in the computation.
Infinite and NaN values are handled according to the
following rules, applied in the order presented:
this or divisor has a NaN value
in either part, NaN is returned.
divisor equals ZERO, NaN is returned.
this and divisor are both infinite,
NaN is returned.
this is finite (i.e., has no Infinite or
NaN parts) and divisor is infinite (one or both parts
infinite), ZERO is returned.
this is infinite and divisor is finite,
NaN values are returned in the parts of the result if the
Double rules applied to the definitional formula
force NaN results.
divide in interface FieldElement<Complex>divisor - Value by which this Complex is to be divided.this / divisor.NullArgumentException - if divisor is null.public Complex divide(double divisor)
Complex whose value is (this / divisor),
with divisor interpreted as a real number.divisor - Value by which this Complex is to be divided.this / divisor.divide(Complex)public Complex reciprocal()
this element.reciprocal in interface FieldElement<Complex>this.public boolean equals(Object other)
Double.NaN, the two
Complex objects are considered to be equal.
The behavior is the same as for JDK's Double:
NaN values are considered to be equal,
i.e, if either (or both) real and imaginary parts of the complex
number are equal to Double.NaN, the complex number is equal
to NaN.
public static boolean equals(Complex x, Complex y, int maxUlps)
true if both arguments are equal or within the
range of allowed error (inclusive).x - First value (cannot be null).y - Second value (cannot be null).maxUlps - (maxUlps - 1) is the number of floating point
values between the real (resp. imaginary) parts of x and
y.true if there are fewer than maxUlps floating
point values between the real (resp. imaginary) parts of x
and y.Precision.equals(double,double,int)public static boolean equals(Complex x, Complex y)
true iff the values are equal as defined by
equals(x, y, 1).x - First value (cannot be null).y - Second value (cannot be null).true if the values are equal.public static boolean equals(Complex x, Complex y, double eps)
true if, both for the real part and for the imaginary
part, there is no double value strictly between the arguments or the
difference between them is within the range of allowed error
(inclusive). Returns false if either of the arguments is NaN.x - First value (cannot be null).y - Second value (cannot be null).eps - Amount of allowed absolute error.true if the values are two adjacent floating point
numbers or they are within range of each other.Precision.equals(double,double,double)public static boolean equalsWithRelativeTolerance(Complex x, Complex y, double eps)
true if, both for the real part and for the imaginary
part, there is no double value strictly between the arguments or the
relative difference between them is smaller or equal to the given
tolerance. Returns false if either of the arguments is NaN.x - First value (cannot be null).y - Second value (cannot be null).eps - Amount of allowed relative error.true if the values are two adjacent floating point
numbers or they are within range of each other.Precision.equalsWithRelativeTolerance(double,double,double)public int hashCode()
Double.NaN value in real or imaginary part produces
the same hash code 7.public double getImaginary()
public double getReal()
public boolean isNaN()
NaN.NaN; false otherwise.public boolean isInfinite()
Double.POSITIVE_INFINITY or
Double.NEGATIVE_INFINITY) and neither part
is NaN.NaN.public Complex multiply(Complex factor) throws NullArgumentException
Complex whose value is this * factor.
Implements preliminary checks for NaN and infinity followed by
the definitional formula:
(a + bi)(c + di) = (ac - bd) + (ad + bc)i
NaN if either this or factor has one or
more NaN parts.
Returns INF if neither this nor factor has one
or more NaN parts and if either this or factor
has one or more infinite parts (same result is returned regardless of
the sign of the components).
Returns finite values in components of the result per the definitional formula in all remaining cases.
multiply in interface FieldElement<Complex>factor - value to be multiplied by this Complex.this * factor.NullArgumentException - if factor is null.public Complex multiply(int factor)
Complex whose value is this * factor, with factor
interpreted as a integer number.multiply in interface FieldElement<Complex>factor - value to be multiplied by this Complex.this * factor.multiply(Complex)public Complex multiply(double factor)
Complex whose value is this * factor, with factor
interpreted as a real number.factor - value to be multiplied by this Complex.this * factor.multiply(Complex)public Complex negate()
Complex whose value is (-this).
Returns NaN if either real or imaginary
part of this Complex number is Double.NaN.negate in interface FieldElement<Complex>-this.public Complex subtract(Complex subtrahend) throws NullArgumentException
Complex whose value is
(this - subtrahend).
Uses the definitional formula
(a + bi) - (c + di) = (a-c) + (b-d)i
this or subtrahend has a NaN] value in either part,
NaN is returned; otherwise infinite and NaN values are
returned in the parts of the result according to the rules for
Double arithmetic.subtract in interface FieldElement<Complex>subtrahend - value to be subtracted from this Complex.this - subtrahend.NullArgumentException - if subtrahend is null.public Complex subtract(double subtrahend)
Complex whose value is
(this - subtrahend).subtrahend - value to be subtracted from this Complex.this - subtrahend.subtract(Complex)public Complex acos()
acos(z) = -i (log(z + i (sqrt(1 - z<sup>2</sup>))))
NaN if either real or imaginary part of the
input argument is NaN or infinite.public Complex asin()
asin(z) = -i (log(sqrt(1 - z<sup>2</sup>) + iz))
Returns NaN if either real or imaginary part of the
input argument is NaN or infinite.
public Complex atan()
atan(z) = (i/2) log((i + z)/(i - z))
Returns NaN if either real or imaginary part of the
input argument is NaN or infinite.
public Complex cos()
cos(a + bi) = cos(a)cosh(b) - sin(a)sinh(b)i
where the (real) functions on the right-hand side are
FastMath.sin(double), FastMath.cos(double),
FastMath.cosh(double) and FastMath.sinh(double).
Returns NaN if either real or imaginary part of the
input argument is NaN.
Infinite values in real or imaginary parts of the input may result in infinite or NaN values returned in parts of the result.
Examples:
cos(1 ± INFINITY i) = 1 ∓ INFINITY i
cos(±INFINITY + i) = NaN + NaN i
cos(±INFINITY ± INFINITY i) = NaN + NaN i
public Complex cosh()
cosh(a + bi) = cosh(a)cos(b) + sinh(a)sin(b)i
where the (real) functions on the right-hand side are
FastMath.sin(double), FastMath.cos(double),
FastMath.cosh(double) and FastMath.sinh(double).
Returns NaN if either real or imaginary part of the
input argument is NaN.
Examples:
cosh(1 ± INFINITY i) = NaN + NaN i
cosh(±INFINITY + i) = INFINITY ± INFINITY i
cosh(±INFINITY ± INFINITY i) = NaN + NaN i
public Complex exp()
exp(a + bi) = exp(a)cos(b) + exp(a)sin(b)i
where the (real) functions on the right-hand side are
FastMath.exp(double), FastMath.cos(double), and
FastMath.sin(double).
Returns NaN if either real or imaginary part of the
input argument is NaN.
Examples:
exp(1 ± INFINITY i) = NaN + NaN i
exp(INFINITY + i) = INFINITY + INFINITY i
exp(-INFINITY + i) = 0 + 0i
exp(±INFINITY ± INFINITY i) = NaN + NaN i
ethis.public Complex log()
log(a + bi) = ln(|a + bi|) + arg(a + bi)i
where ln on the right hand side is FastMath.log(double),
|a + bi| is the modulus, abs(), and
arg(a + bi) = FastMath.atan2(double, double)(b, a).
Returns NaN if either real or imaginary part of the
input argument is NaN.
Examples:
log(1 ± INFINITY i) = INFINITY ± (π/2)i
log(INFINITY + i) = INFINITY + 0i
log(-INFINITY + i) = INFINITY + πi
log(INFINITY ± INFINITY i) = INFINITY ± (π/4)i
log(-INFINITY ± INFINITY i) = INFINITY ± (3π/4)i
log(0 + 0i) = -INFINITY + 0i
ln this, the natural logarithm
of this.public Complex pow(Complex x) throws NullArgumentException
x.
Implements the formula:
yx = exp(x·log(y))
where exp and log are exp() and
log(), respectively.
Returns NaN if either real or imaginary part of the
input argument is NaN or infinite, or if y
equals ZERO.
x - exponent to which this Complex is to be raised. thisx.NullArgumentException - if x is null.public Complex pow(double x)
x.x - exponent to which this Complex is to be raised.thisx.pow(Complex)public Complex sin()
sin(a + bi) = sin(a)cosh(b) - cos(a)sinh(b)i
where the (real) functions on the right-hand side are
FastMath.sin(double), FastMath.cos(double),
FastMath.cosh(double) and FastMath.sinh(double).
Returns NaN if either real or imaginary part of the
input argument is NaN.
Infinite values in real or imaginary parts of the input may result in
infinite or NaN values returned in parts of the result.
Examples:
sin(1 ± INFINITY i) = 1 ± INFINITY i
sin(±INFINITY + i) = NaN + NaN i
sin(±INFINITY ± INFINITY i) = NaN + NaN i
public Complex sinh()
sinh(a + bi) = sinh(a)cos(b)) + cosh(a)sin(b)i
where the (real) functions on the right-hand side are
FastMath.sin(double), FastMath.cos(double),
FastMath.cosh(double) and FastMath.sinh(double).
Returns NaN if either real or imaginary part of the
input argument is NaN.
Infinite values in real or imaginary parts of the input may result in infinite or NaN values returned in parts of the result.
Examples:
sinh(1 ± INFINITY i) = NaN + NaN i
sinh(±INFINITY + i) = ± INFINITY + INFINITY i
sinh(±INFINITY ± INFINITY i) = NaN + NaN i
this.public Complex sqrt()
sqrt(a + bi):
t = sqrt((|a| + |a + bi|) / 2)ifa ≥ 0returnt + (b/2t)ielse return|b|/2t + sign(b)t i
|a| = FastMath.abs(int)(a)|a + bi| = abs()(a + bi)sign(b) = copySign(1d, b)
Returns NaN if either real or imaginary part of the
input argument is NaN.
Examples:
sqrt(1 ± INFINITY i) = INFINITY + NaN i
sqrt(INFINITY + i) = INFINITY + 0i
sqrt(-INFINITY + i) = 0 + INFINITY i
sqrt(INFINITY ± INFINITY i) = INFINITY + NaN i
sqrt(-INFINITY ± INFINITY i) = NaN ± INFINITY i
this.public Complex sqrt1z()
1 - this2 for this complex
number.
Computes the result directly as
sqrt(ONE.subtract(z.multiply(z))).
Returns NaN if either real or imaginary part of the
input argument is NaN.
1 - this2.public Complex tan()
tan(a + bi) = sin(2a)/(cos(2a)+cosh(2b)) + [sinh(2b)/(cos(2a)+cosh(2b))]i
where the (real) functions on the right-hand side are
FastMath.sin(double), FastMath.cos(double), FastMath.cosh(double) and
FastMath.sinh(double).
Returns NaN if either real or imaginary part of the
input argument is NaN.
Examples:
tan(a ± INFINITY i) = 0 ± i
tan(±INFINITY + bi) = NaN + NaN i
tan(±INFINITY ± INFINITY i) = NaN + NaN i
tan(±π/2 + 0 i) = ±INFINITY + NaN i
this.public Complex tanh()
tan(a + bi) = sinh(2a)/(cosh(2a)+cos(2b)) + [sin(2b)/(cosh(2a)+cos(2b))]i
where the (real) functions on the right-hand side are
FastMath.sin(double), FastMath.cos(double), FastMath.cosh(double) and
FastMath.sinh(double).
Returns NaN if either real or imaginary part of the
input argument is NaN.
Examples:
tanh(a ± INFINITY i) = NaN + NaN i
tanh(±INFINITY + bi) = ±1 + 0 i
tanh(±INFINITY ± INFINITY i) = NaN + NaN i
tanh(0 + (π/2)i) = NaN + INFINITY i
this.public double getArgument()
If either real or imaginary part (or both) is NaN, NaN is returned.
Infinite parts are handled as Math.atan2 handles them,
essentially treating finite parts as zero in the presence of an
infinite coordinate and returning a multiple of pi/4 depending on
the signs of the infinite parts.
See the javadoc for Math.atan2 for full details.
this.public List<Complex> nthRoot(int n) throws NotPositiveException
zk = abs1/n (cos(phi + 2πk/n) + i (sin(phi + 2πk/n))
for k=0, 1, ..., n-1, where abs and phi
are respectively the modulus and
argument of this complex number.
If one or both parts of this complex number is NaN, a list with just
one element, NaN is returned.
if neither part is NaN, but at least one part is infinite, the result
is a one-element list containing INF.
n - Degree of root.n-th roots of this.NotPositiveException - if n <= 0.protected Complex createComplex(double realPart, double imaginaryPart)
realPart - Real part.imaginaryPart - Imaginary part.valueOf(double, double)public static Complex valueOf(double realPart, double imaginaryPart)
realPart - Real part.imaginaryPart - Imaginary part.public static Complex valueOf(double realPart)
realPart - Real part.protected final Object readResolve()
createComplex(double, double) to
deserialize properly.public ComplexField getField()
Field to which the instance belongs.getField in interface FieldElement<Complex>Field to which the instance belongsCopyright © 2003–2016 The Apache Software Foundation. All rights reserved.