精华内容
下载资源
问答
  • GPU矩阵计算

    千次阅读 2019-05-22 10:22:26
    学习GPU加速 参考例子和网上博文写的GPU矩阵计算 //矩阵转置 __global__ void transposeGPU(double *outdata, double *indata, int width, int height) { __shared__ double block[BLOCK_DIM][BLOCK_DIM + 1]; ...

    学习GPU加速 参考例子和网上博文写的GPU矩阵计算

    //矩阵转置
    __global__ void transposeGPU(double *outdata, double *indata, int width, int height)
    {
        __shared__ double block[BLOCK_DIM][BLOCK_DIM + 1];
        unsigned int xIndex = blockIdx.x*BLOCK_DIM + threadIdx.x;
        unsigned int yIndex = blockIdx.y*BLOCK_DIM + threadIdx.y;

        if ((xIndex < width) && (yIndex < height))
        {
            unsigned int index_in = yIndex*width + xIndex;
            block[threadIdx.y][threadIdx.x] = indata[index_in];
        }

        __syncthreads();

        xIndex = blockIdx.y*BLOCK_DIM + threadIdx.x;
        yIndex = blockIdx.x*BLOCK_DIM + threadIdx.y;

        if ((xIndex < height) && (yIndex < width))
        {
            unsigned int index_out = yIndex*height + xIndex;
            outdata[index_out] = block[threadIdx.x][threadIdx.y];
            //        std::cout <<" !!index_out:" <<index_out<<" block[threadIdx.x][threadIdx.y]:"<< block[threadIdx.x][threadIdx.y] <<std::endl;
        }

    }

    void transpose(double *outdata, double *indata, int width, int height)
    {
        double *d_a, *d_b;
        cudaMalloc((double**)&d_a, sizeof(double) * width * height);
        cudaMalloc((double**)&d_b, sizeof(double) * height * width);

        cudaMemcpy((void*)d_a, (void*)indata, sizeof(double) * width * height, cudaMemcpyHostToDevice);

        dim3 Threads(BLOCK_DIM, BLOCK_DIM);
        int b_x = ceil((float)width / (float)BLOCK_DIM);
        int b_y = ceil((float)height / (float)BLOCK_DIM);
        dim3 Blocks(b_x, b_y);

        transposeGPU << <Blocks, Threads >> > (d_b, d_a, width, height);
        cudaMemcpy((void*)outdata, (void*)d_b, sizeof(double) * width * height, cudaMemcpyDeviceToHost);

    }
    //矩阵乘法

    template<int BLOCK_SIZE> __global__ void MatrixMulGPU(double *c, const double *a, const double *b, unsigned int WA, unsigned int WB)
    {
        // Block index
        int bx = blockIdx.x;
        int by = blockIdx.y;

        // Thread index
        int tx = threadIdx.x;
        int ty = threadIdx.y;

        // Index of the first sub-matrix of A processed by the block
        int aBegin = WA * BLOCK_SIZE * by;

        // Index of the last sub-matrix of A processed by the block
        int aEnd = aBegin + WA - 1;

        // Step size used to iterate through the sub-matrices of A
        int aStep = BLOCK_SIZE;

        // Index of the first sub-matrix of B processed by the block
        int bBegin = BLOCK_SIZE * bx;

        // Step size used to iterate through the sub-matrices of B
        int bStep = BLOCK_SIZE * WB;

        // Csub is used to store the element of the block sub-matrix
        // that is computed by the thread
        double Csub = 0;

        // Loop over all the sub-matrices of A and B
        // required to compute the block sub-matrix
        for (int i = aBegin, j = bBegin;
            i <= aEnd;
            i += aStep, j += bStep)
        {

            // Declaration of the shared memory array As used to
            // store the sub-matrix of A
            __shared__ double As[BLOCK_SIZE][BLOCK_SIZE];

            // Declaration of the shared memory array Bs used to
            // store the sub-matrix of B
            __shared__ double Bs[BLOCK_SIZE][BLOCK_SIZE];

            // Load the matrices from device memory
            // to shared memory; each thread loads
            // one element of each matrix
            As[ty][tx] = a[i + WA * ty + tx];
            Bs[ty][tx] = b[j + WB * ty + tx];

            // Synchronize to make sure the matrices are loaded
            __syncthreads();

            // Multiply the two matrices together;
            // each thread computes one element
            // of the block sub-matrix
    #pragma unroll

            for (int k = 0; k < BLOCK_SIZE; ++k)
            {
                Csub += As[ty][k] * Bs[k][tx];
            }

            // Synchronize to make sure that the preceding
            // computation is done before loading two new
            // sub-matrices of A and B in the next iteration
            __syncthreads();
        }

        // Write the block sub-matrix to device memory;
        // each thread writes one element
        int k = WB * BLOCK_SIZE * by + BLOCK_SIZE * bx;
        c[k + WB * ty + tx] = Csub;
    }

    void  MultiMatrix(double **A, double **B, double **R, int Arow, int Acol, int Brow, int Bcol)
    {
        double *dev_a = 0;
        double *dev_b = 0;
        double *dev_c = 0;
        cudaMalloc((void**)&dev_a, Arow * Acol * sizeof(double));
        cudaMalloc((void**)&dev_b, Brow * Bcol * sizeof(double));
        cudaMalloc((void**)&dev_c, Arow * Bcol * sizeof(double));

        cudaMemcpy(dev_a, *A, Arow * Acol * sizeof(double), cudaMemcpyHostToDevice);
        cudaMemcpy(dev_b, *B, Brow * Bcol * sizeof(double), cudaMemcpyHostToDevice);

        dim3 Threads(BLOCK_DIM, BLOCK_DIM);
        int b_x = ceil((float)Bcol / (float)BLOCK_DIM);
        int b_y = ceil((float)Arow / (float)BLOCK_DIM);
        dim3 Blocks(b_x, b_y);
        MatrixMulGPU<BLOCK_DIM> << <Blocks, Threads >> > (dev_c, dev_a, dev_b, Acol, Bcol);

        cudaMemcpy(*R, dev_c, Arow * Bcol * sizeof(double), cudaMemcpyDeviceToHost);
        cudaFree(dev_a);
        cudaFree(dev_b);
        cudaFree(dev_c);
    }

    //矩阵求逆
    __global__ void InvertAGPU(double *A, double *R,int matrix_size)
    {
        __shared__ double MXI[BLOCK_DIM][BLOCK_DIM];

        int isx = threadIdx.x;
        int isy = threadIdx.y;
        double tmpIn;
        double tmpInv;
        //initialize E
        if (isx == isy)
            MXI[isy][isx] = 1;
        else 
            MXI[isy][isx] = 0;

        for (int i = 0; i < matrix_size; i++)
        {
            if (i == isy && isx < matrix_size && isy < matrix_size)
            {
                //消除对角线上的元素(主元)为1
                tmpIn = A[i*matrix_size + i];
                A[i*matrix_size + isx] /= tmpIn;
                MXI[i][isx] /= tmpIn;
            }
            __syncthreads();
            if (i != isy && isx < matrix_size && isy < matrix_size)
            {
                //将主元所在列的元素化为0 所在行的元素同时变化
                tmpInv = A[isy*matrix_size + i];
                A[isy*matrix_size + isx] -= tmpInv * A[i*matrix_size + isx];
                MXI[isy][isx] -= tmpInv * MXI[i][isx];
            }
            __syncthreads();
        }

        R[isx*matrix_size + isy] = MXI[isx][isy];
    }

    void InvertA(double *A, double *R, int matrix_size)
    {
        double *Agpu;
        double *Rgpu;

        cudaMalloc((void**)&Agpu, matrix_size * matrix_size * sizeof(double));
        cudaMalloc((void**)&Rgpu, matrix_size * matrix_size * sizeof(double));

        cudaMemcpy(Agpu, A, matrix_size * matrix_size * sizeof(double), cudaMemcpyHostToDevice);

        dim3 Threads(BLOCK_DIM, BLOCK_DIM);
        int b_x = ceil((float)matrix_size / (float)BLOCK_DIM);
        int b_y = ceil((float)matrix_size / (float)BLOCK_DIM);
        dim3 Blocks(b_x, b_y);
        InvertAGPU << <Blocks, Threads >> > (Agpu, Rgpu, matrix_size);

        cudaMemcpy(R, Rgpu, matrix_size * matrix_size * sizeof(double), cudaMemcpyDeviceToHost);

        cudaFree(Agpu);
        cudaFree(Rgpu);
    }

    //矩阵加法

    __global__ void addGPU(double* a, double* b, double *c, int width, int height)

    {
        int i = threadIdx.x + blockIdx.x * blockDim.x;
        int j = threadIdx.y + blockIdx.y * blockDim.y;

        if (i < height && j < width)
        {
            c[i*width + j] = a[i*width + j] + b[i*width + j];
        }
    }

    void  add(double* a, double* b, double *result, int width, int height)
    {
        double *dev_a = 0;
        double *dev_b = 0;
        double *dev_c = 0;
        cudaMalloc((void**)&dev_a, width * height * sizeof(double));
        cudaMalloc((void**)&dev_b, width * height * sizeof(double));
        cudaMalloc((void**)&dev_c, width * height * sizeof(double));

        cudaMemcpy(dev_a, a, width * height * sizeof(double), cudaMemcpyHostToDevice);
        cudaMemcpy(dev_b, b, width * height * sizeof(double), cudaMemcpyHostToDevice);

        dim3 Threads(BLOCK_DIM, BLOCK_DIM);
        int b_x = ceil((float)width / (float)BLOCK_DIM);
        int b_y = ceil((float)height / (float)BLOCK_DIM);
        dim3 Blocks(b_x, b_y);
        addGPU << <Blocks, Threads >> > (dev_a, dev_b, dev_c, width, height);

        cudaMemcpy(result, dev_c, width * height * sizeof(double), cudaMemcpyDeviceToHost);

    }

    //矩阵减法

    __global__ void subGPU(double* a, double* b, double *c, int width, int height)

    {
        int i = threadIdx.x + blockIdx.x * blockDim.x;
        int j = threadIdx.y + blockIdx.y * blockDim.y;

        if (i < height && j < width)
        {
            c[i*width + j] = a[i*width + j] - b[i*width + j];
        }
    }

    void  sub(double* a, double* b, double *result, int width, int height)
    {
        double *dev_a = 0;
        double *dev_b = 0;
        double *dev_c = 0;
        cudaMalloc((void**)&dev_a, width * height * sizeof(double));
        cudaMalloc((void**)&dev_b, width * height * sizeof(double));
        cudaMalloc((void**)&dev_c, width * height * sizeof(double));

        cudaMemcpy(dev_a, a, width * height * sizeof(double), cudaMemcpyHostToDevice);
        cudaMemcpy(dev_b, b, width * height * sizeof(double), cudaMemcpyHostToDevice);

        dim3 Threads(BLOCK_DIM, BLOCK_DIM);
        int b_x = ceil((float)width / (float)BLOCK_DIM);
        int b_y = ceil((float)height / (float)BLOCK_DIM);
        dim3 Blocks(b_x, b_y);
        subGPU << <Blocks, Threads >> > (dev_a, dev_b, dev_c, width, height);

        cudaMemcpy(result, dev_c, width * height * sizeof(double), cudaMemcpyDeviceToHost);

    }

    展开全文
  • Matrix矩阵计算

    千次阅读 2015-03-27 09:50:15
    矩阵计算是图形学上的一个基础处理 a) 向量的Matrix矩阵变换 b) Matrix的矩阵乘法 c) Matrix求逆矩阵
    (Owed by: 春夜喜雨 http://blog.csdn.net/chunyexiyu 转载请标明来源)
    
    
    
    

    a) 向量的Matrix矩阵变换


    三维Matrix通常是四行四列的entry[4][4]: 实际使用的是三行四列,最后行为补充行
    [A00,A01, A02, A03]
    [A10,A11, A12, A13]
    [A20,A21, A22, A23]
    [0,  0, 0, 1 ]

    向量相当于
    [X]
    [Y]
    [Z]
    [1]

    一个三维向量计算的时候:
    Matrix3d * vec3dOrg  = Vec3dNew
    Vec3dNew.x = vec3dOrg.x * matrix3d.entry[0][0] + vec3dOrg.y * matrix3d.entry[0][1] + vec3dOrg.z * matrix3d.entry[0][2] + matrix3d.entry[0][3];
    Vec3dNew.y = vec3dOrg.x * matrix3d.entry[1][0] + vec3dOrg.y * matrix3d.entry[1][1] + vec3dOrg.z * matrix3d.entry[1][2] + matrix3d.entry[1][3];
    Vec3dNew.z = vec3dOrg.x * matrix3d.entry[2][0] + vec3dOrg.y * matrix3d.entry[2][1] + vec3dOrg.z * matrix3d.entry[2][2] + matrix3d.entry[2][3];

     

    b) Matrix矩阵乘法


    注意: 后做的偏移放前面
    例如先偏移M1,再旋转M2,复合矩阵 = M2 * M1

    矩阵相乘的时候,效果如下,结果为
    Cij = 求和(k=1..n) AikBkj

    [A11,A12, A13, A14]
    [A21,A22, A23, A24]
    [A31,A32, A33, A34]
    [0,  0, 0, 1 ]
    *
    [B11,B12, B13, B14]
    [B21,B22, B23, B24]
    [B31,B32, B33, B34]
    [0,  0, 0, 1 ]

    结果为
    Cij = 求和(k=1..n) AikBkj

    ---前两列                                                             
    A11 * B11 + A12 * B21 + A13 * B31,  A11 * B12 + A12 * B22 + A13 * B32,
    A21 * B11 + A22 * B21 + A23 * B31,  A21 * B12 + A22 * B22 + A23 * B32,
    A31 * B11 + A32 * B21 + A33 * B31,  A31 * B12 + A32 * B22 + A33 * B32,
    0, 0                                                                  
    ---后两列                                                             
    A11 * B13 + A12 * B23 + A13 * B33,  A11 * B14 + A12 * B24 + A13 * B34 
    A21 * B13 + A22 * B23 + A23 * B33,  A21 * B14 + A22 * B24 + A23 * B34,
    A31 * B13 + A32 * B23 + A33 * B33,  A31 * B14 + A32 * B24 + A33 * B34,
    0, 1

    例如: 放大矩阵 与 位移矩阵相乘 相当于先位移再放大(先做的偏移放后面乘)
    [2,0,0,0] // 以0,0,0为基点放大两倍
    [0,2,0,0]
    [0,0,2,0]
    [0,0,0,1]

    [1,0,0,-6] // x.y各位移6
    [0,1,0,-6]
    [0,0,1,0]
    [0,0,0,1]

    结果为:
    [2,0,0,-12] 
    [0,2,0,-12]
    [0,0,2,0]
    [0,0,0,1]
    如果乘以向量(0,0,0)得到的结果是(12,12,0),相当于(0,0,0)点位移(6,6,0),并整体坐标放大两位

     

    c) Matrix求逆矩阵

     

    求逆矩阵的话,就必须要知道秩det的概念
    1.矩阵的秩
    Det为组合矩阵单元生成的一个数

    二维情况
    [A11 A12]
    [A21, A22]
    detA = A11 * A22 – A12 * A21

    N维情况
    [A11,A12, A13]
    [A21,A22, A23]
    [A31,A32, A33]

    通过行求
    detA = 求合(j=1..n)   (-1)^(j+k)  Ajk det[A]jk 
    例如: 三阶时detA = A11 * (A22 * A33 – A23 * A32) - A12 * (A21 * A33 – A23 * A31) + A13 * (A21 * A33 – A23 * A31)

    通过列求
    detA = 求合(k=1..n)   (-1)^(j+k)  Ajk det[A]jk 
    例如: 三阶时detA = A11 * (A22 * A33 – A23 * A32) – A21 * (A12 * A33 – A13 * A32) + A31 * (A12 * A23 – A13 * A22)

    注: det[A]jk 为去掉 j行 k列后形成的 n-1阶矩阵的秩


    2. 求逆矩阵-通过秩
    Mjk = (-1)^(j+k) * det[A]kj / detA

    注: det[A]kj 为去掉k行j列后形成的秩
       detA为矩阵A的秩
    注: detA不能为0,否则矩阵没有逆矩阵


    3. 求逆矩阵-通过自然变换
    通过例如
    第1行 = 第1行 + 第三行 * 2
    第1列 = 第1列 – 第二列
    第2列 = 第2列 / 2;
    类似方向,
    1. 把A矩阵通过多次变换  单位矩阵
    2. 同理,把单位矩阵经历相同的变换,单位矩阵就会成为A的逆矩阵 (A)^-1

    原理就是
    A * A^(-1) = 单位矩阵
    A * P1 * P2 * P3 ..* Pn = 单位矩阵

    A^(-1) = P1 * P2 * P3 ..*Pn = 单位矩阵 * P1 * P2 * P3 ..*Pn

     

     

    (Owed by: 春夜喜雨 http://blog.csdn.net/chunyexiyu 转载请标明来源)

    展开全文
  • 复数矩阵相乘的扩展矩阵计算方法

    千次阅读 2018-07-04 21:44:18
    Matlab是矩阵计算语言,其最基本的存储单位就是矩阵。在诸多信号处理领域,我们所涉及到的信号都是复数信号,那么matlab如何处理复数矩阵呢? 假设矩阵AA\boldsymbol{A}和BB\boldsymbol{B}为复数矩阵,当我们运用...

    Matlab是矩阵计算语言,其最基本的存储单位就是矩阵。在诸多信号处理领域,我们所涉及到的信号都是复数信号,那么matlab如何处理复数矩阵呢? 假设矩阵AB为复数矩阵,当我们运用matlab计算两个矩阵的乘积时(矩阵AB满足矩阵相乘的维度条件),我们可以直接在命令窗口输入AB

    当然,我们也可以采用扩展矩阵的做法来计算复数矩阵的计算。首先是对矩阵进行拆分B=BR+jBM,我们用实数矩阵表示B,如

    (393)B=(BRBM)

    另外
    (394)A=(ARAMAMAR)

    则有
    (395)AB=(ARAMAMAR)(BRBM)=(ARBRAMBMAMBR+ARBM)

    最后,我们用AB的计算结果来表示C,即C=ARBRAMBM+j(AMBR+ARBM)

    展开全文
  • 协方差矩阵计算方法

    2018-12-25 11:01:00
    协方差矩阵计算方法 2017年11月09日 16:05:51Rise_1024阅读数:5468 1. 协方差定义 X、Y 是两个随机变量,X、Y 的协方差 cov(X, Y) 定义为: 其中: 、 2. 协方差矩阵定义 矩阵中的...

    协方差矩阵计算方法

     

    1. 协方差定义

     

    X、Y 是两个随机变量,X、Y 的协方差 cov(X, Y) 定义为:

    其中:

     、

     

    2. 协方差矩阵定义

    矩阵中的数据按行排列与按列排列求出的协方差矩阵是不同的,这里默认数据是按行排列。即每一行是一个observation(or sample),那么每一列就是一个随机变量。

     

    协方差矩阵:

    协方差矩阵的维度等于随机变量的个数,即每一个 observation 的维度。在某些场合前边也会出现 1 / m,而不是 1 / (m - 1).

    3. 求解协方差矩阵的步骤

    举个例子,矩阵 X 按行排列:

     
     

    1. 求每个维度的平均值

     
     

    2. 将 X 的每一列减去平均值

     
     
    其中:
     

    3. 计算协方差矩阵

     

     

    转载于:https://www.cnblogs.com/jeasonit/p/10172748.html

    展开全文
  • 相机参数矩阵计算(内外矩阵)以及光束法平差
  • The matrix cookbook (矩阵计算)pdf

    万次阅读 多人点赞 2018-05-08 16:16:51
    The matrix cookbook (矩阵计算)pdf版本,适合矩阵求导和计算,下载链接:下载地址
  • 参考文章1:【矩阵计算GPU加速】numpy 矩阵计算利用GPU加速,cupy包 参考文章2:NumExpr:加速Numpy、Pandas数学运算新利器! 参考文章3:CuPy:将Numpy提速700倍!
  • Qt中的矩阵计算库eigen

    千次阅读 2020-03-08 19:38:32
    原文链接Qt中的矩阵计算库eigen 在实际工程中由于需要使用矩阵计算,网上搜罗了下,发现 eigen 库比较靠谱,这里简要介绍下食用方法,以及如何避免运行断言 下载库 eigen 官网 引入到 Qt 工程中 将 源码中的 的 Eigen...
  • 矩阵自身(行)向量之间的距离矩阵计算2.1 第一种方法:简单使用两重循环2.2 第二种方法:矩阵內积双重循环2.3 第三种方法:避免循环内的点积运算2.4 第四种方法:避免循环2.5 第五种方法:利用`scipy`求距离矩阵...
  • ARM内核矩阵计算教程(STM32)

    千次阅读 2020-04-25 12:24:52
    假设将矩阵设置成N*N维的二维数组后,我们想求两个矩阵相乘,那就需要按照矩阵计算规则编写矩阵相乘函数,而且4*4矩阵得编一个,5*5矩阵又得编一个,要求逆还得编一个,求行列式还得编,而且自己写的函数代码效率低...
  • 电力系统导纳矩阵计算,MATLAB 这学期在上大四专业选修课时,一个课后作业是写一个电力系统的导纳矩阵计算程序,我找了找资料肝了半天的程序如下图所示,希望能对大家有用。 程序说明 1.具有非标准变比的变压器处理 ...
  • C++矩阵计算库Eigen3之:矩阵的基本操作和运算我写了一个示例程序来展示Eigen3的一些接口使用,一些来自官网示例,后续我还会写这种程序展示更复杂的矩阵运算功能。你必须在使用时,注释掉其他主函数,使用编译链接...
  • 层次分析法中判断矩阵的填写方法、一致性检验的步骤、以及根据判断矩阵计算权重的方法
  • 关于语义分割评价指标和混淆矩阵的基本知识和代码这篇博客讲得很详细,我这里只是详解一下混淆矩阵计算的代码。 # 计算混淆矩阵 def _fast_hist(label_true, label_pred, n_class): mask = (label_true >= 0) &...
  • 电影相似度矩阵计算三.运行结果 一.新鲜一感 永远不要沉迷过去,那样只会无限消耗自己 二.电影相似度矩阵计算 回顾: 上一篇离线开发已经做完,ALS模型也进行了优化 任务: 现在开始进行实时开发模块 代码实现...
  • 1.几种简单矩阵计算的Fortran实现

    千次阅读 2018-08-26 16:51:22
    为了实现分子按照特定方向转向,参考之前利用VESTA手动截取晶面并采用矩阵计算转向的方法,用fortran编写了一个实现简单矩阵计算功能的小程序,用于处理矩阵加、减、乘、除、行列式值、求逆、转置几类计算,主要是求...
  • Python矩阵计算

    千次阅读 2018-09-05 10:18:51
    python的numpy库提供矩阵运算的功能,因此我们在需要矩阵运算的时候,需要导入numpy的包。 1.numpy的导入和使用 from numpy import *;#导入numpy的库函数import numpy as np; #这个方式使用nump...
  • 利用矩阵计算提升推荐系统的速度

    千次阅读 2016-03-18 11:40:05
    利用矩阵计算方式重写评分矩阵的计算程序,运行速度大大提升。重写后的程序包含cal_matscore()和recommend()两个方法,分别用来计算评分矩阵和进行推荐。
  • 矩阵计算误差分析(条件数和范数)

    千次阅读 2019-02-02 23:11:35
    矩阵计算误差分析(条件数和范数) 引言 误差问题是不可避免的,在大量的数据样本中,如果能去掉部分可能造成误差很大的样本,那么对于应用矩阵得到的结果的可靠性则大大加强。例如有999个员工的月收入为10410^4104元...
  • Gram矩阵计算实例

    千次阅读 2017-10-07 16:59:46
    一开始没搞明白具体咋计算,后来经人指点,记录下: matlab代码如下: ’ 代表向量的转置 x1=[3,3]', x2=[4,3]', x3=[1,1]', G=[x1'*x1,x1'*x2,x1'*x3; x2'*x1,x2'*x2,x2'*x3; x3'*x1,x3'*x2,x3'*x3] ...
  • 这个项目本来是用来支持Chainer这个深度学习框架的,但是开发者把这个“GPU 计算包”单独分出来了,方便了大家!!! 来看几个例子: import numpy as np import cupy as cp import time x=np.ones((1024,512,4,...
  • 惯性矩阵计算

    千次阅读 2019-01-12 12:43:36
  • 介绍矩阵计算库MTL

    千次阅读 2012-12-01 11:37:35
    介绍矩阵计算库MTL  主页见参考1,但是这个库没有计算行列式的函数,见参考4给出了计算行列式函数。 1. 主页 http://osl.iu.edu/research/mtl/mtl2.php3 2.源码下载 ...
  • python矩阵计算(特征值,特征向量,对角化)

    万次阅读 多人点赞 2019-03-10 10:30:24
    用sympy进行矩阵计算的基本操作 首先创建矩阵基本操作,首先构造下图中的矩阵,特别注意:一维矩阵的建立格式。 from sympy import * import math import numpy as np a = Matrix([[3,5],[-1,1],[0,5]]) print...
  • 徐映红老师矩阵计算第一节课,上课内容是对于矩阵知识与相关术语词汇的复习。作业是编一个密码相关的小程序。 原理 二战时期,为了避免信息背敌方截获破译,需要对发送的信息进行加密。 这里,刚好运用我们学习...
  • python散点图及相关系数矩阵计算 # -*- coding:utf-8 -*- # __author__ = "LQ" import matplotlib.pyplot as plt import pandas as pd import scipy.stats as stats #自定义方法调用,上一篇有该方法 from Data...
  • C++实现的线性代数矩阵计算

    千次阅读 2011-07-19 23:08:44
    /** * 线性代数矩阵计算 * 实现功能:行列向量获取,子矩阵获取,转置矩阵获取, * 行列式计算,转置伴随矩阵获取,逆矩阵计算 * * Copyright 2011 Shi Y.M. All Rights Reserved */#ifndef MATI
  • 汉澳sinox并行矩阵计算机的技术实现

    千次阅读 2015-01-12 17:56:10
    最近linus提出并行技术不可行,我仔细的分析思考了汉澳sinox的并行技术,汉澳矩阵计算机逐渐清晰起来,并可能很快...矩阵计算机可以理解为2的N次方个计算单元并行计算。 并行计算(Parallel Computing)是指同时使用多
  • MIT线性代数1806(22) 特征值 特征向量 斐波那契数列 K阶矩阵计算

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,886
精华内容 17,954
关键字:

矩阵计算