NumericArray.h

Go to the documentation of this file.

 
#ifndef LLU_CONTAINERS_NUMERICARRAY_H_
#define LLU_CONTAINERS_NUMERICARRAY_H_
 
#include <initializer_list>
#include <type_traits>
 
#include "LLU/Containers/Generic/NumericArray.hpp"
#include "LLU/Containers/MArray.hpp"
#include "LLU/LibraryData.h"
#include "LLU/Utilities.hpp"
 
namespace LLU {
 
    template<typename T>
    class TypedNumericArray : public MArray<T> {
    public:
        using MArray<T>::MArray;
    private:
        T* getData() const noexcept override {
            return static_cast<T*>(LibraryData::NumericArrayAPI()->MNumericArray_getData(this->getInternal()));
        }
 
        virtual MNumericArray getInternal() const = 0;
    };
 
    template<typename T>
    class NumericArray : public TypedNumericArray<T>, public GenericNumericArray {
    public:
        NumericArray(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 NumericArray(const Container& c) : NumericArray(c, {static_cast<mint>(c.size())}) {}
 
        template<class Container, typename = std::enable_if_t<is_iterable_container_with_matching_type_v<Container, T>>>
        NumericArray(const Container& c, MArrayDimensions dims) : NumericArray(std::begin(c), std::end(c), std::move(dims)) {}
 
        template<class InputIt, typename = enable_if_input_iterator<InputIt>>
        NumericArray(InputIt first, InputIt last);
 
        NumericArray(T init, MArrayDimensions dims);
 
        template<class InputIt, typename = enable_if_input_iterator<InputIt>>
        NumericArray(InputIt first, InputIt last, MArrayDimensions dims);
 
        NumericArray(MNumericArray na, Ownership owner);
 
        explicit NumericArray(GenericNumericArray na);
 
        explicit NumericArray(const GenericNumericArray& other, NA::ConversionMethod method, double param = 0.0);
 
        NumericArray() = default;
 
        NumericArray clone() const {
            return NumericArray {cloneContainer(), Ownership::Library};
        }
 
    private:
        using GenericBase = GenericNumericArray;
 
        MNumericArray getInternal() const noexcept override {
            return this->getContainer();
        }
    };
 
    template<typename T>
    NumericArray<T>::NumericArray(std::initializer_list<T> v) : NumericArray(std::begin(v), std::end(v), {static_cast<mint>(v.size())}) {}
 
    template<typename T>
    template<class InputIt, typename>
    NumericArray<T>::NumericArray(InputIt first, InputIt last) : NumericArray(first, last, {static_cast<mint>(std::distance(first, last))}) {}
 
    template<typename T>
    NumericArray<T>::NumericArray(T init, MArrayDimensions dims)
        : TypedNumericArray<T>(std::move(dims)), GenericBase(NumericArrayType<T>, this->rank(), this->dimensions().data()) {
        std::fill(this->begin(), this->end(), init);
    }
 
    template<typename T>
    template<class InputIt, typename>
    NumericArray<T>::NumericArray(InputIt first, InputIt last, MArrayDimensions dims)
        : TypedNumericArray<T>(std::move(dims)), GenericBase(NumericArrayType<T>, this->rank(), this->dimensions().data()) {
        if (std::distance(first, last) != this->getFlattenedLength()) {
            ErrorManager::throwException(ErrorName::NumericArrayNewError, "Length of data range does not match specified dimensions");
        }
        std::copy(first, last, this->begin());
    }
 
    template<typename T>
    NumericArray<T>::NumericArray(GenericBase na) : TypedNumericArray<T>({na.getDimensions(), na.getRank()}), GenericBase(std::move(na)) {
        if (NumericArrayType<T> != GenericBase::type()) {
            ErrorManager::throwException(ErrorName::NumericArrayTypeError);
        }
    }
 
    template<typename T>
    NumericArray<T>::NumericArray(MNumericArray na, Ownership owner) : NumericArray(GenericBase {na, owner}) {}
 
    template<typename T>
    NumericArray<T>::NumericArray(const GenericNumericArray& other, NA::ConversionMethod method, double param)
        : TypedNumericArray<T>({other.getDimensions(), other.getRank()}), GenericBase(other.convert(NumericArrayType<T>, method, param)) {}
 
} /* namespace LLU */
 
#endif /* LLU_CONTAINERS_NUMERICARRAY_H_ */