Public Types | |
typedef Number | value_type |
typedef value_type * | pointer |
typedef const value_type * | const_pointer |
typedef value_type * | iterator |
typedef const value_type * | const_iterator |
typedef value_type & | reference |
typedef const value_type & | const_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 > |
Related Functions | |
(Note that these are not member functions.) | |
template<typename Number > | |
void | swap (Vector< Number > &u, Vector< Number > &v) |
vector
(with a lowercase "v"), this class implements an element of a vector space suitable for numerical computations.
<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).typedef Number Vector< Number >::value_type |
Declare standard types used in all containers. These types parallel those in the C++
standard libraries vector<...>
class.
typedef value_type* Vector< Number >::pointer |
typedef const value_type* Vector< Number >::const_pointer |
typedef value_type* Vector< Number >::iterator |
typedef const value_type* Vector< Number >::const_iterator |
typedef value_type& Vector< Number >::reference |
typedef const value_type& Vector< Number >::const_reference |
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. Create a vector of dimension zero.
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.
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.
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.
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.
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.
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.
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.
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.
Destructor, deallocates memory. Made virtual to allow for derived classes to behave properly.
void Vector< Number >::compress | ( | ) | const |
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.
virtual void Vector< Number >::reinit | ( | const unsigned int | N, | |
const bool | fast = 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 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 >.
Referenced by PETScWrappers::MPI::BlockVector::reinit(), PETScWrappers::BlockVector::reinit(), and Vector< Number >::Vector().
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)
.
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.
Reimplemented in VectorView< Number >.
Referenced by Vector< Number >::swap(), TrilinosWrappers::BlockVector::swap(), and TrilinosWrappers::MPI::BlockVector::swap().
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.
Vector<Number>& Vector< Number >::operator= | ( | const Vector< Number > & | c | ) |
Copy the given vector. Resize the present vector if necessary.
Vector<Number>& Vector< Number >::operator= | ( | const Vector< Number2 > & | v | ) | [inline] |
Copy the given vector. Resize the present vector if necessary.
Vector<Number>& Vector< Number >::operator= | ( | const BlockVector< Number > & | v | ) |
Copy operator for assigning a block vector to a regular vector.
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.
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.
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.
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.
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.
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.
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 .
Return square of the -norm.
Number Vector< Number >::mean_value | ( | ) | const |
Mean value of the elements of this vector.
-norm of the vector. The sum of the absolute values.
-norm of the vector. The square root of the sum of the squares of the elements.
-norm of the vector. The pth root of the sum of the pth powers of the absolute values of the elements.
Maximum absolute value of the elements.
Return dimension of the vector.
Referenced by PointerMatrixVector< number >::Tvmult(), PointerMatrixVector< number >::Tvmult_add(), PointerMatrixVector< number >::vmult(), and PointerMatrixVector< number >::vmult_add().
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.
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.
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.
Referenced by Vector< Number >::add(), Vector< Number >::operator=(), Vector< Number >::sadd(), Vector< Number >::scale(), and Vector< Number >::Vector().
const_iterator Vector< Number >::begin | ( | ) | const |
Return constant iterator to the start of the vectors.
Return an iterator pointing to the element past the end of the array.
Referenced by Vector< Number >::add(), Vector< Number >::operator=(), Vector< Number >::sadd(), and Vector< Number >::scale().
const_iterator Vector< Number >::end | ( | ) | const |
Return a constant iterator pointing to the element past the end of the array.
Access the value of the ith
component.
Access the ith
component as a writeable reference.
Vector<Number>& Vector< Number >::operator+= | ( | const Vector< Number > & | V | ) |
Add the given vector to the present one.
Vector<Number>& Vector< Number >::operator-= | ( | const Vector< Number > & | V | ) |
Subtract the given vector from the present one.
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().
Simple vector addition, equal to the operator +=
.
Simple addition of a multiple of a vector, i.e. *this += a*V
.
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
.
void Vector< Number >::sadd | ( | const Number | s, | |
const Vector< Number > & | V | |||
) |
Scaling and simple vector addition, i.e. *this = s*(*this)+V
.
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
.
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.
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
.
void Vector< Number >::scale | ( | const Number | 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.
Referenced by Vector< Number >::operator*=().
Scale each element of the vector by a constant value.
Referenced by Vector< Number >::operator/=().
Scale each element of the vector by the inverse of the given value.
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.
void Vector< Number >::equ | ( | const Number | a, | |
const Vector< Number2 > & | u | |||
) | [inline] |
Assignment *this = a*u
.
Referenced by PointerMatrixVector< number >::Tvmult().
void Vector< Number >::equ | ( | const Number | a, | |
const Vector< Number > & | u, | |||
const Number | b, | |||
const Vector< Number > & | v | |||
) |
Assignment *this = a*u + b*v
.
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
.
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.
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.
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.
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.
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.
Determine an estimate for the memory consumption (in bytes) of this object.
Reimplemented in SwappableVector< number >.
friend class Vector [friend] |
friend class LAPACKFullMatrix< Number > [friend] |
friend class VectorView< Number > [friend] |
Dimension. Actual number of components contained in the vector. Get this number by calling size()
.
Referenced by Vector< Number >::add(), Vector< Number >::end(), Vector< Number >::operator()(), Vector< Number >::operator=(), Vector< Number >::reinit(), Vector< Number >::sadd(), Vector< Number >::scale(), Vector< Number >::size(), and Vector< Number >::swap().
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 Vector< Number >::reinit(), and Vector< Number >::swap().
Pointer to the array of elements of this vector.
Referenced by Vector< Number >::begin(), Vector< Number >::end(), Vector< Number >::operator()(), Vector< Number >::reinit(), Vector< Number >::swap(), and Vector< Number >::~Vector().