densevector.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_DENSEVECTOR_HH
#define DUNE_DENSEVECTOR_HH
 
#include <algorithm>
#include <limits>
#include <type_traits>
 
#include "genericiterator.hh"
#include "ftraits.hh"
#include "matvectraits.hh"
#include "promotiontraits.hh"
#include "dotproduct.hh"
#include "boundschecking.hh"
 
namespace Dune {
 
  // forward declaration of template
  template<typename V> class DenseVector;
 
  template<typename V>
  struct FieldTraits< DenseVector<V> >
  {
    typedef typename FieldTraits< typename DenseMatVecTraits<V>::value_type >::field_type field_type;
    typedef typename FieldTraits< typename DenseMatVecTraits<V>::value_type >::real_type real_type;
  };
 
  namespace fvmeta
  {
    template<class K>
    inline typename FieldTraits<K>::real_type absreal (const K& k)
    {
      using std::abs;
      return abs(k);
    }
 
    template<class K>
    inline typename FieldTraits<K>::real_type absreal (const std::complex<K>& c)
    {
      using std::abs;
      return abs(c.real()) + abs(c.imag());
    }
 
    template<class K>
    inline typename FieldTraits<K>::real_type abs2 (const K& k)
    {
      return k*k;
    }
 
    template<class K>
    inline typename FieldTraits<K>::real_type abs2 (const std::complex<K>& c)
    {
      return c.real()*c.real() + c.imag()*c.imag();
    }
 
    template<class K, bool isInteger = std::numeric_limits<K>::is_integer>
    struct Sqrt
    {
      static inline typename FieldTraits<K>::real_type sqrt (const K& k)
      {
        using std::sqrt;
        return sqrt(k);
      }
    };
 
    template<class K>
    struct Sqrt<K, true>
    {
      static inline typename FieldTraits<K>::real_type sqrt (const K& k)
      {
        using std::sqrt;
        return typename FieldTraits<K>::real_type(sqrt(double(k)));
      }
    };
 
    template<class K>
    inline typename FieldTraits<K>::real_type sqrt (const K& k)
    {
      return Sqrt<K>::sqrt(k);
    }
 
  }
 
  template<class C, class T, class R =T&>
  class DenseIterator :
    public Dune::RandomAccessIteratorFacade<DenseIterator<C,T,R>,T, R, std::ptrdiff_t>
  {
    friend class DenseIterator<typename std::remove_const<C>::type, typename std::remove_const<T>::type, typename mutable_reference<R>::type >;
    friend class DenseIterator<const typename std::remove_const<C>::type, const typename std::remove_const<T>::type, typename const_reference<R>::type >;
 
    typedef DenseIterator<typename std::remove_const<C>::type, typename std::remove_const<T>::type, typename mutable_reference<R>::type > MutableIterator;
    typedef DenseIterator<const typename std::remove_const<C>::type, const typename std::remove_const<T>::type, typename const_reference<R>::type > ConstIterator;
  public:
 
    typedef std::ptrdiff_t DifferenceType;
 
    typedef typename C::size_type SizeType;
 
    // Constructors needed by the base iterators.
    DenseIterator()
      : container_(0), position_()
    {}
 
    DenseIterator(C& cont, SizeType pos)
      : container_(&cont), position_(pos)
    {}
 
    DenseIterator(const MutableIterator & other)
      : container_(other.container_), position_(other.position_)
    {}
 
    DenseIterator(const ConstIterator & other)
      : container_(other.container_), position_(other.position_)
    {}
 
    // Methods needed by the forward iterator
    bool equals(const MutableIterator &other) const
    {
      return position_ == other.position_ && container_ == other.container_;
    }
 
 
    bool equals(const ConstIterator & other) const
    {
      return position_ == other.position_ && container_ == other.container_;
    }
 
    R dereference() const {
      return container_->operator[](position_);
    }
 
    void increment(){
      ++position_;
    }
 
    // Additional function needed by BidirectionalIterator
    void decrement(){
      --position_;
    }
 
    // Additional function needed by RandomAccessIterator
    R elementAt(DifferenceType i) const {
      return container_->operator[](position_+i);
    }
 
    void advance(DifferenceType n){
      position_=position_+n;
    }
 
    DifferenceType distanceTo(DenseIterator<const typename std::remove_const<C>::type,const typename std::remove_const<T>::type> other) const
    {
      assert(other.container_==container_);
      return static_cast< DifferenceType >( other.position_ ) - static_cast< DifferenceType >( position_ );
    }
 
    DifferenceType distanceTo(DenseIterator<typename std::remove_const<C>::type, typename std::remove_const<T>::type> other) const
    {
      assert(other.container_==container_);
      return static_cast< DifferenceType >( other.position_ ) - static_cast< DifferenceType >( position_ );
    }
 
    SizeType index () const
    {
      return this->position_;
    }
 
  private:
    C *container_;
    SizeType position_;
  };
 
  template<typename V>
  class DenseVector
  {
    typedef DenseMatVecTraits<V> Traits;
    // typedef typename Traits::value_type K;
 
    // Curiously recurring template pattern
    V & asImp() { return static_cast<V&>(*this); }
    const V & asImp() const { return static_cast<const V&>(*this); }
 
  protected:
    // construction allowed to derived classes only
    constexpr DenseVector() = default;
    // copying only allowed by derived classes
    DenseVector(const DenseVector&) = default;
 
  public:
    //===== type definitions and constants
 
    typedef typename Traits::derived_type derived_type;
 
    typedef typename Traits::value_type value_type;
 
    typedef typename FieldTraits< value_type >::field_type field_type;
 
    typedef typename Traits::value_type block_type;
 
    typedef typename Traits::size_type size_type;
 
    enum {
      blocklevel = 1
    };
 
    //===== assignment from scalar
    inline derived_type& operator= (const value_type& k)
    {
      for (size_type i=0; i<size(); i++)
        asImp()[i] = k;
      return asImp();
    }
 
     //===== assignment from other DenseVectors
  protected:
    DenseVector& operator=(const DenseVector&) = default;
 
  public:
 
    template <typename W,
              std::enable_if_t<
                std::is_assignable<value_type&, typename DenseVector<W>::value_type>::value, int> = 0>
    derived_type& operator= (const DenseVector<W>& other)
    {
      assert(other.size() == size());
      for (size_type i=0; i<size(); i++)
        asImp()[i] = other[i];
      return asImp();
    }
 
    //===== access to components
 
    value_type & operator[] (size_type i)
    {
      return asImp()[i];
    }
 
    const value_type & operator[] (size_type i) const
    {
      return asImp()[i];
    }
 
    value_type& front()
    {
      return asImp()[0];
    }
 
    const value_type& front() const
    {
      return asImp()[0];
    }
 
    value_type& back()
    {
      return asImp()[size()-1];
    }
 
    const value_type& back() const
    {
      return asImp()[size()-1];
    }
 
    bool empty() const
    {
      return size() == 0;
    }
 
    size_type size() const
    {
      return asImp().size();
    }
 
    typedef DenseIterator<DenseVector,value_type> Iterator;
    typedef Iterator iterator;
 
    Iterator begin ()
    {
      return Iterator(*this,0);
    }
 
    Iterator end ()
    {
      return Iterator(*this,size());
    }
 
    Iterator beforeEnd ()
    {
      return Iterator(*this,size()-1);
    }
 
    Iterator beforeBegin ()
    {
      return Iterator(*this,-1);
    }
 
    Iterator find (size_type i)
    {
      return Iterator(*this,std::min(i,size()));
    }
 
    typedef DenseIterator<const DenseVector,const value_type> ConstIterator;
    typedef ConstIterator const_iterator;
 
    ConstIterator begin () const
    {
      return ConstIterator(*this,0);
    }
 
    ConstIterator end () const
    {
      return ConstIterator(*this,size());
    }
 
    ConstIterator beforeEnd () const
    {
      return ConstIterator(*this,size()-1);
    }
 
    ConstIterator beforeBegin () const
    {
      return ConstIterator(*this,-1);
    }
 
    ConstIterator find (size_type i) const
    {
      return ConstIterator(*this,std::min(i,size()));
    }
 
    //===== vector space arithmetic
 
    template <class Other>
    derived_type& operator+= (const DenseVector<Other>& x)
    {
      DUNE_ASSERT_BOUNDS(x.size() == size());
      for (size_type i=0; i<size(); i++)
        (*this)[i] += x[i];
      return asImp();
    }
 
    template <class Other>
    derived_type& operator-= (const DenseVector<Other>& x)
    {
      DUNE_ASSERT_BOUNDS(x.size() == size());
      for (size_type i=0; i<size(); i++)
        (*this)[i] -= x[i];
      return asImp();
    }
 
    template <class Other>
    derived_type operator+ (const DenseVector<Other>& b) const
    {
      derived_type z = asImp();
      return (z+=b);
    }
 
    template <class Other>
    derived_type operator- (const DenseVector<Other>& b) const
    {
      derived_type z = asImp();
      return (z-=b);
    }
 
    derived_type operator- () const
    {
      V result;
      using idx_type = typename decltype(result)::size_type;
 
      for (idx_type i = 0; i < size(); ++i)
        result[i] = -asImp()[i];
 
      return result;
    }
 
 
    template <typename ValueType>
    typename std::enable_if<
      std::is_convertible<ValueType, value_type>::value,
      derived_type
    >::type&
    operator+= (const ValueType& kk)
    {
      const value_type& k = kk;
      for (size_type i=0; i<size(); i++)
        (*this)[i] += k;
      return asImp();
    }
 
 
    template <typename ValueType>
    typename std::enable_if<
      std::is_convertible<ValueType, value_type>::value,
      derived_type
    >::type&
    operator-= (const ValueType& kk)
    {
      const value_type& k = kk;
      for (size_type i=0; i<size(); i++)
        (*this)[i] -= k;
      return asImp();
    }
 
 
    template <typename FieldType>
    typename std::enable_if<
      std::is_convertible<FieldType, field_type>::value,
      derived_type
    >::type&
    operator*= (const FieldType& kk)
    {
      const field_type& k = kk;
      for (size_type i=0; i<size(); i++)
        (*this)[i] *= k;
      return asImp();
    }
 
 
    template <typename FieldType>
    typename std::enable_if<
      std::is_convertible<FieldType, field_type>::value,
      derived_type
    >::type&
    operator/= (const FieldType& kk)
    {
      const field_type& k = kk;
      for (size_type i=0; i<size(); i++)
        (*this)[i] /= k;
      return asImp();
    }
 
    template <class Other>
    bool operator== (const DenseVector<Other>& x) const
    {
      DUNE_ASSERT_BOUNDS(x.size() == size());
      for (size_type i=0; i<size(); i++)
        if ((*this)[i]!=x[i])
          return false;
 
      return true;
    }
 
    template <class Other>
    bool operator!= (const DenseVector<Other>& x) const
    {
      return !operator==(x);
    }
 
 
    template <class Other>
    derived_type& axpy (const field_type& a, const DenseVector<Other>& x)
    {
      DUNE_ASSERT_BOUNDS(x.size() == size());
      for (size_type i=0; i<size(); i++)
        (*this)[i] += a*x[i];
      return asImp();
    }
 
    template<class Other>
    typename PromotionTraits<field_type,typename DenseVector<Other>::field_type>::PromotedType operator* (const DenseVector<Other>& x) const {
      typedef typename PromotionTraits<field_type, typename DenseVector<Other>::field_type>::PromotedType PromotedType;
      PromotedType result(0);
      assert(x.size() == size());
      for (size_type i=0; i<size(); i++) {
        result += PromotedType((*this)[i]*x[i]);
      }
      return result;
    }
 
    template<class Other>
    typename PromotionTraits<field_type,typename DenseVector<Other>::field_type>::PromotedType dot(const DenseVector<Other>& x) const {
      typedef typename PromotionTraits<field_type, typename DenseVector<Other>::field_type>::PromotedType PromotedType;
      PromotedType result(0);
      assert(x.size() == size());
      for (size_type i=0; i<size(); i++) {
        result += Dune::dot((*this)[i],x[i]);
      }
      return result;
    }
 
    //===== norms
 
    typename FieldTraits<value_type>::real_type one_norm() const {
      using std::abs;
      typename FieldTraits<value_type>::real_type result( 0 );
      for (size_type i=0; i<size(); i++)
        result += abs((*this)[i]);
      return result;
    }
 
 
    typename FieldTraits<value_type>::real_type one_norm_real () const
    {
      typename FieldTraits<value_type>::real_type result( 0 );
      for (size_type i=0; i<size(); i++)
        result += fvmeta::absreal((*this)[i]);
      return result;
    }
 
    typename FieldTraits<value_type>::real_type two_norm () const
    {
      typename FieldTraits<value_type>::real_type result( 0 );
      for (size_type i=0; i<size(); i++)
        result += fvmeta::abs2((*this)[i]);
      return fvmeta::sqrt(result);
    }
 
    typename FieldTraits<value_type>::real_type two_norm2 () const
    {
      typename FieldTraits<value_type>::real_type result( 0 );
      for (size_type i=0; i<size(); i++)
        result += fvmeta::abs2((*this)[i]);
      return result;
    }
 
    template <typename vt = value_type,
              typename std::enable_if<!HasNaN<vt>::value, int>::type = 0>
    typename FieldTraits<vt>::real_type infinity_norm() const {
      using real_type = typename FieldTraits<vt>::real_type;
      using std::abs;
      using std::max;
 
      real_type norm = 0;
      for (auto const &x : *this) {
        real_type const a = abs(x);
        norm = max(a, norm);
      }
      return norm;
    }
 
    template <typename vt = value_type,
              typename std::enable_if<!HasNaN<vt>::value, int>::type = 0>
    typename FieldTraits<vt>::real_type infinity_norm_real() const {
      using real_type = typename FieldTraits<vt>::real_type;
      using std::max;
 
      real_type norm = 0;
      for (auto const &x : *this) {
        real_type const a = fvmeta::absreal(x);
        norm = max(a, norm);
      }
      return norm;
    }
 
    template <typename vt = value_type,
              typename std::enable_if<HasNaN<vt>::value, int>::type = 0>
    typename FieldTraits<vt>::real_type infinity_norm() const {
      using real_type = typename FieldTraits<vt>::real_type;
      using std::abs;
      using std::max;
 
      real_type norm = 0;
      real_type isNaN = 1;
      for (auto const &x : *this) {
        real_type const a = abs(x);
        norm = max(a, norm);
        isNaN += a;
      }
      return norm * (isNaN / isNaN);
    }
 
    template <typename vt = value_type,
              typename std::enable_if<HasNaN<vt>::value, int>::type = 0>
    typename FieldTraits<vt>::real_type infinity_norm_real() const {
      using real_type = typename FieldTraits<vt>::real_type;
      using std::max;
 
      real_type norm = 0;
      real_type isNaN = 1;
      for (auto const &x : *this) {
        real_type const a = fvmeta::absreal(x);
        norm = max(a, norm);
        isNaN += a;
      }
      return norm * (isNaN / isNaN);
    }
 
    //===== sizes
 
    size_type N () const
    {
      return size();
    }
 
    size_type dim () const
    {
      return size();
    }
 
  };
 
  template<typename V>
  std::ostream& operator<< (std::ostream& s, const DenseVector<V>& v)
  {
    for (typename DenseVector<V>::size_type i=0; i<v.size(); i++)
      s << ((i>0) ? " " : "") << v[i];
    return s;
  }
 
} // end namespace
 
#endif // DUNE_DENSEVECTOR_HH