tensor_view.h

#ifndef TENSOR_VIEW_H
#define TENSOR_VIEW_H
 
#include "nforge/core/tensor.h"
#include "nforge/core/tensor_layout.h"
#include "nforge/core/tensor_shape.h"
 
class Tensor::View {
public:
    View(Tensor& parent);
 
    View(Tensor& parent, const std::vector<size_t>& position);
 
    View(Tensor& parent, const std::vector<size_t>& position, const TensorLayout& layout);
 
    View(const Tensor& parent);
 
    static Tensor::View broadcast(Tensor& source, const Tensor::Shape& shape);
 
    static Tensor::View subsample(const View& src, const std::vector<size_t>& factors);
 
    void print() const;
 
    inline Tensor& getParent() const { return m_parent; }
 
    inline std::vector<size_t> getPosition() const { return m_position; }
 
    inline size_t getOffset() const { return m_layout.offset; }
 
    inline Tensor::Shape getShape() const { return Tensor::Shape(m_layout); }
 
    std::vector<size_t> getStride() const;
 
    const TensorLayout& getLayout() const { return m_layout; }
 
    std::string getBackendString() const { return m_parent.getBackendString(); }
 
    inline Backend getBackend() const { return m_parent.getBackend(); }
 
    Tensor copy() const;
 
    std::vector<float> toVector() const;
 
    Tensor operator+(const Tensor::View& rhs) const;
 
    Tensor operator-(const Tensor::View& rhs) const;
 
    Tensor operator*(const Tensor::View& rhs) const;
 
    Tensor operator/(const Tensor::View& rhs) const;
 
    void operator+=(const Tensor::View& rhs);
 
    void operator-=(const Tensor::View& rhs);
 
    void operator*=(const Tensor::View& rhs);
 
    void operator/=(const Tensor::View& rhs);
 
    Tensor mean(size_t dim = 0) const;
 
    Tensor sum(size_t dim = 0) const;
 
    Tensor min(size_t dim = 0) const;
 
    Tensor max(size_t dim = 0) const;
 
    Tensor prod(size_t dim = 0) const;
 
    Tensor norm() const;
 
    Tensor::View operator=(const Tensor& rhs);
 
    Tensor::View operator=(const Tensor::View& rhs);
 
    Tensor::View operator=(float scalar);
 
    Tensor::View operator[](size_t idx) const;
 
    Tensor matmul(const Tensor::View& rhs) const;
 
    Tensor::View subsample(std::vector<size_t> strides) const;
 
    bool operator==(const Tensor& rhs) const;
 
    bool operator==(const Tensor::View& rhs) const;
 
    bool operator!=(const Tensor& rhs) const;
 
    bool operator!=(const Tensor::View& rhs) const;
 
    Tensor operator<(const Tensor::View& rhs) const;
 
    Tensor operator<=(const Tensor::View& rhs) const;
 
    Tensor operator>(const Tensor::View& rhs) const;
 
    Tensor operator>=(const Tensor::View& rhs) const;
 
    Tensor isClose(const Tensor::View& rhs, float tolerance = 1e-5f) const;
 
private:
    // Differentiates the broadcast constructor from public constructors.
    struct BroadcastTag {};
 
    // Constructs a view with explicit stride and shape. Used by broadcast().
    View(Tensor& parent, const std::vector<size_t>& stride, const Tensor::Shape& shape,
         BroadcastTag);
 
    Tensor& m_parent;
    std::vector<size_t> m_position;
    TensorLayout m_layout;
};
 
#endif  // TENSOR_VIEW_H