asr(2rheolef) [debian 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

vec(2rheolef)							    rheolef-6.1 						     vec(2rheolef)

NAME

       vec - vector in distributed environment (rheolef-6.1)

SYNOPSYS

       STL-like vector container for a sequential or distributed memory machine model.	Additional operation fom classical algebra.

EXAMPLE

       A sample usage of the class is:

	    int main(int argc, char**argv) {
	       environment distributed(argc, argv);
	       vec<double> x(100, 3.14);
	       dout << x << endl;
	    }

IMPLEMENTATION NOTE

       Implementation use array<T,M>.

IMPLEMENTATION

       template <class T, class M = rheo_default_memory_model>
       class vec : public array<T, M> {
       public:

       // typedef:

	   typedef array<T, M> base;
	   typedef typename base::size_type			    size_type;
	   typedef std::ptrdiff_t				    difference_type;
       #ifdef TODO
	   // pb compile avec boost sur foehn:
	   typedef typename base::difference_type		    difference_type;
       #endif // TODO
	   typedef basic_range<size_type, difference_type>	    range_type;
	   typedef typename base::reference			    reference;
	   typedef typename base::const_reference		    const_reference;
	   typedef typename base::iterator			    iterator;
	   typedef typename base::const_iterator		    const_iterator;

       // allocator/deallocator:

	   vec (const distributor& ownership,
	       const T&  init_val = std::numeric_limits<T>::max());

	   vec(size_type dis_size = 0,
	       const T&  init_val = std::numeric_limits<T>::max());

	   void resize (
	       const distributor& ownership,
	       const T&  init_val = std::numeric_limits<T>::max());

	   void resize (
	       size_type size = 0,
	       const T&  init_val = std::numeric_limits<T>::max());

       // accessors:

	   const_reference operator[] (size_type i) const;
	   reference	   operator[] (size_type i);

	   T max_abs () const;

       // range:

	   vec(const vec_range<T,M>& vr);
	   vec(const vec_range_const<T,M>& vr);
	   vec<T,M>& operator= (const vec_range<T,M>& vr);
	   vec<T,M>& operator= (const vec_range_const<T,M>& vr);

	   vec_range_const<T,M> operator[] (const range_type& r) const;
	   vec_range<T,M>	operator[] (const range_type& r);

       // assignment to a constant:

	   vec<T,M>& operator= (const int& expr);
	   vec<T,M>& operator= (const T& expr);

       // expression template:

	   template<typename Expr>
	   vec (const Expr& expr);

	   template<typename Expr>
	   vec<T,M>& operator= (const vec_expr<Expr>& expr);

	   template<typename Expr>
	   vec<T,M>& operator+= (const Expr& expr);

	   template<typename Expr>
	   vec<T,M>& operator-= (const Expr& expr);

       // initializer list (c++ 2011):

       #ifdef _RHEOLEF_HAVE_STD_INITIALIZER_LIST
	   vec (const std::initializer_list<vec_concat_value<T,M> >& init_list);
	   vec<T,M>& operator= (const std::initializer_list<vec_concat_value<T,M> >& init_list);
       #endif // _RHEOLEF_HAVE_STD_INITIALIZER_LIST
       };

rheolef-6.1							    rheolef-6.1 						     vec(2rheolef)

Linux and UNIX Man Pages

asr(2rheolef) [debian man page]

Check Out this Related Man Page