asr(2rheolef)							    rheolef-6.1 						     asr(2rheolef)

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);

rheolef-6.1							    rheolef-6.1 						     asr(2rheolef)