A Tutorial 1: NetLogo

A.1 Parte 1 ¿Qué es NetLogo?

NetLogo es un programa de modelado y programación basado en agentes (MOBA) de código abierto, desarrollado por el Northwestern University Center for Connected Learning (CCL) and Computer-Based Modeling [1]. Se basa en el lenguaje de programación Logo original [2], incorporando y ampliando conceptos y construcciones introducidas en StarLogo y MacStarLogo [3], ambos desarrollados por el Media Lab y el Scheller Education Program del MIT. NetLogo se conoce como una herramienta basada en agentes, debido al hecho de que el lenguaje de programación y la interfaz de usuario están destinadas principalmente para el modelado y simulación de sistemas de múltiples agentes que interactúan (see “Tipos de Agentes”, p. 13). Por lo general, estos agentes no necesitan tener comportamientos extensos o complicados; se pueden desarrollar útiles modelos a menudo con los agentes siguiendo reglas muy simples. Desarrollado en Java y Scala, y ejecutando en la máquina virtual de Java (JVM), NetLogo es muy portable: modelos escritos en NetLogo para Windows (por ejemplo) pueden ser modificado y ejecutado usando las ediciones OS X y Linux de NetLogo. Los modelos también se pueden ejecutar como applets de Java en las páginas Web (aunque este uso está obsoleto oficialmente), o traducidos “sobre la marcha” al JavaScript para la ejecución basada en navegador. Extensiones a NetLogo pueden ser elaborados en Java o Scala, y la propia NetLogo se pueden crear instancias y controlados por un programa de Java, Scala, o virtualmente cualquier otro idioma que se ejecuta en la JVM. Con cada lanzamiento (versión) importante, NetLogo se ha mejorado de manera significativa. Las características del lenguaje orientadas a los agentes se han racionalizadas, para ser más consistentes y coherentes que en las versiones anteriores. Operaciones sobre listas y conjuntos se han ampliado, y el rendimiento de esas operaciones se ha mejorado. Agentes de tipo enlace se ha añadido, en apoyo no sólo para el modelado de las redes (sociales, la comunicación, etc.), sino también de estructuras físicas y lógicas, y ensamblados.

A.2 Terminología de NetLogo

Al igual que prácticamente todos los lenguajes de programación modernos, NetLogo tiene en común con otros lenguajes muchos conceptos y facilidades. Sin embargo, la terminología utilizada en NetLogo a veces difiere significativamente de la de otros idiomas. Algunas de estas diferencias se originaron en dialectos anteriores de Logo,mientras que otros son el resultado de decisiones deliberadas por parte de los diseñadores de NetLogo. En cualquier caso, una familiaridad con algunos de estos términos distintivos – y sus correspondencias con los términos en otros lenguajes – puede ser muy útil. Los siguientes son tres términos que son críticos para empezar; estos y otros términos se exploran con más detalle, más adelante en este documento. • Agente En programación en NetLogo, los agentes son esencialmente objetos: entidades que contienen datos, comportamientos y contextos de ejecución independientes. Para los propósitos de visualización gráfica, un agente en NetLogo (y, en particular, una tortuga, o agente móvil) es más o menos equivalente al concepto de un sprite: una entidad que puede moverse y mostrarse independientemente de otros elementos gráficos. Para obtener más información sobre los tipos de agentes provistos por NetLogo, consulte “Tipos de Agentes” (p. 13). • Comando Un comando es conceptualmente equivalente a lo que se suele llamar una sentencia: la especificación de una acción a realizar, para cambiar el estado del sistema. En NetLogo, este estado incluye no sólo las variables globales, el espacio de visualización gráfica y el sistema de archivos, sino también los estados individuales de todos los agentes. Los comandos pueden ser invocaciones de los comandos primitivos (comandos definidos por NetLogo sí mismo) o de los procedimientos comandos (definidos en el código de programación de un modelo). • Reportero En la mayoría de los lenguajes de programación, llamamos a esto una expresión. Considerando que un comando se usa para cambiar el estado del sistema, el propósito de un reportero es calcular y devolver (reportar) algún valor. Esto puede ser un valor de un tipo de datos primitivo (por ejemplo, un número, booleano, o una cadena de caracteres), un agente, o una estructura de datos que contiene (potencialmente) varios elementos de datos. Al igual que los comandos, los reporteros pueden incluir invocaciones de los reporteros primitivos, así como los procedimientos reporteros. Para obtener más información sobre comandos y reporteros, consulte “Comandos, Reporteros, Definiciones y Declaraciones” (p. 11).

A.3 El mundo NetLogo

A.3.1 Sistema de coordenadas

En la construcción de los modelos de NetLogo es importante entender el sistema de coordenadas utilizado. Este diagrama, con las explicaciones que siguen, ilustran algunos puntos importantes para recordar:

Como el sistema de coordenadas cartesianas utilizado tradicionalmente en la geometría analítica, el mundo NetLogo tiene ejes X e Y. El centro del sistema de coordenadas es el origen (que es a menudo – pero no siempre – situado en el centro físico del mundo NetLogo), donde X e Y tienen los valores de cero (0).
Superpuesto en el sistema de coordenadas está una rejilla de cuadrículas (parcelas o cuadrados de tamaño 1 X 1), cada uno de los cuales es un agente fijo (en Inglés y en código de NetLogo, se llama patch). Cada tiene un color y una etiqueta opcional. También se puede definir variables adicionales para los agentes fijos.
El centro de un agente fijo es un punto en el sistema de coordenadas donde X e Y tienen valores integrales; estas coordenadas se utilizan para referirse al agente fijo. Por ejemplo, patch 3 2 en el diagrama es un cuadrado con su centro en (3, 2); este cuadrado está definido por la región donde 2,5 ≤ X < 3,5 and 1,5 ≤ Y < 2,5. (También podemos hacer referencia a los agentes fijos con coordenadas de punto flotante; se redondearán a enteros si fuera necesario.)
Las coordenadas de los agentes fijos son siempre valores enteros, pero eso no es necesariamente así en el caso de un agente móvil. En el diagrama, hay un agente móvil localizada en (-4,6, -8,3), que se encuentra en la cuadrado centrada en (-5, -8). Aunque un agente móvil puede aparecer como si es en dos o más cuadrados a la vez, el punto central del agente móvil es lo que importa: este punto central se trata como la ubicación real del agente móvil, y el cuadrado que contiene ese punto central es considerado como el cuadrado en la que el agente móvil está de pie.
El usuario puede cambiar el ancho o alto del mundo NetLogo en cualquier momento; debido a esto, el código de un programa de NetLogo no deben hacer referencia a las dimensiones del mundo con valores literales, a menos que sea absolutamente necesario. Afortunadamente, los programas de NetLogo siempre pueden utilizar world-width y world-height para obtener las dimensiones actuales del mundo (area de simulación).
Los agentes fijos en la parte extrema del lado derecho del mundo NetLogo tienen la coordenada X con el valor max-pxcor; los de la cima del mundo tienen Y con el valor max-pycor. Del mismo modo, min-pxcor y min-pycor son las coordenadas X e Y (respectivamente) de los agentes fijos en la parte izquierda extrema y parte inferior (respectivamente) del mundo NetLogo. Estas variables están relacionadas con el tamaño total del mundo, como sigue: world-width = (max-pxcor - min-pxcor) + 1 world-height = (max-pycor - min-pycor) + 1

A.3.2 Ángulos y direcciones

Todos los ángulos en NetLogo se especifican en grados, y las direcciones se basan en rumbos de la brújula, con 0° estando “arriba” (es decir, al norte), el 90° hacia la derecha (es decir, al este), etc. Para instruir a un agente móvil que mire a una dirección en particular, podemos hacerlo estableciendo el rumbo del agente a la dirección deseada según la brújula, o diciendo al agente móvil que gire a la derecha o a la izquierda por el número de grados necesarios. También podemos encargar a un agente móvil que mire a otro agente especificando el segundo agente, con el comando face, en lugar de calcular la dirección de la brújula o ángulo de giro requerido.

A.3.3 Topología

Nótese que podemos especificar que el mundo NetLogo tenga continuidad en su borde horizontal, vertical, o ambos, o en ningún borde. Cuando el envolvente (wrapping) está encendido en posición horizontal (por ejemplo), un agente móvil se mueve fuera del borde derecho del mundo y volverá a aparecer en el borde izquierdo, y viceversa. Si el envolvente horizontal no está habilitado, el agente móvil será incapaz de salir por el borde derecho o el izquierdo. 1. ¿Cuál es la “forma” lógica del mundo NetLogo, si el envolvente está encendido en posición horizontal, pero no verticalmente? 2. ¿Cuál es la forma del mundo NetLogo, si el envolvente está encendido verticalmente, pero no horizontalmente? 3. ¿Cuál es la forma del mundo NetLogo, si el envolvente está activado tanto vertical como horizontalmente?

##Programación en general: la enseñanza de la computadora

Aunque las computadoras (más precisamente, los procesadores) son capaces de manipular los datos de manera muy eficiente, y aunque los procesadores modernos incluyen unidades de procesamiento de punto flotante que pueden realizar cálculos aritméticas, trigonométricas y logarítmicos impresionantes, también son ingenuos: Son generalmente incapaces de realizar la mayor parte de las tareas que el usuario medio consideraría significativa – hasta que se les enseña a hacerlas. Enseñamos a las computadoras a hacer esto a través de la programación: por medio de la codificación de un algoritmo (un procedimiento para completar una tarea o resolver un problema) en una forma que la computadora pueda entender, para lo cual se necesitará insumos específicos, y desde el cual se puede presentar un resultado significativo como salida. Afortunadamente para nosotros, prácticamente todas las computadoras modernas y disponibles en el mercado vienen con millones de líneas de estas instrucciones algorítmicas ya escritas y precargadas en los discos duros, chips de memoria programables, etc. Estas instrucciones forman parte del sistema operativo (que nos permite leer y escribir los datos desde y hacia el teclado, el monitor y archivos), controladores (que indican a la computadora cómo conectarse y hacer uso de los dispositivos de hardware – por ejemplo, adaptadores de visualización de vídeo, unidades de disco, impresoras, dispositivos de memoria externos) y aplicaciones (archivos especiales que se pueden ejecutar según la demanda por el usuario, para funciones más específica). Podemos aumentar esta capacidad a través de la instalación o elaboración de nuevos programas para que la computadora las ejecute; cuando hacemos esto, estamos literalmente enseñando a la computadora a realizar nuevas tareas. Algunos programas de ordenadores son traductores de instrucciones: ellos permiten a los programadores escribir nuevos programas, sin que tengan que entender mucho del funcionamiento interno de la computadora. Estos traductores pueden convertir las instrucciones de los programadores hacia una forma que la computadora puede ejecutar. NetLogo es un tal traductor: nos permite escribir programas en un lenguaje especializado para describir el comportamiento de los agentes; luego convierte estos programas (modelos) en una forma que la computadora puede ejecutar,1 sin que tengamos que saber nada acerca de cómo la conversión se lleva a cabo. No obstante, podemos considerar los modelos de NetLogo que escribimos como secuencias de instrucciones que enseñamos a la computadora; quizá más útil, podemos considerer nuestra tarea, en la construcción de modelos de NetLogo como el de la enseñanza de NetLogo en sí mismo. ## Programación en NetLogo ### Reseña Damos instrucciones a NetLogo de tres maneras: 1. Podemos escribir instrucciones en el Terminal de Instrucciones (Command Center):

Algunas instrucciones pueden ser incluidos en los botones y otros controles en las interfaces de usuario que creamos. Esta funcionalidad es la más utilizada para relacionar los botones que creamos a las nuevas capacidades que hemos enseñado a NetLogo en nuestro programa.
Por último, y lo más importante, cuando escribimos instrucciones en la ventana de Código, estamos creando un programa NetLogo, que consiste en uno o más procedimientos. Lo que escribimos en la ventana de Código no se ejecuta inmediatamente, pero se suma a lo que NetLogo sabe hacer. Podemos invocar a esta nueva funcionalidad a través de botones y monitores en la interfaz de usuario, escribiendo comandos en el Centro de Comando, o por referencia en otros procedimientos en el código que hemos escrito en la ventana de Código.

A.4 Procedimientos

Para enseñar un procedimiento a otra persona para completar una tarea, es posible comenzar diciendo: “Para hacer X, primero hacer A, luego hacer B”, y así sucesivamente. Enseñando a NetLogo para realizar una tarea es muy similar: utilizamos la palabra clave to, seguido del nombre de la tarea, y luego la secuencia de instrucciones que componen el procedimiento; por último, indicamos que no hay más instrucciones para esta tarea con la palabra clave end. Por ejemplo, aquí enseñamos a NetLogo un procedimiento que se puede seguir por un agente móvil para dibujar un cuadrado:

Tenga en cuenta que hay palabras con guiones en el código de este ejemplo. Aunque esto no se permite en la mayoría de lenguajes de programación, es válido y común en los dialectos de Logo, y hay varios primitivos (comandos y reporteros definidos por NetLogo sí mismo) con nombres con guiones. Sin embargo, aunque el procedimiento y los nombres de variables pueden incluir guiones – así como muchos otros símbolos de puntuación – no pueden incluir espacios. Ahora que hemos escrito el procedimiento de draw-square (dibujar cuadrado), podemos invocarlo por su nombre en el Terminal de Instrucciones, en un botón, o en otro procedimiento. La mayoría de los lenguajes de programación soporta dos diferentes tipos de procedimientos (también llamadas funciones, métodos, subrutinas, etc.): aquellos que modifican el estado del sistema, y los que computan y devuelven un resultado. El procedimiento anterior es un ejemplo del primero: modifica el rumbo y la posición de un agente, pero no devuelve un resultado. En NetLogo, este tipo de procedimiento se llama un procedimiento comando. También podemos escribir un procedimiento que devuelve un resultado; en NetLogo, este tipo se llama procedimiento reportero. Por ejemplo, el siguiente procedimiento calcula y retorna el cuadrado de una entrada:

La sintaxis para un procedimiento reportero difiere de la de un procedimiento comando en dos aspectos claves: 1. La definición de un procedimiento reportero comienza con to-report, en lugar de to. 2. El comando primitivo report se utiliza (y se requiere) para salir y devolver un valor de un procedimiento reportero. Como se ha visto anteriormente, parámetros de entrada se incluyen en la definición de un procedimiento (comando o reportero) por encerrándolas entre corchetes después del nombre del procedimiento.

A.5 Comandos, Reporteros, Definiciones y Declaraciones

Anteriormente, vimos que podemos crear procedimientos comandos y reporteros en nuestro código. De hecho, podemos considerar cualquier programa NetLogo como un conjunto de comandos, reporteros, definiciones y declaraciones. Un comando es una instrucción que invoca (llama) a un procedimiento comando o un comando primitivo (predefinido por NetLogo), especificando los parámetros de entrada requeridos por el primitivo o procedimiento. Por ejemplo, forward 5 es un comando que indica a un agente móvil para mover 5 pasos en la dirección hacia delante; aquí, el comando primitivo es forward (hacia adelante), y la entrada requerida es un valor numérico que indica la distancia a moverse. Por supuesto, mientras que 5 es un valor numérico literal simple, podríamos usar forward (2 + 3) en su lugar, y el resultado será el mismo. Del mismo modo, si existe la variable step-length en nuestro programa, y el valor actual de step-length es de 5, entonces forward step-length también dará lugar al agente móvil a moverse 5 pasos para delante. ¿Qué tienen 5, (2 + 3) y step-length en común? Son expresiones que NetLogo puede evaluar - es decir, de las cuales NetLogo puede calcular un valor. Genéricamente, y en la mayoría de los lenguajes de programación, expresiones como éstas se llaman precisamente eso: expresiones. En NetLogo, se llaman reporteros (en algunos contextos, se llaman indicadores). Así que un reportero es un simple valor literal, una variable de referencia, una invocación de un procedimiento reportero o reportero primitivos con las entradas requeridas – que son ellos mismos reporteros – o una combinación de éstos, usando operadores aritméticos o lógicos (que también son reporteros primitivos) para calcular el resultado. (Con cualquiera de las posibilidades anteriores, los paréntesis pueden usarse para especificar el orden de evaluación de manera explícita - o incluso sólo para mejor claridad visual.) El ejemplo de un procedimiento reportero en la sección anterior incluye la línea

Aquí, toda la línea es un comando, invocando el comando primitivo report, y proveyendo la entrada esperada por report. Esa entrada es el reportero

Este reporte se compone de paréntesis (utilizado aquí para dejar claro que por muy complicado que el reporte sea, estamos calculando y reportando un único valor) que rodea el reporte

El operador aritmético * es un reportero primitivo de un tipo especial: es un reportero infix (uno para el cual se requieren datos antes y después). Así que este reportero consiste en el primitivo *, con input-value (una referencia a una variable) especificada para ambas de las entradas esperadas. Podemos ir por un largo camino con los comandos y reporteros primitivos – pero no podemos realmente escribir programas NetLogo, a menos que también incluyamos declaraciones para la definición de nuevos procedimientos. Como ya vimos, hacemos eso con la palabra clave to o to-report, seguido por el nombre del procedimiento, seguido opcionalmente por una lista entre paréntesis de parámetros de entrada. Entonces, después de que los comandos que conforman el cuerpo del procedimiento, utilizamos la palabra clave end para indicar a NetLogo que se finaliza la definición del procedimiento. Por último, la mayoría de los programas de NetLogo no triviales también requieren declaraciones. Estas son sentencias escritas al comienzo de nuestro código que declaran información esencial sobre el programa a NetLogo sí mismo: las variables globales que serán asignadas y mencionadas en el código; las razas (breeds) correspondientes a los distintos tipos de agentes móviles y de enlaces que serán utilizados; las variables que serán los atributos de nuestros agentes (más allá de los predefinido por NetLogo); las extensiones NetLogo y archivos adicionales de código fuente que nuestro programa requiere. No miramos a estos en detalle en este resumen, pero los examinaremos en el contexto de ejemplos específicos posteriores; por ahora, sólo nótese que estas declaraciones emplean las palabras claves globals, breed, undirected-link-breed, directed-link-breed, patches-own, turtles-own, links-own, breeds-own, extensions y __includes. Un importante comando primitivo es en realidad una combinación de una declaración y un comando: El comando let se utiliza dentro de un procedimiento o bloque de comandos (una secuencia de comandos encerrados por corchetes) para declarar una variable local y para asignarle un valor inicial. Ese valor – y la propia variable – se conserva sólo dentro del procedimiento o del bloque de comandos donde se declara.

A.6 Tipos de Agentes

Hay cuatro tipos de agentes en NetLogo; cada uno es capaz de realizar diferentes tipos de acciones, y cada uno sirve a un propósito diferente en un modelo de NetLogo: 1. Observador (observer) – Siempre existe solo una instancia de este tipo de agente. Este agente no se visualiza en el mundo NetLogo, pero es el único agente que puede realizar ciertas operaciones globales en un modelo (por ejemplo, clear-all, tick). 2. Parcela (agente fijo, cuadrado, patch) – Esto es un agente estacionario; hay exactamente un agente fijo por cada unidad cuadrada en la cuadrícula del mundo NetLogo. Un agente fijo no se puede mostrar de una manera o forma distinta que un cuadrado, pero cada puede tener su propio color, así como una etiqueta. 3. Tortuga (agente móvil, turtle) – Esto es un agente que puede moverse por el mundo NetLogo independientemente de otros agentes; las instrucciones que especifican movimiento sólo puede ser ejecutado por los estos agentes móviles. La forma, el color, el tamaño y la etiqueta de un agente móvil pueden ser manipulados por el código de un modelo de NetLogo. 4. Enlace (link) – Estos son los agentes que conectan un agente móvil con otro. No hay instrucciones para mover enlaces directamente; un enlace se mueve cuando una o ambos de los agentes móviles en sus puntos finales se mueven. Un enlace también se puede configurar como un empalme (tie), donde el movimiento del agente móvil en uno de sus puntos finales se traduce automáticamente en el movimiento del agente móvil en otro punto final. Un enlace puede ser dirigido o no dirigido: con enlaces no dirigidos, no consideramos el enlace como proveniente de un agente móvil a otro, sino simplemente que es entre los dos; un enlace dirigido, por otro lado, es siempre de un agente móvil a otro. Los enlaces y los agentes móviles son los únicos agentes que pueden ser creados o destruidos por las instrucciones contenidas en el código del modelo. Además, los enlaces y los agentes móviles son los únicos agentes que se pueden organizar en razas. Los agentes móviles pueden interactuar con otros agentes móviles mediante la lectura de los atributos de esos agentes, o pidiendo a esos agentes para ejecutar unas instrucciones; también pueden interactuar así con los agentes fijos. Los agentes fijos pueden interactuar con agentes móviles y con otros agentes fijos. Los enlaces generalmente interactúan con los agentes móviles que son sus puntos finales, sino que se pueden interactuar con otros enlaces, agentes móviles y agentes fijos. El observador puede pedir a los agentes móviles, a los agentes fijos y a los enlaces para realizar las operaciones especificadas. Por otro lado, los agentes móviles, los agentes fijos y los enlaces no pueden pedir explícitamente al observador realizar cualquier acción. Sin embargo, los modelos tienen las variables globales (algunos predefinidos por NetLogo, y otros que podemos definir en nuestros deslizadores y en los código del programa); los agentes fijos, los enlaces y los agentes móviles pueden modificar los valores de algunas de estas variables globales – y estos cambios pueden afectar las acciones del observador.

A.7 Tipos de Datos

NetLogo es un lenguaje débilmente tipado. Cuando se declara una variable, no se especifica el tipo de datos que se grabará en la variable; la variable puede ser utilizada para almacenar cualquiera de los tipos soportados de datos. De hecho, durante la vida de una determinada variable, puede contener los datos de diferentes tipos en diferentes momentos (aunque por lo general no es una buena idea). Del mismo modo, la definición de un procedimiento reportero no especifica el tipo de dato devuelto por el procedimiento; es posible (aunque generalmente no es recomendable) que un procedimiento reportero devuelva valores de diferentes tipos en diferentes condiciones. NetLogo nativamente soporta seis tipos de datos: • Numérico El formato de punto flotante de doble precisión estándar IEEE 754 se utiliza internamente para todos los valores numéricos en NetLogo [4]. Este tipo de datos utiliza 64 bits para representar números enteros exactos en el rango [−253 , 253 ] y los valores de punto flotante (no exactamente, en su mayor parte) en el rango [−1.797693×10308 , 1.797693×10308 ]

• Booleano Este es un tipo que contiene sólo los valores true (veradero) y false (falso). Tenga en cuenta que estos no son los valores de cadena (texto) “true” y “false”; tampoco son intercambiables con los valores de número entero 1 y 0, respectivamente. • Cadena de caracteres (text) Una cadena es una secuencia de caracteres, que puede incluir letras, números, signos de puntuación y otros símbolos, así como el espacio en blanco. Tenga en cuenta que los reporteros primitivos para la manipulación de cadena son bastante mínimas: para el procesamiento de texto de uso general, NetLogo es raramente el idioma de su elección. En particular, NetLogo no tiene capacidad integrada para convertir una cadena de dígitos y otros caracteres utilizados para la representación de números en el valor numérico correspondiente. Otra manera en que podríamos pensar en cadenas en NetLogo es como listas de caracteres (consulte “List”, a continuación): muchos de los reporteros primitivos y comandos primitivos que funcionan con listas también operan en las cadenas. Por esta razón y otras, a menudo es útil considerar cadenas no como un tipo de datos distinto, sino como una lista especializada. • Agente Una variable puede almacenar (y un reportero puede devolver) una referencia a cualquier agente aparte del observador. Por ejemplo, en un modelo de ecosistema con los procesos de nacimiento y muerte, podría ser útil que cada agente móvil (en representación de algún miembro individual del ecosistema) recuerde sus padres - es decir, mantener las referencias a ellos en sus variables. Si una variable está almacenando una referencia a un agente móvil o un enlace, y ese agente muere, la variable se actualizará automáticamente para contener el valor de nobody (nadie), que es una referencia especial que no se refiere a ningún agente. • List La lista es la estructura de datos fundamental (un tipo compuesto de datos, posiblemente contiene múltiples componentes) en NetLogo - en cuanto a eso, en la mayoría de dialectos de Logo. Una lista es una secuencia ordenada de cero o más elementos. Los elementos se pueden adjuntar (ser añadido al final de) o antepuesto (ser introducido al principio de) una lista. Cada vez que una lista dada se atraviesa (sin ninguna modificación que altere el contenido de la lista), el orden de los elementos permanecerá consistente. La heterogeneidad es otra propiedad importante de las listas en NetLogo: Cada elemento puede ser de cualquiera de los tipos disponibles de datos (incluyendo listas). En parte debido a la temprana influencia de Lisp (otra lenguaje de programación) en Logo, y en parte debido a la polinización cruzada desde Python y otros lenguajes, NetLogo incluye un amplio conjunto de primitivos para el manejo de listas. Incluso muchos modelos de NetLogo que no utilizan la mayor parte de estos primitivos, o que no asigna explícitamente valores del tipo lista a las variables, todavía emplean listas implícitamente – por ejemplo, como valores de entrada con los reporteros que calculan estadísticas agregadas (count, max, mean, min, sum, etc.). Muchos de estos usos se encuentran cuando se leen valores de todos los miembros de un conjunto de agentes (a continuación). • Conjunto de agentes (agentset) El conjunto de agentes es la segunda estructura de datos fundamental en NetLogo. La mayoría de los lenguajes de programación y las bibliotecas que implementan listas y conjuntos diferencian estos dos tipos de datos en la misma forma que se diferencian los correspondientes conceptos matemáticos: ◦ A pesar de que una lista es ordenada, un conjunto no lo es. Al agregar un miembro a un conjunto, no tenemos control sobre la posición de ese miembro dentro del conjunto – de hecho, “posición” no tiene sentido para los conjuntos. Si leemos un conjunto varias veces, incluso sin la adición o eliminación de miembros entre los recorridos, el orden de recorrido puede ser diferente cada vez. ◦ Una lista puede contener el mismo valor en múltiples posiciones dentro de la lista. Un conjunto contiene un especificado valor o bien no lo contiene - no puede contener varias instancias del mismo valor al mismo tiempo. En la implementación de NetLogo, los conjuntos tienen algunas limitaciones importantes: ◦ Un conjunto sólo puede contener agentes (más exactamente, contiene referencias a los agentes). NetLogo no admite conjuntos de valores numéricos, conjuntos de cadenas, conjuntos de conjuntos, etc. Por eso los conjuntos de NetLogo se llaman agentsets. ◦ Conjuntos de agentes son homogéneos: Sólo un tipo de agente se puede contener en un conjunto en cualquier momento dado. Así que un conjunto no puede (por ejemplo) contener agentes fijos y móviles simultáneamente. (También, como las variables simples no pueden referirse al observador, el observador no puede incluirse en un conjunto de agentes.) Aún con estas limitaciones, los conjuntos de NetLogo son muy útiles - y dominar su uso es una parte esencial de convertirse en un experto desarrollador de los modelos de NetLogo. Un conjunto se puede filtrar por una variedad de predicados lógicos, para crear un subconjunto; se puede atravesar con el propósito de obtener información de todos los miembros (esto produce una lista de valores); tan fácilmente, se puede atravesar con el propósito de pedir a cada miembro para llevar a cabo uno o más comandos; se puede combinar con otro conjunto, para construir un nuevo conjunto de la unión, la intersección, o la diferencia de los dos. Las razas de agentes móviles y enlaces pueden considerarse como conjuntos especiales, en los cuales NetLogo maneja la membresía automáticamente. Además de los tipos de datos anteriores, las extensiones de NetLogo pueden definir nuevos tipos de datos simples y estructurados; referencias a instancias de estos tipos de datos se pueden devolver por procedimientos reporteros y asignar a variables. Unos ejemplos notables de esto son las estructuras de datos definidas por las extensiones tabla, matriz y GIS, que se incluyen en la instalación estándar de NetLogo.

Referencias [1] Wilensky, U. NetLogo, 2015. [en linea]. http://ccl.northwestern.edu/netlogo/. Center for Connected Learning and Computer-Based Modeling, Northwestern University. Evanston, IL. [Consulta: 24 agosto 2015]. [2] Logo Programming, 2014. [en linea]. http://el.media.mit.edu/logofoundation/ what_is_logo/logo_programming.html. The Logo Foundation, Cambridge, MA. [Consulta: 24 agosto 2015]. [3] StarLogo TNG, 2015. [en linea]. http://education.mit.edu/portfolio_page/starlogotng/. MIT Scheller Teacher Education Program, Cambridge, MA. [Consulta: 24 agosto 2015]. [4] “Double-precision floating-point format.” 15 agosto 2015. [en linea]. http://en.wikipedia.org/wiki/Double-precision_floating-point_format. Wikipedia. [Consulta: 24 agosto 2015].

A.8 Parte 2 : Un Modelo Completo en NetLogo

A.8.1 Antes de…

Para comenzar, instalemos NetLogo y veamos los conceptos básicos.

Vaya al sitio web de NetLogo (http://ccl.northwestern.edu/netlogo/) y descargue y Instalar NetLogo. Esto lleva solo unos minutos. Verá que hay versiones disponibles para Todos los sistemas operativos informáticos comunes. Este libro está actualizado con NetLogo versión 6.0.4
Inicie NetLogo, haga clic en “Ayuda” y luego en “Manual del usuario de NetLogo”. Esto abre una documentación extensa, que aparecerá en su navegador web.Los manuales son especialmente importantes aligual que la Introducción y los tutoriales en la sección “Learning NetLogo”. La guía de interfaz y programación será esencial tan pronto como comience a escribir sus propios modelos, por lo que debe También familiarízate con ellos.
Antes de continuar, trabaje con el “Tutorial # 1: Modelos” en el manual de usuario de NetLogo . Asegúrese de comprender la configuración y los botones, los deslizadores e interruptores, gráficos y monitores, qué son las Vistas y cómo ajustar su configuración, y cómo abrir y jugar con la biblioteca de modelos.
Mire y pruebe algunos de los modelos en la Biblioteca de modelos. Asegúrese de mirar la pestaña Información para ver una descripción escrita del modelo, para qué puede usarlo y aprender de él.La Biblioteca de modelos contiene muchos modelos interesantes, agrupados por disciplina. Sin embargo, muchos de estos modelos de ejemplo explican problemas científicos bastante simples, probablemente porquefueron diseñados para ser fácilmente entendidos e ilustrar las excelentes herramientas de NetLogo para modelar, jugar con los modelos de ejemplo puede conducir a la impresión de que NetLogo es bueno principalmente solo para producir resultados animados, sin embargo,este no es el caso. Siempre que no esté seguro de cómo programar algo, debe buscar ideas en los ejemplos de código.

A.8.2 Un Primer Modelo : Buscador de Hongos

Ahora estamos listos para programar nuestro primer modelo, el modelo de búsqueda de hongos discutido en

colocar enlace

Describiremos el modelo a medida que avanzamos. * Crear, a través de Archivo / Nuevo en el menú de NetLogo, un nuevo programa de NetLogo. Guárdelo a través de Archivo /Guardar como, en un directorio de su elección y con el nombre de archivo BusHongos.nlogo. * Haga clic en el botón Configuración, el botón Configuración abre el cuadro de diálogo de configuración del modelo, donde puede verificar la geometría del mundo.Por ahora usaremos la geometría predeterminada con el origen (parcela 0,0) en el centro de el mundo, y la coordenada máxima en x (max-pxcor) y coordenada máxima en y (max-pycor) en 16. Esto forma un cuadrado de 33 × 33 parcelas. Haga clic en Aceptar para cerrar. el cuadro de diálogo Configuración del modelo. Para nuestro modelo de búsqueda de hongos , queremos crear un mundo de parcelas negras, con algunos grupos de parcelas rojas (que representan hongos) distribuidas al azar ; también crearemos dos agentes (turtles) que serán nuestros buscadores y luego dejar que los buscadores encuentren parcelas rojas. Por lo tanto, necesitamos inicializar (crear) el Mundo y los buscadores , y luego las acciones que realizan los buscadores cuando el modelo corre.

A.8.3 Procedimiento setup

Siempre seguiremos la convención de NetLogo de usar el nombre setup para el procedimiento que inicializa el mundo y los agentes (buscadores), y el nombre go para el procedimiento que realiza las acciones repetidamente a medida que se ejecuta el modelo. A estas alturas ya debías saber que ( al leer la guíaa de programción de NtLogo) que un procedimiento comienza y termine con las palabras clave to y end, respectivamente, Antes de programar los procedimientos de inicio (setup) y de acciones (go) vamos a creaar botones en la pestaña Interfaz que se utilizarán para activar estos procedimientos. * En la pestaña Interfaz, hay un menú desplegable, generalmente etiquetado como “Botón”, que le permite seleccione uno de los elementos de interfaz proporcionados por NetLogo (botón, control deslizante, interruptor, etc.).Haga clic en este selector, que abre una lista de estos elementos, luego en Botón. Colocar el cursor del mouse en la parte en blanco de la interfaz, a la izquierda de la ventana negra del mundo y haga clic Esto pone un nuevo botón en la interfaz y abre una ventana que le permite colocar las características de este nuevo botón:

* En el campo Comandos, escriba “setup” y haga clic en Aceptar. Ahora hemos creado un botón que ejecuta un procedimiento llamado setup La etiqueta del botón está en rojo, lo que indica que hay un problema: no hay un comando o procedimiento correspondiente llamado de esa manera, esto lo arreglaremos en un minuto.A continuación, escribamos el procedimiento de setup ► Haga clic en la pestaña Código, donde encontrará un espacio en blanco en blanco para ingresar su código.Al inicio escriba:

to setup
end

► Haga clic en el botón Comprobar Este botón ejecuta el verificador de sintaxis de NetLogo, que busca errores en su código como : ¿faltan paréntesis? ¿Los comandos tienen el número correcto de entradas? ¿el procedimiento no existe?, etc. Es importante usar el verificador de sintaxis con frecuencia, después de cada declaración que escriba, de esta manera se encuentran errores de inmediato y se sabe exactamente donde están. Sin embargo, este corrector no encuentra todos los errores; más adelante veremos otras formas de encontrar errores. Ahora no debería haber ningún mensaje de error. Si vuelve a la pestaña Interfaz, la etiqueta del botón de configuración debe estar en negro, lo que indica que ahora el procedimiento setup se puede ejecutar, a pesar de que este procedimiento todavía está vacío y no hace nada. * Regrese a la pestaña Código y elimine la palabra final. Haga clic en el botón Verificar nuevamente. Se obtendrá un mensaje de error que dice que un procedimiento no termina con end. * Deshaga su eliminación escribiendo CTRL-Z varias veces.

Regrese a la pestaña Interfaz y cree un segundo botón, asígnele el comando “go” haga clic en la casilla de verificación Continuamente en la ventana Botón y haga clic en Aceptar.Este segundo botón, go, ahora tiene un par de flechas circulares que indican que es un botón Forever.“Para siempre” significa que cuando se hace clic en el botón, se ejecutará su procedimiento una y otra vez hasta que se vuelva a hacer clic en el botón.
De la misma manera que creamos el procedimiento de setup (con dos líneas que dicen setup y end), escriba el “esqueleto” del procedimiento go.Ahora, le diremos al procedimiento de configuración que cambie el color de los parches.
Cambie el procedimiento de configuración a lo siguiente:

to setup
  ask patches 
   [
     set pcolor red
   ]
end

ask es el comando más importante y poderoso de NetLogo. Hace que el los agentes seleccionados (aquí, todos las parcelas) realizan todas las acciones especificadas dentro de los corchetes. Estos corchetes siempre delinean un bloque de acciones que se ejecutan juntas. Las declaraciones que acabamos de escribir “preguntan” a todos las parcelas que cambien de color a rojo ( pcolor=. Las parcelas por defecto tienen pcolor configurado en negro (por eso el mundo se ve así un gran cuadrado negro), en nuestro nuevo procedimiento de setup usamos el comando “set” para cambiar el color a rojo, este comando es un operador de asignación: asigna un valor (rojo) a una variable (pcolor). (En muchos lenguajes de programación, esta declaración se escribiría pcolor =rojo, que absolutamente no funciona en NetLogo!) * Pruebe el nuevo procedimiento de setup yendo a la pestaña Interfaz y haciendo clic en el botón, Todas los parcelas deben ponerse rojas. Sin embargo, queremos que solo unos pocos grupos de parcelass se vuelvan rojos. Hagamos que NetLogo seleccione cuatro parcelas aleatorias, y luego pida a esas cuatro parcelas que vuelvan rojas veinte parcelas cercanas. la modificación del procedimiento setup es la siguiente:

ask n-of 4 patches
  [
    ask n-of 20 patches in-radius 5
    [
      set pcolor red
    ]
  ]

Los comandos n-of y in-radius son nuevos * Busque n-of y in-radius en el Diccionario NetLogo. Puedes encontrarlos en al Diccionario y haciendo clic en la categoría Agentset (un buen lugar para buscar primitivas que tienen que ver con grupos de agentes).

(Nota: un truco importante para ir directamente a la definición de cualquier comando es haciendo clic dentro de la palabra y presionando F1.)

El Diccionario explica que n-of selecciona un subconjunto aleatorio de un grupo de agentes, e in-radius selecciona todos los agentes (en este caso parcelas) dentro de un radio especificado ( cinco ). Por lo tanto, nuestro nuevo código de setup identifica cuatro parcelas aleatorias y les pide a cada una de ellas que identifique aleatoriamente veinte parcelas dentro de un radio de cinco, y que les cambie el color a rojo. * Vaya a la pestaña Interfaz y presione el botón de setup Si todos las parcelas quedan en rojo ¡no pasa nada! ¿Hay algún error? En realidad no, porque solo le dijo al programa que pusiera algunas parcelas en rojo, pero todos las parcelas ya estaban en rojo, así que no se ve ningún cambio. Para evitar este tipo de problema, asegurémonos de que el mundo siempre sea restablecido a su estado inicial ( o sea las parcelas en negro) Esto se hace con el comando clear-all que debe agregar como segunda línea del procedimiento setup:

to setup
  clear-all
   ask n-of 4 patches
     [
       ask n-of 20 patches in-radius 5
     [
       set pcolor red
     ]
end

Olvidar poner clear-all al comienzo del procedimiento de setup es un error común para principiantes. Casi siempre, necesitamos comenzar el proceso de setup
borrando todo lo que quedaba desde la última vez que ejecutamos el modelo. Si se hace clic en el botón de setup ahora, verá un mundo en negro y rojo, Si se hace clic en el botón de setup varias veces, verá que cuatro grupos aleatorios de manchas rojas se crean, de hecho a veces parece que se crean menos grupos grandes porque los grupos se superponen. Otras veces parece que parte de un clúster se crea en el borde del mundo; para entender por qué, vaya a la sección de la Guía de interfaz de NetLogo en las Vistas y lea sobre “World Wrapping”, y vea la sección de la Guía de programación llamada “Topología”. Comprender la noción de “World Wrapping” de NetLogo es extremadamente importante! * Desde el menú principal de NetLogo, presione Archivo / Guardar. ¡Guarda tu trabajo a menudo! NetLogo no lo hará recupere su trabajo no guardado si sucede algo malo. (Y, de aquí en adelante, tu código debe coincidir con el programa completo que proporcionamos al final de esta sección) Ahora hagamos que el número de grupos de parches rojos sea un parámetro del modelo, para hacer esto, necesitamos crear una variable global numérica llamada num-clusters y darle un valor de 4, luego usela en la instrucción ask que crea los clusters. Usted puede asigne un valor a una variable utilizando el comando set, pero primero debe definir esa variable. ► En la pestaña de Código, vaya a la parte superior de todo su código e inserte

globals
  [
   num-clusters
  ]

En el procedimiento de setup, agregue al principio lo siguiente:

set num-clusters 4

reemplace el 4 en la instrucción ask n-of 4 parches por num-clusters. Ahora, si queremos cambiar el número de grupos, sabemos exactamente dónde encontrar y cambiar el valor del parámetro sin modificar nada más en el modelo. (Más tarde, usaremos deslizadores para cambiar los parámetros desde la interfaz.) Ahora que hemos construido el “mundo” del modelo, necesitamos crear los agentes, en nuestro caso dos buscadores. Esto se hace con el comando create-turtles, La declaración create-turtles 2 [] crea dos tortugas (agentes) y les hace ejecutar el código dentro de los corchetes
Agregue el siguiente código al final del procedimiento de setup Haga clic en Comprobar para buscar errores, luego pruébelo usando el botón de setup en la interfaz

create-turtles  2
  [
    set size 2
    set color yellow
  ]

El tamaño y el color son variables predefinidas de los agentes (turtles) por lo que podemos establecerlas sin definirlas. Si se hace clic en el botón setup varias veces, verá que los buscadores se colocan, por defecto, en el centro del mundo, pero su dirección varía al azar:

A.8.4 Procedimiento go

Ahora vamos a programar el procedimiento go. El procedimiento go define el “comportamiento” del modelo, o sea los procesos que se realizarán una y otra vez, y su orden. Para mantener el procedimiento go simple y fácil de entender, lo cual es muy importante porque es el corazón del programa: casi nunca programamos procesos o acciones reales dentro de ella. En cambio, definimos procedimientos auxiliares donde se programa cada acción. En nuestro modelo de b+uaqueda de hongos, solo tenemos una acción, la búsqueda de los agentes Por lo tanto, el procedimiento go necesita incluir solo un prodcedimiento, que le dice a todas las tortugas (nuestros dos buscadores) que ejecuten un procedimiento de búsqueda:

ask turtles [search]

Para que esto funcione, por supuesto, necesitamos escribir el procedimiento llamado “search” para los buscadores. * Agregue la linea, ask turtles [search] al procedimiento go. Luego cree un vacío procedimiento vacio para que pueda verificar el código :

to search
end

Ahora programemos cómo buscan los agentes(buscadores) Cada vez que se ejecuta la búsqueda, queremos que los cazadores giren, ya sea un poco si no han encontrado nada recientemente (por ejemplo, en los últimos veinte parcelas recorridas), o bruscamente para seguir buscando en la misma área si encontraron un hongo recientemente.Luego de girar los buscadores deben avanzar una parcela. * Agregue este código al procedimiento de búsqueda, cualquier parte que no entienda búsquela an el diccionario de NetLogo:

ifelse time-since-last-found <= 20
  [right (random 181) - 90]
  [right (random 21) - 10]
  
forward 1

Puede deducir buscando en el Diccionario de NetLogo que la declaración right (random 181 - 90 hace que los buscadores (turtles) giren un ángulo aleatorio entre −90 y +90 grados Observe cómo usamos lainstrución ifelse para modelar decisiones. Si la condición booleana que sigue a ifelse es verdadera, entonces el código en el primer conjunto de corchetes se ejecuta; si es falso, se ejecuta el código en el segundo conjunto de corchetes.Una condición booleana es una declaración que es verdadera o falsa. Aquí, la condición booleana time-since-last-found <= 20 consiste en una comparación: es cierto si el valor de time-since-last-found es menor o igual a 20. Pero cuando ahora presiona el botón Comprobar hay un problema:

¿Qué es el time-since-last-found?

Queremos que sea una variable que registre cuánto tiempo ha pasado desde que cada buscador encontró el último hongo Eso significa tres cosas. Primero, cada cazador debe tener su propio valor único para esta variable, por lo que debe ser una variable de tipo turtle (agente). * Justo después de la declaración global al comienzo de su programa, agregue

turtles-own
  [
    time-since-last-found
  ]

En segundo lugar, necesitamos establecer el valor inicial de esta variable cuando creamos los buscadores Estableceremos,asumiendo que los cazadores aún no han encontrado un hongo, un valor mayor que 20. ► En el procedimiento de setup, cambie la instrucción create-turtles a esto:

create-turtles 2
  [
    set size 2
    set color yellow
    set time-since-last-found 999
  ]

Finalmente, los cazadores deben actualizar time-since-last-found cada vez que se mueven Si encuentran un hongo, necesitan restablecer time-since-last-found a cero (¡y recoger el hongo!); de lo contrario, necesitan agregar uno a time-since-last-found. Definimos encontrar un hongo como llegar a una parcela roja. ► Agregue estas declaraciones al final del procedimiento search:

ifelse pcolor = red
  [
     set time-since-last-found 0
     set pcolor yellow
  ]
  [
    set time-since-last-found time-since-last-found + 1
  ]

Tenga en cuenta que estas declaraciones solo funcionan porque NetLogo permite a los agentes leer y cambiar variables de la parcela en la que están; aquí, los buscadores usan pcolor, el color de su parcela. También tenga en cuenta que para agregar uno a time-since-last-found tuvimos que usar set para asignar su nuevo valor a su antiguo valor más uno. (Tenga en cuenta que en NetLogo debe usar espacios alrededor de operadores aritméticos como “+”; de lo contrario, NetLogo cree que son parte del nombre de la variable). Asegúrese de comprender que las coordenadas de la parcela son variables discretas: solo tienen valores enteros, en unidades de ancho de parcela En contraste, las coordenadas de tortuga son variables continuas: pueden tomar cualquier valor dentro de una parcela, por ejemplo, 13.11 unidades. Por eso es importante distinguir entre instrucci9nes que se refieren a coordenadas de tortuga y aquellas que se refieren a parcelas Por ejemplo lainstrucción move-to mueve un agente (turtle) al centro de una parcela , pero forward puede colocar un agente en cualquier lugar.

Si ahora prueba el programa haciendo clic en el botón go, es posible que no pueda ver mucho porque los agentes buscadores se mueven demasiado rápido Si es así, ajuste el controlador de velocidad de ejecución en la interfaz. (Haga clic en go por segunda vez para detener la ejecución). Voilà! ¡Aquí tenemos nuestro primer programa completo de NetLogo! (¡Asegúrese de guardarlo!) A pesar de su simplicidad, contiene los elementos más importantes de cualquier modelo basado en agentes de NetLogo. Pero…

A.8.5 Tres Herramientas Importantes

antes de mirar nuestro modelo detengámonos un momento para echar un vistazo a tres herramientas muy importantes de NetLogo:

monitores de agentes,
el Centro de Comandos y
los ticks

A.8.5.1 Monitor de Agentes

Los monitores de agentes son herramientas para ver y cambiar las variables de un agente (tortuga, parcela o enlace). * Mueva el cursor sobre uno de los cazadores y haga clic derecho. Aparece un panel en el que aprece al final“turtle 0”; mueva el cursor a turtle 0 entrada y seleccione “inspect turtle 0”.

Se abre un Monitor de agente que incluye dos paneles: una vista ampliada de donde se encuentra el agente (turtle 0) y su entorno y una lista de todas las variables del agente: su posición, color, dirección, etc. Observe que aparece la variable que definimos a los agentes buscadores (time-since-last-found) (Cada panel se puede cerrary se vuelve a abrir haciendo clic en el pequeño triángulo negro en su esquina superior izquierda). Sin cerrar esta ventana, puede reiniciar el modelo haciendo clic en go y observa cómo cambian las variables del agente, también puede cambiar sus valores siempre que lo desee, simplemente ingresando un nuevo valor en el monitor. * Detenga el programa y cambie el tamaño de la tortuga a 5, y su tiempo desde la última vez que se encontró a −99. (Sus cambios se activan cuando presiona la tecla Enter o mueve el cursor fuera del cuadro de diálogo donde se ingresan los valores) Hay más cosas que puede hacer con los monitores de agentes, incluido dar comandos directamente al agente seleccionado escribiendo los mismos tipos de declaraciones de NetLogo que usaría en su código. Lea la sección Monitores de agentes de la Guía de interfaz del Manual del usuario.

A.8.5.2 Centro de Comandos

El Centro de Comando0s aparece en la parte inferior de la pestaña Interfaz. Aquí se pueden colocar comandos para el observador o para todos los parcelas, tortugas(agentes) o enlaces- Lea la sección del Centro de comandos del Manual del usuario y pruebe algunos comandos, como decirle a las parcelas que cambien su color a azul, el Centro de Comandos no parece útil al principio, pero a medida que se convierta en un mejor modelador de NetLogo, encontrará estas herramientas extramadamente útiles. Como ejemplo divertido, use el Centro de comando para hacer lo siguiente: * Después de configurar el modelo y dejar que se ejecute por un segundo o dos, para. Haga clic en el texto “observador>” en el Centro de Comandos. De la lista que aparece seleccione “tortugas>” para que ahora pueda emitir un comando a todas las tortugas. En la ventana adyacente, ingrese “hatch 1 [right 160]”, que le dice a cada buscador que cree un segundo buscador, que luego gira 160 grados:

► Ejecute el programa y vea cómo los cuatro cazadores buscan parcelas rojas. Usted puede repetir el comando para crear aún más cazadores: simplemente coloque el cursor en la línea de comando y presione la flecha hacia arriba para recuperar el comando anterior, luego teclle enter

► Después de crear más buscadores , haga que el Centro de Comando le diga cuántos buscadores hay Seleccione observador> para enviar comandos e ingrese “show count turtles”

Hasta ahora, nuestro modelo no maneja el tiempo explícitamente: no hacemos un seguimiento de cuántas veces se ejecuta el procedimiento, por lo que no podemos determinar cuánto tiempo ha transcurrido si por ejemplo, que cada vez que los buscadores de hongos se mueven representa un minuto.Para modelar el tiempo, hay que usar la instrucción tick cada vez que se ejecuta el procedimiento go. (Lea en la guía de programación la sección contador de ticks (tick counter)) y se dará cuenta que:

► Al final del procedimiento setup, se debe insertar una línea con la instrucción reset-ticks. Al comienzo del procedimiento go, inserte una línea con lainstrucción tick

Si ahora hace clic en setup y luego en go va, puede observar el contador de ticks en la parte superior de la Vista; estemuestra cuántas veces se ha ejecutado el procedimiento go. Finalmente, ¿no sería útil ver el camino del cada buscador?, Podemos hacer esto muy fácilmente cambiando las variable pen-mode.

En el procedimiento setup, agregue la instrucción pen-down, luego de la instrucción create-turtles.

UUUfff Listo!!!!!

El modelo completo de buscador de hongos es el siguente:

globals
  [
    num-clusters
  ]

turtles-own
  [
    time-since-last-found
  ]
to setup
  clear-all
  set num-clusters 4
  ask n-of num-clusters patches
    [
      ask n-of 20 patches in-radius 5
        [
          set pcolor red
        ]
    ]
create-turtles 2
  [
    set size 2
    set color yellow
    set time-since-last-found 999
    pen-down
  ]
reset-ticks
end


to go
  tick
  ask turtles [search]
end

to search
  ifelse time-since-last-found <= 20
    [right (random 181) - 90]
    [right (random 21) - 10]
  fd 1
  ifelse pcolor = red
    [
      set time-since-last-found 0
      set pcolor yellow
    ]
    [
      set time-since-last-found time-since-last-found + 1
    ]
end

Puede ensayarlo en el siguiente applet: