faiss 0.5.3 → 0.6.1

data/vendor/faiss/faiss/VectorTransform.cpp

@@ -150,7 +150,9 @@ void VectorTransform::reverse_transform(idx_t, const float*, float*) const {
 }
 
 void VectorTransform::check_identical(const VectorTransform& other) const {
-    FAISS_THROW_IF_NOT(other.d_in == d_in && other.d_in == d_in);
+    FAISS_THROW_IF_NOT_MSG(
+            other.d_in == d_in && other.d_out == d_out,
+            "transforms must have matching d_in and d_out");
 }
 
 /*********************************************
@@ -158,9 +160,9 @@ void VectorTransform::check_identical(const VectorTransform& other) const {
  *********************************************/
 
 /// both d_in > d_out and d_out < d_in are supported
-LinearTransform::LinearTransform(int d_in, int d_out, bool have_bias)
-        : VectorTransform(d_in, d_out),
-          have_bias(have_bias),
+LinearTransform::LinearTransform(int din, int dout, bool have_bias_in)
+        : VectorTransform(din, dout),
+          have_bias(have_bias_in),
           is_orthonormal(false),
           verbose(false) {
     is_trained = false; // will be trained when A and b are initialized
@@ -171,21 +173,25 @@ void LinearTransform::apply_noalloc(idx_t n, const float* x, float* xt) const {
 
     float c_factor;
     if (have_bias) {
-        FAISS_THROW_IF_NOT_MSG(b.size() == d_out, "Bias not initialized");
+        FAISS_THROW_IF_NOT_MSG(
+                b.size() == static_cast<size_t>(d_out), "Bias not initialized");
         float* xi = xt;
-        for (int i = 0; i < n; i++)
-            for (int j = 0; j < d_out; j++)
+        for (idx_t i = 0; i < n; i++) {
+            for (int j = 0; j < d_out; j++) {
                 *xi++ = b[j];
+            }
+        }
         c_factor = 1.0;
     } else {
         c_factor = 0.0;
     }
 
     FAISS_THROW_IF_NOT_MSG(
-            A.size() == d_out * d_in, "Transformation matrix not initialized");
+            A.size() == static_cast<size_t>(d_out) * d_in,
+            "Transformation matrix not initialized");
 
     float one = 1;
-    FINTEGER nbiti = d_out, ni = n, di = d_in;
+    FINTEGER nbiti = d_out, ni = static_cast<FINTEGER>(n), di = d_in;
     sgemm_("Transposed",
            "Not transposed",
            &nbiti,
@@ -203,20 +209,21 @@ void LinearTransform::apply_noalloc(idx_t n, const float* x, float* xt) const {
 
 void LinearTransform::transform_transpose(idx_t n, const float* y, float* x)
         const {
+    std::vector<float> y_bias_corrected;
     if (have_bias) { // allocate buffer to store bias-corrected data
-        float* y_new = new float[n * d_out];
+        y_bias_corrected.resize(n * d_out);
         const float* yr = y;
-        float* yw = y_new;
+        float* yw = y_bias_corrected.data();
         for (idx_t i = 0; i < n; i++) {
             for (int j = 0; j < d_out; j++) {
                 *yw++ = *yr++ - b[j];
             }
         }
-        y = y_new;
+        y = y_bias_corrected.data();
     }
 
     {
-        FINTEGER dii = d_in, doi = d_out, ni = n;
+        FINTEGER dii = d_in, doi = d_out, ni = static_cast<FINTEGER>(n);
         float one = 1.0, zero = 0.0;
         sgemm_("Not",
                "Not",
@@ -232,9 +239,6 @@ void LinearTransform::transform_transpose(idx_t n, const float* y, float* x)
                x,
                &dii);
     }
-
-    if (have_bias)
-        delete[] y;
 }
 
 void LinearTransform::set_is_orthonormal() {
@@ -249,7 +253,7 @@ void LinearTransform::set_is_orthonormal() {
     }
 
     double eps = 4e-5;
-    FAISS_ASSERT(A.size() >= d_out * d_in);
+    FAISS_ASSERT(A.size() >= static_cast<size_t>(d_out) * d_in);
     {
         std::vector<float> ATA(d_out * d_out);
         FINTEGER dii = d_in, doi = d_out;
@@ -273,9 +277,10 @@ void LinearTransform::set_is_orthonormal() {
         for (long i = 0; i < d_out; i++) {
             for (long j = 0; j < d_out; j++) {
                 float v = ATA[i + j * d_out];
-                if (i == j)
+                if (i == j) {
                     v -= 1;
-                if (fabs(v) > eps) {
+                }
+                if (std::fabs(v) > eps) {
                     is_orthonormal = false;
                 }
             }
@@ -298,10 +303,13 @@ void LinearTransform::print_if_verbose(
         const std::vector<double>& mat,
         int n,
         int d) const {
-    if (!verbose)
+    if (!verbose) {
         return;
+    }
     printf("matrix %s: %d*%d [\n", name, n, d);
-    FAISS_THROW_IF_NOT(mat.size() >= n * d);
+    FAISS_THROW_IF_NOT_MSG(
+            mat.size() >= static_cast<size_t>(n) * d,
+            "matrix size is too small for the given dimensions");
     for (int i = 0; i < n; i++) {
         for (int j = 0; j < d; j++) {
             printf("%10.5g ", mat[i * d + j]);
@@ -314,8 +322,10 @@ void LinearTransform::print_if_verbose(
 void LinearTransform::check_identical(const VectorTransform& other_in) const {
     VectorTransform::check_identical(other_in);
     auto other = dynamic_cast<const LinearTransform*>(&other_in);
-    FAISS_THROW_IF_NOT(other);
-    FAISS_THROW_IF_NOT(other->A == A && other->b == b);
+    FAISS_THROW_IF_NOT_MSG(other, "failed to cast to LinearTransform");
+    FAISS_THROW_IF_NOT_MSG(
+            other->A == A && other->b == b,
+            "LinearTransform matrix A and bias vector b must match");
 }
 
 /*********************************************
@@ -352,18 +362,149 @@ void RandomRotationMatrix::train(idx_t /*n*/, const float* /*x*/) {
     init(12345);
 }
 
+/*********************************************
+ * HadamardRotation
+ *********************************************/
+
+// In-place Fast Walsh-Hadamard Transform. n must be a power of 2.
+// Applies the unnormalized Hadamard butterfly: O(n log n) add/sub, no
+// multiplies.
+static void fwht_inplace(float* buf, size_t n) {
+    for (size_t step = 1; step < n; step *= 2) {
+        for (size_t i = 0; i < n; i += step * 2) {
+            for (size_t j = i; j < i + step; j++) {
+                float a = buf[j];
+                float b = buf[j + step];
+                buf[j] = a + b;
+                buf[j + step] = a - b;
+            }
+        }
+    }
+}
+
+// Smallest power of 2 >= n.
+static int next_power_of_2(int n) {
+    int p = 1;
+    while (p < n) {
+        p *= 2;
+    }
+    return p;
+}
+
+// Generate three sign-flip vectors from the given seed.
+static void generate_signs(
+        uint32_t seed,
+        size_t p,
+        std::vector<float>& s1,
+        std::vector<float>& s2,
+        std::vector<float>& s3) {
+    FAISS_THROW_IF_NOT_MSG(
+            p > 0, "number of Hadamard factors p must be positive");
+    SplitMix64RandomGenerator rng(seed);
+    s1.resize(p);
+    s2.resize(p);
+    s3.resize(p);
+    for (size_t j = 0; j < p; j++) {
+        s1[j] = (rng.rand_int(2) == 0) ? -1.0f : 1.0f;
+    }
+    for (size_t j = 0; j < p; j++) {
+        s2[j] = (rng.rand_int(2) == 0) ? -1.0f : 1.0f;
+    }
+    for (size_t j = 0; j < p; j++) {
+        s3[j] = (rng.rand_int(2) == 0) ? -1.0f : 1.0f;
+    }
+}
+
+HadamardRotation::HadamardRotation(int d, uint32_t seed_in)
+        : VectorTransform(d, next_power_of_2(d)), seed(seed_in) {
+    init(seed_in);
+}
+
+void HadamardRotation::init(uint32_t seed_in) {
+    seed = seed_in;
+    is_trained = true;
+    generate_signs(seed, d_out, signs1, signs2, signs3);
+}
+
+void HadamardRotation::train(idx_t, const float*) {
+    init(seed != 0 ? seed : 12345);
+}
+
+void HadamardRotation::apply_noalloc(idx_t n, const float* x, float* xt) const {
+    FAISS_THROW_IF_NOT_MSG(is_trained, "Transformation not trained yet");
+
+    size_t d = d_in;
+    size_t p = d_out;
+    FAISS_THROW_IF_NOT_MSG(
+            signs1.size() == p,
+            "sign-flip vector 1 size must match output dimension");
+    FAISS_THROW_IF_NOT_MSG(
+            signs2.size() == p,
+            "sign-flip vector 2 size must match output dimension");
+    FAISS_THROW_IF_NOT_MSG(
+            signs3.size() == p,
+            "sign-flip vector 3 size must match output dimension");
+
+    // Each unnormalized FWHT scales norms by sqrt(p).
+    // Three rounds scale by p^(3/2). Normalize once at the end.
+    float total_scale = 1.0f / (p * std::sqrt(static_cast<float>(p)));
+
+#pragma omp parallel for schedule(dynamic)
+    for (idx_t i = 0; i < n; i++) {
+        const float* xi = x + i * d;
+        float* xo = xt + i * p;
+
+        // Round 1: copy + zero-pad + sign-flip + FWHT
+        for (size_t j = 0; j < d; j++) {
+            xo[j] = xi[j] * signs1[j];
+        }
+        for (size_t j = d; j < p; j++) {
+            xo[j] = 0.0f;
+        }
+        fwht_inplace(xo, p);
+
+        // Round 2: sign-flip + FWHT
+        for (size_t j = 0; j < p; j++) {
+            xo[j] *= signs2[j];
+        }
+        fwht_inplace(xo, p);
+
+        // Round 3: sign-flip + FWHT + normalize
+        for (size_t j = 0; j < p; j++) {
+            xo[j] *= signs3[j];
+        }
+        fwht_inplace(xo, p);
+
+        for (size_t j = 0; j < p; j++) {
+            xo[j] *= total_scale;
+        }
+    }
+}
+
+void HadamardRotation::check_identical(const VectorTransform& other) const {
+    auto* hr = dynamic_cast<const HadamardRotation*>(&other);
+    FAISS_THROW_IF_NOT_MSG(hr, "failed to cast to HadamardRotation");
+    FAISS_THROW_IF_NOT_MSG(
+            d_in == hr->d_in, "HadamardRotation input dimensions must match");
+    FAISS_THROW_IF_NOT_MSG(
+            d_out == hr->d_out,
+            "HadamardRotation output dimensions must match");
+    FAISS_THROW_IF_NOT_MSG(
+            seed == hr->seed, "HadamardRotation seeds must match");
+}
+
 /*********************************************
  * PCAMatrix
  *********************************************/
 
 PCAMatrix::PCAMatrix(
-        int d_in,
-        int d_out,
-        float eigen_power,
-        bool random_rotation)
-        : LinearTransform(d_in, d_out, true),
-          eigen_power(eigen_power),
-          random_rotation(random_rotation) {
+        int din,
+        int dout,
+        float eigen_power_in,
+        bool random_rotation_in)
+        : LinearTransform(din, dout, true),
+          eigen_power(eigen_power_in),
+          random_rotation(random_rotation_in) {
     is_trained = false;
     max_points_per_d = 1000;
     balanced_bins = 0;
@@ -377,7 +518,7 @@ namespace {
 
 void eig(size_t d_in, double* cov, double* eigenvalues, int verbose) {
     { // compute eigenvalues and vectors
-        FINTEGER info = 0, lwork = -1, di = d_in;
+        FINTEGER info = 0, lwork = -1, di = static_cast<FINTEGER>(d_in);
         double workq;
 
         dsyev_("Vectors as well",
@@ -389,8 +530,8 @@ void eig(size_t d_in, double* cov, double* eigenvalues, int verbose) {
                &workq,
                &lwork,
                &info);
-        lwork = FINTEGER(workq);
-        double* work = new double[lwork];
+        lwork = static_cast<FINTEGER>(workq);
+        std::vector<double> work(lwork);
 
         dsyev_("Vectors as well",
                "Upper",
@@ -398,12 +539,10 @@ void eig(size_t d_in, double* cov, double* eigenvalues, int verbose) {
                cov,
                &di,
                eigenvalues,
-               work,
+               work.data(),
                &lwork,
                &info);
 
-        delete[] work;
-
         if (info != 0) {
             fprintf(stderr,
                     "WARN ssyev info returns %d, "
@@ -414,15 +553,17 @@ void eig(size_t d_in, double* cov, double* eigenvalues, int verbose) {
 
         if (verbose && d_in <= 10) {
             printf("info=%ld new eigvals=[", long(info));
-            for (int j = 0; j < d_in; j++)
+            for (size_t j = 0; j < d_in; j++) {
                 printf("%g ", eigenvalues[j]);
+            }
             printf("]\n");
 
             double* ci = cov;
             printf("eigenvecs=\n");
-            for (int i = 0; i < d_in; i++) {
-                for (int j = 0; j < d_in; j++)
+            for (size_t i = 0; i < d_in; i++) {
+                for (size_t j = 0; j < d_in; j++) {
                     printf("%10.4g ", *ci++);
+                }
                 printf("\n");
             }
         }
@@ -430,12 +571,13 @@ void eig(size_t d_in, double* cov, double* eigenvalues, int verbose) {
 
     // revert order of eigenvectors & values
 
-    for (int i = 0; i < d_in / 2; i++) {
+    for (size_t i = 0; i < d_in / 2; i++) {
         std::swap(eigenvalues[i], eigenvalues[d_in - 1 - i]);
         double* v1 = cov + i * d_in;
         double* v2 = cov + (d_in - 1 - i) * d_in;
-        for (int j = 0; j < d_in; j++)
+        for (size_t j = 0; j < d_in; j++) {
             std::swap(v1[j], v2[j]);
+        }
     }
 }
 
@@ -451,17 +593,20 @@ void PCAMatrix::train(idx_t n, const float* x_in) {
     mean.resize(d_in, 0.0);
     if (have_bias) { // we may want to skip the bias
         const float* xi = x;
-        for (int i = 0; i < n; i++) {
-            for (int j = 0; j < d_in; j++)
+        for (idx_t i = 0; i < n; i++) {
+            for (int j = 0; j < d_in; j++) {
                 mean[j] += *xi++;
+            }
         }
-        for (int j = 0; j < d_in; j++)
+        for (int j = 0; j < d_in; j++) {
             mean[j] /= n;
+        }
     }
     if (verbose) {
         printf("mean=[");
-        for (int j = 0; j < d_in; j++)
+        for (int j = 0; j < d_in; j++) {
             printf("%g ", mean[j]);
+        }
         printf("]\n");
     }
 
@@ -472,12 +617,13 @@ void PCAMatrix::train(idx_t n, const float* x_in) {
         { // initialize with  mean * mean^T term
             float* ci = cov;
             for (int i = 0; i < d_in; i++) {
-                for (int j = 0; j < d_in; j++)
+                for (int j = 0; j < d_in; j++) {
                     *ci++ = -n * mean[i] * mean[j];
+                }
             }
         }
         {
-            FINTEGER di = d_in, ni = n;
+            FINTEGER di = d_in, ni = static_cast<FINTEGER>(n);
             float one = 1.0;
             ssyrk_("Up",
                    "Non transposed",
@@ -494,38 +640,44 @@ void PCAMatrix::train(idx_t n, const float* x_in) {
             float* ci = cov;
             printf("cov=\n");
             for (int i = 0; i < d_in; i++) {
-                for (int j = 0; j < d_in; j++)
+                for (int j = 0; j < d_in; j++) {
                     printf("%10g ", *ci++);
+                }
                 printf("\n");
             }
         }
 
         std::vector<double> covd(d_in * d_in);
-        for (size_t i = 0; i < d_in * d_in; i++)
+        for (size_t i = 0; i < d_in * d_in; i++) {
             covd[i] = cov[i];
+        }
 
         std::vector<double> eigenvaluesd(d_in);
 
         eig(d_in, covd.data(), eigenvaluesd.data(), verbose);
 
-        for (size_t i = 0; i < d_in * d_in; i++)
+        for (size_t i = 0; i < d_in * d_in; i++) {
             PCAMat[i] = covd[i];
+        }
         eigenvalues.resize(d_in);
 
-        for (size_t i = 0; i < d_in; i++)
+        for (int i = 0; i < d_in; i++) {
             eigenvalues[i] = eigenvaluesd[i];
+        }
 
     } else {
         std::vector<float> xc(n * d_in);
 
-        for (size_t i = 0; i < n; i++)
-            for (size_t j = 0; j < d_in; j++)
+        for (idx_t i = 0; i < n; i++) {
+            for (int j = 0; j < d_in; j++) {
                 xc[i * d_in + j] = x[i * d_in + j] - mean[j];
+            }
+        }
 
         // compute Gram matrix
         std::vector<float> gram(n * n);
         {
-            FINTEGER di = d_in, ni = n;
+            FINTEGER di = d_in, ni = static_cast<FINTEGER>(n);
             float one = 1.0, zero = 0.0;
             ssyrk_("Up",
                    "Transposed",
@@ -542,16 +694,18 @@ void PCAMatrix::train(idx_t n, const float* x_in) {
         if (verbose && d_in <= 10) {
             float* ci = gram.data();
             printf("gram=\n");
-            for (int i = 0; i < n; i++) {
-                for (int j = 0; j < n; j++)
+            for (idx_t i = 0; i < n; i++) {
+                for (idx_t j = 0; j < n; j++) {
                     printf("%10g ", *ci++);
+                }
                 printf("\n");
             }
         }
 
         std::vector<double> gramd(n * n);
-        for (size_t i = 0; i < n * n; i++)
+        for (size_t i = 0; i < n * n; i++) {
             gramd[i] = gram[i];
+        }
 
         std::vector<double> eigenvaluesd(n);
 
@@ -561,17 +715,19 @@ void PCAMatrix::train(idx_t n, const float* x_in) {
 
         PCAMat.resize(d_in * n);
 
-        for (size_t i = 0; i < n * n; i++)
+        for (size_t i = 0; i < n * n; i++) {
             gram[i] = gramd[i];
+        }
 
         eigenvalues.resize(d_in);
         // fill in only the n first ones
-        for (size_t i = 0; i < n; i++)
+        for (idx_t i = 0; i < n; i++) {
             eigenvalues[i] = eigenvaluesd[i];
+        }
 
         { // compute PCAMat = x' * v
-            FINTEGER di = d_in, ni = n;
-            float one = 1.0;
+            FINTEGER di = d_in, ni = static_cast<FINTEGER>(n);
+            float one = 1.0, zero = 0.0;
 
             sgemm_("Non",
                    "Non Trans",
@@ -583,7 +739,7 @@ void PCAMatrix::train(idx_t n, const float* x_in) {
                    &di,
                    gram.data(),
                    &ni,
-                   &one,
+                   &zero,
                    PCAMat.data(),
                    &di);
         }
@@ -591,9 +747,10 @@ void PCAMatrix::train(idx_t n, const float* x_in) {
         if (verbose && d_in <= 10) {
             float* ci = PCAMat.data();
             printf("PCAMat=\n");
-            for (int i = 0; i < n; i++) {
-                for (int j = 0; j < d_in; j++)
+            for (idx_t i = 0; i < n; i++) {
+                for (int j = 0; j < d_in; j++) {
                     printf("%10g ", *ci++);
+                }
                 printf("\n");
             }
         }
@@ -605,7 +762,9 @@ void PCAMatrix::train(idx_t n, const float* x_in) {
 }
 
 void PCAMatrix::copy_from(const PCAMatrix& other) {
-    FAISS_THROW_IF_NOT(other.is_trained);
+    FAISS_THROW_IF_NOT_MSG(
+            other.is_trained,
+            "source PCAMatrix must be trained before copying");
     mean = other.mean;
     eigenvalues = other.eigenvalues;
     PCAMat = other.PCAMat;
@@ -615,7 +774,7 @@ void PCAMatrix::copy_from(const PCAMatrix& other) {
 
 void PCAMatrix::prepare_Ab() {
     FAISS_THROW_IF_NOT_FMT(
-            d_out * d_in <= PCAMat.size(),
+            static_cast<size_t>(d_out) * d_in <= PCAMat.size(),
             "PCA matrix cannot output %d dimensions from %d ",
             d_out,
             d_in);
@@ -628,14 +787,17 @@ void PCAMatrix::prepare_Ab() {
         if (eigen_power != 0) {
             float* ai = A.data();
             for (int i = 0; i < d_out; i++) {
-                float factor = pow(eigenvalues[i] + epsilon, eigen_power);
-                for (int j = 0; j < d_in; j++)
+                float factor = std::pow(eigenvalues[i] + epsilon, eigen_power);
+                for (int j = 0; j < d_in; j++) {
                     *ai++ *= factor;
+                }
             }
         }
 
         if (balanced_bins != 0) {
-            FAISS_THROW_IF_NOT(d_out % balanced_bins == 0);
+            FAISS_THROW_IF_NOT_MSG(
+                    d_out % balanced_bins == 0,
+                    "output dimension must be divisible by balanced_bins");
             int dsub = d_out / balanced_bins;
             std::vector<float> Ain;
             std::swap(A, Ain);
@@ -663,8 +825,9 @@ void PCAMatrix::prepare_Ab() {
 
             if (verbose) {
                 printf("  bin accu=[");
-                for (int i = 0; i < balanced_bins; i++)
+                for (int i = 0; i < balanced_bins; i++) {
                     printf("%g ", accu[i]);
+                }
                 printf("]\n");
             }
         }
@@ -682,8 +845,9 @@ void PCAMatrix::prepare_Ab() {
         if (eigen_power != 0) {
             for (int i = 0; i < d_out; i++) {
                 float factor = pow(eigenvalues[i], eigen_power);
-                for (int j = 0; j < d_out; j++)
+                for (int j = 0; j < d_out; j++) {
                     rr.A[j * d_out + i] *= factor;
+                }
             }
         }
 
@@ -713,8 +877,9 @@ void PCAMatrix::prepare_Ab() {
 
     for (int i = 0; i < d_out; i++) {
         float accu = 0;
-        for (int j = 0; j < d_in; j++)
+        for (int j = 0; j < d_in; j++) {
             accu -= mean[j] * A[j + i * d_in];
+        }
         b[i] = accu;
     }
 
@@ -738,7 +903,7 @@ void ITQMatrix::train(idx_t n, const float* xf) {
                init_rotation.data(),
                d * d * sizeof(rotation[0]));
     } else {
-        RandomRotationMatrix rrot(d, d);
+        RandomRotationMatrix rrot(static_cast<int>(d), static_cast<int>(d));
         rrot.init(seed);
         for (size_t i = 0; i < d * d; i++) {
             rotation[i] = rrot.A[i];
@@ -755,9 +920,11 @@ void ITQMatrix::train(idx_t n, const float* xf) {
     std::vector<double> u(d * d), vt(d * d), singvals(d);
 
     for (int i = 0; i < max_iter; i++) {
-        print_if_verbose("rotation", rotation, d, d);
+        print_if_verbose(
+                "rotation", rotation, static_cast<int>(d), static_cast<int>(d));
         { // rotated_data = np.dot(training_data, rotation)
-            FINTEGER di = d, ni = n;
+            FINTEGER di = static_cast<FINTEGER>(d),
+                     ni = static_cast<FINTEGER>(n);
             double one = 1, zero = 0;
             dgemm_("N",
                    "N",
@@ -773,14 +940,19 @@ void ITQMatrix::train(idx_t n, const float* xf) {
                    rotated_x.data(),
                    &di);
         }
-        print_if_verbose("rotated_x", rotated_x, n, d);
+        print_if_verbose(
+                "rotated_x",
+                rotated_x,
+                static_cast<int>(n),
+                static_cast<int>(d));
         // binarize
         for (size_t j = 0; j < n * d; j++) {
             rotated_x[j] = rotated_x[j] < 0 ? -1 : 1;
         }
         // covariance matrix
         { // rotated_data = np.dot(training_data, rotation)
-            FINTEGER di = d, ni = n;
+            FINTEGER di = static_cast<FINTEGER>(d),
+                     ni = static_cast<FINTEGER>(n);
             double one = 1, zero = 0;
             dgemm_("N",
                    "T",
@@ -796,10 +968,11 @@ void ITQMatrix::train(idx_t n, const float* xf) {
                    cov_mat.data(),
                    &di);
         }
-        print_if_verbose("cov_mat", cov_mat, d, d);
+        print_if_verbose(
+                "cov_mat", cov_mat, static_cast<int>(d), static_cast<int>(d));
         // SVD
         {
-            FINTEGER di = d;
+            FINTEGER di = static_cast<FINTEGER>(d);
             FINTEGER lwork = -1, info;
             double lwork1;
 
@@ -819,8 +992,11 @@ void ITQMatrix::train(idx_t n, const float* xf) {
                     &lwork,
                     &info);
 
-            FAISS_THROW_IF_NOT(info == 0);
-            lwork = size_t(lwork1);
+            FAISS_THROW_IF_NOT_FMT(
+                    info == 0,
+                    "LAPACK dgesvd workspace query returned info=%d",
+                    int(info));
+            lwork = static_cast<FINTEGER>(lwork1);
             std::vector<double> work(lwork);
             dgesvd_("A",
                     "A",
@@ -838,11 +1014,11 @@ void ITQMatrix::train(idx_t n, const float* xf) {
                     &info);
             FAISS_THROW_IF_NOT_FMT(info == 0, "sgesvd returned info=%d", info);
         }
-        print_if_verbose("u", u, d, d);
-        print_if_verbose("vt", vt, d, d);
+        print_if_verbose("u", u, static_cast<int>(d), static_cast<int>(d));
+        print_if_verbose("vt", vt, static_cast<int>(d), static_cast<int>(d));
         // update rotation
         {
-            FINTEGER di = d;
+            FINTEGER di = static_cast<FINTEGER>(d);
             double one = 1, zero = 0;
             dgemm_("N",
                    "T",
@@ -858,7 +1034,11 @@ void ITQMatrix::train(idx_t n, const float* xf) {
                    rotation.data(),
                    &di);
         }
-        print_if_verbose("final rot", rotation, d, d);
+        print_if_verbose(
+                "final rot",
+                rotation,
+                static_cast<int>(d),
+                static_cast<int>(d));
     }
     A.resize(d * d);
     for (size_t i = 0; i < d; i++) {
@@ -869,20 +1049,23 @@ void ITQMatrix::train(idx_t n, const float* xf) {
     is_trained = true;
 }
 
-ITQTransform::ITQTransform(int d_in, int d_out, bool do_pca)
-        : VectorTransform(d_in, d_out),
-          do_pca(do_pca),
-          itq(d_out),
-          pca_then_itq(d_in, d_out, false) {
-    if (!do_pca) {
-        FAISS_THROW_IF_NOT(d_in == d_out);
+ITQTransform::ITQTransform(int din, int dout, bool do_pca_in)
+        : VectorTransform(din, dout),
+          do_pca(do_pca_in),
+          itq(dout),
+          pca_then_itq(din, dout, false) {
+    if (!do_pca_in) {
+        FAISS_THROW_IF_NOT_MSG(
+                din == dout,
+                "input and output dimensions must match when PCA is disabled");
     }
     max_train_per_dim = 10;
     is_trained = false;
 }
 
 void ITQTransform::train(idx_t n, const float* x_in) {
-    FAISS_THROW_IF_NOT(!is_trained);
+    FAISS_THROW_IF_NOT_MSG(
+            !is_trained, "ITQTransform has already been trained");
 
     size_t max_train_points = std::max(d_in * max_train_per_dim, 32768);
     const float* x =
@@ -974,17 +1157,18 @@ void ITQTransform::apply_noalloc(idx_t n, const float* x, float* xt) const {
 void ITQTransform::check_identical(const VectorTransform& other_in) const {
     VectorTransform::check_identical(other_in);
     auto other = dynamic_cast<const ITQTransform*>(&other_in);
-    FAISS_THROW_IF_NOT(other);
+    FAISS_THROW_IF_NOT_MSG(other, "failed to cast to ITQTransform");
     pca_then_itq.check_identical(other->pca_then_itq);
-    FAISS_THROW_IF_NOT(other->mean == mean);
+    FAISS_THROW_IF_NOT_MSG(
+            other->mean == mean, "ITQTransform mean vectors must match");
 }
 
 /*********************************************
  * OPQMatrix
  *********************************************/
 
-OPQMatrix::OPQMatrix(int d, int M, int d2)
-        : LinearTransform(d, d2 == -1 ? d : d2, false), M(M) {
+OPQMatrix::OPQMatrix(int d, int M_in, int d2)
+        : LinearTransform(d, d2 == -1 ? d : d2, false), M(M_in) {
     is_trained = false;
     // OPQ is quite expensive to train, so set this right.
     max_train_points = 256 * 256;
@@ -1030,17 +1214,20 @@ void OPQMatrix::train(idx_t n, const float* x_in) {
     {
         std::vector<float> sum(d);
         const float* xi = x;
-        for (size_t i = 0; i < n; i++) {
-            for (int j = 0; j < d_in; j++)
+        for (idx_t i = 0; i < n; i++) {
+            for (int j = 0; j < d_in; j++) {
                 sum[j] += *xi++;
+            }
         }
-        for (int i = 0; i < d; i++)
+        for (size_t i = 0; i < d; i++) {
             sum[i] /= n;
+        }
         float* yi = xtrain.data();
         xi = x;
-        for (size_t i = 0; i < n; i++) {
-            for (int j = 0; j < d_in; j++)
+        for (idx_t i = 0; i < n; i++) {
+            for (int j = 0; j < d_in; j++) {
                 *yi++ = *xi++ - sum[j];
+            }
             yi += d - d_in;
         }
     }
@@ -1049,16 +1236,18 @@ void OPQMatrix::train(idx_t n, const float* x_in) {
     if (A.size() == 0) {
         A.resize(d * d);
         rotation = A.data();
-        if (verbose)
+        if (verbose) {
             printf("  OPQMatrix::train: making random %zd*%zd rotation\n",
                    d,
                    d);
+        }
         float_randn(rotation, d * d, 1234);
         matrix_qr(d, d, rotation);
         // we use only the d * d2 upper part of the matrix
         A.resize(d * d2);
     } else {
-        FAISS_THROW_IF_NOT(A.size() == d * d2);
+        FAISS_THROW_IF_NOT_MSG(
+                A.size() == d * d2, "rotation matrix A has incorrect size");
         rotation = A.data();
     }
 
@@ -1072,7 +1261,9 @@ void OPQMatrix::train(idx_t n, const float* x_in) {
     double t0 = getmillisecs();
     for (int iter = 0; iter < niter; iter++) {
         { // torch.mm(xtrain, rotation:t())
-            FINTEGER di = d, d2i = d2, ni = n;
+            FINTEGER di = static_cast<FINTEGER>(d),
+                     d2i = static_cast<FINTEGER>(d2),
+                     ni = static_cast<FINTEGER>(n);
             float zero = 0, one = 1;
             sgemm_("Transposed",
                    "Not transposed",
@@ -1107,18 +1298,21 @@ void OPQMatrix::train(idx_t n, const float* x_in) {
 
         float pq_err = fvec_L2sqr(pq_recons.data(), xproj.data(), n * d2) / n;
 
-        if (verbose)
+        if (verbose) {
             printf("    Iteration %d (%d PQ iterations):"
                    "%.3f s, obj=%g\n",
                    iter,
                    pq_regular.cp.niter,
                    (getmillisecs() - t0) / 1000.0,
                    pq_err);
+        }
 
         {
             float *u = tmp.data(), *vt = &tmp[d * d];
             float* sing_val = &tmp[2 * d * d];
-            FINTEGER di = d, d2i = d2, ni = n;
+            FINTEGER di = static_cast<FINTEGER>(d),
+                     d2i = static_cast<FINTEGER>(d2),
+                     ni = static_cast<FINTEGER>(n);
             float one = 1, zero = 0;
 
             if (verbose) {
@@ -1157,7 +1351,11 @@ void OPQMatrix::train(idx_t n, const float* x_in) {
                     &lwork,
                     &info);
 
-            lwork = int(worksz);
+            FAISS_THROW_IF_NOT_FMT(
+                    info == 0,
+                    "LAPACK sgesvd workspace query returned info=%d",
+                    int(info));
+            lwork = static_cast<FINTEGER>(worksz);
             std::vector<float> work(lwork);
             // u and vt swapped
             sgesvd_("All",
@@ -1193,9 +1391,10 @@ void OPQMatrix::train(idx_t n, const float* x_in) {
     }
 
     // revert A matrix
-    if (d > d_in) {
-        for (long i = 0; i < d_out; i++)
+    if (d > static_cast<size_t>(d_in)) {
+        for (long i = 0; i < d_out; i++) {
             memmove(&A[i * d_in], &A[i * d], sizeof(A[0]) * d_in);
+        }
         A.resize(d_in * d_out);
     }
 
@@ -1207,8 +1406,8 @@ void OPQMatrix::train(idx_t n, const float* x_in) {
  * NormalizationTransform
  *********************************************/
 
-NormalizationTransform::NormalizationTransform(int d, float norm)
-        : VectorTransform(d, d), norm(norm) {}
+NormalizationTransform::NormalizationTransform(int d, float norm_in)
+        : VectorTransform(d, d), norm(norm_in) {}
 
 NormalizationTransform::NormalizationTransform()
         : VectorTransform(-1, -1), norm(-1) {}
@@ -1234,8 +1433,9 @@ void NormalizationTransform::check_identical(
         const VectorTransform& other_in) const {
     VectorTransform::check_identical(other_in);
     auto other = dynamic_cast<const NormalizationTransform*>(&other_in);
-    FAISS_THROW_IF_NOT(other);
-    FAISS_THROW_IF_NOT(other->norm == norm);
+    FAISS_THROW_IF_NOT_MSG(other, "failed to cast to NormalizationTransform");
+    FAISS_THROW_IF_NOT_MSG(
+            other->norm == norm, "normalization type must match");
 }
 
 /*********************************************
@@ -1250,12 +1450,12 @@ void CenteringTransform::train(idx_t n, const float* x) {
     FAISS_THROW_IF_NOT_MSG(n > 0, "need at least one training vector");
     mean.resize(d_in, 0);
     for (idx_t i = 0; i < n; i++) {
-        for (size_t j = 0; j < d_in; j++) {
+        for (int j = 0; j < d_in; j++) {
             mean[j] += *x++;
         }
     }
 
-    for (size_t j = 0; j < d_in; j++) {
+    for (int j = 0; j < d_in; j++) {
         mean[j] /= n;
     }
     is_trained = true;
@@ -1263,10 +1463,11 @@ void CenteringTransform::train(idx_t n, const float* x) {
 
 void CenteringTransform::apply_noalloc(idx_t n, const float* x, float* xt)
         const {
-    FAISS_THROW_IF_NOT(is_trained);
+    FAISS_THROW_IF_NOT_MSG(
+            is_trained, "CenteringTransform has not been trained");
 
     for (idx_t i = 0; i < n; i++) {
-        for (size_t j = 0; j < d_in; j++) {
+        for (int j = 0; j < d_in; j++) {
             *xt++ = *x++ - mean[j];
         }
     }
@@ -1274,10 +1475,11 @@ void CenteringTransform::apply_noalloc(idx_t n, const float* x, float* xt)
 
 void CenteringTransform::reverse_transform(idx_t n, const float* xt, float* x)
         const {
-    FAISS_THROW_IF_NOT(is_trained);
+    FAISS_THROW_IF_NOT_MSG(
+            is_trained, "CenteringTransform has not been trained");
 
     for (idx_t i = 0; i < n; i++) {
-        for (size_t j = 0; j < d_in; j++) {
+        for (int j = 0; j < d_in; j++) {
             *x++ = *xt++ + mean[j];
         }
     }
@@ -1287,8 +1489,9 @@ void CenteringTransform::check_identical(
         const VectorTransform& other_in) const {
     VectorTransform::check_identical(other_in);
     auto other = dynamic_cast<const CenteringTransform*>(&other_in);
-    FAISS_THROW_IF_NOT(other);
-    FAISS_THROW_IF_NOT(other->mean == mean);
+    FAISS_THROW_IF_NOT_MSG(other, "failed to cast to CenteringTransform");
+    FAISS_THROW_IF_NOT_MSG(
+            other->mean == mean, "CenteringTransform mean vectors must match");
 }
 
 /*********************************************
@@ -1296,37 +1499,40 @@ void CenteringTransform::check_identical(
  *********************************************/
 
 RemapDimensionsTransform::RemapDimensionsTransform(
-        int d_in,
-        int d_out,
+        int din,
+        int dout,
         const int* map_in)
-        : VectorTransform(d_in, d_out) {
-    map.resize(d_out);
-    for (int i = 0; i < d_out; i++) {
+        : VectorTransform(din, dout) {
+    map.resize(dout);
+    for (int i = 0; i < dout; i++) {
         map[i] = map_in[i];
-        FAISS_THROW_IF_NOT(map[i] == -1 || (map[i] >= 0 && map[i] < d_in));
+        FAISS_THROW_IF_NOT_MSG(
+                map[i] == -1 || (map[i] >= 0 && map[i] < din),
+                "map entries must be -1 (unused) or valid input dimension indices");
     }
 }
 
 RemapDimensionsTransform::RemapDimensionsTransform(
-        int d_in,
-        int d_out,
+        int din,
+        int dout,
         bool uniform)
-        : VectorTransform(d_in, d_out) {
-    map.resize(d_out, -1);
+        : VectorTransform(din, dout) {
+    map.resize(dout, -1);
 
     if (uniform) {
-        if (d_in < d_out) {
-            for (int i = 0; i < d_in; i++) {
-                map[i * d_out / d_in] = i;
+        if (din < dout) {
+            for (int i = 0; i < din; i++) {
+                map[i * dout / din] = i;
             }
         } else {
-            for (int i = 0; i < d_out; i++) {
-                map[i] = i * d_in / d_out;
+            for (int i = 0; i < dout; i++) {
+                map[i] = i * din / dout;
             }
         }
     } else {
-        for (int i = 0; i < d_in && i < d_out; i++)
+        for (int i = 0; i < din && i < dout; i++) {
             map[i] = i;
+        }
     }
 }
 
@@ -1348,8 +1554,9 @@ void RemapDimensionsTransform::reverse_transform(
     memset(x, 0, sizeof(*x) * n * d_in);
     for (idx_t i = 0; i < n; i++) {
         for (int j = 0; j < d_out; j++) {
-            if (map[j] >= 0)
+            if (map[j] >= 0) {
                 x[map[j]] = xt[j];
+            }
         }
         x += d_in;
         xt += d_out;
@@ -1360,6 +1567,7 @@ void RemapDimensionsTransform::check_identical(
         const VectorTransform& other_in) const {
     VectorTransform::check_identical(other_in);
     auto other = dynamic_cast<const RemapDimensionsTransform*>(&other_in);
-    FAISS_THROW_IF_NOT(other);
-    FAISS_THROW_IF_NOT(other->map == map);
+    FAISS_THROW_IF_NOT_MSG(other, "failed to cast to RemapDimensionsTransform");
+    FAISS_THROW_IF_NOT_MSG(
+            other->map == map, "RemapDimensionsTransform maps must match");
 }