精华内容
下载资源
问答
  • 对称矩阵:设一个N*N的方阵A,A中任意元素Aij,当且仅当Aij == Aji(0 <= i <= N-1 &&0 <= j <= N-1),则矩阵A是对称矩阵。以矩阵的对角线为分隔,分为上三角和下三角。如下面矩阵:对称矩阵压缩...

    对称矩阵:

    设一个N*N的方阵A,A中任意元素Aij,当且仅当Aij == Aji(0 <= i <= N-1 && 0 <= j <= N-1),则矩阵A是对称矩阵。以矩阵的对角线为分隔,分为上三角和下三角。

    如下面矩阵:

    spacer.gif

    7a30f31df5f53933684218c77dee0b64.png

    spacer.gif对称矩阵压缩存储时只需要存储i*(i+1)/2个数据。

    对称矩阵与压缩矩阵的关系是:

    对称矩阵SymmetricMatrix[i][j] =压缩矩阵Array(i*(i+1)/2+j)。

    spacer.gif下面我实现一下对称矩阵存储在压缩矩阵以及将压缩矩阵中的元素还原成对称矩阵打印出来的代码。

    代码如下:#include

    using namespace std;

    template

    class SymmtrixMatrix

    {

    public:

    SymmtrixMatrix(T* a, size_t size)

    :_a(new T[size*(size+1)/2])

    , _size(size*(size + 1) / 2)

    {

    for (int i = 0; i 

    {

    for (int j = 0; j 

    {

    if (i >= j)

    {

    //将对称矩阵转换为压缩矩阵

    _a[i*(i + 1) / 2+j] = a[i*size+j];

    }

    }

    }

    }

    //压缩矩阵的访问打印

    void Print(size_t size)

    {

    for (int i = 0; i 

    {

    for (int j = 0; j 

    {

    int row = i;

    int col = j;

    if (row 

    {

    swap(row, col);

    }

    cout <

    }

    cout <

    }

    cout <

    }

    private:

    T* _a;

    size_t _size;    //即n,对称矩阵为方阵

    };

    void Test()

    {

    int a[5][5] = {

    { 0, 1, 2, 3, 4 },

    { 1, 0, 1, 2, 3 },

    { 2, 1, 0, 1, 2 },

    { 3, 2, 1, 0, 1 },

    { 4, 3, 2, 1, 0 },

    };

    SymmtrixMatrix sm((int*)a, 5);

    sm.Print(5);

    }

    int main()

    {

    Test();

    system("pause");

    return 0;

    }

    展开全文
  • 特殊矩阵(对称矩阵)的压缩存储和解压缩 参考书目:严蔚敏《数据结构》P95-96 一、背景 ​ 矩阵在工程计算中经常使用,对于一些特殊矩阵,比如对称矩阵,稀疏矩阵……有时为了节省空间,可以对这类矩阵进行压缩...
    特殊矩阵(对称矩阵)的压缩存储和解压缩

    参考书目:严蔚敏《数据结构》P95-96


    一、背景

    ​ 矩阵在工程计算中经常使用,对于一些特殊矩阵,比如对称矩阵,稀疏矩阵……有时为了节省空间,可以对这类矩阵进行压缩存储这里只讨论对称矩阵,上(下)三角矩阵和对角矩阵,掌握其他类似对称矩阵就很容易了

    二、压缩原则

    ​ 为多个值相同的元素只分配一个存储空间,对零元素不分配空间。

    三、对称矩阵的压缩

    • 性质:
      0<=i,j<=n-1(在 程序中 数组下标是从 0 开始的)

      举例:

    • 压缩:以行序为主序存储下三角(包括对角线)元素

    • 推导如下:

      ①为书上的方法

      ②自己想的一种,在压缩 对角矩阵 时会多节省一点空间

    推导

    四、程序实现 4阶 对称矩阵压缩

    ​ 4阶矩阵压缩(后面会总结 n阶 )

    #include <iostream>
    using namespace std;
    
    //原始矩阵 
    int a[4][4]=
    {{0,4,5,6},	
     {4,1,7,8},
     {5,7,2,9},
     {6,8,9,3}}; 
    //压缩矩阵 
    int Sa1[10];
    int Sa2[10];
    //通过压缩矩阵复原 原矩阵 
    int a1[4][4] = {0}; 
    
    void Printa()
    {
    	for(int i=0; i<4; i++)
    	{
    		for(int j=0; j<4; j++)
    			cout << a[i][j] << "\t";
    		cout << endl;
    	}
    
    	cout << endl;	
    } 
    
    void MatrixCompression1()//矩阵压缩 1
    {
    	for(int i=0; i<4; i++)
    	{
    		for(int j=0; j<=i; j++)
    		{
    			int k = i*(i+1)/2+j;
    			Sa1[k] = a[i][j];
    		}
    	}
    }
    
    void MatrixCompression2()//矩阵压缩 2
    {
    	for(int i=0; i<4; i++)
    	{
    		for(int j=0; j<=i; j++)
    		{
    			int m = i-j;
    			int k = 4*m-m*(m-1)/2+j;
    			Sa2[k] = a[i][j]; 
    		}
    	}
    }
    
    int main()
    {
    	cout << "原始矩阵:" << endl;
    	Printa(); 
    	
    	MatrixCompression1();
    	cout << "第一种压缩方式:"; 
    	cout << "Sa1 = ";
    	for(int i=0; i<10; i++)
    		cout << Sa1[i] << " "; 
    	
    	cout << endl;
    
    	MatrixCompression2();	
    	cout << "第二种压缩方式:"; 
    	cout << "Sa2 = ";
    	for(int i=0; i<10; i++)
    		cout << Sa2[i] << " "; 
    	return 0;
     } 
    

    运行结果:压缩运行结果

    五、解压缩

    压缩容易,解压难,不聪明的小脑袋瓜子想了一节课,发现直接从公式出发就好了

    其实都可以用暴力法穷举出来,第一种方式我优化了一下,为 O(n2);第二种方式为 O(n4),n 表示阶数

    void MatrixRecovery1()//矩阵复原1
    {
    	int i=3,j,k; 
    	for(k=9; k>=0; k--)
    	{
    		j = k-(i+1)*i/2;
    		if(j>=0)
    		{
    			a1[i][j] = a1[j][i] = Sa1[k]; 
    		}
    		else
    		{
    			i--;
    			j = k-(i+1)*i/2;
    			a1[i][j]  = Sa1[k];
    		}
    	}
    	
    } 
    
    void MatrixRecovery2()//矩阵复原2
    {
    	int i,j,k,m; 
    	for(k=0; k<10; k++)
    	{
    		for(i=0; i<4; i++)
    			for(j=0; j<=i; j++)
    			{
    				m = i-j;
    				if(k==4*m-m*(m-1)/2+j)	
    				{
    					a2[i][j] = a2[j][i] = Sa2[k];
    					break;	
    				}
    			}
    	}
    } 
    

    六、全部代码和运行结果

    ![请添加图片描述](https://img-blog.csdnimg.cn/2198cf24da4b49e785ba403cd5db6abf.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5ZCb5YWu5pWF5Lq66L6e,size_20,color_FFFFFF,t_70,g_se,x_16)
    #include <iostream>
    #include <iostream>
    using namespace std;
    
    //原始矩阵 
    int a[4][4]=
    {{0,4,5,6},	
     {4,1,7,8},
     {5,7,2,9},
     {6,8,9,3}}; 
    //压缩矩阵 
    int Sa1[10];
    int Sa2[10];
    //通过压缩矩阵  解压缩回 原矩阵 
    int a1[4][4] = {0}; 
    int a2[4][4] = {0}; 
    
    void PrintArray(int a[][4])
    {
    	for(int i=0; i<4; i++)
    	{
    		for(int j=0; j<4; j++)
    			cout << a[i][j] << "\t";
    		cout << endl;
    	}
    
    	cout << endl;	
    } 
    
    
    void MatrixCompression1()//矩阵压缩 1
    {
    	for(int i=0; i<4; i++)
    	{
    		for(int j=0; j<=i; j++)
    		{
    			int k = i*(i+1)/2+j;
    			Sa1[k] = a[i][j];
    		}
    	}
    }
    
    void MatrixCompression2()//矩阵压缩 2
    {
    	for(int i=0; i<4; i++)
    	{
    		for(int j=0; j<=i; j++)
    		{
    			int m = i-j;
    			int k = 4*m-m*(m-1)/2+j;
    			Sa2[k] = a[i][j]; 
    		}
    	}
    }
    
    void MatrixRecovery1()//矩阵复原1
    {
    	int i=3,j,k; 
    	for(k=9; k>=0; k--)
    	{
    		j = k-(i+1)*i/2;
    		if(j>=0)
    		{
    			a1[i][j] = a1[j][i] = Sa1[k]; 
    		}
    		else
    		{
    			i--;
    			j = k-(i+1)*i/2;
    			a1[i][j]  = Sa1[k];
    		}
    	}
    	
    } 
    
    void MatrixRecovery2()//矩阵复原2
    {
    	int i,j,k,m; 
    	for(k=0; k<10; k++)
    	{
    		for(i=0; i<4; i++)
    			for(j=0; j<=i; j++)
    			{
    				m = i-j;
    				if(k==4*m-m*(m-1)/2+j)	
    				{
    					a2[i][j] = a2[j][i] = Sa2[k];
    					break;	
    				}
    			}
    	}
    	
    } 
    
    int main()
    {
    	cout << "原始矩阵 a :" << endl;
    	PrintArray(a); 
    	cout << endl;
    	
    	MatrixCompression1();
    	cout << "第一种压缩方式:"; 
    	cout << "Sa1 = ";
    	for(int i=0; i<10; i++)
    		cout << Sa1[i] << " "; 
    	cout << endl;
    	
    	 
    	MatrixCompression2();	
    	cout << "第二种压缩方式:"; 
    	cout << "Sa2 = ";
    	for(int i=0; i<10; i++)
    		cout << Sa2[i] << " "; 
    	cout << endl;	
    	
    	cout << endl;
    	MatrixRecovery1();
    	cout << "第一种压缩方式的解压缩 a1 :" << endl; 
    	PrintArray(a1);
    
    	MatrixRecovery2();
    	cout << "第二种压缩方式的解压缩 a2 :" << endl; 
    	PrintArray(a2); 
    		
    	return 0;
     } 
    

    运行结果:
    4阶矩阵压缩和解压代码运行结果

    七、n阶

    改改参数就好了

    #include <iostream>
    using namespace std;
    
    const int RECORD = 20;//阶数
    
    //原始矩阵 
    int a[RECORD][RECORD]={0}; 
    //压缩矩阵 
    int Sa1[RECORD*(RECORD+1)/2];
    int Sa2[RECORD*(RECORD+1)/2];
    //通过压缩矩阵  解压缩回 原矩阵 
    int a1[RECORD][RECORD] = {0}; 
    int a2[RECORD][RECORD] = {0}; 
    
    void Inita()
    {
    	int cnt = 0;
    	for(int i=0; i<RECORD; i++)
    		for(int j=0; j<=i; j++)
    		{
    			a[i][j] = a[j][i] = cnt;
    			cnt++;	
    		} 
    } 
    
    
    void PrintArray(int a[][RECORD])
    {
    	for(int i=0; i<RECORD; i++)
    	{
    		for(int j=0; j<RECORD; j++)
    			cout << a[i][j] << "\t";
    		cout << endl;
    	}
    
    	cout << endl;	
    } 
    
    
    void MatrixCompression1()//矩阵压缩 1
    {
    	for(int i=0; i<RECORD; i++)
    	{
    		for(int j=0; j<=i; j++)
    		{
    			int k = i*(i+1)/2+j;
    			Sa1[k] = a[i][j];
    		}
    	}
    }
    
    void MatrixCompression2()//矩阵压缩 2
    {
    	for(int i=0; i<RECORD; i++)
    	{
    		for(int j=0; j<=i; j++)
    		{
    			int m = i-j;
    			int k = RECORD*m-m*(m-1)/2+j;
    			Sa2[k] = a[i][j]; 
    		}
    	}
    }
    
    void MatrixRecovery1()//矩阵复原1
    {
    	int i=RECORD-1,j,k; 
    	for(k=RECORD*(RECORD+1)/2-1; k>=0; k--)
    	{
    		j = k-(i+1)*i/2;
    		if(j>=0)
    		{
    			a1[i][j] = a1[j][i] = Sa1[k]; 
    		}
    		else
    		{
    			i--;
    			j = k-(i+1)*i/2;
    			a1[i][j]  = Sa1[k];
    		}
    	}
    	
    } 
    
    void MatrixRecovery2()//矩阵复原2
    {
    	int i,j,k,m; 
    	for(k=0; k<RECORD*(RECORD+1)/2; k++)
    	{
    		for(i=0; i<RECORD; i++)
    			for(j=0; j<=i; j++)
    			{
    				m = i-j;
    				if(k==RECORD*m-m*(m-1)/2+j)	
    				{
    					a2[i][j] = a2[j][i] = Sa2[k];
    					break;	
    				}
    			}
    	}
    	
    } 
    
    int main()
    {
    	//初始化 原始矩阵 a
    	Inita();
    	
    	cout << "原始矩阵 a" << "(" << RECORD << "阶)" <<":" << endl;
    	PrintArray(a); 
    	cout << endl;
    	
    	MatrixCompression1();
    	cout << "第一种压缩方式:"; 
    	cout << "Sa1 = ";
    	for(int i=0; i<RECORD*(RECORD+1)/2; i++)
    		cout << Sa1[i] << " "; 
    	cout << endl;
    	
    	 
    	MatrixCompression2();	
    	cout << "第二种压缩方式:"; 
    	cout << "Sa2 = ";
    	for(int i=0; i<RECORD*(RECORD+1)/2; i++)
    		cout << Sa2[i] << " "; 
    	cout << endl;	
    	
    	cout << endl;
    	MatrixRecovery1();
    	cout << "第一种压缩方式的解压缩 a1 :" << endl; 
    	PrintArray(a1);
    
    	MatrixRecovery2();
    	cout << "第二种压缩方式的解压缩 a2 :" << endl; 
    	PrintArray(a2); 
    		
    	return 0;
     } 
    

    各阶数所花时间:
    5
    1015
    20
    25

    阶数510152025
    时间/s(编译器粗略估计的)0.1830.3320.5100.8421.038

    阶数越高,运行成本越高。

    展开全文
  • 对称矩阵

    2021-01-07 09:59:52
    对称矩阵 题目描述 输入一个N维矩阵,判断是否对称。 输入 输入第一行包括一个数:N(1<=N<=100),表示矩阵的维数。 接下来的N行,每行包括N个数,表示N*N矩阵的元素。 输出 可能有多组测试数据,对于每组数据...

    对称矩阵

    题目描述

    输入一个N维矩阵,判断是否对称。

    输入

    输入第一行包括一个数:N(1<=N<=100),表示矩阵的维数。
    接下来的N行,每行包括N个数,表示N*N矩阵的元素。

    输出

    可能有多组测试数据,对于每组数据,
    输出"Yes!”表示矩阵为对称矩阵。
    输出"No!”表示矩阵不是对称矩阵。

    样例输入

    1
    68 
    3
    1 70 25 
    70 79 59 
    25 59 63 
    3
    6 46 82 
    28 62 92 
    96 43 28 
    

    样例输出

    Yes!
    Yes!
    No!
    

    Code

    package Week2;
    import java.util.Scanner;
    
    public class Q1 {
        //输入一个N维矩阵,判断是否对称。
        //用一个二维数组判断
        public static void main(String[] args) {
            int N, sum;
            Scanner sc = new Scanner(System.in);
            while (sc.hasNext()) {
                sum = 0;
                N = sc.nextInt();
                int[][] arr = new int[N][N];
                for (int i = 0; i < N; i++) {
                    for (int j = 0; j < N; j++) {
                        arr[i][j] = sc.nextInt();
                    }
                }
                for (int i = 0; i < N; i++) {
                    for (int j = 0; j < N; j++) {
                        if (arr[i][j] == arr[j][i]) {
                            sum++;
                            //System.out.println("i,j,sum"+i+j+sum);
                        }
                    }
                }
                    if (sum == N * N) {
    
                        System.out.println("Yes!");
                    } else {
                        System.out.println("No!");
                    }
                    //System.out.println(sum);
    
    
            }
    
        }
    }
    
    
    
    展开全文
  • 对称矩阵及稀疏矩阵的压缩存储1.稀疏矩阵对于那些零元素数目远远多于非零元素数目,并且非零元素的分布没有规律的矩阵称为稀疏矩阵(sparse)。人们无法给出稀疏矩阵的确切定义,一般都只是凭个人的直觉来理解这个概念...

    对称矩阵及稀疏矩阵的压缩存储

    1.稀疏矩阵

    对于那些零元素数目远远多于非零元素数目,并且非零元素的分布没有规律的矩阵称为稀疏矩阵(sparse)。

    人们无法给出稀疏矩阵的确切定义,一般都只是凭个人的直觉来理解这个概念,即矩阵中非零元素的个数远远小于矩阵元素的总数,并且非零元素没有分布规律。

    实现代码:

    //稀疏矩阵及其压缩存储

    #pragma once

    #include

    #include

    using namespace std;

    template

    struct Triple

    {

    size_t _r;

    size_t _c;

    T _value;

    Triple(size_t row = 0, size_t col = 0, const T& value = T())

    :_r(row)

    ,_c(col)

    ,_value(value)

    {}

    };

    template

    class SparseMatrix

    {

    public:

    SparseMatrix()

    :_row(0)

    ,_col(0)

    ,_illegal(T())

    {}

    SparseMatrix(T* arr, size_t row, size_t col, const T& illegal)

    :_row(row)

    ,_col(col)

    ,_illegal(illegal)

    {

    for(size_t i = 0; i

    {

    for(size_t j = 0; j

    {

    if(arr[i*col+j] != illegal)

    {

    Triple t(i,j,arr[i*col+j]);

    _matrix.push_back(t);

    }

    }

    }

    }

    void Display()

    {

    vector >::iterator iter;

    iter = _matrix.begin();

    for(size_t i = 0; i<_row>

    {

    for(size_t j = 0; j<_col>

    {

    if(iter!=_matrix.end()

    &&iter->_r == i

    &&iter->_c == j)

    {

    cout << iter->_value <

    ++iter;

    }

    else

    {

    cout << _illegal <

    }

    }

    cout << endl;

    }

    cout << endl;

    }

    //普通转置(行优先存储)

    //列变行,从0列开始,将列数据一个一个放进转置矩阵

    SparseMatrix Transpose()

    {

    SparseMatrix tm;

    tm._row = _col;

    tm._col = _row;

    tm._illegal = _illegal;

    tm._matrix.reserve(_matrix.size());

    for(size_t i = 0; i<_col>

    {

    size_t index = 0;

    while(index < _matrix.size())

    {

    if(_matrix[index]._c == i)

    {

    Triple t(_matrix[index]._c, _matrix[index]._r, _matrix[index]._value);

    tm._matrix.push_back(t);

    }

    ++index;

    }

    }

    return tm;

    }

    SparseMatrix FastTranspose()

    {

    SparseMatrix tm;

    tm._row = _col;

    tm._col = _row;

    tm._illegal = _illegal;

    tm._matrix.resize(_matrix.size());

    int* count = new int[_col];//记录每行的元素个数

    memset(count, 0, sizeof(int)*_col);

    int* start = new int[_col];//转置矩阵中元素的位置

    start[0] = 0;

    size_t index = 0;

    while(index < _matrix.size())

    {

    count[_matrix[index]._c]++;

    ++index;

    }

    for(size_t i=1; i<_col>

    {

    start[i] = start[i-1] + count[i-1];

    }

    index = 0;

    while(index < _matrix.size())

    {

    Triple t(_matrix[index]._c, _matrix[index]._r, _matrix[index]._value);

    tm._matrix[start[_matrix[index]._c]++] = t; //核心代码

    ++index;

    }

    delete[] count;

    delete[] start;

    return tm;

    }

    protected:

    vector > _matrix;

    size_t _row;

    size_t _col;

    T _illegal;

    };

    2.对称矩阵

    实现代码:

    //对称矩阵及其压缩存储

    #pragma once

    #include

    using namespace std;

    template

    class SymmetricMatrix

    {

    public:

    SymmetricMatrix(T* arr, size_t n)

    :_n(n)

    ,_matrix(new T[n*(n+1)/2])

    {

    size_t index = 0;

    for(size_t i = 0; i

    {

    for(size_t j=0; j

    {

    if(i >= j)

    {

    _matrix[index] = arr[i*n+j];

    ++index;

    }

    else

    {

    continue;

    }

    }

    }

    }

    void Display()

    {

    for(size_t i =0; i < _n; ++i)

    {

    for(size_t j = 0; j < _n; ++j)

    {

    /* if(i

    {

    swap(i,j);

    cout<<_matrix>

    swap(i,j);

    }

    else

    cout<<_matrix>

    */

    cout << Access(i,j) << " ";

    }

    cout << endl;

    }

    cout << endl;

    }

    T& Access(size_t row, size_t col)

    {

    if(row

    {

    swap(row, col);

    }

    return _matrix[row*(row+1)/2+col];

    }

    ~SymmetricMatrix()

    {

    if(_matrix != NULL)

    {

    delete[] _matrix;

    _matrix = NULL;

    }

    }

    protected:

    T* _matrix;

    size_t _n; //对称矩阵的行列大小

    };

    以上就是C++ 数据结构实现稀疏矩阵与对称矩阵,如有疑问请留言或者到本站社区交流讨论,感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

    时间: 2017-08-10

    展开全文
  • 线性代数之 实对称矩阵,正交对角化,二次型与正定矩阵前言实对称矩阵正交对角化二次型正定矩阵实对称矩阵的正定判断条件后记 前言 终于快到矩阵分解了。在矩阵分解前,最后一个内容是实对称矩阵,二次型和正定矩阵...
  • 对称矩阵一定可以相似对角化

    千次阅读 2021-09-12 21:46:56
    对于任意的nnn阶实对称矩阵AAA,存在正交矩阵QQQ,使得 Q−1AQ=QTAQ=diag(λ1,…,λn)Q^{-1}AQ=Q^T AQ=diag(\lambda_1,\dots,\lambda_n)Q−1AQ=QTAQ=diag(λ1​,…,λn​) 其中λ1,…,λn\lambda_1,\dots,\lambda_n...
  • 1、什么是对称矩阵这就是一个4阶矩阵,红色为对角线。除对角线的元素,关于对角线的元素值相等。 2、问题的由来对于N阶矩阵,有n*n个元素,如果采用二维数组存储,则需要对应数量的存储单元,可以利用对阵矩阵中a[i]...
  • 有时候做实验需要使用对称矩阵,这里介绍如何使用Matlab产生随机的对称矩阵。用例子说明一下:我要产生4X4的随机矩阵,要求是对称矩阵。产生对称矩阵A=rand(4);B=tril(A,-1)+triu(A',0);方法一:B是A的下三角矩阵...
  • 《第四节 实对称矩阵的对角化》由会员分享,可在线阅读,更多相关《第四节 实对称矩阵的对角化(9页珍藏版)》请在人人文库网上搜索。1、一、实对称矩阵的性质,1,2,1,2,1,2,1,2,6.4.1,A,引理,设,是实对称矩阵,的两个...
  • 对称矩阵的判定Time Limit:1000 msMemory Limit:65536 KiBSubmitStatisticProblem Description输入矩阵的行数,再依次输入矩阵的每行元素,判断该矩阵是否为对称矩阵,若矩阵对称输出“yes",不对称输出”no“。...
  • 4.2 矩阵的压缩存储(一) 在有些情况下,矩阵中含有许多值相同或者值为零的元素,如果还按前面的方法来存储这种矩阵,就会产生大量的空间浪费。为了节省存储空间,可以对这类矩阵采用压缩存储。...对称矩阵中的元素
  • 25_对称矩阵和正定矩阵

    千次阅读 2021-05-02 20:37:15
    ①实对称矩阵的特征值也为实数,我们主要讨论实对称矩阵 之前讲过旋转矩阵的特征值为复数,这里不会遇到了 ②特征向量也很特殊 特征向量是垂直的 why? 首先对于单位矩阵,特征值为1,是实数,①肯定成立 对于②,指...
  • 对称矩阵性质

    千次阅读 2021-06-21 11:02:27
    对称矩阵的不同特征值对应的特征向量是正交的; 实对称矩阵特征值是实数, 特征向量都是实向量; n阶实对称阵必可以对角化, 且相似的对角阵的元素即是原矩阵的特征值; 若λk\lambda_{k}λk​具有k重特征值, 必有k个...
  • 对称矩阵转置

    千次阅读 2021-07-03 13:37:45
    把一个m×n矩阵的行,列互换得到的n×m矩阵,称为A的转置矩阵,记为A’或AT。 矩阵转置的运算律(即性质):...由定义知对称矩阵一定是方阵,而且位于主对角线对称位置上的元素必对应相等,即aij=aji对任意i,j都成立。 ...
  • 对称矩阵 n阶矩阵中任意一个元素aij都有aij=aji,则为对称矩阵 只存储主对角线+下三角区(按行优先存储在一维数组中) 数组大小:(1+n)*n/2 三角矩阵 三对角矩阵 稀疏矩阵 三元表(行,列,值) 十字链表...
  • 矩阵乘法、转置矩阵、对称矩阵

    千次阅读 2020-12-18 14:00:36
    程序实现随机生成N阶方阵,然后求转置矩阵,利用对称矩阵与原矩阵相乘, 构造对称矩阵。 代码如下: //生成方阵,转置矩阵,对称矩阵 #include <stdio.h> #include <time.h> #include <stdlib.h>...
  • 对角矩阵 ...对称矩阵是转置矩阵和自己相等的矩阵: A=AT A = A^T A=AT 当某些不依赖参数顺序的双参数函数生成元素时,对称矩阵经常会出现。例如,如果AAA是一个表示距离的矩阵,Ai,jA_{i,j}Ai,j​表示点i
  • 假设两个实对称矩阵A和B,如果存在一个可逆的矩阵X, XAX'=B,已知A和B,知道怎么用matlab求X?本例中数据如下:A=[0.287402 0 00 0.483209 00 0 0.000025];B=[0.287402 -0.028039 -0.0000727-0.028039 0.483209 0....
  • 有时候做实验需要使用对称矩阵,这里介绍如何使用Matlab产生随机的对称矩阵。用例子说明一下:我要产生4X4的随机矩阵,要求是对称矩阵。产生对称矩阵A = rand(4);B = tril(A,-1)+triu(A',0);方法一:B是A的下三角...
  • http://www.open-open.com/code/view/14324763583012015.05说明... j,例如:1 2 3 4 50 6 7 8 90 0 10 11 120 0 0 13 140 0 0 0 15下三角矩阵矩阵在对角线以上的元素均为0,即Aij = 0,i < j,例如:1 0 0 0 ...
  • 对称矩阵的基本性质

    千次阅读 2021-07-01 22:40:01
    1.对于任何方形矩阵X,X+XT是对称矩阵。 2.A为方形矩阵是A为对称矩阵的必要条件。 3.对角矩阵都是对称矩阵。 4.两个对称矩阵的积是对称矩阵,当且仅当两者的乘法可交换。两个实对称矩阵乘法可交换当且仅当两者的特征...
  • C++计算对称矩阵的实特征值和特征向量C++计算对称矩阵的实特征值和特征向量完整源码 C++计算对称矩阵的实特征值和特征向量完整源码 #include <cassert> #include <cmath> #include <cstdlib> #...
  • 本章是特征值与特征向量知识的延续,根据谱定理可知实对称矩阵可以正交对角化,对角阵为其特征值,正交矩阵为其两两正交的单位特征向量。除此之外,还介绍了二次型,标准形,规范形的知识。二次型的化简问题是本章的...
  • MATLAB 非对称矩阵求逆

    2021-03-28 09:32:16
    本人记录,大佬请跳过。 对称矩阵A的求逆很简单inv(A)就可以,对于非对称矩阵 命令: A=[1 2 3;4 5 6]; pinv(A) 传送门
  • 判断对称矩阵对任意i和j,有a[i,j]=a[j,i]/// /// 检查一个矩阵是否为对称矩阵/// /// 矩阵/// true:是对称矩阵 false:不是对称矩阵private static bool isSymmetric(double[][] matrix){//矩阵没有元素的情况if ...
  • 什么是对称矩阵

    千次阅读 2021-07-01 22:39:31
    对称矩阵(Symmetric Matrices)是指以主对角线为对称轴,各元素对应相等的矩阵。在线性代数中,对称矩阵是一个方形矩阵,其转置矩阵和自身相等。1855年,埃米特(C.Hermite,1822-1901年)证明了别的数学家发现的一些...
  • 问题及代码:/*2015,烟台大学计算机与控制工程学院*作者:桑立*完成日期:2015年10月26日*问题描述:用压缩形式存储对称矩阵,实现下面的操作并测试.*/(1)头文件:#ifndef TUP_H_INCLUDED#define TUP_H_INCLUDED#...
  • 在Matrix.java添加这些操作:判断一个矩阵是否为上三角矩阵:publicbooleanisUpperTriangularMatrix()判断一个矩阵是否为下三角矩阵:publicbooleanisLowerTriangularMatrix()判断一个...在Matrix.java添加这些操作...
  • (17)对称矩阵的cholesky分解 补发笔记
  • 数据结构与算法基础之对称矩阵 学习来源: 数据结构与算法基础(青岛大学-王卓) 地址: https://www.bilibili.com/video/BV1nJ411V7bd?p=22&spm_id_from=pageDriver 背景: 实现视频里老师的伪代码,并不完全...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 69,370
精华内容 27,748
关键字:

对称矩阵

友情链接: pocklington_radiation.zip