Scala: Berechnung der gleitenden Summe einer Liste mit einem festen Fenster

Ich bin neu in Scala und möchte eine bewegliche Summe mit einem festen Fenster für eine Liste berechnen.

Beispiel: Angesichts der Listenwerte (1.0, 2.0, 3.0, 6.0, 7.0, 8.0, 12.0, 9.0, 4.0, 1.0) und der Periode 4 sollte die Funktion Folgendes zurückgeben: (1.0, 3.0, 6.0, 12.0, 18.0, 24,0, 33,0, 36,0, 33,0, 26,0)

Wenn list.size <period ist, geben Sie einfach die kumulative Summe zurück.

Ich habe einige Versuche gemacht

def mavg(values: List[Double], period: Int): List[Double] = {
  if (values.size <= period) (values.sum ) :: List.fill(period -1)(values.sum ) else {
      val rest: List[Double] = mavg(values.tail, period)
      (rest.head + ((values.head - values(period)))):: rest
  }
}

Ich habe jedoch

List(12.0, 18.0, 24.0, 33.0, 36.0, 33.0, 26.0, 26.0, 26.0, 26.0

das ist nicht richtig. Ich möchte Pyspark nicht verwenden, um die Ergebnisse zu erhalten. Kann jemand helfen?

Danke vielmals.

  def mavg(values: Seq[Double], period: Int): Seq[Double] = {
    (Seq.fill(math.min(period - 1, values.length))(0.0) ++ values) // padding zeros
      .sliding(period)                  
      .map(_.sum)
      .toSeq
  }

Hier ist eine Möglichkeit, dies zu beheben.

def mavg(values: List[Double], period: Int): List[Double] =
  values.inits    //shrinking list of inits
        .toList   //result type
        .reverse  //growing list of inits
        .tail     //drop the empty one
        .map(_.takeRight(period).sum) //sum the window

testen:

mavg(List(1.0, 2.0, 3.0, 6.0, 7.0, 8.0, 12.0, 9.0, 4.0, 1.0), 4)
//res0: List[Double] = List(1.0, 3.0, 6.0, 12.0, 18.0, 24.0, 33.0, 36.0, 33.0, 26.0)

Dies ist eine andere Möglichkeit, wie Sie dies tun können:

  val l = List(1.0, 2.0, 3.0, 6.0, 7.0, 8.0, 12.0, 9.0, 4.0, 1.0,5.0,1.0,2.0)
  def mavg(step: Int, list: List[Double], ans: List[Double] = List.empty[Double], splitCount: Int = 0): List[Double] = {
    if (list.length > 1) {
      mavg(step - 1, list.take(step), list.sliding(step, 1).toList.map(_.sum) ::: ans, splitCount + 1)
    } else {
      ans.splitAt(splitCount + 2)._1.sliding(1, 2).toList.flatten ::: ans.drop(splitCount + 2)
    }
  }

  val ans = mavg(4, l)
  println(ans)

Ein anderer Ansatz, ähnlich der Antwort von @ User9123

Der Unterschied besteht darin, dass nicht die Summe aller Elemente im Schiebefenster berechnet wird, sondern der Wert des letzten Fensterkopfs von seiner Summe subtrahiert und der Wert des nächsten Fensterkopfs addiert wird, um die nächste rollierende Summe zu erhalten. Dies sollte bei großen Fenstern effizienter sein.

def rollingSum[N](values: Seq[N], period: Int)(
    implicit num: Numeric[N]
): Seq[N] = {
  import num._
  values match {
    case values if period == 1 => values // Can't slide on period 1
    case head :: tail if period < values.size =>
      (Seq.fill(period - 2)(num.zero) ++ (values)) // zero padding
        .sliding(period)
        .foldLeft((num.zero, Seq(head))) { // Use a tuple to store previous head
          case ((prevHead, acc), y) => {
            (y.head, acc :+ acc.last - prevHead + y.last) // do the magic
          }
        }
        ._2 // only return the result
    case head :: tail => tail.scanLeft(head)(_ + _) // Regular cummulative sum
    case Nil          => Nil
  }
}

Ich habe auch einige Schutzvorrichtungen für Sonderfälle hinzugefügt, die behandelt werden müssen, und es zu einer generischen Funktion für alle NumericTypen gemacht.

Hier ist ein laufendes Beispiel mit einigen Testfällen.