Tensor.h

Go to the documentation of this file.

 
#ifndef LLU_CONTAINERS_TENSOR_H_
#define LLU_CONTAINERS_TENSOR_H_
 
#include <initializer_list>
#include <type_traits>
 
#include "LLU/Containers/Generic/Tensor.hpp"
#include "LLU/Containers/MArray.hpp"
#include "LLU/LibraryData.h"
#include "LLU/Utilities.hpp"
 
namespace LLU {
 
    template<typename T>
    class TypedTensor : public MArray<T> {
    public:
        using MArray<T>::MArray;
    private:
        T* getData() const noexcept override;
 
        virtual MTensor getInternal() const = 0;
    };
 
    template<typename T>
    class Tensor : public TypedTensor<T>, public GenericTensor {
    public:
        Tensor(std::initializer_list<T> v);
 
        template<class Container, typename = std::enable_if_t<is_iterable_container_with_matching_type_v<Container, T> && has_size_v<Container>>>
        explicit Tensor(const Container& c) : Tensor(c, {static_cast<mint>(c.size())}) {}
 
        template<class Container, typename = std::enable_if_t<is_iterable_container_with_matching_type_v<Container, T>>>
        Tensor(const Container& c, MArrayDimensions dims) : Tensor(std::begin(c), std::end(c), std::move(dims)) {}
 
        template<class InputIt, typename = enable_if_input_iterator<InputIt>>
        Tensor(InputIt first, InputIt last);
 
        Tensor(T init, MArrayDimensions dims);
 
        template<class InputIt, typename = enable_if_input_iterator<InputIt>>
        Tensor(InputIt first, InputIt last, MArrayDimensions dims);
 
        Tensor(MTensor t, Ownership owner);
 
        explicit Tensor(GenericTensor t);
 
        Tensor() = default;
 
        Tensor clone() const {
            return Tensor {cloneContainer(), Ownership::Library};
        }
    private:
        using GenericBase = MContainer<MArgumentType::Tensor>;
 
        MTensor getInternal() const noexcept override {
            return this->getContainer();
        }
    };
 
    template<typename T>
    Tensor<T>::Tensor(std::initializer_list<T> v) : Tensor(std::begin(v), std::end(v), {static_cast<mint>(v.size())}) {}
 
    template<typename T>
    template<class InputIt, typename>
    Tensor<T>::Tensor(InputIt first, InputIt last) : Tensor(first, last, {static_cast<mint>(std::distance(first, last))}) {}
 
    template<typename T>
    Tensor<T>::Tensor(T init, MArrayDimensions dims)
        : TypedTensor<T>(std::move(dims)), GenericBase(TensorType<T>, this->rank(), this->dimensions().data()) {
        std::fill(this->begin(), this->end(), init);
    }
 
    template<typename T>
    template<class InputIt, typename>
    Tensor<T>::Tensor(InputIt first, InputIt last, MArrayDimensions dims)
        : TypedTensor<T>(std::move(dims)), GenericBase(TensorType<T>, this->rank(), this->dimensions().data()) {
        if (std::distance(first, last) != this->getFlattenedLength()) {
            ErrorManager::throwException(ErrorName::TensorNewError, "Length of data range does not match specified dimensions");
        }
        std::copy(first, last, this->begin());
    }
 
    template<typename T>
    Tensor<T>::Tensor(GenericBase t) : TypedTensor<T>({t.getDimensions(), t.getRank()}), GenericBase(std::move(t)) {
        if (TensorType<T> != GenericBase::type()) {
            ErrorManager::throwException(ErrorName::TensorTypeError);
        }
    }
 
    template<typename T>
    Tensor<T>::Tensor(MTensor t, Ownership owner) : Tensor(GenericBase {t, owner}) {}
 
 
} /* namespace LLU */
 
#endif /* LLU_CONTAINERS_TENSOR_H_ */