NetLogo: Listas
Listas
Iteraciones sobre listas
Debido a la estructura de las listas, una de las operaciones más comunes que se realiza sobre ellas es la recursión o iteración. NetLogo incluye algunas funciones que permiten realizar diversos tipos de iteración sobre esta estructura:
- foreach se usa para ejecutar una secuencia de comandos sobre cada elemento de la lista.
foreach ls [proc-anonimo]
Por ejemplo:
foreach [2 4 6] [ x ->
crt x
show (word x " tortugas creadas")]Una forma más compleja de este comando permite usar varias listas de entrada, L_1,..., L_n, no solo una, todas del mismo tamaño, y de forma que en la i-ésima iteración del procedimiento anónimo, que debe tomar n datos de entrada, considera el conjunto de los n elementos i-ésimos de cada lista en el orden dado. Es decir:
(foreach [a_11 ... a_1k] ...[a_n1 ... a_nk] [ [x1 ... xn] -> comandos ] )Por ejemplo:
(foreach [1 2] [3 4]
[[x y] -> print (x * y)]) - map es similar a foreach, pero no devuelve una acción, sino un resultado:
map f [a_0 ... a_n] --> [f(a_0) ... f(a_n)]
Por ejemplo:
map [x -> x + 1] [1 2 3 4] = [2 3 4 5]
map round [1.2 2.4 4.6] = [1 2 5]Al igual que ocurría en el caso anterior, esta función también admite el uso de varias listas de entrada, en este caso:
(map f [a_11 ... a_1k] ...[a_n1 ... a_nk]) = [f(a_11 ... a_n1) ... f(a_1k ... a_nk)]
Por ejemplo:
(map [[x y] -> x * y] [1 2] [3 4]) = [3 8]
Otras funciones que hacen uso de la recursión sobre listas son:
- reduce: Itera el proceso de reducir los dos primeros elementos de la lista en uno por medio de la función f, hasta que devuelve un solo elemento. Es decir:
reduce f [a_0 ... a_n] = f(...f(f(a_0,a_1),a_2),...,a_n)
Por ejemplo:
reduce + [1 2 3 4] = 10
reduce and [True False True True] = False - filter: devuelve la lista formada por los elementos de ls que verifican el predicado.
filter predicado ls
Por ejemplo:
filter [ x -> x > 0 ] [-1 -2 4 5] = [4 5]
- n-values: genera una lista a partir de un procedimiento anónimo
n-values n f = map f [0 ... n-1]
Por ejemplo:
n-values 5 [x -> 2 * x] = [0 2 4 6 8]
- sort-by: ordena la lista haciendo uso del predicado binario que se da como procedimiento anónimo
sort-by predicado [a1 ... an]
Por ejemplo:
sort-by [ [x y] -> first x < first y] [ [2 4] [1 5] [3 3] ] = [ [1 5] [2 4] [3 3] ] sort-by [ [x y] -> last x < last y] [ [2 4] [1 5] [3 3] ] = [ [3 3] [2 4] [1 5] ]
Listas de agentes
Habitualmente, los conjuntos de agentes se toman en orden aleatorio (distinto cada vez que se accede a ellos). A veces puede ser necesario fijar un orden en el conjunto de agentes y para ello trabajamos con lo que se llaman listas de agentes, que no son más que listas de agentes identificados por sus identificadores. Una vez hecho esto, podemos trabajar con la lista de agentes como haríamos con cualquier otra lista, por ejemplo, usando los comando sort y sort-by para ordenarlos, o shuffle para desordenarla aleatoriamente. Se debe recordar que a pesar de que estas funciones pueden recibir como entrada un conjunto de agentes, su devolución es siempre una lista (que no es exactamente lo mismo).
Si se usa sort sobre un conjunto de agentes de tipo tortuga, el resultado es una lista de tortugas ordenadas de forma ascendente por el identificador (el que se almacena en la variable interna de agente who). Si se aplica sobre un conjunto de agentes de tipo patch, el resultado será una lista de patches ordenados de izquierda a derecha y de arriba a abajo. Si se desea el orden inverso, podemos hacer uso combinado del comando reverse.
Lo más probable es que una vez que tengamos una lista de agentes, queramos pedirles que hagan algo. El problema es que el comando ask solo se puede realizar sobre conjuntos de agentes, no sobre listas de agentes. Para conseguir el mismo resultado hemos de combinar el uso de foreach y ask de la siguiente forma:
foreach lista-agentes
[ x -> ask x lista-comandos]
Se debe tener en cuenta que por el método anterior, los agentes de la lista ejecutan los comandos de forma no concurrente, es decir, cada agente ejecuta todos los comandos antes de que comience el siguiente, y siempre se hace el recorrido siguendo el orden que los agentes ocupan en la lista. Si se quiere meter aleatoriedad en este orden de ejecución se puede combinar este esquema con el uso de shuffle.