SparseArray.h

Go to the documentation of this file.

 
#ifndef LLU_CONTAINERS_SPARSEARRAY_H
#define LLU_CONTAINERS_SPARSEARRAY_H
 
#include "LLU/Containers/Generic/SparseArray.hpp"
#include "LLU/Containers/Tensor.h"
 
namespace LLU {
 
    template<typename T>
    class SparseArray : public GenericSparseArray {
    public:
        using value_type = T;
 
        SparseArray() = default;
 
        SparseArray(MSparseArray t, Ownership owner);
 
        explicit SparseArray(GenericSparseArray t);
 
        SparseArray(const Tensor<mint>& positions, const Tensor<T>& values, const Tensor<mint>& dimensions, T implicitValue);
 
        SparseArray(const Tensor<T>& data, T implicitValue);
 
        SparseArray(const SparseArray& s, T implicitValue);
 
        mint rank() const {
            return getRank();
        }
 
        T implicitValue() const;
 
        void setImplicitValue(T newImplicitValue);
 
        Tensor<T> explicitValues() const;
 
        Tensor<mint> rowPointers() const;
 
        Tensor<mint> columnIndices() const;
 
        [[nodiscard]] Tensor<mint> explicitPositions() const;
 
        [[nodiscard]] Tensor<T> toTensor() const;
    };
 
    template<typename F>
    auto asTypedSparseArray(const GenericSparseArray& sa, F&& callable) {
        switch (sa.type()) {
            case MType_Integer: return std::forward<F>(callable)(SparseArray<mint> {sa.getContainer(), Ownership::LibraryLink});
            case MType_Real: return std::forward<F>(callable)(SparseArray<double> {sa.getContainer(), Ownership::LibraryLink});
            case MType_Complex: return std::forward<F>(callable)(SparseArray<std::complex<double>> {sa.getContainer(), Ownership::LibraryLink});
            default: ErrorManager::throwException(ErrorName::SparseArrayTypeError);
        }
    }
 
    // Overload of asTypedSparseArray for MSparseArray
    template<typename F>
    auto asTypedSparseArray(MSparseArray t, F&& callable) {
        return asTypedSparseArray(GenericSparseArray {t, Ownership::LibraryLink}, std::forward<F>(callable));
    }
 
    template<typename T>
    SparseArray<T>::SparseArray(GenericSparseArray t) : GenericSparseArray(std::move(t)) {
        if (TensorType<T> != GenericSparseArray::type()) {
            ErrorManager::throwException(ErrorName::SparseArrayTypeError);
        }
    }
 
    template<typename T>
    SparseArray<T>::SparseArray(MSparseArray t, Ownership owner) : SparseArray(GenericSparseArray {t, owner}) {}
 
    template<typename T>
    SparseArray<T>::SparseArray(const Tensor<mint>& positions, const Tensor<T>& values, const Tensor<mint>& dimensions, T implicitValue) :
        GenericSparseArray(positions, values, dimensions, Tensor<T>(implicitValue, {})){}
 
    template<typename T>
    SparseArray<T>::SparseArray(const Tensor<T>& data, T implicitValue) : GenericSparseArray(data, Tensor<T>(implicitValue, {})) {}
 
 
    template<typename T>
    SparseArray<T>::SparseArray(const SparseArray& s, T implicitValue) : GenericSparseArray(s, Tensor<T>(implicitValue, {})) {}
 
    template<typename T>
    T SparseArray<T>::implicitValue() const {
        return Tensor<T> {GenericSparseArray::getImplicitValueAsTensor()}.front();
    }
 
    template<typename T>
    void SparseArray<T>::setImplicitValue(T newImplicitValue) {
        GenericSparseArray::setImplicitValueFromTensor(Tensor<T>(newImplicitValue, {}));
    }
 
    template<typename T>
    Tensor<T> SparseArray<T>::explicitValues() const {
        return Tensor<T> {GenericSparseArray::getExplicitValues()};
    }
 
    template<typename T>
    Tensor<mint> SparseArray<T>::rowPointers() const {
        return Tensor<mint> {MContainer::getRowPointers()};
    }
    template<typename T>
    Tensor<mint> SparseArray<T>::columnIndices() const {
        return Tensor<mint> {MContainer::getColumnIndices()};
    }
    template<typename T>
    Tensor<mint> SparseArray<T>::explicitPositions() const {
        return Tensor<mint> {MContainer::getExplicitPositions()};
    }
    template<typename T>
    Tensor<T> SparseArray<T>::toTensor() const {
        return Tensor<T> {MContainer::toGenericTensor()};
    }
 
    
} // namespace LLU
 
#endif    // LLU_CONTAINERS_SPARSEARRAY_H