精华内容
下载资源
问答
  • 转置矩阵

    2019-12-04 00:16:39
    转置矩阵 编辑讨论 本词条由“科普中国”科学百科词条编写与应用工作项目审核 。 将矩阵的行列互换得到的新矩阵称为转置矩阵转置矩阵的行列式不变。 中文名 转置矩阵 外文名 transposed matrix 目录 1...

    转置矩阵

     编辑 讨论

    本词条由“科普中国”科学百科词条编写与应用工作项目 审核 。

    将矩阵的行列互换得到的新矩阵称为转置矩阵,转置矩阵的行列式不变。

    中文名

    转置矩阵

    外文名

    transposed matrix

    目录

    1. 定义
    2. 运算性质

    定义

    编辑

     矩阵

    的行列互换之后得到的矩阵,称为

     的转置矩阵,记作

     ,即

    由定义可知,

     为

     矩阵,则

     为

    矩阵。

    例如,

    如果

    阶方阵和它的转置相等 ,即

    ,则称矩阵

    对称矩阵

    如果

    ,则称矩阵

    反对称矩阵。 [1] 

    运算性质

    编辑

    (1)

    (2)

    (3)

    (4)

    (5)

    ,即转置矩阵的行列式不变。 [1] 

    展开全文
  • C++矩阵转置代码!
  • 提出了行(列)转置矩阵与行(列)反对称矩阵的概念,研究了它们的性质,获得了一些新的结果,给出了行(列)反对称矩阵的秩分解公式,它们可极大地减少行(列)反对称矩阵的秩分解的计算量与存储量,并且不会丧失数值精度 。
  • 一个稀疏矩阵A的转置矩阵B,输入使用三元组输入,输出原三元组,原矩阵,转置后三元组,转置后矩阵
  • 摘要:VB源码,算法相关,转置矩阵 运行环境:Windows/VB6
  • 矩阵的逆矩阵 和 转置矩阵

    万次阅读 2019-06-17 13:59:25
    这几天用到了逆矩阵,就在这里总结一下逆矩阵和转置矩阵。 逆矩阵 逆矩阵就是一个矩阵的逆向。比如一个点乘以一个矩阵后得到了一个新的点的位置,如果想通过这个点再获得矩阵转换前的位置,那我们就需要乘以这个矩阵...

    这几天用到了逆矩阵,就在这里总结一下逆矩阵和转置矩阵。

    逆矩阵

    逆矩阵就是一个矩阵的逆向。比如一个点乘以一个矩阵后得到了一个新的点的位置,如果想通过这个点再获得矩阵转换前的位置,那我们就需要乘以这个矩阵的逆矩阵。
    在Three.js里面,我们可以通过new THREE.Matrix4().getInverse(matrix4)方法来获得一个矩阵的逆矩阵。

    具有的性质:
    可逆矩阵一定是方阵。
    如果矩阵是可逆的,那它的逆矩阵具有唯一性。
    矩阵A的逆矩阵的逆矩阵,等于它自身。

    Three.js获得一个矩阵的逆矩阵:

    var m = `new THREE.Matrix4().getInverse(matrix4);
    

    Three.js求逆矩阵源码:

    		getInverse: function ( m, throwOnDegenerate ) {
    
    			// based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
    			var te = this.elements,
    				me = m.elements,
    
    				n11 = me[ 0 ], n21 = me[ 1 ], n31 = me[ 2 ], n41 = me[ 3 ],
    				n12 = me[ 4 ], n22 = me[ 5 ], n32 = me[ 6 ], n42 = me[ 7 ],
    				n13 = me[ 8 ], n23 = me[ 9 ], n33 = me[ 10 ], n43 = me[ 11 ],
    				n14 = me[ 12 ], n24 = me[ 13 ], n34 = me[ 14 ], n44 = me[ 15 ],
    
    				t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44,
    				t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44,
    				t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44,
    				t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
    
    			var det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
    
    			if ( det === 0 ) {
    
    				var msg = "THREE.Matrix4: .getInverse() can't invert matrix, determinant is 0";
    
    				if ( throwOnDegenerate === true ) {
    
    					throw new Error( msg );
    
    				} else {
    
    					console.warn( msg );
    
    				}
    
    				return this.identity();
    
    			}
    
    			var detInv = 1 / det;
    
    			te[ 0 ] = t11 * detInv;
    			te[ 1 ] = ( n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44 ) * detInv;
    			te[ 2 ] = ( n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44 ) * detInv;
    			te[ 3 ] = ( n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43 ) * detInv;
    
    			te[ 4 ] = t12 * detInv;
    			te[ 5 ] = ( n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44 ) * detInv;
    			te[ 6 ] = ( n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44 ) * detInv;
    			te[ 7 ] = ( n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43 ) * detInv;
    
    			te[ 8 ] = t13 * detInv;
    			te[ 9 ] = ( n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44 ) * detInv;
    			te[ 10 ] = ( n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44 ) * detInv;
    			te[ 11 ] = ( n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43 ) * detInv;
    
    			te[ 12 ] = t14 * detInv;
    			te[ 13 ] = ( n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34 ) * detInv;
    			te[ 14 ] = ( n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34 ) * detInv;
    			te[ 15 ] = ( n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33 ) * detInv;
    
    			return this;
    
    		}
    

    转置矩阵

    说到转置矩阵,这里就要说一下矩阵的排列。矩阵的排列有两种方式:行优先和列优先。而转置矩阵其实就是行优先和列优先之间的切换。
    两种方式在数学上没有什么不同,大多数人都习惯上使用行优先。在Three.js中,我们需要通过行优先设置,而在存储中,则使用列优先存储数据到elements。
    设置矩阵时使用行优先:

    var m = new Matrix4();
    
    m.set( 11, 12, 13, 14,
           21, 22, 23, 24,
           31, 32, 33, 34,
           41, 42, 43, 44 );
    

    元素数组elements将存储为:

    m.elements = [ 11, 21, 31, 41,
                   12, 22, 32, 42,
                   13, 23, 33, 43,
                   14, 24, 34, 44 ];
    

    在Three.js中,我们可以同过transpose()方法,将矩阵转置:

    matrix.transpose();
    

    Three.js的转置源码:

    	transpose: function () {
    
    		var te = this.elements;
    		var tmp;
    
    		tmp = te[ 1 ]; te[ 1 ] = te[ 4 ]; te[ 4 ] = tmp;
    		tmp = te[ 2 ]; te[ 2 ] = te[ 8 ]; te[ 8 ] = tmp;
    		tmp = te[ 6 ]; te[ 6 ] = te[ 9 ]; te[ 9 ] = tmp;
    
    		tmp = te[ 3 ]; te[ 3 ] = te[ 12 ]; te[ 12 ] = tmp;
    		tmp = te[ 7 ]; te[ 7 ] = te[ 13 ]; te[ 13 ] = tmp;
    		tmp = te[ 11 ]; te[ 11 ] = te[ 14 ]; te[ 14 ] = tmp;
    
    		return this;
    
    	},
    
    展开全文
  • leetcode转置矩阵

    2021-02-26 15:56:11
    转置矩阵-python ##

    转置矩阵-python

    转置矩阵题目要求以及示例

    方法一:利用python自带函数

    array=[[1,2,3],[4,5,6]]
    array.transpose()
    #transpose(1,0)和(0,1)和()等效
    

    注意:只有array可以用transpose,list不可以

    #list转array:
    np.array(a)
    #array转list:
    a.tolist()
    

    transpose函数对三维数组也适用,x轴为0,y轴为1,z轴为2。原文点这里

    方法二:利用append函数

    #A是要转置的array
    n=len(A) #行数
    m=len(A[0]) #列数
    res=[]  # 生成一个空列表list
    for i in range(m): #按行遍历
    	x=[]
        for j in range(n): #按列遍历
        	x.append(A[j][i])
        res.append(x)
    return res
    #来自leetcode 12ms案例
    

    append函数 原博客点这里

    1. 用途:在list末尾添加新的元素
    2. 用法:list.append(obj)
    展开全文
  • 给出行(列)转置矩阵与行(列)对称矩阵的概念,并对行(列)转置矩阵的行列式、特征值、可逆性、相似性、对称性等进行了研究,得到n阶实方阵与它的行转置矩阵和列转置矩阵三者具有相同的可逆性、行转置矩阵与列转置矩阵...
  • 程序实现随机生成N阶方阵,然后求转置矩阵,利用对称矩阵与原矩阵相乘, 构造对称矩阵。 代码如下: //生成方阵,转置矩阵,对称矩阵 #include <stdio.h> #include <time.h> #include <stdlib.h>...

    程序实现随机生成N阶方阵,然后求转置矩阵,利用对称矩阵与原矩阵相乘,构造对称矩阵。

    代码如下:

    
    /*
    方阵,转置矩阵,对称矩阵
    程序说明:
        利用随机数生成随机的 N阶方阵    GeneratedMatrix函数
        将生成的 N阶方阵 转置,得到转置方阵    TransposeMatrixAi函数
        将原方阵与转置方阵相乘 得到 对称矩阵    MatrixMutiply函数
        输出矩阵   OutputMatrixAi函数
    */
    #include <stdio.h>
    #include <time.h>
    #include <stdlib.h>
    
    #define N 3 //确定方阵的阶数
    int i = 0;
    int j = 0;
    int t = 0;
    int OriginalMatrix[N][N] = { 0 };
    int TransposeMatrix[N][N] = { 0 };
    int SymmetricMatrix[N][N] = { 0 };
    //输出矩阵内容
    void OutputMatrixAi(int TransposeMatrix[N][N]);
    //随机生成矩阵
    void GeneratedMatrix();
    //转置矩阵算法
    void TransposeMatrixAi(int TransposeMatrix[N][N]);
    //矩阵相乘算法
    void MatrixMutiply(int m, int n, int p, int Matrix1[N][N], int Matrix2[N][N], int MatrixResult[N][N]);
    int main(void)
    {
    
        //随机生成原矩阵
        GeneratedMatrix();
        //输出原矩阵
        printf("原矩阵:\n");
        OutputMatrixAi(OriginalMatrix);
    
    
        //将原矩阵转置,调用转置算法
        TransposeMatrixAi(TransposeMatrix);
        //输出转置矩阵
        printf("转置矩阵:\n");
        OutputMatrixAi(TransposeMatrix);
    
    
        //求对称矩阵,调用矩阵相乘函数
        MatrixMutiply(N, N, N, TransposeMatrix, OriginalMatrix, SymmetricMatrix);
        //输出对称矩阵
        printf("对称矩阵:\n");
        OutputMatrixAi(SymmetricMatrix);
    
    
        system("pause");
        return 0;
    }
    void MatrixMutiply(int m, int n, int p, int Matrix1[N][N], int Matrix2[N][N], int MatrixResult[N][N])
    {
        int i, j, k;
        int Sum;
    
        /*嵌套循环计算结果矩阵(m*p)的每个元素*/
        for (i = 0; i < m; i++)
            for (j = 0; j < p; j++)
            {
                /*按照矩阵乘法的规则计算结果矩阵的i*j元素*/
                Sum = 0;
                for (k = 0; k < n; k++)
                    Sum += Matrix1[i][k] * Matrix2[k][j];
                MatrixResult[i][j] = Sum;
            }
    }
    void GeneratedMatrix()
    {
        srand(time(NULL));
        for (i = 0; i < N; i++)
        {
            for (j = 0; j < N; j++)
            {
                OriginalMatrix[i][j] = rand() % 10;
                TransposeMatrix[i][j] = OriginalMatrix[i][j];
            }
        }
    }
    void TransposeMatrixAi(int TransposeMatrix[N][N])
    {
        for (i = 0; i < N; i++)
        {
            for (j = 0; j < N; j++)
            {
                if (i > j)
                {
                    t = TransposeMatrix[i][j];
                    TransposeMatrix[i][j] = TransposeMatrix[j][i];
                    TransposeMatrix[j][i] = t;
                }
            }
        }
    }
    void OutputMatrixAi(int TransposeMatrix[N][N])
    {
        for (i = 0; i < N; i++)
        {
            for (j = 0; j < N; j++)
            {
                printf("%d ", TransposeMatrix[i][j]);
            }
            putchar('\n');
        }
    }
    
    
    
    
    
    展开全文
  • 文章目录python处理矩阵运算转置矩阵单位矩阵&反向单位矩阵逆矩阵矩阵相乘 python处理矩阵运算 转置矩阵 import numpy as np matrix = [[1, 2, 3], [1, 2, 3], [1, 2, 3]] # 转置矩阵 transposed_matrix = np....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,639
精华内容 3,455
关键字:

转置矩阵