jcomplex.java

一个用Java制作的实现“复数”各种操作的计算器。包括 加减乘除根模 自然对数 实幂指数 虚幂指数 正弦 余弦 正切。 主要是各种算法和类的设计。 可以供初学面向对象程序设计和Java的同学参考。

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package complexcalculator;

/**
 *
 * @author Wilson
 */
public class JComplex {

    //保护性数据
    protected double m_dblX; //复数的实部

    protected double m_dblY; //复数的虚部

    //公有接口函数

    //构造
    public JComplex() {
        //基本构造函数
        SetReal(0.0);
        SetImag(0.0);
    }

    public JComplex(double dblX, double dblY) {
        //指定值构造函数
        Set(dblX, dblY);
    }

    public JComplex(String strX, String strY) {
        //指定值构造函数
        SetReal(Double.parseDouble(strX));
        SetImag(Double.parseDouble(strY));
        //SetReal(Double.valueOf(strX).doubleValue());
        //SetImag(Double.valueOf(strY).doubleValue());
    }

    public JComplex(JComplex other) {
        //拷贝构造函数
        Set(other);
    }

    //输入与显示
    public void SetReal(double dblX) {
        //指定复数实部
        m_dblX = dblX;
    }

    public void SetImag(double dblY) {
        //指定复数虚部
        m_dblY = dblY;
    }

    public double GetReal() {
        //取实部
        return m_dblX;
    }

    public double GetImag() {
        //取虚部
        return m_dblY;
    }

    @Override
    public String toString() {
        //转换为a+bj形式的字符串
        if (m_dblX == 0 && m_dblY == 0) {
            return "0";
        }
        String s = new String();
        if (m_dblX != 0.0) {
            if (m_dblY > 0) {
                s = String.format("%g + %g i", m_dblX, m_dblY);
            } else if (m_dblY < 0) {
                s = String.format("%g - %g i", m_dblX, Math.abs(m_dblY));
            } else {
                s = String.format("%g", m_dblX);
            }
        } else {
            if (m_dblY != 0) {
                s = String.format("%g i", m_dblY);
            }
        }
        return s;
    }

    public void FromString(String s, String sDelim) {
        //将a,b形式的字符串转换为复数，a为实部，b为虚部
    }

    //数学运算
    public boolean Equal(JComplex cpxX) {
        // ==
        return (m_dblX == cpxX.m_dblX && m_dblY == cpxX.m_dblY);
    }

    public void Set(JComplex cpxX) {
        // =
        SetReal(cpxX.GetReal());
        SetImag(cpxX.GetReal());
    }

    public void Set(double dblX, double dblY) {
        SetReal(dblX);
        SetImag(dblY);
    }

    public JComplex Add(JComplex cpxX) {
        // +
        return new JComplex(m_dblX + cpxX.m_dblX, m_dblY + cpxX.m_dblY);
    }

    public JComplex Sub(JComplex cpxX) {
        // -
        return new JComplex(m_dblX - cpxX.m_dblX, m_dblY - cpxX.m_dblY);
    }

    public JComplex Mul(JComplex cpxX) {
        // *
        return new JComplex(
                m_dblX * cpxX.m_dblX - m_dblY * cpxX.m_dblY,
                m_dblX * cpxX.m_dblY + m_dblY * cpxX.m_dblX);
    }

    public JComplex Div(JComplex cpxX) {
        // /
        double e, f, x, y;
        if (Math.abs(cpxX.m_dblX) >= Math.abs(cpxX.m_dblY)) {
            e = cpxX.m_dblY / cpxX.m_dblX;
            f = cpxX.m_dblX + e * cpxX.m_dblY;

            x = (m_dblX + m_dblY * e) / f;
            y = (m_dblY - m_dblX * e) / f;
        } else {
            e = cpxX.m_dblX / cpxX.m_dblY;
            f = cpxX.m_dblY + e * cpxX.m_dblX;

            x = (m_dblX * e + m_dblY) / f;
            y = (m_dblY * e - m_dblX) / f;
        }
        return new JComplex(x, y);
    }

    public double Abs() {
        //复数的模
        double x = Math.abs(m_dblX), y = Math.abs(m_dblY);
        if (m_dblX == 0) {
            return y;
        }
        if (m_dblY == 0) {
            return x;
        }
        if (x > y) {
            return (x * Math.sqrt(1 + (y / x) * (y / x)));
        }
        return (y * Math.sqrt((1 + (x / y) * (x / y))));
    }

    //函数运算
    public JComplex[] Root(int n) {
        //复数的根
        if (n < 1) {
            return null;
        }
        double q = Math.atan2(m_dblY, m_dblX);
        double r = Math.sqrt(m_dblX * m_dblX + m_dblY * m_dblY);
        if (r != 0) {
            r = Math.exp((1.0 / n) * Math.log(r));
        }
        JComplex[] jcpxR = new JComplex[n];
        for (int k = 0; k < n; k++) {
            double t = (2.0 * k * Math.PI + q) / n;
            jcpxR[k] = new JComplex(r * Math.cos(t), r * Math.sin(t));
        }
        return jcpxR;
    }

    public JComplex Pow(double dblW) {
        //复数的实幂指数
        double r, t;
        if ((m_dblX == 0) && (m_dblY == 0)) {
            return new JComplex(0, 0);
        }
        if (m_dblX == 0) {
            if (m_dblY > 0) {
                t = Math.PI / 2;
            } else {
                t = -Math.PI / 2;
            }
        } else {
            if (m_dblX > 0) {
                t = Math.atan2(m_dblY, m_dblX);
            } else {
                if (m_dblY >= 0) {
                    t = Math.atan2(m_dblY, m_dblX) + Math.PI;
                } else {
                    t = Math.atan2(m_dblY, m_dblX) - Math.PI;
                }
            }
        }
        r = Math.exp(dblW * Math.log(Math.sqrt(m_dblX * m_dblX + m_dblY * m_dblY)));
        return new JComplex(r * Math.cos(dblW * t), r * Math.sin(dblW * t));
    }

    public JComplex Pow(JComplex cpxW, int n) {
        //复数的复幂指数
        double r, s, u, v;
        if (m_dblX == 0) {
            if (m_dblY == 0) {
                return new JComplex(0, 0);
            }
            s = Math.PI / 2 * (Math.abs(m_dblY) / m_dblY + 4 * n);
        } else {
            s = 2 * Math.PI * n + Math.atan2(m_dblY, m_dblX);
            if (m_dblX < 0) {
                if (m_dblY > 0) {
                    s += Math.PI;
                } else {
                    s -= Math.PI;
                }
            }
        }
        r = 0.5 * Math.log(m_dblX * m_dblX + m_dblY * m_dblY);
        v = cpxW.m_dblX * r + cpxW.m_dblY * s;
        u = Math.exp(cpxW.m_dblX * r - cpxW.m_dblY * s);
        return new JComplex(u * Math.cos(v), u * Math.sin(v));
    }

    public JComplex Log() {
        //复数的对数
        return new JComplex(
                Math.log(Math.sqrt(m_dblX * m_dblX + m_dblY * m_dblY)),
                Math.atan2(m_dblY, m_dblX));
    }
    final double[] c = { //切比雪夫公式的常数系数
        1.13031820798497,
        0.04433684984866,
        0.00054292631191,
        0.00000319843646,
        0.00000001103607,
        0.00000000002498
    };

    public JComplex Sin() {
        //复数的正弦
        int i;
        double x, y, y1, b1, b2, br = 0;
        y1 = Math.exp(m_dblY);
        x = 0.5 * (y1 + 1 / y1);
        if (Math.abs(m_dblY) >= 1) {
            y = 0.5 * (y1 - 1 / y1);
        } else {
            b1 = 0;
            b2 = 0;
            y1 = 2 * (2 * m_dblY * m_dblY - 1);
            for (i = 5; i >= 0; i--) {
                br = y1 * b1 - b2 - c[i];
                if (i != 0) {
                    b2 = b1;
                    b1 = br;
                }
            }
            y = m_dblY * (br - b1);
        }

        x *= Math.sin(m_dblX);
        y *= Math.cos(m_dblX);
        return new JComplex(x, y);
    }

    public JComplex Cos() {
        //复数的余弦
        int i;
        double x, y, y1, b1, b2, br = 0;
        y1 = Math.exp(m_dblY);
        x = 0.5 * (y1 + 1 / y1);
        if (Math.abs(m_dblY) >= 1) {
            y = 0.5 * (y1 - 1 / y1);
        } else {
            b1 = 0;
            b2 = 0;
            y1 = 2 * (2 * m_dblY * m_dblY - 1);
            for (i = 5; i >= 0; i--) {
                br = y1 * b1 - b2 - c[i];
                if (i != 0) {
                    b2 = b1;
                    b1 = br;
                }
            }
            y = m_dblY * (br - b1);
        }
        x *= Math.cos(m_dblX);
        y = -y * Math.sin(m_dblX);
        return new JComplex(x, y);
    }

    public JComplex Tan() {
        //复数的正切
        return Sin().Div(Cos());
    }
}