小编MLe*_*ria的帖子

假设我有这两个矩阵:

double[][] a = new double[2][2]
a[0][0] = 1
a[0][1] = 2
a[1][0] = 3
a[1][1] = 4

double[][] b = new double[2][2]
b[0][0] = 1
b[0][1] = 2
b[1][0] = 3
b[1][1] = 4

以传统方式,总结这个矩阵我会做一个嵌套for循环:

int rows = a.length;
int cols = a[0].length;
double[][] res = new double[rows][cols];
for(int i = 0; i < rows; i++){
    for(int j = 0; j < cols; j++){
        res[i][j] = a[i][j] + b[i][j];
    }
}

我对流API很新,但我认为这非常适合使用,parallelStream所以我的问题是,如果有办法做到这一点并利用并行处理？

编辑:不确定这是不是正确的地方,但我们走了:使用一些建议我把Stream推到测试.设置如下:经典方法:

public class ClassicMatrix …

我有两个数组:

val diceProbDist = new Array[Double](2 * DICE + 1)

和

val diceExpDist = new Array[Double](2 * DICE + 1)

我想合并一个单一的结构(某种元组,也许):

(0, 0.0, 0,0)(1, 0.0, 0.0)(2, 0.02778, 0.02878)...

其中第一个条目是数组索引,第二个条目是第一个数组值,第三个条目是第二个数组值.

是否有一些scala函数可以实现(使用地图或类似的拉链)？

谢谢,ML

假设我有一个int数组,我想找到总和为零的所有对.在过去,我会做这样的事情:

public static int count(int[] a) {
    int cnt = 0;
    int N = a.length;
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N; j++) {

        if (a[i] + a[j] == 0) {
            cnt++;
        }
       }
    }
    return cnt;
    }

现在我在将此转换为流时遇到了一些麻烦.

我尝试了以下方法但是我收到了IllegalStateException:

final IntStream stream1 = Arrays.stream(a);
final IntStream stream2 = Arrays.stream(a);
long res = stream1.flatMap(i -> stream2.filter(j -> (j + i == 0))).count();

我有一个结构List[Array[Double]]，我想转换为 DenseMatrix。我有这个解决方案，但我认为可能有更好的方法：

val data = List[Array[Double]]
val rows = data.length;
val cols = data(0).length;
val matrix = DenseMatrix.zeros[Double](rows, cols)
for (i <- 0 until data.length) {
  for (j <- 0 until data(i).length) {
    matrix(i,j)= data(i)(j)

  }
}

我已经浏览了微风文档，但没有找到任何东西。有没有更好的办法？

假设我有这个数组x:

x = array([1, 2, 3, 4, 5, 6, 7, 8])
x.shape = (8,1)

我想重塑它成为

array([[1, 3, 5, 7], 
       [2, 4, 6, 8]])

这是x上的重塑(2,4)但是直接的方式:

y = x.reshape(2,4)

我变成了

array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

那不是我想要的.有没有办法以特定的方式转换数组？