Vector< Number > Class Template Reference
[Vector classes]

Inheritance diagram for Vector< Number >:
Inheritance graph
[legend]

List of all members.

Public Types

typedef Number value_type
typedef value_typepointer
typedef const value_typeconst_pointer
typedef value_typeiterator
typedef const value_typeconst_iterator
typedef value_typereference
typedef const value_typeconst_reference
typedef size_t size_type
typedef numbers::NumberTraits
< Number >::real_type 
real_type

Public Member Functions

1: Basic Object-handling



 Vector ()
 Vector (const 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 unsigned int n)
template<typename InputIterator >
 Vector (const InputIterator first, const InputIterator last)
virtual ~Vector ()
void compress () const
virtual void reinit (const unsigned int N, const bool fast=false)
template<typename Number2 >
void reinit (const Vector< Number2 > &V, const bool fast=false)
virtual void swap (Vector< Number > &v)
Vector< Number > & operator= (const Number s)
Vector< Number > & operator= (const Vector< Number > &c)
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
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
unsigned int size () const
bool all_zero () const
bool is_non_negative () const
iterator begin ()
const_iterator begin () const
iterator end ()
const_iterator end () const
2: Data-Access



Number operator() (const unsigned int i) const
Number & operator() (const unsigned int i)
3: Modification of vectors



Vector< Number > & operator+= (const Vector< Number > &V)
Vector< Number > & operator-= (const Vector< Number > &V)
void add (const Number s)
void add (const Vector< Number > &V)
void add (const Number a, const Vector< Number > &V)
void add (const Number a, const Vector< Number > &V, const Number b, const Vector< Number > &W)
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)
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)
void scale (const Number factor)
Vector< Number > & operator*= (const Number factor)
Vector< Number > & operator/= (const Number factor)
template<typename Number2 >
void scale (const Vector< Number2 > &scaling_factors)
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)
void equ (const Number a, const Vector< Number > &u, const Number b, const Vector< Number > &v, const Number c, const Vector< Number > &w)
void ratio (const Vector< Number > &a, const Vector< Number > &b)
5: Mixed stuff



void print (const char *format=0) const
void print (std::ostream &out, const unsigned int precision=3, const bool scientific=true, const bool across=true) const
void block_write (std::ostream &out) const
void block_read (std::istream &in)
unsigned int memory_consumption () const

Protected Attributes

unsigned int vec_size
unsigned int max_vec_size
Number * val

Friends

class Vector
class LAPACKFullMatrix< Number >
class VectorView< Number >

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 mesures the norm of the vector in order to mesure its length in a suitable norm. The second type support the abgebraic operation for vectors. The third und last type helps us to manipulate the components of the vector. 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>, <long double>, <std::complex<float>>, <std::complex<double>>, <std::complex<long double>>; others can be generated in application programs (see the section on Template instantiations in the manual).
Author:
Guido Kanschat, Franz-Theo Suttmeier, Wolfgang Bangerth

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.

template<typename Number>
typedef value_type* Vector< Number >::pointer
template<typename Number>
typedef const value_type* Vector< Number >::const_pointer
template<typename Number>
typedef value_type* Vector< Number >::iterator
template<typename Number>
typedef const value_type* Vector< Number >::const_iterator
template<typename Number>
typedef value_type& Vector< Number >::reference
template<typename Number>
typedef const value_type& Vector< Number >::const_reference
template<typename Number>
typedef size_t Vector< Number >::size_type
template<typename Number>
typedef numbers::NumberTraits<Number>::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.


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 STL insists on using it implicitly.

template<typename Number>
template<typename OtherNumber >
Vector< Number >::Vector ( const Vector< OtherNumber > &  v  )  [inline, 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  ) 

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  ) 

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  ) 

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  ) 

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 unsigned int  n  )  [inline, 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.

References Vector< Number >::reinit().

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

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.

References Vector< Number >::begin(), and Vector< Number >::reinit().

template<typename Number >
Vector< Number >::~Vector (  )  [inline, virtual]

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

References Vector< Number >::val.


Member Function Documentation

template<typename Number >
void Vector< Number >::compress (  )  const [inline]

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

For the PETSc vector wrapper class, thios 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 >
void Vector< Number >::reinit ( const unsigned int  N,
const bool  fast = false 
) [inline, 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 STL containers.

If fast 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 >.

References Assert, Vector< Number >::max_vec_size, Vector< Number >::val, and Vector< Number >::vec_size.

Referenced by PETScWrappers::MPI::BlockVector::reinit(), PETScWrappers::BlockVector::reinit(), and Vector< Number >::Vector().

template<typename Number>
template<typename Number2 >
void Vector< Number >::reinit ( const Vector< Number2 > &  V,
const bool  fast = false 
) [inline]

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(), fast).

template<typename Number>
void Vector< Number >::swap ( Vector< Number > &  v  )  [inline, 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 analog 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.

References Vector< Number >::max_vec_size, Vector< Number >::val, and Vector< Number >::vec_size.

Referenced by TrilinosWrappers::BlockVector::swap(), and TrilinosWrappers::MPI::BlockVector::swap().

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

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.

References Assert, Vector< Number >::begin(), Vector< Number >::end(), numbers::is_finite(), and Vector< Number >::vec_size.

Referenced by VectorView< Number >::reinit().

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

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

Reimplemented from Subscriptor.

Reimplemented in SwappableVector< number >.

template<typename Number>
template<typename Number2 >
Vector<Number>& Vector< Number >::operator= ( const Vector< Number2 > &  v  )  [inline]

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

Reimplemented from Subscriptor.

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

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

template<typename Number>
Vector<Number>& 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<Number>& 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<Number>& 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<Number>& 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.

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

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 [inline]

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 [inline]

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}$.

template<typename Number>
real_type Vector< Number >::norm_sqr (  )  const

Return square of the $l_2$-norm.

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

Mean value of the elements of this vector.

template<typename Number>
real_type Vector< Number >::l1_norm (  )  const

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

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.

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.

template<typename Number>
real_type Vector< Number >::linfty_norm (  )  const

Maximum absolute value of the elements.

template<typename Number >
unsigned int Vector< Number >::size (  )  const [inline]
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 seldomly 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 >
Vector< Number >::iterator Vector< Number >::begin (  )  [inline]

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.

References Vector< Number >::val.

Referenced by Vector< Number >::add(), Vector< Number >::operator=(), Vector< Number >::sadd(), Vector< Number >::scale(), and Vector< Number >::Vector().

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

Return constant iterator to the start of the vectors.

References Vector< Number >::val.

template<typename Number >
Vector< Number >::iterator Vector< Number >::end (  )  [inline]

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

References Vector< Number >::val, and Vector< Number >::vec_size.

Referenced by Vector< Number >::add(), Vector< Number >::operator=(), Vector< Number >::sadd(), and Vector< Number >::scale().

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

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

References Vector< Number >::val, and Vector< Number >::vec_size.

template<typename Number >
Number Vector< Number >::operator() ( const unsigned int  i  )  const [inline]

Access the value of the ith component.

References Assert, Vector< Number >::val, and Vector< Number >::vec_size.

template<typename Number >
Number & Vector< Number >::operator() ( const unsigned int  i  )  [inline]

Access the ith component as a writeable reference.

References Assert, Vector< Number >::val, and Vector< Number >::vec_size.

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

Add the given vector to the present one.

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

Subtract the given vector from the present one.

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.

Referenced by PointerMatrixVector< number >::Tvmult_add().

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

Simple vector addition, equal to the operator +=.

template<typename Number>
void Vector< Number >::add ( const Number  a,
const Vector< Number > &  V 
) [inline]

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

References Assert, Vector< Number >::begin(), Vector< Number >::end(), numbers::is_finite(), and Vector< Number >::vec_size.

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.

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.

template<typename Number>
void Vector< Number >::sadd ( const Number  s,
const Number  a,
const Vector< Number > &  V 
) [inline]

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

References Assert, Vector< Number >::begin(), Vector< Number >::end(), numbers::is_finite(), and Vector< Number >::vec_size.

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

Scaling and multiple addition.

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.

template<typename Number>
void Vector< Number >::scale ( const Number  factor  )  [inline]

Scale each element of the vector by the given factor.

This function is deprecated and will be removed in a future version. Use operator *= and operator /= instead.

References Assert, Vector< Number >::begin(), Vector< Number >::end(), numbers::is_finite(), and Vector< Number >::vec_size.

Referenced by Vector< Number >::operator*=().

template<typename Number>
Vector< Number > & Vector< Number >::operator*= ( const Number  factor  )  [inline]

Scale each element of the vector by a constant value.

References Assert, numbers::is_finite(), and Vector< Number >::scale().

Referenced by Vector< Number >::operator/=().

template<typename Number>
Vector< Number > & Vector< Number >::operator/= ( const Number  factor  )  [inline]

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

References Assert, numbers::is_finite(), and Vector< Number >::operator*=().

template<typename Number>
template<typename Number2 >
void Vector< Number >::scale ( const Vector< Number2 > &  scaling_factors  )  [inline]

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>
template<typename Number2 >
void Vector< Number >::equ ( const Number  a,
const Vector< Number2 > &  u 
) [inline]

Assignment *this = a*u.

Referenced by PointerMatrixVector< number >::Tvmult().

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.

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.

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.

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.

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 >::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>
unsigned int Vector< Number >::memory_consumption (  )  const

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

Reimplemented in SwappableVector< number >.


Friends And Related Function Documentation

template<typename Number>
Vector< Number >::Vector [friend]
template<typename Number>
friend class LAPACKFullMatrix< Number > [friend]
template<typename Number>
friend class VectorView< Number > [friend]

Member Data Documentation

template<typename Number>
unsigned int Vector< Number >::vec_size [protected]
template<typename Number>
unsigned int 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.

Referenced by VectorView< Number >::reinit(), Vector< Number >::reinit(), Vector< Number >::swap(), VectorView< Number >::VectorView(), and VectorView< Number >::~VectorView().

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

The documentation for this class was generated from the following file:

deal.II documentation generated on Mon Nov 23 22:58:16 2009 by doxygen 1.6.1