Class Tensor

imperative/python/src/tensor.h:39–91

extern PyObject* cpp_astensor1d;

struct Tensor {
private:
    ValueRef m_data;
    std::string m_name;

public:
    using Handle = interpreter::Interpreter::Handle;

    inline explicit Tensor(ValueRef data) : m_data{data} {}

    ~Tensor() = default;

    inline Tensor copy() { return Tensor(imperative::apply(DupTensor(), data())[0]); }

    inline DType dtype() { return *data().dtype(); }
    inline CompNode comp_node() { return *data().device(); }
    inline std::optional<ValueShape> shape() {
        auto shape = data().shape();
        if (!shape) {
            return {};
        }
        return *shape;
    }
    inline Format format() { return *data().format(); }
    inline void set_format(std::string format) {
        if (!format.empty()) {
            m_data = imperative::apply(SetFormat(format), m_data)[0];
        }
    }
    inline void as_format(std::string format) {
        if (!format.empty()) {
            m_data = imperative::apply(AsFormat(format), m_data)[0];
        }
    }
    inline HostValue::ref_t numpy() { return data().numpy(); }
    inline void reset(ValueRef value) {
        m_data = value;
        if (!m_name.empty()) {
            set_name(m_name);
        }
    }
    inline ValueRef data() const { return m_data.unwrap(); }
    bool is_scalar() { return data().is_scalar(); }
    inline std::string name() { return m_name; }
    inline size_t value_id() { return m_data.id(); }
    inline void set_name(std::string name) {
        m_name = name;
        if (!name.empty()) {
            auto output = imperative::apply(RenameValue(name), m_data)[0];
            m_data = output;
        }
    }
};

struct TensorWrapper {
public: