Java/Data Type/Complex Number
A class to represent Complex Numbers
<source lang="java">
/** 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));
}
}
</source>
This class represents complex numbers, and defines methods for performing arithmetic on complex numbers
<source lang="java">
/*
* 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);
}
}
</source>
