Add braces around single-line control flow statements (#5090)

Summary:
Pull Request resolved: #5090

Fix 136 `readability-braces-around-statements` lint warnings by adding braces to all single-line `if`, `else`, `for`, and `while` statements across 4 files: `IndexLSH.cpp` (14 issues), `IndexIVFPQ.cpp` (36 issues), `IndexPQ.cpp` (25 issues), and `VectorTransform.cpp` (61 issues). This improves code readability and prevents bugs from accidentally adding statements to unbraced blocks.

Reviewed By: mnorris11

Differential Revision: D100580151

Author: junjieqi

faiss/IndexIVFPQ.cpp

@@ -71,8 +71,9 @@ void IndexIVFPQ::train_encoder(
     pq.train(n, x);
 
     if (do_polysemous_training) {
-        if (verbose)
+        if (verbose) {
             printf("doing polysemous training for PQ\n");
+        }
         PolysemousTraining default_pt;
         PolysemousTraining* pt =
                 polysemous_training ? polysemous_training : &default_pt;
@@ -97,8 +98,9 @@ void IndexIVFPQ::encode(idx_t key, const float* x, uint8_t* code) const {
         std::vector<float> residual_vec(d);
         quantizer->compute_residual(x, residual_vec.data(), key);
         pq.compute_code(residual_vec.data(), code);
-    } else
+    } else {
         pq.compute_code(x, code);
+    }
 }
 
 void IndexIVFPQ::encode_multiple(
@@ -107,8 +109,9 @@ void IndexIVFPQ::encode_multiple(
         const float* x,
         uint8_t* xcodes,
         bool compute_keys) const {
-    if (compute_keys)
+    if (compute_keys) {
         quantizer->assign(n, x, keys);
+    }
 
     encode_vectors(n, x, keys, xcodes);
 }
@@ -153,11 +156,12 @@ static std::unique_ptr<float[]> compute_residuals(
     // Parallelize with OpenMP (each iteration is independent)
 #pragma omp parallel for if (n > 1000)
     for (idx_t i = 0; i < n; i++) {
-        if (list_nos[i] < 0)
+        if (list_nos[i] < 0) {
             memset(residuals.get() + i * d, 0, sizeof(float) * d);
-        else
+        } else {
             quantizer->compute_residual(
                     x + i * d, residuals.get() + i * d, list_nos[i]);
+        }
     }
     return residuals;
 }
@@ -290,8 +294,9 @@ void IndexIVFPQ::add_core_o(
         if (key < 0) {
             direct_map.add_single_id(id, -1, 0);
             n_ignore++;
-            if (residuals_2)
+            if (residuals_2) {
                 memset(residuals_2, 0, sizeof(*residuals_2) * d);
+            }
             continue;
         }
 
@@ -303,8 +308,9 @@ void IndexIVFPQ::add_core_o(
             float* res2 = residuals_2 + i * d;
             const float* xi = to_encode + i * d;
             pq.decode(code, res2);
-            for (int j = 0; j < d; j++)
+            for (int j = 0; j < d; j++) {
                 res2[j] = xi[j] - res2[j];
+            }
         }
 
         direct_map.add_single_id(id, key, offset);
@@ -313,8 +319,9 @@ void IndexIVFPQ::add_core_o(
     double t3 = getmillisecs();
     if (verbose) {
         char comment[100] = {0};
-        if (n_ignore > 0)
+        if (n_ignore > 0) {
             snprintf(comment, 100, "(%zd vectors ignored)", n_ignore);
+        }
         printf(" add_core times: %.3f %.3f %.3f %s\n",
                t1 - t0,
                t2 - t1,
@@ -401,9 +408,9 @@ void initialize_IVFPQ_precomputed_table(
         }
         const MultiIndexQuantizer* miq =
                 dynamic_cast<const MultiIndexQuantizer*>(quantizer);
-        if (miq && pq.M % miq->pq.M == 0)
+        if (miq && pq.M % miq->pq.M == 0) {
             use_precomputed_table = 2;
-        else {
+        } else {
             size_t table_size = pq.M * pq.ksub * nlist * sizeof(float);
             if (table_size > precomputed_table_max_bytes) {
                 if (verbose) {
@@ -425,11 +432,12 @@ void initialize_IVFPQ_precomputed_table(
 
     // squared norms of the PQ centroids
     std::vector<float> r_norms(pq.M * pq.ksub, NAN);
-    for (size_t m = 0; m < pq.M; m++)
+    for (size_t m = 0; m < pq.M; m++) {
         for (size_t j = 0; j < pq.ksub; j++) {
             r_norms[m * pq.ksub + j] =
                     fvec_norm_L2sqr_dispatch(pq.get_centroids(m, j), pq.dsub);
         }
+    }
 
     if (use_precomputed_table == 1) {
         precomputed_table.resize(nlist * pq.M * pq.ksub);
@@ -559,12 +567,14 @@ struct QueryTables {
     // query-specific initialization
     void init_query(const float* qi_in) {
         this->qi = qi_in;
-        if (metric_type == METRIC_INNER_PRODUCT)
+        if (metric_type == METRIC_INNER_PRODUCT) {
             init_query_IP();
-        else
+        } else {
             init_query_L2();
-        if (!by_residual && polysemous_ht != 0)
+        }
+        if (!by_residual && polysemous_ht != 0) {
             pq.compute_code(qi_in, q_code.data());
+        }
     }
 
     void init_query_IP() {
@@ -599,10 +609,11 @@ struct QueryTables {
         uint64_t t0;
         TIC;
         if (by_residual) {
-            if (metric_type == METRIC_INNER_PRODUCT)
+            if (metric_type == METRIC_INNER_PRODUCT) {
                 dis0 = precompute_list_tables_IP();
-            else
+            } else {
                 dis0 = precompute_list_tables_L2();
+            }
         }
         init_list_cycles += TOC;
         return dis0;
@@ -613,10 +624,11 @@ struct QueryTables {
         uint64_t t0;
         TIC;
         if (by_residual) {
-            if (metric_type == METRIC_INNER_PRODUCT)
+            if (metric_type == METRIC_INNER_PRODUCT) {
                 FAISS_THROW_MSG("not implemented");
-            else
+            } else {
                 dis0 = precompute_list_table_pointers_L2();
+            }
         }
         init_list_cycles += TOC;
         return dis0;
@@ -1328,8 +1340,9 @@ size_t IndexIVFPQ::find_duplicates(idx_t* dup_ids, size_t* lims) const {
     for (size_t list_no = 0; list_no < nlist; list_no++) {
         size_t n = invlists->list_size(list_no);
         std::vector<int> ord(n);
-        for (size_t i = 0; i < n; i++)
+        for (size_t i = 0; i < n; i++) {
             ord[i] = static_cast<int>(i);
+        }
         InvertedLists::ScopedCodes codes(invlists, list_no);
         CodeCmp cs = {codes.get(), code_size};
         std::sort(ord.begin(), ord.end(), cs);

faiss/IndexLSH.cpp

@@ -58,8 +58,9 @@ const float* IndexLSH::apply_preprocess(idx_t n, const float* x) const {
         float* xp = xt;
         for (idx_t i = 0; i < n; i++) {
             const float* xl = x + i * d;
-            for (int j = 0; j < nbits; j++)
+            for (int j = 0; j < nbits; j++) {
                 *xp++ = xl[j];
+            }
         }
     }
 
@@ -70,9 +71,11 @@ const float* IndexLSH::apply_preprocess(idx_t n, const float* x) const {
         }
 
         float* xp = xt;
-        for (idx_t i = 0; i < n; i++)
-            for (int j = 0; j < nbits; j++)
+        for (idx_t i = 0; i < n; i++) {
+            for (int j = 0; j < nbits; j++) {
                 *xp++ -= thresholds[j];
+            }
+        }
     }
 
     return xt ? xt : x;
@@ -88,9 +91,11 @@ void IndexLSH::train(idx_t n, const float* x) {
 
         std::unique_ptr<float[]> transposed_x(new float[n * nbits]);
 
-        for (idx_t i = 0; i < n; i++)
-            for (idx_t j = 0; j < nbits; j++)
+        for (idx_t i = 0; i < n; i++) {
+            for (idx_t j = 0; j < nbits; j++) {
                 transposed_x[j * n + i] = xt[i * nbits + j];
+            }
+        }
 
         for (idx_t i = 0; i < nbits; i++) {
             float* xi = transposed_x.get() + i * n;
@@ -132,20 +137,23 @@ void IndexLSH::search(
     hammings_knn_hc(&res, qcodes.get(), codes.data(), ntotal, code_size, true);
 
     // convert distances to floats
-    for (int i = 0; i < k * n; i++)
+    for (int i = 0; i < k * n; i++) {
         distances[i] = idistances[i];
+    }
 }
 
 void IndexLSH::transfer_thresholds(LinearTransform* vt) {
-    if (!train_thresholds)
+    if (!train_thresholds) {
         return;
+    }
     FAISS_THROW_IF_NOT(nbits == vt->d_out);
     if (!vt->have_bias) {
         vt->b.resize(nbits, 0);
         vt->have_bias = true;
     }
-    for (int i = 0; i < nbits; i++)
+    for (int i = 0; i < nbits; i++) {
         vt->b[i] -= thresholds[i];
+    }
     train_thresholds = false;
     thresholds.clear();
 }

faiss/IndexPQ.cpp

@@ -53,8 +53,9 @@ void IndexPQ::train(idx_t n, const float* x) {
     } else {
         idx_t ntrain_perm = polysemous_training.ntrain_permutation;
 
-        if (ntrain_perm > n / 4)
+        if (ntrain_perm > n / 4) {
             ntrain_perm = n / 4;
+        }
         if (verbose) {
             printf("PQ training on %" PRId64 " points, remains %" PRId64
                    " points: "
@@ -222,9 +223,11 @@ void IndexPQ::search(
             for (idx_t i = 0; i < n; i++) {
                 const float* xi = x + i * d;
                 uint8_t* code = q_codes.get() + i * pq.code_size;
-                for (size_t j = 0; j < static_cast<size_t>(d); j++)
-                    if (xi[j] > 0)
+                for (size_t j = 0; j < static_cast<size_t>(d); j++) {
+                    if (xi[j] > 0) {
                         code[j >> 3] |= 1 << (j & 7);
+                    }
+                }
             }
         }
 
@@ -260,8 +263,9 @@ void IndexPQ::search(
             }
 
             // convert distances to floats
-            for (idx_t i = 0; i < k * n; i++)
+            for (idx_t i = 0; i < k * n; i++) {
                 distances[i] = idistances[i];
+            }
         }
 
         indexPQ_stats.nq += n;
@@ -495,8 +499,9 @@ void IndexPQ::hamming_distance_histogram(
         for (idx_t q0 = 0; q0 < n; q0 += bs) {
             // printf ("dis stats: %zd/%zd\n", q0, n);
             size_t q1 = q0 + bs;
-            if (q1 > static_cast<size_t>(n))
+            if (q1 > static_cast<size_t>(n)) {
                 q1 = n;
+            }
 
             hammings(
                     q_codes.get() + q0 * pq.code_size,
@@ -506,13 +511,15 @@ void IndexPQ::hamming_distance_histogram(
                     pq.code_size,
                     distances.get());
 
-            for (size_t i = 0; i < nb * (q1 - q0); i++)
+            for (size_t i = 0; i < nb * (q1 - q0); i++) {
                 histi[distances[i]]++;
+            }
         }
 #pragma omp critical
         {
-            for (int i = 0; i <= nbits; i++)
+            for (int i = 0; i <= nbits; i++) {
                 hist[i] += histi[i];
+            }
         }
     }
 }
@@ -572,8 +579,9 @@ struct SortedArray {
 
     void init(const T* x_2) {
         this->x = x_2;
-        for (int n = 0; n < N; n++)
+        for (int n = 0; n < N; n++) {
             perm[n] = n;
+        }
         ArgSort<T> cmp = {x_2};
         std::sort(perm.begin(), perm.end(), cmp);
     }
@@ -654,8 +662,9 @@ struct SemiSortedArray {
 
     void init(const T* x_2) {
         this->x = x_2;
-        for (int n = 0; n < N; n++)
+        for (int n = 0; n < N; n++) {
             perm[n] = n;
+        }
         k = 0;
         grow(initial_k);
     }
@@ -758,8 +767,9 @@ struct MinSumK {
             seen.resize((n_ids + 7) / 8);
         }
 
-        for (int m = 0; m < M; m++)
+        for (int m = 0; m < M; m++) {
             ssx.push_back(SSA(N));
+        }
     }
 
     int64_t weight(int i) {
@@ -771,8 +781,9 @@ struct MinSumK {
     }
 
     void mark_seen(int64_t i) {
-        if (use_seen)
+        if (use_seen) {
             seen[i >> 3] |= 1 << (i & 7);
+        }
     }
 
     void run(const T* x, int64_t ldx, T* sums, int64_t* terms) {
@@ -828,8 +839,9 @@ struct MinSumK {
             for (int m = 0; m < M; m++) {
                 int64_t n = ii & (((int64_t)1 << nbit) - 1);
                 ii >>= nbit;
-                if (n + 1 >= N)
+                if (n + 1 >= N) {
                     continue;
+                }
 
                 enqueue_follower(ti, m, n, sum);
             }
@@ -884,8 +896,9 @@ void MultiIndexQuantizer::train(idx_t n, const float* x) {
     is_trained = true;
     // count virtual elements in index
     ntotal = 1;
-    for (size_t m = 0; m < pq.M; m++)
+    for (size_t m = 0; m < pq.M; m++) {
         ntotal *= pq.ksub;
+    }
 }
 
 // block size used in MultiIndexQuantizer::search