ml_tensor.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef ML_TENSOR_H
#define ML_TENSOR_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "ml_global.h"
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// STL INCLUDES
//=============================================================================================================
 
#include <cassert>
#include <cstdint>
#include <memory>
#include <vector>
 
//=============================================================================================================
// DEFINE NAMESPACE MLLIB
//=============================================================================================================
 
namespace MLLIB
{
 
//=============================================================================================================
class MLSHARED_EXPORT MlTensor
{
public:
    //  --- type aliases used in the public API --------------------------------
    using RowMajorMatrixXf = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
    using RowMajorMatrixMap = Eigen::Map<RowMajorMatrixXf>;
    using ConstRowMajorMatrixMap = Eigen::Map<const RowMajorMatrixXf>;
 
    //=========================================================================================================
    MlTensor();
 
    //=========================================================================================================
    MlTensor(std::vector<float>&& data, std::vector<int64_t> shape);
 
    //=========================================================================================================
    MlTensor(const float* data, std::vector<int64_t> shape);
 
    //=========================================================================================================
    explicit MlTensor(const Eigen::MatrixXf& mat);
 
    //=========================================================================================================
    explicit MlTensor(const Eigen::MatrixXd& mat);
 
    //=========================================================================================================
    static MlTensor view(float* data, std::vector<int64_t> shape);
 
    //=========================================================================================================
    static MlTensor fromBuffer(const float* data, int rows, int cols);
 
    //  --- shape access -------------------------------------------------------
 
    //=========================================================================================================
    int ndim() const;
 
    //=========================================================================================================
    int64_t size() const;
 
    //=========================================================================================================
    const std::vector<int64_t>& shape() const;
 
    //=========================================================================================================
    int64_t shape(int dim) const;
 
    //=========================================================================================================
    int rows() const;
 
    //=========================================================================================================
    int cols() const;
 
    //  --- raw data access (zero-copy) ----------------------------------------
 
    //=========================================================================================================
    float* data();
 
    //=========================================================================================================
    const float* data() const;
 
    //  --- Eigen Map accessors (zero-copy, 2-D) -------------------------------
 
    //=========================================================================================================
    RowMajorMatrixMap matrix();
 
    //=========================================================================================================
    ConstRowMajorMatrixMap matrix() const;
 
    //  --- Eigen copy helpers (produce column-major copies) -------------------
 
    //=========================================================================================================
    Eigen::MatrixXf toMatrixXf() const;
 
    //=========================================================================================================
    Eigen::MatrixXd toMatrixXd() const;
 
    //  --- reshape / query ----------------------------------------------------
 
    //=========================================================================================================
    MlTensor reshape(std::vector<int64_t> newShape) const;
 
    //=========================================================================================================
    bool isView() const;
 
    //=========================================================================================================
    bool empty() const;
 
private:
    static int64_t computeSize(const std::vector<int64_t>& shape);
 
    std::shared_ptr<std::vector<float>> m_storage; 
    float* m_data = nullptr;                       
    std::vector<int64_t> m_shape;                  
    int64_t m_size = 0;                            
};
 
} // namespace MLLIB
 
#endif // ML_TENSOR_H