精华内容
下载资源
问答
  • 假设 n×nn \times nn×n 矩阵 AAA has nnn 线性无关的特征向量x1,…,xnx_{1}, \ldots, x_{n}x1​,…,xn​ ,将这n个特征向量组成特征向量矩阵 SSS. 那么 S−1ASS^{-1} A SS−1AS 特征值矩 Λ\LambdaΛ。 S−1AS=...

    假设 n×nn \times n 矩阵 AAnn 线性无关的特征向量x1,,xnx_{1}, \ldots, x_{n} ,将这n个特征向量组成特征向量矩阵 SS. 那么 S1ASS^{-1} A S 是特征值矩 Λ\Lambda
    S1AS=Λ=[λ1λn]S^{-1} A S=\Lambda=\left[\begin{array}{lll}\lambda_{1} & \\ & \ddots \\ & & \lambda_{n}\end{array}\right]

    证明:
    AS=A[x1xn]=[λ1x1λnxn]A S=A\left[\begin{array}{lll}x_{1} & \cdots & x_{n}\end{array}\right]=\left[\begin{array}{lll}\lambda_{1} x_{1} & \cdots & \lambda_{n} x_{n}\end{array}\right]

    SΛ=[x1xn][λ1λn]=[λ1x1λnxn]S\Lambda=\left[\begin{array}{lll}x_{1} & \cdots & x_{n}\end{array}\right]\left[\begin{array}{lll}\lambda_{1} & \\ & \ddots \\ & & \lambda_{n}\end{array}\right]=\left[\begin{array}{lll}\lambda_{1} x_{1} & \cdots & \lambda_{n} x_{n}\end{array}\right]

    因此 AS=SΛAS=S\Lambda,即 S1AS=ΛS^{-1} A S=\Lambda

    附:矩阵(方阵)能完全对角化的条件是n个线性无关的特征向量。若矩阵有n个完全不同的特征值,则一定可以对角化。

    展开全文
  • 对角矩阵:M一个对角矩阵,当且仅当i!=l时,M(i,j)=0 三对角矩阵:M一个三对角矩阵,当且仅当|i-j|>1时,M(i,j)=0 下三角矩阵:M一个下三角矩阵,当且仅当i<j时,M(i,j)=0 上三角矩阵:M一个上...

    一、特殊矩阵(方阵)

    • 方阵:是指行数与列数相同的矩阵
    • 一些常用的特殊方阵如下:
      • 对角矩阵:M是一个对角矩阵,当且仅当i!=l时,M(i,j)=0
      • 三对角矩阵:M是一个三对角矩阵,当且仅当|i-j|>1时,M(i,j)=0
      • 下三角矩阵:M是一个下三角矩阵,当且仅当i<j时,M(i,j)=0
      • 上三角矩阵:M是一个上三角矩阵,当且仅当i>j时,M(i,j)=0
      • 对称矩阵:M是一个对称矩阵,当且仅当对于所有的j和j,M(i,j)=M(j,i)

    二、特殊矩阵(方阵)在实际中的应用

    应用①

    • 佛罗里达州的6个城市Gainsville、Jacksonville、Miami、Orlando、Tallaha-ssee和Tampa
    • 按照这个顺序,依次从1~6编号。任意两个城市之间的距离用一个6*6的矩阵distance表示。矩阵的第i行和第i列代表第i个城市。distance(i,j)代表城市i和城市j之间的距离
    • 下图给出了相应的矩阵,因为对于所有的i和j有distance(i,j)=distance(j,i),所以这是一个对称矩阵

    应用②

    三、对角矩阵

    • 对角矩阵:M是一个对角矩阵,当且仅当i!=l时,M(i,j)=0

    编码实现:

    • 一个rows*rows的对角矩阵D可以表示为一个二维数组element[rows][rows],其中element[i-1][j-1]=D(i,i)。这种表示法需要rows*rows个类型为T的数据空间
    • 然后对角矩阵最多只有rows个非0元素,因此可以用一位数组element[rows]来表示,其中element[i-1]=D(i,i),所有未在一维数组中出现的矩阵元素均为0

    异常类定义

    class illegalParameterValue
    {
    	string message;
    public:
    	illegalParameterValue(const char *theMessage ="Illegal Parameter Value"):message(theMessage) {}
    	const char *what() {
    		return message.c_str();
    	}
    };
    
    class matrixIndexOutOfBounds
    {
    public:
    	matrixIndexOutOfBounds(string theMessage = "Matrix index out of bounds") :message(theMessage){}
    	const char *what() {
    		return message.c_str();
    	}
    private:
    	string message;
    };

    类定义

    template<typename T>
    class diagonalMatrix
    {
    public:
    	diagonalMatrix(int theN = 10);
    	~diagonalMatrix();
    	void set(int i, int j, T value);
    	T get(int i, int j)const;
    	void output(ostream& out) const;
    private:
    	T *element;  //存放矩阵的数组
    	int n;  //矩阵维度
    };

    类成员实现

    • 构造函数时间复杂度:当T时内部数据类型时为O(1),当T为用户定义类型时为O(rows)
    • get、set的时间复杂度:Θ(1)
    template<typename T>
    diagonalMatrix<T>::diagonalMatrix(int theN = 10)
    {
    	if (theN < 1) {
    		throw illegalParameterValue("Parameter mu be >=1");
    	}
    
    	element = new T[theN];
    	n = theN;
    }
    
    template<typename T>
    diagonalMatrix<T>::~diagonalMatrix()
    {
    	if (element) {
    		delete[] element;
    		element = nullptr;
    	}
    }
    
    template<typename T>
    void diagonalMatrix<T>::set(int i, int j, T value)
    {
    	if ((i<1) || (j<1) || (i>n) || (j>n)) {
    		throw matrixIndexOutOfBounds();
    	}
    
    	if (i == j) {
    		element[i] = value;
    	}
    	else {
    		if (value != 0) {
    			throw illegalParameterValue("nondiagonal elements must be zero");
    		}
    	}
    }
    
    template<typename T>
    T diagonalMatrix<T>::get(int i, int j)const
    {
    	if ((i<1) || (j<1) || (i>n) || (j>n)) {
    		throw matrixIndexOutOfBounds();
    	}
    
    	if (i == j)
    		return element[i];
    	else
    		return 0;
    }
    
    template<typename T>
    void diagonalMatrix<T>::output(ostream& out) const
    {
    	for (int i = 1; i <= n; ++i) {
    		for (int j = 1; j <= n; j++) {
    			if (i == j) {
    				out << element[i]<<" ";
    				continue;
    			}
    			out << "0 ";
    		}
    		out << endl;
    	}
    }

    演示案例

    int main()
    {
    	diagonalMatrix<int> *matrix = new diagonalMatrix<int>(3);
    
    	matrix->set(1,1,1);
    	matrix->set(2, 2, 2);
    	matrix->set(3, 3, 3);
    
    	cout << "matrix[1,1]="<< matrix->get(1, 1) <<endl;
    	cout << "matrix[2,2]=" << matrix->get(2, 2) << endl;
    	cout << "matrix[3,3]=" << matrix->get(3, 3) << endl;
    
    	matrix->output(cout);
    
    	return 0;
    }

    四、三对角矩阵

    • 三对角矩阵:M是一个三对角矩阵,当且仅当|i-j|>1时,M(i,j)=0

    • 非0元素排列在如下三条对角线上:
      • ①主对角线:i=j
      • ②主对角线之下的对角线(称为低对角线):i=j+1
      • ③主对角线之上的对角线(称为高对角线):i=j-1

    编码实现:

    • 三条对角线上的元素总数为3*rows-2。可以用一个容量3*rows-2的一维数组element来描述三对角矩阵
    • 以下图这个三对角矩阵为例:
      • 如果逐行映射:则element[0-9]={2,1,3,1,3,5,7,9,0}
      • 如果逐列映射:则element[0-9]={2,3,1,1,5,3,2,9,7,0}
      • 如果从低对角线开始逐条对角线映射:则element[0-9]={3,5,9,2,1,2,0,1,3,7}

    • 每一种映射方式,get和set方法的代码都不同,下面我们假设为逐条对角线映射

    异常类定义

    class illegalParameterValue
    {
    	string message;
    public:
    	illegalParameterValue(const char *theMessage ="Illegal Parameter Value"):message(theMessage) {}
    	const char *what() {
    		return message.c_str();
    	}
    };
    
    class matrixIndexOutOfBounds
    {
    public:
    	matrixIndexOutOfBounds(string theMessage = "Matrix index out of bounds") :message(theMessage){}
    	const char *what() {
    		return message.c_str();
    	}
    private:
    	string message;
    };

    类定义 

    template<typename T>
    class tridiagonalMatrix
    {
    public:
    	tridiagonalMatrix(int theN = 10);
    	~tridiagonalMatrix();
    	T get(int i,int j)const;
    	void set(int i, int j, T value);
    	void output(ostream& out) const;
    private:
    	T *element;  //存放矩阵的数组
    	int n; //矩阵维数
    };

    类成员实现

    template<typename T>
    tridiagonalMatrix<T>::tridiagonalMatrix(int theN = 10)
    {
    	if (theN < 1) {
    		throw illegalParameterValue("Parameter mu be >=1");
    	}
    
    	element = new T[3*theN-2];
    	n = theN;
    }
    
    template<typename T>
    tridiagonalMatrix<T>::~tridiagonalMatrix()
    {
    	if (element) {
    		delete[] element;
    		element = nullptr;
    	}
    }
    
    template<typename T>
     T tridiagonalMatrix<T>::get(int i, int j)const
    {
    	if ((i<1) || (j<1) || (i>n) || (j>n)) {
    		throw matrixIndexOutOfBounds();
    	}
    
    	switch (i-j)
    	{
    	case 1: //下对角线
    		return element[i - 2];
    	case 0: //主对角线
    		return element[n + i - 2];
    	case -1: //上对角线
    		return element[2 * n + i - 2];
    	default:
    		return 0;
    	}
    }
    
    template<typename T>
    void tridiagonalMatrix<T>::set(int i, int j, T value)
    {
    	if ((i<1) || (j<1) || (i>n) || (j>n)) {
    		throw matrixIndexOutOfBounds();
    	}
    
    	switch(i - j)
    	{
    	case 1: //下对角线
    		element[i - 2] = value;
    		break;
    	case 0: //主对角线
    		element[n + i - 2] = value;
    		break;
    	case -1: //上对角线
    		element[2 * n + i - 2] = value;
    		break;
    	default:
    		if (value != 0) {
    			throw illegalParameterValue("nondiagonal elements must be zero");
    		}
    		break;
    	}
    }
    
    template<typename T>
    void tridiagonalMatrix<T>::output(ostream& out) const
    {
    	for (int i = 1; i <= n; i++) {
    		for (int j = 1; j <= n; j++) {
    			switch (i - j)
    			{
    			case 1: //下对角线
    				out << element[i - 2] << " ";
    				continue;
    			case 0: //主对角线
    				out << element[n + i - 2] << " ";
    				continue;
    			case -1: //上对角线
    				out << element[2 * n + i - 2]<<" ";
    				continue;
    			default:
    				out << "0 ";
    				continue;
    			}
    		}
    		out << endl;
    	}
    }

    演示效果

    int main()
    {
    	tridiagonalMatrix<int> *matrix = new tridiagonalMatrix<int>(4);
    	matrix->set(1, 1, 2);
    	matrix->set(1, 2, 1);
    	matrix->set(2, 1, 3);
    	matrix->set(2, 2, 1);
    	matrix->set(2, 3, 3);
    	matrix->set(3, 2, 5);
    	matrix->set(3, 3, 2);
    	matrix->set(3, 4, 7);
    	matrix->set(4, 3, 9);
    	matrix->set(4, 4, 0);
    
    	matrix->output(cout);
    	return 0;
    }

    五、三角矩阵

    • 下三角矩阵:M是一个下三角矩阵,当且仅当i<j时,M(i,j)=0
    • 上三角矩阵:M是一个上三角矩阵,当且仅当i>j时,M(i,j)=0

    编码实现:

    • 在一个n行的下三角矩阵中(见下图),非0区域的第一行有1个元素,第二行有2个元素,......,第n行有n个元素
    • 在一个n行的上三角矩阵中(见下图),非0区域的第一行有n个元素,第二行有n-1个元素,......,第n行有1个元素

    • 总结:下三角矩阵或上三角矩阵中非0区域共有非0元素:n(n+1)/2。一个三角矩阵可以用一个大小为n(n+1)/2的一维数组来表示
    • 以下面的下三角矩阵为例:
      • 按行映射:element[0-9]={2,5,1,0,3,1,4,2,7,0}
      • 按列映射:element[0-9]={2,5,0,4,1,3,2,1,7,0}

    • 下三角矩阵的元素L(i,j):
      • 如果i<j,则L(i,j)=0
      • 如果i>=j,则L(i,j)位于非0区域。如果按行映射,在元素L(i,j)(i>=j)之前分别有个元素位于第1行至第i-1行的非0区域和j-1个元素位于第i行的非0区域拒,共有

    异常类定义

    class illegalParameterValue
    {
    	string message;
    public:
    	illegalParameterValue(const char *theMessage ="Illegal Parameter Value"):message(theMessage) {}
    	const char *what() {
    		return message.c_str();
    	}
    };
    
    class matrixIndexOutOfBounds
    {
    public:
    	matrixIndexOutOfBounds(string theMessage = "Matrix index out of bounds") :message(theMessage){}
    	const char *what() {
    		return message.c_str();
    	}
    private:
    	string message;
    };

    类定义 

    template<typename T>
    class lowerTriangularMatrix
    {
    public:
    	lowerTriangularMatrix(int theN = 10);
    	~lowerTriangularMatrix();
    	void set(int i, int j, T value);
    	T get(int i, int j)const;
    	void output(ostream& out) const;
    private:
    	T *element;  //存放矩阵的数组
    	int n;  //矩阵维度
    };

    类成员实现

    template<typename T>
    lowerTriangularMatrix<T>::lowerTriangularMatrix(int theN = 10)
    {
    	if (theN < 1) {
    		throw illegalParameterValue("Parameter mu be >=1");
    	}
    
    	element = new T[theN*(theN + 1) / 2];
    	n = theN;
    }
    
    template<typename T>
    lowerTriangularMatrix<T>::~lowerTriangularMatrix()
    {
    	if (element) {
    		delete[] element;
    		element = nullptr;
    	}
    }
    
    template<typename T>
    void lowerTriangularMatrix<T>::set(int i, int j, T value)
    {
    	if ((i<1) || (j<1) || (i>n) || (j>n)) {
    		throw matrixIndexOutOfBounds();
    	}
    
    	if (i >= j) {
    		element[i*(i - 1) / 2 + j - 1] = value;
    	}
    	else {
    		if (value != 0) {
    			throw illegalParameterValue("nondiagonal elements must be zero");
    		}
    	}
    }
    
    template<typename T>
    T lowerTriangularMatrix<T>::get(int i, int j)const
    {
    	if ((i<1) || (j<1) || (i>n) || (j>n)) {
    		throw matrixIndexOutOfBounds();
    	}
    
    	if (i >= j)
    		return element[i*(i - 1) / 2 + j - 1];
    	else
    		return 0;
    }
    
    template<typename T>
    void lowerTriangularMatrix<T>::output(ostream& out) const
    {
    	for (int i = 1; i <= n; ++i) {
    		for (int j = 1; j <= n; j++) {
    			if (i >= j) {
    				out << element[i*(i - 1) / 2 + j - 1] << " ";
    				continue;
    			}
    			out << "0 ";
    		}
    		out << endl;
    	}
    }

    演示效果

    int main()
    {
    	lowerTriangularMatrix<int> *matrix = new lowerTriangularMatrix<int>(4);
    	matrix->set(1, 1, 2);
    	matrix->set(2, 1, 5);
    	matrix->set(2, 2, 1);
    	matrix->set(3, 1, 0);
    	matrix->set(3, 2, 3);
    	matrix->set(3, 3, 1);
    	matrix->set(4, 1, 4);
    	matrix->set(4, 2, 2);
    	matrix->set(4, 3, 7);
    	matrix->set(4, 4, 0);
    
    	matrix->output(cout);
    
    	return 0;
    }

    六、对称矩阵

    • 对称矩阵:M是一个对称矩阵,当且仅当对于所有的j和j,M(i,j)=M(j,i)

    • 编码实现:一个n*n的对称矩阵,可以视为下三角或上三角矩阵,用三角矩阵的表示方法,用一个大小为n(n+1)/2的一维数组来表示。未存储的元素可以用存储的元素来计算

    七、总结

    展开全文
  • 对角矩阵的压缩存储

    千次阅读 2020-03-31 16:29:29
    对角矩阵的压缩存储什么是对角矩阵矩阵的压缩1,当带宽b=1时2,当b不等于1.且b小于n/2 什么是对角矩阵 定义 若一个n阶方阵A满足其所有非零元素都集中在以主对角为中心的带状区域中,则称其为n阶对角矩阵(diagonal ...

    什么是对角矩阵

    1. 定义
      若一个n阶方阵A满足其所有非零元素都集中在以主对角为中心的带状区域中,则称其为n阶对角矩阵(diagonal matrix)。

    2. 图片解释
      在这里插入图片描述

    矩阵的压缩

    1,当带宽b=1时

    只有一条带子,像上面那个图一样,第一行(列)最后一行(列)都只有两个元素,
    按照存储 也就是一行一行的存储

    a[i][j]=2+(i-1)*3+(j-(i-b))
    a[i][j]=2i+j
    

    2,当b不等于1.且b小于n/2

    • 行排序
      a[i][j]=1+b+(i-1)*(b+2)+ (j-(i-b))=k
    • 列排序
      a[i][j]=1+b+(j-1)*(b+2)+(i-(j-b))=k
    展开全文
  • 特殊矩阵——三对角矩阵(Tridiagonal Matrix)

    万次阅读 多人点赞 2016-06-27 13:06:31
    对角矩阵是一种特殊的上Hessenberg矩阵(这个就是上三角矩阵加上下三角部分的第一条次对角线有元素,其他都为0元素)。 2. 三对角矩阵的特性 设一个n*n的方阵A,对于矩阵A中的任一元素aij,当|i-j|>1时,有aij=0...

    特殊矩阵——三对角矩阵(Tridiagonal Matrix)

    注:压缩存储的矩阵可以分为特殊矩阵和稀疏矩阵。对于那些具有相同元素或零元素在矩阵中分布具有一定规律的矩阵,被称之为特殊矩阵。对于那些零元素数据远远多于非零元素数目,并且非零元素的分布没有规律的矩阵称之为稀疏矩阵。

    1. 三对角矩阵的概念

    • 三对角矩阵就是对角线、邻近对角线的上下次对角线上有元素,其他位置均为0的矩阵。
    • 三对角矩阵是一种特殊的上Hessenberg矩阵(这个就是上三角矩阵加上下三角部分的第一条次对角线有元素,其他都为0元素)。

    2. 三对角矩阵的特性

    • 设一个n*n的方阵A,对于矩阵A中的任一元素aij,当|i-j|>1时,有aij=0(0in10jn1)时,矩阵A为三对角矩阵。
    • 三对角矩阵中除主对角线及在主对角线上下最邻近的两条对角线上的元素外,所有其他元素均为0。

    3. 三对角矩阵的压缩存储

    • 可以利用三对角矩阵的上述特性,只存储主对角线及其上、下两侧次对角线上的元素,其他的零元素一律不存储。对一个n*n的三对角方阵A,元素总数有n2个,而其中非零的元素共有3*n-2个。因此,存储三对角矩阵时最多只需存储3*n-2个元素。
      这里写图片描述
    • 可以仿照对称矩阵的压缩存储,可用一维数组B存储三对角矩阵A(这要区分两种存储方式:行优先方式和列优先方式)。
      (1)行优先方式存储
      这里写图片描述
      (2)列优先方式存储
      这里写图片描述

    4. 三对角矩阵的实现

    • 文件:TridiagonalMatrix.h

      
      #include <iostream>
      
      
      using namespace std;
      
      //压缩存储后,存储对称方阵时最多只需存储n*(n+1)/2个元素
      
      #define GetTotalLen(n) 3 * n - 2                
      
      
      //按行优先方式存放三对角矩阵,矩阵元素下标对应的一维数组的下标
      
      #define GetIndexRow(i, j) 2 * i + j 
      
      
      //按列优先方式存放三对角矩阵,矩阵元素下标对应的一维数组的下标
      
      #define GetIndexCol(i, j) 2 * j + i
      
      
      
      class TridiagonalMatrix
      {
      public:
          TridiagonalMatrix(int order);
      
          ~TridiagonalMatrix();
      
      public:
          void create();                      //创建矩阵
      
          void destroy();                     //销毁矩阵
      
          void transpos();                    //矩阵转置
      
          int get_order();                    //获取矩阵阶数
      
          int* compressed_storage_row();      //压缩存储特殊矩阵——三对角矩阵,按行优先方式存放
      
          int* compressed_storage_col();      //压缩存储特殊矩阵——三对角矩阵,按列优先方式存放
      
          bool is_tridiagonal();              //判断矩阵是否为三对角矩阵
      
      public:
          friend ostream& operator<<(ostream& os, TridiagonalMatrix& m);    //输出矩阵
      
      private:
          int _order;
          int **_matrix;
      };
    • 文件:TridiagonalMatrix.cpp

      
      #include "TridiagonalMatrix.h"
      
      
      #include <math.h>
      
      
      TridiagonalMatrix::TridiagonalMatrix(int order)
      : _order(order), _matrix(new int*[order])
      {
          create();
      }
      
      TridiagonalMatrix::~TridiagonalMatrix()
      {
          destroy();
      }
      
      void TridiagonalMatrix::create()
      {
          for (int i = 0; i < _order; i++)
          {
              _matrix[i] = new int[_order];
              for (int j = 0; j < _order; j++)
              {
                  if (abs(i-j) > 1)
                  {
                      _matrix[i][j] = 0;
                  }
                  else
                  {
                      _matrix[i][j] = 1;
                  }
              }
          }
      }
      
      void TridiagonalMatrix::destroy()
      {
          for (int i = 0; i < _order; i++)
          {
              delete[] _matrix[i];
          }
          delete[] _matrix;
          _matrix = NULL;
      }
      
      void TridiagonalMatrix::transpos()
      {
          int temp = 0;
          for (int i = 0; i < _order; i++)
          {
              for (int j = 0; j < _order; j++)
              {
                  temp = _matrix[i][j];
                  _matrix[i][j] = _matrix[j][i];
                  _matrix[j][i] = temp;
              }
          }
      }
      
      
      int TridiagonalMatrix::get_order()
      {
          return _order;
      }
      
      int* TridiagonalMatrix::compressed_storage_row()
      {
          int index = 0;
          int total_count = GetTotalLen(_order);
          int *a = new int[total_count];
          for (int i = 0; i < _order; i++)
          {
              for (int j = 0; j < _order; j++)
              {
                  if (abs(i-j) <= 1)
                  {
                      index = GetIndexRow(i, j);
                      a[index] = _matrix[i][j];
                  }
              }   
          }
          return a;
      }
      
      int* TridiagonalMatrix::compressed_storage_col()
      {
          int index = 0;
          int total_count = GetTotalLen(_order);
          int *a = new int[total_count];
          for (int j = 0; j < _order; j++)
          {
              for (int i = 0; i < _order; i++)
              {
                  if (abs(i - j) <= 1)
                  {
                      index = GetIndexCol(i, j);
                      a[index] = _matrix[i][j];
                  }
              }
          }
          return a;
      }
      
      bool TridiagonalMatrix::is_tridiagonal()
      {
          for (int i = 0; i < _order; i++)
          {
              for (int j = 0; j < _order; j++)
              {
                  if ((abs(i-j) > 1) && (_matrix[i][j] != 0))
                  {
                      return false;
                  }
              }
          }
          return true;
      }
      
      ostream& operator<<(ostream& os, TridiagonalMatrix& m)
      {
          os << "三对角矩阵:" << endl;
          for (int i = 0; i < m._order; i++)
          {
              for (int j = 0; j < m._order; j++)
              {
                  os << m._matrix[i][j] << " ";
              }
              os << endl;
          }
          return os;
      }
    • 文件:main.cpp

      
      #include "TridiagonalMatrix.h"
      
      
      int main()
      {
          int n = 0;
          cout << "请输入三对角矩阵的阶数,n = ";
          cin >> n;
      
          TridiagonalMatrix matrix(n);
          if (true == matrix.is_tridiagonal())
          {
              cout << "$ 输出三对角矩阵:" << endl;
              cout << matrix;//或operator<<(cout, matrix);
          }
      
          matrix.transpos();
          if (true == matrix.is_tridiagonal())
          {
              cout << "$ 输出转置后的三对角矩阵:" << endl;
              cout << matrix;//或operator<<(cout, matrix);
          }
      
          cout << "\n$ 输出压缩存储后的一维数组(按行优先方式存放):" << endl;
          int *arrayr = matrix.compressed_storage_row();
          for (int i = 0; i < GetTotalLen(matrix.get_order()); i++)
          {
              cout << arrayr[i] << " ";
          }
          cout << endl;
          delete[] arrayr;
      
          cout << "\n$ 输出压缩存储后的一维数组(按列优先方式存放):" << endl;
          int *arrayc = matrix.compressed_storage_col();
          for (int i = 0; i < GetTotalLen(matrix.get_order()); i++)
          {
              cout << arrayc[i] << " ";
          }
          cout << endl;
          delete[] arrayc;
      
          system("pause");
          return 0;
      }

    参考文献:
    [1]《数据结构(用面向对象方法与C++语言描述)(第2版)》殷人昆——第四章
    [2] 百度搜索关键字:三对角线矩阵、多对角线矩阵

    展开全文
  • 引入对角矩阵 D ==> 综上 A = L * D * U 举例 A 执行高斯消元法 ==> L 矩阵 ==> 由于,第二行没有主元,交换两行 ==> 交换过后 ==> L矩阵需要引入新的矩阵 ==> 综上 A ==
  • 但一般说对角矩阵,考虑的都是方阵的情况,对于方阵,那就是只有主对角线上的元素可以不为0,其它元素都是0。 主对角元从左上角到右下角的次序常常记为一个列向量: 然后以它们为主对角元的对角方阵就可以记为...
  • 如果一个方阵 相似于对角矩阵,也就是说存在一个可逆矩阵 使得 是对角矩阵,则就被称为可以相似对角化的。下面,我们就通过矩阵的相似对角化:来简单从数学角度解释下面几个问题:为什么要进行矩阵的相似对角化?...
  • 矩阵矩阵就是所有元素都0的矩阵,一般记做O。可以在后面加 m,n表示其规模。 在前一章,我们讲到,矩阵就是映射。零矩阵,就表示了将所有的点都映到原点的映射...在一个方阵中,如果从左上到右下的对角元素...
  • 对角矩阵是指除主对角线和其相邻的上下两条对角线之外,其他所有元素都为0的矩阵。 本次实验给定一个三对角矩阵A和右端矩阵B,求解矩阵方程AX=B。 可以认为B=[b1,b2,...,bn]为一些列向量的组合,从而解出的矩阵X...
  • numpy.eye() 生成对角矩阵

    千次阅读 2017-12-14 17:33:22
    numpy.eye() 生成对角矩阵 转载 2017年02月23日 23:57:22 标签: 3012 编辑 删除 numpy.eye(N,M=None, k=0, dtype=) 关注第一个第三个参数就行了 第一个参数:输出方阵(行数=列数...
  • 矩阵

    2019-11-08 17:19:52
    对角矩阵是方阵矩阵,单位矩阵是对角矩阵 n×1矩阵,列向量 1×n 矩阵, 行向量 矩阵的转置,沿着对角线翻折,行变成列,列变成行 行向量的转置是列向量,列向量的转置是行向量 对角矩阵的转置等于本身 的转置= ...
  • 对角分块矩阵

    2020-05-14 16:33:55
    这个词我自己发明的,就是形如 或 的矩阵,其中A,B分别为m和n阶方程 1.求逆矩阵 的逆矩阵为 的逆矩阵为 2.求值 通过拉普拉斯展开式求 *代表任何方阵,包括0矩阵
  • / 例5.9 已知一个66的矩阵方阵),把矩阵二条对角线上的元素值加上10,然后输出这个新矩阵。【分析】 矩阵即表格,一个二维数组,有6行6列共36个元素,每个矩阵都有二条对角线,本题难点在于对角线的元素怎么...
  • 3、建立块对角矩阵 导入库 import numpy as np 1、LU分解 LU分解,矩阵分解的一种,将系数矩阵A转为等价的两个矩阵L、U的乘积,L为单位下三角,U为上三角,高斯消元法的一种表达式。 在线性代数中已经证明,如果...
  • 第三个参数:默认情况下输出的是对角线全“1”,其余全“0”的方阵,如果k为正整数,则在右上方第k条对角线全“1”其余全“0”,k为负整数则在左下方第k条对角线全“1”其余全“0”。 &gt;&gt;&...
  • matlab方阵对角线清零

    2021-01-08 14:54:53
    邻接矩阵对角线表示自己跟自己的距离,众所周知其为0,对该临街矩阵进行操作,一不小心除一下,对角线就变成Inf了,如何重新将对角线置零呢? 假设A方阵: A(logical(eye(size(A))))=0 相当于取A的大小,做一...
  • python矩阵对角元操作

    2020-04-05 22:00:26
    对于矩阵对角元进行操作在进行矩阵操作前经常进行的一步,比如使矩阵可逆等。可以使用.flat对矩阵对角元进行快速的操作。 X2.flat[::X.shape[1] + 1] += 0.01 以上矩阵,X2为一个方阵,将矩阵进行拉伸之后,再...
  • 矩阵对角化的充要条件及证明

    万次阅读 2018-08-04 22:37:04
    对角化:若方阵A相似于对角矩阵,即存在可逆矩阵P和对角矩阵D,有,则称A可对角化。 可对角化的充要条件: n*n阶矩阵A可对角化的充分必要条件矩阵A有n个线性无关的特征向量。 充分性证明: 设A的n个线性无关的...
  • 判断上三角矩阵 上三角矩阵指主对角线以下的元素都为0的矩阵;主对角线为从矩阵的左上角至右下角的连线。 本题要求编写程序,判断一个给定的方阵是否上三角矩阵。...如果输入的矩阵是上三角矩阵...
  • 本文为原创,如有错误疏漏,烦请指出。...一、方阵的特征值和特征向量 , ...首先寻找特征值,通过求解A的行列式 , ,一共 个特征值【注意矩阵的行列式 个标量,个关于变量 的n次多项式】。多项式 的根有r个,其...
  • 矩阵对角化的条件

    2020-05-29 21:04:36
    总结:对于任意方阵,如果没有重根,矩阵总是可以对角化。麻烦的重根问题 如果有重根,那么需要验证所谓几何重数,与代数重数相等。 那么对于有重根,不能对角化的矩阵怎么办?这就引入了Jordan标准型的故事。 ...
  • 如果一个方阵有n个线性无关的特征向量,那么就可以对角化,去相似,去拟合 在这里插入图片描述 ...B的对角矩阵,就是对角元素时特征值: 等式两边同时乘以P的逆,就是上图那个式子: 例子: ...
  • 相似矩阵和相似对角

    千次阅读 2018-05-24 19:34:48
    对称矩阵对角化(方阵) 对称矩阵的一些性质: 1:对称矩阵的特征值为实数 2:设λ1λ1\lambda_1和λ2λ2\lambda_2对称矩阵AAA的两个特征值,p1p1\mathbf{p}_1,p2p2\mathbf{p}_2对应的特征向量,若λ1≠λ2...
  • 盖尔金圆定理(Gersghorin Circle Thorem)盖尔金圆定理(Gersghorin Circle Thorem)线性代数中一个有趣而实用的定理,可以用它来描述矩阵的特征值。首先我们先来看一下盖尔金圆定理。(盖尔金圆定理)对于任意的$n$阶...
  • 1、X = diag(v,k)当v一个含有n个元素的向量时,返回一个n+abs(k)阶方阵X,向量v在矩阵X中的第k个对角线上,k=0表示主对角线,k>0表示在主对角线上方,k v=[1 2 3]; diag(v, 3) ans =  0 0 0 1 0
  • /* 问题B:上三角矩阵判断...“NO”(上三角矩阵即主对角线以下的元素都为0的矩阵,主对角线为从矩阵的左上角至右下角的连线)。 输入 3 1 2 3 0 1 2 0 0 1 输出 YES */ #include <stdio.h> #include <str...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 943
精华内容 377
关键字:

对角矩阵是方阵