tensor4(2rheolef) [debian man page]

tensor4(2rheolef)						    rheolef-6.1 						 tensor4(2rheolef)

NAME

       tensor4 - a fouth order tensor

SYNOPSYS

       The tensor4 class defines a fourth tensor where indices varie from zero to 2 (aka 3D physical space).

IMPLEMENTATION

       template<class T>
       class tensor4_basic {
       public:

	 typedef size_t size_type;
	 typedef T	element_type;

       // allocators:

	 tensor4_basic (const T& init_val = 0);
	 tensor4_basic (const tensor4_basic<T>& a);

       // affectation:

	 tensor4_basic<T>& operator= (const tensor4_basic<T>& a);
	 tensor4_basic<T>& operator= (const T& val);

       // accessors:

	 T&	  operator()(size_type i, size_type j, size_type k, size_type l);
	 const T& operator()(size_type i, size_type j, size_type k, size_type l) const;

       // data:
       protected:
	 T _x [3][3][3][3];
       };
       typedef tensor4_basic<Float> tensor4;

rheolef-6.1							    rheolef-6.1 						 tensor4(2rheolef)

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)