SparseCompressed< Scalar_t, Options_ > Class Template Reference

Collaboration diagram for SparseCompressed< Scalar_t, Options_ >:

Public Types
typedef Scalar_t	Scalar
typedef Eigen::NumTraits< Scalar_t >::Real	RealScalar

Public Member Functions
__host__ __device__	SparseCompressed ()
__host__ __device__	SparseCompressed (int rows, int cols)
__host__ __device__	SparseCompressed (SparseCompressed const &other)
template<typename Scalar_ >
__host__ __device__	SparseCompressed (SparseCompressed< Scalar_, Options_ > const &other)
template<class Derived >
__host__	SparseCompressed (Eigen::SparseMatrixBase< Derived > &other)
template<typename Derived >
__host__	SparseCompressed (Eigen::ReturnByValue< Derived > const &other)
__host__ __device__ int &	rows ()
__host__ __device__ int	rows () const
__host__ __device__ int &	cols ()
__host__ __device__ int	cols () const
__host__ __device__ int	reserved () const
__host__ __device__ int	outerSize () const
__host__ __device__ int	innerSize () const
__host__ __device__ int &	setNonZeros (int input)
__host__ __device__ int	nonZeros () const
__host__ __device__ int *	outerIndexPtr () const
__host__ __device__ int *	innerIndexPtr () const
__host__ __device__ Scalar_t *	valuePtr () const
template<typename NewScalar >
__host__ __device__ SparseCompressed< NewScalar, Options_ >	cast () const
__host__ __device__ SparseCompressed	adjoint () const
Storage management
__host__ __device__	~SparseCompressed ()
__host__ __device__ void	resize (int rows, int cols, int reserved=1)
__host__ __device__ void	conservativeResize (Integer_t row, Integer_t col)

Static Public Attributes
static constexpr bool	IsRowMajor = bool(Options_ == Eigen::RowMajor)

Private Attributes
int	m_outerSize = -1
int	m_innerSize = -1
int	m_numNonZeros = 0
int *	m_outerIndex = nullptr
int *	m_innerIndex = nullptr
Scalar_t *	m_value = nullptr
int	m_reserved = 0

Static Private Attributes
static constexpr Eigen::StorageOptions	m_scheme = Options_

Operator overloads
__host__ __device__ SparseCompressed &	operator= (SparseCompressed const &other)
__host__ __device__ SparseCompressed &	operator= (SparseCompressed &&other)
__host__ friend std::ostream &	operator<< (std::ostream &os, SparseCompressed const &sparseMat)

Member Typedef Documentation

RealScalar

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

typedef Eigen::NumTraits<Scalar_t>::Real SparseCompressed< Scalar_t, Options_ >::RealScalar

Scalar

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

typedef Scalar_t SparseCompressed< Scalar_t, Options_ >::Scalar

Constructor & Destructor Documentation

SparseCompressed() [1/6]

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ SparseCompressed< Scalar_t, Options_ >::SparseCompressed ( )

inline

{ debug_constructor_printf(1); }

SparseCompressed() [2/6]

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ SparseCompressed< Scalar_t, Options_ >::SparseCompressed ( int  rows, int  cols  )

inline

                                                                 {
            debug_constructor_printf(2);
            this->resize(rows, cols);
        }

SparseCompressed() [3/6]

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ SparseCompressed< Scalar_t, Options_ >::SparseCompressed ( SparseCompressed< Scalar_t, Options_ > const &  other )

inline

                                                                            {
            debug_constructor_printf(3 - a(Copy));
            this->resize(other.rows(), other.cols(), other.nonZeros());
            m_numNonZeros = other.nonZeros();
            memcpy(m_outerIndex, other.outerIndexPtr(), (m_outerSize + 1) * sizeof(int));
            memcpy(m_innerIndex, other.innerIndexPtr(), m_numNonZeros * sizeof(int));
            memcpy(m_value, other.valuePtr(), m_numNonZeros * sizeof(Scalar_t));
        }

SparseCompressed() [4/6]

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

template<typename Scalar_ >

__host__ __device__ SparseCompressed< Scalar_t, Options_ >::SparseCompressed ( SparseCompressed< Scalar_, Options_ > const &  other )

inline

                                                                                               {
            debug_constructor_printf(3 - b(Copy));
            this->resize(other.rows(), other.cols(), other.nonZeros());
            m_numNonZeros = other.nonZeros();
            memcpy(m_outerIndex, other.outerIndexPtr(), (m_outerSize + 1) * sizeof(int));
            memcpy(m_innerIndex, other.innerIndexPtr(), m_numNonZeros * sizeof(int));
 
            Scalar_t* valuePtr;
            cuCHECK(cudaMalloc((void**)&valuePtr, m_numNonZeros * sizeof(Scalar_t)));
            for(int j = 0; j != m_numNonZeros; ++j)
                valuePtr[j] = static_cast<Scalar_t>(other.valuePtr()[j]);
            memcpy(m_value, valuePtr, m_numNonZeros * sizeof(Scalar_t));
            cuCHECK(cudaFree(valuePtr));
        }

SparseCompressed() [5/6]

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

template<class Derived >

__host__ SparseCompressed< Scalar_t, Options_ >::SparseCompressed ( Eigen::SparseMatrixBase< Derived > &  other )

inline

                                                                         {
            debug_constructor_printf(4(Copy));
            other.makeCompressed();
            this->resize(other.rows(), other.cols(), other.nonZeros());
            m_numNonZeros = other.nonZeros();
            memcpy(m_outerIndex, other.outerIndexPtr(), (m_outerSize + 1) * sizeof(int));
            memcpy(m_innerIndex, other.innerIndexPtr(), m_numNonZeros * sizeof(int));
            memcpy(m_value, other.valuePtr(), m_numNonZeros * sizeof(Scalar_t));
        }

SparseCompressed() [6/6]

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

template<typename Derived >

__host__ SparseCompressed< Scalar_t, Options_ >::SparseCompressed ( Eigen::ReturnByValue< Derived > const &  other )

inline

            : SparseCompressed(other.eval()) {
            debug_constructor_printf(5(Copy from expression));
        }

~SparseCompressed()

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ SparseCompressed< Scalar_t, Options_ >::~SparseCompressed ( )

inline

                                                {
            cuCHECK(cudaFree(m_outerIndex));
            cuCHECK(cudaFree(m_innerIndex));
            cuCHECK(cudaFree(m_value));
        }

Member Function Documentation

adjoint()

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ SparseCompressed SparseCompressed< Scalar_t, Options_ >::adjoint ( ) const

inline

                                                             {
            debug_printf("%s\n", __PRETTY_FUNCTION__);
            SparseCompressed res;
            res.resize(this->cols(), this->rows(), this->nonZeros());
            res.setNonZeros(this->nonZeros());
            for(int j = 0; j != this->outerSize(); ++j) {
                for(int k = this->outerIndexPtr()[j]; k != this->outerIndexPtr()[j + 1]; ++k) {
                    // debug_printf("\t res.innerIndexPtr()[%d] = %d\n", k, j);
                    res.innerIndexPtr()[k] = j;
                }
            }
            Eigen::ArrayX<int> resOuterIndex(res.nonZeros());
            for(int j = 0; j != this->nonZeros(); ++j) {
                resOuterIndex(j)  = this->innerIndexPtr()[j];
                res.valuePtr()[j] = conj(this->valuePtr()[j]);
            }
 
#ifdef __CUDA_ARCH__
            Eigen::ArrayX<int> resOuterIndexCpy(resOuterIndex);
            thrust::sort_by_key(thrust::seq, resOuterIndexCpy.data(),
                                resOuterIndexCpy.data() + res.nonZeros(), res.valuePtr());
            thrust::sort_by_key(thrust::seq, resOuterIndex.data(),
                                resOuterIndex.data() + res.nonZeros(), res.innerIndexPtr());
#else
            Eigen::ArrayX< std::tuple<int, int, Scalar_t> > data(res.nonZeros());
    #pragma omp parallel
            {
    #pragma omp for
                for(int j = 0; j < res.nonZeros(); ++j) {
                    data(j) = std::tuple<int, int, Scalar_t>(
                        resOuterIndex(j), res.innerIndexPtr()[j], res.valuePtr()[j]);
                }
    #pragma omp single
                std::sort(data.data(), data.data() + res.nonZeros(),
                          [](auto& lhs, auto& rhs) { return std::get<0>(lhs) < std::get<0>(rhs); });
    #pragma omp for
                for(int j = 0; j < res.nonZeros(); ++j) {
                    resOuterIndex(j)       = std::get<0>(data(j));
                    res.innerIndexPtr()[j] = std::get<1>(data(j));
                    res.valuePtr()[j]      = std::get<2>(data(j));
                }
            }
#endif
 
            int prev                             = 0;
            res.outerIndexPtr()[0]               = 0;
            res.outerIndexPtr()[res.outerSize()] = res.nonZeros();
            for(int count = 0; count != res.nonZeros(); ++count) {
                if(prev != resOuterIndex(count)) {
                    assert(resOuterIndex(count) < res.nonZeros()
                           && "Out of bounds for resOuterIndex.");
                    for(int j = prev + 1; j != resOuterIndex(count); ++j) {
                        res.outerIndexPtr()[j] = res.outerIndexPtr()[prev];
                    }
                    res.outerIndexPtr()[resOuterIndex(count)] = count;
                }
                prev = resOuterIndex(count);
            }
            return res;
        }

cast()

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

template<typename NewScalar >

__host__ __device__ SparseCompressed< NewScalar, Options_ > SparseCompressed< Scalar_t, Options_ >::cast ( ) const

inline

                                                                               {
            if constexpr(std::is_same_v<Scalar, NewScalar>) return *this;
            return SparseCompressed<NewScalar, Options_>(*this);
        }

cols() [1/2]

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ int & SparseCompressed< Scalar_t, Options_ >::cols ( )

inline

                                        {
            if constexpr(IsRowMajor) { return m_innerSize; }
            return m_outerSize;
        }

cols() [2/2]

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ int SparseCompressed< Scalar_t, Options_ >::cols ( ) const

inline

                                             {
            if constexpr(IsRowMajor) { return m_innerSize; }
            return m_outerSize;
        }

conservativeResize()

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ void SparseCompressed< Scalar_t, Options_ >::conservativeResize ( Integer_t  row, Integer_t  col  )

inline

                                                                                  {
            debug_printf("%s: For compatibility to Eigen's interface. Does nothing for now.\n\n",
                         __PRETTY_FUNCTION__);
            return;
        };

innerIndexPtr()

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ int * SparseCompressed< Scalar_t, Options_ >::innerIndexPtr ( ) const

inline

{ return m_innerIndex; }

innerSize()

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ int SparseCompressed< Scalar_t, Options_ >::innerSize ( ) const

inline

{ return m_innerSize; }

nonZeros()

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ int SparseCompressed< Scalar_t, Options_ >::nonZeros ( ) const

inline

{ return m_numNonZeros; }

operator=() [1/2]

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ SparseCompressed & SparseCompressed< Scalar_t, Options_ >::operator= ( SparseCompressed< Scalar_t, Options_ > &&  other )

inline

                                                                                  {
            debug_printf("%s:\n\tMove assignment operator\n", __PRETTY_FUNCTION__);
            delete[] m_outerIndex;
            delete[] m_innerIndex;
            delete[] m_value;
 
            m_outerSize   = other.m_outerSize;
            m_innerSize   = other.m_innerSize;
            m_numNonZeros = other.m_numNonZeros;
            m_reserved    = other.m_reserved;
            m_outerIndex  = other.m_outerIndex;
            m_innerIndex  = other.m_innerIndex;
            m_value       = other.m_value;
 
            other.m_outerIndex = nullptr;
            other.m_innerIndex = nullptr;
            other.m_value      = nullptr;
            return *this;
        }

operator=() [2/2]

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ SparseCompressed & SparseCompressed< Scalar_t, Options_ >::operator= ( SparseCompressed< Scalar_t, Options_ > const &  other )

inline

                                                                                       {
            debug_printf("%s: Copy assignment operator\n", __PRETTY_FUNCTION__);
            this->resize(other.rows(), other.cols(), other.nonZeros());
            m_numNonZeros = other.m_numNonZeros;
            memcpy(m_outerIndex, other.m_outerIndex, (m_outerSize + 1) * sizeof(int));
            memcpy(m_innerIndex, other.m_innerIndex, m_numNonZeros * sizeof(int));
            memcpy(m_value, other.m_value, m_numNonZeros * sizeof(Scalar_t));
            return *this;
        }

outerIndexPtr()

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ int * SparseCompressed< Scalar_t, Options_ >::outerIndexPtr ( ) const

inline

{ return m_outerIndex; }

outerSize()

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ int SparseCompressed< Scalar_t, Options_ >::outerSize ( ) const

inline

{ return m_outerSize; }

reserved()

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ int SparseCompressed< Scalar_t, Options_ >::reserved ( ) const

inline

{ return m_reserved; }

resize()

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ void SparseCompressed< Scalar_t, Options_ >::resize ( int  rows, int  cols, int  reserved = 1  )

inline

                                                                              {
            debug_printf("%s\n", __PRETTY_FUNCTION__);
            assert(rows >= 0 && cols >= 0 && reserved >= 1);
            int outerDim, innerDim;
            if constexpr(IsRowMajor) {
                outerDim = rows;
                innerDim = cols;
            }
            else {
                outerDim = cols;
                innerDim = rows;
            }
 
            if(outerDim > m_outerSize) {
                m_outerSize = outerDim;
                cuCHECK(cudaFree(m_outerIndex));
                cuCHECK(cudaMalloc((void**)&m_outerIndex, (m_outerSize + 1) * sizeof(int)));
                memset(m_outerIndex, 0, (m_outerSize + 1) * sizeof(int));
            }
            if(reserved > m_reserved) {
                m_reserved = reserved;
                cuCHECK(cudaFree(m_innerIndex));
                cuCHECK(cudaFree(m_value));
                cuCHECK(cudaMalloc((void**)&m_innerIndex, m_reserved * sizeof(int)));
                cuCHECK(cudaMalloc((void**)&m_value, m_reserved * sizeof(Scalar_t)));
                m_innerIndex[0] = 0;
                m_value[0]      = {0, 0};
            }
 
            m_outerSize   = outerDim;
            m_innerSize   = innerDim;
            m_numNonZeros = 0;
            return;
        }

rows() [1/2]

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ int & SparseCompressed< Scalar_t, Options_ >::rows ( )

inline

                                        {
            if constexpr(IsRowMajor) { return m_outerSize; }
            return m_innerSize;
        }

rows() [2/2]

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ int SparseCompressed< Scalar_t, Options_ >::rows ( ) const

inline

                                             {
            if constexpr(IsRowMajor) { return m_outerSize; }
            return m_innerSize;
        }

setNonZeros()

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ int & SparseCompressed< Scalar_t, Options_ >::setNonZeros ( int  input )

inline

{ return m_numNonZeros = input; }

valuePtr()

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ __device__ Scalar_t * SparseCompressed< Scalar_t, Options_ >::valuePtr ( ) const

inline

{ return m_value; }

Friends And Related Symbol Documentation

operator<<

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

__host__ friend std::ostream & operator<< ( std::ostream &  os, SparseCompressed< Scalar_t, Options_ > const &  sparseMat  )

friend

                                                                                    {
            assert(sparseMat.m_numNonZeros <= sparseMat.m_reserved
                   && "Failed: sparseMat.m_numNonZeros <= sparseMat.m_reserved");
            Eigen::Map< Eigen::SparseMatrix<Scalar_t, Options_> > map(
                sparseMat.rows(), sparseMat.cols(), sparseMat.m_numNonZeros, sparseMat.m_outerIndex,
                sparseMat.m_innerIndex, sparseMat.m_value);
            os << Eigen::MatrixX<Scalar_t>(map);
            return os;
        }

Member Data Documentation

IsRowMajor

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

constexpr bool SparseCompressed< Scalar_t, Options_ >::IsRowMajor = bool(Options_ == Eigen::RowMajor)

staticconstexpr

m_innerIndex

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

int* SparseCompressed< Scalar_t, Options_ >::m_innerIndex = nullptr

private

m_innerSize

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

int SparseCompressed< Scalar_t, Options_ >::m_innerSize = -1

private

m_numNonZeros

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

int SparseCompressed< Scalar_t, Options_ >::m_numNonZeros = 0

private

m_outerIndex

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

int* SparseCompressed< Scalar_t, Options_ >::m_outerIndex = nullptr

private

m_outerSize

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

int SparseCompressed< Scalar_t, Options_ >::m_outerSize = -1

private

m_reserved

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

int SparseCompressed< Scalar_t, Options_ >::m_reserved = 0

private

m_scheme

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

constexpr Eigen::StorageOptions SparseCompressed< Scalar_t, Options_ >::m_scheme = Options_

staticconstexprprivate

m_value

template<typename Scalar_t = Complex_t<Real_t>, Eigen::StorageOptions Options_ = Eigen::ColMajor>

Scalar_t* SparseCompressed< Scalar_t, Options_ >::m_value = nullptr

private

---

The documentation for this class was generated from the following file:

• /Users/shoki/GitHub/Locality/Headers/MatrixUtils/MatrixUtils.cuh