c/ Use %zu consistently for printing size_t.

Author: MLopez-Ibanez

c/hv_contrib.c

@@ -134,7 +134,8 @@ hvc_1point_diffs_nondom(double * restrict hvc, double * restrict points,
 #undef swap_points
 }
 
-/* O(n log n) dimension-sweep algorithm.
+/**
+   O(n log n) dimension-sweep algorithm.
 
    hvc[] must be already allocated with size n.  Points that are duplicated
    have zero exclusive contribution.  Thus, the sum of contributions may
@@ -147,34 +148,35 @@ hvc2d(double * restrict hvc, const double * restrict data, size_t n,
       const double * restrict ref)
 {
     ASSUME(n > 0);
-    const double **p = generate_sorted_doublep_2d_filter_by_ref(data, &n, ref[0]);
+    const double ** p = generate_sorted_doublep_2d_filter_by_ref(data, &n, ref[0]);
     if (unlikely(n == 0)) return 0;
     if (unlikely(!p)) return -1;
 
     size_t j = 0;
     // Find first point below the reference point.
-    while (j < n && p[j][1] >= ref[1])
+    while (p[j][1] >= ref[1]) {
         j++;
-    if (unlikely(j == n)) {
-        free(p);
-        return 0;
+        if (unlikely(j == n)) {
+            free(p);
+            return 0;
+        }
     }
-    double height = ref[1] - p[j][1];
-    double hyperv = (ref[0] - p[j][0]) * height;
     const double * prev = p[j];
+    double height = ref[1] - prev[1];
+    double hyperv = (ref[0] - prev[0]) * height;
     j++;
     while (j < n) {
-        DEBUG2_PRINT("[%lld]=(%g, %g) -> [%lld]=(%g,%g) (height=%g)\n",
-                     (long long)(prev - data) / 2, prev[0], prev[1],
-                     (long long)(p[j] - data) / 2, p[j][0], p[j][1], height);
+        DEBUG2_PRINT("[%zu]=(%g, %g) -> [%zu]=(%g,%g) (height=%g)\n",
+                     ((size_t)(prev - data)) / 2, prev[0], prev[1],
+                     ((size_t)(p[j] - data)) / 2, p[j][0], p[j][1], height);
         // likely() because most points will be non-dominated.
         if (likely(prev[1] > p[j][1])) {
             assert(prev[0] < p[j][0]);
             /* Compute the contribution of prev.  We have to accumulate because
                we may have computed partial contributions.  */
             hvc[(prev - data) / 2] += (p[j][0] - prev[0]) * height;
-            DEBUG2_PRINT("hvc[%lld] += %g * %g = %g\n",
-                         (long long) (prev - data) / 2,
+            DEBUG2_PRINT("hvc[%zu] += %g * %g = %g\n",
+                         ((size_t)(prev - data)) / 2,
                          p[j][0] - prev[0], height,
                          (p[j][0] - prev[0]) * height);
             height = prev[1] - p[j][1];
@@ -183,20 +185,20 @@ hvc2d(double * restrict hvc, const double * restrict data, size_t n,
             prev = p[j];
             j++;
         } else if (prev[0] < p[j][0]) {
-            // prev[1] <= p[j][1], thus pj contributes partially to hvc[prev].
+            // prev[1] <= p[j][1], thus p[j] contributes partially to hvc[prev].
             double new_h = p[j][1] - prev[1];
             if (new_h < height) {
                 hvc[(prev - data) / 2] += (p[j][0] - prev[0]) * (height - new_h);
-                DEBUG2_PRINT("hvc[%lld] += %g * %g = %g\n",
-                             (long long) (prev - data) / 2,
+                DEBUG2_PRINT("hvc[%zu] += %g * %g = %g\n",
+                             ((size_t)(prev - data)) / 2,
                              p[j][0] - prev[0], height - new_h,
                              (p[j][0] - prev[0]) * (height - new_h));
                 height = new_h;
             }
             j++;
         } else if (prev[1] == p[j][1]) { // && prev[0] == p[j][0]
             // Duplicates contribute zero.
-            DEBUG2_PRINT("hvc[%lld] = %g\n", (long long)(prev - data) / 2,
+            DEBUG2_PRINT("hvc[%zu] = %g\n", ((size_t)(prev - data)) / 2,
                          hvc[(prev - data) / 2]);
             assert(hvc[(prev - data) / 2] == 0);
             /* We set height=0 here so that we set hvc[prev] = 0 when we find the
@@ -221,7 +223,7 @@ hvc2d(double * restrict hvc, const double * restrict data, size_t n,
     }
 
     hvc[(prev - data) / 2] += (ref[0] - prev[0]) * height;
-    DEBUG2_PRINT("hvc[%lld] = %g * %g = %g\n", (long long)(prev - data) / 2,
+    DEBUG2_PRINT("hvc[%zu] = %g * %g = %g\n", ((size_t)(prev - data)) / 2,
                  ref[0] - prev[0], height,  (ref[0] - prev[0]) * height);
     free(p);
     return hyperv;
@@ -232,33 +234,34 @@ hvc2d_nondom(double * restrict hvc, const double * restrict data, size_t n,
              const double * restrict ref)
 {
     ASSUME(n > 0);
-    const double **p = generate_sorted_doublep_2d_filter_by_ref(data, &n, ref[0]);
+    const double ** p = generate_sorted_doublep_2d_filter_by_ref(data, &n, ref[0]);
     if (unlikely(n == 0)) return 0;
     if (unlikely(!p)) return -1;
 
     size_t j = 0;
     // Find first point below the reference point.
-    while (j < n && p[j][1] >= ref[1])
+    while (p[j][1] >= ref[1]) {
         j++;
-    if (unlikely(j == n)) {
-        free(p);
-        return 0;
+        if (unlikely(j == n)) {
+            free(p);
+            return 0;
+        }
     }
-    double height = ref[1] - p[j][1];
-    double hyperv = (ref[0] - p[j][0]) * height;
     const double * prev = p[j];
+    double height = ref[1] - prev[1];
+    double hyperv = (ref[0] - prev[0]) * height;
     j++;
     while (j < n) {
-        DEBUG2_PRINT("[%lld]=(%g, %g) -> [%lld]=(%g,%g) (height=%g)\n",
-                     (long long)(prev - data) / 2, prev[0], prev[1],
-                     (long long)(p[j] - data) / 2, p[j][0], p[j][1], height);
+        DEBUG2_PRINT("[%zu]=(%g, %g) -> [%zu]=(%g,%g) (height=%g)\n",
+                     ((size_t)(prev - data)) / 2, prev[0], prev[1],
+                     ((size_t)(p[j] - data)) / 2, p[j][0], p[j][1], height);
         // likely() because most points will be non-dominated.
         if (likely(prev[1] > p[j][1])) {
             assert(prev[0] < p[j][0]);
-            /* Compute the contribution of prev.  */
+            // Compute the contribution of prev.
             hvc[(prev - data) / 2] = (p[j][0] - prev[0]) * height;
-            DEBUG2_PRINT("hvc[%lld] = %g * %g = %g\n",
-                         (long long) (prev - data) / 2,
+            DEBUG2_PRINT("hvc[%zu] = %g * %g = %g\n",
+                         ((size_t)(prev - data)) / 2,
                          p[j][0] - prev[0], height,
                          (p[j][0] - prev[0]) * height);
             height = prev[1] - p[j][1];
@@ -269,16 +272,16 @@ hvc2d_nondom(double * restrict hvc, const double * restrict data, size_t n,
         } else if (prev[0] == p[j][0]) { // && prev[1] <= p[j][1]
             if (prev[1] == p[j][1]) {
                 // Duplicates contribute zero.
-                DEBUG2_PRINT("hvc[%lld] = %g\n", (long long)(prev - data) / 2,
+                DEBUG2_PRINT("hvc[%zu] = %g\n", ((size_t)(prev - data)) / 2,
                              hvc[(prev - data) / 2]);
                 assert(hvc[(prev - data) / 2] == 0);
-                /* We set this here so that we set hvc[prev] = 0 when we find the next
-                   non-duplicate.  */
+                /* We set this here so that we set hvc[prev] = 0 when we find
+                   the next non-duplicate.  */
                 height = 0;
                 prev = p[j];
             }
-            /* All points with same 0-coordinate are weakly dominated by
-               prev, so they can be ignored.  */
+            /* All points with same 0-coordinate are weakly dominated by prev,
+               so they can be ignored.  */
             do {
                 j++;
             } while (j < n && prev[0] == p[j][0]);
@@ -291,7 +294,7 @@ hvc2d_nondom(double * restrict hvc, const double * restrict data, size_t n,
     }
 
     hvc[(prev - data) / 2] = (ref[0] - prev[0]) * height;
-    DEBUG2_PRINT("hvc[%lld] = %g * %g = %g\n", (long long)(prev - data) / 2,
+    DEBUG2_PRINT("hvc[%zu] = %g * %g = %g\n", ((size_t)(prev - data)) / 2,
                  ref[0] - prev[0], height,  (ref[0] - prev[0]) * height);
     free(p);
     return hyperv;

c/hvapprox.c

@@ -225,12 +225,11 @@ construct_polar_a(dimension_t dim, uint_fast32_t nsamples)
         61, 67, 67 };
 
     const dimension_t p = primes[dim];
-    DEBUG2_PRINT("construct_polar_a: prime: %u\n", (unsigned int)p);
+    DEBUG2_PRINT("construct_polar_a: prime: %d\n", p);
 
     uint_fast32_t * a = malloc(dim * sizeof(*a));
     a[0] = 1;
-    DEBUG2_PRINT("construct_polar_a: a[%u] = %lu",
-                 (unsigned int) dim, (unsigned long) a[0]);
+    DEBUG2_PRINT("construct_polar_a: a[%d] = %lu", dim, (unsigned long) a[0]);
     for (dimension_t k = 1; k < dim; k++) {
         long double temp = 2 * fabsl(cosl(2 * M_PIl * k / p));
         temp = fractl(temp);

c/nondominated.h

@@ -2,7 +2,6 @@
 #define NONDOMINATED_H
 
 #include "config.h"
-
 #include <string.h> // memcpy
 #include <math.h> // INFINITY
 #include "sort.h"
@@ -23,7 +22,8 @@ typedef struct avl_node_t {
 enum objs_agree_t { AGREE_MINIMISE = -1, AGREE_NONE = 0, AGREE_MAXIMISE = 1 };
 
 static inline void
-printf_point(const char * prefix, const double * p, dimension_t dim, const char * suffix)
+printf_point(const char * prefix, const double * p, dimension_t dim,
+             const char * suffix)
 {
     fprintf(stderr, "%s%g", prefix, p[0]);
     for (dimension_t d = 1; d < dim; d++)
@@ -46,7 +46,7 @@ printf_rows(const char * prefix,
     if (size > 0) {
         fprintf(stderr, "%s", prefix);
         printf_point(" = [ ", rows[0], dim, " ], ");
-        // We cannot use %zu for size_t because of MingW compiler used by CRAN.
+        // The 32-bit MinGW toolchain from Rtools 4.0 does not support %zu.
         fprintf(stderr, "%s = %lu\n", size_lab, (unsigned long) size);
         print_rows(rows, size, dim);
     } else {

c/whv.c

@@ -77,13 +77,13 @@ rect_weighted_hv2d(double *data, int n, double * rectangles,
                    int rectangles_nrow, const double * reference)
 {
 #define debug_print_point(k, p, r, rect)                                       \
-    DEBUG2_PRINT("%d: p[%lu] = (%16.15g, %16.15g)"                             \
-                 "\trectangle[%lu] = (%16.15g, %16.15g, %16.15g, %16.15g)\n",  \
-                 __LINE__, (unsigned long) k, p[0], p[1], (unsigned long) r, rect[0], rect[1], rect[2], rect[3])
+    DEBUG2_PRINT("%d: p[%zu] = (%16.15g, %16.15g)"                             \
+                 "\trectangle[%zu] = (%16.15g, %16.15g, %16.15g, %16.15g)\n",  \
+                 __LINE__, (size_t) k, p[0], p[1], (size_t) r, rect[0], rect[1], rect[2], rect[3])
 
 #define debug_print_rect(r, rect)                                              \
-    DEBUG2_PRINT("%d: rectangle[%lu] = (%16.15g, %16.15g, %16.15g, %16.15g, %16.15g)\n", \
-                 __LINE__, (unsigned long) r, rect[0], rect[1], rect[2], rect[3], rect[4])
+    DEBUG2_PRINT("%d: rectangle[%zu] = (%16.15g, %16.15g, %16.15g, %16.15g, %16.15g)\n", \
+                 __LINE__, (size_t) r, rect[0], rect[1], rect[2], rect[3], rect[4])
 
 // rectangles: Two points per row + color
 // FIXME: Should we really allow color == 0
@@ -106,8 +106,7 @@ rect_weighted_hv2d(double *data, int n, double * rectangles,
         debug_print_point(pk, p, r, rect);                                     \
     } while(0)
 
-    // We cannot use %zu for size_t because of MingW compiler used by CRAN.
-    DEBUG2_PRINT("n = %lu\trectangles = %lu\n", (unsigned long)n, (unsigned long)rectangles_nrow);
+    DEBUG2_PRINT("n = %zu\trectangles = %zu\n", (size_t)n, (size_t)rectangles_nrow);
     if (rectangles_nrow <= 0 || n <= 0) return 0;
 
     int old_rectangles_nrow = rectangles_nrow;