## 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 = Structure address = 6bc1ab0 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 = Structure address = 6bc31e0 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.