R: Creates matrix or array objects for use in nimbleFunctions

nimMatrix {nimble} | R Documentation

## Creates matrix or array objects for use in nimbleFunctions

### Description

In a `nimbleFunction`, `matrix` and `array` are identical to `nimMatrix` and `nimArray`, respectively

### Usage

    nimMatrix(value = 0, nrow = NA, ncol = NA, init = TRUE,
      fillZeros = TRUE, recycle = TRUE, type = "double")

    nimArray(value = 0, dim = c(1, 1), init = TRUE, fillZeros = TRUE,
      recycle = TRUE, nDim, type = "double")

### Arguments

`value` | value(s) for initialization (default = 0). This can be a vector, matrix or array, but it will be used as a vector.
`nrow` | the number of rows in a matrix (default = 1)
`ncol` | the number of columns in a matrix (default = 1)
`init` | logical, whether to initialize values (default = `TRUE`)
`fillZeros` | logical, whether to initialize any elements not filled by (possibly recycled) `value` with 0 (or `FALSE` for `nimLogical`) (default = `TRUE`)
`recycle` | logical, whether `value` should be recycled to fill the entire contents of the new object (default = `TRUE`)
`type` | character representing the data type, i.e. `'double'`, `'integer'`, or `'logical'` (default = `'double'`)
`dim` | vector of dimension sizes in an array (default = `c(1, 1)`)
`nDim` | number of dimensions in an array. This is only necessary for `compileNimble` if the length of `dim` cannot be determined during compilation.

### Details

These functions are similar to R's `matrix` and `array` functions, but they can be used in a nimbleFunction and compiled using `compileNimble`. Largely for compilation purposes, finer control is provided over initialization behavior, similarly to `nimNumeric`, `nimInteger`, and `nimLogical`. If `init = FALSE`, no initialization will be done, and `value`, `fillZeros` and `recycle` will be ignored. If `init=TRUE` and `recycle=TRUE`, then `fillZeros` will be ignored, and `value` will be repeated (according to R's recycling rule) as much as necessary to fill the object. If `init=TRUE` and `recycle=FALSE`, then if `fillZeros=TRUE`, values of 0 (or FALSE for `nimLogical`) will be filled in after `value`. Compiled code will be more efficient if unnecessary initialization is not done, but this may or may not be noticeable depending on the situation.

When used in a `nimbleFunction` (in `run` or other member function), `matrix` and `array` are immediately converted to `nimMatrix` and `nimArray`, respectively.

The `nDim` argument is only necessary for a use like `dim <- c(2, 3, 4); A <- nimArray(0, dim = dim, nDim = 3)`. It is necessary because the NIMBLE compiler must determine during compilation that `A` will be a 3-dimensional numeric array. However, the compiler doesn't know for sure what the length of `dim` will be at run time, only that it is a vector. On the other hand, `A <- nimArray(0, dim = c(2, 3, 4))` is allowed because the compiler can directly determine that a vector of length three is constructed inline for the `dim` argument.

### Author(s)

Daniel Turek and Perry de Valpine

### See Also

`nimNumeric` `nimInteger` `nimLogical`

[Package nimble version 0.9.1 Index]