**NetLogo: Fundamentos**
En el mundo de la simulación basada en agentes, NetLogo se destaca como una herramienta flexible y accesible para explorar sistemas complejos. Comenzaremos esta inmersión en NetLogo definiendo este entorno: ¿qué es exactamente NetLogo y por qué es tan popular en el ámbito de la simulación? A partir de ahí, exploraremos los conceptos básicos que fundamentan esta plataforma, desde los Agentes que son las entidades activas en la simulación, hasta las Propiedades y Variables Globales que pueden afectar el comportamiento del sistema en su totalidad. También abordaremos los Conjuntos de Agentes, que permiten agrupar y controlar múltiples entidades de manera eficiente, así como las Estructuras de Control que nos brindan las herramientas para diseñar la lógica de nuestra simulación. Por último, no olvidaremos las Especies, como rebaños o familias, que pueden ser modeladas y estudiadas dentro de NetLogo, proporcionando un marco completo para la exploración de sistemas complejos y dinámicos."
# ¿Qué es NetLogo?
![](./img/netlogo.jpeg align="right")**NetLogo** es un lenguaje de programación simple y adaptado al modelado/simulación de fenómenos en los que aparecen muchos individuos interactuando (como, por ejemplo, en los fenómenos habituales que se dan en la naturaleza, las sociedades, o muchas áreas de las ciencias):
* es adecuado para modelar sistemas complejos que evolucionan en el tiempo,
* es adecuado para modelar centenares o miles de individuos (personas, bacterias, insectos, organizaciones, nodos de un grafo, etc.) que interactúan entre sí y con el entorno,
* permite explorar la conexión entre las interacciones locales a nivel de individuo y los patrones macroscópicos que emergen de dichas interacciones.
Es también un ambiente de programación fácil e intuitivo de usar para crear y probar nuevos modelos:
* Permite abrir y experimentar simulaciones.
* Permite crear modelos rápidamente para comprobar hipótesis sobre sistemas descentralizados.
* Viene con una gran biblioteca de simulaciones en ciencias naturales y sociales, que pueden ser usadas y modificadas.
* Los modelos se construyen usando un lenguaje muy simple, que incluso es adecuado como primer lenguaje de programación, y que tiene inspiración en el paradigma funcional/declarativo.
* Posee una interfaz gráfica intuitiva y fácil de usar.
A pesar de todas las ventajas, debe tenerse presente que el objetivo de NetLogo es proporcionar una herramienta de prototipado y desarrollo rápido de modelos de simulación, no de aplicaciones finales.
Hay dos maneras de ejecutar NetLogo:
1. Descargando e instalando el programa: lo que permite ejecutarlo como cualquier otro programa habitual.
2. Usando la nueva versión Web del software desde un navegador (está en desarrollo y todavía no presenta las mismas funcionalidades que la versión de escritorio, pero ya está muy avanzado).
A pesar de ser interesante ejecutar un modelo en NetLogo Web, la ejecución como programa independiente ofrece una serie de ventajas:
* El programa se ejecuta más rápido, por lo que los modelos van más deprisa.
* Está disponible un menú para edición y tiene muchas otras funcionalidades disponibles.
* Permite crear nuevos modelos.
Para descargar los ficheros de instalación de NetLogo, basta ir al sitio [http://ccl.northwestern.edu/netlogo/](http://ccl.northwestern.edu/netlogo/). El software funciona en varios sistemas operativos: Windows, MacOS, y Linux, siempre y cuando haya instalada una máquina virtual Java (JVM - Java Virtual Machine). Desde que NetLogo se actualizó a usar Java 8, en todas las versiones la descarga por defecto incluye la JVM necesaria y optimizada para NetLogo, y que no afectará a otras versiones instaladas en el sistema operativo.
# Conceptos básicos
A pesar de que el lenguaje NetLogo es bastante fácil de aprender, no pone límites a la sofisticación de los modelos que pueden ser creados con él. Tiene como orientación principal la de modelar sistemas compuestos por individuos que interaccionan entre sí y con el medio, basándose en el paradigma de **modelado por agentes**:
!!!note:Paradigma ABM
* Un **agente** es un _individuo sintético, autónomo y dotado de reglas o características que gobiernan su comportamiento y su capacidad de tomar decisiones_.
* Los agentes **interaccionan entre sí y con el medio ambiente** obedeciendo un conjunto de reglas.
* Los agentes son **flexibles** y tienen capacidad de aprender y adaptar su comportamiento basándose en la experiencia. Esta capacidad requiere alguna forma de memoria. Los agentes incluso pueden tener reglas para modificar sus reglas de comportamiento.
## Agentes
!!!def
NetLogo viene equipado con cuatro tipos de agentes:
* **_Agentes móviles (tortugas):_** son los agentes que se mueven por el mundo. El mundo es (en principio) 2D y está dividido en una malla de _patches_.
* _**Agentes inmóviles (patches):**_ cada una de las divisiones cuadradas del mundo.
* _**Agentes conectores (links):**_ agentes que conectan entre sí los agentes móviles (a modo de aristas de un grafo).
* _**Agente observador:**_ no tiene localización, y puede interactuar con todos los elementos del mundo. De alguna forma, representa al superagente que puede controlar todas las demás componentes del mundo.
Podemos controlar un modelo de NetLogo por medio de botones e interruptores. Además, el sistema ofrece la posibilidad de controlar los modelos por medio del **centro de comandos**. Desde el que se pueden ejecutar comandos sobre un modelo y modificar sus parámetros.
Para familiarizarnos con los comandos básicos de NetLogo, vamos a construir un acuario virtual de tortugas y peces. Al iniciar NetLogo nos encontramos con un modelo vacío, que podemos modificar y ampliar a nuestro antojo.
En general, las _tortugas_ y los _patches_ se controlan usando respectivamente los siguientes comandos:
```
ask turtles [ comandos ]
ask patches [ comandos ]
```
Comenzaremos por representar el agua dando un color azul a los _patches_. Para ello, escribimos el comando
```
ask patches [ set pcolor blue]
```
en el centro de comandos y pulsamos _enter_.
Aunque los patches ya están creados en el mundo cuando comenzamos a trabajar con él, no ocurre lo mismo con las tortugas (ni con los links), que hay que crearlos explícitamente para poder usarlos. Tanto el _observador_ (observer), como las _tortugas_ o los _patches_ pueden crear _tortugas_ nuevas, cada uno usando un comando distinto. Los comandos respectivos para ello son:
* Observador: `crt n` (versión abreviada de `create-turtles n`). Este comando crea _n_ _tortugas_ todas ellas localizadas en el origen (aunque con orientaciones y colores al azar).
* Tortugas: `hatch n [ comandos ]`. La tortuga genera _n_ nuevas _tortugas_ idénticas a ella y en la misma posición `(xcor, ycor)`, posteriormente, cada cuna de las nuevas tortugas ejecutará los comandos.
* Patch: `sprout n [ comandos ]`. Del _patch_ *brotan* `n` _tortugas_ localizadas en las coordenadas (enteras) del `patch (pxcor, pyxor)` y posteriromente, las nuevas tortugas ejecutará los comandos.
Vamos a colocar en nuestro ejemplo 10 tortugas en el acuario. Escribimos el comando
```
crt 10
```
en el centro de comandos y pulsamos _enter_. Inicialmente, las tortugas están agrupadas en el patch que ocupa el origen de coordenadas, pero podemos moverlas a sus posiciones finales.
En NetLogo además de la posición `(xcor, ycor)`, las tortugas también tienen una orientación (`heading`) medida en grados a partir del eje _y_. Para asignar valores a estas propiedades se dispone de los siguientes comandos:
* `set heading θ`, donde `θ` es un número real entre 0 y 360.
* `setxy x y`, donde `(x, y)` es un punto dentro del dominio.
* `set xcor x`, donde `x` es un número real dentro del dominio.
* `set ycor y`, donde `y` es un número real dentro del dominio.
Y para modificarlos también podemos usar los siguientes comandos:
* `fd l` (`forward l`) La _tortuga_ avanza `l` pasos en la dirección de su orientación.
* `lt θ` (`left θ`). La _tortuga_ gira `θ` grados a su izquierda.
* `rt θ` (`right θ`). La _tortuga_ gira `θ` grados a su derecha.
## Propiedades y Variables Globales
Ya hemos visto algunas variables que vienen predefinidas en NetLogo, por ejemplo `pcolor` en el caso de `patches` y `xcor`, `ycor`, `heading` y `color` en el caso de las `tortugas`. Podemos crear nuestras propias variables, que pueden ser globales, cuando representan una propiedad global del sistema (por ejemplo, el número de generaciones que se van formando), variables que pertenecen a los `patches` y que son usadas para representar atributos de memoria de cada tesela de terreno (por ejemplo, la altitud de esa tesela, o la cantidad de comida que hay en ese trozo de suelo), o variables que pertenecen a _tortugas_ y que representan igualmente atributos de memoria para cada una de las tortugas (por ejemplo, el sexo o la posición que ocupaba antes).
A continuación damos ejemplos de estos tres tipos de variables que se pueden encontrar en NetLogo:
* Variables intrínsecas a cada `patch:`
```
patches-own [ altitud poblacion ]
```
* Variables intrínsecas a cada _tortuga:_
```
turtles-own [ sexo posicion-anterior ]
```
* Variables globales:
```
globals [ generacion ]
```
Estos comandos solo funcionan en la pestaña `Procedures`, que es donde se añade el código del modelo (con la ventaja lógica sobre el centro de comandos). Como ejemplo de aplicación vamos a dotar de sexo a las tortugas añadiendo el comando
```
turtles-own [ sexo ]
```
en la pestaña `Procedures` y a continuación añadimos el comando
```
ask turtles [
set sexo (random 2)
]
```
en el centro de comandos para dar valores (`0` o `1`) a la variable `sexo` que acabamos de crear.
NetLogo viene provisto de una extensa colección de funciones, por ejemplo:
* `count turtles`. Cuenta el número de tortugas.
* `random n`. Genera un número aleatorio entre `0` y `n - 1`.
* `random-float x`. Genera un número aleatorio real en `[0,x)`.
* `random-xcor`, `random-ycor`. Genera números aleatorios reales para las coordenadas `x` e `y`, respectivamente, dentro del dominio gráfico.
Por supuesto, también permite construir nuestras propias funciones, como veremos más adelante.
## Conjuntos de agentes
Vamos ahora a usar el sexo de las tortugas para modificar su asepcto visual. Una forma de hacerlo consiste en dividir las torugas por el valor que contenga su variable sexo. Para ello podemos usar el comando
```
ask turtles with [ sexo = 0 ] [
set color pink
]
```
Lo que el comando anterior consigue es ejecutar una acción determinada sobre el subconjunto de las tortugas que verifica una cierta propiedad.
El NetLogo proporciona herramientas muy potentes para aplicar comandos selectivamente a un conjunto de agentes que verifiquen cierta propiedad por medio del ask conjunto-de-agentes [ comandos ]. En realidad, esta es la forma general de la instrucción ask, pero anteriormente la habíamos aplicado al caso particular en el que considerábamos como conjunto de agentes el total de tortugas (turtles) o patches. Algunos ejemplos de cómo construir conjuntos de agentes son:
* `turtles with [ sexo = 1 ]`. Tortugas de `sexo = 1`.
* `turtles with [ xcor > 0 ]`. Tortugas en el lado derecho del mundo.
* `patches with [ pycor > 0 ]`. `Patches` en el "hemisferio" norte.
* `turtles-here`. Todas las tortugas en cietro `patch`, esta forma debe ser usada por otra tortuga o patch. Por ejemplo la regla: _las tortugas infectadas (color rojo) infectan a las demás que están en el mismo patch_ sería traducida al siguiente comando:
```
ask turtles with [ color = red ][
ask turtles-here [
set color red
]
]
```
* `other turtles`. Similar a turtles, pero en este caso no se considera la tortuga que ejecuta la llamada.
## Estructuras de control
Vamos a cambiar también la apariencia visual de las tortugas de `sexo = 1`. En este caso vamos a usar estructuras de control para ilustrar su uso. Para ello, podemos ejecutar el comando
```
ask turtles [
if (sexo = 1) [ set color sky ]
]
```
Las estructuras de control ofrecen otra forma de ejecutar selectivamente acciones en NetLogo:
* `if condicion [ comandos ]`. Si se verifica la condición, se ejecutan los comandos. Por ejemplo:
```
if (sexo = 1) [ set color sky ]
```
* `ifelse condicion [ comandos1 ][ comandos2 ]`. Si se verifica la condición, se ejecutan los `comandos1`, si no, los `comandos2`. Por ejemplo:
```
ifelse
(sexo = 0) [ set color pink ]
[ set color sky ]
```
* `ifelse condicion1 [ comandos1 ] condicion2 [ comandos2 ]...[condicion-else]`. Si se verifica la `condición-i`, se ejecutan los `comandos-i`, si no, los `comandos-else`. Por ejemplo (a partir de NetLogo 6.1.0):
```
ifelse
(sexo = 0) [ set color pink ]
(sexo = 1) [ set color sky ]
[ set color gree ]
```
* `while [ condicion ][ comandos ]`. Mientras se verifique la condición se ejecutan los `comandos`. Por ejemplo:
```
ask turtles [
while [ ycor < 0 ] [
set ycor (ycor + 1)
]
]
```
(las tortugas se desplazan hacia el hemisferio norte).
NetLogo permite combinar predicados por medio de operadores lógicas para construir estructuras más sofisticadas. Las tres operaciones más comunes son `and` (y), `or` (o) y `not` (no).
## Especies (rebaños, familias,...)
En el sistema no estamos limitados al uso de una sola especie de agentes móviles (_tortugas_), sino que podemos crear tantas como queramos, cada una con sus propios atributos y comportamientos. De esta forma podemos imitar ecosistemas compuestos por varias especies o economías sofisticadas formadas por distintos tipos de productores y consumidores.
Para crear una especie se usa el comando:
```
breed [ especie-plural especie-singular ]
```
al principio de la parte de _Procedures_. De esta forma, nos podemos referir a la especie entera o a uno de sus individuos. Algunos comandos y reportes usarán nombre plural (la de la especie), como por ejemplo `create`, mientras que otros harán uso de la versión singular, `neighbor` (entorno del individuo). En general, las reglas que sigue para usar uno u otro son las derivadas del lenguaje natural.
Una vez definida una especie nueva, automáticamente se genera un conjunto de agentes asociado a ella, de forma que todo lo que hemos visto para conjuntos de agentes en general se aplica para seleccionar individuos de una misma especie.
Por ejemplo para crear dos especies (`ranas` y `peces`) usaríamos los comandos:
```
breed [ ranas rana ]
breed [ peces pez ]
```
Una vez creadas, todas las nuevas especies tienen comandos equivalentes a los de las _tortugas_, que son heredados automáticamente. Para usarlos basta sustituir, en cada comando, la palabra clave turtles por el del nombre de la especie. Por ejemplo:
* `create-turtles n`
* `ask turtles [ comandos ]`
* `ask turtles [ hatch n [ comandos ] ]`
* `count turtles`
* `ask turtles with [ condición ][ comandos ]`
* `turtles-here`
* `other turtles`
* `turtles-own`
* `create-peces n`
* `ask peces [ comandos ]`
* `ask peces [ hatch n [ comandos ] ]`
* `count peces`
* `ask peces with [ condición ][ comandos ]`
* `peces-here`
* `other peces`
* `peces-own`
Además, cada especie hereda las siguientes primitivas de forma automática: `create-`, `hatch-`, `sprout-`, `-here`, `-at`, `-on` y `is-?`.
Incluso, los individuos de una especie pueden migrar de especie. Por ejemplo un pez no tiene que ser pez el resto de su vida, y podría convertirse en un anfibio (suponiendo que hemos declarado ambas especies), modificando adecuadamente la propiedad `breed` que tienen todos los agentes:
```
ask one-of peces [
set breed ranas
]
```
Como apoyo visual, el NetLogo ofrece también una forma de modificar el aspecto de las diversas familias de tortugas que podemos crear por medio del comando:
```
ask turtles [
set shape nombre-de-forma
]
```
Ahora podemos aplicar los comandos para crear nuestro acuario de tortugas y peces. Para ellos, escribimos en Procedures:
```
breed [ ranas rana ]
breed [ peces pez ]
tortugas-own [ sexo ]
```
y en el centro de comandos:
```
ask patches [ set pcolor blue ]
create-ranas 10
ask ranas [ fd 10 ]
ask ranas [ set sexo (random 2) ]
ask ranas [ if (sexo = 0) [set color pink] ]
ask ranas with [sexo = 1] [ set color sky ]
create-peces 5
ask peces [ fd 5 ]
ask ranas [ set shape "frog" ]
ask peces [ set shape "fish" set color green ]
```
Para cada individuo se puede preguntar por la especie a la que pertenece, ya que automáticamente se añade entre sus variables una especial, de nombre `breed`, en la que almacena el nombre de su especie. Por ejemplo:
```
if breed = peces [ ... ]
```
Gracias a esta variable, podemos hacer que un individuo cambie de especie (sí, es verdad que no es algo habitual en la biología, pero pensemos que las especies pretenden ser tan generales como para representar cualquier tipo de familia de agentes). Para ello basta usar la palabra clave set tal y como hacemos con cualquier variable:
```
ask one-of peces [ set breed ranas ]
```
(insert menu.md.html here)