vector.hpp

Go to the documentation of this file.

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

#ifndef LIN_CORE_TYPES_VECTOR_HPP_
#define LIN_CORE_TYPES_VECTOR_HPP_

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

#include <type_traits>

namespace lin {

template <typename T, size_t N, size_t MN = N>
class Vector : public internal::Tensor<Vector<T, N, MN>> {
  static_assert(internal::is_col_vector<Vector<T, N, MN>>::value,
      "Invalid Vector<...> parameters");

 public:
  typedef internal::traits<Vector<T, N, MN>> Traits;

  typedef internal::vector_traits<Vector<T, N, MN>> VectorTraits;

 protected:
  using internal::Tensor<Vector<T, N, MN>>::derived;

 public:
  using internal::Tensor<Vector<T, N, MN>>::Tensor;
  using internal::Tensor<Vector<T, N, MN>>::rows;
  using internal::Tensor<Vector<T, N, MN>>::cols;
  using internal::Tensor<Vector<T, N, MN>>::size;
  using internal::Tensor<Vector<T, N, MN>>::data;
  using internal::Tensor<Vector<T, N, MN>>::eval;
  using internal::Tensor<Vector<T, N, MN>>::resize;
  using internal::Tensor<Vector<T, N, MN>>::operator=;
  using internal::Tensor<Vector<T, N, MN>>::operator();

  constexpr Vector() = default;
  constexpr Vector(Vector<T, N, MN> const &) = default;
  constexpr Vector(Vector<T, N, MN> &&) = default;
  constexpr Vector<T, N, MN> &operator=(Vector<T, N, MN> const &) = default;
  constexpr Vector<T, N, MN> &operator=(Vector<T, N, MN> &&) = default;

  constexpr Vector(size_t n)
  : internal::Tensor<Vector<T, N, MN>>(n, 1) { }

  template <typename U>
  constexpr Vector(size_t n, std::initializer_list<U> const &list)
  : internal::Tensor<Vector<T, N, MN>>(n, 1, list) { }

  constexpr void resize(size_t n) {
    resize(n, 1);
  }
};

template <typename T, size_t N, size_t MN = N>
class RowVector : public internal::Tensor<RowVector<T, N, MN>> {
  static_assert(internal::is_row_vector<RowVector<T, N, MN>>::value,
      "Invalid RowVector<...> parameters");

 public:
  typedef internal::traits<RowVector<T, N, MN>> Traits;

  typedef internal::vector_traits<RowVector<T, N, MN>> VectorTraits;

 protected:
  using internal::Tensor<RowVector<T, N, MN>>::derived;

 public:
  using internal::Tensor<RowVector<T, N, MN>>::Tensor;
  using internal::Tensor<RowVector<T, N, MN>>::rows;
  using internal::Tensor<RowVector<T, N, MN>>::cols;
  using internal::Tensor<RowVector<T, N, MN>>::size;
  using internal::Tensor<RowVector<T, N, MN>>::data;
  using internal::Tensor<RowVector<T, N, MN>>::eval;
  using internal::Tensor<RowVector<T, N, MN>>::resize;
  using internal::Tensor<RowVector<T, N, MN>>::operator=;
  using internal::Tensor<RowVector<T, N, MN>>::operator();

  constexpr RowVector() = default;
  constexpr RowVector(RowVector<T, N, MN> const &) = default;
  constexpr RowVector(RowVector<T, N, MN> &&) = default;
  constexpr RowVector<T, N, MN> &operator=(RowVector<T, N, MN> const &) = default;
  constexpr RowVector<T, N, MN> &operator=(RowVector<T, N, MN> &&) = default;

  constexpr RowVector(size_t n)
  : internal::Tensor<RowVector<T, N, MN>>(1, n) { }

  template <typename U>
  constexpr RowVector(size_t n, std::initializer_list<U> const &list)
  : internal::Tensor<RowVector<T, N, MN>>(1, n, list) { }

  constexpr void resize(size_t n) {
    resize(1, n);
  }
};

template <size_t N, size_t MN = N>
using Vectorf = Vector<float, N, MN>;

typedef Vectorf<2> Vector2f; 
typedef Vectorf<3> Vector3f; 
typedef Vectorf<4> Vector4f; 

template <size_t N, size_t MN = N>
using Vectord = Vector<double, N, MN>;

typedef Vectord<2> Vector2d; 
typedef Vectord<3> Vector3d; 
typedef Vectord<4> Vector4d; 

template <size_t N, size_t MN = N>
using RowVectorf = RowVector<float, N, MN>;

typedef RowVectorf<2> RowVector2f; 
typedef RowVectorf<3> RowVector3f; 
typedef RowVectorf<4> RowVector4f; 

template <size_t N, size_t MN = N>
using RowVectord = RowVector<double, N, MN>;

typedef RowVectord<2> RowVector2d; 
typedef RowVectord<3> RowVector3d; 
typedef RowVectord<4> RowVector4d; 

namespace internal {

template <typename T, size_t N, size_t MN>
struct _elem<Vector<T, N, MN>> {
  typedef T type;
};

template <typename T, size_t N, size_t MN>
struct _dims<Vector<T, N, MN>> {
  static constexpr size_t rows = N;
  static constexpr size_t cols = 1;
  static constexpr size_t max_rows = MN;
  static constexpr size_t max_cols = 1;
};

template <class C>
struct _eval<C, std::enable_if_t<is_col_vector<C>::value>> {
  typedef Vector<
      _elem_t<C>,
      _dims<C>::rows,
      _dims<C>::max_rows
    > type;
};

template <typename T, size_t N, size_t MN>
struct _elem<RowVector<T, N, MN>> {
  typedef T type;
};

template <typename T, size_t N, size_t MN>
struct _dims<RowVector<T, N, MN>> {
  static constexpr size_t rows = 1;
  static constexpr size_t cols = N;
  static constexpr size_t max_rows = 1;
  static constexpr size_t max_cols = MN;
};

template <class C>
struct _eval<C, std::enable_if_t<is_row_vector<C>::value>> {
  typedef RowVector<
      _elem_t<C>,
      _dims<C>::cols,
      _dims<C>::max_cols
    > type;
};
}  // namespace internal
}  // namespace lin

#endif