Java 8矩阵*向量乘法
Java 8矩阵*向量乘法
提问于 2015-12-30 06:15:36
我想知道在Java 8中是否有一种更简洁的方式来对streams执行以下操作：
public static double[] multiply(double[][] matrix, double[] vector) {
int rows = matrix.length;
int columns = matrix[0].length;
double[] result = new double[rows];
for (int row = 0; row < rows; row++) {
double sum = 0;
for (int column = 0; column < columns; column++) {
sum += matrix[row][column]
* vector[column];
}
result[row] = sum;
}
return result;
}进行编辑。我得到了一个非常好的答案，但是性能比旧的实现慢了大约10倍，所以我在这里添加了测试代码，以防有人想要调查它：
@Test
public void profile() {
long start;
long stop;
int tenmillion = 10000000;
double[] vector = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
double[][] matrix = new double[tenmillion][10];
for (int i = 0; i < tenmillion; i++) {
matrix[i] = vector.clone();
}
start = System.currentTimeMillis();
multiply(matrix, vector);
stop = System.currentTimeMillis();
}回答 2
Stack Overflow用户
回答已采纳
发布于 2015-12-30 06:31:37
直接使用Stream的方法如下所示：
public static double[] multiply(double[][] matrix, double[] vector) {
return Arrays.stream(matrix)
.mapToDouble(row -> IntStream.range(0, row.length)
.mapToDouble(col -> row[col] * vector[col])
.sum())
.toArray();
}这将创建矩阵(Stream<double[]>)的每一行的流，然后将每一行映射到使用vector数组计算乘积所得到的双精度值。
我们必须在索引上使用Stream来计算产品，因为不幸的是，没有内置的工具来将两个流压缩在一起。
Stack Overflow用户
发布于 2015-12-31 20:50:29
测量性能的方式并不十分可靠，而且手动编写微基准通常也不是一个好主意。例如，在编译代码时，JVM可能会选择更改执行顺序，而start和stop变量可能没有分配到预期的位置，因此会在测量中产生意想不到的结果。预热JVM也很重要，让JIT编译器进行所有的优化。GC在引入应用程序的吞吐量和响应时间变化方面也扮演着非常重要的角色。我强烈建议使用JMH和Caliper等专门工具进行微基准测试。
我还编写了一些使用JVM预热、随机数据集和更高迭代次数的基准测试代码。事实证明，Java 8 streams提供了更好的结果。
/**
*
*/
public class MatrixMultiplicationBenchmark {
private static AtomicLong start = new AtomicLong();
private static AtomicLong stop = new AtomicLong();
private static Random random = new Random();
/**
* Main method that warms-up each implementation and then runs the benchmark.
*
* @param args main class args
*/
public static void main(String[] args) {
// Warming up with more iterations and smaller data set
System.out.println("Warming up...");
IntStream.range(0, 10_000_000).forEach(i -> run(10, MatrixMultiplicationBenchmark::multiplyWithStreams));
IntStream.range(0, 10_000_000).forEach(i -> run(10, MatrixMultiplicationBenchmark::multiplyWithForLoops));
// Running with less iterations and larger data set
startWatch("Running MatrixMultiplicationBenchmark::multiplyWithForLoops...");
IntStream.range(0, 10).forEach(i -> run(10_000_000, MatrixMultiplicationBenchmark::multiplyWithForLoops));
endWatch("MatrixMultiplicationBenchmark::multiplyWithForLoops");
startWatch("Running MatrixMultiplicationBenchmark::multiplyWithStreams...");
IntStream.range(0, 10).forEach(i -> run(10_000_000, MatrixMultiplicationBenchmark::multiplyWithStreams));
endWatch("MatrixMultiplicationBenchmark::multiplyWithStreams");
}
/**
* Creates the random matrix and vector and applies them in the given implementation as BiFunction object.
*
* @param multiplyImpl implementation to use.
*/
public static void run(int size, BiFunction<double[][], double[], double[]> multiplyImpl) {
// creating random matrix and vector
double[][] matrix = new double[size][10];
double[] vector = random.doubles(10, 0.0, 10.0).toArray();
IntStream.range(0, size).forEach(i -> matrix[i] = random.doubles(10, 0.0, 10.0).toArray());
// applying matrix and vector to the given implementation. Returned value should not be ignored in test cases.
double[] result = multiplyImpl.apply(matrix, vector);
}
/**
* Multiplies the given vector and matrix using Java 8 streams.
*
* @param matrix the matrix
* @param vector the vector to multiply
*
* @return result after multiplication.
*/
public static double[] multiplyWithStreams(final double[][] matrix, final double[] vector) {
final int rows = matrix.length;
final int columns = matrix[0].length;
return IntStream.range(0, rows)
.mapToDouble(row -> IntStream.range(0, columns)
.mapToDouble(col -> matrix[row][col] * vector[col])
.sum()).toArray();
}
/**
* Multiplies the given vector and matrix using vanilla for loops.
*
* @param matrix the matrix
* @param vector the vector to multiply
*
* @return result after multiplication.
*/
public static double[] multiplyWithForLoops(double[][] matrix, double[] vector) {
int rows = matrix.length;
int columns = matrix[0].length;
double[] result = new double[rows];
for (int row = 0; row < rows; row++) {
double sum = 0;
for (int column = 0; column < columns; column++) {
sum += matrix[row][column] * vector[column];
}
result[row] = sum;
}
return result;
}
private static void startWatch(String label) {
System.out.println(label);
start.set(System.currentTimeMillis());
}
private static void endWatch(String label) {
stop.set(System.currentTimeMillis());
System.out.println(label + " took " + ((stop.longValue() - start.longValue()) / 1000) + "s");
}
}以下是输出
Warming up...
Running MatrixMultiplicationBenchmark::multiplyWithForLoops...
MatrixMultiplicationBenchmark::multiplyWithForLoops took 100s
Running MatrixMultiplicationBenchmark::multiplyWithStreams...
MatrixMultiplicationBenchmark::multiplyWithStreams took 89s页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接：
https://stackoverflow.com/questions/34519952
复制相关文章
相似问题
腾讯云开发者
