### Archive

Archive for January, 2012

## Viewing the internals of MATLAB Matrices

A cool undocumented trick I just learnt from The MathWorks’ Bob Gilmore. If you type

```format debug
```

Then printing any vector reveals information about its internal representation. For example:

```x = magic(3)

x =

m = 3
n = 3
pr = d8dccf0
pi = 0
8     1     6
3     5     7
4     9     2
```

The structure address is the address in memory where the matrix is stored, `m` and `n` are the number of rows and columns respectively of the matrix, and `pr` and `pi` are pointers to the addresses of the matrices storing the real and imaginary components of the matrix.

One interesting thing to look at is the representation of scalar numbers.

``` y = 1

y =

m = 1
n = 1
pr = d790b90
pi = 0
1
```

Yep: they are stored in exactly the same way as matrices: in the same way the “everything in R is a vector”, everything in MATLAB is a matrix. To finish up, here are some more examples for you to explore:

```% higher dimensional arrays
rand(2, 3, 4)
% cell arrays (unfortunately not that revealing)
{1, magic(3)}
% sparse matrices (very interesting)
sparse(ones(3))
```

## Exploring the functions in a package

Sometimes it can be useful to list all the functions inside a package. This is done in the same way that you would list variables in your workspace. That is, using `ls`. The syntax is `ls(pos = "package:packagename")`, which is easy enough if you can remember it. Unfortunately, I never can, and have to type `search()` first to see what the format of that string is.

Today, that problem is solved with a tiny utility function to save remembering things, and to save typing.

```lsp <- function(package, all.names = FALSE, pattern)
{
package <- deparse(substitute(package))
ls(
pos = paste("package", package, sep = ":"),
all.names = all.names,
pattern = pattern
)
}
```

`all.names` and `pattern` behave in the same way as they do in regular `ls`. You use it like this:

```lsp(base)
lsp(base, TRUE)
lsp(base, pattern = "^is")
```

EDIT: I’ve had a couple of questions about the use case, and there are some interesting comments on alternatives. My thinking behind this function was that I sometimes know I’ve seen a function in a package but can’t remember what it’s called. If you can hazard a guess at the name, then `apropos` is probably better, though it looks everywhere on the search path rather than in a particular package. Autocompletion is also useful for this, but you need to know the first few characters of what you are looking for. (Activate autocompletions by pressing TAB in R GUI or Rstudio or CTRL+space in eclipse. I can’t remember what the shortcut is in emacs, but you probably just mash CTRL+META until you have RSI.) Finally, the `unknownR` package is useful for finding new functions that you hadn’t heard of yet.