tensor.hpp

Go to the documentation of this file.

// vim: set tabstop=2:softtabstop=2:shiftwidth=2:expandtab

#ifndef LIN_CORE_TYPES_TENSOR_HPP_
#define LIN_CORE_TYPES_TENSOR_HPP_

#include "../config.hpp"
#include "../traits.hpp"
#include "base.hpp"

#include <initializer_list>

namespace lin {
namespace internal {

template <class D>
class Tensor : public Base<D> {
  static_assert(has_valid_traits<D>::value,
      "Derived types to Tensor<...> must have valid traits");

 public:
  typedef traits<D> Traits;

 private:
  typename Traits::elem_t elems[Traits::max_size] = { typename Traits::elem_t(0) };

 protected:
  using Base<D>::derived;

 public:
  using Base<D>::rows;
  using Base<D>::cols;
  using Base<D>::resize;
  using Base<D>::size;
  using Base<D>::operator=;
  using Base<D>::operator();
  using Base<D>::data;
  using Base<D>::eval;

  constexpr Tensor(Tensor<D> const &) = default;
  constexpr Tensor(Tensor<D> &&) = default;
  constexpr Tensor<D> &operator=(Tensor<D> const &) = default;
  constexpr Tensor<D> &operator=(Tensor<D> &&) = default;

  constexpr Tensor() {
    resize(Traits::max_rows, Traits::max_cols);
  }

  constexpr Tensor(size_t r, size_t c) {
    resize(r, c);
  }

  template <typename T>
  constexpr Tensor(std::initializer_list<T> const &list) {
    derived() = list;
  }

  template <typename T>
  constexpr Tensor(size_t r, size_t c, std::initializer_list<T> const &list) {
    resize(r, c);
    derived() = list;
  }

  template <class C>
  constexpr Tensor(Stream<C> const &s) {
    resize(s.rows(), s.cols());
    derived() = s;
  }

  constexpr typename Traits::elem_t *data() {
    return elems;
  }
};
}  // namespace internal
}  // namespace lin

#endif