Views/Tensor.hpp

Go to the documentation of this file.

 
#ifndef LLU_CONTAINERS_VIEWS_TENSOR_HPP
#define LLU_CONTAINERS_VIEWS_TENSOR_HPP
 
#include "LLU/Containers/Generic/Tensor.hpp"
#include "LLU/Containers/Interfaces.h"
#include "LLU/Containers/Iterators/IterableContainer.hpp"
 
namespace LLU {
 
    class TensorView : public TensorInterface {
    public:
        TensorView() = default;
 
        TensorView(const GenericTensor& gTen) : t {gTen.getContainer()} {}    // NOLINT: implicit conversion to a view is useful and harmless
 
        TensorView(MTensor mt) : t {mt} {}    // NOLINT
 
        mint getRank() const override {
            return LibraryData::API()->MTensor_getRank(t);
        }
 
        mint const* getDimensions() const override {
            return LibraryData::API()->MTensor_getDimensions(t);
        }
 
        mint getFlattenedLength() const override {
            return LibraryData::API()->MTensor_getFlattenedLength(t);
        }
 
        mint type() const final {
            return LibraryData::API()->MTensor_getType(t);
        }
 
        void* rawData() const override {
            switch (type()) {
                case MType_Integer: return LibraryData::API()->MTensor_getIntegerData(t);
                case MType_Real: return LibraryData::API()->MTensor_getRealData(t);
                case MType_Complex: return LibraryData::API()->MTensor_getComplexData(t);
                default: return nullptr;
            }
        }
 
    private:
        MTensor t = nullptr;
    };
 
    template<typename T>
    class TensorTypedView : public TensorView, public IterableContainer<T> {
    public:
        TensorTypedView() = default;
 
        TensorTypedView(const GenericTensor& gTen) : TensorView(gTen) {    // NOLINT: implicit conversion to a view is useful and harmless
            if (TensorType<T> != type()) {
                ErrorManager::throwException(ErrorName::TensorTypeError);
            }
        }
 
        TensorTypedView(TensorView tv) : TensorView(std::move(tv)) {    // NOLINT
            if (TensorType<T> != type()) {
                ErrorManager::throwException(ErrorName::TensorTypeError);
            }
        }
 
        TensorTypedView(MTensor mt) : TensorView(mt) {    // NOLINT
            if (TensorType<T> != type()) {
                ErrorManager::throwException(ErrorName::TensorTypeError);
            }
        }
 
    private:
        T* getData() const noexcept override {
            return static_cast<T*>(rawData());
        }
 
        mint getSize() const noexcept override {
            return getFlattenedLength();
        }
    };
 
    template<typename TensorT, typename F>
    auto asTypedTensor(TensorT&& t, F&& callable) {
        switch (t.type()) {
            case MType_Integer: return std::forward<F>(callable)(TensorTypedView<mint> {std::forward<TensorT>(t)});
            case MType_Real: return std::forward<F>(callable)(TensorTypedView<double> {std::forward<TensorT>(t)});
            case MType_Complex: return std::forward<F>(callable)(TensorTypedView<std::complex<double>> {std::forward<TensorT>(t)});
            default: ErrorManager::throwException(ErrorName::TensorTypeError);
        }
    }
 
    // Specialization of asTypedTensor for MTensor
    template<typename F>
    auto asTypedTensor(MTensor t, F&& callable) {
        return asTypedTensor(TensorView {t}, std::forward<F>(callable));
    }
}  // namespace LLU
 
#endif    // LLU_CONTAINERS_VIEWS_TENSOR_HPP