标签: matrix-multiplication

我在按照本教程尝试使用 GLM 进行矩阵和向量相乘时遇到此错误。

reading1.cpp: In function \xe2\x80\x98int main()\xe2\x80\x99:\nreading1.cpp:50:44: error: conversion from \xe2\x80\x98glm::detail::tmat4x4<int>\xe2\x80\x99 to non-scalar type \xe2\x80\x98glm::mat4 {aka glm::detail::tmat4x4<float>}\xe2\x80\x99 requested\n

我正在使用这个命令来编译。

g++ 1.cpp -o 1 -lGLEW -lglfw

#include <glm/glm.hpp>\n#include <glm/gtx/transform.hpp>\n\n//program\n\n\n\nglm::mat4 myMatrix = glm::translate(10,0,0);\nglm::vec4 myVector(10,10,10,0);\nglm::vec4 transformedVector = myMatrix * myVector;\n\n//program\n

我正在使用 Eigen 库在 C++ 中进行一些大型随机矩阵（至少 1000x1000）计算，我的代码由以下函数组成：

Eigen::VectorXd 网格(...); 使用快速排序算法和 ran1 算法（逐个元素）初始化对数正态分布值的排序向量，假设大小为 N，则所有矩阵的大小均为 NxN。

Eigen::VectorXd 条件网格(...); 返回包含网格向量减去时间相关值的向量的循环。

特征::MatrixXd xjkMatrix(...); 通过循环由两个向量构造的矩阵。

本征::MatrixXd qzMatrix(...); 使用 xjk 矩阵通过概率密度函数逐个元素构造一个新矩阵。

本征::MatrixXd q1zMatrix(...); 也使用 xjk 矩阵，使用概率密度函数逐个元素构造一个新矩阵。

本征::MatrixXd qjkMatrix(...); qz 和网格的组合，逐个元素循环。

本征::MatrixXd q1jkMatrix(...); qz、q1z 和网格的组合，逐个元素循环。

Eigen::MatrixXd mjkMatrix(...); 对 qjk 和 q1jk 中的元素逐个循环求和。

Eigen::MatrixXd globalMatrix(...); 循环除网格之外的所有函数（一般为 120 次），网格是固定的，并将 120 个 mjk 矩阵相乘以获得全局矩阵。

全局矩阵 200x200 大约需要 20 秒的计算时间，500x500 大约需要 200 秒。如何使我的代码运行得更快并优化我的矩阵乘法？（我尝试过稀疏矩阵，但花了更长的时间）。

我正在使用 MinGW64。

Eigen 具有惊人的快速 GEMM 实现，因此我想在我的宠物项目张量库中使用它。如果我理解正确的话，可以通过 Eigen::Map 来实现。我编写了简单的示例并进行了定义EIGEN_NO_MALLOC，以确保没有不需要的分配。

它适用于简单的矩阵乘法，例如C += A * B. 但不幸的是它无法处理C += alpha * A * B（GEMM 之类）情况。

#include <iostream>
#include <vector>

#define EIGEN_NO_MALLOC
#include "Eigen/Core"

int main()
{
    using Scalar = float;
    using namespace Eigen;
    std::vector<Scalar> aDat = {1, 2, 3, 4};
    std::vector<Scalar> bDat = {1, 2, 3, 4};
    std::vector<Scalar> cDat = {1, 2, 3, 4};
    Map<Matrix<Scalar, -1, -1, RowMajor>, Unaligned> a(aDat.data(), 2, 2);
    Map<Matrix<Scalar, -1, -1, RowMajor>, Unaligned> b(bDat.data(), 2, 2); …

这是我到目前为止,但我不认为这是对的.

for (int i = 0 ; i < 5; i++)
{
    for (int j = 0;  j < 5; j++)
    {
        matrix[i][j] += matrix[i][j] * matrix[i][j];
    }
}

Divide&Conquer Matrix Multiplication是否会执行与经典矩阵乘法相同的加法/减法量？

我知道他们专门针对乘法,因为它们都具有相同的O(n ^ 3)复杂度......

但是当我尝试在我正在制作的程序中计算它们时,添加/减少会出现不同的数字,我不确定这是否正确.

如果有人知道,请告诉我,谢谢.

我会非常简短!这是一个可重复的例子:

Z1 <- matrix(rep(c(1, 0, 0, 0, 0,
                   1, 1, 0, 0, 0,
                   1, 0, 1, 0, 0,
                   1, 0, 0, 1, 0,
                   1, 0, 0, 0, 1),
                 times = 3),
               nrow  = 15,
               ncol  = 5,
               byrow = TRUE)

z <- matrix(c(0.1, 0.2, 0.3, 0.4, 0.5,
              0.6, 0.7, 0.8, 0.9,   1,
                1,   2,   3,   4,   5),
            nrow  = 3,
            ncol  = 5,
            byrow = TRUE)

我需要一个可扩展的非for循环解决方案(例如,涉及来自apply-family的东西),它给出了我现在将手动执行的这些计算的等效结果:

Zz1 <- Z1[1:5,]   %*% z[1,]
Zz2 <- Z1[6:10,]  %*% …

因此，我得到了一个分配，以读取一个文件，将数字放入两个矩阵中，将矩阵相乘，最后将输出结果放入.txt文件中。

我以前从未使用过Ada，所以我认为这将是一个很好的挑战。我陷入试图确定两个单独的数组的界限。

这是我目前拥有的：

currentSpread := I;
g := Ada.Numerics.Generic_Complex_Elementary_Functions.Sqrt(I);
while J < g loop

  if(I mod J = 0) THEN
     if(currentSpread > ((I/J - J)/2)) THEN
        currentSpread := ((I/J - J)/2);
        arrayBounds := J;
     end if;

  end if;

  J := J + 1;
end loop;

我遇到的问题是sqrt函数。我想找到矩阵乘法最佳边界的因素，这是我认为实现该矩阵的唯一方法。

我得到的错误是：

invalid prefix in selected component "Ada.Numerics.Generic_Complex_Elementary_Functions"

非常感谢您的帮助。

-更新

完整代码要求：

with Ada.Text_IO;use Ada.Text_IO;
with Ada.Integer_Text_IO;
with Ada.Numerics.Generic_Complex_Elementary_Functions;
with Ada.Numerics.Generic_Elementary_Functions;
with Ada.Numerics.Complex_Elementary_Functions;
with Ada.Numerics.Generic_Complex_Types;

procedure Main is

   dataFile : File_Type;
   resultFile : File_Type;
   value : …

我有一个矩阵列表。我需要将它们相乘。通常，如果我们有矩阵A和B，并且需要在R中进行矩阵乘法，则使用

A*B

但在这种情况下，我似乎无法使lapply起作用。如果我的矩阵列表称为l1，而我使用lapply（l1，*），则会出现错误；如果我使用lapply（l1，prod），它将给出每个矩阵内所有元素的乘积。

例：

> l1
[[1]]
     [,1] [,2]
[1,]    2    5
[2,]    3    7

[[2]]
     [,1] [,2]
[1,]    3    7
[2,]    5    9

[[3]]
     [,1] [,2]
[1,]    5    8
[2,]    1    2

所需的输出：

 l1
      [,1] [,2]
[,1]   30   280
[,2]   15   126

我需要将数组A的每一行与元素B的所有行相乘.例如,假设我们有以下数组:

A = np.array([[1,5],[3,6]])
B = np.array([[4,2],[8,2]])

我想得到以下数组C:

C = np.array([[4,10],[8,10],[12,12],[24,12]])

我可以通过使用for循环来做到这一点但我认为可能有更好的方法来做到这一点.

编辑:我想重复和平铺,但我的阵列不是那么小.它可能会产生一些内存问题.

我的Julia代码中的以下部分会杀死我的所有表现:

        for j = 1:size(phi,3)
            for i = 1:size(phi,2)
                    phi[:,i,j] += dt*convolutionmagnitude*
                                    weightMatrix*phi[:,i,j]                     
            end
        end 

即phi三张量,对于每一个i,j我们想要通过矩阵向量乘积更新第一维(乘以一些标量).weightMatrix是大小的矩阵size(phi,1)通过size(phi,1)(这可能是在未来稀疏).一切都发生了floats.

Julia分配了大量内存,即使一切都应该到位(至少我希望如此).我已阅读了julia文档并发现view但无法使用它.我怎样才能加速这个计算？