Reference documentation for deal.II version 8.5.0
Vector< Number > Class Template Reference

#include <deal.II/lac/vector.h>

Inheritance diagram for Vector< Number >:
[legend]

## Public Types

typedef Number value_type

typedef numbers::NumberTraits< Number >::real_type real_type

## Public Member Functions

Basic object handling
Vector ()

Vector (const Vector< Number > &v)

Vector (Vector< Number > &&v)

template<typename OtherNumber >
Vector (const Vector< OtherNumber > &v)

Vector (const PETScWrappers::Vector &v)

Vector (const PETScWrappers::MPI::Vector &v)

Vector (const TrilinosWrappers::MPI::Vector &v)

Vector (const TrilinosWrappers::Vector &v)

Vector (const size_type n)

template<typename InputIterator >
Vector (const InputIterator first, const InputIterator last)

virtual ~Vector ()

void compress (::VectorOperation::values operation=::VectorOperation::unknown) const

virtual void reinit (const size_type N, const bool omit_zeroing_entries=false)

template<typename Number2 >
void reinit (const Vector< Number2 > &V, const bool omit_zeroing_entries=false)

virtual void swap (Vector< Number > &v)

Vector< Number > & operator= (const Number s)

Vector< Number > & operator= (const Vector< Number > &v)

Vector< Number > & operator= (Vector< Number > &&v)

template<typename Number2 >
Vector< Number > & operator= (const Vector< Number2 > &v)

Vector< Number > & operator= (const BlockVector< Number > &v)

Vector< Number > & operator= (const PETScWrappers::Vector &v)

Vector< Number > & operator= (const PETScWrappers::MPI::Vector &v)

Vector< Number > & operator= (const TrilinosWrappers::MPI::Vector &v)

Vector< Number > & operator= (const TrilinosWrappers::Vector &v)

template<typename Number2 >
bool operator== (const Vector< Number2 > &v) const

template<typename Number2 >
bool operator!= (const Vector< Number2 > &v) const

Scalar products, norms and related operations
template<typename Number2 >
Number operator* (const Vector< Number2 > &V) const

real_type norm_sqr () const

Number mean_value () const

real_type l1_norm () const

real_type l2_norm () const

real_type lp_norm (const real_type p) const

real_type linfty_norm () const

Number add_and_dot (const Number a, const Vector< Number > &V, const Vector< Number > &W)

Data access
iterator begin ()

const_iterator begin () const

iterator end ()

const_iterator end () const

Number operator() (const size_type i) const

Number & operator() (const size_type i)

Number operator[] (const size_type i) const

Number & operator[] (const size_type i)

template<typename OtherNumber >
void extract_subvector_to (const std::vector< size_type > &indices, std::vector< OtherNumber > &values) const

template<typename ForwardIterator , typename OutputIterator >
void extract_subvector_to (ForwardIterator indices_begin, const ForwardIterator indices_end, OutputIterator values_begin) const

Modification of vectors
Vector< Number > & operator+= (const Vector< Number > &V)

Vector< Number > & operator-= (const Vector< Number > &V)

template<typename OtherNumber >
void add (const std::vector< size_type > &indices, const std::vector< OtherNumber > &values)

template<typename OtherNumber >
void add (const std::vector< size_type > &indices, const Vector< OtherNumber > &values)

template<typename OtherNumber >
void add (const size_type n_elements, const size_type *indices, const OtherNumber *values)

void add (const Vector< Number > &V) 1

void add (const Number a, const Vector< Number > &V, const Number b, const Vector< Number > &W)

void add (const Number a, const Vector< Number > &V)

void sadd (const Number s, const Vector< Number > &V)

void sadd (const Number s, const Number a, const Vector< Number > &V)

void sadd (const Number s, const Number a, const Vector< Number > &V, const Number b, const Vector< Number > &W) 1

void sadd (const Number s, const Number a, const Vector< Number > &V, const Number b, const Vector< Number > &W, const Number c, const Vector< Number > &X) 1

Vector< Number > & operator*= (const Number factor)

Vector< Number > & operator/= (const Number factor)

void scale (const Vector< Number > &scaling_factors)

template<typename Number2 >
void scale (const Vector< Number2 > &scaling_factors)

void equ (const Number a, const Vector< Number > &u)

template<typename Number2 >
void equ (const Number a, const Vector< Number2 > &u)

void equ (const Number a, const Vector< Number > &u, const Number b, const Vector< Number > &v) 1

void equ (const Number a, const Vector< Number > &u, const Number b, const Vector< Number > &v, const Number c, const Vector< Number > &w) 1

void ratio (const Vector< Number > &a, const Vector< Number > &b) 1

void update_ghost_values () const

Input and output
void print (const char *format=0) const 1

void print (std::ostream &out, const unsigned int precision=3, const bool scientific=true, const bool across=true) const

void print (LogStream &out, const unsigned int width=6, const bool across=true) const 1

void block_write (std::ostream &out) const

template<class Archive >
void save (Archive &ar, const unsigned int version) const

template<class Archive >
void load (Archive &ar, const unsigned int version)

bool in_local_range (const size_type global_index) const

IndexSet locally_owned_elements () const

std::size_t size () const

bool all_zero () const

bool is_non_negative () const

std::size_t memory_consumption () const

Public Member Functions inherited from Subscriptor
Subscriptor ()

Subscriptor (const Subscriptor &)

Subscriptor (Subscriptor &&)

virtual ~Subscriptor ()

Subscriptoroperator= (const Subscriptor &)

Subscriptoroperator= (Subscriptor &&)

void subscribe (const char *identifier=0) const

void unsubscribe (const char *identifier=0) const

unsigned int n_subscriptions () const

void list_subscribers () const

template<class Archive >
void serialize (Archive &ar, const unsigned int version)

## Static Public Attributes

static const bool supports_distributed_data = false

## Protected Attributes

size_type vec_size

size_type max_vec_size

Number * val

## Private Member Functions

void allocate ()

void deallocate ()

## Friends

template<typename Number2 >
class Vector

template<typename Number2 >
class LAPACKFullMatrix

class VectorView< Number >

## Related Functions

(Note that these are not member functions.)

template<typename Number >
void swap (LinearAlgebra::distributed::Vector< Number > &u, LinearAlgebra::distributed::Vector< Number > &v)

template<typename Number >

template<typename Number >
void swap (Vector< Number > &u, Vector< Number > &v)

Static Public Member Functions inherited from Subscriptor
static::ExceptionBase & ExcInUse (int arg1, char *arg2, std::string &arg3)

static::ExceptionBase & ExcNoSubscriber (char *arg1, char *arg2)

## Detailed Description

### template<typename Number> class Vector< Number >

Numerical vector of data. For this class there are different types of functions available. The first type of function initializes the vector, changes its size, or computes the norm of the vector in order to measure its length in a suitable norm. The second type helps us to manipulate the components of the vector. The third type defines the algebraic operations for vectors, while the last type defines a few input and output functions. As opposed to the array of the C++ standard library called vector (with a lowercase "v"), this class implements an element of a vector space suitable for numerical computations.

Note
Instantiations for this template are provided for <float>, <double>, <std::complex<float>>, <std::complex<double>>; others can be generated in application programs (see the section on Template instantiations in the manual).

Definition at line 34 of file function.h.

## Member Typedef Documentation

template<typename Number>
 typedef Number Vector< Number >::value_type

Declare standard types used in all containers. These types parallel those in the C++ standard libraries vector<...> class.

Definition at line 137 of file vector.h.

template<typename Number>
 typedef numbers::NumberTraits::real_type Vector< Number >::real_type

Declare a type that has holds real-valued numbers with the same precision as the template argument to this class. If the template argument of this class is a real data type, then real_type equals the template argument. If the template argument is a std::complex type then real_type equals the type underlying the complex numbers.

This typedef is used to represent the return type of norms.

Definition at line 155 of file vector.h.

## Constructor & Destructor Documentation

template<typename Number>
 Vector< Number >::Vector ( )

Constructor. Create a vector of dimension zero.

template<typename Number>
 Vector< Number >::Vector ( const Vector< Number > & v )

Copy constructor. Sets the dimension to that of the given vector, and copies all elements.

We would like to make this constructor explicit, but standard containers insist on using it implicitly.

template<typename Number>
 Vector< Number >::Vector ( Vector< Number > && v )

Move constructor. Creates a new vector by stealing the internal data of the vector v.

Note
This constructor is only available if deal.II is configured with C++11 support.
template<typename Number>
template<typename OtherNumber >
 Vector< Number >::Vector ( const Vector< OtherNumber > & v )
explicit

Copy constructor taking a vector of another data type. This will fail if there is no conversion path from OtherNumber to Number. Note that you may lose accuracy when copying to a vector with data elements with less accuracy.

Older versions of gcc did not honor the explicit keyword on template constructors. In such cases, it is easy to accidentally write code that can be very inefficient, since the compiler starts performing hidden conversions. To avoid this, this function is disabled if we have detected a broken compiler during configuration.

template<typename Number>
 Vector< Number >::Vector ( const PETScWrappers::Vector< Number > & v )
explicit

Another copy constructor: copy the values from a sequential PETSc wrapper vector class. This copy constructor is only available if PETSc was detected during configuration time.

template<typename Number>
 Vector< Number >::Vector ( const PETScWrappers::MPI::Vector< Number > & v )
explicit

Another copy constructor: copy the values from a parallel PETSc wrapper vector class. This copy constructor is only available if PETSc was detected during configuration time.

Note that due to the communication model used in MPI, this operation can only succeed if all processes do it at the same time. I.e., it is not possible for only one process to obtain a copy of a parallel vector while the other jobs do something else.

template<typename Number>
 Vector< Number >::Vector ( const TrilinosWrappers::MPI::Vector< Number > & v )
explicit

Another copy constructor: copy the values from a Trilinos wrapper vector. This copy constructor is only available if Trilinos was detected during configuration time.

Note that due to the communication model used in MPI, this operation can only succeed if all processes do it at the same time. This means that it is not possible for only one process to obtain a copy of a parallel vector while the other jobs do something else. This call will rather result in a copy of the vector on all processors.

template<typename Number>
 Vector< Number >::Vector ( const TrilinosWrappers::Vector< Number > & v )
explicit

Another copy constructor: copy the values from a localized Trilinos wrapper vector. This copy constructor is only available if Trilinos was detected during configuration time.

template<typename Number>
 Vector< Number >::Vector ( const size_type n )
explicit

Constructor. Set dimension to n and initialize all elements with zero.

The constructor is made explicit to avoid accidents like this: v=0;. Presumably, the user wants to set every element of the vector to zero, but instead, what happens is this call: v=Vector<number>(0);, i.e. the vector is replaced by one of length zero.

template<typename Number>
template<typename InputIterator >
 Vector< Number >::Vector ( const InputIterator first, const InputIterator last )

Initialize the vector with a given range of values pointed to by the iterators. This function is there in analogy to the std::vector class.

template<typename Number>
 virtual Vector< Number >::~Vector ( )
virtual

Destructor, deallocates memory. Made virtual to allow for derived classes to behave properly.

## Member Function Documentation

template<typename Number>
 void Vector< Number >::compress ( ::VectorOperation::values operation = ::VectorOperation::unknown ) const

This function does nothing but is there for compatibility with the PETScWrappers::Vector class.

For the PETSc vector wrapper class, this function compresses the underlying representation of the PETSc object, i.e. flushes the buffers of the vector object if it has any. This function is necessary after writing into a vector element-by-element and before anything else can be done on it.

However, for the implementation of this class, it is immaterial and thus an empty function.

template<typename Number>
 virtual void Vector< Number >::reinit ( const size_type N, const bool omit_zeroing_entries = false )
virtual

Change the dimension of the vector to N. The reserved memory for this vector remains unchanged if possible, to make things faster; this may waste some memory, so keep this in mind. However, if N==0 all memory is freed, i.e. if you want to resize the vector and release the memory not needed, you have to first call reinit(0) and then reinit(N). This cited behaviour is analogous to that of the standard library containers.

If omit_zeroing_entries is false, the vector is filled by zeros. Otherwise, the elements are left an unspecified state.

This function is virtual in order to allow for derived classes to handle memory separately.

Reimplemented in VectorView< Number >.

template<typename Number>
template<typename Number2 >
 void Vector< Number >::reinit ( const Vector< Number2 > & V, const bool omit_zeroing_entries = false )

Change the dimension to that of the vector V. The same applies as for the other reinit function.

The elements of V are not copied, i.e. this function is the same as calling reinit (V.size(), omit_zeroing_entries).

template<typename Number>
 virtual void Vector< Number >::swap ( Vector< Number > & v )
virtual

Swap the contents of this vector and the other vector v. One could do this operation with a temporary variable and copying over the data elements, but this function is significantly more efficient since it only swaps the pointers to the data of the two vectors and therefore does not need to allocate temporary storage and move data around.

This function is analogous to the the swap function of all C++ standard containers. Also, there is a global function swap(u,v) that simply calls u.swap(v), again in analogy to standard functions.

This function is virtual in order to allow for derived classes to handle memory separately.

Reimplemented in VectorView< Number >.

template<typename Number>
 Vector& Vector< Number >::operator= ( const Number s )

Set all components of the vector to the given number s. Simply pass this down to the individual block objects, but we still need to declare this function to make the example given in the discussion about making the constructor explicit work.

Since the semantics of assigning a scalar to a vector are not immediately clear, this operator should really only be used if you want to set the entire vector to zero. This allows the intuitive notation v=0. Assigning other values is deprecated and may be disallowed in the future.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 Vector& Vector< Number >::operator= ( const Vector< Number > & v )

Copy the given vector. Resize the present vector if necessary.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 Vector& Vector< Number >::operator= ( Vector< Number > && v )

Move the given vector. This operator replaces the present vector with the internal data of the vector v and resets v to the state it would have after being newly default-constructed.

Note
This operator is only available if deal.II is configured with C++11 support.
template<typename Number>
template<typename Number2 >
 Vector& Vector< Number >::operator= ( const Vector< Number2 > & v )

Copy the given vector. Resize the present vector if necessary.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 Vector& Vector< Number >::operator= ( const BlockVector< Number > & v )

Copy operator for assigning a block vector to a regular vector.

template<typename Number>
 Vector& Vector< Number >::operator= ( const PETScWrappers::Vector< Number > & v )

Another copy operator: copy the values from a sequential PETSc wrapper vector class. This operator is only available if PETSc was detected during configuration time.

template<typename Number>
 Vector& Vector< Number >::operator= ( const PETScWrappers::MPI::Vector< Number > & v )

Another copy operator: copy the values from a parallel PETSc wrapper vector class. This operator is only available if PETSc was detected during configuration time.

Note that due to the communication model used in MPI, this operation can only succeed if all processes do it at the same time. I.e., it is not possible for only one process to obtain a copy of a parallel vector while the other jobs do something else.

template<typename Number>
 Vector& Vector< Number >::operator= ( const TrilinosWrappers::MPI::Vector< Number > & v )

Another copy operator: copy the values from a (sequential or parallel, depending on the underlying compiler) Trilinos wrapper vector class. This operator is only available if Trilinos was detected during configuration time.

Note that due to the communication model used in MPI, this operation can only succeed if all processes do it at the same time. I.e., it is not possible for only one process to obtain a copy of a parallel vector while the other jobs do something else.

template<typename Number>
 Vector & Vector< Number >::operator= ( const TrilinosWrappers::Vector< Number > & v )

Another copy operator: copy the values from a sequential Trilinos wrapper vector class. This operator is only available if Trilinos was detected during configuration time.

Definition at line 580 of file trilinos_vector.cc.

template<typename Number>
template<typename Number2 >
 bool Vector< Number >::operator== ( const Vector< Number2 > & v ) const

Test for equality. This function assumes that the present vector and the one to compare with have the same size already, since comparing vectors of different sizes makes not much sense anyway.

template<typename Number>
template<typename Number2 >
 bool Vector< Number >::operator!= ( const Vector< Number2 > & v ) const

Test for inequality. This function assumes that the present vector and the one to compare with have the same size already, since comparing vectors of different sizes makes not much sense anyway.

template<typename Number>
template<typename Number2 >
 Number Vector< Number >::operator* ( const Vector< Number2 > & V ) const

Return the scalar product of two vectors. The return type is the underlying type of this vector, so the return type and the accuracy with which it the result is computed depend on the order of the arguments of this vector.

For complex vectors, the scalar product is implemented as $$\left<v,w\right>=\sum_i v_i \bar{w_i}$$.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile). The algorithm uses pairwise summation with the same order of summation in every run, which gives fully repeatable results from one run to another.
template<typename Number>
 real_type Vector< Number >::norm_sqr ( ) const

Return square of the $$l_2$$-norm.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile). The algorithm uses pairwise summation with the same order of summation in every run, which gives fully repeatable results from one run to another.
template<typename Number>
 Number Vector< Number >::mean_value ( ) const

Mean value of the elements of this vector.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile). The algorithm uses pairwise summation with the same order of summation in every run, which gives fully repeatable results from one run to another.
template<typename Number>
 real_type Vector< Number >::l1_norm ( ) const

$$l_1$$-norm of the vector. The sum of the absolute values.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile). The algorithm uses pairwise summation with the same order of summation in every run, which gives fully repeatable results from one run to another.
template<typename Number>
 real_type Vector< Number >::l2_norm ( ) const

$$l_2$$-norm of the vector. The square root of the sum of the squares of the elements.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile). The algorithm uses pairwise summation with the same order of summation in every run, which gives fully repeatable results from one run to another.
template<typename Number>
 real_type Vector< Number >::lp_norm ( const real_type p ) const

$$l_p$$-norm of the vector. The pth root of the sum of the pth powers of the absolute values of the elements.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile). The algorithm uses pairwise summation with the same order of summation in every run, which gives fully repeatable results from one run to another.
template<typename Number>
 real_type Vector< Number >::linfty_norm ( ) const

Maximum absolute value of the elements.

template<typename Number>
 Number Vector< Number >::add_and_dot ( const Number a, const Vector< Number > & V, const Vector< Number > & W )

Performs a combined operation of a vector addition and a subsequent inner product, returning the value of the inner product. In other words, the result of this function is the same as if the user called

return_value = *this * W;

The reason this function exists is that this operation involves less memory transfer than calling the two functions separately. This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile). The algorithm uses pairwise summation with the same order of summation in every run, which gives fully repeatable results from one run to another.
template<typename Number>
 iterator Vector< Number >::begin ( )

Make the Vector class a bit like the vector<> class of the C++ standard library by returning iterators to the start and end of the elements of this vector.

template<typename Number>
 const_iterator Vector< Number >::begin ( ) const

Return constant iterator to the start of the vectors.

template<typename Number>
 iterator Vector< Number >::end ( )

Return an iterator pointing to the element past the end of the array.

template<typename Number>
 const_iterator Vector< Number >::end ( ) const

Return a constant iterator pointing to the element past the end of the array.

template<typename Number>
 Number Vector< Number >::operator() ( const size_type i ) const

Access the value of the ith component.

template<typename Number>
 Number& Vector< Number >::operator() ( const size_type i )

Access the ith component as a writeable reference.

template<typename Number>
 Number Vector< Number >::operator[] ( const size_type i ) const

Access the value of the ith component.

Exactly the same as operator().

template<typename Number>
 Number& Vector< Number >::operator[] ( const size_type i )

Access the ith component as a writeable reference.

Exactly the same as operator().

template<typename Number>
template<typename OtherNumber >
 void Vector< Number >::extract_subvector_to ( const std::vector< size_type > & indices, std::vector< OtherNumber > & values ) const

A collective get operation: instead of getting individual elements of a vector, this function allows to get a whole set of elements at once. The indices of the elements to be read are stated in the first argument, the corresponding values are returned in the second.

template<typename Number>
template<typename ForwardIterator , typename OutputIterator >
 void Vector< Number >::extract_subvector_to ( ForwardIterator indices_begin, const ForwardIterator indices_end, OutputIterator values_begin ) const

Just as the above, but with pointers. Useful in minimizing copying of data around.

template<typename Number>
 Vector& Vector< Number >::operator+= ( const Vector< Number > & V )

Add the given vector to the present one.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 Vector& Vector< Number >::operator-= ( const Vector< Number > & V )

Subtract the given vector from the present one.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
template<typename OtherNumber >
 void Vector< Number >::add ( const std::vector< size_type > & indices, const std::vector< OtherNumber > & values )

A collective add operation: This function adds a whole set of values stored in values to the vector components specified by indices.

template<typename Number>
template<typename OtherNumber >
 void Vector< Number >::add ( const std::vector< size_type > & indices, const Vector< OtherNumber > & values )

This is a second collective add operation. As a difference, this function takes a deal.II vector of values.

template<typename Number>
template<typename OtherNumber >
 void Vector< Number >::add ( const size_type n_elements, const size_type * indices, const OtherNumber * values )

Take an address where n_elements are stored contiguously and add them into the vector. Handles all cases which are not covered by the other two add() functions above.

template<typename Number>
 void Vector< Number >::add ( const Number s )

Addition of s to all components. Note that s is a scalar and not a vector.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 void Vector< Number >::add ( const Vector< Number > & V )

Simple vector addition, equal to the operator +=.

Deprecated:
Use the operator += instead.
Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 void Vector< Number >::add ( const Number a, const Vector< Number > & V, const Number b, const Vector< Number > & W )

Multiple addition of scaled vectors, i.e. *this += a*V+b*W.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 void Vector< Number >::add ( const Number a, const Vector< Number > & V )

Simple addition of a multiple of a vector, i.e. *this += a*V.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 void Vector< Number >::sadd ( const Number s, const Vector< Number > & V )

Scaling and simple vector addition, i.e. *this = s*(*this)+V.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 void Vector< Number >::sadd ( const Number s, const Number a, const Vector< Number > & V )

Scaling and simple addition, i.e. *this = s*(*this)+a*V.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 void Vector< Number >::sadd ( const Number s, const Number a, const Vector< Number > & V, const Number b, const Vector< Number > & W )

This function is deprecated.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 void Vector< Number >::sadd ( const Number s, const Number a, const Vector< Number > & V, const Number b, const Vector< Number > & W, const Number c, const Vector< Number > & X )

Scaling and multiple addition. *this = s*(*this)+a*V + b*W + c*X.

This function is deprecated.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 Vector& Vector< Number >::operator*= ( const Number factor )

Scale each element of the vector by a constant value.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 Vector& Vector< Number >::operator/= ( const Number factor )

Scale each element of the vector by the inverse of the given value.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 void Vector< Number >::scale ( const Vector< Number > & scaling_factors )

Scale each element of this vector by the corresponding element in the argument. This function is mostly meant to simulate multiplication (and immediate re-assignment) by a diagonal scaling matrix.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
template<typename Number2 >
 void Vector< Number >::scale ( const Vector< Number2 > & scaling_factors )

Scale each element of this vector by the corresponding element in the argument. This function is mostly meant to simulate multiplication (and immediate re-assignment) by a diagonal scaling matrix.

template<typename Number>
 void Vector< Number >::equ ( const Number a, const Vector< Number > & u )

Assignment *this = a*u.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
template<typename Number2 >
 void Vector< Number >::equ ( const Number a, const Vector< Number2 > & u )

Assignment *this = a*u.

template<typename Number>
 void Vector< Number >::equ ( const Number a, const Vector< Number > & u, const Number b, const Vector< Number > & v )

Assignment *this = a*u + b*v.

This function is deprecated.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 void Vector< Number >::equ ( const Number a, const Vector< Number > & u, const Number b, const Vector< Number > & v, const Number c, const Vector< Number > & w )

Assignment *this = a*u + b*v + b*w.

This function is deprecated.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 void Vector< Number >::ratio ( const Vector< Number > & a, const Vector< Number > & b )

Compute the elementwise ratio of the two given vectors, that is let this[i] = a[i]/b[i]. This is useful for example if you want to compute the cellwise ratio of true to estimated error.

This vector is appropriately scaled to hold the result.

If any of the b[i] is zero, the result is undefined. No attempt is made to catch such situations.

Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
template<typename Number>
 void Vector< Number >::update_ghost_values ( ) const

This function does nothing but is there for compatibility with the PETScWrappers::Vector class.

For the PETSc vector wrapper class, this function updates the ghost values of the PETSc vector. This is necessary after any modification before reading ghost values.

However, for the implementation of this class, it is immaterial and thus an empty function.

template<typename Number>
 void Vector< Number >::print ( const char * format = 0 ) const

Output of vector in user-defined format. For complex-valued vectors, the format should include specifiers for both the real and imaginary parts.

This function is deprecated.

template<typename Number>
 void Vector< Number >::print ( std::ostream & out, const unsigned int precision = 3, const bool scientific = true, const bool across = true ) const

Print to a stream. precision denotes the desired precision with which values shall be printed, scientific whether scientific notation shall be used. If across is true then the vector is printed in a line, while if false then the elements are printed on a separate line each.

template<typename Number>
 void Vector< Number >::print ( LogStream & out, const unsigned int width = 6, const bool across = true ) const

Print to a LogStream. width is used as argument to the std::setw manipulator, if printing across. If across is true then the vector is printed in a line, while if false then the elements are printed on a separate line each.

This function is deprecated.

template<typename Number>
 void Vector< Number >::block_write ( std::ostream & out ) const

Write the vector en bloc to a file. This is done in a binary mode, so the output is neither readable by humans nor (probably) by other computers using a different operating system or number format.

template<typename Number>
 void Vector< Number >::block_read ( std::istream & in )

Read a vector en block from a file. This is done using the inverse operations to the above function, so it is reasonably fast because the bitstream is not interpreted.

The vector is resized if necessary.

A primitive form of error checking is performed which will recognize the bluntest attempts to interpret some data as a vector stored bitwise to a file, but not more.

template<typename Number>
template<class Archive >
 void Vector< Number >::save ( Archive & ar, const unsigned int version ) const

Write the data of this object to a stream for the purpose of serialization.

template<typename Number>
template<class Archive >
 void Vector< Number >::load ( Archive & ar, const unsigned int version )

Read the data of this object from a stream for the purpose of serialization.

template<typename Number>
 bool Vector< Number >::in_local_range ( const size_type global_index ) const

Return true if the given global index is in the local range of this processor. Since this is not a distributed vector the method always returns true.

template<typename Number>
 IndexSet Vector< Number >::locally_owned_elements ( ) const

Return an index set that describes which elements of this vector are owned by the current processor. Note that this index set does not include elements this vector may store locally as ghost elements but that are in fact owned by another processor. As a consequence, the index sets returned on different processors if this is a distributed vector will form disjoint sets that add up to the complete index set. Obviously, if a vector is created on only one processor, then the result would satisfy

vec.locally_owned_elements() == complete_index_set (vec.size())

Since the current data type does not support parallel data storage across different processors, the returned index set is the complete index set.

template<typename Number>
 std::size_t Vector< Number >::size ( ) const

Return dimension of the vector.

template<typename Number>
 bool Vector< Number >::all_zero ( ) const

Return whether the vector contains only elements with value zero. This function is mainly for internal consistency checks and should seldom be used when not in debug mode since it uses quite some time.

template<typename Number>
 bool Vector< Number >::is_non_negative ( ) const

Return true if the vector has no negative entries, i.e. all entries are zero or positive. This function is used, for example, to check whether refinement indicators are really all positive (or zero).

The function obviously only makes sense if the template argument of this class is a real type. If it is a complex type, then an exception is thrown.

template<typename Number>
 std::size_t Vector< Number >::memory_consumption ( ) const

Determine an estimate for the memory consumption (in bytes) of this object.

template<typename Number>
 void Vector< Number >::allocate ( )
private

Allocate and align val along 64-byte boundaries. The size of the allocated memory is determined by max_vec_size .

template<typename Number>
 void Vector< Number >::deallocate ( )
private

Deallocate val.

## Friends And Related Function Documentation

template<typename Number>
template<typename Number2 >
 friend class Vector
friend

Make all other vector types friends.

Make all other ReadWriteVector types friends.

Typedef for the vector type used.

Definition at line 1021 of file vector.h.

template<typename Number>
template<typename Number2 >
 friend class LAPACKFullMatrix
friend

Definition at line 1026 of file vector.h.

template<typename Number>
 friend class VectorView< Number >
friend

VectorView will access the pointer.

Definition at line 1031 of file vector.h.

template<typename Number >
 void swap ( LinearAlgebra::distributed::Vector< Number > & u, LinearAlgebra::distributed::Vector< Number > & v )
related

Global function swap which overloads the default implementation of the C++ standard library which uses a temporary object. The function simply exchanges the data of the two vectors.

Definition at line 1466 of file la_parallel_vector.h.

template<typename Number >
 void swap ( LinearAlgebra::ReadWriteVector< Number > & u, LinearAlgebra::ReadWriteVector< Number > & v )
related

Global function swap which overloads the default implementation of the C++ standard library which uses a temporary object. The function simply exchanges the data of the two vectors.

Definition at line 930 of file read_write_vector.h.

## Member Data Documentation

template<typename Number>
 const bool Vector< Number >::supports_distributed_data = false
static

A variable that indicates whether this vector supports distributed data storage. If true, then this vector also needs an appropriate compress() function that allows communicating recent set or add operations to individual elements to be communicated to other processors.

For the current class, the variable equals false, since it does not support parallel data storage.

Deprecated:
instead of using this variable, please use the type trait value is_serial_vector< VectorType >::value

Definition at line 169 of file vector.h.

template<typename Number>
 size_type Vector< Number >::vec_size
protected

Dimension. Actual number of components contained in the vector. Get this number by calling size().

Definition at line 997 of file vector.h.

template<typename Number>
 size_type Vector< Number >::max_vec_size
protected

Amount of memory actually reserved for this vector. This number may be greater than vec_size if a reinit was called with less memory requirements than the vector needed last time. At present reinit does not free memory when the number of needed elements is reduced.

Definition at line 1005 of file vector.h.

template<typename Number>
 Number* Vector< Number >::val
protected

Pointer to the array of elements of this vector.

Definition at line 1010 of file vector.h.

template<typename Number>