GeezerVison

Create a matrix using data from writable auxiliary (external) memory, where ptr_aux_mem is a pointer to the memory. By default the matrix allocates its own memory and copies data from the auxiliary memory (for safety). However, if copy_aux_mem is set to false, the matrix will instead directly use the auxiliary memory (ie. no copying); this is faster, but can be dangerous unless you know what you are doing!

The strict parameter comes into effect only when copy_aux_mem is set to false (ie. the matrix is directly using auxiliary memory)
• when strict is set to false, the matrix will use the auxiliary memory until a size change or an aliasing event
• when strict is set to true, the matrix will be bound to the auxiliary memory for its lifetime; the number of elements in the matrix can't be changed

Create a matrix by copying data from read-only auxiliary memory, where ptr_aux_mem is a pointer to the memory

Create a fixed size matrix, with the size specified via template arguments. Memory for the matrix is reserved at compile time. This is generally faster than dynamic memory allocation, but the size of the matrix can't be changed afterwards (directly or indirectly).

For convenience, there are several pre-defined typedefs for each matrix type (where the types are: umat, imat, fmat, mat, cx_fmat, cx_mat). The typedefs specify a square matrix size, ranging from 2x2 to 9x9. The typedefs were defined by appending a two digit form of the size to the matrix type; examples: mat33 is equivalent to mat::fixed<3,3>, while cx_mat44 is equivalent to cx_mat::fixed<4,4>.

Create a fixed size matrix, with the elements explicitly initialised according to fill_form

Create a fixed size matrix, with the size specified via template arguments; data is copied from auxiliary memory, where ptr_aux_mem is a pointer to the memory

#define ARMA_U8_TYPE std::uint8_t
#define ARMA_S8_TYPE  std::int8_t
#include <armadillo>

mat A(5, 5, fill::randu);
double x = A(1,2);

mat B = A + A;
mat C = A * B;
mat D = A % B;

cx_mat X(A,B);

B.zeros();
B.set_size(10,10);
B.ones(5,6);

B.print("B:");

mat::fixed<5,6> F;

double aux_mem[24];
mat H(&aux_mem[0], 4, 6, false);  // use auxiliary memory

Create a column vector using data from writable auxiliary (external) memory, where ptr_aux_mem is a pointer to the memory. By default the vector allocates its own memory and copies data from the auxiliary memory (for safety). However, if copy_aux_mem is set to false, the vector will instead directly use the auxiliary memory (ie. no copying); this is faster, but can be dangerous unless you know what you are doing!

The strict parameter comes into effect only when copy_aux_mem is set to false (ie. the vector is directly using auxiliary memory)
• when strict is set to false, the vector will use the auxiliary memory until a size change or an aliasing event
• when strict is set to true, the vector will be bound to the auxiliary memory for its lifetime; the number of elements in the vector can't be changed

Create a column vector by copying data from read-only auxiliary memory, where ptr_aux_mem is a pointer to the memory

Create a fixed size column vector, with the size specified via the template argument. Memory for the vector is reserved at compile time. This is generally faster than dynamic memory allocation, but the size of the vector can't be changed afterwards (directly or indirectly).

For convenience, there are several pre-defined typedefs for each vector type (where the types are: uvec, ivec, fvec, vec, cx_fvec, cx_vec as well as the corresponding colvec versions). The pre-defined typedefs specify vector sizes ranging from 2 to 9. The typedefs were defined by appending a single digit form of the size to the vector type; examples: vec3 is equivalent to vec::fixed<3>, while cx_vec4 is equivalent to cx_vec::fixed<4>.

Create a fixed size column vector, with the elements explicitly initialised according to fill_form

Create a fixed size column vector, with the size specified via the template argument; data is copied from auxiliary memory, where ptr_aux_mem is a pointer to the memory

vec x(10);
vec y(10, fill::ones);

mat A(10, 10, fill::randu);
vec z = A.col(5); // extract a column vector

Create a row vector using data from writable auxiliary (external) memory, where ptr_aux_mem is a pointer to the memory. By default the vector allocates its own memory and copies data from the auxiliary memory (for safety). However, if copy_aux_mem is set to false, the vector will instead directly use the auxiliary memory (ie. no copying); this is faster, but can be dangerous unless you know what you are doing!

The strict parameter comes into effect only when copy_aux_mem is set to false (ie. the vector is directly using auxiliary memory)
• when strict is set to false, the vector will use the auxiliary memory until a size change or an aliasing event
• when strict is set to true, the vector will be bound to the auxiliary memory for its lifetime; the number of elements in the vector can't be changed

Create a row vector by copying data from read-only auxiliary memory, where ptr_aux_mem is a pointer to the memory

Create a fixed size row vector, with the size specified via the template argument. Memory for the vector is reserved at compile time. This is generally faster than dynamic memory allocation, but the size of the vector can't be changed afterwards (directly or indirectly).

For convenience, there are several pre-defined typedefs for each vector type (where the types are: urowvec, irowvec, frowvec, rowvec, cx_frowvec, cx_rowvec). The pre-defined typedefs specify vector sizes ranging from 2 to 9. The typedefs were defined by appending a single digit form of the size to the vector type; examples: rowvec3 is equivalent to rowvec::fixed<3>, while cx_rowvec4 is equivalent to cx_rowvec::fixed<4>.

Create a fixed size row vector, with the elements explicitly initialised according to fill_form

Create a fixed size row vector, with the size specified via the template argument; data is copied from auxiliary memory, where ptr_aux_mem is a pointer to the memory

rowvec x(10);
rowvec y(10, fill::ones);

mat    A(10, 10, fill::randu);
rowvec z = A.row(5); // extract a row vector

Create a fixed size cube, with the size specified via template arguments. Memory for the cube is reserved at compile time. This is generally faster than dynamic memory allocation, but the size of the cube can't be changed afterwards (directly or indirectly).

Create a cube using data from writable auxiliary (external) memory, where ptr_aux_mem is a pointer to the memory. By default the cube allocates its own memory and copies data from the auxiliary memory (for safety). However, if copy_aux_mem is set to false, the cube will instead directly use the auxiliary memory (ie. no copying); this is faster, but can be dangerous unless you know what you are doing!

The strict parameter comes into effect only when copy_aux_mem is set to false (ie. the cube is directly using auxiliary memory)
• when strict is set to false, the cube will use the auxiliary memory until a size change or an aliasing event
• when strict is set to true, the cube will be bound to the auxiliary memory for its lifetime; the number of elements in the cube can't be changed

Create a cube by copying data from read-only auxiliary memory, where ptr_aux_mem is a pointer to the memory

cube x(1, 2, 3);
cube y(4, 5, 6, fill::randu);

mat A = y.slice(1);  // extract a slice from the cube
                     // (each slice is a matrix)

mat B(4, 5, fill::randu);
y.slice(2) = B;     // set a slice in the cube

cube q = y + y;     // cube addition
cube r = y % y;     // element-wise cube multiplication

cube::fixed<4,5,6> f;
f.ones();

mat A = randn(2,3);
mat B = randn(4,5);

field<mat> F(2,1);

F(0,0) = A;
F(1,0) = B; 

F.print("F:");

F.save("mat_field");

• For forms 1, 2, 3, locations is a dense matrix of type umat, with a size of 2 x N, where N is the number of values to be inserted; the location of the i-th element is specified by the contents of the i-th column of the locations matrix, where the row is in locations(0,i), and the column is in locations(1,i)


• For form 4, rowind is a dense column vector of type uvec containing the row indices of the values to be inserted, and colptr is a dense column vector of type uvec (with length n_cols + 1) containing indices of values corresponding to the start of new columns; the vectors correspond to the arrays used by the compressed sparse column format; this form is useful for copying data from other CSC sparse matrix containers


• For all forms, values is a dense column vector containing the values to be inserted; it must have the same element type as the sparse matrix. For forms 1 and 2, the value in values[i] will be inserted at the location specified by the i-th column of the locations matrix.


• For form 3, add_values is either true or false; when set to true, identical locations are allowed, and the values at identical locations are added


• The size of the constructed matrix is either automatically determined from the maximal locations in the locations matrix (form 1), or manually specified via n_rows and n_cols (forms 2, 3, 4)


• If sort_locations is set to false, the locations matrix is assumed to contain locations that are already sorted according to column-major ordering; do not set this to false unless you know what you are doing!


• If check_for_zeros is set to false, the values vector is assumed to contain no zero values; do not set this to false unless you know what you are doing!


• NOTE: the sparse matrix class has an internal caching mechanism which provides efficient read/write access to individual elements, such as X(row,col) = val; this reduces the need for batch insertion via the above constructors

sp_mat A = sprandu(1000, 2000, 0.01);
sp_mat B = sprandu(2000, 1000, 0.01);

sp_mat C = 2*B;
sp_mat D = A*C;

sp_mat E(1000,1000);
E(1,2) = 123;


// batch insertion of 3 values at
// locations (1, 2), (7, 8), (9, 9)

umat locations = { { 1, 7, 9 },
                   { 2, 8, 9 } };

vec values = { 1.0, 2.0, 3.0 };

sp_mat X(locations, values);

mat A(5, 10, fill::randu);
mat B(5, 10, fill::randu);
mat C(10, 5, fill::randu);

mat P = A + B;
mat Q = A - B;
mat R = -B;
mat S = A / 123.0;
mat T = A % B;
mat U = A * C;

// V is constructed without temporaries
mat V = A + B + A + B;

imat AA = "1 2 3; 4 5 6; 7 8 9;";
imat BB = "3 2 1; 6 5 4; 9 8 7;";

// compare elements
umat ZZ = (AA >= BB);

mat X(4,5);
cout << "X has " << X.n_cols << " columns" << endl;

mat M(10, 10, fill::randu);
M(9,9) = 123.0;
double x = M(1,2);

vec v(10, fill::randu);
v(9) = 123.0;
double y = v(0);

vec v = { 1, 2, 3 };

mat A = { {1, 3, 5},
          {2, 4, 6} };

mat A;
A.zeros(5, 10);   // or:  mat A(5, 10, fill::zeros);

mat B;
B.zeros( size(A) );

mat C(5, 10, fill::randu);
C.zeros();

mat A;
A.ones(5, 10);   // or:  mat A(5, 10, fill::ones);

mat B;
B.ones( size(A) );

mat C(5, 10, fill::randu);
C.ones();

mat A;
A.eye(5, 5);  // or:  mat A(5, 5, fill::eye);

mat B;
B.eye( size(A) );

mat C(5, 5, fill::randu);
C.eye();

mat A;
A.randu(5, 10);   // or:  mat A(5, 10, fill::randu);

mat B;
B.randu( size(A) );

mat C(5, 10, fill::zeros);
C.randu();

mat A(5, 6);

A.fill(123.0);

std::mt19937 engine;  // Mersenne twister random number engine

std::uniform_real_distribution<double> distr(0.0, 1.0);
  
mat A(4, 5, fill::none);
  
A.imbue( [&]() { return distr(engine); } );

vec v;

v.push_back(1.23);
v.push_back(4.56);
v.push_back(7.89);

sp_mat A;

A.sprandu(1000, 1000, 0.01);

A(12,34) =  datum::eps;
A(56,78) = -datum::eps;

A.clean(datum::eps);

mat A(5, 6, fill::randu);

A.diag().fill(datum::nan);

A.replace(datum::nan, 0);  // replace each NaN with 0

mat A(5, 6, fill::randu);

A.clamp(0.2, 0.8);

mat A(4, 5, fill::ones);

// add 123 to every element
A.transform( [](double val) { return (val + 123.0); } );

// add 123 to each element in a dense matrix

mat A(4, 5, fill::ones);

A.for_each( [](mat::elem_type& val) { val += 123.0; } );  // NOTE: the '&' is crucial!


// add 123 to each non-zero element in a sparse matrix

sp_mat S; S.sprandu(1000, 2000, 0.1);

S.for_each( [](sp_mat::elem_type& val) { val += 123.0; } );  // NOTE: the '&' is crucial!


// set the size of all matrices in field F

field<mat> F(2,3);

F.for_each( [](mat& X) { X.zeros(4,5); } );  // NOTE: the '&' is crucial!

mat A;
A.set_size(5, 10);      // or:  mat A(5, 10, fill::none);

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

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

mat A(4, 5, fill::randu);

A.reshape(5,4);

mat A(4, 5, fill::randu);

A.resize(7,6);

mat A(5, 6, fill::randu);

mat B;
B.copy_size(A);

cout << B.n_rows << endl;
cout << B.n_cols << endl;

mat A(5, 5, fill::randu);
A.reset();

mat A(5, 10, 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;

cube A(2, 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 X(5, 5, fill::randu);

vec a = X.diag();
vec b = X.diag(1);
vec c = X.diag(-2);

X.diag() = randu<vec>(5);
X.diag() += 6;
X.diag().ones();

sp_mat S = sprandu<sp_mat>(10,10,0.1);

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

mat X(6, 5, fill::ones);
vec v = linspace<vec>(10,15,6);

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

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

// subtract v from columns 0 through to 3 in X
X.cols(0,3).each_col() -= v;


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

X.each_col(indices) = v;   // copy v to columns 2 and 4 in X


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

const mat& XX = X;
XX.each_col( [](const vec& b){ b.print(); } );  // lambda function with const vector

cube C(4, 5, 6, fill::randu);

mat M = repmat(linspace<vec>(1,4,4), 1, 5);

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


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.print(); } );     // lambda function with non-const matrix

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

   mat A(4, 5, fill::randu);
   mat B(4, 5, fill::randu);

cx_mat C(4, 5, fill::zeros);

C.set_real(A);
C.set_imag(B);

   mat A(4, 5, fill::randu);
   mat B(4, 5, fill::randu);

cx_mat C = cx_mat(A,B);

mat A(5, 10, fill::randu);
mat B(5,  2, fill::ones );

// at column 2, insert a copy of B;
// A will now have 12 columns
A.insert_cols(2, B);

// at column 1, insert 5 zeroed columns;
// B will now have 7 columns
B.insert_cols(1, 5);

mat A(5, 10, fill::randu);
mat B(5, 10, fill::randu);

A.shed_row(2);
A.shed_cols(2,4);

uvec indices = {4, 6, 8};
B.shed_cols(indices);

mat X(5, 5, fill::randu);
X.swap_rows(0,4);

mat A(4, 5, fill::zeros);
mat B(6, 7, fill::ones );

A.swap(B);

      mat A(5, 5, fill::randu);
const mat B(5, 5, fill::randu);

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

mat A(5, 5, fill::randu);

double* mem = A.colptr(2);

mat X(5, 6, fill::randu);

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

for(; it != it_end; ++it)
  {
  cout << (*it) << endl;
  }

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

for(; col_it != col_it_end; ++col_it)
  {
  cout << (*col_it) << endl;
  (*col_it) = 123.0;
  }

cube X(2, 3, 4, fill::randu);

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

for(; it != it_end; ++it)
  {
  cout << (*it) << endl;
  }

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

for(; s_it != s_it_end; ++s_it)
  {
  cout << (*s_it) << endl;
  (*s_it) = 123.0;
  }

sp_mat X = sprandu<sp_mat>(1000, 2000, 0.1);

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

for(; it != it_end; ++it)
  {
  cout << "val: " << (*it)    << endl;
  cout << "row: " << it.row() << endl;
  cout << "col: " << it.col() << endl;
  }

mat X(100, 200, fill::randu);

for( double& val : X(span(40,60), span(50,100)) )
  {
  cout << val << endl;
  val = 123.0;
  }

mat A(5, 5, fill::randu);
cout << A.size() << endl;

A.clear();
cout << A.empty() << endl;

mat X(4, 5, fill::randu);

vec v = X.as_col();

cube Q(5, 4, 3, fill::randu);

mat A = Q.slice(2);       // size of A: 5x4

mat B = Q.col_as_mat(2);  // size of B: 5x3

mat C = Q.row_as_mat(2);  // size of C: 3x4

sp_mat A; A.sprandu(1000, 1000, 0.1);

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

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

mat A(4, 5, fill::randu);
mat B = A.t();

mat A(4, 4, fill::randu);

mat X = A.i();

mat Y = (A+A).i();

mat A(5, 5, fill::randu);

double max_val = A.max();

mat A(5, 5, fill::randu);

uword i = A.index_max();

double max_val = A(i);

cx_mat A( randu<mat>(4,4), randu<mat>(4,4) );

real(A).eval().save("A_real.dat", raw_ascii);
imag(A).eval().save("A_imag.dat", raw_ascii);

mat A(4, 5, fill::randu);

cout << A.in_range(0,0) << endl;  // true
cout << A.in_range(3,4) << endl;  // true
cout << A.in_range(4,5) << endl;  // false

mat A(5, 5, fill::randu);
cout << A.is_empty() << endl;

A.reset();
cout << A.is_empty() << endl;

mat A(1, 5, fill::randu);
mat B(5, 1, fill::randu);
mat C(5, 5, fill::randu);

cout << A.is_vec() << endl;
cout << B.is_vec() << endl;
cout << C.is_vec() << endl;

vec a(10, fill::randu);
vec b = sort(a);

bool check1 = a.is_sorted();
bool check2 = b.is_sorted();


mat A(10, 10, fill::randu);

// check whether each column is sorted in descending manner
cout << A.is_sorted("descend") << endl;

// check whether each row is sorted in ascending manner
cout << A.is_sorted("ascend", 1) << endl;

mat A(5, 5, fill::randu);
mat B = trimatl(A);

cout << A.is_trimatu() << endl;
cout << B.is_trimatl() << endl;

mat A(5, 5, fill::randu);
mat B = diagmat(A);

cout << A.is_diagmat() << endl;
cout << B.is_diagmat() << endl;

mat A(5, 5, fill::randu);
mat B(6, 7, fill::randu);

cout << A.is_square() << endl;
cout << B.is_square() << endl;

mat A(5, 5, fill::randu);
mat B = A.t() * A;

cout << A.is_symmetric() << endl;
cout << B.is_symmetric() << endl;

cx_mat A(5, 5, fill::randu);
cx_mat B = A.t() * A;

cout << A.is_hermitian() << endl;
cout << B.is_hermitian() << endl;

mat A(5, 5, fill::randu);

mat B = A.t() * A;

cout << A.is_sympd() << endl;
cout << B.is_sympd() << endl;

mat A(5, 5, fill::zeros);

A(0,0) = datum::eps;

cout << A.is_zero()           << endl;
cout << A.is_zero(datum::eps) << endl;

mat A(5, 5, fill::randu);
mat B(5, 5, fill::randu);

B(1,1) = datum::inf;

cout << A.is_finite() << endl;
cout << B.is_finite() << endl;

mat A(5, 5, fill::randu);
mat B(5, 5, fill::randu);

B(1,1) = datum::inf;

cout << A.has_inf() << endl;
cout << B.has_inf() << endl;

mat A(5, 5, fill::randu);
mat B(5, 5, fill::randu);

B(1,1) = datum::nan;

cout << A.has_nan() << endl;
cout << B.has_nan() << endl;

mat A(5, 5, fill::randu);
mat B(6, 6, fill::randu);

A.print();

// print a transposed version of A
A.t().print();

// "B:" is the optional header line
B.print("B:");

cout << A << endl;

cout << "B:" << endl;
cout << B << endl;

mat A(5, 5, fill::randu);

cout.precision(11);
cout.setf(ios::fixed);

A.raw_print(cout, "A:");

mat A(123, 456, fill::randu);

A.brief_print("A:");

// possible output:
// 
// A:
// [matrix size: 123x456]
//    0.8402   0.7605   0.6218      ...   0.9744
//    0.3944   0.9848   0.0409      ...   0.7799
//    0.7831   0.9350   0.4140      ...   0.8835
//         :        :        :        :        :        
//    0.4954   0.1826   0.9848      ...   0.1918

mat A(5, 6, fill::randu);

// default save format is arma_binary
A.save("A.bin");

// save in raw_ascii format
A.save("A.txt", raw_ascii);

// save in CSV format without a header
A.save("A.csv", csv_ascii);

// save in CSV format with a header
field<std::string> header(A.n_cols);
header(0) = "foo";
header(1) = "bar";  // etc
A.save( csv_name("A.csv", header) );

// save in HDF5 format with internal dataset named as "my_data"
A.save(hdf5_name("A.h5", "my_data"));

// automatically detect format type while loading
mat B;
B.load("A.bin");

// force loading in arma_ascii format
mat C;
C.load("A.txt", arma_ascii);


// example of testing for success
mat D;
bool ok = D.load("A.bin");

if(ok == false)
  {
  cout << "problem with loading" << endl;
  }