BlockVector< Number > Class Template Reference
[Vector classes]

Inheritance diagram for BlockVector< Number >:

Inheritance graph
[legend]

List of all members.

Classes

class  ExcIteratorRangeDoesNotMatchVectorSize

Public Types

typedef BlockVectorBase
< Vector< Number > > 
BaseClass
typedef BaseClass::BlockType BlockType
typedef BaseClass::value_type value_type
typedef BaseClass::real_type real_type
typedef BaseClass::pointer pointer
typedef BaseClass::const_pointer const_pointer
typedef BaseClass::reference reference
typedef BaseClass::const_reference const_reference
typedef BaseClass::size_type size_type
typedef BaseClass::iterator iterator
typedef BaseClass::const_iterator const_iterator

Public Member Functions

 BlockVector (const unsigned int num_blocks=0, const unsigned int block_size=0)
 BlockVector (const BlockVector< Number > &V)
template<typename OtherNumber >
 BlockVector (const BlockVector< OtherNumber > &v)
 BlockVector (const TrilinosWrappers::BlockVector &v)
 BlockVector (const std::vector< unsigned int > &block_sizes)
template<typename InputIterator >
 BlockVector (const std::vector< unsigned int > &n, const InputIterator first, const InputIterator end)
 ~BlockVector ()
BlockVectoroperator= (const value_type s)
BlockVectoroperator= (const BlockVector &V)
template<class Number2 >
BlockVectoroperator= (const BlockVector< Number2 > &V)
BlockVectoroperator= (const Vector< Number > &V)
BlockVectoroperator= (const TrilinosWrappers::BlockVector &V)
void reinit (const unsigned int num_blocks, const unsigned int block_size=0, const bool fast=false)
void reinit (const std::vector< unsigned int > &N, const bool fast=false)
template<typename Number2 >
void reinit (const BlockVector< Number2 > &V, const bool fast=false)
void scale (const value_type factor)
template<class BlockVector2 >
void scale (const BlockVector2 &v)
void swap (BlockVector< Number > &v)
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)

Related Functions

(Note that these are not member functions.)

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


Detailed Description

template<typename Number>
class BlockVector< Number >

An implementation of block vectors based on deal.II vectors. While the base class provides for most of the interface, this class handles the actual allocation of vectors and provides functions that are specific to the underlying vector type.

Note:
Instantiations for this template are provided for <float> and <double>; others can be generated in application programs (see the section on Template instantiations in the manual).
Author:
Wolfgang Bangerth, Guido Kanschat, 1999, 2000, 2001, 2002, 2004

Member Typedef Documentation

template<typename Number>
typedef BlockVectorBase<Vector<Number> > BlockVector< Number >::BaseClass

Typedef the base class for simpler access to its own typedefs.

template<typename Number>
typedef BaseClass::BlockType BlockVector< Number >::BlockType

Typedef the type of the underlying vector.

Reimplemented from BlockVectorBase< Vector< Number > >.

template<typename Number>
typedef BaseClass::value_type BlockVector< Number >::value_type

Import the typedefs from the base class.

Reimplemented from BlockVectorBase< Vector< Number > >.

template<typename Number>
typedef BaseClass::real_type BlockVector< 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.

Reimplemented from BlockVectorBase< Vector< Number > >.

template<typename Number>
typedef BaseClass::pointer BlockVector< Number >::pointer

template<typename Number>
typedef BaseClass::const_pointer BlockVector< Number >::const_pointer

template<typename Number>
typedef BaseClass::reference BlockVector< Number >::reference

template<typename Number>
typedef BaseClass::const_reference BlockVector< Number >::const_reference

template<typename Number>
typedef BaseClass::size_type BlockVector< Number >::size_type

template<typename Number>
typedef BaseClass::iterator BlockVector< Number >::iterator

template<typename Number>
typedef BaseClass::const_iterator BlockVector< Number >::const_iterator


Constructor & Destructor Documentation

template<typename Number>
BlockVector< Number >::BlockVector ( const unsigned int  num_blocks = 0,
const unsigned int  block_size = 0 
) [explicit]

Constructor. There are three ways to use this constructor. First, without any arguments, it generates an object with no blocks. Given one argument, it initializes num_blocks blocks, but these blocks have size zero. The third variant finally initializes all blocks to the same size block_size.

Confer the other constructor further down if you intend to use blocks of different sizes.

template<typename Number>
BlockVector< Number >::BlockVector ( const BlockVector< Number > &  V  ) 

Copy-Constructor. Dimension set to that of V, all components are copied from V

template<typename Number>
template<typename OtherNumber >
BlockVector< Number >::BlockVector ( const BlockVector< OtherNumber > &  v  )  [inline, explicit]

Copy constructor taking a BlockVector 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 BlockVector 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>
BlockVector< Number >::BlockVector ( const TrilinosWrappers::BlockVector< Number > &  v  ) 

A copy constructor taking a (parallel) Trilinos block vector and copying it into the deal.II own format.

template<typename Number>
BlockVector< Number >::BlockVector ( const std::vector< unsigned int > &  block_sizes  ) 

Constructor. Set the number of blocks to block_sizes.size() and initialize each block with block_sizes[i] zero elements.

template<typename Number>
template<typename InputIterator >
BlockVector< Number >::BlockVector ( const std::vector< unsigned int > &  n,
const InputIterator  first,
const InputIterator  end 
) [inline]

Constructor. Set the number of blocks to n.size(). Initialize the vector with the elements pointed to by the range of iterators given as second and third argument. Apart from the first argument, this constructor is in complete analogy to the respective constructor of the std::vector class, but the first argument is needed in order to know how to subdivide the block vector into different blocks.

template<typename Number>
BlockVector< Number >::~BlockVector (  ) 

Destructor. Clears memory


Member Function Documentation

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

Copy operator: fill all components of the vector with the given scalar value.

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

Copy operator for arguments of the same type. Resize the present vector if necessary.

template<typename Number>
template<class Number2 >
BlockVector& BlockVector< Number >::operator= ( const BlockVector< Number2 > &  V  )  [inline]

Copy operator for template arguments of different types. Resize the present vector if necessary.

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

Copy a regular vector into a block vector.

Reimplemented from BlockVectorBase< Vector< Number > >.

template<typename Number>
BlockVector& BlockVector< Number >::operator= ( const TrilinosWrappers::BlockVector< Number > &  V  ) 

A copy constructor from a Trilinos block vector to a deal.II block vector.

template<typename Number>
void BlockVector< Number >::reinit ( const unsigned int  num_blocks,
const unsigned int  block_size = 0,
const bool  fast = false 
)

Reinitialize the BlockVector to contain num_blocks blocks of size block_size each.

If the second argument is left at its default value, then the block vector allocates the specified number of blocks but leaves them at zero size. You then need to later reinitialize the individual blocks, and call collect_sizes() to update the block system's knowledge of its individual block's sizes.

If fast==false, the vector is filled with zeros.

Referenced by SchurMatrix< MA_inverse, MB, MDt, MC >::postprocess(), SchurMatrix< MA_inverse, MB, MDt, MC >::prepare_rhs(), and SchurMatrix< MA_inverse, MB, MDt, MC >::vmult().

template<typename Number>
void BlockVector< Number >::reinit ( const std::vector< unsigned int > &  N,
const bool  fast = false 
)

Reinitialize the BlockVector such that it contains block_sizes.size() blocks. Each block is reinitialized to dimension block_sizes[i].

If the number of blocks is the same as before this function was called, all vectors remain the same and reinit() is called for each vector.

If fast==false, the vector is filled with zeros.

Note that you must call this (or the other reinit() functions) function, rather than calling the reinit() functions of an individual block, to allow the block vector to update its caches of vector sizes. If you call reinit() on one of the blocks, then subsequent actions on this object may yield unpredictable results since they may be routed to the wrong block.

template<typename Number>
template<typename Number2 >
void BlockVector< Number >::reinit ( const BlockVector< 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).

Note that you must call this (or the other reinit() functions) function, rather than calling the reinit() functions of an individual block, to allow the block vector to update its caches of vector sizes. If you call reinit() of one of the blocks, then subsequent actions of this object may yield unpredictable results since they may be routed to the wrong block.

template<typename Number>
void BlockVector< Number >::scale ( const value_type  factor  ) 

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.

Deprecated:
Use operator*= instead.

Referenced by SchurMatrix< MA_inverse, MB, MDt, MC >::residual().

template<typename Number>
template<class BlockVector2 >
void BlockVector< Number >::scale ( const BlockVector2 &  v  )  [inline]

Multiply each element of this vector by the corresponding element of v.

Reimplemented from BlockVectorBase< Vector< Number > >.

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

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.

Limitation: right now this function only works if both vectors have the same number of blocks. If needed, the numbers of blocks should be exchanged, too.

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.

Referenced by BlockVector< Number >::swap().

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

Output of vector in user-defined format.

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

Print to a stream.

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

Write the vector en bloc to a stream. 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 BlockVector< 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.


Friends And Related Function Documentation

template<typename Number >
void swap ( BlockVector< Number > &  u,
BlockVector< Number > &  v 
) [related]

Global function 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.

Author:
Wolfgang Bangerth, 2000

References BlockVector< Number >::swap().


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

deal.II documentation generated on Sat Aug 15 16:51:41 2009 by doxygen 1.5.9