faiss 0.1.4 → 0.2.1

data/vendor/faiss/faiss/index_factory.h

@@ -5,8 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-// -*- c++ -*-
-
 #pragma once
 
 #include <faiss/Index.h>
@@ -16,10 +14,11 @@ namespace faiss {
 
 /** Build and index with the sequence of processing steps described in
  *  the string. */
-Index *index_factory (int d, const char *description,
-                      MetricType metric = METRIC_L2);
-
-IndexBinary *index_binary_factory (int d, const char *description);
+Index* index_factory(
+        int d,
+        const char* description,
+        MetricType metric = METRIC_L2);
 
+IndexBinary* index_binary_factory(int d, const char* description);
 
-}
+} // namespace faiss

data/vendor/faiss/faiss/index_io.h

@@ -12,10 +12,9 @@
 #ifndef FAISS_INDEX_IO_H
 #define FAISS_INDEX_IO_H
 
-
 #include <cstdio>
-#include <typeinfo>
 #include <string>
+#include <typeinfo>
 #include <vector>
 
 /** I/O functions can read/write to a filename, a file handle or to an
@@ -36,13 +35,13 @@ struct IOReader;
 struct IOWriter;
 struct InvertedLists;
 
-void write_index (const Index *idx, const char *fname);
-void write_index (const Index *idx, FILE *f);
-void write_index (const Index *idx, IOWriter *writer);
+void write_index(const Index* idx, const char* fname);
+void write_index(const Index* idx, FILE* f);
+void write_index(const Index* idx, IOWriter* writer);
 
-void write_index_binary (const IndexBinary *idx, const char *fname);
-void write_index_binary (const IndexBinary *idx, FILE *f);
-void write_index_binary (const IndexBinary *idx, IOWriter *writer);
+void write_index_binary(const IndexBinary* idx, const char* fname);
+void write_index_binary(const IndexBinary* idx, FILE* f);
+void write_index_binary(const IndexBinary* idx, IOWriter* writer);
 
 // The read_index flags are implemented only for a subset of index types.
 const int IO_FLAG_READ_ONLY = 2;
@@ -51,32 +50,30 @@ const int IO_FLAG_READ_ONLY = 2;
 const int IO_FLAG_ONDISK_SAME_DIR = 4;
 // don't load IVF data to RAM, only list sizes
 const int IO_FLAG_SKIP_IVF_DATA = 8;
-// try to memmap data (useful to load an ArrayInvertedLists as an OnDiskInvertedLists)
+// try to memmap data (useful to load an ArrayInvertedLists as an
+// OnDiskInvertedLists)
 const int IO_FLAG_MMAP = IO_FLAG_SKIP_IVF_DATA | 0x646f0000;
 
+Index* read_index(const char* fname, int io_flags = 0);
+Index* read_index(FILE* f, int io_flags = 0);
+Index* read_index(IOReader* reader, int io_flags = 0);
 
-Index *read_index (const char *fname, int io_flags = 0);
-Index *read_index (FILE * f, int io_flags = 0);
-Index *read_index (IOReader *reader, int io_flags = 0);
+IndexBinary* read_index_binary(const char* fname, int io_flags = 0);
+IndexBinary* read_index_binary(FILE* f, int io_flags = 0);
+IndexBinary* read_index_binary(IOReader* reader, int io_flags = 0);
 
-IndexBinary *read_index_binary (const char *fname, int io_flags = 0);
-IndexBinary *read_index_binary (FILE * f, int io_flags = 0);
-IndexBinary *read_index_binary (IOReader *reader, int io_flags = 0);
+void write_VectorTransform(const VectorTransform* vt, const char* fname);
+VectorTransform* read_VectorTransform(const char* fname);
 
-void write_VectorTransform (const VectorTransform *vt, const char *fname);
-VectorTransform *read_VectorTransform (const char *fname);
+ProductQuantizer* read_ProductQuantizer(const char* fname);
+ProductQuantizer* read_ProductQuantizer(IOReader* reader);
 
-ProductQuantizer * read_ProductQuantizer (const char*fname);
-ProductQuantizer * read_ProductQuantizer (IOReader *reader);
-
-void write_ProductQuantizer (const ProductQuantizer*pq, const char *fname);
-void write_ProductQuantizer (const ProductQuantizer*pq, IOWriter *f);
-
-void write_InvertedLists (const InvertedLists *ils, IOWriter *f);
-InvertedLists *read_InvertedLists (IOReader *reader, int io_flags = 0);
+void write_ProductQuantizer(const ProductQuantizer* pq, const char* fname);
+void write_ProductQuantizer(const ProductQuantizer* pq, IOWriter* f);
 
+void write_InvertedLists(const InvertedLists* ils, IOWriter* f);
+InvertedLists* read_InvertedLists(IOReader* reader, int io_flags = 0);
 
 } // namespace faiss
 
-
 #endif

data/vendor/faiss/faiss/invlists/BlockInvertedLists.cpp

@@ -12,81 +12,80 @@
 #include <faiss/impl/io.h>
 #include <faiss/impl/io_macros.h>
 
-
 namespace faiss {
 
-BlockInvertedLists::BlockInvertedLists (
-        size_t nlist, size_t n_per_block,
-        size_t block_size):
-    InvertedLists (nlist, InvertedLists::INVALID_CODE_SIZE),
-    n_per_block(n_per_block), block_size(block_size)
-{
-    ids.resize (nlist);
-    codes.resize (nlist);
+BlockInvertedLists::BlockInvertedLists(
+        size_t nlist,
+        size_t n_per_block,
+        size_t block_size)
+        : InvertedLists(nlist, InvertedLists::INVALID_CODE_SIZE),
+          n_per_block(n_per_block),
+          block_size(block_size) {
+    ids.resize(nlist);
+    codes.resize(nlist);
 }
 
-BlockInvertedLists::BlockInvertedLists ():
-    InvertedLists (0, InvertedLists::INVALID_CODE_SIZE),
-    n_per_block(0), block_size(0)
-{}
-
-
-size_t BlockInvertedLists::add_entries (
-           size_t list_no, size_t n_entry,
-           const idx_t* ids_in, const uint8_t *code)
-{
-    if (n_entry == 0) return 0;
-    FAISS_THROW_IF_NOT (list_no < nlist);
-    size_t o = ids [list_no].size();
-    FAISS_THROW_IF_NOT (o == 0); // not clear how we should handle subsequent adds
-    ids [list_no].resize (o + n_entry);
-    memcpy (&ids[list_no][o], ids_in, sizeof (ids_in[0]) * n_entry);
+BlockInvertedLists::BlockInvertedLists()
+        : InvertedLists(0, InvertedLists::INVALID_CODE_SIZE),
+          n_per_block(0),
+          block_size(0) {}
+
+size_t BlockInvertedLists::add_entries(
+        size_t list_no,
+        size_t n_entry,
+        const idx_t* ids_in,
+        const uint8_t* code) {
+    if (n_entry == 0)
+        return 0;
+    FAISS_THROW_IF_NOT(list_no < nlist);
+    size_t o = ids[list_no].size();
+    FAISS_THROW_IF_NOT(
+            o == 0); // not clear how we should handle subsequent adds
+    ids[list_no].resize(o + n_entry);
+    memcpy(&ids[list_no][o], ids_in, sizeof(ids_in[0]) * n_entry);
 
     // copy whole blocks
     size_t n_block = (n_entry + n_per_block - 1) / n_per_block;
-    codes [list_no].resize (n_block * block_size);
-    memcpy (&codes[list_no][o * code_size], code, n_block * block_size);
+    codes[list_no].resize(n_block * block_size);
+    memcpy(&codes[list_no][o * code_size], code, n_block * block_size);
     return o;
 }
 
-size_t BlockInvertedLists::list_size(size_t list_no) const
-{
-    assert (list_no < nlist);
+size_t BlockInvertedLists::list_size(size_t list_no) const {
+    assert(list_no < nlist);
     return ids[list_no].size();
 }
 
-const uint8_t * BlockInvertedLists::get_codes (size_t list_no) const
-{
-    assert (list_no < nlist);
+const uint8_t* BlockInvertedLists::get_codes(size_t list_no) const {
+    assert(list_no < nlist);
     return codes[list_no].get();
 }
 
-const InvertedLists::idx_t * BlockInvertedLists::get_ids (size_t list_no) const
-{
-    assert (list_no < nlist);
+const InvertedLists::idx_t* BlockInvertedLists::get_ids(size_t list_no) const {
+    assert(list_no < nlist);
     return ids[list_no].data();
 }
 
-void BlockInvertedLists::resize (size_t list_no, size_t new_size)
-{
-    ids[list_no].resize (new_size);
+void BlockInvertedLists::resize(size_t list_no, size_t new_size) {
+    ids[list_no].resize(new_size);
     size_t prev_nbytes = codes[list_no].size();
     size_t n_block = (new_size + n_per_block - 1) / n_per_block;
     size_t new_nbytes = n_block * block_size;
-    codes[list_no].resize (new_nbytes);
+    codes[list_no].resize(new_nbytes);
     if (prev_nbytes < new_nbytes) {
         // set new elements to 0
-        memset(
-            codes[list_no].data() + prev_nbytes, 0,
-            new_nbytes - prev_nbytes
-        );
+        memset(codes[list_no].data() + prev_nbytes,
+               0,
+               new_nbytes - prev_nbytes);
     }
 }
 
-void BlockInvertedLists::update_entries (
-      size_t , size_t , size_t ,
-      const idx_t *, const uint8_t *)
-{
+void BlockInvertedLists::update_entries(
+        size_t,
+        size_t,
+        size_t,
+        const idx_t*,
+        const uint8_t*) {
     FAISS_THROW_MSG("not impemented");
     /*
     assert (list_no < nlist);
@@ -96,29 +95,25 @@ void BlockInvertedLists::update_entries (
     */
 }
 
-
-BlockInvertedLists::~BlockInvertedLists ()
-{}
+BlockInvertedLists::~BlockInvertedLists() {}
 
 /**************************************************
  * IO hook implementation
  **************************************************/
 
-BlockInvertedListsIOHook::BlockInvertedListsIOHook():
-    InvertedListsIOHook("ilbl", typeid(BlockInvertedLists).name())
-{}
-
+BlockInvertedListsIOHook::BlockInvertedListsIOHook()
+        : InvertedListsIOHook("ilbl", typeid(BlockInvertedLists).name()) {}
 
-void BlockInvertedListsIOHook::write(const InvertedLists *ils_in, IOWriter *f) const
-{
-    uint32_t h = fourcc ("ilbl");
-    WRITE1 (h);
-    const BlockInvertedLists *il =
-        dynamic_cast<const BlockInvertedLists*> (ils_in);
-    WRITE1 (il->nlist);
-    WRITE1 (il->code_size);
-    WRITE1 (il->n_per_block);
-    WRITE1 (il->block_size);
+void BlockInvertedListsIOHook::write(const InvertedLists* ils_in, IOWriter* f)
+        const {
+    uint32_t h = fourcc("ilbl");
+    WRITE1(h);
+    const BlockInvertedLists* il =
+            dynamic_cast<const BlockInvertedLists*>(ils_in);
+    WRITE1(il->nlist);
+    WRITE1(il->code_size);
+    WRITE1(il->n_per_block);
+    WRITE1(il->block_size);
 
     for (size_t i = 0; i < il->nlist; i++) {
         WRITEVECTOR(il->ids[i]);
@@ -126,13 +121,13 @@ void BlockInvertedListsIOHook::write(const InvertedLists *ils_in, IOWriter *f) c
     }
 }
 
-InvertedLists * BlockInvertedListsIOHook::read(IOReader *f, int /* io_flags */) const
-{
-    BlockInvertedLists *il = new BlockInvertedLists();
-    READ1 (il->nlist);
-    READ1 (il->code_size);
-    READ1 (il->n_per_block);
-    READ1 (il->block_size);
+InvertedLists* BlockInvertedListsIOHook::read(IOReader* f, int /* io_flags */)
+        const {
+    BlockInvertedLists* il = new BlockInvertedLists();
+    READ1(il->nlist);
+    READ1(il->code_size);
+    READ1(il->n_per_block);
+    READ1(il->block_size);
 
     il->ids.resize(il->nlist);
     il->codes.resize(il->nlist);
@@ -145,7 +140,4 @@ InvertedLists * BlockInvertedListsIOHook::read(IOReader *f, int /* io_flags */)
     return il;
 }
 
-
-
-
 } // namespace faiss

data/vendor/faiss/faiss/invlists/BlockInvertedLists.h

@@ -5,13 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-
 #pragma once
 
+#include <faiss/index_io.h>
 #include <faiss/invlists/InvertedLists.h>
 #include <faiss/invlists/InvertedListsIOHook.h>
 #include <faiss/utils/AlignedTable.h>
-#include <faiss/index_io.h>
 
 namespace faiss {
 
@@ -28,49 +27,48 @@ namespace faiss {
  * The writing functions add_entries and update_entries operate on block-aligned
  * data.
  */
-struct BlockInvertedLists: InvertedLists {
-
-    size_t n_per_block;   // nb of vectors stored per block
-    size_t block_size;    // nb bytes per block
+struct BlockInvertedLists : InvertedLists {
+    size_t n_per_block; // nb of vectors stored per block
+    size_t block_size;  // nb bytes per block
 
     std::vector<AlignedTable<uint8_t>> codes;
     std::vector<std::vector<idx_t>> ids;
 
-
-    BlockInvertedLists (
-        size_t nlist, size_t vec_per_block,
-        size_t block_size
-    );
+    BlockInvertedLists(size_t nlist, size_t vec_per_block, size_t block_size);
 
     BlockInvertedLists();
 
     size_t list_size(size_t list_no) const override;
-    const uint8_t * get_codes (size_t list_no) const override;
-    const idx_t * get_ids (size_t list_no) const override;
+    const uint8_t* get_codes(size_t list_no) const override;
+    const idx_t* get_ids(size_t list_no) const override;
 
     // works only on empty BlockInvertedLists
     // the codes should be of size ceil(n_entry / n_per_block) * block_size
     // and padded with 0s
-    size_t add_entries (
-           size_t list_no, size_t n_entry,
-           const idx_t* ids, const uint8_t *code) override;
+    size_t add_entries(
+            size_t list_no,
+            size_t n_entry,
+            const idx_t* ids,
+            const uint8_t* code) override;
 
     /// not implemented
-    void update_entries (size_t list_no, size_t offset, size_t n_entry,
-                         const idx_t *ids, const uint8_t *code) override;
+    void update_entries(
+            size_t list_no,
+            size_t offset,
+            size_t n_entry,
+            const idx_t* ids,
+            const uint8_t* code) override;
 
     // also pads new data with 0s
-    void resize (size_t list_no, size_t new_size) override;
-
-    ~BlockInvertedLists () override;
+    void resize(size_t list_no, size_t new_size) override;
 
+    ~BlockInvertedLists() override;
 };
 
 struct BlockInvertedListsIOHook : InvertedListsIOHook {
     BlockInvertedListsIOHook();
-    void write(const InvertedLists *ils, IOWriter *f) const override;
-    InvertedLists * read(IOReader *f, int io_flags) const override;
+    void write(const InvertedLists* ils, IOWriter* f) const override;
+    InvertedLists* read(IOReader* f, int io_flags) const override;
 };
 
-
 } // namespace faiss

data/vendor/faiss/faiss/invlists/DirectMap.cpp

@@ -9,142 +9,130 @@
 
 #include <faiss/invlists/DirectMap.h>
 
-#include <cstdio>
 #include <cassert>
+#include <cstdio>
 
-#include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/AuxIndexStructures.h>
+#include <faiss/impl/FaissAssert.h>
 
 namespace faiss {
 
-DirectMap::DirectMap(): type(NoMap)
-{}
+DirectMap::DirectMap() : type(NoMap) {}
 
-void DirectMap::set_type (Type new_type, const InvertedLists *invlists, size_t ntotal) {
-
-    FAISS_THROW_IF_NOT (new_type == NoMap || new_type == Array ||
-                        new_type == Hashtable);
+void DirectMap::set_type(
+        Type new_type,
+        const InvertedLists* invlists,
+        size_t ntotal) {
+    FAISS_THROW_IF_NOT(
+            new_type == NoMap || new_type == Array || new_type == Hashtable);
 
     if (new_type == type) {
         // nothing to do
         return;
     }
 
-    array.clear ();
-    hashtable.clear ();
+    array.clear();
+    hashtable.clear();
     type = new_type;
 
     if (new_type == NoMap) {
         return;
     } else if (new_type == Array) {
-        array.resize (ntotal, -1);
+        array.resize(ntotal, -1);
     } else if (new_type == Hashtable) {
-        hashtable.reserve (ntotal);
+        hashtable.reserve(ntotal);
     }
 
     for (size_t key = 0; key < invlists->nlist; key++) {
-        size_t list_size = invlists->list_size (key);
-        InvertedLists::ScopedIds idlist (invlists, key);
+        size_t list_size = invlists->list_size(key);
+        InvertedLists::ScopedIds idlist(invlists, key);
 
         if (new_type == Array) {
             for (long ofs = 0; ofs < list_size; ofs++) {
-                FAISS_THROW_IF_NOT_MSG (
-                       0 <= idlist [ofs] && idlist[ofs] < ntotal,
-                       "direct map supported only for seuquential ids");
-                array [idlist [ofs]] = lo_build(key, ofs);
+                FAISS_THROW_IF_NOT_MSG(
+                        0 <= idlist[ofs] && idlist[ofs] < ntotal,
+                        "direct map supported only for seuquential ids");
+                array[idlist[ofs]] = lo_build(key, ofs);
             }
         } else if (new_type == Hashtable) {
             for (long ofs = 0; ofs < list_size; ofs++) {
-                hashtable [idlist [ofs]] = lo_build(key, ofs);
+                hashtable[idlist[ofs]] = lo_build(key, ofs);
             }
         }
     }
 }
 
-void DirectMap::clear()
-{
-    array.clear ();
-    hashtable.clear ();
+void DirectMap::clear() {
+    array.clear();
+    hashtable.clear();
 }
 
-
-DirectMap::idx_t DirectMap::get (idx_t key) const
-{
+DirectMap::idx_t DirectMap::get(idx_t key) const {
     if (type == Array) {
-        FAISS_THROW_IF_NOT_MSG (
-             key >= 0 && key < array.size(), "invalid key"
-        );
+        FAISS_THROW_IF_NOT_MSG(key >= 0 && key < array.size(), "invalid key");
         idx_t lo = array[key];
         FAISS_THROW_IF_NOT_MSG(lo >= 0, "-1 entry in direct_map");
         return lo;
     } else if (type == Hashtable) {
-        auto res = hashtable.find (key);
-        FAISS_THROW_IF_NOT_MSG (res != hashtable.end(), "key not found");
+        auto res = hashtable.find(key);
+        FAISS_THROW_IF_NOT_MSG(res != hashtable.end(), "key not found");
         return res->second;
     } else {
-        FAISS_THROW_MSG ("direct map not initialized");
+        FAISS_THROW_MSG("direct map not initialized");
     }
 }
 
-
-
-void DirectMap::add_single_id (idx_t id, idx_t list_no, size_t offset)
-{
-    if (type == NoMap) return;
+void DirectMap::add_single_id(idx_t id, idx_t list_no, size_t offset) {
+    if (type == NoMap)
+        return;
 
     if (type == Array) {
-        assert (id == array.size());
+        assert(id == array.size());
         if (list_no >= 0) {
-            array.push_back (lo_build (list_no, offset));
+            array.push_back(lo_build(list_no, offset));
         } else {
-            array.push_back (-1);
+            array.push_back(-1);
         }
     } else if (type == Hashtable) {
         if (list_no >= 0) {
-            hashtable[id] = lo_build (list_no, offset);
+            hashtable[id] = lo_build(list_no, offset);
         }
     }
-
 }
 
-void DirectMap::check_can_add (const idx_t *ids) {
+void DirectMap::check_can_add(const idx_t* ids) {
     if (type == Array && ids) {
-        FAISS_THROW_MSG ("cannot have array direct map and add with ids");
+        FAISS_THROW_MSG("cannot have array direct map and add with ids");
     }
 }
 
 /********************* DirectMapAdd implementation */
 
-
-DirectMapAdd::DirectMapAdd (DirectMap &direct_map, size_t n, const idx_t *xids):
-    direct_map(direct_map), type(direct_map.type), n(n), xids(xids)
-{
-    if (type == DirectMap::Array)  {
-        FAISS_THROW_IF_NOT (xids == nullptr);
+DirectMapAdd::DirectMapAdd(DirectMap& direct_map, size_t n, const idx_t* xids)
+        : direct_map(direct_map), type(direct_map.type), n(n), xids(xids) {
+    if (type == DirectMap::Array) {
+        FAISS_THROW_IF_NOT(xids == nullptr);
         ntotal = direct_map.array.size();
-        direct_map.array.resize (ntotal + n, -1);
+        direct_map.array.resize(ntotal + n, -1);
     } else if (type == DirectMap::Hashtable) {
         // can't parallel update hashtable so use temp array
-        all_ofs.resize (n, -1);
+        all_ofs.resize(n, -1);
     }
 }
 
-
-void DirectMapAdd::add (size_t i, idx_t list_no, size_t ofs)
-{
+void DirectMapAdd::add(size_t i, idx_t list_no, size_t ofs) {
     if (type == DirectMap::Array) {
-        direct_map.array [ntotal + i] = lo_build (list_no, ofs);
+        direct_map.array[ntotal + i] = lo_build(list_no, ofs);
     } else if (type == DirectMap::Hashtable) {
-        all_ofs [i] = lo_build (list_no, ofs);
+        all_ofs[i] = lo_build(list_no, ofs);
     }
 }
 
-DirectMapAdd::~DirectMapAdd ()
-{
+DirectMapAdd::~DirectMapAdd() {
     if (type == DirectMap::Hashtable) {
         for (int i = 0; i < n; i++) {
             idx_t id = xids ? xids[i] : ntotal + i;
-            direct_map.hashtable [id] = all_ofs [i];
+            direct_map.hashtable[id] = all_ofs[i];
         }
     }
 }
@@ -154,9 +142,7 @@ DirectMapAdd::~DirectMapAdd ()
 using ScopedCodes = InvertedLists::ScopedCodes;
 using ScopedIds = InvertedLists::ScopedIds;
 
-
-size_t DirectMap::remove_ids(const IDSelector& sel, InvertedLists *invlists)
-{
+size_t DirectMap::remove_ids(const IDSelector& sel, InvertedLists* invlists) {
     size_t nlist = invlists->nlist;
     std::vector<idx_t> toremove(nlist);
 
@@ -166,16 +152,16 @@ size_t DirectMap::remove_ids(const IDSelector& sel, InvertedLists *invlists)
         // exhaustive scan of IVF
 #pragma omp parallel for
         for (idx_t i = 0; i < nlist; i++) {
-            idx_t l0 = invlists->list_size (i), l = l0, j = 0;
-            ScopedIds idsi (invlists, i);
+            idx_t l0 = invlists->list_size(i), l = l0, j = 0;
+            ScopedIds idsi(invlists, i);
             while (j < l) {
-                if (sel.is_member (idsi[j])) {
+                if (sel.is_member(idsi[j])) {
                     l--;
-                    invlists->update_entry (
-                        i, j,
-                        invlists->get_single_id (i, l),
-                        ScopedCodes (invlists, i, l).get()
-                    );
+                    invlists->update_entry(
+                            i,
+                            j,
+                            invlists->get_single_id(i, l),
+                            ScopedCodes(invlists, i, l).get());
                 } else {
                     j++;
                 }
@@ -191,30 +177,28 @@ size_t DirectMap::remove_ids(const IDSelector& sel, InvertedLists *invlists)
             }
         }
     } else if (type == Hashtable) {
-        const IDSelectorArray *sela =
-            dynamic_cast<const IDSelectorArray*>(&sel);
-        FAISS_THROW_IF_NOT_MSG (
-             sela,
-             "remove with hashtable works only with IDSelectorArray"
-        );
+        const IDSelectorArray* sela =
+                dynamic_cast<const IDSelectorArray*>(&sel);
+        FAISS_THROW_IF_NOT_MSG(
+                sela, "remove with hashtable works only with IDSelectorArray");
 
         for (idx_t i = 0; i < sela->n; i++) {
             idx_t id = sela->ids[i];
-            auto res = hashtable.find (id);
+            auto res = hashtable.find(id);
             if (res != hashtable.end()) {
-                size_t list_no = lo_listno (res->second);
-                size_t offset = lo_offset (res->second);
-                idx_t last = invlists->list_size (list_no) - 1;
-                hashtable.erase (res);
+                size_t list_no = lo_listno(res->second);
+                size_t offset = lo_offset(res->second);
+                idx_t last = invlists->list_size(list_no) - 1;
+                hashtable.erase(res);
                 if (offset < last) {
-                    idx_t last_id = invlists->get_single_id (list_no, last);
-                    invlists->update_entry (
-                        list_no, offset,
-                        last_id,
-                        ScopedCodes (invlists, list_no, last).get()
-                    );
+                    idx_t last_id = invlists->get_single_id(list_no, last);
+                    invlists->update_entry(
+                            list_no,
+                            offset,
+                            last_id,
+                            ScopedCodes(invlists, list_no, last).get());
                     // update hash entry for last element
-                    hashtable [last_id] = list_no << 32 | offset;
+                    hashtable[last_id] = list_no << 32 | offset;
                 }
                 invlists->resize(list_no, last);
                 nremove++;
@@ -227,41 +211,41 @@ size_t DirectMap::remove_ids(const IDSelector& sel, InvertedLists *invlists)
     return nremove;
 }
 
-void DirectMap::update_codes (InvertedLists *invlists,
-                              int n, const idx_t *ids,
-                              const idx_t *assign,
-                              const uint8_t *codes)
-{
-    FAISS_THROW_IF_NOT (type == Array);
+void DirectMap::update_codes(
+        InvertedLists* invlists,
+        int n,
+        const idx_t* ids,
+        const idx_t* assign,
+        const uint8_t* codes) {
+    FAISS_THROW_IF_NOT(type == Array);
 
     size_t code_size = invlists->code_size;
 
     for (size_t i = 0; i < n; i++) {
         idx_t id = ids[i];
-        FAISS_THROW_IF_NOT_MSG (0 <= id && id < array.size(),
-                                "id to update out of range");
+        FAISS_THROW_IF_NOT_MSG(
+                0 <= id && id < array.size(), "id to update out of range");
         { // remove old one
-            idx_t dm = array [id];
-            int64_t ofs = lo_offset (dm);
-            int64_t il = lo_listno (dm);
-            size_t l = invlists->list_size (il);
+            idx_t dm = array[id];
+            int64_t ofs = lo_offset(dm);
+            int64_t il = lo_listno(dm);
+            size_t l = invlists->list_size(il);
             if (ofs != l - 1) { // move l - 1 to ofs
-                int64_t id2 = invlists->get_single_id (il, l - 1);
-                array[id2] = lo_build (il, ofs);
-                invlists->update_entry (il, ofs, id2,
-                                        invlists->get_single_code (il, l - 1));
+                int64_t id2 = invlists->get_single_id(il, l - 1);
+                array[id2] = lo_build(il, ofs);
+                invlists->update_entry(
+                        il, ofs, id2, invlists->get_single_code(il, l - 1));
             }
-            invlists->resize (il, l - 1);
+            invlists->resize(il, l - 1);
         }
         { // insert new one
             int64_t il = assign[i];
-            size_t l = invlists->list_size (il);
-            idx_t dm = lo_build (il, l);
-            array [id] = dm;
-            invlists->add_entry (il, id, codes + i * code_size);
+            size_t l = invlists->list_size(il);
+            idx_t dm = lo_build(il, l);
+            array[id] = dm;
+            invlists->add_entry(il, id, codes + i * code_size);
         }
     }
 }
 
-
-}
+} // namespace faiss