复数是C#中没有的,不能直接调用的。但是我们可以通过封装,构造自己的复数形式。这里我自己封装了一个Complex类,也不知道写得如何。可能还有一些东西没有考虑。

不过这里包含了复数的基本晕算了了,包括加减乘除、取模运算、计算相位角等!详细信息其直接阅读代码。都包含注释了。

/// <summary>
    /// 复数类
    /// </summary>
    public class Complex
    {
        private double real;//实部
        private double image;//虚部
        /// <summary>
        /// 获取或设置实部
        /// </summary>
        public double Real
        {
            get { return real; }
            set { real = value; }
        }
        /// <summary>
        /// 获取或者设置虚部
        /// </summary>
        public double Image
        {
            get { return image; }
            set { image = value; }
        }
        public Complex(double real, double image)
        {
            this.real = real;
            this.image = image;
        }
        public Complex() { }
        /// <summary>
        /// 取共轭
        /// </summary>
        public Complex Conjugate()
        {
            //Complex complex = new Complex();
            //complex.real = this.real;
            //complex.image = -complex.image;
            //return complex;
            return new Complex(this.real, -this.image);
        }
        /// <summary>
        /// 加法重载函数
        /// </summary>
        /// <param name="C">加数</param>
        /// <param name="c">加数</param>
        /// <returns>复数相加的结果</returns>
        public static Complex operator +(Complex C, Complex c)
        {
            //Complex com = new Complex();
            //com.real = C.real + c.real;
            //com.image = C.image + c.image;
            //return com;
            return new Complex(c.real + C.real, C.image + c.image);
        }
        /// <summary>
        /// 复数的加法,可以同时实现多个复数相加
        /// 其实跟直接用+号来相加的结果是一样的,
        /// 个人只是想多学习可变参数的用法
        /// </summary>
        /// <param name="complexs"></param>
        /// <returns></returns>
        public Complex Add(params Complex[] complexs)
        {
            if (complexs.Length == 0)
            {
                throw new Exception("输入的参数不能为空!");
            }
            Complex com = new Complex();
            foreach (Complex c in complexs)
            {
                com = com + c;
            }
            return com;
        }
        /// <summary>
        /// 复数的减法重载函数
        /// </summary>
        /// <param name="C">被减数</param>
        /// <param name="c">减数</param>
        /// <returns>复数相减后的结果</returns>
        public static Complex operator -(Complex C, Complex c)
        {
            //Complex com = new Complex();
            //com.real = C.real -c.real;
            //com.image = C.image - c.image;
            //return com;
            return new Complex(C.real - c.real, C.image - c.Image);
        }
        /// <summary>
        /// 双等号函数的重载
        /// </summary>
        /// <param name="C"></param>
        /// <param name="c"></param>
        /// <returns>如果相等返回true,否则返回fasle</returns>
        public static bool operator ==(Complex C, Complex c)
        {
            return (C.real == c.real && C.image == c.image);
        }
        /// <summary>
        /// 不等号函数的重载
        /// </summary>
        /// <param name="C"></param>
        /// <param name="c"></param>
        /// <returns></returns>
        public static bool operator !=(Complex C, Complex c)
        {
            return (C.real != c.real || C.image != c.image);
        }
        /// <summary>
        /// 复数的相减,可以同时实现多个复数相减
        /// 其实跟直接用-号来相加的结果是一样的,
        /// 个人只是想多学习可变参数的用法
        /// </summary>
        /// <param name="complexs">数的集合</param>
        /// <returns>相减操作后的复数</returns>
        public Complex Minus(params Complex[] complexs)
        {
            if (complexs.Length == 0)
            {
                throw new Exception("输入的参数不能为空!");
            }
            Complex com =complexs[0];
            for (int i = 1; i < complexs.Length; i++)
            {
                com = com - complexs[i];
            }
            return com;
        }
        /// <summary>
        /// 复数的乘法运算
        /// </summary>
        /// <param name="c"></param>
        /// <param name="C"></param>
        /// <returns></returns>
        public static Complex operator *(Complex c, Complex C)
        {
            //(a+b*i)*(c+d*i)=(ac-bd)+(ad+bc)*i
            return new Complex(c.real * C.real-c.image*C.image, c.real*C.image+c.image * C.real);
        }
        public Complex Multiplicative(params Complex[] complexs)
        {
            if (complexs.Length == 0)
            {
                throw new Exception("输入的参数不能为空!");
            }
            Complex com = complexs[0];
            for (int i = 1; i < complexs.Length; i++)
            {
                com += complexs[i];
            }
            return null;
        }
        /// <summary>
        /// 复数除法
        /// </summary>
        /// <param name="C"></param>
        /// <param name="c"></param>
        /// <returns></returns>
        public static Complex operator /(Complex C, Complex c)
        {
            if (c.real == 0 && c.image == 0)
            {
                throw new Exception("除数的虚部和实部不能同时为零(除数不能为零)");
            }
            double real = (C.real * c.real + c.image * C.image)/(c.real*c.real+c.image+c.image);
            double image=(C.image*c.real-c.image*C.real)/(c.real*c.real+c.image+c.image);
            return new Complex(real,image);
        }
        /// <summary>
        /// 复数除法运算
        /// </summary>
        /// <param name="complexs">一系列复数</param>
        /// <returns>除法运算后的结果</returns>
        public Complex Divison(params Complex[] complexs)
        {
            if (complexs.Length == 0)
            {
                throw new Exception("输入的参数不能为空!");
            }
            foreach (Complex com in complexs)
            {
                if (com.image==0&&com.real==0)
                {
                    throw new Exception("除数的实部和虚部不能同时为零!");
                }
            }
            Complex COM = new Complex();
            COM = complexs[0];
            for (int i = 1; i < complexs.Length; i++)
            {
                COM = COM / complexs[i];
            }
            return COM;
        }
        /// <summary>
        /// 取模运算
        /// </summary>
        /// <param name="c"></param>
        /// <returns></returns>
        public double Mod(Complex c)
        {
            return Math.Sqrt(c.real * c.real + c.image * c.image);
        }
        /// <summary>
        /// 判断复数是否相等
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public override bool Equals(object obj)
        {
            if (obj is Complex)
            {
                Complex com = (Complex)obj;
                return (com.real == this.real && com.image == this.image);
            }
            return false;
        }
        /// <summary>
        /// 计算复数相位角
        /// </summary>
        /// <param name="c"></param>
        /// <returns></returns>
        public static double GetAngle(Complex c)
        {
            return Math.Atan2(c.real, c.image);
        }
        public override string ToString()
        {
            //string str = null;
            //if (this.image == 0)
            //{
            //    str = "=";
            //}
            //else if (this.image > 0)
            //{
            //    str = ">";
            //}
            //switch (str)
            //{
            //    case ">":
            //        if (this.real == 0)
            //        {
            //            return string.Format("{0}i", this.image);
            //        }
            //        return string.Format("{0}+{1}i", this.real, this.image);
            //    case "=":
            //        return string.Format("{0}",this.real);
            //    default:
            //         if (this.real == 0)
            //        {
            //            return string.Format("{0}i", this.image);
            //        }
            //        return string.Format("{0}+{1}i", this.real, this.image);
            //}
            return string.Format("<{0} , {1}>", this.real, this.image);
        }
    }

第一次发博文,也知道自己的水平菜菜的,慢慢进步。。

C#复数类的总结的更多相关文章

  1. [GeekBand] C++学习笔记(1)——以复数类为例

    本篇笔记以复数类(不含指针的类)为例进行面向对象的学习 ========================================================= 复数类的声明: class ...

  2. 复数类(C++练习一)

    写一个复数类,实现基本的运算,目的熟悉封装与数据抽象. 类的定义 #include <iostream> #include <vector> using namespace s ...

  3. C++习题 复数类--重载运算符2+

    Description 定义一个复数类Complex,重载运算符"+",使之能用于复数的加法运算.参加运算的两个运算量可以都是类对象,也可以其中有一个是整数,顺序任意.例如,c1+ ...

  4. C++习题 复数类--重载运算符+

    Description 定义一个复数类Complex,重载运算符"+",使之能用于复数的加法运算.将运算符函数重载为非成员.非友元的普通函数.编写程序,求两个复数之和. Input ...

  5. 15.C++-操作符重载、并实现复数类

    首先回忆下以前学的函数重载 函数重载 函数重载的本质为相互独立的不同函数 通过函数名和函数参数来确定函数调用 无法直接通过函数名得到重载函数的入口地址 函数重载必然发生在同一个作用域中 类中的函数重载 ...

  6. C++ 实验 使用重载运算符实现一个复数类

    实验目的: 1.掌握用成员函数重载运算符的方法 2.掌握用友元函数重载运算符的方法 实验要求: 1.定义一个复数类,描述一些必须的成员函数,如:构造函数,析构函数,赋值函数,返回数据成员值的函数等. ...

  7. 定义一个复数(z=x+iy)类Complex,包含: 两个属性:实部x和虚部y 默认构造函数 Complex(),设置x=0,y=0 构造函数:Complex(int i,int j) 显示复数的方法:showComp()将其显示为如: 5+8i或5-8i 的形式。 求两个复数的和的方法:(参数是两个复数类对象,返回值是复数类对象)public Complex addComp(Compl

    因标题框有限,题目未显示完整,以下再放一份: 定义一个复数(z=x+iy)类Complex,包含: 两个属性:实部x和虚部y 默认构造函数 Complex(),设置x=0,y=0 构造函数:Compl ...

  8. 侯捷《C++面向对象开发》——动手实现自己的复数类

    前言 最近在看侯捷的一套课程<C++面向对象开发>,刚看完第一节introduction之后就被疯狂圈粉.感觉侯捷所提及所重视的部分也正是我一知半解的知识盲区,我之前也写过一些C++面向对 ...

  9. YTU 2443: C++习题 复数类--重载运算符3+

    2443: C++习题 复数类--重载运算符3+ 时间限制: 1 Sec  内存限制: 128 MB 提交: 1368  解决: 733 题目描述 请编写程序,处理一个复数与一个double数相加的运 ...

随机推荐

  1. serde

    一.背景 1.当进程在进行远程通信时,彼此可以发送各种类型的数据,无论是什么类型的数据都会以二进制序列的形式在网络上传送. 发送方需要把对象转化为字节序列才可在网络上传输,称为对象序列化: 接收方则需 ...

  2. 【搜索】Fliptile

    #include<stdio.h> #include<stdlib.h> #include<string.h> ; ; typedef long long ll; ...

  3. HDU 6129 Just do it

    题意:给你一个包含n个数的序列A和一个数m,序列B中的数是序列A经过异或得到的,比如:b[i]=a[1]^a[2]^…..^a[i].现在让你求经过m次异或后,序列B的值.  思路:这题其实和杨辉三角 ...

  4. html-day04

    html-day04 1.html属性的弊端 1.完成相同的功能需要不同的属性支持 2.可维护性不高2.CSS 1.什么是CSS Cascading Style Sheet 层叠样式表.级联样式表.样 ...

  5. 2018.11.05 bzoj2143: 飞飞侠(最短路)

    传送门 最短路好题. 考虑对每个二维坐标建立一个高度属性. 这样每次如果在点(i,j,0)(i,j,0)(i,j,0)只能选择花费bi,jb_{i,j}bi,j​跳向(i,j,ai,j)(i,j,a_ ...

  6. poj-1195(二维树状数组)

    题目链接:传送门 题意:给出操作,按照操作进行. 思路:将树状数组设置为二维的就行了. 注意: (1)每次求出的面积是S(x2,y2)-S(x1-1,y2)-S(x2,y1-1)+S(x1-1,y1- ...

  7. nxn随机矩阵乘以概率向量依旧是概率向量

    由上面可进一步推到出A*A是随机矩阵看成(A a1,A a2...A an) 所以A^m依然是随机矩阵.

  8. Livelock

    Unlike deadlock, livelocked packets continue to move through the network, but never reach their dest ...

  9. Mybatis之动态构建SQL语句(转)

    https://www.cnblogs.com/zhangminghui/p/4903351.html

  10. mysql update受影响的行数为0或查询结果为空时

    当执行update语句时,如果受影响的行数是0,返回的也是true. $conn = new mysqli(); $sql = "update ..."; $query = $co ...