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 | IThe square root of -1. | 
| static Complex | INFA complex number representing "+INF + INFi" | 
| static Complex | NaNA complex number representing "NaN + NaNi" | 
| static Complex | ONEA complex number representing "1.0 + 0.0i" | 
| static Complex | ZEROA 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  Complexwhose value is(this + addend). | 
| Complex | add(double addend)Returns a  Complexwhose value is(this + addend),
 withaddendinterpreted 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  Complexwhose value is(this / divisor). | 
| Complex | divide(double divisor)Returns a  Complexwhose value is(this / divisor),
 withdivisorinterpreted as a real number. | 
| static boolean | equals(Complex x,
      Complex y)Returns  trueiff the values are equal as defined byequals(x, y, 1). | 
| static boolean | equals(Complex x,
      Complex y,
      double eps)Returns  trueif, 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  trueif, 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  Fieldto 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_INFINITYorDouble.NEGATIVE_INFINITY) and neither part
 isNaN. | 
| 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  Complexwhose value isthis * factor. | 
| Complex | multiply(double factor)Returns a  Complexwhose value isthis * factor, withfactorinterpreted as a real number. | 
| Complex | multiply(int factor)Returns a  Complexwhose value isthis * factor, withfactorinterpreted as a integer number. | 
| Complex | negate()Returns a  Complexwhose 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  thiselement. | 
| 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 - this2for this complex
 number. | 
| Complex | subtract(Complex subtrahend)Returns a  Complexwhose value is(this - subtrahend). | 
| Complex | subtract(double subtrahend)Returns a  Complexwhose 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.