Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.commons.math.complex
Class Complex

    java.lang.Object
      org.apache.commons.math.complex.Complex

All Implemented Interfaces:
  Serializable

public class Complex
extends Object
implements Serializable

Representation of a Complex number - a number which has both a real and imaginary part.

Implementations of arithmetic operations handle `NaN` and infinite values according to the rules for `Double` arithmetic, applying definitional formulas and returning `NaN` or infinite values in real or imaginary parts as these arise in computation. See individual method javadocs for details.

`equals(java.lang.Object)` identifies all values with `NaN` in either real or imaginary part - e.g.,

     1 + NaNi  == NaN + i == NaN + NaNi.

Version:
  $Revision: 349309 $ $Date: 2005-11-27 13:55:08 -0700 (Sun, 27 Nov 2005) $
Author:
  Apache Software Foundation
See Also:
  Serialized Form

Field Summary
`static Complex` | `I` The square root of -1.
`protected double` | `imaginary` The imaginary part
`static Complex` | `NaN` A complex number representing "NaN + NaNi"
`static Complex` | `ONE` A complex number representing "1.0 + 0.0i"
`protected double` | `real` The real part
`static Complex` | `ZERO` A complex number representing "0.0 + 0.0i"

Constructor Summary
`Complex(double real, double imaginary)` Create a complex number given the real and imaginary parts.

Method Summary
`double` | `abs()` Return the absolute value of this complex number.
`Complex` | `add(Complex rhs)` Return the sum of this complex number and the given complex number.
`Complex` | `conjugate()` Return the conjugate of this complex number.
`Complex` | `divide(Complex rhs)` Return the quotient of this complex number and the given complex number.
`boolean` | `equals(Object other)` Test for the equality of two Complex objects.
`double` | `getImaginary()` Access the imaginary part.
`double` | `getReal()` Access the real part.
`int` | `hashCode()` Get a hashCode for the complex number.
`boolean` | `isInfinite()` Returns true if 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()` Returns true if either or both parts of this complex number is NaN; false otherwise
`Complex` | `multiply(Complex rhs)` Return the product of this complex number and the given complex number.
`Complex` | `negate()` Return the additive inverse of this complex number.
`Complex` | `subtract(Complex rhs)` Return the difference between this complex number and the given complex number.

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### I

    public static final Complex I

  The square root of -1. A number representing "0.0 + 1.0i"

### NaN

    public static final Complex NaN

  A complex number representing "NaN + NaNi"

### ONE

    public static final Complex ONE

  A complex number representing "1.0 + 0.0i"

### ZERO

    public static final Complex ZERO

  A complex number representing "0.0 + 0.0i"

### imaginary

    protected double imaginary

  The imaginary part

### real

    protected double real

  The real part

Constructor Detail

### Complex

    public Complex(double real,
                   double imaginary)

  Create a complex number given the real and imaginary parts.

Parameters:
  `real` - the real part
  `imaginary` - the imaginary part

Method Detail

### abs

    public double abs()

  Return the absolute value of this complex number.

  Returns `NaN` if either real or imaginary part is `NaN` and `Double.POSITIVE_INFINITY` if neither part is `NaN`, but at least one part takes an infinite value.

  Returns:
    the absolute value

### add

    public Complex add(Complex rhs)

  Return the sum of this complex number and the given complex number.

  Uses the definitional formula

       (a + bi) + (c + di) = (a+c) + (b+d)i

  If either this or `rhs` has a NaN value in either part, `NaN` is returned; otherwise Inifinite and NaN values are returned in the parts of the result according to the rules for `Double` arithmetic.

  Parameters:
    `rhs` - the other complex number
  Returns:
    the complex number sum
  Throws:
    `NullPointerException` - if `rhs` is null

### conjugate

    public Complex conjugate()

  Return the conjugate of this complex number. The conjugate of "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`

  Returns:
    the conjugate of this Complex object

### divide

    public Complex divide(Complex rhs)

  Return the quotient of this complex number and the given complex number.

  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 / returned according to the following rules, applied in the order presented:

  - If either this or `rhs` has a NaN value in either part, `NaN` is returned.
  - If `rhs` equals `ZERO`, `NaN` is returned.
  - If this and `rhs` are both infinite, `NaN` is returned.
  - If this is finite (i.e., has no infinite or NaN parts) and `rhs` is infinite (one or both parts infinite), `ZERO` is returned.
  - If this is infinite and `rhs` is finite, NaN values are returned in the parts of the result if the `Double` rules applied to the definitional formula force NaN results.

  Parameters:
    `rhs` - the other complex number
  Returns:
    the complex number quotient
  Throws:
    `NullPointerException` - if `rhs` is null

### equals

    public boolean equals(Object other)

  Test for the equality of two Complex objects.

  If both the real and imaginary parts of two Complex numbers are exactly the same, and neither is `Double.NaN`, the two Complex objects are considered to be equal.

  All `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 `Complex.NaN`.

  Parameters:
    `other` - Object to test for equality to this
  Returns:
    true if two Complex objects are equal, false if object is null, not an instance of Complex, or not equal to this Complex instance

### hashCode

    public int hashCode()

  Get a hashCode for the complex number.

  All NaN values have the same hash code.

  Returns:
    a hash code value for this object

### getImaginary

    public double getImaginary()

  Access the imaginary part.

  Returns:
    the imaginary part

### getReal

    public double getReal()

  Access the real part.

  Returns:
    the real part

### isNaN

    public boolean isNaN()

  Returns true if either or both parts of this complex number is NaN; false otherwise

  Returns:
    true if either or both parts of this complex number is NaN; false otherwise

### isInfinite

    public boolean isInfinite()

  Returns true if 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`.

  Returns:
    true if one or both parts of this complex number are infinite and neither part is `NaN`

### multiply

    public Complex multiply(Complex rhs)

  Return the product of this complex number and the given complex number.

  Implements the definitional formula:

       (a + bi)(c + di) = (ac - bd) + (ad + bc)i

  Returns `NaN` if either this or `rhs` has one or more NaN parts.

  Returns NaN or infinite values in components of the result per the definitional formula and and the rules for `Double` arithmetic. Examples:

        (1 + i) (INF + i)  =  INF + INFi
        (1 + INFi) (1 - INFi) = INF + NaNi
        (-INF + -INFi)(1 + NaNi) = NaN + NaNi

  Parameters:
    `rhs` - the other complex number
  Returns:
    the complex number product
  Throws:
    `NullPointerException` - if `rhs` is null

### negate

    public Complex negate()

  Return the additive inverse of this complex number.

  Returns `Complex.NaN` if either real or imaginary part of this Complex number equals `Double.NaN`.

  Returns:
    the negation of this complex number

### subtract

    public Complex subtract(Complex rhs)

  Return the difference between this complex number and the given complex number.

  Uses the definitional formula

       (a + bi) - (c + di) = (a-c) + (b-d)i

  If either this or `rhs` has a NaN value in either part, `NaN` is returned; otherwise inifinite and NaN values are returned in the parts of the result according to the rules for `Double` arithmetic.

  Parameters:
    `rhs` - the other complex number
  Returns:
    the complex number difference
  Throws:
    `NullPointerException` - if `rhs` is null

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2003-2005 The Apache Software Foundation. All Rights Reserved.