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
• 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
• the default setting of strict in versions 6.000+ is false
• the default setting of strict in versions 5.600 and earlier is true

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 allocated 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 simply appending a two digit form of the size to the matrix type -- for example, 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 size specified via template arguments; data is copied from auxiliary memory, where ptr_aux_mem is a pointer to the memory

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

mat A(5,5);  A = 123.0;

mat A(5,5);  A.fill(123.0);

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
• 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
• the default setting of strict in versions 6.000+ is false
• the default setting of strict in versions 5.600 and earlier is true

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 allocated 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 simply appending a single digit form of the size to the vector type -- for example, 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 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 = zeros<vec>(10);

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

vec a(5);  a = 123.0;

vec a(5);  a.fill(123.0);

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
• 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
• the default setting of strict in versions 6.000+ is false
• the default setting of strict in versions 5.600 and earlier is true

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 allocated 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 simply appending a single digit form of the size to the vector type -- for example, 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 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 = zeros<rowvec>(10);

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

rowvec r(5);  r = 123.0;

rowvec r(5);  r.fill(123.0);

Create a fixed size cube, with the size specified via template arguments. Memory for the cube is allocated 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
• 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
• the default setting of strict in versions 6.000+ is false
• the default setting of strict in versions 5.600 and earlier is true

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 = randu<cube>(4,5,6);

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

mat B = randu<mat>(4,5);
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


• If check_for_zeros is set to false, the values vector is assumed to contain no zero values

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;  // element access (Armadillo 8.x)


// batch insertion of two values at (5, 6) and (9, 9)
umat locations;
locations << 5 << 9 << endr
          << 6 << 9 << endr;

vec values;
values << 1.5 << 3.2 << endr;

sp_mat X(locations, values);

mat A = randu<mat>(5,10);
mat B = randu<mat>(5,10);
mat C = randu<mat>(10,5);

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 A = randu<mat>(10,10);
A(9,9) = 123.0;
double x = A.at(9,9);
double y = A[99];

vec p = randu<vec>(10,1);
p(9) = 123.0;
double z = p[9];

// C++11

vec v = { 1, 2, 3 };

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


// C++98

mat B;

B << 1 << 3 << 5 << endr
  << 2 << 4 << 6 << endr;

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

mat B;  B.zeros(10,20);

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

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

mat B;  B.ones(10,20);

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

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

mat B;  B.eye(5,5);

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

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

mat B;  B.randu(10,20);

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

arma_rng::set_seed_random();  // set the seed to a random value

mat A(5,5);
A.fill(123.0);

// C++11 only example
// need to include <random>

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

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

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

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

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

// C++11 only example

mat A = ones<mat>(4,5);

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

// C++11 only examples

mat A = ones<mat>(4,5);

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


field<mat> F(2,3);

// set the size of all matrices in field F
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);

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

vec v;  v.set_size(100);        // or:  vec v(100);

mat A = randu<mat>(4,5);

A.reshape(5,4);

mat A = randu<mat>(4,5);
A.resize(7,6);

mat A = randu<mat>(5,6);
mat B;
B.copy_size(A);

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

mat A = randu<mat>(5, 5);
A.reset();

mat A = zeros<mat>(5,10);

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 = randu<mat>(5,5);

// 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;
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 = randu<cube>(2,3,4);

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 = randu<mat>(5,5);

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 = ones<mat>(6,5);
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 = randu<mat>(4,5);
   mat B = randu<mat>(4,5);

cx_mat C = zeros<cx_mat>(4,5);

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

   mat A = randu<mat>(4,5);
   mat B = randu<mat>(4,5);

cx_mat C = cx_mat(A,B);

mat A = randu<mat>(5,10);
mat B = ones<mat>(5,2);

// 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 = randu<mat>(5,10);

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

mat X = randu<mat>(5,5);
X.swap_rows(0,4);

mat A = zeros<mat>(4,5);
mat B =  ones<mat>(6,7);

A.swap(B);

      mat A = randu<mat>(5,5);
const mat B = randu<mat>(5,5);

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

mat A = randu<mat>(5,5);

double* mem = A.colptr(2);

mat X = randu<mat>(5,5);


mat::iterator a = X.begin();
mat::iterator b = X.end();

for(mat::iterator i=a; i!=b; ++i)
  {
  cout << *i << endl;
  }


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

for(mat::col_iterator i=c; i!=d; ++i)
  {
  cout << *i << endl;
  (*i) = 123.0;
  }

cube X = randu<cube>(2,3,4);


cube::iterator a = X.begin();
cube::iterator b = X.end();

for(cube::iterator i=a; i!=b; ++i)
  {
  cout << *i << endl;
  }


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

for(cube::slice_iterator i=c; i!=d; ++i)
  {
  cout << *i << endl;
  (*i) = 123.0;
  }

mat A = randu<mat>(5,5);
cout << A.size() << endl;

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

mat A = randu<mat>(4,5);
mat B = A.t();

mat A = randu<mat>(4,4);
mat B = randu<mat>(4,1);

mat X = A.i();

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

mat A = randu<mat>(5,5);

double max_val = A.max();

mat A = randu<mat>(5,5);

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 = randu<mat>(4,5);

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 = randu<mat>(5,5);
cout << A.is_empty() << endl;

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

mat A = randu<mat>(5,5);
mat B = randu<mat>(6,7);

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

mat A = randu<mat>(1,5);
mat B = randu<mat>(5,1);
mat C = randu<mat>(5,5);

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

vec a = randu<vec>(10);
vec b = sort(a);

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


mat A = randu<mat>(10,10);

// 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 = randu<mat>(5,5);
mat B = randu<mat>(5,5);

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

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

mat A = randu<mat>(5,5);
mat B = randu<mat>(5,5);

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

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

mat A = randu<mat>(5,5);
mat B = randu<mat>(5,5);

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

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

mat A = randu<mat>(5,5);
mat B = randu<mat>(6,6);

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 = randu<mat>(5,5);

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

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

mat A = randu<mat>(5,5);

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

// force saving in arma_ascii format
A.save("A.txt", arma_ascii);

// 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;
  }

mat A = eye<mat>(5,5);  // or:  mat A(5,5,fill::eye);

mat B = 123.0 * eye<mat>(5,5);

mat C = eye<mat>( size(B) );

vec a = linspace<vec>(0, 5, 6);

vec b = linspace<vec>(5, 0, 6);

vec a = logspace<vec>(0, 5, 6);

vec b = logspace<vec>(5, 0, 6);

vec  v = ones<vec>(10);
uvec u = ones<uvec>(11);
mat  A = ones<mat>(5,6);
cube Q = ones<cube>(5,6,7);

mat  B = 123.0 * ones<mat>(5,6);

imat A = randi<imat>(5, 6);

imat A = randi<imat>(6, 7, distr_param(-10, +20));

arma_rng::set_seed_random();  // set the seed to a random value

vec  v = randu<vec>(5);
mat  A = randu<mat>(5,6);
cube Q = randu<cube>(5,6,7);

arma_rng::set_seed_random();  // set the seed to a random value

vec v = randg<vec>(100, distr_param(2,1));

mat X = randg<mat>(10, 10, distr_param(2,1));

 vec a = regspace< vec>(0,  9);       // 0,  1, ...,   9
uvec b = regspace<uvec>(2,  2,  10);  // 2,  4, ...,  10
ivec c = regspace<ivec>(0, -1, -10);  // 0, -1, ..., -10

sp_mat A = speye<sp_mat>(5,5);

sp_mat A = sprandu<sp_mat>(100, 200, 0.1);

sp_mat B = spones(A);

sp_mat A = sprandu<sp_mat>(100, 200, 0.1);

vec A = randu<vec>(5);
mat X = toeplitz(A);
mat Y = circ_toeplitz(A);

vec  v = zeros<vec>(10);
uvec u = zeros<uvec>(11);
mat  A = zeros<mat>(5,6);
cube Q = zeros<cube>(5,6,7);

mat A = randu<mat>(5,5);
mat B = abs(A); 

cx_mat X = randu<cx_mat>(5,5);
   mat Y = abs(X);

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

double x = accu(A);

double y = accu(A % B);

// accu(A % B) is a "multiply-and-accumulate" operation
// as operator % performs element-wise multiplication

mat44 A; A.randu();
vec3  B; B.randu();

vec4  C = affmul(A,B);

vec V = randu<vec>(10);
mat X = randu<mat>(5,5);


// status1 will be set to true if vector V has all non-zero elements
bool status1 = all(V);

// status2 will be set to true if vector V has all elements greater than 0.5
bool status2 = all(V > 0.5);

// status3 will be set to true if matrix X has all elements greater than 0.6;
// note the use of vectorise()
bool status3 = all(vectorise(X) > 0.6);

// generate a row vector indicating which columns of X have all elements greater than 0.7
umat A = all(X > 0.7);

vec V = randu<vec>(10);
mat X = randu<mat>(5,5);


// status1 will be set to true if vector V has any non-zero elements
bool status1 = any(V);

// status2 will be set to true if vector V has any elements greater than 0.5
bool status2 = any(V > 0.5);

// status3 will be set to true if matrix X has any elements greater than 0.6;
// note the use of vectorise()
bool status3 = any(vectorise(X) > 0.6);

// generate a row vector indicating which columns of X have elements greater than 0.7
umat A = any(X > 0.7);

mat A = randu<mat>(5,5);
mat B = A + 0.001;

bool same1 = approx_equal(A, B, "absdiff", 0.002);


mat C = 1000 * randu<mat>(5,5);
mat D = C + 1;

bool same2 = approx_equal(C, D, "reldiff", 0.1);

bool same3 = approx_equal(C, D, "both", 2, 0.1);

cx_mat A = randu<mat>(5,5);
   mat B = arg(A); 

rowvec r = randu<rowvec>(5);
colvec q = randu<colvec>(5);
mat    X = randu<mat>(5,5);

// examples of expressions which have optimised implementations

double a = as_scalar(r*q);
double b = as_scalar(r*X*q);
double c = as_scalar(r*diagmat(X)*q);
double d = as_scalar(r*inv(diagmat(X))*q);

mat A = randu<mat>(5,5);

mat B = clamp(A, 0.2, 0.8); 

mat C = clamp(A, A.min(), 0.8); 

mat D = clamp(A, 0.2, A.max()); 

mat    A = randu<mat>(5,5);
double c = cond(A);

cx_mat X = randu<cx_mat>(5,5);
cx_mat Y = conj(X);

mat  A = randu<mat>(5,5);
fmat B = conv_to<fmat>::from(A);

typedef std::vector<double> stdvec;

stdvec x(3);
x[0] = 0.0; x[1] = 1.0;  x[2] = 2.0;

colvec y = conv_to< colvec >::from(x);
stdvec z = conv_to< stdvec >::from(y); 

vec a = randu<vec>(3);
vec b = randu<vec>(3);

vec c = cross(a,b);

mat A = randu<mat>(5,5);
mat B = cumsum(A);
mat C = cumsum(A, 1);

vec x = randu<vec>(10);
vec y = cumsum(x);

mat A = randu<mat>(5,5);
mat B = cumprod(A);
mat C = cumprod(A, 1);

vec x = randu<vec>(10);
vec y = cumprod(x);

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

double x = det(A);

mat A = randu<mat>(5,5);
mat B = diagmat(A);
mat C = diagmat(A,1);

vec v = randu<vec>(5);
mat D = diagmat(v);
mat E = diagmat(v,1);

mat A = randu<mat>(5,5);

vec d = diagvec(A);