asr(2rheolef) [linux man page]

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)

Check Out this Related Man Page

distributor(2rheolef)						    rheolef-6.1 					     distributor(2rheolef)

NAME

       distributor - data distribution table (rheolef-6.1)

SYNOPSYS

       Used by "array"(1), "asr"(1) and "csr"(1).  and such classes that distribute data as chunk.

IMPLEMENTATION

       class distributor : public Vector<std::allocator<int>::size_type> {
       public:

       // typedefs:

	       typedef std::allocator<int>::size_type size_type;
	       typedef Vector<size_type>	      _base;
	       typedef _base::iterator		      iterator;
	       typedef _base::const_iterator	      const_iterator;
	       typedef int			      tag_type;
	       typedef communicator		      communicator_type;

       // constants:

	       static const size_type decide = size_type(-1);

       // allocators/deallocators:

	       distributor(
		       size_type dis_size = 0,
		       const communicator_type& c = communicator_type(),
		       size_type loc_size = decide);

	       distributor(const distributor&);
	       ~distributor();

	       void resize(
		       size_type dis_size = 0,
		       const communicator_type& c = communicator_type(),
		       size_type loc_size = decide);

       // accessors:

	       const communicator_type& comm() const;

	       /// global and local sizes
	       size_type dis_size () const;

	       /// current process id
	       size_type process () const;

	       /// number of processes
	       size_type n_process () const;

	       /// find iproc associated to a global index dis_i: CPU=log(nproc)
	       size_type find_owner (size_type dis_i) const;

	       /// global index range and local size owned by ip-th process
	       size_type first_index (size_type ip) const;
	       size_type last_index (size_type ip) const;
	       size_type size (size_type ip) const;

	       /// global index range and local size owned by current process
	       size_type first_index () const;
	       size_type last_index () const;
	       size_type size () const;

	       /// true when dis_i in [first_index(ip):last_index(ip)[
	       bool is_owned (size_type dis_i, size_type ip) const;

	       // the same with ip=current process
	       bool is_owned (size_type dis_i) const;

	       /// returns a new tag
	       static tag_type get_new_tag();

       // comparators:

	       bool operator== (const distributor&) const;
	       bool operator!= (const distributor&) const;
       // data:
       protected:
	       communicator_type _comm;
       };

rheolef-6.1							    rheolef-6.1 					     distributor(2rheolef)

Linux and UNIX Man Pages

asr(2rheolef) [linux man page]

Check Out this Related Man Page