复数类[一]----C#实现

using System;
using System.Collections.Generic;
using System.Text;

namespace CSharpalgorithm.Algorithm
{
    /// <summary>
    /// 复数的定义，包括相关成员和方法
    /// </summary>
    public partial class Complex
    {
        private double real = 0.0;  //实部

        public double Real
        {
            get { return real; }
            set { real = value; }
        }

        private double imaginary = 0.0;　//虚部

        public double Imaginary
        {
            get { return imaginary; }
            set { imaginary = value; }
        }

        private double eps = 0.00;　　//缺省精度

        public double Eps
        {
            get { return eps; }
            set { eps = value; }
        }

        /// <summary>
        /// 基本构造函数
        /// </summary>
        public Complex()
        {
        }

        /// <summary>
        /// 指定参数的构造函数
        /// </summary>
        /// <param name="real1">实部</param>
        /// <param name="imagnary2">虚部</param>
        public Complex(double real1, double imagnary2)
        {
            real = real1;
            imaginary = imagnary2;
        }

        /// <summary>
        /// 拷贝函数
        /// </summary>
        /// <param name="obj">源复数</param>
        public Complex(Complex obj)
        {
            real = obj.real;
            imaginary=obj.imaginary;
        }

        /// <summary>
        /// 根据“a,b”形式的字符串来构造复数，以a为复数的实部，b为虚部
        /// </summary>
        /// <param name="s">“a,b”形式的字符串</param>
        /// <param name="sDelim">分格符“，”</param>
        public Complex(string s, string sDelim)
        {
            SetValue(s, sDelim);
        }

        /// <summary>
        /// 新的精度
        /// </summary>
        /// <param name="newEps"></param>
        public void SetEps(double newEps)
        {
            eps=newEps;
        }

        public double GetEps()
        {
            return eps;
        }

        public void SetReal(double real1)
        {
            real = real1;
        }

        public void SetImag(double imag1)
        {
            imaginary = imag1;
        }

        public double GetReal()
        {
            return real;
        }

        public double GetImag()
        {
            return imaginary;
        }

        public void SetValue(double real, double imag)
        {
            SetReal(real);
            SetImag(imag);
        }

        /// <summary>
        /// 将“a,b”形式的字符串转化为实部和虚部
        /// </summary>
        /// <param name="s">“a,b”形式的字符串</param>
        /// <param name="SDelim">分格符</param>
        public void SetValue(string s, string SDelim)
        {
            int nPos = s.IndexOf(SDelim);
            if (nPos == -1)
            {
                s = s.Trim();
                real = Double.Parse(s);
                imaginary = 0;
            }
            else
            {
                int nLen = s.Length;
                string sLeft = s.Substring(0, nPos);
                string sRight = s.Substring(nPos + 1, nLen - nPos - 1);
                sLeft = sLeft.Trim();
                sRight = sRight.Trim();
                real = Double.Parse(sLeft);
                imaginary = Double.Parse(sRight);
            }

        }

        /// <summary>
        /// 重载+运算符
        /// </summary>
        /// <param name="cpx1">当前复数</param>
        /// <param name="cpx2"></param>
        /// <returns></returns>
        public static Complex operator +(Complex cpx1, Complex cpx2)
        {
            return cpx1.Add(cpx2);
        }

        /// <summary>
        /// 重载-运算符
        /// </summary>
        /// <param name="cpx1"></param>
        /// <param name="cpx2"></param>
        /// <returns></returns>
        public static Complex operator -(Complex cpx1, Complex cpx2)
        {
            return cpx1.Subtract(cpx2);
        }

        /// <summary>
        /// 重装*运算符
        /// </summary>
        /// <param name="cpx1"></param>
        /// <param name="cpx2"></param>
        /// <returns></returns>
        public static Complex operator *(Complex cpx1, Complex cpx2)
        {
            return cpx1.Multiply(cpx2);
        }

        /// <summary>
        /// 重载/运算符
        /// </summary>
        /// <param name="cpx1"></param>
        /// <param name="cpx2"></param>
        /// <returns></returns>
        public static Complex operator /(Complex cpx1, Complex cpx2)
        {
            return cpx1.Divide(cpx2);
        }

        /// <summary>
        /// 重载double运算符
        /// </summary>
        /// <param name="cpx"></param>
        /// <returns></returns>
        public static implicit operator double(Complex cpx)
        {
            return cpx.Abs();
        }

        /// <summary>
        /// 将复数a+bj形式
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            string s;
            if (real != 0.0)
            {
                if (imaginary > 0)
                    s = real.ToString("F") + "+" + imaginary.ToString("F") + "j";
                else if (imaginary < 0)
                {
                    double absImag = -1 * imaginary;
                    s = real.ToString("F") + "-" + absImag.ToString("F");
                }
                else
                {
                    s = real.ToString("F");
                }
            }
            else
            {
                if (imaginary > 0)
                    s = imaginary.ToString("F") + "j";
                else if (imaginary < 0)
                {
                    double absImag = -1 * imaginary;
                    s = absImag.ToString("F") + "j";
                }
                else
                    s = real.ToString("F");
            }
            return s;
        }

        public override bool Equals(object obj)
        {
            Complex cmpx = obj as Complex;
            if (cmpx == null)
                return false;
            return Math.Abs(this.real - cmpx.real) <= eps && Math.Abs(this.imaginary - cmpx.imaginary) <= eps;
        }

        /// <summary>
        /// 重写GetHashCode
        /// </summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            return (int)Math.Sqrt(real * real + imaginary * imaginary);
        }

        /// <summary>
        /// 给复数赋值
        /// </summary>
        /// <param name="cpxx"></param>
        /// <returns></returns>
        public Complex SetValue(Complex cpxx)
        {
            real = cpxx.real;
            imaginary = cpxx.imaginary;
            return this;
        }

    }
}