Convenience functions
The main functions in this package are mat, dmat, and bmat and can be viewed as an extension to matrix; however, a number of convenience functions are also available, most of which are listed in Table~. Some of these functions appear in other R packages as well. Of particular note are the matlab and pracma packages.
| Function(s) | Description |
|---|---|
argmax, argmin |
Find the position of the maximum or minimum in each row or column of a matrix. |
eye |
Construct an identity matrix. |
hcat, vcat |
Concatenate matrices. |
fill, ones, zeros, trues, falses |
Fill a matrix or array with a particular value. |
flatten |
Flatten or collapse a matrix into one dimension. |
inv |
Compute the inverse of a square matrix. |
linspace, logspace |
Construct a vector of linearly-spaced or logarithmically-spaced elements. |
meshgrid |
Construct rectangular 2-D grids (useful for plotting). |
rand, randi, randn |
Construct a matrix or array of pseudorandom numbers. |
size, resize |
Extract or change the size and shape of a matrix or array. |
tr |
Compute the trace of a matrix. |
tri, tril, triu |
Construct or extract lower and upper triangular matrices. |
Although the functionality listed in Table~ can be accomplished in base R (though, not necessarily through a simple function), the ramify functions are simple and more familiar to most Julia, MATLAB/Octave, and Python+NumPy users; thus, making the transition to R easier. linspace and logspace are two such functions. For example, linspace(1+2i, 10+10i, 8) creates a vector of complex numbers with 8 evenly spaced points between 1+2i and 10+10i. In base R, we would use seq(1+2i, 10+10i, length = 8). There is no base R equivalent to logspace.
Another example is finding the trace of a matrix. To obtain the trace of a matrix in base R the user must manually sum the diagonal entries. Using the ramify function tr is simpler:
m <- rand(10, 10)
sum(diag(m)) # compute the trace in base R## [1] 5.211895tr(m) # compute the trace using ramify's tr function## [1] 5.211895The function is called tr, rather than trace, to avoid conflicts with a base R function called trace that is used for interactive tracing and debugging.
Many popular scientific languages also provide convenient ways to generate vectors and matrices of pseudo-random numbers. Commonly found functions are rand (for uniform random numbers) and randn (for normally distributed random numbers). These and more are available from ramify. We saw basic use of randn in the section describing the pprint function. The following snippet of code compares creating a \(100 \times 100 \times 2\) array of \(\mathcal{U}\left(0, 1\right)\) random deviates in both base R and ramify via the rand function.
a <- array(runif(20000), c(100, 100, 2)) # base R
a <- rand(100, 100, 2) # ramify
pprint(a[,,1]) # print the first matrix## 100 x 100 matrix of doubles:
##
## [,1] [,2] [,3] ... [,100]
## [1,] 0.3297376 0.6542253 0.0922442 ... 0.2079020
## [2,] 0.7626018 0.0176845 0.8700669 ... 0.3039885
## [3,] 0.3917442 0.6808564 0.0866955 ... 0.6346251
## ... ... ... ... ... ...
## [100,] 0.3540397 0.9553487 0.5778184 ... 0.5009529Of course, the base R approach is more flexible as it allows you to use any one of the built-in distributions (e.g., binomial), however, generating uniform (continuous or discrete) and normal random variates is far more common, hence, the popularity of the rand, randi, and randn functions often seen in other languages.
As seen in the previous example, many of the functions listed in Table~ can be used to construct vectors, matrices, or multi-way arrays just by specifying the extra dimensions. For example,
zeros(10) # 10x1 matrix (i.e., column vector) of zeros## [,1]
## [1,] 0
## [2,] 0
## [3,] 0
## [4,] 0
## [5,] 0
## [6,] 0
## [7,] 0
## [8,] 0
## [9,] 0
## [10,] 0ones(10, 10) # 10x10 matrix of ones## [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
## [1,] 1 1 1 1 1 1 1 1 1 1
## [2,] 1 1 1 1 1 1 1 1 1 1
## [3,] 1 1 1 1 1 1 1 1 1 1
## [4,] 1 1 1 1 1 1 1 1 1 1
## [5,] 1 1 1 1 1 1 1 1 1 1
## [6,] 1 1 1 1 1 1 1 1 1 1
## [7,] 1 1 1 1 1 1 1 1 1 1
## [8,] 1 1 1 1 1 1 1 1 1 1
## [9,] 1 1 1 1 1 1 1 1 1 1
## [10,] 1 1 1 1 1 1 1 1 1 1# fill(pi, 10, 10, 3) # 10x10x3 array filled with the constant piNote that these functions, by default, always return a "matrix" or "array" object meaning there is always a "dim" attribute. In contrast, in base R, vectors do not have a "dim" attribute. So, when creating a vector using zeros(10), for example, the result will be a matrix of zeros with ten rows and one column. To bypass this behavior, you can use the atleast_2d option:
zeros(10, atleast_2d = FALSE) # has class "integer", rather than "matrix"## [1] 0 0 0 0 0 0 0 0 0 0This behavior can also be changed globally using options(atleast_2d = FALSE).
As a last example, we shal demonstrate the meshgrid function. A meshgrid function is available in MATLAB/Octave and Python+NumPy and is most frequently used to produce input for a 2-D or 3-D function that will be plotted. It should be noted, however, that the R version of meshgrid provided by ramify returns a list of matrices. The following code, for example, plots contours of the function \[
y = \cos{\left(x_1^2 + x_2^2\right)} \times \exp\left(-\frac{\sqrt{x_1^2 + x_2^2}}{6}\right)
\] over the Cartesian grid \(\left[-4\pi, 4\pi\right] \times \left[-4\pi, 4\pi\right]\). The resulting plot is created as follows.
x <- meshgrid(linspace(-4*pi, 4*pi, 27)) # list of input matrices
y <- cos(x[[1]]^2 + x[[2]]^2) * exp(-sqrt(x[[1]]^2 + x[[2]]^2)/6)
par(mar = c(0, 0, 0, 0)) # remove margins
image(y, axes = FALSE) # color image
contour(y, add = TRUE, drawlabels = FALSE) # add contour lines
Color image and contour lines for \(y\).