scalarmatrixview.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_COMMON_SCALARMATRIXVIEW_HH
#define DUNE_COMMON_SCALARMATRIXVIEW_HH
 
#include <cstddef>
#include <type_traits>
#include <ostream>
 
#include <dune/common/boundschecking.hh>
#include <dune/common/typetraits.hh>
#include <dune/common/matvectraits.hh>
#include <dune/common/densematrix.hh>
#include <dune/common/fmatrix.hh>
#include <dune/common/scalarvectorview.hh>
 
 
namespace Dune {
 
namespace Impl {
 
  template<class K>
  class ScalarMatrixView :
    public DenseMatrix<ScalarMatrixView<K>>
  {
    ScalarVectorView<K> data_;
    using Base = DenseMatrix<ScalarMatrixView<K>>;
 
    template <class>
    friend class ScalarMatrixView;
  public:
 
    //===== type definitions and constants
 
    enum {
      blocklevel = 1
    };
 
    using size_type = typename Base::size_type;
    using row_type = typename Base::row_type;
    using row_reference = typename Base::row_reference;
    using const_row_reference = typename Base::const_row_reference;
 
    enum {
      rows = 1,
      cols = 1
    };
 
    //===== constructors
    constexpr ScalarMatrixView ()
      : data_()
    {}
 
    ScalarMatrixView (K* p) :
      data_(p)
    {}
 
    ScalarMatrixView (const ScalarMatrixView &other) :
      Base(),
      data_(other.data_)
    {}
 
    ScalarMatrixView (ScalarMatrixView &&other) :
      Base(),
      data_( other.data_ )
    {}
 
    ScalarMatrixView& operator= (const ScalarMatrixView& other)
    {
      data_ = other.data_;
      return *this;
    }
 
    template<class KK>
    ScalarMatrixView& operator= (const ScalarMatrixView<KK>& other)
    {
      data_ = other.data_;
      return *this;
    }
 
    template<typename T,
      std::enable_if_t<std::is_convertible<T, K>::value, int> = 0>
    inline ScalarMatrixView& operator= (const T& k)
    {
      data_ = k;
      return *this;
    }
 
    // make this thing a matrix
    static constexpr size_type mat_rows() { return 1; }
    static constexpr size_type mat_cols() { return 1; }
 
    row_reference mat_access ( size_type i )
    {
      DUNE_UNUSED_PARAMETER(i);
      DUNE_ASSERT_BOUNDS(i == 0);
      return data_;
    }
 
    const_row_reference mat_access ( size_type i ) const
    {
      DUNE_UNUSED_PARAMETER(i);
      DUNE_ASSERT_BOUNDS(i == 0);
      return data_;
    }
  }; // class ScalarMatrixView
 
  template<typename K>
  std::ostream& operator<< (std::ostream& s, const ScalarMatrixView<K>& a)
  {
    s << a[0][0];
    return s;
  }
 
  template<class T,
    std::enable_if_t<IsNumber<T>::value, int> = 0>
  auto asMatrix(T& t)
  {
    return ScalarMatrixView<T>{&t};
  }
 
  template<class T,
    std::enable_if_t<IsNumber<T>::value, int> = 0>
  auto asMatrix(const T& t)
  {
    return ScalarMatrixView<const T>{&t};
  }
 
  template<class T,
    std::enable_if_t<not IsNumber<T>::value, int> = 0>
  T& asMatrix(T& t)
  {
    return t;
  }
 
  template<class T,
    std::enable_if_t<not IsNumber<T>::value, int> = 0>
  const T& asMatrix(const T& t)
  {
    return t;
  }
 
} // end namespace Impl
 
  template<class K>
  struct FieldTraits<Impl::ScalarMatrixView<K>> : public FieldTraits<std::remove_const_t<K>> {};
 
  template<class K>
  struct DenseMatVecTraits<Impl::ScalarMatrixView<K>>
  {
    using derived_type = Impl::ScalarMatrixView<K>;
    using row_type = Impl::ScalarVectorView<K>;
    using row_reference = row_type&;
    using const_row_reference = const row_type&;
    using value_type = std::remove_const_t<K>;
    using size_type = std::size_t;
  };
 
 
  template<class K>
  struct AutonomousValueType<Impl::ScalarMatrixView<K>>
  {
    using type = FieldMatrix<std::remove_const_t<K>,1,1>;
  };
 
 
} // end namespace Dune
 
#endif // DUNE_COMMON_SCALARMATRIXVIEW_HH