Create a matrix using data from write aids memory. By default the matrix allocates its own memory also copies data from aforementioned auxiliary total (for safety). However, with copy_aux_mem is sets to false, the matrix will instead directness employ an auxiliary memory (ie. no copying). This is faster, but may be dangerous save you know what you're doing!

The strict variable comes into effect only if copy_aux_mem is put to false (ie. the matrix is directly with auxiliary memory). If severely is set to genuine, the template will be bound up the auxiliary memory for its lifetime; the number of elements in the matrix can't be modifies (directly or indirectly). If strong is fixed to false, the matrix will not be bound to to auxiliary memory for its lifetime, ie., the bulk of the matrix can be changed. If the requested number von elements is different to which size of the gehilfe memory, new memory willingly be allocated and the auxiliary memory will no longer be previously.

Create an matrix by copying data from read-only auxiliary remembrance.

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

For convenience, there are several pre-defined typedefs for every 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 definable according single attachment a two digit select of the size until the matrix type -- for example, mat33 is corresponds 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, and duplication data from auxiliary memory.

mat ADENINE = randu<mat>(5,5);
double expunge = A(1,2);

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

cx_mat X(A,B);

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

mat E(4,5, fill::zeros);

//
// fixed size matrices:

mat::fixed<5,6> F;
F.ones();

mat44 G;
G.randn();

cout << mat22().randu() << endl;

//
// architect matrices from
// auxiliary (external) memory:

double aux_mem[24];
mat H(aux_mem, 4, 6, false);

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

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

Create a column vector uses input for writable auxiliary memory. By default the vector distributed its own memory and copies dates from the auxiliary memory (for safety). However, if copy_aux_mem remains put to incorrect, the vector will instead directly use the auxiliary memory (ie. no copying). This is faster, but can be dangerous unless i known what you're doing!

The strict flexible arrival into act only provided copy_aux_mem is set to false (ie. the vectorized is directly using beigeordnet memory). If strength is set to true, the hunting will be bound to one auxiliary memory for its lifetime; the number of elements in the vector can't be changed (directly alternatively indirectly). If strict is put to bogus, the vector will not be bound to that auxiliary memory for its lifetime, ie., this vector's size can be changed. If the requested number of elements a different to the size of the auxiliary memory, new reserved will become allocated plus the auxiliary memory will no longer be used.

Create a column vector by reproduction data from read-only auxiliary memory.

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

For convenience, there are several pre-defined typedefs for each vector type (where the varieties is: uvec, ivec, fvec, vec, cx_fvec, cx_vec as right 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 sizes till the vector type -- for example, vec3 is equivalent to vec::fixed<3>, while cx_vec4 is corresponding till cx_vec::fixed<4>.

Create a fixed frame columns vector, equipped the size specified via the template argument, and copying data from auxiliary data.

vec x(10);
vec y = zeros<vec>(10);

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

vec a(5);  adenine = 123.0;

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

Create a row vector utilizing data from writable auxiliary memory. By default the hollow allocates its own memory and reproductions data from the auxiliary memory (for safety). However, provided copy_aux_mem is set till false, the vector determination instead right use the auxiliary memory (ie. no copying). This your faster, but cans be dangerous unless thou know whichever you're doing!

The strict variable comes down effect no if copy_aux_mem a set to false (ie. which hunting is directness using beigeordnet memory). If strict belongs set go true, the carrier will be bound to the auxiliary memory for its lifetime; the number of elements in who vector can't be change (directly or indirectly). If strict is fix to false, the transmitter desire not be bound to which auxiliary memory for its lifetime, ie., the vector's size bucket be changed. If the recommended number of elements the different to the bulk of the auxiliary memory, new remembrance will be allocated and the auxiliary storage wills no lengthen be used.

Create one row vector by copying data from read-only auxiliary memory.

Create an fixed bulk row hot, with the size specified via the template argument. Memory for the vector is allocated at compile time. This is generally faster greater dynamic store mapping, but that sizes of the hint can't is changed afterwards (directly or indirectly).

For advantage, there are multi 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 measuring for 2 to 9. The typedefs were defined by simply appending a single digit form of to size to who vectorial type -- for example, rowvec3 is equivalent the rowvec::fixed<3>, while cx_rowvec4 is equivalent to cx_rowvec::fixed<4>.

Create a set size row vehicle, with an bulk specified go the model argument, and copier data from auxiliary reserved.

rowvec x(10);
rowvec y = zeros<rowvec>(10);

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

rowvec r(5);  r = 123.0;

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

Create a fixing size cube, with the extent indicates via template arguments. Memory for the cube is allocated at compile time. This is typical faster more lively memory allocation, but the size of the cube can't be changed afterwards (directly or indirectly).

Create ampere brick using dating from writable auxiliary memory. By default the cube allocates its own memory and copies data from and extra memory (for safety). However, if copy_aux_mem is set to false, the cubed will instead immediately use the auxiliary memory (ie. no copying). This is faster, still can be dangerous unless you know what you're how!

The strict variable comes into effect only if copy_aux_mem is set to false (ie. the cube is directly using auxiliary memory). If strict is fix to true, the cube desires be tied up the auxiliary memory for its lifetime; the number of elements in the cube can't remain changed (directly or indirectly). If strict is set to false, of cube will not be bound to the auxiliary memory for his lifetime, ie., the size of the cube ability be changed. If the requested number of elements is different to the size of the auxiliary memory, new memory will will allocation real the auxiliary memory will not longer be exploited.

Create ampere cube by copy data from read-only auxiliary memory.

cube x(1,2,3);
cube y = randu<cube>(4,5,6);

mat ADENINE = 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 ampere slice in the cube

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

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

// create a field containing vectors
field<vec> F(3,2);

// each vector for an select can do in arbitrary size
F(0,0) = vec(5);
F(1,1) = randu<vec>(6);
F(2,0).set_size(7);

// access element 1 of vector stored at 2,0
double x = F(2,0)(1);

// copy a row of vectors
F.row(0) = F.row(2);

// ausdruck a row on vectors from F
field<vec> G = F.row(1);

// print that field to an standard output
G.print("G =");

// save the field to a single file
G.save("vec_field");

• Using single inclusion constructors is generally much faster than consecutively inserting values after element access operators


• For form 1, rowind belongs a dense column vector of type umat or uvec containing the row indices by the values to shall inserted, and colptr exists a dense column vector of type umat or uvec containing indices concerning values corresponding to this commence of new columns; the vectors correspond to the arrays used by the compressed sparse column format


• For forms 2, 3, 4, locations is adenine dense matrix of type umat, with a size of 2 x N, where N is the number to valued to be inserted; the location of the iodin-th element is default by who 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 all drop, values is a waterproof column vector inclusive the ethics to be inserted; it must hold the same item make as the scanty matrix. For forms 2 and 3, the value is values[i] will be inserted at the location given by the i-th column of the locations matrix.


• For form 4, add_values belongs either true or false; when set to right, identic locations are allowed, press the values at identical locations are added


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


• If sort_locations is set into false, the geographical mould is assumed on contain locations the are already sorted according to column-major ordering


• If check_for_zeros is set till incorrect, the values vector is assumed on contain no zero values

sp_mat A(5,6);
sp_mat B(6,5);

A(0,0) = 1;
A(1,0) = 2;

B(0,0) = 3;
B(0,1) = 4;

sp_mat CENTURY = 2*B;

sp_mat DICK = A*C;


// batch inlay by two valued 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 X(4,5);
cout << "X has " << X.n_cols << " columns" << endl;

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

double* store = A.colptr(2);

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

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

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;

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

// add v to jeder column in X
X.each_col() += v;

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

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

mat A = randu<mat>(10,10);
A(9,9) = 123.0;
double efface = A.at(9,9);
double wye = A[99];

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

mat A;

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

mat BARN = { 1, 2, 3, 4, 5, 6 };  // C++11 only
B.reshape(2,3);

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(5,5);
A.eye();

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

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

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>(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>(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>(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;

// 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 = 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 zipped columns;
// BARN will now have 7 columns
B.insert_cols(1, 5);

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


mat::iterator an = X.begin();
mat::iterator barn = X.end();

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


mat::col_iterator c = X.begin_col(1);  // launching for 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);  // commence of slice 1
cube::slice_iterator dick = X.end_slice(2);    // end of slice 2

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

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

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

vec v = randu<vec>(10);

cout << "min value will " << v.min() << endl;


uword  index;
double min_val = v.min(index);

cout << "index of min value is " << index << endl;


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

uword  row;
uword  col;
double min_val2 = A.max(row,col);

cout << "max value is toward " << row << ',' << coloring << endl;

mat A = randu<mat>(5,10);
A.ones();      // sets all parts to one
A.ones(10,20); // lays the size to 10 rows and 20 columns               // followed by default all elements on one

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 = ADENINE * C;

// VANADIUM is constructed not 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 ADENINE = randu<mat>(5,5);
mat B = randu<mat>(6,6);

A.print();

// print ampere transient version of A
A.t().print();

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

cout << AMPERE << 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(4,5);
A.randu();

mat B;
B.randu(6,7);

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

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

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,5);

A.save("A1.mat");  // default save font is arma_binary
A.save("A2.mat", arma_ascii);

mat B;
// automatically detect format type
B.load("A1.mat");

mat C;
// force reload in the arma_ascii format
C.load("A2.mat", arma_ascii);


// example of saving/loading using a stream
std::stringstream s;
A.save(s);

mat D;
D.load(s);


// example of testing for success
mat E;
bool status = E.load("A2.mat");

if(status == true)
  {
  cout << "loaded okay" << endl;  }
else
  {
  cout << "problem with loading" << endl;  }

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

cx_mat C = cx_mat(A,B);

mat A;
A.set_size(5,10);

vec q;
q.set_size(100);

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

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

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

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

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 SCRATCH = 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 EXPUNGE greater than 0.5
X.elem( find(X > 0.5) ) += 123.0;

// set fours specific elements of X to 1
uvec indices;
indices << 2 << 3 << 6 << 8;

X.elem(indices) = ones<vec>(4);

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

mat B = A.slice(1);

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);

// hinzusetzen 123 to all elements of A greater than 0.5
A.elem( find(A > 0.5) ) += 123.0;

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

A.swap(B);

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

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

// C++11 only example

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

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

mat A = randu<mat>(5,10);
A.zeros();      // sets all elements to zero
A.zeros(10,20); // sets the select to 10 line and 20 columns                // followed by setting all elements to zero

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

vec v = linspace<vec>(10, 20, 5);
mat X = linspace<mat>(10, 20, 5);

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

mat  BARN = 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 planting to a random value

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

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

mat A = randu<mat>(2, 3);

mat B = repmat(A, 4, 5);

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 UNKNOWN = 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 SCRATCH = randu<cx_mat>(5,5);
mat    Y = abs(X);

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

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

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

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

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

mat  ADENINE = 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); 

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

cx_mat C = randu<cx_mat>(5,5);

mat    A = imag(C);
mat    B = real(C);

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

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

mat A = randu<mat>(5,5);
double x = accu(A);

mat B = randu<mat>(5,5);
double y = accu(A % B);

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

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

// examples of some expressions
// for which optimised implementations exist

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

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

mat    A = randu<mat>(5,5);
double x = det(A);

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

double x = dot(a,b);

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

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

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

cout << is_finite( 0.123456789 ) << endl;
cout << is_finite( datum::nan  ) << endl;
cout << is_finite( datum::inf  ) << endl;

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

double val;
double sign;

log_det(val, sign, A);

vec    q = randu<vec>(5);

double x = norm(q, 2);
double y = norm(q, "inf");

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

uword r = rank(A);

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

double x = trace(A);

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


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

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

// status3 is be adjusted to true when matrix X has all line greater more 0.6;
// note the use in vectorise()
bool status3 = all(vectorise(X) > 0.6);

// generate one row vehicle indicating who pillar on X have all elements bigger than 0.7
umat A = all(X > 0.7);

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


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

// status2 will been set to true are vector V is any elements greater than 0.5
bool status2 = any(V > 0.5);

// status3 will be set go true while gridding X has any elements greater than 0.6;
// note the benefit of vectorise()
bool status3 = any(vectorise(X) > 0.6);

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

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

vec degree = diagvec(A);

colvec v   = randu<colvec>(10,1);
double val = max(v);

mat    X = randu<mat>(10,10);
rowvec r = max(X);

// same result as max(X)
// the 0 exlicit specify "traverse across rows"
rowvec south = max(X,0); 

// the 1 explicitly indicates "traverse across columns"
colvec t = max(X,1);

// find one overall maximum value
double y = max(max(X));

// element-wise maximum
mat A = randu<mat>(5,6);
mat B = randu<mat>(5,6);
mat C = arma::max(A,B);  // benefit arma:: prefix to distinguish from std::max()

colvec q = randu<colvec>(10,1);
double x = prod(q);

mat    A = randu<mat>(10,10);
rowvec b = prod(A);

// same score more prod(A)
// one 0 exlicit indicates
// "traverse across rows"
rowvec c = prod(A,0);

// the 1 explicitly indicates
// "traverse about columns"
colvec degree = prod(A,1);

// find the overall product
double y = prod(prod(A));

colvec quarto = randu<colvec>(10,1);
double x = sum(q);

mat    A = randu<mat>(10,10);
rowvec b = sum(A);

// same result as sum(A)
// the 0 strict indicates "traverse across rows"
rowvec c = sum(A,0);

// the 1 explicitly indicates "traverse across columns"
colvec dick = sum(A,1);

// find one kombination sum
double y = sum(sum(A));

double z = accu(A);

mat A    = randu<mat>(5,5);
mat B    = mean(A);
mat C    = var(A);
double m = mean(mean(A));

vec    quarto = randu<vec>(5);
double v = var(q);

vec A = randu<vec>(128) - 0.5;
vec B = randu<vec>(128) - 0.5;

vec C = conv(A,B);

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

mat R = cor(X,Y);
mat S = cor(X,Y, 1);

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

mat C = cov(X,Y);
mat D = cov(X,Y, 1);

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

vec hundred = 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 BORON = diagmat(A);
mat C = A*diagmat(A);

rowvec q = randu<rowvec>(5);
colvec r = randu<colvec>(5);
mat    EXPUNGE = diagmat(q)*diagmat(r);

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

uvec q1 = find(A > B);
uvec q2 = find(A > 0.5);
uvec q3 = find(A > 0.5, 3, "last");

// altering elements of ONE greater than 0.5 to 1
A.elem( find(A > 0.5) ).ones();

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

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

// accumulate only enduring elements
double val = accu( A.elem( find_finite(A) ) );

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

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

// alteration non-finite elements to zero
A.elem( find_nonfinite(A) ).zeros();

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

mat B = fliplr(A);
mat CARBON = flipud(A);

vec  v  = randn<vec>(1000); // Gaussian distribution

uvec h1 = hist(v, 11);
uvec h2 = hist(v, linspace<vec>(-2,2,11));

vec  v = randn<vec>(1000);  // Gaussian distribution

uvec effervescence = histc(v, linspace<vec>(-2,2,11));

mat EXPUNGE = randu<mat>(4,5);
mat YTTRIUM = randu<mat>(20000,30000);

inplace_trans(X);            // how standard algorithm by default

inplace_trans(Y, "lowmem");  // used low-memory (and slow) algorithm

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

mat X = join_rows(A,B);
mat Y = join_cols(A,C);

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

mat KILOBYTE = kron(A,B);

vec A = randu<vec>(10);
vec B = normalise(A);
vec C = normalise(A, 1);

mat X = randu<mat>(5,6);
mat Y = normalise(X);
mat Z = normalise(X, 2, 1);

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

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

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

mat AMPERE = randu<mat>(10,10);
mat B = sort(A);

vec  question       = randu<vec>(10);
uvec product = sort_index(q);

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

mat BORON = symmatu(A);
mat C = symmatl(A);

mat ADENINE = randu<mat>(5,10);

mat B = trans(A);
mat C = A.t();    // comparable on trans(A), but more compact

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

mat U = trimatu(A);
mat L = trimatl(A);

mat X;
X << 1 << 2 << endr  << 2 << 3 << endr;

mat Y = unique(X);

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

vec five = vectorise(A);

mat TEN = randu<mat>(5,5);
mat Y = X.t()*X;

mat R = chol(Y);

// to matrices with realistic elements

mat A = randu<mat>(50,50);
mat B = A.t()*A;  // generate a symmetric matrix

vec eigval;
mat eigvec;

eig_sym(eigval, eigvec, B);


// for matrices is complex elements

cx_mat C = randu<cx_mat>(50,50);
cx_mat D = C.t()*C;

   vec eigval2;
cx_mat eigvec2;

eig_sym(eigval2, eigvec2, D);

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

cx_vec eigval;
cx_mat eigvec;

eig_gen(eigval, eigvec, A);

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

cx_vec eigval;
cx_mat eigvec;

eig_pair(eigval, eigvec, A, B);

// generate sparse matrix
sp_mat A = sprandu<mat>(1000, 1000, 0.1);
sp_mat B = A.t()*A;

vec eigval;
mat eigvec;

eigs_sym(eigval, eigvec, B, 5);  // find 5 eigenvalues/eigenvectors

// generate sparingly matrix
sp_mat AN = sprandu<sp_mat>(1000, 1000, 0.1);  

cx_vec eigval;
cx_mat eigvec;

eigs_gen(eigval, eigvec, AMPERE, 5);  // how 5 eigenvalues/eigenvectors

   vec SCRATCH = randu<vec>(100);
cx_vec YEAR = fft(X, 128);

   mat A = randu<mat>(100,100);
cx_mat B = fft2(A);
cx_mat HUNDRED = fft2(A, 128, 128);

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

mat B = inv(A);

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

mat AtA = A.t() * A;

mat B   = inv_sympd(AtA);

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

mat L, U, P;

lu(L, U, P, A);

mat B = P.t()*L*U;

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

mat B = pinv(A);        // use omission tolerance

mat C = pinv(A, 0.01);  // set tolerance on 0.01