The Zen of R

gistfile1.r

# I am a scientist who has been using R for about 2 years. Today I achieved a measure of enlightenment into
# the zen of R, and I want to share it with you.

# I was simulating a set of independent random walks, which are formed by a multiplicative process. Here is
# the code I had built up over a few months of working on it and modifying it on and off as research
# questions changed:

TimeSteps <- 1000
Walks <- 100
ErrorMagnitude <- 0.03
StartingValue <- 15

Iterate <- function (Function, number.of.times, starting.value, accumulate = FALSE, ...) {
	results <- list (Function (starting.value, ...))
	for (iteration in seq_len (number.of.times - 1))
		results[[iteration + 1]] <- Function (results[[iteration]], ...)
	return (if (accumulate) results else results[[number.of.times]])}
RandomWalk <- function (previous.generation) {
	previous.generation * rnorm (Walks, 1, ErrorMagnitude)}
PlotResults <- function (results) {
	results <- matrix (unlist (results), ncol = length (results))
	plot (colMeans (results), type = "l")}

PlotResults (Iterate (RandomWalk, number.of.times = TimeSteps,
                                  starting.value = rep (StartingValue, Walks),
                                  accumulate = TRUE))

# Hopefully it is self-explanatory. 'RandomWalk' makes one time step of random walking happen, 'Iterate' feeds
# this back onto itself a bunch of times, and `PlotResults` is obvious.

# Today I thought for a while about the terse style of R code I sometimes see: code that leans heavily on
# built-in library functions, and finds a clever way of representing one's problem within the semantic world
# of those functions. Eventually, I wrote:

plot (colMeans (t (replicate (100, cumprod (rnorm (1000, 1, 0.03)))) * 15), type = "l")

# You can verify for yourself that this does the same thing. But I believe it captures an essential simplicity
# of the simulation in a way that just can't be seen in the first, long-winded version. The use of typical
# programming structures blinded me to the elegant way something can be expressed if your language offers
# tools truly suited to your domain. And note that in this case the programming structures that were getting
# in the way of my mental clarity were structures from functional programming (functions and higher-order
# functions), not the imperative structures that are usually charged with closing programmers' minds.

# I'm interested in your thoughts and comments, if any. Incidentally, the idea of using a Gist as an
# essay-writing platform tickled my fancy - we shall see how it works, if at all.