精华内容
下载资源
问答
  • 使用opencv实现复数矩阵相除,点除

    千次阅读 2019-05-28 11:57:51
    因为有matlab代码需要在opencv上实现,遇到了./的问题,在网上参考了许多代码,但是与matlab的结果不符,于是自己着手实现了一下,与matlab验证证明是正确的。 Mat cmplxDivision(Mat m1, Mat m2) { ...

    因为有matlab代码需要在opencv上实现,遇到了./的问题,在网上参考了许多代码,但是与matlab的结果不符,于是自己着手实现了一下,与matlab验证证明是正确的。

    Mat cmplxDivision(Mat m1, Mat m2) {

    int rows = m2.rows;//矩阵的行数以及列数
    int cols = m2.cols;
    
    Mat m1_2[2], m2_2[2];//用于存放矩阵的实部和虚部
    Mat m1_rea, m1_ima, m2_rea, m2_ima;//用于分开存放实部和虚部,便于计算
    
    split(m1, m1_2);
    split(m2, m2_2);
    
    m1_rea = m1_2[0];
    m1_ima = m1_2[1];
    m2_rea = m2_2[0];
    m2_ima = m2_2[1];
    
    Mat result1(rows, cols, CV_64FC1);//存放用于计算的实部
    Mat result2(rows, cols, CV_64FC1);//存放用于计算的虚部
    //(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +((bc-ad)/(c^2+d^2))i
    for (int i = 0; i < rows; i++)
    {
    	for (int j = 0; j < cols; j++)
    	{
    		result1.at<double>(i, j) = (m1_rea.at<double>(i, j)*m2_rea.at<double>(i, j) + m1_ima.at<double>(i, j)*m2_ima.at<double>(i, j)) / (m2_rea.at<double>(i, j)*m2_rea.at<double>(i, j)+ m2_ima.at<double>(i, j)*m2_ima.at<double>(i, j));
    		result2.at<double>(i, j) = (m1_ima.at<double>(i, j)*m2_rea.at<double>(i, j) - m1_rea.at<double>(i, j)*m2_ima.at<double>(i, j)) / (m2_rea.at<double>(i, j)*m2_rea.at<double>(i, j) + m2_ima.at<double>(i, j)*m2_ima.at<double>(i, j));
    	}
    }
    
    Mat result_2[2] = { result1 ,result2 };
    Mat result;
    merge(result_2, 2, result);
    return result;
    

    }

    展开全文
  • 实现复数

    2021-01-09 17:17:19
    实现复数类 【问题描述】 实现复数类,下图是复数类的UML图。... div 复数相除 QQ图片20200403091931.jpg 【输入形式】 【输出形式】 【样例输入】 1 2 3 4 【样例输出】 c1: 1 + 2i c2: 3 + 4i c3: 0 + 0i c1

    实现复数类

    **
    【问题描述】

    实现复数类
    add-复数相加
    sub-复数相减
    mul-复数相乘
    div- 复数相除

    【样例输入】

    1 2 3 4

    【样例输出】

    c1: 1 + 2i

    c2: 3 + 4i

    c3: 0 + 0i

    c1+c2 = 4 + 6i

    c1-c2 = -2 + -2i

    c1*c2 = -5 + 10i

    c1/c2 = 0.44 + 0.08i

    #include <iostream>
    
    using namespace std;
    
    class ComplexNumber
    {
    private:
        double real,imaginary;
    public:
        ComplexNumber();
        ComplexNumber(double ,double );
        double Getreal();
        double Getimaginary();
        ComplexNumber add(ComplexNumber );
        ComplexNumber sub(ComplexNumber );
        ComplexNumber mul(ComplexNumber );
        ComplexNumber div(ComplexNumber );
        void output();
    };
    ComplexNumber::ComplexNumber()
    {
        cin>>real>>imaginary;
    }
    ComplexNumber::ComplexNumber(double r,double i)
    {
        real=r;
        imaginary=i;
    }
    double ComplexNumber::Getreal()
    {
        return real;
    }
    double ComplexNumber::Getimaginary()
    {
        return imaginary;
    }
    ComplexNumber ComplexNumber:: add(ComplexNumber cn)
    {
        ComplexNumber c;
        c.real=real+cn.real;
        c.imaginary=imaginary+cn.imaginary;
        return c;
    }
    ComplexNumber ComplexNumber:: sub(ComplexNumber cn)
    {
        ComplexNumber c;
        c.real=real-cn.real;
        c.imaginary=imaginary-cn.imaginary;
        return c;
    }
    ComplexNumber ComplexNumber:: mul(ComplexNumber cn)
    {
        ComplexNumber c;
        c.real=real*cn.real-imaginary*cn.imaginary;
        c.imaginary=imaginary*cn.real+real*cn.imaginary;
        return c;
    }
    ComplexNumber ComplexNumber:: div(ComplexNumber cn)
    {
        ComplexNumber c;
        c.real=(real*cn.real+imaginary*cn.imaginary)/(cn.real*cn.real+cn.imaginary*cn.imaginary);
        c.imaginary=(imaginary*cn.real-real*cn.imaginary)/(cn.real*cn.real+cn.imaginary*cn.imaginary);
        return c;
    }
    void ComplexNumber::output()
    {
        cout<<real<<" + "<<imaginary<<"i"<<endl;
    }
    int main()
    {
       ComplexNumber c3(0,0);
       ComplexNumber c1,c2;
       cout<<"c1: ";
       c1.output();
       cout<<"c2: ";
       c2.output();
       cout<<"c3: ";
       c3.output();
       c3=c1.add(c2);
       cout<<"c1+c2 = ";
       c3.output();
       c3=c1.sub(c2);
       cout<<"c1-c2 = ";
       c3.output();
       c3=c1.mul(c2);
       cout<<"c1*c2 = ";
       c3.output();
       c3=c1.div(c2);
       cout<<"c1/c2 = ";
       c3.output();
        return 0;
    }
    
    展开全文
  • 2通道复数Mat的共轭 代码如下 cv::Mat conj4mat(cv::Mat src) { if (src.channels() != 2) { std::cout &lt;&lt; "func CONJ4MAT : channels parameters error!" &lt;&lt; std::...

    2通道复数Mat的共轭

    代码如下

    cv::Mat conj4mat(cv::Mat src) {
            if (src.channels() != 2) {
                std::cout << "func CONJ4MAT : channels parameters error!" << std::endl;
                return Mat();
            }
            int cols = src.cols;// 表示x轴
            int rows = src.rows;// 表示y轴
            cv::Mat result = cv::Mat::zeros(cv::Size(cols, rows), CV_32FC2);
            /*核心思想:
                将图像按照每一行的顺序,进行展开,成为一个长的向量。
                例如一个Size(640,480)的图像,展开后,向量的长度为 640*480
            */
            std::vector<cv::Mat> channels;//用于存放实部和虚部,channels[0]存放的是实部,channels[1]存放的是虚部
            std::complex<double>* conj4mat = new std::complex<double>[cols * rows]; //用于存放展开后的复数向量
            std::complex<double> temp;
            cv::split(src, channels);
            int k = 0;//用于存放数据到复数数组里的索引,其最大值应该为 rows * cols
            double real = 0, imag = 0;
    
            //前向计算过程
            for (size_t i = 0; i < cols; i++) {
                for (size_t j = 0; j < rows; j++) {
                    real = channels[0].at<float>(j, i);
                    imag = channels[1].at<float>(j, i);
                    temp = std::complex<double>(real, imag);
    
                    conj4mat[k] = temp;
                    k++;
                }
            }
            k = 0;
            std::complex<double> middle;
            //反向释放数据到Mat
            for (size_t i = 0; i < cols; i++) {
                for (size_t j = 0; j < rows; j++) {
                    middle = std::conj(conj4mat[k]);
                    real = middle.real();
                    imag = middle.imag();
                    channels[0].at<float>(j, i) = real;
                    channels[1].at<float>(j, i) = imag;
    
                    k++;
                }
            }
    
            // 将求得的结果合并为一个Mat
            merge(channels, result);
            return result;
        }

    两个复数Mat的直积

    cv::Mat cmplxMul(cv::Mat m1, cv::Mat m2) {
        //assert(m1.rows != m2.rows,"相乘矩阵的维度不一致");
        //assert(m1.cols != m2.cols,"相乘矩阵的维度不一致");
    
        int rows = m1.rows;//矩阵的行数以及列数
        int cols = m1.cols;
    
        cv::Mat result = cv::Mat::zeros(rows, cols,CV_32FC2);
    
        //用于存放实部[0]以及虚部[1]
        vector<Mat> channels_m1;
        vector<Mat> channels_m2;
        vector<Mat> channels_result;
    
        split(m1, channels_m1);
        split(m2, channels_m2);
        split(result, channels_result);
    
        //用于将矩阵形式的复数转换乘向量
        vector<std::complex<float>> complex_result;
    
    
        std::complex<float> m1_c;
        std::complex<float> m2_c;
    
        //分解m1以及m2中的复数
        for (size_t i = 0; i < rows; i++) {
            for (size_t j = 0; j < cols; j++) {
                m1_c = std::complex<float>(
                    channels_m1[0].at<float>(i, j),
                    channels_m1[1].at<float>(i, j));
                m2_c = std::complex<float>(
                    channels_m2[0].at<float>(i, j),
                    channels_m2[1].at<float>(i, j));
                complex_result.push_back(m1_c * m2_c);
            }
        }
    
        int k = 0;
        //反向释放数据到Mat
        for (size_t i = 0; i < rows; i++) {
            for (size_t j = 0; j < cols; j++) {
                channels_result[0].at<float>(i, j) = complex_result[k].real();
                channels_result[1].at<float>(i, j) = complex_result[k].imag();
                k++;
            }
        }
    
        merge(channels_result, result);
    
        return result;
    }

    两个复数Mat的对应位相除

    cv::Mat cmplxDivision(cv::Mat m1, cv::Mat m2) {
        //assert(m1.rows != m2.rows,"相乘矩阵的维度不一致");
        //assert(m1.cols != m2.cols,"相乘矩阵的维度不一致");
    
        int rows = m1.rows;//矩阵的行数以及列数
        int cols = m1.cols;
    
        cv::Mat result = cv::Mat::zeros(rows, cols, CV_32FC2);
    
        //用于存放实部[0]以及虚部[1]
        vector<Mat> channels_m1;
        vector<Mat> channels_m2;
        vector<Mat> channels_result;
    
        split(m1, channels_m1);
        split(m2, channels_m2);
        split(result, channels_result);
    
        //用于将矩阵形式的复数转换乘向量
        vector<std::complex<float>> complex_result;
    
        std::complex<float> m1_c;
        std::complex<float> m2_c;
    
        //分解m1以及m2中的复数
        for (size_t i = 0; i < rows; i++) {
            for (size_t j = 0; j < cols; j++) {
                m1_c = std::complex<float>(
                    channels_m1[0].at<float>(i, j),
                    channels_m1[1].at<float>(i, j));
                m2_c = std::complex<float>(
                    channels_m2[0].at<float>(i, j),
                    channels_m2[1].at<float>(i, j));
                complex_result.push_back(m1_c / m2_c);
            }
        }
        int k = 0;
        //反向释放数据到Mat
        for (size_t i = 0; i < rows; i++) {
            for (size_t j = 0; j < cols; j++) {
                channels_result[0].at<float>(i, j) = complex_result[k].real();
                channels_result[1].at<float>(i, j) = complex_result[k].imag();
                k++;
            }
        }
        merge(channels_result, result);
        return result;
    }
    展开全文
  • 1.重载和实现复数相除 #include using namespace std; class complex { public: complex () { real = 0; imag = 0; } complex(double r, double i) { real = r; imag = i; } complex operator / (complex &...

    1.重载和实现复数相除

    #include<iostream
    using namespace std;
    class complex
    {
    public:
    complex ()
    { real = 0; imag = 0; }
    complex(double r, double i) { real = r; imag = i; }
    complex operator / (complex &c2);
    void display();
    private:
    double real;
    double imag;
    };
    complex complex:: operator / (complex &c2)
    {
    complex c;
    c.real = (realc2.real + imag * c2.imag) / ((c2, real + c2.imag)(C2, real + c2.imag));
    c.imag = (inagc2.real 一realc2 imag) / ((c2, real + c2.imag)*(c2, real + c2.inag));
    return c;
    }

    void complex : : disp1ay()
    {
    cout << “(”<< real <<","<< imag << “i)” << endl ;
    }

    int main()
    {
    complex c1(3,9), c2(6, 4),c3;
    c3 = c1 / c2;
    cout << “c1/c2=”;
    c3.display();
    return 0;
    }

    2.重载和实现复数相减

    a.友元的加入

    #include <iostream
    using namespace std;
    class complex
    {
    public:
    complex() { real = 0; imag = 0; }
    complex(double r, double i) { real = r; imag = i; }
    friend complex operator - (complex &c1, complex &c2);
    void display();
    private:
    double real;
    double imag;

    };

    complex operator - (complex &c1, complex &c2)
    {
    return(c1.real - c2.real, c1.imag - c2.imag);
    }
    void complex::display()
    {
    cout<<"("<< real<<","<< imag << “i)” << endl;
    }
    int main()
    {
    complex c1(3, 9), c2(8, 7), c3;
    c3 = c1 - c2;
    cout << “c1-c2”;
    c3.display();
    return 0;
    }

    b.类的的成员函数

    #include<iostream
    using namespace std;
    class complex
    {
    public:
    complex() { real = 0; imag = 0; }
    complex(double r, double i) { real = r; imag = i; }
    complex operator - (complex &c2);
    void display();
    private:
    double real;
    double imag;

    };

    complex complex:: operator - (complex &c2)
    {
    complex c;
    c.real = real + c2.real;
    c.imag = imag + c2.imag;
    return c;
    }
    void complex:: display()
    {
    cout<<"("<< real <<","<<imag << “i)”<<endl;
    }
    int main()
    {
    complex c1(3, 9), c2(8, 7), c3;
    c3 = c1 - c2;
    cout << “c1-c2=”;
    c3.display();
    return 0;
    }

    展开全文
  • //复数相加: (a+bi)+(c+di)=(a+c)+(b+d)i. //复数相乘:(a+bi)(c+di)=(ac-bd)+(bc+ad)i. ...//复数相除:(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +(bc-ad)/(c^2+d^2)i #include using namespace std;
  • 公式: 复数相加:(a+bi)+(c+di)=(a+c)+(b+d)i 复数相减:(a+bi)-(c+di)=(a-c)+(b-d)i ...复数相除:(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +(bc-ad)/(c^2+d^2)i 代码: #include <iostream> usi...
  • 复数

    2018-01-12 12:19:54
    定义复数类,实现对复数的相加,相乘和相除操作#include using namespace std; class Complex { private: float real; float image; public: Complex(){real=0;image=0;}; Complex(float r,float i):real...
  • 自然数学-复数

    2020-12-10 19:49:22
    相乘三角式 相乘指数式相除三角式 相除用向量表示复数共轭复数复数的乘幂及开方运算性质例4 问题引入 虚数单位 例1 复数的定义 例2 复数的相等 两个非实数的复数不能比较大小, 只能说相等或不相等 例3 ...
  • 本文实例为大家分享了简单实现C++复数计算器的具体代码,供大家参考,具体内容如下 1.有关计算器的功能  A,实现多个复数(包括实数)的加减乘除,大小比较,   B.实现十进制实数的进制转换,...辗转相除,记录每次
  • 复数四则运算

    2013-04-09 10:47:40
    设计、编写和调试面向对象C++ 程序,支持和实现任意两个复数的加、 ...显示及任意两个复数相加/ 相减/ 相乘/ 相除与结果显示功能(注意是通过调用复数 类的对应成员函数来实现而非其自身直接实现)
  • 结论:迭代序列: x (n+1...牛顿迭代法:在实数和复数域求方程的近似根,由泰勒级数前几项寻找 计算方法: 设 x 是 f(x) = 0的根,选取 x0 作为 x 初始近似值,过点( x0, f(x ) )做曲线y = f(x)的切线L,则...
  • 复数 布尔 Integer Float Complex Boolean 算术运算符 PY中所有算术运算符如下: 运算符 中文名称 功能描述 例子 + 加 两个数字相加 print(3+5),输出8 - 减 两个数字相减 print(5-3),输出2 * 乘...
  • 1.7 多项式相除 1.8 复系数多项式相除 第2章 复数运算 2.1 复数乘法 2.2 负数除法 2.3 复数乘幂 2.4 复数的n次方根 2.5 复数指数 2.6 复数对数 2.7 复数正弦 2.8 复数余弦 第3章 随机数的产生 3.1 产生0到1之间均匀...
  • 1.**Python相除** 整数相除不会丢失小数部分,但精度与机器相关。调用//相除可以将小数部分去掉; 2.**复数** 复数也有支持; 虚数部分写得时候要加上后缀, j 或 i. 实部非零的复数被写作 (real+imagj), 也可以...
  • Python笔记:数字类型

    2021-02-22 18:21:30
    整数在Python中相除,结果以浮点型存放。( 例如 6/2 =3.0) 2.浮点数 在python 中浮点数计算会产生误差,它跟c语言一样采用 IEEE754 的标准来存储浮点数。 那么,如何做到精确浮点数的计算呢,我们需要借助一个...
  • 2、利用辗转相除法求两个数的最大公约数。要求能接受用户的输入,输出最大公约数。 辗转相除法原理: ...3、完善实验四中的复数类,为复数类重写方法equals,判断该对象与参数是否相等。方法头为:
  • Python 内置函数

    2021-01-27 15:38:45
    目录获取数字的绝对值获取两数相除的商和余数控制台输入打开文件 获取数字的绝对值 """ 参数可以是整数、浮点数、复数(z=a+bj) 如果你不知道复数是啥,当我没说= 。= """ # 输出整数的绝对值 结果:1 print...
  • Python 02天

    2021-06-02 11:01:05
    一.数字类型 ...x除以y得结果(地板除 即如果相除结果不是整数则向下取整 [取比目标结果小的最大整数]) divmod(x,y) 返回(x // y , x % y) -x x的相反数 +x x本身 abs(x) x的绝对值 如果x为复数
  • 2021/2/1 Day3

    2021-02-01 16:34:11
    前几天把进度落下了,惭愧,今天开始继续学,希望...abs在实数时返回绝对值,但是在复数时返回的时复数的模 以下是所有结果为False的情况: 逻辑运算符 and和or都遵从短路逻辑 Python的运算符优先级: ...
  • * 初等函数的MATLAB实验 三角函数 建立一个复数 舍入和相除后求余 离散数学 三角函数 双曲余割 xh(z) =1/sh z 其中指数函数exponential function可由无穷级数定义 e^z=1+z/1+z^2/2+z^3/3+z^4/4++z^n/n+ 双曲函数的反...
  • 1.7 多项式相除 1.8 复系数多项式相除 1.9 实系数多项式类 1.10 复系数多项式类 第2章 复数运算 2.1 复数乘法 2.2 复数除法 2.3 复数乘幂 2.4 复数的n次方根 2.5 复数指数 2.6 复数对数 2.7 复数正弦 2.8 复数余弦 ...
  • 使用复数向量法对一种非平面9杆巴氏桁架进行了位移分析。首先建立4个回路几何关系,列出矢量方程组,并转化成为复指数形式;然后使用Sylvester结式对4个多项式方程消元,直接得到一元46次方程,再用辗转相除法求其他...
  • PHP学习笔记2

    2021-01-17 01:46:20
    % :取余(模)运算,两个数(整数)相除,保留余数,如果被除数(%前面那个)是复数结果也是复数 &&:逻辑与,左边的条件与右边的条件同时成立(两边结果都为true) ||:逻辑或,左边的条件或者右边的条件...
  • python基础

    2018-06-06 08:42:32
    1,数据类型分为6种:Number 数字String 字符串List 列表Tuple 元祖Sets 集合Dictionary 字典数值类型3种:int 整数float 浮点数complex 复数2.2.1整型整数与整数相除默认值为浮点数,使用地板除(//)就是取点前面的...
  • 数字分为整数,浮点数,复数和布尔 算术运算符表 运算符 中文名 功能 例子 + 加 两个数字相加 print(1+2),3 - 减 两个数字相减 print(2-1),1 * 乘 两个数字相乘 print(1*2),2 / 除 两个数字相除 print...
  • 首先使用矢量法和复数法建立4个几何约束方程式,再使用Sylvester结式消元法对4个方程式分3步消元,得到一个一元44次的多项式方程,在使用辗转相除法求解其他3个变量的过程中发现了4个增根。分柝了增根产生的原因并...
  • python基础:数

    2020-11-15 14:35:46
    python数的总结 python数的详细说明 ...注意:相除得到的结果始终是float类型,无论2个数都是int型,还是不全为int a = 3/2 print(type(a), a) b = 3/3 print(type(b), b) 取整,// 平方,** ...
  • Python基础(1)

    2018-09-29 19:46:14
    int , float, complex(复数类型), bool。 简单的数值计算 _ : 存储上一次计算的结果 // : 两数相除后的商向下取整 ** : 次方 decimal : 精确运算,控制小数点后的位数等等。 序列类型 turpel(元组), list, ...
  • 首先使用矢量法和复数法建立4个几何约束方程式,并将其转化成复指数形式,再使用Dixon结式对其中3个方程式构造一个消去两个变元的6×6Dixon矩阵。将矩阵的行列式展开后得到二元高次多项式方程,该方程与剩下一个含有...
  • 线性代数应该这样学

    2019-10-31 21:39:33
    1.负数:先介绍了复数的各种基本操作,例如相加相减相乘相除,结合律,分配率。  单位元,从某种程度上可以理解为0,加法逆就是负数,乘法逆就是倒数。 2.向量空间:是一个有长度(非负)的组,n也是其长度。 3.组...

空空如也

空空如也

1 2 3
收藏数 49
精华内容 19
关键字:

复数相除