faiss 0.2.0 → 0.2.4

data/vendor/faiss/faiss/VectorTransform.cpp

@@ -10,20 +10,19 @@
 #include <faiss/VectorTransform.h>
 
 #include <cinttypes>
-#include <cstdio>
 #include <cmath>
+#include <cstdio>
 #include <cstring>
 #include <memory>
 
+#include <faiss/IndexPQ.h>
+#include <faiss/impl/FaissAssert.h>
 #include <faiss/utils/distances.h>
 #include <faiss/utils/random.h>
 #include <faiss/utils/utils.h>
-#include <faiss/impl/FaissAssert.h>
-#include <faiss/IndexPQ.h>
 
 using namespace faiss;
 
-
 extern "C" {
 
 // this is to keep the clang syntax checker happy
@@ -31,134 +30,183 @@ extern "C" {
 #define FINTEGER int
 #endif
 
-
 /* declare BLAS functions, see http://www.netlib.org/clapack/cblas/ */
 
-int sgemm_ (
-        const char *transa, const char *transb, FINTEGER *m, FINTEGER *
-        n, FINTEGER *k, const float *alpha, const float *a,
-        FINTEGER *lda, const float *b,
-        FINTEGER *ldb, float *beta,
-        float *c, FINTEGER *ldc);
-
-int dgemm_ (
-        const char *transa, const char *transb, FINTEGER *m, FINTEGER *
-        n, FINTEGER *k, const double *alpha, const double *a,
-        FINTEGER *lda, const double *b,
-        FINTEGER *ldb, double *beta,
-        double *c, FINTEGER *ldc);
-
-int ssyrk_ (
-        const char *uplo, const char *trans, FINTEGER *n, FINTEGER *k,
-        float *alpha, float *a, FINTEGER *lda,
-        float *beta, float *c, FINTEGER *ldc);
+int sgemm_(
+        const char* transa,
+        const char* transb,
+        FINTEGER* m,
+        FINTEGER* n,
+        FINTEGER* k,
+        const float* alpha,
+        const float* a,
+        FINTEGER* lda,
+        const float* b,
+        FINTEGER* ldb,
+        float* beta,
+        float* c,
+        FINTEGER* ldc);
+
+int dgemm_(
+        const char* transa,
+        const char* transb,
+        FINTEGER* m,
+        FINTEGER* n,
+        FINTEGER* k,
+        const double* alpha,
+        const double* a,
+        FINTEGER* lda,
+        const double* b,
+        FINTEGER* ldb,
+        double* beta,
+        double* c,
+        FINTEGER* ldc);
+
+int ssyrk_(
+        const char* uplo,
+        const char* trans,
+        FINTEGER* n,
+        FINTEGER* k,
+        float* alpha,
+        float* a,
+        FINTEGER* lda,
+        float* beta,
+        float* c,
+        FINTEGER* ldc);
 
 /* Lapack functions from http://www.netlib.org/clapack/old/single/ */
 
-int ssyev_ (
-        const char *jobz, const char *uplo, FINTEGER *n, float *a,
-        FINTEGER *lda, float *w, float *work, FINTEGER *lwork,
-        FINTEGER *info);
-
-int dsyev_ (
-        const char *jobz, const char *uplo, FINTEGER *n, double *a,
-        FINTEGER *lda, double *w, double *work, FINTEGER *lwork,
-        FINTEGER *info);
+int ssyev_(
+        const char* jobz,
+        const char* uplo,
+        FINTEGER* n,
+        float* a,
+        FINTEGER* lda,
+        float* w,
+        float* work,
+        FINTEGER* lwork,
+        FINTEGER* info);
+
+int dsyev_(
+        const char* jobz,
+        const char* uplo,
+        FINTEGER* n,
+        double* a,
+        FINTEGER* lda,
+        double* w,
+        double* work,
+        FINTEGER* lwork,
+        FINTEGER* info);
 
 int sgesvd_(
-        const char *jobu, const char *jobvt, FINTEGER *m, FINTEGER *n,
-        float *a, FINTEGER *lda, float *s, float *u, FINTEGER *ldu, float *vt,
-        FINTEGER *ldvt, float *work, FINTEGER *lwork, FINTEGER *info);
-
+        const char* jobu,
+        const char* jobvt,
+        FINTEGER* m,
+        FINTEGER* n,
+        float* a,
+        FINTEGER* lda,
+        float* s,
+        float* u,
+        FINTEGER* ldu,
+        float* vt,
+        FINTEGER* ldvt,
+        float* work,
+        FINTEGER* lwork,
+        FINTEGER* info);
 
 int dgesvd_(
-     const char *jobu, const char *jobvt, FINTEGER *m, FINTEGER *n,
-     double *a, FINTEGER *lda, double *s, double *u, FINTEGER *ldu, double *vt,
-     FINTEGER *ldvt, double *work, FINTEGER *lwork, FINTEGER *info);
-
+        const char* jobu,
+        const char* jobvt,
+        FINTEGER* m,
+        FINTEGER* n,
+        double* a,
+        FINTEGER* lda,
+        double* s,
+        double* u,
+        FINTEGER* ldu,
+        double* vt,
+        FINTEGER* ldvt,
+        double* work,
+        FINTEGER* lwork,
+        FINTEGER* info);
 }
 
 /*********************************************
  * VectorTransform
  *********************************************/
 
-
-
-float * VectorTransform::apply (Index::idx_t n, const float * x) const
-{
-    float * xt = new float[n * d_out];
-    apply_noalloc (n, x, xt);
+float* VectorTransform::apply(Index::idx_t n, const float* x) const {
+    float* xt = new float[n * d_out];
+    apply_noalloc(n, x, xt);
     return xt;
 }
 
-
-void VectorTransform::train (idx_t, const float *) {
+void VectorTransform::train(idx_t, const float*) {
     // does nothing by default
 }
 
-
-void VectorTransform::reverse_transform (
-             idx_t , const float *,
-             float *) const
-{
-    FAISS_THROW_MSG ("reverse transform not implemented");
+void VectorTransform::reverse_transform(idx_t, const float*, float*) const {
+    FAISS_THROW_MSG("reverse transform not implemented");
 }
 
-
-
-
 /*********************************************
  * LinearTransform
  *********************************************/
 
 /// 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),
-    is_orthonormal (false), verbose (false)
-{
+LinearTransform::LinearTransform(int d_in, int d_out, bool have_bias)
+        : VectorTransform(d_in, d_out),
+          have_bias(have_bias),
+          is_orthonormal(false),
+          verbose(false) {
     is_trained = false; // will be trained when A and b are initialized
 }
 
-void LinearTransform::apply_noalloc (Index::idx_t n, const float * x,
-                               float * xt) const
-{
+void LinearTransform::apply_noalloc(Index::idx_t n, const float* x, float* xt)
+        const {
     FAISS_THROW_IF_NOT_MSG(is_trained, "Transformation not trained yet");
 
     float c_factor;
     if (have_bias) {
-        FAISS_THROW_IF_NOT_MSG (b.size() == d_out, "Bias not initialized");
-        float * xi = xt;
+        FAISS_THROW_IF_NOT_MSG(b.size() == d_out, "Bias not initialized");
+        float* xi = xt;
         for (int i = 0; i < n; i++)
-            for(int j = 0; j < d_out; j++)
+            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");
+    FAISS_THROW_IF_NOT_MSG(
+            A.size() == d_out * d_in, "Transformation matrix not initialized");
 
     float one = 1;
     FINTEGER nbiti = d_out, ni = n, di = d_in;
-    sgemm_ ("Transposed", "Not transposed",
-            &nbiti, &ni, &di,
-            &one, A.data(), &di, x, &di, &c_factor, xt, &nbiti);
-
+    sgemm_("Transposed",
+           "Not transposed",
+           &nbiti,
+           &ni,
+           &di,
+           &one,
+           A.data(),
+           &di,
+           x,
+           &di,
+           &c_factor,
+           xt,
+           &nbiti);
 }
 
-
-void LinearTransform::transform_transpose (idx_t n, const float * y,
-                                           float *x) const
-{
+void LinearTransform::transform_transpose(idx_t n, const float* y, float* x)
+        const {
     if (have_bias) { // allocate buffer to store bias-corrected data
-        float *y_new = new float [n * d_out];
-        const float *yr = y;
-        float *yw = y_new;
+        float* y_new = new float[n * d_out];
+        const float* yr = y;
+        float* yw = y_new;
         for (idx_t i = 0; i < n; i++) {
             for (int j = 0; j < d_out; j++) {
-                *yw++ = *yr++ - b [j];
+                *yw++ = *yr++ - b[j];
             }
         }
         y = y_new;
@@ -167,15 +215,26 @@ void LinearTransform::transform_transpose (idx_t n, const float * y,
     {
         FINTEGER dii = d_in, doi = d_out, ni = n;
         float one = 1.0, zero = 0.0;
-        sgemm_ ("Not", "Not", &dii, &ni, &doi,
-                &one, A.data (), &dii, y, &doi, &zero, x, &dii);
+        sgemm_("Not",
+               "Not",
+               &dii,
+               &ni,
+               &doi,
+               &one,
+               A.data(),
+               &dii,
+               y,
+               &doi,
+               &zero,
+               x,
+               &dii);
     }
 
-    if (have_bias) delete [] y;
+    if (have_bias)
+        delete[] y;
 }
 
-void LinearTransform::set_is_orthonormal ()
-{
+void LinearTransform::set_is_orthonormal() {
     if (d_out > d_in) {
         // not clear what we should do in this case
         is_orthonormal = false;
@@ -193,44 +252,53 @@ void LinearTransform::set_is_orthonormal ()
         FINTEGER dii = d_in, doi = d_out;
         float one = 1.0, zero = 0.0;
 
-        sgemm_ ("Transposed", "Not", &doi, &doi, &dii,
-                &one, A.data (), &dii,
-                A.data(), &dii,
-                &zero, ATA.data(), &doi);
+        sgemm_("Transposed",
+               "Not",
+               &doi,
+               &doi,
+               &dii,
+               &one,
+               A.data(),
+               &dii,
+               A.data(),
+               &dii,
+               &zero,
+               ATA.data(),
+               &doi);
 
         is_orthonormal = true;
         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) v-= 1;
+                if (i == j)
+                    v -= 1;
                 if (fabs(v) > eps) {
                     is_orthonormal = false;
                 }
             }
         }
     }
-
 }
 
-
-void LinearTransform::reverse_transform (idx_t n, const float * xt,
-                                         float *x) const
-{
+void LinearTransform::reverse_transform(idx_t n, const float* xt, float* x)
+        const {
     if (is_orthonormal) {
-        transform_transpose (n, xt, x);
+        transform_transpose(n, xt, x);
     } else {
-        FAISS_THROW_MSG ("reverse transform not implemented for non-orthonormal matrices");
+        FAISS_THROW_MSG(
+                "reverse transform not implemented for non-orthonormal matrices");
     }
 }
 
-
-void LinearTransform::print_if_verbose (
-         const char*name, const std::vector<double> &mat,
-         int n, int d) const
-{
-    if (!verbose) return;
+void LinearTransform::print_if_verbose(
+        const char* name,
+        const std::vector<double>& mat,
+        int n,
+        int d) const {
+    if (!verbose)
+        return;
     printf("matrix %s: %d*%d [\n", name, n, d);
-    FAISS_THROW_IF_NOT (mat.size() >= n * d);
+    FAISS_THROW_IF_NOT(mat.size() >= n * d);
     for (int i = 0; i < n; i++) {
         for (int j = 0; j < d; j++) {
             printf("%10.5g ", mat[i * d + j]);
@@ -244,24 +312,22 @@ void LinearTransform::print_if_verbose (
  * RandomRotationMatrix
  *********************************************/
 
-void RandomRotationMatrix::init (int seed)
-{
-
-    if(d_out <= d_in) {
-        A.resize (d_out * d_in);
-        float *q = A.data();
+void RandomRotationMatrix::init(int seed) {
+    if (d_out <= d_in) {
+        A.resize(d_out * d_in);
+        float* q = A.data();
         float_randn(q, d_out * d_in, seed);
         matrix_qr(d_in, d_out, q);
     } else {
         // use tight-frame transformation
-        A.resize (d_out * d_out);
-        float *q = A.data();
+        A.resize(d_out * d_out);
+        float* q = A.data();
         float_randn(q, d_out * d_out, seed);
         matrix_qr(d_out, d_out, q);
         // remove columns
         int i, j;
         for (i = 0; i < d_out; i++) {
-            for(j = 0; j < d_in; j++) {
+            for (j = 0; j < d_in; j++) {
                 q[i * d_in + j] = q[i * d_out + j];
             }
         }
@@ -271,247 +337,281 @@ void RandomRotationMatrix::init (int seed)
     is_trained = true;
 }
 
-void RandomRotationMatrix::train (Index::idx_t /*n*/, const float * /*x*/)
-{
+void RandomRotationMatrix::train(Index::idx_t /*n*/, const float* /*x*/) {
     // initialize with some arbitrary seed
-    init (12345);
+    init(12345);
 }
 
-
 /*********************************************
  * 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)
-{
+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) {
     is_trained = false;
     max_points_per_d = 1000;
     balanced_bins = 0;
+    epsilon = 0;
 }
 
-
 namespace {
 
 /// Compute the eigenvalue decomposition of symmetric matrix cov,
 /// dimensions d_in-by-d_in. Output eigenvectors in cov.
 
-void eig(size_t d_in, double *cov, double *eigenvalues, int verbose)
-{
+void eig(size_t d_in, double* cov, double* eigenvalues, int verbose) {
     { // compute eigenvalues and vectors
         FINTEGER info = 0, lwork = -1, di = d_in;
         double workq;
 
-        dsyev_ ("Vectors as well", "Upper",
-                &di, cov, &di, eigenvalues, &workq, &lwork, &info);
+        dsyev_("Vectors as well",
+               "Upper",
+               &di,
+               cov,
+               &di,
+               eigenvalues,
+               &workq,
+               &lwork,
+               &info);
         lwork = FINTEGER(workq);
-        double *work = new double[lwork];
+        double* work = new double[lwork];
 
-        dsyev_ ("Vectors as well", "Upper",
-                &di, cov, &di, eigenvalues, work, &lwork, &info);
+        dsyev_("Vectors as well",
+               "Upper",
+               &di,
+               cov,
+               &di,
+               eigenvalues,
+               work,
+               &lwork,
+               &info);
 
-        delete [] work;
+        delete[] work;
 
         if (info != 0) {
-            fprintf (stderr, "WARN ssyev info returns %d, "
-                     "a very bad PCA matrix is learnt\n",
-                     int(info));
+            fprintf(stderr,
+                    "WARN ssyev info returns %d, "
+                    "a very bad PCA matrix is learnt\n",
+                    int(info));
             // do not throw exception, as the matrix could still be useful
         }
 
-
-        if(verbose && d_in <= 10) {
+        if (verbose && d_in <= 10) {
             printf("info=%ld new eigvals=[", long(info));
-            for(int j = 0; j < d_in; j++) printf("%g ", eigenvalues[j]);
+            for (int j = 0; j < d_in; j++)
+                printf("%g ", eigenvalues[j]);
             printf("]\n");
 
-            double *ci = cov;
+            double* ci = cov;
             printf("eigenvecs=\n");
-            for(int i = 0; i < d_in; i++) {
-                for(int j = 0; j < d_in; j++)
+            for (int i = 0; i < d_in; i++) {
+                for (int j = 0; j < d_in; j++)
                     printf("%10.4g ", *ci++);
                 printf("\n");
             }
         }
-
     }
 
     // revert order of eigenvectors & values
 
-    for(int i = 0; i < d_in / 2; i++) {
-
+    for (int 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++)
+        double* v1 = cov + i * d_in;
+        double* v2 = cov + (d_in - 1 - i) * d_in;
+        for (int j = 0; j < d_in; j++)
             std::swap(v1[j], v2[j]);
     }
-
 }
 
+} // namespace
 
-}
-
-void PCAMatrix::train (Index::idx_t n, const float *x)
-{
-    const float * x_in = x;
+void PCAMatrix::train(Index::idx_t n, const float* x) {
+    const float* x_in = x;
 
-    x = fvecs_maybe_subsample (d_in, (size_t*)&n,
-                               max_points_per_d * d_in, x, verbose);
+    x = fvecs_maybe_subsample(
+            d_in, (size_t*)&n, max_points_per_d * d_in, x, verbose);
 
-    ScopeDeleter<float> del_x (x != x_in ? x : nullptr);
+    ScopeDeleter<float> del_x(x != x_in ? x : nullptr);
 
     // compute mean
-    mean.clear(); mean.resize(d_in, 0.0);
+    mean.clear();
+    mean.resize(d_in, 0.0);
     if (have_bias) { // we may want to skip the bias
-        const float *xi = x;
+        const float* xi = x;
         for (int i = 0; i < n; i++) {
-            for(int j = 0; j < d_in; j++)
+            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) {
+    if (verbose) {
         printf("mean=[");
-        for(int j = 0; j < d_in; j++) printf("%g ", mean[j]);
+        for (int j = 0; j < d_in; j++)
+            printf("%g ", mean[j]);
         printf("]\n");
     }
 
-    if(n >= d_in) {
+    if (n >= d_in) {
         // compute covariance matrix, store it in PCA matrix
         PCAMat.resize(d_in * d_in);
-        float * cov = PCAMat.data();
+        float* cov = PCAMat.data();
         { // 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++)
-                    *ci++ = - n * mean[i] * mean[j];
+            float* ci = cov;
+            for (int i = 0; i < d_in; i++) {
+                for (int j = 0; j < d_in; j++)
+                    *ci++ = -n * mean[i] * mean[j];
             }
         }
         {
             FINTEGER di = d_in, ni = n;
             float one = 1.0;
-            ssyrk_ ("Up", "Non transposed",
-                    &di, &ni, &one, (float*)x, &di, &one, cov, &di);
-
+            ssyrk_("Up",
+                   "Non transposed",
+                   &di,
+                   &ni,
+                   &one,
+                   (float*)x,
+                   &di,
+                   &one,
+                   cov,
+                   &di);
         }
-        if(verbose && d_in <= 10) {
-            float *ci = cov;
+        if (verbose && d_in <= 10) {
+            float* ci = cov;
             printf("cov=\n");
-            for(int i = 0; i < d_in; i++) {
-                for(int j = 0; j < d_in; j++)
+            for (int i = 0; i < d_in; i++) {
+                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++) covd [i] = cov [i];
+        std::vector<double> covd(d_in * d_in);
+        for (size_t i = 0; i < d_in * d_in; i++)
+            covd[i] = cov[i];
 
-        std::vector<double> eigenvaluesd (d_in);
+        std::vector<double> eigenvaluesd(d_in);
 
-        eig (d_in, covd.data (), eigenvaluesd.data (), verbose);
+        eig(d_in, covd.data(), eigenvaluesd.data(), verbose);
 
-        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 * d_in; i++)
+            PCAMat[i] = covd[i];
+        eigenvalues.resize(d_in);
 
         for (size_t i = 0; i < d_in; i++)
-            eigenvalues [i] = eigenvaluesd [i];
-
+            eigenvalues[i] = eigenvaluesd[i];
 
     } else {
-
-        std::vector<float> xc (n * d_in);
+        std::vector<float> xc(n * d_in);
 
         for (size_t i = 0; i < n; i++)
-            for(size_t j = 0; j < d_in; j++)
-                xc [i * d_in + j] = x [i * d_in + j] - mean[j];
+            for (size_t 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);
+        std::vector<float> gram(n * n);
         {
             FINTEGER di = d_in, ni = n;
             float one = 1.0, zero = 0.0;
-            ssyrk_ ("Up", "Transposed",
-                    &ni, &di, &one, xc.data(), &di, &zero, gram.data(), &ni);
+            ssyrk_("Up",
+                   "Transposed",
+                   &ni,
+                   &di,
+                   &one,
+                   xc.data(),
+                   &di,
+                   &zero,
+                   gram.data(),
+                   &ni);
         }
 
-        if(verbose && d_in <= 10) {
-            float *ci = gram.data();
+        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 (int i = 0; i < n; i++) {
+                for (int j = 0; j < n; j++)
                     printf("%10g ", *ci++);
                 printf("\n");
             }
         }
 
-        std::vector<double> gramd (n * n);
+        std::vector<double> gramd(n * n);
         for (size_t i = 0; i < n * n; i++)
-            gramd [i] = gram [i];
+            gramd[i] = gram[i];
 
-        std::vector<double> eigenvaluesd (n);
+        std::vector<double> eigenvaluesd(n);
 
         // eig will fill in only the n first eigenvals
 
-        eig (n, gramd.data (), eigenvaluesd.data (), verbose);
+        eig(n, gramd.data(), eigenvaluesd.data(), verbose);
 
         PCAMat.resize(d_in * n);
 
         for (size_t i = 0; i < n * n; i++)
-            gram [i] = gramd [i];
+            gram[i] = gramd[i];
 
-        eigenvalues.resize (d_in);
+        eigenvalues.resize(d_in);
         // fill in only the n first ones
         for (size_t i = 0; i < n; i++)
-            eigenvalues [i] = eigenvaluesd [i];
+            eigenvalues[i] = eigenvaluesd[i];
 
         { // compute PCAMat = x' * v
             FINTEGER di = d_in, ni = n;
             float one = 1.0;
 
-            sgemm_ ("Non", "Non Trans",
-                    &di, &ni, &ni,
-                    &one, xc.data(), &di, gram.data(), &ni,
-                    &one, PCAMat.data(), &di);
+            sgemm_("Non",
+                   "Non Trans",
+                   &di,
+                   &ni,
+                   &ni,
+                   &one,
+                   xc.data(),
+                   &di,
+                   gram.data(),
+                   &ni,
+                   &one,
+                   PCAMat.data(),
+                   &di);
         }
 
-        if(verbose && d_in <= 10) {
-            float *ci = PCAMat.data();
+        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 (int i = 0; i < n; i++) {
+                for (int j = 0; j < d_in; j++)
                     printf("%10g ", *ci++);
                 printf("\n");
             }
         }
-        fvec_renorm_L2 (d_in, n, PCAMat.data());
-
+        fvec_renorm_L2(d_in, n, PCAMat.data());
     }
 
     prepare_Ab();
     is_trained = true;
 }
 
-void PCAMatrix::copy_from (const PCAMatrix & other)
-{
-    FAISS_THROW_IF_NOT (other.is_trained);
+void PCAMatrix::copy_from(const PCAMatrix& other) {
+    FAISS_THROW_IF_NOT(other.is_trained);
     mean = other.mean;
     eigenvalues = other.eigenvalues;
     PCAMat = other.PCAMat;
-    prepare_Ab ();
+    prepare_Ab();
     is_trained = true;
 }
 
-void PCAMatrix::prepare_Ab ()
-{
-    FAISS_THROW_IF_NOT_FMT (
+void PCAMatrix::prepare_Ab() {
+    FAISS_THROW_IF_NOT_FMT(
             d_out * d_in <= PCAMat.size(),
             "PCA matrix cannot output %d dimensions from %d ",
-            d_out, d_in);
+            d_out,
+            d_in);
 
     if (!random_rotation) {
         A = PCAMat;
@@ -519,23 +619,23 @@ void PCAMatrix::prepare_Ab ()
 
         // first scale the components
         if (eigen_power != 0) {
-            float *ai = A.data();
+            float* ai = A.data();
             for (int i = 0; i < d_out; i++) {
-                float factor = pow(eigenvalues[i], eigen_power);
-                for(int j = 0; j < d_in; j++)
+                float factor = 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(d_out % balanced_bins == 0);
             int dsub = d_out / balanced_bins;
-            std::vector <float> Ain;
+            std::vector<float> Ain;
             std::swap(A, Ain);
             A.resize(d_out * d_in);
 
-            std::vector <float> accu(balanced_bins);
-            std::vector <int> counter(balanced_bins);
+            std::vector<float> accu(balanced_bins);
+            std::vector<int> counter(balanced_bins);
 
             // greedy assignment
             for (int i = 0; i < d_out; i++) {
@@ -550,9 +650,8 @@ void PCAMatrix::prepare_Ab ()
                 }
                 int row_dst = best_j * dsub + counter[best_j];
                 accu[best_j] += eigenvalues[i];
-                counter[best_j] ++;
-                memcpy (&A[row_dst * d_in], &Ain[i * d_in],
-                        d_in * sizeof (A[0]));
+                counter[best_j]++;
+                memcpy(&A[row_dst * d_in], &Ain[i * d_in], d_in * sizeof(A[0]));
             }
 
             if (verbose) {
@@ -563,11 +662,11 @@ void PCAMatrix::prepare_Ab ()
             }
         }
 
-
     } else {
-        FAISS_THROW_IF_NOT_MSG (balanced_bins == 0,
-             "both balancing bins and applying a random rotation "
-             "does not make sense");
+        FAISS_THROW_IF_NOT_MSG(
+                balanced_bins == 0,
+                "both balancing bins and applying a random rotation "
+                "does not make sense");
         RandomRotationMatrix rr(d_out, d_out);
 
         rr.init(5);
@@ -576,8 +675,8 @@ 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++)
-                   rr.A[j * d_out + i] *= factor;
+                for (int j = 0; j < d_out; j++)
+                    rr.A[j * d_out + i] *= factor;
             }
         }
 
@@ -586,15 +685,24 @@ void PCAMatrix::prepare_Ab ()
             FINTEGER dii = d_in, doo = d_out;
             float one = 1.0, zero = 0.0;
 
-            sgemm_ ("Not", "Not", &dii, &doo, &doo,
-                    &one, PCAMat.data(), &dii, rr.A.data(), &doo, &zero,
-                    A.data(), &dii);
-
+            sgemm_("Not",
+                   "Not",
+                   &dii,
+                   &doo,
+                   &doo,
+                   &one,
+                   PCAMat.data(),
+                   &dii,
+                   rr.A.data(),
+                   &doo,
+                   &zero,
+                   A.data(),
+                   &dii);
         }
-
     }
 
-    b.clear(); b.resize(d_out);
+    b.clear();
+    b.resize(d_out);
 
     for (int i = 0; i < d_out; i++) {
         float accu = 0;
@@ -604,57 +712,61 @@ void PCAMatrix::prepare_Ab ()
     }
 
     is_orthonormal = eigen_power == 0;
-
 }
 
 /*********************************************
  * ITQMatrix
  *********************************************/
 
-ITQMatrix::ITQMatrix (int d):
-    LinearTransform(d, d, false),
-    max_iter (50),
-    seed (123)
-{
-}
-
+ITQMatrix::ITQMatrix(int d)
+        : LinearTransform(d, d, false), max_iter(50), seed(123) {}
 
 /** translated from fbcode/deeplearning/catalyzer/catalyzer/quantizers.py */
-void ITQMatrix::train (Index::idx_t n, const float* xf)
-{
+void ITQMatrix::train(Index::idx_t n, const float* xf) {
     size_t d = d_in;
-    std::vector<double> rotation (d * d);
+    std::vector<double> rotation(d * d);
 
     if (init_rotation.size() == d * d) {
-        memcpy (rotation.data(), init_rotation.data(),
-                d * d * sizeof(rotation[0]));
+        memcpy(rotation.data(),
+               init_rotation.data(),
+               d * d * sizeof(rotation[0]));
     } else {
-        RandomRotationMatrix rrot (d, d);
-        rrot.init (seed);
+        RandomRotationMatrix rrot(d, d);
+        rrot.init(seed);
         for (size_t i = 0; i < d * d; i++) {
             rotation[i] = rrot.A[i];
         }
     }
 
-    std::vector<double> x (n * d);
+    std::vector<double> x(n * d);
 
     for (size_t i = 0; i < n * d; i++) {
         x[i] = xf[i];
     }
 
-    std::vector<double> rotated_x (n * d), cov_mat (d * d);
-    std::vector<double> u (d * d), vt (d * d), singvals (d);
+    std::vector<double> rotated_x(n * d), cov_mat(d * d);
+    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, d, d);
         { // rotated_data = np.dot(training_data, rotation)
             FINTEGER di = d, ni = n;
             double one = 1, zero = 0;
-            dgemm_ ("N", "N", &di, &ni, &di,
-                    &one, rotation.data(), &di, x.data(), &di,
-                    &zero, rotated_x.data(), &di);
+            dgemm_("N",
+                   "N",
+                   &di,
+                   &ni,
+                   &di,
+                   &one,
+                   rotation.data(),
+                   &di,
+                   x.data(),
+                   &di,
+                   &zero,
+                   rotated_x.data(),
+                   &di);
         }
-        print_if_verbose ("rotated_x", rotated_x, n, d);
+        print_if_verbose("rotated_x", rotated_x, n, d);
         // binarize
         for (size_t j = 0; j < n * d; j++) {
             rotated_x[j] = rotated_x[j] < 0 ? -1 : 1;
@@ -663,88 +775,119 @@ void ITQMatrix::train (Index::idx_t n, const float* xf)
         { // rotated_data = np.dot(training_data, rotation)
             FINTEGER di = d, ni = n;
             double one = 1, zero = 0;
-            dgemm_ ("N", "T", &di, &di, &ni,
-                    &one, rotated_x.data(), &di, x.data(), &di,
-                    &zero, cov_mat.data(), &di);
+            dgemm_("N",
+                   "T",
+                   &di,
+                   &di,
+                   &ni,
+                   &one,
+                   rotated_x.data(),
+                   &di,
+                   x.data(),
+                   &di,
+                   &zero,
+                   cov_mat.data(),
+                   &di);
         }
-        print_if_verbose ("cov_mat", cov_mat, d, d);
+        print_if_verbose("cov_mat", cov_mat, d, d);
         // SVD
         {
-
             FINTEGER di = d;
             FINTEGER lwork = -1, info;
             double lwork1;
 
             // workspace query
-            dgesvd_ ("A", "A", &di, &di, cov_mat.data(), &di,
-                     singvals.data(), u.data(), &di,
-                     vt.data(), &di,
-                     &lwork1, &lwork, &info);
-
-            FAISS_THROW_IF_NOT (info == 0);
-            lwork = size_t (lwork1);
-            std::vector<double> work (lwork);
-            dgesvd_ ("A", "A", &di, &di, cov_mat.data(), &di,
-                     singvals.data(), u.data(), &di,
-                     vt.data(), &di,
-                     work.data(), &lwork, &info);
-            FAISS_THROW_IF_NOT_FMT (info == 0, "sgesvd returned info=%d", info);
-
+            dgesvd_("A",
+                    "A",
+                    &di,
+                    &di,
+                    cov_mat.data(),
+                    &di,
+                    singvals.data(),
+                    u.data(),
+                    &di,
+                    vt.data(),
+                    &di,
+                    &lwork1,
+                    &lwork,
+                    &info);
+
+            FAISS_THROW_IF_NOT(info == 0);
+            lwork = size_t(lwork1);
+            std::vector<double> work(lwork);
+            dgesvd_("A",
+                    "A",
+                    &di,
+                    &di,
+                    cov_mat.data(),
+                    &di,
+                    singvals.data(),
+                    u.data(),
+                    &di,
+                    vt.data(),
+                    &di,
+                    work.data(),
+                    &lwork,
+                    &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, d, d);
+        print_if_verbose("vt", vt, d, d);
         // update rotation
         {
             FINTEGER di = d;
             double one = 1, zero = 0;
-            dgemm_ ("N", "T", &di, &di, &di,
-                    &one, u.data(), &di, vt.data(), &di,
-                    &zero, rotation.data(), &di);
+            dgemm_("N",
+                   "T",
+                   &di,
+                   &di,
+                   &di,
+                   &one,
+                   u.data(),
+                   &di,
+                   vt.data(),
+                   &di,
+                   &zero,
+                   rotation.data(),
+                   &di);
         }
-        print_if_verbose ("final rot", rotation, d, d);
-
+        print_if_verbose("final rot", rotation, d, d);
     }
-    A.resize (d * d);
+    A.resize(d * d);
     for (size_t i = 0; i < d; i++) {
         for (size_t j = 0; j < d; j++) {
             A[i + d * j] = rotation[j + d * i];
         }
     }
     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)
-{
+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);
+        FAISS_THROW_IF_NOT(d_in == d_out);
     }
     max_train_per_dim = 10;
     is_trained = false;
 }
 
+void ITQTransform::train(idx_t n, const float* x) {
+    FAISS_THROW_IF_NOT(!is_trained);
 
-
-
-void ITQTransform::train (idx_t n, const float *x)
-{
-    FAISS_THROW_IF_NOT (!is_trained);
-
-    const float * x_in = x;
+    const float* x_in = x;
     size_t max_train_points = std::max(d_in * max_train_per_dim, 32768);
-    x = fvecs_maybe_subsample (d_in, (size_t*)&n, max_train_points, x);
+    x = fvecs_maybe_subsample(d_in, (size_t*)&n, max_train_points, x);
 
-    ScopeDeleter<float> del_x (x != x_in ? x : nullptr);
+    ScopeDeleter<float> del_x(x != x_in ? x : nullptr);
 
-    std::unique_ptr<float []> x_norm(new float[n * d_in]);
+    std::unique_ptr<float[]> x_norm(new float[n * d_in]);
     { // normalize
         int d = d_in;
 
-        mean.resize (d, 0);
+        mean.resize(d, 0);
         for (idx_t i = 0; i < n; i++) {
             for (idx_t j = 0; j < d; j++) {
                 mean[j] += x[i * d + j];
@@ -755,38 +898,47 @@ void ITQTransform::train (idx_t n, const float *x)
         }
         for (idx_t i = 0; i < n; i++) {
             for (idx_t j = 0; j < d; j++) {
-            x_norm[i * d + j] = x[i * d + j] - mean[j];
+                x_norm[i * d + j] = x[i * d + j] - mean[j];
             }
         }
-        fvec_renorm_L2 (d_in, n, x_norm.get());
+        fvec_renorm_L2(d_in, n, x_norm.get());
     }
 
     // train PCA
 
-    PCAMatrix pca (d_in, d_out);
-    float *x_pca;
-    std::unique_ptr<float []> x_pca_del;
+    PCAMatrix pca(d_in, d_out);
+    float* x_pca;
+    std::unique_ptr<float[]> x_pca_del;
     if (do_pca) {
-        pca.have_bias = false;  // for consistency with reference implem
-        pca.train (n, x_norm.get());
-        x_pca = pca.apply (n, x_norm.get());
+        pca.have_bias = false; // for consistency with reference implem
+        pca.train(n, x_norm.get());
+        x_pca = pca.apply(n, x_norm.get());
         x_pca_del.reset(x_pca);
     } else {
         x_pca = x_norm.get();
     }
 
     // train ITQ
-    itq.train (n, x_pca);
+    itq.train(n, x_pca);
 
     // merge PCA and ITQ
     if (do_pca) {
         FINTEGER di = d_out, dini = d_in;
         float one = 1, zero = 0;
         pca_then_itq.A.resize(d_in * d_out);
-        sgemm_ ("N", "N", &dini, &di, &di,
-                &one, pca.A.data(), &dini,
-                itq.A.data(), &di,
-                &zero, pca_then_itq.A.data(), &dini);
+        sgemm_("N",
+               "N",
+               &dini,
+               &di,
+               &di,
+               &one,
+               pca.A.data(),
+               &dini,
+               itq.A.data(),
+               &di,
+               &zero,
+               pca_then_itq.A.data(),
+               &dini);
     } else {
         pca_then_itq.A = itq.A;
     }
@@ -794,12 +946,11 @@ void ITQTransform::train (idx_t n, const float *x)
     is_trained = true;
 }
 
-void ITQTransform::apply_noalloc (Index::idx_t n, const float * x,
-                               float * xt) const
-{
+void ITQTransform::apply_noalloc(Index::idx_t n, const float* x, float* xt)
+        const {
     FAISS_THROW_IF_NOT_MSG(is_trained, "Transformation not trained yet");
 
-    std::unique_ptr<float []> x_norm(new float[n * d_in]);
+    std::unique_ptr<float[]> x_norm(new float[n * d_in]);
     { // normalize
         int d = d_in;
         for (idx_t i = 0; i < n; i++) {
@@ -809,41 +960,36 @@ void ITQTransform::apply_noalloc (Index::idx_t n, const float * x,
         }
         // this is not really useful if we are going to binarize right
         // afterwards but OK
-        fvec_renorm_L2 (d_in, n, x_norm.get());
+        fvec_renorm_L2(d_in, n, x_norm.get());
     }
 
-    pca_then_itq.apply_noalloc (n, x_norm.get(), xt);
+    pca_then_itq.apply_noalloc(n, x_norm.get(), xt);
 }
 
 /*********************************************
  * OPQMatrix
  *********************************************/
 
-
-OPQMatrix::OPQMatrix (int d, int M, int d2):
-    LinearTransform (d, d2 == -1 ? d : d2, false), M(M),
-    niter (50),
-    niter_pq (4), niter_pq_0 (40),
-    verbose(false),
-    pq(nullptr)
-{
+OPQMatrix::OPQMatrix(int d, int M, int d2)
+        : LinearTransform(d, d2 == -1 ? d : d2, false),
+          M(M),
+          niter(50),
+          niter_pq(4),
+          niter_pq_0(40),
+          verbose(false),
+          pq(nullptr) {
     is_trained = false;
     // OPQ is quite expensive to train, so set this right.
     max_train_points = 256 * 256;
     pq = nullptr;
 }
 
+void OPQMatrix::train(Index::idx_t n, const float* x) {
+    const float* x_in = x;
 
+    x = fvecs_maybe_subsample(d_in, (size_t*)&n, max_train_points, x, verbose);
 
-void OPQMatrix::train (Index::idx_t n, const float *x)
-{
-
-    const float * x_in = x;
-
-    x = fvecs_maybe_subsample (d_in, (size_t*)&n,
-                               max_train_points, x, verbose);
-
-    ScopeDeleter<float> del_x (x != x_in ? x : nullptr);
+    ScopeDeleter<float> del_x(x != x_in ? x : nullptr);
 
     // To support d_out > d_in, we pad input vectors with 0s to d_out
     size_t d = d_out <= d_in ? d_in : d_out;
@@ -867,22 +1013,26 @@ void OPQMatrix::train (Index::idx_t n, const float *x)
 #endif
 
     if (verbose) {
-        printf ("OPQMatrix::train: training an OPQ rotation matrix "
-                "for M=%d from %" PRId64 " vectors in %dD -> %dD\n",
-                M, n, d_in, d_out);
+        printf("OPQMatrix::train: training an OPQ rotation matrix "
+               "for M=%d from %" PRId64 " vectors in %dD -> %dD\n",
+               M,
+               n,
+               d_in,
+               d_out);
     }
 
-    std::vector<float> xtrain (n * d);
+    std::vector<float> xtrain(n * d);
     // center x
     {
-        std::vector<float> sum (d);
-        const float *xi = x;
+        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++)
-                sum [j] += *xi++;
+                sum[j] += *xi++;
         }
-        for (int i = 0; i < d; i++) sum[i] /= n;
-        float *yi = xtrain.data();
+        for (int 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++)
@@ -890,71 +1040,80 @@ void OPQMatrix::train (Index::idx_t n, const float *x)
             yi += d - d_in;
         }
     }
-    float *rotation;
+    float* rotation;
 
-    if (A.size () == 0) {
-        A.resize (d * d);
+    if (A.size() == 0) {
+        A.resize(d * d);
         rotation = A.data();
         if (verbose)
             printf("  OPQMatrix::train: making random %zd*%zd rotation\n",
-                   d, d);
-        float_randn (rotation, d * d, 1234);
-        matrix_qr (d, d, rotation);
+                   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);
+        A.resize(d * d2);
     } else {
-        FAISS_THROW_IF_NOT (A.size() == d * d2);
+        FAISS_THROW_IF_NOT(A.size() == d * d2);
         rotation = A.data();
     }
 
-    std::vector<float>
-        xproj (d2 * n), pq_recons (d2 * n), xxr (d * n),
-        tmp(d * d * 4);
-
+    std::vector<float> xproj(d2 * n), pq_recons(d2 * n), xxr(d * n),
+            tmp(d * d * 4);
 
-    ProductQuantizer pq_default (d2, M, 8);
-    ProductQuantizer &pq_regular = pq ? *pq : pq_default;
-    std::vector<uint8_t> codes (pq_regular.code_size * n);
+    ProductQuantizer pq_default(d2, M, 8);
+    ProductQuantizer& pq_regular = pq ? *pq : pq_default;
+    std::vector<uint8_t> codes(pq_regular.code_size * n);
 
     double t0 = getmillisecs();
     for (int iter = 0; iter < niter; iter++) {
-
         { // torch.mm(xtrain, rotation:t())
             FINTEGER di = d, d2i = d2, ni = n;
             float zero = 0, one = 1;
-            sgemm_ ("Transposed", "Not transposed",
-                    &d2i, &ni, &di,
-                    &one, rotation, &di,
-                    xtrain.data(), &di,
-                    &zero, xproj.data(), &d2i);
+            sgemm_("Transposed",
+                   "Not transposed",
+                   &d2i,
+                   &ni,
+                   &di,
+                   &one,
+                   rotation,
+                   &di,
+                   xtrain.data(),
+                   &di,
+                   &zero,
+                   xproj.data(),
+                   &d2i);
         }
 
         pq_regular.cp.max_points_per_centroid = 1000;
         pq_regular.cp.niter = iter == 0 ? niter_pq_0 : niter_pq;
         pq_regular.verbose = verbose;
-        pq_regular.train (n, xproj.data());
+        pq_regular.train(n, xproj.data());
 
         if (verbose) {
             printf("    encode / decode\n");
         }
         if (pq_regular.assign_index) {
-            pq_regular.compute_codes_with_assign_index
-                (xproj.data(), codes.data(), n);
+            pq_regular.compute_codes_with_assign_index(
+                    xproj.data(), codes.data(), n);
         } else {
-            pq_regular.compute_codes (xproj.data(), codes.data(), n);
+            pq_regular.compute_codes(xproj.data(), codes.data(), n);
         }
-        pq_regular.decode (codes.data(), pq_recons.data(), n);
+        pq_regular.decode(codes.data(), pq_recons.data(), n);
 
-        float pq_err = fvec_L2sqr (pq_recons.data(), xproj.data(), n * d2) / n;
+        float pq_err = fvec_L2sqr(pq_recons.data(), xproj.data(), n * d2) / n;
 
         if (verbose)
-            printf ("    Iteration %d (%d PQ iterations):"
-                    "%.3f s, obj=%g\n", iter, pq_regular.cp.niter,
-                    (getmillisecs () - t0) / 1000.0, pq_err);
+            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];
+            float *u = tmp.data(), *vt = &tmp[d * d];
+            float* sing_val = &tmp[2 * d * d];
             FINTEGER di = d, d2i = d2, ni = n;
             float one = 1, zero = 0;
 
@@ -962,36 +1121,69 @@ void OPQMatrix::train (Index::idx_t n, const float *x)
                 printf("    X * recons\n");
             }
             // torch.mm(xtrain:t(), pq_recons)
-            sgemm_ ("Not", "Transposed",
-                    &d2i, &di, &ni,
-                    &one, pq_recons.data(), &d2i,
-                    xtrain.data(), &di,
-                    &zero, xxr.data(), &d2i);
-
+            sgemm_("Not",
+                   "Transposed",
+                   &d2i,
+                   &di,
+                   &ni,
+                   &one,
+                   pq_recons.data(),
+                   &d2i,
+                   xtrain.data(),
+                   &di,
+                   &zero,
+                   xxr.data(),
+                   &d2i);
 
             FINTEGER lwork = -1, info = -1;
             float worksz;
             // workspace query
-            sgesvd_ ("All", "All",
-                     &d2i, &di, xxr.data(), &d2i,
-                     sing_val,
-                     vt, &d2i, u, &di,
-                     &worksz, &lwork, &info);
+            sgesvd_("All",
+                    "All",
+                    &d2i,
+                    &di,
+                    xxr.data(),
+                    &d2i,
+                    sing_val,
+                    vt,
+                    &d2i,
+                    u,
+                    &di,
+                    &worksz,
+                    &lwork,
+                    &info);
 
             lwork = int(worksz);
-            std::vector<float> work (lwork);
+            std::vector<float> work(lwork);
             // u and vt swapped
-            sgesvd_ ("All", "All",
-                     &d2i, &di, xxr.data(), &d2i,
-                     sing_val,
-                     vt, &d2i, u, &di,
-                     work.data(), &lwork, &info);
-
-            sgemm_ ("Transposed", "Transposed",
-                    &di, &d2i, &d2i,
-                    &one, u, &di, vt, &d2i,
-                    &zero, rotation, &di);
-
+            sgesvd_("All",
+                    "All",
+                    &d2i,
+                    &di,
+                    xxr.data(),
+                    &d2i,
+                    sing_val,
+                    vt,
+                    &d2i,
+                    u,
+                    &di,
+                    work.data(),
+                    &lwork,
+                    &info);
+
+            sgemm_("Transposed",
+                   "Transposed",
+                   &di,
+                   &d2i,
+                   &d2i,
+                   &one,
+                   u,
+                   &di,
+                   vt,
+                   &d2i,
+                   &zero,
+                   rotation,
+                   &di);
         }
         pq_regular.train_type = ProductQuantizer::Train_hot_start;
     }
@@ -999,59 +1191,52 @@ void OPQMatrix::train (Index::idx_t n, const float *x)
     // revert A matrix
     if (d > 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);
+            memmove(&A[i * d_in], &A[i * d], sizeof(A[0]) * d_in);
+        A.resize(d_in * d_out);
     }
 
     is_trained = true;
     is_orthonormal = true;
 }
 
-
 /*********************************************
  * NormalizationTransform
  *********************************************/
 
-NormalizationTransform::NormalizationTransform (int d, float norm):
-    VectorTransform (d, d), norm (norm)
-{
-}
+NormalizationTransform::NormalizationTransform(int d, float norm)
+        : VectorTransform(d, d), norm(norm) {}
 
-NormalizationTransform::NormalizationTransform ():
-    VectorTransform (-1, -1), norm (-1)
-{
-}
+NormalizationTransform::NormalizationTransform()
+        : VectorTransform(-1, -1), norm(-1) {}
 
-void NormalizationTransform::apply_noalloc
-      (idx_t n, const float* x, float* xt) const
-{
+void NormalizationTransform::apply_noalloc(idx_t n, const float* x, float* xt)
+        const {
     if (norm == 2.0) {
-        memcpy (xt, x, sizeof (x[0]) * n * d_in);
-        fvec_renorm_L2 (d_in, n, xt);
+        memcpy(xt, x, sizeof(x[0]) * n * d_in);
+        fvec_renorm_L2(d_in, n, xt);
     } else {
-        FAISS_THROW_MSG ("not implemented");
+        FAISS_THROW_MSG("not implemented");
     }
 }
 
-void NormalizationTransform::reverse_transform (idx_t n, const float* xt,
-                                                float* x) const
-{
-    memcpy (x, xt, sizeof (xt[0]) * n * d_in);
+void NormalizationTransform::reverse_transform(
+        idx_t n,
+        const float* xt,
+        float* x) const {
+    memcpy(x, xt, sizeof(xt[0]) * n * d_in);
 }
 
 /*********************************************
  * CenteringTransform
  *********************************************/
 
-CenteringTransform::CenteringTransform (int d):
-    VectorTransform (d, d)
-{
+CenteringTransform::CenteringTransform(int d) : VectorTransform(d, d) {
     is_trained = false;
 }
 
-void CenteringTransform::train(Index::idx_t n, const float *x) {
+void CenteringTransform::train(Index::idx_t n, const float* x) {
     FAISS_THROW_IF_NOT_MSG(n > 0, "need at least one training vector");
-    mean.resize (d_in, 0);
+    mean.resize(d_in, 0);
     for (idx_t i = 0; i < n; i++) {
         for (size_t j = 0; j < d_in; j++) {
             mean[j] += *x++;
@@ -1064,11 +1249,9 @@ void CenteringTransform::train(Index::idx_t n, const float *x) {
     is_trained = true;
 }
 
-
-void CenteringTransform::apply_noalloc
-      (idx_t n, const float* x, float* xt) const
-{
-    FAISS_THROW_IF_NOT (is_trained);
+void CenteringTransform::apply_noalloc(idx_t n, const float* x, float* xt)
+        const {
+    FAISS_THROW_IF_NOT(is_trained);
 
     for (idx_t i = 0; i < n; i++) {
         for (size_t j = 0; j < d_in; j++) {
@@ -1077,64 +1260,58 @@ void CenteringTransform::apply_noalloc
     }
 }
 
-void CenteringTransform::reverse_transform (idx_t n, const float* xt,
-                                                float* x) const
-{
-    FAISS_THROW_IF_NOT (is_trained);
+void CenteringTransform::reverse_transform(idx_t n, const float* xt, float* x)
+        const {
+    FAISS_THROW_IF_NOT(is_trained);
 
     for (idx_t i = 0; i < n; i++) {
         for (size_t j = 0; j < d_in; j++) {
             *x++ = *xt++ + mean[j];
         }
     }
-
 }
 
-
-
-
-
 /*********************************************
  * RemapDimensionsTransform
  *********************************************/
 
-
-RemapDimensionsTransform::RemapDimensionsTransform (
-        int d_in, int d_out, const int *map_in):
-    VectorTransform (d_in, d_out)
-{
-    map.resize (d_out);
+RemapDimensionsTransform::RemapDimensionsTransform(
+        int d_in,
+        int d_out,
+        const int* map_in)
+        : VectorTransform(d_in, d_out) {
+    map.resize(d_out);
     for (int i = 0; i < d_out; i++) {
         map[i] = map_in[i];
-        FAISS_THROW_IF_NOT (map[i] == -1 || (map[i] >= 0 && map[i] < d_in));
+        FAISS_THROW_IF_NOT(map[i] == -1 || (map[i] >= 0 && map[i] < d_in));
     }
 }
 
-RemapDimensionsTransform::RemapDimensionsTransform (
-      int d_in, int d_out, bool uniform): VectorTransform (d_in, d_out)
-{
-    map.resize (d_out, -1);
+RemapDimensionsTransform::RemapDimensionsTransform(
+        int d_in,
+        int d_out,
+        bool uniform)
+        : VectorTransform(d_in, d_out) {
+    map.resize(d_out, -1);
 
     if (uniform) {
         if (d_in < d_out) {
             for (int i = 0; i < d_in; i++) {
-                map [i * d_out / d_in] = i;
-        }
+                map[i * d_out / d_in] = i;
+            }
         } else {
             for (int i = 0; i < d_out; i++) {
-                map [i] = i * d_in / d_out;
+                map[i] = i * d_in / d_out;
             }
         }
     } else {
         for (int i = 0; i < d_in && i < d_out; i++)
-            map [i] = i;
+            map[i] = i;
     }
 }
 
-
-void RemapDimensionsTransform::apply_noalloc (idx_t n, const float * x,
-                                              float *xt) const
-{
+void RemapDimensionsTransform::apply_noalloc(idx_t n, const float* x, float* xt)
+        const {
     for (idx_t i = 0; i < n; i++) {
         for (int j = 0; j < d_out; j++) {
             xt[j] = map[j] < 0 ? 0 : x[map[j]];
@@ -1144,13 +1321,15 @@ void RemapDimensionsTransform::apply_noalloc (idx_t n, const float * x,
     }
 }
 
-void RemapDimensionsTransform::reverse_transform (idx_t n, const float * xt,
-                                                  float *x) const
-{
-    memset (x, 0, sizeof (*x) * n * d_in);
+void RemapDimensionsTransform::reverse_transform(
+        idx_t n,
+        const float* xt,
+        float* x) const {
+    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) x[map[j]] = xt[j];
+            if (map[j] >= 0)
+                x[map[j]] = xt[j];
         }
         x += d_in;
         xt += d_out;