Of all the many programming languages, none has quite caught my attention like the “Iversonian” programming languages, that is, languages like APL, Shakti, Ivy, BQN and J - the subject of this blog post.

One misconception is that languages like J are in the same caliber as Brain F**k and other esoteric or golfing languages which are mostly for recreational programming. Languages like J however were designed to be a replacement to traditional maths notation - an interface for thinking or a tool of thought as their inventor Kenneth E. Iverson called them in his Turing Award lecture.

In this blog post I am going to introduce the J programming language by using it as a “tool of thought” to explain the 1 dimensional random walk.

To try out the code yourself you will have to install the J interpreter. The easiest way to get it working on Mac is through running the brew formula brew install --cask j. For other platforms, see the installation instructions.

First, a random walk in 5 lines.

The 1 dimensional random walk is a toy model used in finance for creating what may look like stock market prices. In it’s simplest form, a 1 dimensional random walk consists of;

• Several steps (a list of values), and at each step (for each value) it is either up (indicated by +1) or down (indicated by -1).
• Note that the value of each step -1 or +1 is chosen at random. Hence the term ‘random walk’. So a random walk is basically a list of -1 and +1 generated at random.
• To attain the ‘synthetic price’ or what looks like stock prices, we simply compute the running sum of this list of random -1 and +1 integers.

The entire toy model of prices we described above is created using the J code below. Let me describe how.

load 'plot' NB. Import the utility for plotting  charts
indices     =: ? 100#2          NB. Generate indices
walks       =: indices { _1 1   NB. Use indices to create list of -1 & +1 integers
running_sum =: +/\ walks        NB. Compute synthetic price
plot running_sum                NB. Plot the running sum

Generating indices.

An index refers to the position of an item in a list. For example, the list 1 2 3 4 has the indices 0 for 1, 2, 3, with the index 0 referring to 1, the index 1 referring to 2, the index 2 referring to 3 and the index 3 referring to 4.

Line 2, indices =: ? 100#2 generates indices as follows. The # symbol takes in two values 2 and 100 and what it does is that it “copies” 2 into an list 100 times. For example 5#1 copies 1 five times to give 1 1 1 1 1. So 100#2 returns 2 2 2 2 2 2 2 2 2 2 ... 2 up to the 100’th 2.

The ? symbol generates random numbers, you can think of it as rolling a dice. For example, ? 5 may randomly return 0, 1, 2, 3 or 4. So ? 5 can be read as “generate a random number below 5”, 0 is included since the values ? generates are always greater than or equal to 0.

And finally to generate a list of random numbers, we simply give ? a list of numbers for example ? 3 3 3 3 3 may generate 1 1 0 2 2 i.e 5 random numbers under 3. Recall that in line 2, 100#2 generates a list of one hundred 2’s. ? then takes the list of one hundred 2’s and for each 2 it generates a random number less than 2 i.e 0 or 1.

? 100#2 can be read as “generate a list one hundred 2’s and for each item in the list, generate a random integer less that 2”. This will return a random list of 100 items made up of exclusively 1’s and 0’s looking like 0 0 1 1 0 0 1 1 1 0 0 1 0 1 0 1 1 0 1 0 1 1 0 1 .... We then store this in a variable called indices using =:

This is what we shall use as our indices.

Use indices to create list of -1 & +1 integers.

In line 3, we use our list of 0’s and 1’s as indices to generate a random walk (random list made up of -1’s & +1’s). To do this, we use the symbol { in indices { _1 1 that takes in two sets of values, first is the variable indices which is a list of randomly generated 1’s & 0’s. On the other side of { is _1 1, which represent the directions of our random walk _1 for -1 (down) and 1 for +1 or (up).

What { does is that it “pulls” items from a list given an index. The list _1 1 has the indices 0 for _1 and 1 for 1, recall that an index refers to the position of an item in the list. So the statement 0 { _1 1 would return _1 and 1 { _1 1 returns 1 from the list.

A list of indices would also return a list of items, for instance 1 0 0 1 { _1 1 would return 1 _1 _1 1. Which is similar to what indices { _1 1 is doing. Since indices is a list of random one hundred 1’s and 0’s it will also randomly pull out a list of _1 and 1 thus giving us a list like _1 _1 1 1 _1 _1 _1 _1 _1 _1 1 _1 ... up to the one hundredth index. Which is the random walk of 100 steps.

We also store this list into a variable walks using =:.

Compute the synthetic prices.

In line 4 we use +/\ the running sum of the random walk. For example +/\ 1 1 1 1 1 1 1 computes the running sum of seven 1’s, which gives us 1 2 3 4 5 6 7. Which is exactly what we do with +/\ walks.

Since walks is made up of randomly generated _1 and 1, it’s running sum will equally fluctuate up and down. The running sum of 1 _1 1 _1 _1 _1 1 1 1 _1 _1 will look like 1 0 1 0 _1 _2 _1 0 1 0 _1

The running sum (synthetic price) +/\ walks is then stored inside the variable running_sum with =:

A random walk in 2 lines.

This post was supposed how to create a random walk in 2 lines of J. So below is the exact code above refactored to run in two lines.

load 'plot'              NB. Import the plot library
plot +/\ (?100#2) { _1 1 NB. Plot synthetic price/ random walk

Adjusting step size

100 denotes the number of steps the random walk takes. The more the steps the closer to actual stock prices the plot will look like.

Random Walk of 100 steps

Random Walk of 200 steps

Random Walk of 500 steps

Random Walk of 1,000 steps

Random Walk of 10,000 steps