package jsat.math;
import java.io.Serializable;
/**
* A class for representing a complex value by a real and imaginary double pair.
*
* @author Edward Raff
*/
public class Complex implements Cloneable, Serializable
{
private static final long serialVersionUID = -2219274170047061708L;
private double real, imag;
/**
* Returns the complex number representing sqrt(-1)
* @return the complex number i
*/
public static Complex I()
{
return new Complex(0.0, 1.0);
}
/**
* Creates a new Complex number
* @param real the real part of the number
* @param imag the imaginary part of the number
*/
public Complex(double real, double imag)
{
this.real = real;
this.imag = imag;
}
/**
* Returns the real part of this complex number
* @return the real part of this complex number
*/
public double getReal()
{
return real;
}
/**
* Sets the real value part of this complex number
* @param r the new real value
*/
public void setReal(double r)
{
this.real = r;
}
/**
* Sets the imaginary value part of this complex number
* @param imag the new imaginary value
*/
public void setImag(double imag)
{
this.imag = imag;
}
/**
* Returns the imaginary part of this complex number
* @return the imaginary part of this complex number
*/
public double getImag()
{
return imag;
}
/**
* Alters this complex number as if an addition of another complex number was performed.
* @param r the real part of the other number
* @param i the imaginary part of the other number
*/
public void mutableAdd(double r, double i)
{
this.real += r;
this.imag += i;
}
/**
* Alters this complex number to contain the result of the addition of another
* @param c the complex value to add to this
*/
public void mutableAdd(Complex c)
{
mutableAdd(c.real, c.imag);
}
/**
* Creates a new complex number containing the resulting addition of this and another
* @param c the number to add
* @return this+c
*/
public Complex add(Complex c)
{
Complex ret = new Complex(real, imag);
ret.mutableAdd(c);
return ret;
}
/**
* Alters this complex number as if a subtraction of another complex number was performed.
* @param r the real part of the other number
* @param i the imaginary part of the other number
*/
public void mutableSubtract(double r, double i)
{
mutableAdd(-r, -i);
}
/**
* Alters this complex number to contain the result of the subtraction of another
* @param c the number to subtract
*/
public void mutableSubtract(Complex c)
{
mutableSubtract(c.real, c.imag);
}
/**
* Creates a new complex number containing the resulting subtracting another from this one
* @param c the number to subtract
* @return this-c
*/
public Complex subtract(Complex c)
{
Complex ret = new Complex(real, imag);
ret.mutableSubtract(c);
return ret;
}
/**
* Performs a complex multiplication
*
* @param a the real part of the first number
* @param b the imaginary part of the first number
* @param c the real part of the second number
* @param d the imaginary part of the second number
* @param results an array to store the real and imaginary results in. First index is the real, 2nd is the imaginary.
*/
public static void cMul(double a, double b, double c, double d, double[] results)
{
results[0] = a*c-b*d;
results[1] = b*c+a*d;
}
/**
* Alters this complex number as if a multiplication of another complex number was performed.
* @param c the real part of the other number
* @param d the imaginary part of the other number
*/
public void mutableMultiply(double c, double d)
{
double newR = this.real*c-this.imag*d;
double newI = this.imag*c+this.real*d;
this.real = newR;
this.imag = newI;
}
/**
* Alters this complex number to contain the result of the multiplication of another
* @param c the number to multiply by
*/
public void mutableMultiply(Complex c)
{
mutableMultiply(c.real, c.imag);
}
/**
* Creates a new complex number containing the resulting multiplication between this and another
* @param c the number to multiply by
* @return this*c
*/
public Complex multiply(Complex c)
{
Complex ret = new Complex(real, imag);
ret.mutableMultiply(c);
return ret;
}
/**
* Performs a complex division operation.
* The standard complex division performs a set of operations that is
* suseptible to both overflow and underflow. This method is more
* numerically stable while still being relatively fast to execute.
*
* @param a the real part of the first number
* @param b the imaginary part of the first number
* @param c the real part of the second number
* @param d the imaginary part of the second number
* @param results an array to store the real and imaginary results in. First
* index is the real, 2nd is the imaginary.
*/
public static void cDiv(double a, double b, double c, double d, double[] results)
{
/**
* Douglas M. Priest. Efficient scaling for complex division. ACM Trans.
* Math. Softw., 30(4):389–401, 2004
*/
long aa, bb, cc, dd, ss;
double t;
int ha, hb, hc, hd, hz, hw, hs;
/*extract high-order 32 bits to estimate |z| and |w| */
aa = Double.doubleToRawLongBits(a);
bb = Double.doubleToRawLongBits(b);
ha = (int) ((aa >> 32) & 0x7fffffff);
hb = (int) ((bb >> 32) & 0x7fffffff);
hz = (ha > hb)? ha : hb;
cc = Double.doubleToRawLongBits(c);
dd = Double.doubleToRawLongBits(d);
hc = (int) ((cc >> 32) & 0x7fffffff);
hd = (int) ((dd >> 32) & 0x7fffffff);
hw = (hc > hd)? hc : hd;
/* compute the scale factor */
if (hz < 0x07200000 && hw >= 0x32800000 && hw < 0x47100000)
{
/* |z| < 2^-909 and 2^-215 <= |w| < 2^114 */
hs = (((0x47100000 - hw) >> 1) & 0xfff00000) + 0x3ff00000;
}
else
hs = (((hw >> 2) - hw) + 0x6fd7ffff) & 0xfff00000;
ss = ((long) hs) << 32;
/* scale c and d, and compute the quotient */
double ssd = Double.longBitsToDouble(ss);
c *= ssd;
d *= ssd;
t = 1.0 / (c * c + d * d);
c *= ssd;
d *= ssd;
results[0] = (a * c + b * d) * t;
results[1] = (b * c - a * d) * t;
}
/**
* Alters this complex number as if a division by another complex number was performed.
* @param c the real part of the other number
* @param d the imaginary part of the other number
*/
public void mutableDivide(double c, double d)
{
final double[] r = new double[2];
cDiv(real, imag, c, d, r);
this.real = r[0];
this.imag = r[1];
}
/**
* Alters this complex number to contain the result of the division by another
* @param c the number to divide by
*/
public void mutableDivide(Complex c)
{
mutableDivide(c.real, c.imag);
}
/**
* Creates a new complex number containing the resulting division of this by
* another
*
* @param c the number to divide by
* @return this/c
*/
public Complex divide(Complex c)
{
Complex ret = new Complex(real, imag);
ret.mutableDivide(c);
return ret;
}
/**
* Computes the magnitude of this complex number, which is
* sqrt({@link #getReal() Re}2+{@link #getImag() Im}2)
* @return the magnitude of this complex number
*/
public double getMagnitude()
{
return Math.hypot(real, imag);
}
/**
* Computes the Argument, also called phase, of this complex number. Unless
* the result is {@link Double#NaN}, which occurs only for complex zero, the
* result will be in the range [-pi, pi]
* @return the argument of this complex number
*/
public double getArg()
{
return Math.atan2(imag, real);
}
/**
* Alters this complex number so that it represents its complex conjugate
* instead.
*/
public void mutateConjugate()
{
this.imag = -imag;
}
/**
* Returns a new complex number representing the complex conjugate of this
* one
* @return the complex conjugate of this
*/
public Complex getConjugate()
{
return new Complex(real, -imag);
}
@Override
public String toString()
{
if(imag == 0)
return Double.toString(real);
else if(real == 0)
return imag + "i";
else
return "("+real + " + " + imag + "i)";
}
@Override
protected Complex clone()
{
return new Complex(real, imag);
}
@Override
public boolean equals(Object obj)
{
return equals(obj, 0.0);
}
@Override
public int hashCode()
{
int hash = 5;
hash = 67 * hash + (int) (Double.doubleToLongBits(this.real) ^ (Double.doubleToLongBits(this.real) >>> 32));
hash = 67 * hash + (int) (Double.doubleToLongBits(this.imag) ^ (Double.doubleToLongBits(this.imag) >>> 32));
return hash;
}
/**
* Checks if this is approximately equal to another Complex object
* @param obj the object to compare against
* @param eps the maximum acceptable difference between values to be
* considered equal
* @return true if the objects are approximately equal
*/
public boolean equals(Object obj, double eps)
{
if( obj instanceof Complex)
{
Complex other = (Complex) obj;
if(Math.abs(this.real-other.real) > eps)
return false;
else if(Math.abs((this.imag - other.imag)) > eps)
return false;
return true;
}
return false;
}
}
Ads help maintain this website.