对两个列表进行元素总和的最快方法

Question

我可以使用 Zipped 函数进行元素运算，例如求和。让我有两个列表 L1 和 L2 如下所示

val L1 = List(1,2,3,4)
val L2 = List(5,6,7,8)

我可以通过以下方式逐元素求和

(L1,L2).zipped.map(_+_)

结果是

List(6, 8, 10, 12) 

正如预期的那样。

我在我的实际代码中使用 Zipped 函数，但它需要太多时间。实际上，我的列表大小超过 1000，并且我有超过 1000 个列表，而且我的算法是迭代的，其中迭代可能高达 10 亿 .

在代码中我必须做以下事情

list =( (L1,L2).zipped.map(_+_).map (_  * math.random) , L3).zipped.map(_+_)

L1、L2和L3的尺寸相同。此外，我必须在集群上执行我的实际代码。

在 Scala 中获取列表元素和的最快方法是什么？

Answer 1

一种选择是使用 Streaming 实现，利用 惰性 可能会提高性能。

使用 LazyList 的示例 （在 Scala 中引入 2.13）。

def usingLazyList(l1: LazyList[Double], l2: LazyList[Double], l3: LazyList[Double]): LazyList[Double] =
  ((l1 zip l2) zip l3).map {
    case ((a, b), c) =>
      ((a + b) * math.random()) + c
  }

还有一个使用fs2.Stream的例子（由fs2库引入）。

import fs2.Stream
import cats.effect.IO

def usingFs2Stream(s1: Stream[IO, Double], s2: Stream[IO, Double], s3: Stream[IO, Double]): Stream[IO, Double] =
  s1.zipWith(s2) {
    case (a, b) =>
      (a + b) * math.random()
  }.zipWith(s3) {
    case (acc, c) =>
      acc + c
  }

---

但是，如果这些仍然太慢，最好的选择是使用普通数组。

这是一个使用 ArraySeq （在 Scala 2.13 中也引入）的示例，它至少会保持不变性。如果您愿意，可以使用原始数组，但要小心。
（如果需要，您也可以使用 collections-parallel module 以提高性能）

import scala.collection.immutable.ArraySeq
import scala.collection.parallel.CollectionConverters._

def usingArraySeq(a1: ArraySeq[Double], a2: ArraySeq[Double], a3: ArraySeq[Double]): ArraySeq[Double] = {
  val length = a1.length

  val arr = Array.ofDim[Double](length)

  (0 until length).par.foreach { i =>
    arr(i) = ((a1(i) + a2(i)) * math.random()) + a3(i)
  }

  ArraySeq.unsafeWrapArray(arr)
}