Scala: Calculando a soma móvel de uma lista com uma janela fixa

Eu sou novo no Scala e quero calcular uma soma móvel com uma janela fixa para uma lista.

Por exemplo: Dados os valores da lista (1.0, 2.0, 3.0, 6.0, 7.0, 8.0, 12.0, 9.0, 4.0, 1.0) e o período 4, a função deve retornar: (1.0, 3.0, 6.0, 12.0, 18.0, 24,0, 33,0, 36,0, 33,0, 26,0)

Se list.size <period, basta retornar a soma acumulada.

Eu fiz algumas tentativas

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
  }
}

No entanto, eu tenho

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

o que não está correto. Não quero usar o Pyspark para obter os resultados. Alguém pode ajudar?

Muito Obrigado.

  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
  }

Aqui está uma maneira de lidar com isso.

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

teste:

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)

Esta é outra maneira de fazer isso:

  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)

Outra abordagem, semelhante à resposta de @ User9123

A diferença é que ele não calcula a soma de todos os elementos na janela deslizante, mas subtrai o valor do cabeçalho da última janela da sua soma e adiciona o valor do cabeçalho da próxima janela para gerar a próxima soma rolante. Isso deve ser mais eficiente para janelas grandes.

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
  }
}

Também adicionei alguns protetores para casos especiais que precisam ser manipulados e a tornei uma função genérica para todos os Numerictipos.

Aqui está um exemplo em execução com alguns casos de teste.