You can also use REvaluate to make assignments. So you can, for example, do the following assignment to a global variable myint in the R workspace:

REvaluate can now be used to check the content of the newly created global variable myint:

The following assignment will return a function reference:

It may be used either on the R side (since this function was given a name in R):

Or on the Mathematica side:

To make assignments but suppress returning the result back to Mathematica, you can suppress the output by adding a semicolon at the end:

While you can handle multidimensional arrays with REvaluate just as easily as one-dimensional arrays, there are a few subtleties.

This will create a random one-dimensional array in R:

Since R stores arrays in column-major order, the previous result is not what you might have expected. But this is needed for consistency regarding array indexing:

To convert the array to row-major order (which is the order used by Mathematica), you can use Transpose:

For example:

The dimensions get reversed:

And the same for indexing for the converted array:

The above issues only show up for arrays created in R and then sent to Mathematica. If you create an array in Mathematica and then send it to R, it is automatically transformed to column-major order, and back to row-major order when you get it back from R. Therefore, in such cases, you get back the original array.

This creates an array in Mathematica:

Send it to R:

And get it from R:

As before, the indexing is consistent with that in Mathematica:

This means that you can send Mathematica arrays to R and continue working with them in R, just like you would in Mathematica.

As another example, consider matrix multiplication. First, construct a matrix in Mathematica:

Now send it to R, assigning it to a variable mmat in the R workspace:

This will perform the matrix multiplication:

It yields the same result as it would in Mathematica:

There is currently a one-directional support for special quantities such as NaNs and infinities of various kinds.

The following R input demonstrates how various quantities are translated into Mathematica. This is what you would get directly in the R console:

And in Mathematica:

In order to get a complex result when taking a square root of a negative number, that number must be entered manifestly as a complex number:

While getting such quantities from R to Mathematica is supported, the reverse is currently not:

Vectors and lists in R support missing points. In Mathematica, such points are represented by Missing[].

Here is a typical example for a vector:

And a list:

The action of most functions on missing elements is to produce another missing element. For example:

Missing points have a bidirectional support in RLink. For example, the following performs the same computation as the previous example, but with the data sent to R from Mathematica:

For a number of reasons described in the tutorial "Functions" on R functions, the following syntax is much preferred:

Here is an example of one possible implementation of the Mathematica Tuples function in R, returning tuples as data frames:

Here is how it can be used:

All objects in R can have one or several attributes. In RLink, R objects with generic attributes are represented on the Mathematica side by Mathematica expressions with the head RObject. Some aspects of this also affect REvaluate.

The following will construct a matrix in Mathematica, send it to R, and assign it to a variable myInt in the R workspace:

You can inspect the class of the resulting R object stored in a variable:

Attributes of any R object are stored in an R list. Objects of the class matrix have at least one attribute, "dim", which stores the information about dimensions (dimensions themselves are represented as an integer vector):

You can see that this list itself has attributes, in particular the attribute "names", and therefore it cannot be represented as just a Mathematica list, but has a head RObject. One shortcut to retrieve the value of a given attribute is to use the R attr function:

You can use REvaluate to perform non-trivial reshaping of your matrix on the R side by modifying its dim attribute. For example, you may convert the matrix into a three-dimensional array with dimensions {2,5,2}:

Which results in the following:

At some point, you may wish to add some new attributes to myInt, for example:

And now:

The dim attribute is implicit. You can always use RObject-based general representation, even for objects with no attributes: