la_vector.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2015 - 2018 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_la_vector_h
#define dealii_la_vector_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/index_set.h>
#include <deal.II/base/logstream.h>
 
#include <deal.II/lac/read_write_vector.h>
#include <deal.II/lac/vector_operation.h>
#include <deal.II/lac/vector_space_vector.h>
#include <deal.II/lac/vector_type_traits.h>
 
// boost::serialization::make_array used to be in array.hpp, but was
// moved to a different file in BOOST 1.64
#include <boost/version.hpp>
#if BOOST_VERSION >= 106400
#  include <boost/serialization/array_wrapper.hpp>
#else
#  include <boost/serialization/array.hpp>
#endif
#include <boost/serialization/split_member.hpp>
 
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
 
 
DEAL_II_NAMESPACE_OPEN
 
namespace LinearAlgebra
{
  template <typename Number>
  class Vector : public ReadWriteVector<Number>,
                 public VectorSpaceVector<Number>
  {
  public:
    using size_type  = types::global_dof_index;
    using value_type = typename ReadWriteVector<Number>::value_type;
 
    Vector() = default;
 
    Vector(const Vector<Number> &V);
 
    explicit Vector(const size_type n);
 
    template <typename InputIterator>
    Vector(const InputIterator first, const InputIterator last);
 
    virtual void
    reinit(const size_type size,
           const bool      omit_zeroing_entries = false) override;
 
    template <typename Number2>
    void
    reinit(const ReadWriteVector<Number2> &in_vector,
           const bool                      omit_zeroing_entries = false);
 
    virtual void
    reinit(const IndexSet &locally_stored_indices,
           const bool      omit_zeroing_entries = false) override;
 
 
    virtual void
    reinit(const VectorSpaceVector<Number> &V,
           const bool omit_zeroing_entries = false) override;
 
    Vector<Number> &
    operator=(const Vector<Number> &in_vector);
 
    template <typename Number2>
    Vector<Number> &
    operator=(const Vector<Number2> &in_vector);
 
    virtual Vector<Number> &
    operator=(const Number s) override;
 
    virtual Vector<Number> &
    operator*=(const Number factor) override;
 
    virtual Vector<Number> &
    operator/=(const Number factor) override;
 
    virtual Vector<Number> &
    operator+=(const VectorSpaceVector<Number> &V) override;
 
    virtual Vector<Number> &
    operator-=(const VectorSpaceVector<Number> &V) override;
 
    virtual Number operator*(const VectorSpaceVector<Number> &V) const override;
 
    virtual void
    import(
      const ReadWriteVector<Number> &                 V,
      VectorOperation::values                         operation,
      std::shared_ptr<const CommunicationPatternBase> communication_pattern =
        std::shared_ptr<const CommunicationPatternBase>()) override;
 
    virtual void
    add(const Number a) override;
 
    virtual void
    add(const Number a, const VectorSpaceVector<Number> &V) override;
 
    virtual void
    add(const Number                     a,
        const VectorSpaceVector<Number> &V,
        const Number                     b,
        const VectorSpaceVector<Number> &W) override;
 
    virtual void
    sadd(const Number                     s,
         const Number                     a,
         const VectorSpaceVector<Number> &V) override;
 
    virtual void
    scale(const VectorSpaceVector<Number> &scaling_factors) override;
 
    virtual void
    equ(const Number a, const VectorSpaceVector<Number> &V) override;
 
    virtual bool
    all_zero() const override;
 
    virtual value_type
    mean_value() const override;
 
    virtual typename VectorSpaceVector<Number>::real_type
    l1_norm() const override;
 
    virtual typename VectorSpaceVector<Number>::real_type
    l2_norm() const override;
 
    virtual typename VectorSpaceVector<Number>::real_type
    linfty_norm() const override;
 
    virtual Number
    add_and_dot(const Number                     a,
                const VectorSpaceVector<Number> &V,
                const VectorSpaceVector<Number> &W) override;
 
    virtual size_type
    size() const override;
 
    virtual ::IndexSet
    locally_owned_elements() const override;
 
    virtual void
    print(std::ostream &     out,
          const unsigned int precision  = 3,
          const bool         scientific = true,
          const bool         across     = true) const override;
 
    void
    block_write(std::ostream &out) const;
 
    void
    block_read(std::istream &in);
 
    virtual std::size_t
    memory_consumption() const override;
 
    DeclException0(ExcVectorTypeNotCompatible);
 
  private:
    template <typename Archive>
    void
    serialize(Archive &ar, const unsigned int version);
 
    friend class boost::serialization::access;
 
    template <typename Number2>
    friend class Vector;
  };
 
  /*--------------------------- Inline functions ----------------------------*/
 
  template <typename Number>
  inline Vector<Number>::Vector(const Vector<Number> &V)
    : ReadWriteVector<Number>(V)
  {}
 
 
 
  template <typename Number>
  inline Vector<Number>::Vector(const size_type n)
    : ReadWriteVector<Number>(n)
  {}
 
 
 
  template <typename Number>
  template <typename InputIterator>
  inline Vector<Number>::Vector(const InputIterator first,
                                const InputIterator last)
  {
    this->reinit(complete_index_set(std::distance(first, last)), true);
    std::copy(first, last, this->begin());
  }
 
 
 
  template <typename Number>
  inline typename Vector<Number>::size_type
  Vector<Number>::size() const
  {
    return ReadWriteVector<Number>::size();
  }
 
 
 
  template <typename Number>
  inline ::IndexSet
  Vector<Number>::locally_owned_elements() const
  {
    return IndexSet(ReadWriteVector<Number>::get_stored_elements());
  }
 
 
 
  template <typename Number>
  inline void
  Vector<Number>::print(std::ostream &     out,
                        const unsigned int precision,
                        const bool         scientific,
                        const bool) const
  {
    ReadWriteVector<Number>::print(out, precision, scientific);
  }
 
 
 
  template <typename Number>
  template <typename Archive>
  inline void
  Vector<Number>::serialize(Archive &ar, const unsigned int)
  {
    size_type current_size = this->size();
    ar &static_cast<Subscriptor &>(*this);
    ar & this->stored_elements;
    // If necessary, resize the vector during a read operation
    if (this->size() != current_size)
      this->reinit(this->size());
    ar &boost::serialization::make_array(this->values.get(), this->size());
  }
 
 
 
  template <typename Number>
  inline std::size_t
  Vector<Number>::memory_consumption() const
  {
    return ReadWriteVector<Number>::memory_consumption();
  }
} // end of namespace LinearAlgebra
 
 
template <typename Number>
struct is_serial_vector<LinearAlgebra::Vector<Number>> : std::true_type
{};
 
 
DEAL_II_NAMESPACE_CLOSE
 
#ifdef DEAL_II_MSVC
#  include <deal.II/lac/la_vector.templates.h>
#endif
 
#endif