Skip to content
Snippets Groups Projects
Select Git revision
  • d9a1a3c01b8bb29055ed4bf3d111972883a03367
  • develop default protected
  • feature/variational-hydro
  • origin/stage/bouguettaia
  • feature/gmsh-reader
  • feature/reconstruction
  • save_clemence
  • feature/kinetic-schemes
  • feature/local-dt-fsi
  • feature/composite-scheme-sources
  • feature/composite-scheme-other-fluxes
  • feature/serraille
  • feature/composite-scheme
  • hyperplastic
  • feature/polynomials
  • feature/gks
  • feature/implicit-solver-o2
  • feature/coupling_module
  • feature/implicit-solver
  • feature/merge-local-dt-fsi
  • master protected
  • v0.5.0 protected
  • v0.4.1 protected
  • v0.4.0 protected
  • v0.3.0 protected
  • v0.2.0 protected
  • v0.1.0 protected
  • Kidder
  • v0.0.4 protected
  • v0.0.3 protected
  • v0.0.2 protected
  • v0 protected
  • v0.0.1 protected
33 results

ConnectivityDispatcher.cpp

Blame
  • Vector.hpp 3.13 KiB
    #ifndef VECTOR_HPP
    #define VECTOR_HPP
    
    #include <PugsMacros.hpp>
    #include <PugsUtils.hpp>
    
    #include <PugsAssert.hpp>
    
    #include <Array.hpp>
    
    template <typename DataType>
    class Vector
    {
     public:
      using data_type  = DataType;
      using index_type = size_t;
    
     private:
      Array<DataType> m_values;
      static_assert(std::is_same_v<typename decltype(m_values)::index_type, index_type>);
    
     public:
      friend PUGS_INLINE Vector
      copy(const Vector& x)
      {
        auto values = copy(x.m_values);
    
        Vector x_copy{0};
        x_copy.m_values = values;
        return x_copy;
      }
    
      friend std::ostream&
      operator<<(std::ostream& os, const Vector<DataType>& x)
      {
        for (index_type i = 0; i < x.size(); ++i) {
          os << i << " : " << x[i] << '\n';
        }
        return os;
      }
    
      friend Vector operator*(const DataType& a, const Vector& x)
      {
        Vector y = copy(x);
        return y *= a;
      }
    
      PUGS_INLINE
      DataType
      operator,(const Vector& y)
      {
        DataType sum = 0;
    
        // Does not use parallel_for to preserve sum order
        for (index_type i = 0; i < this->size(); ++i) {
          sum += m_values[i] * y.m_values[i];
        }
    
        return sum;
      }
    
      PUGS_INLINE
      Vector&
      operator/=(const DataType& a)
      {
        const DataType inv_a = 1. / a;
        return (*this) *= inv_a;
      }
    
      PUGS_INLINE
      Vector&
      operator*=(const DataType& a)
      {
        parallel_for(
          this->size(), PUGS_LAMBDA(const index_type& i) { m_values[i] *= a; });
    
        return *this;
      }
    
      PUGS_INLINE
      Vector&
      operator-=(const Vector& y)
      {
        Assert(this->size() == y.size());
    
        parallel_for(
          this->size(), PUGS_LAMBDA(const index_type& i) { m_values[i] -= y.m_values[i]; });
    
        return *this;
      }
    
      PUGS_INLINE
      Vector&
      operator+=(const Vector& y)
      {
        Assert(this->size() == y.size());
    
        parallel_for(
          this->size(), PUGS_LAMBDA(const index_type& i) { m_values[i] += y.m_values[i]; });
    
        return *this;
      }
    
      PUGS_INLINE
      Vector
      operator+(const Vector& y) const
      {
        Assert(this->size() == y.size());
        Vector sum{y.size()};
    
        parallel_for(
          this->size(), PUGS_LAMBDA(const index_type& i) { sum.m_values[i] = m_values[i] + y.m_values[i]; });
    
        return sum;
      }
    
      PUGS_INLINE
      Vector
      operator-(const Vector& y) const
      {
        Assert(this->size() == y.size());
        Vector sum{y.size()};
    
        parallel_for(
          this->size(), PUGS_LAMBDA(const index_type& i) { sum.m_values[i] = m_values[i] - y.m_values[i]; });
    
        return sum;
      }
    
      PUGS_INLINE
      DataType& operator[](const index_type& i) const noexcept(NO_ASSERT)
      {
        return m_values[i];
      }
    
      PUGS_INLINE
      size_t
      size() const noexcept
      {
        return m_values.size();
      }
    
      PUGS_INLINE Vector&
      operator=(const DataType& value) noexcept
      {
        m_values.fill(value);
        return *this;
      }
    
      template <typename DataType2>
      PUGS_INLINE Vector&
      operator=(const Vector<DataType2>& vector) noexcept
      {
        m_values = vector.m_values;
        return *this;
      }
    
      PUGS_INLINE
      Vector& operator=(const Vector&) = default;
    
      PUGS_INLINE
      Vector& operator=(Vector&&) = default;
    
      Vector(const Vector&) = default;
    
      Vector(Vector&&) = default;
    
      Vector(const size_t& size) : m_values(size) {}
      ~Vector() = default;
    };
    
    #endif   // VECTOR_HPP