精华内容
下载资源
问答
  • 学计算功能Abs(x)实数的绝对值或复数的幅值floor(x)对x朝-∞方向取整Acos(x)反余弦arcsinxgcd(m,n)求正整数m和n的最大公约数acosh(x)反双曲余弦arccoshximag(x)求复数x的虚部angle(x)在四象限内求复数x的相角lcm(m...

    Abs(x)

    实数的绝对值或复数的幅值

    floor(x)

    x

    -

    ∞方向取整

    Acos(x)

    反余弦

    arcsin

    x

    gcd(m

    n

    )

    求正整数

    m

    n

    的最大公约数

    acosh(x)

    反双曲余弦

    arccosh

    x

    imag(x)

    求复数

    x

    的虚部

    angle(x)

    在四象限内求复数

    x

    的相角

    lcm(m

    n)

    求正整数

    m

    n

    的最小公倍数

    asin(x)

    反正弦

    arcsin

    x

    log(x)

    自然对数(以

    e

    为底数)

    asinh(x)

    反双曲正弦

    arcsinh

    x

    log10(x)

    常用对数(以

    10

    为底数)

    atan(x)

    反正切

    arctan

    x

    real(x)

    求复数

    x

    的实部

    atan2(x,y)

    在四象限内求反正切

    Rem(m

    n)

    求正整数

    m

    n

    m/n

    之余数

    atanh(x)

    反双曲正切

    arctanh

    x

    round(x)

    x

    四舍五入到最接近的整数

    ceil(x)

    x

    +

    ∞方向取整

    sign(x)

    符号函数:求出

    x

    的符号

    conj(x)

    求复数

    x

    的共轭复数

    sin(x)

    正弦

    sin

    x

    cos(x)

    余弦

    cos

    x

    sinh(x)

    反双曲正弦

    sinh

    x

    cosh(x)

    双曲余弦

    cosh

    x

    sqrt(x)

    求实数

    x

    的平方根:

    x

    exp(x)

    指数函数

    xe

    tan(x)

    正切

    tan

    x

    fix(x)

    x

    朝原点方向取整

    tanh(x)

    双曲正切

    tanh

    x

    2

    、常量与变量

    系统的变量命名规则:

    变量名区分字母大小写;

    变量名必须以字母打头,

    其后可以是任

    意字母,

    数字,

    或下划线的组合。

    此外,

    系统内部预先定义了几个有特殊意义和用途的变量,

    见下表:

    特殊的变量、常量

    展开全文
  • 1前言谈谈关于MATLAB的矩阵算数运算。上节仿真结果得到出一个五元一...下面介绍介绍矩阵运算与非齐次线性方程组求解。2MATLAB矩阵算术运算在这里先纠正一个错误,第一节中“Scope工具栏还原方法”中set(gcf,'menubar...

    03715934a2197bcb4ef3942a349deb15.gif

    1前言

    谈谈关于MATLAB的矩阵算数运算。上节仿真结果得到出一个五元一次方程组,而且数据还有复数,这样的仿真组人工计算很难完成,那就不得不借助MATLAB强大的计算功能。本算例建立.m文件处理数据,可以快速得出多个未知变量解。下面介绍介绍矩阵运算与非齐次线性方程组求解。

    aca52bee685caefaee1caa9176e4275c.png2 MATLAB矩阵算术运算

    在这里先纠正一个错误,第一节中“Scope工具栏还原方法”中

    set(gcf,'menubar','figure')重复了两遍,需要将第一条命令改为:

    set(0,'ShowHiddenHandles','On')。

    1、矩阵加减运算

    同型矩阵通过“+”,“-”直接完成运算。

    clcclearA = [1.1 + 0.2i 3.2 - 2.1i;     0.8 - 0.3i 9.3 + 0.6i];B = [1.9 + 0.9i 9.2 - 6.1i;     0.1 - 4.3i 5.3 + 4.6i];C = A + B;D = A - B;vpa(C,5)vpa(D,5)

    运行结果

    882554027328e2aab83f74a06d4a78bb.png

    2、矩阵乘法运算

    矩阵乘法分为直接相乘(A1*B1)和点乘(A.*B),直接相乘要求A矩阵的列数等于B矩阵的行数,点乘是两个同型矩阵对应元素相乘。

    A1 = [1.1 + 0.2i 3.2 - 2.1i 0.6 - 4.4i;0.8 - 0.3i 9.3 + 0.6i 1.4 + 3.1i];B1 = [1.9 + 0.9i 9.2 - 6.1i;0.1 - 4.3i 5.3 + 4.6i;3.1 + 0.4i 5.2 - 1.3i];C1 = A1 * B1;D1 = A .* B;vpa(C1,5)vpa(D1,5)

    运行结果

    5ed7f4f5f325c1b8b86bb624c47df3ad.png

    3、矩阵的除法

    矩阵除法分为左除(A1\B2)、右除(A1/B2)和点除(A1./B3)。左除是求解Ax=b的解、右除是求解xA=b的解、点除表示同型矩阵对应元素相除。

    A1 = [1.1 + 0.2i 3.2 - 2.1i 0.6 - 4.4i;     0.8 - 0.3i 9.3 + 0.6i 1.4 + 3.1i;     2.8 - 0.8i 2.3 + 1.6i 1.9 + 2.1i];B2 = [4 2 7]';B3 = [4 1 3;      2 4 5;      7 3 8]';C2 = A1 \ B2;D2 = A1 / B3; E2 = A1 ./ B3;vpa(C2,5)vpa(D2,5)vpa(E2,5)

    运行结果

    03d2e11b41ad1a1d8bc7266b02dfd83a.png

    其他运算不再举例参考书籍:1.MATLAB.&Simulink开发实例系列丛书 新编MATLAB/Simulink自学一本通2.MATLAB的工程数学应用3非齐次线性方程组求解

    1、非齐次线性方程求解问题

    例:五元一次方程求解,形如Ax=b。

    A1x=B4

    A1 = [1.1 + 0.2i 0 0 0 0.6 - 4.4i;      0 9.3 + 0.6i 0 0 1.4 + 3.1i;      0 0 2.8 - 0.8i 0 1.9 + 2.1i;      0 0 4.6 - 0.2i 0 1.5 + 0.6i;      0 0 0 2.3 + 0.5i 2.3 + 9.2i];B4 = [2 4 1 6 3]';format rationalE3 = A1 \ B4;  vpa(E3,5)

    运行结果

    87a0d00e89d4d4e4fe51edd4555649ba.png

    其他形式不再举例。98e46b05e611b2b8b98ca8ef91874cbd.png8a9d5e309fc8f42ed6a2ac1c1ba2a29e.png

    往期精选

    MATLAB/simulink仿真入门(第一节)

    LLC谐振变换器原理(第一部分)

    LLC谐振变换器原理(第三部分)

    LLC谐振变换器(第五部分)TL431

    1kW LLC谐振参数计算书

    对称半桥LLC工作过程分析

    对称半桥与不对称半桥对比

    end

    您的点赞

    就是我的动力

    研途

    db0e8344dea2431062ae31a9ae916649.png6a55424d7d118fae44234545840b8a1e.png5ab868f71d1e9657b86e5e915f534507.png

    你的“在看”就是最大的鼓励!3fce0176ec17d46119c1ff59ee13383f.gif

    展开全文
  • 一、前言 最近在企业实习,花了三个星期的时间肝了一个室内定位算法(雏形,还未优化),实现matlab和C的联写、联调,其难点...谨以此连载文档记录一下算法开发的关键--复数矩阵运算。 网上关于C语言实现矩阵运算的de

    一、前言

       本连载文章主要内容是实现复数矩阵的各种运算,并利用matlab进行联写、联调,验证C语言编写的各个矩阵运算函数的正确性。其难点笔者认为在于矩阵的各种运算,C++中有Eigen库可用,以前在学slam和做课题时候在Ubuntu下用过一段时间的Eigen,功能强大,提供了各种典型的matrix计算接口,但是在C中,需要我们自己编写每个功能模块。谨以此连载文档记录一下算法开发的关键--复数矩阵运算的实现,纯粹为了学习交流。
       网上关于C语言实现矩阵运算的demo较多,但是大体都不够完整和准确,很多function直接git下来各种问题,且用起来没有统一的标准,另外,只在实数域(Double)内讨论,但是我们知道在算法领域,很多矩阵运算都涉及到复数(Complex)运算,复数域内矩阵运算其实与实数域还是有很大区别的(PS:这也是我在写C程序时候遇到的坑,之后本文会一一介绍)。
       因此,在本连载文章中,我将完全使用C语言完成对矩阵的定义、内存初始化、访问索引、内存销毁的基本功能,更重要的是编写求取代数余子式、行列式、逆矩阵、协方差矩阵、特征值、特征向量等功能函数。所有函数demo我都单独拿出来仔细讲解,并结合matlab,编程对比验证demo正确性,大家可以放心阅读和使用。
    

    二、知识储备和编程工具

       1. 知识储备:熟练C语言,精通指针、数组等C语言“灵魂”知识;
       2. IDE工具:Visual Studio2019Community; MATLAB2019a;
       3. C相关头文件:complex库
    

    三、矩阵的定义

    注意到社区内有小伙伴用二维数组来定义一个矩阵,但是矩阵并不总是二维的,在matlab里面,矩阵可以是N维的,若是试图用更高维度的数组去完成定义,在后续的访问矩阵/数组元胞时候显得非常冗余。虽说C是结构化程序设计语言,但一定的“鲁棒性”也是需要的。另外我是用C++和matlab居多,所以总是或多或少在编程时候有一定的C++的思想。后者面向对象,具有类模板和模板函数。
    PS:在之后贴出来的code中,我都会分别给出Double和Complex两份demo,以及调用到的complex库文件的相关函数接口说明。

    1.头文件

    	 # include <complex.h>  // Complex Numbers
    	 # include <stdlib.h>   // malloc/free, et.al
    

    说明
    关于复数头文件,C11开始提供了大量函数接口,这里我只对用到的单独拿出来讲一下。有兴趣的可以点开源文件看看都有什么内容。首先是定义,源文件见下:

    	#ifndef _C_COMPLEX_T
        	#define _C_COMPLEX_T
        	typedef struct _C_double_complex
        	{
           	 double _Val[2];
        	} _C_double_complex;  // This is what I need
    
       	 typedef struct _C_float_complex
        	{
            	float _Val[2];
        	} _C_float_complex;
    
        	typedef struct _C_ldouble_complex
        	{
            	long double _Val[2];
        	} _C_ldouble_complex;
    	#endif
    
    	typedef _C_double_complex  _Dcomplex;  // This is what I need
    	typedef _C_float_complex   _Fcomplex;
    	typedef _C_ldouble_complex _Lcomplex;
    

    简而言之,complex.h头文件通过定义一个结构体来表示一个复数。具体说来,结构体内部成员是一个一维数组,存储两个数据,由该数组来储存复数的实部(real)和虚部(imaginary),根据实/虚部浮点精度不同定义了三种数组,分别是double、float、long double,对应定义了三种结构体类型,再对应每个function都定义了三个函数。谨记,这三种常规类型指的是复数的实部和虚部的数据类型。算法中,我用到的是double类型。所以以下涉及到复数运算的我都只调用了complex.h头文件中跟double类型相关的函数。

    2.定义

    这里我用一个结构体来完成对矩阵的定义和“模拟”。

    	typedef _Dcomplex ComplexType;   // Complex Variables
    	typedef double DoubleType;       // Double Variables
    
    	/* Complex Cell */
    	typedef struct   // Matrix Structor
    	{
    		int row, column;  // Size
    		ComplexType* arrayComplex;     // Pointer to Cell
    	}Matrix;
    
    	/* Double Cell */
    	typedef struct
    	{
    		int row, column;
    		DoubleType* arrayDouble;
    	}Matrix2Double;
    	/* bool */
    	typedef enum 
    	{ 
    		False = 0, True = 1 
    	}Bool;
    

    说明
    (1) 虽然complex.h头文件内已经对复数类型_C_double_complex取了别名_Dcomplex,为了区别double和complex,我对二者再次取了一个别名,遵守Google命名规则,随后的定义矩阵的两个结构体类型和bool变量的枚举类型同理;
    (2) 重点来了,两种不同元素类型的矩阵,我定义了两个结构体,一个是元胞是实数类型的,一个是复数类型的。结构体内部两个int类型的member代表的是矩阵的行数(row)和列数(column),指针member用于指向存储元素/元胞(cell)的一段内存,因此矩阵元胞可以用指针来进行访问和遍历,此时内部数据结构指针是1D的,但却可以表示2D及以上的矩阵,从这里可以看到指针代替数组的优越性;
    (3) 最后,笔者还定义了一个枚举类型,后续的用于安全机制的函数有用到;
    (4) 可以看到,两个不同类型的矩阵其结构体其实完全一样,只是内部指针变量类型不一样。

    3.初始化内存分配

    首先是写一个对一个复数进行初始化的函数,因为复数也是一个结构体,当定义一个复数变量时候,最好也对其进行初始化。此外,后续涉及到复数的累加累乘,因此也需要对其赋值和初始化:

    	/* Initiation of Complex Number */
    	void InitComplex(ComplexType* Complex)  // Transfer of Pointer
    	{
    		Complex->_Val[0] = 0.0;
    		Complex->_Val[1] = 0.0;
    
    	}
    

    然后是对矩阵进行初始化:

    	/* Initiation of Complex Matrix */
    	void InitComplexMatrix(Matrix* matrix, int row, int column)  // Transmiss of Pointer
    	{
    		int size = row * column * sizeof(ComplexType);
    		if (size <= 0)
    		{
    			puts("ERROE: An invalid matrix!\n");
    			return;
    		}
    		matrix->arrayComplex = (ComplexType*)malloc(size); 			// initiate pointer
    		if(matrix->arrayComplex)
    		{
    			matrix->row = row;                           			 //  initiate row and size
    			matrix->column = column;
    			for (int index = 0; index < row * column; index++)       //  initiate cell
    			{
    				InitComplex(matrix->arrayComplex + index);  // call InitComplex() function
    			}
    		}
    	}
    	
    
    	/* Initiation of Double Matrix */
    	void InitDoubleMatrix(Matrix2Double* matrix, int row, int column)
    	{
    		int size = row * column * sizeof(DoubleType);
    		if (size <= 0)
    		{
    			puts("ERROE: An invalid matrix!\n");
    			return;
    		}
    		matrix->arrayDouble = (DoubleType*)malloc(size);
    		if (matrix->arrayDouble)
    		{
    			matrix->row = row;
    			matrix->column = column;
    			for (int row_i = 0; row_i < row; ++row_i)
    			{
    				for (int column_j = 0; column_j < column; ++column_j)
    				{
    					matrix->arrayDouble[row_i * matrix->column + column_j] = 0.0;
    				}
    			}
    
    		}	
    	}
    

    说明
    (1) 矩阵初始化涉及到确定矩阵row/column的大小、初始化元胞,也就是对结构体变量进行初始化赋值,其核心是对指针动态申请一段内存,采用的是malloc()函数,包含在头文件stdlib.h中;
    (2) 用指针访问/遍历(iteration)矩阵元胞,其实也就是指针指向的每个单元内保存的数,在initiate cell环节,这里其实有三种表示方式,主要是指针访问元素矩阵访问元胞具有不同的方式。后续访问元素/元胞时候我都是随机选一种写的(sorry,我当时写代码时候这些都不是重点,所以想到哪种写哪种),但是为了避免读者阅读混乱,这里,笔者都给出来:

    	// Solution_1
    	for (int index = 0; index < row * column; index++)       //  initiate cell
    	{
    		InitComplex(matrix->arrayComplex + index);
    	}
    	// Solution_2
    	for (int index = 0; index < row * column; index++)
    	{
    		InitComplex(&(matrix->arrayComplex[index]));
    	}
    	// Solution_3
    	for (int row_i = 0; row_i < row; ++row_i)
    	{
    		for (int column_j = 0; column_j < column; ++column_j)
    		{
    			InitComplex(matrix->arrayComplex + row_i * matrix->column + column_j);
    		}
    	}
    

    (3) 另外,为了安全起见,我还加入了两个if语句,可以进一步减少最后compile时出现的各种堆栈溢出等内存bug和exception,比如free掉已经不存在的内存或者malloc失败的内存,也就是C语言使用指针出现的野指针堆错误
    (4) double类型的矩阵类同complex类型,甚至在初始化值时候还要简单一点,因为每个double元胞只有一个元素,而complex有实部和虚部两个。

    4.内存销毁

    我们知道在Linux内,malloc()和free()系统函数总是成对出现,有内存申请必有内存的释放,同样在VS下,利用一个结构体变量定义了一个矩阵之后,调用了malloc()函数申请了一段memory,故而需要释放:

    	/* Validity of Complex Matrix */
    	Bool IsNullComplexMatrix(const Matrix* matrix)
    	{
    		int size = matrix->row * matrix->column;
    
    		if (size <= 0 || matrix->arrayComplex == NULL)
    		{
    			return True;
    		}
    		return False;
    	}	
    	/* Free Memory of Complex Matrix */
    	void DestroyComplexMatrix(Matrix* matrix)
    	{
    		if (!IsNullComplexMatrix(matrix))    // Nested Call of IsNullComplexMatrix()
    		{
    			free(matrix->arrayComplex);      // Pair: malloc--free
    			matrix->arrayComplex = NULL;
    		}
    		matrix->row = matrix->column = 0;
    	}
    	
    	
    	/* Validity of Double Matrix */
    	Bool IsNullDoubleMatrix(const Matrix2Double* matrix)
    	{
    		int size = matrix->row * matrix->column;
    
    		if (size <= 0 || matrix->arrayDouble == NULL)
    		{
    			return True;
    		}
    		return False;
    	}
    	/* Free Memory of Double Matrix */
    	void DestroyDoubleMatrix(Matrix2Double* matrix)
    	{
    		if (!IsNullDoubleMatrix(matrix))
    		{
    			free(matrix->arrayDouble); 
    			matrix->arrayDouble = NULL;
    		}
    		matrix->row = matrix->column = 0;
    	}
    

    说明
    (1) 首先,定义一个IsNullComplexMatrix()函数用于判断矩阵是否初始化成功,主要判断结构体内部的member是否初始化成功(体现在矩阵,就是行列数和内存)。属于保障内存安全的操作。看到没,这里我就调用了前文说到的Bool枚举类型成员;
    (2) 之后,定义一个DestroyComplexMatrix()函数释放结构体内部的member,即嵌套调用free()释放掉指针成员指向的内存,并置为NULL(这步虽然不是必须的但是笔者建议各位读者每次都加上),再将两外两个int类型的member变量置为0;
    (3) 关于double类型,同样给出,不再赘述。
    (4) 补充一点,在我的算法框架中,出现了大量矩阵的定义,也就是多次内存的申请和释放,甚至在几个核心的算法函数内部,出现了二十个以上的矩阵,要是每个矩阵调用一次初始化和销毁函数,会严重影响编程美观和效率。因此,我又写了几个初始化(initiate)和内存销毁(destroy)函数,其目的是一次性只调用一个函数将我需要的所有的矩阵进行内存的申请和释放。当然,这个功能只在我的具体算法场景下用得到,所以我只是做一个补充拓展贴出来,另外,我只给出内存销毁函数,后续我会依次写demo验证一下这个function:

    	/* Free Memory of Complex Matrice Array */
    	void DestroyComplexMatrixArray(Matrix matrixArray[], int num)  // Array Transfer--->Pointer Transfer
    	{
    		if (num)      // if no matrix
    		{
    			for (int i = 0; i < num; i++)
    			{
    				DestroyComplexMatrix(&matrixArray[i]);  // Nested Call of DestroyComplexMatrix()
    			}
    		}
    	}
    
    
    	/* Free Memory of Double Matrice Array */
    	void DestroyDoubleMatrixArray(Matrix2Double* matrixArray, int num)
    	{
    		if (num)  // if no cell
    		{
    			for (int i = 0; i < num; i++)
    			{
    				DestroyDoubleMatrix(&matrixArray[i]);
    			}
    		}
    	}
    

    5.获取矩阵行、列、元胞数目

    这里我也定义了三个函数用于返回相应的值:

    /* Return Matrix Row Size */
    int MatrixRow(const Matrix* matrix)
    {
    	return matrix->row;
    }
    /* Return Matrix Column Size */
    int MatrixColumn(const Matrix* matrix)
    {
    	return matrix->column;
    }
    /* Return Complex Matrix Size */
    int MatrixSize(const Matrix* matrix)
    {
    	return MatrixRow(matrix) * MatrixColumn(matrix) ;   // Size Refers to Numbers of Cell of Matrix
    }
    

    说明
    (1) 由于这里的矩阵笔者用的结构体来~~“模拟”~~ 实现,我们为了让矩阵看起来“更像”我们数学中那样的“格式”,数学美学要用计算机实现,还是定义了相关函数来返回我们要的量,但是事实上,可以直接采用如下格式直接获取

    /** pointer     &   variable**/
    matrix->row; // matrix.row
    matrix->column; // matrix.column
    matrix->row * matrix->column; // matrix.row * matrix.column
    

    四、总结

    这是第一章节的内容,整体上来讲,只是为了完成矩阵的定义、初始化、内存销毁等,但是非常重要,因为后续的所有矩阵运算函数和接口都基于此,事实上,我遇到的很多问题都是出现在这一部分。为后续方便读者阅读,或者帮助读者编程时候排雷,笔者对个人编程习惯和这部分遇到的坑做个总结:

    1. 尽量写void类型的函数,避免在函数内部定义local variable,也就是局部矩阵,频繁调用初始化和销毁函数,造成计算机内存频繁的申请和释放;
    2. 函数形参尽量定义为指针类型,尤其是矩阵/结构体变量,因为是void函数,没有return返回值,因此用传地址方式而不能采用传值操作,避免出错;
    3. 调用函数时候,实参尽量定义为一般变量,尤其是矩阵/结构体变量,这样可以避免结构体指针变量本身就需要分配和释放内存,关于这一点,由于笔者使用C语言编程经历真心不多,所以当时把实参也清一色定义为指针,造成后续在每个函数里面出现了大量结构体指针初始化、结构体内部指针初始化的操作,矩阵多了之后就很混乱,如果分配和释放不及时,会造成编译时候cast各种exception,这也是我当时遇到过的第一个大坑;
    4. 因为const在C++里面意义非常丰富,在C里面,我也习惯性只要是在函数内部不改变传入的实参值的,都在定义函数时为形参加上一个const。这样可以避免在复杂的函数嵌套调用实参和形参传递矩阵运算过程中出现对本不想修改的变量进行修改的情况,造成结果不可预测。事实上,只要是不会修改的实参,我们在定义形参的时候都应为其加上一个const;
    5. 在定义函数内部,只要是传入了一个实参矩阵,我都对其进行是否为空的判断(调用一个IsNullComplexMatrix()函数),再进行下面的功能实现。事实上,编程时候,都应该在code内部加上一些安全性的操作逻辑;
    6. 下一章我将详细给出实数、复数域上矩阵运算的函数,敬请期待…
      传送门:(二)
    展开全文
  • 今天遇到一个问题,有一个4333*1的**complex double 矩阵**,进行相关运算时候,发现matlab运行出不来结果,于是就开始着手解决这个问题,后来参考很多资料,总结了两种方案,比较得出第二种方案更佳: 首先思路都...
    	今天遇到一个问题,有一个4333*1的**complex double 矩阵**,进行相关运算时候,发现matlab运行出不来结果,于是就开始着手解决这个问题,后来参考很多资料,总结了两种方案,比较得出第二种方案更佳:
    	首先思路都是先将这个变量矩阵保存为.dat的文件,然后下次用到时候再引用出来。用到语句是:
    	    fid_r=fopen('test_111.dat','w'); %创建文件test_111.dat
    		fwrite(fid_r,rc_e,precision); %将rc_e变量写入fid_r,即存入变量test_111.dat中
    		
    		fid_r=fopen('test_111.dat','r');%读数据文件
    		data_real = fread(fid_r,Nr,precision);%将数据文件test_111.dat写入data_real
    	1.一开始为了图省事,我把这个complex矩阵存到一个dat文件中,但是后面在for循环中调用时候,又会运行很慢! 这里面在存储dat文件时候,需要调用一个Des_conv函数,下面会说到。
    	2.另一种思路,把complex数据分成实部,虚部存到两个dat文件中,后面for循环用到时候也是先分别调用出来,再用y=data1+j*data2的形式构建原来complex数据。这样效率大大提高了! 当然在存储时候,也用到了Des_conv函数。
    	【Des_conv函数】:在size比较大的复数矩阵存储时候,如果直接存储会偶尔出错,并且每运行一次就有一次新结果。将文件A中的矩阵分成4块来转置存储到B中,实现了矩阵的快速存储。附上函数代码:
    
    function RDS_conv(src,dst,row,column)
    % 实现将文件src中的矩阵分成4块来转置存储到dst中,不必考虑M是否为4的整数倍。
    BYTE = 4;
    precision = 'float32';
    SUB_NUM = 4;             % 将矩阵分成4块来处理
    block = fix(column/SUB_NUM);  % 向零取整
    reml = rem(column,SUB_NUM);   % column/CON_LINE取余
    fs = fopen(src,'r');
    fd = fopen(dst,'w');
    fseek(fs,0,-1);
    fseek(fd,0,-1);
    temp = zeros(row,block);
    for jj = 1 : SUB_NUM
        fseek(fs,0,-1);
        beginN = (jj - 1)*block*BYTE;
        endN = (SUB_NUM - jj)*block*BYTE + reml*BYTE;
        for ii = 1 : row
            fseek(fs,beginN,0);
            kkk = fread(fs,block,precision);
            temp(ii,:) = kkk.';
            fseek(fs,endN,0);
        end
        fwrite(fd,temp,precision);    
    end
    if (reml>0)
        temp_rem = zeros(row,reml);
        fseek(fs,0,-1);
        for ii = 1 : row
            fseek(fs,SUB_NUM*block*BYTE,0);
            ggg = fread(fs,reml,precision);
            temp_rem(ii,:) = ggg.';
        end
        fwrite(fd,temp_rem,precision);
    end
    fclose('all');
    disp('end of matrix_rotate')
    

    最后把整个处理的大致代码附上:

    fid_r=fopen('data_real.dat','r');
    fid_i=fopen('data_image.dat','r');
    /*   中间复数变量RC的计算过程   */
    fwrite(fid_r,real(RC),precision);
    fwrite(fid_i,imag(RC),precision);
    RDS_conv('data_real.dat','data_real_ro.dat',Na,Nr_effect); %分块存储实部
    RDS_conv('data_image.dat','data_image_ro.dat',Na,Nr_effect);%分块存储虚部
    
    fid_r=fopen('data_real.dat','r');
    fid_i=fopen('data_image.dat','r');
    data_real_range= fread(fid_r,Nr,precision);
    data_image_range = fread(fid_i,Nr,precision);
    data_last=(data_real_range+1i*data_image_range).';
    
    /*   后面计算过程   */
    
    

    当然,这只是我遇到的matlab运行结果慢时候的一种情形解决方案,有其他问题导致运行效率低的同学,也可以参考这篇博文:提高matlab运行效率:https://blog.csdn.net/pursh0000/article/details/51314209

    展开全文
  • 本章开始,笔者将详细讲解实数和复数矩阵的模(范数)、协方差等运算,并给出函数和测试demo的C代码,以及与matlab计算的结果; 并且,本章也出现了我在编写函数、后期与matlab联调跑数据时候踩到的一个坑,读者稍微...
  • 本章开始,开始详细讲解实数和复数矩阵的转置、复制、行列式、代数余子式、逆等运算,并给出函数和测试demo的C代码,以及与matlab计算的结果; 并且,本章出现了我在编写函数、后期与matlab联调跑数据时候出现...
  • matlab数据类型 数值型数据 整数型: 带符号的整数 -128~127 不带符号的整数 0~255 浮点型数据: 单精度数据 双精度数据 数据类型的函数: single(x):将数据x转化为单精度数据的数值 double(x):将数据x...
  • 另,这将也是我此连载文章的系列精品之一,矩阵运算的功能越来越复杂,但是笔者全部分模块进行,化繁为简,化整为零,所以需要调用的小函数越来越多,读者遇到不熟悉的函数可以随时Jump到(一)、(二)、(三)、...
  • MATLAB基本语法 变量 1.MATLAB中的变量不需要声明 2.使用 “ = ” 为变量赋值 变量名 1.与大多数编程语言相同,MATLAB中的变量名是大小写敏感的(也就是说大写A与小写a所代表的含义是不一样的) ...复数算子
  • Ez是一个关于phi和z的复数矩阵,假设行表示phi,列表示z,phi取值范围为-180~180(2度一个点),n取值范围为-90~90,z取值范围为-2.5~2.5(0.05一个点),h取值范围为-50~50,那么我根据公式求和运算计算结果和直接...
  • 如图这样的txt文档,我该如何导入到MATLAB的工作区,形成数组,然后对这些数进行运算。 如下是我找到的一段代码 ``` clc; clear; fin=fopen('222.txt','r'); result={}; while feof(fin)==0 str=fgetl...
  • MATLAB数据及其运算

    2020-09-23 11:25:52
    MATLAB数据及其运算 数据特点 最基本、最重要的数据对象:矩阵。 数据类型: 整形:有符号、无符号 浮点型: 复数
  • 复数矩阵的转置、共轭、共轭转置

    千次阅读 2020-03-23 10:18:58
    复数矩阵的转置分【共轭转置】和【点转置】两种,如果不加说明默认指的是【共轭转置】。 在 MATLAB 中,点转置运算、共轭运算和共轭转置运算分别如下所示: ...
  • MATLAB基础2.1 基本概念2.1.1 MATLAB数据类型概述2.1.2 整数类型2.1.3 浮点数类型2.1.4 复数2.1.5 无穷量(Inf)和非数值量(NaN)2.1.6 数值类型的显示格式2.1.7 确定数值类型的函数2.1.8 常量与变量2.1.9 标量、向量、...
  • MATLAB—面向复数和数组的基本运算

    千次阅读 2020-02-28 13:27:44
    文章目录一.MATLAB基本运算说明二.面向复数的计算特点1.基础知识2.对复数的基本操作3.复数的开方问题二.面向数组1....MATLAB面向复数设计,其所有运算都定义在复数域上,所以对于方根运算运算只...
  • PS:主要是讲解矩阵的相应的实现方法,其实... (一)MATLAB矩阵 一、矩阵的建立 1、直接输入法创建: 还可以有复数矩阵的建立,有两种方法: (1)直接按照直接输入法来建立矩阵,但是元素可以直接打成复数的形...
  • 矩阵是MATLAB最基本,最重要的数据类型,MATLAB的大部分运算或命令都是在矩阵运算的意义下执行的,而且这种运算定义在复数域上。向量和单个数据都可以作为矩阵的特例来处理。 数据类型 1.矩阵 2.整型 带符号整数...
  • Matlab符号运算中的矩阵转置 转置向量或矩阵 B = A.' B = transpose(A) 说明 B =A.'返回A的非共轭转置,即每个元素的行和列索引都会互换。如果A包含复数元素,则A.'不会影响虚部符号。例如,如果A(3,2)是1+2i且...
  • logm() %对矩阵求对数 指数区分 exp() %不能写成e^x exp(1) %不能写成e 取整函数 round %四舍五入取整 fix %朝0方向取整 floor %朝-∞方向取整 ceil %朝+∞方向取整 取余函数 mod(-13,5) %结果为3 rem...
  • 数据类型 逻辑型 字符型 数值型 单元数组 结构数组 函数句柄 定制类 int8, uint8 int16, uint16 int32, uint32 Single Double 整数 浮点数 复数 Inf NaN 15种基本数据类型每种基本数据类型均以数组/矩阵的形式出现 ...
  • matlab数组运算

    千次阅读 2015-05-09 21:24:01
    一个个标量数据被组织成矩形或长方形的阵列集合,这就是数组(Array)。而每次调用命令将同时地加在数组所含的每个标量元素 上,构成所谓的数组运算。...MatLab是以复数矩阵作为基本的运算单元,向量和标量都作为特
  • 本文件包括一个库函数cs.cpp和一个头文件cs.h,其中的代码是移植自SuiteSparse官方代码中的Csparse原始代码,功能包括除了复数矩阵以外的所有功能,已成功在vs2010的c++环境下执行过,在毕业设计中用于求解超大型...
  • MATLAB-S3数值运算

    2020-08-21 15:36:36
    数值运算3 向量和矩阵3.1 向量3.1.1 向量的创建和引用3.1.2 向量的运算3.2 矩阵3.2.1 矩阵的创建3.2.2 矩阵的操作函数3.2.3 矩阵元素的引用3.2.4 矩阵的基本运算3.2.5 矩阵的操作函数3.2.5 求解线性方程组3.3 多项式...
  • ##Matlab运算 (1)矩阵求逆 inv (2)求取矩阵行列式值 det (3)提取矩阵对角元素 diag (4)矩阵的转置 ‘ #矩阵的其他操作 1.求矩阵的尺寸 size(A) 2.求绝对值 abs,返回每个元素的绝对值 3. 矩阵每一列的...
  • 矩阵的共轭转置(也叫Hermite转置):代表共轭转置,即转置的同时,对每个复数做共轭处理。在MATLAB中的命令为:C = A’ 矩阵的直接转置:MATLAB中的命令为:C = A.’ 矩阵左除:如果A为非奇异方阵,那么得到的...
  • 思维导图四则运算:(^,*,/,+,-)不会使用的功能和函数通过:help+函数/功能查询。函数嵌套。变量变量不可以以数字开头(2A),但是变数开头可以有数字(A2)。区分大小写。who:查看已有变量;whos:查看已有变量大小...
  • matlab基础----复数表示

    千次阅读 2020-09-28 23:22:15
    matlab计算基础 2.7 复数和复变函数 ...利用两个矩阵分别做实部和虚部构造新的复数矩阵 复数绘图 直角坐标图 极坐标图 t=0:0.05:2*pi; y=t+i*t.*sin(t); r=abs(y); theta=angle(y); subplot(1,2,1);
  • 数值数组(Numeric Array)和数组运算(Array Operation)是Matlab的核心运算 内容 一导言 二一维数组 (向量) 三二维数组矩阵 四高维数组 五MATLAB 的运算符 一导言 1数组的定义 数组是指一组实数或复数排成的长方阵列...

空空如也

空空如也

1 2 3 4 5 6
收藏数 108
精华内容 43
关键字:

matlab复数矩阵运算

matlab 订阅