NAME

       distributor - data distribution table (rheolef-6.7)

SYNOPSYS

       Used  by  "disarray"(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;
       };