tensor.h

Go to the documentation of this file.

// Copyright (C) 2024 The m-AIA AUTHORS
//
// This file is part of m-AIA (https://git.rwth-aachen.de/aia/m-AIA/m-AIA)
//
// SPDX-License-Identifier: LGPL-3.0-only
 
#ifndef TENSOR_H_
#define TENSOR_H_
 
#include <ostream>
#include "INCLUDE/maiatypes.h"
#include "debug.h"
#include "functions.h"
 
namespace maia {
namespace tensor {
 
// Forward declaration of TensorStorage
namespace detail_ {
template <class T>
class TensorStorage;
}
 
template <class T>
class Tensor {
 public:
  // Public types
  typedef MLong size_type;
  typedef T value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef pointer iterator;
  typedef const_pointer const_iterator;
  typedef MInt dim_type;
 
  // Constructors & destructor
  Tensor();
  explicit Tensor(size_type n0, size_type n1 = 1, size_type n2 = 1, size_type n3 = 1, size_type n4 = 1);
  Tensor(T* data, size_type n0, size_type n1 = 1, size_type n2 = 1, size_type n3 = 1, size_type n4 = 1);
  ~Tensor();
 
  size_type size() const;
  size_type resize(size_type n0, size_type n1 = 1, size_type n2 = 1, size_type n3 = 1, size_type n4 = 1);
  void assign(size_type n, const T& newValue);
  void set(const T& value);
  void clear();
  void transpose();
 
  void swap(Tensor<T>& other);
  template <class TT>
  friend void swap(Tensor<TT>& a, Tensor<TT>& b);
 
  size_type dim(size_type d) const;
  size_type dim0() const;
  size_type dim1() const;
  size_type dim2() const;
  size_type dim3() const;
  size_type dim4() const;
 
  Tensor<T>& operator=(Tensor<T> copy);
  Tensor<T>(Tensor<T>&& copy) = default;
  Tensor<T>(const Tensor<T>& copy) = default;
 
 
  T& operator[](size_type index);
  const T& operator[](size_type index) const;
  T& operator()(size_type i0);
  const T& operator()(size_type i0) const;
  T& operator()(size_type i0, size_type i1);
  const T& operator()(size_type i0, size_type i1) const;
  T& operator()(size_type i0, size_type i1, size_type i2);
  const T& operator()(size_type i0, size_type i1, size_type i2) const;
  T& operator()(size_type i0, size_type i1, size_type i2, size_type i3);
  const T& operator()(size_type i0, size_type i1, size_type i2, size_type i3) const;
  T& operator()(size_type i0, size_type i1, size_type i2, size_type i3, size_type i4);
  const T& operator()(size_type i0, size_type i1, size_type i2, size_type i3, size_type i4) const;
 
 private:
  static const dim_type m_maxNoDims = 5;
  typedef detail_::TensorStorage<T> DataStorage;
 
  DataStorage m_data;
  size_type m_size;
  size_type m_dim[m_maxNoDims]{};
};
 
 
template <class T>
inline Tensor<T>::Tensor() : m_data(), m_size(0) {
  m_dim[0] = 0;
  m_dim[1] = 0;
  m_dim[2] = 0;
  m_dim[3] = 0;
  m_dim[4] = 0;
}
 
template <class T>
inline Tensor<T>::Tensor(size_type n0, size_type n1, size_type n2, size_type n3, size_type n4) {
  ASSERT(n0 > 0, "Dimension n0 must be greater than zero");
  ASSERT(n1 > 0, "Dimension n1 must be greater than zero");
  ASSERT(n2 > 0, "Dimension n2 must be greater than zero");
  ASSERT(n3 > 0, "Dimension n3 must be greater than zero");
  ASSERT(n4 > 0, "Dimension n4 must be greater than zero");
 
  m_dim[0] = n0;
  m_dim[1] = n1;
  m_dim[2] = n2;
  m_dim[3] = n3;
  m_dim[4] = n4;
 
  m_size = n0 * n1 * n2 * n3 * n4;
  m_data.resize(m_size);
}
 
 
template <class T>
inline Tensor<T>::Tensor(T* data, size_type n0, size_type n1, size_type n2, size_type n3, size_type n4) {
  ASSERT(n0 > 0, "Dimension n0 must be greater than zero");
  ASSERT(n1 > 0, "Dimension n1 must be greater than zero");
  ASSERT(n2 > 0, "Dimension n2 must be greater than zero");
  ASSERT(n3 > 0, "Dimension n3 must be greater than zero");
  ASSERT(n4 > 0, "Dimension n4 must be greater than zero");
 
  m_dim[0] = n0;
  m_dim[1] = n1;
  m_dim[2] = n2;
  m_dim[3] = n3;
  m_dim[4] = n4;
 
  m_size = n0 * n1 * n2 * n3 * n4;
  m_data.resize(m_size, data);
}
 
template <class T>
inline Tensor<T>::~Tensor() {
  clear();
}
 
 
template <class T>
inline typename Tensor<T>::size_type Tensor<T>::size() const {
  return m_size;
}
 
 
template <class T>
inline typename Tensor<T>::size_type Tensor<T>::resize(size_type n0, size_type n1, size_type n2, size_type n3,
                                                       size_type n4) {
  m_dim[0] = n0;
  m_dim[1] = n1;
  m_dim[2] = n2;
  m_dim[3] = n3;
  m_dim[4] = n4;
 
  m_size = n0 * n1 * n2 * n3 * n4;
  m_data.resize(size());
 
  return size();
}
 
 
template <class T>
inline void Tensor<T>::assign(size_type n, const T& value) {
  resize(n);
  set(value);
}
 
 
template <class T>
inline void Tensor<T>::set(const T& value) {
  std::fill_n(&m_data[0], size(), value);
}
 
 
template <class T>
inline void Tensor<T>::clear() {
  m_dim[0] = 0;
  m_dim[1] = 0;
  m_dim[2] = 0;
  m_dim[3] = 0;
  m_dim[4] = 0;
 
  m_size = 0;
  m_data.clear();
}
 
 
template <class T>
inline void Tensor<T>::transpose() {
  Tensor<T> tmp(*this);
 
  std::swap(m_dim[0], m_dim[1]);
 
  for(MInt i = 0; i < tmp.dim0(); i++) {
    for(MInt j = 0; j < tmp.dim1(); j++) {
      (*this)(j, i) = tmp(i, j);
    }
  }
}
 
 
template <class T>
inline void Tensor<T>::swap(Tensor<T>& other) {
  using std::swap;
  swap(m_data, other.m_data);
  swap(m_size, other.m_size);
  for(dim_type i = 0; i < m_maxNoDims; ++i)
    swap(m_dim[i], other.m_dim[i]);
}
 
 
template <class T>
inline typename Tensor<T>::size_type Tensor<T>::dim(size_type d) const {
  ASSERT(d >= 0, "Dimension d must be greater than or equal to zero!");
  ASSERT(d < m_maxNoDims, "Dimension d must be less than m_maxNoDims!");
 
  return m_dim[d];
}
 
 
template <class T>
inline typename Tensor<T>::size_type Tensor<T>::dim0() const {
  return m_dim[0];
}
 
 
template <class T>
inline typename Tensor<T>::size_type Tensor<T>::dim1() const {
  return m_dim[1];
}
 
 
template <class T>
inline typename Tensor<T>::size_type Tensor<T>::dim2() const {
  return m_dim[2];
}
 
 
template <class T>
inline typename Tensor<T>::size_type Tensor<T>::dim3() const {
  return m_dim[3];
}
 
 
template <class T>
inline typename Tensor<T>::size_type Tensor<T>::dim4() const {
  return m_dim[4];
}
 
 
template <class T>
inline Tensor<T>& Tensor<T>::operator=(Tensor<T> copy) {
  swap(copy);
 
  return *this;
}
 
 
template <class T>
inline T& Tensor<T>::operator[](size_type index) {
  ASSERT(index >= 0 && index < size(), "Index out of bounds");
 
  return m_data[index];
}
 
 
template <class T>
inline const T& Tensor<T>::operator[](size_type index) const {
  ASSERT(index >= 0 && index < size(), "Index out of bounds");
 
  return m_data[index];
}
 
 
template <class T>
inline T& Tensor<T>::operator()(size_type i0) {
  ASSERT(i0 >= 0 && i0 < dim0(), "Index i0 out of bounds");
 
  return m_data[i0];
}
 
 
template <class T>
inline const T& Tensor<T>::operator()(size_type i0) const {
  ASSERT(i0 >= 0 && i0 < dim0(), "Index i0 out of bounds");
 
  return m_data[i0];
}
 
 
template <class T>
inline T& Tensor<T>::operator()(size_type i0, size_type i1) {
  ASSERT(i0 >= 0 && i0 < dim0(), "Index i0 out of bounds");
  ASSERT(i1 >= 0 && i1 < dim1(), "Index i1 out of bounds");
 
  return m_data[i0 * dim1() + i1];
}
 
 
template <class T>
inline const T& Tensor<T>::operator()(size_type i0, size_type i1) const {
  ASSERT(i0 >= 0 && i0 < dim0(), "Index i0 out of bounds");
  ASSERT(i1 >= 0 && i1 < dim1(), "Index i1 out of bounds");
 
  return m_data[i0 * dim1() + i1];
}
 
 
template <class T>
inline T& Tensor<T>::operator()(size_type i0, size_type i1, size_type i2) {
  ASSERT(i0 >= 0 && i0 < dim0(), "Index i0 out of bounds");
  ASSERT(i1 >= 0 && i1 < dim1(), "Index i1 out of bounds");
  ASSERT(i2 >= 0 && i2 < dim2(), "Index i2 out of bounds");
 
  return m_data[i0 * dim1() * dim2() + i1 * dim2() + i2];
}
 
 
template <class T>
inline const T& Tensor<T>::operator()(size_type i0, size_type i1, size_type i2) const {
  ASSERT(i0 >= 0 && i0 < dim0(), "Index i0 out of bounds");
  ASSERT(i1 >= 0 && i1 < dim1(), "Index i1 out of bounds");
  ASSERT(i2 >= 0 && i2 < dim2(), "Index i2 out of bounds");
 
  return m_data[i0 * dim1() * dim2() + i1 * dim2() + i2];
}
 
 
template <class T>
inline T& Tensor<T>::operator()(size_type i0, size_type i1, size_type i2, size_type i3) {
  ASSERT(i0 >= 0 && i0 < dim0(), "Index i0 out of bounds");
  ASSERT(i1 >= 0 && i1 < dim1(), "Index i1 out of bounds");
  ASSERT(i2 >= 0 && i2 < dim2(), "Index i2 out of bounds");
  ASSERT(i3 >= 0 && i3 < dim3(), "Index i3 out of bounds");
 
  return m_data[i0 * dim1() * dim2() * dim3() + i1 * dim2() * dim3() + i2 * dim3() + i3];
}
 
 
template <class T>
inline const T& Tensor<T>::operator()(size_type i0, size_type i1, size_type i2, size_type i3) const {
  ASSERT(i0 >= 0 && i0 < dim0(), "Index i0 out of bounds");
  ASSERT(i1 >= 0 && i1 < dim1(), "Index i1 out of bounds");
  ASSERT(i2 >= 0 && i2 < dim2(), "Index i2 out of bounds");
  ASSERT(i3 >= 0 && i3 < dim3(), "Index i3 out of bounds");
 
  return m_data[i0 * dim1() * dim2() * dim3() + i1 * dim2() * dim3() + i2 * dim3() + i3];
}
 
 
template <class T>
inline T& Tensor<T>::operator()(size_type i0, size_type i1, size_type i2, size_type i3, size_type i4) {
  ASSERT(i0 >= 0 && i0 < dim0(), "Index i0 out of bounds");
  ASSERT(i1 >= 0 && i1 < dim1(), "Index i1 out of bounds");
  ASSERT(i2 >= 0 && i2 < dim2(), "Index i2 out of bounds");
  ASSERT(i3 >= 0 && i3 < dim3(), "Index i3 out of bounds");
  ASSERT(i4 >= 0 && i4 < dim4(), "Index i4 out of bounds");
 
  return m_data[i0 * dim1() * dim2() * dim3() * dim4() + i1 * dim2() * dim3() * dim4() + i2 * dim3() * dim4()
                + i3 * dim4() + i4];
}
 
 
template <class T>
inline const T& Tensor<T>::operator()(size_type i0, size_type i1, size_type i2, size_type i3, size_type i4) const {
  ASSERT(i0 >= 0 && i0 < dim0(), "Index i0 out of bounds");
  ASSERT(i1 >= 0 && i1 < dim1(), "Index i1 out of bounds");
  ASSERT(i2 >= 0 && i2 < dim2(), "Index i2 out of bounds");
  ASSERT(i3 >= 0 && i3 < dim3(), "Index i3 out of bounds");
  ASSERT(i4 >= 0 && i4 < dim4(), "Index i4 out of bounds");
 
  return m_data[i0 * dim1() * dim2() * dim3() * dim4() + i1 * dim2() * dim3() * dim4() + i2 * dim3() * dim4()
                + i3 * dim4() + i4];
}
 
 
template <class TT>
std::ostream& operator<<(std::ostream& os, const Tensor<TT>& t) {
  for(MInt i = 0; i < t.dim0(); i++) {
    for(MInt j = 0; j < t.dim1(); j++) {
      for(MInt k = 0; k < t.dim2(); k++) {
        for(MInt l = 0; l < t.dim3(); l++) {
          os << "(" << i << "," << j << "," << k << "," << l << ") = ";
          os << t(i, j, k, l) << std::endl;
        }
      }
    }
  }
 
  os << "Dimensions (i,j,k,l) = (" << t.dim0() << "," << t.dim1() << "," << t.dim2() << "," << t.dim3() << ")"
     << std::endl;
 
  return os;
}
 
 
template <class TT>
inline void swap(Tensor<TT>& a, Tensor<TT>& b) {
  a.swap(b);
}
 
 
 
 
// Internal namespace for methods/class that are generally not needed outside of Tensor
namespace detail_ {
 
template <class T>
class TensorStorage {
 public:
  // Public types
  typedef MLong size_type;
  typedef T value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef pointer iterator;
  typedef const_pointer const_iterator;
 
  // Constructors & destructor
  TensorStorage();
  TensorStorage(const TensorStorage<T>& ts);
  explicit TensorStorage(size_type n);
  TensorStorage(size_type n, T* data);
  ~TensorStorage();
 
  size_type size() const;
  void resize(size_type n);
  void resize(size_type n, T* data);
 
  void clear();
  void swap(TensorStorage<T>& other);
  template <class TT>
  friend void swap(TensorStorage<TT>& a, TensorStorage<TT>& b);
 
  TensorStorage<T>& operator=(TensorStorage<T> copy);
  T& operator[](size_type n);
  const T& operator[](size_type n) const;
 
 private:
  MBool isAllocated();
  void reallocate(size_type n);
 
 private:
  T* m_data;
  size_type m_size;
  MBool m_isAllocated;
};
 
 
template <class T>
inline TensorStorage<T>::TensorStorage() : m_data(0), m_size(0), m_isAllocated(false) {
  // Nothing here
}
 
 
template <class T>
inline TensorStorage<T>::TensorStorage(const TensorStorage<T>& ts) : m_data(0), m_size(0), m_isAllocated(false) {
  // Allocate new memory and copy the data members
  reallocate(ts.size());
  std::copy(&ts.m_data[0], &ts.m_data[0] + ts.size(), m_data);
}
 
 
template <class T>
inline TensorStorage<T>::TensorStorage(size_type n) : m_data(0), m_size(0), m_isAllocated(false) {
  resize(n);
}
 
 
template <class T>
inline TensorStorage<T>::TensorStorage(size_type n, T* data) : m_data(data), m_size(n), m_isAllocated(false) {
  ASSERT(n >= 0, "New storage size must be greater or equal to zero.");
  ASSERT(data != 0, "Data pointer may not be a null pointer.");
}
 
 
template <class T>
inline TensorStorage<T>::~TensorStorage() {
  clear();
}
 
 
template <class T>
inline typename TensorStorage<T>::size_type TensorStorage<T>::size() const {
  return m_size;
}
 
 
template <class T>
inline void TensorStorage<T>::resize(size_type n) {
  ASSERT(n >= 0, "New storage size must be greater or equal to zero.");
 
  reallocate(n);
}
 
 
template <class T>
inline void TensorStorage<T>::resize(size_type n, T* data) {
  ASSERT(n >= 0, "New storage size must be greater or equal to zero.");
  ASSERT(data != 0, "Data pointer may not be a null pointer.");
 
  clear();
  m_size = n;
  m_data = data;
}
 
 
template <class T>
inline void TensorStorage<T>::clear() {
  if(isAllocated()) {
    delete[] m_data;
  }
 
  m_data = 0;
  m_size = 0;
  m_isAllocated = false;
}
 
 
template <class T>
inline void TensorStorage<T>::swap(TensorStorage<T>& other) {
  using std::swap;
  swap(m_data, other.m_data);
  swap(m_size, other.m_size);
  swap(m_isAllocated, other.m_isAllocated);
}
 
 
template <class TT>
inline void swap(TensorStorage<TT>& a, TensorStorage<TT>& b) {
  a.swap(b);
}
 
 
template <class T>
inline TensorStorage<T>& TensorStorage<T>::operator=(TensorStorage<T> copy) {
  swap(copy);
 
  return *this;
}
 
 
template <class T>
inline T& TensorStorage<T>::operator[](size_type n) {
  ASSERT(n >= 0 && n < size(), "Index out of bounds");
 
  return m_data[n];
}
 
 
template <class T>
inline const T& TensorStorage<T>::operator[](size_type n) const {
  ASSERT(n >= 0 && n < size(), "Index out of bounds");
 
  return m_data[n];
}
 
 
template <class T>
inline MBool TensorStorage<T>::isAllocated() {
  return m_isAllocated;
}
 
 
template <class T>
[[gnu::noinline]] // this is neccesary for flto compilation
void TensorStorage<T>::reallocate(size_type n) {
  clear();
 
  m_data = (n <= 0) ? nullptr : new T[std::min(n, PTRDIFF_MAX)];
  m_size = n;
  m_isAllocated = true;
}
 
} // namespace detail_
 
 
} // namespace tensor
} // namespace maia
 
// Define some types for ease of use
typedef maia::tensor::Tensor<MFloat> MFloatVector;
typedef maia::tensor::Tensor<MInt> MIntVector;
typedef maia::tensor::Tensor<MInt> MIntVector;
typedef maia::tensor::Tensor<MFloat> MFloatMatrix;
typedef maia::tensor::Tensor<MInt> MIntMatrix;
typedef maia::tensor::Tensor<MInt> MIntMatrix;
typedef maia::tensor::Tensor<MFloat> MFloatTensor;
typedef maia::tensor::Tensor<MInt> MIntTensor;
typedef maia::tensor::Tensor<MInt> MIntTensor;
 
#endif /* TENSOR_H_ */