A veces quieres combinar una secuencia en un solo valor; otras veces quieres ver cada valor intermedio que la combinación produce en el camino. Factor divide esto en dos herramientas: reduce (en sequences) para el plegado a un solo valor, y la familia acumulativa de math.statistics para la forma acumulada.
reduce: el plegado general
reduce ( seq init quot: ( prev elt -- next ) -- result )
reduce recorre una secuencia un elemento a la vez, llevando consigo un resultado acumulado (el acumulador) y pasándolo a una quotation de dos argumentos. La quotation recibe el acumulador actual y el siguiente elemento; lo que deje en la pila se convierte en el nuevo acumulador.
USING: math sequences ;
{ 1 2 3 4 } 0 [ + ] reduce . ! => 10
{ 1 2 3 4 } 1 [ * ] reduce . ! => 24
Una semilla distinta de cero y un combinador personalizado son las partes de reduce a las que sum y product no llegan. Por ejemplo, el valor más grande de una secuencia, con un valor predeterminado por si ningún valor lo supera:
USING: math.order ;
{ 3 1 -4 5 -2 } 0 [ max ] reduce . ! => 5
{ -3 -1 -4 } 0 [ max ] reduce . ! => 0
La semilla 0 participa en la comparación: actúa como resultado cuando todos los elementos pierden, así que una secuencia de valores todos negativos igual produce 0 en lugar de algún valor mínimo arbitrario.
Reducciones acumulativas
A veces quieres cada resultado intermedio, no solo el final. La familia acumulativa de math.statistics devuelve una secuencia de la misma longitud que la entrada, donde cada posición es la reducción sobre el prefijo que termina en esa posición:
cum-sum ( seq -- newseq ) ! running total
cum-product ( seq -- newseq ) ! running product
cum-min ( seq -- newseq ) ! running minimum
cum-max ( seq -- newseq ) ! running maximum
USING: math.statistics ;
{ 3 1 4 1 5 9 2 6 } cum-sum . ! => { 3 4 8 9 14 23 25 31 }
{ 1 2 3 4 } cum-product . ! => { 1 2 6 24 }
{ 3 1 4 1 5 9 2 6 } cum-min . ! => { 3 1 1 1 1 1 1 1 }
{ 3 1 4 1 5 9 2 6 } cum-max . ! => { 3 3 4 4 5 9 9 9 }
Un patrón útil son las reducciones acumulativas encadenadas: la salida de una es a su vez una secuencia, lista para alimentar a otra. Eso hace que «resumen acumulado de un resumen acumulado» se pueda expresar en dos palabras. Las combinaciones son flexibles: combínalas según lo que resuma cada paso.
produce: el despliegue
reduce consume una secuencia y la convierte en un valor. produce (en sequences) va en la otra dirección: genera una secuencia a partir de una semilla probando y avanzando repetidamente:
produce ( pred quot -- seq )
Cada iteración primero ejecuta pred sobre el estado actual; si devuelve un valor verdadero, se llama a quot para producir el siguiente elemento y actualizar el estado. Cuando pred devuelve f, la iteración se detiene y se devuelven los elementos recopilados.
Un ejemplo clásico es la sucesión de Fibonacci (cada número es la suma de los dos anteriores). El estado actual es el par (a, b). Cada paso emite b y luego reemplaza el par por (b, a + b):
USING: kernel math sequences ;
! Fibonacci numbers strictly below 100:
0 1 [ dup 100 < ] [ tuck + over ] produce 2nip .
! => { 1 1 2 3 5 8 13 21 34 55 89 }
El estado actual abarca dos valores, así que el cuerpo usa tuck (en kernel), el barajado de tres elementos que copia el de arriba debajo del segundo, para avanzar el par, y 2nip (también en kernel, el análogo de dos elementos de nip) para dejar todo limpio al final. Si lees la llamada de izquierda a derecha:
- El predicado
[ dup 100 < ] examina la parte superior del par (el siguiente número que se va a emitir) y continúa mientras siga por debajo del límite.
- El cuerpo
[ tuck + over ] avanza el estado a (b, a + b) y emite b, dejando tres valores en la pila: el nuevo par abajo y el número emitido arriba.
- Después de que
produce se detiene, los dos valores sobrantes (el par final) se descartan con 2nip, dejando solo la secuencia producida.
produce es el dual exacto de reduce: donde reduce pliega una secuencia hasta un valor, produce despliega un valor hasta una secuencia.
Ejercicio de aprendizaje
