Does Java have a class for complex numbers?

Does Java have a clas开发者_StackOverflow社区s for complex numbers?

There's an Apache Commons one called Complex. I don't believe the JDK has one.

No, the JDK does not have one but here is an implementation I have written.

Here is the GITHUB project.

/**
 * <code>ComplexNumber</code> is a class which implements complex numbers in Java. 
 * It includes basic operations that can be performed on complex numbers such as,
 * addition, subtraction, multiplication, conjugate, modulus and squaring. 
 * The data type for Complex Numbers.
 * <br /><br />
 * The features of this library include:<br />
 * <ul>
 * <li>Arithmetic Operations (addition, subtraction, multiplication, division)</li>
 * <li>Complex Specific Operations - Conjugate, Inverse, Absolute/Magnitude, Argument/Phase</li>
 * <li>Trigonometric Operations - sin, cos, tan, cot, sec, cosec</li>
 * <li>Mathematical Functions - exp</li>
 * <li>Complex Parsing of type x+yi</li>
 * </ul>
 * 
 * @author      Abdul Fatir
 * @version     1.1
 * 
 */
public class ComplexNumber
{
    /**
    * Used in <code>format(int)</code> to format the complex number as x+yi
    */
    public static final int XY = 0;
    /**
    * Used in <code>format(int)</code> to format the complex number as R.cis(theta), where theta is arg(z)
    */
    public static final int RCIS = 1;
    /**
    * The real, Re(z), part of the <code>ComplexNumber</code>.
    */
    private double real;
    /**
    * The imaginary, Im(z), part of the <code>ComplexNumber</code>.
    */
    private double imaginary;
    /**
    * Constructs a new <code>ComplexNumber</code> object with both real and imaginary parts 0 (z = 0 + 0i).
    */
    public ComplexNumber()
    {
        real = 0.0;
        imaginary = 0.0;
    }

    /**
    * Constructs a new <code>ComplexNumber</code> object.
    * @param real the real part, Re(z), of the complex number
    * @param imaginary the imaginary part, Im(z), of the complex number
    */

    public ComplexNumber(double real, double imaginary)
    {
        this.real = real;
        this.imaginary = imaginary;
    }

    /**
    * Adds another <code>ComplexNumber</code> to the current complex number.
    * @param z the complex number to be added to the current complex number
    */

    public void add(ComplexNumber z)
    {
        set(add(this,z));
    }

    /**
    * Subtracts another <code>ComplexNumber</code> from the current complex number.
    * @param z the complex number to be subtracted from the current complex number
    */

    public void subtract(ComplexNumber z)
    {
        set(subtract(this,z));
    }

    /**
    * Multiplies another <code>ComplexNumber</code> to the current complex number.
    * @param z the complex number to be multiplied to the current complex number
    */

    public void multiply(ComplexNumber z)
    {
        set(multiply(this,z));
    }
    /**
    * Divides the current <code>ComplexNumber</code> by another <code>ComplexNumber</code>.
    * @param z the divisor
    */  
    public void divide(ComplexNumber z)
    {
        set(divide(this,z));
    }
    /**
    * Sets the value of current complex number to the passed complex number.
    * @param z the complex number
    */
    public void set(ComplexNumber z)
    {
        this.real = z.real;
        this.imaginary = z.imaginary;
    }
    /**
    * Adds two <code>ComplexNumber</code>.
    * @param z1 the first <code>ComplexNumber</code>.
    * @param z2 the second <code>ComplexNumber</code>.
    * @return the resultant <code>ComplexNumber</code> (z1 + z2).
    */
    public static ComplexNumber add(ComplexNumber z1, ComplexNumber z2)
    {
        return new ComplexNumber(z1.real + z2.real, z1.imaginary + z2.imaginary);
    }

    /**
    * Subtracts one <code>ComplexNumber</code> from another.
    * @param z1 the first <code>ComplexNumber</code>.
    * @param z2 the second <code>ComplexNumber</code>.
    * @return the resultant <code>ComplexNumber</code> (z1 - z2).
    */  
    public static ComplexNumber subtract(ComplexNumber z1, ComplexNumber z2)
    {
        return new ComplexNumber(z1.real - z2.real, z1.imaginary - z2.imaginary);
    }
    /**
    * Multiplies one <code>ComplexNumber</code> to another.
    * @param z1 the first <code>ComplexNumber</code>.
    * @param z2 the second <code>ComplexNumber</code>.
    * @return the resultant <code>ComplexNumber</code> (z1 * z2).
    */  
    public static ComplexNumber multiply(ComplexNumber z1, ComplexNumber z2)
    {
        double _real = z1.real*z2.real - z1.imaginary*z2.imaginary;
        double _imaginary = z1.real*z2.imaginary + z1.imaginary*z2.real;
        return new ComplexNumber(_real,_imaginary);
    }
    /**
    * Divides one <code>ComplexNumber</code> by another.
    * @param z1 the first <code>ComplexNumber</code>.
    * @param z2 the second <code>ComplexNumber</code>.
    * @return the resultant <code>ComplexNumber</code> (z1 / z2).
    */      
    public static ComplexNumber divide(ComplexNumber z1, ComplexNumber z2)
    {
        ComplexNumber output = multiply(z1,z2.conjugate());
        double div = Math.pow(z2.mod(),2);
        return new ComplexNumber(output.real/div,output.imaginary/div);
    }

    /**
    * The complex conjugate of the current complex number.
    * @return a <code>ComplexNumber</code> object which is the conjugate of the current complex number
    */

    public ComplexNumber conjugate()
    {
        return new ComplexNumber(this.real,-this.imaginary);
    }

    /**
    * The modulus, magnitude or the absolute value of current complex number.
    * @return the magnitude or modulus of current complex number
    */

    public double mod()
    {
        return Math.sqrt(Math.pow(this.real,2) + Math.pow(this.imaginary,2));
    }

    /**
    * The square of the current complex number.
    * @return a <code>ComplexNumber</code> which is the square of the current complex number.
    */

    public ComplexNumber square()
    {
        double _real = this.real*this.real - this.imaginary*this.imaginary;
        double _imaginary = 2*this.real*this.imaginary;
        return new ComplexNumber(_real,_imaginary);
    }
    /**
    * @return the complex number in x + yi format
    */
    @Override
    public String toString()
    {
        String re = this.real+"";
        String im = "";
        if(this.imaginary < 0)
            im = this.imaginary+"i";
        else
            im = "+"+this.imaginary+"i";
        return re+im;
    }
    /**
    * Calculates the exponential of the <code>ComplexNumber</code>
    * @param z The input complex number
    * @return a <code>ComplexNumber</code> which is e^(input z)
    */
    public static ComplexNumber exp(ComplexNumber z)
    {
        double a = z.real;
        double b = z.imaginary;
        double r = Math.exp(a);
        a = r*Math.cos(b);
        b = r*Math.sin(b);
        return new ComplexNumber(a,b);
    }
    /**
    * Calculates the <code>ComplexNumber</code> to the passed integer power.
    * @param z The input complex number
    * @param power The power.
    * @return a <code>ComplexNumber</code> which is (z)^power
    */
    public static ComplexNumber pow(ComplexNumber z, int power)
    {
        ComplexNumber output = new ComplexNumber(z.getRe(),z.getIm());
        for(int i = 1; i < power; i++)
        {
            double _real = output.real*z.real - output.imaginary*z.imaginary;
            double _imaginary = output.real*z.imaginary + output.imaginary*z.real;
            output = new ComplexNumber(_real,_imaginary);
        }
        return output;
    }
    /**
    * Calculates the sine of the <code>ComplexNumber</code>
    * @param z the input complex number
    * @return a <code>ComplexNumber</code> which is the sine of z.
    */
    public static ComplexNumber sin(ComplexNumber z)
    {
        double x = Math.exp(z.imaginary);
        double x_inv = 1/x;
        double r = Math.sin(z.real) * (x + x_inv)/2;
        double i = Math.cos(z.real) * (x - x_inv)/2;
        return new ComplexNumber(r,i);
    }
    /**
    * Calculates the cosine of the <code>ComplexNumber</code>
    * @param z the input complex number
    * @return a <code>ComplexNumber</code> which is the cosine of z.
    */
    public static ComplexNumber cos(ComplexNumber z)
    {
        double x = Math.exp(z.imaginary);
        double x_inv = 1/x;
        double r = Math.cos(z.real) * (x + x_inv)/2;
        double i = -Math.sin(z.real) * (x - x_inv)/2;
        return new ComplexNumber(r,i);
    }
    /**
    * Calculates the tangent of the <code>ComplexNumber</code>
    * @param z the input complex number
    * @return a <code>ComplexNumber</code> which is the tangent of z.
    */
    public static ComplexNumber tan(ComplexNumber z)
    {
        return divide(sin(z),cos(z));
    }
    /**
    * Calculates the co-tangent of the <code>ComplexNumber</code>
    * @param z the input complex number
    * @return a <code>ComplexNumber</code> which is the co-tangent of z.
    */
    public static ComplexNumber cot(ComplexNumber z)
    {
        return divide(new ComplexNumber(1,0),tan(z));
    }
    /**
    * Calculates the secant of the <code>ComplexNumber</code>
    * @param z the input complex number
    * @return a <code>ComplexNumber</code> which is the secant of z.
    */
    public static ComplexNumber sec(ComplexNumber z)
    {
        return divide(new ComplexNumber(1,0),cos(z));
    }
    /**
    * Calculates the co-secant of the <code>ComplexNumber</code>
    * @param z the input complex number
    * @return a <code>ComplexNumber</code> which is the co-secant of z.
    */
    public static ComplexNumber cosec(ComplexNumber z)
    {
        return divide(new ComplexNumber(1,0),sin(z));
    }
    /**
    * The real part of <code>ComplexNumber</code>
    * @return the real part of the complex number
    */
    public double getRe()
    {
        return this.real;
    }
    /**
    * The imaginary part of <code>ComplexNumber</code>
    * @return the imaginary part of the complex number
    */
    public double getIm()
    {
        return this.imaginary;
    }
    /**
    * The argument/phase of the current complex number.
    * @return arg(z) - the argument of current complex number
    */
    public double getArg()
    {
        return Math.atan2(imaginary,real);
    }
    /**
    * Parses the <code>String</code> as a <code>ComplexNumber</code> of type x+yi.
    * @param s the input complex number as string
    * @return a <code>ComplexNumber</code> which is represented by the string.
    */
    public static ComplexNumber parseComplex(String s)
    {
        s = s.replaceAll(" ","");
        ComplexNumber parsed = null;
        if(s.contains(String.valueOf("+")) || (s.contains(String.valueOf("-")) && s.lastIndexOf('-') > 0))
        {
            String re = "";
            String im = "";
            s = s.replaceAll("i","");
            s = s.replaceAll("I","");
            if(s.indexOf('+') > 0)
            {
                re = s.substring(0,s.indexOf('+'));
                im = s.substring(s.indexOf('+')+1,s.length());
                parsed = new ComplexNumber(Double.parseDouble(re),Double.parseDouble(im));
            }
            else if(s.lastIndexOf('-') > 0)
            {
                re = s.substring(0,s.lastIndexOf('-'));
                im = s.substring(s.lastIndexOf('-')+1,s.length());
                parsed = new ComplexNumber(Double.parseDouble(re),-Double.parseDouble(im));
            }
        }
        else
        {
            // Pure imaginary number
            if(s.endsWith("i") || s.endsWith("I"))
            {
                s = s.replaceAll("i","");
                s = s.replaceAll("I","");
                parsed = new ComplexNumber(0, Double.parseDouble(s));
            }
            // Pure real number
            else
            {
                parsed = new ComplexNumber(Double.parseDouble(s),0);
            }
        }
        return parsed;
    }
    /**
    * Checks if the passed <code>ComplexNumber</code> is equal to the current.
    * @param z the complex number to be checked
    * @return true if they are equal, false otherwise
    */
    @Override
    public final boolean equals(Object z) 
    {
        if (!(z instanceof ComplexNumber))
            return false;
        ComplexNumber a = (ComplexNumber) z;
        return (real == a.real) && (imaginary == a.imaginary);
    }
    /**
    * The inverse/reciprocal of the complex number.
    * @return the reciprocal of current complex number.
    */
    public ComplexNumber inverse()
    {
        return divide(new ComplexNumber(1,0),this);
    }
    /**
    * Formats the Complex number as x+yi or r.cis(theta)
    * @param format_id the format ID <code>ComplexNumber.XY</code> or <code>ComplexNumber.RCIS</code>.
    * @return a string representation of the complex number
    * @throws IllegalArgumentException if the format_id does not match.
    */
    public String format(int format_id) throws IllegalArgumentException
    {
        String out = "";
        if(format_id == XY)
            out = toString();
        else if(format_id == RCIS)
        {
            out = mod()+" cis("+getArg()+")";
        }
        else
        {
            throw new IllegalArgumentException("Unknown Complex Number format.");
        }
        return out;
    }
}

The JDK doesn't current have any classes for complex numbers, unfortunately.

You could have a look at:

http://www.java2s.com/Code/Java/Data-Type/Thisclassrepresentscomplexnumbersanddefinesmethodsforperformingarithmeticoncomplexnumbers.htm

which provides an implementation you may find useful.