Difference between revisions of "Primitive Operators and Properties"

Latest revision as of 18:57, 17 November 2018

Numerus supports a large set of primitives divided into properties and primitive operators, or primops.

A property is an identifier assigned a value at the beginning of a simulation run which is not expected to change. For example, the rows and cols properties of a CellMatrix are fixed at the start of a run and don’t change. A special type of property, called a scope, is used to look up the current values of components.

Primops are functions of zero or more arguments. Some primitives may be used without restriction; others make sense only in specific contexts; for example rows and cols are only useful in spatial contexts such as CellMatrices, AgentVectors and SimWorlds.

Here are the properties and primops supported by the current Numerus implementation, organized by type and area of applicability. All properties (except for mathematical properties) begin with a lower case letter, and all primops are composed entirely of capital letters. Primops are always functions, and therefore require an argument list (even if empty) in order to be invoked.

Notation: x, y represent values (numbers or string constants or expressions); fn represents a Javascript function; exp represents a string expression; [x, y] represents one or more optional arguments, coords represents a coords object of the form {row: r, col: c} or (in the case of 3 dimensions) {row: r, col: c, plane: p}.

Universal Properties and Primops

These can be used in any expression in any component.

Properties

self
scope: The scope of a simulator (Capsule, CellMatrix, etc.) Used to look up component values (see the section on scopes, coming soon).

Self
_cap_: Reference from the scope of a simulator to that simulator.

Control Primops

ALERT(h, [b], [t]): Displays string h in a dialog box as the header of message.; If optional string b is provided, it is the body of the message.; If optional string t is provided, it is the title of the message.

COUNT(fn, l): fn is a boolean function of one argument and a l is list.; Returns: COUNT(f, l) applies f to each element of l and returns the number of times the result is true.

DELAY(comp, x, [y]): Returns: the value of component comp delayed by x time units. Comp is a string naming a stateful component (i.e., stock, variable or sequence).; Optional y is returned if the current time is less than x. If y is omitted then 0 is returned.

PULSE(amount, start, interval): Returns: amount when current time is start, start + interval, start + 2*interval, etc.; 0 otherwise

DELAYN(comp scale shape init): Returns: the n-th order exponentially smooth delay for component comp. comp should be a string naming a Stock, Sequence or Term.

STEP(x, y): Returns: the value of x if the current time is y or greater; 0 otherwise.

TERMINATE(): Terminates the running simulation.

TOTAL(fn, l): fn is a numerical function of one argument and a l is list.; Returns: TOTAL(fn, l) applies fn to each element of l and returns the sum of the results.

RESETTING(): Returns: true when the system is currently resetting.

Convenience Primops

These primops perform useful functions that could otherwise be programmed.

FLIP(p): Simulates a Bernoulli trial.; Returns: true with probability p and false with probability 1-p.

BOUNCER(angle, x, y, cols, rows): Returns: the expected angle in one step of a projectile moving on a surface bounded by [x, cols] and [y, rows], deflecting off of the edge according to the standard laws of physics.

NORMALIZE(theta)
NORMALIZE02PI(theta): Returns: angle theta normalized on the interval [-π, π ] and [0, 2π ], respectively.

Input/Output Primops

BASEDIR(): Returns: the current model directory.

In each of the following path designates a textfile. if path begins with “/” it is treated as an absolute pathname; otherwise it is treated as relative to the current model directory.

OPENREAD(path): Opens path for reading and returns a Java BufferedReader object. The latter contains methods read and readLine to perform input. See http://docs.oracle.com/javase/7/docs/api/java/io/BufferedReader.html for complete details.

OPENWRITE(path): Opens path for writing and returns a Java PrintWriter object. The latter contains methods print and println to perform output. See http://docs.oracle.com/javase/7/docs/api/java/io/PrintWriter.html for complete details.

READDATA(path): Returns: the content of the file path as a string.

PRINT(x0, x1, ...): Returns: nothing; outputs the values of its arguments to the console, separated by spaces.

Mathematical Properties

PI
PI2
PIO2: Constants π, 2π and π/2, respectively

MPI
MPI2
MPIO2: Constants -π, -2π and -π/2, respectively

LN10
LN2
LOG10E
LOG2E: Constants ln(10), ln(2), log₁₀(e) and log₂(e)

SQRT1_2
SQRT2: Constants 1/√2 and √2, respectively.

Mathematical Primops

Math.XXX: The JavaScript Math functions and constants; see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math.

DERIVN(fn, n): Returns: the value of the nth derivative of fn at the current time, with precision based on the value of dt. fn should be a string naming a State (Stock or Sequence) or Term.

DISTANCE(x0, y0, x1, y1): Returns: Euclidean distance between points (x0, y0) and (x1, y1).

RANDOM(): Returns: a uniformly distributed random number between 0 and 1.

SEED(x): Returns: nothing; sets the seed of the random number generator. Should be part of simulation initialization.

RANDOM_HEADING(): Returns: a uniformly distributed random number between -π and π.

BINOMIAL(n, p): n is an integer; 0 ≤ p ≤ 1; Returns: a random number from the binomial distribution with n trials and success probability p.

MULTIBINOMIAL(n, p, k): Returns: Sum of k independent executions of BINOMIAL(n, p).

MULTINOMIAL(n, [p0, p1, ... pm]): Returns: an m-element vector of outcomes from performing n independent generalized Bernoulli trials.

SELECT([s0,...,sm], [p0, .... pm]): A single generalized Bernoulli trial over the states s0, ... sm with respective probabilities p0, ... pm.; Returns: One of the values si with probability pi. Note: if the probabilities do not sum to 1, pm is increased accordingly

NORMAL(x, y): Returns: a random number from the normal distribution with mean x and standard deviation y.

POISSON(lambda): Returns: a random number from the Poisson distribution with density lambda.

UNIFORM(x, y): Returns: a uniformly distributed random variable between x and y.

SIN(x): Returns: the trigonometric sin of x.

SINWAVE(x, y): Returns: x*sin(2πt/y), where t is the current time.

COS(x): Returns: the trigonometric cosine of x.

COSWAVE(x): Returns: x*cos(2πt/y), where t is the current time.

TAN(x): Returns: the trigonometric tangent of x.

ACOS(x): Returns the trigonometric arccosine of x.

ASIN(x): Returns the trigonometric arcsine of x.

ATAN(x): Returns: the trigonometric arctangent of x.

ATAN2(y, x): Returns: the trigonometric tangent of y/x.

MIN(x, y, z ...)
MAX(x, y, z, ...): Returns:, respectively, the lowest or highest value in a list of arguments:

CEIL(x)
FLOOR(x)
ROUND(x);: Returns:, respectively, x rounded up, x rounded down, and x rounded to the nearest integer.

SQRT(x): Returns: √x

ABS(x): Returns: |x|

POW(x, y): Returns: x^y

EXP(x): Returns: e^x

LOG(x): Returns: ln(x)

LOG2(x): Returns: log₂(x)

LOG10(x): Returns: log₁₀(x)

ARRAYSUM(a): Returns: the sum of the elements in array a.

ARRAYOF(n, x): Returns: an array of length n filled with x.

WRAPXM(v, m): Returns: v mod m normalized to [0, m].

FIXAT(n, d): Returns: Number n with at most d decimal places.

FACT(n): Returns: The factorial of n, using Stirling's formula for n > 20.

GRAPHFUN([[x0, y0], [x1, y1], ...])
GRAPHFUN([x0, y0], [x1, y1], ...): Returns: A function based on the graph defined by the ordered pairs in the argument, interpolated linearly. Acceptable input can be single argument consisting of an array of ordered pairs, or multiple arguments, each an ordered pair. The list need not be in increasing order of x. The returned function maps any value smaller (greater) than the smallest (largest) domain value x_k to x_k 's value in the range.

Matrix Primops

COLUMNSPLIT(tab): tab is a 2-dimensional array derived from a table, where the first row contains column headers.; Returns: an object in which each property name is a column header with property value an array comprising the corresponding column.

CSVTOMAT(csv): csv is a string where line is a comma separated sequence of values.; Returns: the matrix in which each row corresponds to a line in csv.

ROWSTOOBJS(tab): tab is a 2-dimensional array derived from a table, where the first row contains column headers.; Returns: an array of objects, one for each non-header row. In each object properties are column headers bound to the entry for that column in the corresponding row.

TRANSPOSE(mat): mat is a matrix (i.e. 2-dimensional array); Returns: the transpose of mat.

Simulation Primops

CLOCK(): Returns the current clock as an object.

DT(): Returns: current delta value (dt).

SIMSTART()
SIMEND()
SIMMETHOD(): Returns: simulation start time, end time and integration method, respectively.

TIME(): Returns: current simulation time.

TICK(): Returns: the number of simulation steps since the start of the simulation.

SET_DT(dt): Returns: nothing; sets the current DT value to dt.

DIMENSION(state): Return: the dimension of the State component state. state should be a string naming a State component (Stock or Sequence).

TRAIL(state): Returns: an array containing all values recorded for component state. state should be a string naming a State component (Stock or Sequence). Note: complete component history requires that the full history checkbox be selected for the component.

Miscellaneous Primops

_.XXX: The underscore.js library of useful functions. See http://underscorejs.org.

ASVALUE(v): Required when supplying an array or function value to the input pin of an aggregator. Arrays supplied as input to aggregators are usually interpreted so that each array element is used as input for one of the elements of the aggregator. Similarly, functions are invoked on the id of each element to compute the input value for that element. An array or function wrapped with ASVALUE is sent intact to each element of the aggregator.

DEPENDSON(comp): Returns: 0. This is used during model construction to assert dependencies.

DISTRIBUTE(a): Returns: if a is an array of at most 3 dimensions, DISTRIBUTE returns a function f which takes as many arguments as the dimension of a and returns the selected value. Otherwise f is a function of no arguments that return a.

LOOKUP_AREA(term, lo, hi): Returns: the integral of component term on the interval [lo, hi]. term is a string naming a Term.

Cell Properties and Primops

The following may only be used by capsules contained in a CellMatrix, or cell capsule in a SimWorld. row and col are integers representing row-column coordinates within the CellMatrix. coords is a Coords object All primops expecting coordinate pairs as parameters can either be called with separate row-column arguments or with a Coords object.

Cartesian coordinates will generally be automatically wrapped; i.e. if the coordinate space has dimension rows x cols, then a negative value for row or col is treated respectively as rows + row and cols + col. Values that exceed the dimensions respectively become row – rows and col – cols. This type of space is topologically equivalent to a torus.

Properties

coords: Object whose row and col properties respectively reference the caller’s row and column coordinates within the CellMatrix.

rows
cols: Bound to the total number of rows and columns, respectively.

matrix: Bound to the 2 dimensional array of cells in a CellMatrix

Primops

BLOCK(n, [wrap]): Returns: a list (array) of coordinate objects (i.e., containing row and col properties) comprising the square block of cells n units away from the caller or less. (if wrap is true, BLOCK treats the surface as a torus).

CELL(row, col)
CELL(coords): Returns the scope for the cell at the given coordinates, which may be passed either as separate parameters or in a coords object. The fields of the scope bind each of the Stocks, Terms and Flows in the cell to the current value of the corresponding component.

CELLS(): Returns the entire matrix (i.e., 2-dimensional array) of scopes for the CellMatrix.

  CELLS()[row][col] == CELL(row, col).

CELL_VALUE(row, col, comp)
CELL_VALUE(coords, comp): comp is a String naming a Stock, Flow or Term in the cell capsule.; Returns: the current value of that component in the cell with the given coordinates.

  CELL VALUE(row, col, comp) == CELL(row, col)[comp]

RING(n, [wrap]): Returns: a list (array) of coordinate objects (i.e., containing row and col properties) for all cells comprising the square exactly n units away from the caller. (if wrap is true, RING treats the surface as a torus).

WRAP(row, col)
WRAP(coords): Performs a “wraparound” of the coordinates if they exceed the size of the matrix (or are negative). Returns an array containing the new row and column.

Hexagonal Primops

The following should only be used if the CellMatrix is in hexagonal mode.

HEXRING(n, [wrap]): Returns: a list (array) of coordinate objects (i.e., containing row and col properties) for all cells comprising the hexagon exactly n units away from the caller. (If wrap is true, HEXRING treats the surface as a torus.)

HEXBLOCK(n, [wrap]): Returns: a list (array) of coordinate objects (i.e., containing row and col properties) comprising the hexagonal block of cells n units away from the caller or less. (If wrap is true, HEXBLOCK treats the surface as a torus.)

Convenience Primops

These primops perform useful functions that could otherwise be programmed.

COUNT_CELLS(l, comp, value): l is a list of cell scopes objects, comp is a string naming a component in those cells (stock, term, flow, etc.), and value is any JavaScript data element.; Returns: Returns the number of objects in l for which the current value of comp is value.

ALL_CELLS(l, comp, value)
NO_CELL(l, comp, value)
SOME_CELL(l, comp, value): l is a list of cell scopes, comp is a string naming a component in those cells (stock, term, flow, etc.), and value is any JavaScript data element.; Returns: Respectively returns true if for all, none or some scopes in l the current value of comp is value; false otherwise.

Agent Properties and Primops

The following may only be used by capsules contained in an AgentVector. id is an integer representing agent id of an agent. The term “caller” is used to identify the agent in which the primop is being executed, or the property value is being looked up. loc is a location object with properties x and y.

Properties

birth: The point in model time at which the caller was created.

myId: The unique agent ID that has been assigned to the caller.

rows
cols
planes: Bound to the total number of rows and columns in the space occupied by this AgentVector. Planes returns 0

unless space is 3d.

vector: Bound to the object mapping agent ids to agents in an AgentVector

Primops

ADATA(s): Returns: if s = "AGENTIDS", then ADATA returns the current list of agents; if s == "AGENTCOUNT", then ADATA returns the current agent count. Used to extract data from AgentVectors.

AGE(id)
MYAGE(): Returns: the age (i.e., time since birth) of agent id, or of the caller, respectively.

AGENT(id): Returns: the scope of the agent identified by id, if it exists.

AGENTS(): Returns: the list of live agent scopes.

AGENTS_AT(row, col)
AGENTS_AT(coords): Returns: a list of agents contained in the cell at specified coordinates.

AGENT_COUNT(): Returns: the total number of agents.

AGENT_IDS(): Returns: the array of ids for currently living agents.

AGENT_VALUE(id, comp): comp is a String naming a Stock, Flow or Term in the agent capsule.; Returns: the current value of that component in agent id.

   AGENT VALUE(id, comp) == AGENT(id)[comp]

CELL_COORDS(id): Returns: a coords object containing the row/col coordinates of the current position of the agent identified by id. If id is omitted, returns the row/col coordinates of the caller.

CREATE([init], [n]): Schedules the creation of a n new agents (n is assumed to be 1 if omitted). init is an initializer object containing bindings for properties in the new agent. These may include init_x, init_ y and init_heading, to indicate the new agent’s initial position and direction. It may also include alternate initialization expressions for Stocks, Local Variables and Properties. If init is omitted, the new agent is a clone of the caller. All new agents are created at the end of the cycle.

KILL(id): Schedules the elimination of agent id. All agent eliminations are carried out at the end of the cycle.

LOCATION(id): Returns: the cartesian location of the agent identified by id in an object with properties x and y (and z if the space is 3-dimensional), and the current heading of the agent with property theta. If id is omitted, returns these data for the caller.

LWRAP(x, y)
LWRAP(loc): Performs a “wraparound” of the location if either coordinate exceeds the size of the agent coordinate space (or is negative).; Returns: an array containing the new x and y;

AGENTBLOCK(n, [sort]): Returns: a list of the scopes of all agents within a block of n units from the caller. If sort is true the list is sorted based on distance from the caller.

HEXAGENTBLOCK(n, [sort]): Returns: a list of the scopes of all agents within a block of n units from the caller on a hexagonal surface. If sort is true the list is sorted based on distance from the caller.

NEIGHBORS(n): Returns: a sorted list (based on distance from the caller) of the scopes of all other agents within n units of the caller.

HEXNEIGHBORS(n): Returns: a list of the scopes of all agents within n units of the caller on a hexagonal surface.

NEAREST_NEIGHBOR(n): Returns: the scope of the nearest neighbor within n units of the caller.

MOVE(x, y, [z])
MOVETO(x, y, [z]): Sets the location of the caller to (x, y), or (x, y, z) in 3 dimensions. All moves occur at the end of the cycle.

MOVEPLUS(x, y, [z]): Sets the location of the caller to its current location plus (x, y), or (x, y, z) in 3 dimensions.

HEADTO(theta, [phi])
SET_HEADING(theta, [phi]): Sets the directional heading(s) of the caller to theta (and phi in 3 dimensions). Angles are given in radians.

HEADPLUS(theta, [phi]): Sets the directional heading(s) of the caller to its current direction(s) plus theta (and phi in 3 dimensions). Angles are given in radians.

GO(speed, theta, [,phi]): Move the location of the caller to its new location based the given speed using directional angle(s) theta (and phi in 3 dimensions). Angles are given in radians.

GO_BOUNCE(speed, theta): Equivalent to GO(speed, theta) except that the agent bounces off the edge of the space like a billiard ball. Currently only available in 2 dimensions.

HEXMOVE(speed, theta): Move the location of the caller to its new location based on the given speed and direction theta. Theta is one of N,NE,SE,S,SW,NW.

Convenience Primops

These primops perform useful functions that could otherwise be programmed.

COUNT_AGENTS(l, comp, value): l is a list of agent scopes, comp is a string naming a component in those agents (stock, term, flow, etc.), and value is any JavaScript data element.; Returns: Returns the number of objects in l for which the current value of comp is value.

ALL_AGENTS(l, comp, value)
NO_AGENT(l, comp, value)
SOME_AGENT(l, comp, value): l is a list of agent scopes, comp is a string naming a component in those agents, and value is any JavaScript data element.; Returns: Respectively returns true if for all, none or some scope in l the current value of comp is value; false otherwise.

ALL_NEIGHBORS(d, comp, value)
NO_NEIGHBOR(d, comp, value)
SOME_NEIGHBOR(d, comp, value): Analogous to ALL_AGENTS, etc. except the agents of interest are those within a radius of d units from the agent making the call. Forms that list of agents and returns true if for all, none, or some agent scope in that list the current value of comp is value; false otherwise.

RANDOM_MOVE(loc, [wrap]): Returns: a location object (i.e., with fields x and y) representing a random move (wrapping if wrap is true) of one unit from the location object loc. If loc is omitted it defaults to the location of the caller.

HEX_RANDOM_MOVE(loc, [wrap]): Returns: a location object (i.e., with fields x and y) representing a random move (wrapping if wrap is true) of one unit from the location object loc on a hexagonal surface. If loc is omitted it defaults to the location of the caller.

INBOUNDS(x, y): Returns: true if 0 ≤ x < columns and 0 ≤ y < rows, where [columns, rows] is the dimension of the agent landscape.

SimWorld Properties

cellmatrix: Bound to the CellMatrix component in a SimWorld

agentvector: Bound to the AgentVector component in a SimWorld

SimWorld Primops

Cell and agent capsules in a SimWorld may respectively use the Cell and Agent properties and primops described above. Also in a SimWorld, cell capsules may call some agent primops and agent capsules may call some cell primops, as detailed below.

Cell Primops in a SimWorld

Cell capsules may call the following agent primops:

AGENT
AGENTS AT
AGENT_COUNT
AGENT_IDS
AGENT_VALUE
AGENTS
CREATE
KILL

Cell capsules in a SimWorld may call the following new primops:

MYAGENTS(): Returns: the list of agents currently contained in the caller.

MYAGENT_COUNT(): Returns: the number of agents currently contained in the caller.

Agent Primops in a SimWorld

Agent capsules may call the following cell primops:

CELL
CELLS
CELL_VALUE

Agent capsules in a SimWorld may call the following new primop:

MYCELL(): Returns: the scope of the cell containing the caller.

Hexagonal Agent Primop

The following should only be used by an agent if the cell component of the SimWorld is in hexagonal mode.

HEXMOVE(dist, dir): Moves the calling agent distance dist in the direction dir. Directions are denoted by compass directions; i.e., “N”, “NE”, “SE”, “S”, “SW”, “NW”.

Convenience Primops

These primops perform useful functions that could otherwise be programmed.

AGENTBLOCK(n, ["sort"])
AGENTWBLOCK(n, ["sort"])
AGENTRING(n, ["sort"])
AGENTWRING(n, ["sort"]): Returns: a list of scopes for all agents in the ring or block (wrapped or otherwise) specified by n. If “sort” is included, the list is sorted in order of increasing distance from the caller.

Node Properties and Primops

The following may only be used by capsules contained in a NodeNetwork. id is an integer representing node id of a node.

Properties

myId: Bound to the caller’s node id.

count: Bound to the number of nodes in the NodeNetwork.

nodes: Bound to the 1-dimensional array of Nodes in a NodeNetwork.

Primops

CONNECTION(id0, id1): Returns: the connection from Node with id id0 to Node with id id1, or null if no such connection exists.

CONNECTIONS_IN([id]): Returns: the array of connections into the node id (if id is omitted, it is assumed to be the caller). Each connection is an object with 3 properties: id, the node id of the source; strength, the raw strength of the connection; and n_strength, the normalized strength of the connection, where the total normalized strength of all connections into the caller is 1.

CONNECTIONS_OUT([id]): Returns: the array of connections from the node id (if id is omitted, it is assumed to be the caller). Each connection is an object with 3 properties: id, the node id of the target; strength, the raw strength of the connection; and n_strength, the normalized strength of the connection, where the total normalized strength of all connections from the caller is 1.

NODE(id): Returns: a scope for node id.

NODECOUNT(): Returns: the total number of nodes.

NODE_VALUE(id, comp): comp is a String naming a Stock, Flow or Term in the node capsule.; Returns: the current value of that component in node id.

 NODE_VALUE(id, comp) == NODE(id)[comp]

NODES(): Returns: the array of node scopes.

INFLOW([id]): Returns: the total strength of connections into node id (if id is omitted, it is assumed to be the caller).

OUTFLOW([id]): Returns: the total strength of connections from node id (if id is omitted, it is assumed to be the caller).

NEIGHBORS_IN([id])
NEIGHBORS_OUT([id]): Returns: a list of all scopes of Nodes with input (output) connections to the Node with given id. If id is omitted, the caller's id is used.

NetWorld Primops

Cell and agent capsules in a NetWorld may respectively use the Node and Agent properties and primops described above. Also in a NetWorld, node capsules may call some agent primops and agent capsules may call some node primops, as detailed below.

Node Primops in a NodeWorld

Node capsules may call the following agent primops:

AGENT
AGENTS AT
AGENT_COUNT
AGENT_IDS
AGENT_VALUE
AGENTS
CREATE
KILL

Node capsules in a NetWorld may call the following new primops:

MYAGENTS(): Returns: the list of agents currently contained in the caller.

MYAGENT_COUNT(): Returns: the number of agents currently contained in the caller.

Agent Primops in a NetWorld

Agent capsules may call the following node primops:

NODE
NODES
NODE_VALUE

Agent capsules in a NetWorld may call the following new primops:

MYNODE(): Returns: the scope of the node containing the caller.

NETMOVE(nodeId): Changes current location of caller to node indicated by nodeId. All moves occur at the end of the cycle.

NODE_NEIGHBORS(agentId): Returns: a list of scopes corresponding to the the nodes to which the node currently occupied by agent agentId has outward links. If agentId is omitted, it is assumed to be the caller.

Difference between revisions of "Primitive Operators and Properties"

Latest revision as of 18:57, 17 November 2018

Contents

Universal Properties and Primops

Properties

Control Primops

Convenience Primops

Input/Output Primops

Mathematical Properties

Mathematical Primops

Matrix Primops

Simulation Primops

Miscellaneous Primops

Cell Properties and Primops

Properties

Primops

Hexagonal Primops

Convenience Primops

Agent Properties and Primops

Properties

Primops

Convenience Primops

SimWorld Properties

SimWorld Primops

Cell Primops in a SimWorld

Agent Primops in a SimWorld

Hexagonal Agent Primop

Convenience Primops

Node Properties and Primops

Properties

Primops

NetWorld Primops

Node Primops in a NodeWorld

Agent Primops in a NetWorld

Navigation menu

Search

@@ Line 18: / Line 18: @@
 ;scope
 :The scope of a simulator (Capsule, CellMatrix, etc.) Used to look up component values (see the section on scopes, coming soon).
+</div></div>
 <div id="Self">
 <div id="_cap_">
@@ Line 23: / Line 24: @@
 ;_cap_
 :Reference from the scope of a simulator to that simulator.
+</div></div>
 ===Control Primops===
 <div id="control">
@@ Line 31: / Line 32: @@
 :If optional string b is provided, it is the body of the message.
 :If optional string t is provided, it is the title of the message.
+</div>
 <div id="COUNT">
 ;COUNT(fn, l)
 :''fn'' is a boolean function of one argument and a ''l'' is list.
 :'''Returns''': '''COUNT(f, l)''' applies ''f'' to each element of ''l'' and returns the number of times the result is ''true''.
+</div>
 <div id="DELAY">
 ;DELAY(comp, x, [y])
 :'''Returns''': the value of component comp delayed by ''x'' time units. Comp is a string naming a stateful component (i.e., stock, variable or sequence).
 :Optional ''y'' is returned if the current time is less than ''x''. If ''y'' is omitted then 0 is returned.
+</div>
 <div id="PULSE">
 ;PULSE(amount, start, interval)
 :'''Returns''': amount when current time is ''start'', ''start + interval'', ''start + 2*interval'', etc.; 0 otherwise
+</div>
 <div id="DELAYN">
 ;DELAYN(comp scale shape init)
 :'''Returns''': the n-th order exponentially smooth delay for component ''comp''. ''comp'' should be a string naming a Stock, Sequence or Term.
+</div>
 <div id="STEP">
 ;STEP(x, y)
 :'''Returns''': the value of ''x'' if the current time is ''y'' or greater; 0 otherwise.
+</div>
 <div id="TERMINATE">
 ;TERMINATE()
 :Terminates the running simulation.
+</div>
 <div id="TOTAL">
 ;TOTAL(fn, l)
 :''fn'' is a numerical function of one argument and a ''l'' is list.
 :'''Returns''': '''TOTAL(fn, l)''' applies ''fn'' to each element of ''l'' and returns the sum of the results.
+</div>
+<div id="RESETTING">
+;RESETTING()
+:'''Returns''': true when the system is currently resetting.
+</div>
+</div>
 ===Convenience Primops===
 <div id="convenience">
@@ Line 63: / Line 76: @@
 :Simulates a Bernoulli trial.
 :'''Returns''': ''true'' with probability ''p'' and ''false'' with probability ''1-p''.
+</div>
 <div id="BOUNCER">
 ;BOUNCER(angle, x, y, cols, rows)
 :'''Returns''': the expected angle in one step of a projectile moving on a surface bounded by [''x'', ''cols''] and [''y'', ''rows''], deflecting off of the edge according to the standard laws of physics.
+</div>
+<div id="NORMALIZE">
+<div id="NORMALIZE02PI">
+;NORMALIZE(theta)
+;NORMALIZE02PI(theta)
+:'''Returns''': angle ''theta'' normalized on the interval [''-π'', ''π'' ] and [''0'', ''2π'' ], respectively.
+</div></div></div>
 ===Input/Output Primops===
 <div id="io">
@@ Line 72: / Line 92: @@
 ;BASEDIR()
 :'''Returns''': the current model directory.
+</div>
 <!--
 <div id="LOAD">
 ;LOAD(l)
 :''l'' is a list of JavaScript or NovaScript filenames contained in the current model directory. Each is loaded into the runtime system. Should be part of simulation initialization.
+</div>
 -->
 In each of the following ''path'' designates a textfile. if ''path'' begins with “/” it is treated as an absolute pathname; otherwise it is treated as relative to the current model directory.
@@ Line 81: / Line 103: @@
 ;OPENREAD(path)
 :Opens ''path'' for reading and returns a Java <code>BufferedReader</code> object. The latter contains methods read and readLine to perform input. See http://docs.oracle.com/javase/7/docs/api/java/io/BufferedReader.html for complete details.
+</div>
 <div id="OPENWRITE">
 ;OPENWRITE(path)
 :Opens path for writing and returns a Java <code>PrintWriter</code> object. The latter contains methods <tt>print</tt> and <tt>println</tt> to perform output. See http://docs.oracle.com/javase/7/docs/api/java/io/PrintWriter.html for complete details.
+</div>
 <div id="READDATA">
 ;READDATA(path)
 :'''Returns''': the content of the file path as a string.
+</div>
+<div id="PRINT">
+;PRINT(x0, x1, ...)
+:'''Returns''': nothing; outputs the values of its arguments to the console, separated by spaces.
+</div>
 <div id="math">
+<div id="Math">
 ===Mathematical Properties===
-<div id="E">
-;E
-:Euler's constant ''e''.
 <div id="PI">
 <div id="PI2">
@@ Line 101: / Line 126: @@
 ;PIO2
 :Constants <code>π</code>, <code>2π</code> and <code>π/2</code>, respectively
+</div></div></div>
 <div id="MPI">
 <div id="MPI2">
@@ Line 117: / Line 143: @@
 ;LOG2E
 :Constants <code>ln(10)</code>, <code>ln(2)</code>, <code>log<sub>10</sub>(e)</code> and <code>log<sub>2</sub>(e)</code>
+</div></div></div></div>
 <div id="SQRT1_2">
 <div id="SQRT2">
@@ Line 122: / Line 149: @@
 ;SQRT2
 :Constants <code>1/√<span style="text-decoration:overline;">2</span></code> and <code>√<span style="text-decoration:overline;">2</span></code>, respectively.
+</div></div>
 ===Mathematical Primops===
 <div id="MathXXX">
 ;Math.XXX
 :The JavaScript Math functions and constants; see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math.
+</div>
 <div id="DERIVN">
 ;DERIVN(fn, n)
 :'''Returns''': the value of the ''nth'' derivative of ''fn'' at the current time, with precision based on the value of ''dt''. ''fn'' should be a string naming a State (Stock or Sequence) or Term.
+</div>
 <div id="DISTANCE">
 ;DISTANCE(x0, y0, x1, y1)
 :'''Returns''': Euclidean distance between points (''x0, y0'') and (''x1, y1'').
+</div>
 <div id="RANDOM">
 ;RANDOM()
 :'''Returns''': a uniformly distributed random number between 0 and 1.
+</div>
 <div id="SEED">
 ;SEED(x)
 :'''Returns''': nothing; sets the seed of the random number generator. Should be part of simulation initialization.
+</div>
+<div id="RANDOM_HEADING">
+;RANDOM_HEADING()
+:'''Returns''': a uniformly distributed random number between ''-&pi;'' and ''&pi;''.
 <div id="BINOMIAL">
 ;BINOMIAL(n, p)
 :''n'' is an integer; ''0 ≤ p ≤ 1''
 :'''Returns''': a random number from the binomial distribution with ''n'' trials and success probability ''p''.
+</div>
 <div id="MULTIBINOMIAL">
 ;MULTIBINOMIAL(n, p, k)
 :'''Returns''': Sum of ''k'' independent executions of BINOMIAL(''n'', ''p'').
+</div>
 <div id="MULTINOMIAL">
 ;MULTINOMIAL(n, [p0, p1, ... pm])
-:'''Returns''': an ''m''-element vector of outcomes from performing ''n'' independent generalized Bernoulli trials. ''As of Version 13.5.''
+:'''Returns''': an ''m''-element vector of outcomes from performing ''n'' independent generalized Bernoulli trials.
+</div>
+<div id="SELECT">
+;SELECT([s0,...,sm], [p0, .... pm])
+:A single generalized Bernoulli trial over the states ''s0, ... sm'' with respective probabilities ''p0, ... pm''.
+:'''Returns''': One of the values ''si'' with probability ''pi''. Note:  if the probabilities do not sum to 1, ''pm'' is increased accordingly
+</div>
 <div id="NORMAL">
 ;NORMAL(x, y)
 :'''Returns''': a random number from the normal distribution with mean x and standard deviation y.
+</div>
 <div id="POISSON">
 ;POISSON(lambda)
 :'''Returns''': a random number from the Poisson distribution with density lambda.
+</div>
 <div id="UNIFORM">
 ;UNIFORM(x, y)
 :'''Returns''': a uniformly distributed random variable between ''x'' and ''y''.
+</div>
 <div id="SIN">
 ;SIN(x)
 :'''Returns''': the trigonometric sin of ''x''.
+</div>
 <div id="SINWAVE">
 ;SINWAVE(x, y)
 :'''Returns''': <code>x*sin(2πt/y)</code>, where ''t'' is the current time.
+</div>
 <div id="COS">
 ;COS(x)
 :'''Returns''': the trigonometric cosine of ''x''.
+</div>
 <div id="COSWAVE">
 ;COSWAVE(x)
 :'''Returns''': <code>x*cos(2πt/y)</code>, where ''t'' is the current time.
+</div>
 <div id="TAN">
 ;TAN(x)
 :'''Returns''': the trigonometric tangent of ''x''.
+</div>
 <div id="ACOS">
 ;ACOS(x)
 :'''Returns''' the trigonometric arccosine of ''x''.
+</div>
 <div id="ASIN">
 ;ASIN(x)
 :'''Returns''' the trigonometric arcsine of ''x''.
+</div>
 <div id="ATAN">
 ;ATAN(x)
 :'''Returns''': the trigonometric arctangent of ''x''.
+</div>
 <div id="ATAN2">
 ;ATAN2(y, x)
 :'''Returns''': the trigonometric tangent of <code>y/x</code>.
+</div>
 <div id="MIN">
 <div id="MAX">
@@ Line 190: / Line 245: @@
 ;MAX(x, y, z, ...)
 :'''Returns''':, respectively, the lowest or highest value in a list of arguments:
+</div>
+</div>
 <div id="CEIL">
 <div id="FLOOR">
@@ Line 197: / Line 254: @@
 ;ROUND(x);
 :'''Returns''':, respectively, ''x'' rounded up, ''x'' rounded down, and ''x'' rounded to the nearest integer.
+</div>
+</div>
+</div>
 <div id="SQRT">
 ;SQRT(x)
 :'''Returns''': <code>&radic;<span style="text-decoration:overline;">x</span></code>
+</div>
 <div id="ABS">
 ;ABS(x)
 :'''Returns''': <code>|x|</code>
+</div>
 <div id="POW">
 ;POW(x, y)
 :'''Returns''': <code>x<sup>y</sup></code>
+</div>
 <div id="EXP">
 ;EXP(x)
 :'''Returns''': <code>e<sup>x</sup></code>
+</div>
 <div id="LOG">
 ;LOG(x)
 :'''Returns''': <code>ln(x)</code>
+</div>
 <div id="LOG2">
 ;LOG2(x)
 :'''Returns''': <code>log<sub>2</sub>(x)</code>
+</div>
 <div id="LOG10">
 ;LOG10(x)
 :'''Returns''': <code>log<sub>10</sub>(x)</code>
+</div>
 <div id="ARRAYSUM">
 ;ARRAYSUM(a)
 :'''Returns''': the sum of the elements in array ''a''.
+</div>
 <div id="ARRAYOF">
 ;ARRAYOF(n, x)
 :'''Returns''': an array of length ''n'' filled with ''x''.
+</div>
+<div id="WRAPXM">
+;WRAPXM(v, m)
+:'''Returns''': <code>''v'' mod ''m''</code> normalized to [''0'', ''m''].
+</div>
 <div id="FIXAT">
 ;FIXAT(n, d)
 :'''Returns''': Number ''n'' with at most ''d'' decimal places.
+</div>
 <div id="FACT">
 ;FACT(n)
 :'''Returns''': The factorial of ''n'', using Stirling's formula for ''n > 20''.
+</div>
 <div id="GRAPHFUN">
 ;GRAPHFUN([[x0, y0], [x1, y1], ...])
 ;GRAPHFUN([x0, y0], [x1, y1], ...)
 :'''Returns''': A function based on the graph defined by the ordered pairs in the argument, interpolated linearly. Acceptable input can be single argument consisting of an array of ordered pairs, or multiple arguments, each an ordered pair. The list need not be in increasing order of ''x''. The returned function maps any value smaller (greater) than the smallest (largest) domain value ''x<sub>k</sub>'' to ''x<sub>k</sub>'' 's value in the range.
+</div>
 ===Matrix Primops===
-<div id="matrix">
 <div id="COLUMNSPLIT">
 ;COLUMNSPLIT(tab)
 :''tab'' is a 2-dimensional array derived from a table, where the first row contains column headers.
 :'''Returns''': an object in which each property name is a column header with property value an array comprising the corresponding column.
+</div>
 <div id="CSVTOMAT">
 ;CSVTOMAT(csv)
 :''csv'' is a string where line is a comma separated sequence of values.
 :'''Returns''': the matrix in which each row corresponds to a line in ''csv''.
+</div>
 <div id="ROWSTOOBJS">
 ;ROWSTOOBJS(tab)
 :''tab'' is a 2-dimensional array derived from a table, where the first row contains column headers.
 :'''Returns''': an array of objects, one for each non-header row. In each object properties are column headers bound to the entry for that column in the corresponding row.
+</div>
 <div id="TRANSPOSE">
 ;TRANSPOSE(mat)
 :''mat'' is a matrix (i.e. 2-dimensional array)
 :'''Returns''': the transpose of ''mat''.
+</div>
 ===Simulation Primops===
@@ Line 272: / Line 351: @@
 ;TIME()
 :'''Returns''': current simulation time.
+<div id="TICK">
+;TICK()
+:'''Returns''': the number of simulation steps since the start of the simulation.
+<div id="SET_DT">
+;SET_DT(dt)
+:'''Returns''': nothing; sets the current DT value to ''dt''.
 <div id="DIMENSION">
 ;DIMENSION(state)
 :'''Return''': the dimension of the State component ''state''. ''state'' should be a string naming a State component (Stock or Sequence).
+<div id="TRAIL">
+;TRAIL(state)
+:'''Returns''': an array containing all values recorded for component ''state''. ''state'' should be a string naming a State component (Stock or Sequence). Note:  complete component history requires that the '''full history''' checkbox be selected for the component.
 ===Miscellaneous Primops===
@@ Line 281: / Line 369: @@
 ;_.XXX
 :The underscore.js library of useful functions. See http://underscorejs.org.
+</div>
+<div id="ASVALUE">
+;ASVALUE(v)
+:Required when supplying an array or function value to the input pin of an aggregator. Arrays supplied as input to aggregators are usually interpreted so that each array element is used as input for one of the elements of the aggregator. Similarly, functions are invoked on the id of each element to compute the input value for that element. An array or function wrapped with ASVALUE is sent intact to each element of the aggregator.
+</div>
 <div id="DEPENDSON">
 ;DEPENDSON(comp)
 :'''Returns''': 0. This is used during model construction to assert dependencies.
+</div>
 <div id="DISTRIBUTE">
 ;DISTRIBUTE(a)
 :'''Returns''': if ''a'' is an array of at most 3 dimensions, DISTRIBUTE returns a function ''f'' which takes as many arguments as the dimension of ''a'' and returns the selected value. Otherwise ''f'' is a function of no arguments that return ''a''.
+</div>
 <div id="LOOKUP_AREA">
 ;LOOKUP_AREA(term, lo, hi)
 :'''Returns''': the integral of component ''term'' on the interval [''lo'', ''hi'']. ''term'' is a string naming a Term.
+</div>
 <!--
 ==Clocked Chip Primops==
@@ Line 297: / Line 393: @@
 ;SUPERCLOCK()
 :'''Returns''': the clock associated with the container of the Clocked Chip.
+</div>
 <div id="SUPERTIME">
 ;SUPERTIME()
 :'''Returns''': the model time of the container of the Clocked Chip.
+</div>
+</div>
 -->
@@ Line 306: / Line 405: @@
 Cartesian coordinates will generally be automatically wrapped; i.e. if the coordinate space has dimension ''rows'' x ''cols'', then a negative value for ''row'' or ''col'' is treated respectively as ''rows + row'' and ''cols + col''. Values that exceed the dimensions respectively become ''row – rows'' and ''col – cols.'' This type of space is topologically equivalent to a torus.
-Neighborhood function '''BLOCK''' and '''RING''' come in two versions, one that includes wrapping ('''WBLOCK''' and '''WRING'''), and one that treats the edges as boundaries ('''BLOCK''' and '''RING''').
 ===Properties===
@@ Line 314: / Line 411: @@
 ;coords
 :Object whose row and col properties respectively reference the caller’s row and column coordinates within the CellMatrix.
+</div>
 <div id="rows">
 <div id="cols">
@@ Line 319: / Line 417: @@
 ;cols
 :Bound to the total number of rows and columns, respectively.
+</div>
+</div>
+<div id="matrix">
+;matrix
+:Bound to the 2 dimensional array of cells in a CellMatrix
+</div>
 ===Primops===
@@ Line 326: / Line 430: @@
 ;BLOCK(n, [wrap])
 :'''Returns''': a list (array) of coordinate objects (i.e., containing row and col properties) comprising the square block of cells ''n'' units away from the caller or less. (if ''wrap'' is true, BLOCK treats the surface as a torus).
+</div>
+</div>
+</div>
 <div id="CELL">
 ;CELL(row, col)
 ;CELL(coords)
 :'''Returns''' the scope for the cell at the given coordinates, which may be passed either as separate parameters or in a coords object. The fields of the scope bind each of the Stocks, Terms and Flows in the cell to the current value of the corresponding component.
+</div>
 <div id="CELLS">
 ;CELLS()
@@ Line 335: / Line 443: @@
     CELLS()[row][col] == CELL(row, col).
+</div>
 <div id="CELL_VALUE">
 ;CELL_VALUE(row, col, comp)
@@ Line 341: / Line 450: @@
 :'''Returns''': the current value of that component in the cell with the given coordinates.
     CELL VALUE(row, col, comp) == CELL(row, col)[comp]
+</div>
 <div id="RING">
 ;RING(n, [wrap])
 :'''Returns''': a list (array) of coordinate objects (i.e., containing row and col properties) for all cells comprising the square exactly ''n'' units away from the caller. (if ''wrap'' is true, RING treats the surface as a torus).
+</div>
 <div id="WRAP">
 ;WRAP(row, col)
 ;WRAP(coords)
 :Performs a “wraparound” of the coordinates if they exceed the size of the matrix (or are negative). Returns an array containing the new row and column.
+</div>
+</div>
 ===Hexagonal Primops===
@@ Line 355: / Line 468: @@
 ;HEXRING(n, [wrap])
 :'''Returns''': a list (array) of coordinate objects (i.e., containing ''row'' and ''col'' properties) for all cells comprising the hexagon exactly ''n'' units away from the caller. (If wrap is true, HEXRING treats the surface as a torus.)
+</div>
 <div id="HEXBLOCK">
 ;HEXBLOCK(n, [wrap])
 :'''Returns''': a list (array) of coordinate objects (i.e., containing ''row'' and ''col'' properties) comprising the hexagonal block of cells ''n'' units away from the caller or less. (If wrap is true, HEXBLOCK treats the surface as a torus.)
+</div>
 <div id="HEXPATH">
 <!--
@@ Line 363: / Line 478: @@
 :'''Returns''': a list of coordinates comprising the path of length ''dist'' in the direction indicated by ''dir''. Directions are denoted by compass directions; i.e., “N”, “NE”, “SE”, “S”, “SW”, “NW”.
 -->
+</div>
+</div>
 ===Convenience Primops===
 <div id="cell_conv">
@@ Line 371: / Line 487: @@
 :''l'' is a list of cell scopes objects, comp is a string naming a component in those cells (stock, term, flow, etc.), and value is any JavaScript data element.
 :'''Returns''':  Returns the number of objects in ''l'' for which the current value of comp is value.
+</div>
 <div id="ALL_CELLS">
-<div id="NO_CELLS">
+<div id="NO_CELL">
-<div id="SOME_CELLS">
+<div id="SOME_CELL">
 ;ALL_CELLS(l, comp, value)
 ;NO_CELL(l, comp, value)
@@ Line 379: / Line 496: @@
 :''l'' is a list of cell scopes, comp is a string naming a component in those cells (stock, term, flow, etc.), and value is any JavaScript data element.
 :'''Returns''':  Respectively returns ''true'' if for all, none or some scopes in ''l'' the current value of comp is value; ''false'' otherwise.
+</div>
+</div>
+</div>
+</div>
 ==Agent Properties and Primops==
@@ Line 389: / Line 510: @@
 ;birth
 :The point in model time at which the caller was created.
+</div>
 <div id="myId">
 ;myId
 :The unique agent ID that has been assigned to the caller.
+</div>
 <div id="rows">
 <div id="cols">
@@ Line 400: / Line 523: @@
 :Bound to the total number of rows and columns in the space occupied by this AgentVector. Planes returns 0
 unless space is 3d.
+</div>
+</div>
+</div>
+<div id="vector">
+;vector
+:Bound to the object mapping agent ids to agents in an AgentVector
+</div>
+</div>
 ===Primops===
@@ Line 406: / Line 537: @@
 ;ADATA(s)
 :'''Returns''': if ''s = "AGENTIDS"'', then ADATA returns the current list of agents; if ''s == "AGENTCOUNT"'', then ADATA returns the current agent count. Used to extract data from AgentVectors.
+</div></div>
 <div id="AGE">
 <div id="MYAGE">
@@ Line 411: / Line 543: @@
 ;MYAGE()
 :'''Returns''': the age (i.e., time since birth) of agent ''id'', or of the caller, respectively.
+</div>
+</div>
 <div id="AGENT">
 ;AGENT(id)
 :'''Returns''': the scope of the agent identified by ''id,'' if it exists.
+</div>
 <div id="AGENTS">
 ;AGENTS()
 :'''Returns''': the list of live agent scopes.
+</div>
 <div id="AGENTS_AT">
 ;AGENTS_AT(row, col)
 ;AGENTS_AT(coords)
 :'''Returns''': a list of agents contained in the cell at specified coordinates.
+</div>
 <div id="AGENT_COUNT">
 ;AGENT_COUNT()
 :'''Returns''': the total number of agents.
+</div>
 <div id="AGENT_IDS">
 ;AGENT_IDS()
 :'''Returns''': the array of ids for currently living agents.
+</div>
 <div id="AGENT_VALUE">
 ;AGENT_VALUE(id, comp)
@@ Line 433: / Line 572: @@
      AGENT VALUE(id, comp) == AGENT(id)[comp]
+</div>
 <div id="CELL_COORDS">
 ;CELL_COORDS(id)
 :'''Returns''': a coords object containing the ''row/col'' coordinates of the current position of the agent identified by ''id''.  If ''id'' is omitted, returns the ''row/col'' coordinates of the caller.
+</div>
 <div id="CREATE">
 ;CREATE([init], [n])
 :Schedules the creation of a ''n'' new agents (''n'' is assumed to be 1 if omitted). ''init'' is an initializer object containing bindings for properties in the new agent. These may include ''init_x,'' ''init_ y'' and ''init_heading'', to indicate the new agent’s initial position and direction. It may also include alternate initialization expressions for Stocks, Local Variables and Properties. If ''init'' is omitted, the new agent is a clone of the caller. All new agents are created at the end of the cycle.
+</div>
 <div id="KILL">
 ;KILL(id)
 :Schedules the elimination of agent ''id''. All agent eliminations are carried out at the end of the cycle.
+</div>
 <div id="LOCATION">
 ;LOCATION(id)
 :'''Returns''': the cartesian location of the agent identified by id in an object with properties x and y (and z if the space is 3-dimensional), and the current heading of the agent with property theta.  If id is omitted, returns these data for the caller.
+</div>
 <div id="LWRAP">
 ;LWRAP(x, y)
@@ Line 450: / Line 594: @@
 :Performs a “wraparound” of the location if either coordinate exceeds the size of the agent coordinate space (or is negative).
 :'''Returns''': an array containing the new ''x'' and ''y'';
+</div>
 <div id="AGENTBLOCK">
 ;AGENTBLOCK(n, [sort])
 :'''Returns''': a list of the scopes of all agents within a block of ''n'' units from the caller. If ''sort'' is true the list is sorted based on distance from the caller.
+</div>
 <div id="HEXAGENTBLOCK">
 ;HEXAGENTBLOCK(n, [sort])
 :'''Returns''': a list of the scopes of all agents within a block of ''n'' units from the caller on a hexagonal surface. If ''sort'' is true the list is sorted based on distance from the caller.
+</div>
 <div id="NEIGHBORS">
 ;NEIGHBORS(n)
 :'''Returns''': a sorted list (based on distance from the caller) of the scopes of all other agents within ''n'' units of the caller.
+</div>
 <div id="HEXNEIGHBORS">
 ;HEXNEIGHBORS(n)
 :'''Returns''': a list of the scopes of all agents within ''n'' units of the caller on a hexagonal surface.
+</div>
 <div id="NEAREST_NEIGHBOR">
 ;NEAREST_NEIGHBOR(n)
 :'''Returns''': the scope of the nearest neighbor within ''n'' units of the caller.
+</div>
 <div id="MOVE">
 <div id="MOVETO">
@@ Line 470: / Line 620: @@
 ;MOVETO(x, y, [z])
 :Sets the location of the caller to (''x, y''), or (''x, y, z'') in 3 dimensions. All moves occur at the end of the cycle.
+</div>
+</div>
 <div id="MOVEPLUS">
 ;MOVEPLUS(x, y, [z])
 :Sets the location of the caller to its current location plus (''x, y''), or (''x, y, z'') in 3 dimensions.
+</div>
 <div id="HEADTO">
+<div id="SET_HEADING">
 ;HEADTO(theta, [phi])
-:Sets the directional heading(s) of the caller to ''theta'' (and ''phi'' in 3 dimensions). Angles are given in radians.<div id="HEADPLUS">
+;SET_HEADING(theta, [phi])
+:Sets the directional heading(s) of the caller to ''theta'' (and ''phi'' in 3 dimensions). Angles are given in radians.
+</div>
+</div>
+<div id="HEADPLUS">
 ;HEADPLUS(theta, [phi])
 :Sets the directional heading(s) of the caller to its current direction(s) plus ''theta'' (and ''phi'' in 3 dimensions). Angles are given in radians.
+</div>
 <div id="GO">
 ;GO(speed, theta, [,phi])
 :Move the location of the caller to its new location based the given ''speed'' using directional angle(s) ''theta'' (and ''phi'' in 3 dimensions). Angles are given in radians.
-<div id="HEXMOVE">
+</div>
+<div id="GO_BOUNCE">
+;GO_BOUNCE(speed, theta)
+:Equivalent to <tt>GO(speed, theta)</tt> except that the agent bounces off the edge of the space like a billiard ball. Currently only available in 2 dimensions.
+</div><div id="HEXMOVE">
 ;HEXMOVE(speed, theta)
 :Move the location of the caller to its new location based on the given ''speed'' and direction ''theta''. ''Theta'' is one of ''N'',''NE'',''SE'',''S'',''SW'',''NW''.
+</div>
 ===Convenience Primops===
 <div id="agent_conv">
 These primops perform useful functions that could otherwise be programmed.
+</div>
 <div id="COUNT_AGENTS">
 ;COUNT_AGENTS(l, comp, value)
 :''l'' is a list of agent scopes, ''comp'' is a string naming a component in those agents (stock, term, flow, etc.), and ''value'' is any JavaScript data element.
 :'''Returns''':  Returns the number of objects in ''l'' for which the current value of ''comp'' is ''value''.
+</div>
 <div id="ALL_AGENTS">
-<div id="NO_AGENTS">
+<div id="NO_AGENT">
 <div id="SOME_AGENT">
 ;ALL_AGENTS(l, comp, value)
@@ Line 500: / Line 666: @@
 :''l'' is a list of agent scopes, ''comp'' is a string naming a component in those agents, and ''value'' is any JavaScript data element.
 :'''Returns''':  Respectively returns ''true'' if for all, none or some scope in ''l'' the current value of  ''comp'' is ''value''; ''false'' otherwise.
+</div></div></div>
+<div id="ALL_NEIGHBORS">
+<div id="NO_NEIGHBORS">
+<div id="SOME_NEIGHBOR">
+;ALL_NEIGHBORS(d, comp, value)
+;NO_NEIGHBOR(d, comp, value)
+;SOME_NEIGHBOR(d, comp, value)
+:Analogous to ALL_AGENTS, etc. except the agents of interest are those within a radius of ''d'' units from the agent making the call. Forms that list of agents and returns ''true'' if for all, none, or some agent scope in that list the current value of ''comp'' is '' value''; ''false'' otherwise.
+</div></div></div>
 <div id="RANDOM_MOVE">
 ;RANDOM_MOVE(loc, [wrap])
 :'''Returns''': a location object (i.e., with fields ''x'' and ''y'') representing a random move (wrapping if wrap is true) of one unit from the location object ''loc''. If ''loc'' is omitted it defaults to the location of the caller.
+</div>
 <div id="HEX_RANDOM_MOVE">
 ;HEX_RANDOM_MOVE(loc, [wrap])
 :'''Returns''': a location object (i.e., with fields ''x'' and ''y'') representing a random move (wrapping if wrap is true) of one unit from the location object ''loc'' on a hexagonal surface. If ''loc'' is omitted it defaults to the location of the caller.
+</div>
 <div id="INBOUNDS">
 ;INBOUNDS(x, y)
 :'''Returns''': true if ''0 ≤ x < columns'' and ''0 ≤ y < rows'', where [''columns'', ''rows''] is the dimension of the agent landscape.
+</div>
+<div id="simworld">
+==SimWorld Properties==
+<div id="cellmatrix">
+;cellmatrix
+:Bound to the CellMatrix component in a SimWorld
+</div>
+<div id="agentvector">
+;agentvector
+:Bound to the AgentVector component in a SimWorld
+</div>
 ==SimWorld Primops==
-<div id="simworld">
 Cell and agent capsules in a SimWorld may respectively use the Cell and Agent properties and primops described above.
 Also in a SimWorld, cell capsules may call some agent primops and agent capsules may call some cell primops, as detailed below.
@@ Line 531: / Line 719: @@
 ;MYAGENTS()
 :'''Returns''': the list of agents currently contained in the caller.
+</div>
 <div id="MYAGENT_COUNT">
 ;MYAGENT_COUNT()
 :'''Returns''': the number of agents currently contained in the caller.
+</div>
 ===Agent Primops in a SimWorld===
@@ Line 547: / Line 736: @@
 ;MYCELL()
 :'''Returns''': the scope of the cell containing the caller.
+</div>
 ===Hexagonal Agent Primop===
@@ Line 554: / Line 743: @@
 ;HEXMOVE(dist, dir)
 :Moves the calling agent distance dist in the direction dir. Directions are denoted by compass directions; i.e., “N”, “NE”, “SE”, “S”, “SW”, “NW”.
+</div>
 ===Convenience Primops===
 These primops perform useful functions that could otherwise be programmed.
@@ Line 565: / Line 754: @@
 ;AGENTRING(n, ["sort"])
 ;AGENTWRING(n, ["sort"])
-:'''Returns''': a list of scopes for all agents in the ring or block (wrapped or otherwise) specified by ''n.'' If “sort” is included, the list is sorted in order of increasing distance from the caller.
+:'''Returns''': a list of scopes for all agents in the ring or block (wrapped or otherwise) specified by ''n''. If “sort” is included, the list is sorted in order of increasing distance from the caller.
+</div></div></div></div>
 ==Node Properties and Primops==
@@ Line 575: / Line 765: @@
 ;myId
 :Bound to the caller’s node ''id''.
+</div>
 <div id="count">
 ;count
 :Bound to the number of nodes in the NodeNetwork.
+</div>
+<div id="nodes">
+;nodes
+:Bound to the 1-dimensional array of Nodes in a NodeNetwork.
+</div></div>
 ===Primops===
 <div id="node">
 <div id="CONNECTION">
 ;CONNECTION(id0, id1)
-:''Returns'': the connection from Node with id ''id0'' to Node with id ''id1'', or null if no such connection exists.
+:'''Returns''': the connection from Node with id ''id0'' to Node with id ''id1'', or null if no such connection exists.
+</div>
 <div id="CONNECTIONS_IN">
 ;CONNECTIONS_IN([id])
 :'''Returns''': the array of connections into the node ''id'' (if ''id'' is omitted, it is assumed to be the caller). Each connection is an object with 3 properties: ''id'', the node id of the source; ''strength'', the raw strength of the connection; and ''n_strength'', the normalized strength of the connection, where the total normalized strength of all connections into the caller is 1.
+</div>
 <div id="CONNECTIONS_OUT">
 ;CONNECTIONS_OUT([id])
 :'''Returns''': the array of connections from the node ''id'' (if ''id'' is omitted, it is assumed to be the caller). Each connection is an object with 3 properties: ''id'', the node id of the target; ''strength'', the raw strength of the connection; and ''n_strength'', the normalized strength of the connection, where the total normalized strength of all connections from the caller is 1.
+</div>
 <div id="NODE">
 ;NODE(id)
 :'''Returns''': a scope for node ''id''.
-<div id="NODE_COUNT()">
+</div>
-;NODE_COUNT()
+<div id="NODECOUNT">
+;NODECOUNT()
 :'''Returns''': the total number of nodes.
+</div>
 <div id="NODE_VALUE">
 ;NODE_VALUE(id, comp)
@@ Line 602: / Line 802: @@
    NODE_VALUE(id, comp) == NODE(id)[comp]
+</div>
 <div id="NODES">
 ;NODES()
 :'''Returns''': the array of node scopes.
+</div>
 <div id="INFLOW">
 ;INFLOW([id])
 :'''Returns''': the total strength of connections into node ''id'' (if ''id'' is omitted, it is assumed to be the caller).
+</div>
 <div id="OUTFLOW">
 ;OUTFLOW([id])
 :'''Returns''': the total strength of connections from node ''id'' (if ''id'' is omitted, it is assumed to be the caller).
+</div>
 <div id="NEIGHBORS_IN">
 <div id="NEIGHBORS_OUT">
@@ Line 616: / Line 820: @@
 ;NEIGHBORS_OUT([id])
 :'''Returns''': a list of all scopes of Nodes with input (output) connections to the Node with given ''id''. If ''id'' is omitted, the caller's id is used.
+</div></div></div>
 ==NetWorld Primops==