IODA NetLogo Dictionary

Clears all interactions and matrices. This is done automatically if you use the clear-all NetLogo command, but you might also need to re-load different interactions (or matrices) without resetting the whole model.

See also ioda:clear-matrices.

Clears interaction and update matrices. This is done automatically if you use the clear-all NetLogo command, but you might also need to re-load different matrices without resetting the whole model.
NB: Interactions are kept unchanged. If you need to clear also interactions, use ioda:clear-all instead.

Kills the agent with regards to the IODA simulation process: the agent is not immediately removed from the NetLogo simulation, but it is no more taken into account in the IODA engine. You MUST use this command instead of the die NetLogo command to destroy IODA agents in a proper way. If the agent is a turtle, it is actually removed from the NetLogo simulation at the end of the ioda:go procedure.

<p>Reports the distance between the current agent (a turtle or a patch) and the specified agent (a turtle or a patch). Please remember that in NetLogo the distance to or from a patch is computed from the center of the patch. Thus, a turtle can interact with the patch-here at distance 0 only if it is exactly at the center of the patch.

N.B.: By default, the distance is computed using the Euclidean metric (i.e. the NetLogo distance reporter), but you can use the Moore or the Von Neumann metric instead.

See also ioda:set-metric

Filters, adds, removes or retains only neighbors situated within the specified distance (using ioda:distance). This commands are very useful for writing concrete primitives for the filter-neighbors abstract primitive.

See the Tutorial for detailed explanations about this process.
See also ioda:distance, ioda:filter-neighbors-in-cone, ioda:filter-neighbors-custom, ioda:filter-neighbors-on-patches, ioda:filter-neighbors-on-links.

Filters, adds, removes or retains only neighbors of the relevant kind (i.e. the breeds or patches which are likely to undergo interactions from the caller), according to the specified reporter name and its parameters. This commands may be used for writing concrete primitives for the filter-neighbors abstract primitive. The string is the name of a reporter which is supposed to take 3 arguments: the source agent, the target agent, and a list of parameters. It must return a boolean which indicates whether or not the target can be perceived by the source, w.r.t the parameters.

For instance, suppose that you want to divide your worlds into logical "levels" (e.g. several floors, without using true 3D): then you endow all agents with a variable "level" and you expect that each agent cannot interact but with agents of the same level. This can be done as follows:

turtles-own [ level ]
...
to-report same-level? [ source target params ] ; here we do not use params
  report [level] of source = [level] of target
end

to myspecies::filter-neighbors
  ioda:filter-neighbors-custom "same-level?" [] 
end

Another example: suppose that you model aerials which can only interact with agents endowed with a specific frequency range defined by a slider. You can do this as follows:

to-report within-range? [source target range]
  let f [frequency] of target
  report (f >= first range) and (f <= last range)
end

to aerials::filter-neighbors
  ioda:filter-neighbors-custom "within-range?" (list min-freq max-freq)
end

See the Tutorial for detailed explanations about this process.
See also ioda:distance, ioda:filter-neighbors-in-cone, ioda:filter-neighbors-in-radius, ioda:filter-neighbors-on-patches, ioda:filter-neighbors-on-links.

Filters, adds, removes or retains only neighbors situated within the specified distance and angle. This commands are very useful for writing concrete primitives for the filter-neighbors abstract primitive.

See the Tutorial for detailed explanations about this process.
See also ioda:distance, ioda:filter-neighbors-in-radius, ioda:filter-neighbors-custom, ioda:filter-neighbors-on-patches, ioda:filter-neighbors-on-links.

Filters, adds, removes or retains only neighbors situated on the specified patches. This commands are very useful for writing concrete primitives for the filter-neighbors abstract primitive.

See the Tutorial for detailed explanations about this process.
See also ioda:filter-neighbors-in-radius, ioda:filter-neighbors-in-cone, ioda:filter-neighbors-custom, ioda:filter-neighbors-on-links.

Filters, adds, removes or retains only neighbors which are linked with the current agent through the specified linkset (which can contain symmetrical links or outgoing links at the same time). This commands are very useful for writing concrete primitives for the filter-neighbors abstract primitive, especially if you work with social networks.

See the Tutorial for detailed explanations about this process.
See also ioda:filter-neighbors-on-patches, ioda:filter-neighbors-in-cone, ioda:filter-neighbors-custom, ioda:filter-neighbors-in-radius.

Performs one simulation step according to the IODA simulation process. During a IODA simulation step, the following operations occur:

1. All labile agents perform their update interactions
2. All active and operative agents try to perform an

interaction on either themselves, or one or more target agents chosen among their passive neighbors.

See the Tutorial for detailed explanations about this process.
See also ioda:setup.

Initializes a new agent. Especially, notifies the IODA scheduler about the new agent. Thus, you are strongly recommended to run this command as soon as you create a new agent during the simulation, especially in the action primitives of an interaction.

Reads the specified text file and builds the corresponding interactions. An interaction file must follow the following syntax:

[EXCLUSIVE|PARALLEL] INTERACTION <name>
[TRIGGER <tr_1> ... <tr_n>]
[TRIGGER <tr'_1> ... <tr'_n>]
...
[CONDITION <cond_1> ... <cond_n>]
[CONDITION <cond'_1> ... <cond'_n>]
...
[ACTIONS <act_1> ... <act_n>]
END

See the Tutorial for detailed examples.
See also ioda:load-matrices, ioda:read-interactions-from-string.

Save the interactions of the current model into the specified text file. If the boolean is true, then a confirmation is asked before overwriting an existing file.

See also ioda:save-matrices, ioda:load-interactions.

Reads the specified multi-linge string and builds the corresponding interactions. An interaction string must follow the following syntax:

[EXCLUSIVE|PARALLEL] INTERACTION <name>
[TRIGGER <tr_1> ... <tr_n>]
[TRIGGER <tr'_1> ... <tr'_n>]
...
[CONDITION <cond_1> ... <cond_n>]
[CONDITION <cond'_1> ... <cond'_n>]
...
[ACTIONS <act_1> ... <act_n>]
END

See also ioda:load-interactions.

Reads the text file specified by string1 and builds the corresponding interaction and update matrices. Since matrix files are CSV files, string2 provides the characters used as field separators: in most example, spaces (' ') and tabs ('\t'), thus string2 is " \t". A matrix file must follow the following fields:

<source> <interaction> <priority>
OR: 
<source> <interaction> <priority> UPDATE
OR: 
<source> <interaction> <priority> <target> <distance> [<target-selection-policy>]

See the Tutorial for detailed examples.
See also ioda:load-interactions.

Save the interaction and update matrices of the current model into the specified text file. If the boolean is true, then a confirmation is asked before overwriting an existing file.

See also ioda:save-interactions, ioda:load-matrices.

This reporter is frequently used in perception or action primitives, during interaction selection and interaction execution. It reports either the potential (in perception primitives) or actual (in action primitives) target(s) of an interaction (when run by the potential or actual source agent), or the potential or actual source of an interaction (when run in the target agent). This is used very frequently for the evaluation of triggers and conditions, and for performing the actions of an interaction.

Three kind of values may be reported:

• nobody means that the interaction is a reflexive one (the target agent is also the source): thus trigger, condition and actions only depend on the source agent.
• one agent: this agent is a candidate partner for an interaction. If ioda:my-target is run by a potential target agents, it reports the source of the potential interaction.
• a list of agents is reported when special interaction target policies are used (namely: ALL, FILTER:, ALL-BEST: and NUMBER:)

See the Tutorial for detailed examples.

Reports a string representing the declaration of all IODA primitives needed by your current model (i.e. for your current interaction matrix and update matrix). IODA primitives are:

• reporters of the form "A-BREED::A-REPORTER", where "A-REPORTER" appears in the trigger or condition of an interaction, and "A-BREED" is the agentset name (including patches) of the agent that will have to evaluate the reporter
• commands of the form "A-BREED::A-COMMAND", where "A-COMMAND" appears in the actions of an interaction, and "A-BREED" is the agentset name (including patches) of the agent that will have to run the command

The resulting string is the squeletton for writing the appropriate code without forgetting any IODA primitive. You just have copy-paste the commands and reporters in your Procedures tab, and fill them with your own code.

See also ioda:check-consistency.

Initializes all variables and data structures needed to run a IODA NetLogo simulation. This command has to be run at the end of the setup procedure, just before starting the simulation.

See also ioda:go.

Specifies a metric for computing distances in the IODA NetLogo simulation engine. At the end of the ioda:setup procedure, the ioda:metric variable is set to "Euclidean". You can change it either to "Moore" or to "Von Neumann".

ioda:set-metric "Euclidean" 
print [ioda:distance patch 2 1] of patch 0 0 
=> 2.23606797749979

ioda:set-metric "Moore"
print [ioda:distance patch 2 1] of patch 0 0
=> 2

ioda:set-metric "Von Neumann"
print [ioda:distance patch 2 1] of patch 0 0
=> 3

See also ioda:distance.

Reports the product version of the IODA NetLogo extension.

print ioda:version
=> 2.3

Reports true if all IODA primitives of your current model (i.e. for your current interaction matrix and update matrix) have been written in your program; throws an exception otherwise. IODA primitives are:

• reporters of the form "A-BREED::A-REPORTER", where "A-REPORTER" appears in the trigger or condition of an interaction, and "A-BREED" is the agentset name (including patches) of the agent that will have to evaluate the reporter
• commands of the form "A-BREED::A-COMMAND", where "A-COMMAND" appears in the actions of an interaction, and "A-BREED" is the agentset name (including patches) of the agent that will have to run the command

See also ioda:primitives-to-write.

Reports the agentset which corresponds to the specified string. For turtles and patches the string can use the singular or plural form, but for other breeds only the plural form gives the appropriate agentset. Otherwise, reports nobody.

breed [ants ant]
print ioda:get-breed-named "ants"
=> ants
print ioda:get-breed-named "ant"
=> nobody
print ioda:get-breed-named "turtles"
=> turtles
print ioda:get-breed-named "patch"
=> patches

Reports the name of the concrete primitive that this breed must implement so as to be able to run the abstract primitive given in the string.

print ioda:concrete-primitive one-of wolves "wiggle"
=> wolves::wiggle

Reports true if this agent can take part in the IODA simulation, false otherwise (i.e. if it is ignored by the IODA simulation engine).

See also ioda:alive? ioda:set-alive

Defines whether or not this agent can take part in the IODA simulation, or if must be ignored by the IODA simulation engine.

See also ioda:alive? ioda:is-alive?

Reports false if the agent has already performed an interaction or if it has been the target of an exclusive interaction within the current time step.

See also ioda:operative? ioda:set-operative

Defines whether or not this agent can act as a source, or undergo an exclusive interaction, during the current time step.

See also ioda:operative? ioda:is-operative?

Reports the interaction and target chosen and performed by this agent during the current time step.

See also ioda:decision

Reports the agents (turtles or patches) that have been perceived by this agent during the current time step.

See also ioda:neighbors ioda:set-my-neighbors

Defines the list of the agents (turtles or patches) that are perceived by this agent during the current time step. This can be used to customize the filter-neighbors perception primitive.

See also ioda:neighbors ioda:my-neighbors

Defines a special ordering for scheduling active agents during the interaction selection step. By default, the list of active agents is shuffled at each tick: by using this primitive, the list is sorted according to the reporter task that is specified. This should be used carefully so as to avoid simulation biases. In order to work properly, this primitive has to be executed after the ioda:setup primitive. Using this primitive with parameter "random" restores the default scheduling.
Below is an example that schedules active agents according to their ID (who).

ioda:set-ordering-policy-for-interaction-selection task [ [who] of ?1 < [who] of ?2]

See also: the example provided in tutorial files (4b-leap years), ioda:set-ordering-policy-for-update

Defines a special ordering for scheduling labile agents during the update step. By default, the list of labile agents is shuffled at each tick: by using this primitive, the list is sorted according to the reporter task that is specified. This should be used carefully so as to avoid simulation biases. In order to work properly, this primitive has to be executed after the ioda:setup primitive. Using this primitive with parameter "random" restores the default scheduling.
Below is an example that schedules labile agents according to their ID (who).

ioda:set-ordering-policy-for-update task [ [who] of ?1 < [who] of ?2]

See also: the example provided in tutorial files (4b-leap years), ioda:set-ordering-policy-for-interaction-selection

Reports the list of all interactions defined in the model.

Prints the list of all interactions defined in the model as they can be found in the text files.

Reports true if the interaction is EXCLUSIVE, false if it is PARALLEL. The Tutorial provides explanations about exclusive and parallel interactions.

See also ioda:set-exclusive, ioda:set-exclusive-interactions.

Specifies wether or not the interaction must be used as EXCLUSIVE or PARALLEL. The Tutorial provides explanations about exclusive and parallel interactions.

See also ioda:is-exclusive?, ioda:set-exclusive-interactions.

Specifies wether or not the interaction to be declared must be defined as EXCLUSIVE (true) or PARALLEL (false) by default. Interactions that have already been declared are kept unchanged. By default, interactions are considered PARALLEL. The Tutorial provides explanations about exclusive and parallel interactions.

See also ioda:is-exclusive?, ioda:set-exclusive.

Reports the interaction of the specified name.

print ioda:get-interaction "Hunt"
=> {{ioda:interaction ["hunt" [["hungry?"]] [["adult?" "target:alone?"]] ["chase"]]}}

See also ioda:interaction-from-list.

Reports an interaction with the specified name, trigger, condition and actions.

print ioda:interaction-make "Hunt" [["hungry?"]] [["adult?" "target:alone?"]] ["chase"]
=> {{ioda:interaction ["Hunt" [["hungry?"]] [["adult?" "target:alone?"]] ["chase"]]}}

Reports the name of the interaction.

print ioda:interaction-name ioda:interaction-make "Hunt" [["hungry?"]] [["adult?" "target:alone?"]] ["chase"]
=> Hunt

Reports an interaction built from a list containing a name, a list of triggers, a list of conditions and a list of actions.

print ioda:interaction-from-list ["Hunt" [["hungry?"]] [["adult?" "target:alone?"]] ["chase"]]
=> {{ioda:interaction ["Hunt" [["hungry?"]] [["adult?" "target:alone?"]] ["chase"]]}}

See also ioda:interaction-make.

Reports a list containing one or two lists, which themselves contain the actual reporters that should be evaluated in order to know wether the condition of the interaction is fulfilled or not, with a list identifying the agent (turtle or patch) running this reporter as the source agent, and the other turtle or patch as the target of the interaction (or nobody if the interaction is degenerate). The first item each sublist identifies the agent that should evaluate the reporters, the other items are the reporter themselves with their target.

let i ioda:interaction-make "Hunt" [["hungry?"]] [["adult?" "target:alone?"]] ["chase"]
print [ioda:eval-condition i one-of sheep] of one-of wolves
=> [[[[51] [WOLVES::adult? [25]]] [[25] [SHEEP::alone? [51]]]]]
;; means that turtle 51 (a wolf) must evaluate reporter wolves::adult? 
;; with parameter turtle 25, and conversely turtle 25 (a sheep) must 
;; evaluate reporter sheep::alone? with parameter turtle 51

set i ioda:interaction-make "Sleep" [["tired?"]] [["no-danger?"]] ["rest"]
print [ioda:eval-condition i nobody] of one-of wolves
=> [[[[50] [WOLVES::no-danger? []]]]]
;; turtle 50 has to evaluate reporter wolves::no-danger? with parameter nobody
;; (no target agent, represented by the empty list following the reporter)

See also ioda:eval-trigger, ioda:perform-actions.

Reports a list containing one or two lists, which themselves contain the actual reporters that should be evaluated in order to know wether the trigger of the interaction is fulfilled or not, with the agent (turtle or patch) running this reporter as the source agent, and the other turtle or patch as the target of the interaction (or nobody if the interaction is degenerate). The first item of each sublist is the agent that should evaluate the reporters, the other items are the reporter themselves.

let i ioda:interaction-make "Hunt" [["hungry?"]] [["adult?" "target:alone?"]] ["chase"]
print [ioda:eval-trigger i one-of sheep] of one-of wolves
=> [[[(TURTLE 5) (WOLVES::hungry?(TURTLE 1))]]]
;; means that turtle 5 (a wolf) must evaluate reporter wolves::hungry? with parameter turtle 1 

set i ioda:interaction-make "Sleep" [["tired?"]] [["no-danger?"]] ["rest"]
print [ioda:eval-trigger i nobody] of one-of wolves
=> [[[(TURTLE 4) (WOLVES::tired?(nobody))]]]
;; turtle 4 has to evaluate reporter wolves::tired? with parameter nobody (no target agent)

See also ioda:eval-condition, ioda:perform-actions.

Reports a list containing zero, one or more lists, which themselves contain the actual procedures that should be run in order to perform the interaction, with the agent (turtle or patch) running this command as the source agent, and the other turtle or patch as the target of the interaction (or nobody if the interaction is degenerate). The first item of each sublist is the agent that should run the procedures, the other items are the procedures themselves. Note that the order of the procedures is generally important.

let i ioda:interaction-make "Eat" [["hungry?"]] [["target:healthy?"]] ["digest" "roar" "target:die"]
print [ioda:perform-actions i one-of sheep] of one-of wolves
=> [[(TURTLE 4) (WOLVES::digest(TURTLE 0)) (WOLVES::roar(TURTLE 0))] [(TURTLE 0) (SHEEP::die(TURTLE 4))]]
;; means that turtle 4 (a wolf) must run procedure wolves::digest with parameter turtle 0, 
;; then procedure wolves::roar with parameter turtle 0 ; after that turtle 0 (a sheep) must
;; run procedure sheep::die with parameter turtle 4

set i ioda:interaction-make "Sleep" ["tired?"] ["no-danger?"] ["rest"]
print [ioda:perform-actions i nobody] of one-of sheep
=> [[(TURTLE 2) (SHEEP::rest(nobody))]]
;; turtle 2 has to run procedure sheep::rest with parameter nobody (no target agent)

See also ioda:eval-condition, ioda:eval-trigger.

Reports an assignation built from the items of the list. The list may contain the following items:

• a source breed name, an interaction name, a priority level: in that case, the target is nobody (reflexive interaction)
• a source breed name, an interaction name, a priority level, a target breed name, a limit distance
• a source breed name, an interaction name, a priority level, a target breed name, a limit distance, a target selection policy

print ioda:assignation-from-list ["ants" "Take" 20 "food" 1]
;; reports the assignation of the "Take" interaction (which must exist!)
;; to "ants" agents as sources, with "food" agents as targets,
;; at priority level 20, and with a limit distance of 1.
=> {{ioda:assignation ["ants" "take" 20 "food" 1 "RANDOM"]}}

See ioda:assignation-to-list

Reports a list built from the specified assignation. The list may contain the following items:

• a source breed name, an interaction name, a priority level: in that case, the target is nobody (reflexive interaction)
• a source breed name, an interaction name, a priority level, a target breed name, a limit distance
• a source breed name, an interaction name, a priority level, a target breed name, a limit distance, a target selection policy

See ioda:assignation-from-list

Reports the source breed for the specified assignation.

print ioda:get-source-breed ioda:assignation-from-list ["ants" "Take" 20 "food" 1]
=> ants

See also ioda:get-target-breed, ioda:get-priority, ioda:get-distance, ioda:get-interaction-of, ioda:target-selection-method, ioda:set-target-selection-method, ioda:is-degenerate?.

Reports the target breed for the specified assignation.

print ioda:get-target-breed ioda:assignation-from-list ["ants" "Take" 20 "food" 1]
=> food
print ioda:get-target-breed ioda:assignation-from-list ["ants" "Move" 10]
=> nobody

See also ioda:get-source-breed, ioda:get-priority, ioda:get-distance, ioda:get-interaction-of, ioda:target-selection-method, ioda:set-target-selection-method, ioda:is-degenerate?.

Reports the priority level for the specified assignation.

print ioda:get-priority ioda:assignation-from-list ["ants" "Take" 20 "food" 1]
=> 20

See also ioda:get-source-breed, ioda:get-target-breed, ioda:get-distance, ioda:get-interaction-of, ioda:target-selection-method, ioda:set-target-selection-method, ioda:is-degenerate?.

Reports the limit distance for the specified assignation.

print ioda:get-distance ioda:assignation-from-list ["ants" "Take" 20 "food" 1]
=> 1

See also ioda:get-source-breed, ioda:get-target-breed, ioda:get-priority, ioda:get-interaction-of, ioda:target-selection-method, ioda:set-target-selection-method, ioda:is-degenerate?.

Reports the interaction for the specified assignation.

print ioda:get-interaction-of ioda:assignation-from-list ["turtles" "Delete" 20 "turtles" 1]
=> {{ioda:interaction ["delete" [] [] ["target:die"]]}}

See also ioda:get-source-breed, ioda:get-target-breed, ioda:get-priority, ioda:get-distance, ioda:target-selection-method, ioda:set-target-selection-method, ioda:is-degenerate?.

Reports true if the assignation is degenerate (i.e. if it has nobody as target), false otherwise.

print ioda:is-degenerate? ioda:assignation-from-list ["turtles" "Delete" 20 "turtles" 1]
=> false
print ioda:is-degenerate? ioda:assignation-from-list ["ants" "Move" 10]
=> true

See also ioda:get-source-breed, ioda:get-target-breed, ioda:get-priority, ioda:get-distance, ioda:get-interaction-of, ioda:target-selection-method, ioda:set-target-selection-method.

Reports the interaction/target selection policy used by this assignation (by default: "RANDOM", which means that all interaction/target pairs found by the simulation engine to be realizable are chosen with equal probability for performing an interaction.

See also ioda:get-source-breed, ioda:get-target-breed, ioda:get-priority, ioda:get-distance, ioda:get-interaction-of, ioda:set-target-selection-method, ioda:is-degenerate?.

Defines the interaction/target selection policy used by this assignation (by default: "RANDOM", which means that all interaction/target pairs found by the simulation engine to be realizable are chosen with equal probability for performing an interaction). Possible string values are: "RANDOM", "RANDOM-INT", "BEST:/aReporter/", "PRORATA:/aReporter/", "NUMBER:/min/-/max/", "ALL-BEST:/aReporter/", "FILTER:/aReporter/". Please refer to the "Pheromones" and "Explosion" sections of the Tutorial to learn about target selection policies.

See also ioda:get-source-breed, ioda:get-target-breed, ioda:get-priority, ioda:get-distance, ioda:get-interaction-of, ioda:target-selection-method, ioda:is-degenerate?.

Reports a list of active breeds (including patches if necessary), i.e. breed (or patches in general) that can perform some interactions (according to the Interaction Matrix of the current model).

See also ioda:active-agents-with-targets, ioda:passive-agents, ioda:labile-agents.

Reports a list of active breeds (including patches if necessary) which can perform at least one non-degenerate interaction, i.e. breed (or patches in general) that can perform some interactions (according to the Interaction Matrix of the current model) on other agents.

See also ioda:active-agents, ioda:passive-agents, ioda:labile-agents.

Reports a list of passive breeds (including patches if necessary), i.e. breed (or patches in general) that can undergo some interactions (according to the Interaction Matrix of the current model).

See also ioda:active-agents, ioda:active-agents-with-targets, ioda:labile-agents.

Reports a list of labile breeds (including patches if necessary), i.e. breed (or patches in general) that can change their state through update interactions (according to the Update Matrix of the current model).

See also ioda:active-agents, ioda:active-agents-with-targets, ioda:passive-agents.

Reports true if this turtle or patch is member of an active breed, i.e. if its breed (or if patches in general if this agent is a patch) can perform some interactions (according to the Interaction Matrix of the current model) ; reports false otherwise.

See also ioda:is-labile?, ioda:is-passive?.

Reports true if this turtle or patch is member of a passive breed, i.e. if its breed (or if patches in general if this agent is a patch) can undergo some interactions (according to the Interaction Matrix of the current model) ; reports false otherwise.

See also ioda:is-active?, ioda:is-labile?.

Reports true if this turtle or patch is member of a labile breed, i.e. if its breed (or if patches in general if this agent is a patch) can change their state through update interactions (according to the Update Matrix of the current model) ; reports false otherwise.

See also ioda:is-active?, ioda:is-passive?.

Reports the interaction matrix for the current model.

;; load the "simple ecosystem" example and run "setup" first
print ioda:get-interaction-matrix
=> {{ioda:matrix [{{ioda:assignation ["wolves" "eat" 10 "sheep" 1 "RANDOM"]}} 
      {{ioda:assignation ["wolves" "hunt" 5 "sheep" 5 "RANDOM"]}} 
      {{ioda:assignation ["wolves" "moverandomly" 0]}} 
      {{ioda:assignation ["sheep" "eat" 10 "patches" 0 "RANDOM"]}} 
      {{ioda:assignation ["sheep" "mate" 5 "sheep" 1 "RANDOM"]}} 
      {{ioda:assignation ["sheep" "moverandomly" 0]}}]}}

See also ioda:set-interaction-matrix, ioda:get-update-matrix, ioda:set-update-matrix.

Reports the update matrix for the current model.

;; load the "simple ecosystem" example and run "setup" first
print ioda:get-update-matrix
=> {{ioda:matrix [{{ioda:assignation ["patches" "grow" 0]}}]}}

See also ioda:get-interaction-matrix, ioda:set-interaction-matrix, ioda:set-update-matrix.

Defines the interaction matrix for the current model.

See also ioda:get-interaction-matrix, ioda:get-update-matrix, ioda:set-update-matrix.

Defines the update matrix for the current model.

See also ioda:get-interaction-matrix, ioda:set-interaction-matrix, ioda:get-update-matrix.

Prints the interaction matrix for the current model as a CSV file (with tabs as field separator).

See also ioda:print-update-matrix

Prints the update matrix for the current model as a CSV file (with tabs as field separator).

See also ioda:print-interaction-matrix

Reports a new, empty interaction or update matrix.

Reports a list containing all assignations contained in the specified matrix.

Reports a list corresponding to the actual data structure used for storing assignations (priority-ordered lists, grouped by source breeds).

;; load the "simple ecosystem" example and run "setup" first
print ioda:matrix-view ioda:get-interaction-matrix
=> [[wolves [{{ioda:assignation ["wolves" "eat" 10 "sheep" 1 "RANDOM"]}}] 
            [{{ioda:assignation ["wolves" "hunt" 5 "sheep" 5 "RANDOM"]}}] 
            [{{ioda:assignation ["wolves" "moverandomly" 0]}}]] 
    [sheep [{{ioda:assignation ["sheep" "eat" 10 "patches" 0 "RANDOM"]}}] 
           [{{ioda:assignation ["sheep" "mate" 5 "sheep" 1 "RANDOM"]}}] 
           [{{ioda:assignation ["sheep" "moverandomly" 0]}}]]]

Adds the specified assignation to the specified matrix. When used direclty, it is recommended to run ioda:check-consistency to ensure that all required concrete primitives are already written.

;; a very small IODA model
let im ioda:matrix-make
let i ioda:interaction-make "Take" [] [["can-take-load?"]] ["take-target" "target:die"]
ioda:add-assignation im ioda:assignation-from-list ["ants" "Take" 20 "food" 1]
ioda:set-interaction-matrix im

See also ioda:remove-assignation, ioda:replace-assignation, ioda:check-consistency

Removes the specified assignation from the specified matrix.

ioda:remove-assignation ioda:get-interaction-matrix ioda:assignation-from-list ["ants" "Take" 20 "food" 1]

See also ioda:add-assignation, ioda:replace-assignation

Replaces the specified assignation by the new one in the specified matrix. Replacement is done by merely removing the old assignation, then adding the new one. When used direclty, it is recommended to run ioda:check-consistency to ensure that all required concrete primitives are already written.

ioda:replace-assignation ioda:get-interaction-matrix 
  ioda:assignation-from-list ["ants" "Take" 20 "food" 1]
  ioda:assignation-from-list ["ants" "Take" 30 "food" 2 "BEST"]

See also ioda:remove-assignation, ioda:add-assignation, ioda:check-consistency

Reports a priority-ordered list corresponding to assignations where the specified breed plays the role of the source.

;; load the "particles" example and run the "setup" procedure first
print ioda:get-matrix-line ioda:get-interaction-matrix turtles
=> [[{{ioda:assignation ["turtles" "delete" 1 "turtles" 1 "RANDOM"]}}]
    [{{ioda:assignation ["turtles" "moverandomly" 0]}}]]

Reports a list of breeds (including patches) corresponding to agentsets which can be the target of interactions performed by this breed (eventually patches).

;; load the "simple ecosystem" example and run the "setup" procedure first
print ioda:get-breed-targets sheep
=> [patches sheep]  
;; that means that sheep are able to perform interaction on patches and on other sheep

The name of the metric used to compute distances between agents in the IODA NetLogo simulation. In this version three metrics are pre-defined: "Euclidean", "Moore" and "Von Neumann". In order to prevent this variable to take invalid values, please use the ioda:set-metric procedure to change the metric.

See also ioda:set-metric

The task used for scheduling active agents during the interaction selection step. The default value for this variable is "random", which means that the list of active agents is shuffled at each tick (so as to avoid simulation biases). In order to prevent this variable to take invalid values, please use the ioda:set-ordering-policy-for-interaction-selection procedure to change the task.

See also ioda:set-ordering-policy-for-interaction-selection

The task used for scheduling labile agents during the update step. The default value for this variable is "random", which means that the list of labile agents is shuffled at each tick (so as to avoid simulation biases). In order to prevent this variable to take invalid values, please use the ioda:set-ordering-policy-for-update procedure to change the task.

See also ioda:set-ordering-policy-for-update

The list of actual interactions that have been performed during one interaction selection step within the run of the ioda:go procedure. This can be useful for statistics or debugging. The list contains items of the form [/source-agent/ interaction-name target-agent/], where /target-agent is nobody in reflexive interactions.

See also ioda:performed-updates

The list of actual interactions that have been performed during one update step within the ioda:go procedure. This can be useful for statistics or debugging. The list contains items of the form [/source-agent/ /interaction-name/] (since all update interactions are reflexive interactions).

See also ioda:performed-interactions

Contains true if this agent (turtle or patch) is considered alive in the IODA model, i.e. allowed to perform or undergo interactions (from the interaction or update matrices). Otherwise, a dead agent cannot take part in the simulation.
NB  1: As the alive variable has a different name in turtles and patches, you should rather use ioda:is-alive? and ioda:set-alive to inspect or modify this variable.
NB  2: The alive status can be used to ignore temporarily some agents without removing them from the simulation, since dead agents are not actually removed, unless they are explicitly killed using the ioda:die procedure. See for instance the setup and go procedures in the "ants and food" example.

See also ioda:die, ioda:is-alive?, ioda:set-alive

Contains the interaction and target that result from the interaction selection process of the agent. This depends on the interaction matrix and the neighboring agents.
NB: As the decision variable has a different name in turtles and patches, you should rather use ioda:my-decision to inspect this variable.

See also ioda:my-decision

Contains the neighbors that have been perceived by the agent during this time step.
NB: As the neighbors variable has a different name in turtles and patches, you should rather use ioda:my-neighbors and ioda:set-my-neighbors to inspect or modify this variable.

See also ioda:my-neighbors, ioda:set-my-neighbors, ioda:filter-neighbors-in-radius, ioda:filter-neighbors-on-patches

Contains false if the agent has already performed an interaction or if it has been the target of an exclusive interaction within the current time step.
NB: As the operative variable has a different name in turtles and patches, you should rather use ioda:is-operative? and ioda:set-operative to inspect or modify this variable.

See also ioda:is-operative?, ioda:set-operative.

This variable can be useful to identify the actual or potential partner of an agent in an interaction.
NB: As the target variable has a different name in turtles and patches, you should rather use ioda:my-target to inspect this variable.

See also ioda:my-target.