# A Hack to Create Matrices in R, Matlab style

March 7, 2014
By

(This article was first published on Publishable Stuff, and kindly contributed to R-bloggers)

The Matlab syntax for creating matrices is pretty and convenient. Here is a 2×3 matrix in Matlab syntax where `,` marks a new column and `;` marks a new row:

``````[1, 2, 3;
4, 5, 6]

```
Here is how to create the corresponding matrix in R:
```matrix(c(1,4,2,5,3,6), 2, 3)

```
```##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6

```
Functional but not as pretty, plus the default is to specify the values column wise. A better solution is to use `rbind`:

```rbind(c(1,2,3),
c(4,5,6))

```
```##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6

```
Lately I’ve been reading up on the metaprogramming capabilities of R in Hadley Wickham’s great Advanced R programming (while it is freely available online, you can already pre-order the IRL version here). Using metaprogramming we can hack together a function that allow us to create matrices in a similar way as in Matlab. I’ll first show some examples of how the function works and after that I’ll show you the code. The function is called `qm` as in “quick matrix” where `,` is used to separate columns and `|` is used to separate rows:
```qm(1,2,3|
4,5,6)

```
```##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6

```
```qm(1:3 | rnorm(3) | 0, 0, 0)

```
```##       [,1]   [,2]  [,3]
## [1,] 1.000 2.0000 3.000
## [2,] 2.421 0.9801 1.202
## [3,] 0.000 0.0000 0.000

```
```qm(1|2|3|4)

```
```##      [,1]
## [1,]    1
## [2,]    2
## [3,]    3
## [4,]    4

```
```# qm is useful when defining covariance matrices, for example:
library(MASS)
sigma = qm( 1 , 0.7|
0.7,  1 )
xy <- mvrnorm(100, c(0, 0), sigma)
plot(xy, xlab = "x", ylab = "y")

```

Pretty cool, right? 🙂
Here is finally the full `qm` function. The trick is roughly to grab the arguments to `qm` as a list, split every argument with a `|` into two, and finally form the rows of the matrix by evaluating and concatenating the arguments between each `|`. (`qm` is not extensively tested so use it at your own risk and please tell me if you find any way to improve the code!)
```qm <- function(...) {
# Get the arguments as a list
arg <- eval(substitute(alist(...)))
# Initialize l as a list of vecors, each vector in l corresponds to one row
# of the matrix.
l <- list(c())
# rhl_l is a list where we will push the rhs of expressions like 1 | 2 | 3 ,
# which parses as (1 | 2) | 3 , while we deal with the left hand side (1 |
# 2)
rhl_l <- list()
while (length(arg) > 0) {
a <- arg[[1]]
arg <- tail(arg, -1)
if (a[[1]] == "|") {
# Push the left hand side of the ... | ... expression back on the arguments
# list and push the rhs onto rhl_l
arg <- c(a[[2]], arg)
rhl_l <- c(a[[3]], rhl_l)
} else {
# Just a normal element, that we'll evaluate and append to the last
# vector/row in l.
l[[length(l)]] <- c(l[[length(l)]], eval(a))
# If there are rhs elements left in rhs_l we'll append them as new
# vectors/rows on l and then we empty rhs_l.
for (i in seq_along(rhl_l)) {
l[[length(l) + 1]] <- eval(rhl_l[[i]])
}
rhl_l <- list()
}
}
do.call(rbind, l)
}

```
While I’m not sure that `qm` is really a super useful function, I still think it is a nice example of what you can hack together using the metaprogramming facilities of R.

Related

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

```