vector_space_vector.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2015 - 2021 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_vector_space_vector_h
#define dealii_vector_space_vector_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/communication_pattern_base.h>
#include <deal.II/base/numbers.h>
 
#include <deal.II/lac/vector_operation.h>
 
#include <memory>
 
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declarations
#ifndef DOXYGEN
class IndexSet;
namespace LinearAlgebra
{
  template <typename Number>
  class ReadWriteVector;
} // namespace LinearAlgebra
#endif
 
namespace LinearAlgebra
{
  template <typename Number>
  class VectorSpaceVector
  {
  public:
    using value_type = Number;
    using size_type  = types::global_dof_index;
    using real_type  = typename numbers::NumberTraits<Number>::real_type;
 
    virtual void
    reinit(const VectorSpaceVector<Number> &V,
           const bool                       omit_zeroing_entries = false) = 0;
 
    virtual VectorSpaceVector<Number> &
    operator=(const Number s) = 0;
 
    virtual VectorSpaceVector<Number> &
    operator*=(const Number factor) = 0;
 
    virtual VectorSpaceVector<Number> &
    operator/=(const Number factor) = 0;
 
    virtual VectorSpaceVector<Number> &
    operator+=(const VectorSpaceVector<Number> &V) = 0;
 
    virtual VectorSpaceVector<Number> &
    operator-=(const VectorSpaceVector<Number> &V) = 0;
 
    virtual void
    import(const ReadWriteVector<Number> &V,
           VectorOperation::values        operation,
           std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
             communication_pattern = {}) = 0;
 
    virtual Number
    operator*(const VectorSpaceVector<Number> &V) const = 0;
 
    virtual void
    add(const Number a) = 0;
 
    virtual void
    add(const Number a, const VectorSpaceVector<Number> &V) = 0;
 
    virtual void
    add(const Number                     a,
        const VectorSpaceVector<Number> &V,
        const Number                     b,
        const VectorSpaceVector<Number> &W) = 0;
 
    virtual void
    sadd(const Number                     s,
         const Number                     a,
         const VectorSpaceVector<Number> &V) = 0;
 
    virtual void
    scale(const VectorSpaceVector<Number> &scaling_factors) = 0;
 
    virtual void
    equ(const Number a, const VectorSpaceVector<Number> &V) = 0;
 
    virtual bool
    all_zero() const = 0;
 
    virtual value_type
    mean_value() const = 0;
 
    virtual real_type
    l1_norm() const = 0;
 
    virtual real_type
    l2_norm() const = 0;
 
    virtual real_type
    linfty_norm() const = 0;
 
    virtual Number
    add_and_dot(const Number                     a,
                const VectorSpaceVector<Number> &V,
                const VectorSpaceVector<Number> &W) = 0;
 
    virtual void compress(VectorOperation::values)
    {}
 
    virtual size_type
    size() const = 0;
 
    virtual ::IndexSet
    locally_owned_elements() const = 0;
 
    virtual void
    print(std::ostream &     out,
          const unsigned int precision  = 3,
          const bool         scientific = true,
          const bool         across     = true) const = 0;
 
    virtual std::size_t
    memory_consumption() const = 0;
 
    virtual ~VectorSpaceVector() = default;
  };
} // namespace LinearAlgebra
 
// ---------------------------- Free functions --------------------------
 
namespace LinearAlgebra
{
  template <typename Number>
  void
  set_zero_mean_value(VectorSpaceVector<Number> &vector)
  {
    vector.add(-vector.mean_value());
  }
} // namespace LinearAlgebra
 
DEAL_II_NAMESPACE_CLOSE
 
#endif