**The Shape of Code » R**, and kindly contributed to R-bloggers)

While I have been using the R language/environment for over five years or so, whenever I needed to do some statistical calculations, until recently I was only a casual user. A few months ago I started to use R in more depth and made a conscious decision to try and do things the ‘R way’.

While it is claimed that R is a functional language with object oriented features these are sufficiently well hidden that the casual user would be forgiven for thinking R was your usual kind of domain specific imperative language cooked up by a bunch of people who had not done this sort of thing before.

The feature I most wanted to start using in an R-like way was vectors. A literal value in R is not a scalar, it is a vector of length 1 and the built-in operators take vector operands and return a vector result, e.g., the result of the multiplication (`c`

is the concatenation operator and in the following case returns a vector of containing two elements)

> c(1, 2) * c(3, 4) [1] 3 8 >

The language does contain a for-loop and an if-statement, however the R-way is to use the various built-in functions operating on vectors rather than explicit loops.

A problem that has got me scratching my head for a better solution than the one I have is the following. I have a vector of numbers (e.g., 1 7 1 2 9 3 2) and I want to find out how many of each value are contained in the vector (i.e., 1 2, 2 2, 3 1, 7 1, 9 1).

The `unique`

function returns a vector containing one instance of each value contained in the argument passed to it, so that removes duplicates. Now how do I get a count of each of these values?

When two vectors of unequal length are compared the shorter operand is extended (or rather the temporary holding its value is extended) to contain the same number of elements as the longer operand by ‘reusing’ values from the shorter operand (i.e., when indexing reaches the end of a vector the index is reset to the beginning and then moves forward again). This means that in the equality test `X == 2`

the right operand is extended to be a vector having the number of elements as `X`

, all with the value 2. Some of these comparisons will be true and others false, but importantly the resulting vector can be used to index `X`

, i.e., `X[X == 2]`

returns a vector of 2′s, one for each occurrence of 2 in `X`

. We can use `length`

to obtain the number of elements in a vector.

The following function returns the number of instances of `n`

in the vector `X`

(now you will see why thinking the ‘R way’ needs practice):

num_occurrences = function(n) { length(X[X == n]) # X is a global variable }

My best solution to the counting problem, so far, uses the function `lapply`

, which applies its second argument to every element of its first argument, as follows:

unique_X = unique(X) # I know, real staticians use <- for assignment X_counts = lapply(unique_X, num_occurrences)

Using `lapply`

feels like a bit of a cheat to me. Ok, the loop is in compiled C code rather than interpreted R code, but an R function is being called for every unique value.

I have been rereading Matter Computational which has gotten me looking for a solution like those in the first few chapters of this book (and which will probably be equally obscure).

Any R experts out there with suggestions for a non-`lapply`

solution?

**leave a comment**for the author, please follow the link and comment on his blog:

**The Shape of Code » R**.

R-bloggers.com offers

**daily e-mail updates**about R news and tutorials on topics such as: visualization (ggplot2, Boxplots, maps, animation), programming (RStudio, Sweave, LaTeX, SQL, Eclipse, git, hadoop, Web Scraping) statistics (regression, PCA, time series, trading) and more...