Escala | función agregada

La función de agregado() se utiliza para combinar resultados. Inicialmente, se aplica una operación de secuencia ya que es el primer parámetro de la función de agregado() y luego le sigue una operación de combinación que se utiliza para combinar las soluciones generadas por la operación de secuencia realizada. Esta función se puede aplicar en todas las estructuras de datos de colección en Scala y se puede practicar en las estructuras de datos de colección tanto mutables como inmutables de Scala. Pertenece al rasgo TraversableOnce en Scala.
Sintaxis:

def aggregate[B](z: => B)(seqop: (B, A) => B, combop: (B, B) => B): B

Dónde,

• B es el tipo de resultados agregados y z es el valor inicial del resultado agregado.
• seqop es un operador para la operación de secuencias y se utiliza para calcular la suma de cada uno de los elementos de la colección indicada y también enumera el número total de elementos de la colección.
• combop es un operador de combinación que se utiliza para combinar los resultados obtenidos por el cálculo paralelo de la colección.

• Cálculo paralelo:
  Let, List = (2, 3, 4, 5, 6, 7, 8)
  Supongamos que tiene tres hilos de la lista indicada anteriormente donde, let el primer hilo es (2, 3, 4), segundo hilo es (5, 6) y el tercer hilo es (7, 8).
  Ahora, realicemos cálculos paralelos.

• First thread = (2, 3, 4) = (2+3+4, 3) = (9, 3)
  // It is evaluated like below,
  // (sum of all the elements, total number of elements)
  

• Second thread = (5, 6) = (5+6, 2) = (11, 2)
  

• Third thread = (7, 8) = (7+8, 2) = (15, 2)
  

  Finalmente, después del cálculo paralelo, tenemos (9, 3), (11, 2) y (15, 2) y ahora este operador de combinación se aplica para combinar los resultados de cada subproceso, es decir,

• (9+11+15, 3+2+2) = (35, 7)

Ahora veamos un ejemplo.
Ejemplo:

// Scala program of aggregate()
// function
  
// Creating an object
object GfG
{
  
    // Main method
    def main(args: Array[String]) 
    {
  
        // Creating a list of numbers
        val s = List(1, 2, 3, 4)
  
        // Applying aggregate function
        val r = s.par.aggregate((0, 0))((s, r) =>(s._1 + r, s._2 + 1), 
                                (s,r) => (s._1 + r._1, s._2 + r._2))
  
        // Displays summation of all the 
        // elements in the list and also
        // total number of elements
        println("(Sum of all the elements , total number of elements) = "+r)
    }
}

(Sum of all the elements, total number of elements) = (10, 4)

Aquí, par implica paralelo que se utiliza para el cálculo paralelo de la lista. discutiremos tres partes en detalle.

aggregate(0, 0)

Esta es la primera parte donde la función de agregado() tiene dos ceros que son los valores iniciales del registro s , por lo que s._1 es el primer cero que se utiliza para calcular la suma de todos los elementos en la lista y s._2 también es cero al principio, lo que ayuda a enumerar el número total de elementos en la lista.

(s._1 + r, s._2 + 1)

Esta es la segunda parte, realiza la operación de secuencia para la lista indicada anteriormente. La primera parte de este código evalúa la suma y la segunda parte es para contar elementos totales. Ahora, veamos la evaluación paso a paso.
Aquí, Lista = (1, 2, 3, 4)

(s._1 + r, s._2 + 1) // (Initially, s._1 and s._2 = 0) 
= (0+1, 0+1) = (1, 1) // r is the initial value of the list
= (1+2, 1+1) = (3, 2)
= (3+3, 2+1) = (6, 3)
= (6+4, 3+1) = (10, 4)

Esto muestra cómo se realiza exactamente la evaluación.

(s._1 + r._1, s._2 + r._2)

Esta es la última parte, se utiliza en la operación combinada, como se indicó anteriormente en el cálculo paralelo . Supongamos que, durante el cálculo paralelo de la lista (1, 2, 3, 4), se divide en dos hilos, es decir, (1, 2) y (3, 4), luego evaluémosla paso a paso.
Primer hilo:

(1, 2) = (1+2, 2) = (3, 2)

Segundo hilo:

(3,  4) = (3+4, 2) = (7, 2)

Ahora, combinemos los dos subprocesos, es decir, (3, 2) y (7, 2) usando el operador de combinación como se indicó anteriormente.

(s._1 + r._1, s._2 + r._2) // s._1 and s._2 = 0
= (0+3, 0+2) = (3, 2)       // r._1 = 3 and r._2 = 2
= (3+7, 2+2) = (10, 4)        // r._1 = 7 and r._2 = 2

Por lo tanto, esta parte funciona así.

A ver, un ejemplo más.
Ejemplo:

// Scala program of aggregate()
// function
  
// Creating an object
object GfG
{
  
    // Main method
    def main(args: Array[String]) 
    {
  
        // Creating a sequence of strings
        val seq = Seq("nidhi", "yes", "sonu", "Geeks")
  
        // Applying aggregate function
        val result = seq.par.aggregate(0)(_ + _.length, _ + _)
  
        // Displays total number of
        // letters used
        println("The total number of letters used are: "+result)
    }
}

The total number of letters used are: 17

Aquí, el valor inicial de la función agregada es cero, que se utiliza para calcular el número total de letras en las strings utilizadas aquí. La longitud del método se utiliza para enumerar la longitud de cada string.
Analicemos en detalle el siguiente código utilizado en el programa anterior.

(_ + _.length, _ + _)

Aquí, Seq = («nidhi», «sí», «sonu», «Geeks»)

Primero realicemos la operación de secuencia.

 (0 + "nidhi".length ) // (0+5) = 5
 (0 + "yes".length)     // (0+3) = 3
 (0 + "sonu".length)       // (0+4) = 4
 (0 + "Geeks".length)        // (0+5) = 5

Por lo tanto, tenemos (5), (3), (4), (5) de la operación de secuencia.
Ahora, realicemos la operación de combinación.

(5+3) = 8 
(4+5) = 9
// Now lets combine it again
(8+9) = 17

Por lo tanto, el número total de letras es 17.