Add scalar soft-to-hard conversion helper

Signed-off-by: Melody Ren <melodyr@nvidia.com>

Author: melody-ren

libs/qec/include/cudaq/qec/decoder.h

@@ -282,6 +282,16 @@ class decoder
   std::vector<std::vector<uint32_t>> D_sparse;
 };
 
+/// @brief Convert a single soft probability to a hard 0/1 decision.
+/// @param in Soft probability input in range [0.0, 1.0]
+/// @param thresh Values >= thresh return true; all others return false.
+template <typename t_soft,
+          typename std::enable_if<std::is_floating_point<t_soft>::value,
+                                  int>::type = 0>
+constexpr inline bool convert_soft_to_hard(t_soft in, t_soft thresh = 0.5) {
+  return in >= thresh;
+}
+
 /// @brief Convert a vector of soft probabilities to a vector of hard
 /// probabilities.
 /// @param in Soft probability input vector in range [0.0, 1.0]
@@ -298,7 +308,7 @@ inline void convert_vec_soft_to_hard(const std::vector<t_soft> &in,
                                      t_soft thresh = 0.5) {
   out.resize(in.size());
   for (std::size_t i = 0; i < in.size(); i++)
-    out[i] = static_cast<t_hard>(in[i] >= thresh ? 1 : 0);
+    out[i] = static_cast<t_hard>(convert_soft_to_hard(in[i], thresh));
 }
 
 /// @brief Convert a vector of soft probabilities to a tensor<uint8_t> of hard
@@ -326,7 +336,7 @@ inline void convert_vec_soft_to_tensor_hard(const std::vector<t_soft> &in,
         "Vector to tensor conversion requires tensor dim == vector length");
   auto raw_ptr = out.data();
   for (size_t i = 0; i < in.size(); ++i)
-    raw_ptr[i] = static_cast<t_hard>(in[i] >= thresh ? 1 : 0);
+    raw_ptr[i] = static_cast<t_hard>(convert_soft_to_hard(in[i], thresh));
 }
 
 /// @brief Convert a vector of hard probabilities to a vector of soft
@@ -392,7 +402,7 @@ inline void convert_vec_soft_to_hard(const std::vector<std::vector<t_soft>> &in,
     auto &out_row = out[row_index++];
     out_row.resize(r.size());
     for (std::size_t c = 0; c < r.size(); c++)
-      out_row[c] = static_cast<t_hard>(r[c] >= thresh ? 1 : 0);
+      out_row[c] = static_cast<t_hard>(convert_soft_to_hard(r[c], thresh));
   }
 }
 

libs/qec/lib/decoders/lut.cpp

@@ -172,14 +172,12 @@ class multi_error_lut : public decoder {
     decoder_result result{false, std::vector<float_t>(block_size, 0.0)};
 
     // Convert syndrome to a string
-    std::vector<uint8_t> hard_syndrome;
-    cudaq::qec::convert_vec_soft_to_hard(syndrome, hard_syndrome);
-    std::string syndrome_str(hard_syndrome.size(), '0');
+    std::string syndrome_str(syndrome.size(), '0');
     int syndrome_weight = 0;
     assert(syndrome_str.length() == syndrome_size);
     bool anyErrors = false;
     for (std::size_t i = 0; i < syndrome_size; i++) {
-      if (hard_syndrome[i]) {
+      if (cudaq::qec::convert_soft_to_hard(syndrome[i])) {
         syndrome_str[i] = '1';
         anyErrors = true;
         syndrome_weight++;

libs/qec/lib/decoders/plugins/example/single_error_lut_example.cpp

@@ -49,13 +49,11 @@ class single_error_lut_example : public decoder {
     decoder_result result{false, std::vector<float_t>(block_size, 0.0)};
 
     // Convert syndrome to a string
-    std::vector<uint8_t> hard_syndrome;
-    cudaq::qec::convert_vec_soft_to_hard(syndrome, hard_syndrome);
-    std::string syndrome_str(hard_syndrome.size(), '0');
+    std::string syndrome_str(syndrome.size(), '0');
     assert(syndrome_str.length() == syndrome_size);
     bool anyErrors = false;
     for (std::size_t i = 0; i < syndrome_size; i++) {
-      if (hard_syndrome[i]) {
+      if (cudaq::qec::convert_soft_to_hard(syndrome[i])) {
         syndrome_str[i] = '1';
         anyErrors = true;
       }

libs/qec/lib/decoders/plugins/pymatching/pymatching.cpp

@@ -167,12 +167,10 @@ class pymatching : public decoder {
     auto t1 = std::chrono::high_resolution_clock::now();
 #endif
 
-    std::vector<uint8_t> hard_syndrome;
-    cudaq::qec::convert_vec_soft_to_hard(syndrome, hard_syndrome);
     std::vector<uint64_t> detection_events;
-    detection_events.reserve(hard_syndrome.size());
-    for (size_t i = 0; i < hard_syndrome.size(); i++)
-      if (hard_syndrome[i])
+    detection_events.reserve(syndrome.size());
+    for (size_t i = 0; i < syndrome.size(); i++)
+      if (cudaq::qec::convert_soft_to_hard(syndrome[i]))
         detection_events.push_back(i);
 #if PERFORM_TIMING
     auto t2 = std::chrono::high_resolution_clock::now();

libs/qec/lib/decoders/plugins/trt_decoder/trt_decoder.cpp

@@ -926,7 +926,6 @@ std::vector<decoder_result> trt_decoder::decode_batch_impl(
       // Prepare input batch. For float input we preserve soft (raw) values;
       // for uint8 we binarize to 0/1.
       std::vector<IoType> input_host(impl_->input_size);
-      std::vector<uint8_t> hard_syndrome;
       for (size_t batch_idx = 0; batch_idx < actual_batch; ++batch_idx) {
         const auto &syndrome = syndromes[batch_start + batch_idx];
         if constexpr (std::is_same_v<IoType, float>) {
@@ -935,10 +934,10 @@ std::vector<decoder_result> trt_decoder::decode_batch_impl(
                 static_cast<IoType>(syndrome[i]);
           }
         } else {
-          cudaq::qec::convert_vec_soft_to_hard(syndrome, hard_syndrome);
           for (size_t i = 0; i < syndrome_size_per_sample_; ++i) {
             input_host[batch_idx * syndrome_size_per_sample_ + i] =
-                static_cast<IoType>(hard_syndrome[i]);
+                static_cast<IoType>(
+                    cudaq::qec::convert_soft_to_hard(syndrome[i]));
           }
         }
       }

libs/qec/unittests/test_decoders.cpp

@@ -75,6 +75,27 @@ TEST(DecoderUtils, CovertSoftToHard) {
   }
 }
 
+TEST(DecoderUtils, ConvertSoftToHardScalar) {
+  // Default threshold (0.5): the canonical >= contract.
+  EXPECT_TRUE(cudaq::qec::convert_soft_to_hard(0.6f));
+  EXPECT_FALSE(cudaq::qec::convert_soft_to_hard(0.4f));
+  EXPECT_TRUE(cudaq::qec::convert_soft_to_hard(0.5f));
+  EXPECT_FALSE(cudaq::qec::convert_soft_to_hard(0.499f));
+  EXPECT_TRUE(cudaq::qec::convert_soft_to_hard(0.501f));
+
+  // Double-precision input.
+  EXPECT_TRUE(cudaq::qec::convert_soft_to_hard(0.5));
+  EXPECT_FALSE(cudaq::qec::convert_soft_to_hard(0.499));
+
+  // Custom threshold.
+  EXPECT_TRUE(cudaq::qec::convert_soft_to_hard(0.4f, 0.4f));
+  EXPECT_FALSE(cudaq::qec::convert_soft_to_hard(0.3f, 0.4f));
+
+  // Usable in a constant-expression context.
+  static_assert(cudaq::qec::convert_soft_to_hard(0.5f));
+  static_assert(!cudaq::qec::convert_soft_to_hard(0.49f));
+}
+
 TEST(DecoderUtils, ConvertVecSoftToTensorHard) {
   // Generate a million random floats between 0 and 1 using mt19937
   std::mt19937_64 gen(13);