Centro de Investigacin Cientfica y Desarrollo Tecnolgico (I+D) Universidad de Valladolid David Poza

Manual Bsico

Tabla de contenido
1. 2. 3. 4. Manual de Netlogo en espaol ................................................................................................. 2 Qu es Netlogo? Dnde puedo obtener el programa? .......................................................... 2 Introduccin al escenario de simulacin de Netlogo ................................................................. 3 Vistas en Netlogo (1) ................................................................................................................. 4 Ejercicio 1. Primitivas bsicas en la ventana de comandos. .......................................................... 5 Ejercicio 2. Procedimientos ........................................................................................................... 7 Ejercicio 3. Botones ....................................................................................................................... 8 Ejercicio 4. Propiedades de los agentes (1) ................................................................................. 10 Ejercicio 5. Propiedades de los agentes (2) ................................................................................. 12 Ejercicio 6. Propiedades de los agentes (3) ................................................................................. 14 Ejercicio 7. Propiedades de los agentes (4) ................................................................................. 15 Ejercicio 8. Variables globales. Variables de entrada. ................................................................. 17 Ejercicio 9. Variables globales y variables locales. Sentencias condicionales if ........................... 21 Ejercicio 10. Sentencias ifelse. Procedimientos con retorno (to-report) ..................................... 24 Ejercicio 11. Propiedades adicionales de los agentes .................................................................. 26 Ejercicio 12. Razas (breeds) de agentes ................................................................................... 29 Ejercicio 13. Bucles while ............................................................................................................ 31 Ejercicio 14. Representaciones grficas en Netlogo .................................................................... 33 Ejercicio 15. Listas (1) .................................................................................................................. 39 Ejercicio 16. Listas (2) .................................................................................................................. 43 Ejercicio 17. Operaciones sobre listas ......................................................................................... 45

1. Manual de Netlogo en espaol

He preparado un manual de Netlogo en espaol que te permitir familiarizarte con este lenguaje de programacin de una forma muy sencilla, a travs de pequeos programas-ejemplo.

2. Qu es Netlogo? Dnde puedo obtener el programa?

Netlogo es un entorno de programacin que permite la simulacin de fenmenos naturales y sociales. Fue creado por Uri Wilensky en 1999 y est en continuo desarrollo por el Center for Connected Learning and Computer-Based Modeling. Netlogo es particularmente til para modelar sistemas complejos que evolucionan en el tiempo. Los implementadores de modelos pueden dar instrucciones a cientos o miles de agentes para que todos ellos operen de manera independiente, entre s y con el entorno. Esto hace posible explorar la relacin entre el comportamiento a bajo nivel de los individuos y los patrones macroscpicos que surgen a partir de la interaccin de muchos individuos entre s. Netlogo permite a los usuarios abrir simulaciones y jugar con ellas, as como explorar su comportamiento bajo una serie de condiciones. Asimismo, permite al usuario la creacin de sus propios modelos. Netlogo es lo suficientemente sencillo como para que los estudiantes y los profesores puedan ejecutar las simulaciones o incluso construir las suyas propias. Adems, su grado de desarrollo actual es suficiente como para servir como una herramienta potente para investigadores en muchos mbitos. Existe abundante documentacin y tutoriales sobre Netlogo. El programa incluye una galera de modelos (models library), que contiene una amplia coleccin de simulaciones que pueden ser ejecutadas y modificadas. Este conjunto de modelos pertenece a mbitos muy diversos, tanto de la naturaleza como de ciencias sociales (biologa, medicina, fsica y qumica, matemticas y computacin, economa y psicologa social). Existen dos maneras de ejecutar Netlogo: 1. Descargando e instalando el programa (permite simular y editar modelos, as como la creacin de modelos propios). 2. Ejecutar un applet desde una pgina web (permite la ejecucin de los modelos, pero no editarlos ni crear modelos nuevos). El programa puede descargarse de manera gratuita desde aqu. Para su funcionamiento, requiere tener instalada en el ordenador una mquina virtual de Java (JVM - Java Virtual Machine) versin 1.4.2 o superior. En la versin de descarga para Windows existe la opcin de descargar una versin que incluye la JVM necesaria.

3. Introduccin al escenario de simulacin de Netlogo

Netlogo es un lenguaje de programacin que sigue la filosofa del modelado basado en agentes. Concretamente, en Netlogo existen 3 tipos de agentes:

Turtles (tortugas). Patches (celdas). Links (relaciones entre tortugas). Observer (observador).

Las tortugas son los agentes que se mueven por el mundo. Interaccionan entre s y con el medio. Cada tortuga viene identificada por un identificador que es nico para cada tortuga. Netlogo denomina mundo (world) al terreno en el que se mueven las tortugas. Cada porcin cuadrada de mundo se denomina patch. Cada patch est identificado por las coordenadas de su punto central. Las tortugas se mueven por el mundo (y, por tanto, por encima de los patches). Las tortugas interaccionan entre s segn unas reglas de comportamiento y con el medio (es decir, con los patches). Se pueden modelar la relacin entre distintas tortugas mediante links, que es el tercer tipo de agente presente en Netlogo. Los links se designan mediante un par (tortuga1, tortuga2), que indica las dos tortugas relacionadas mediante dicho link. Finalmente, la ltima figura presente en los modelos de Netlogo es el observador. ste no est representado en el mundo, pero puede interactuar con l (crea y destruye agentes, asigna propiedades a los agentes, etc).

4. Vistas en Netlogo (1)

Cuando arranquemos Netlogo, la pantalla de nuestro ordenador presentar el siguiente aspecto:

En la parte superior observamos tres pestaas: interface (interfaz), information (informacin) y procedures (procedimientos). Aunque lo veremos con mayor detenimiento prximamente, en la primera de las pestaas (interface) ser donde se represente nuestro modelo. En la segunda pestaa (information) podremos aadir informacin sobre nuestro modelo para informar a los usuarios:

y en la ltima pestaa (procedures) escribiremos los procedimientos que se encargarn de llevar a cabo la ejecucin de nuestro modelo:

Ejercicio 1. Primitivas bsicas en la ventana de comandos.

Para crear tortugas, usamos la primitiva create-turtles ( crt en abreviatura), seguido del nmero de tortugas que queremos crear. Ejemplo: crt 2 ; crea dos tortugas (equivalente: create-turtles 2) Se generarn dos tortugas en el centro de coordenadas. Podemos pedir a los agentes que realicen acciones. Para ello usamos la primitiva ask seguida del agente (o agentes) a los que vamos a ordenar la accin y, a continuacin, entre corchetes, la accin a realizar por el / los agente(s). Algunas de estas primitivas se muestran a continuacin: (en cada caso, se indica entre parntesis el comando abreviado correspondiente, de existir) forward ; (fd) avanzar back ; (bk) retroceder left ; (lt) giro a la izquierda right ; (rt) giro a la derecha repeat ; repetir un conjunto de primitivas pen-up ; (pu) subir el lpiz (los agentes no deja huella al moverse) pen-down ; (pd) bajar el lpiz (los agentes dejan trazos al moverse) clear-all; (ca) se resetean variables, se limpia el mundo, se borran grficas, etc. Nota: En Netlogo, para introducir un comentario detrs de una lnea de cdigo, se emplea punto y coma (;) antes del comentario. Prueba a escribir lo siguiente en la ventana de comandos (lnea a lnea) y observa lo que ocurre:

Ejercicio 2. Procedimientos
Un procedimiento en un nuevo comando definido por el programador que engloba un conjunto de comandos de Netlogo (esto es anlogo al concepto de funcin en otros lenguajes de programacin). A continuacin crearemos un nuevo procedimiento llamado comenzar. Dicho procedimiento englobar los comandos que utilizamos en el ejercicio anterior, es decir, crear una tortuga, y sta dibujar un cuadrado. Seleccionamos la pestaa procedures en la pantalla de Netlogo y escribimos lo siguiente:

Observa que para iniciar la definicin de un proceso utilizamos la palabra to seguida del nombre que queramos dar al procedimiento. Despus introducimos el conjunto de comandos que componen la primitiva y finalmente cerramos la definicin del procedimiento con la palabra end. Para ejecutar el comando, debes ir a la pestaa interface, y, en la lnea de comandos, teclear el nombre del procedimiento que acabas de crear (comenzar). Pulsa enter y observa lo que ocurre.

Ejercicio 3. Botones
El objetivo de este ejercicio es crear un botn para que al pulsarlo se ejecute el procedimiento creado en el ejercicio anterior. En la pestaa interface, en el men desplegable de la parte superior de la pantalla, elegimos button. A continuacin hacemos clic en el punto de la pantalla en el que deseemos colocar el botn. En el campo de comandos (commands) escribimos los comandos que queremos que se ejecuten al presionar el botn (en este caso escribiremos comenzar, sin comillas, para que se ejecute el procedimiento que acabamos de crear). Opcionalmente, en el campo display name puede escribirse el nombre que queremos que se muestre sobre el botn. Tambin podemos asignar al botn una tecla del teclado para no tener que utilizar el ratn. Para ello, introduce la tecla deseada en el campo action key. La pantalla debera mostrar un aspecto semejante al que se muestra a continuacin:

Marcar la casilla "Forever" provocar que el procedimiento "comenzar" se repitiera una y otra vez, hasta que pulsramos de nuevo el botn COMENZAR, momento en el que el programa terminar. En cambio, si dejamos esta casilla sin marcar, cada vez que pulsemos el botn COMENZAR, se llamar al procedimiento "comenzar" una sola vez, por lo que se dibujar el

cuadrado una sola vez y el programa terminar. Esto es til para simulaciones paso a paso, y es lo que emplearemos en el programa que estamos elaborando. Cuando hayas terminado, pulsa ok. Aprieta el botn y observa lo que ocurre.

Ejercicio 4. Propiedades de los agentes (1)

Cada uno de los agentes que creamos, ya sean tortugas, patches o links, tienen una serie de propiedades. Algunas de estas propiedades vienen predefinidas en Netlogo. Por ejemplo, las tortugas tienen las siguientes propiedades predefinidas: who ;; identificador (no se puede modificar) color ;; color heading ;; orientacin xcor ;; coordenada x ycor ;; coordenada y shape ;; forma label ;; etiqueta label-color ;; color de la etiqueta breed ;;raza hidden? ;; visible o no visible? size ;; tamao pen-size ;; tamao del trazo al desplazarse (cuando pen-mode=down) pen-mode ;; dejar trazo al desplazarse o no? Para ver las propiedades de cada tortuga en cada momento, no tenemos ms que colocar el puntero del ratn sobre la tortuga y hacer clic en el botn derecho del ratn. Aparecer una ventana. Deberemos seleccionar turtle x, y, a continuacin, inspect turtle x (x es el identificador de la tortuga sobre la que hemos colocado el puntero del ratn). Emerger una ventana con las propiedades de la tortuga seleccionada en el momento actual:

Ms adelante veremos cmo aadir nuevas propiedades a los agentes.

10

Los patches tambin tienen sus propiedades: pxcor ;; coordenada x del patch pycor ;; coordenada y del patch pcolor ;; color del patch plabel ;; etiqueta del patch plabel-color ;; color de la etiqueta del patch En este ejercicio, modificaremos el procedimiento del ejercicio 3 para que el cuadrado est alineado con los ejes de coordenadas. El color del cuadrado no puede ser aleatorio, sino que debe ser definido de antemano. Adems, podremos el mundo de color azul (es decir, modificaremos la propiedad pcolor de todos los patches para que stos sean de color azul). Debemos partir del ejercicio anterior y modificar el procedimiento comenzar (en la pestaa procedures).

El resultado debera ser semejante al que se muestra a continuacin:

Observacin: Tambin es posible asignar propiedades a los agentes justo en el momento de crearlos. Comparemos las siguientes rdenes: OPCIN 1: crt 1 ask turtles [set color orange set heading 0] OPCIN 2: crt 1 [set color orange set heading 0]

En el caso de la opcin 1, en primer lugar se crea la tortuga (y se le asignan los parmetros por defecto, es decir, color y orientacin aleatorias) y, despus, con la segunda lnea de cdigo, se modifican las propiedades color y heading. En cambio, con la opcin 2, la tortuga se est creando directamente con las propiedades de color y heading definidas por el programador.

11

Ejercicio 5. Propiedades de los agentes (2)

En este ejercicio vamos a repasar rpidamente cmo modificar las propiedades de los agentes. Adems, vamos a distinguir cmo dar rdenes a un agente o a un conjunto de agentes. Practica escribiendo las siguientes rdenes en la ventana de comandos de Netlogo: En primer lugar crearemos 5 tortugas y las desplazaremos 5 unidades: crt 5 ask turtles [fd 5] Nota: Hasta ahora hemos visto cmo dar rdenes a todas las tortugas que hay en el mundo. Ahora consideraremos cmo dar rdenes a una tortuga en concreto. Como ya hemos visto, cada tortuga que creamos en Netlogo est representada por un identificador (who). La primera tortuga que creemos tendr el identificador 0 (who = 0), la segunda 1 (who=1) y as sucesivamente. En este ltimo ejemplo, hemos creado 5 tortugas, por lo que para referirnos a cada una de ellas deberemos emplear turtle 0, turtle 1, turtle 2, turtle 3 turtle 4 en funcin de a qu tortuga nos estemos refiriendo. Vamos a colocar la tortuga 2 en el punto x = 3 ; y = 4 ask turtle 2 [set xcor 3 set ycor 4] ;; equivalente: ask turtle 2 [setxy 3 4] Vamos a dar forma de tortuga a la tortuga 2: ask turtle 2 [set shape turtle] Aumentamos el tamao de esta misma tortuga: ask turtle 2 [set size 2] Pedimos a la tortuga 2 que nos muestre su identificador ask turtle 2 [show who]

12

Nota: Para ver las formas que pueden adoptar las tortugas (y tambin para crear las nuestras propias) debemos seleccionar tools en la barra de men, y a continuacin en turtle shapes editor.

13

Ejercicio 6. Propiedades de los agentes (3)

Acceso al contenido de las propiedades de un agente. En este ejercicio vamos a aprender a acceder a las propiedades de un agente. Escribe un procedimiento que cree 5 tortugas, cada una de ellas de un tamao distinto. Al ejecutar el procedimiento, en la ventana de comandos cada tortuga debe decir su identificador y qu tamao tiene.

Comentarios:
1. Sintaxis para acceder a las propiedades de un agente: [propiedad] of agente 2. Para mostrar un mensaje en la ventana de comandos: type mensaje y print mensaje. La diferencia entre ambas primitivas es que print hace un retorno de carro al final del mensaje y type no.

14

Ejercicio 7. Propiedades de los agentes (4)

Discriminacin de agentes por sus propiedades. Hasta el momento, para identificar a los agentes, o bien les hemos llamado a todos a la vez: ask turtles [comandos] ;; pedimos a todas las tortugas que ejecuten ciertos comandos ask patches [comandos] ;; pedimos a todos los patches que ejecuten ciertos comandos o bien les hemos llamado por su identificador (who en el caso de las tortugas, [pxcor pycor] en el caso de los patches): ask turtle 5 [fd 5] ;;pedimos que slo la tortuga 5 avance 5 posiciones ask patch 3 4 [set pcolor blue] ;;pedimos que slo el patch [3 4] se ponga azul Cmo seleccionamos un conjunto de agentes que tienen una propiedad concreta? Es decir, cmo seleccionaramos por ejemplo todas las tortugas de color rojo o todos los patches que tengan coordenadas x positivas? Para hacer esta distincin de los agentes a partir de sus propiedades, se utiliza la primitiva with. La sintaxis es la siguiente: ask agentes with [propiedad] [acciones] A continuacin se muestran unos ejemplos de cmo hacer uso de esta primitiva. Escrbelos paso a paso en la ventana de comandos para familiarizarte con el uso de la primitiva with. PASO 1. Creamos 2 tortugas de tamao 1, las situamos en una posicin aleatoria del mundo y las pintamos de rojo. crt 2 [set shape "turtle" set size 1 set xcor random-pxcor set ycor random-pycor set color red] PASO 2. Creamos 2 tortugas de tamao 2, las situamos en una posicin aleatoria del mundo y las pintamos de azul crt 2 [set shape "turtle" set size 2 set xcor random-pxcor set ycor random-pycor set color blue] PASO 3. Creamos 2 tortugas de tamao 3, las situamos en una posicin aleatoria del mundo y las pintamos de blanco crt 2 [set shape "turtle" set size 3 set xcor random-pxcor set ycor random-pycor set color white] PASO 4. Pedimos a las tortugas rojas que avancen 5 posiciones. ask turtles with [color = red] [fd 5] PASO 5. Pedimos a las tortugas azules que adquieran tamao 4. ask turtles with [color = blue] [set size 4] PASO 6. Pedimos a las tortugas blancas que muestren soy blanca como etiqueta. ask turtles with [color = white] [set label soy blanca show label] PASO 7. Pedimos a las tortugas que tengan coordenada y positiva que avancen 3 posiciones. ask turtles with [ycor > 0] [fd 3]

15

PASO 8. Pedimos a los patches que tengan coordenada x negativa que se vuelvan de color amarillo. ask patches with [pxcor <0] [set pcolor yellow]

16

Ejercicio 8. Variables globales. Variables de entrada.

Una variable global es aqulla cuyo valor es accesible por todos los procedimientos que se creen dentro de un mismo programa de Netlogo. Un caso particular de variable global son las variables de entrada, denominadas as porque son introducidas por el usuario desde la interfaz del programa. En este ejercicio vamos a modificar el cdigo del procedimiento del ejercicio 4 para permitir que la longitud del lado del cuadrado pueda ser elegido por el usuario en la vista interfaz: Por tanto, puede resultarte til partir del archivo correspondiente al ejercicio 4. En concreto, lo que buscamos es que la longitud del cuadrado, en lugar de ser fija como en el ejercicio 4, pueda ser introducida mediante:

Ejercicio 8.nlogo - Un botn input - Una barra desplazadora (slider) - Un botn chooser Introduce estos 3 tipos de botones en la vista interfaz (interface) de la misma manera que introdujiste el botn del ejercicio 4. Observa la siguiente captura de pantalla:

17

Al colocar el botn input, se te pedir que le des un nombre a la variable global asignada a dicha entrada. Introduce el nombre lado, tal como se indica en la siguiente figura. Puesto que se trata de un nmero, elige number en el campo type:

Ahora introduciremos una barra desplazadora (slider) de la misma manera:

18

En la ventana que aparece, escribimos lado en el campo global variable y en la siguiente lnea el intervalo en el que puede elegirse el lado del cuadrado. Escoge un mnimo de 1, un mximo de 10 y un incremento de 1, para poder incrementar el lado del cuadrado de uno en uno. Finalmente, en el campo value, escoge 5 (este es el valor que se tomar la variable lado por defecto). A continuacin, introduciremos un men desplegable (chooser), de una manera totalmente similar:

En el campo global variable, escribe lado. En el campo choices, escribe los posibles valores que pueden tomar el lado del cuadro (en este caso 1, 2, 3, 4, 5, 6, 7, 8, 9 10). Finalmente, introduciremos una nota de texto sobre cada botn introducido. Para ello, elige la opcin note en el men desplegable de dnde has sacado el resto de los botones:

19

Por ltimo, modifica el procedimiento que creaste en el ejercicio 4 de la siguiente forma:

Vuelve a la pestaa interface, haz clic en el botn comenzar y observa lo que ocurre.

20

Ejercicio 9. Variables globales y variables locales. Sentencias condicionales if

El objetivo de este ejercicio es crear un procedimiento que dibuje un polgono de n lados y con una longitud de lado dada. Aprovecharemos este ejemplo para distinguir entre variables globales y locales en Netlogo, as como para presentar la sentencia condicional if.

Qu diferencia hay entre una variable global y una variable local? Las variables globales son accesibles para todos los procedimientos del programa, mientras que las variables locales slo tienen validez dentro de un mismo procedimiento. Otra diferencia es que las variables globales hay que declararlas (es decir, tenemos que decirle a Netlogo al principio del programa que vamos a utilizar una variable global de cierto nombre, aunque el valor se lo asignemos posteriormente). Las variables locales, en cambio, no se declaran al principio del programa, sino que se crean y se les asigna un valor segn se va necesitando a lo largo del programa. Para declarar una variable global, utilizaremos la primitiva globals, y, entre corchetes, el nombre de las variables globales que vayamos a utilizar en nuestro programa: globals [ variable_global_1 variable_global_2 variable_global_n ] Para asignar un valor a una variable global, se utiliza la primitiva set (recuerda: la misma que se utilizaba para dar valores a las propiedades de los agentes): set variable_global_1 5 ;; asignamos el valor 5 a la variable variable_global_1

21

Para asignar un valor a una variable local, por primera vez, se utiliza la primitiva let. Si a lo largo del mismo procedimiento debemos asignar un nuevo valor a esta variable, entonces utilizaremos la primitiva set: let variable_local 5 ;; asignamos el valor 5 a la variable ;; comandos set variable_local 7 ;; asignamos el valor 7 a la variable Nota: Si recuerdas, en el ejercicio 8 ya utilizamos variables globales. Entonces dijimos que la variable lado era una variable global. Sin embargo, en aquel caso no la tenamos que declarar dentro del cdigo del programa, ya que sta quedaba definida dentro de un botn (input, slider, chooser), por lo que el programa se encargaba de declararla de forma interna. Una vez hechas estas observaciones, comenzaremos a programar nuestro modelo. El cdigo se muestra a continuacin: El cdigo del procedimiento se muestra a continuacin:

Observa la sintaxis de las sentencias condicionales if: if condicin [ ;; comandos ]

22

Si se cumple la condicin que sigue a if, entonces se ejecutarn el conjunto de comandos que escribamos a continuacin, entre corchetes. Si no se cumple, no se ejecutarn dichos comandos. Nota: El hecho de emplear n como una variable global en este ejemplo es simplemente ilustrativo: ya que slo existe un procedimiento en nuestro programa, podramos haber utilizado una variable local en su lugar. Una vez escrito el procedimiento, en la vista interfaz debers introducir un botn que inicialice el procedimiento, una barra desplazadora para elegir el lado del polgono y un men desplegable para elegir el polgono a dibujar, de la misma manera que lo hemos hecho en ejercicios anteriores. Los valores de lado debern ser 1, 2, 3, 4, 5 6. Presta atencin a la configuracin del botn chooser. Las posibles opciones han de escribirse entre comillas:

Ejecuta el programa probando los distintos polgonos y tamaos.

23

Ejercicio 10. Sentencias ifelse. Procedimientos con retorno (to-report)

En el ejercicio 9 introdujimos las sentencias condicionales if. En este ejercicio utilizaremos la sentencia condicional ifelse. Si recordamos, cuando emplebamos la sentencia if, si se cumpla la condicin que prosegua a if, se ejecutaban un conjunto de comandos que escribamos entre corchetes, y, si no se cumpla, no se haca nada: el programa ignoraba los comandos escritos entre corchetes. La filosofa de la sentencia ifelse consiste en que si se cumple una determinada condicin, se ejecutarn una serie de comandos (al igual que ocurra con if) pero si no se cumple, en lugar de no hacer nada, se ejecutarn otra serie de comandos. Su sintaxis es la que se muestra a continuacin:

Con procedimientos con retorno, nos referimos a aquellos que devuelven cierto valor al procedimiento que les ha llamado. Un procedimiento con retorno (a diferencia de un procedimiento convencional) comienza con la palabra clave to-report y termina con la palabra end. La variable o valor que devuelve al procedimiento llamante va precedido de la palabra clave report. La sintaxis genrica de este tipo de procedimientos es la que se muestra a continuacin:
to-report nombre_del_procedimiento [valor_recibido_del_procedimiento_llamante] ;; comandos ;; [...] report valor_resultante end

Aclaremos todo esto con un programa sencillo: elaboraremos un procedimiento que recibir un nmero y nos devolver su valor absoluto. El cdigo es el siguiente (escrbelo en la pantalla de procedimientos):
to-report valor_absoluto [numero] ifelse numero >= 0 [ report numero ] [ report (-1) * numero ] end

A continuacin, escribe lo siguiente en la ventana de comandos, para probar el correcto funcionamiento del procedimiento que has elaborado:

24

show valor_absoluto (5) how valor_absoluto (-5)

25

Ejercicio 11. Propiedades adicionales de los agentes

En el ejercicio 4 vimos que cada agente (ya sea tortuga, patch o link) tiene una serie de propiedades intrnsecas. Por ejemplo, las tortugas tienen las siguientes propiedades por defecto: who ;; identificador (no se puede modificar) color ;; color heading ;; orientacin xcor ;; coordenada x ycor ;; coordenada y shape ;; forma label ;; etiqueta label-color ;; color de la etiqueta breed ;;raza hidden? ;; visible o no visible? size ;; tamao pen-size ;; tamao del trazo al desplazarse (cuando pen-mode=down) pen-mode ;; dejar trazo al desplazarse o no? Nosotros podemos aadir propiedades adicionales a los agentes. Por ejemplo, supn que ests haciendo un estudio sobre tortugas y que te resulta interesante poder asignarle a cada tortuga una edad. Para aadir una propiedad adicional a un agente, se utiliza la primitiva own. Veamos cmo se aade la propiedad edad a una tortuga: turtles-own [edad] ;; aadimos la propiedad edad al conjunto de propiedades de las tortugas. Para fijar ideas, crea este sencillo procedimiento:

Despus, en la ventana de comandos escribe comenzar para ejecutar el procedimiento que acabas de crear. Vers que se muestra, en primer lugar, el agente al que hemos pedido que ejecute la accin y, a continuacin, la propiedad que le hemos mandado mostrar (en este caso edad).

26

Si recuerdas, en casos anteriores, para mostrar las propiedades de un agente en la ventana de comandos emplebamos la primitiva print (ver ejercicio 6). La diferencia entre print y show es que con show se muestra el agente llamado, mientras que con print no. Ambas dejan un retorno de carro al final. Para comprobar esta diferencia, puedes sustituir la lnea de cdigo ask turtles [show edad] por la siguiente: ask turtles [print edad] Como alternativa, se propone colocarle la edad a las tortugas del ejercicio 7. Vea que sucede y analice los cambios en las edades de las tortugas: Porqu tienen edades diferentes a las asignadas?

27

28

Ejercicio 12. Razas (breeds) de agentes

Hasta el momento, hemos supuesto que todas las tortugas que empleamos en el modelo van a tener el mismo tipo de propiedades. Por ejemplo, en el ejercicio 11 creamos una propiedad adicional (edad) para todas las tortugas. Sin embargo, supongamos que en nuestro modelo necesitamos dos tipos de agentes lo suficientemente diferenciados como para que cada uno de ellos tenga unas propiedades diferentes. A cada tipo de agente con propiedades diferenciadas, Netlogo lo denomina raza (breed). Para definir una raza, utilizaremos la primitiva breed y, a continuacin, entre corchetes, indicaremos el nombre del conjunto de agentes de la nueva raza (en plural) y el nombre del agente de la nueva raza (en singular). Por ejemplo, para definir la raza coches emplearemos la siguiente lnea de cdigo: breed [coches coche] Para asignar nuevas propiedades a la nueva raza de agentes, procederemos de la misma forma que en el ejercicio 11, utilizando la primitiva own. Por tanto, para aadir la propiedad edad a la raza coche, emplearemos la siguiente sentencia: coches-own [edad] Una vez creada la nueva raza, podemos decirle a Netlogo la forma que debe dar a los agentes de esta raza cada vez que le mandemos crear alguno de ellos. Para ello se emplea la primitiva set-dafault-shape. Por ejemplo, para que los agentes de la raza coche tengan forma de coche por defecto cada vez que los creemos, deberemos usar la siguiente sentencia: set-default-shape coches car Para crear los agentes de la nueva raza, usaremos la primitiva create seguida de un guin y el nombre de la raza. Por ejemplo, para crear 20 coches emplearemos la siguiente codificacin: create-coches 20 Para pedir a los agentes de una raza concreta que realicen alguna accin, empleamos la primitiva ask seguido de la raza y, a continuacin, entre corchetes, las acciones a realizar. Por ejemplo, para pedir a los coches que avancen 10 posiciones, emplearemos: ask coches [fd 10] En el siguiente ejemplo crearemos dos razas de agentes distintas: por un lado una raza coches" con la propiedad edad y una raza flores con la propiedad planta. Asignaremos formas distintas a los agentes de las dos razas y finalmente ordenaremos acciones distintas a cada raza de agentes.

29

Al ejecutar el modelo la aplicacin tenemos:

30

Ejercicio 13. Bucles while

En este ejercicio introduciremos la primitiva while. Esta primitiva sirve para repetir un conjunto de acciones mientras se cumpla una determinada condicin. En el ejercicio 1 ya empleamos una primitiva que nos permita repetir un nmero de comandos: la primitiva repeat. Sin embargo, con repeat, el nmero de veces que se repiten los comandos ha de ser un nmero fijo (no se evala ninguna condicin para ejecutar el conjunto de comandos a repetir), mientras que con while s que se evala una condicin: si se cumple la condicin se entra en el bucle si no se cumple se sale del bucle. Su sintaxis es la que se muestra a continuacin:
while condicin ;; comandos ]

Comprala con la sintaxis de la primitiva repeat:

repeat n ;; n es el nmero de veces que queremos que se repita el conjunto de comandos [ ;; comandos ]

Para ilustrar el funcionamiento de los bucles while, vamos a construir un pequeo modelo. En l crearemos dos coches que, partiendo del lado izquierdo del mundo debern alcanzar el lado derecho del mundo avanzando una distancia aleatoria en cada iteracin.

El cdigo se muestra a continuacin:

31

En primer lugar definimos la raza coches con la palabra clave breed. En este modelo tenemos dos procedimientos, el primero de ellos llamado setup y el segundo llamado go. Esto es muy comn en los sistemas modelados en Netlogo. En general, el procedimiento setup inicializa las variables, los agentes, las grficas, la interfaz, etc. y prepara el terreno para que el procedimiento go ejecute la simulacin del modelo. En nuestro caso, el procedimiento setup define la forma por defecto de la raza coches, pinta el mundo de color blanco, crea dos coches, cada uno de un color y los coloca en la parte izquierda del mundo. El procedimiento go se encarga de hacer avanzar los coches hasta que uno de ellos alcanza la parte derecha del mundo. Observa que la condicin para que el bucle while se siga ejecutando es que todos los coches tengan una coordenada x inferior a la coordenada x del patch situado ms a la derecha del mundo (max-pxcor) Observa tambin cmo funciona la primitiva all?, que sirve para evaluar las propiedades de todo un conjunto de agentes. No olvides crear dos botones en la vista interfaz: uno que ejecute el procedimiento setup y otro que ejecute el procedimiento go.

Ejecuta el modelo, para ello pulsa primeramente el botn setup, para preparar el modelo. Finalmente pulsa el botn go, para iniciar la simulacin. Es posible que tengas que bajar la velocidad de la simulacin para poder ver cmo se desplazan los coches a lo largo del mundo. Puedes descargarte el cdigo fuente del programa en la seccin de 'Archivos adjuntos', al final de esta pgina.

32

Ejercicio 14. Representaciones grficas en Netlogo

Para realizar este ejercicio partiremos del cdigo del ejercicio anterior (ejercicio 13). Lo que pretendemos hacer es representar grficamente la distancia que avanza cada uno de los coches del ejercicio anterior en cada iteracin.

Para ello, lo primero ser colocar un grfico en la vista interfaz. Las grficas se introducen de la misma manera que los botones, barras desplazadoras (sliders), etc. Selecciona plot tal como se muestra en la siguiente captura de pantalla:

Coloca la grfica en un hueco libre de la interfaz. Automticamente se abrir una ventana con las propiedades de la grfica, que deberemos rellenar:

33

En el campo name introduciremos un nombre para esta grfica. Escribe Distancia (sin las comillas). Debemos recordar el nombre que introducimos aqu, ya que lo utilizaremos en el cdigo del programa para indicarle a Netlogo dnde debe dibujar. A continuacin, las lneas X axis label y Y axis label nos permiten introducir una etiqueta para los ejes de coordenadas, as como definir el rango en el que stos estarn definidos. En un primer momento no modificaremos estos parmetros. Ahora nos centraremos en el campo Plot Pens, que nos permitir seleccionar lpices de distintos colores para los distintos datos que podemos representar dentro de una misma grfica. Como el primero de los coches (coche 0) tiene color verde, representaremos su distancia avanzada en cada iteracin mediante trazos verdes en el grfico que hemos creado. Para ello, pulsamos el botn create. Aparecer una ventana en la que deberemos introducir un nombre para el lpiz que estamos creando. Introduce coche1 en este campo, tal como se indica en la siguiente captura de pantalla: A continuacin elige el color verde para este lpiz:

34

Repite los mismos pasos para crear un lpiz para el segundo coche (coche1). Haz que este lpiz sea de color naranja, para que coincida con el color del coche.

35

Finalmente escoge el lpiz default y elimnalo del conjunto de lpices. Para ello pulsa el botn delete.

En la lista desplegable de lpices slo deberan quedar los lpices correspondientes a coche0 y coche1. Marca la casilla show legend y pulsa el botn ok para finalizar.

Ahora introduciremos un nuevo procedimiento llamado grafica en el cdigo del ejercicio 13. El cdigo correspondiente al ejercicio 14 se muestra a continuacin. Puedes descargrtelo en la seccin de 'Archivos adjuntos' al final de esta pgina.

36

37

Observaciones: Hemos aadido el cdigo del procedimiento grafica al final del cdigo del ejercicio 13. Para llamar a este procedimiento dentro del procedimiento go, simplemente intercalamos el nombre del procedimiento grafica en el cdigo del procedimiento go. El procedimiento grafica necesita conocer la distancia avanzada por los coches (variables distancia_coche_1 y distancia_coche_2) para poder realizar el grfico. En el ejercicio 13, estas dos variables estaban definidas como variables locales, dentro del procedimiento go, ya que solamente se iban a emplear dentro de este procedimiento. Sin embargo, en este ejercicio, el procedimiento tanto el procedimiento go como el procedimiento grafica necesitan acceder al contenido de estas variables. Por ello, tendremos que definir estas dos variables como variables globales. Esto lo haremos al principio del programa empleando la palabra clave globals:
globals [ distancia_coche_1 distancia_coche_2 ]

Como ya dijimos anteriormente en este tutorial, para asignar un valor a una variable global empleamos la primitiva set (observa la diferencia con las variables locales, para las cuales se emplea la primitiva let). Fijmonos en la diferencia en la forma de asignar valores a las variables distancia_coche_1 y distancia_coche_2 en el ejercicio 13 (variables locales) y en el ejercicio 14 (variables globales):

EJERCICIO 13 (variables locales)

EJERCICIO14 (variables globales)

globals [ distancia_coche_1 distancia_coche_2 ] ;; [ . . .]

let distancia_coche_1 random 3 let distancia_coche_2 random 3

set distancia_coche_1 random 3 set distancia_coche_2 random 3

Haz clic en setup, despus en go y observa cmo se va trazando la grfica a medida que los coches avanzan.

38

Ejercicio 15. Listas (1)

Concepto de lista Una lista es una estructura de datos que nos permite almacenar varios elementos de informacin como un nico objeto. El concepto de lista en Netlogo es equivalente al concepto de vector o array en otros lenguajes de programacin. En Netlogo, las listas se representan con dos corchetes entre los cuales se introducen los elementos que componen dicha lista. Ejemplos de lista son [3 6 83 4 2] [a f h o] [3 1 hola 4 1]. Un factor a tener en cuenta es que Netlogo comienza a numerar las listas a partir del elemento 0. Es decir, que, por ejemplo, para la lista [12 4 5], 12 sera el elemento 0; 4 el elemento 1 y 5 el elemento 2. Cmo construir una lista? Depende de si los datos que componen la lista son conocidos a priori o no. Si los datos son conocidos: Para crear una lista, simplemente escribiremos entre corchetes los datos individuales que queremos que formen parte de la lista. Por ejemplo, para crear una lista llamada a con los elementos 1 2 3 4 5 6 7 simplemente escribiremos: let a [1 2 3 4 5 6 7] Si los datos que forman la lista no son conocidos: Si los datos que van a formar parte de la lista no son conocidos a priori, sino que son variables del programa (caso ms habitual), deberemos emplear la primitiva list: list recibir una serie de argumentos y nos devolver una lista con los estos argumentos en el mismo orden en que se los hemos pasado. La sintaxis de list depende del nmero de argumentos que recibe: Si recibe 2 argumentos, simplemente escribiremos los argumentos entre corchetes: list [a b] ;; nota: a y b son nmeros o variables Si recibe 3 o ms argumentos, escribiremos list seguido de los argumentos que compondrn la lista, sin corchetes y con parntesis englobando toda la sentencia (inluida la primitiva list): (list a b c d e f g h i j k) variables ;; nota: a, b, c, d, e, f, g, h, i, j, k son nmeros o

Cmo acceder a los elementos de una lista? Para acceder al primer elemento de una lista usamos la primitiva first. Ejemplo

39

first [a b c d e f g h i j k] --> a

;; nota: a, b, , k son nmeros o variables.

Para obtener el ltimo elemento de la lista utilizamos el primitiva last: last [a b c d e f g h i j k] --> k ;; nota: a, b, , k son nmeros o variables.

Para obtener todos los elementos de la lista excepto el primero se emplea la primitiva but-first. Ejemplo: but-first [a b c d e f g h i j k] --> [b c d e f g h i j k] o variables. ;; nota: a, b, , k son nmeros

Para obtener todos los elementos de la lista excepto el ltimo se emplea la primitiva but-last: but-last [a b c d e f g h i j k] --> [a b c d e f g h i j] son nmeros o variables. ;; nota: a, b, , k

Para obtener el elemento n de la lista, empleamos la primitiva item. Ejemplo: item 5 [a b c d e f g h i j k] --> f ;; nota: a, b, , k son nmeros o variables. Nota: Recuerda que Netlogo numera las listas a partir del elemento 0. Para tomar un elemento al azar de una lista se emplea la primitiva one-of: one-of [a b c d e f g h i j k ] --> cualquier elemento de la lista tomado al azar

Y para tomar varios elementos al azar de una lista empleamos n-of: n-of 3 [a b c d e f g h i j k ] --> nos devuelve otra lista con 3 elementos de la lista inicial tomados al azar.

Cmo modificar una lista? Para introducir un nuevo elemento al comienzo de una lista, empleamos la primitiva fput: fput z [a b c d e f g h i j k ] --> [z a b c d e f g h i j k ] nmeros o variables. ;; nota: a, b, , k son

Y para introducirlo al final de la lista, utilizamos la primitiva lput: lput z [a b c d e f g h i j k ] --> [a b c d e f g h i j k z] nmeros o variables. ;; nota: a, b, , k son

Para eliminar un elemento de una lista, usamos la primitiva remove: remove d [a b c d e f g h i j k ] --> [a b c e f g h i j k ] ;; nota: a, b, , k son nmeros o variables. Nota: remove elimina todas las paraciciones del elemento en la lista.

40

Si conocemos la posicin que ocupa un elemento dentro de una lista, podemos eliminarlo con la primitiva remove-item: remove-item 4 [a b c d e f g h i j k ] --> [a b c d f g h i j k] ;; nota: a, b, , k son nmeros o variables. Nota: Recuerda que Netlogo numera las listas a partir del elemento 0.

Una variacin de la primitiva remove es la primitiva remove-duplicates, que elimina todos los elementos repetidos en la lista, dejando nicamente la primera aparicin de los mismos. Ejemplo: remove-duplicates [a a b b b c c d e e e e e f f g g h h i i j j j k k ] --> [a b c d e f g h i j k]

Para reemplazar un elemento de la lista por otro, empleamos la primitiva replace-item: replace-item 4 [a b c d e f g h i j k ] z --> [a b c d z f g h i j k] son nmeros o variables. ;; nota: a, b, , k

Otras primitivas tiles relacionadas con listas: Para conocer la longitud de una lista (esto es, su nmero de elementos) empleamos la primitiva length: length [a b c d e f g h i j k ] --> 11 ;; nota: a, b, , k son nmeros o variables.

Para obtener el elemento que ms se repite dentro de una lista (es decir, la moda), se emplea la primitiva modes: modes [a a b c d e f g h i j k] --> a ;; nota: a, b, , k son nmeros o variables.

Para conocer la posicin de un elemento dentro de una lista se utiliza la primitiva position: position a [a b c d e f g h i j k ] --> 0 variables. ;; nota: a, b, , k son nmeros o

Para desordenar aleatoriamente los elementos de una lista utilizamos la primitiva shuffle: shuffle [a b c d e f g h i j k ] --> [d k a c e i j h f b g] nmeros o variables. ;; nota: a, b, , k son

Para obtener una lista ordenada de manera inversa a la original, empleamos la primitiva reverse: reverse [a b c d e f g h i j k ] --> [k j i h g f e d c b a] nmeros o variables. ;; nota: a, b, , k son

41

Para obtener una lista con los elementos ordenados en orden creciente, empleamos la primitiva sort: sort [4 6 2 8 4] --> [2 4 4 6 8] Nota 1: Recuerda siempre que, para Netlogo, el primer elemento de una lista es el elemento 0. Nota 2: Recuerda que si los elementos de una lista son caracteres, stos deben escribirse entre comillas: [a b c d e f g h i j k]

42

Ejercicio 16. Listas (2)

En este ejercicio veremos algunas cuestiones tiles relacionados con las listas: Tcnicamente, las listas no pueden ser modificadas, pero s que se pueden construir nuevas listas a partir de listas antiguas... incluso con el mismo nombre. Para ello se utiliza la orden set. Por ejemplo, si tenemos la lista 'mi-lista' con el siguiente contenido: [ 1 10 15 20 ] y queremos que pase a tener el contenido [ 10 15 20 ], es decir, queremos eliminar el primer elemento de la lista, lo que haremos ser emplear conjuntamente las primitivas set y but-first (para ms informacin sobrebut-first, consulta el ejercicio anterior)
let mi-lista (list 1 10 15 20) set mi-lista but-first mi-lista ;; creamos la lista inicial ;; asignamos a la variable mi-lista el resultado ;; de crear una nueva lista con todos los elementos ;; de la lista original excepto el primero ;; muestra [10 15 20]

show mi-lista

Esta manera de contruir nuevas listas a partir de otras existentes es aplicable, tambin, a las rdenesbut-last, remove-item, replace-item que introdujimos en el ejercicio anterior. Para concatenar varias listas, usamos la orden sentence. Observa el siguiente ejemplo:
let lista1 [1 2 3 4] ;; creamos la lista inicial let lista2 [5 6 7 8] ;; asignamos a la variable mi-lista el let lista3 [9 10 11 12] let nueva-lista sentence lista1 lista2 ;; [1 2 3 4 5 6 7 8] let nueva-lista2 (sentence lista1 lista2 lista 3) ;; [1 2 3 4 5 6 7 8 9 10 11 12]

Observa que cuando vamos a concatenar tras o ms listas, la sentencia sentence completa debe ir entre parntesis.

43

Los elementos de las listas de Netlogo pueden ser, a su vez, otras listas. Para crear estas 'lista de listas' podemos utilizar nuevamente la orden sentence, pero esta vez con doble corchete. Compara las siguientes dos lneas de cdigo:
let lista (sentence [[ 1 2 3 ]] [[ 4 5 6 ]] [[7 8 9 ]]) ;; frente a... let lista (sentence [ 1 2 3 ] [ 4 5 6 ] [7 8 9 ]) ;;[1 2 3 4 5 6 7 8 9] ;;[1 2 3] [4 5 6] [7 8 9]

Se pueden anidar las funciones de extraccin para modificar elementos en 'listas de listas'. Observa el siguiente ejemplo, en el que deseamos sustituir el '6' por un '7':
let lista [[1 2] [3 4] [5 6]] set mylist (replace-item 2 mylist (replace-item 1 (item 2 mylist) 7 ) ) ;; [[1 2] [3 4] [5 7]]

Para ordenar los elementos de una lista, empleamos la primitiva sort-by:

let lista [1 3 5 7 9 2 4 6 8] let lista-menor-mayor sort-by [?1 < ?2] lista ;; [1 2 3 4 5 6 7 8 9] let lista-mayor-menor sort-by [?1 > ?2] lista ;; [9 8 7 6 5 4 3 2 1]

44

Ejercicio 17. Operaciones sobre listas

Aunque para realizar operaciones con cada elemento de una lista se puede utilizar un bucle lgico con repeat, con while o un procedimiento recursivo, existen 2 primitivas especiales: foreach y map foreach realiza un conjunto de operaciones sobre cada elemento de una lista. Se utiliza ? para hacer referencia al valor actual en el bloque de operaciones. En el siguiente programa, creamos 5 tortugas y asignamos a cada una de ellas un tamao acorde a su identificador. Es decir, a la tortuga 0 le damos un tamao 0, a la tortuga 1 un tamao 1, y a la tortuga 4 un tamao 4.

El smbolo ? va tomando valores distintos en cada repeticin del bucle, segn los valores de los elementos de la lista. En la primera repeticin del bucle, ? vale 0 (primer elemento de la lista) y, as, se pide a la tortuga 0 que adquiera un tamao 0; en la segunda repeticin del bucle, ? vale 1, por lo que a la tortuga 1 se le asigna un valor 1... y as sucesivamente.

45

foreach tambin puede operar sobre varias listas a la vez (aunque stas deben ser de la misma longitud). En este caso hay que colocar la operacin completa entre parntesis. El smbolo ?1 hace referencia al valor que toma el elemento actual de la lista 1; ?2 hace referencia al valor que toma el elemento actual de la lista 2, etc. El siguiente ejemplo aclara la sintaxis de la orden foreach cuando opera sobre ms de una lista. En l calcularemos el producto escalar de dos vectores: a = [1 2 3] y b = [4 5 6]. El resultado del producto escalar ser: 1*4 + 2*5 + 3*6 = 32. Veamos cmo se programara todo esto (puedes descargarte el cdigo de la seccin 'Archivos adjuntos', Ejercicio17b.nlogo, al final de esta pgina):

Finalmente, aprenderemos el manejo de la primitiva map. Se trata de una orden que toma como entrada una lista y da como resultado otra lista que contiene el resultado de aplicar una funcin a cada uno de los elementos de la original. Al igual que ocurra con la primitiva foreach, con ? se hace referencia al valor actual. Su sintaxis es la siguiente: map ["operacin"] lista Para aclarar ideas, observemos la siguiente rutina en la cual queremos convertir el vector [1 2 3] en un vector unitario. Para ello, debemos dividir las componentes del vector entre el mdulo del mismo. Aprovecharemos para repasar el uso de la orden foreach y calcularemos la suma

46

de los cuadrados de los componentes del vector empleando esta primitiva. Despus calcularemos el mdulo del vector (raz cuadrada de la suma de los cuadrados de los componentes) y, finalmente, emplearemos la orden map para obtener un nuevo vector (unitario) en el que cada componente es la correspondiente componente del vector inicial dividida entre el mdulo del vector.

47