TensorShape.h

Go to the documentation of this file.

#ifndef TENSOR_SHAPE_H
#define TENSOR_SHAPE_H
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <ostream>
#include <stdexcept>
#include <vector>
 
namespace txeo {
 
namespace detail {
class TensorHelper;
}
 
class TensorShape {
  public:
    TensorShape(const TensorShape &shape);
    TensorShape(TensorShape &&shape) noexcept;
    ~TensorShape();
 
    TensorShape &operator=(const TensorShape &shape);
    TensorShape &operator=(TensorShape &&shape) noexcept;
    bool operator==(const TensorShape &shape) const;
    bool operator!=(const TensorShape &shape) const;
 
    friend std::ostream &operator<<(std::ostream &os, const TensorShape &shape);
 
    explicit TensorShape(int number_of_axes, size_t dim);
 
    explicit TensorShape(const std::vector<size_t> &shape);
 
    explicit TensorShape(std::vector<size_t> &&shape);
 
    explicit TensorShape(const std::initializer_list<size_t> &shape)
        : TensorShape(std::vector<size_t>(shape)) {}
 
    [[nodiscard]] int number_of_axes() const noexcept;
 
    [[nodiscard]] int size() const noexcept { return this->number_of_axes(); };
 
    [[nodiscard]] int64_t axis_dim(int axis) const;
 
    [[nodiscard]] const std::vector<size_t> &stride() const;
 
    [[nodiscard]] std::vector<int64_t> axes_dims() const noexcept;
 
    [[nodiscard]] bool is_fully_defined() const noexcept;
 
    void push_axis_back(size_t dim);
 
    void insert_axis(int axis, size_t dim);
 
    void remove_axis(int axis);
 
    void remove_all_axes();
 
    void set_dim(int axis, size_t dim);
 
    [[nodiscard]] size_t calculate_capacity() const noexcept;
 
    [[nodiscard]] TensorShape clone() const;
 
  private:
    struct Impl;
    std::unique_ptr<Impl> _impl{nullptr};
 
    template <typename T>
    friend class Tensor;
 
    template <typename T>
    friend class Predictor;
 
    template <typename T>
    friend class TensorAgg;
 
    friend class txeo::detail::TensorHelper;
 
    template <typename P>
    void create_from_vector(P &&shape);
 
    explicit TensorShape();
};
 
class TensorShapeError : public std::runtime_error {
  public:
    using std::runtime_error::runtime_error;
};
 
} // namespace txeo
 
#endif