Bounded random walk

Question

I have a random walk algorithm that I want to implement, but I am getting a recursion depth issue. I am making a list of points that Z particles can be in over the domain $(-L/2,L/2)$. I am using a double For loop that will generate the values for the points of the different particles given this domain. The code is:

    Remove["Global`*"]
    Z = 3;
    NMAX = 3;
    l = 1;
    L = 100;
    x[0, i_] = 0;
    For[i = 0, i <= Z, i++,

    For[n = 1, n <= NMAX, n++,

    If[Abs[x[n - 1, i] + l Cos[2 π RandomReal[]]] >= L/2, 
    x[n, i] := x[n, i] = x[n - 1, i] - l Cos[2 π RandomReal[]], 
    x[n, i] := x[n, i] = x[n - 1, i] + l Cos[2 π RandomReal[]]]]]

    Table[x[n, i], {n, 0, NMAX}, {i, 0, Z}] // TableForm

$l$ is the uniform step that the particle will take and the If statement makes sure that the x position is assigned such that the value is within the domain. I would like to extend this also to y coordinates but that is something I will tackle after I can work this kink out.

I also started the list of particles (at time $n=0$) at position (0,0). The issue I am running into is that while the position for all (3) particles, starts off at 0 and then the first time step is shown but after that the out put is x[2,i] and x[3,i]. It works for the first time step, but not for any subsequent time steps. The error that I get is:

Recursion depth of 1024 exceeded.

I tried setting the recursion limit to 4000, since I found this somewhere else and it works for some problems, but ...

1. I am not sure what setting the recursion limit does.

2. It didn't work for me.

Any help would be appreciated!

Answer 1

Random walks are easy to implement with Mathematica. I think you would find many examples on this site if you were to search on "random walk". To implement the walk you describe, it just as easy to implement the 2D version you are aiming for as the 1D one, so the 2D walk is what I will discuss here.

First. Nested For-loops are not the way to go. I will use NestList which is a commonly used functional looping construct. I will also use recursion to handle the bounds constraint, but in a way the will not lead to uncontrolled recursion.

Second. I will use a divide-and-conquer implementation strategy. I break the problem in three parts.

1. A function nextPt, which given the current point and the radius of the disk of possible next locations returns the next point of the walk. nextPt uses recursion to implement the boundary constraint.

2. A function walk, which given the starting point, the radius of the disk of possible next locations, and the number of steps to be taken returns a list of points comprising the walk.

3. A function walkPlot, which given a list made by walk produces a visualization of the walk. The stating point is shown as a red dot and ending point is shown as a blue dot. walkPlot will take additional options which will be passed on to Graphics, so the look of the plot can be modified to suit other needs. (The option handling could certainly be improved, but I thought adding the extra code required would distract from the main point of this answer.)

You may not need walkPlot for your work. You may just need first two functions to generated data for any further processing you have in mind.

With[{w = 10., h = 8.}, 
  With[{bounds = Rectangle[{-w/2., -h/2.}, {w/2., h/2}]}, 
    nextPt[ pt_, r_] := 
      Block[{nxt = pt + r {Cos[#], Sin[#]}&[RandomReal[2. π]]},
        If[RegionMember[bounds, nxt], Return[nxt]];
        nextPt[pt, r]];
    walk[start : {_Real, _Real}, r_Real?Positive, steps_Integer?Positive] :=
      NestList[nextPt[#, r] &, start, steps]; 
    walkPlot[path_, opts : OptionsPattern[]] :=
      Graphics[{
        Line[path],
        Red, Disk[First[path], Scaled[.015]],
        Blue, Disk[Last[path], Scaled[.015]]},
        opts,
        PlotRange -> Transpose[List @@ bounds],
        Frame -> True]]]

Note the following:

• RegionMember, a fairly recent addition to Mathematica, is used to test whether or not a candidate point lies within the boundary rectangle.
• The walk function is extremely simple in Mathematica's functional style. It also has much better performance than For.

Now let's run three experiments with the following code.

SeedRandom[2];
Column[Table[walkPlot[walk[{0., 0.}, 2., 150], ImageSize -> Medium], 3]]

Update

I have corrected an error in the function nextPt. The updated version correctly generates steps of magnitude r.