ICPSR - Complex Systems Models in the Social Sciences - Lab Session 1 - 2013 - Professor Daniel Martin Katz from Daniel Martin Katz
jueves, 5 de septiembre de 2013
miércoles, 4 de septiembre de 2013
martes, 3 de septiembre de 2013
lunes, 2 de septiembre de 2013
domingo, 1 de septiembre de 2013
domingo, 4 de agosto de 2013
Manual de Netlogo: Introducción, escenario y algunas vistas iniciales
He preparado un manual de Netlogo en español que te permitirá familiarizarte con este lenguaje de programación de una forma muy sencilla, a través de pequeños programas-ejemplo.
¿Qué es Netlogo? ¿Dónde puedo obtener el programa?
Netlogo es un entorno de programación que permite la simulación de fenómenos 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 relación entre el comportamiento a bajo nivel de los individuos y los patrones macroscópicos que surgen a partir de la interacción 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 creación 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. Además, su grado de desarrollo actual es suficiente como para servir como una herramienta potente para investigadores en muchos ámbitos.
Existe abundante documentación y tutoriales sobre Netlogo. El programa incluye una galería de modelos (models library), que contiene una amplia colección 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 (biología, medicina, física y química, matemáticas y computación, economía y psicología social).
Existen dos maneras de ejecutar Netlogo:
1. Descargando e instalando el programa (permite simular y editar modelos, así como la creación de modelos propios).
2. Ejecutar un applet desde una página web (permite la ejecución 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 máquina virtual de Java (JVM - Java Virtual Machine) versión 1.4.2 o superior. En la versión de descarga para Windows existe la opción de descargar una versión que incluye la JVM necesaria.
Introducción al escenario de simulación de Netlogo
Netlogo es un lenguaje de programación que sigue la filosofía 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 porción 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í según unas reglas de comportamiento y con el medio (es decir, con los patches).
Se pueden modelar la relación 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).
Vistas en Netlogo (1)
Cuando arranquemos Netlogo, la pantalla de nuestro ordenador presentará el siguiente aspecto:
En la parte superior observamos tres pestañas: interface (interfaz), information (información) y procedures (procedimientos).
Aunque lo veremos con mayor detenimiento próximamente, en la primera de las pestañas (interface) será donde se represente nuestro modelo.
En la segunda pestaña (information) podremos añadir información sobre nuestro modelo para informar a los usuarios:
y en la última pestaña (procedures) escribiremos los procedimientos que se encargarán de llevar a cabo la ejecución de nuestro modelo:
viernes, 2 de agosto de 2013
Simulando juegos, gana la conducta cooperativa
Be nice. Evolution will punish you if you’re not, says study
Selfish people have short-term advantage, but co-operation and communication win out in the long term
JAMES VINCENT
New research has challenged the notion that evolution favours self-interest above co-operation, suggesting instead that selfish individuals eventually ‘compete each other out of existence’.
The study, published in the journal Nature, used models of evolutionary game theory (EGT) to show how co-operative populations are more successful than selfish ones in the long run.
Researchers used computers to play through vast numbers of “games” simulating scenarios of co-operation and betrayal. By tweaking the strategies of the virtual players they were then able to compare which behaviours resulted in survival.
The study pitched players following so-called “zero determinant” strategies (those who acted selfishly) against others taking more benevolent approaches. While the selfish strategists enjoyed a brief advantage, opponents eventually came to recognise and overcome selfish individuals.
“Communication is critical for cooperation – we think communication is the reason co-operation occurs,” said Christoph Adami, a professor at Michigan State University and the lead author of the paper. “In an evolutionary setting, with populations of strategies, you need extra information to distinguish each other.
“We found evolution will punish you if you’re selfish and mean. For a short time and against a specific set of opponents, some selfish organisms may come out ahead. But selfishness isn’t evolutionarily sustainable.”
Much of what we understand about the working of selfish and selfless behaviour in society comes from game theory, a branch of mathematics concerned with decision making. It was developed throughout the middle of the 20th century but came to prominence first through the works of John Nash and then as a guiding political ideology during the cold war.
One of game theory’s most infamous studies is the “prisoner’s dilemma”, a hypothetical scenario where two prisoners are offered their freedom if they inform on the other. Under Nash’s explanation it seemed to show that individuals should pursue their own interests because they cannot predict how others will act.
The problem with such examples is that they are abstract and theoretical – they don’t take into account the many nuances of real-world scenarios where individuals have the opportunity to gauge how trustworthy others are, discuss their options, and also evaluate other people’s past behaviour.
Despite the apparent humane message of the findings of the new research, they do not contradict the concept of the “selfish gene” – the theory that living organisms exist only to propagate their genetic material.
Instead, the findings may complement it, as co-operative behaviour benefits whole species and thus the existence of a wider gene pool. Co-operation within a group does not preclude selfishness outside of it.
The Independent
Selfish people have short-term advantage, but co-operation and communication win out in the long term
JAMES VINCENT
New research has challenged the notion that evolution favours self-interest above co-operation, suggesting instead that selfish individuals eventually ‘compete each other out of existence’.
The study, published in the journal Nature, used models of evolutionary game theory (EGT) to show how co-operative populations are more successful than selfish ones in the long run.
Researchers used computers to play through vast numbers of “games” simulating scenarios of co-operation and betrayal. By tweaking the strategies of the virtual players they were then able to compare which behaviours resulted in survival.
The study pitched players following so-called “zero determinant” strategies (those who acted selfishly) against others taking more benevolent approaches. While the selfish strategists enjoyed a brief advantage, opponents eventually came to recognise and overcome selfish individuals.
“Communication is critical for cooperation – we think communication is the reason co-operation occurs,” said Christoph Adami, a professor at Michigan State University and the lead author of the paper. “In an evolutionary setting, with populations of strategies, you need extra information to distinguish each other.
“We found evolution will punish you if you’re selfish and mean. For a short time and against a specific set of opponents, some selfish organisms may come out ahead. But selfishness isn’t evolutionarily sustainable.”
Much of what we understand about the working of selfish and selfless behaviour in society comes from game theory, a branch of mathematics concerned with decision making. It was developed throughout the middle of the 20th century but came to prominence first through the works of John Nash and then as a guiding political ideology during the cold war.
One of game theory’s most infamous studies is the “prisoner’s dilemma”, a hypothetical scenario where two prisoners are offered their freedom if they inform on the other. Under Nash’s explanation it seemed to show that individuals should pursue their own interests because they cannot predict how others will act.
The problem with such examples is that they are abstract and theoretical – they don’t take into account the many nuances of real-world scenarios where individuals have the opportunity to gauge how trustworthy others are, discuss their options, and also evaluate other people’s past behaviour.
Despite the apparent humane message of the findings of the new research, they do not contradict the concept of the “selfish gene” – the theory that living organisms exist only to propagate their genetic material.
Instead, the findings may complement it, as co-operative behaviour benefits whole species and thus the existence of a wider gene pool. Co-operation within a group does not preclude selfishness outside of it.
The Independent
martes, 23 de julio de 2013
La necesidad de una ciencia social computacional
Let’s Shake Up the Social Sciences
By NICHOLAS A. CHRISTAKIS
TWENTY-FIVE years ago, when I was a graduate student, there were departments of natural science that no longer exist today. Departments of anatomy, histology, biochemistry and physiology have disappeared, replaced by innovative departments of stem-cell biology, systems biology, neurobiology and molecular biophysics. Taking a page from Darwin, the natural sciences are evolving with the times. The perfection of cloning techniques gave rise to stem-cell biology; advances in computer science contributed to systems biology. Whole new fields of inquiry, as well as university departments and majors, owe their existence to fresh discoveries and novel tools.
In contrast, the social sciences have stagnated. They offer essentially the same set of academic departments and disciplines that they have for nearly 100 years: sociology, economics, anthropology, psychology and political science. This is not only boring but also counterproductive, constraining engagement with the scientific cutting edge and stifling the creation of new and useful knowledge. Such inertia reflects an unnecessary insecurity and conservatism, and helps explain why the social sciences don’t enjoy the same prestige as the natural sciences.
One reason citizens, politicians and university donors sometimes lack confidence in the social sciences is that social scientists too often miss the chance to declare victory and move on to new frontiers. Like natural scientists, they should be able to say, “We have figured this topic out to a reasonable degree of certainty, and we are now moving our attention to more exciting areas.” But they do not.
I’m not suggesting that social scientists stop teaching and investigating classic topics like monopoly power, racial profiling and health inequality. But everyone knows that monopoly power is bad for markets, that people are racially biased and that illness is unequally distributed by social class. There are diminishing returns from the continuing study of many such topics. And repeatedly observing these phenomena does not help us fix them.
So social scientists should devote a small palace guard to settled subjects and redeploy most of their forces to new fields like social neuroscience, behavioral economics, evolutionary psychology and social epigenetics, most of which, not coincidentally, lie at the intersection of the natural and social sciences. Behavioral economics, for example, has used psychology to radically reshape classical economics.
Such interdisciplinary efforts are also generating practical insights about fundamental problems like chronic illness, energy conservation, pandemic disease, intergenerational poverty and market panics. For example, a better understanding of the structure and function of human social networks is helping us understand which individuals within social systems have an outsize impact when it comes to the spread of germs or the spread of ideas. As a result, we now have at our disposal new ways to accelerate the adoption of desirable practices as diverse as vaccination in rural villages and seat-belt use among urban schoolchildren.
It is time to create new social science departments that reflect the breadth and complexity of the problems we face as well as the novelty of 21st-century science. These would include departments of biosocial science, network science, neuroeconomics, behavioral genetics and computational social science. Eventually, these departments would themselves be dismantled or transmuted as science continues to advance.
Some recent examples offer a glimpse of the potential. At Yale, the Jackson Institute for Global Affairs applies diverse social sciences to the study of international issues and offers a new major. At Harvard, the sub-discipline of physical anthropology, which increasingly relies on modern genetics, was hived off the anthropology department to make the department of human evolutionary biology. Still, such efforts are generally more like herds splitting up than like new species emerging. We have not yet changed the basic DNA of the social sciences. Failure to do so might even result in having the natural sciences co-opt topics rightly and beneficially in the purview of the social sciences.
New social science departments could also help to better train students by engaging in new types of pedagogy. For example, in the natural sciences, even college freshmen do laboratory experiments. Why is this rare in the social sciences? When students learn about social phenomena, why don’t they go to the lab to examine them — how markets reach equilibrium, how people cooperate, how social ties are formed? Newly invented tools make this feasible. It is now possible to use the Internet to enlist thousands of people to participate in randomized experiments. This seems radical only because our current social science departments weren’t organized to teach this way.
For the past century, people have looked to the physical and biological sciences to solve important problems. The social sciences offer equal promise for improving human welfare; our lives can be greatly improved through a deeper understanding of individual and collective behavior. But to realize this promise, the social sciences, like the natural sciences, need to match their institutional structures to today’s intellectual challenges.
lunes, 22 de julio de 2013
Dinámica evolutiva en Netlogo con el replicador
Evolutionary Dynamics
Replicator Dynamics are a math formula meant to simplify the dynamics of evolution. But, we can code, we don't have to simplify.
In this video I show how to simulate simple evolutionary dynamics with more detail than before. The program, it turns out, is simpler than before.
Replicator Dynamics are a math formula meant to simplify the dynamics of evolution. But, we can code, we don't have to simplify.
In this video I show how to simulate simple evolutionary dynamics with more detail than before. The program, it turns out, is simpler than before.
domingo, 21 de julio de 2013
Netlogo y la extensión en R
NetLogo & R Extension
I'm really a heavy user of R and was so much before starting to do any agent based models. So the first thing I was looking in any software package for ABM was some automated link to R (much like spgrass6for GRASS and R for GIS).
I thought Repast Simphony was the way to go, since the website claims about capabilities to work along with R, but then I was disappointed to find out that it was only storing the output in a data.frame class object (and besides it does not work on a Mac…). Then after switching (at this stage almost completely) to NetLogo, I found this awesome extension, currently in beta stage (and alas, still not working on yet on a Mac…) but as far as I've seen it works perfectly fine.
The NetLogo-R-Extension developed by Jan C. Thiele and Volker Grimm (one of the authors of the ABM textbook of the previous post) links seamlessly NetLogo to R through the rJava package. This means that you can do much more than exporting your results in a data.frame class object: you can call R while your simulation is running!!!! So for instance you can plot the L-function of your agents' spatial distribution on the fly while the simulation is running (see the picture below). But this is just the tip of the iceberg! Since you can virtually call any command in R while running your model, you can save plots in any folder, link to Databases (I haven't tried yet, but I guess it's possible), and virtually do any analysis you would like to do and store it in a .Rdata file!!!
Example of a NetLogo ABM with continuos plot of the L function (along with the Confidence Envelope)
viernes, 19 de julio de 2013
Implementación de la dinámica de replicador
Replicator Dynamics Implementation
In tomorrow's lecture I will be talking about replicator dynamics in games. The video below shows you how to implement it:
viernes, 5 de julio de 2013
martes, 2 de julio de 2013
lunes, 1 de julio de 2013
Netlogo: Una introducción
Programación
en NetLogo
Por Juan MC Larrosa
A1. Introducción
NetLogo es un entorno de modelado
programable para simular fenómenos naturales y sociales desde la perspectiva de
la modelización basada en agentes. Fue escrito por Uri Wilensky en 1999 (Wilensky,
1999) y ha estado en constante evolución desde entonces en el Center for
Connected Learning and Computer-Based Modeling (Centro para el Aprendizaje Conectado
y la Modelización informatizada) de la Northwestern University. Es
especialmente adecuado para el modelado de sistemas complejos dinámicos. Los creadores
de modelos pueden dar instrucciones a los cientos o miles de
"agentes" de todos los que operan de forma independiente. Esto hace
que sea posible explorar la conexión entre el comportamiento a nivel micro de
los individuos y el macro-nivel de los patrones que emergen de la interacción
de muchos individuos.
El programa se presenta con una
amplia documentación y tutoriales. Es provisto con una biblioteca de modelos,
que es una gran colección de simulaciones pre-escritas que pueden ser utilizadas
y modificadas. Estas simulaciones abordar muchas áreas de contenido en las
ciencias naturales y sociales, incluyendo la biología y la medicina, la física
y la química, las matemáticas y ciencias de la computación, y la economía y la
psicología social.
Es la generación siguiente de una
serie ambientes multi-lenguajes de modelado de agentes que se inició con
StarLogo. NetLogo se ejecuta en la máquina virtual Java, así que funciona en
todas las principales plataformas (Mac, Windows, Linux, et al). Se ejecuta también
como una aplicación independiente. Modelos y actividades HubNet se puede
ejecutar como applets de Java en un navegador web.
Dada la teoría expuesta en el segundo
capítulo y la descripción presentada en el tercer capítulo sobre los algoritmos
genéticos (AG), el presente capítulo plantea la modelización del esquema
teórico de juegos de formación de redes en un esquema de AG.
En este capítulo se presentará los
experimentos computacionales para verificar como los modelos teóricos son
modelados y analizados mediante el esquema de algoritmos genéticos. En ese
sentido un esquema general será presentado con variaciones en el esquema de fitness el cual será adaptado a cada
modelo particular proveyendo esto la adaptación a cada modelo teórico.
El modelado será desarrollado en un ambiente
de programación basada en agentes llamado Netlogo. Ese ambiente de programación ha sido creado
en Java e interpreta un lenguaje de programación denominado Quasi-Pearl. En
todos los casos analizados se generará una población inicial aleatoria (o una
serie de poblaciones) a partir de la cual se valorará su desempeño y mediante
diferentes estrategias de selección se extraerán individuos cuales serán
apareados para obtener nuevos individuos y así generar una nueva población
desarrollándose este procedimiento hasta la activación de algún procedimiento
de finalización.
A.2 Esquema general
El código presenta una interface en
donde se aprecia una red circular con un mínimo de tres nodos y un máximo de
100, pudiéndose elegir el número de nodos de la que se pretende analizar a
través movilizar un menú deslizante a la derecha. Del mismo modo se presentan
diversos menúes desplegables, deslizantes y botones de activación para ir
seleccionando las diversas configuraciones de algoritmo genético. Entre las
opciones se encuentran seleccionar los parámetros de los operadores genéticos
así como elegir diversas estructuras de costos de interconexión y recepción de
información directa o indirecta. A medida que el algoritmo realiza la búsqueda
de las estructuras evolutivas de equilibrio va presentando cada una de las
corridas en pantalla. Parte de la información se presenta en menús de la
interfaz. El Gráfico 1 muestra la interfaz de uno de los cuatros códigos
realizados para este trabajo, siendo todos básicamente similares.
Gráfico 1. Interface
A.3 Principios de programación en ambiente NetLogo
Agentes
|
El mundo NetLogo
se compone de los agentes. Los agentes son seres que pueden seguir las
instrucciones. Cada agente puede llevar a cabo su propia actividad, todo
simultáneamente.
En NetLogo, hay
cuatro tipos de agentes: las tortugas, los parches, los vínculos, y el
observador. Las tortugas son los agentes que se mueven alrededor del mundo.
El mundo es de dos dimensiones y se divide en una cuadrícula de parches. Cada
parche es un cuadrado de "tierra" sobre las que las tortugas pueden
moverse. Los enlaces son los agentes que conectan dos tortugas. El observador
no tiene un lugar - usted puede imaginarlo cómo mirando al mundo de las
tortugas y los parches.
Cuando NetLogo se
inicia, no hay tortugas todavía. El observador puede crear nuevas tortugas.
Los parches pueden crear nuevas tortugas también. (Los parches no se pueden
mover, pero por lo demás son tan "vivos", como las tortugas y el
observador son.)
Los enlaces no
tienen las coordenadas, sino que se tienen dos extremos (cada una tortuga).
Enlaces aparecer entre los dos extremos, a lo largo de la ruta más corta
posible, incluso si eso significa envolver todo el mundo.
La forma en que el
World o lanscape de los parches está conectado puede cambiar. Por defecto, el
mundo es un toro que significa que no está acotado, pero "se
ajusta" - así que cuando una tortuga se mueve más allá del borde del
mundo, desaparece y reaparece en el borde opuesto y cada parche tiene el
mismo número de " muestras cercanas ", si usted es un parche en el
borde del mundo, algunos de sus" vecinos "están en el borde
opuesto. Sin embargo, puede cambiar las configuraciones de ajuste con el
botón Configuración. Si el envase no está permitido en una dirección dada a
continuación, en esa dirección (X o Y) el mundo es limitada. Parches a lo
largo de esa frontera que tenga menos de 8 vecinos y las tortugas no se mueve
más allá del borde del mundo. Vea la sección de Topología para más información.
|
Procedimientos
|
En NetLogo, los
comandos y los reporteros les dicen a los agentes qué hacer. Un comando es
una acción de un agente para llevar a cabo. Un reportero se obtiene un
resultado e informar de ello.
La mayoría de los
comandos comienzan con verbos ("create", "die",
"jump", "inspect", "clear"), mientras que la
mayoría de los reporteros son sustantivos o sintagmas nominales.
Los comandos y los
reporteros integrados en NetLogo son llamados primitivas. El Diccionario
NetLogo tiene una lista completa de comandos integrados y los reporteros.
Los comandos y los
reporteros que se definen a sí mismo se denominan procedimientos. Cada
procedimiento tiene un nombre, precedido por la palabra to. La palabra clave end marca
el final de los comandos en el procedimiento. Una vez que se define un
procedimiento, se puede utilizar en otra parte del programa.
Muchos de los
comandos y los reporteros reciben entradas (inputs) - los valores que el comando
o el reportero utiliza para llevar a cabo sus acciones.
Ejemplos: Aquí hay
dos procedimientos de comandos:
to setup
clear-all ;; inicializa el
mundo a cero
crt 10
;; crea 10 nuevas tortugas
end
to go
ask turtles
[ fd
1 ;; todas las tortugas se
mueven un paso
rt
random 10 ;; adelante y rotan n
pasos al azar
lt
random 10 ]
end
Observe el uso del
punto y coma para agregar "comentarios" para el programa.
Comentarios que su programa más fácil de leer y entender.
En este programa, setup y go son comandos
definidos por el usuario. Por otro lado, clear-all, crt ("create turtles"), ask, lt ("left turn"), y rt ("right
turn") son todos los comandos primitivos.
random
y turtles son reporteros primitivos. random toma
un solo número como una entrada y reporta un número entero aleatorio que es
menor que la de entrada (en este caso, entre 0 y 9). turtles reporta
el conjunto de agentes (agentes) constituida por todas las tortugas.
setup
y go pueden ser llamados por otros
procedimientos o por botones. Muchos modelos de NetLogo tienen el botón que
llama una vez a un procedimiento llamado setup,
(sólo se requiere inicializar los datos al principio) y un botón de llamada
permanente que llama a un procedimiento llamado go.
En NetLogo, debe
especificar qué agentes - tortugas, parches, enlaces, y al observador - van a
ejecutar cada comando. (Si no se especifica, el código se ejecuta por el
observador.) En el código anterior, el observador utiliza para pedir que el
conjunto de todas las tortugas de ejecutar los comandos entre corchetes.
clear-all y crt sólo se puede ejecutar por el observador. fd, por el contrario, sólo puede ser ejecutado por las
tortugas. Algunos otros comandos y los reporteros, como conjunto, pueden ser
ejecutados por diferentes tipos de agentes.
Aquí están algunas
características más avanzadas que puede aprovechar la hora de definir sus
propios procedimientos.
Procedimientos con entradas
Sus propios
procedimientos pueden tomar entradas, al igual que lo hacen las primitivas.
Para crear un procedimiento que acepta entradas, incluye una lista de nombres
de entrada entre corchetes después de que el nombre del procedimiento. Por ejemplo:
to draw-polygon
[num-sides len]
pen-down
repeat num-sides
[ fd len
rt 360 / num-sides ]
end
En el resto del
programa, usted podría pedir a las tortugas cada sorteo un octágono con una
longitud lateral igual a su número de los que:
ask turtles [
draw-polygon 8 who ]
Procedimientos
de reportero
Al igual que usted
puede definir sus propios comandos, usted puede definir sus propios
reporteros. Usted debe hacer dos cosas especiales. En primer lugar, use to-report en lugar de comenzar el procedimiento con to. Luego, en el cuerpo del procedimiento, utilice el
reporte para comunicar el valor que desea que se informe.
to-report
absolute-value [number]
ifelse number >= 0
[ report number ]
[ report (- number) ]
end
|
Variables
|
Variables de agentes
Agente de
variables son los lugares para almacenar los valores (como los números) en un
agente. Una variable de agente puede ser una variable global, una variable de
tortuga, una variable de parche, o una variable de enlace.
Si una variable es
una variable global, hay un solo valor para la variable, y cada agente puede
acceder a ella. Usted puede pensar en las variables globales como
pertenecientes al observador.
Las variables de tortuga,
parche, y enlace son diferentes. Cada tortuga tiene su propio valor para cada
variable de tortuga, y cada parche tiene su propio valor para cada variable
de parche, y lo mismo para los enlaces.
Algunas variables
están integradas en NetLogo. Por ejemplo, todas las tortugas tienen una
variable de color, y todos los parches tienen una variable de pcolor. (La variable parche comienza con "p"
para que no se confunda con la variable de la tortuga.) Si se establece la
variable, la tortuga o cambios de parches de color.
Otras variables
incorporadas tortuga incluyendo xcor, ycor, y heading.
Otras variables incorporadas de parches incluyen pxcor y pycor.
Usted también
puede definir sus propias variables. Usted puede hacer una variable global
mediante la adición de un interruptor o un control deslizante para su modelo,
o con los globales clave en el comienzo de su código, así:
globals [ score ]
También se puede
definir nueva tortuga, el parche y enlace variables usando las
tortugas-propias, parches-y vínculos propios, palabras propias, como esto:
turtles-own [energy speed]
patches-own [friction]
links-own [strength]
Estas variables
pueden ser utilizadas libremente en su modelo. Utilice el comando set para
establecerlos. (Si no se les van a empezar a almacenar un valor de cero.)
Las variables
globales se pueden leer y establecer en cualquier momento por cualquier
agente. Además, una tortuga puede leer y establecer las variables de revisión
de la revisión es de pie. Por ejemplo, este código:
ask turtles [ set pcolor red ]
hace que cada
tortuga para hacer la revisión que está de pie en la luz roja. (Dado que las
variables de parches son compartidos por las tortugas de esta manera, no se
puede tener una variable de tortuga y una variable de parche con el mismo
nombre.)
En otras
situaciones en la que desea un agente para leer variable de un agente
diferente, usted puede aprovechar. Ejemplo:
show [color] of turtle 5
;; imprime el color actual de la tortuga cuyo
número who es 5
También se puede
utilizar de una expresión más complicada que el nombre de una variable, por
ejemplo:
show [xcor + ycor] of turtle 5
;;
imprime la suma de las coordenadas x e y de la
;; tortuga
cuyo número who es 5
Las variables locales
Una variable local
se define y utiliza sólo en el contexto de un determinado procedimiento o
parte de un procedimiento. Para crear una variable local, utilice el comando let. Usted puede utilizar este comando en cualquier
lugar. Si lo usa en la parte superior de un procedimiento, la variable existe en todo el procedimiento. Si lo
usa dentro de un conjunto de corchetes, por ejemplo dentro de un "ask", entonces existirá sólo dentro de los corchetes.
to swap-colors
[turtle1 turtle2]
let temp [color] of turtle1
ask turtle1 [ set color [color] of turtle2
]
ask turtle2 [ set color temp ]
end
|
Listas
|
En los modelos más
simples, cada variable tiene sólo una pieza de información, normalmente un
número o una cadena de caracteres. La característica de la lista le permite
almacenar múltiples piezas de información en una sola variable mediante la
recopilación de las piezas de información en una lista. Cada valor en la
lista puede ser cualquier tipo de valor: un número o una cadena de bits, un
agente o agentset, o incluso otra lista.
Las listas permiten
el conveniente embalaje de la información en NetLogo. Si sus agentes realizar
un cálculo repetitivo en múltiples variables, podría ser más fácil tener una
lista de variables, en lugar de las variables de número múltiples. Varias
primitivas simplifican el proceso de realizar el mismo cálculo para cada
valor en una lista.
Listas de constante
Usted puede hacer
una lista con sólo poner los valores que desee en la lista entre corchetes,
como sigue: set
mylist [2 4 6 8]. Tenga en cuenta que
los valores individuales están separados por espacios. Puede hacer listas que
contienen números y cadenas de esta forma, así como listas de listas, por
ejemplo, [[2
4] [3 5]].
La lista vacía es
escrita por poner nada entre paréntesis, así: [].
Crear listas sobre la marcha
Si desea hacer una
lista en la que los valores son determinados por los periodistas, en lugar de
ser una serie de constantes, utiliza el reportero lista. El reportero de la
lista acepta otros dos reporteros, los ejecuta, y los informes de los
resultados como una lista.
Si quisiera una
lista que contiene dos valores aleatorios, que podría utilizar el siguiente
código:
set random-list
list (random 10) (random 20)
Esto conjunto random-list para
una nueva lista de dos números enteros aleatorios cada vez que se ejecuta.
Para hacer las
listas más o menos largo, puede utilizar el reportero lista con menos o más
de dos entradas, pero para poder hacerlo, deberá adjuntar toda la llamada en
paréntesis, por ejemplo:
(list random 10)
(list random 10
random 20 random 30)
|
Comandos
Comando
|
Sintaxis e interpretación
|
ask
|
ask agentset [commands]
ask agent [commands]
El agente determinado o conjunto de
agentes (agentes) ejecuta las órdenes dadas.
Ej.
ask turtles [fd 1] ;; Todas las tortugas de avanzar un paso
ask patches [set pcolor
red] ;; Todos los parches de color
rojo
ask turtle 4 [rt 90] ;,
Sólo la tortuga 4 gira a la derecha
Nota: sólo el observador puede pedir a
todas las tortugas o todos los parches. Esto impide que sin darse cuenta que
todas las tortugas de pedir a todas las tortugas o todos los parches de pedir
a todos los parches, que es un error común de hacer si no somos cuidadosos
con la que los agentes se ejecute el código que está escribiendo.
Nota:
Sólo los agentes que están en el agentset en el momento de pedir comienza
ejecutar los comandos.
|
breed
|
breed
Se trata de una variable integrada de
tortuga y de enlace. Lleva a cabo la agentset de todas las tortugas o los
enlaces de la misma raza que esta tortuga o un enlace. (Para las tortugas o
los enlaces que no tienen ninguna raza en particular, se trata del agentset
de todas las tortugas o de todos los enlaces, respectivamente.) Puede
establecer esta variable a cambio de una tortuga o enlace de la raza.
Ej.
breed [cats cat]
breed [dogs dog]
;; código de
tortuga:
if breed = cats [
show "meow!" ]
set breed dogs
show
"woof!"
|
ca
|
clear-all
Resetea
todas las variables globales a cero, y llama a todas las variables integradas
calls reset-ticks, clear-turtles, clear-patches, clear-drawing,
clear-all-plots, y clear-output para inicialicen todo.
|
if
|
if condición [ commands ]
El reportero debe reportar un valor
booleano (verdadero ó falso).
Si condición reporta verdadero, se
ejecutan los commands.
El reportero podría reportar un valor
diferente para agentes diferentes, de modo que algunos agentes ejecutarían
algunos comandos y otros no.
Ej.
if xcor > 0[ set
color blue ]
;; las tortugas en la
mitad derecha del landscape se tornan azules
|
ifelse
|
ifelse reportero [ commands1
] [ commands2 ]
El reportero debe reportar un valor
booleano (verdadero o falso).
Si el reportero reporta verdadero, se
ejecutan los commands1.
Si el reportero reporta falso, se
ejecutan los commands2.
El reportero podría reportar un valor
diferente para agentes diferentes, de modo que algunos agentes ejecutarían
los commands1 y otros los commands2.
Ej.
ask patches
[ ifelse pxcor > 0
[ set pcolor blue ]
[ set pcolor red ] ]
;; la mitad izquierda del
landscape se torna rojo y
;; la otra mitad se torna azul
|
item
|
item índice lista
item índice string
En listas, reporta el valor del ítem en
la lista mencionada con el índice mencionado.
En las cadenas de caracteres (strings),
reporta el carácter en la cadena mencionada en el índice citado.
Nótese que los índices comienzan de 0,
no de 1. (El primer ítem es el item 0, el segundo ítem es item 1, y así.)
Ej.
;; suponga que mylist es
[2 4 6 8 10]
show item 2 mylist
=> 6
show item 3
"my-shoe"
=> "s"
|
length
|
length lista
length string
Reporta
el número de ítems en una lista dada, ó el número de caracteres en una cadena
de caracteres.
|
let
|
let variable valor
Crea una nueva variable local y le da un
valor dado. Una variable local es una que existe solo dentro de un bloque
cerrado de commands.
Es para crear la variable, si dentro del
bloque de commands se quiere cambiar el valor se debe usar set.
Ej:
let prey one-of
sheep-here
if prey != nobody
[ ask prey [ die ] ]
|
lput
|
lput valor lista
Añade un valor al final de una lista y
reporta la nueva lista.
Ej.
;; suponga que mylist es
[2 7 10 "Bob"]
set mylist lput 42
mylist
;; mylist ahora queda [2 7 10 "Bob" 42]
|
max
|
max lista
Reporta el valor numérico máximo en la
lista. Ignora otro tipo de ítems.
Ej.
show max [xcor] of
turtles
;; Imprime la coordinada x
de la Tortuga que está más
;; a la derecha en el landscape
|
min
|
min lista
Reporta el valor numérico mínimo en la
lista. Ignora otro tipo de ítems.
Ej.
show min [xcor] of
turtles
;; imprime la menor coordenada x de todas las tortugas
|
of
|
[reporter] of agent
[reporter] of agentset
For an
agent, reports the value of the reporter for that agent (turtle or patch).
Ej.
show [pxcor]of
patch 3 5 ;; imprime 3
show [pxcor] of
one-of patches ;; imprime el valor pxcor de un parche aleatorio
show [who * who] of
turtle 5 ;;=> 25
show [count turtles
in-radius 3] of patch 0 0 ;; imprime
el número de tortugas localizadas dentro de un radio de tres parches del
origen
Para un conjunto de agentes (agentset),
reporta una lista que contiene el valor del reportero para cada agente en el
agentset (en orden aleatorio).
Ej.
crt 4
show sort [who] of
turtles
=> [0 1 2 3]
show sort [who *
who] of turtles
=> [0 1 4 9]
|
precision
|
precision número lugares
Reporta el número redondeado a lugares
decimales.
Si lugares es negativo, el redondeo toma
lugar al izquierda del punto decimal.
Ej.
show precision
1.23456789 3
=> 1.235
show precision 3834
-3
=> 4000
|
repeat
|
repeat número [ commands ]
Corre commands un número de veces.
Ej.
pd repeat 36 [ fd 1 rt 10 ] ;; la tortuga
dibuja un círculo
|
replace-item
|
replace-item índice lista valor
replace-item índice string1 string2
En una lista, reemplaza un ítem en esa
lista. índice es el índice del ítem a ser remplazado, empezando desde 0.
(El sexto ítem en una lista tendría un
índice de 5.) Nótese que "replace-item" es usado en conjunción con
"set" para cambiar una lista.
Del mismo modo para una cadena de
caracteres, pero el carácter dado del string1
removido y los contenidos del string2 son cortados en vez.
show replace-item 2
[2 7 4 5] 15
=> [2 7 15 5]
show replace-item 1
"cat" "are"
=> "caret"
|
set
|
set variable valor
Fija a la variable un valor dado.
Variable puede ser cualquiera de los
siguientes:
·
Una variable global declarada usando
"globals"
·
La variable global asociada con un menú deslizable,
un switch, un selector, ó un cuadro de ingreso de datos (input box).
·
Una variable perteneciente a un agente que está
siendo llamado
·
Si el agente llamado es una tortuga, una variable
perteneciente al parche debajo de la tortuga.
·
Una variable local creada por el comando let.
·
Una entrada al procedure actual.
·
Una variable especial local (?, ?1, ?2...).
|
sum
|
sum lista
Reporta
la suma de los ítems en la lista.
Ej.
show sum [energy] of turtles
;; prints the total of the variable "energy"
;; from all the turtles
|
while
|
while [reporter] [
commands ]
Si el
reporter reporta falso, sale del ciclo. En cualquier otro caso corre run
commands y lo repite.
El
reporter podría tener diferente valores para diferentes agentes de modo que algunos podrían correr los
commands un número diferente de veces que otros agentes.
Ej.
while [any? other turtles-here]
[ fd 1 ]
;;
la tortuga se mueve hasta que encuentra un parche que
;; no tenga ninguna tortuga encima.
|
Suscribirse a:
Entradas (Atom)