Add generation of documentation

.gitignore

@@ -0,0 +1,38 @@
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+# doxygen generation
+docs/
+
+# MacOS specific
+**/.DS_Store

README.md

@@ -212,6 +212,17 @@ See example for [Fortran](examples/Fortran/CMakeLists.txt) and [C++](examples/CX
 **NOTE:** The library does not provide ILP64 support.
 
 
+## Building documentation
+
+To build documentation, you need to have installed [doxygen](https://www.doxygen.nl/index.html).
+
+With installed `doxygen`, run:
+```console
+doxygen DOXYGEN
+```
+to build documentation in html and latex formats.
+
+
 ## Notes about MPI implementations
 
 ### OpenMPI

src/CXX/SLB4MPI/SLB4MPI/abstract_load_balancer.hpp

@@ -30,11 +30,11 @@ namespace SLB4MPI {
        *
        * @brief initialize default values of abstract load balancer
        *
-       * @param[in]           communicator   - MPI communicator on which load balancer will be used
-       * @param[in]           lower_bound    - lower bound of range
-       * @param[in]           upper_bound    - upper bound of range, upper_bound >= lower_bound
-       * @param[in, optional] min_chunk_size - minimal size of chank that can be associated with job, default: 1
-       * @param[in, optional] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
+       * @param[in] communicator   - MPI communicator on which load balancer will be used
+       * @param[in] lower_bound    - lower bound of range
+       * @param[in] upper_bound    - upper bound of range, upper_bound >= lower_bound
+       * @param[in] min_chunk_size - minimal size of chank that can be associated with job, default: 1
+       * @param[in] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
        *
        */
       AbstractLoadBalancer(const MPI_Comm communicator, const int64_t lower_bound, const int64_t upper_bound, const int64_t min_chunk_size = 1, const int64_t max_chunk_size = -1);
@@ -47,14 +47,14 @@ namespace SLB4MPI {
       /**
        *
        * @brief get range to compute
-       * @note upper_bound can be only less than or equal <Any>LoadBalancer%upper_bound
-       *       so, for last elements a batch with size less than min_chunk_size can be returned
+       * @note `upper_bound` can be only less than or equal `AbstractLoadBalancer.upper_bound`.
+       *       So, for last elements a batch with size less than `min_chunk_size` can be returned
        *
        * @param[out] lower_bound - lower bound of range to compute
        * @param[out] upper_bound - upper bound of range to compute
-       * @return                 - is there something to compute?
+       * @return                 - true if there is something to compute
        *
        */
-      virtual bool get_range(int64_t&, int64_t&) = 0;
+      virtual bool get_range(int64_t& lower_bound, int64_t& upper_bound) = 0;
   };
 }

src/CXX/SLB4MPI/SLB4MPI/dynamic_load_balancer.hpp

@@ -20,11 +20,11 @@ namespace SLB4MPI {
        *
        * @brief initialize values of dynamic load balancer
        *
-       * @param[in]           communicator   - MPI communicator on which load balancer will be used
-       * @param[in]           lower_bound    - lower bound of range
-       * @param[in]           upper_bound    - upper bound of range, upper_bound >= lower_bound
-       * @param[in, optional] min_chunk_size - minimal size of chank that can be associated with job, default: 1
-       * @param[in, optional] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
+       * @param[in] communicator   - MPI communicator on which load balancer will be used
+       * @param[in] lower_bound    - lower bound of range
+       * @param[in] upper_bound    - upper bound of range, upper_bound >= lower_bound
+       * @param[in] min_chunk_size - minimal size of chank that can be associated with job, default: 1
+       * @param[in] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
        *
        */
       DynamicLoadBalancer(const MPI_Comm communicator, const int64_t lower_bound, const int64_t upper_bound, const int64_t min_chunk_size = 1, const int64_t max_chunk_size = -1);
@@ -37,12 +37,12 @@ namespace SLB4MPI {
       /**
        *
        * @brief get range to compute
-       * @note upper_bound can be only less than or equal DynamicLoadBalancer.upper_bound
-       *       so, for last elements a batch with size less than min_chunk_size can be returned
+       * @note `upper_bound` can be only less than or equal `DynamicLoadBalancer.upper_bound`.
+       *       So, for last elements a batch with size less than `min_chunk_size` can be returned
        *
        * @param[out] lower_bound - lower bound of range to compute
        * @param[out] upper_bound - upper bound of range to compute
-       * @return                 - is there something to compute?
+       * @return                 - true if there is something to compute
        *
        */
       virtual bool get_range(int64_t&, int64_t&);

src/CXX/SLB4MPI/SLB4MPI/guided_load_balancer.hpp

@@ -20,11 +20,11 @@ namespace SLB4MPI {
        *
        * @brief initialize values of guided load balancer
        *
-       * @param[in]           communicator   - MPI communicator on which load balancer will be used
-       * @param[in]           lower_bound    - lower bound of range
-       * @param[in]           upper_bound    - upper bound of range, upper_bound >= lower_bound
-       * @param[in, optional] min_chunk_size - minimal size of chank that can be associated with job, default: 1
-       * @param[in, optional] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
+       * @param[in] communicator   - MPI communicator on which load balancer will be used
+       * @param[in] lower_bound    - lower bound of range
+       * @param[in] upper_bound    - upper bound of range, upper_bound >= lower_bound
+       * @param[in] min_chunk_size - minimal size of chank that can be associated with job, default: 1
+       * @param[in] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
        *
        */
       GuidedLoadBalancer(const MPI_Comm communicator, const int64_t lower_bound, const int64_t upper_bound, const int64_t min_chunk_size = 1, const int64_t max_chunk_size = -1);
@@ -37,12 +37,12 @@ namespace SLB4MPI {
       /**
        *
        * @brief get range to compute
-       * @note upper_bound can be only less than or equal GuidedLoadBalancer.upper_bound
-       *       so, for last elements a batch with size less than min_chunk_size can be returned
+       * @note `upper_bound` can be only less than or equal `GuidedLoadBalancer.upper_bound`.
+       *       So, for last elements a batch with size less than `min_chunk_size` can be returned
        *
        * @param[out] lower_bound - lower bound of range to compute
        * @param[out] upper_bound - upper bound of range to compute
-       * @return                 - is there something to compute?
+       * @return                 - true if there is something to compute
        *
        */
       virtual bool get_range(int64_t&, int64_t&);

src/CXX/SLB4MPI/SLB4MPI/local_static_load_balancer.hpp

@@ -17,11 +17,11 @@ namespace SLB4MPI {
        *
        * @brief initialize values of local static load balancer
        *
-       * @param[in]           communicator   - MPI communicator on which load balancer will be used
-       * @param[in]           lower_bound    - lower bound of range
-       * @param[in]           upper_bound    - upper bound of range, upper_bound >= lower_bound
-       * @param[in, optional] min_chunk_size - minimal size of chank that can be associated with job, default: 1
-       * @param[in, optional] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
+       * @param[in] communicator   - MPI communicator on which load balancer will be used
+       * @param[in] lower_bound    - lower bound of range
+       * @param[in] upper_bound    - upper bound of range, upper_bound >= lower_bound
+       * @param[in] min_chunk_size - minimal size of chank that can be associated with job, default: 1
+       * @param[in] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
        *
        */
       LocalStaticLoadBalancer(const MPI_Comm communicator, const int64_t lower_bound, const int64_t upper_bound, const int64_t min_chunk_size = 1, const int64_t max_chunk_size = -1);
@@ -34,12 +34,12 @@ namespace SLB4MPI {
       /**
        *
        * @brief get range to compute
-       * @note upper_bound can be only less than or equal LocalStaticLoadBalancer.upper_bound
-       *       so, for last elements a batch with size less than min_chunk_size can be returned
+       * @note `upper_bound` can be only less than or equal `LocalStaticLoadBalancer.upper_bound`.
+       *       So, for last elements a batch with size less than `min_chunk_size` can be returned
        *
        * @param[out] lower_bound - lower bound of range to compute
        * @param[out] upper_bound - upper bound of range to compute
-       * @return                 - is there something to compute?
+       * @return                 - true if there is something to compute
        *
        */
       virtual bool get_range(int64_t&, int64_t&);

src/CXX/SLB4MPI/SLB4MPI/runtime_load_balancer.hpp

@@ -20,12 +20,12 @@ namespace SLB4MPI {
        *
        * @brief initialize values of static load balancer
        *
-       * @param[in]           lbtype         - load balancer type
-       * @param[in]           communicator   - MPI communicator on which load balancer will be used
-       * @param[in]           lower_bound    - lower bound of range
-       * @param[in]           upper_bound    - upper bound of range, upper_bound >= lower_bound
-       * @param[in, optional] min_chunk_size - minimal size of chank that can be associated with job, default: 1
-       * @param[in, optional] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
+       * @param[in] lbtype         - load balancer type
+       * @param[in] communicator   - MPI communicator on which load balancer will be used
+       * @param[in] lower_bound    - lower bound of range
+       * @param[in] upper_bound    - upper bound of range, upper_bound >= lower_bound
+       * @param[in] min_chunk_size - minimal size of chank that can be associated with job, default: 1
+       * @param[in] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
        *
        */
       RuntimeLoadBalancer(const std::string& lbtype, const MPI_Comm communicator, const int64_t lower_bound, const int64_t upper_bound, const int64_t min_chunk_size = 1, const int64_t max_chunk_size = -1);
@@ -38,12 +38,12 @@ namespace SLB4MPI {
       /**
        *
        * @brief get range to compute
-       * @note upper_bound can be only less than or equal RuntimeLoadBalancer.upper_bound
-       *       so, for last elements a batch with size less than min_chunk_size can be returned
+       * @note `upper_bound` can be only less than or equal `RuntimeLoadBalancer.upper_bound`.
+       *       So, for last elements a batch with size less than `min_chunk_size` can be returned
        *
        * @param[out] lower_bound - lower bound of range to compute
        * @param[out] upper_bound - upper bound of range to compute
-       * @return                 - is there something to compute?
+       * @return                 - true if there is something to compute
        *
        */
       virtual bool get_range(int64_t&, int64_t&);

src/CXX/SLB4MPI/SLB4MPI/static_load_balancer.hpp

@@ -17,11 +17,11 @@ namespace SLB4MPI {
        *
        * @brief initialize values of static load balancer
        *
-       * @param[in]           communicator   - MPI communicator on which load balancer will be used
-       * @param[in]           lower_bound    - lower bound of range
-       * @param[in]           upper_bound    - upper bound of range, upper_bound >= lower_bound
-       * @param[in, optional] min_chunk_size - minimal size of chank that can be associated with job, default: 1
-       * @param[in, optional] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
+       * @param[in] communicator   - MPI communicator on which load balancer will be used
+       * @param[in] lower_bound    - lower bound of range
+       * @param[in] upper_bound    - upper bound of range, upper_bound >= lower_bound
+       * @param[in] min_chunk_size - minimal size of chank that can be associated with job, default: 1
+       * @param[in] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
        *
        */
       StaticLoadBalancer(const MPI_Comm communicator, const int64_t lower_bound, const int64_t upper_bound, const int64_t min_chunk_size = 1, const int64_t max_chunk_size = -1);
@@ -34,12 +34,12 @@ namespace SLB4MPI {
       /**
        *
        * @brief get range to compute
-       * @note upper_bound can be only less than or equal StaticLoadBalancer.upper_bound
-       *       so, for last elements a batch with size less than min_chunk_size can be returned
+       * @note `upper_bound` can be only less than or equal `StaticLoadBalancer.upper_bound`.
+       *       So, for last elements a batch with size less than `min_chunk_size` can be returned
        *
        * @param[out] lower_bound - lower bound of range to compute
        * @param[out] upper_bound - upper bound of range to compute
-       * @return                 - is there something to compute?
+       * @return                 - true if there is something to compute
        *
        */
       virtual bool get_range(int64_t&, int64_t&);

src/CXX/SLB4MPI/SLB4MPI/work_stealing_load_balancer.hpp

@@ -26,11 +26,11 @@ namespace SLB4MPI {
        *
        * @brief initialize values of work stealing load balancer
        *
-       * @param[in]           communicator   - MPI communicator on which load balancer will be used
-       * @param[in]           lower_bound    - lower bound of range
-       * @param[in]           upper_bound    - upper bound of range, upper_bound >= lower_bound
-       * @param[in, optional] min_chunk_size - minimal size of chank that can be associated with job, default: 1
-       * @param[in, optional] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
+       * @param[in] communicator   - MPI communicator on which load balancer will be used
+       * @param[in] lower_bound    - lower bound of range
+       * @param[in] upper_bound    - upper bound of range, upper_bound >= lower_bound
+       * @param[in] min_chunk_size - minimal size of chank that can be associated with job, default: 1
+       * @param[in] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
        *
        */
       WorkStealingLoadBalancer(const MPI_Comm communicator, const int64_t lower_bound, const int64_t upper_bound, const int64_t min_chunk_size = 1, const int64_t max_chunk_size = -1);
@@ -43,12 +43,12 @@ namespace SLB4MPI {
       /**
        *
        * @brief get range to compute
-       * @note upper_bound can be only less than or equal WorkStealingLoadBalancer.upper_bound
-       *       so, for last elements a batch with size less than min_chunk_size can be returned
+       * @note `upper_bound` can be only less than or equal `WorkStealingLoadBalancer.upper_bound`.
+       *       So, for last elements a batch with size less than `min_chunk_size` can be returned
        *
        * @param[out] lower_bound - lower bound of range to compute
        * @param[out] upper_bound - upper bound of range to compute
-       * @return                 - is there something to compute?
+       * @return                 - true if there is something to compute
        *
        */
       virtual bool get_range(int64_t&, int64_t&);

src/CXX/abstract_load_balancer.cxx

@@ -8,11 +8,11 @@
  *
  * @brief initialize default values of abstract load balancer
  *
- * @param[in]           communicator   - MPI communicator on which load balancer will be used
- * @param[in]           lower_bound    - lower bound of range
- * @param[in]           upper_bound    - upper bound of range, upper_bound >= lower_bound
- * @param[in, optional] min_chunk_size - minimal size of chank that can be associated with job, default: 1
- * @param[in, optional] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
+ * @param[in] communicator   - MPI communicator on which load balancer will be used
+ * @param[in] lower_bound    - lower bound of range
+ * @param[in] upper_bound    - upper bound of range, upper_bound >= lower_bound
+ * @param[in] min_chunk_size - minimal size of chank that can be associated with job, default: 1
+ * @param[in] max_chunk_size - maximal size of chank that can be associated with job, default: upper_bound - lower_bound + 1
  *
  */
 SLB4MPI::AbstractLoadBalancer::AbstractLoadBalancer(const MPI_Comm communicator, const int64_t lower_bound, const int64_t upper_bound, const int64_t min_chunk_size, const int64_t max_chunk_size) {