Tensor.h

Go to the documentation of this file.

#ifndef TENSOR_H
#define TENSOR_H
 
#pragma once
 
#include "txeo/TensorIterator.h"
#include "txeo/TensorShape.h"
#include "txeo/types.h"
 
#include <concepts>
#include <cstddef>
#include <exception>
#include <initializer_list>
#include <iosfwd>
#include <memory>
#include <stdexcept>
#include <type_traits>
#include <vector>
 
namespace txeo {
class TensorShape;
enum class NormalizationType;
 
template <typename T>
concept c_numeric = std::is_arithmetic_v<T> && !std::is_same_v<T, bool>;
 
namespace detail {
class TensorHelper;
}
 
template <typename T>
class Predictor;
template <typename T>
class TensorAgg;
template <typename T>
class TensorFunc;
template <typename T>
class TensorOp;
template <typename T>
class TensorPart;
 
template <typename T>
class Tensor {
  public:
    explicit Tensor();
    Tensor(const Tensor &tensor);
    Tensor(Tensor &&tensor) noexcept;
    virtual ~Tensor();
 
    Tensor &operator=(const Tensor &tensor);
    Tensor &operator=(Tensor &&tensor) noexcept;
    bool operator==(const Tensor &tensor);
    bool operator!=(const Tensor &tensor);
 
    template <typename U>
    friend std::ostream &operator<<(std::ostream &os, const Tensor<U> &tensor);
 
    explicit Tensor(txeo::TensorShape &&shape);
 
    explicit Tensor(const txeo::TensorShape &shape) : Tensor{shape.clone()} {};
 
    explicit Tensor(std::vector<size_t> &&shape);
 
    explicit Tensor(const std::vector<size_t> &shape) : Tensor{std::vector<size_t>(shape)} {};
 
    explicit Tensor(const std::initializer_list<size_t> &shape)
        : Tensor(std::vector<size_t>(shape)) {}
 
    explicit Tensor(txeo::TensorShape &&shape, const T &fill_value);
 
    explicit Tensor(const txeo::TensorShape &shape, const T &fill_value)
        : Tensor{shape.clone(), fill_value} {};
 
    explicit Tensor(std::vector<size_t> &&shape, const T &fill_value);
 
    explicit Tensor(const std::vector<size_t> &shape, const T &fill_value)
        : Tensor(std::vector<size_t>(shape), fill_value) {};
 
    explicit Tensor(const std::initializer_list<size_t> &shape, const T &fill_value)
        : Tensor(std::vector<size_t>(shape), fill_value) {}
 
    explicit Tensor(const txeo::TensorShape &shape, const std::vector<T> &values);
 
    explicit Tensor(const std::vector<size_t> &shape, const std::vector<T> &values);
 
    explicit Tensor(const std::initializer_list<size_t> &shape, const std::vector<T> &values)
        : Tensor(std::vector<size_t>(shape), values) {}
 
    explicit Tensor(const std::initializer_list<std::initializer_list<T>> &values);
 
    explicit Tensor(
        const std::initializer_list<std::initializer_list<std::initializer_list<T>>> &values);
 
    [[nodiscard]] const txeo::TensorShape &shape() const;
 
    constexpr std::type_identity_t<T> type() const;
 
    [[nodiscard]] int order() const;
 
    [[nodiscard]] size_t dim() const;
 
    [[nodiscard]] size_t number_of_elements() const { return this->dim(); };
 
    [[nodiscard]] size_t memory_size() const;
 
    Tensor<T> slice(size_t first_axis_begin, size_t first_axis_end) const;
 
    void view_of(const Tensor<T> &tensor, const txeo::TensorShape &shape);
 
    template <typename U>
    [[nodiscard]] bool is_equal_shape(const Tensor<U> &other) const {
      return this->shape() == other.shape();
    };
 
    T &operator()();
 
    template <typename... Args>
      requires(std::convertible_to<Args, size_t> && ...)
    T &operator()(Args... args);
 
    T &at();
 
    template <typename... Args>
      requires(std::convertible_to<Args, size_t> && ...)
    T &at(Args... args);
 
    const T &operator()() const;
 
    template <typename... Args>
      requires(std::convertible_to<Args, size_t> && ...)
    const T &operator()(Args... args) const;
 
    const T &at() const;
 
    template <typename... Args>
      requires(std::convertible_to<Args, size_t> && ...)
    const T &at(Args... args) const;
 
    void reshape(const txeo::TensorShape &shape);
 
    void reshape(const std::vector<size_t> &shape);
 
    void reshape(const std::initializer_list<size_t> &shape) {
      this->reshape(std::vector<size_t>(shape));
    };
 
    Tensor<T> flatten() const;
 
    void fill(const T &value);
 
    void fill_with_uniform_random(const T &min, const T &max);
 
    void fill_with_uniform_random(const T &min, const T &max, const size_t &seed1,
                                  const size_t &seed2);
 
    void shuffle();
 
    void squeeze();
 
    Tensor<T> &increase_dimension(size_t axis, T value);
 
    Tensor<T> &power(const T &exponent);
 
    Tensor<T> &square();
 
    Tensor<T> &sqrt();
 
    Tensor<T> &abs();
 
    Tensor<T> &permute(const std::vector<size_t> &axes);
 
    Tensor<T> &normalize(size_t axis, txeo::NormalizationType type);
 
    Tensor<T> &normalize(txeo::NormalizationType type);
 
    T inner(const Tensor<T> &tensor) const;
 
    Tensor<T> &operator=(const T &value);
 
    T *data();
 
    [[nodiscard]] const T *data() const;
 
    Tensor<T> clone() const;
 
    template <typename U>
    friend txeo::Tensor<U> operator+(const txeo::Tensor<U> &left, const txeo::Tensor<U> &right);
 
    template <typename U>
    friend txeo::Tensor<U> operator+(const txeo::Tensor<U> &left, const U &right);
 
    template <typename U>
    friend txeo::Tensor<U> operator-(const txeo::Tensor<U> &left, const txeo::Tensor<U> &right);
 
    template <typename U>
    friend txeo::Tensor<U> operator-(const txeo::Tensor<U> &left, const U &right);
 
    template <typename U>
    friend txeo::Tensor<U> operator-(const U &left, const txeo::Tensor<U> &right);
 
    template <typename U>
    friend txeo::Tensor<U> operator*(const txeo::Tensor<U> &tensor, const U &scalar);
 
    template <typename U>
    friend txeo::Tensor<U> operator*(const U &scalar, const txeo::Tensor<U> &tensor);
 
    template <typename U>
    friend txeo::Tensor<U> operator/(const txeo::Tensor<U> &left, const U &right);
 
    template <typename U>
    friend txeo::Tensor<U> operator/(const U &left, const txeo::Tensor<U> &right);
 
    Tensor<T> &operator+=(const Tensor<T> &tensor);
    Tensor<T> &operator+=(const T &tensor);
    Tensor<T> &operator-=(const Tensor<T> &tensor);
    Tensor<T> &operator-=(const T &tensor);
    Tensor<T> &operator*=(const T &scalar);
    Tensor<T> &operator/=(const T &scalar);
 
    txeo::TensorIterator<T> begin();
    txeo::TensorIterator<T> end();
    txeo::TensorIterator<const T> begin() const;
    txeo::TensorIterator<const T> end() const;
 
  protected:
    struct Impl;
 
    std::unique_ptr<Impl> _impl{nullptr};
 
    friend class txeo::Predictor<T>;
    friend class txeo::TensorAgg<T>;
    friend class txeo::TensorPart<T>;
    friend class txeo::TensorOp<T>;
    friend class txeo::TensorFunc<T>;
    friend class txeo::detail::TensorHelper;
 
    template <typename P>
    void create_from_shape(P &&shape);
 
    void fill_data_shape(const std::initializer_list<std::initializer_list<T>> &list,
                         std::vector<T> &flat_data, std::vector<size_t> &shape);
 
    void fill_data_shape(
        const std::initializer_list<std::initializer_list<std::initializer_list<T>>> &list,
        std::vector<T> &flat_data, std::vector<size_t> &shape);
 
    void check_indexes(const std::vector<size_t> &indexes);
};
 
class TensorError : public std::runtime_error {
  public:
    using std::runtime_error::runtime_error;
};
 
template <typename T>
template <typename... Args>
  requires(std::convertible_to<Args, size_t> && ...)
inline T &Tensor<T>::operator()(Args... args) {
  size_t indexes[] = {static_cast<size_t>(args)...};
  size_t size = this->order();
  auto *stride = this->shape().stride().data();
  size_t flat_index{indexes[size - 1]};
 
  for (size_t i = 0; i < size - 1; ++i)
    flat_index += indexes[i] * stride[i];
 
  return this->data()[flat_index];
}
 
template <typename T>
template <typename... Args>
  requires(std::convertible_to<Args, size_t> && ...)
inline const T &Tensor<T>::operator()(Args... args) const {
  size_t indexes[] = {static_cast<size_t>(args)...};
  size_t size = this->order();
  auto *stride = this->shape().stride().data();
  size_t flat_index{indexes[size - 1]};
 
  for (size_t i = 0; i < size - 1; ++i)
    flat_index += indexes[i] * stride[i];
 
  return this->data()[flat_index];
}
 
template <typename T>
template <typename... Args>
  requires(std::convertible_to<Args, size_t> && ...)
inline T &Tensor<T>::at(Args... args) {
  if (this->order() != sizeof...(Args))
    throw TensorError("The number of axes specified and the order of this tensor do no match.");
  try {
    check_indexes({static_cast<size_t>(args)...});
  } catch (std::exception e) {
    throw txeo::TensorError(e.what());
  }
 
  return (*this)(args...);
}
 
template <typename T>
template <typename... Args>
  requires(std::convertible_to<Args, size_t> && ...)
inline const T &Tensor<T>::at(Args... args) const {
  if (this->order() != sizeof...(Args))
    throw TensorError("The number of axes specified and the order of this tensor do no match.");
  try {
    check_indexes({static_cast<size_t>(args)...});
  } catch (std::exception e) {
    throw txeo::TensorError(e.what());
  }
 
  return (*this)(args...);
}
 
template <typename T>
void Tensor<T>::fill_data_shape(const std::initializer_list<std::initializer_list<T>> &list,
                                std::vector<T> &flat_data, std::vector<size_t> &shape) {
 
  shape.emplace_back(list.size());
  std::vector<std::initializer_list<T>> v_list(list);
  for (size_t i{1}; i < v_list.size(); ++i)
    if (v_list[i].size() != v_list[i - 1].size())
      throw txeo::TensorError("Tensor initialization is inconsistent!");
 
  shape.emplace_back(v_list[0].size());
  for (auto &item : v_list)
    for (auto &subitem : item)
      flat_data.emplace_back(subitem);
}
 
template <typename T>
void Tensor<T>::fill_data_shape(
    const std::initializer_list<std::initializer_list<std::initializer_list<T>>> &list,
    std::vector<T> &flat_data, std::vector<size_t> &shape) {
  shape.emplace_back(list.size());
  std::vector<std::initializer_list<std::initializer_list<T>>> v_list(list);
  for (size_t i{1}; i < v_list.size(); ++i)
    if (v_list[i].size() != v_list[i - 1].size())
      throw txeo::TensorError("Tensor initialization is inconsistent!");
 
  shape.emplace_back(v_list[0].size());
  bool emplaced{false};
  for (size_t i{0}; i < v_list.size(); ++i) {
    std::vector<std::initializer_list<T>> v_sublist(v_list[i]);
    for (size_t i{1}; i < v_sublist.size(); ++i)
      if (v_sublist[i].size() != v_sublist[i - 1].size())
        throw txeo::TensorError("Tensor initialization is inconsistent!");
 
    if (!emplaced) {
      shape.emplace_back(v_sublist[0].size());
      emplaced = true;
    }
    for (auto &item : v_sublist)
      for (auto &subitem : item)
        flat_data.emplace_back(subitem);
  }
}
 
} // namespace txeo
 
#endif // TENSOR_H