精华内容
下载资源
问答
  • MATLAB 定义数组时,行数和列数必须是提前确定好的,因此,MATLAB定义矩阵一定是等宽的。 而 java 定义数组时,可以只确定行数,因此,可以定义不等宽的矩阵。 举例:  double[][] e = new double[3][]; for...

    MATLAB 定义数组时,行数和列数必须是提前确定好的,因此,MATLAB定义的矩阵一定是等宽的,除非用元胞类型 cell。

    而 java 定义数组时,可以只确定行数,因此,可以定义不等宽的矩阵。

    举例: 


    double[][] e = new double[3][];
    		for (int i=0;i<3;i++)
    		{
    			e[i] = new double[i+1];
    		}
    
    		
    		System.out.println(Arrays.deepToString(e));


    输出:

    [[0.0], [0.0, 0.0], [0.0, 0.0, 0.0]]

    展开全文
  • { //如何定义M1为空矩阵 /*M1 = (int **)malloc(sizeof(int *)); for (i = 0; i ; i++) { for (j = 0; j ; j++) { *(M1 + i) = (double *)malloc(sizeof(double) * 3); } } for (i...
  • 定义: 含有大量0元素的矩阵 不是稀疏矩阵,则称满矩阵。full matrix matlab对稀疏矩阵有专门的的运算命令,为了节省存储空间和运算时间。 怎么节省存储空间? 一个m×nm\times nm×n的满矩阵,元素的数据类型是...

    定义: 含有大量0元素的矩阵

    不是稀疏矩阵,则称满矩阵。full matrix

    matlab对稀疏矩阵有专门的的运算命令,为了节省存储空间和运算时间。

    • 怎么节省存储空间?
      一个m×nm\times n的满矩阵,元素的数据类型是double,则总共需要m×n×8m\times n\times 8个Bytes。

    如果它满足稀疏特性,即大量元素为0,则可以存储为稀疏矩阵,只需要存储所有非零元素的值和位置(行号,列号),一般行号列号均占8个字节,所以每个非零元素需要用24个字节,那么如果有M个非零元素,则需要的存储空间是24×M24\times M个Bytes。

    非零元素越少,需要的内存越少。
    在这里插入图片描述

    a=eye(1000); % 单位阵
    b=speye(1000); % 或sparse(a)
    whos
    

    b多了8个字节,我不知道是存了什么

     Name         Size                Bytes  Class     Attributes
    
      a         1000x1000            8000000  double              
      b         1000x1000              24008  double    sparse    
    
    • 怎么节省运算时间?
      计算时也只对非零元素操作,

    在这里插入图片描述

    s=sparse([1,2,3,4,5],[5,4,3,2,1],[12 23 34 45 53],6,7) % 6行7列的稀疏矩阵
    a=full(s)
    b=[1 0 0;3 0 4;0 0 3;0 5 0]
    c=sparse(b)
    d=rand(10,6)>0.96;  % 稀疏矩阵,这时是完全存储
    d=sparse(d) % 存储为稀疏矩阵
    whos d
    

    注意稀疏矩阵的存储仍然是按完全存储的列存储的顺序来的,即第一列存完再存第2列····输出顺序和存储顺序一样
    完全存储是把矩阵(不管几维)存成一条向量

    s =
       (5,1)       53
       (4,2)       45
       (3,3)       34
       (2,4)       23
       (1,5)       12
    a =
         0     0     0     0    12     0     0
         0     0     0    23     0     0     0
         0     0    34     0     0     0     0
         0    45     0     0     0     0     0
        53     0     0     0     0     0     0
         0     0     0     0     0     0     0
    b =
         1     0     0
         3     0     4
         0     0     3
         0     5     0
    c =
       (1,1)        1
       (2,1)        3
       (4,2)        5
       (2,3)        4
       (3,3)        3
    d =
      10×6 稀疏 logical 数组
      (10,1)      1
       (2,2)      1
      Name       Size            Bytes  Class      Attributes
    
      d         10x6                74  logical    sparse   
    

    查看稀疏矩阵中非零元素的信息:

    d=rand(10,6)>0.94;  % 稀疏矩阵,这时是完全存储
    d=sparse(d) % 存储为稀疏矩阵
    n1=nnz(d) % number of non-zero elements
    n2=nonzeros(d) %查看非零元素的值
    n3=nzmax(d)  % 
    spy(d) % 图形化显示非零元素的分布
    n4=n1/prod(size(d)) % 查看稀疏程度(非零元素密度),prod(size(d))是矩阵总的元素数目
    
    d =
      10×6 稀疏 logical 数组
       (4,1)      1
       (6,4)      1
       (8,5)      1
    n1 =
         3
    n2 =
      3×1 logical 数组
       1
       1
       1
    n3 =
         3
    n4 =
        0.0500
    >> 
    

    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • vc定义数组在matlab矩阵存储方式

    千次阅读 2011-12-17 15:10:11
    vc定义一下一个数组并生成matlab矩阵 static double real_data[]={1.1, 2.56, 3, 4, 5, 6, 7, 8, 9};mat0=mxCreateDoubleMatrix(3,3,mxREAL); memcpy((void*)mxGetPr(mat0),(void*)real_data,sizeof(real_data)); ...

    vc定义一下一个数组并生成matlab矩阵

    static double real_data[]={1.1, 2.56, 3, 4, 5, 6, 7, 8, 9};
    mat0=mxCreateDoubleMatrix(3,3,mxREAL);
    memcpy((void*)mxGetPr(mat0),(void*)real_data,sizeof(real_data));

     

    那么所得矩阵是按行优先(也就是先把第一列填满数据,然后第二列,依次类推)来存储数组real_data的,并不是按列优先

     
    
    
    
    
    展开全文
  • 使用c++实现Matlab矩阵Matrix类,是今后c++实现Matlab函数功能的基础,保留了Matlab矩阵复制、赋值,加减乘数算数运算,()运算,正负号运算,以及矩阵使用类似Matlab中的生成方式,子矩阵读取,矩阵的扩充,变换等...
    
        ad1.jpg
    

    全栈工程师开发手册 (作者:栾鹏)

    matlab2c动态链接库下载
    matlab库函数大全
    matlab2c基础教程
    matlab2c开发全解教程

    开发注意事项:

    1、目前matlab2c对矩阵的实现仅包含实数型、复数型数据。实数型矩阵使用Matrix定义,复数型矩阵使用CMatrix定义。
    2、实数矩阵元素int、float元素类型会自动转为double。 复数元素类型为c++标准复数std::complex使用typedef别名定义为Complex
    3、本应用开发环境为vs2012,建议使用c++11编译器
    4、借助广大网友的力量,动态链接库会实时更新实现更多的函数功能,欢迎下载最新版。
    5、开发中请尽量规范代码编写,调用函数使用Matlab2c::xx函数,避免与其他库同名函数、同名变量的冲突

    matlab2c调用方法:

    1、下载动态链接库
    2、将Matlab2c.dll拷贝到exe同目录下
    3、将Matlab2c.h、Matlab2c.lib放到项目头文件目录下
    4、在cpp文件中引入下面的代码

    #include "Matlab2c.h"
    #pragma comment(lib,"Matlab2c.lib")  
    using namespace Matlab2c;
    

    c++实现Matlab矩阵Matrix类

    使用c++实现Matlab实数矩阵Matrix类和复数矩阵CMatrix,是今后c++实现Matlab函数功能的基础,保留了Matlab中矩阵复制、赋值,加减乘数算数运算,()运算,正负号运算,以及矩阵使用类似Matlab中的生成方式,子矩阵读取,矩阵的扩充,变换等。建议首先查看matlab2c基础教程

    在文章首部下载matlab2c动态链接库即可下载到该h文件。

    #pragma once                  //防止文件被多重包含
    #include <stdio.h>
    #include <stdlib.h>
    #include <string>             //字符串
    #include <fstream>            //文件流
    #include <iostream>           //数据流
    #include <memory>             //内存操作
    #include <regex>              //正则表达式
    #include <exception>          //异常
    #include <stdexcept>          //异常
    #include <stdexcept>          //异常类型
    #include <iterator>			  //迭代器
    #include <array>              //可获取大小的固定数组
    #include <vector>             //数据结构  连续分布的动态数组
    #include <algorithm>          //STL算法
    #include <numeric>            //数值计算算法
    #include <math.h>             //数值计算算法
    #include <complex>
    #include <functional>         //函数指针,将函数指针作为自定义函数参数   实现设置回调函数
    #include <time.h>             //时间类型
    #include <stdarg.h>			  //各种参数形式
    #include <algorithm>		  //min函数和max函数
    #include <iomanip>			//为了能固定输出小数位的个数
    #include <random>			//随机数库
    #include <complex>			//引入复数
    
    using namespace std;
    
    
    //自定义命名空间
    namespace Matlab2c
    {
    	class CMatrix;
    	class Matrix;
    	typedef std::complex<double> Complex;
    
    	const float  FLOATERROR = 1.0e-6F;   //最小浮点数,浮点比较误差
    	const double DOUBLEERROR = 1.0e-15;  //最小double,比较误差
    	const long double LONGDOUBLEERROR = 1.0e-30;   //long double比较误差
    	const double GoldNo = 0.618033399;		//黄金分割常数(1.0-0.381966)
    	const double inf = DBL_MAX;   //无穷大
    	const double pi = 3.1415926535898;   //圆周率
    	const double PI = 3.1415926535898;   //圆周率
    	const double eps = DOUBLEERROR;  //精度容许误差
    	
    	//内联函数,用于在出现逻辑错误时,弹出信息
    	inline void throw_logic_error(string str){
    		throw logic_error(str);
    	}
    	//声明调用字符串
    	 void trim_string(string &s)
    	 {
    		 if (!s.empty())   
    		 {  
    			 s.erase(0,s.find_first_not_of(" "));  
    			 s.erase(s.find_last_not_of(" ") + 1);  
    		 }
    	 }
    	 void split_char(const std::string& yuan, std::vector<std::string>& arr, const std::string& split)
    	 {
    		 std::string::size_type pos1, pos2;
    		 pos2 = yuan.find_first_of(split);
    		 pos1 = 0;
    		 while(std::string::npos != pos2)
    		 {
    			 if (pos1!=pos2)
    				 arr.push_back(yuan.substr(pos1, pos2-pos1));
    			 pos1 = pos2 + 1;
    			 pos2 = yuan.find_first_of(split, pos1);   //find_first_of方法查询任意一个字符首次出现的位置,允许了使用多个分割字符
    		 }
    		 if(pos1 != yuan.length())  //分割剩余的最后一个字符串
    			 arr.push_back(yuan.substr(pos1));
    	 }
    	 void split_string(const std::string& yuan, std::vector<std::string>& arr, const std::string& split)
    	 {
    		 std::string::size_type pos1, pos2;
    		 pos2 = yuan.find(split);
    		 pos1 = 0;
    		 while(std::string::npos != pos2)
    		 {
    			 if (pos1!=pos2)
    				 arr.push_back(yuan.substr(pos1, pos2-pos1));
    			 pos1 = pos2 + split.size();
    			 pos2 = yuan.find(split, pos1);   //find_first_of方法查询任意一个字符首次出现的位置,允许了使用多个分割字符
    		 }
    		 if(pos1 != yuan.length())
    			 arr.push_back(yuan.substr(pos1));
    	 }
    
    	//比较两double浮点数相等
    	 bool FloatEqual(double lhs, double rhs)		
    	 {		 
    		 if (std::abs(lhs - rhs) < Matlab2c::DOUBLEERROR)
    			 return true;
    		 else
    			 return false;
    	 }
    	 //比较两double浮点数不相等
    	 bool FloatNotEqual(double lhs, double rhs)	
    	 {
    		 if (std::abs(lhs - rhs) >= Matlab2c::DOUBLEERROR)
    			 return true;
    		 else
    			 return false;
    	 }
    
    
    //定义矩阵类
     class Matrix{
    //公共数据
    public:		
    	double* data;
    	int row;
    	int column;
    	//构造函数,构建空矩阵
    	Matrix(){
    		row=0;column=0;data=nullptr;
    	}
    	//由doube转化为1x1矩阵
    	Matrix(double item){
    		row=1;column=1;this->data=new double[row*column];
    		data[0]=item;
    	}
    	//构建矩阵,不赋值
    	Matrix(int row,int column){
    		this->row=row;
    		this->column=column;
    		this->data=new double[row*column];
    	}
    	//构建值矩阵,矩阵中每个元素都等于给定值
    	Matrix(int row,int column,double data){
    		this->row=row;
    		this->column=column;
    		this->data=new double[row*column];
    		for (int i=0;i<row*column;i++)
    			this->data[i]=data;
    	}
    	//根据数组构建矩阵,复制元素
    	Matrix(int row,int column,double *data){
    		this->row=row;
    		this->column=column;
    		this->data=new double[row*column];
    		for (int i=0;i<row*column;i++)
    			this->data[i]=data[i];
    	}
    	//根据数组构建矩阵,复制元素
    	Matrix(double *data,int row,int column){
    		this->row=row;
    		this->column=column;
    		this->data=new double[row*column];
    		for (int i=0;i<row*column;i++)
    			this->data[i]=data[i];
    	}
    	//根据向量构建矩阵
    	template<class T>
    	Matrix(vector<T> a){
    		this->row=a.size();
    		this->column=1;
    		this->data=new double[row*column];
    		for (int i=0;i<a.size();i++)
    			this->data[i] = (double)a[i];
    	}
    	//根据向量构建矩阵
    	template<class T>
    	Matrix(vector<T> a,int row,int column){
    		if (a.size()<row*column)
    		{
    			throw_logic_error("无法根据向量vector生成矩阵");
    			return;
    			//*this=NULL;
    		}
    		this->row=row;
    		this->column=column;
    		this->data=new double[row*column];
    		for (int i=0;i<a.size();i++)
    			this->data[i] = (double)a[i];
    	}
    	//根据向量构建矩阵
    	Matrix(vector<vector<double>> a){
    		if (a.size()>0 && a[0].size()>0)
    		{
    			this->row=a.size();
    			this->column=a[0].size();
    			this->data=new double[row*column];
    			for (int i=0;i<row;i++)
    				for (int j=0;j<column;j++)
    					this->data[i*column+j] = a[i][j];
    		}
    	}
    	//通过matlab字符串构造矩阵
    	Matrix(string str){    //去除两边空格  去除两边[]   按;分割  按,或空格分割   按:分割
    		Matrix a= str2matrix(str);
    		this->row=a.row;
    		this->column=a.column;
    		this->data=new double[row*column];
    		for (int i=0;i<a.row*a.column;i++)
    			this->data[i]=a.data[i];
    	}
    	Matrix str2matrix(string str){   //根据一个字符串判断是否      \[([0-9\-\.:]*[ ,]*;*)+\]    基本元素为0-9.:-组成   行内连接使用空格或,行间连接使用;最外层为[]
    		trim_string(str);   //去掉首尾空格
    
    		if (str[0]=='[' && str[str.length()-1]==']')   //首尾是否为[]
    		{
    			str = str.substr(1,str.length()-2);
    			Matrix p = str2matrix(str);
    			return p;
    		}
    		else if(str.find(';')!= string::npos){    //是否包含;  是否有行
    			vector<string> strarr1;
    			split_char(str,strarr1,";");   //分割每行
    			Matrix p;
    			for (int i=0;i<strarr1.size();i++)
    			{
    				Matrix temp=str2matrix(strarr1[i]);   //根据每一行数据字符串,获取每一行的数据
    				p.append_bottom(temp);   //增加一行数据
    			}
    			return p;
    		}else if (str.find_first_of(", ")!= string::npos)   //是否包含 ,是否有多列
    		{
    			vector<string> strarr2;
    			split_char(str,strarr2,", ");   //分割每列
    
    			Matrix p;
    			for (int i=0;i<strarr2.size();i++)
    			{
    				Matrix temp=str2matrix(strarr2[i]);   //根据每一列数据字符串,获取每一列的数据
    				p.append_right(temp);   //增加一列数据
    			}
    			return p;
    		}else if (str.find(':')!= string::npos)    //判断每个元素是否是增量元素
    		{
    			vector<string> strarr3;
    			split_char(str,strarr3,":");   
    			if (strarr3.size()==3)//如果包含首元素、步长、尾元素
    			{
    				double begindata=atof(strarr3[0].c_str());
    				double jiangedata = atof(strarr3[1].c_str());
    				int num = (int)((atof(strarr3[2].c_str())-begindata)/jiangedata)+1;
    				double* date_temp = new double[num];
    				for (int i=0;i<num;i++)
    				{
    					date_temp[i]= begindata+jiangedata*i;
    				}
    				return Matrix(1,num,date_temp);    //分析增量矩阵,返回成行向量,按道理也可以返回成列矩阵
    			}
    			if (strarr3.size()==2)//如果包含首元素,尾元素,默认步长为1
    			{
    				double begindata=atof(strarr3[0].c_str());
    				int num = (int)((atof(strarr3[1].c_str())-begindata))+1;
    				double* date_temp = new double[num];
    				for (int i=0;i<num;i++)
    				{
    					date_temp[i]= begindata+i;
    				}
    				return Matrix(1,num,date_temp);    //分析增量矩阵,返回成行向量,按道理也可以返回成列矩阵
    			}
    		}else
    		{
    			return Matrix(1,1,atof(str.c_str()));   //如果是纯数字就转化为double
    		}
    	}
    	//复制构造函数
    	Matrix(const Matrix& another){
    		this->row=another.row;
    		this->column=another.column;
    		this->data=new double[row*column];
    		for (int i=0;i<row*column;i++)
    			this->data[i]=another.data[i];
    	}	
    	//重载赋值运算符,保留在matlab中赋值等于深复制的效果
    	Matrix& operator=(const Matrix& another){
    		if(this==&another)
    			return *this;
    		this->row=another.row;
    		this->column=another.column;
    		if(data !=nullptr)
    			delete[] data;
    		this->data=new double[row*column];
    		for (int i=0;i<row*column;i++)
    			this->data[i]=another.data[i];
    		return *this;
    	}
    	//重载()运算符,下标从0开始的习惯,读取时调用
    	double operator()(int i,int j) const
    	{
    		if (i>this->row-1 || i<0)
    			throw_logic_error("读取矩阵元素,超出矩阵范围");
    		if (j>this->column-1 || j<0)
    			throw_logic_error("读取矩阵元素,超出矩阵范围");
    		return data[i*column+j];
    	}
    	//重载()运算符,下标从0开始的习惯,写入时调用
    	double& operator()(int i,int j)
    	{
    		if (i>this->row-1 || i<0)
    			throw_logic_error("读取矩阵元素,超出矩阵范围");
    		if (j>this->column-1 || j<0)
    			throw_logic_error("读取矩阵元素,超出矩阵范围");
    		return data[i*column+j];
    	}
    	//重载()运算符,下标从0开始的习惯,读取时调用
    	double operator()(int i) const
    	{
    		if (i>this->row*this->column-1 || i<0)
    			throw_logic_error("读取矩阵元素,超出矩阵范围");
    		return data[i];
    	}
    	//重载()运算符,下标从0开始的习惯
    	double& operator()(int i){
    		if (i>this->row*this->column-1 || i<0)
    			throw_logic_error("读取矩阵元素,超出矩阵范围");
    		return data[i];
    	}
    	//重载()运算符,下标从0开始的习惯,读取子矩阵,读取时调用
    	Matrix operator()(int row1,int row2,int column1,int column2) const   //包含所有下标行或列
    	{
    		Matrix p(row2-row1+1,column2-column1+1);
    		for (int i=row1;i<row2+1;i++)
    			for (int j=column1;j<column2+1;j++)
    				p(i-row1,j-column1) = this->data[i*column+j];
    		return p;
    	}
    	//根据字符串读取子矩阵,不能对子矩阵赋值
    	Matrix operator()(string str){
    		Matrix rowcontrol,columncontrol;   //行控制数列,和列控制数列
    		trim_string(str);   //去掉首尾空格
    		if(str==":")
    			return Matrix(*this);
    		int index=str.find_first_of(",");
    		if (index>-1)   //如果包含,表明同时控制行和列
    		{
    			string strtemp1=str.substr(0,str.find_first_of(","));   //查询行控制字符串
    			trim_string(strtemp1);   //去掉首尾空格
    			if (strtemp1==":")   //表示整行或整列。不做处理
    			{
    				rowcontrol = Matrix(1,row);
    				for (int i=0;i<row;i++)
    					rowcontrol(i)=i;
    			}
    			else
    				rowcontrol = Matrix(strtemp1);
    
    			string strtemp2=str.substr(str.find_first_of(",")+1);   //查询列控制字符串
    			trim_string(strtemp2);   //去掉首尾空格
    			if (strtemp2==":")   //表示整行或整列。不做处理
    			{
    				columncontrol = Matrix(1,column);
    				for (int i=0;i<column;i++)
    					columncontrol(i)=i;
    			}	
    			else
    				columncontrol = Matrix(strtemp2);
    			Matrix p(rowcontrol.row*rowcontrol.column,columncontrol.row*columncontrol.column);
    			for (int i=0;i<rowcontrol.row*rowcontrol.column;i++)
    			{
    				for (int j=0;j<columncontrol.row*columncontrol.column;j++){
    					p(i,j) = this->data[(int)(rowcontrol.data[i]*column+columncontrol.data[j])];
    				}
    			}
    			return p;
    		}
    		else			//不包含,输入按向量使用,取向量局部数据
    		{
    			columncontrol = Matrix(str);
    			Matrix p(1,columncontrol.row*columncontrol.column);
    			for (int j=0;j<columncontrol.row*columncontrol.column;j++){
    				p(j) = this->data[(int)(columncontrol.data[j])];
    			}
    			return p;
    		}
    
    	}
    	//转化函数   
    	//operator double() const
    	//{
    	//	return data[0];
    	//}
    	//重载加法运算符
    	Matrix operator+(double xi){
    		Matrix p(row,column);
    		for (int i=0;i<p.row*p.column;i++)
    			p.data[i] = data[i]+xi;
    		return p;
    	}
    	//重载加法运算符
    	Matrix& operator+=(double xi){
    		for (int i=0;i<row*column;i++)
    			this->data[i] += xi;
    		return *this;
    	}
    	//重载加法运算符
    	Matrix operator+(Matrix& another){
    		if(!another.data)
    			return *this;
    		if (row!=another.row || column!=another.column)
    			throw_logic_error ("矩阵不匹配");
    		Matrix p(row,column);
    		for (int i=0;i<row*column;i++)
    			p(i)=data[i]+another(i);
    		return p;
    	}
    	//重载加法运算符
    	Matrix& operator+=(Matrix& another){
    		if(!another.data)
    			return *this;
    		if (row!=another.row || column!=another.column)
    			throw_logic_error ("矩阵不匹配");
    		for (int i=0;i<row*column;i++)
    			this->data[i]+=another.data[i];
    		return *this;
    	}
    	//重载减法运算符
    	Matrix operator-(double xi){
    		Matrix p(row,column);
    		for (int i=0;i<p.row*p.column;i++)
    			p.data[i] = data[i]-xi;
    		return p;
    	}
    	//重载减法运算符
    	Matrix& operator-=(double xi){
    		for (int i=0;i<row*column;i++)
    			this->data[i] -= xi;
    		return *this;
    	}
    	//重载减法运算符
    	Matrix operator-(Matrix& another){
    		if(!another.data)
    			return *this;
    		if (row!=another.row || column!=another.column)
    			throw_logic_error ("矩阵不匹配");
    		Matrix p(row,column);
    		for (int i=0;i<row*column;i++)
    			p.data[i]=data[i]-another.data[i];
    		return p;
    	}
    	//重载减法运算符
    	Matrix& operator-=(Matrix& another){
    		if(!another.data)
    			return *this;
    		if (row!=another.row || column!=another.column)
    			throw_logic_error ("矩阵不匹配");
    		for (int i=0;i<row*column;i++)
    			this->data[i]-=another.data[i];
    		return *this;
    	}
    	//重载乘法运算符
    	Matrix operator*(double xi){
    		Matrix p(row,column);
    		for (int i=0;i<p.row*p.column;i++)
    			p.data[i] = this->data[i]*xi;
    		return p;
    	}
    	//重载乘法运算符
    	Matrix& operator*=(double xi){
    		for (int i=0;i<row*column;i++)
    			this->data[i] *= xi;
    		return *this;
    	}
    	//重载乘法运算符
    	Matrix operator*(Matrix& another){
    		if(!another.data || !this->data)
    			throw_logic_error("矩阵乘法数据为空");
    		if (column!=another.row)
    			throw_logic_error ("矩阵不匹配");
    		Matrix p(row,another.column);
    		for (int i=0;i<p.row;i++)
    			for (int j=0;j<p.column;j++)
    			{
    				double sum=0;
    				for (int t=0;t<column;t++)  //第一个矩阵的第i行乘以第二个矩阵的第j列
    					sum+=data[i*column+t]*another(t,j);
    				p(i,j) = sum;
    			}
    		return p;
    	}
    	//重载除法运算符
    	Matrix operator/(double xi){
    		Matrix p(row,column);
    		for (int i=0;i<p.row*p.column;i++)
    			p.data[i] = data[i]/xi;
    		return p;
    	}
    	//重载除法运算符
    	Matrix& operator/=(double xi){
    		for (int i=0;i<row*column;i++)
    			this->data[i] /= xi;
    		return *this;
    	}
    	//重载矩阵等号==运算符
    	bool operator==(Matrix& another){
    		if (this->row!= another.row)
    			return false;
    		if (this->column != another.column)
    			return false;
    
    		for (int i = 0; i < row*column; i ++)
    			if (FloatNotEqual(this->data[i],another.data[i]))
    				return false;
    		return true;
    	}
    	//重载矩阵等号!=运算符
    	bool operator!=(Matrix& another){
    		if (this->row!= another.row)
    			return true;
    		if (this->column != another.column)
    			return true;
    
    		for (int i = 0; i < row*column; i ++)
    			if (FloatNotEqual(this->data[i],another.data[i]))
    				return true;
    		return false;
    	}
    	//重载一元操作符:正号
    	Matrix operator +() const
    	{
    		return *this;			//不用作任何处理,维持原状
    	}
    	//重载一元操作符:负号
    	Matrix operator -() const
    	{
    		Matrix p(row,column);
    		for (int i=0;i<row*column;i++)
    			p.data[i]=-this->data[i];
    		return p;
    	}
    	//矩阵转置,不改变源矩阵
    	Matrix T()
    	{
    		Matrix p(column,row);
    		for(int i=0;i<row;i++)
    			for(int j=0;j<column;j++)
    				p(j,i)=(*this)(i,j);
    		return p;
    	}
    
    	//矩阵左扩展,改变了源矩阵
    	void append_left(Matrix& a){
    		if (a.row==0)
    			return;
    		if (this->row==0){
    			this->row = a.row;
    			this->column=a.column;
    			this->data = new double[row*column];
    			for (int i=0;i<row*column;i++)
    				this->data[i]=a.data[i];
    			return;
    		}
    		int new_column=a.column+column;
    		if (a.row==this->row)
    		{
    			double* datanew=new double[row*new_column];
    			for (int i=0;i<a.row;i++)
    			{
    				for (int j=0;j<a.column;j++)
    					datanew[i*new_column+j]=a(i,j);
    				for (int j=0;j<column;j++)
    					datanew[i*new_column+j+a.column]=this->data[i*column+j];
    			}
    			this->column=new_column;
    			delete[] this->data;
    			this->data = datanew;
    		}else
    		{
    			throw_logic_error("合并矩阵行数不等");
    		}
    	}
    	//向量首部添加元素
    	void append_left(double x){
    		Matrix a(1,1,x);
    		if(column==1)
    			this->append_top(a);
    		else if(row==1)
    			this->append_left(a);
    	}
    	//矩阵右扩展,改变了源矩阵
    	void append_right(Matrix& a){
    		if (a.row==0)
    			return;
    		if (this->row==0){
    			this->row = a.row;
    			this->column=a.column;
    			this->data = new double[row*column];
    			for (int i=0;i<row*column;i++)
    				this->data[i]=a.data[i];
    			return;
    		}
    		int new_column=a.column+column;
    		if (a.row==this->row)
    		{
    			double* datanew=new double[row*new_column];
    			for (int i=0;i<row;i++)
    			{
    				for (int j=0;j<column;j++)
    					datanew[i*new_column+j]=this->data[i*column+j];
    				for (int j=0;j<a.column;j++)
    					datanew[i*new_column+j+column]=a(i,j);
    			}
    			this->column=new_column;
    			delete[] this->data;
    			this->data = datanew;
    		}else
    		{
    			throw_logic_error("合并矩阵行数不等");
    		}
    	}
    	//向量尾部添加元素
    	void append_right(double x){
    		Matrix a(1,1,x);
    		if(column==1)
    			this->append_bottom(a);
    		else if(row==1)
    			this->append_right(a);
    	}
    	//矩阵上扩展,改变了源矩阵
    	void append_top(Matrix& a){
    		if (a.row==0)
    			return;
    		if (this->row==0){
    			this->row = a.row;
    			this->column=a.column;
    			this->data = new double[row*column];
    			for (int i=0;i<row*column;i++)
    				this->data[i]=a.data[i];
    			return;
    		}
    		int new_row=a.row+row;
    		if (a.column==this->column)
    		{
    			double* datanew=new double[new_row*column];
    			for (int i=0;i<a.row;i++)
    				for (int j=0;j<a.column;j++)
    					datanew[i*column+j]=a(i,j);
    			for (int i=0;i<row;i++)
    				for (int j=0;j<column;j++)
    					datanew[(i+a.row)*column+j]=this->data[i*column+j];
    			this->row=new_row;
    			delete[] this->data;
    			this->data = datanew;
    		}else
    		{
    			throw_logic_error("合并矩阵列数不等");
    		}
    	}
    	//向量首部添加元素
    	void append_top(double x){
    		Matrix a(1,1,x);
    		if(column==1)
    			this->append_top(a);
    		else if(row==1)
    			this->append_left(a);
    	}
    	//矩阵下扩展,改变了源矩阵
    	void append_bottom(Matrix& a){
    		if (a.row==0)
    			return;
    		if (this->row==0){
    			this->row = a.row;
    			this->column=a.column;
    			this->data = new double[row*column];
    			for (int i=0;i<row*column;i++)
    				this->data[i]=a.data[i];
    			return;
    		}
    		int new_row=a.row+row;
    		if (a.column==this->column)
    		{
    			double* datanew=new double[new_row*column];
    			for (int i=0;i<row;i++)
    				for (int j=0;j<column;j++)
    					datanew[i*column+j]=this->data[i*column+j];
    			for (int i=0;i<a.row;i++)
    				for (int j=0;j<a.column;j++)
    					datanew[(i+row)*column+j]=a(i,j);
    			this->row=new_row;
    			delete[] this->data;
    			this->data = datanew;
    		}else
    		{
    			throw_logic_error("合并矩阵列数不等");
    		}
    	}
    	//向量尾部添加元素
    	void append_bottom(double x){
    		Matrix a(1,1,x);
    		if(column==1)
    			this->append_bottom(a);
    		else if(row==1)
    			this->append_right(a);
    	}
    	//删除指定行,改变了源矩阵
    	void remove_row(int rowindex)  //删除指定行
    	{
    		if (rowindex>=row || rowindex<0)
    		{
    			throw_logic_error("删除行范围越界");
    			return;
    		}
    		double* datetemp = data;
    		int newrow=row-1;
    		data = new double[newrow*column];
    		for (int i=0;i<rowindex;i++)
    			for (int j=0;j<this->column;j++)
    				this->data[i*column+j] = datetemp[i*column+j];
    		for (int i=rowindex;i<newrow;i++)
    			for (int j=0;j<this->column;j++)
    				this->data[i*column+j] = datetemp[(i+1)*column+j];
    		row=newrow;
    		delete[] datetemp;
    	}
    	//删除指定行,改变了源矩阵
    	void remove_row(int row1,int row2)  //删除多行,包含两个下标
    	{
    		if (row1>=row || row2>=row || row1<0||row2<0)
    		{
    			throw_logic_error("删除行范围越界");
    			return;
    		}
    		double* datetemp = data;
    		int newrow=row-row2+row1-1;
    		data = new double[newrow*column];
    		for (int i=0;i<row1;i++)
    			for (int j=0;j<this->column;j++)
    				this->data[i*column+j] = datetemp[i*column+j];
    		for (int i=row1;i<newrow;i++)
    			for (int j=0;j<this->column;j++)
    				this->data[i*column+j] = datetemp[(i+row2-row1+1)*column+j];
    		row=newrow;
    		delete[] datetemp;
    	}
    	//删除指定列,改变了源矩阵
    	void remove_column(int columnindex)  //删除指定列
    	{
    		if (columnindex>=column || columnindex<0)
    		{
    			throw_logic_error("删除列范围越界");
    			return;
    		}
    		double* datetemp = data;
    		int newcolumn=column-1;
    		data = new double[row*newcolumn];
    		for (int i=0;i<row;i++)
    		{
    			for (int j=0;j<columnindex;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j];
    			for (int j=columnindex;j<newcolumn;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j+1];
    		}
    		column=newcolumn;
    		delete[] datetemp;
    	}
    	//删除指定列,改变了源矩阵
    	void remove_column(int column1,int column2)  //删除多列,包含两个下标
    	{
    		if (column1>=column || column2>=column || column1<0||column2<0)
    		{
    			throw_logic_error("删除列范围越界");
    			return;
    		}
    		double* datetemp = data;
    		int newcolumn=column-column2+column1-1;
    		data = new double[row*newcolumn];
    		
    		for (int i=0;i<row;i++)
    		{
    			for (int j=0;j<column1;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j];
    			for (int j=column1;j<newcolumn;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j+column2-column1+1];
    		}
    		column=newcolumn;
    		delete[] datetemp;
    	}
    	//删除指定的行和列
    	void remove_row_column(int rowindex,int columnindex)
    	{
    		if (columnindex>=column || columnindex<0 || rowindex<0 || rowindex>=row)
    		{
    			throw_logic_error("删除行列范围越界");
    			return;
    		}
    		double* datetemp = data;
    		int newcolumn=column-1;
    		int newrow=row-1;
    		data = new double[newrow*newcolumn];
    		for (int i=0;i<rowindex;i++)
    		{
    			for (int j=0;j<columnindex;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j];
    			for (int j=columnindex;j<newcolumn;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j+1];
    		}
    		for (int i=rowindex;i<newrow;i++)
    		{
    			for (int j=0;j<columnindex;j++)
    				this->data[i*newcolumn+j] = datetemp[(i+1)*column+j];
    			for (int j=columnindex;j<newcolumn;j++)
    				this->data[i*newcolumn+j] = datetemp[(i+1)*column+j+1];
    		}
    		column=newcolumn;
    		row =newrow;
    		delete[] datetemp;
    	}
    	//删除多行和多列
    	void remove_row_column(int row1,int row2,int column1,int column2)
    	{
    		if (column1>=column || column1<0 || row1<0 || row1>=row || column2>=column || column2<0 || row2<0 || row2>=row)
    		{
    			throw_logic_error("删除行列范围越界");
    			return;
    		}
    		double* datetemp = data;
    		int newcolumn=column-column2+column1-1;
    		int newrow=row-row2+row1-1;
    		data = new double[newrow*newcolumn];
    		for (int i=0;i<row1;i++)
    		{
    			for (int j=0;j<column1;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j];
    			for (int j=column1;j<newcolumn;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j+column2-column1+1];
    		}
    		for (int i=row1;i<newrow;i++)
    		{
    			for (int j=0;j<column1;j++)
    				this->data[i*newcolumn+j] = datetemp[(i+row2-row1+1)*column+j];
    			for (int j=column1;j<newcolumn;j++)
    				this->data[i*newcolumn+j] = datetemp[(i+row2-row1+1)*column+j+column2-column1+1];
    		}
    		column=newcolumn;
    		row =newrow;
    		delete[] datetemp;
    	}
    	//替换局部矩阵,改变了源矩阵,
    	void replace(Matrix &a,int row1,int column1) 
    	{
    		int endrow=std::min(this->row,a.row+row1);
    		int endcolumn=std::min(this->column,a.column+column1);
    		for (int i=row1;i<endrow;i++)
    			for (int j=column1;j<endcolumn;j++)
    				this->data[i*column+j] = a((i-row1),j-column1);
    	}
    
    
    
    	//矩阵元素遍历操作,需要传入遍历函数,函数传入元素值,所属行,所属列,源矩阵,返回替换值。不改变源矩阵
    	Matrix map(function<double(double item,int row,int column,Matrix& src)> fun){
    		Matrix p(this->row,this->column);
    		for (int i=0;i<this->row;i++)
    			for (int j=0;j<this->column;j++)
    				p(i,j)=fun(this->data[i*column+j],i,j,*this);
    		return p;	
    	}
    
    	//定义一个按行遍历函数(固定格式),每一行得到一个值,遍历结果为一个列向量。
    	 //输入参数:前一个元素,当前元素,当前元素所属行,当前元素所属列,源矩阵
    	//迭代从第二项开始,prev初始值为第一项,cur初始值为第二项。计算值自动传给下一函数的prev,返回最后一次迭代产生的值
    	Matrix map_row(function<double(double prev,double cur,int row,int column,Matrix& src)> fun){
    		Matrix p(this->row,1);
    		for (int i=0;i<this->row;i++)
    		{
    			double result = this->data[i*column];
    			for (int j=1;j<this->column;j++)
    				result = fun(result,this->data[i*column+j],i,j,*this);
    			p(i) = result;
    		}
    		return p;
    	}
    
    	//定义一个按列遍历函数(固定格式),每一列得到一个值
    	 //输入参数:前一个元素,当前元素,当前元素所属行,当前元素所属列,源矩阵
    	//迭代从第二项开始,prev初始值为第一项,cur初始值为第二项。计算值自动传给下一函数的prev,返回最后一次迭代产生的值
    	Matrix map_column(function<double(double prev,double cur,int row,int column,Matrix& src)> fun){
    		Matrix p(1,this->column);
    		for (int j=0;j<this->column;j++)
    		{
    			double result = this->data[j];
    			for (int i=1;i<this->row;i++)
    				result = fun(result,this->data[i*column+j],i,j,*this);
    			p(j) = result;
    		}
    		return p;
    	}
    	//点运算
    	Matrix dot(Matrix& a,string operation)
    	{
    		if (row!=a.row || column!=a.column)
    		{
    			throw_logic_error("点运算矩阵不匹配");
    			return NULL;
    		}
    		Matrix p(row,column);
    		if (operation=="+")
    			for (int i=0;i<row;i++)
    				for(int j=0;j<column;j++)
    					p(i,j)=(*this)(i,j)+a(i,j);
    		else if (operation=="-")
    			for (int i=0;i<row;i++)
    				for(int j=0;j<column;j++)
    					p(i,j)=(*this)(i,j)-a(i,j);
    		else if (operation=="*")
    			for (int i=0;i<row;i++)
    				for(int j=0;j<column;j++)
    					p(i,j)=(*this)(i,j)*a(i,j);
    		else if (operation=="/")
    			for (int i=0;i<row;i++)
    				for(int j=0;j<column;j++)
    					p(i,j)=(*this)(i,j)/a(i,j);
    		else if (operation=="\\")
    			for (int i=0;i<row;i++)
    				for(int j=0;j<column;j++)
    					p(i,j)=a(i,j)/(*this)(i,j);
    		return p;
    	}
    
    	//查询是否是向量
    	bool isVector()
    	{
    		if (row==1||column==1)
    			return true;
    		return false;
    	}
    	//字符串形式表示
    	string toString(){
    		stringstream back;
    		for (int i=0;i<row;i++)
    		{
    			for(int j=0;j<column;j++)
    			{
    				back<< fixed << setprecision(4)<<data[i*column+j];
    				back<<"   ";
    			}
    			if(i!=row-1)
    				back<<"\n";
    		}
    		return back.str();
    	}
    	//按行优先转化为series
    	double* toSeries(){
    		double* back = new double[row*column];
    		for (int i=0;i<column*row;i++)
    			back[i] = data[i];
    		return back;
    	}
    	//转化为二位数组
    	double** toArray(){
    		double** back = new double*[column];
    		int n=0;
    		for (int i=0;i<row;i++){
    			back[i]=new double[column];
    			for(int j=0;j<column;j++)
    				back[i][j] = data[i*column+j];
    		}
    		return back;
    	}
    	//按行优先转化为一维vector
    	vector<double> toVector(){
    		int t=0;
    		vector<double> back(row*column);
    		for (int i=0;i<row;i++)
    			for (int j=0;j<column;j++)
    				back[t++]=data[i*column+j];
    		return back;
    	}
    	//按行优先转化为二维vector
    	vector<vector<double>> toVector2(){
    		int rowindex=0;
    		int columnindex=0;
    		vector<vector<double>> back(row);
    		for (int i=0;i<row;i++)
    		{
    			columnindex=0;
    			vector<double> newrow(column);
    			for (int j=0;j<column;j++)
    				newrow[columnindex++]=data[i*column+j];
    			back[rowindex++]=newrow;
    		}
    		return back;
    	}
    	//析构函数,不能使用析构函数的原因在于很多函数局部类型返回需要保留data数据,不能使局部类型析构造成接收对象不可用。但是如果重写了赋值运算符,可以加上,因为在函数内,先赋值,在析构局部变量
    	~Matrix(){
    		row=0;column=0;
    		if(data !=nullptr){
    			delete[] data;
    			data=nullptr;
    		}
    	}
    
    };
    
    
    
    
    //定义复数矩阵类
    _DLL_API class CMatrix{
    //公共数据
    public:		
    	Complex* data;
    	int row;
    	int column;
    	//构造函数,构建空矩阵
    	CMatrix(){
    		row=0;column=0;data=nullptr;
    	}
    	//由Complex转化为1x1矩阵
    	CMatrix(Complex item){
    		row=1;column=1;this->data=new Complex[row*column];
    		data[0]=item;
    	}
    	//由实矩阵转化为复数矩阵
    	CMatrix(Matrix& a){
    		row=a.row;
    		column=a.column;
    		this->data=new Complex[row*column];
    		for (int i=0;i<row;i++)
    			for(int j=0;j<column;j++)
    				data[i*column+j]=Complex(a(i,j),0);
    	}
    	//由实部和虚部组成复数矩阵
    	CMatrix(Matrix& real,Matrix& imag){
    		row=real.row;
    		column=real.column;
    		this->data=new Complex[row*column];
    		for (int i=0;i<row;i++)
    			for(int j=0;j<column;j++)
    				data[i*column+j]=Complex(real(i,j),imag(i,j));
    	}
    
    	//构建矩阵,不赋值
    	CMatrix(int row,int column){
    		this->row=row;
    		this->column=column;
    		this->data=new Complex[row*column];
    	}
    	//构建值矩阵,矩阵中每个元素都等于给定值
    	CMatrix(int row,int column,Complex data){
    		this->row=row;
    		this->column=column;
    		this->data=new Complex[row*column];
    		for (int i=0;i<row*column;i++)
    			this->data[i]=data;
    	}
    	//根据数组构建矩阵,复制元素
    	CMatrix(int row,int column,double *x,double *y){
    		this->row=row;
    		this->column=column;
    		this->data=new Complex[row*column];
    		for (int i=0;i<row*column;i++)
    			this->data[i]=Complex(x[i],y[i]);
    	}
    	//根据数组构建矩阵,复制元素
    	CMatrix(double *x,double *y,int row,int column){
    		this->row=row;
    		this->column=column;
    		this->data=new Complex[row*column];
    		for (int i=0;i<row*column;i++)
    			this->data[i]=Complex(x[i],y[i]);
    	}
    	//根据数组构建矩阵,复制元素
    	CMatrix(int row,int column,Complex *data){
    		this->row=row;
    		this->column=column;
    		this->data=new Complex[row*column];
    		for (int i=0;i<row*column;i++)
    			this->data[i]=data[i];
    	}
    	//根据数组构建矩阵,复制元素
    	CMatrix(Complex *data,int row,int column){
    		this->row=row;
    		this->column=column;
    		this->data=new Complex[row*column];
    		for (int i=0;i<row*column;i++)
    			this->data[i]=data[i];
    	}
    	//根据向量构建矩阵
    	CMatrix(vector<Complex> a){
    		this->row=a.size();
    		this->column=1;
    		this->data=new Complex[row*column];
    		for (int i=0;i<a.size();i++)
    			this->data[i] = a[i];
    	}
    	//根据向量构建矩阵
    	CMatrix(vector<Complex> a,int row,int column){
    		if (a.size()<row*column)
    		{
    			throw_logic_error("无法根据向量vector生成矩阵");
    			return;
    			//*this=NULL;
    		}
    		this->row=row;
    		this->column=column;
    		this->data=new Complex[row*column];
    		for (int i=0;i<a.size();i++)
    			this->data[i] = a[i];
    	}
    	//根据向量构建矩阵
    	CMatrix(vector<vector<Complex>> a){
    		if (a.size()>0 && a[0].size()>0)
    		{
    			this->row=a.size();
    			this->column=a[0].size();
    			this->data=new Complex[row*column];
    			for (int i=0;i<row;i++)
    				for (int j=0;j<column;j++)
    					this->data[i*column+j] = a[i][j];
    		}
    	}
    	//复制构造函数
    	CMatrix(const CMatrix& another){
    		this->row=another.row;
    		this->column=another.column;
    		this->data=new Complex[row*column];
    		for (int i=0;i<row*column;i++)
    			this->data[i]=another.data[i];
    	}	
    	//重载赋值运算符,保留在matlab中赋值等于深复制的效果
    	CMatrix& operator=(const CMatrix& another){
    		if(this==&another)
    			return *this;
    		this->row=another.row;
    		this->column=another.column;
    		if(data !=nullptr)   //必须新释放之前的内存,不然内存泄漏了
    			delete[] data;
    		this->data=new Complex[row*column];
    		for (int i=0;i<row*column;i++)
    			this->data[i]=another.data[i];
    		return *this;
    	}
    	//重载()运算符,下标从0开始的习惯,读取时调用
    	Complex operator()(int i,int j) const
    	{
    		if (i>this->row-1 || i<0)
    			throw_logic_error("读取矩阵元素,超出矩阵范围");
    		if (j>this->column-1 || j<0)
    			throw_logic_error("读取矩阵元素,超出矩阵范围");
    		return data[i*column+j];
    	}
    	//重载()运算符,下标从0开始的习惯,写入时调用
    	Complex& operator()(int i,int j)
    	{
    		if (i>this->row-1 || i<0)
    			throw_logic_error("读取矩阵元素,超出矩阵范围");
    		if (j>this->column-1 || j<0)
    			throw_logic_error("读取矩阵元素,超出矩阵范围");
    		return data[i*column+j];
    	}
    	//重载()运算符,下标从0开始的习惯,读取时调用
    	Complex operator()(int i) const
    	{
    		if (i>this->row*this->column-1 || i<0)
    			throw_logic_error("读取矩阵元素,超出矩阵范围");
    		return data[i];
    	}
    	//重载()运算符,下标从0开始的习惯
    	Complex& operator()(int i){
    		if (i>this->row*this->column-1 || i<0)
    			throw_logic_error("读取矩阵元素,超出矩阵范围");
    		return data[i];
    	}
    	//重载()运算符,下标从0开始的习惯,读取子矩阵,读取时调用
    	CMatrix operator()(int row1,int row2,int column1,int column2) const   //包含所有下标行或列
    	{
    		CMatrix p(row2-row1+1,column2-column1+1);
    		for (int i=row1;i<row2+1;i++)
    			for (int j=column1;j<column2+1;j++)
    				p(i-row1,j-column1) = this->data[i*column+j];
    		return p;
    	}
    	
    	//重载加法运算符
    	CMatrix operator+(Complex xi){
    		CMatrix p(row,column);
    		for (int i=0;i<p.row*p.column;i++)
    			p.data[i] = data[i]+xi;
    		return p;
    	}
    	//重载加法运算符
    	CMatrix& operator+=(Complex xi){
    		for (int i=0;i<row*column;i++)
    			this->data[i] += xi;
    		return *this;
    	}
    	//重载加法运算符
    	CMatrix operator+(CMatrix& another){
    		if(!another.data)
    			return *this;
    		if (row!=another.row || column!=another.column)
    			throw_logic_error ("矩阵不匹配");
    		CMatrix p(row,column);
    		for (int i=0;i<row*column;i++)
    			p(i)=data[i]+another(i);
    		return p;
    	}
    	//重载加法运算符
    	CMatrix& operator+=(CMatrix& another){
    		if(!another.data)
    			return *this;
    		if (row!=another.row || column!=another.column)
    			throw_logic_error ("矩阵不匹配");
    		for (int i=0;i<row*column;i++)
    			this->data[i]+=another.data[i];
    		return *this;
    	}
    	//重载减法运算符
    	CMatrix operator-(Complex xi){
    		CMatrix p(row,column);
    		for (int i=0;i<p.row*p.column;i++)
    			p.data[i] = data[i]-xi;
    		return p;
    	}
    	//重载减法运算符
    	CMatrix& operator-=(Complex xi){
    		for (int i=0;i<row*column;i++)
    			this->data[i] -= xi;
    		return *this;
    	}
    	//重载减法运算符
    	CMatrix operator-(CMatrix& another){
    		if(!another.data)
    			return *this;
    		if (row!=another.row || column!=another.column)
    			throw_logic_error ("矩阵不匹配");
    		CMatrix p(row,column);
    		for (int i=0;i<row*column;i++)
    			p.data[i]=data[i]-another.data[i];
    		return p;
    	}
    	//重载减法运算符
    	CMatrix& operator-=(CMatrix& another){
    		if(!another.data)
    			return *this;
    		if (row!=another.row || column!=another.column)
    			throw_logic_error ("矩阵不匹配");
    		for (int i=0;i<row*column;i++)
    			this->data[i]-=another.data[i];
    		return *this;
    	}
    	//重载乘法运算符
    	CMatrix operator*(Complex xi){
    		CMatrix p(row,column);
    		for (int i=0;i<p.row*p.column;i++)
    			p.data[i] = this->data[i]*xi;
    		return p;
    	}
    	//重载乘法运算符
    	CMatrix& operator*=(Complex xi){
    		for (int i=0;i<row*column;i++)
    			this->data[i] *= xi;
    		return *this;
    	}
    	//重载乘法运算符
    	CMatrix operator*(CMatrix& another){
    		if(!another.data || !this->data)
    			throw_logic_error("矩阵乘法数据为空");
    		if (column!=another.row)
    			throw_logic_error ("矩阵不匹配");
    		CMatrix p(row,another.column);
    		for (int i=0;i<p.row;i++)
    			for (int j=0;j<p.column;j++)
    			{
    				Complex sum=0;
    				for (int t=0;t<column;t++)  //第一个矩阵的第i行乘以第二个矩阵的第j列
    					sum+=data[i*column+t]*another(t,j);
    				p(i,j) = sum;
    			}
    		return p;
    	}
    	//重载除法运算符
    	CMatrix operator/(Complex xi){
    		CMatrix p(row,column);
    		for (int i=0;i<p.row*p.column;i++)
    			p.data[i] = data[i]/xi;
    		return p;
    	}
    	//重载除法运算符
    	CMatrix& operator/=(Complex xi){
    		for (int i=0;i<row*column;i++)
    			this->data[i] /= xi;
    		return *this;
    	}
    	//重载矩阵等号==运算符
    	bool operator==(CMatrix& another){
    		if (this->row!= another.row)
    			return false;
    		if (this->column != another.column)
    			return false;
    
    		for (int i = 0; i < row*column; i ++)
    			if (FloatNotEqual(this->data[i].real(),another.data[i].real()) || FloatNotEqual(this->data[i].imag(),another.data[i].imag()))
    				return false;
    		return true;
    	}
    	//重载矩阵等号!=运算符
    	bool operator!=(CMatrix& another){
    		if (this->row!= another.row)
    			return true;
    		if (this->column != another.column)
    			return true;
    
    		for (int i = 0; i < row*column; i ++)
    			if (FloatNotEqual(this->data[i].real(),another.data[i].real()) || FloatNotEqual(this->data[i].imag(),another.data[i].imag()))
    				return true;
    		return false;
    	}
    	//重载一元操作符:正号
    	CMatrix operator +() const
    	{
    		return *this;			//不用作任何处理,维持原状
    	}
    	//重载一元操作符:负号
    	CMatrix operator -() const
    	{
    		CMatrix p(row,column);
    		for (int i=0;i<row*column;i++)
    			p.data[i]=-this->data[i];
    		return p;
    	}
    	//矩阵转置,不改变源矩阵
    	CMatrix T()
    	{
    		CMatrix p(column,row);
    		for(int i=0;i<row;i++)
    			for(int j=0;j<column;j++)
    				p(j,i)=(*this)(i,j);
    		return p;
    	}
    
    	//矩阵左扩展,改变了源矩阵
    	void append_left(CMatrix& a){
    		if (a.row==0)
    			return;
    		if (this->row==0){
    			this->row = a.row;
    			this->column=a.column;
    			this->data = new Complex[row*column];
    			for (int i=0;i<row*column;i++)
    				this->data[i]=a.data[i];
    			return;
    		}
    		int new_column=a.column+column;
    		if (a.row==this->row)
    		{
    			Complex* datanew=new Complex[row*new_column];
    			for (int i=0;i<a.row;i++)
    			{
    				for (int j=0;j<a.column;j++)
    					datanew[i*new_column+j]=a(i,j);
    				for (int j=0;j<column;j++)
    					datanew[i*new_column+j+a.column]=this->data[i*column+j];
    			}
    			this->column=new_column;
    			delete[] this->data;
    			this->data = datanew;
    		}else
    		{
    			throw_logic_error("合并矩阵行数不等");
    		}
    	}
    	//向量首部添加元素
    	void append_left(Complex x){
    		CMatrix a(1,1,x);
    		if(column==1)
    			this->append_top(a);
    		else if(row==1)
    			this->append_left(a);
    	}
    	//矩阵右扩展,改变了源矩阵
    	void append_right(CMatrix& a){
    		if (a.row==0)
    			return;
    		if (this->row==0){
    			this->row = a.row;
    			this->column=a.column;
    			this->data = new Complex[row*column];
    			for (int i=0;i<row*column;i++)
    				this->data[i]=a.data[i];
    			return;
    		}
    		int new_column=a.column+column;
    		if (a.row==this->row)
    		{
    			Complex* datanew=new Complex[row*new_column];
    			for (int i=0;i<row;i++)
    			{
    				for (int j=0;j<column;j++)
    					datanew[i*new_column+j]=this->data[i*column+j];
    				for (int j=0;j<a.column;j++)
    					datanew[i*new_column+j+column]=a(i,j);
    			}
    			this->column=new_column;
    			delete[] this->data;
    			this->data = datanew;
    		}else
    		{
    			throw_logic_error("合并矩阵行数不等");
    		}
    	}
    	//向量尾部添加元素
    	void append_right(Complex x){
    		CMatrix a(1,1,x);
    		if(column==1)
    			this->append_bottom(a);
    		else if(row==1)
    			this->append_right(a);
    	}
    	//矩阵上扩展,改变了源矩阵
    	void append_top(CMatrix& a){
    		if (a.row==0)
    			return;
    		if (this->row==0){
    			this->row = a.row;
    			this->column=a.column;
    			this->data = new Complex[row*column];
    			for (int i=0;i<row*column;i++)
    				this->data[i]=a.data[i];
    			return;
    		}
    		int new_row=a.row+row;
    		if (a.column==this->column)
    		{
    			Complex* datanew=new Complex[new_row*column];
    			for (int i=0;i<a.row;i++)
    				for (int j=0;j<a.column;j++)
    					datanew[i*column+j]=a(i,j);
    			for (int i=0;i<row;i++)
    				for (int j=0;j<column;j++)
    					datanew[(i+a.row)*column+j]=this->data[i*column+j];
    			this->row=new_row;
    			delete[] this->data;
    			this->data = datanew;
    		}else
    		{
    			throw_logic_error("合并矩阵列数不等");
    		}
    	}
    	//向量首部添加元素
    	void append_top(Complex x){
    		CMatrix a(1,1,x);
    		if(column==1)
    			this->append_top(a);
    		else if(row==1)
    			this->append_left(a);
    	}
    	//矩阵下扩展,改变了源矩阵
    	void append_bottom(CMatrix& a){
    		if (a.row==0)
    			return;
    		if (this->row==0){
    			this->row = a.row;
    			this->column=a.column;
    			this->data = new Complex[row*column];
    			for (int i=0;i<row*column;i++)
    				this->data[i]=a.data[i];
    			return;
    		}
    		int new_row=a.row+row;
    		if (a.column==this->column)
    		{
    			Complex* datanew=new Complex[new_row*column];
    			for (int i=0;i<row;i++)
    				for (int j=0;j<column;j++)
    					datanew[i*column+j]=this->data[i*column+j];
    			for (int i=0;i<a.row;i++)
    				for (int j=0;j<a.column;j++)
    					datanew[(i+row)*column+j]=a(i,j);
    			this->row=new_row;
    			delete[] this->data;
    			this->data = datanew;
    		}else
    		{
    			throw_logic_error("合并矩阵列数不等");
    		}
    	}
    	//向量尾部添加元素
    	void append_bottom(Complex x){
    		CMatrix a(1,1,x);
    		if(column==1)
    			this->append_bottom(a);
    		else if(row==1)
    			this->append_right(a);
    	}
    	//删除指定行,改变了源矩阵
    	void remove_row(int rowindex)  //删除指定行
    	{
    		if (rowindex>=row || rowindex<0)
    		{
    			throw_logic_error("删除行范围越界");
    			return;
    		}
    		Complex* datetemp = data;
    		int newrow=row-1;
    		data = new Complex[newrow*column];
    		for (int i=0;i<rowindex;i++)
    			for (int j=0;j<this->column;j++)
    				this->data[i*column+j] = datetemp[i*column+j];
    		for (int i=rowindex;i<newrow;i++)
    			for (int j=0;j<this->column;j++)
    				this->data[i*column+j] = datetemp[(i+1)*column+j];
    		row=newrow;
    		delete[] datetemp;
    	}
    	//删除指定行,改变了源矩阵
    	void remove_row(int row1,int row2)  //删除多行,包含两个下标
    	{
    		if (row1>=row || row2>=row || row1<0||row2<0)
    		{
    			throw_logic_error("删除行范围越界");
    			return;
    		}
    		Complex* datetemp = data;
    		int newrow=row-row2+row1-1;
    		data = new Complex[newrow*column];
    		for (int i=0;i<row1;i++)
    			for (int j=0;j<this->column;j++)
    				this->data[i*column+j] = datetemp[i*column+j];
    		for (int i=row1;i<newrow;i++)
    			for (int j=0;j<this->column;j++)
    				this->data[i*column+j] = datetemp[(i+row2-row1+1)*column+j];
    		row=newrow;
    		delete[] datetemp;
    	}
    	//删除指定列,改变了源矩阵
    	void remove_column(int columnindex)  //删除指定列
    	{
    		if (columnindex>=column || columnindex<0)
    		{
    			throw_logic_error("删除列范围越界");
    			return;
    		}
    		Complex* datetemp = data;
    		int newcolumn=column-1;
    		data = new Complex[row*newcolumn];
    		for (int i=0;i<row;i++)
    		{
    			for (int j=0;j<columnindex;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j];
    			for (int j=columnindex;j<newcolumn;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j+1];
    		}
    		column=newcolumn;
    		delete[] datetemp;
    	}
    	//删除指定列,改变了源矩阵
    	void remove_column(int column1,int column2)  //删除多列,包含两个下标
    	{
    		if (column1>=column || column2>=column || column1<0||column2<0)
    		{
    			throw_logic_error("删除列范围越界");
    			return;
    		}
    		Complex* datetemp = data;
    		int newcolumn=column-column2+column1-1;
    		data = new Complex[row*newcolumn];
    		
    		for (int i=0;i<row;i++)
    		{
    			for (int j=0;j<column1;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j];
    			for (int j=column1;j<newcolumn;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j+column2-column1+1];
    		}
    		column=newcolumn;
    		delete[] datetemp;
    	}
    	//删除指定的行和列
    	void remove_row_column(int rowindex,int columnindex)
    	{
    		if (columnindex>=column || columnindex<0 || rowindex<0 || rowindex>=row)
    		{
    			throw_logic_error("删除行列范围越界");
    			return;
    		}
    		Complex* datetemp = data;
    		int newcolumn=column-1;
    		int newrow=row-1;
    		data = new Complex[newrow*newcolumn];
    		for (int i=0;i<rowindex;i++)
    		{
    			for (int j=0;j<columnindex;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j];
    			for (int j=columnindex;j<newcolumn;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j+1];
    		}
    		for (int i=rowindex;i<newrow;i++)
    		{
    			for (int j=0;j<columnindex;j++)
    				this->data[i*newcolumn+j] = datetemp[(i+1)*column+j];
    			for (int j=columnindex;j<newcolumn;j++)
    				this->data[i*newcolumn+j] = datetemp[(i+1)*column+j+1];
    		}
    		column=newcolumn;
    		row =newrow;
    		delete[] datetemp;
    	}
    	//删除多行和多列
    	void remove_row_column(int row1,int row2,int column1,int column2)
    	{
    		if (column1>=column || column1<0 || row1<0 || row1>=row || column2>=column || column2<0 || row2<0 || row2>=row)
    		{
    			throw_logic_error("删除行列范围越界");
    			return;
    		}
    		Complex* datetemp = data;
    		int newcolumn=column-column2+column1-1;
    		int newrow=row-row2+row1-1;
    		data = new Complex[newrow*newcolumn];
    		for (int i=0;i<row1;i++)
    		{
    			for (int j=0;j<column1;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j];
    			for (int j=column1;j<newcolumn;j++)
    				this->data[i*newcolumn+j] = datetemp[i*column+j+column2-column1+1];
    		}
    		for (int i=row1;i<newrow;i++)
    		{
    			for (int j=0;j<column1;j++)
    				this->data[i*newcolumn+j] = datetemp[(i+row2-row1+1)*column+j];
    			for (int j=column1;j<newcolumn;j++)
    				this->data[i*newcolumn+j] = datetemp[(i+row2-row1+1)*column+j+column2-column1+1];
    		}
    		column=newcolumn;
    		row =newrow;
    		delete[] datetemp;
    	}
    	//替换局部矩阵,改变了源矩阵,
    	void replace(CMatrix &a,int row1,int column1) 
    	{
    		int endrow=std::min(this->row,a.row+row1);
    		int endcolumn=std::min(this->column,a.column+column1);
    		for (int i=row1;i<endrow;i++)
    			for (int j=column1;j<endcolumn;j++)
    				this->data[i*column+j] = a((i-row1),j-column1);
    	}
    
    
    
    	//矩阵元素遍历操作,需要传入遍历函数,函数传入元素值,所属行,所属列,源矩阵,返回替换值。不改变源矩阵
    	CMatrix map(function<Complex(Complex item,int row,int column,CMatrix& src)> fun){
    		CMatrix p(this->row,this->column);
    		for (int i=0;i<this->row;i++)
    			for (int j=0;j<this->column;j++)
    				p(i,j)=fun(this->data[i*column+j],i,j,*this);
    		return p;	
    	}
    
    	//定义一个按行遍历函数(固定格式),每一行得到一个值,遍历结果为一个列向量。
    	 //输入参数:前一个元素,当前元素,当前元素所属行,当前元素所属列,源矩阵
    	//迭代从第二项开始,prev初始值为第一项,cur初始值为第二项。计算值自动传给下一函数的prev,返回最后一次迭代产生的值
    	CMatrix map_row(function<Complex(Complex prev,Complex cur,int row,int column,CMatrix& src)> fun){
    		CMatrix p(this->row,1);
    		for (int i=0;i<this->row;i++)
    		{
    			Complex result = this->data[i*column];
    			for (int j=1;j<this->column;j++)
    				result = fun(result,this->data[i*column+j],i,j,*this);
    			p(i) = result;
    		}
    		return p;
    	}
    
    	//定义一个按列遍历函数(固定格式),每一列得到一个值
    	 //输入参数:前一个元素,当前元素,当前元素所属行,当前元素所属列,源矩阵
    	//迭代从第二项开始,prev初始值为第一项,cur初始值为第二项。计算值自动传给下一函数的prev,返回最后一次迭代产生的值
    	CMatrix map_column(function<Complex(Complex prev,Complex cur,int row,int column,CMatrix& src)> fun){
    		CMatrix p(1,this->column);
    		for (int j=0;j<this->column;j++)
    		{
    			Complex result = this->data[j];
    			for (int i=1;i<this->row;i++)
    				result = fun(result,this->data[i*column+j],i,j,*this);
    			p(j) = result;
    		}
    		return p;
    	}
    	//点运算
    	CMatrix dot(CMatrix& a,string operation)
    	{
    		if (row!=a.row || column!=a.column)
    		{
    			throw_logic_error("点运算矩阵不匹配");
    			return NULL;
    		}
    		CMatrix p(row,column);
    		if (operation=="+")
    			for (int i=0;i<row;i++)
    				for(int j=0;j<column;j++)
    					p(i,j)=(*this)(i,j)+a(i,j);
    		else if (operation=="-")
    			for (int i=0;i<row;i++)
    				for(int j=0;j<column;j++)
    					p(i,j)=(*this)(i,j)-a(i,j);
    		else if (operation=="*")
    			for (int i=0;i<row;i++)
    				for(int j=0;j<column;j++)
    					p(i,j)=(*this)(i,j)*a(i,j);
    		else if (operation=="/")
    			for (int i=0;i<row;i++)
    				for(int j=0;j<column;j++)
    					p(i,j)=(*this)(i,j)/a(i,j);
    		else if (operation=="\\")
    			for (int i=0;i<row;i++)
    				for(int j=0;j<column;j++)
    					p(i,j)=a(i,j)/(*this)(i,j);
    		return p;
    	}
    
    	//查询是否是向量
    	bool isVector()
    	{
    		if (row==1||column==1)
    			return true;
    		return false;
    	}
    	//实部矩阵
    	Matrix real(){
    		Matrix p(row,column);
    		for (int i=0;i<p.row*p.column;i++){
    			p(i) = data[i].real();
    		}
    		return p;
    	}
    	//虚部矩阵
    	Matrix imag(){
    		Matrix p(row,column);
    		for (int i=0;i<p.row*p.column;i++){
    			p(i) = data[i].imag();
    		}
    		return p;
    	}
    	//模值矩阵
    	Matrix abs(){
    		Matrix p(row,column);
    		for (int i=0;i<p.row*p.column;i++)
    				p(i)=(double)std::sqrt((this->data[i].imag())*(this->data[i].imag())+(this->data[i].real())*(this->data[i].real()));
    		return p;
    	}
    	//角度矩阵
    	Matrix angle(){
    		Matrix p(row,column);
    		for (int i=0;i<p.row*p.column;i++)
    				p(i)=(double)std::atan((this->data[i].imag())/(this->data[i].real()));
    		return p;
    	}
    	//共轭矩阵
    	CMatrix conj(){
    		CMatrix p(row,column);
    		for (int i=0;i<p.row*p.column;i++)
    				p(i)=Complex(this->data[i].real(),-(this->data[i].imag()));
    		return p;
    	}
    	//字符串形式表示
    	string toString(){
    		stringstream back;
    		for (int i=0;i<row;i++)
    		{
    			for(int j=0;j<column;j++)
    			{
    				if(data[i*column+j].imag()<0)
    					back<< fixed << setprecision(4)<<data[i*column+j].real()<<data[i*column+j].imag()<<"i";
    				else
    				{
    					back<< fixed << setprecision(4)<<data[i*column+j].real()<<"+"<<data[i*column+j].imag()<<"i";
    				}
    				back<<"   ";
    			}
    			if(i!=row-1)
    				back<<"\n";
    		}
    		return back.str();
    	}
    	//按行优先转化为series
    	Complex* toSeries(){
    		Complex* back = new Complex[row*column];
    		for (int i=0;i<column*row;i++)
    			back[i] = data[i];
    		return back;
    	}
    	//转化为二位数组
    	Complex** toArray(){
    		Complex** back = new Complex*[column];
    		int n=0;
    		for (int i=0;i<row;i++){
    			back[i]=new Complex[column];
    			for(int j=0;j<column;j++)
    				back[i][j] = data[i*column+j];
    		}
    		return back;
    	}
    	//按行优先转化为一维vector
    	vector<Complex> toVector(){
    		int t=0;
    		vector<Complex> back(row*column);
    		for (int i=0;i<row;i++)
    			for (int j=0;j<column;j++)
    				back[t++]=data[i*column+j];
    		return back;
    	}
    	//按行优先转化为二维vector
    	vector<vector<Complex>> toVector2(){
    		int rowindex=0;
    		int columnindex=0;
    		vector<vector<Complex>> back(row);
    		for (int i=0;i<row;i++)
    		{
    			columnindex=0;
    			vector<Complex> newrow(column);
    			for (int j=0;j<column;j++)
    				newrow[columnindex++]=data[i*column+j];
    			back[rowindex++]=newrow;
    		}
    		return back;
    	}
    	//析构函数,不能使用析构函数的原因在于很多函数局部类型返回需要保留data数据,不能使局部类型析构造成接收对象不可用。但是如果重写了赋值运算符,可以加上,因为在函数内,先赋值,在析构局部变量
    	~CMatrix(){
    		row=0;column=0;
    		if(data !=nullptr){
    			delete[] data;
    			data=nullptr;
    		}
    	}
    
    };
    
    
    
    }
    
    
    
    展开全文
  • Python调Matlab function多维numpy矩阵输入

    千次阅读 2019-02-25 14:42:45
    假设matlab中某一个函数的输入参数是多维矩阵,那我们可以把python中定义好的数组先转成list,如下: np_a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) mat_a = matlab.double(np_a.tolist()) 这样生成的mat_a...
  • c与MATLAB混合编程 mxArray矩阵赋值

    千次阅读 2018-10-10 16:19:12
    MATLAB里边定义 a = [1, 4, 2; 3, 2, 0]; 在C语言等效定义double a[2][3] = { 1, 3, 4, 2, 2, 0 };//c语言的数组在内存里边是按行依次存储的,而MATLAB的mxArray是按列依次存储...//定义一个2行3列的矩阵 me...
  • 基操与矩阵输入基操运算符优先级变量赋值命令优先级输出格式Format命令其他矩阵输入(矩阵和向量)定义矩阵创建等差数列矩阵的运算:+ - * / ^ . '(转置)特殊的矩阵矩阵的命令 基操 运算符优先级 从左到右运算 括号...
  • 做法,需要输入种群大小矩阵以及func_num,对于后者这个参数实在摸不着头脑, 已百度,仍然无解,求教!急急急! 2.附上代码: ``` /* CEC13 Test Function Suite Jane Jing Liang (email: liangjing...
  • %% 初始定义 x1=275;y1=71; x2=299;y2=26.5; X = p(1); Y = p(2); sys= [X;Y];%结果输出 toc %% 自定义函数 function p = CrossPoint(x1,y1,x2,y2,a,b) r = sqrt((x2-x1)^2...
  • 一,double类型 1.Matlab默认的矩阵数据结构都是双精度浮点型,即64位来表示一个数字,大多数的函数和操作都定义double数据结构.
  • double 把其他类型对象转换为双精度数值 drawnow 更新事件队列强迫Matlab刷新屏幕 dsolve 符号计算解微分方程 E e echo M文件被执行指令的显示 edit 启动M文件编辑器 eig 求特征值和特征向量 eigs 求...
  • 矩阵MATLAB最基本,最重要的数据类型,MATLAB的大部分运算或命令都是在矩阵运算的意义下执行的,而且这种运算定义在复数域上。向量和单个数据都可以作为矩阵的特例来处理。 数据类型 1.矩阵 2.整型 带符号整数...
  • 前言 在初次使用matlab cvx求解凸优化问题时遇到了一些问题,在这里记录一下。...一开始定义了一个矩阵,想把cvx求得的最优解放入矩阵的某一行: 然后在cxv求解结束时,把cvx求得的最优解放入矩阵的某一行(这
  • 模糊矩阵的合成

    千次阅读 2012-11-19 13:50:25
    昨天晚上用matlab写了一下,后来又想用c去实现同样的效果,不像matlab有封装好的求最大值最小值函数,在c中需要自己定义,代码写的还算详细的,配合注释应该能够看懂的。 #include #define M 2 #define N 3 double ...
  • MATLAB基础——关于数组(一)

    千次阅读 2019-09-18 20:27:35
    数组可以定义为向量(一般描述为一维数组)或矩阵(一般描述为二维或多维) 访问数组中的元素:数组名+() MATLAB变量名的命名:以字母开头,可跟字母、数字、下划线,只有前31个字符有效 区分字母的大小写 强类型...
  • Function test1) %定义test函数 im=imread'water.tif; %读取一幅tif格式的water图像命名为im figure(1,imshow(im,[]) %创建图像1用来显示刚才读取的im图像 im=double(im; %生成矩阵im [nx,ny]=size(im; %读取矩阵的...
  • 掩膜矩阵可以是用户定义,也可以是系统定义好的。返回矩阵Z和X有相同的数据结构和数据类型。 整个函数处理的中间过程都会使用double类型,所以不必担心中间结果的精度。 2、获取系统掩膜函数H=fspecial...
  • 原文地址C++矩阵库 Eigen 快速入门 不仅有函数的基本形式,还有对应的...Eigen 矩阵定义 #include <Eigen/Dense> Matrix<double, 3, 3> A; // Fixed rows and cols. Same as Matrix3d. Matrix...
  • ImageNum=double(Image(I,J,1)); A(I,J)=ImageNum/255; B(I,J)=0; end end figure; imshow(A); pi=3.1415926; for I=1:1:N for J=1:1:N R=rand(1,1);%生成一个元素在0,1之间均匀分布的随机矩阵R B(I,J)=A(I,J...
  • clc; clear; close all; warning off; addpath 'func\' %% %参数初始化 ...I = double(imread('Test_Image\hand.jpg'));...%初始模板,模板在初始的时候只要定义一个较大的矩阵即可 S1 = size(I,1); E1 ...
  • 获取帮助: help / help <函数名> / help win / help desk = doc 找出相关命令: look for <关键字> ...double(默认) ...数组/矩阵 ...只能含有同种类型, 定义[], 访问() 元胞 可以含有
  • //定义matlab引擎指针 if (!(ep=engOpen(NULL))) //测试是否启动Matlab引擎成功。 { cout <<"Can't start Matlab engine!" ; exit(1); } int x[1],y[1]; x[0]=(int)w.ImageWidth; y[0]=(int)w....
  • data[count*[count+1])矩阵数组;count:方程元数; //Answer[count]:求解数组。返回0,求解成功。-1无解或无穷解; int LinearEquations(double *data,int count,double *Answer) { int j ,m ,n; double tmp...
  • 与结构体类似,通过某一种关系将不同的数据、字符串及矩阵组织在一起,每个成员各住在一个“房间”里。 定义一个cell变量,可以用大括号来表示"{}"。有两种定义方式: 第一种: A1(1,1) = {[1 4 3; 0 5 8; 7 2 9...
  • 如何得到MATLAB和C++数据交类请参考:http://blog.csdn.net/visualsan/archive/2011/03/05/6226205.aspx<br />  我们要处理的mat文件中的数据结构类型有:string,标量、矩阵、阵列和结构体;数据类型有...
  • %将输入的4位数拆开,组成矩阵B for i=1:4 B(5-i) = mod(instr,10); for j=1:4 if isequal(B(5-i),A(j)) %判断B与A是否有相同元素,并将其个数存入b b=b+1; end end instr = fix(instr/10); end %判断输入...

空空如也

空空如也

1 2 3
收藏数 41
精华内容 16
热门标签
关键字:

matlab定义double矩阵

matlab 订阅