精华内容
下载资源
问答
  • 第三十篇 雅可比主对角线化求对称矩阵的特征值 对于标准特征值方程 由特征值问题编程基础可知,对于任何非0解矩阵[P],标准方程可以转化为具有相同特征值的方程 其中 这种转换技术的关键核心在于[A *]的特征值比...

    第三十篇 雅可比主对角线化求对称矩阵的特征值

    对于标准特征值方程
    在这里插入图片描述
    特征值问题编程基础可知,对于任何非0解矩阵[P],标准方程可以转化为具有相同特征值的方程
    在这里插入图片描述
    其中
    在这里插入图片描述
    这种转换技术的关键核心在于[A *]的特征值比原始[A]的特征值更容易找到。
    然而,如果[A]是对称的,则变换后的矩阵不太可能保持对称。很容易证明下面变换
    在这里插入图片描述
    将保持[A∗]的对称性。为了使上面方程中给出的特征值[A∗]与[A]的特征值相同,必须把这两个性质综合起来
    在这里插入图片描述
    这种类型的矩阵称为“正交矩阵”,具有这种性质的矩阵称为“旋转矩阵”。
    在这里插入图片描述
    将此变换应用于下面的矩阵,我们有
    在这里插入图片描述
    在这里插入图片描述
    其中很明显[A∗]对于任何α值都是对称的。这种情况,明显可以选择一个α值使得[A∗]成为一个对角矩阵,因为如果这样,对角线就是特征值。下面的情况,非对角线项将被消除
    在这里插入图片描述
    得出,tan α = 1和α = π/4,给出sin α = cos α = 1/√2。
    得到的变换矩阵是
    在这里插入图片描述
    即[A]的特征值分别为3和1。
    对于大于2 × 2的矩阵[A],变换矩阵[P]必须通过在其他主对角线上放1,在所有非对角线上放0来“填充”,被消去的行和列选择上面的矩阵。例如,如果[A]是4 × 4,则变换矩阵可以选择6种形式中的一种,这取决于要消去初始矩阵中的哪些非对角项,例如:
    在这里插入图片描述
    上面第一个矩阵经过[P]T [A][P]变换后将原矩阵[A]中的a12和a21项消去,而第二个矩阵将消去a24和a42项。1和0的作用是让[A]的其他行和列保持不变。这意味着在一次转换中变为零的非对角线项在随后的转换中会恢复为非零值(尽管通常是很“小”的值),因此正如期望的那样,该方法是迭代的。
    这种类型的迭代的最早形式称为“雅可比对角化”,它通过消除每一次迭代剩余的“最大的”非对角项连续进行迭代。
    对于任何对称矩阵[A],得到广义方程为
    在这里插入图片描述
    得到[A∗]形式的非对角线项为
    在这里插入图片描述
    求α使这一项等于零
    在这里插入图片描述
    因此
    在这里插入图片描述
    因此,为了建立一个雅可比对角化的简单程序,必须在[a]中搜索“最大的”非对角线项,并找到它所在的行和列。“旋转矩阵”α按照之前的方法构建。矩阵[P]可以使用一个numpy库的transpose转化,然后矩阵乘积形成方程的[A *]。重复这个过程,直到[A∗]的主对角线在可接受的公差内收敛到[A]的特征值为止。
    计算实例:
    使用雅可比对角化去估算下面对称矩阵的特征值
    在这里插入图片描述
    下面的结果保留到小数点后四位,但实际计算的精确度更高。
    第一次迭代
    最大的非主对角项为a23 = a32 = −9.0,因此根据之前方程
    在这里插入图片描述
    第一次转换矩阵将包含下面的项
    在这里插入图片描述
    因此
    在这里插入图片描述
    通过转化矩阵得到
    在这里插入图片描述
    详细的数值为
    在这里插入图片描述
    最后
    在这里插入图片描述
    第二次迭代
    最大的非主对角项为a12 = a21 = −7.7782,因此
    在这里插入图片描述
    第二次转化矩阵将包括下面的项
    在这里插入图片描述
    因此,
    在这里插入图片描述
    同上面一样,矩阵乘积将等于
    在这里插入图片描述
    可以看到,虽然位置(2,3)和(3,2)不再为零,但与初始矩阵中的值相比足够“小”。随着迭代的进行,旋转角度αk→0,变换矩阵[Pk]→[I]和变换矩阵[Ak]趋向于一个对角矩阵,特征值在对角线上。
    对于这个例子,经过六次迭代,容差为1.0e-5
    得到
    在这里插入图片描述
    因此[A]的特征值λ = 0.4659, 20.9681,−0.9340。特征向量将通过将每个特征值代入求线性方程的解。
    程序如下
    分为一个主程序和两个子程序,分别为判断收敛的子程序checkit,和高斯消元求特征向量的子程序eliminate。详情可参照之前文章的线性方程求解部分
    主程序:

    #雅可比主对角线化求对称矩阵的特征值
    import numpy as np
    import B
    import math
    n=3;tol=1.0e-5;limit=100
    enew=np.zeros((n,1))
    eold=np.zeros((n,1))
    p=np.zeros((n,n))
    a1=np.zeros((n,n))
    a=np.array([[10,5,6],[5,20,4],[6,4,30]],dtype=np.float)
    a2=a
    pi=math.acos(-1)
    x=np.zeros((n,1))
    x=np.ones((3,1),dtype=np.float)
    print('雅可比主对角线化求对称矩阵的特征值')
    print('矩阵A')
    print(a[:])
    print('前几次迭代值')
    iters=0;eold[:]=0
    while(True):
        iters=iters+1
        big=0
        for i in range(1,n+1):
            for j in range(i+1,n+1):
                if abs(a[i-1,j-1]>big):
                    big=abs(a[i-1,j-1]);hold=a[i-1,j-1];nr=i;nc=j
        if abs(big)<1.0e-20:
            break
        den=a[nr-1,nr-1]-a[nc-1,nc-1]
        if abs(den)<1.0e-20:
            alpha=pi/4.0
            if hold<0:
                alpha=-alpha
        else:
            alpha=math.atan(2.0*hold/den)/2.0
        ct=math.cos(alpha);st=math.sin(alpha);p[:]=0
        for i in range(1,n+1):
            p[i-1,i-1]=1.0
        p[nr-1,nr-1]=ct;p[nc-1,nc-1]=ct;p[nr-1,nc-1]=-st;p[nc-1,nr-1]=st
        a=np.dot(np.dot(np.transpose(p),a),p)
        if iters<5:
            for i in range(1,n+1):
                for j in range(1,n+1):
                    print('{:13.4e}'.format(a[i-1,j-1]),end='')
                print(end='\n')
            print(end='\n')
        for i in range(1,n+1):
            enew[i-1,0]=a[i-1,i-1]
        if B.checkit(enew,eold,tol) or iters==limit:
            break
        eold[:,0]=enew[:,0]
    print('迭代到收敛次数',iters)
    print('最后的转化矩阵A')
    for i in range(1,n+1):
        for j in range(1,n+1):
            print('{:13.4e}'.format(a[i-1,j-1]),end='')
        print(end='\n')
    for i in range(1,n+1):
        a1[:]=a2[:]
        for j in range(1,n+1):
            a1[j-1,j-1]=a1[j-1,j-1]-a[i-1,i-1]
        x[:]=0;a1[i-1,i-1]=1.0e20;x[i-1]=1.0e20;x[:]=B.eliminate(a1,x)
        l2=np.linalg.norm(x)
        print('特征值','{:13.4e}'.format(a[i-1,i-1]))
        print('特征向量')
        for i in range(1,n+1):
            print('{:13.4e}'.format(x[i-1,0]/l2),end=' ')
        print()
        
        
    
    
    checkit
    
    def checkit(loads,oldlds,tol):
    #检查多个未知数的收敛
      neq=loads.shape[0]
      big=0.0
      converged=True
      for i in range(1,neq+1):
        if abs(loads[i-1,0])>big:
          big=abs(loads[i-1,0])
      for i in range(1,neq+1):
        if abs(loads[i-1,0]-oldlds[i-1,0])/big>tol:
          converged=False
      checkit=converged
      return  checkit
    
    eliminate
    
    def eliminate(a,b):
      n=a.shape[0]
    ##确定主对角线最大值
      for i in range(1,n):
        big=abs(a[i-1,i-1]);ihold=i
        for j in range(i+1,n+1):
          if abs(a[j-1,i-1])>big:
            big=abs(a[j-1,i-1]); ihold=j
        if ihold!=i:
          for j in range(i,n+1):
            hold=a[i-1,j-1]; a[i-1,j-1]=a[ihold-1,j-1]; a[ihold-1,j-1]=hold
          hold=b[i-1,0]; b[i-1,0]=b[ihold-1,0]; b[ihold-1,0]=hold
    ##消元阶段
        for j in range(i+1,n+1):
          fac=a[j-1,i-1]/a[i-1,i-1]
          for l in range(i,n+1):
            a[j-1,l-1]=a[j-1,l-1]-a[i-1,l-1]*fac
          b[j-1]=b[j-1]-b[i-1]*fac
    ##从后迭代
      for i in range(n,0,-1):
        hold=0.0
        for l in range(i+1,n+1):
          hold=hold+a[i-1,l-1]*b[l-1]
        b[i-1]=(b[i-1]-hold)/a[i-1,i-1]
      return b
    

    终端输出结果如下:
    在这里插入图片描述

    展开全文
  • 我在使用matlabeig函数计算对称矩阵的特征值和特征向量时遇到了一个问题。在矩阵D10x10所有对角线元素=0.45所有非对角线元素=-0.05当使用[vec,val]=eig(D)时,一些得到的特征向量包含复数(即0.3384+0.0052i)。我...

    我在使用matlabeig函数计算对称矩阵的特征值和特征向量时遇到了一个问题。在

    矩阵D是

    10x10

    所有对角线元素=0.45

    所有非对角线元素=-0.05

    当使用[vec,val]=eig(D)时,一些得到的特征向量包含复数(即0.3384+0.0052i)。我在网上搜索过,发现了两篇关于类似问题的相关帖子,但没有帮助我找到解决办法。在

    所以我在pythonnumpy中尝试了相同的子例程(纽比.利纳格.埃(D) )它给了我所有的实特征值和特征向量。Python的结果是正确的,因为我能够用一篇发表的论文来验证我的最终结果。在

    我的问题是什么导致MATLAB给出对称矩阵的复特征值和特征向量?有办法绕过它吗?我当然可以用Python重写我的算法,但我宁愿避免这种情况。在

    注:如果我尝试4x4矩阵,所有对角线元素=0.375,所有非对角线元素=-0.125,那么MATLAB eig(D)给出了所有实特征值和特征向量。在

    提前感谢您对这个问题的任何建议。在

    跟进。用于生成D和特征值/向量的代码:P = eye(10) - 1/10;

    delta = 1 - eye(10);

    A = -0.5 * delta;

    D = P*A*P;

    [vec val] =eig(D)

    展开全文
  • 雅可比方法用于求解实对称矩阵的特征值和特征向量,对于实对称矩阵AAA,必有正交矩阵UUU,使得UTAU=DU^{T}AU=DUTAU=D.DDD一个对角阵,主对角线的元素矩阵AAA的特征值,正交矩阵UUU的每一列对应于属于矩阵DDD的主对角...

    一 算法原理

    雅可比方法用于求解实对称矩阵的特征值和特征向量,对于实对称矩阵AA,必有正交矩阵UU,使得UTAU=DU^{T}AU=D.DD是一个对角阵,主对角线的元素是矩阵AA的特征值,正交矩阵UU的每一列对应于属于矩阵DD的主对角线对应元素的特征向量.
    雅可比方法用平面旋转对矩阵AA做相似变换,化AA为对角阵,从而求解出特征值和特征向量.旋转矩阵UpqU_p{_q},是一个单位阵在第pp行,第pp列,第qq行,第qq列,元素为cosφcos\varphi,第pp行第qq列为sinφ-sin\varphi,第qq行第pp列为sinφsin\varphi.对于这样的平面旋转矩阵,不难验证其是一种正交矩阵.因此对于向量xx,UpqxU_p{_q}x等同于把第pp个坐标轴和第qq个坐标轴共同所确定的平面旋转了φ\varphi度.记矩阵A1=UpqTAUpqA_1=U_p{_q}^{T}AU_p{_q}.因为旋转矩阵是正交阵,因此实际上矩阵A1A_1与矩阵AA是相似的,因此其特征值是相同的.
    设矩阵A1A_1ii行,第jj列的元素为bijb_i{_j},矩阵AA的第ii行,第jj列的元素为aija_i{_j}(i=0,1,2,...,n1,j=0,1,2,...,n1i=0,1,2,...,n-1,j=0,1,2,...,n-1).式(1-1-1)给出了两矩阵元素之间的运算关系.
    {bpp=appcos2φ+aqqsin2φ+2apqcosφsinφbqq=appsin2φ+aqqcos2φ2apqcosφsinφbpq=bqp=12(aqqapp)sin2φ+apqcos2φbpi=apicosφ+aqisinφ,(ip,q)bqi=apisinφ+aqicosφ,(ip,q)bjp=ajpcosφ+ajqsinφ,(jp,q)bjq=ajqsinφ+ajqcosφ,(jp,q)bij=bji=aij,ip,q;jp,q(1-1-1) \begin{cases} b_p{_p}=a_p{_p}cos^2\varphi+a_q{_q}sin^2\varphi+2a_p{_q}cos\varphi{sin\varphi}\\ b_q{_q}=a_p{_p}sin^2\varphi+a_q{_q}cos^2\varphi-2a_p{_q}cos\varphi{sin\varphi}\\ b_p{_q}=b_q{_p}=\frac{1}2(a_q{_q}-a_p{_p})sin2\varphi+a_p{_q}cos2\varphi\\ b_p{_i}=a_p{_i}cos\varphi+a_q{_i}sin\varphi,(i\ne{p},q)\\ b_q{_i}=-a_p{_i}sin\varphi+a_q{_i}cos\varphi,(i\ne{p},q)\\ b_j{_p}=a_j{_p}cos\varphi+a_j{_q}sin\varphi,(j\ne{p},q)\\ b_j{_q}=-a_j{_q}sin\varphi+a_j{_q}cos\varphi,(j\ne{p},q)\\ b_i{_j}=b_j{_i}=a_i{_j},i{\ne}p,q;j{\ne}p,q \end{cases} \tag{1-1-1}
    其中有两点需要说明:(1) pp,qq分别是前一次的迭代矩阵的非主对角线上绝对值最大元素的行列号
    (2)φ\varphi是旋转角度,可以由式(1-1-2)确定
    tan2φ=2apqaqqapp(1-1-2) tan2\varphi=\frac{-2a_p{_q}}{a_q{_q}-a_p{_p}} \tag{1-1-2}
    归纳得到雅可比方法求解矩阵特征值和特征向量的具体步骤如下:
    (1).初始化特征向量为对角阵V,主对角线元素为1,其他元素为0.
    (2).在AA的非主对角线的元素中,找到绝对值最大元素apqa_p{_q}.
    (3).用式(1-1-2)计算出旋转矩阵
    (4).计算矩阵A1A1,用当前的矩阵VV乘旋转矩阵得到当前的特征矩阵VV.
    (5).若当前迭代的矩阵AA的非主对角线元素最大值小于给定阈值,停止计算,否则执行上述过程.停止计算时,特征值为矩阵AA的主对角线元素,特征矩阵为矩阵VV.


    二 C语言实现

    #include<stdio.h>
    #include<stdlib.h>
    float** Matrix_Jac_Eig(float **array, int n, float *eig);
    int Matrix_Free(float **tmp, int m, int n);
    int main(void)
    {
    	int n;
    	printf("请输入矩阵维度:\n");
    	scanf("%d", &n);
    	float **array = (float **)malloc(n * sizeof(float *));
    	if (array == NULL)
    	{
    		printf("error :申请数组内存空间失败\n");
    		return -1;
    	}
    	for (int i = 0; i < n; i++)
    	{
    		array[i] = (float *)malloc(n * sizeof(float));
    		if (array[i] == NULL)
    		{
    			printf("error :申请数组子内存空间失败\n");
    			return -1;
    		}
    	}
    	printf("请输入矩阵元素:\n");
    	for (int i = 0; i < n; i++)
    	{
    		for (int j = 0; j < n; j++)
    		{
    			scanf("%f", &array[i][j]);
    		}
    	}
    	float *eig = (float *)malloc(n * sizeof(float));
    	float **Result = Matrix_Jac_Eig(array, n, eig);
    	printf("特征矩阵元素:\n");
    	for (int i = 0; i < n; i++)
    	{
    		for (int j = 0; j < n; j++)
    		{
    			printf("%f ", Result[i][j]);
    		}
    		printf("\n");
    	}
    	printf("特征矩阵元素:\n");
    	for (int i = 0; i < n; i++)
    	{
    		printf("%f \n", eig[i]);
    	}
    	Matrix_Free(Result, n, n);
    	free(eig);
    	eig = NULL;
    	return 0;
    }
    float** Matrix_Jac_Eig(float **array, int n, float *eig)
    {
    	//先copy一份array在temp_mat中,因为我实在堆区申请的空间,在对其进行处理
    	//的过程中会修改原矩阵的值,因此要存储起来,到最后函数返回的
    	//时候再重新赋值
    	int i, j, flag, k;
    	flag = 0;
    	k = 0;
    	float sum = 0;
    	float **temp_mat = (float **)malloc(n * sizeof(float *));
    	for (i = 0; i < n; i++)
    	{
    		temp_mat[i] = (float *)malloc(n * sizeof(float));
    	}
    	for (i = 0; i < n; i++)
    	{
    		for (j = 0; j < n; j++)
    		{
    			temp_mat[i][j] = array[i][j];
    		}
    	}
    	//判断是否为对称矩阵
    	for (i = 0; i < n; i++)
    	{
    		for (j = i; j < n; j++)
    		{
    			if (array[i][j] != array[j][i])
    			{
    				flag = 1;
    				break;
    			}
    		}
    	}
    	if (flag == 1)
    	{
    		printf("error in Matrix_Eig: 输入并非是对称矩阵:\n");
    		return NULL;
    	}
    	else
    	{
    		//开始执行算法
    		int p, q;
    		float thresh = 0.0000000001;
    		float max = array[0][1];
    		float tan_angle, sin_angle, cos_angle;
    		float **result = (float **)malloc(n * sizeof(float *));
    		if (result == NULL)
    		{
    			printf("error in Matrix_Eig:申请空间失败\n");
    			return NULL;
    		}
    		float **result_temp = (float **)malloc(n * sizeof(float *));
    		if (result_temp == NULL)
    		{
    			printf("error in Matrix_Eig:申请空间失败\n");
    			return NULL;
    		}
    		float **rot = (float **)malloc(n * sizeof(float *));
    		if (rot == NULL)
    		{
    			printf("error in Matrix_Eig:申请空间失败\n");
    			return NULL;
    		}
    		float **mat = (float **)malloc(n * sizeof(float *));
    		if (mat == NULL)
    		{
    			printf("error in Matrix_Eig:申请空间失败\n");
    			return NULL;
    		}
    		for (i = 0; i < n; i++)
    		{
    			result[i] = (float *)malloc(n * sizeof(float));
    			if (result[i] == NULL)
    			{
    				printf("error in Matrix_Eig:申请子空间失败\n");
    				return NULL;
    			}
    			result_temp[i] = (float *)malloc(n * sizeof(float));
    			if (result_temp[i] == NULL)
    			{
    				printf("error in Matrix_Eig:申请子空间失败\n");
    				return NULL;
    			}
    			rot[i] = (float *)malloc(n * sizeof(float));
    			if (rot[i] == NULL)
    			{
    				printf("error in Matrix_Eig:申请子空间失败\n");
    				return NULL;
    			}
    			mat[i] = (float *)malloc(n * sizeof(float));
    			if (mat[i] == NULL)
    			{
    				printf("error in Matrix_Eig:申请子空间失败\n");
    				return NULL;
    			}
    		}
    		for (i = 0; i < n; i++)
    		{
    			for (j = 0; j < n; j++)
    			{
    				if (i == j)
    				{
    					result[i][j] = 1;
    				}
    				else
    				{
    					result[i][j] = 0;
    				}
    			}
    		}
    		for (i = 0; i < n; i++)
    		{
    			for (j = 0; j < n; j++)
    			{
    				if (i == j)
    				{
    					mat[i][j] = 1;
    				}
    				else
    				{
    					mat[i][j] = 0;
    				}
    			}
    		}
    		max = array[0][1];
    		for (i = 0; i < n; i++)
    		{
    			for (j = 0; j < n; j++)
    			{
    				if (i == j)
    				{
    					continue;
    				}
    				else
    				{
    					if (fabs(array[i][j]) >= fabs(max))
    					{
    						max = array[i][j];
    						p = i;
    						q = j;
    					}
    					else
    					{
    						continue;
    					}
    				}
    			}
    		}
    		while (fabs(max) > thresh)
    		{
    			if (fabs(max) < thresh)
    			{
    				break;
    			}
    			tan_angle = -2 * array[p][q] / (array[q][q] - array[p][p]);
    			sin_angle = sin(0.5*atan(tan_angle));
    			cos_angle = cos(0.5*atan(tan_angle));
    			for (i = 0; i < n; i++)
    			{
    				for (j = 0; j < n; j++)
    				{
    
    					if (i == j)
    					{
    						mat[i][j] = 1;
    					}
    					else
    					{
    						mat[i][j] = 0;
    					}
    				}
    			}
    			mat[p][p] = cos_angle;
    			mat[q][q] = cos_angle;
    			mat[q][p] = sin_angle;
    			mat[p][q] = -sin_angle;
    			for (i = 0; i < n; i++)
    			{
    				for (j = 0; j < n; j++)
    				{
    					rot[i][j] = array[i][j];
    				}
    			}
    			for (j = 0; j < n; j++)
    			{
    				rot[p][j] = cos_angle*array[p][j] + sin_angle*array[q][j];
    				rot[q][j] = -sin_angle*array[p][j] + cos_angle*array[q][j];
    				rot[j][p] = cos_angle*array[j][p] + sin_angle*array[j][q];
    				rot[j][q] = -sin_angle*array[j][p] + cos_angle*array[j][q];
    			}
    			rot[p][p] = array[p][p] * cos_angle*cos_angle +
    				array[q][q] * sin_angle*sin_angle +
    				2 * array[p][q] * cos_angle*sin_angle;
    			rot[q][q] = array[q][q] * cos_angle*cos_angle +
    				array[p][p] * sin_angle*sin_angle -
    				2 * array[p][q] * cos_angle*sin_angle;
    			rot[p][q] = 0.5*(array[q][q] - array[p][p]) * 2 * sin_angle*cos_angle +
    				array[p][q] * (2 * cos_angle*cos_angle - 1);
    			rot[q][p] = 0.5*(array[q][q] - array[p][p]) * 2 * sin_angle*cos_angle +
    				array[p][q] * (2 * cos_angle*cos_angle - 1);
    			for (i = 0; i < n; i++)
    			{
    				for (j = 0; j < n; j++)
    				{
    					array[i][j] = rot[i][j];
    				}
    			}
    			max = array[0][1];
    			for (i = 0; i < n; i++)
    			{
    				for (j = 0; j < n; j++)
    				{
    					if (i == j)
    					{
    						continue;
    					}
    					else
    					{
    						if (fabs(array[i][j]) >= fabs(max))
    						{
    							max = array[i][j];
    							p = i;
    							q = j;
    						}
    						else
    						{
    							continue;
    						}
    					}
    				}
    			}
    			for (i = 0; i < n; i++)
    			{
    				eig[i] = array[i][i];
    			}
    			for (i = 0; i < n; i++)
    			{
    				for (j = 0; j < n; j++)
    				{
    					sum = 0;
    					for (k = 0; k < n; k++)
    					{
    						sum = sum + result[i][k] * mat[k][j];
    					}
    					result_temp[i][j] = sum;
    				}
    			}
    			for (i = 0; i < n; i++)
    			{
    				for (j = 0; j < n; j++)
    				{
    					result[i][j] = result_temp[i][j];
    				}
    			}
    		}
    		for (i = 0; i < n; i++)
    		{
    			for (j = 0; j < n; j++)
    			{
    				array[i][j] = temp_mat[i][j];
    			}
    		}
    		Matrix_Free(result_temp, n, n);
    		Matrix_Free(rot, n, n);
    		Matrix_Free(mat, n, n);
    		Matrix_Free(temp_mat, n, n);
    		return result;
    	}
    }
    int Matrix_Free(float **tmp, int m, int n)
    {
    	int i, j;
    	if (tmp == NULL)
    	{
    		return(1);
    	}
    	for (i = 0; i < m; i++)
    	{
    		if (tmp[i] != NULL)
    		{
    			free(tmp[i]);
    			tmp[i] = NULL;
    		}
    	}
    	if (tmp != NULL)
    	{
    		free(tmp);
    		tmp = NULL;
    	}
    	return(0);
    }
    

    三 结果

    在这里插入图片描述

    展开全文
  • 把一个m×n矩阵的行,列互换得到的n×m矩阵,称为A的转置矩阵,记为A’或ATA^TAT。 矩阵转置的运算律(即...由定义知对称矩阵一定方阵,而且位于主对角线对称位置上的元素必对应相等,即aij=ajia_{ij}=a_{ji}aij​...

    把一个m×n矩阵的行,列互换得到的n×m矩阵,称为A的转置矩阵,记为A’或ATA^T
    矩阵转置的运算律(即性质):
    1.(A’)’=A
    2.(A+B)’=A’+B’
    3.(kA)’=kA’(k为实数)
    4.(AB)’=B’A’
    若矩阵A满足条件A=A’,则称A为对称矩阵。由定义知对称矩阵一定是方阵,而且位于主对角线对称位置上的元素必对应相等,即aij=ajia_{ij}=a_{ji}对任意i,j都成立。

    Ae=λeAe=\lambda e
    λ\lambda为特征值,实数或复数。e为特征向量
    实数组成的对称矩阵的特征值全部为实数。
    对称矩阵的特征向量正交。
    如果对称矩阵的所有特征向量长度为1,则为标准对称矩阵,有如下性质:
    EET=IET=E1 EE^T=I\\ E^T=E^{-1}
    逆矩阵等于转置矩阵

    展开全文
  • 一、对称矩阵(Symmetric Matrices)指元素以主对角线为对称轴对应相等的矩阵。 对称矩阵是一个方形矩阵,其转置矩阵和自身相等。 如果有n阶矩阵A,其矩阵的元素都为实数,且矩阵A的转置等于其本身(aij=aji)(i,...
  • 因此基于此,有一些特殊的方法可以快速计算三阶实对称矩阵的特征值和特征向量。 一. 猜根法计算特征值 特征值之和等于矩阵的对角线元素之和 特征值之积等于矩阵的行列式 假设矩阵的特征值都整数 ...
  • 但一般说对角矩阵,考虑方阵情况,对于方阵,那就是只有主对角线元素可以不为0,其它元素都0。 主对角元从左上角到右下角次序常常记为一个列向量: 然后以它们为主对角元对角方阵就可以记为...
  • 今天给大家带来的知识点:矩阵是否相似于对角阵的...(4) A与B的迹相同【注】矩阵A的迹等于A的主对角线元素的和3.矩阵的相似对角化4.矩阵A相似对角化的条件这部分内容在考研中非常重要!!!判断方法如下:(1)判断A...
  • 1. 特征值与特征向量 矩阵作用于向量的特殊情况是它能等价于用一个常数作用于... 对角化 很多情况下A可以做这样的分解D是对角矩阵,这样可以方便求解 。 考虑如果A有n个线性无关的特征向量。 ,其中P由这个n个向量组...
  • 思想:对于实对称矩阵 ,存在正交矩阵 使得 是对角矩阵,对角线元素就是 的特征值, 的第 列就是对应 的特征向量.如何找正交矩阵?以二阶矩阵为例 考虑二次型 希望通过坐标旋转将 变为标准型 .取 那么 .一般地,对于...
  • 雅可比方法用于求解实对称矩阵的特征值和特征向量,对于实对称矩阵AAA,必有正交矩阵UUU,使得UTAU=DU^{T}AU=DUTAU=D.DDD一个对角阵,主对角线的元素矩阵AAA的特征值,正交矩阵UUU的每一列对应于属于矩阵DDD的主对角...
  • 矩阵A、B相似==A、B特征值相同且A、B均可相似标准化(特征对角阵化)——1 矩阵A、B合同==A、B有相同正负惯性指数——2 矩阵A、B均以正交变换进行相似对角化,即A、B均与各自相似标准型合同==A、B与各自对应二次型,...
  • 特征值与奇异值

    2018-10-24 12:32:43
    一、特征值 定义:设A n阶方阵,如果存在λ和n维非零向量V ,使得AV=λV,则称λ为方阵A一个特征,V为特征向量。...对于实对称矩阵,特征向量正交,可以将特征向量如下表示,其中Σ一个对角阵。 ...
  • CX的协方差矩阵,RY的协方差矩阵,二者都一个对称矩阵 协方差矩阵的对角线以外的n维变量各分量之间的相关性的度量,当值为0时表示两个分量无关,即相互独立,此时我们得到的变量具有很好的统计特性,...
  • 对称矩阵(symmetricmatrix\mathrm{symmetric\quad matrix}symmetricmatrix):元素以主对角线为对称轴对应相等矩阵。满足AT=AA^T=AAT=A,对称矩阵是一个方阵。 正交矩阵:满足AAT=EAA^T=EAAT=E或者ATA=EA^TA=EATA...
  • 线性代数(22)——矩阵SVD分解

    千次阅读 2019-06-13 20:02:14
    矩阵SVD分解对称矩阵概念对称矩阵性质正交对角化对称矩阵一定可以被正交对角化如果一个矩阵能够被正交对角化,则它一定对称矩阵谱定理奇异值概念奇异值几何意义 对称矩阵 ...对称矩阵的特征值一定...
  • 矩阵的奇异分解:设 ,若 为实对称矩阵,则存在正交阵 使得 一般的,设 ,有: ,其中 , , 表示为 , 都是正交阵。...矩阵的 分解: 对于非奇异矩阵 的 分解,分解的标准为 是对角线全为 的下三...
  • 上一次我们学习了PCA过程,并且在最后还特意为大家介绍了协方差矩阵...它对称矩阵对角线元素代表某个特征本身方差,其他元素某两个特征之间协方差。因此是对称矩阵特征值分解后,可以得到,不同
  • 有4个途径可以判定该矩阵是否正定矩阵(注意这个矩阵的4个元素中有2个b,这因为正定矩阵是对称矩阵,如果A的次对角线的元素不相等,A就不是对称的,也就没有必要进一步判定是否正定的):所有特征值大于 行列...
  • 一个实对称矩阵一个维向量,则矩阵的一个特征值,而是矩阵的特征值所对应的特征向量。如果这些特征向量线性无关的,即任意一个特征向量都不能被其他的向量的线性组合所表述出来,那么矩阵就可以特征分解,...
  • 方阵,舒尔分解,对称

    千次阅读 2019-03-07 14:47:39
    硕士时候曾经开了一门课叫《矩阵》,当时觉得没啥用。这两年看凸优化方面知识...若 AAA 为实对称矩阵,则 UUU 为一个对角线矩阵,并且 UUU 的对角线上恰恰 AAA 各个特征值。 显然正定矩阵也有上面性质。 ...
  • 正定矩阵

    千次阅读 2017-08-25 11:21:43
    定义:一个nn阶实对称矩阵MM符合正定矩阵的条件当且仅当非零实系数向量zz,都有zTMzz^TMz...2.若A为n阶对称正定矩阵,则存在唯一的主对角线元素都正数的下三角阵LL,使得A=L∗LTL*L^T,此分解式称为 正定矩阵的Chol
  • 矩阵基础知识

    2017-07-17 15:35:00
     矩阵对角线上的元素Aii 2. 矩阵的基本运算  2.1 矩阵的加法  2.2 矩阵的减法  2.3 矩阵的乘法  2.4 矩阵的求逆  2.5 矩阵的转置 3. 矩阵的行列式 det(A) 4. 特征值与特征向量 5. 对称矩阵  A = ...
  • 奇异值分解(SVD)特征值分解奇异值分解奇异值 奇异值分解是特征值分解的一...其中U和V都单位正交阵,U为左奇异矩阵,V为右奇异矩阵,E仅在对角线方向上有值,称为奇异值。 奇异值 奇异值可以被看作成一个矩阵的代表
  • 范数✨对称矩阵:沿对角线对称, ✨正定矩阵:特征值大于零,顺序主子式大于零,且 5️⃣向量范数等价性5️⃣向量序列收敛性定理二、矩阵范数(由向量范数导出矩阵范数)1️⃣矩阵范数定义2️⃣矩阵范数相容性...
  • 正定矩阵(用于SVMMercer定理)

    千次阅读 2014-11-27 10:49:31
    定义:一个n × n的实对称矩阵 M 正定的当且仅当对于所有的非零实系数向量z,都有 zTMz > 0。 正定矩阵判定: 1. 矩阵M的所有的特征值 λi都...因此,M正定阵当且仅当相应的D的对角线上元素都正数。 2. 半双线性
  • 再品协方差矩阵

    2021-02-18 18:01:10
    4维列向量,则协方差矩阵4*4维非负定对称矩阵,主对角线是各个维度数据方差,其余位置对应两个维度协方差。 协方差矩阵不是无缘无故求,一般从推导过程中提取出来,或者用于提取主成分。经典...
  • SVD奇异分解简述

    千次阅读 2020-07-09 19:46:56
    SVD奇异分解简述 BY:YANG LIU 1.什么奇异分解 奇异分解(Singular Value Decomposition)...对称矩阵(Symmetric Matrices)指以主对角线为对称轴,各元素对应相等矩阵。 厄米特矩阵(Hermitian Matrix
  • 线性代数-正定矩阵

    2018-07-30 16:46:00
    1 定义 一个n阶实对称矩阵MM符合正定矩阵的条件当且仅当非零实系数向量zz,都有zTMzzTMz>...若A为n阶对称正定矩阵,则存在唯一的主对角线元素都正数的下三角阵LL,使得A=L∗LTL∗LT,此分解式称为 正定矩阵的...

空空如也

空空如也

1 2 3 4
收藏数 69
精华内容 27
关键字:

对称矩阵的特征值是对角线