R agent-based proximity

Question

I am trying to use R to model grids of agents that change their decisions based on the decisions of other agents in their direct proximity. Basically, each agent looks to the other agents around him on the grid, and might change its behaviour based on the the actions around him. I have included some sample dinky-toy code per below to show (one iteration) of such dynamic.

I am wondering whether

1. there is an elegant manner to address the boundaries of the grid (currently the t+1, i+1 code doesn't work on the edges),

2. or whether there are other approaches that use the "spatial" dimension of the matrix / use graph-based approaches to simulate these kind of models?

---

NCols=10 
NRows=10
df=round(matrix(runif(NCols*NRows), ncol=NCols),0); df

t=1;i=1

for(i in 1:(nrow(df)-1)){
  for(t in 1:(ncol(df)-1)){
     prox=sum(df[t+1,i]+df[t+1,i-1]+df[t+1,i+1]+df[t,i]+df[t,i-1]+df[t,i+1]+df[t-1,i]+df[t-1,i-1]+df[t-1,i+1])
    if(prox<=3) {df[t,i]=0} else {df[t,i]=1}
  }
}
df

Answer 1

One relatively simple solution to the edge problem is to cause agents at opposite edges to be next to those at the corresponding location on the opposite edge. This makes the grid into a kind of torus. Since your numbering runs from 0 to n, one simple way to implement this is to use modulo. For example, instead of i+1, use (i+1) %% (NRows+1). For example, when NRows=10, %% (NRows+1) maps 11 into 0, and -1 into 10.

There are many different ways to set up rules specifying which agents affect each other, and these rules can produce radically different behaviors from identical rules specifying what to do once it's decided who interacts with whom. It looks like you're using the 8-element Von Neumann neighborhood. The other common grid-based alternative is 4-element Moore neighborhood. I learned alot about how network structure and neighborhood structure affects outcomes from J. McKenzie Alexander's book The Structural Evolution of Morality. There are other sources for this kind of insight, but Alexander really makes the point clear.

R might not be the best language for experimenting with simple interaction rules on different network structures. Of course you can do it, and there are probably R packages that make it easier, but it's nice to have easy tools for such experimentation. I personally think NetLogo is great for this kind of experimentation. It's a little quirky, but easy to learn, and it's easy to tell it to set up various network structures, or to use the built-in grid with either Von Neumann or Moore neighborhoods. There is also an add-on to allow interaction between NetLogo and R, but I've never tried it. You may have good reasons to build your models from scratch in R, however.