### Compile C++ Program with Armadillo and OpenBLAS from Non-Standard Location

Source: https://arma.sourceforge.net/faq

This command compiles a C++ program (`prog.cpp`) using Armadillo, linking against an OpenBLAS library installed in a custom directory. It includes Armadillo headers, defines a preprocessor macro to avoid wrapper usage, and specifies the OpenBLAS library path and name. Users need to replace placeholder paths with their actual installation directories.

```Bash
g++ prog.cpp -o prog -O2 -I /home/xyz/armadillo-12.0.1/include -DARMA_DONT_USE_WRAPPER -L /home/xyz/OpenBLAS-0.3.20 -lopenblas
```

--------------------------------

### Benchmark Matrix Operations with Armadillo C++

Source: https://arma.sourceforge.net/speed

This code snippet outlines a basic benchmarking setup for evaluating the performance of matrix operations using the Armadillo C++ library. It initializes matrices, starts a timer, performs a matrix addition operation multiple times within a loop, and then calculates the average time taken per operation. The 'size' and 'N' parameters are expected to be user-defined.

```C++
// size and N are specified by the user on the command line
mat A = randu(size,size);
mat B = randu(size,size);
...
mat Z = zeros(size,size);

timer.tic();

for(int i=0; i<N; ++i)
  {
  Z = A+B;  // or Z = A+B+C ... etc
  }

cout << "time taken = " << timer.toc() / double(N) << endl;
```

--------------------------------

### Optimize Complex Vector Operations with Armadillo C++

Source: https://arma.sourceforge.net/speed

This example showcases Armadillo's ability to optimize complex multi-operation expressions involving vectors and matrices. The entire expression, including transpose, inverse, and multiplication, is compiled into a single loop, eliminating the need for temporary matrices or vectors and significantly improving efficiency.

```C++
colvec p = randu(size);
colvec q = randu(size);
colvec r = randu(size);
...
double result = as_scalar(trans(p) * inv(diagmat(q)) * r);
```

--------------------------------

### Compile C++ program with Armadillo using g++

Source: https://arma.sourceforge.net/faq

This command compiles a C++ source file (`prog.cpp`) using the g++ compiler, linking it against the Armadillo run-time library. It specifies the C++11 standard and an optimization level of O2 for efficient execution.

```Bash
g++ prog.cpp -o prog -std=c++11 -O2 -larmadillo
```

--------------------------------

### Compile C++ Program with Armadillo and OpenMP Parallelization

Source: https://arma.sourceforge.net/faq

This command compiles a C++ program (`prog.cpp`) with Armadillo, enabling automatic parallelization via OpenMP. It uses `-O3` for optimization, specifies C++11 standard, and activates OpenMP support with `-fopenmp` for computationally expensive element-wise functions.

```Bash
g++ prog.cpp -o prog -O3 -larmadillo -std=c++11 -fopenmp
```

--------------------------------

### Compile C++ Program with Armadillo for SIMD Vectorization

Source: https://arma.sourceforge.net/faq

These commands compile a C++ program (`prog.cpp`) with Armadillo, enabling automatic SIMD vectorization. The first command uses `-O3` for general optimization, while the second adds `-march=native` to enable processor-specific instruction sets like AVX for further speedups, or SSE2 on 32-bit machines.

```Bash
g++ prog.cpp -o prog -O3 -larmadillo
```

```Bash
g++ prog.cpp -o prog -O3 -march=native -larmadillo
```

--------------------------------

### Armadillo Interfacing with External Libraries

Source: https://arma.sourceforge.net/faq

Armadillo facilitates interfacing with other libraries through several mechanisms: creating matrices or cubes that utilize auxiliary memory, accessing elements via STL-style iterators, or directly obtaining a pointer to matrix memory using the `.memptr()` function.

```APIDOC
Interfacing Mechanisms:
  1. Auxiliary Memory:
     Description: Create matrices/cubes using externally managed memory.
     Reference: `docs.html#Mat`
  2. STL-style Iterators:
     Description: Access matrix elements using standard iterators.
     Reference: `docs.html#iterators_mat`
  3. .memptr() function:
     Description: Obtain a direct pointer to the matrix's internal memory.
     Reference: `docs.html#memptr`
```

--------------------------------

### Armadillo Sparse Matrix Support (SpMat)

Source: https://arma.sourceforge.net/faq

Armadillo provides support for sparse matrices, with considerably improved functionality from version 9.600 onwards. Sparse matrices are stored in compressed sparse column format via the `SpMat` class. Additionally, dense matrix multiplication and inversion involving `diagmat` (diagonal matrices) account for sparsity to reduce computation.

```APIDOC
Class: SpMat
  Description: Represents sparse matrices
  Storage Format: Compressed Sparse Column (CSC)
  Minimum Recommended Version: 9.600

Function: diagmat
  Description: Handles diagonal matrices
  Interaction: Dense matrix multiplication and inversion with diagmat take sparsity into account for performance.
```

--------------------------------

### Armadillo Fixed-Size Matrix Support

Source: https://arma.sourceforge.net/faq

Armadillo supports fixed-size (static size) matrices, which can aid compiler optimization. This feature is generally recommended for small matrices (e.g., ≤ 10x10 or ≤ 100 elements) and is implemented via advanced matrix constructors.

```APIDOC
Feature: Fixed-size (static size) matrices
  Usage: Via advanced matrix constructors (e.g., `arma::Mat<double, 3, 3> M;`)
  Recommendation: For small matrices (≤ 10x10 or 100 elements)
  Benefit: Compiler optimization
```

--------------------------------

### Perform Element-wise Addition of Two Matrices in Armadillo C++

Source: https://arma.sourceforge.net/speed

This snippet demonstrates the straightforward syntax for adding two matrices, A and B, and storing the result in matrix Z using Armadillo's overloaded '+' operator. This operation benefits from Armadillo's internal optimizations, leading to significant speed-ups compared to other libraries.

```C++
Z = A+B
```

--------------------------------

### Disable Armadillo wrapper and link directly with BLAS/LAPACK

Source: https://arma.sourceforge.net/faq

To bypass Armadillo's default run-time library wrapper and link directly with external BLAS/LAPACK implementations, define `ARMA_DONT_USE_WRAPPER`. This can be achieved either by including the define in your C++ source file or by passing it as a compiler flag during compilation.

```C++
#define ARMA_DONT_USE_WRAPPER
#include <armadillo>
```

```Bash
g++ prog.cpp -o prog -std=c++11 -O2 -I /home/xyz/armadillo-12.0.1/include -DARMA_DONT_USE_WRAPPER -lopenblas
```

--------------------------------

### Perform Element-wise Addition of Four Matrices in Armadillo C++

Source: https://arma.sourceforge.net/speed

This snippet illustrates how Armadillo handles chained matrix addition. By combining multiple additions into a single expression, Armadillo's delayed evaluation and template meta-programming optimize the operation, often resulting in better performance than traditional approaches.

```C++
Z = A+B+C+D
```

--------------------------------

### Armadillo Aliasing Handling

Source: https://arma.sourceforge.net/faq

Armadillo checks for aliasing where possible in normal library usage. However, when constructing matrices using writeable auxiliary memory (externally managed memory), the user's code becomes responsible for managing potential aliasing issues.

```APIDOC
Feature: Aliasing detection
  Default Behavior: Armadillo checks for aliasing in normal usage.
  Exception: When using writeable auxiliary memory (externally managed memory), user code is responsible for aliasing management.
  Related: Advanced matrix constructors (`docs.html#adv_constructors_mat`)
```

--------------------------------

### Armadillo Supported Element Types

Source: https://arma.sourceforge.net/faq

Armadillo matrices support a predefined set of element types, including various floating-point, complex, and integer types. Support for user-defined or custom element types is not within the scope of the library.

```APIDOC
Supported Element Types:
  - `float`
  - `double`
  - `std::complex<float>`
  - `std::complex<double>`
  - `short`
  - `int`
  - `long`
  - `unsigned short`
  - `unsigned int`
  - `unsigned long`
```

--------------------------------

### Armadillo Interoperability with Python and R

Source: https://arma.sourceforge.net/faq

Armadillo can be used from other programming languages through dedicated bindings. For Python, CARMA provides bidirectional conversion with NumPy arrays, and PyArmadillo offers a streamlined linear algebra library. For R, RcppArmadillo provides a bidirectional interface, widely used in many R packages.

```APIDOC
Language Bindings:
  - Python:
    - CARMA: Bidirectional conversion with NumPy arrays.
      Link: `https://github.com/RUrlus/carma`
    - PyArmadillo: User-friendly linear algebra library based on Armadillo and pybind11.
      Link: `https://pyarma.sourceforge.io`
  - R language:
    - RcppArmadillo: Bidirectional interface between R and Armadillo.
      Link: `http://dirk.eddelbuettel.com/code/rcpp.armadillo.html`
```

--------------------------------

### Copy Row Between Matrices in Armadillo C++

Source: https://arma.sourceforge.net/speed

This snippet demonstrates efficient submatrix manipulation in Armadillo. It shows how to copy a specific row (the first row of matrix A) to another row (the last row of matrix B) using direct assignment, which is optimized for performance.

```C++
B.row(size-1) = A.row(0)
```

--------------------------------

### Perform Chained Matrix Multiplication with Armadillo C++

Source: https://arma.sourceforge.net/speed

This snippet shows chained matrix multiplication. Armadillo automatically determines the most efficient order of operations for expressions like A*B*C*D, especially when matrices have varying dimensions, to minimize computational cost and maximize performance.

```C++
Z = A*B*C*D
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.