(`AddEdge`*One*,*Two*)- Adds an edge between the agent with index
*One*and the agent with index*Two*.bsh% for (i=0; i<14; i++) {

AddEdge (0, (100/13)*i);

}

Before

After

Agent(**GetAgent***Index*)

- Returns the agent at
*index*. This function works for all models except two-dimensional lattices (which require an additional coordinate).

In a one-dimensional lattice, the index increases from 0 at the left to*NumberOfAgents-1*at the right.

In small-world networks, the index increases from 0 at 3 o'clock (see above) to*NumberOfAgents-1*in clockwise fashion.

In bounded degree networks, the index increases as in small-world networks.

Dynamic networks draw the index over the center of the node.

*Agent*(**GetAgent***XCoordinate*,*YCoordinate*)- Returns the agent in the two-dimensional lattice at
*(XCoordinate*,*YCoordinate*). This function only works for two-dimensional lattices.

*LinkedList*(**ExpandedNeighborhood***Agent*,*Depth*)- Get the expanded neighborhood of
*Agent*to*Depth*. The expanded neighborhood consists of all neighbors, plus neighbors-of-neighbors, plus neighbors-of-neighbors-of-neighbors, where the length of the chain is the depth. An expanded neighborhood of depth 1 is just the original neighborhood of the agent. An expanded neighborhood of depth 2 is the original neighborhood plus all of the neighbors of neighbors.By definition, any expanded neighborhood of depth greater than 1 contains the original agent.

It is marginally more efficient to get the neighborhood of an agent by calling

*agent.getNeighborhood()*instead of*ExpandedNeighborhood(agent,1);*The following code sets all members of the 3-expanded neighborhood (using the Moore 8 neighborhood) of the agent at (50,50) to 5.

bsh% SetStrategies( ExpandedNeighborhood( GetAgent(50,50), 3), 5);

Before After

*Collection*(**ExpandedNeighborhood***Collection*,*Depth*)

- Construct the expanded neighborhood of for all agents in
*Collection*and return it as a collection.

When combined with

, this allows one to introduce "blocks" of mutants at random locations in the network or lattice. For**RandomSubset**

example, in a two-dimensional lattice where all individuals use the Moore 8 neighborhood, the following command selects 4 individuals at

random from the population and changes them, plus the squares surrounding them in the lattice, to the strategy Demand 5.

bsh% SetStrategies( ExpandedNeighborhood( RandomSubset(population, 4), 2), 5);

This could also be written (for greater clarity) as:

bsh% subset = RandomSubset(population, 4);

bsh% expanded_subset = ExpandedNeighborhood(subset, 2);

bsh% SetStrategies( expanded_subset, 5 );

Before After

Collection(**RandomSubset***Collection*,*Size*)

- Construct a random subset containing
*size*elements from*Collection*and return this as a collection.This can be used to introduce a number of "mutations" into the population. For example, suppose we have a 4--6 polymorphism of

divide-the-dollar. Then the following command introduces 3 mutants following Demand 5 into the population:

bsh% SetStrategies( RandomSubset( population, 3 ), 5 );

(**SaveBitmap***Filename*)

- Save a bitmapped image of the current display to
*Filename*. The bitmapped image is in PNG format.

bsh% SaveBitmap("/Users/jalex/bitmaps/foo.png");

(

`SetInitialConditions`*Array*)

- Change the default initial conditions for future new models to that
specified by
*Array*. The value of*Array*[i] is the

relative frequency of strategy i.

The values of

*Array*need not sum to 1, as the sum is normalized before being used. This makes it convenient to specify

frequencies in terms of one strategy being twice as common as another and six times as common as yet another.

The length of

*array*must equal the number of strategies in the current model, otherwise an error occurs.bsh% double[] array = {0.0, 0.0, 1.0, 0.5, 0.25, 4.0}

bsh% SetInitialConditions(array); (**SetStrategy***Agent*,*Strategy*)

- Sets the strategy of
*Agent*to*strategy*. All strategies are represented by integers between 0 and*NumberOfStrategies.*bsh% SetStrategy( GetAgent( 50 ), 5);

(

SetStrategy*Collection*,*Strategy*)

- Sets the strategy of all agents in
*collection*to*strategy*. This function is most useful when combined with the functions that automatically generate collections, like**Partition**,**ExpandedNeighborhood**, and**RandomSubset**. (

SetStrategies*Collection*,*Strategy*)

- A grammatically correct form of
**SetStrategy**applied to collections.

Collection[](**Partition***Collection*,*Number*)- Partition
*Collection*into*number*disjoint subsets and return an array of collections, each collection containing the members of one partition.

bsh% p = Partition(population, 3);

bsh% SetStrategies(p[0], 4);

bsh% SetStrategies(p[1], 5);

bsh% SetStrategues(p[2], 6);

(**FrontierCompetition***LeftStrategy*,*RightStrategy*)- Creates a frontier competition between
*LeftStrategy*and*RightStrategy.* -
bsh% FrontierCompetition( 3, 6 );

(**FrontierCompetition***LeftStrategy, LeftOtherStrategy, Probability, RightStrategy*)- Creates a frontier competition between
*LeftStrategy*and*RightStrategy*, adding the additional strategy*LeftOtherStrategy*to the left region with*Probability*.bsh% FrontierCompetition(3, 5, 0.25, 6);

(**FrontierCompetition***LeftStrategy, RightStrategy, RightOtherStrategy, Probability*)- As above, but with the additional strategy added to the right region.
bsh% FrontierCompetition(3, 5, 6, 0.25);

(**FrontierCompetition***LeftStrategy, LeftOtherStrategy, Probability1, RightStrategy, RightOtherStrategy, Probability2*)- The combined version of the above. Useful for generating competitions
between polymorphic pairs.
bsh% FrontierCompetition(4, 6, 0.2, 3, 7, 0.2);

(**CenterCompetition***MajorStrategy, MinorStrategy, Diameter*)- Creates a competition with
*MajorStrategy*assigned to all agents in the lattice, except for a block of width*Diameter*in the middle assigned*MinorStrategy*. (

`DiagonalCompetition`*MajorStrategy, MinorStrategy*)- Creates a competition in a two-dimensional lattice with opposing strategies above and below the main diagonal.