【Java开源代码栏目提醒】:网学会员为广大网友收集整理了,Complex.java,希望对大家有所帮助!
package com.javapatterns.immutable.complex;
final public class Complex extends Number
implements java.io.Serializable, Cloneable, Comparable
{
static final public Complex i = new Complex(0.0, 1.0);
private double re;
private double im;
public Complex(Complex z)
{
re = z.re;
im = z.im;
}
public Complex(double re, double im)
{
this.re = re;
this.im = im;
}
public Complex(double re)
{
this.re = re;
this.im = 0.0;
}
public Complex()
{
re = 0.0;
im = 0.0;
}
public boolean equals(Complex z)
{
return (re == z.re && im == z.im);
}
public boolean equals(Object obj)
{
if (obj == null)
{
return false;
}
else if (obj instanceof Complex)
{
return equals((Complex)obj);
}
else
{
return false;
}
}
public int hashCode()
{
long re_bits = Double.doubleToLongBits(re);
long im_bits = Double.doubleToLongBits(im);
return (int)((re_bits^im_bits)^((re_bits^im_bits)>>32));
}
/**
* Returns the value of the real part as an int.
*/
public int intValue()
{
return (int)re;
}
/**
* Returns the value of the real part as a byte.
*/
public byte byteValue()
{
return (byte)re;
}
/**
* Returns the value of the real part as a long.
*/
public long longValue()
{
return (long)re;
}
/**
* Returns the value of the real part as a float.
*/
public float floatValue()
{
return (float)re;
}
/**
* Returns the value of the real part as a double.
*/
public double doubleValue()
{
return re;
}
/**
* Compares this Complex to another Object. If the Object is a Complex,
* this function behaves like compareTo(Complex). Otherwise, it throws
* a ClassCastException (as Complex objects are comparable only to other
* Complex objects).
*/
public int compareTo(Object obj)
{
return compareTo((Complex)obj);
}
/**
* Compares two Complex objects.
* <P>A lexagraphical ordering is used. First the real parts are compared
* in the sense of Double.compareTo. If the real parts are unequal this
* is the return value. If the return parts are equal then the comparison
* of the imaginary parts is returned.
* @return The value 0 if z is equal to this Complex;
* a value less than 0 if this Complex is less than z;
* and a value greater than 0 if this Complex is greater
* than z.
*/
public int compareTo(Complex z)
{
int compare = new Double(re).compareTo(new Double(z.re));
if (compare == 0)
{
compare = new Double(im).compareTo(new Double(z.im));
}
return compare;
}
public double real()
{
return re;
}
public double imag()
{
return im;
}
public static double real(Complex z)
{
return z.re;
}
public static double imag(Complex z)
{
return z.im;
}
public static Complex negate(Complex z)
{
return new Complex(-z.re, -z.im);
}
public static Complex conjugate(Complex z)
{
return new Complex(z.re, -z.im);
}
public static Complex add(Complex x, Complex y)
{
return new Complex(x.re+y.re, x.im+y.im);
}
public static Complex add(Complex x, double y)
{
return new Complex(x.re+y, x.im);
}
public static Complex add(double x, Complex y)
{
return new Complex(x+y.re, y.im);
}
public static Complex subtract(Complex x, Complex y)
{
return new Complex(x.re-y.re, x.im-y.im);
}
public static Complex subtract(Complex x, double y)
{
return new Complex(x.re-y, x.im);
}
public static Complex subtract(double x, Complex y)
{
return new Complex(x-y.re, -y.im);
}
public static Complex multiply(Complex x, Complex y)
{
return new Complex(x.re*y.re-x.im*y.im, x.re*y.im+x.im*y.re);
}
public static Complex multiply(Complex x, double y)
{
return new Complex(x.re*y, x.im*y);
}
public static Complex multiply(double x, Complex y)
{
return new Complex(x*y.re, x*y.im);
}
public static Complex multiplyImag(Complex x, double y)
{
return new Complex(-x.im*y, x.re*y);
}
public static Complex multiplyImag(double x, Complex y)
{
return new Complex(-x*y.im, x*y.re);
}
public static Complex divide(Complex x, Complex y)
{
double a = x.re;
double b = x.im;
double c = y.re;
double d = y.im;
double scale = Math.max(Math.abs(c), Math.abs(d));
double den = c*c + d*d;
return new Complex((a*c+b*d)/den, (b*c-a*d)/den);
}
public static Complex divide(Complex x, double y)
{
return new Complex(x.re/y, x.im/y);
}
public static Complex divide(double x, Complex y)
{
double den, t;
Complex z;
if (Math.abs(y.re) > Math.abs(y.im))
{
t = y.im / y.re;
den = y.re + y.im*t;
z = new Complex(x/den, -x*t/den);
}
else
{
t = y.re / y.im;
den =