distributor - memory distribution table (rheolef-7.2)

       Pierre  Saramito  <Pierre.Saramito@imag.fr>

       Copyright   (C)  2000-2018  Pierre  Saramito  <Pierre.Saramito@imag.fr> GPLv3+: GNU GPL version 3 or
       later  <http://gnu.org/licenses/gpl.html>.  This  is  free  software:  you  are free to change and
       redistribute it.  There is NO WARRANTY, to the extent permitted by law.

rheolef                                            Version 7.2                             distributor(4rheolef)

       Given an array size, this class decides which process will own which part of a distributed memory array
       such as disarray(4).

           distributor ownership (100);

       This documentation has been generated from file linalg/lib/distributor.h

       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;

               size_type dis_size () const;

               size_type process () const;

               size_type n_process () const;

               size_type find_owner (size_type dis_i) const;

               size_type first_index (size_type iproc) const;
               size_type last_index (size_type iproc) const;
               size_type size (size_type iproc) const;

               size_type first_index () const;
               size_type last_index () const;
               size_type size () const;

               bool is_owned (size_type dis_i, size_type iproc) const;

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

               static tag_type get_new_tag();

       // comparators:

               bool operator== (const distributor&) const;
               bool operator!= (const distributor&) const;

       };

       distributor - memory distribution table (rheolef-7.2)

       Ambiguous use of size() and dis_size(). Here size() refers to n_process(), while size(iproc) and
       dis_size() refer to the size of the index ranges. Then, size() should be avoided, and we should use
       n_process() instead.