matlabr: a Package to Calling MATLAB from R with system

ゝ一世哀愁。 2022-08-07 12:39 22阅读 0赞

(This article was first published on  **[A HopStat and Jump Away » Rbloggers][A HopStat and Jump Away _ Rbloggers]**, and kindly contributed to [R-bloggers)][R-bloggers]

In my research, I primarily use `R`, but I try to use existing code if available.  In neuroimaging and other areas, that means calling MATLAB code.  There are some existing solutions for the problem of `R` to MATLAB: namely the [ `R.matlab`][_R.matlab] package and the [ RMatlab][RMatlab] package (which can call `R` from MATLAB as well).  I do not use thse solutions usually though.

Previously, [ Mandy Mejia wrote “THREE WAYS TO USE MATLAB FROM R”][Mandy Mejia wrote _THREE WAYS TO USE MATLAB FROM R].  Option 2 is about how to use `R.matlab`, and Mandy gives and example with some cod.  She also describes in Options 1 and 3 how to use the `system` command to call MATLAB commands.

I like this strategy options because:

1.  I didn’t take the time to learn `R.matlab`.
2.  It worked for me.
3.  I wrote a package to wrap the options Mandy described: `matlabr`.

## matlabr: Wrapping together system calls to MATLAB ##

The [ `matlabr`][_matlabr] package is located in GitHub and you can install it with the following command:

devtools::install_github("muschellij2/matlabr")

It has a very small set of functions and I will go through each function and describe what they do:

1.  `get_matlab`: Mostly internal command that will return a character string that will be passed to `system`.  If `matlab` is in your PATH (bash variable), and you are using R based on the terminal, the command would return `"matlab"`.  If MATLAB is not in your PATH or using a GUI-based system like RStudio, you must set `options(matlab.path='/your/path/to/matlab')`.
2.  `have_matlab`: Wrapper for `get_matlab` to return a logical if `matlab` is found.
3.  `run_matlab_script`: This will pass a `.m` file to MATLAB.  It also wraps the command in a [ try-catch][try-catch] statement in MATLAB so that if it fails, it will print the error message.  Without this try-catch, if MATLAB errors, then running the command will remain in MATLAB and not return to `R`.
4.  `run_matlab_code`: This takes a character vector of MATLAB code, ends lines with `;`, writes it to a temporary `.m` file, and then runs `run_matlab_script` on the temporary `.m` file.
5.  `rvec_to_matlab`: Takes in a numeric `R` vector and creates a MATLAB column matrix.
6.  `rvec_to_matlabclist`: Takes in a vector from `R` (usually a character vector) and quotes these strings with single quotes and places them in a MATLAB cell using curly braces: `{` and `}`.  It then stacks these cells into a “matrix” of cells.

## Setting up `matlabr` ##

Let’s set up the `matlab.path` as I’m running in RStudio:

library(matlabr)
    options(matlab.path = "/Applications/MATLAB_R2014b.app/bin")
    have_matlab()

The result from `have_matlab()` indicates that the `matlab` command can be called.

### Let’s write some code to test it ###

Here we will create some code to take a value for `x`, `y`, `z` (scalars) and a matrix named `a` and then save `x`, `a`, `z` to a text file:

code = c("x = 10", 
             "y=20;", 
             "z=x+y", 
             "a = [1 2 3; 4 5 6; 7 8 10]",
             "save('test.txt', 'x', 'a', 'z', '-ascii')")
    res = run_matlab_code(code)

/var/folders/1s/wrtqcpxn685_zk570bnx9_rr0000gr/T//RtmpHnOinq/file2f8352c04937.m

### Output ###

First off, we see that `test.txt` indeed was written to disk.

file.exists("test.txt")

[1] TRUE

We can read in the `test.txt` from using `readLines`:

output = readLines(con = "test.txt")
    print(output)

[1] "   1.0000000e+01"                                
    [2] "   1.0000000e+00   2.0000000e+00   3.0000000e+00"
    [3] "   4.0000000e+00   5.0000000e+00   6.0000000e+00"
    [4] "   7.0000000e+00   8.0000000e+00   1.0000000e+01"
    [5] "   3.0000000e+01"

## Conclusions ##

`matlabr` isn’t fancy and most likely has some drawbacks as using `system` can have some quirks.  However, these functions have been helpful for me to use some [SPM][] routines and other MATLAB commands while remaining “within `R`“.  `R.matlab` has a better framework, but it may not be as straightforward for batch processing.  Also `matlabr` has some wrappers that will do a try-catch so that you don’t get stuck in MATLAB after calling `system`.

Let me know if this was helpful or if you have ideas on how to make this better.  Or better yet, give a [ pull request][pull request].

[A HopStat and Jump Away _ Rbloggers]: https://hopstat.wordpress.com/2015/04/08/matlabr-a-package-to-calling-matlab-from-r-with-system/
[R-bloggers]: http://www.r-bloggers.com/
[_R.matlab]: http://cran.r-project.org/web/packages/R.matlab/index.html
[RMatlab]: http://www.omegahat.org/RMatlab/
[Mandy Mejia wrote _THREE WAYS TO USE MATLAB FROM R]: https://mandymejia.wordpress.com/2014/08/18/three-ways-to-use-matlab-from-r/
[_matlabr]: https://github.com/muschellij2/matlabr
[try-catch]: http://www.mathworks.com/help/matlab/ref/try.html
[SPM]: http://www.fil.ion.ucl.ac.uk/spm/
[pull request]: https://github.com/muschellij2/matlabr/pulls