* Copy operator: fill all components of the vector with the given
* scalar value.
*/
- BlockVector &operator = (const value_type s);
+ virtual BlockVector &operator = (const value_type s) override;
/**
* Copy operator for arguments of the same type. Resize the present
* elements do not agree.
*
*/
- void compress (::dealii::VectorOperation::values operation);
+ virtual void compress (::dealii::VectorOperation::values operation) override;
/**
* Fills the data field for ghost indices with the values stored in the
/**
* Compute the mean value of all the entries in the vector.
*/
- Number mean_value () const;
+ virtual Number mean_value () const override;
/**
* $l_p$-norm of the vector. The pth root of the sum of the pth powers
* copied.
*/
virtual void reinit(const VectorSpaceVector<Number> &V,
- const bool omit_zeroing_entries = false);
+ const bool omit_zeroing_entries = false) override;
/**
* Multiply the entire vector by a fixed factor.
*/
- virtual BlockVector<Number> &operator*= (const Number factor);
+ virtual BlockVector<Number> &operator*= (const Number factor) override;
/**
* Divide the entire vector by a fixed factor.
*/
- virtual BlockVector<Number> &operator/= (const Number factor);
+ virtual BlockVector<Number> &operator/= (const Number factor) override;
/**
* Add the vector @p V to the present one.
*/
- virtual BlockVector<Number> &operator+= (const VectorSpaceVector<Number> &V);
+ virtual BlockVector<Number> &operator+= (const VectorSpaceVector<Number> &V) override;
/**
* Subtract the vector @p V from the present one.
*/
- virtual BlockVector<Number> &operator-= (const VectorSpaceVector<Number> &V);
+ virtual BlockVector<Number> &operator-= (const VectorSpaceVector<Number> &V) override;
/**
* Import all the elements present in the vector's IndexSet from the input
virtual void import(const LinearAlgebra::ReadWriteVector<Number> &V,
VectorOperation::values operation,
std::shared_ptr<const CommunicationPatternBase> communication_pattern =
- std::shared_ptr<const CommunicationPatternBase> ());
+ std::shared_ptr<const CommunicationPatternBase> ()) override;
/**
* Return the scalar product of two vectors.
*/
- virtual Number operator* (const VectorSpaceVector<Number> &V) const;
+ virtual Number operator* (const VectorSpaceVector<Number> &V) const override;
/**
* Add @p a to all components. Note that @p a is a scalar not a vector.
*/
- virtual void add(const Number a);
+ virtual void add(const Number a) override;
/**
* Simple addition of a multiple of a vector, i.e. <tt>*this += a*V</tt>.
*/
- virtual void add(const Number a, const VectorSpaceVector<Number> &V);
+ virtual void add(const Number a, const VectorSpaceVector<Number> &V) override;
/**
* Multiple addition of scaled vectors, i.e. <tt>*this += a*V+b*W</tt>.
*/
virtual void add(const Number a, const VectorSpaceVector<Number> &V,
- const Number b, const VectorSpaceVector<Number> &W);
+ const Number b, const VectorSpaceVector<Number> &W) override;
/**
* A collective add operation: This function adds a whole set of values
* s*(*this)+a*V</tt>.
*/
virtual void sadd(const Number s, const Number a,
- const VectorSpaceVector<Number> &V);
+ const VectorSpaceVector<Number> &V) override;
/**
* 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.
*/
- virtual void scale(const VectorSpaceVector<Number> &scaling_factors);
+ virtual void scale(const VectorSpaceVector<Number> &scaling_factors) override;
/**
* Assignment <tt>*this = a*V</tt>.
*/
- virtual void equ(const Number a, const VectorSpaceVector<Number> &V);
+ virtual void equ(const Number a, const VectorSpaceVector<Number> &V) override;
/**
* Return the l<sub>1</sub> norm of the vector (i.e., the sum of the
* absolute values of all entries among all processors).
*/
- virtual real_type l1_norm() const;
+ virtual real_type l1_norm() const override;
/**
* Return the l<sub>2</sub> norm of the vector (i.e., the square root of
* the sum of the square of all entries among all processors).
*/
- virtual real_type l2_norm() const;
+ virtual real_type l2_norm() const override;
/**
* Return the maximum norm of the vector (i.e., the maximum absolute value
* among all entries and among all processors).
*/
- virtual real_type linfty_norm() const;
+ virtual real_type linfty_norm() const override;
/**
* Perform a combined operation of a vector addition and a subsequent
*/
virtual Number add_and_dot(const Number a,
const VectorSpaceVector<Number> &V,
- const VectorSpaceVector<Number> &W);
+ const VectorSpaceVector<Number> &W) override;
/**
* Return the global size of the vector, equal to the sum of the number of
* locally owned indices among all processors.
*/
- virtual size_type size() const;
+ virtual size_type size() const override;
/**
* Return an index set that describes which elements of this vector are
* vec.locally_owned_elements() == complete_index_set(vec.size())
* @endcode
*/
- virtual dealii::IndexSet locally_owned_elements() const;
+ virtual dealii::IndexSet locally_owned_elements() const override;
/**
* Print the vector to the output stream @p out.
virtual void print(std::ostream &out,
const unsigned int precision=3,
const bool scientific=true,
- const bool across=true) const;
+ const bool across=true) const override;
/**
* Return the memory consumption of this class in bytes.
*/
- virtual std::size_t memory_consumption() const;
+ virtual std::size_t memory_consumption() const override;
//@}
/**
/**
* Destructor.
*/
- virtual ~Vector ();
+ virtual ~Vector () override;
/**
* Set the global size of the vector to @p size without any actual
* ghost element is found, it is compared to the value on the owning
* processor and an exception is thrown if these elements do not agree.
*/
- void compress (::dealii::VectorOperation::values operation);
+ virtual void compress (::dealii::VectorOperation::values operation) override;
/**
* Fills the data field for ghost indices with the values stored in the
* copied.
*/
virtual void reinit(const VectorSpaceVector<Number> &V,
- const bool omit_zeroing_entries = false);
+ const bool omit_zeroing_entries = false) override;
/**
* Multiply the entire vector by a fixed factor.
*/
- virtual Vector<Number> &operator*= (const Number factor);
+ virtual Vector<Number> &operator*= (const Number factor) override;
/**
* Divide the entire vector by a fixed factor.
*/
- virtual Vector<Number> &operator/= (const Number factor);
+ virtual Vector<Number> &operator/= (const Number factor) override;
/**
* Add the vector @p V to the present one.
*/
- virtual Vector<Number> &operator+= (const VectorSpaceVector<Number> &V);
+ virtual Vector<Number> &operator+= (const VectorSpaceVector<Number> &V) override;
/**
* Subtract the vector @p V from the present one.
*/
- virtual Vector<Number> &operator-= (const VectorSpaceVector<Number> &V);
+ virtual Vector<Number> &operator-= (const VectorSpaceVector<Number> &V) override;
/**
* Import all the elements present in the vector's IndexSet from the input
virtual void import(const LinearAlgebra::ReadWriteVector<Number> &V,
VectorOperation::values operation,
std::shared_ptr<const CommunicationPatternBase> communication_pattern =
- std::shared_ptr<const CommunicationPatternBase> ());
+ std::shared_ptr<const CommunicationPatternBase> ()) override;
/**
* Return the scalar product of two vectors.
*/
- virtual Number operator* (const VectorSpaceVector<Number> &V) const;
+ virtual Number operator* (const VectorSpaceVector<Number> &V) const override;
/**
* Add @p a to all components. Note that @p a is a scalar not a vector.
*/
- virtual void add(const Number a);
+ virtual void add(const Number a) override;
/**
* Simple addition of a multiple of a vector, i.e. <tt>*this += a*V</tt>.
*/
- virtual void add(const Number a, const VectorSpaceVector<Number> &V);
+ virtual void add(const Number a, const VectorSpaceVector<Number> &V) override;
/**
* Multiple addition of scaled vectors, i.e. <tt>*this += a*V+b*W</tt>.
*/
virtual void add(const Number a, const VectorSpaceVector<Number> &V,
- const Number b, const VectorSpaceVector<Number> &W);
+ const Number b, const VectorSpaceVector<Number> &W) override;
/**
* A collective add operation: This function adds a whole set of values
* s*(*this)+a*V</tt>.
*/
virtual void sadd(const Number s, const Number a,
- const VectorSpaceVector<Number> &V);
+ const VectorSpaceVector<Number> &V) override;
/**
* 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.
*/
- virtual void scale(const VectorSpaceVector<Number> &scaling_factors);
+ virtual void scale(const VectorSpaceVector<Number> &scaling_factors) override;
/**
* Assignment <tt>*this = a*V</tt>.
*/
- virtual void equ(const Number a, const VectorSpaceVector<Number> &V);
+ virtual void equ(const Number a, const VectorSpaceVector<Number> &V) override;
/**
* Return the l<sub>1</sub> norm of the vector (i.e., the sum of the
* absolute values of all entries among all processors).
*/
- virtual real_type l1_norm() const;
+ virtual real_type l1_norm() const override;
/**
* Return the l<sub>2</sub> norm of the vector (i.e., the square root of
* the sum of the square of all entries among all processors).
*/
- virtual real_type l2_norm() const;
+ virtual real_type l2_norm() const override;
/**
* Return the maximum norm of the vector (i.e., the maximum absolute value
* among all entries and among all processors).
*/
- virtual real_type linfty_norm() const;
+ virtual real_type linfty_norm() const override;
/**
* Perform a combined operation of a vector addition and a subsequent
*/
virtual Number add_and_dot(const Number a,
const VectorSpaceVector<Number> &V,
- const VectorSpaceVector<Number> &W);
+ const VectorSpaceVector<Number> &W) override;
/**
* Return the global size of the vector, equal to the sum of the number of
* locally owned indices among all processors.
*/
- virtual size_type size() const;
+ virtual size_type size() const override;
/**
* Return an index set that describes which elements of this vector are
* vec.locally_owned_elements() == complete_index_set(vec.size())
* @endcode
*/
- virtual dealii::IndexSet locally_owned_elements() const;
+ virtual dealii::IndexSet locally_owned_elements() const override;
/**
* Print the vector to the output stream @p out.
virtual void print(std::ostream &out,
const unsigned int precision=3,
const bool scientific=true,
- const bool across=true) const;
+ const bool across=true) const override;
/**
* Return the memory consumption of this class in bytes.
*/
- virtual std::size_t memory_consumption() const;
+ virtual std::size_t memory_consumption() const override;
//@}
/**
* zero, also ghost elements are set to zero, otherwise they remain
* unchanged.
*/
- Vector<Number> &operator = (const Number s);
+ virtual Vector<Number> &operator = (const Number s) override;
/**
* This is a collective add operation that adds a whole set of values
/**
* Compute the mean value of all the entries in the vector.
*/
- virtual Number mean_value () const;
+ virtual Number mean_value () const override;
/**
* $l_p$-norm of the vector. The pth root of the sum of the pth powers
* user must make sure to fill it with reasonable data before using it).
*/
virtual void reinit(const size_type size,
- const bool omit_zeroing_entries = false);
+ const bool omit_zeroing_entries = false) override;
/**
* Uses the same IndexSet as the one of the input vector @p in_vector and
* locally_stored_indices.
*/
virtual void reinit(const IndexSet &locally_stored_indices,
- const bool omit_zeroing_entries = false);
+ const bool omit_zeroing_entries = false) override;
/**
* copied.
*/
virtual void reinit(const VectorSpaceVector<Number> &V,
- const bool omit_zeroing_entries = false);
+ const bool omit_zeroing_entries = false) override;
/**
* Copies the data of the input vector @p in_vector.
* Sets all elements of the vector to the scalar @p s. This operation is
* only allowed if @p s is equal to zero.
*/
- Vector<Number> &operator= (const Number s);
+ virtual Vector<Number> &operator= (const Number s) override;
/**
* Multiply the entire vector by a fixed factor.
*/
- virtual Vector<Number> &operator*= (const Number factor);
+ virtual Vector<Number> &operator*= (const Number factor) override;
/**
* Divide the entire vector by a fixed factor.
*/
- virtual Vector<Number> &operator/= (const Number factor);
+ virtual Vector<Number> &operator/= (const Number factor) override;
/**
* Add the vector @p V to the present one.
*/
- virtual Vector<Number> &operator+= (const VectorSpaceVector<Number> &V);
+ virtual Vector<Number> &operator+= (const VectorSpaceVector<Number> &V) override;
/**
* Subtract the vector @p V from the present one.
*/
- virtual Vector<Number> &operator-= (const VectorSpaceVector<Number> &V);
+ virtual Vector<Number> &operator-= (const VectorSpaceVector<Number> &V) override;
/**
* Return the scalar product of two vectors.
*/
- virtual Number operator* (const VectorSpaceVector<Number> &V) const;
+ virtual Number operator* (const VectorSpaceVector<Number> &V) const override;
/**
* This function is not implemented and will throw an exception.
VectorOperation::values operation,
std::shared_ptr<const CommunicationPatternBase>
communication_pattern =
- std::shared_ptr<const CommunicationPatternBase>());
+ std::shared_ptr<const CommunicationPatternBase>()) override;
/**
* Add @p a to all components. Note that @p a is a scalar not a vector.
*/
- virtual void add(const Number a);
+ virtual void add(const Number a) override;
/**
* Simple addition of a multiple of a vector, i.e. <tt>*this += a*V</tt>.
*/
- virtual void add(const Number a, const VectorSpaceVector<Number> &V);
+ virtual void add(const Number a, const VectorSpaceVector<Number> &V) override;
/**
* Multiple addition of a multiple of a vector, i.e. <tt>*this +=
* a*V+b*W</tt>.
*/
virtual void add(const Number a, const VectorSpaceVector<Number> &V,
- const Number b, const VectorSpaceVector<Number> &W);
+ const Number b, const VectorSpaceVector<Number> &W) override;
/**
* Scaling and simple addition of a multiple of a vector, i.e. <tt>*this =
* s*(*this)+a*V</tt>.
*/
virtual void sadd(const Number s, const Number a,
- const VectorSpaceVector<Number> &V);
+ const VectorSpaceVector<Number> &V) override;
/**
* 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.
*/
- virtual void scale(const VectorSpaceVector<Number> &scaling_factors);
+ virtual void scale(const VectorSpaceVector<Number> &scaling_factors) override;
/**
* Assignment <tt>*this = a*V</tt>.
*/
- virtual void equ(const Number a, const VectorSpaceVector<Number> &V);
+ virtual void equ(const Number a, const VectorSpaceVector<Number> &V) override;
/**
* Return wether the vector contains only elements with value zero.
/**
* Return the mean value of all the entries of this vector.
*/
- virtual value_type mean_value() const;
+ virtual value_type mean_value() const override;
/**
* Return the l<sub>1</sub> norm of the vector (i.e., the sum of the
* absolute values of all entries).
*/
- virtual typename VectorSpaceVector<Number>::real_type l1_norm() const;
+ virtual typename VectorSpaceVector<Number>::real_type l1_norm() const override;
/**
* Return the l<sub>2</sub> norm of the vector (i.e., the square root of
* the sum of the square of all entries among all processors).
*/
- virtual typename VectorSpaceVector<Number>::real_type l2_norm() const;
+ virtual typename VectorSpaceVector<Number>::real_type l2_norm() const override;
/**
* Return the maximum norm of the vector (i.e., the maximum absolute value
* among all entries and among all processors).
*/
- virtual typename VectorSpaceVector<Number>::real_type linfty_norm() const;
+ virtual typename VectorSpaceVector<Number>::real_type linfty_norm() const override;
/**
* Perform a combined operation of a vector addition and a subsequent
*/
virtual Number add_and_dot(const Number a,
const VectorSpaceVector<Number> &V,
- const VectorSpaceVector<Number> &W);
+ const VectorSpaceVector<Number> &W) override;
/**
* Return the global size of the vector, equal to the sum of the number of
* locally owned indices among all processors.
*/
- virtual size_type size() const;
+ virtual size_type size() const override;
/**
* Return an index set that describes which elements of this vector are
* vec.locally_owned_elements() == complete_index_set(vec.size())
* @endcode
*/
- virtual dealii::IndexSet locally_owned_elements() const;
+ virtual dealii::IndexSet locally_owned_elements() const override;
/**
* Prints the vector to the output stream @p out.
virtual void print(std::ostream &out,
const unsigned int precision=3,
const bool scientific=true,
- const bool across=true) const;
+ const bool across=true) const override;
+
/**
* 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
/**
* Return the memory consumption of this class in bytes.
*/
- virtual std::size_t memory_consumption() const;
+ virtual std::size_t memory_consumption() const override;
/**
* Attempt to perform an operation between two incompatible vector types.
* copied.
*/
virtual void reinit(const VectorSpaceVector<double> &V,
- const bool omit_zeroing_entries = false);
+ const bool omit_zeroing_entries = false) override;
/**
* Copy function. This function takes a Vector and copies all the
* Sets all elements of the vector to the scalar @p s. This operation is
* only allowed if @p s is equal to zero.
*/
- Vector &operator= (const double s);
+ virtual Vector &operator= (const double s) override;
/**
* Imports all the elements present in the vector's IndexSet from the input
virtual void import(const ReadWriteVector<double> &V,
VectorOperation::values operation,
std::shared_ptr<const CommunicationPatternBase> communication_pattern =
- std::shared_ptr<const CommunicationPatternBase> ());
+ std::shared_ptr<const CommunicationPatternBase> ()) override;
/**
* Multiply the entire vector by a fixed factor.
*/
- virtual Vector &operator*= (const double factor);
+ virtual Vector &operator*= (const double factor) override;
/**
* Divide the entire vector by a fixed factor.
*/
- virtual Vector &operator/= (const double factor);
+ virtual Vector &operator/= (const double factor) override;
/**
* Add the vector @p V to the present one.
*/
- virtual Vector &operator+= (const VectorSpaceVector<double> &V);
+ virtual Vector &operator+= (const VectorSpaceVector<double> &V) override;
/**
* Substract the vector @p V from the present one.
*/
- virtual Vector &operator-= (const VectorSpaceVector<double> &V);
+ virtual Vector &operator-= (const VectorSpaceVector<double> &V) override;
/**
* Return the scalar product of two vectors. The vectors need to have the
* same layout.
*/
- virtual double operator* (const VectorSpaceVector<double> &V) const;
+ virtual double operator* (const VectorSpaceVector<double> &V) const override;
/**
* Add @p a to all components. Note that @p is a scalar not a vector.
*/
- virtual void add(const double a);
+ virtual void add(const double a) override;
/**
* Simple addition of a multiple of a vector, i.e. <tt>*this +=
* a*V</tt>. The vectors need to have the same layout.
*/
- virtual void add(const double a, const VectorSpaceVector<double> &V);
+ virtual void add(const double a, const VectorSpaceVector<double> &V) override;
/**
* Multiple addition of multiple of a vector, i.e. <tt>*this> +=
* a*V+b*W</tt>. The vectors need to have the same layout.
*/
virtual void add(const double a, const VectorSpaceVector<double> &V,
- const double b, const VectorSpaceVector<double> &W);
+ const double b, const VectorSpaceVector<double> &W) override;
/**
* Scaling and simple addition of a multiple of a vector, i.e. <tt>*this
* = s*(*this)+a*V</tt>.
*/
virtual void sadd(const double s, const double a,
- const VectorSpaceVector<double> &V);
+ const VectorSpaceVector<double> &V) override;
/**
* Scale each element of this vector by the corresponding element in the
* (and immediate re-assignement) by a diagonal scaling matrix. The
* vectors need to have the same layout.
*/
- virtual void scale(const VectorSpaceVector<double> &scaling_factors);
+ virtual void scale(const VectorSpaceVector<double> &scaling_factors) override;
/**
* Assignement <tt>*this = a*V</tt>.
*/
- virtual void equ(const double a, const VectorSpaceVector<double> &V);
+ virtual void equ(const double a, const VectorSpaceVector<double> &V) override;
/**
* Return wether the vector contains only elements with value zero.
/**
* Return the mean value of the element of this vector.
*/
- virtual double mean_value() const;
+ virtual double mean_value() const override;
/**
* Return the l<sub>1</sub> norm of the vector (i.e., the sum of the
* absolute values of all entries among all processors).
*/
- virtual double l1_norm() const;
+ virtual double l1_norm() const override;
/**
* Return the l<sub>2</sub> norm of the vector (i.e., the square root of
* the sum of the square of all entries among all processors).
*/
- virtual double l2_norm() const;
+ virtual double l2_norm() const override;
/**
* Return the maximum norm of the vector (i.e., the maximum absolute value
* among all entries and among all processors).
*/
- virtual double linfty_norm() const;
+ virtual double linfty_norm() const override;
/**
* Performs a combined operation of a vector addition and a subsequent
*/
virtual double add_and_dot(const double a,
const VectorSpaceVector<double> &V,
- const VectorSpaceVector<double> &W);
+ const VectorSpaceVector<double> &W) override;
/**
* This function always returns false and is present only for backward
* compatibility.
* Return the global size of the vector, equal to the sum of the number of
* locally owned indices among all processors.
*/
- virtual size_type size() const;
+ virtual size_type size() const override;
/**
* Return the MPI communicator object in use with this object.
* vec.locally_owned_elements() == complete_index_set(vec.size())
* @endcode
*/
- virtual ::dealii::IndexSet locally_owned_elements() const;
+ virtual ::dealii::IndexSet locally_owned_elements() const override;
/**
* Return a const reference to the underlying Trilinos
virtual void print(std::ostream &out,
const unsigned int precision=3,
const bool scientific=true,
- const bool across=true) const;
+ const bool across=true) const override;
/**
* Return the memory consumption of this class in bytes.
*/
- virtual std::size_t memory_consumption() const;
+ virtual std::size_t memory_consumption() const override;
/**
* The vectors have different partitioning, i.e. they have use different
projects / dealii.git / commitdiff