Armadillo：矩阵类、向量类、Cube类和泛型类-Toy模板网

这篇具有很好参考价值的文章主要介绍了Armadillo：矩阵类、向量类、Cube类和泛型类。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

矩阵类、向量类、Cube类和泛型类

Mat

mat

cx_mat

密集矩阵的类，其元素按列优先顺序存储（即逐列）

根矩阵类是 Mat<type>，其中 type 是以下项之一：
float、double、std::complex<float>、std::complex<double>short、int、long 和无符号的 short、int、long

为方便起见，定义了以下 typedef：

mat	 = 	Mat<double>
dmat	 = 	Mat<double>
fmat	 = 	Mat<float>
cx_mat	 = 	Mat<cx_double>
cx_dmat	 = 	Mat<cx_double>
cx_fmat	 = 	Mat<cx_float>
umat	 = 	Mat<uword>
imat	 = 	Mat<sword>

在本文档中，为了方便起见，使用了垫子类型; 可以使用其他矩阵类型来代替，例如FMAT系列。

具有整数元素的矩阵类型（如 umat 和 imat）不能包含特殊值，如 NaN 和 Inf。

使用 LAPACK 的函数（通常为矩阵分解）仅对以下矩阵类型有效：mat、dmat、fmat、cx_mat、cx_dmat`` cx_fmat

构造函数：

mat()	 	
mat(n_rows, n_cols)	 	 
mat(n_rows, n_cols, fill_form)	 	（元素根据 fill_form 进行初始化)
mat(size(X))	 	 
mat(size(X), fill_form)	 	（元素根据 fill_form 进行初始化)
mat(mat)	 	 
mat(vec)	 	 
mat(rowvec)	 	 
mat(initializer_list)	 	 
mat(string)	 	 
mat(std::vector)	 	（被视为列向量）
mat(sp_mat)	 	（用于将稀疏矩阵转换为密集矩阵）
cx_mat(mat,mat)	 	（用于从两个实数矩阵中构造一个复矩阵）

这些元素可以在构造过程中通过指定 fill_form 来显式初始化，这是其中之一：

fill::zeros	↦	将所有元素设置为 0
fill::ones	↦	将所有元素设置为 1
fill::eye	↦	将主对角线上的元素设置为 1，将非对角线上的元素设置为 0
fill::randu	↦	将所有元素设置为 [0,1] 区间内均匀分布中的随机值
fill::randn	↦	将所有元素设置为均值和单位方差为零的正态/高斯分布中的随机值
fill::value(scalar)	↦	将所有元素设置为指定的标量
fill::none	↦	不要初始化元素

警告：
从Armadillo 10.5 开始，元素默认初始化为零
在 Armadillo 10.4 及更早版本中，除非指定fill_form否则不会初始化元素; 即，如果不指定fill_form，元素可能包含垃圾值，包括NaN

对于 mat（string）构造函数，格式是用空格分隔的元素，用分号表示的行; 例如，可以使用 ; 请注意，基于字符串的初始化比直接设置元素或使用元素初始化（“1 0; 0 1”）要慢

每个 mat 实例都会自动分配和释放内部存储器。一旦实例超出范围，mat 实例使用的所有内部分配的内存都会自动释放。例如，如果在函数中声明了 mat 的实例，它将在函数结束时自动销毁。要在任何时候强制释放内存，请使用 .reset（）;请注意，在正常使用中，这不是必需的。

高级构造函数：

mat(ptr_aux_mem, n_rows, n_cols, copy_aux_mem = true, strict = false)

使用来自可写辅助（外部）存储器的数据创建矩阵，其中 ptr_aux_mem 是指向存储器的指针。默认情况下，矩阵分配自己的内存并从辅助内存中复制数据（为了安全起见）。但是，如果 copy_aux_mem 设置为 false，矩阵将直接使用辅助存储器（即不复制）; 这更快，但除非您知道自己在做什么，否则可能会很危险！

严格参数仅在 copy_aux_mem 设置为 false 时生效（即矩阵直接使用辅助存储器）
当 strict 设置为 false 时，矩阵将使用辅助存储器，直到大小更改或出现别名事件
当 strict 设置为 true 时，矩阵将在其生命周期内绑定到辅助存储器; 矩阵中的元素数无法更改

	mat(const ptr_aux_mem, n_rows, n_cols)

通过从只读辅助存储器复制数据来创建矩阵，其中 ptr_aux_mem 是指向内存的指针

	mat::fixed<n_rows, n_cols>

创建一个固定大小的矩阵，其大小通过模板参数指定。矩阵的内存在编译时保留。这通常比动态内存分配更快，但之后无法（直接或间接）更改矩阵的大小。

为方便起见，每个矩阵类型都有几个预定义的 typedef （其中类型为：UMAT、IMAT、FMAT、MAT、cx_fmat、cx_mat）。 typedefs 指定方阵大小，范围从 2x2 到 9x9。 typedefs 是通过将大小的两位数形式附加到矩阵类型来定义的; 示例：mat33 等效于 mat::fixed<3,3>，而 cx_mat44 等效于 cx_ma::fixed<4,4>。

mat::fixed<n_rows, n_cols>(fill_form)

创建一个固定大小的矩阵，其中元素根据fill_form显式初始化

mat::fixed<n_rows, n_cols>(const ptr_aux_mem)

创建一个固定大小的矩阵，其大小通过模板参数指定; 数据从辅助内存复制，其中 ptr_aux_mem 是指向内存的指针

例子：

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

另请参阅：

matrix attributes
accessing elements
initialising elements
math & relational operators
submatrix views
saving & loading matrices
printing matrices
element iterators
.eval()
conv_to() （在矩阵类型之间转换）
Col class
Row class
Cube class
SpMat 类（具有压缩稀疏列格式的稀疏矩阵）
config.hpp
TypeDef的解释 （cplusplus.com） 
C 数据类型 （维基百科）

Col

vec

cx_vec

列向量的类（具有一列的密集矩阵）

Col<type> 类派生自 Mat<type> 类并继承了大部分成员函数

为方便起见，定义了以下 typedef：

vec	 = 	colvec	 = 	Col<double>
dvec	 = 	dcolvec	 = 	Col<double>
fvec	 = 	fcolvec	 = 	Col<float>
cx_vec	 = 	cx_colvec	 = 	Col<cx_double>
cx_dvec	 = 	cx_dcolvec	 = 	Col<cx_double>
cx_fvec	 = 	cx_fcolvec	 = 	Col<cx_float>
uvec	 = 	ucolvec	 = 	Col<uword>
ivec	 = 	icolvec	 = 	Col<sword>

vec和 colvec类型具有相同的含义，可以互换使用

在本文档中，为方便起见，使用了 vec 或 colvec 类型;可以使用其他列向量类型来代替，例如。FVEC、FCOLVEC

以 Mat 为输入的函数通常也可以以 Col 为输入; 主要的例外是需要平方矩阵的函数

构造函数：

vec()	 	 
vec(n_elem)	 	 
vec(n_elem, fill_form)	 	（元素根据 fill_form 进行初始化)
vec(size(X))	 	 
vec(size(X), fill_form)	 	（元素根据 fill_form 进行初始化)
vec(vec)	 	 
vec(mat)	 	(如果给定矩阵具有多列，则会引发 std：：logic_error 异常）
vec(initializer_list)	 	 
vec(string)	 	（用空格分隔的元素）
vec(std::vector)	 	 
cx_vec(vec,vec)	 	（用于从两个实向量中构造一个复向量）

警告：
从Armadillo 10.5 开始，元素默认初始化为零
在 Armadillo 10.4 及更早版本中，除非指定fill_form否则不会初始化元素; 即。如果不指定fill_form，元素可能包含垃圾值，包括 NaN;有关fill_form的详细信息，请参阅 Mat 类

高级构造函数：

vec(ptr_aux_mem, number_of_elements, copy_aux_mem = true, strict = false)

使用来自可写辅助（外部）存储器的数据创建列向量，其中 ptr_aux_mem 是指向内存的指针。默认情况下，向量分配自己的内存并从辅助内存中复制数据（为了安全起见）。但是，如果 copy_aux_mem 设置为 false，向量将直接使用辅助存储器（即不复制）; 这更快，但除非您知道自己在做什么，否则可能会很危险！

严格参数仅在 copy_aux_mem 设置为 false 时生效（即向量直接使用辅助存储器）
当 strict 设置为 false 时，向量将使用辅助存储器，直到大小更改或出现混叠事件
当 strict 设置为 true 时，向量将在其生命周期内绑定到辅助存储器; 无法更改向量中的元素数

vec(const ptr_aux_mem, number_of_elements)

通过从只读辅助存储器复制数据来创建列向量，其中 ptr_aux_mem 是指向内存的指针

vec::fixed<number_of_elements>

创建一个固定大小的列向量，其大小通过 template 参数指定。向量的内存在编译时保留。这通常比动态内存分配更快，但事后无法（直接或间接）更改向量的大小。

为方便起见，每个向量类型都有几个预定义的 typedef （其中类型为：UVEC、IVEC、FVEC、VEC、cx_fvec、cx_vec以及相应的 COLVEC 版本）。预定义的 typedef 指定范围为 2 到 9 的向量大小。 typedefs 是通过将大小的单位数形式附加到向量类型来定义的; 示例：vec3 等效于 vec::fixed<3>，而 cx_vec4 等效于 cx_vec::fixed<4>。

vec::fixed<number_of_elements>(fill_form)

创建一个固定大小的列向量，并根据fill_form显式初始化元素

vec::fixed<number_of_elements>(const ptr_aux_mem)

创建一个固定大小的列向量，其大小通过 template 参数指定; 数据从辅助内存复制，其中 ptr_aux_mem 是指向内存的指针

例子：

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

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

另请参阅：

element initialisation
Mat class
Row class

Row

rowvec

cx_rowvec

行向量的类（具有一行的密集矩阵）

模板 Row<type> 类派生自 Mat<type> 类并继承了大部分成员函数

为方便起见，定义了以下 typedef：

rowvec	 = 	Row<double>
drowvec	 = 	Row<double>
frowvec	 = 	Row<float>
cx_rowvec	 = 	Row<cx_double>
cx_drowvec	 = 	Row<cx_double>
cx_frowvec	 = 	Row<cx_float>
urowvec	 = 	Row<uword>
irowvec	 = 	Row<sword>

在本文档中，为了方便起见，使用了 rowvec 类型; 可以使用其他行向量类型来代替，例如frowvec

以 Mat 为输入的函数通常也可以以 Row 为输入; 主要的例外是需要平方矩阵的函数

构造函数：

rowvec()	 	 
rowvec(n_elem)	 	 
rowvec(n_elem, fill_form)	 	（元素根据 fill_form 进行初始化)
rowvec(size(X))	 	 
rowvec(size(X), fill_form)	 	（元素根据 fill_form 进行初始化)
rowvec(rowvec)	 	 
rowvec(mat)	 	(std：：logic_error 如果给定矩阵有多行，则抛出异常）
rowvec(initializer_list)	 	 
rowvec(string)	 	（用空格分隔的元素）
rowvec(std::vector)	 	 
cx_rowvec(rowvec,rowvec)	 	（用于从两个实行向量中构造一个复数行向量）

警告：
从Armadillo 10.5 开始，元素默认初始化为零
在 Armadillo 10.4 及更早版本中，除非指定fill_form否则不会初始化元素; 即，如果不指定fill_form，元素可能包含垃圾值，包括 NaN;有关fill_form的详细信息，请参阅 Mat 类

高级构造函数：

rowvec(ptr_aux_mem, number_of_elements, copy_aux_mem = true, strict = false)

使用来自可写辅助（外部）存储器的数据创建行向量，其中 ptr_aux_mem 是指向存储器的指针。默认情况下，向量分配自己的内存并从辅助内存中复制数据（为了安全起见）。但是，如果 copy_aux_mem 设置为 false，向量将直接使用辅助存储器（即不复制）; 这更快，但除非您知道自己在做什么，否则可能会很危险！

严格参数仅在 copy_aux_mem 设置为 false 时生效（即向量直接使用辅助存储器）
当 strict 设置为 false 时，向量将使用辅助存储器，直到大小更改或出现混叠事件
当 strict 设置为 true 时，向量将在其生命周期内绑定到辅助存储器; 无法更改向量中的元素数

rowvec(const ptr_aux_mem, number_of_elements)

通过从只读辅助存储器复制数据来创建行向量，其中 ptr_aux_mem 是指向内存的指针

rowvec::fixed<number_of_elements>

创建一个固定大小的行向量，其大小通过 template 参数指定。向量的内存在编译时保留。这通常比动态内存分配更快，但事后无法（直接或间接）更改向量的大小。

为方便起见，每个向量类型都有几个预定义的 typedef （其中类型为：urowvec、irowvec、frowvec、rowvec、cx_frowvec、cx_rowvec）。预定义的 typedef 指定范围为 2 到 9 的向量大小。 typedefs 是通过将大小的单位数形式附加到向量类型来定义的; 示例：rowvec3 等效于 rowvec::fixed<3>，而 cx_rowvec4 等效于 cx_rowvec::fixed<4>。

rowvec::fixed<number_of_elements>(fill_form)

创建一个固定大小的行向量，并根据fill_form显式初始化元素

rowvec::fixed<number_of_elements>(const ptr_aux_mem)

创建一个固定大小的行向量，其大小通过 template 参数指定; 数据从辅助内存复制，其中 ptr_aux_mem 是指向内存的指针

例子：

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

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

另请参阅：

element initialisation
Mat class
Col class

Cube

cube

cx_cube

立方体（准三阶张量）的类，也称为“三维矩阵”

数据存储为一组连续存储在内存中的切片（矩阵）; 在每个切片中，元素以列优先顺序（即逐列）存储

根多维数据集类是 Cube<type>，其中 type 是以下项之一：
float、double、std::complex<float>、std::complex<double>short、int、long 和无符号版本的 short、int、long

为方便起见，定义了以下 typedef：

cube	 = 	Cube<double>
dcube	 = 	Cube<double>
fcube	 = 	Cube<float>
cx_cube	 = 	Cube<cx_double>
cx_dcube	 = 	Cube<cx_double>
cx_fcube	 = 	Cube<cx_float>
ucube	 = 	Cube<uword>
icube	 = 	Cube<sword>

在本文档中，为方便起见，使用了多维数据集类型; 可以使用其他类型来代替，例如fcube

构造函数：

cube()
cube(n_rows, n_cols, n_slices)	 	 
cube(n_rows, n_cols, n_slices, fill_form)	 	（元素根据 fill_form 进行初始化)
cube(size(X))	 	 
cube(size(X), fill_form)	 	（元素根据 fill_form 进行初始化)
cube(cube)	 	 
cx_cube(cube, cube)	 	（用于从两个实立方体中构造一个复杂的立方体）

这些元素可以在构造过程中通过指定 fill_form 来显式初始化，这是其中之一：

fill::zeros	↦	将所有元素设置为 0
fill::ones	↦	将所有元素设置为 1
fill::randu	↦	将所有元素设置为 [0,1] 区间内均匀分布中的随机值
fill::randn	↦	将所有元素设置为均值和单位方差为零的正态/高斯分布中的随机值
fill::value(scalar)	↦	将所有元素设置为指定的标量
fill::none	↦	不要初始化元素

警告：
从Armadillo 10.5 开始，元素默认初始化为零
在 Armadillo 10.4 及更早版本中，除非指定fill_form否则不会初始化元素; 即。如果不指定fill_form，元素可能包含垃圾值，包括 NaN

每个多维数据集实例都会自动分配和释放内部存储器。一旦实例超出范围，多维数据集实例使用的所有内部分配的内存都会自动释放。例如，如果在函数中声明了 cube 的实例，它将在函数结束时自动销毁。要在任何时候强制释放内存，请使用 .reset();请注意，在正常使用中，这不是必需的。

高级构造函数：

cube::fixed<n_rows, n_cols, n_slices>

创建一个固定大小的多维数据集，其大小通过模板参数指定。多维数据集的内存在编译时保留。这通常比动态内存分配更快，但之后无法（直接或间接）更改多维数据集的大小。

cube(ptr_aux_mem, n_rows, n_cols, n_slices, copy_aux_mem = true, strict = false)

使用可写辅助（外部）存储器中的数据创建多维数据集，其中 ptr_aux_mem 是指向内存的指针。默认情况下，多维数据集分配自己的内存，并从辅助内存中复制数据（为了安全起见）。但是，如果 copy_aux_mem 设置为 false，立方体将直接使用辅助存储器（即不复制）; 这更快，但除非您知道自己在做什么，否则可能会很危险！

strict 参数仅在 copy_aux_mem 设置为 false 时生效（即 Cube 直接使用辅助存储器）
当 strict 设置为 false 时，多维数据集将使用辅助内存，直到大小更改或出现别名事件
当 strict 设置为 true 时，多维数据集将在其生存期内绑定到辅助内存; 无法更改多维数据集中的元素数

cube(const ptr_aux_mem, n_rows, n_cols, n_slices)

通过从只读辅助存储器复制数据来创建多维数据集，其中 ptr_aux_mem 是指向内存的指针

例子：

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 作为输入的函数通常也可以将立方体切片作为输入

无法更改单个切片的大小。例如，以下操作将不起作用：

cube c(5,6,7);
c.slice(0) = randu<mat>(10,20); // wrong size

另请参阅：

cube attributes
accessing elements
math & relational operators
subcube views and slices
saving & loading cubes
element iterators
field class
Mat class

field<object_type>

用于在矩阵式或立方体式布局中存储任意对象的类

有点类似于矩阵或立方体，但不是每个元素都是标量，每个元素可以是向量、矩阵或立方体

每个元素可以具有任意大小（例如，在矩阵字段中，每个矩阵可以具有唯一的大小）

构造函数，其中 object_type 是另一个类，例如。vec、mat、std::string 等：

field<object_type>()
field<object_type>(n_elem)
field<object_type>(n_rows, n_cols)
field<object_type>(n_rows, n_cols, n_slices)
field<object_type>(size(X))
field<object_type>(field<object_type>)

警告: 要存储一组相同大小的矩阵，Cube 类效率更高

例子:

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

另请参阅：

field attributes
subfield views
saving / loading fields
Cube class

SpMat

sp_mat

sp_cx_mat

稀疏矩阵的类;用于存储大型矩阵，其中大多数元素为零

根稀疏矩阵类是 SpMat<type>，其中 type 是以下项之一：
float、double、std：：complex<float>、std：：complex<double>、short、int、long 和无符号版本的short、int、long

为方便起见，定义了以下 typedef：

sp_mat	 = 	SpMat<double>
sp_dmat	 = 	SpMat<double>
sp_fmat	 = 	SpMat<float>
sp_cx_mat	 = 	SpMat<cx_double>
sp_cx_dmat	 = 	SpMat<cx_double>
sp_cx_fmat	 = 	SpMat<cx_float>
sp_umat	 = 	SpMat<uword>
sp_imat	 = 	SpMat<sword>

在本文档中，为了方便起见，使用了sp_mat类型; 可以使用其他类型来代替，例如sp_fmat

构造函数：

sp_mat()	 	 
sp_mat(n_rows, n_cols)	 	 
sp_mat(size(X))	 	 
sp_mat(sp_mat)	 	 
sp_mat(mat)	 	（用于将密集矩阵转换为稀疏矩阵）
sp_cx_mat(sp_mat,sp_mat)	 	（用于从两个实数矩阵中构造一个复矩阵）

默认情况下，所有元素都被视为零（即矩阵初始化为包含零）

非零元素以压缩稀疏列（CSC）格式存储（即列优先排序）; 从不存储零值元素

此类的行为方式与密集矩阵 Mat 类类似; 但是，故意省略了将所有元素设置为非零值的成员函数（因此对稀疏矩阵没有意义）; 省略函数示例：.fill()、.ones()、+= 标量等。

注意：稀疏矩阵类不适用于小矩阵（例如，大小≤ 100x100），因为压缩存储格式的开销; 对于小矩阵，即使大多数元素为零，也使用 Mat 类

批量插入构造函数：
形式1：sp_mat(locations, values, sort_locations = true)
形式 2：sp_mat(locations, values, n_rows, n_cols, sort_locations = true, check_for_zeros = true)
形式 3：sp_mat(add_values, locations, values, n_rows, n_cols, sort_locations = true, check_for_zeros = true)
形式 4：sp_mat(rowind, colptr, values, n_rows, n_cols, check_for_zeros = true)

对于形式 1、2、3，locations 是 umat 类型的致密矩阵，大小为 2 x N，其中 N 是要插入的值的数量; 第 i 个元素的位置由位置矩阵的第 i 列的内容指定，其中行位于 locations(0，i) 中，列位于 locations(1，i) 中

对于形式 4，rowind 是 uvec 类型的密集列向量，包含要插入的值的行索引， colptr 是 UVEC 类型的密集列向量（长度为 n_cols + 1），包含对应于新列开头的值的索引; 向量对应于压缩稀疏列格式使用的数组; 此表单可用于从其他 CSC 稀疏矩阵容器复制数据

对于所有形式，values 是包含要插入的值的密集列向量; 它必须具有与稀疏矩阵相同的元素类型。对于表单 1 和 2，values[i] 中的值将插入到位置矩阵的第 i 列指定的位置。

对于形式 3，add_values 要么是 true 要么是 false;设置为 true 时，允许相同的位置，并添加相同位置的值

构造矩阵的大小为根据位置矩阵（表单 1）中的最大位置自动确定，或通过n_rows和n_cols手动指定（形式 2、3、4）

如果sort_locations设置为 false，则假定位置矩阵包含已根据列主要排序排序的位置;除非您知道自己在做什么，否则不要将其设置为 false！

如果check_for_zeros设置为 false，则假定值向量不包含零值;除非您知道自己在做什么，否则不要将其设置为 false！

以下操作和函数的子集可用于稀疏矩阵：
基本算术运算（如加法和乘法）
子矩阵视图：X.cols(vector_of_column_indices) 的大多数连续形式和非连续形式
对角线视图
保存和加载（使用 arma_binary、coord_ascii 和 csv_ascii 格式）
元素函数：abs()、cbrt()、ceil()、conj()、floor()、imag()、real()、round()、sign()、sqrt()、square()、trunc()
矩阵的标量函数：accu()、as_scalar()、dot()、norm()、norm2est()、trace()
矩阵的向量值函数：diagvec()、min()、max()、nonzeros()、sum()、mean()、var()、vecnorm()、vectorise()
矩阵的矩阵值函数： clamp()， diagmat()， spdiags()， flipud()/fliplr()， join_rows()， join_cols()， kron()， normalise()， repelem()， repmat()， reshape()， resize()， reverse()， shift()， symmatu()/symmatl()， trimatu()/trimatl()， .t()、trans()
生成矩阵：speye()、spones()、sprandu()、sprandn()、zeros()
特征分解和 SVD：eigs_sym()、eigs_gen()、svds()
稀疏线性系统的解：spsolve()
其他：approx_equal()、元素访问、元素迭代器、.as_col()/.as_row()、.for_each()、.print()、.clean()、.replace()、.transform()、.is_finite()、.is_symmetric()、.is_hermitian()、.is_trimatu()、.is_trimatl()、.is_diagmat()

例子：

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

另请参阅：

element access
element iterators (稀疏矩阵)
printing matrices
Sparse Matrix in Wikipedia
Mat class (稠密矩阵)

运算符： + − * % / == ！= <= >= < > && ||

Mat、Col、Row 和 Cube 类的重载运算符

运算符：

符号	含义
+	两个对象相加
−	从另一个对象中减去一个对象或一个负数
*	两个对象的矩阵乘法;不适用于 Cube 类，除非乘以标量
%	两个对象的元素乘法（Schur 积）
/	将一个对象逐个元素除以另一个对象或标量
==	两个对象的元素相等性评估;生成 umat/ucube 类型的矩阵/立方体
!=	两个对象的元素不相等评估;生成 umat/ucube 类型的矩阵/立方体
>=	对两个对象进行元素“大于或等于”评估;生成 umat/ucube 类型的矩阵/立方体
<=	对两个对象进行元素“小于或等于”评估;生成 umat/ucube 类型的矩阵/立方体
>	对两个对象进行元素“大于”评估;生成 umat/ucube 类型的矩阵/立方体
<	对两个对象进行元素“小于”评估;生成 umat/ucube 类型的矩阵/立方体
&&	两个对象的逐元素逻辑 AND 计算;生成 umat/ucube 类型的矩阵/立方体
\|\|	两个对象的逐元素逻辑 OR 求值;生成 umat/ucube 类型的矩阵/立方体

用于元素关系和逻辑操作(比如 , , , , , , , ) 生成的对象中的每个元素都是 0 或 1，具体取决于操作的结果==!=>=<=><&&||

注意：涉及相等比较的运算符（比如 , , ,）不建议用于 mat 或 fmat 类型的矩阵，由于浮点元素类型的精度必然有限; 考虑改用 approx_equal（）==!=>=<=

如果和运算符是链接的，则 Armadillo 旨在避免生成临时值; 如果所有给定对象的类型和大小相同，则不会生成临时对象+−%

如果算子是链式的，Armadillo 的目标是找到矩阵乘法的有效排序*

广播操作可通过 .each_col（）、.each_row（）、.each_slice（）进行

如果使用不兼容的对象大小，则会引发 std：：logic_error 异常

例子：

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

另请参阅：文章来源地址https://www.toymoban.com/news/detail-852285.html

approx_equal()
pow()
any()
all()
affmul()
accu()
as_scalar()
find()
.replace()
.transform()
.each_col（） 和 .each_row（） （应用于每列或每行的向量运算）
其他元素函数（exp、log、sqrt、square、round 等）
维基百科中的浮点运算
MathWorld 中的浮点表示

到了这里，关于Armadillo：矩阵类、向量类、Cube类和泛型类的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！