Java/Data Type/Complex Number

A class to represent Complex Numbers

/** A class to represent Complex Numbers. A Complex object is
 * immutable once created; the add, subtract and multiply routines
 * return newly-created Complex objects containing the results.
 *
 * @author Ian F. Darwin, inspired by David Flanagan.
 * @version $Id: Complex.java,v 1.3 2004/05/13 22:28:59 ian Exp $
 */
public class Complex {
  /** The real part */
  private double r;
  /** The imaginary part */
  private double i;
  /** Construct a Complex */
  Complex(double rr, double ii) {
    r = rr;
    i = ii;
  }
  /** Display the current Complex as a String, for use in
   * println() and elsewhere.
   */
  public String toString() {
    StringBuffer sb = new StringBuffer().append(r);
    if (i>0)
      sb.append("+");  // else append(i) appends - sign
    return sb.append(i).append("i").toString();
  }
  /** Return just the Real part */
  public double getReal() {
    return r;
  }
  /** Return just the Real part */
  public double getImaginary() {
    return i;
  }
  /** Return the magnitude of a complex number */
  public double magnitude() {
    return Math.sqrt(r*r + i*i);
  }
  /** Add another Complex to this one
   */
  public Complex add(Complex other) {
    return add(this, other);
  }
  /** Add two Complexes
   */
  public static Complex add(Complex c1, Complex c2) {
    return new Complex(c1.r+c2.r, c1.i+c2.i);
  }
  /** Subtract another Complex from this one
   */
  public Complex subtract(Complex other) {
    return subtract(this, other);
  }
  /** Subtract two Complexes
   */
  public static Complex subtract(Complex c1, Complex c2) {
    return new Complex(c1.r-c2.r, c1.i-c2.i);
  }
  /** Multiply this Complex times another one
   */
  public Complex multiply(Complex other) {
    return multiply(this, other);
  }
  /** Multiply two Complexes
   */
  public static Complex multiply(Complex c1, Complex c2) {
    return new Complex(c1.r*c2.r - c1.i*c2.i, c1.r*c2.i + c1.i*c2.r);
  }
  /** Divide c1 by c2.
   * @author Gisbert Selke.
   */
  public static Complex divide(Complex c1, Complex c2) {
    return new Complex(
      (c1.r*c2.r+c1.i*c2.i)/(c2.r*c2.r+c2.i*c2.i),
      (c1.i*c2.r-c1.r*c2.i)/(c2.r*c2.r+c2.i*c2.i));
  }
  
  /* Compare this Complex number with another
   */
  public boolean equals(Object o) {
    if (!(o instanceof Complex))
      throw new IllegalArgumentException(
          "Complex.equals argument must be a Complex");
    Complex other = (Complex)o;
    return r == other.r && i == other.i;
  }
  
  /* Generate a hashCode; not sure how well distributed these are.
   */
  public int hashCode() {
    return (int)( r) |  (int)i;
  }
  public static void main(String[] args) {
    Complex c = new Complex(3,  5);
    Complex d = new Complex(2, -2);
    System.out.println(c);
    System.out.println(c + ".getReal() = " + c.getReal());
    System.out.println(c + " + " + d + " = " + c.add(d));
    System.out.println(c + " + " + d + " = " + Complex.add(c, d));
    System.out.println(c + " * " + d + " = " + c.multiply(d));
    System.out.println(Complex.divide(c, d));
  }
}

This class represents complex numbers, and defines methods for performing arithmetic on complex numbers

 
/*
 * Copyright (c) 2004 David Flanagan.  All rights reserved.
 * This code is from the book Java Examples in a Nutshell, 3nd Edition.
 * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
 * You may study, use, and modify it for any non-commercial purpose,
 * including teaching and use in open-source projects.
 * You may distribute it non-commercially as long as you retain this notice.
 * For a commercial use license, or to purchase the book, 
 * please visit http://www.davidflanagan.ru/javaexamples3.
 */
/**
 * This class represents complex numbers, and defines methods for performing
 * arithmetic on complex numbers.
 */
public class ComplexNumber {
  // These are the instance variables. Each ComplexNumber object holds
  // two double values, known as x and y. They are private, so they are
  // not accessible from outside this class. Instead, they are available
  // through the real() and imaginary() methods below.
  private double x, y;
  /** This is the constructor. It initializes the x and y variables */
  public ComplexNumber(double real, double imaginary) {
    this.x = real;
    this.y = imaginary;
  }
  /**
   * An accessor method. Returns the real part of the complex number. Note that
   * there is no setReal() method to set the real part. This means that the
   * ComplexNumber class is "immutable".
   */
  public double real() {
    return x;
  }
  /** An accessor method. Returns the imaginary part of the complex number */
  public double imaginary() {
    return y;
  }
  /** Compute the magnitude of a complex number */
  public double magnitude() {
    return Math.sqrt(x * x + y * y);
  }
  /**
   * This method converts a ComplexNumber to a string. This is a method of
   * Object that we override so that complex numbers can be meaningfully
   * converted to strings, and so they can conveniently be printed out with
   * System.out.println() and related methods
   */
  public String toString() {
    return "{" + x + "," + y + "}";
  }
  /**
   * This is a static class method. It takes two complex numbers, adds them, and
   * returns the result as a third number. Because it is static, there is no
   * "current instance" or "this" object. Use it like this: ComplexNumber c =
   * ComplexNumber.add(a, b);
   */
  public static ComplexNumber add(ComplexNumber a, ComplexNumber b) {
    return new ComplexNumber(a.x + b.x, a.y + b.y);
  }
  /**
   * This is a non-static instance method by the same name. It adds the
   * specified complex number to the current complex number. Use it like this:
   * ComplexNumber c = a.add(b);
   */
  public ComplexNumber add(ComplexNumber a) {
    return new ComplexNumber(this.x + a.x, this.y + a.y);
  }
  /** A static class method to multiply complex numbers */
  public static ComplexNumber multiply(ComplexNumber a, ComplexNumber b) {
    return new ComplexNumber(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
  }
  /** An instance method to multiply complex numbers */
  public ComplexNumber multiply(ComplexNumber a) {
    return new ComplexNumber(x * a.x - y * a.y, x * a.y + y * a.x);
  }
}