Switched I to be a template type to avoid requiring a copy constructor.

Author: LTLA

include/scran_markers/auc.hpp

@@ -16,21 +16,21 @@ namespace internal {
 template<typename Value_, typename Group_, typename Output_>
 struct AucWorkspace {
     AucWorkspace(const std::size_t ngroups, Output_* const buffer) : 
-        less_than(sanisizer::cast<decltype(I(less_than.size()))>(ngroups)
+        less_than(sanisizer::cast<I<decltype(less_than.size())> >(ngroups)
 #ifdef SCRAN_MARKERS_TEST_INIT
             , SCRAN_MARKERS_TEST_INIT
 #endif
         ),
-        equal(sanisizer::cast<decltype(I(equal.size()))>(ngroups)
+        equal(sanisizer::cast<I<decltype(equal.size())> >(ngroups)
 #ifdef SCRAN_MARKERS_TEST_INIT
             , SCRAN_MARKERS_TEST_INIT
 #endif
         ),
-        outputs(sanisizer::cast<decltype(I(outputs.size()))>(ngroups)),
+        outputs(sanisizer::cast<I<decltype(outputs.size())> >(ngroups)),
         output_start(buffer),
         output_end(buffer)
     {
-        for (decltype(I(ngroups)) i = 0; i < ngroups; ++i) {
+        for (I<decltype(ngroups)> i = 0; i < ngroups; ++i) {
             outputs[i] = output_end;
             output_end += ngroups;
         }
@@ -66,7 +66,7 @@ void compute_pairwise_auc(AucWorkspace<Value_, Group_, Output_>& work, const std
     const auto ngroups = num_zeros.size();
 
     const auto num_input = input.size();
-    typedef decltype(I(num_input)) Position;
+    typedef I<decltype(num_input)> Position;
 
     auto inner_loop = [&](Position& pos) -> void {
         const auto& current = input[pos];
@@ -82,17 +82,17 @@ void compute_pairwise_auc(AucWorkspace<Value_, Group_, Output_>& work, const std
         if (tied) {
             ++equal[current.second]; // contribution of the current (tied) observation.
 
-            for (decltype(I(ngroups)) l = 1; l < ngroups; ++l) { // starting from 1 as zero has no work for the g < l condition anyway.
+            for (I<decltype(ngroups)> l = 1; l < ngroups; ++l) { // starting from 1 as zero has no work for the g < l condition anyway.
                 const auto num_eq = equal[l];
                 if (num_eq) {
                     const auto outptr = outputs[l];
-                    for (decltype(I(l)) g = 0; g < l; ++g) {
+                    for (I<decltype(l)> g = 0; g < l; ++g) {
                         outptr[g] += num_eq * (less_than[g] + 0.5 * equal[g]);
                     }
                 }
             }
 
-            for (decltype(I(ngroups)) l = 0; l < ngroups; ++l) {
+            for (I<decltype(ngroups)> l = 0; l < ngroups; ++l) {
                 less_than[l] += equal[l];
                 equal[l] = 0;
             }
@@ -113,17 +113,17 @@ void compute_pairwise_auc(AucWorkspace<Value_, Group_, Output_>& work, const std
     }
 
     // Values == 0. 
-    for (decltype(I(ngroups)) l = 1; l < ngroups; ++l) { // starting from 1, see above.
+    for (I<decltype(ngroups)> l = 1; l < ngroups; ++l) { // starting from 1, see above.
         const auto num_z = num_zeros[l];
         if (num_z) {
             const auto outptr = outputs[l];
-            for (decltype(I(l)) g = 0; g < l; ++g) {
+            for (I<decltype(l)> g = 0; g < l; ++g) {
                 outptr[g] += num_z * (less_than[g] + 0.5 * num_zeros[g]);
             }
         }
     }
 
-    for (decltype(I(ngroups)) l = 0; l < ngroups; ++l) {
+    for (I<decltype(ngroups)> l = 0; l < ngroups; ++l) {
         less_than[l] += num_zeros[l];
     }
 
@@ -134,8 +134,8 @@ void compute_pairwise_auc(AucWorkspace<Value_, Group_, Output_>& work, const std
     }
 
     // Filling in the other side.
-    for (decltype(I(ngroups)) l = 1; l < ngroups; ++l) { // starting from 1, see above.
-        for (decltype(I(l)) g = 0; g < l; ++g) {
+    for (I<decltype(ngroups)> l = 1; l < ngroups; ++l) { // starting from 1, see above.
+        for (I<decltype(l)> g = 0; g < l; ++g) {
             const Output_ prod = static_cast<Output_>(totals[l]) * static_cast<Output_>(totals[g]);
             outputs[g][l] = prod - outputs[l][g];
 
@@ -163,7 +163,7 @@ void compute_pairwise_auc(AucWorkspace<Value_, Group_, Output_>& work, const std
     const auto ngroups = num_zeros.size();
 
     const auto num_input = input.size();
-    typedef decltype(I(num_input)) Position;
+    typedef I<decltype(num_input)> Position;
 
     auto inner_loop = [&](Position& pos, Position& comp) -> void {
         const auto& current = input[pos];
@@ -186,20 +186,20 @@ void compute_pairwise_auc(AucWorkspace<Value_, Group_, Output_>& work, const std
         if (tied) {
             do {
                 const auto outptr = outputs[input[pos].second];
-                for (decltype(I(ngroups)) g = 0; g < ngroups; ++g) {
+                for (I<decltype(ngroups)> g = 0; g < ngroups; ++g) {
                     outptr[g] += less_than[g] + 0.5 * equal[g];
                 }
                 ++pos;
             } while (pos != num_input && input[pos].first == current.first);
 
-            for (decltype(I(ngroups)) l = 0; l < ngroups; ++l) {
+            for (I<decltype(ngroups)> l = 0; l < ngroups; ++l) {
                 less_than[l] += equal[l];
                 equal[l] = 0;
             }
         } else {
             do {
                 const auto outptr = outputs[input[pos].second];
-                for (decltype(I(ngroups)) g = 0; g < ngroups; ++g) {
+                for (I<decltype(ngroups)> g = 0; g < ngroups; ++g) {
                     outptr[g] += less_than[g];
                 }
                 ++pos;
@@ -244,11 +244,11 @@ void compute_pairwise_auc(AucWorkspace<Value_, Group_, Output_>& work, const std
             ++comp;
         }
 
-        for (decltype(I(ngroups)) l = 0; l < ngroups; ++l) {
+        for (I<decltype(ngroups)> l = 0; l < ngroups; ++l) {
             const auto num_z = num_zeros[l];
             if (num_z) {
                 const auto outptr = outputs[l];
-                for (decltype(I(ngroups)) g = 0; g < ngroups; ++g) {
+                for (I<decltype(ngroups)> g = 0; g < ngroups; ++g) {
                     outptr[g] += less_than[g] * num_z;
                 }
             }
@@ -263,29 +263,29 @@ void compute_pairwise_auc(AucWorkspace<Value_, Group_, Output_>& work, const std
         }
 
         if (tied) {
-            for (decltype(I(ngroups)) l = 0; l < ngroups; ++l) {
+            for (I<decltype(ngroups)> l = 0; l < ngroups; ++l) {
                 const auto num_z = num_zeros[l];
                 if (num_z) {
                     const auto outptr = outputs[l];
-                    for (decltype(I(ngroups)) g = 0; g < ngroups; ++g) {
+                    for (I<decltype(ngroups)> g = 0; g < ngroups; ++g) {
                         outptr[g] += 0.5 * equal[g] * num_z;
                     }
                 }
             }
 
-            for (decltype(I(ngroups)) l = 0; l < ngroups; ++l) {
+            for (I<decltype(ngroups)> l = 0; l < ngroups; ++l) {
                 less_than[l] += equal[l];
                 equal[l] = 0;
             }
         }
 
         // Or to each other, if the threshold is zero.
         if (threshold == 0) {
-            for (decltype(I(ngroups)) l = 0; l < ngroups; ++l) {
+            for (I<decltype(ngroups)> l = 0; l < ngroups; ++l) {
                 const auto num_z = num_zeros[l];
                 if (num_z) {
                     const auto outptr = outputs[l];
-                    for (decltype(I(ngroups)) g = 0; g < ngroups; ++g) {
+                    for (I<decltype(ngroups)> g = 0; g < ngroups; ++g) {
                         outptr[g] += num_z * 0.5 * num_zeros[g];
                     }
                 }
@@ -300,13 +300,13 @@ void compute_pairwise_auc(AucWorkspace<Value_, Group_, Output_>& work, const std
     // Adding the contribution of zeros (in terms of the limit _being_ at zero + threshold)
     while (pos != num_input && static_cast<Threshold_>(input[pos].first) == threshold) {
         const auto outptr = outputs[input[pos].second];
-        for (decltype(I(ngroups)) g = 0; g < ngroups; ++g) {
+        for (I<decltype(ngroups)> g = 0; g < ngroups; ++g) {
             outptr[g] += less_than[g] + 0.5 * num_zeros[g];
         }
         ++pos;
     }
 
-    for (decltype(I(ngroups)) l = 0; l < ngroups; ++l) {
+    for (I<decltype(ngroups)> l = 0; l < ngroups; ++l) {
         less_than[l] += num_zeros[l];
     }
 
@@ -316,8 +316,8 @@ void compute_pairwise_auc(AucWorkspace<Value_, Group_, Output_>& work, const std
 
     // Dividing by the product of sizes.
     if (normalize) {
-        for (decltype(I(ngroups)) l = 0; l < ngroups; ++l) {
-            for (decltype(I(ngroups)) g = 0; g < ngroups; ++g) {
+        for (I<decltype(ngroups)> l = 0; l < ngroups; ++l) {
+            for (I<decltype(ngroups)> g = 0; g < ngroups; ++g) {
                 const Output_ prod = static_cast<Output_>(totals[l]) * static_cast<Output_>(totals[g]);
                 if (prod) {
                     outputs[l][g] /= prod;

include/scran_markers/average_group_stats.hpp

@@ -16,8 +16,8 @@ namespace internal {
 template<typename Stat_>
 std::vector<Stat_> compute_total_weight_per_group(const std::size_t ngroups, const std::size_t nblocks, const Stat_* const combo_weights) {
     auto output = sanisizer::create<std::vector<Stat_> >(ngroups);
-    for (decltype(I(nblocks)) b = 0; b < nblocks; ++b) {
-        for (decltype(I(ngroups)) g = 0; g < ngroups; ++g) {
+    for (I<decltype(nblocks)> b = 0; b < nblocks; ++b) {
+        for (I<decltype(ngroups)> g = 0; g < ngroups; ++g) {
             output[g] += combo_weights[sanisizer::nd_offset<std::size_t>(g, ngroups, b)];
         }
     }
@@ -34,7 +34,7 @@ void average_group_stats_blockmean(
     const Stat_* const total_weights,
     const std::vector<Stat_*>& out_stats 
 ) {
-    for (decltype(I(ngroups)) g = 0; g < ngroups; ++g) {
+    for (I<decltype(ngroups)> g = 0; g < ngroups; ++g) {
         auto& output = out_stats[g][gene];
 
         const auto total_weight = total_weights[g];
@@ -44,7 +44,7 @@ void average_group_stats_blockmean(
         }
 
         Stat_ sum = 0;
-        for (decltype(I(nblocks)) b = 0; b < nblocks; ++b) {
+        for (I<decltype(nblocks)> b = 0; b < nblocks; ++b) {
             // Remember, blocks are the slower changing dimension, so we need to jump by 'ngroups'.
             const auto offset = sanisizer::nd_offset<std::size_t>(g, ngroups, b);
             const auto& curweight = combo_weights[offset];
@@ -67,10 +67,10 @@ void average_group_stats_blockquantile(
     scran_blocks::SingleQuantileVariable<Stat_, typename std::vector<Stat_>::iterator>& qcalc,
     const std::vector<Stat_*>& out_stats 
 ) {
-    for (decltype(I(ngroups)) g = 0; g < ngroups; ++g) {
+    for (I<decltype(ngroups)> g = 0; g < ngroups; ++g) {
         buffer.clear();
 
-        for (decltype(I(nblocks)) b = 0; b < nblocks; ++b) {
+        for (I<decltype(nblocks)> b = 0; b < nblocks; ++b) {
             // Remember, blocks are the slower changing dimension, so we need to jump by 'ngroups'.
             const auto offset = sanisizer::nd_offset<std::size_t>(g, ngroups, b);
             const auto val = stats[offset];
@@ -92,9 +92,9 @@ void preallocate_average_results(
 ) {
     res.reserve(ngroups);
     ptrs.reserve(ngroups);
-    for (decltype(I(ngroups)) g = 0; g < ngroups; ++g) {
+    for (I<decltype(ngroups)> g = 0; g < ngroups; ++g) {
         res.emplace_back(
-            sanisizer::cast<decltype(I(res.front().size()))>(ngenes)
+            sanisizer::cast<I<decltype(res.front().size())> >(ngenes)
 #ifdef SCRAN_MARKERS_TEST_INIT
             , SCRAN_MARKERS_TEST_INIT
 #endif

include/scran_markers/block_averages.hpp

@@ -36,20 +36,20 @@ class PrecomputedPairwiseWeights {
     // 'combo_weights' are expected to be 'ngroups * nblocks' arrays where
     // groups are the faster-changing dimension and the blocks are slower.
     PrecomputedPairwiseWeights(const std::size_t ngroups, const std::size_t nblocks, const Stat_* const combo_weights) :
-        my_total(sanisizer::product<decltype(I(my_total.size()))>(ngroups, ngroups)),
-        my_by_block(sanisizer::product<decltype(I(my_by_block.size()))>(my_total.size(), nblocks)),
+        my_total(sanisizer::product<I<decltype(my_total.size())> >(ngroups, ngroups)),
+        my_by_block(sanisizer::product<I<decltype(my_by_block.size())> >(my_total.size(), nblocks)),
         my_ngroups(ngroups),
         my_nblocks(nblocks)
     {
         auto blocks_in_use = sanisizer::create<std::vector<std::size_t> >(my_total.size());
-        for (decltype(I(nblocks)) b = 0; b < nblocks; ++b) {
-            for (decltype(I(ngroups)) g1 = 1; g1 < ngroups; ++g1) {
+        for (I<decltype(nblocks)> b = 0; b < nblocks; ++b) {
+            for (I<decltype(ngroups)> g1 = 1; g1 < ngroups; ++g1) {
                 const auto w1 = combo_weights[sanisizer::nd_offset<std::size_t>(g1, ngroups, b)];
                 if (w1 == 0) {
                     continue;
                 }
 
-                for (decltype(I(g1)) g2 = 0; g2 < g1; ++g2) {
+                for (I<decltype(g1)> g2 = 0; g2 < g1; ++g2) {
                     const auto w2 = combo_weights[sanisizer::nd_offset<std::size_t>(g2, ngroups, b)];
                     if (w2 == 0) {
                         continue;
@@ -71,15 +71,15 @@ class PrecomputedPairwiseWeights {
         // So, we set the weight to 1 to ensure that the weighted mean calculation is a no-op,
         // i.e., there won't be any introduction of floating-point errors from a mult/div by the weight. 
         // Zero weights do need to be preserved, though, as mult/div by zero gives NaN.
-        for (decltype(I(ngroups)) g1 = 1; g1 < ngroups; ++g1) {
-            for (decltype(I(g1)) g2 = 0; g2 < g1; ++g2) {
+        for (I<decltype(ngroups)> g1 = 1; g1 < ngroups; ++g1) {
+            for (I<decltype(g1)> g2 = 0; g2 < g1; ++g2) {
                 const auto out_offset1 = sanisizer::nd_offset<std::size_t>(g2, ngroups, g1);
                 if (blocks_in_use[out_offset1] != 1) {
                     continue;
                 }
 
                 my_total[out_offset1] = 1;
-                for (decltype(I(nblocks)) b = 0; b < nblocks; ++b) {
+                for (I<decltype(nblocks)> b = 0; b < nblocks; ++b) {
                     auto& curweight = my_by_block[sanisizer::nd_offset<std::size_t>(b, nblocks, out_offset1)];
                     curweight = (curweight > 0);
                     my_by_block[sanisizer::nd_offset<std::size_t>(b, nblocks, g1, ngroups, g2)] = curweight;
@@ -88,8 +88,8 @@ class PrecomputedPairwiseWeights {
         }
 
         // Filling the other side of my_totals, for completeness.
-        for (decltype(I(ngroups)) g1 = 1; g1 < ngroups; ++g1) {
-            for (decltype(I(g1)) g2 = 0; g2 < g1; ++g2) {
+        for (I<decltype(ngroups)> g1 = 1; g1 < ngroups; ++g1) {
+            for (I<decltype(g1)> g2 = 0; g2 < g1; ++g2) {
                 my_total[sanisizer::nd_offset<std::size_t>(g1, ngroups, g2)] = my_total[sanisizer::nd_offset<std::size_t>(g2, ngroups, g1)];
             }
         }

include/scran_markers/cohens_d.hpp

@@ -76,7 +76,7 @@ std::pair<Stat_, Stat_> compute_cohens_d_blockmean(
 
     std::pair<Stat_, Stat_> output(0, 0);
     Stat_ total_weight = 0; // need to calculate it dynamically, in case there are NaN variances for non-zero weights (e.g., one observation per block).
-    for (decltype(I(nblocks)) b = 0; b < nblocks; ++b) {
+    for (I<decltype(nblocks)> b = 0; b < nblocks; ++b) {
         const auto weight = winfo.first[b];
         if (weight == 0) {
             continue;
@@ -125,8 +125,8 @@ void compute_pairwise_cohens_d_blockmean(
     const PrecomputedPairwiseWeights<Stat_>& preweights,
     Stat_* const output)
 {
-    for (decltype(I(ngroups)) g1 = 0; g1 < ngroups; ++g1) {
-        for (decltype(I(g1)) g2 = 0; g2 < g1; ++g2) {
+    for (I<decltype(ngroups)> g1 = 0; g1 < ngroups; ++g1) {
+        for (I<decltype(g1)> g2 = 0; g2 < g1; ++g2) {
             const auto tmp = compute_cohens_d_blockmean(g1, g2, means, vars, ngroups, nblocks, threshold, preweights);
             output[sanisizer::nd_offset<std::size_t>(g2, ngroups, g1)] = tmp.first;
             output[sanisizer::nd_offset<std::size_t>(g1, ngroups, g2)] = tmp.second;
@@ -151,7 +151,7 @@ std::pair<Stat_, Stat_> compute_cohens_d_blockquantile(
     buffer.clear();
     rev_buffer.clear();
 
-    for (decltype(I(nblocks)) b = 0; b < nblocks; ++b) {
+    for (I<decltype(nblocks)> b = 0; b < nblocks; ++b) {
         const auto offset1 = sanisizer::nd_offset<std::size_t>(g1, ngroups, b); // remember, 'groups' is the faster-changing dimension.
         const auto offset2 = sanisizer::nd_offset<std::size_t>(g2, ngroups, b);
         const auto left_var = vars[offset1];
@@ -200,8 +200,8 @@ void compute_pairwise_cohens_d_blockquantile(
     scran_blocks::SingleQuantileVariable<Stat_, typename std::vector<Stat_>::iterator>& qcalc,
     Stat_* const output
 ) {
-    for (decltype(I(ngroups)) g1 = 0; g1 < ngroups; ++g1) {
-        for (decltype(I(g1)) g2 = 0; g2 < g1; ++g2) {
+    for (I<decltype(ngroups)> g1 = 0; g1 < ngroups; ++g1) {
+        for (I<decltype(g1)> g2 = 0; g2 < g1; ++g2) {
             const auto tmp = compute_cohens_d_blockquantile(g1, g2, means, vars, ngroups, nblocks, threshold, buffer, rev_buffer, qcalc);
             output[sanisizer::nd_offset<std::size_t>(g2, ngroups, g1)] = tmp.first;
             output[sanisizer::nd_offset<std::size_t>(g1, ngroups, g2)] = tmp.second;

include/scran_markers/create_combinations.hpp

@@ -20,7 +20,7 @@ namespace internal {
 template<typename Group_, typename Block_>
 std::vector<std::size_t> create_combinations(const std::size_t ngroups, const Group_* const group, const Block_* const block, const std::size_t NC) {
     auto combinations = sanisizer::create<std::vector<std::size_t> >(NC);
-    for (decltype(I(NC)) c = 0; c < NC; ++c) {
+    for (I<decltype(NC)> c = 0; c < NC; ++c) {
         combinations[c] = sanisizer::nd_offset<std::size_t>(group[c], ngroups, block[c]); // group is the faster changing dimension.
     }
     return combinations;