我想出了这种矩阵乘法算法.我在某处读到矩阵乘法的时间复杂度为o(n ^ 2).但我认为我的算法会给出o(n ^ 3).我不知道如何计算嵌套循环的时间复杂度.所以请纠正我.
for i=1 to n
for j=1 to n
c[i][j]=0
for k=1 to n
c[i][j] = c[i][j]+a[i][k]*b[k][j]
ma=diag(3)+t(da)%*%da
R代码如上,错误信息如下:
Error in t(da) %*% da : requires numeric/complex matrix/vector arguments
da 是一个矩阵,如下所示:
V45 V46 V47 V48 V49 V50 V51
1 0.461727059 2.357732985 -1.536932071 -1.34425710 0.893541975 -0.0676913075 -0.86532231
2 0.253022555 1.524473647 -0.588911138 -1.65207275 -0.072255170 -0.5212951533 -1.43686625
3 0.824678362 1.497001189 0.335973892 -0.84027799 0.275289411 -0.2921928001 -0.16277595
4 0.854530787 2.258305198 0.107346531 -1.69194014 -0.841572928 -1.1153931009 -1.939461341
5 1.148286984 -0.232390389 -0.498465734 -0.45728816 0.352889082 0.9868844505 -0.68401129
任何人都可以帮我弄清楚错误吗？
我有两个数字列表,我想找到所有可能的数字对.例如,给定列表[1,2,3]和[3,4],结果应该是[(1,3),(1,4),(2,3),(2,4),(3) ,3),(3,4)].
我知道我可以使用for循环来做到这一点,但有没有更简洁的方法来使用Java 8流？
我试过以下但是我错过了一些东西,因为我得到了List<Stream<int[]>>而不是List<int[]>.
public static void main(String[] args) {
List<Integer> list1 = Arrays.asList(1, 2, 3);
List<Integer> list2 = Arrays.asList(3, 4);
List<int[]> pairs = list1.stream().map(i -> list2.stream().map(j -> new int[] { i, j }))
.collect(Collectors.toList());
pairs.forEach(i -> {
System.out.println("{" + i[0]+ "," + i[1]+ "}");
});
}
取两个3x3矩阵的乘积A*B=C.天真地,这需要使用标准算法进行 27次乘法.如果一个人很聪明,你可以只使用23次乘法来做到这一点,这是拉德曼于1973年发现的结果.该技术涉及保存中间步骤并以正确的方式组合它们.
现在让我们修改一个语言和一个类型,比如说C++的元素double.如果Laderman算法是硬编码而不是简单的双循环,那么我们是否可以期望现代编译器的性能能够消除算法的差异？
关于这个问题的注释:这是一个编程站点,问题是在时间关键内循环的最佳实践的上下文中提出的; 过早优化这不是.关于实施的提示非常受欢迎.
我有一个非常大的矩阵(100M行乘100M列),它有很多重复的值,彼此相邻.例如:
8 8 8 8 8 8 8 8 8 8 8 8 8
8 4 8 8 1 1 1 1 1 8 8 8 8
8 4 8 8 1 1 1 1 1 8 8 8 8
8 4 8 8 1 1 1 1 1 8 8 8 8
8 4 8 8 1 1 1 1 1 8 8 8 8
8 4 8 8 1 1 1 1 1 8 8 8 8
8 …algorithm sparse-matrix matrix-multiplication data-structures
我用这个简单的算法进行矩阵乘法.为了更灵活,我使用了包含动态创建数组的matricies对象.
将此解决方案与我的第一个解决方案与静态数组进行比较,速度慢了4倍.我该怎么做才能加快数据访问速度？我不想改变算法.
matrix mult_std(matrix a, matrix b) {
matrix c(a.dim(), false, false);
for (int i = 0; i < a.dim(); i++)
for (int j = 0; j < a.dim(); j++) {
int sum = 0;
for (int k = 0; k < a.dim(); k++)
sum += a(i,k) * b(k,j);
c(i,j) = sum;
}
return c;
}
k和j循环迭代 - >性能改进dim()并operator()() 作为inline- >性能改进现在的表现与现在的表现几乎相同.也许应该有一点改进. …
我有两个函数来查找两个矩阵的乘积:
void MultiplyMatrices_1(int **a, int **b, int **c, int n){
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
c[i][j] = c[i][j] + a[i][k]*b[k][j];
}
void MultiplyMatrices_2(int **a, int **b, int **c, int n){
for (int i = 0; i < n; i++)
for (int k = 0; k < n; k++)
for (int j = 0; j < n; j++)
c[i][j] …我正在努力寻找一种更好的线性回归方法.我一直在使用Moore-Penrose伪逆和QR分解与JAMA库,但结果并不令人满意.将ojAlgo是有用的？我一直在达到我知道不应该存在的准确度限制.该算法应该能够将输入变量的影响降低到零.也许这采取迭代重加权最小二乘的形式,但我不知道该算法,也无法找到它的库.输出应该是权重矩阵或向量,使得输入矩阵与权重矩阵的矩阵乘法将产生预测矩阵.我的输入矩阵几乎总是有多行而不是列.谢谢您的帮助.
对于类,我必须为稀疏矩阵编写自己的线性方程求解器.我可以自由地为稀疏矩阵使用任何类型的数据结构,我必须实现几个解,包括共轭渐变.
我想知道是否有一种着名的方法来存储稀疏矩阵,使得与向量的乘法相对较快.
现在我的稀疏矩阵基本上实现了一个包装std::map< std::pair<int, int>, double>,用于存储数据(如果有的话).这将矩阵与向量的乘法转换为O(n²)复杂度到O(n²log(n)),因为我必须对每个矩阵元素进行查找.我查看了耶鲁稀疏矩阵格式,似乎元素的检索也在O(log(n))中,所以我不确定它是否会更快.
作为参考,我有一个800x800矩阵,填充了5000个条目.使用共轭梯度法大约需要450秒来解决这样的系统.
您认为使用其他数据结构可以更快地完成吗？
谢谢!
c++ matrix linear-algebra sparse-matrix matrix-multiplication
在numpy操作中,我有两个向量,假设向量A是4X1,向量B是1X5,如果我做AXB,它应该得到一个大小为4X5的矩阵.
但我尝试了很多次,进行了多种重塑和转置,它们都会引发错误,说不对齐或返回单个值.
我应该如何得到我想要的矩阵的输出产品？