This vignette is adapted from the official Armadillo documentation.

Function/Variable	Description
`.n_rows`	number of rows
`.n_cols`	number of columns
`.n_elem`	number of elements
`.n_slices`	number of slices
`()`	element access
`[]`	element access
`.at()`	element access
`.zeros`	set all elements to zero
`.ones`	set all elements to one
`.eye`	set elements along main diagonal to one and off-diagonal elements to zero
`.randu`	set all elements to random values from a uniform distribution
`.randn`	set all elements to random values from a normal distribution
`.fill`	set all elements to specified value
`.imbue`	imbue (fill) with values provided by functor or lambda function
`.clean`	replace elements below a threshold with zeros
`.replace`	replace specific elements with a new value
`.clamp`	clamp values to lower and upper limits
`.transform`	transform each element via functor or lambda function
`.for_each`	apply a functor or lambda function to each element
`.set_size`	change size without keeping elements (fast)
`.reshape`	change size while keeping elements
`.resize`	change size while keeping elements and preserving layout
`.copy_size`	change size to be same as given object
`.reset`	change size to empty
`.diag`	read/write access to matrix diagonals
`.each_col`	vector operations applied to each column of matrix (aka “broadcasting”)
`.each_row`	vector operations applied to each row of matrix (aka “broadcasting”)
`.each_slice`	matrix operations applied to each slice of cube (aka “broadcasting”)
`.set_imag`	set imaginary part
`.set_real`	set real part
`.insert_rows`	insert vector/matrix/cube at specified row
`.insert_cols`	insert vector/matrix/cube at specified column
`.insert_slices`	insert vector/matrix/cube at specified slice
`.shed_rows`	remove specified rows
`.shed_cols`	remove specified columns
`.shed_slices`	remove specified slices
`.swap_rows`	swap specified rows
`.swap_cols`	swap specified columns
`.swap`	swap contents with given object
`.memptr`	raw pointer to memory
`.colptr`	raw pointer to memory used by specified column
`.as_col`	return flattened matrix column as column vector
`.as_row`	return flattened matrix row as row vector
`.col_as_mat`	return matrix representation of cube column
`.row_as_mat`	return matrix representation of cube row
`.as_dense`	return dense vector/matrix representation of sparse matrix expression
`.t`	return matrix transpose
`.st`	return matrix conjugate transpose
`.i`	return inverse of square matrix
`.min`	return minimum value
`.max`	return maximum value
`.index_min`	return index of minimum value
`.index_max`	return index of maximum value
`.eval`	force evaluation of delayed expression
`.in_range`	check whether given location or span is valid
`.is_empty`	check whether object is empty
`.is_vec`	check whether matrix is a vector
`.is_sorted`	check whether vector or matrix is sorted
`.is_trimatu`	check whether matrix is upper triangular
`.is_trimatl`	check whether matrix is lower triangular
`.is_diagmat`	check whether matrix is diagonal
`.is_square`	check whether matrix is square sized
`.is_symmetric`	check whether matrix is symmetric
`.is_hermitian`	check whether matrix is hermitian
`.is_sympd`	check whether matrix is symmetric/hermitian positive definite
`.is_zero`	check whether all elements are zero
`.is_finite`	check whether all elements are finite
`.has_inf`	check whether any element is +/- infinity
`.has_nan`	check whether any element is NaN

Attributes

n_* provides information for different objects:

.n_rows number of rows for Mat, Col, Row, Cube, field, and SpMat.
.n_cols number of columns for Mat, Col, Row, Cube, field, and SpMat.
.n_elem total number of elements for Mat, Col, Row, Cube, field, and SpMat.
.n_slices number of slices for Cube and field.
.n_nonzero number of non-zero elements for SpMat.

For the Col and Row classes, n_elem also indicates vector length.

The variables are read-only and of type uword. To change the size, use set_size, copy_size, zeros_member, ones_member, or reset.

To avoid compiler warnings about implicit conversion when operating uword with integers/doubles to pass data to R, converte uword to int with static_cast<int> or declare these as int.

Examples

a <- matrix(runif(4), nrow = 2, ncol = 2)

[[cpp11::register]] integers attr1_(const doubles_matrix<>& a) {
  mat A = as_Mat(a);  // convert from R to C++

  // uword or int can be used
  int n_rows = A.n_rows;  // number of rows
  int n_cols = A.n_cols;  // number of columns
  int n_elem = A.n_elem;  // number of elements

  writable::integers res({n_rows, n_cols, n_elem});
  res.attr("names") = strings({"n_rows", "n_cols", "n_elem"});

  return res;
}

Element/object access

Provide access to individual elements or objects stored in a container object (e.g., Mat, Col, Row, Cube, field).

(i) For vec and rowvec, access the element stored at index i. For Mat, Cube and field, access the element/object stored at index i under the assumption of a flat layout, with column-major ordering of data (e.g., column by column). An exception is thrown if the requested element is out of bounds.
.at(i) or [i] As for (i), but without a bounds check. Not recommended.
(r,c) For Mat and 2D field classes, access the element/object stored at row r and column c. An exception is thrown if the requested element is out of bounds.
.at(r,c) As for (r,c), but without a bounds check. Not recommended.
(r,c,s) For Cube and 3D field classes, access the element/object stored at row r, column c, and slice s. An exception is thrown if the requested element is out of bounds.
.at(r,c,s) As for (r,c,s), but without a bounds check. Not recommended.

Examples

a <- matrix(runif(4), nrow = 2, ncol = 2)

[[cpp11::register]] doubles_matrix<> access1_(const doubles_matrix<>& a) {
  mat A = as_Mat(a);  // convert from R to C++
  A(1,1) = 123.0;     // set element at row 2, column 2

  vec B(2, fill::randu);

  double x = A(0,1);  // copy element at row 1, column 2 to a double
  double y = B(1);    // copy element at coordinate 2 to a double

  uword i, j; // int also works
  uword N = A.n_rows;
  uword M = A.n_cols;

  for(i = 0; i < N; ++i) {
    for(j = 0; j < M; ++j) {
      A(i,j) = A(i,j) + x + y;
    }
  }

  return as_doubles_matrix(A);  // convert from C++ to R
}

Caveats

For .at() or [i], .at(r,c) and .at(r,c,s):

Indexing in C++ starts at 0
Accessing elements without bounds checks is slightly faster, but is not recommended until your code has been thoroughly debugged first
Accessing elements via [r,c] and [r,c,s] does not work correctly in C++; instead use (r,c) and (r,c,s)

The indices of elements are specified via the uword type, which is a typedef for an unsigned integer type. When using loops to access elements, it more efficient to use uword instead of int.

Element initialisation

Set elements in Mat, Col and Row via braced initialiser lists.

Examples

a <- matrix(runif(4), nrow = 2, ncol = 2)

[[cpp11::register]] doubles_matrix<> initialization1_(const doubles_matrix<>& a) {
  mat A = as_Mat(a);  // convert from R to C++
  mat B = {{1, 2}, {3, 4}}; // create new matrix
  vec C = {1, 2}; // create new column vector

  // sum C to the diagonal of A
  A(0,0) = A(0,0) + C(0);
  A(1,1) = A(1,1) + C(1);

  mat D = A + B;
  
  return as_doubles_matrix(D);  // convert from C++ to R
}

Zeros

Set the elements of an object to zero, optionally first changing the size to specified dimensions.

.zeros() (member function of Mat, Col, Row, SpMat, Cube) .zeros(n_elem) (member function of Col and Row) .zeros(n_rows, n_cols) (member function of Mat and SpMat) .zeros(n_rows, n_cols, n_slices) (member function of Cube) .zeros(size(X)) (member function of Mat, Col, Row, Cube, SpMat)

Examples

a <- matrix(runif(4), nrow = 2, ncol = 2)

[[cpp11::register]] doubles_matrix<> zeros1_(const doubles_matrix<>& a) {
  mat A = as_Mat(a);  // convert from R to C++
  A.zeros();          // set all elements to zero

  mat B;
  B.zeros(size(A)); // set size to be the same as A and set all elements to zero

  mat C(A.n_rows, A.n_cols, fill::zeros);

  mat D = A + B + C;

  return as_doubles_matrix(D);  // convert from C++ to R
}

Ones

Set all the elements of an object to one, optionally first changing the size to specified dimensions.

Function	Mat	Col	Row	Cube
`.ones()`	✓	✓	✓	✓
`.ones(n_elem)`		✓	✓
`.ones(n_rows, n_cols)`	✓
`.ones(n_rows, n_cols, n_slices)`				✓
`.ones(size(X))`	✓	✓	✓	✓

Examples

a <- matrix(runif(4), nrow = 2, ncol = 2)

[[cpp11::register]] doubles_matrix<> ones1_(const doubles_matrix<>& a) {
  mat A = as_Mat(a);  // convert from R to C++
  A.ones();          // set all elements to zero

  mat B;
  B.ones(size(A)); // set size to be the same as A and set all elements to zero

  mat C(A.n_rows, A.n_cols, fill::ones);

  mat D = A + B + C;

  return as_doubles_matrix(D);  // convert from C++ to R
}

Eye

.eye() is member function of Mat and SpMat. .eye(n_rows, n_cols) sets the elements along the main diagonal to one and off-diagonal elements to zero, optionally first changing the size to specified dimensions. .eye(size(X)) creates an identity matrix is generated when n_rows = n_cols.

Examples

a <- matrix(runif(4), nrow = 2, ncol = 2)

[[cpp11::register]] doubles_matrix<> eye1_(const doubles_matrix<>& a) {
  mat A = as_Mat(a);  // convert from R to C++
  A.eye();            // create an identity matrix

  mat B;
  B.eye(size(A)); // another identity matrix

  uword N = A.n_rows;
  uword M = A.n_cols;
  mat C(N, M, fill::randu);
  C.eye(N, M); // yet another identity matrix

  mat D = A + B + C;

  return as_doubles_matrix(D);  // convert from C++ to R
}

Random uniform

Set all the elements to random values from a uniform distribution in the [0,1] interval, optionally first changing the size to specified dimensions.

For complex elements, the real and imaginary parts are treated separately.

Function/Method	Mat	Col	Row	Cube
`.randu()`	✓	✓	✓	✓
`.randu(n_elem)`		✓	✓
`.randu(n_rows, n_cols)`	✓
`.randu(n_rows, n_cols, n_slices)`				✓
`.randu(size(X))`	✓	✓	✓	✓

a <- matrix(runif(4), nrow = 2, ncol = 2)

[[cpp11::register]] doubles_matrix<> randu1_(const doubles_matrix<>& a) {
  mat A = as_Mat(a);  // convert from R to C++

  mat B;
  B.randu(size(A)); // random uniform matrix with the same size as A

  mat C(A.n_rows, A.n_cols, fill::randu);

  mat D = A + B + C;

  return as_doubles_matrix(D);  // convert from C++ to R
}

[[cpp11::register]] doubles_matrix<> randu2_(const int& n) {
  GetRNGstate();  // Ensure R's RNG state is synchronized
  mat y(n, n);
  ::arma_rng::randu<double>::fill(y.memptr(), y.n_elem);
  PutRNGstate();

  return as_doubles_matrix(y);
}

Normal distribution

Set all the elements to random values from a normal distribution with zero mean and unit variance, optionally first changing the size to specified dimensions.

For complex elements, the real and imaginary parts are treated separately.

Function/Method	Mat	Col	Row	Cube
`.randn()`	✓	✓	✓	✓
`.randn(n_elem)`		✓	✓
`.randn(n_rows, n_cols)`	✓
`.randn(n_rows, n_cols, n_slices)`				✓
`.randn(size(X))`	✓	✓	✓	✓

Examples

a <- matrix(runif(4), nrow = 2, ncol = 2)

[[cpp11::register]] doubles_matrix<> randn1_(const doubles_matrix<>& a) {
  mat A = as_Mat(a);  // convert from R to C++

  mat B;
  B.randn(size(A)); // random normal matrix with the same size as A

  mat C(A.n_rows, A.n_cols, fill::randn);

  mat D = A + B + C;

  return as_doubles_matrix(D);  // convert from C++ to R
}

[[cpp11::register]] doubles_matrix<> randn2_(const int& n) {
  GetRNGstate();  // Ensure R's RNG state is synchronized
  mat y(n, n);
  ::arma_rng::randn<double>::fill(y.memptr(), y.n_elem);
  PutRNGstate();
  
  return as_doubles_matrix(y);
}

Fill

Sets the elements to a specified value

.fill(value) is a member function of Mat, Col, Row, Cube, field.

The type of value must match the type of elements used by the container object (e.g., for Mat the type is double)

Examples

a <- matrix(runif(4), nrow = 2, ncol = 2)

[[cpp11::register]] doubles_matrix<> fill1_(const doubles_matrix<>& a) {
  mat A = as_Mat(a);  // convert from R to C++

  uword N = A.n_rows;
  uword M = A.n_cols;

  mat B(size(A), fill::value(200.0));  // create a matrix filled with 200.0
  mat C(N, M, fill::value(100.0));     // matrix filled with 100.0
  mat D(N, M, fill::zeros);            // matrix filled with zeros
  mat E(N, M, fill::ones);             // matrix filled with ones

  mat F = A + B + C + D + E;

  return as_doubles_matrix(F);  // convert from C++ to R
}

Imbue

.imbue(functor) is a member function of Mat, Col, Row and Cube, it fills the elements with values provided by a functor. The argument can be a functor or lambda function.

For matrices, filling is done column-by-column (e.g., column 0 is filled, then column 1, etc.)

For cubes, filling is done slice-by-slice, with each slice treated as a matrix

Examples

a <- matrix(runif(4), nrow = 2, ncol = 2)

[[cpp11::register]] doubles_matrix<> imbue1_(const doubles_matrix<>& a) {
  mat A = as_Mat(a);  // convert from R to C++

  std::mt19937 engine;  // Mersenne twister random number engine
  std::uniform_real_distribution<double> distr(0.0, 1.0);

  mat B(size(A), fill::none);                // create an empty matrix
  B.imbue([&]() { return distr(engine); });  // fill with random values

  mat C = A + B;

  return as_doubles_matrix(C);  // convert from C++ to R
}

[[cpp11::register]] doubles_matrix<> imbue2_(const doubles_matrix<>& a) {
  GetRNGstate();  // Ensure R's RNG state is synchronized

  mat A = as_Mat(a);  // Convert from R to C++

  mat B(size(A), fill::none);  // Create an empty matrix
  B.imbue([]() { return unif_rand(); });  // Fill with random values

  mat C = A + B;

  PutRNGstate();

  return as_doubles_matrix(C);  // Convert from C++ to R
}

Clean

.clean(threshold) is a member function of Mat, Col, Row, Cube, and SpMat. It can be used to sparsify a matrix, in the sense of zeroing values with small magnitudes.

For objects with non-complex elements: each element with an absolute value less or equal to the threshold is replaced by zero.
For objects with complex elements: for each element, each component (real and imaginary) with an absolute value less or equal to the threshold is replaced by zero.

Examples

[[cpp11::register]] doubles_matrix<> clean1_(const int& n) {
  mat A(n, n, fill::randu); // create a random matrix

  A(0, 0) = datum::eps; // set the diagonal with small values (+/- epsilon)
  A(1, 1) = -datum::eps;

  A.clean(datum::eps); // set elements with small values to zero

  return as_doubles_matrix(A); // Convert from C++ to R
}

Caveat

To explicitly convert from dense storage to sparse storage, use the SpMat.

Replace

.replace( old_value, new_value ) is a member function of Mat, Col, Row, Cube, and SpMat.

For all elements equal to old_value, set them to new_value.

Examples

[[cpp11::register]] doubles_matrix<> replace1_(const int& n) {
  mat A(n, n, fill::randu); // create a random matrix

  A.diag().fill(datum::nan); // set the diagonal with NaN values
  A.replace(datum::nan, 0);  // replace each NaN with 0

  return as_doubles_matrix(A); // Convert from C++ to R
}

Caveats

The type of old_value and new_value must match the type of elements used by the container object (e.g., for Mat the type is double).
Floating point numbers (float and double) are approximations due to their limited precision.
For sparse matrices (SpMat), replacement is not done when old_value = 0.

Clamp

.clamp(min_value, max_value) is a member function of Mat, Col, Row, Cube and SpMat that transforms all values lower than min_val to min_val, and all values higher than max_val to max_val.

For complex elements, the real and imaginary components are clamped separately.
For sparse matrices, clamping is applied only to the non-zero elements.

Examples

[[cpp11::register]] doubles_matrix<> clamp1_(const int& n) {
  mat A(n, n, fill::randu); // create a random matrix
  A.diag().fill(0.1);       // set the diagonal with 0.1 values

  A.clamp(0.2, 0.8); // clamp values to the [0.2, 0.8] interval

  return as_doubles_matrix(A); // Convert from C++ to R
}

Transform

.transform(functor) is a member function of Mat, Col, Row, Cube, and SpMat. The argument can be a functor or lambda function.

For dense matrices, transformation is done column-by-column for all elements.
For sparse matrices, transformation is done column-by-column for non-zero elements.
For cubes, transformation is done slice-by-slice, with each slice treated as a matrix.

Examples

[[cpp11::register]] doubles_matrix<> transform1_(const int& n) {
  mat A(n, n, fill::ones);  // create a matrix filled with ones
  A.transform([](double val) { return (val + 122.0); });
  return as_doubles_matrix(A); // Convert from C++ to R
}

For each

.for_each(functor) is a member function of Mat, Col, Row, Cube, SpMat, and field. The argument can be a functor or lambda function.

For dense matrices and fields, the processing is done column-by-column for all elements.
For sparse matrices, the processing is done column-by-column for non-zero elements.
For cubes, processing is done slice-by-slice, with each slice treated as a matrix.

Examples

[[cpp11::register]] doubles_matrix<> for_each1_(const int& n) {
  // add 122 to each element in a dense matrix, the '&' is important
  mat D(n, n, fill::ones);
  D.for_each([](mat::elem_type& val) { val += 122.0; });

  // add 122 to each non-zero element in a sparse matrix
  sp_mat S;
  S.sprandu(n, n, 1.0);
  S.for_each([](sp_mat::elem_type& val) { val += 123.0; });

  // set the size of all matrices in a field
  field<mat> F(2, 2);
  F.for_each([n](mat& X) { X.zeros(n, n); });  // capture n for the lambda

  mat res = D + S + F(0) + F(1);

  return as_doubles_matrix(res);  // Convert from C++ to R
}

Set size

Change the size of an object, without explicitly preserving data and without initialising the elements (e.g., elements may contain garbage values, including NaN).

.set_size(n_elem) (member function of Col, Row, field)
.set_size(n_rows, n_cols) (member function of Mat, SpMat, field)
.set_size(n_rows, n_cols, n_slices) (member function of Cube and field)
.set_size(size(X)) (member function of Mat, Col, Row, Cube, SpMat, field)

To initialise the elements to zero while changing the size, use .zeros() instead. To explicitly preserve data while changing the size, use .reshape() or .resize() instead.

Examples

[[cpp11::register]] doubles set_size1_(const int& n) {
  mat A;
  A.set_size(n, n);  // or:  mat A(n, n, fill::none);

  mat B;
  B.set_size(size(A));  // or:  mat B(size(A), fill::none);

  vec C;
  C.set_size(n);  // or:  vec v(n, fill::none);

  A.fill(1.0);  // set all elements to 1.0
  B.fill(2.0);  // set all elements to 2.0
  C.fill(3.0);  // set all elements to 3.0

  vec res = A.col(0) + B.col(1) + C;

  return as_doubles(res);  // Convert from C++ to R
}

Reshape

Recreate an object according to given size specifications, with the elements taken from the previous version of the object in a column-wise manner. The elements in the generated object are placed column-wise (e.g., the first column is filled up before filling the second column)

.reshape(n_rows, n_cols) (member function of Mat and SpMat)
.reshape(n_rows, n_cols, n_slices) (member function of Cube)
.reshape(size(X)) (member function of Mat, Cube, SpMat)

The layout of the elements in the recreated object will be different to the layout in the previous version of the object

If the total number of elements in the previous version of the object is less than the specified size, the extra elements in the recreated object are set to zero

If the total number of elements in the previous version of the object is greater than the specified size, only a subset of the elements is taken

Examples

[[cpp11::register]] doubles_matrix<> reshape1_(const int& n) {
  mat A(n + 1, n - 1, fill::randu);
  A.reshape(n - 1, n + 1);
  return as_doubles_matrix(A);  // Convert from C++ to R
}

Caveats

.reshape() is considerably slower than .set_size().
To change the size without preserving data, use .set_size().
To grow/shrink the object while preserving the elements and the layout of the elements, use .resize()
To flatten a matrix into a vector, use vectorise() or .as_col()/.as_row().

Resize

Resize an object according to given size specifications, while preserving the elements and the layout of the elements. It can be used for growing or shrinking an object (e.g., adding/removing rows, and/or columns, and/or slices).

.resize(n_elem): member function of Col, Row.
.resize(n_rows, n_cols): member function of Mat and SpMat.
.resize(n_rows, n_cols, n_slices): member function of Cube.
.resize(size(X)): member function of Mat, Col, Row, Cube, SpMat.

Examples

[[cpp11::register]] doubles_matrix<> resize1_(const int& n) {
  mat A(n + 1, n - 1, fill::randu);
  A.resize(n - 1, n + 1);
  return as_doubles_matrix(A);  // Convert from C++ to R
}

Caveats

.resize() is considerably slower than .set_size().
to change the size without preserving data, .set_size() instead.

Copy size

.copy_size(A) sets the size of a matrix/vector/cube to be the same as matrix/vector/cube A.

Examples

[[cpp11::register]] integers copy_size1_(const int& n) {
  mat A(n, n, fill::randu);

  mat B;
  B.copy_size(A);

  int N = B.n_rows;
  int M = B.n_cols;
  
  writable::integers res({N, M});
  res.attr("names") = strings({"n_rows", "n_cols"});

  return as_integers(res);  // Convert from C++ to R
}

Caveat

To set the size of an object B, A must be of the same type as B. For example, the size of a matrix cannot be set by providing a cube.

Reset

.reset() sets a matrix/vector size to zero (the object will have no elements).

Examples

[[cpp11::register]] integers reset1_(const int& n) {
  mat A(n, n, fill::randu);
  A.reset();

  int N = A.n_rows;
  int M = A.n_cols;
  
  writable::integers res({N, M});
  res.attr("names") = strings({"n_rows", "n_cols"});

  return as_integers(res);  // Convert from C++ to R
}

Submatrix views

A collection of member functions of Mat, Col and Row classes that provide read/write access to submatrix views.

Contiguous views for matrix

X.col(col_number)
X.row(row_number)
X.cols(first_col, last_col)
X.rows(first_row, last_row)
X.submat(first_row, first_col, last_row, last_col)
X(span(first_row, last_row), span(first_col, last_col))
X(first_row, first_col, size(n_rows, n_cols))
X(first_row, first_col, size(Y)) (Y is a matrix)
X(span(first_row, last_row), col_number)
X(row_number, span(first_col, last_col))
X.head_cols(number_of_cols)
X.head_rows(number_of_rows)
X.tail_cols(number_of_cols)
X.tail_rows(number_of_rows)
X.unsafe_col(col_number) (use with caution)

Contiguous views for vector

Y(span(first_index, last_index))
Y.subvec(first_index, last_index)
Y.subvec(first_index, size(X)) (X is a vector)
Y.head(number_of_elements)
Y.tail(number_of_elements)

Non-contiguous views for matrix or vector:

X.elem(vector_of_indices)
X(vector_of_indices)
X.cols(vector_of_column_indices)
X.rows(vector_of_row_indices)
X.submat(vector_of_row_indices, vector_of_column_indices)
X(vector_of_row_indices, vector_of_column_indices)

Instances of span(start, end) can be replaced by span::all_ to indicate the entire range.

For functions requiring one or more vector of indices, for example X.submat(vector_of_row_indices, vector_of_column_indices), each vector of indices must be of type uvec.

In the function X.elem(vector_of_indices), elements specified in vector_of_indices are accessed. X is interpreted as one long vector, with column-by-column ordering of the elements of X. The vector_of_indices must evaluate to a vector of type uvec (e.g., generated by the find() function). The aggregate set of the specified elements is treated as a column vector (e.g., the output of X.elem() is always a column vector).

The function .unsafe_col() is provided for speed reasons and should be used only if you know what you are doing. It creates a seemingly independent Col vector object (e.g., vec), but uses memory from the existing matrix object. As such, the created vector is not alias safe, and does not take into account that the underlying matrix memory could be freed (e.g., due to any operation involving a size change of the matrix).

Examples

[[cpp11::register]] doubles_matrix<> subview1_(const int& n) {
  mat A(n, n, fill::zeros);

  A.submat(0,1,2,3) = randu<mat>(3,3);
  A(span(0,2), span(1,3)) = randu<mat>(3,3);
  A(0,1, size(3,3)) = randu<mat>(3,3);

  mat B = A.submat(0,1,2,3);
  mat C = A(span(0,2), span(1,3) );
  mat D = A(0, 1, size(3,3) );

  A.col(1) = randu<mat>(5,1);
  A(span::all, 1) = randu<mat>(5,1);

  mat X(5, 5, fill::randu);
    
  // get all elements of X that are greater than 0.5
  vec q = X.elem( find(X > 0.5) );
    
  // add 123 to all elements of X greater than 0.5
  X.elem( find(X > 0.5) ) += 123.0;
    
  // set four specific elements of X to 1
  uvec indices = { 2, 3, 6, 8 };
    
  X.elem(indices) = ones<vec>(4);
    
  // add 123 to the last 5 elements of vector a
  vec a(10, fill::randu);
  a.tail(5) += 123.0;
    
  // add 123 to the first 3 elements of column 2 of X
  X.col(2).head(3) += 123;

  return as_doubles_matrix(X);  // Convert from C++ to R
}

Subcube views and slices

A collection of member functions of the Cube class that provide subcube views.

Contiguous views for cube

Q.slice(slice_number)
Q.slices(first_slice, last_slice)
Q.row(row_number)
Q.rows(first_row, last_row)
Q.col(col_number)
Q.cols(first_col, last_col)
Q.subcube( first_row, first_col, first_slice, last_row, last_col, last_slice)
Q(span(first_row, last_row), span(first_col, last_col), span(first_slice, last_slice))
Q(first_row, first_col, first_slice, size(n_rows, n_cols, n_slices))
Q(first_row, first_col, first_slice, size(R)) (R is a cube)
Q.head_slices(number_of_slices)
Q.tail_slices(number_of_slices)
Q.tube(row, col)
Q.tube(first_row, first_col, last_row, last_col)
Q.tube(span(first_row, last_row), span(first_col, last_col))
Q.tube(first_row, first_col, size(n_rows, n_cols))

Non-contiguous views for cube

Q.elem(vector_of_indices), Q(vector_of_indices), and Q.slices( vector_of_slice_indices) are instances of span(a,b) that can be replaced by:

span() or span::all, to indicate the entire range.
span(a), to indicate a particular row, column or slice.

An individual slice, accessed via .slice(), is an instance of the Mat class (a reference to a matrix is provided).

All .tube() forms are variants of .subcube(), using first_slice = 0 and last_slice = Q.n_slices-1. The .tube(row,col) form uses row = first_row = last_row, and col = first_col = last_col.

In the function Q.elem(vector_of_indices), elements specified in vector_of_indices are accessed. Q is interpreted as one long vector, with slice-by-slice and column-by-column ordering of the elements of Q. The vector_of_indices must evaluate to a vector of type uvec (e.g., generated by the find() function). The aggregate set of the specified elements is treated as a column vector (e.g., the output of Q.elem() is always a column vector).

In the function Q.slices(vector_of_slice_indices), slices specified in vector_of_slice_indices are accessed. The vector_of_slice_indices must evaluate to a vector of type uvec.

Examples

[[cpp11::register]] doubles_matrix<> subview2_(const int& n) {
  cube A(n, 3, 4, fill::randu);
    
  mat B = A.slice(1); // each slice is a matrix
    
  A.slice(0) = randu<mat>(2,3);
  A.slice(0)(1,2) = 99.0;
    
  A.subcube(0,0,1,  1,1,2)           = randu<cube>(2,2,2);
  A(span(0,1), span(0,1), span(1,2)) = randu<cube>(2,2,2);
  A(0,0,1, size(2,2,2))              = randu<cube>(2,2,2);
    
  // add 123 to all elements of A greater than 0.5
  A.elem( find(A > 0.5) ) += 123.0;
    
  cube C = A.head_slices(2);  // get first two slices
    
  A.head_slices(2) += 123.0;

  mat res = A.slice(0) + B + C.slice(1);

  return as_doubles_matrix(res);  // Convert from C++ to R
}

Subfield views

A collection of member functions of the field class that provide subfield views.

For a 2D field F, the subfields are accessed as:

F.row(row_number)
F.col(col_number)
F.rows(first_row, last_row)
F.cols(first_col, last_col)
F.subfield(first_row, first_col, last_row, last_col)
F(span(first_row, last_row), span(first_col, last_col))
F(first_row, first_col, size(G)) (G is a 2D field)
F(first_row, first_col, size(n_rows, n_cols))

For a 3D field F, the subfields are accessed as:

F.slice(slice_number)
F.slices(first_slice, last_slice)
F.subfield(first_row, first_col, first_slice, last_row, last_col, last_slice)
F(span(first_row, last_row), span(first_col, last_col), span(first_slice, last_slice))
F(first_row, first_col, first_slice, size(G)) (G is a 3D field)
F(first_row, first_col, first_slice, size(n_rows, n_cols, n_slices))

Instances of span(a,b) can be replaced by:

span() or span::all, to indicate the entire range.
span(a), to indicate a particular row or column.

Diagonal

.diag() is a member functions of Mat and SpMat with read/write access to the diagonal in a matrix. The argument can be empty or a value k to specify the diagonal to (k = 0 by default). The diagonal is interpreted as a column vector within expressions.

k = 0 indicates the main diagonal (default setting)
k < 0 indicates the k-th sub-diagonal (below main diagonal, towards bottom-left corner)
k > 0 indicates the k-th super-diagonal (above main diagonal, towards top-right corner)

Examples

[[cpp11::register]] doubles diagonal1_(const int& n) {
  mat X(n, n, fill::randu);

  vec A = X.diag(); // extract the main diagonal
  double B = accu(X.diag(1)); // sum of elements on the first upper diagonal
  double C = accu(X.diag(-1)); // sum of elements on the first lower diagonal

  X.diag() = randu<vec>(n);
  X.diag() += A;
  X.diag() /= B;
  X.diag() *= C;

  sp_mat S = sprandu<sp_mat>(n, n, 0.0);
  S.diag().ones();

  vec v(S.diag());  // copy sparse diagonal to dense vector
  v += X.diag();

  return as_doubles(v);  // Convert from C++ to R
}

Caveat

To calculate only the diagonal elements of a compound expression, use diagvec() or diagmat().

Each col

.each_col() is a member function of Mat. It applies a vector operation to each column of a matrix, and are similar to “broadcasting” in Matlab/Octave. The argument can be empty, a vector of indices, or a lambda function.

Operation	`.each_col()`	`.each_col(vector_of_indices)`	`.each_col(lambda)`
`+` addition	✓	✓
`+=` in-place addition	✓	✓
`-` subtraction	✓	✓
`-=` in-place subtraction	✓	✓
`%` element-wise multiplication	✓	✓
`%=` in-place element-wise multiplication	✓	✓
`/` element-wise division	✓	✓
`/=` in-place element-wise division	✓	✓
`=` assignment (copy)	✓	✓
`lambda` (lambda function)			✓

Examples

[[cpp11::register]] doubles_matrix<> each_col1_(const int& n) {
  mat X(n, n + 1, fill::ones);

  // create a vector with n elements ranging from 5 to 10
  vec v = linspace<vec>(5, 10, n);

  // in-place addition of v to each column vector of X
  X.each_col() += v;

  // generate Y by adding v to each column vector of X
  mat Y = X.each_col() + v;

  // subtract v from columns 1 and 2 of X
  X.cols(0, 1).each_col() -= v;

  uvec indices(2);
  indices(0) = 1;
  indices(1) = 2;

  X.each_col(indices) = v;  // copy v to columns 1 and 2 of X

  // lambda function with non-const vector
  X.each_col([](vec& a) { 2 * a; });

  const mat& XX = X;

  // lambda function with const vector
  XX.each_col([](const vec& b) { 3 * b; });

  mat res = X + Y + XX;

  return as_doubles_matrix(res);  // Convert from C++ to R
}

Each row

.each_row(), .each_row(vector_of_indices), .each_row(lambdaction) are member functions of Mat. These apply a vector operation to each row of a matrix, and are similar to “broadcasting” in Matlab/Octave.

Form 1

.each_row() supports the following operations:

+ addition
+= in-place addition
- subtraction
-= in-place subtraction
% element-wise multiplication
%= in-place element-wise multiplication
/ element-wise division
/= in-place element-wise division
= assignment (copy)

Form 2

.each_row(vector_of_indices) supports the same operations as form 1. The argument vector_of_indices contains a list of indices of the rows to be used, and it must evaluate to a vector of type uvec.

Form 3

.each_col(lambdaction) applies the given lambdaction to each column vector. The function must accept a reference to a Row object with the same element type as the underlying matrix.

Examples

[[cpp11::register]] doubles_matrix<> each_row1_(const int& n) {
  mat X(n + 1, n, fill::ones);

  // create a vector with n elements ranging from 5 to 10
  rowvec v = linspace<rowvec>(5, 10, n);

  // in-place addition of v to each rows vector of X
  X.each_row() += v;

  // generate Y by adding v to each rows vector of X
  mat Y = X.each_row() + v;

  // subtract v from rows 1 and 2 of X
  X.rows(0, 1).each_row() -= v;

  uvec indices(2);
  indices(0) = 1;
  indices(1) = 2;

  X.each_row(indices) = v;       // copy v to columns 1 and 2 of X

  // lambda function with non-const vector
  X.each_row([](rowvec& a) { a / 2; });

  const mat& XX = X;

  // lambda function with const vector
  XX.each_row([](const rowvec& b) { b / 3; });

  mat res = X + Y + XX;

  return as_doubles_matrix(res);  // Convert from C++ to R
}

Each slice

.each_slice() is a member function of Cube that applies a matrix operation to each slice of a cube, with each slice treated as a matrix. It is similar to “broadcasting” in Matlab/Octave.

Form 1

.each_slice(vector_of_indices)

Supported operations:

+ addition
+= in-place addition
- subtraction
-= in-place subtraction
% element-wise multiplication
%= in-place element-wise multiplication
/ element-wise division
/= in-place element-wise division
* matrix multiplication
*= in-place matrix multiplication
= assignment (copy)

Form 2

.each_slice(lambdaction)

The argument vector_of_indices contains a list of indices of the slices to be used; it must evaluate to a vector of type uvec.
Arithmetic operations as per form 1 are supported, except for * and *= (e.g., matrix multiplication).

Form 3

.each_slice(lambdaction, use_mp)

Apply the given lambdaction to each slice.
The function must accept a reference to a Mat object with the same element type as the underlying cube.

Form 4

Apply the given lambdaction to each slice, as per form 3.
The argument use_mp is a bool to enable the use of OpenMP for multi-threaded execution of lambdaction on multiple slices at the same time.
The order of processing the slices is not deterministic (e.g., slice 2 can be processed before slice 1).
lambdaction must be thread-safe, e.g., it must not write to variables outside of its scope.

Examples:

[[cpp11::register]] doubles_matrix<> each_slice1_(const int& n) {
  cube C(n, n + 1, 6, fill::randu);

  mat M = repmat(linspace<vec>(1, n, n), 1, n + 1);

  C.each_slice() += M;  // in-place addition of M to each slice of C

  cube D = C.each_slice() + M;  // generate D by adding M to each slice of C

  // sum all slices of D into a single n x (n + 1) matrix
  mat D_flat = sum(D, 2);

  uvec indices(2);
  indices(0) = 2;
  indices(1) = 4;

  C.each_slice(indices) = M;  // copy M to slices 2 and 4 in C
  C.each_slice([](mat& X) { X * 2.0; });  // lambda function with non-const matrix
  mat C_flat = sum(C, 2);

  const cube& CC = C;
  CC.each_slice([](const mat& X) { X / 3.0; });  // lambda function with const matrix

  mat CC_flat = sum(CC, 2);

  mat res = C_flat + D_flat + CC_flat;

  return as_doubles_matrix(res);  // Convert from C++ to R
}

Set real

.set_real(X) sets the real part of an object. X must have the same size as the recipient object.

Examples

[[cpp11::register]] list set_real1_(const int& n) {
  mat A(n + 1, n - 1, fill::randu);

  cx_mat C(n + 1, n - 1, fill::zeros);

  C.set_real(A);

  return as_complex_matrix(C);  // Convert from C++ to R
}

Caveat

To directly construct a complex matrix out of two real matrices, the following code is faster:

[[cpp11::register]] list set_real2_(const int& n) {    
  mat A(n - 1, n + 1, fill::randu);
  mat B(n - 1, n + 1, fill::randu);
  
  cx_mat C = cx_mat(A,B);

  return as_complex_matrix(C);  // Convert from C++ to R
}

Set imaginary

.set_imaginary(X) sets the imaginary part of an object. X must have the same size as the recipient object.

Examples

[[cpp11::register]] list set_imag1_(const int& n) {
  mat B(n + 1, n - 1, fill::randu);

  cx_mat C(n + 1, n - 1, fill::zeros);

  C.set_imag(B);

  return as_complex_matrix(C);  // Convert from C++ to R
}

Caveat

To directly construct a complex matrix out of two real matrices, the following code is faster:

[[cpp11::register]] list set_imag2_(const int& n) {    
  mat A(n - 1, n + 1, fill::randu);
  mat B(n - 1, n + 1, fill::randu);
  
  cx_mat C = cx_mat(A,B);

  return as_complex_matrix(C);  // Convert from C++ to R
}

Insert columns

.insert_cols() is a member function of Mat, Row and Cube. The arguments can be colnumber, X to indicate the column number and the matrix to insert, or colnumber, number_of_cols to indicate the column number and the number of columns to insert.

The X argument inserts a copy of X at the specified column. X must have the same number of rows (and slices) as the recipient object.

The number_of_cols argument expands the object by creating new columns that are set to zero.

Examples

[[cpp11::register]] doubles_matrix<> insert_columns1_(const int& n) {
  mat A(n, n * 2, fill::randu);
  mat B(n, n - 1, fill::ones);

  // at column n - 1, insert a copy of B
  // A will now have 3n - 1 columns
  A.insert_cols(n - 1, B);

  // at column 1, insert 2n zeroed columns
  // B will now have 3n - 1 columns
  B.insert_cols(1, n * 2);

  mat res = A + B;

  return as_doubles_matrix(res);  // Convert from C++ to R
}

Insert rows

.insert_rows() is a member function of Mat, Row and Cube. The arguments can be rownumber, X to indicate the row number and the matrix to insert, or rownumber, number_of_rows to indicate the row number and the number of rows to insert.

The X argument inserts a copy of X at the specified column. X must have the same number of columns (and slices) as the recipient object.

The number_of_rows argument expands the object by creating new rows that are set to zero.

Examples

[[cpp11::register]] doubles_matrix<> insert_rows1_(const int& n) {
  mat A(n * 2, n, fill::randu);
  mat B(n - 1, n, fill::ones);

  // at row n - 1, insert a copy of B
  // A will now have 3n - 1 rows
  A.insert_rows(n - 1, B);

  // at row 1, insert 2n zeroed rows
  // B will now have 3n - 1 columns
  B.insert_rows(1, n * 2);

  mat res = A + B;

  return as_doubles_matrix(res);  // Convert from C++ to R
}

Insert slice

.insert_slices() is a member function of Cube. The arguments can be slice_number, X to indicate the slice number and the matrix to insert, or slice_number, number_of_slices to indicate the slice number and the number of slices to insert.

The X argument inserts a copy of X at the specified slice. X must have the same number of columns and rows as the recipient object.

The number_of_slices argument expands the object by creating new slices that are set to zero.

Examples

[[cpp11::register]] doubles_matrix<> insert_slices1_(const int& n) {
  cube A(n, n, n * 2, fill::randu);
  cube B(n, n, n - 1, fill::ones);

  // At slice n - 1, insert a copy of B
  // A will now have 3n - 1 slices
  A.insert_slices(n - 1, B);

  // At slice 1, insert 2n zeroed slices
  // B will now have 3n - 1 slices
  B.insert_slices(1, n * 2);

  mat res = sum(A + B);

  return as_doubles_matrix(res);  // Convert from C++ to R
}

Shed columns

.shed_col(row_number) and .shed_cols(first_row, last_row) are member functions of Mat, Col, SpMat, and Cube. With a single scalar argument it remove the specified column, and with two scalar arguments it removes the specified range of columns.

.shed_cols(vector_of_indices) is a member function of Mat and Col. With a vector of indices it must evaluate to a vector of type uvec containing the indices of the columns to remove.

Examples

[[cpp11::register]] doubles_matrix<> shed_columns1_(const int& n) {
  mat A(n, n * 5, fill::randu);

  // remove the first column
  A.shed_col(0);

  // remove columns 1 and 2
  A.shed_cols(0, 1);

  // remove columns 2 and 4
  uvec indices(2);
  indices(0) = 1;
  indices(1) = 3;
  A.shed_cols(indices);

  return as_doubles_matrix(A);  // Convert from C++ to R
}

Shed rows

.shed_row(row_number) and .shed_rows(first_row, last_row) are member functions of Mat, Col, SpMat, and Cube. With a single scalar argument it remove the specified rows, and with two scalar arguments it removes the specified range of rows.

.shed_rows(vector_of_indices) is a member function of Mat and Row. With a vector of indices it must evaluate to a vector of type uvec containing the indices of the rows to remove.

Examples

[[cpp11::register]] doubles_matrix<> shed_rows1_(const int& n) {
  mat A(n * 5, n, fill::randu);

  // remove the first row
  A.shed_row(0);

  // remove rows 1 and 2
  A.shed_rows(0, 1);

  // remove rows 2 and 4
  uvec indices(2);
  indices(0) = 1;
  indices(1) = 3;
  A.shed_rows(indices);

  return as_doubles_matrix(A);  // Convert from C++ to R
}

Shed slices

.shed_slices() is a member function of Cube. With a single scalar argument it remove the specified slices, and with two scalar arguments it removes the specified range of slices. With a vector of indices it must evaluate to a vector of type uvec containing the indices of the rows to remove. The arguments can be slice_number to indicate the slice number to remove, first_slice, last_slice to indicate the range of slices to remove, or vector_of_indices to indicate the indices of the slices to remove.

Examples

[[cpp11::register]] doubles_matrix<> shed_slices1_(const int& n) {
  cube A(n, n, n * 5, fill::randu);

  // remove the first slice
  A.shed_slice(0);

  // remove slices 1 and 2
  A.shed_slices(0, 1);

  // remove slices 2 and 4
  uvec indices(2);
  indices(0) = 1;
  indices(1) = 3;
  A.shed_slices(indices);

  mat res = sum(A, 2);

  return as_doubles_matrix(res);  // Convert from C++ to R
}

Swap columns

.swap_cols( col1, col2 ) is a member functions of Mat, Col, Row, and SpMat. It swaps the contents of the specified columns.

Examples

[[cpp11::register]] doubles_matrix<> swap_columns1_(const int& n) {
  mat A(n, n * 5, fill::randu);

  // swap columns 1 and 2
  A.swap_cols(0, 1);

  // swap columns 2 and 4
  A.swap_cols(1, 3);

  return as_doubles_matrix(A);  // Convert from C++ to R
}

Swap rows

.swap_rows( col1, col2 ) is a member functions of Mat, Col, Row, and SpMat. It swaps the contents of the specified rows.

Examples

[[cpp11::register]] doubles_matrix<> swap_rows1_(const int& n) {
  mat A(n * 5, n, fill::randu);

  // swap rows 1 and 2
  A.swap_rows(0, 1);

  // swap rows 2 and 4
  A.swap_rows(1, 3);

  return as_doubles_matrix(A);  // Convert from C++ to R
}

Swap

.swap( X ) is a member function of Mat, Col, Row, and Cube. It swaps the contents with object X.

Examples

[[cpp11::register]] doubles_matrix<> swap1_(const int& n) {
  mat A(n, n + 1, fill::zeros);
  mat B(n * 2, n - 1, fill::ones);

  A.swap(B);

  return as_doubles_matrix(A);  // Convert from C++ to R
}

Memory pointer

.memptr() is a member function of Mat, Col, Row, and Cube. It obtains a raw pointer to the memory used for storing elements. Data for matrices is stored in a column-by-column order. Data for cubes is stored in a slice-by-slice (matrix-by-matrix) order.

Examples

[[cpp11::register]] doubles_matrix<> memptr1_(const int& n) {
  mat A(n, n, fill::randu);
  const mat B(n, n, fill::randu);

  double* A_mem = A.memptr();
  const double* B_mem = B.memptr();

  // alter A_mem
  // B_mem is const, so it cannot be altered
  for (int i = 0; i < n * n; ++i) {
    A_mem[i] += 123.0 + B_mem[i];
  }

  return as_doubles_matrix(A);  // Convert from C++ to R
}

Caveats

The pointer becomes invalid after any operation involving a size change or aliasing.
This function is not recommended for use unless you know what you are doing.

Column pointer

.colptr( col_number ) is a member function of the Mat class that obtains a raw pointer to the memory used by elements in the specified column.

Examples

[[cpp11::register]] doubles_matrix<> colptr1_(const int& n) {
  mat A(n, n, fill::randu);

  // pointer to the memory of the first column of A
  double* Acol1_mem = A.colptr(0);

  // alter memory
  for (int i = 0; i < n; ++i) {
    Acol1_mem[i] += 123.0;
  }

  return as_doubles_matrix(A);  // Convert from C++ to R
}

Caveats

The pointer becomes invalid after any operation involving a size change or aliasing.
This function is not recommended for use unless you know what you are doing.
It is safer to use submat() instead.

Iterators

Iterators for traverse over all elements within the specified range. These return the column/row/slice of an object as a uword type.

Member functions

Dense matrices and vectors (Mat, Col, and Row):

.begin() is an iterator referring to the first element.
.end() is an iterator referring to the past the end element.
.begin_col(col_number) is an iterator referring to the first element of the specified column.
.end_col(col_number) is an iterator referring to the past-the-end element of the specified column.
begin_row(row_number) is an iterator referring to the first element of the specified row.
end_row(row_number) is an iterator referring to the past-the-end element of the specified row.

Cubes (Cube):

begin() is an iterator referring to the first element.
end() is an iterator referring to the past-the-end element.
begin_slice(slice_number) iterator referring to the first element of the specified slice.
end_slice(slice_number) iterator referring to the past-the-end element of the specified slice.

Sparse matrices (SpMat):

begin() is an iterator referring to the first element.
end() is an iterator referring to the past-the-end element.
begin_col(col_number) is an iterator referring to the first element of the specified column.
end_col(col_number) is an iterator referring to the past-the-end element of the specified column.
begin_row(row_number) is an iterator referring to the first element of the specified row.
end_row(row_number) is an iterator referring to the past-the-end element of the specified row.

Dense submatrices and subcubes (submatrix and subcube):

span(row, col) and span(row, col, slice) can be used to specify the range of elements to iterate over.

Iterator types

Dense matrices and vectors (Mat, Col, and Row):

mat::iterator, vec::iterator and rowvec::iterator are random access iterators, for read/write access to elements (which are stored column by column).
mat::const_iterator, vec::const_iterator and rowvec::const_iterator are random access iterators, for read-only access to elements (which are stored column by column)
mat::col_iterator, vec::col_iterator and rowvec::col_iterator random access iterators, for read/write access to the elements of specified columns.
mat::const_col_iterator, vec::const_col_iterator and rowvec::const_col_iterator are random access iterators, for read-only access to the elements of specified columns.
mat::row_iterator is a bidirectional iterator, for read/write access to the elements of specified rows.
mat::const_row_iterator is a bidirectional iterator, for read-only access to the elements of specified rows.
vec::row_iterator and rowvec::row_iterator are random access iterators, for read/write access to the elements of specified rows.
vec::const_row_iterator and rowvec::const_row_iterator are random access iterators, for read-only access to the elements of specified rows.

Cubes (Cube):

cube::iterator is a random access iterator, for read/write access to elements. The elements are ordered slice by slice; the elements within each slice are ordered column by column.
cube::const_iterator is a random access iterator, for read-only access to elements.
cube::slice_iterator is a random access iterator, for read/write access to the elements of a particular slice. The elements are ordered column by column.
cube::const_slice_iterator is a random access iterator, for read-only access to the elements of a particular slice.

Sparse matrices (SpMat):

sp_mat::iterator is a bidirectional iterator, for read/write access to elements (which are stored column by column).
sp_mat::const_iterator is a bidirectional iterator, for read-only access to elements (which are stored column by column).
sp_mat::col_iterator is a bidirectional iterator, for read/write access to the elements of a specific column.
sp_mat::const_col_iterator is a bidirectional iterator, for read-only access to the elements of a specific column.
sp_mat::row_iterator is a bidirectional iterator, for read/write access to the elements of a specific row.
sp_mat::const_row_iterator is a bidirectional iterator, for read-only access to the elements of a specific row.

Examples

[[cpp11::register]] doubles_matrix<> iterators1_(const int& n) {
  mat X(n, n + 1, fill::randu);

  mat::iterator it = X.begin();
  mat::iterator it_end = X.end();

  for (; it != it_end; ++it) {
    (*it) += 123.0;
  }

  mat::col_iterator col_it = X.begin_col(1);    // start of column 1
  mat::col_iterator col_it_end = X.end_col(n);  //   end of column n

  for (; col_it != col_it_end; ++col_it) {
    (*col_it) = 321.0;
  }

  return as_doubles_matrix(X);  // Convert from C++ to R
}

[[cpp11::register]] doubles_matrix<> iterators2_(const int& n) {
  cube X(n, n + 1, n + 2, fill::randu);

  cube::iterator it = X.begin();
  cube::iterator it_end = X.end();

  for (; it != it_end; ++it) {
    (*it) += 123.0;
  }

  cube::slice_iterator s_it = X.begin_slice(1);    // start of slice 1
  cube::slice_iterator s_it_end = X.end_slice(n);  // end of slice n

  for (; s_it != s_it_end; ++s_it) {
    (*s_it) = 321.0;
  }

  mat res = sum(X, 2);

  return as_doubles_matrix(res);  // Convert from C++ to R
}

[[cpp11::register]] doubles_matrix<> iterators3_(const int& n) {
  sp_mat X = sprandu<sp_mat>(n, n * 2, 0.1);

  sp_mat::iterator it = X.begin();
  sp_mat::iterator it_end = X.end();

  for (; it != it_end; ++it) {
    (*it) += 123.0;
  }

  return as_doubles_matrix(X);  // Convert from C++ to R
}

[[cpp11::register]] doubles_matrix<> iterators4_(const int& n) {
  mat X(n, n, fill::randu);

  for (double& val : X(span(0, 1), span(1, 1))) {
    val = 123.0;
  }

  return as_doubles_matrix(X);  // Convert from C++ to R
}

Caveats

Writing a zero value into a sparse matrix through an iterator will invalidate all current iterators associated with the sparse matrix.
To modify the non-zero elements in a safer manner, use .transform() or .for_each() instead of iterators.
For submatrix and subcube the iterators are intended only to be used with range-based for loops. Any other use is not supported. For example, the direct use of the .begin() and .end() functions, as well as the underlying iterators types is not supported. The implementation of submatrices and subcubes uses short-lived temporary objects that are subject to automatic deletion, and as such are error-prone to handle manually.

Compatibility container functions

Member functions for the Col and Row classes to mimic the functionality of containers in the C++ standard library:

.front() accesses the first element in a vector.
.back() accesses the last element in a vector.

Member functions for the Col, Row, Mat, Cube and SpMat classes to mimic the functionality of containers in the C++ standard library:

.clear() removes the elements from an object.
.empty() returns true if the object has no elements and false if the object has one or more elements.
.size() returns the total number of elements in an object.

Examples

[[cpp11::register]] doubles compatibility1_(const int& n) {
  vec X(n, fill::randu);

  writable::doubles res = {X.front(), X.back()};

  res.attr("names") = strings({"front", "back"});

  return res;
}

[[cpp11::register]] integers compatibility2_(const int& n) {
  mat X(n, n, fill::randu);

  writable::integers res(2);
  res[0] = X.n_rows;

  X.clear();
  res[1] = X.n_rows;

  res.attr("names") = strings({"before", "after"});

  return res;
}

Convert matrix to column

.as_col() is a member function of the Mat class, it returns a flattened version of the matrix as a column vector. Flattening is done by concatenating all columns.

Examples

[[cpp11::register]] doubles as_col1_(const int& n) {
  mat M(n, n + 1, fill::randu);
  vec V = M.as_col();
  return as_doubles(V);
}

Convert matrix to row

.as_row() is a member function of the Mat class, it returns a flattened version of the matrix as a row vector. Flattening is done by concatenating all rows.

Examples

[[cpp11::register]] doubles as_row1_(const int& n) {
  mat M(n, n + 1, fill::randu);
  vec V = M.as_row();
  return as_doubles(V);
}

Caveat

Converting columns to rows is faster than converting rows to columns.

Convert column to matrix

.col_as_mat(col_number) is a member function of the Cube class, it returns a matrix of the specified cube column and the number of rows is preserved. Given a cube of size R x C x S, the resultant matrix size is R x S.

Examples

[[cpp11::register]] list col_as_mat1_(const int& n) {
  cube C(n, n + 1, n + 2, fill::randu);
  mat M = C.col_as_mat(0);  // size n x (n + 1)
  
  writable::list res(5);
  res[0] = as_doubles_matrix(C.slice(0));
  res[1] = as_doubles_matrix(C.slice(1));
  res[2] = as_doubles_matrix(C.slice(2));
  res[3] = as_doubles_matrix(C.slice(3));
  res[4] = as_doubles_matrix(M);

  res.attr("names") = strings({"slice0", "slice1", "slice2", "slice3",
    "col_as_mat"});

  return res;
}

Convert column to matrix

.row_as_mat(row_number) is a member function of the Cube class, it returns a matrix of the specified cube row and the number of columns is preserved. Given a cube of size R x C x S, the resultant matrix size is S x C.

Examples

[[cpp11::register]] list row_as_mat1_(const int& n) {
  cube C(n, n + 1, n + 2, fill::randu);
  mat M = C.row_as_mat(0);  // size (n + 2) x (n + 1)

  writable::list res(5);
  res[0] = as_doubles_matrix(C.slice(0));
  res[1] = as_doubles_matrix(C.slice(1));
  res[2] = as_doubles_matrix(C.slice(2));
  res[3] = as_doubles_matrix(C.slice(3));
  res[4] = as_doubles_matrix(M);

  res.attr("names") = strings({"slice0", "slice1", "slice2", "slice3",
    "row_as_mat"});

  return res;
}

Convert sparse matrix to dense matrix

.as_dense() is a member function of the SpMat class, it avoids the construction of an intermediate sparse matrix representation of the expression.

Examples

[[cpp11::register]] doubles as_dense1_(const int& n) {
  sp_mat A;
  A.sprandu(n, n, 0.1);

  // extract column 1 of A directly into dense column vector
  colvec c = A.col(0).as_dense();

  // store the sum of each column of A directly in dense row vector
  rowvec r = sum(A).as_dense();

  return as_doubles(c + r.t());
}

Dense matrix and vector transposition

.t() is a member function of the Mat, Col and Row classes, it returns a transposed copy of the object. For real matrices, the transpose is a simple transposition of the elements. For complex matrices, the transpose is a Hermitian conjugate transposition of the elements (e.g., the signs of the imaginary components are flipped).

Examples

[[cpp11::register]] doubles_matrix<> transpose1_(const int& n) {
  mat A(n, n + 1, fill::randu);
  mat B = A.t();
  return as_doubles_matrix(B);
}

Sparse matrix transposition

.st() is a member function of the SpMat classe, it returns a transposed copy of the object. For real matrices, it is not applicable. For complex matrices, the transpose is a simple transposition of the elements (e.g., the signs of imaginary components are not flipped).

Examples

[[cpp11::register]] doubles_matrix<> transpose2_(const int& n) {
  sp_mat A;
  A.sprandu(n, n + 1, 0.1);
  sp_mat B = A.t();
  return as_doubles_matrix(B);
}

Matrix inversion

.i() is a member function of the Mat class, it provides an inverse of the matrix. If the matrix is not square sized, a std::logic_error exception is thrown. If the matrix appears to be singular, the output matrix is reset and a std::runtime_error exception is thrown.

Examples

[[cpp11::register]] doubles inverse1_(const doubles_matrix<>& a,
                                      const doubles b) {
  mat A = as_Mat(a);
  vec B = as_Col(b);

  mat X = inv(A);
  vec Y = X * B;

  return as_doubles(Y);
}

Caveats

If the matrix is known to be symmetric positive definite, inv_sympd().
To solve a system of linear equations, such as Z = inv(X) * Y, solve() can be faster and/or more accurate.

Maximum and minimum

.min() and .max() are member functions of the Mat, Col, Row, and Cube classes. These return the minimum and maximum values of the object, respectively. For objects with complex numbers, absolute values are used for comparison.

Examples

[[cpp11::register]] doubles maxmin1_(const int& n) {
  mat A = randu<mat>(n, n);

  writable::doubles res(2);
  res[0] = A.max();
  res[1] = A.min();

  res.attr("names") = strings({"max", "min"});

  return res;
}

Linear index of maximum and minimum

.index_min() and .index_max() are member functions of the Mat, Col, Row, and Cube classes. They return the linear index of the minimum and maximum values of the object, respectively. For objects with complex numbers, absolute values are used for comparison. The returned index is of type uword.

Examples

[[cpp11::register]] doubles index_maxmin1_(const int& n) {
  mat A = randu<mat>(n, n);

  writable::doubles res(6);
  res[0] = static_cast<int>(A.index_max());
  res[1] = static_cast<int>(A.index_min());
  res[2] = A(0, 0);
  res[3] = A(1, 0);
  res[4] = A(0, 1);
  res[5] = A(1, 1);

  res.attr("names") = strings({"index_max", "index_min", "element0", "element1",
    "element2", "element3"});

  return res;
}

In-range

.in_range(** i **) is a member function of Mat, Col, Row, Cube, SpMat and field, it returns true if the given location or span is currently valid and false if the object is empty, the location is out of bounds, or the span is out of bounds.

Function	Mat	Col	Row	Cube	SpMat	Field
`.in_range(span(start, end))`	✓	✓	✓	✓	✓	✓
`.in_range(row, col)`	✓	✓	✓	✓	✓	✓
`.in_range(span(start_row, end_row), span(start_col, end_col))`	✓	✓	✓		✓	✓
`.in_range(row, col, slice)`				✓		✓
`.in_range(span(start_row, end_row), span(start_col, end_col), span(start_slice, end_slice))`				✓		✓
`.in_range(first_row, first_col, size(X))` (`X` is a matrix or field)	✓	✓	✓		✓	✓
`.in_range(first_row, first_col, size(n_rows, n_cols))`	✓	✓	✓		✓	✓
`.in_range(first_row, first_col, first_slice, size(Q))` (`Q` is a cube or field)				✓		✓
`.in_range(first_row, first_col, first_slice, size(n_rows, n_cols, n_slices))`				✓		✓

Instances of span(a,b) can be replaced by:

span() or span::all to indicate the entire range.
span(a) to indicate a particular row, column, or slice.

Examples

[[cpp11::register]] logicals in_range1_(const int& n) {
  mat A(n, n + 1, fill::randu);

  writable::logicals res(3);
  res[0] = A.in_range(0, 0);
  res[1] = A.in_range(3, 4);
  res[2] = A.in_range(4, 5);

  res.attr("names") = strings({"in_range00", "in_range34", "in_range45"});

  return res;
}

Is empty

.is_empty() is a member function of the Mat, Col, Row, Cube, SpMat, and field classes. It returns true if the object has no elements and false if the object has one or more elements.

Examples

[[cpp11::register]] logicals is_empty1_(const int& n) {
  mat A(n, n + 1, fill::randu);

  writable::logicals res(2);
  res[0] = A.is_empty();

  A.reset();
  res[1] = A.is_empty();

  res.attr("names") = strings({"before_reset", "after_reset"});

  return res;
}

Is vector/column vector/row vector

.is_vec(), .is_colvec() and .is_rowvec() are member functions of Mat and SpMat.

.is_vec() returns true if the matrix can be interpreted as a vector (either column or row vector) and false otherwise.
.is_colvec() returns true if the matrix can be interpreted as a column vector and false otherwise.
.is_rowvec() returns true if the matrix can be interpreted as a row vector and false otherwise.

Examples

[[cpp11::register]] logicals is_vec1_(const int& n) {
  mat A(n, 1, fill::randu);
  mat B(1, n, fill::randu);
  mat C(0, 1, fill::randu);
  mat D(1, 0, fill::randu);

  writable::logicals res(5);
  res[0] = A.is_vec();
  res[1] = A.is_colvec();
  res[2] = B.is_rowvec();
  res[3] = C.is_colvec();
  res[4] = D.is_rowvec();

  res.attr("names") = strings({"Nx1_is_vec", "Nx1_is_colvec", "1xN_is_rowvec",
    "0x1_is_colvec", "1x0_is_rowvec"});

  return res;
}

Caveat

Do not assume that the vector has elements if these functions return true. It is possible to have an empty vector (e.g., 0x1 as in the examples).

Is sorted

.is_sorted(), .is_sorted(sort_direction) and .is_sorted(sort_direction, dim) are member function of Mat, Row, and Col. For matrices and vectors with complex numbers, order is checked via absolute values.

If the object is a vector, these return a bool indicating whether the elements are sorted. If the object is a matrix, these return a bool indicating whether the elements are sorted in each column (dim = 0, default) or each row (dim = 1), and the dim argument is optional.

The sort_direction argument is optional, sort_direction can be one of the following strings:

"ascend": the elements are ascending, consecutive elements can be equal, and this is the default operation.
"descend": the elements are descending, and consecutive elements can be equal.
"strictascend": the elements are strictly ascending, and consecutive elements cannot be equal.
"strictdescend": the elements are strictly descending, and consecutive elements cannot be equal.

Examples

[[cpp11::register]] logicals is_sorted1_(const int& n) {
  vec a(n, fill::randu);
  vec b = sort(a);
  mat A(10, 10, fill::randu);

  writable::logicals res(4);
  res[0] = a.is_sorted();
  res[1] = b.is_sorted();
  res[2] = A.is_sorted("descend", 1);
  res[4] = A.is_sorted("ascend", 1);

  res.attr("names") = strings({"a_sorted", "b_sorted", "A_descend",
    "A_ascend"});

  return res;
}

Is upper triangular/lower triangular

.is_trimatu() and .is_trimatl() are member functions of Mat and SpMat. .is_trimatu() returns true if the matrix is upper triangular (e.g., the matrix is square sized and all elements below the main diagonal are zero) and false otherwise. .is_trimatl() returns true if the matrix is lower triangular (e.g., the matrix is square sized and all elements above the main diagonal are zero) and false otherwise.

Examples

[[cpp11::register]] logicals is_triangular1_(const int& n) {
  mat A(n, n, fill::randu);
  mat B = trimatl(A);

  writable::logicals res(3);
  res[0] = B.is_trimatu();
  res[1] = B.is_trimatl();

  B.reset();
  res[2] = B.is_trimatu();

  res.attr("names") = strings({"is_trimatu", "is_trimatl",
    "is_trimatu_after_reset"});

  return res;
}

Caveat

If these functions return true, do not assume that the matrix contains non-zero elements on or above/below the main diagonal. It is possible to have an empty matrix (e.g., 0x0 as in the examples).

Is diagonal

is_diagmat() is a member function of Mat and SpMat. It returns true if the matrix is diagonal (e.g., all elements outside of the main diagonal are zero). If the matrix is not square sized, a std::logic_error exception is thrown.

Examples

[[cpp11::register]] logicals is_diagonal1_(const int& n) {
  mat A(n, n, fill::randu);
  mat B = diagmat(A);

  writable::logicals res(3);
  res[0] = A.is_diagmat();
  res[1] = B.is_diagmat();

  A.reset();
  res[2] = A.is_diagmat();

  res.attr("names") = strings({"A_diagmat", "B_diagmat",
    "A_diagmat_after_reset"});

  return res;
}

Caveat

If this function returns true, do not assume that the matrix contains non-zero elements on the main diagonal only. It is possible to have an empty matrix (e.g., 0x0 as in the examples).

Is square

.is_square() is a member function of the Mat and SpMat classes. It returns true if the matrix is square sized (e.g., the number of rows is equal to the number of columns) and false otherwise.

Examples

[[cpp11::register]] logicals is_square1_(const int& n) {
  mat A(n, n, fill::randu);
  mat B = diagmat(A);

  writable::logicals res(3);
  res[0] = A.is_square();
  res[1] = B.is_square();

  A.reset();
  res[2] = A.is_square();

  res.attr("names") = strings({"A_square", "B_square",
    "A_square_after_reset"});

  return res;
}

Caveats

If this function returns true, do not assume that the matrix is non-empty. It is possible to have an empty matrix (e.g., 0x0 as in the examples).

Is symmetric

.is_symmetric() is a member function of the Mat and SpMat classes. It returns true if the matrix is symmetric (e.g., the matrix is square sized and the transpose is equal to the original matrix) and false otherwise.

Examples

[[cpp11::register]] logicals is_symmetric1_(const int& n) {
  mat A(n, n, fill::randu);
  mat B = symmatu(A);

  writable::logicals res(3);
  res[0] = A.is_symmetric();
  res[1] = B.is_symmetric();

  A.reset();
  res[2] = A.is_symmetric();

  res.attr("names") = strings({"A_symmetric", "B_symmetric",
    "A_symmetric_after_reset"});

  return res;
}

Caveats

If this function returns true, do not assume that the matrix is non-empty. It is possible to have an empty matrix (e.g., 0x0 as in the examples).

Is hermitian

.is_hermitian() is a member function of the Mat and SpMat classes. It returns true if the matrix is Hermitian or self-adjoint (e.g., the matrix is square sized and the conjugate transpose is equal to the original matrix) and false otherwise.

Examples

[[cpp11::register]] logicals is_hermitian1_(const int& n) {
  cx_mat A(n, n, fill::randu);
  cx_mat B = A.t() * A;

  writable::logicals res(3);
  res[0] = A.is_hermitian();
  res[1] = B.is_hermitian();

  A.reset();
  res[2] = A.is_hermitian();

  res.attr("names") = strings({"A_hermitian", "B_hermitian",
    "A_hermitian_after_reset"});

  return res;
}

Caveats

If this function returns true, do not assume that the matrix is non-empty. It is possible to have an empty matrix (e.g., 0x0 as in the examples).

Is symmetric/hermitian positive definite

.is_sympd() and .is_sympd(tol) are a member function of the Mat and SpMat classes. It returns true if the matrix is symmetric/hermitian positive definite within a tolerance (e.g., the matrix is square sized and all its eigenvalues are positive) and false otherwise. The tol argument is optional, the default is tol = 100 * datum::eps * norm(X, "fro").

Examples

[[cpp11::register]] logicals is_sympd1_(const int& n) {
  mat A(n, n, fill::randu);
  mat B = A * A.t();

  writable::logicals res(3);
  res[0] = A.is_sympd();
  res[1] = B.is_sympd();

  A.reset();
  res[2] = A.is_sympd();

  res.attr("names") = strings({"A_sympd", "B_sympd",
    "A_sympd_after_reset"});

  return res;
}

Is zero

.is_zero() and .is_zero(tol) are a member function of the Mat, Col, Row, Cube, and SpMat classes. It returns true if all elements are zero within a tolerance and false otherwise. For complex numbers, each component (real and imaginary) is checked separately. The tol argument is optional.

Examples

[[cpp11::register]] logicals is_zero1_(const int& n) {
  mat A(n, n, fill::randu);
  cube B(n, n, n, fill::zeros);
  sp_mat C(n, n);

  writable::logicals res(3);
  res[0] = A.is_zero(0.005);
  res[1] = B.is_zero(0.005);
  res[2] = C.is_zero(0.005);

  res.attr("names") = strings({"A_is_zero", "B_is_zero", "C_is_zero"});

  return res;
}

Is finite

.is_finite() is a member function of the Mat, Col, Row, Cube, and SpMat classes. It returns true if all elements are finite and false otherwise.

Examples

[[cpp11::register]] logicals is_finite1_(const int& n) {
  mat A(n, n, fill::randu);
  cube B(n, n, n, fill::randu);
  sp_mat C(n, n);

  // Insert infinite values
  B(0, 0, 0) = datum::inf;
  C(0, 0) = -1.0 * datum::inf;

  writable::logicals res(3);
  res[0] = A.is_finite();
  res[1] = B.is_finite();
  res[2] = C.is_finite();

  res.attr("names") = strings({"A_is_finite", "B_is_finite", "C_is_finite"});

  return res;
}

Has infinity

.has_inf() is a member function of the Mat, Col, Row, Cube, and SpMat classes. It returns true if the object contains at least one infinite value and false otherwise.

Examples

[[cpp11::register]] logicals has_inf1_(const int& n) {
  mat A(n, n, fill::randu);
  cube B(n, n, n, fill::randu);
  sp_mat C(n, n);

  // Insert infinite values
  B(0, 0, 0) = datum::inf;
  C(0, 0) = -1.0 * datum::inf;

  writable::logicals res(3);
  res[0] = A.has_inf();
  res[1] = B.has_inf();
  res[2] = C.has_inf();

  res.attr("names") = strings({"A_has_inf", "B_has_inf", "C_has_inf"});

  return res;
}

Has not-a-number

.has_nan() is a member function of the Mat, Col, Row, Cube, and SpMat classes. It returns true if the object contains at least one not-a-number (NaN) value and false otherwise.

Examples

[[cpp11::register]] logicals has_nan1_(const int& n) {
  mat A(n, n, fill::randu);
  cube B(n, n, n, fill::randu);
  sp_mat C(n, n);

  // Insert NaN values
  B(0, 0, 0) = datum::nan;
  C(0, 0) = -1.0 * datum::nan;

  writable::logicals res(3);
  res[0] = A.has_nan();
  res[1] = B.has_nan();
  res[2] = C.has_nan();

  res.attr("names") = strings({"A_has_nan", "B_has_nan", "C_has_nan"});

  return res;
}

Caveat

NaN is not equal to anything, even itself.

- Attributes
  - Examples
- Element/object access
  - Examples
  - Caveats
- Element initialisation
  - Examples
- Zeros
  - Examples
- Ones
  - Examples
- Eye
  - Examples
- Random uniform
- Normal distribution
  - Examples
- Fill
  - Examples
- Imbue
  - Examples
- Clean
  - Examples
  - Caveat
- Replace
  - Examples
  - Caveats
- Clamp
  - Examples
- Transform
  - Examples
- For each
  - Examples
- Set size
  - Examples
- Reshape
  - Examples
  - Caveats
- Resize
  - Examples
  - Caveats
- Copy size
  - Examples
  - Caveat
- Reset
  - Examples
- Submatrix views
  - Contiguous views for matrix
  - Contiguous views for vector
  - Non-contiguous views for matrix or vector:
  - Examples
- Subcube views and slices
  - Contiguous views for cube
  - Non-contiguous views for cube
  - Examples
- Subfield views
- Diagonal
  - Examples
  - Caveat
- Each col
  - Examples
- Each row
  - Form 1
  - Form 2
  - Form 3
  - Examples
- Each slice
  - Form 1
  - Form 2
  - Form 3
  - Form 4
  - Examples:
- Set real
  - Examples
  - Caveat
- Set imaginary
  - Examples
  - Caveat
- Insert columns
  - Examples
- Insert rows
  - Examples
- Insert slice
  - Examples
- Shed columns
  - Examples
- Shed rows
  - Examples
- Shed slices
  - Examples
- Swap columns
  - Examples
- Swap rows
  - Examples
- Swap
  - Examples
- Memory pointer
  - Examples
  - Caveats
- Column pointer
  - Examples
  - Caveats
- Iterators
  - Member functions
  - Iterator types
  - Examples
  - Caveats
- Compatibility container functions
  - Examples
- Convert matrix to column
  - Examples
- Convert matrix to row
  - Examples
  - Caveat
- Convert column to matrix
  - Examples
- Convert column to matrix
  - Examples
- Convert sparse matrix to dense matrix
  - Examples
- Dense matrix and vector transposition
  - Examples
- Sparse matrix transposition
  - Examples
- Matrix inversion
  - Examples
  - Caveats
- Maximum and minimum
  - Examples
- Linear index of maximum and minimum
  - Examples
- In-range
  - Examples
- Is empty
  - Examples
- Is vector/column vector/row vector
  - Examples
  - Caveat
- Is sorted
  - Examples
- Is upper triangular/lower triangular
  - Examples
  - Caveat
- Is diagonal
  - Examples
  - Caveat
- Is square
  - Examples
  - Caveats
- Is symmetric
  - Examples
  - Caveats
- Is hermitian
  - Examples
  - Caveats
- Is symmetric/hermitian positive definite
  - Examples
- Is zero
  - Examples
- Is finite
  - Examples
- Has infinity
  - Examples
- Has not-a-number
  - Examples
  - Caveat

Member functions and variables

Attributes

Examples

Element/object access

Examples

Caveats

Element initialisation

Examples

Zeros

Examples

Ones

Examples

Eye

Examples

Random uniform

Normal distribution

Examples

Fill

Examples

Imbue

Examples

Clean

Examples

Caveat

Replace

Examples

Caveats

Clamp

Examples

Transform

Examples

For each

Examples

Set size

Examples

Reshape

Examples

Caveats

Resize

Examples

Caveats

Copy size

Examples

Caveat

Reset

Examples

Submatrix views

Contiguous views for matrix

Contiguous views for vector

Non-contiguous views for matrix or vector:

Examples

Subcube views and slices

Contiguous views for cube

Non-contiguous views for cube

Examples

Subfield views

Diagonal

Examples

Caveat

Each col

Examples

Each row

Form 1

Form 2

Form 3

Examples

Each slice

Form 1

Form 2

Form 3

Form 4

Examples:

Set real

Examples

Caveat

Set imaginary

Examples

Caveat

Insert columns

Examples