NAME¶

asr - associative sparse matrix (rheolef-6.1)

SYNOPSYS¶

Associative sparse matrix container stored row by row
using the STL map class.

IMPLEMENTATION NOTE¶

Implementation use MPI-1.1 and is inspired from Mat_MPI in PETSc-2.0.22.

TO DO¶

For efficiency purpose, the assembly phase may access directly to the asr representation, without crossing the reference counting and pointer handler. Something like the iterator for dense vectors.

IMPLEMENTATION¶

template<class R>
class basic_asr : public smart_pointer<R> {
public:

// typedefs:

    typedef typename R::size_type          size_type;
    typedef typename R::element_type       element_type;
    typedef typename R::memory_type        memory_type;
    typedef distributor::communicator_type communicator_type;

// allocators/deallocators:

    basic_asr (size_type dis_nrow = 0, size_type dis_ncol = 0);
    basic_asr (const distributor& row_ownership, const distributor& col_ownership);
    explicit basic_asr (const csr<element_type,memory_type>&);

// accessors:

    const communicator_type& comm() const;

    // local sizes
    size_type nrow () const;
    size_type ncol () const;
    size_type nnz () const;

    // global sizes
    size_type dis_nrow () const;
    size_type dis_ncol () const;
    size_type dis_nnz () const;
    const distributor& row_ownership() const;
    const distributor& col_ownership() const;

    // range on local memory
    size_type row_first_index () const;
    size_type row_last_index () const;
    size_type col_first_index () const;
    size_type col_last_index () const;

// global modifiers:

    element_type& dis_entry (size_type dis_i, size_type dis_j);
    void dis_entry_assembly();
    void dis_entry_assembly_begin ();
    void dis_entry_assembly_end ();
    void resize (size_type dis_nrow = 0, size_type dis_ncol = 0);

// output:

    void dump (const std::string& name) const;
};
template <class T, class M = rheo_default_memory_model>
class asr
{
    typedef M memory_type;
};
template <class T>
class asr<T,sequential> : public basic_asr<asr_seq_rep<T> > {
public:
    typedef typename basic_asr<asr_seq_rep<T> >::size_type size_type;
    typedef sequential memory_type;
    asr (size_type dis_nrow = 0, size_type dis_ncol = 0);
    asr (const distributor& row_ownership, const distributor& col_ownertship);
    explicit asr(const csr<T,memory_type>&);
};
#ifdef _RHEOLEF_HAVE_MPI
template <class T>
class asr<T,distributed> : public basic_asr<asr_mpi_rep<T> > {
public:
    typedef distributed memory_type;
    typedef typename basic_asr<asr_mpi_rep<T> >::size_type size_type;
    asr (size_type dis_nrow = 0, size_type dis_ncol = 0);
    asr (const distributor& row_ownership, const distributor& col_ownertship);
    explicit asr(const csr<T,memory_type>&);
};
#endif // _RHEOLEF_HAVE_MPI

// inputs/outputs:
template <class T, class M>
idiststream& operator >> (idiststream& s, asr<T,M>& x);

template <class T, class M>
odiststream& operator << (odiststream& s, const asr<T,M>& x);