tensor_impl.h

#ifndef TENSOR_IMPL_H
#define TENSOR_IMPL_H
 
#include "nforge/core/tensor.h"
#include "nforge/core/tensor_layout.h"
 
class Tensor::Impl {
public:
    Impl() = default;
    virtual ~Impl() = default;
 
    virtual void fillAll(float value) = 0;
 
    virtual void fillRand() = 0;
 
    virtual void print() const = 0;
 
    virtual void print(const std::vector<size_t>& position) const = 0;
 
    virtual size_t getNumElements() const = 0;
 
    virtual Tensor::Shape getShape() const = 0;
 
    virtual std::vector<float> toVector() const = 0;
 
    virtual std::string toString() const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> clone() const = 0;
 
    virtual void copyFromHost(const float* data, size_t count) = 0;
 
    virtual void set(const TensorLayout& lhsLayout, const Tensor::Impl* rhsImpl,
                     const TensorLayout& rhsLayout) = 0;
 
    virtual bool compare(const TensorLayout& lhsLayout, const Tensor::Impl* rhsImpl,
                         const TensorLayout& rhsLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> add(const TensorLayout& lhsLayout,
                                              const Tensor::Impl* rhsImpl,
                                              const TensorLayout& rhsLayout,
                                              const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> sub(const TensorLayout& lhsLayout,
                                              const Tensor::Impl* rhsImpl,
                                              const TensorLayout& rhsLayout,
                                              const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> mul(const TensorLayout& lhsLayout,
                                              const Tensor::Impl* rhsImpl,
                                              const TensorLayout& rhsLayout,
                                              const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> div(const TensorLayout& lhsLayout,
                                              const Tensor::Impl* rhsImpl,
                                              const TensorLayout& rhsLayout,
                                              const TensorLayout& outLayout) const = 0;
 
    virtual void iadd(const TensorLayout& lhsLayout, const Tensor::Impl* rhsImpl,
                      const TensorLayout& rhsLayout) = 0;
 
    virtual void isub(const TensorLayout& lhsLayout, const Tensor::Impl* rhsImpl,
                      const TensorLayout& rhsLayout) = 0;
 
    virtual void imul(const TensorLayout& lhsLayout, const Tensor::Impl* rhsImpl,
                      const TensorLayout& rhsLayout) = 0;
 
    virtual void idiv(const TensorLayout& lhsLayout, const Tensor::Impl* rhsImpl,
                      const TensorLayout& rhsLayout) = 0;
 
    virtual std::unique_ptr<Tensor::Impl> sum(const TensorLayout& layout,
                                              const TensorLayout& blockLayout,
                                              const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> min(const TensorLayout& layout,
                                              const TensorLayout& blockLayout,
                                              const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> max(const TensorLayout& layout,
                                              const TensorLayout& blockLayout,
                                              const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> prod(const TensorLayout& layout,
                                               const TensorLayout& blockLayout,
                                               const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> norm(const TensorLayout& layout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> all(const TensorLayout& layout,
                                              const TensorLayout& blockLayout,
                                              const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> any(const TensorLayout& layout,
                                              const TensorLayout& blockLayout,
                                              const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> matmul(const TensorLayout& lhsLayout,
                                                 const Tensor::Impl* rhsImpl,
                                                 const TensorLayout& rhsLayout,
                                                 const TensorLayout& outLayout, size_t batch,
                                                 size_t m, size_t k, size_t p) const = 0;
 
 
    virtual std::unique_ptr<Tensor::Impl> equal(const TensorLayout& lhsLayout,
                                                const Tensor::Impl* rhsImpl,
                                                const TensorLayout& rhsLayout,
                                                const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> notEqual(const TensorLayout& lhsLayout,
                                                   const Tensor::Impl* rhsImpl,
                                                   const TensorLayout& rhsLayout,
                                                   const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> less(const TensorLayout& lhsLayout,
                                               const Tensor::Impl* rhsImpl,
                                               const TensorLayout& rhsLayout,
                                               const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> lessEqual(const TensorLayout& lhsLayout,
                                                    const Tensor::Impl* rhsImpl,
                                                    const TensorLayout& rhsLayout,
                                                    const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> greater(const TensorLayout& lhsLayout,
                                                  const Tensor::Impl* rhsImpl,
                                                  const TensorLayout& rhsLayout,
                                                  const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> greaterEqual(const TensorLayout& lhsLayout,
                                                       const Tensor::Impl* rhsImpl,
                                                       const TensorLayout& rhsLayout,
                                                       const TensorLayout& outLayout) const = 0;
 
    virtual std::unique_ptr<Tensor::Impl> isClose(const TensorLayout& lhsLayout,
                                                  const Tensor::Impl* rhsImpl,
                                                  const TensorLayout& rhsLayout,
                                                  const TensorLayout& outLayout,
                                                  float tolerance) const = 0;
};
 
#endif  // TENSOR_IMPL_H