Switch argument order of IGD(), IGD_plus(), avg_Hausdorff_dist(), epsilon_additive(), epsilon_mult() to pass first the number of rows then the number of columns.

Author: MLopez-Ibanez

c/NEWS.md

@@ -4,7 +4,8 @@
 
  * `pareto_rank()` is now O(k * n log n) in 3D, which is faster than the naive O(n^3).
  * HV3D+ is slightly faster with repeated coordinates (#41).
- * Switch argument order of `fpli_hv()`, `hv_contributions()`
+ * Switch argument order of `fpli_hv()`, `hv_contributions()`, `IGD()`,
+   `IGD_plus()`, `avg_Hausdorff_dist()`, `epsilon_additive()`, `epsilon_mult()`
    to pass first the number of rows then the number of columns.
 
 ## 0.17.0

c/epsilon.h

@@ -109,17 +109,17 @@ epsilon_mult_agree_none(const signed char * restrict minmax, dimension_t dim,
 _attr_optimize_finite_math
 static inline double
 epsilon_mult_agree_min(dimension_t dim,
-                        const double * restrict points_a, size_t size_a,
-                        const double * restrict points_b, size_t size_b)
+                       const double * restrict points_a, size_t size_a,
+                       const double * restrict points_b, size_t size_b)
 {
     return epsilon_helper_(/* do_mult=*/true, AGREE_MINIMISE, /*minmax=*/NULL, dim, points_a, size_a, points_b, size_b);
 }
 
 _attr_optimize_finite_math
 static inline double
 epsilon_mult_agree_max(dimension_t dim,
-                        const double * restrict points_a, size_t size_a,
-                        const double * restrict points_b, size_t size_b)
+                       const double * restrict points_a, size_t size_a,
+                       const double * restrict points_b, size_t size_b)
 {
     return epsilon_helper_(/* do_mult=*/true, AGREE_MAXIMISE, /*minmax=*/NULL, dim, points_a, size_a, points_b, size_b);
 }
@@ -137,17 +137,17 @@ epsilon_addi_agree_none(const signed char * restrict minmax, dimension_t dim,
 _attr_optimize_finite_math
 static inline double
 epsilon_addi_agree_min(dimension_t dim,
-                        const double * restrict points_a, size_t size_a,
-                        const double * restrict points_b, size_t size_b)
+                       const double * restrict points_a, size_t size_a,
+                       const double * restrict points_b, size_t size_b)
 {
     return epsilon_helper_(/* do_mult=*/false, AGREE_MINIMISE, /*minmax=*/NULL, dim, points_a, size_a, points_b, size_b);
 }
 
 _attr_optimize_finite_math
 static inline double
 epsilon_addi_agree_max(dimension_t dim,
-                        const double * restrict points_a, size_t size_a,
-                        const double * restrict points_b, size_t size_b)
+                       const double * restrict points_a, size_t size_a,
+                       const double * restrict points_b, size_t size_b)
 {
     return epsilon_helper_(/* do_mult=*/false, AGREE_MAXIMISE, /*minmax=*/NULL, dim, points_a, size_a, points_b, size_b);
 }
@@ -194,41 +194,35 @@ epsilon_additive_minmax(const signed char * restrict minmax, dimension_t dim,
 }
 
 _attr_maybe_unused static double
-epsilon_additive(const double * restrict data, int nobj, int npoints,
-                 const double * restrict ref, int ref_size,
+epsilon_additive(const double * restrict data, size_t n, dimension_t dim,
+                 const double * restrict ref, size_t ref_size,
                  const bool * restrict maximise)
 {
-    ASSUME(nobj >= 2);
-    ASSUME(npoints >= 0);
-    ASSUME(ref_size >= 0);
-    dimension_t dim = (dimension_t) nobj;
+    ASSUME(dim >= 2);
     const signed char * minmax = minmax_from_bool(maximise, dim);
-    double value = epsilon_additive_minmax(minmax, dim, data, npoints, ref, ref_size);
+    double value = epsilon_additive_minmax(minmax, dim, data, n, ref, ref_size);
     free ((void *)minmax);
     return value;
 }
 
 _attr_maybe_unused static double
-epsilon_mult(const double * restrict data, int nobj, int npoints,
-             const double * restrict ref, int ref_size,
+epsilon_mult(const double * restrict data, size_t n, dimension_t dim,
+             const double * restrict ref, size_t ref_size,
              const bool * restrict maximise)
 {
-    ASSUME(nobj >= 2);
-    ASSUME(npoints >= 0);
-    ASSUME(ref_size >= 0);
-    dimension_t dim = (dimension_t) nobj;
+    ASSUME(dim >= 2);
     const signed char * minmax = minmax_from_bool(maximise, dim);
-    double value = epsilon_mult_minmax(minmax, dim, data, npoints, ref, ref_size);
+    double value = epsilon_mult_minmax(minmax, dim, data, n, ref, ref_size);
     free ((void *)minmax);
     return value;
 }
 
 /* FIXME: this can be done much faster. For example, the diff needs to
    be calculated just once and stored on a temporary array diff[].  */
 static inline int
-epsilon_additive_ind (dimension_t dim, const signed char * restrict minmax,
-                      const double * restrict points_a, size_t size_a,
-                      const double * restrict points_b, size_t size_b)
+epsilon_additive_ind(dimension_t dim, const signed char * restrict minmax,
+                     const double * restrict points_a, size_t size_a,
+                     const double * restrict points_b, size_t size_b)
 {
     double eps_ab = epsilon_additive_minmax(
         minmax, dim, points_a, size_a, points_b, size_b);

c/igd.c

@@ -168,7 +168,7 @@ do_file (const char *filename, double *reference, size_t reference_size,
 
     for (int n = 0, cumsize = 0; n < nruns; cumsize = cumsizes[n], n++) {
         _attr_maybe_unused double time_elapsed = 0;
-        int size_a = cumsizes[n] - cumsize;
+        size_t size_a = cumsizes[n] - cumsize;
         const double *points_a = &data[nobj * cumsize];
         //Timer_start ();
         sep = "\0";
@@ -177,7 +177,7 @@ do_file (const char *filename, double *reference, size_t reference_size,
         do {                                                                   \
             if (IF) {                                                          \
                 fprintf (outfile, "%s" indicator_printf_format, sep,           \
-                         FUN(nobj, minmax, points_a, size_a, reference, (int) reference_size, ## __VA_ARGS__)); \
+                         FUN((dimension_t) nobj, minmax, points_a, size_a, reference, reference_size, ## __VA_ARGS__)); \
                 sep = "\t";                                                    \
             }                                                                  \
         } while (0)

c/igd.h

@@ -58,23 +58,22 @@
 #include "nondominated.h" // minmax_from_bool
 
 static inline double
-gd_common (int dim, const signed char * restrict minmax,
-           const double * restrict points_a, int size_a,
-           const double * restrict points_r, int size_r,
-           bool plus, bool psize, uint_fast8_t p)
+gd_common(dimension_t dim, const signed char * restrict minmax,
+          const double * restrict points_a, size_t size_a,
+          const double * restrict points_r, size_t size_r,
+          bool plus, bool psize, uint_fast8_t p)
 {
     if (size_a == 0) return INFINITY;
     ASSUME(size_a > 0);
     ASSUME(size_r > 0);
     ASSUME(dim >= 2);
-    ASSUME(dim <= 32);
 
     double gd = 0;
-    for (int a = 0; a < size_a; a++) {
+    for (size_t a = 0; a < size_a; a++) {
         double min_dist = INFINITY;
-        for (int r = 0; r < size_r; r++) {
+        for (size_t r = 0; r < size_r; r++) {
             double dist = 0.0;
-            for (int d = 0; d < dim; d++) {
+            for (dimension_t d = 0; d < dim; d++) {
                 if (minmax[d] == 0) continue;
                 double a_d = points_a[a * dim + d];
                 double r_d = points_r[r * dim + d];
@@ -84,9 +83,8 @@ gd_common (int dim, const signed char * restrict minmax,
                 // TODO: Implement taxicab and infinity norms
                 dist += diff * diff;
             }
-            // We should calculate here the sqrt() of the Euclidean, however
-            // that would not change which one is the minimum, so we compute it
-            // outside the loop, which is faster.
+            // We calculate the sqrt() of the Euclidean outside the loop, which
+            // is faster and does not change the minimum.
             if (dist < min_dist) min_dist = dist;
         }
         // Here we calculate the actual Euclidean distance.
@@ -108,114 +106,112 @@ gd_common (int dim, const signed char * restrict minmax,
 }
 
 static inline double
-GD_minmax (int dim, const signed char * restrict minmax,
-           const double * restrict points_a, int size_a,
-           const double * restrict points_r, int size_r)
+GD_minmax(dimension_t dim, const signed char * restrict minmax,
+          const double * restrict points_a, size_t size_a,
+          const double * restrict points_r, size_t size_r)
 {
-    return gd_common (dim, minmax,
-                      points_a, size_a,
-                      points_r, size_r,
-                      /*plus=*/false, /*psize=*/false,
-                      /*p=*/(uint_fast8_t)1);
+    return gd_common(dim, minmax,
+                     points_a, size_a,
+                     points_r, size_r,
+                     /*plus=*/false, /*psize=*/false, /*p=*/1);
 }
 
 static inline double
-IGD_minmax (int dim, const signed char * restrict minmax,
-            const double * restrict points_a, int size_a,
-            const double * restrict points_r, int size_r)
+IGD_minmax(dimension_t dim, const signed char * restrict minmax,
+           const double * restrict points_a, size_t size_a,
+           const double * restrict points_r, size_t size_r)
 {
-    return gd_common (dim, minmax,
-                      points_r, size_r,
-                      points_a, size_a,
-                      /*plus=*/false, /*psize=*/false,
-                      /*p=*/(uint_fast8_t)1);
+    return gd_common(dim, minmax,
+                     points_r, size_r,
+                     points_a, size_a,
+                     /*plus=*/false, /*psize=*/false, /*p=*/1);
 }
 
 _attr_maybe_unused static double
-IGD (const double * restrict data, int nobj, int npoints,
-     const double * restrict ref, int ref_size,
-     const bool *  restrict maximise)
+IGD(const double * restrict data, size_t npoints, dimension_t nobj,
+    const double * restrict ref, size_t ref_size,
+    const bool *  restrict maximise)
 {
-    ASSUME(nobj > 0 && nobj <= 128);
-    const signed char *minmax = minmax_from_bool(maximise, (dimension_t) nobj);
-    double value = IGD_minmax (nobj, minmax, data, npoints, ref, ref_size);
+    const signed char * minmax = minmax_from_bool(maximise, nobj);
+    double value = IGD_minmax(nobj, minmax, data, npoints, ref, ref_size);
     free ((void *)minmax);
     return value;
 }
 
 static inline double
-GD_p (int dim, const signed char * restrict minmax,
-      const double * restrict points_a, int size_a,
-      const double * restrict points_r, int size_r, unsigned int p)
+GD_p(dimension_t dim, const signed char * restrict minmax,
+     const double * restrict points_a, size_t size_a,
+     const double * restrict points_r, size_t size_r, unsigned int p)
 {
-    return gd_common (dim, minmax,
-                      points_a, size_a,
-                      points_r, size_r,
-                      /*plus=*/false, /*psize=*/true, (uint_fast8_t)p);
+    return gd_common(dim, minmax,
+                     points_a, size_a,
+                     points_r, size_r,
+                     /*plus=*/false, /*psize=*/true, (uint_fast8_t)p);
 }
 
 static inline double
-IGD_p (int dim, const signed char * restrict minmax,
-       const double * restrict points_a, int size_a,
-       const double * restrict points_r, int size_r, unsigned int p)
+IGD_p(dimension_t dim, const signed char * restrict minmax,
+      const double * restrict points_a, size_t size_a,
+      const double * restrict points_r, size_t size_r, unsigned int p)
 {
-    return gd_common (dim, minmax,
-                      points_r, size_r,
-                      points_a, size_a,
-                      /*plus=*/false, /*psize=*/true, (uint_fast8_t) p);
+    return gd_common(dim, minmax,
+                     points_r, size_r,
+                     points_a, size_a,
+                     /*plus=*/false, /*psize=*/true, (uint_fast8_t) p);
 }
 
 static inline double
-IGD_plus_minmax (int dim, const signed char * restrict minmax,
-                 const double * restrict points_a, int size_a,
-                 const double * restrict points_r, int size_r)
+IGD_plus_minmax(dimension_t dim, const signed char * restrict minmax,
+                const double * restrict points_a, size_t size_a,
+                const double * restrict points_r, size_t size_r)
 {
-    return gd_common (dim, minmax,
-                      points_r, size_r,
-                      points_a, size_a,
-                      /*plus=*/true, /*psize=*/true, /*p=*/(uint_fast8_t)1);
+    return gd_common(dim, minmax,
+                     points_r, size_r,
+                     points_a, size_a,
+                     /*plus=*/true, /*psize=*/true, /*p=*/1);
 }
 
 _attr_maybe_unused static double
-IGD_plus (const double * restrict data, int nobj, int npoints, const double * restrict ref, int ref_size,
-          const bool * restrict  maximise)
+IGD_plus(const double * restrict data, size_t npoints, dimension_t nobj,
+         const double * restrict ref, int ref_size,
+         const bool * restrict  maximise)
 {
-    ASSUME(nobj > 0 && nobj <= 128);
-    const signed char *minmax = minmax_from_bool(maximise, (dimension_t) nobj);
-    double value = IGD_plus_minmax (nobj, minmax, data, npoints, ref, ref_size);
+    ASSUME(nobj > 0);
+    const signed char * minmax = minmax_from_bool(maximise, nobj);
+    double value = IGD_plus_minmax(nobj, minmax, data, npoints, ref, ref_size);
     free ((void *)minmax);
-    return(value);
+    return value;
 }
 
 static inline double
-avg_Hausdorff_dist_minmax (int dim, const signed char * restrict minmax,
-                           const double * restrict points_a, int size_a,
-                           const double * restrict points_r, int size_r,
-                           unsigned int p)
+avg_Hausdorff_dist_minmax(dimension_t dim, const signed char * restrict minmax,
+                          const double * restrict points_a, size_t size_a,
+                          const double * restrict points_r, size_t size_r,
+                          unsigned int p)
 {
-    double gd_p = gd_common (dim, minmax,
-                             points_a, size_a,
+    double gd_p = gd_common(dim, minmax,
+                            points_a, size_a,
+                            points_r, size_r,
+                            /*plus=*/false, /*psize=*/true, (uint_fast8_t)p);
+
+    double igd_p = gd_common(dim, minmax,
                              points_r, size_r,
+                             points_a, size_a,
                              /*plus=*/false, /*psize=*/true, (uint_fast8_t)p);
-
-    double igd_p = gd_common (dim, minmax,
-                              points_r, size_r,
-                              points_a, size_a,
-                              /*plus=*/false, /*psize=*/true, (uint_fast8_t)p);
     return MAX(gd_p, igd_p);
 }
 /* TODO: Implement p=INFINITY See [4] */
 
 _attr_maybe_unused static double
-avg_Hausdorff_dist (const double * restrict data, int nobj, int npoints,
-                    const double * restrict ref, int ref_size,
-                    const bool * restrict maximise, unsigned int p)
+avg_Hausdorff_dist(const double * restrict data, size_t npoints, dimension_t nobj,
+                   const double * restrict ref, size_t ref_size,
+                   const bool * restrict maximise, unsigned int p)
 {
-    ASSUME(nobj > 0 && nobj <= 128);
-    const signed char * minmax = minmax_from_bool(maximise, (dimension_t) nobj);
-    double value = avg_Hausdorff_dist_minmax (nobj, minmax, data, npoints, ref, ref_size, p);
+    ASSUME(nobj > 0);
+    const signed char * minmax = minmax_from_bool(maximise, nobj);
+    double value = avg_Hausdorff_dist_minmax(nobj, minmax, data, npoints, ref, ref_size, p);
     free ((void *)minmax);
-    return(value);
+    return value;
 }
 
 #endif /* IGD_H */