
Public Types | |
| typedef BlockVectorBase < Vector< Number > > | BaseClass |
| typedef BaseClass::BlockType | BlockType |
| typedef BaseClass::value_type | value_type |
| typedef BaseClass::real_type | real_type |
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 std::vector< unsigned int > &block_sizes) | |
| ~BlockVector () | |
| BlockVector & | operator= (const value_type s) |
| BlockVector & | operator= (const BlockVector &V) |
| template<class Number2 > | |
| BlockVector & | operator= (const BlockVector< Number2 > &V) |
| BlockVector & | operator= (const Vector< Number > &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) |
Static Public Member Functions | |
| ::ExceptionBase & | ExcIteratorRangeDoesNotMatchVectorSize () |
An implementation of block vectors based on distribued 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.
<float> and <double>; others can be generated in application programs (see the section on Template instantiations in the manual).Definition at line 55 of file parallel_block_vector.h.
| typedef BlockVectorBase<Vector<Number> > parallel::distributed::BlockVector< Number >::BaseClass |
Typedef the base class for simpler access to its own typedefs.
Definition at line 62 of file parallel_block_vector.h.
| typedef BaseClass::BlockType parallel::distributed::BlockVector< Number >::BlockType |
Typedef the type of the underlying vector.
Reimplemented from BlockVectorBase< Vector< Number > >.
Definition at line 68 of file parallel_block_vector.h.
| typedef BaseClass::value_type parallel::distributed::BlockVector< Number >::value_type |
Import the typedefs from the base class.
Reimplemented from BlockVectorBase< Vector< Number > >.
Definition at line 74 of file parallel_block_vector.h.
| typedef BaseClass::real_type parallel::distributed::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 > >.
Definition at line 75 of file parallel_block_vector.h.
| parallel::distributed::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.
| parallel::distributed::BlockVector< Number >::BlockVector | ( | const BlockVector< Number > & | V | ) |
Copy-Constructor. Dimension set to that of V, all components are copied from V
| parallel::distributed::BlockVector< Number >::BlockVector | ( | const BlockVector< OtherNumber > & | v | ) | [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.
| parallel::distributed::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.
| parallel::distributed::BlockVector< Number >::~BlockVector | ( | ) |
Destructor. Clears memory
| BlockVector& parallel::distributed::BlockVector< Number >::operator= | ( | const value_type | s | ) |
Copy operator: fill all components of the vector with the given scalar value.
Reimplemented from BlockVectorBase< Vector< Number > >.
| BlockVector& parallel::distributed::BlockVector< Number >::operator= | ( | const BlockVector< Number > & | V | ) |
Copy operator for arguments of the same type. Resize the present vector if necessary.
| BlockVector& parallel::distributed::BlockVector< Number >::operator= | ( | const BlockVector< Number2 > & | V | ) |
Copy operator for template arguments of different types. Resize the present vector if necessary.
| BlockVector& parallel::distributed::BlockVector< Number >::operator= | ( | const Vector< Number > & | V | ) |
Copy a regular vector into a block vector.
| void parallel::distributed::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.
| void parallel::distributed::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.
| void parallel::distributed::BlockVector< Number >::reinit | ( | const BlockVector< Number2 > & | V, |
| const bool | fast = 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(), 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.
| void parallel::distributed::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.
operator*= instead. | void parallel::distributed::BlockVector< Number >::scale | ( | const BlockVector2 & | v | ) |
Multiply each element of this vector by the corresponding element of v.
Reimplemented from BlockVectorBase< Vector< Number > >.
| void parallel::distributed::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().
documentation generated on Tue May 22 2012 12:07:05 by
doxygen
1.7.3