tensor.hpp

Go to the documentation of this file.

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

#ifndef LIN_CORE_TRAITS_TENSOR_HPP_
#define LIN_CORE_TRAITS_TENSOR_HPP_

#include "utilities.hpp"

#include <type_traits>

namespace lin {
namespace internal {

template <class C>
struct _elem;

template <class C>
using _elem_t = typename _elem<C>::type;

template <class C, typename = void>
struct _eval;

template <class C>
using _eval_t = typename _eval<C>::type;

template <class C>
struct _dims;

template <class C>
struct traits {
  typedef _elem_t<C> elem_t;
  typedef _eval_t<C> eval_t;
  static constexpr size_t rows = _dims<C>::rows;
  static constexpr size_t cols = _dims<C>::cols;
  static constexpr size_t size = rows * cols;
  static constexpr size_t max_rows = _dims<C>::max_rows;
  static constexpr size_t max_cols = _dims<C>::max_cols;
  static constexpr size_t max_size = max_rows * max_cols;
};

template <class C>
using traits_elem_t = typename traits<C>::elem_t;

template <class C>
using traits_eval_t = typename traits<C>::eval_t;

template <class C, typename = void>
struct _has_traits : std::false_type { };

template <class C>
struct _has_traits<C, void_t<typename C::Traits>> : std::true_type { };

template <class C>
struct has_traits : _has_traits<C> { };

template <class C>
struct has_fixed_rows : std::integral_constant<bool, (
    (_dims<C>::rows == _dims<C>::max_rows) && _dims<C>::rows
  )> { };

template <class C>
struct has_fixed_cols : std::integral_constant<bool, (
    (_dims<C>::cols == _dims<C>::max_cols) && _dims<C>::cols
  )> { };

template <class C>
struct has_fixed_dimensions
    : conjunction<has_fixed_rows<C>, has_fixed_cols<C>> { };

template <class C>
struct has_strictly_bounded_rows
    : std::integral_constant<bool, (!_dims<C>::rows && _dims<C>::max_rows)> { };

template <class C>
struct has_strictly_bounded_cols
    : std::integral_constant<bool, (!_dims<C>::cols && _dims<C>::max_cols)> { };

template <class C>
struct has_strictly_bounded_dimensions : conjunction<
    has_strictly_bounded_rows<C>, has_strictly_bounded_cols<C>
  > { };

template <class C>
struct has_bounded_rows
    : disjunction<has_fixed_rows<C>, has_strictly_bounded_rows<C>> { };

template <class C>
struct has_bounded_cols
    : disjunction<has_fixed_cols<C>, has_strictly_bounded_cols<C>> { };

template <class C>
struct has_bounded_dimensions
    : conjunction<has_bounded_rows<C>, has_bounded_cols<C>> { };

template <class C>
struct has_valid_traits : conjunction<
    has_bounded_dimensions<C>,
    std::is_trivial<typename _elem<C>::type>
  > { };

template <class C>
struct is_tall : std::integral_constant<bool, (
    _dims<C>::max_rows >= _dims<C>::max_cols
  )> { };

template <class C>
struct is_short : std::integral_constant<bool, (
    _dims<C>::max_rows <= _dims<C>::max_cols
  )> { };

template <class C>
struct is_square : conjunction<is_tall<C>, is_short<C>> { };

template <class... Cs>
struct have_same_elements;

template <class C, class... Cs>
struct have_same_elements<C, Cs...>
    : conjunction<std::is_same<_elem_t<C>, _elem_t<Cs>>...> { };

template <class C>
struct have_same_elements<C> : std::true_type { };

template <>
struct have_same_elements<> : std::true_type { };

template <class... Cs>
struct have_floating_point_elements
    : conjunction<std::is_floating_point<_elem_t<Cs>>...> { };

template <>
struct have_floating_point_elements<> : std::true_type { };

template <class... Cs>
struct have_integral_elements
    : conjunction<std::is_integral<_elem_t<Cs>>...> { };

template <>
struct have_integral_elements<> : std::true_type { };

template <class... Cs>
struct have_same_rows;

template <class C, class... Cs>
struct have_same_rows<C, Cs...> : conjunction<
    std::integral_constant<bool, (
        (_dims<C>::rows == _dims<Cs>::rows) &&
        (_dims<C>::max_rows == _dims<Cs>::max_rows)
      )>...
  > { };

template <class C>
struct have_same_rows<C> : std::true_type { };

template <>
struct have_same_rows<> : std::true_type { };

template <class... Cs>
struct have_same_cols;

template <class C, class... Cs>
struct have_same_cols<C, Cs...> : conjunction<
    std::integral_constant<bool, (
        (_dims<C>::cols == _dims<Cs>::cols) &&
        (_dims<C>::max_cols == _dims<Cs>::max_cols)
      )>...
  > { };

template <class C>
struct have_same_cols<C> : std::true_type { };

template <>
struct have_same_cols<> : std::true_type { };

template <class... Cs>
struct have_same_dimensions
    : conjunction<have_same_rows<Cs...>, have_same_cols<Cs...>> { };

template <class... Cs>
struct have_same_traits
    : conjunction<have_same_dimensions<Cs...>, have_same_elements<Cs...>> { };

}  // namespace internal
}  // namespace lin

#endif