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 () | |
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) |
BlockVector & | operator= (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) |
<float> and <double>
; others can be generated in application programs (see the section on Template instantiations in the manual).typedef BlockVectorBase<Vector<Number> > BlockVector< Number >::BaseClass |
Typedef the base class for simpler access to its own typedefs.
typedef BaseClass::BlockType BlockVector< Number >::BlockType |
Typedef the type of the underlying vector.
Reimplemented from BlockVectorBase< Vector< Number > >.
typedef BaseClass::value_type BlockVector< Number >::value_type |
Import the typedefs from the base class.
Reimplemented from BlockVectorBase< Vector< 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 > >.
typedef BaseClass::pointer BlockVector< Number >::pointer |
Reimplemented from BlockVectorBase< Vector< Number > >.
typedef BaseClass::const_pointer BlockVector< Number >::const_pointer |
Reimplemented from BlockVectorBase< Vector< Number > >.
typedef BaseClass::reference BlockVector< Number >::reference |
Reimplemented from BlockVectorBase< Vector< Number > >.
typedef BaseClass::const_reference BlockVector< Number >::const_reference |
Reimplemented from BlockVectorBase< Vector< Number > >.
typedef BaseClass::size_type BlockVector< Number >::size_type |
Reimplemented from BlockVectorBase< Vector< Number > >.
typedef BaseClass::iterator BlockVector< Number >::iterator |
Reimplemented from BlockVectorBase< Vector< Number > >.
typedef BaseClass::const_iterator BlockVector< Number >::const_iterator |
Reimplemented from BlockVectorBase< Vector< 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.
BlockVector< Number >::BlockVector | ( | const BlockVector< Number > & | V | ) |
Copy-Constructor. Dimension set to that of V, all components are copied from V
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.
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.
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.
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.
BlockVector< Number >::~BlockVector | ( | ) |
Destructor. Clears memory
BlockVector& BlockVector< Number >::operator= | ( | const value_type | s | ) |
Copy operator: fill all components of the vector with the given scalar value.
BlockVector& BlockVector< Number >::operator= | ( | const BlockVector< Number > & | V | ) |
Copy operator for arguments of the same type. Resize the present vector if necessary.
BlockVector& BlockVector< Number >::operator= | ( | const BlockVector< Number2 > & | V | ) | [inline] |
Copy operator for template arguments of different types. Resize the present vector if necessary.
BlockVector& BlockVector< Number >::operator= | ( | const Vector< Number > & | V | ) |
Copy a regular vector into a block vector.
Reimplemented from BlockVectorBase< Vector< Number > >.
BlockVector& BlockVector< Number >::operator= | ( | const TrilinosWrappers::BlockVector< Number > & | V | ) |
A copy constructor from a Trilinos block vector to a deal.II block vector.
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().
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.
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.
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.
operator*=
instead. Referenced by SchurMatrix< MA_inverse, MB, MDt, MC >::residual().
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 > >.
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().
void BlockVector< Number >::print | ( | const char * | format = 0 |
) | const |
Output of vector in user-defined format.
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.
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.
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.
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.
References BlockVector< Number >::swap().