这个类为基于laspackc的串行向量数据结构提供了一个很好的接口。所有被覆盖的虚函数都记录在numeric_vector.h中。更多...

#include <laspack_matrix.h>

类 libMesh::LaspackVector< T > 继承关系图:

Public 成员函数
	LaspackVector (const Parallel::Communicator &comm, const ParallelType=AUTOMATIC)
	Dummy-Constructor. 更多...

	LaspackVector (const Parallel::Communicator &comm, const numeric_index_type n, const ParallelType=AUTOMATIC)
	Constructor. 更多...

	LaspackVector (const Parallel::Communicator &comm, const numeric_index_type n, const numeric_index_type n_local, const ParallelType=AUTOMATIC)
	Constructor. 更多...

	LaspackVector (const Parallel::Communicator &comm, const numeric_index_type N, const numeric_index_type n_local, const std::vector< numeric_index_type > &ghost, const ParallelType=AUTOMATIC)
	Constructor. 更多...

LaspackVector< T > &	operator= (const LaspackVector< T > &v)
	Copy assignment operator. 更多...

	LaspackVector (LaspackVector &&)=delete
	This class manages a C-style struct (QVector) manually, so we don't want to allow any automatic copy/move functions to be generated, and we can't default the destructor. 更多...

	LaspackVector (const LaspackVector &)=delete

LaspackVector &	operator= (LaspackVector &&)=delete

virtual	~LaspackVector ()
	LaspackVector 对象的析构函数。更多...

virtual void	close () override
	Close the vector. 更多...

virtual void	clear () override
	Clear the vector. 更多...

virtual void	zero () override
	Set all elements of the vector to zero. 更多...

virtual std::unique_ptr < NumericVector< T > >	zero_clone () const override
	创建并返回一个指向该对象的零克隆的 unique_ptr。更多...

virtual std::unique_ptr < NumericVector< T > >	clone () const override
	创建并返回一个指向该对象的克隆的 unique_ptr。更多...

virtual void	init (const numeric_index_type N, const numeric_index_type n_local, const bool fast=false, const ParallelType ptype=AUTOMATIC) override
	使用给定的全局大小和局部大小初始化向量。更多...

virtual void	init (const numeric_index_type N, const bool fast=false, const ParallelType ptype=AUTOMATIC) override
	使用给定的全局大小初始化向量。更多...

virtual void	init (const numeric_index_type N, const numeric_index_type n_local, const std::vector< numeric_index_type > &ghost, const bool fast=false, const ParallelType=AUTOMATIC) override
	使用给定的全局大小、局部大小和 `ghost` 参数指定的索引初始化向量，并为其保留内存。更多...

virtual void	init (const NumericVector< T > &other, const bool fast=false) override
	使用另一个向量的内容初始化向量。更多...

virtual NumericVector< T > &	operator= (const T s) override
	将标量值赋给向量的所有元素。更多...

virtual NumericVector< T > &	operator= (const NumericVector< T > &v) override
	将一个向量的内容赋值给另一个向量。更多...

virtual NumericVector< T > &	operator= (const std::vector< T > &v) override
	将一个 std::vector 的内容赋给向量。更多...

virtual Real	min () const override
	返回向量的最小元素。更多...

virtual Real	max () const override
	返回向量的最大元素。更多...

virtual T	sum () const override
	返回向量的所有元素之和。更多...

virtual Real	l1_norm () const override
	返回向量的 L1 范数。更多...

virtual Real	l2_norm () const override
	返回向量的 L2 范数。更多...

virtual Real	linfty_norm () const override
	返回向量的 Linfinity 范数。更多...

virtual numeric_index_type	size () const override
	返回向量的大小（全局维度）。更多...

virtual numeric_index_type	local_size () const override
	返回向量的局部大小（局部维度）。更多...

virtual numeric_index_type	first_local_index () const override
	返回向量的第一个局部索引。更多...

virtual numeric_index_type	last_local_index () const override
	返回向量的最后一个局部索引。更多...

virtual T	operator() (const numeric_index_type i) const override
	返回指定索引处向量的值。更多...

virtual NumericVector< T > &	operator+= (const NumericVector< T > &v) override
	将另一个向量的元素按元素加到该向量。更多...

virtual NumericVector< T > &	operator-= (const NumericVector< T > &v) override
	将另一个向量的元素按元素从该向量中减去。更多...

virtual NumericVector< T > &	operator*= (const NumericVector< T > &v) override
	将该向量的元素按元素与另一个向量的元素相乘。更多...

virtual NumericVector< T > &	operator/= (const NumericVector< T > &v) override
	将该向量的元素按元素除以另一个向量的元素。更多...

virtual void	reciprocal () override
	计算向量中所有元素的倒数（1/x）。更多...

virtual void	conjugate () override
	计算向量中所有元素的复共轭。更多...

virtual void	set (const numeric_index_type i, const T value) override
	设置指定索引处的元素值。更多...

virtual void	add (const numeric_index_type i, const T value) override
	将指定值添加到指定索引处的元素。更多...

virtual void	add (const T s) override
	将指定的标量值添加到向量的每个元素。更多...

virtual void	add (const NumericVector< T > &v) override
	将另一个向量的元素按元素加到该向量。更多...

virtual void	add (const T a, const NumericVector< T > &v) override
	将另一个向量的元素按元素乘以标量值并添加到该向量。更多...

virtual void	add_vector (const NumericVector< T > &v, const SparseMatrix< T > &A) override
	将一个向量添加到该向量并将结果存储在其中。更多...

virtual void	add_vector_transpose (const NumericVector< T > &v, const SparseMatrix< T > &A) override
	将一个向量的转置添加到该向量并将结果存储在其中。更多...

virtual void	scale (const T factor) override
	缩放向量的所有元素，将它们乘以指定的标量因子。更多...

virtual void	abs () override
	计算向量的每个元素的绝对值。更多...

virtual T	dot (const NumericVector< T > &v) const override
	计算向量与另一个向量的点积。更多...

virtual void	localize (std::vector< T > &v_local) const override
	将向量的元素本地化，以便在不同处理器之间交换。更多...

virtual void	localize (NumericVector< T > &v_local) const override
	将向量的元素本地化，以便在不同处理器之间交换。更多...

virtual void	localize (NumericVector< T > &v_local, const std::vector< numeric_index_type > &send_list) const override
	将向量的元素本地化，以便在不同处理器之间交换，但仅发送指定的索引。更多...

virtual void	localize (std::vector< T > &v_local, const std::vector< numeric_index_type > &indices) const override
	将向量的元素本地化，以便在不同处理器之间交换，但仅发送指定的索引。更多...

virtual void	localize (const numeric_index_type first_local_idx, const numeric_index_type last_local_idx, const std::vector< numeric_index_type > &send_list) override
	本地化向量的一部分，以便在不同处理器之间交换，但仅发送指定的索引。更多...

virtual void	localize_to_one (std::vector< T > &v_local, const processor_id_type proc_id=0) const override
	将向量本地化到指定处理器。更多...

virtual void	pointwise_mult (const NumericVector< T > &vec1, const NumericVector< T > &vec2) override
	对向量的每个元素执行逐元素乘法。更多...

virtual void	pointwise_divide (const NumericVector< T > &vec1, const NumericVector< T > &vec2) override
	对向量的每个元素执行逐元素除法。更多...

virtual void	swap (NumericVector< T > &v) override
	交换两个向量的内容。更多...

virtual std::size_t	max_allowed_id () const override
	获取允许的最大ID（索引）。更多...

virtual bool	initialized () const
	检查向量是否已经初始化。更多...

ParallelType	type () const
	获取向量的类型。更多...

ParallelType &	type ()
	获取向量的类型。更多...

virtual bool	closed () const
	检查向量是否已经关闭并准备好进行计算。更多...

virtual Real	subset_l1_norm (const std::set< numeric_index_type > &indices) const
	获取指定条目的向量的 $\ell_1$ -范数，即指定条目的绝对值之和。更多...

virtual Real	subset_l2_norm (const std::set< numeric_index_type > &indices) const
	获取指定条目的向量的 $\ell_2$ -范数，即指定条目平方和的平方根。更多...

virtual Real	subset_linfty_norm (const std::set< numeric_index_type > &indices) const
	获取指定条目的向量的最大绝对值，即指定条目的 $\ell_{\infty}$ -范数。更多...

Real	l2_norm_diff (const NumericVector< T > &other_vec) const
	获取 $\ell_2$ -范数的向量差值 $\vec{u} - \vec{v}$ ，其中 $\vec{u}$ 是 `this。` 更多...

virtual T	el (const numeric_index_type i) const
	获取向量的第 i 个条目。更多...

virtual void	get (const std::vector< numeric_index_type > &index, T *values) const
	一次访问多个组件。 `values` 将不会重新分配空间；它应该已经具有足够的空间。默认实现对每个索引调用 `operator()` ，但某些实现可能在此处提供更快的方法。更多...

void	get (const std::vector< numeric_index_type > &index, std::vector< T > &values) const
	一次访问多个组件。 `values` 将被调整大小，如果需要，将被填充。默认实现对每个索引调用 `operator()` ，但某些实现可能在此处提供更快的方法。更多...

NumericVector< T > &	operator*= (const T a)
	将向量缩放为 `a` ， $\vec{u} \leftarrow a\vec{u}$ 。等价于 `u.scale(a)。` 更多...

NumericVector< T > &	operator/= (const T a)
	将向量缩放为 `1/a` ， $\vec{u} \leftarrow \frac{1}{a}\vec{u}$ 。等价于 `u.scale`(1. 更多...

virtual void	add_vector (const T *v, const std::vector< numeric_index_type > &dof_indices)
	计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 `v` 是一个指针，每个 `dof_indices`[i] 指定了要添加的值 `v`[i] 的位置。这应该在子类中进行重写以提高效率。请注意，此方法的库实现是线程安全的。更多...

void	add_vector (const std::vector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 `v` 是一个 std::vector，每个 `dof_indices`[i] 指定了要添加的值 `v`[i] 的位置默认实现对每个索引调用 `operator()` ，但某些实现可能在此处提供更快的方法。请注意，此方法的库实现是线程安全的。更多...

void	add_vector (const NumericVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 `v` 是一个 NumericVector，每个 `dof_indices`[i] 指定了要添加的值 `v(i)` 的位置。此方法是线程安全的。更多...

void	add_vector (const DenseVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 `v` 是一个 DenseVector，每个 `dof_indices`[i] 指定了要添加的值 `v(i)` 的位置。此方法是线程安全的。更多...

void	add_vector (const NumericVector< T > &v, const ShellMatrix< T > &A)
	计算 $\vec{u} \leftarrow \vec{u} + A \vec{v}$ ，即将 `ShellMatrix` `A` 和 `NumericVector` `v` 的乘积添加到 `this。` 更多...

virtual void	insert (const T *v, const std::vector< numeric_index_type > &dof_indices)
	将 `v` 的条目插入到 *this 中，位置由 `dof_indices` 指定。请注意，此方法的库实现是线程安全的。更多...

void	insert (const NumericVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	将 `v` 的条目插入到 *this 中，位置由 `v` 指定。只要使用 `NumericVector` 的库实现，此方法是线程安全的。更多...

void	insert (const DenseVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	将 `v` 的条目插入到 *this 中，位置由 `v` 指定。只要使用 `NumericVector` 的库实现，此方法是线程安全的。更多...

void	insert (const DenseSubVector< T > &v, const std::vector< numeric_index_type > &dof_indices)
	将 `v` 的条目插入到 *this 中，位置由 `v` 指定。只要使用 `NumericVector` 的库实现，此方法是线程安全的。更多...

virtual int	compare (const NumericVector< T > &other_vector, const Real threshold=TOLERANCE) const
	比较 `this` 与 `other_vector` 的等效性，（在给定的 `threshold` 内）如果等效则返回 `-1` ，或者返回第一个索引，其中 `abs`(a[i]-b[i]) 超过阈值。更多...

virtual int	local_relative_compare (const NumericVector< T > &other_vector, const Real threshold=TOLERANCE) const
	比较该向量与另一个向量的局部相对差异。更多...

virtual void	print (std::ostream &os=libMesh::out) const
	打印本地向量的内容，默认输出到 libMesh::out 流。更多...

template<>
void	print (std::ostream &os) const

virtual void	print_global (std::ostream &os=libMesh::out) const
	打印全局向量的内容，默认输出到 libMesh::out 流。更多...

template<>
void	print_global (std::ostream &os) const

virtual void	print_matlab (const std::string &="") const
	以Matlab的稀疏矩阵格式打印向量内容。可选择将向量打印到名为 `name` 的文件中。如果未指定 `name，则内容将被打印到屏幕上。` 更多...

virtual void	create_subvector (NumericVector< T > &subvector, const std::vector< numeric_index_type > &rows) const
	使用 `rows` 中的索引从该向量中填充 `subvector。类似于` SparseMatrix 类的 `create_submatrix()` 函数，当前仅对 PetscVectors 实现了此功能。更多...

bool	readable () const
	检查该向量是否能够用于全局操作。更多...

bool	compatible (const NumericVector< T > &v) const
	检查该向量和向量 `v` 是否能够一起用于全局操作。更多...

静态 Public 成员函数
static std::unique_ptr < NumericVector< T > >	build (const Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package())
	构建一个 NumericVector 对象。更多...

static std::string	get_info ()
	Gets a string containing the reference information. 更多...

static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to `libMesh::out`. 更多...

static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects. 更多...

static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info() 更多...

static void	disable_print_counter_info ()

Protected 类型
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
	Data structure to log the information. 更多...

Protected 成员函数
void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter. 更多...

void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter. 更多...

Protected 属性
bool	_is_closed
	用于跟踪向量的值在在一些或全部处理器上进行插入或添加值操作后是否在所有处理器上保持一致的标志。更多...

bool	_is_initialized
	在调用 init() 后设置为 true。更多...

ParallelType	_type
	向量的类型。更多...

std::mutex	_numeric_vector_mutex
	用于执行线程安全操作的互斥锁。更多...

静态 Protected 属性
static Counts	_counts
	Actually holds the data. 更多...

static Threads::atomic < unsigned int >	_n_objects
	The number of objects. 更多...

static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting. 更多...

static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called. 更多...

Private 属性
QVector	_vec
	用于保存向量条目的实际 Laspack 向量数据类型。更多...

友元
class	LaspackLinearSolver< T >
	使其他 Laspack 数据类型成为友元类，以便它们可以访问私有成员。更多...

详细描述

template<typename T>
class libMesh::LaspackVector< T >

这个类为基于laspackc的串行向量数据结构提供了一个很好的接口。所有被覆盖的虚函数都记录在numeric_vector.h中。

作者: Benjamin S. Kirk

日期: 2002

在文件 laspack_matrix.h 第 42 行定义.

成员类型定义说明

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts

protectedinherited

Data structure to log the information.

The log is identified by the class name.

在文件 reference_counter.h 第 119 行定义.

构造及析构函数说明

template<typename T >

libMesh::LaspackVector< T >::LaspackVector	(	const Parallel::Communicator &	comm,
		const ParallelType	ptype = `AUTOMATIC`
	)

inlineexplicit

Dummy-Constructor.

使用通信器 comm 和并行类型 ptype 创建 LaspackVector 对象，维度为 0。

Dimension=0 创建一个维度为0的 LaspackVector 对象。

参数

comm	通信器对象，用于并行计算。
parallel_type	并行类型，默认为 AUTOMATIC。

在文件 laspack_vector.h 第 552 行定义.

参考 libMesh::NumericVector< T >::_type.

   : NumericVector<T>(comm, ptype)
 {
   this->_type = ptype;
 }

template<typename T >

libMesh::LaspackVector< T >::LaspackVector	(	const Parallel::Communicator &	comm,
		const numeric_index_type	n,
		const ParallelType	ptype = `AUTOMATIC`
	)

inlineexplicit

Constructor.

使用通信器 comm 和维度 n，初始化 LaspackVector 对象并将所有元素初始化为零。

Set dimension to n and initialize all elements with zero. 构造函数。将向量维度设置为 n 并将所有元素初始化为零。

参数

comm	通信器对象，用于并行计算。
n	向量的全局维度。
parallel_type	并行类型，默认为 AUTOMATIC。

在文件 laspack_vector.h 第 565 行定义.

参考 libMesh::LaspackVector< T >::init().

   : NumericVector<T>(comm, ptype)
 {
   this->init(n, n, false, ptype);
 }

template<typename T >

libMesh::LaspackVector< T >::LaspackVector	(	const Parallel::Communicator &	comm,
		const numeric_index_type	n,
		const numeric_index_type	n_local,
		const ParallelType	ptype = `AUTOMATIC`
	)

inline

Constructor.

使用通信器 comm、维度 n、本地维度 n_local 初始化 LaspackVector 对象并将所有元素初始化为零。

Set local dimension to n_local, the global dimension to n, and initialize all elements with zero. 构造函数。将向量的局部维度设置为 n_local，全局维度设置为 n，并将所有元素初始化为零。

参数

comm	通信器对象，用于并行计算。
n	向量的全局维度。
n_local	向量的局部维度。
parallel_type	并行类型，默认为 AUTOMATIC。

在文件 laspack_vector.h 第 579 行定义.

参考 libMesh::LaspackVector< T >::init().

   : NumericVector<T>(comm, ptype)
 {
   this->init(n, n_local, false, ptype);
 }

template<typename T >

libMesh::LaspackVector< T >::LaspackVector	(	const Parallel::Communicator &	comm,
		const numeric_index_type	N,
		const numeric_index_type	n_local,
		const std::vector< numeric_index_type > &	ghost,
		const ParallelType	ptype = `AUTOMATIC`
	)

inline

Constructor.

使用通信器 comm、维度 N、本地维度 n_local 和幽灵元素索引 ghost 初始化 LaspackVector 对象。

Set local dimension to n_local, the global dimension to n, but additionally reserve memory for the indices specified by the ghost argument. 构造函数。将向量的局部维度设置为 n_local，全局维度设置为 n，同时为 ghost 参数指定的索引保留内存。

参数

comm	通信器对象，用于并行计算。
N	向量的全局维度。
n_local	向量的局部维度。
ghost	要为其保留内存的索引。
parallel_type	并行类型，默认为 AUTOMATIC。

在文件 laspack_vector.h 第 594 行定义.

参考 libMesh::LaspackVector< T >::init().

   : NumericVector<T>(comm, ptype)
 {
   this->init(N, n_local, ghost, false, ptype);
 }

template<typename T>

libMesh::LaspackVector< T >::LaspackVector ( LaspackVector< T > && )

delete

This class manages a C-style struct (QVector) manually, so we don't want to allow any automatic copy/move functions to be generated, and we can't default the destructor.

由于这个类手动管理 C 风格的结构体 (QVector)，因此不希望生成任何自动生成的复制/移动函数，也不能默认析构函数。

template<typename T>

libMesh::LaspackVector< T >::LaspackVector ( const LaspackVector< T > & )

delete

template<typename T >

libMesh::LaspackVector< T >::~LaspackVector ( )

inlinevirtual

LaspackVector 对象的析构函数。

在文件 laspack_vector.h 第 610 行定义.

 {
   this->clear ();
 }

成员函数说明

template<typename T >

void libMesh::LaspackVector< T >::abs ( )

overridevirtual

计算向量的每个元素的绝对值。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 298 行定义.

参考 std::abs() , 以及 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   const numeric_index_type n = this->size();
 
   for (numeric_index_type i=0; i!=n; ++i)
     this->set(i,std::abs((*this)(i)));
 }

template<typename T >

void libMesh::LaspackVector< T >::add	(	const numeric_index_type	i,
		const T	value
	)

inlineoverridevirtual

将指定值添加到指定索引处的元素。

参数

i	索引值。
value	要添加的值。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.h 第 832 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_less (i, this->size());
 
   std::scoped_lock lock(this->_numeric_vector_mutex);
   V_AddCmp (&_vec, i+1, value);
 
 #ifndef NDEBUG
   this->_is_closed = false;
 #endif
 }

template<typename T >

void libMesh::LaspackVector< T >::add ( const T s )

overridevirtual

将指定的标量值添加到向量的每个元素。

参数

s 要添加的标量值。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 211 行定义.

 {
 #ifndef NDEBUG
   const bool was_closed = this->_is_closed;
 #endif
 
   const numeric_index_type n = this->size();
 
   for (numeric_index_type i=0; i<n; i++)
     this->add (i, v);
 
   // This is an embarrassingly parallel method, but set() isn't in
   // general so set() overzealously marked us as non-closed
 #ifndef NDEBUG
   this->_is_closed = was_closed;
 #endif
 }

template<typename T >

void libMesh::LaspackVector< T >::add ( const NumericVector< T > & v )

overridevirtual

将另一个向量的元素按元素加到该向量。

参数

v 要相加的向量。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 233 行定义.

 {
   this->add (1., v);
 }

template<typename T >

void libMesh::LaspackVector< T >::add	(	const T	a,
		const NumericVector< T > &	v
	)

overridevirtual

将另一个向量的元素按元素乘以标量值并添加到该向量。

参数

a	用于乘法的标量值。
v	要相加的向量。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 241 行定义.

参考 libMesh::LaspackVector< T >::size().

 {
   // Make sure the vector passed in is really a LaspackVector
   const LaspackVector * v = cast_ptr<const LaspackVector *>(&v_in);
 
 #ifndef NDEBUG
   const bool was_closed = this->_is_closed;
 #endif
 
   libmesh_assert(v);
   libmesh_assert_equal_to (this->size(), v->size());
 
   for (auto i : make_range(v->size()))
     this->add (i, a*(*v)(i));
 
 #ifndef NDEBUG
   this->_is_closed = was_closed;
 #endif
 }

template<typename T >

void libMesh::LaspackVector< T >::add_vector	(	const NumericVector< T > &	v,
		const SparseMatrix< T > &	A
	)

overridevirtual

将一个向量添加到该向量并将结果存储在其中。

参数

v	要相加的向量。
A	用于相加的稀疏矩阵。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 264 行定义.

参考 libMesh::LaspackVector< T >::_vec.

 {
   // Make sure the data passed in are really in Laspack types
   const LaspackVector<T> * vec = cast_ptr<const LaspackVector<T> *>(&vec_in);
   const LaspackMatrix<T> * mat = cast_ptr<const LaspackMatrix<T> *>(&mat_in);
 
   libmesh_assert(vec);
   libmesh_assert(mat);
 
   // += mat*vec
   AddAsgn_VV (&_vec, Mul_QV(const_cast<QMatrix*>(&mat->_QMat),
                             const_cast<QVector*>(&vec->_vec)));
 }

template<typename T >

void libMesh::NumericVector< T >::add_vector	(	const T *	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

virtualinherited

计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 v 是一个指针，每个 dof_indices[i] 指定了要添加的值 v[i] 的位置。这应该在子类中进行重写以提高效率。请注意，此方法的库实现是线程安全的。

参数

v	一个指向值的指针。
dof_indices	每个要添加值的位置的索引集合。

被 libMesh::PetscVector< T > , 以及 libMesh::EpetraVector< T > 重载.

在文件 numeric_vector.C 第 379 行定义.

参考自 libMesh::SparseMatrix< T >::vector_mult_add().

 {
   libmesh_assert(v);
 
   for (auto i : index_range(dof_indices))
     this->add (dof_indices[i], v[i]);
 }

template<typename T >

void libMesh::NumericVector< T >::add_vector	(	const std::vector< T > &	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

inlineinherited

计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 v 是一个 std::vector，每个 dof_indices[i] 指定了要添加的值 v[i] 的位置默认实现对每个索引调用 operator() ，但某些实现可能在此处提供更快的方法。请注意，此方法的库实现是线程安全的。

参数

v	包含要添加的值的 std::vector。
dof_indices	每个要添加值的位置的索引集合。

在文件 numeric_vector.h 第 1041 行定义.

 {
   libmesh_assert(v.size() == dof_indices.size());
   if (!v.empty())
     this->add_vector(v.data(), dof_indices);
 }

template<typename T >

void libMesh::NumericVector< T >::add_vector	(	const NumericVector< T > &	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

inherited

计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 v 是一个 NumericVector，每个 dof_indices[i] 指定了要添加的值 v(i) 的位置。此方法是线程安全的。

参数

v	另一个数值向量。
dof_indices	每个要添加值的位置的索引集合。

在文件 numeric_vector.C 第 391 行定义.

参考 libMesh::NumericVector< T >::readable() , 以及 libMesh::NumericVector< T >::size().

 {
   libmesh_assert(v.readable());
 
   const std::size_t n = dof_indices.size();
   libmesh_assert_equal_to(v.size(), n);
   for (numeric_index_type i=0; i != n; i++)
     this->add (dof_indices[i], v(i));
 }

template<typename T >

void libMesh::NumericVector< T >::add_vector	(	const DenseVector< T > &	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

inlineinherited

计算 $\vec{u} \leftarrow \vec{u} + \vec{v}$ ，其中 v 是一个 DenseVector，每个 dof_indices[i] 指定了要添加的值 v(i) 的位置。此方法是线程安全的。

参数

v	另一个数值向量。
dof_indices	每个要添加值的位置的索引集合。

在文件 numeric_vector.h 第 1053 行定义.

参考 libMesh::DenseVector< T >::empty() , 以及 libMesh::DenseVector< T >::size().

 {
   libmesh_assert(v.size() == dof_indices.size());
   if (!v.empty())
     this->add_vector(&v(0), dof_indices);
 }

template<typename T >

void libMesh::NumericVector< T >::add_vector	(	const NumericVector< T > &	v,
		const ShellMatrix< T > &	A
	)

inherited

计算 $\vec{u} \leftarrow \vec{u} + A \vec{v}$ ，即将 ShellMatrix A 和 NumericVector v 的乘积添加到 this。

参数

v	另一个数值向量。
A	Shell 矩阵。

在文件 numeric_vector.C 第 405 行定义.

参考 libMesh::ShellMatrix< T >::vector_mult_add().

 {
   libmesh_assert(this->compatible(v));
 
   a.vector_mult_add(*this,v);
 }

template<typename T >

void libMesh::LaspackVector< T >::add_vector_transpose	(	const NumericVector< T > &	v,
		const SparseMatrix< T > &	A
	)

overridevirtual

将一个向量的转置添加到该向量并将结果存储在其中。

参数

v	要相加的向量的转置。
A	用于相加的稀疏矩阵。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 281 行定义.

 {
   libmesh_not_implemented();
 }

template<typename T >

std::unique_ptr< NumericVector< T > > libMesh::NumericVector< T >::build	(	const Parallel::Communicator &	comm,
		const SolverPackage	solver_package = `libMesh::default_solver_package()`
	)

staticinherited

构建一个 NumericVector 对象。

参数

comm	通信器对象，表示通信方式。
solver_package	线性求解器包的类型。

返回: 指向构建的 NumericVector 对象的 unique_ptr。

在文件 numeric_vector.C 第 50 行定义.

参考 libMesh::EIGEN_SOLVERS, libMesh::LASPACK_SOLVERS , 以及 libMesh::TRILINOS_SOLVERS.

参考自 libMesh::DiagonalMatrix< T >::DiagonalMatrix(), libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::DofMap::enforce_constraints_on_residual() , 以及 libMesh::DofMap::process_mesh_constraint_rows().

 {
   // Build the appropriate vector
   switch (solver_package)
     {
 
 #ifdef LIBMESH_HAVE_LASPACK
     case LASPACK_SOLVERS:
       return std::make_unique<LaspackVector<T>>(comm, AUTOMATIC);
 #endif
 
 #ifdef LIBMESH_HAVE_PETSC
     case PETSC_SOLVERS:
       return std::make_unique<PetscVector<T>>(comm, AUTOMATIC);
 #endif
 
 #ifdef LIBMESH_TRILINOS_HAVE_EPETRA
     case TRILINOS_SOLVERS:
       return std::make_unique<EpetraVector<T>>(comm, AUTOMATIC);
 #endif
 
 #ifdef LIBMESH_HAVE_EIGEN
     case EIGEN_SOLVERS:
       return std::make_unique<EigenSparseVector<T>>(comm, AUTOMATIC);
 #endif
 
     default:
       return std::make_unique<DistributedVector<T>>(comm, AUTOMATIC);
     }
 }

template<typename T >

void libMesh::LaspackVector< T >::clear ( )

inlineoverridevirtual

Clear the vector.

清空向量，将所有元素设为零。

重载 libMesh::NumericVector< T > .

在文件 laspack_vector.h 第 715 行定义.

参考 libMesh::libMeshPrivateData::_is_initialized , 以及 libMesh::initialized().

 {
   if (this->initialized())
     {
       V_Destr (&_vec);
     }
 
   this->_is_initialized = false;
 #ifndef NDEBUG
   this->_is_closed = false;
 #endif
 }

template<typename T >

std::unique_ptr< NumericVector< T > > libMesh::LaspackVector< T >::clone ( ) const

inlineoverridevirtual

创建并返回一个指向该对象的克隆的 unique_ptr。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.h 第 756 行定义.

参考 libMesh::NumericVector< T >::init().

 {
   NumericVector<T> * cloned_vector = new LaspackVector<T>(this->comm());
 
   cloned_vector->init(*this, true);
 
   *cloned_vector = *this;
 
   return std::unique_ptr<NumericVector<T>>(cloned_vector);
 }

template<typename T >

void libMesh::LaspackVector< T >::close ( )

inlineoverridevirtual

Close the vector.

关闭向量。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.h 第 702 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
 #ifndef NDEBUG
   this->_is_closed = true;
 #endif
 }

template<typename T>

virtual bool libMesh::NumericVector< T >::closed ( ) const

inlinevirtualinherited

检查向量是否已经关闭并准备好进行计算。

返回: 如果向量已经关闭并准备好进行计算，则返回 true；否则返回 false。

在文件 numeric_vector.h 第 180 行定义.

参考 libMesh::NumericVector< T >::_is_closed.

参考自 libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::PetscVector< T >::localize(), libMesh::DofMap::max_constraint_error(), libMesh::EigenSparseVector< T >::operator=(), libMesh::LaspackVector< T >::operator=() , 以及 libMesh::PetscVector< T >::operator=().

180 { return _is_closed; }

libMesh::NumericVector::_is_closed

bool _is_closed

用于跟踪向量的值在在一些或全部处理器上进行插入或添加值操作后是否在所有处理器上保持一致的标志。

Definition: numeric_vector.h:913

template<typename T >

int libMesh::NumericVector< T >::compare	(	const NumericVector< T > &	other_vector,
		const Real	threshold = `TOLERANCE`
	)		const

virtualinherited

比较 this 与 other_vector 的等效性，（在给定的 threshold 内）如果等效则返回 -1 ，或者返回第一个索引，其中 abs(a[i]-b[i]) 超过阈值。

注解: "等效" 表示两个向量非常相似或几乎相同，其差异小于或等于给定的阈值。这个阈值通常用于考虑浮点数精度问题，因为在计算机中，浮点数运算可能会导致微小的数值差异。当两个向量被认为等效时，它们的差异小于或等于阈值。具体来说，这是通过计算两个向量的每个元素之间的差异并将其与阈值进行比较来确定的。如果两个向量的差异小于阈值，就可以说它们是等效的。否则，如果差异大于阈值，就可以说它们不等效。

参数

other_vector	另一个数值向量。
threshold	阈值。

返回: 如果向量等效则返回 -1 ，否则返回第一个不等效的索引。

在文件 numeric_vector.C 第 109 行定义.

参考 std::abs().

 {
   libmesh_assert(this->compatible(other_vector));
 
   int first_different_i = std::numeric_limits<int>::max();
   numeric_index_type i = first_local_index();
 
   while (first_different_i==std::numeric_limits<int>::max()
          && i<last_local_index())
   {
     if (std::abs((*this)(i) - other_vector(i)) > threshold)
       first_different_i = i;
     else
       i++;
   }
 
   // Find the correct first differing index in parallel
   this->comm().min(first_different_i);
 
   if (first_different_i == std::numeric_limits<int>::max())
     return -1;
 
   return first_different_i;
 }

template<typename T >

bool libMesh::NumericVector< T >::compatible ( const NumericVector< T > & v ) const

inherited

检查该向量和向量 v 是否能够一起用于全局操作。

参数

v	要比较的另一个向量。

返回: 如果这两个向量可以一起用于全局操作，则返回 true，否则返回 false。

在文件 numeric_vector.C 第 423 行定义.

参考 libMesh::NumericVector< T >::first_local_index(), libMesh::NumericVector< T >::last_local_index(), libMesh::NumericVector< T >::local_size(), libMesh::NumericVector< T >::readable() , 以及 libMesh::NumericVector< T >::size().

 {
   return this->readable() && v.readable() &&
          this->size() == v.size() &&
          this->local_size() == v.local_size() &&
          this->first_local_index() == v.first_local_index() &&
          this->last_local_index() == v.last_local_index();
 }

template<typename T >

void libMesh::LaspackVector< T >::conjugate ( )

overridevirtual

计算向量中所有元素的复共轭。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 187 行定义.

参考 libMesh::libmesh_conj().

 {
   const numeric_index_type n = this->size();
 
 #ifndef NDEBUG
   const bool was_closed = this->_is_closed;
 #endif
 
   for (numeric_index_type i=0; i<n; i++)
     {
       T v = (*this)(i);
 
       this->set(i, libmesh_conj(v) );
     }
 
   // This is an embarrassingly parallel method, but set() isn't in
   // general so set() overzealously marked us as non-closed
 #ifndef NDEBUG
   this->_is_closed = was_closed;
 #endif
 }

template<typename T>

virtual void libMesh::NumericVector< T >::create_subvector	(	NumericVector< T > &	subvector,
		const std::vector< numeric_index_type > &	rows
	)		const

inlinevirtualinherited

使用 rows 中的索引从该向量中填充 subvector。类似于 SparseMatrix 类的 create_submatrix() 函数，当前仅对 PetscVectors 实现了此功能。

参数

subvector	要填充的子向量。
rows	包含用于选择要填充到子向量的索引的向量。

被 libMesh::PetscVector< T > , 以及 libMesh::EpetraVector< T > 重载.

在文件 numeric_vector.h 第 871 行定义.

   {
     libmesh_not_implemented();
   }

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

在文件 reference_counter.C 第 100 行定义.

参考 libMesh::ReferenceCounter::_enable_print_counter.

 {
   _enable_print_counter = false;
   return;
 }

template<typename T >

T libMesh::LaspackVector< T >::dot ( const NumericVector< T > & v ) const

overridevirtual

计算向量与另一个向量的点积。

参数

v	用于计算点积的向量。

返回: 点积的结果。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 309 行定义.

参考 libMesh::LaspackVector< T >::_vec , 以及 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   // Make sure the NumericVector passed in is really a LaspackVector
   const LaspackVector<T> * v = cast_ptr<const LaspackVector<T> *>(&v_in);
   libmesh_assert(v);
 
   return Mul_VV (const_cast<QVector*>(&(this->_vec)),
                  const_cast<QVector*>(&(v->_vec)));
 }

template<typename T>

virtual T libMesh::NumericVector< T >::el ( const numeric_index_type i ) const

inlinevirtualinherited

获取向量的第 i 个条目。

参数

i	要获取的条目的索引。

返回: 第 i 个条目的值。

在文件 numeric_vector.h 第 416 行定义.

416 { return (*this)(i); }

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

Methods to enable/disable the reference counter output from print_info()

在文件 reference_counter.C 第 94 行定义.

参考 libMesh::ReferenceCounter::_enable_print_counter.

 {
   _enable_print_counter = true;
   return;
 }

template<typename T >

numeric_index_type libMesh::LaspackVector< T >::first_local_index ( ) const

inlineoverridevirtual

返回向量的第一个局部索引。

返回: 向量的第一个局部索引。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.h 第 793 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   return 0;
 }

template<typename T >

void libMesh::NumericVector< T >::get	(	const std::vector< numeric_index_type > &	index,
		T *	values
	)		const

inlinevirtualinherited

一次访问多个组件。 values 将 *不会* 重新分配空间；它应该已经具有足够的空间。默认实现对每个索引调用 operator() ，但某些实现可能在此处提供更快的方法。

参数

index	要获取的索引集合。
values	存储获取值的数组。

被 libMesh::PetscVector< T > 重载.

在文件 numeric_vector.h 第 1012 行定义.

参考自 libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::DofMap::enforce_constraints_on_residual() , 以及 libMesh::DofMap::max_constraint_error().

 {
   const std::size_t num = index.size();
   for (std::size_t i=0; i<num; i++)
     {
       values[i] = (*this)(index[i]);
     }
 }

template<typename T >

void libMesh::NumericVector< T >::get	(	const std::vector< numeric_index_type > &	index,
		std::vector< T > &	values
	)		const

inlineinherited

一次访问多个组件。 values 将被调整大小，如果需要，将被填充。默认实现对每个索引调用 operator() ，但某些实现可能在此处提供更快的方法。

参数

index	要获取的索引集合。
values	存储获取值的向量。

在文件 numeric_vector.h 第 1026 行定义.

 {
   const std::size_t num = index.size();
   values.resize(num);
   if (!num)
     return;
 
   this->get(index, values.data());
 }

std::string libMesh::ReferenceCounter::get_info ( )

staticinherited

Gets a string containing the reference information.

在文件 reference_counter.C 第 47 行定义.

参考 libMesh::ReferenceCounter::_counts.

参考自 libMesh::ReferenceCounter::print_info().

 {
 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
   std::ostringstream oss;
 
   oss << '\n'
       << " ---------------------------------------------------------------------------- \n"
       << "| Reference count information                                                |\n"
       << " ---------------------------------------------------------------------------- \n";
 
   for (const auto & [name, cd] : _counts)
     oss << "| " << name << " reference count information:\n"
         << "|  Creations:    " << cd.first    << '\n'
         << "|  Destructions: " << cd.second << '\n';
 
   oss << " ---------------------------------------------------------------------------- \n";
 
   return oss.str();
 
 #else
 
   return "";
 
 #endif
 }

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string & name )

inlineprotectednoexceptinherited

Increments the construction counter.

Should be called in the constructor of any derived class that will be reference counted.

在文件 reference_counter.h 第 183 行定义.

参考 libMesh::err.

参考自 libMesh::ReferenceCountedObject< SparseMatrix< T > >::ReferenceCountedObject().

 {
   libmesh_try
   {
     Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     std::pair<unsigned int, unsigned int> & p = _counts[name];
     p.first++;
   }
   libmesh_catch (...)
   {
     auto stream = libMesh::err.get();
     stream->exceptions(stream->goodbit); // stream must not throw
     libMesh::err << "Encountered unrecoverable error while calling "
                  << "ReferenceCounter::increment_constructor_count() "
                  << "for a(n) " << name << " object." << std::endl;
     std::terminate();
   }
 }

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string & name )

inlineprotectednoexceptinherited

Increments the destruction counter.

Should be called in the destructor of any derived class that will be reference counted.

在文件 reference_counter.h 第 207 行定义.

参考 libMesh::err.

参考自 libMesh::ReferenceCountedObject< SparseMatrix< T > >::~ReferenceCountedObject().

 {
   libmesh_try
   {
     Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     std::pair<unsigned int, unsigned int> & p = _counts[name];
     p.second++;
   }
   libmesh_catch (...)
   {
     auto stream = libMesh::err.get();
     stream->exceptions(stream->goodbit); // stream must not throw
     libMesh::err << "Encountered unrecoverable error while calling "
                  << "ReferenceCounter::increment_destructor_count() "
                  << "for a(n) " << name << " object." << std::endl;
     std::terminate();
   }
 }

template<typename T>

virtual void libMesh::LaspackVector< T >::init	(	const numeric_index_type	N,
		const numeric_index_type	n_local,
		const bool	fast = `false`,
		const ParallelType	ptype = `AUTOMATIC`
	)

overridevirtual

使用给定的全局大小和局部大小初始化向量。

参数

N	向量的全局维度。
n_local	向量的局部维度。
fast	快速初始化标志，默认为 false。
ptype	并行类型，默认为 AUTOMATIC。

实现了 libMesh::NumericVector< T >.

参考自 libMesh::LaspackVector< T >::LaspackVector().

template<typename T >

void libMesh::LaspackVector< T >::init	(	const numeric_index_type	N,
		const bool	fast = `false`,
		const ParallelType	ptype = `AUTOMATIC`
	)

inlineoverridevirtual

使用给定的全局大小初始化向量。

参数

N	向量的全局维度。
fast	快速初始化标志，默认为 false。
ptype	并行类型，默认为 AUTOMATIC。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.h 第 667 行定义.

 {
   this->init(n,n,fast,ptype);
 }

template<typename T>

virtual void libMesh::LaspackVector< T >::init	(	const numeric_index_type	N,
		const numeric_index_type	n_local,
		const std::vector< numeric_index_type > &	ghost,
		const bool	fast = `false`,
		const ParallelType	= `AUTOMATIC`
	)

overridevirtual

使用给定的全局大小、局部大小和 ghost 参数指定的索引初始化向量，并为其保留内存。

参数

N	向量的全局维度。
n_local	向量的局部维度。
ghost	要为其保留内存的索引。
fast	快速初始化标志，默认为 false。
ptype	并行类型，默认为 AUTOMATIC。

实现了 libMesh::NumericVector< T >.

template<class T >

void libMesh::LaspackVector< T >::init	(	const NumericVector< T > &	other,
		const bool	fast = `false`
	)

overridevirtual

使用另一个向量的内容初始化向量。

参数

other	要复制内容的向量。
fast	快速初始化标志，默认为 false。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.h 第 692 行定义.

参考 libMesh::NumericVector< T >::local_size(), libMesh::NumericVector< T >::size() , 以及 libMesh::NumericVector< T >::type().

 {
   this->init(other.size(),other.local_size(),fast,other.type());
 }

template<typename T>

virtual bool libMesh::NumericVector< T >::initialized ( ) const

inlinevirtualinherited

检查向量是否已经初始化。

返回: 如果向量已经初始化，则返回 true；否则返回 false。

在文件 numeric_vector.h 第 159 行定义.

参考 libMesh::NumericVector< T >::_is_initialized.

参考自 libMesh::PetscVector< T >::create_subvector() , 以及 libMesh::PetscVector< T >::init().

159 { return _is_initialized; }

libMesh::NumericVector::_is_initialized

bool _is_initialized

在调用 init() 后设置为 true。

Definition: numeric_vector.h:918

template<typename T >

void libMesh::NumericVector< T >::insert	(	const T *	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

virtualinherited

将 v 的条目插入到 *this 中，位置由 dof_indices 指定。请注意，此方法的库实现是线程安全的。

参数

v	一个指向值的指针。
dof_indices	每个要插入值的位置的索引集合。

被 libMesh::PetscVector< T > , 以及 libMesh::EpetraVector< T > 重载.

在文件 numeric_vector.C 第 84 行定义.

 {
   libmesh_assert (v);
 
   for (auto i : index_range(dof_indices))
     this->set (dof_indices[i], v[i]);
 }

template<typename T >

void libMesh::NumericVector< T >::insert	(	const NumericVector< T > &	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

inherited

将 v 的条目插入到 *this 中，位置由 v 指定。只要使用 NumericVector 的库实现，此方法是线程安全的。

参数

v	一个数值向量。
dof_indices	每个要插入值的位置的索引集合。

在文件 numeric_vector.C 第 96 行定义.

参考 libMesh::NumericVector< T >::readable() , 以及 libMesh::NumericVector< T >::size().

 {
   libmesh_assert_equal_to (V.size(), dof_indices.size());
   libmesh_assert (V.readable());
 
   for (auto i : index_range(dof_indices))
     this->set (dof_indices[i], V(i));
 }

template<typename T >

void libMesh::NumericVector< T >::insert	(	const DenseVector< T > &	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

inlineinherited

将 v 的条目插入到 *this 中，位置由 v 指定。只要使用 NumericVector 的库实现，此方法是线程安全的。

参数

v	一个 DenseVector。
dof_indices	每个要插入值的位置的索引集合。

在文件 numeric_vector.h 第 1077 行定义.

参考 libMesh::DenseVector< T >::empty() , 以及 libMesh::DenseVector< T >::size().

 {
   libmesh_assert(v.size() == dof_indices.size());
   if (!v.empty())
     this->insert(&v(0), dof_indices);
 }

template<typename T >

void libMesh::NumericVector< T >::insert	(	const DenseSubVector< T > &	v,
		const std::vector< numeric_index_type > &	dof_indices
	)

inlineinherited

将 v 的条目插入到 *this 中，位置由 v 指定。只要使用 NumericVector 的库实现，此方法是线程安全的。

参数

v	一个 DenseSubVector。
dof_indices	每个要插入值的位置的索引集合。

在文件 numeric_vector.h 第 1089 行定义.

参考 libMesh::DenseSubVector< T >::empty() , 以及 libMesh::DenseSubVector< T >::size().

 {
   libmesh_assert(v.size() == dof_indices.size());
   if (!v.empty())
     this->insert(&v(0), dof_indices);
 }

template<typename T >

Real libMesh::LaspackVector< T >::l1_norm ( ) const

overridevirtual

返回向量的 L1 范数。

返回: L1 范数的值。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 54 行定义.

参考 libMesh::closed() , 以及 libMesh::Real.

 {
   libmesh_assert (this->closed());
 
   return static_cast<Real>(l1Norm_V(const_cast<QVector*>(&_vec)));
 }

template<typename T >

Real libMesh::LaspackVector< T >::l2_norm ( ) const

overridevirtual

返回向量的 L2 范数。

返回: L2 范数的值。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 64 行定义.

参考 libMesh::closed() , 以及 libMesh::Real.

 {
   libmesh_assert (this->closed());
 
   return static_cast<Real>(l2Norm_V(const_cast<QVector*>(&_vec)));
 }

template<class T >

Real libMesh::NumericVector< T >::l2_norm_diff ( const NumericVector< T > & other_vec ) const

inherited

获取 $\ell_2$ -范数的向量差值 $\vec{u} - \vec{v}$ ，其中 $\vec{u}$ 是 this。

参数

other_vec 另一个数值向量。

返回: $\ell_2$ -范数的向量差值。

在文件 numeric_vector.C 第 363 行定义.

参考 std::norm(), libMesh::TensorTools::norm_sq(), libMesh::Real , 以及 std::sqrt().

 {
   libmesh_assert(this->compatible(v));
 
   Real norm = 0;
   for (const auto i : make_range(this->first_local_index(), this->last_local_index()))
     norm += TensorTools::norm_sq((*this)(i) - v(i));
 
   this->comm().sum(norm);
 
   return std::sqrt(norm);
 }

template<typename T >

numeric_index_type libMesh::LaspackVector< T >::last_local_index ( ) const

inlineoverridevirtual

返回向量的最后一个局部索引。

返回: 向量的最后一个局部索引。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.h 第 804 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   return this->size();
 }

template<typename T >

Real libMesh::LaspackVector< T >::linfty_norm ( ) const

overridevirtual

返回向量的 Linfinity 范数。

返回: Linfinity 范数的值。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 74 行定义.

参考 libMesh::closed() , 以及 libMesh::Real.

 {
   libmesh_assert (this->closed());
 
   return static_cast<Real>(MaxNorm_V(const_cast<QVector*>(&_vec)));
 }

template<typename T >

int libMesh::NumericVector< T >::local_relative_compare	(	const NumericVector< T > &	other_vector,
		const Real	threshold = `TOLERANCE`
	)		const

virtualinherited

比较该向量与另一个向量的局部相对差异。

如果两个向量在给定的局部相对阈值 abs(a[i]-b[i])/max(a[i],b[i]) 下等效，则返回-1，否则返回首个不等效的索引。

参数

other_vector	要比较的另一个向量。
threshold	允许的局部相对差异阈值（可选，默认值为 TOLERANCE）。

返回: -1 表示等效，否则返回不等效的索引。

在文件 numeric_vector.C 第 137 行定义.

参考 std::abs().

 {
   libmesh_assert(this->compatible(other_vector));
 
   int first_different_i = std::numeric_limits<int>::max();
   numeric_index_type i = first_local_index();
 
   do
     {
       if (std::abs((*this)(i) - other_vector(i)) > threshold *
           std::max(std::abs((*this)(i)), std::abs(other_vector(i))))
         first_different_i = i;
       else
         i++;
     }
   while (first_different_i==std::numeric_limits<int>::max()
          && i<last_local_index());
 
   // Find the correct first differing index in parallel
   this->comm().min(first_different_i);
 
   if (first_different_i == std::numeric_limits<int>::max())
     return -1;
 
   return first_different_i;
 }

template<typename T >

numeric_index_type libMesh::LaspackVector< T >::local_size ( ) const

inlineoverridevirtual

返回向量的局部大小（局部维度）。

返回: 向量的局部大小。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.h 第 782 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   return this->size();
 }

template<typename T >

void libMesh::LaspackVector< T >::localize ( std::vector< T > & v_local ) const

overridevirtual

将向量的元素本地化，以便在不同处理器之间交换。

参数

v_local 存储本地化后的元素的向量。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 456 行定义.

 {
   v_local.resize(this->size());
 
   for (auto i : index_range(v_local))
     v_local[i] = (*this)(i);
 }

template<typename T >

void libMesh::LaspackVector< T >::localize ( NumericVector< T > & v_local ) const

overridevirtual

将向量的元素本地化，以便在不同处理器之间交换。

参数

v_local 存储本地化后的元素的向量。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 396 行定义.

 {
   // Make sure the NumericVector passed in is really a LaspackVector
   LaspackVector<T> * v_local =
     cast_ptr<LaspackVector<T> *>(&v_local_in);
 
   libmesh_assert(v_local);
 
   *v_local = *this;
 }

template<typename T>

virtual void libMesh::LaspackVector< T >::localize	(	NumericVector< T > &	v_local,
		const std::vector< numeric_index_type > &	send_list
	)		const

overridevirtual

将向量的元素本地化，以便在不同处理器之间交换，但仅发送指定的索引。

参数

v_local	存储本地化后的元素的向量。
send_list	要发送的索引列表。

实现了 libMesh::NumericVector< T >.

template<typename T >

void libMesh::LaspackVector< T >::localize	(	std::vector< T > &	v_local,
		const std::vector< numeric_index_type > &	indices
	)		const

overridevirtual

将向量的元素本地化，以便在不同处理器之间交换，但仅发送指定的索引。

参数

v_local	存储本地化后的元素的向量。
indices	要发送的索引。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 426 行定义.

 {
   // LaspackVectors are serial, so we can just copy values
   v_local.resize(indices.size());
 
   for (auto i : index_range(v_local))
     v_local[i] = (*this)(indices[i]);
 }

template<typename T>

virtual void libMesh::LaspackVector< T >::localize	(	const numeric_index_type	first_local_idx,
		const numeric_index_type	last_local_idx,
		const std::vector< numeric_index_type > &	send_list
	)

overridevirtual

本地化向量的一部分，以便在不同处理器之间交换，但仅发送指定的索引。

参数

first_local_idx	本地索引范围的起始索引。
last_local_idx	本地索引范围的结束索引。
send_list	要发送的索引列表。

实现了 libMesh::NumericVector< T >.

template<typename T>

void libMesh::LaspackVector< T >::localize_to_one	(	std::vector< T > &	v_local,
		const processor_id_type	proc_id = `0`
	)		const

overridevirtual

将向量本地化到指定处理器。

参数

v_local	存储本地化后的元素的向量。
proc_id	目标处理器的ID。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 468 行定义.

 {
   libmesh_assert_equal_to (pid, 0);
 
   this->localize (v_local);
 }

template<typename T >

Real libMesh::LaspackVector< T >::max ( ) const

overridevirtual

返回向量的最大元素。

返回: 最大元素的值。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 493 行定义.

参考 libMesh::initialized(), libMesh::libmesh_real() , 以及 libMesh::Real.

 {
   libmesh_assert (this->initialized());
   if (!this->size())
     return -std::numeric_limits<Real>::max();
 
   Real the_max = libmesh_real((*this)(0));
 
   const numeric_index_type n = this->size();
 
   for (numeric_index_type i=1; i<n; i++)
     the_max = std::max (the_max, libmesh_real((*this)(i)));
 
   return the_max;
 }

template<typename T >

std::size_t libMesh::LaspackVector< T >::max_allowed_id ( ) const

inlineoverridevirtual

获取允许的最大ID（索引）。

返回: 最大允许的ID。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.h 第 886 行定义.

 {
   // The QVector type declares a "size_t Dim;"
   return std::numeric_limits<std::size_t>::max();
 }

template<typename T >

Real libMesh::LaspackVector< T >::min ( ) const

overridevirtual

返回向量的最小元素。

返回: 最小元素的值。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 512 行定义.

参考 libMesh::initialized(), libMesh::libmesh_real() , 以及 libMesh::Real.

 {
   libmesh_assert (this->initialized());
   if (!this->size())
     return std::numeric_limits<Real>::max();
 
   Real the_min = libmesh_real((*this)(0));
 
   const numeric_index_type n = this->size();
 
   for (numeric_index_type i=1; i<n; i++)
     the_min = std::min (the_min, libmesh_real((*this)(i)));
 
   return the_min;
 }

static unsigned int libMesh::ReferenceCounter::n_objects ( )

inlinestaticinherited

Prints the number of outstanding (created, but not yet destroyed) objects.

在文件 reference_counter.h 第 85 行定义.

参考 libMesh::ReferenceCounter::_n_objects.

参考自 libMesh::LibMeshInit::~LibMeshInit().

86 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition: reference_counter.h:132

template<typename T >

T libMesh::LaspackVector< T >::operator() ( const numeric_index_type i ) const

inlineoverridevirtual

返回指定索引处向量的值。

参数

i 索引值。

返回: 指定索引处的向量元素的值。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.h 第 849 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert ( ((i >= this->first_local_index()) &&
                     (i <  this->last_local_index())) );
 
 
   return static_cast<T>(V_GetCmp(const_cast<QVector*>(&_vec), i+1));
 }

template<typename T >

NumericVector< T > & libMesh::LaspackVector< T >::operator*= ( const NumericVector< T > & v )

overridevirtual

将该向量的元素按元素与另一个向量的元素相乘。

参数

v 用于相乘的向量。

返回: 指向 *this 的引用作为派生类型。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 109 行定义.

参考 libMesh::NumericVector< T >::size().

 {
   libmesh_assert_equal_to(size(), v.size());
 
 #ifndef NDEBUG
   const bool was_closed = this->_is_closed;
 #endif
 
   const numeric_index_type n = this->size();
 
   for (numeric_index_type i=0; i<n; i++)
     this->set(i, (*this)(i) * v(i));
 
   // This is an embarrassingly parallel method, but set() isn't in
   // general so set() overzealously marked us as non-closed
 #ifndef NDEBUG
   this->_is_closed = was_closed;
 #endif
 
   return *this;
 }

template<typename T>

NumericVector<T>& libMesh::NumericVector< T >::operator*= ( const T a )

inlineinherited

将向量缩放为 a ， $\vec{u} \leftarrow a\vec{u}$ 。等价于 u.scale(a)。

参数

a 缩放因子。

返回: 对 *this 的引用。

在文件 numeric_vector.h 第 463 行定义.

参考 libMesh::NumericVector< T >::scale().

463 { this->scale(a); return *this; }

libMesh::NumericVector::scale

virtual void scale(const T factor)=0

缩放向量的每个元素。

template<typename T >

NumericVector< T > & libMesh::LaspackVector< T >::operator+= ( const NumericVector< T > & v )

overridevirtual

将另一个向量的元素按元素加到该向量。

参数

v 要相加的向量。

返回: 指向 *this 的引用作为派生类型。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 84 行定义.

参考 libMesh::closed().

 {
   libmesh_assert (this->closed());
 
   this->add(1., v);
 
   return *this;
 }

template<typename T >

NumericVector< T > & libMesh::LaspackVector< T >::operator-= ( const NumericVector< T > & v )

overridevirtual

将另一个向量的元素按元素从该向量中减去。

参数

v 要相减的向量。

返回: 指向 *this 的引用作为派生类型。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 97 行定义.

参考 libMesh::closed().

 {
   libmesh_assert (this->closed());
 
   this->add(-1., v);
 
   return *this;
 }

template<typename T >

NumericVector< T > & libMesh::LaspackVector< T >::operator/= ( const NumericVector< T > & v )

overridevirtual

将该向量的元素按元素除以另一个向量的元素。

参数

v 用于相除的向量。

返回: 指向 *this 的引用作为派生类型。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 134 行定义.

参考 libMesh::NumericVector< T >::size().

 {
   libmesh_assert_equal_to(size(), v.size());
 
 #ifndef NDEBUG
   const bool was_closed = this->_is_closed;
 #endif
 
   const numeric_index_type n = this->size();
 
   for (numeric_index_type i=0; i<n; i++)
     this->set(i, (*this)(i) / v(i));
 
   // This is an embarrassingly parallel method, but set() isn't in
   // general so set() overzealously marked us as non-closed
 #ifndef NDEBUG
   this->_is_closed = was_closed;
 #endif
 
   return *this;
 }

template<typename T>

NumericVector<T>& libMesh::NumericVector< T >::operator/= ( const T a )

inlineinherited

将向量缩放为 1/a ， $\vec{u} \leftarrow \frac{1}{a}\vec{u}$ 。等价于 u.scale(1.

/a)。

参数

a 缩放因子。

返回: 对 *this 的引用。

在文件 numeric_vector.h 第 481 行定义.

参考 libMesh::NumericVector< T >::scale().

481 { this->scale(1./a); return *this; }

libMesh::NumericVector::scale

virtual void scale(const T factor)=0

缩放向量的每个元素。

template<typename T >

LaspackVector< T > & libMesh::LaspackVector< T >::operator= ( const LaspackVector< T > & v )

Copy assignment operator.

Calls Asgn_VV() to assign the contents of one vector to another. 赋值运算符，用于将一个向量的内容赋值给另一个向量。

参数

v 要赋值的向量。

返回: 指向 *this 的引用作为派生类型。

在文件 laspack_vector.C 第 356 行定义.

参考 libMesh::LaspackVector< T >::_vec, libMesh::NumericVector< T >::closed(), libMesh::initialized() , 以及 libMesh::LaspackVector< T >::size().

 {
   libmesh_assert (this->initialized());
   libmesh_assert (v.closed());
   libmesh_assert_equal_to (this->size(), v.size());
 
   if (v.size() != 0)
     Asgn_VV (const_cast<QVector*>(&_vec),
              const_cast<QVector*>(&v._vec)
              );
 
 #ifndef NDEBUG
   this->_is_closed = true;
 #endif
 
   return *this;
 }

template<typename T>

LaspackVector& libMesh::LaspackVector< T >::operator= ( LaspackVector< T > && )

delete

template<typename T >

NumericVector< T > & libMesh::LaspackVector< T >::operator= ( const T s )

overridevirtual

将标量值赋给向量的所有元素。

参数

s 要赋值的标量。

返回: 指向 *this 的引用作为派生类型。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 325 行定义.

参考 libMesh::closed() , 以及 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert (this->closed());
 
   V_SetAllCmp (&_vec, s);
 
   return *this;
 }

template<typename T >

NumericVector< T > & libMesh::LaspackVector< T >::operator= ( const NumericVector< T > & v )

overridevirtual

将一个向量的内容赋值给另一个向量。

参数

v 要赋值的向量。

返回: 指向 *this 的引用作为派生类型。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 339 行定义.

 {
   // Make sure the NumericVector passed in is really a LaspackVector
   const LaspackVector<T> * v =
     cast_ptr<const LaspackVector<T> *>(&v_in);
 
   libmesh_assert(v);
 
   *this = *v;
 
   return *this;
 }

template<typename T >

NumericVector< T > & libMesh::LaspackVector< T >::operator= ( const std::vector< T > & v )

overridevirtual

将一个 std::vector 的内容赋给向量。

参数

v	要赋值的 std::vector。

返回: 指向 *this 的引用作为派生类型。

Case 1: The vector is the same size of The global vector. Only add the local components.

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 378 行定义.

 {
   if (this->size() == v.size())
     for (auto i : index_range(v))
       this->set (i, v[i]);
 
   else
     libmesh_error_msg("this->size() = " << this->size() << " must be equal to v.size() = " << v.size());
 
   return *this;
 }

template<typename T >

void libMesh::LaspackVector< T >::pointwise_divide	(	const NumericVector< T > &	vec1,
		const NumericVector< T > &	vec2
	)

overridevirtual

对向量的每个元素执行逐元素除法。

参数

vec1	用于逐元素除法的第一个向量。
vec2	用于逐元素除法的第二个向量。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 486 行定义.

 {
   libmesh_not_implemented();
 }

template<typename T >

void libMesh::LaspackVector< T >::pointwise_mult	(	const NumericVector< T > &	vec1,
		const NumericVector< T > &	vec2
	)

overridevirtual

对向量的每个元素执行逐元素乘法。

参数

vec1	用于逐元素乘法的第一个向量。
vec2	用于逐元素乘法的第二个向量。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 479 行定义.

 {
   libmesh_not_implemented();
 }

template<typename T >

void libMesh::NumericVector< T >::print ( std::ostream & os = libMesh::out ) const

inlinevirtualinherited

打印本地向量的内容，默认输出到 libMesh::out 流。

参数

os	输出流，用于指定输出位置（可选，默认为 libMesh::out）。

在文件 numeric_vector.h 第 1121 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   os << "Size\tglobal =  " << this->size()
      << "\t\tlocal =  " << this->local_size() << std::endl;
 
   os << "#\tValue" << std::endl;
   for (auto i : index_range(*this))
     os << i << "\t" << (*this)(i) << std::endl;
 }

template<>

void libMesh::NumericVector< Complex >::print ( std::ostream & os ) const

inlineinherited

在文件 numeric_vector.h 第 1103 行定义.

参考 std::imag(), libMesh::initialized() , 以及 std::real().

 {
   libmesh_assert (this->initialized());
   os << "Size\tglobal =  " << this->size()
      << "\t\tlocal =  " << this->local_size() << std::endl;
 
   // std::complex<>::operator<<() is defined, but use this form
   os << "#\tReal part\t\tImaginary part" << std::endl;
   for (auto i : index_range(*this))
     os << i << "\t"
        << (*this)(i).real() << "\t\t"
        << (*this)(i).imag() << std::endl;
 }

template<typename T >

void libMesh::NumericVector< T >::print_global ( std::ostream & os = libMesh::out ) const

inlinevirtualinherited

打印全局向量的内容，默认输出到 libMesh::out 流。

参数

os	输出流，用于指定输出位置（可选，默认为 libMesh::out）。

在文件 numeric_vector.h 第 1158 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   std::vector<T> v(this->size());
   this->localize(v);
 
   // 现在我们只需要输出的一个副本
   if (this->processor_id())
     return;
 
   os << "Size\tglobal =  " << this->size() << std::endl;
   os << "#\tValue" << std::endl;
   for (auto i : make_range(v.size()))
     os << i << "\t" << v[i] << std::endl;
 }

template<>

void libMesh::NumericVector< Complex >::print_global ( std::ostream & os ) const

inlineinherited

在文件 numeric_vector.h 第 1136 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   std::vector<Complex> v(this->size());
   this->localize(v);
 
   // 现在我们只需要输出的一个副本
   if (this->processor_id())
     return;
 
   os << "Size\tglobal =  " << this->size() << std::endl;
   os << "#\tReal part\t\tImaginary part" << std::endl;
   for (auto i : make_range(v.size()))
     os << i << "\t"
        << v[i].real() << "\t\t"
        << v[i].imag() << std::endl;
 }

void libMesh::ReferenceCounter::print_info ( std::ostream & out_stream = libMesh::out )

staticinherited

Prints the reference information, by default to libMesh::out.

在文件 reference_counter.C 第 81 行定义.

参考 libMesh::ReferenceCounter::_enable_print_counter , 以及 libMesh::ReferenceCounter::get_info().

参考自 libMesh::LibMeshInit::~LibMeshInit().

 {
   if (_enable_print_counter)
     out_stream << ReferenceCounter::get_info();
 }

template<typename T>

virtual void libMesh::NumericVector< T >::print_matlab ( const std::string & = "" ) const

inlinevirtualinherited

以Matlab的稀疏矩阵格式打印向量内容。可选择将向量打印到名为 name 的文件中。如果未指定 name，则内容将被打印到屏幕上。

参数

name	用于指定输出文件名的可选参数（默认为空）。

被 libMesh::PetscVector< T > 重载.

在文件 numeric_vector.h 第 859 行定义.

   {
     libmesh_not_implemented();
   }

template<typename T >

bool libMesh::NumericVector< T >::readable ( ) const

inherited

检查该向量是否能够用于全局操作。

返回: 如果向量可以用于全局操作，则返回 true，否则返回 false。

在文件 numeric_vector.C 第 416 行定义.

参考 libMesh::closed() , 以及 libMesh::initialized().

参考自 libMesh::NumericVector< T >::add_vector(), libMesh::NumericVector< T >::compatible() , 以及 libMesh::NumericVector< T >::insert().

 {
   return this->initialized() && this->closed();
 }

template<typename T >

void libMesh::LaspackVector< T >::reciprocal ( )

overridevirtual

计算向量中所有元素的倒数（1/x）。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 159 行定义.

 {
   const numeric_index_type n = this->size();
 
 #ifndef NDEBUG
   const bool was_closed = this->_is_closed;
 #endif
 
   for (numeric_index_type i=0; i<n; i++)
     {
       T v = (*this)(i);
 
       // Don't divide by zero!
       libmesh_assert_not_equal_to (v, T(0));
 
       this->set(i, 1. / v);
     }
 
   // This is an embarrassingly parallel method, but set() isn't in
   // general so set() overzealously marked us as non-closed
 #ifndef NDEBUG
   this->_is_closed = was_closed;
 #endif
 }

template<typename T >

void libMesh::LaspackVector< T >::scale ( const T factor )

overridevirtual

缩放向量的所有元素，将它们乘以指定的标量因子。

参数

factor 用于缩放的标量因子。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 290 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
 
   Asgn_VV(&_vec, Mul_SV (factor, &_vec));
 }

template<typename T >

void libMesh::LaspackVector< T >::set	(	const numeric_index_type	i,
		const T	value
	)

inlineoverridevirtual

设置指定索引处的元素值。

参数

i	索引值。
value	要设置的值。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.h 第 815 行定义.

参考 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_less (i, this->size());
 
   std::scoped_lock lock(this->_numeric_vector_mutex);
   V_SetCmp (&_vec, i+1, value);
 
 #ifndef NDEBUG
   this->_is_closed = false;
 #endif
 }

template<typename T >

numeric_index_type libMesh::LaspackVector< T >::size ( ) const

inlineoverridevirtual

返回向量的大小（全局维度）。

返回: 向量的大小。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.h 第 771 行定义.

参考 libMesh::initialized().

参考自 libMesh::LaspackVector< T >::add() , 以及 libMesh::LaspackVector< T >::operator=().

 {
   libmesh_assert (this->initialized());
 
   return static_cast<numeric_index_type>(V_GetDim(const_cast<QVector*>(&_vec)));
 }

template<class T >

Real libMesh::NumericVector< T >::subset_l1_norm ( const std::set< numeric_index_type > & indices ) const

virtualinherited

获取指定条目的向量的 $\ell_1$ -范数，即指定条目的绝对值之和。

参数

indices 指定的索引集合。

返回: 指定条目的向量的 $\ell_1$ -范数。

注解: 索引必须位于此处理器上。

在文件 numeric_vector.C 第 306 行定义.

参考 std::abs(), std::norm() , 以及 libMesh::Real.

 {
   libmesh_assert (this->readable());
 
   const NumericVector<T> & v = *this;
 
   Real norm = 0;
 
   for (const auto & index : indices)
     norm += std::abs(v(index));
 
   this->comm().sum(norm);
 
   return norm;
 }

template<class T >

Real libMesh::NumericVector< T >::subset_l2_norm ( const std::set< numeric_index_type > & indices ) const

virtualinherited

获取指定条目的向量的 $\ell_2$ -范数，即指定条目平方和的平方根。

参数

indices 指定的索引集合。

返回: 指定条目的向量的 $\ell_2$ -范数。

注解: 索引必须位于此处理器上。

在文件 numeric_vector.C 第 323 行定义.

参考 std::norm(), libMesh::TensorTools::norm_sq(), libMesh::Real , 以及 std::sqrt().

 {
   libmesh_assert (this->readable());
 
   const NumericVector<T> & v = *this;
 
   Real norm = 0;
 
   for (const auto & index : indices)
     norm += TensorTools::norm_sq(v(index));
 
   this->comm().sum(norm);
 
   return std::sqrt(norm);
 }

template<class T >

Real libMesh::NumericVector< T >::subset_linfty_norm ( const std::set< numeric_index_type > & indices ) const

virtualinherited

获取指定条目的向量的最大绝对值，即指定条目的 $\ell_{\infty}$ -范数。

参数

indices 指定的索引集合。

返回: 指定条目的向量的最大绝对值。

注解: 索引必须位于此处理器上。

在文件 numeric_vector.C 第 340 行定义.

参考 std::abs(), std::norm() , 以及 libMesh::Real.

 {
   libmesh_assert (this->readable());
 
   const NumericVector<T> & v = *this;
 
   Real norm = 0;
 
   for (const auto & index : indices)
     {
       Real value = std::abs(v(index));
       if (value > norm)
         norm = value;
     }
 
   this->comm().max(norm);
 
   return norm;
 }

template<typename T >

T libMesh::LaspackVector< T >::sum ( ) const

overridevirtual

返回向量的所有元素之和。

返回: 所有元素之和的值。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.C 第 37 行定义.

参考 libMesh::closed().

 {
   libmesh_assert (this->closed());
 
   T _sum = 0;
 
   const numeric_index_type n = this->size();
 
   for (numeric_index_type i=0; i!=n; ++i)
     _sum += (*this)(i);
 
   return _sum;
 }

template<typename T >

void libMesh::LaspackVector< T >::swap ( NumericVector< T > & v )

inlineoverridevirtual

交换两个向量的内容。

参数

v	要交换内容的另一个向量。

重载 libMesh::NumericVector< T > .

在文件 laspack_vector.h 第 863 行定义.

 {
   LaspackVector<T> & v = cast_ref<LaspackVector<T> &>(other);
 
   // This is all grossly dependent on Laspack version...
 
   std::swap(_vec.Name, v._vec.Name);
   std::swap(_vec.Dim, v._vec.Dim);
   std::swap(_vec.Instance, v._vec.Instance);
   std::swap(_vec.LockLevel, v._vec.LockLevel);
   std::swap(_vec.Multipl, v._vec.Multipl);
   std::swap(_vec.OwnData, v._vec.OwnData);
 
   // This should still be O(1), since _vec.Cmp is just a pointer to
   // data on the heap
 
   std::swap(_vec.Cmp, v._vec.Cmp);
 }

template<typename T>

ParallelType libMesh::NumericVector< T >::type ( ) const

inlineinherited

获取向量的类型。

返回: 向量的类型（SERIAL、PARALLEL、GHOSTED）。

在文件 numeric_vector.h 第 166 行定义.

参考 libMesh::NumericVector< T >::_type.

参考自 libMesh::DofMap::constrain_element_residual(), libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::DofMap::enforce_constraints_on_residual(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::DofMap::heterogeneously_constrain_element_jacobian_and_residual(), libMesh::DofMap::heterogeneously_constrain_element_residual(), libMesh::DistributedVector< T >::init(), libMesh::EigenSparseVector< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::LaspackVector< T >::init() , 以及 libMesh::PetscVector< T >::localize().

166 { return _type; }

libMesh::NumericVector::_type

ParallelType _type

向量的类型。

Definition: numeric_vector.h:923

template<typename T>

ParallelType& libMesh::NumericVector< T >::type ( )

inlineinherited

获取向量的类型。

返回: 向量的类型（SERIAL、PARALLEL、GHOSTED）。

在文件 numeric_vector.h 第 173 行定义.

参考 libMesh::NumericVector< T >::_type.

173 { return _type; }

libMesh::NumericVector::_type

ParallelType _type

向量的类型。

Definition: numeric_vector.h:923

template<typename T >

void libMesh::LaspackVector< T >::zero ( )

inlineoverridevirtual

Set all elements of the vector to zero.

将向量的所有元素置零。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.h 第 731 行定义.

参考 libMesh::closed() , 以及 libMesh::initialized().

 {
   libmesh_assert (this->initialized());
   libmesh_assert (this->closed());
 
   V_SetAllCmp (&_vec, 0.);
 }

template<typename T >

std::unique_ptr< NumericVector< T > > libMesh::LaspackVector< T >::zero_clone ( ) const

inlineoverridevirtual

创建并返回一个指向该对象的零克隆的 unique_ptr。

实现了 libMesh::NumericVector< T >.

在文件 laspack_vector.h 第 743 行定义.

参考 libMesh::NumericVector< T >::init().

 {
   NumericVector<T> * cloned_vector = new LaspackVector<T>(this->comm());
 
   cloned_vector->init(*this);
 
   return std::unique_ptr<NumericVector<T>>(cloned_vector);
 }

友元及相关函数文档

template<typename T>

friend class LaspackLinearSolver< T >

friend

使其他 Laspack 数据类型成为友元类，以便它们可以访问私有成员。

在文件 laspack_vector.h 第 540 行定义.

类成员变量说明

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

在文件 reference_counter.h 第 124 行定义.

参考自 libMesh::ReferenceCounter::get_info().

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

在文件 reference_counter.h 第 143 行定义.

参考自 libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info() , 以及 libMesh::ReferenceCounter::print_info().

template<typename T>

bool libMesh::NumericVector< T >::_is_closed

protectedinherited

用于跟踪向量的值在在一些或全部处理器上进行插入或添加值操作后是否在所有处理器上保持一致的标志。

在文件 numeric_vector.h 第 913 行定义.

参考自 libMesh::NumericVector< T >::closed(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::DistributedVector< T >::localize(), libMesh::DistributedVector< T >::operator=() , 以及 libMesh::PetscVector< T >::PetscVector().

template<typename T>

bool libMesh::NumericVector< T >::_is_initialized

protectedinherited

在调用 init() 后设置为 true。

在文件 numeric_vector.h 第 918 行定义.

参考自 libMesh::PetscVector< T >::create_subvector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::NumericVector< T >::initialized(), libMesh::DistributedVector< T >::localize(), libMesh::DistributedVector< T >::operator=() , 以及 libMesh::PetscVector< T >::PetscVector().

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

在文件 reference_counter.h 第 137 行定义.

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects

staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

在文件 reference_counter.h 第 132 行定义.

参考自 libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter() , 以及 libMesh::ReferenceCounter::~ReferenceCounter().

template<typename T>

std::mutex libMesh::NumericVector< T >::_numeric_vector_mutex

protectedinherited

用于执行线程安全操作的互斥锁。

在文件 numeric_vector.h 第 928 行定义.

template<typename T>

ParallelType libMesh::NumericVector< T >::_type

protectedinherited

向量的类型。

在文件 numeric_vector.h 第 923 行定义.

参考自 libMesh::DistributedVector< T >::DistributedVector(), libMesh::EigenSparseVector< T >::EigenSparseVector(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::PetscVector< T >::init(), libMesh::LaspackVector< T >::LaspackVector(), libMesh::PetscVector< T >::PetscVector() , 以及 libMesh::NumericVector< T >::type().

template<typename T>

QVector libMesh::LaspackVector< T >::_vec

private

用于保存向量条目的实际 Laspack 向量数据类型。

在文件 laspack_vector.h 第 535 行定义.

参考自 libMesh::LaspackVector< T >::add_vector(), libMesh::LaspackVector< T >::dot() , 以及 libMesh::LaspackVector< T >::operator=().

该类的文档由以下文件生成:

/home/lwz/libmesh/include/numerics/laspack_matrix.h
/home/lwz/libmesh/include/numerics/laspack_vector.h
/home/lwz/libmesh/src/numerics/laspack_vector.C

Public 成员函数

静态 Public 成员函数

Protected 类型

Protected 成员函数

Protected 属性

静态 Protected 属性

Private 属性

友元

详细描述

template<typename T> class libMesh::LaspackVector< T >

成员类型定义说明

构造及析构函数说明

成员函数说明

友元及相关函数文档

类成员变量说明

template<typename T>
class libMesh::LaspackVector< T >