From b7772b3499317b72f51cab43b8c0b9912cb4d47f Mon Sep 17 00:00:00 2001 From: Eduardo Pinho Date: Sun, 24 Mar 2024 10:42:12 +0000 Subject: [PATCH 1/2] [faiss-sys] Update to v1.8.0 - checkout faiss commit referring to v1.8.0 - update gen_bindings.sh to use the latest bindgen version - update bindings.rs and bindings_gpu.rs --- faiss-sys/faiss | 2 +- faiss-sys/gen_bindings.sh | 10 +- faiss-sys/src/bindings.rs | 1693 ++++++++++++++++---------------- faiss-sys/src/bindings_gpu.rs | 1729 +++++++++++++++++---------------- 4 files changed, 1779 insertions(+), 1655 deletions(-) diff --git a/faiss-sys/faiss b/faiss-sys/faiss index 066188e..943d08b 160000 --- a/faiss-sys/faiss +++ b/faiss-sys/faiss @@ -1 +1 @@ -Subproject commit 066188e4a61103811aae91e3530ef68d4125b832 +Subproject commit 943d08bdad7946b22f56d040756669ee444dd681 diff --git a/faiss-sys/gen_bindings.sh b/faiss-sys/gen_bindings.sh index e176f75..dd110d8 100755 --- a/faiss-sys/gen_bindings.sh +++ b/faiss-sys/gen_bindings.sh @@ -4,19 +4,19 @@ # Ensure that the submodule is updated and checked out in the intended revision if ! which bindgen > /dev/null; then echo "ERROR: `bindgen` not found. Please install using cargo:" - echo " cargo install bindgen" + echo " cargo install bindgen-cli --version=^0.69" exit 1 fi repo_url=https://github.com/facebookresearch/faiss -repo_rev=v1.7.2 +repo_rev=v1.8.0 cuda_root=/opt/cuda if [ ! -d faiss ]; then git clone "$repo_url" faiss --branch "$repo_rev" --depth 1 fi -bindgen_opt='--size_t-is-usize --whitelist-function faiss_.* --whitelist-type idx_t|Faiss.* --opaque-type FILE' +bindgen_opt='--allowlist-function faiss_.* --allowlist-type idx_t|Faiss.* --opaque-type FILE' headers=`ls faiss/c_api/*_c.h faiss/c_api/impl/*_c.h faiss/c_api/utils/*_c.h` echo '// Auto-generated, do not edit!' > c_api.h @@ -24,7 +24,7 @@ for header in $headers; do echo "#include \""$header"\"" >> c_api.h; done -cmd="bindgen --rust-target 1.33 $bindgen_opt c_api.h -o src/bindings.rs" +cmd="bindgen --rust-target 1.59 $bindgen_opt c_api.h -o src/bindings.rs" echo ${cmd} ${cmd} @@ -33,7 +33,7 @@ for header in $headers; do echo "#include \""$header"\"" >> c_api.h; done -cmd="bindgen --rust-target 1.33 $bindgen_opt c_api.h -o src/bindings_gpu.rs -- -Ifaiss/c_api -I$cuda_root/include" +cmd="bindgen --rust-target 1.59 $bindgen_opt c_api.h -o src/bindings_gpu.rs -- -Ifaiss/c_api -I$cuda_root/include" echo ${cmd} ${cmd} diff --git a/faiss-sys/src/bindings.rs b/faiss-sys/src/bindings.rs index 89657ae..6676a76 100644 --- a/faiss-sys/src/bindings.rs +++ b/faiss-sys/src/bindings.rs @@ -1,6 +1,5 @@ -/* automatically generated by rust-bindgen 0.59.2 */ +/* automatically generated by rust-bindgen 0.69.4 */ -pub type __int64_t = ::std::os::raw::c_long; pub type faiss_idx_t = i64; pub type idx_t = faiss_idx_t; #[repr(C)] @@ -31,11 +30,25 @@ pub const FaissMetricType_METRIC_Canberra: FaissMetricType = 20; pub const FaissMetricType_METRIC_BrayCurtis: FaissMetricType = 21; #[doc = " some additional metrics defined in scipy.spatial.distance"] pub const FaissMetricType_METRIC_JensenShannon: FaissMetricType = 22; -#[doc = " Some algorithms support both an inner product version and a L2 search"] -#[doc = " version."] +#[doc = " Some algorithms support both an inner product version and a L2 search\n version."] pub type FaissMetricType = ::std::os::raw::c_uint; #[repr(C)] #[derive(Debug, Copy, Clone)] +pub struct FaissSearchParameters_H { + _unused: [u8; 0], +} +pub type FaissSearchParameters = FaissSearchParameters_H; +extern "C" { + pub fn faiss_SearchParameters_free(obj: *mut FaissSearchParameters); +} +extern "C" { + pub fn faiss_SearchParameters_new( + p_sp: *mut *mut FaissSearchParameters, + sel: *mut FaissIDSelector, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] pub struct FaissIndex_H { _unused: [u8; 0], } @@ -62,11 +75,7 @@ extern "C" { pub fn faiss_Index_set_verbose(arg1: *mut FaissIndex, arg2: ::std::os::raw::c_int); } extern "C" { - #[doc = " Perform training on a representative set of vectors"] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param n nb of training vectors"] - #[doc = " @param x training vectors, size n * d"] + #[doc = " Perform training on a representative set of vectors\n\n @param index opaque pointer to index object\n @param n nb of training vectors\n @param x training vectors, size n * d"] pub fn faiss_Index_train( index: *mut FaissIndex, n: idx_t, @@ -74,13 +83,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Add n vectors of dimension d to the index."] - #[doc = ""] - #[doc = " Vectors are implicitly assigned labels ntotal .. ntotal + n - 1"] - #[doc = " This function slices the input vectors in chunks smaller than"] - #[doc = " blocksize_add and calls add_core."] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param x input matrix, size n * d"] + #[doc = " Add n vectors of dimension d to the index.\n\n Vectors are implicitly assigned labels ntotal .. ntotal + n - 1\n This function slices the input vectors in chunks smaller than\n blocksize_add and calls add_core.\n @param index opaque pointer to index object\n @param x input matrix, size n * d"] pub fn faiss_Index_add( index: *mut FaissIndex, n: idx_t, @@ -88,13 +91,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Same as add, but stores xids instead of sequential ids."] - #[doc = ""] - #[doc = " The default implementation fails with an assertion, as it is"] - #[doc = " not supported by all indexes."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param xids if non-null, ids to store for the vectors (size n)"] + #[doc = " Same as add, but stores xids instead of sequential ids.\n\n The default implementation fails with an assertion, as it is\n not supported by all indexes.\n\n @param index opaque pointer to index object\n @param xids if non-null, ids to store for the vectors (size n)"] pub fn faiss_Index_add_with_ids( index: *mut FaissIndex, n: idx_t, @@ -103,15 +100,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " query n vectors of dimension d to the index."] - #[doc = ""] - #[doc = " return at most k vectors. If there are not enough results for a"] - #[doc = " query, the result array is padded with -1s."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param x input vectors to search, size n * d"] - #[doc = " @param labels output labels of the NNs, size n*k"] - #[doc = " @param distances output pairwise distances, size n*k"] + #[doc = " query n vectors of dimension d to the index.\n\n return at most k vectors. If there are not enough results for a\n query, the result array is padded with -1s.\n\n @param index opaque pointer to index object\n @param x input vectors to search, size n * d\n @param labels output labels of the NNs, size n*k\n @param distances output pairwise distances, size n*k"] pub fn faiss_Index_search( index: *const FaissIndex, n: idx_t, @@ -122,16 +111,19 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " query n vectors of dimension d to the index."] - #[doc = ""] - #[doc = " return all vectors with distance < radius. Note that many"] - #[doc = " indexes do not implement the range_search (only the k-NN search"] - #[doc = " is mandatory)."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param x input vectors to search, size n * d"] - #[doc = " @param radius search radius"] - #[doc = " @param result result table"] + #[doc = " query n vectors of dimension d with search parameters to the index.\n\n return at most k vectors. If there are not enough results for a query,\n the result is padded with -1s.\n\n @param index opaque pointer to index object\n @param x input vectors to search, size n * d\n @param params input params to modify how search is done\n @param labels output labels of the NNs, size n*k\n @param distances output pairwise distances, size n*k"] + pub fn faiss_Index_search_with_params( + index: *const FaissIndex, + n: idx_t, + x: *const f32, + k: idx_t, + params: *const FaissSearchParameters, + distances: *mut f32, + labels: *mut idx_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " query n vectors of dimension d to the index.\n\n return all vectors with distance < radius. Note that many\n indexes do not implement the range_search (only the k-NN search\n is mandatory).\n\n @param index opaque pointer to index object\n @param x input vectors to search, size n * d\n @param radius search radius\n @param result result table"] pub fn faiss_Index_range_search( index: *const FaissIndex, n: idx_t, @@ -141,12 +133,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " return the indexes of the k vectors closest to the query x."] - #[doc = ""] - #[doc = " This function is identical as search but only return labels of neighbors."] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param x input vectors to search, size n * d"] - #[doc = " @param labels output labels of the NNs, size n*k"] + #[doc = " return the indexes of the k vectors closest to the query x.\n\n This function is identical as search but only return labels of neighbors.\n @param index opaque pointer to index object\n @param x input vectors to search, size n * d\n @param labels output labels of the NNs, size n*k"] pub fn faiss_Index_assign( index: *mut FaissIndex, n: idx_t, @@ -156,14 +143,11 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " removes all elements from the database."] - #[doc = " @param index opaque pointer to index object"] + #[doc = " removes all elements from the database.\n @param index opaque pointer to index object"] pub fn faiss_Index_reset(index: *mut FaissIndex) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " removes IDs from the index. Not supported by all indexes"] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param nremove output for the number of IDs removed"] + #[doc = " removes IDs from the index. Not supported by all indexes\n @param index opaque pointer to index object\n @param nremove output for the number of IDs removed"] pub fn faiss_Index_remove_ids( index: *mut FaissIndex, sel: *const FaissIDSelector, @@ -171,12 +155,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Reconstruct a stored vector (or an approximation if lossy coding)"] - #[doc = ""] - #[doc = " this function may not be defined for some indexes"] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param key id of the vector to reconstruct"] - #[doc = " @param recons reconstructed vector (size d)"] + #[doc = " Reconstruct a stored vector (or an approximation if lossy coding)\n\n this function may not be defined for some indexes\n @param index opaque pointer to index object\n @param key id of the vector to reconstruct\n @param recons reconstructed vector (size d)"] pub fn faiss_Index_reconstruct( index: *const FaissIndex, key: idx_t, @@ -184,11 +163,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Reconstruct vectors i0 to i0 + ni - 1"] - #[doc = ""] - #[doc = " this function may not be defined for some indexes"] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param recons reconstructed vector (size ni * d)"] + #[doc = " Reconstruct vectors i0 to i0 + ni - 1\n\n this function may not be defined for some indexes\n @param index opaque pointer to index object\n @param recons reconstructed vector (size ni * d)"] pub fn faiss_Index_reconstruct_n( index: *const FaissIndex, i0: idx_t, @@ -197,17 +172,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Computes a residual vector after indexing encoding."] - #[doc = ""] - #[doc = " The residual vector is the difference between a vector and the"] - #[doc = " reconstruction that can be decoded from its representation in"] - #[doc = " the index. The residual can be used for multiple-stage indexing"] - #[doc = " methods, like IndexIVF's methods."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param x input vector, size d"] - #[doc = " @param residual output residual vector, size d"] - #[doc = " @param key encoded index, as returned by search and assign"] + #[doc = " Computes a residual vector after indexing encoding.\n\n The residual vector is the difference between a vector and the\n reconstruction that can be decoded from its representation in\n the index. The residual can be used for multiple-stage indexing\n methods, like IndexIVF's methods.\n\n @param index opaque pointer to index object\n @param x input vector, size d\n @param residual output residual vector, size d\n @param key encoded index, as returned by search and assign"] pub fn faiss_Index_compute_residual( index: *const FaissIndex, x: *const f32, @@ -216,18 +181,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Computes a residual vector after indexing encoding."] - #[doc = ""] - #[doc = " The residual vector is the difference between a vector and the"] - #[doc = " reconstruction that can be decoded from its representation in"] - #[doc = " the index. The residual can be used for multiple-stage indexing"] - #[doc = " methods, like IndexIVF's methods."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param n number of vectors"] - #[doc = " @param x input vector, size (n x d)"] - #[doc = " @param residuals output residual vectors, size (n x d)"] - #[doc = " @param keys encoded index, as returned by search and assign"] + #[doc = " Computes a residual vector after indexing encoding.\n\n The residual vector is the difference between a vector and the\n reconstruction that can be decoded from its representation in\n the index. The residual can be used for multiple-stage indexing\n methods, like IndexIVF's methods.\n\n @param index opaque pointer to index object\n @param n number of vectors\n @param x input vector, size (n x d)\n @param residuals output residual vectors, size (n x d)\n @param keys encoded index, as returned by search and assign"] pub fn faiss_Index_compute_residual_n( index: *const FaissIndex, n: idx_t, @@ -236,6 +190,31 @@ extern "C" { keys: *const idx_t, ) -> ::std::os::raw::c_int; } +extern "C" { + #[doc = " The size of the produced codes in bytes.\n\n @param index opaque pointer to index object\n @param size the returned size in bytes"] + pub fn faiss_Index_sa_code_size( + index: *const FaissIndex, + size: *mut usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " encode a set of vectors\n\n @param index opaque pointer to index object\n @param n number of vectors\n @param x input vectors, size n * d\n @param bytes output encoded vectors, size n * sa_code_size()"] + pub fn faiss_Index_sa_encode( + index: *const FaissIndex, + n: idx_t, + x: *const f32, + bytes: *mut u8, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " decode a set of vectors\n\n @param index opaque pointer to index object\n @param n number of vectors\n @param bytes input encoded vectors, size n * sa_code_size()\n @param x output vectors, size n * d"] + pub fn faiss_Index_sa_decode( + index: *const FaissIndex, + n: idx_t, + bytes: *const u8, + x: *mut f32, + ) -> ::std::os::raw::c_int; +} #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct FaissParameterRange_H { @@ -248,8 +227,7 @@ extern "C" { ) -> *const ::std::os::raw::c_char; } extern "C" { - #[doc = " Getter for the values in the range. The output values are invalidated"] - #[doc = " upon any other modification of the range."] + #[doc = " Getter for the values in the range. The output values are invalidated\n upon any other modification of the range."] pub fn faiss_ParameterRange_values( arg1: *mut FaissParameterRange, arg2: *mut *mut f64, @@ -274,9 +252,7 @@ extern "C" { pub fn faiss_ParameterSpace_n_combinations(arg1: *const FaissParameterSpace) -> usize; } extern "C" { - #[doc = " get string representation of the combination"] - #[doc = " by writing it to the given character buffer."] - #[doc = " A buffer size of 1000 ensures that the full name is collected."] + #[doc = " get string representation of the combination\n by writing it to the given character buffer.\n A buffer size of 1000 ensures that the full name is collected."] pub fn faiss_ParameterSpace_combination_name( arg1: *const FaissParameterSpace, arg2: usize, @@ -321,8 +297,15 @@ extern "C" { arg3: *mut *mut FaissParameterRange, ) -> ::std::os::raw::c_int; } -#[doc = " Class for the clustering parameters. Can be passed to the"] -#[doc = " constructor of the Clustering object."] +pub type FILE = [u64; 27usize]; +extern "C" { + #[doc = " Clone an index. This is equivalent to `faiss::clone_index`"] + pub fn faiss_clone_index( + arg1: *const FaissIndex, + p_out: *mut *mut FaissIndex, + ) -> ::std::os::raw::c_int; +} +#[doc = " Class for the clustering parameters. Can be passed to the\n constructor of the Clustering object."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct FaissClusteringParameters { @@ -338,8 +321,7 @@ pub struct FaissClusteringParameters { pub int_centroids: ::std::os::raw::c_int, #[doc = "< (bool) update index after each iteration?"] pub update_index: ::std::os::raw::c_int, - #[doc = "< (bool) use the centroids provided as input and do"] - #[doc = "< not change them during iterations"] + #[doc = "< (bool) use the centroids provided as input and do\n< not change them during iterations"] pub frozen_centroids: ::std::os::raw::c_int, #[doc = "< otherwise you get a warning"] pub min_points_per_centroid: ::std::os::raw::c_int, @@ -352,6 +334,9 @@ pub struct FaissClusteringParameters { } #[test] fn bindgen_test_layout_FaissClusteringParameters() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 48usize, @@ -363,7 +348,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { concat!("Alignment of ", stringify!(FaissClusteringParameters)) ); assert_eq!( - unsafe { &(*(::std::ptr::null::())).niter as *const _ as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).niter) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", @@ -373,7 +358,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { &(*(::std::ptr::null::())).nredo as *const _ as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).nredo) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", @@ -383,9 +368,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).verbose as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).verbose) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", @@ -395,9 +378,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).spherical as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).spherical) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", @@ -407,9 +388,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).int_centroids as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).int_centroids) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", @@ -419,9 +398,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_index as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).update_index) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", @@ -431,10 +408,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).frozen_centroids as *const _ - as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).frozen_centroids) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", @@ -444,10 +418,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).min_points_per_centroid - as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).min_points_per_centroid) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", @@ -457,10 +428,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).max_points_per_centroid - as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).max_points_per_centroid) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", @@ -470,7 +438,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { &(*(::std::ptr::null::())).seed as *const _ as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).seed) as usize - ptr as usize }, 36usize, concat!( "Offset of field: ", @@ -480,10 +448,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).decode_block_size as *const _ - as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).decode_block_size) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", @@ -618,15 +583,7 @@ extern "C" { pub fn faiss_Clustering_free(clustering: *mut FaissClustering); } extern "C" { - #[doc = " simplified interface"] - #[doc = ""] - #[doc = " @param d dimension of the data"] - #[doc = " @param n nb of training vectors"] - #[doc = " @param k nb of output centroids"] - #[doc = " @param x training set (size n * d)"] - #[doc = " @param centroids output centroids (size k * d)"] - #[doc = " @param q_error final quantization error"] - #[doc = " @return error code"] + #[doc = " simplified interface\n\n @param d dimension of the data\n @param n nb of training vectors\n @param k nb of output centroids\n @param x training set (size n * d)\n @param centroids output centroids (size k * d)\n @param q_error final quantization error\n @return error code"] pub fn faiss_kmeans_clustering( d: usize, n: usize, @@ -636,221 +593,680 @@ extern "C" { q_error: *mut f32, ) -> ::std::os::raw::c_int; } -pub type FaissIndexFlat = FaissIndex_H; +#[doc = " No error"] +pub const FaissErrorCode_OK: FaissErrorCode = 0; +#[doc = " Any exception other than Faiss or standard C++ library exceptions"] +pub const FaissErrorCode_UNKNOWN_EXCEPT: FaissErrorCode = -1; +#[doc = " Faiss library exception"] +pub const FaissErrorCode_FAISS_EXCEPT: FaissErrorCode = -2; +#[doc = " Standard C++ library exception"] +pub const FaissErrorCode_STD_EXCEPT: FaissErrorCode = -4; +#[doc = " An error code which depends on the exception thrown from the previous\n operation. See `faiss_get_last_error` to retrieve the error message."] +pub type FaissErrorCode = ::std::os::raw::c_int; extern "C" { - #[doc = " Opaque type for IndexFlat"] - pub fn faiss_IndexFlat_new(p_index: *mut *mut FaissIndexFlat) -> ::std::os::raw::c_int; + #[doc = " Get the error message of the last failed operation performed by Faiss.\n The given pointer is only invalid until another Faiss function is\n called."] + pub fn faiss_get_last_error() -> *const ::std::os::raw::c_char; } extern "C" { - pub fn faiss_IndexFlat_new_with( - p_index: *mut *mut FaissIndexFlat, - d: idx_t, - metric: FaissMetricType, + pub fn faiss_RangeSearchResult_nq(arg1: *const FaissRangeSearchResult) -> usize; +} +extern "C" { + pub fn faiss_RangeSearchResult_new( + p_rsr: *mut *mut FaissRangeSearchResult, + nq: idx_t, ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " get a pointer to the index's internal data (the `xb` field). The outputs"] - #[doc = " become invalid after any data addition or removal operation."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param p_xb output, the pointer to the beginning of `xb`."] - #[doc = " @param p_size output, the current size of `sb` in number of float values."] - pub fn faiss_IndexFlat_xb(index: *mut FaissIndexFlat, p_xb: *mut *mut f32, p_size: *mut usize); + pub fn faiss_RangeSearchResult_new_with( + p_rsr: *mut *mut FaissRangeSearchResult, + nq: idx_t, + alloc_lims: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IndexFlat_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlat; + #[doc = " called when lims contains the nb of elements result entries\n for each query"] + pub fn faiss_RangeSearchResult_do_allocation( + rsr: *mut FaissRangeSearchResult, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IndexFlat_free(obj: *mut FaissIndexFlat); + pub fn faiss_RangeSearchResult_free(obj: *mut FaissRangeSearchResult); } extern "C" { - #[doc = " compute distance with a subset of vectors"] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param x query vectors, size n * d"] - #[doc = " @param labels indices of the vectors that should be compared"] - #[doc = " for each query vector, size n * k"] - #[doc = " @param distances"] - #[doc = " corresponding output distances, size n * k"] - pub fn faiss_IndexFlat_compute_distance_subset( - index: *mut FaissIndex, - n: idx_t, - x: *const f32, - k: idx_t, - distances: *mut f32, - labels: *const idx_t, - ) -> ::std::os::raw::c_int; + pub fn faiss_RangeSearchResult_buffer_size(arg1: *const FaissRangeSearchResult) -> usize; } -pub type FaissIndexFlatIP = FaissIndex_H; extern "C" { - pub fn faiss_IndexFlatIP_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlatIP; + #[doc = " getter for lims: size (nq + 1)"] + pub fn faiss_RangeSearchResult_lims(rsr: *mut FaissRangeSearchResult, lims: *mut *mut usize); } extern "C" { - pub fn faiss_IndexFlatIP_free(obj: *mut FaissIndexFlatIP); + #[doc = " getter for labels and respective distances (not sorted):\n result for query i is labels[lims[i]:lims[i+1]]"] + pub fn faiss_RangeSearchResult_labels( + rsr: *mut FaissRangeSearchResult, + labels: *mut *mut idx_t, + distances: *mut *mut f32, + ); } extern "C" { - #[doc = " Opaque type for IndexFlatIP"] - pub fn faiss_IndexFlatIP_new(p_index: *mut *mut FaissIndexFlatIP) -> ::std::os::raw::c_int; + pub fn faiss_IDSelector_free(obj: *mut FaissIDSelector); } extern "C" { - pub fn faiss_IndexFlatIP_new_with( - p_index: *mut *mut FaissIndexFlatIP, - d: idx_t, + #[doc = " Encapsulates a set of ids to remove."] + pub fn faiss_IDSelector_is_member( + sel: *const FaissIDSelector, + id: idx_t, ) -> ::std::os::raw::c_int; } -pub type FaissIndexFlatL2 = FaissIndex_H; -extern "C" { - pub fn faiss_IndexFlatL2_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlatL2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissIDSelectorRange_H { + _unused: [u8; 0], } +pub type FaissIDSelectorRange = FaissIDSelectorRange_H; extern "C" { - pub fn faiss_IndexFlatL2_free(obj: *mut FaissIndexFlatL2); + pub fn faiss_IDSelectorRange_free(obj: *mut FaissIDSelectorRange); } extern "C" { - #[doc = " Opaque type for IndexFlatL2"] - pub fn faiss_IndexFlatL2_new(p_index: *mut *mut FaissIndexFlatL2) -> ::std::os::raw::c_int; + pub fn faiss_IDSelectorRange_imin(arg1: *const FaissIDSelectorRange) -> idx_t; } extern "C" { - pub fn faiss_IndexFlatL2_new_with( - p_index: *mut *mut FaissIndexFlatL2, - d: idx_t, - ) -> ::std::os::raw::c_int; + pub fn faiss_IDSelectorRange_imax(arg1: *const FaissIDSelectorRange) -> idx_t; } -pub type FaissIndexRefineFlat = FaissIndex_H; extern "C" { - #[doc = " Opaque type for IndexRefineFlat"] - #[doc = ""] - #[doc = " Index that queries in a base_index (a fast one) and refines the"] - #[doc = " results with an exact search, hopefully improving the results."] - pub fn faiss_IndexRefineFlat_new( - p_index: *mut *mut FaissIndexRefineFlat, - base_index: *mut FaissIndex, + #[doc = " remove ids between [imni, imax)"] + pub fn faiss_IDSelectorRange_new( + p_sel: *mut *mut FaissIDSelectorRange, + imin: idx_t, + imax: idx_t, ) -> ::std::os::raw::c_int; } -extern "C" { - pub fn faiss_IndexRefineFlat_free(obj: *mut FaissIndexRefineFlat); +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissIDSelectorBatch_H { + _unused: [u8; 0], } +pub type FaissIDSelectorBatch = FaissIDSelectorBatch_H; extern "C" { - pub fn faiss_IndexRefineFlat_cast(arg1: *mut FaissIndex) -> *mut FaissIndexRefineFlat; + pub fn faiss_IDSelectorBatch_nbits(arg1: *const FaissIDSelectorBatch) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IndexRefineFlat_own_fields( - arg1: *const FaissIndexRefineFlat, - ) -> ::std::os::raw::c_int; + pub fn faiss_IDSelectorBatch_mask(arg1: *const FaissIDSelectorBatch) -> idx_t; } extern "C" { - pub fn faiss_IndexRefineFlat_set_own_fields( - arg1: *mut FaissIndexRefineFlat, - arg2: ::std::os::raw::c_int, - ); + #[doc = " Remove ids from a set. Repetitions of ids in the indices set\n passed to the constructor does not hurt performance. The hash\n function used for the bloom filter and GCC's implementation of\n unordered_set are just the least significant bits of the id. This\n works fine for random ids or ids in sequences but will produce many\n hash collisions if lsb's are always the same"] + pub fn faiss_IDSelectorBatch_new( + p_sel: *mut *mut FaissIDSelectorBatch, + n: usize, + indices: *const idx_t, + ) -> ::std::os::raw::c_int; } -extern "C" { - pub fn faiss_IndexRefineFlat_k_factor(arg1: *const FaissIndexRefineFlat) -> f32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissIDSelectorNot_H { + _unused: [u8; 0], } +pub type FaissIDSelectorNot = FaissIDSelectorNot_H; extern "C" { - pub fn faiss_IndexRefineFlat_set_k_factor(arg1: *mut FaissIndexRefineFlat, arg2: f32); + pub fn faiss_IDSelectorNot_new( + p_sel: *mut *mut FaissIDSelectorNot, + sel: *const FaissIDSelector, + ) -> ::std::os::raw::c_int; } -pub type FaissIndexFlat1D = FaissIndex_H; -extern "C" { - pub fn faiss_IndexFlat1D_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlat1D; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissIDSelectorAnd_H { + _unused: [u8; 0], } +pub type FaissIDSelectorAnd = FaissIDSelectorAnd_H; extern "C" { - pub fn faiss_IndexFlat1D_free(obj: *mut FaissIndexFlat1D); + pub fn faiss_IDSelectorAnd_new( + p_sel: *mut *mut FaissIDSelectorAnd, + lhs_sel: *const FaissIDSelector, + rhs_sel: *const FaissIDSelector, + ) -> ::std::os::raw::c_int; } -extern "C" { - #[doc = " Opaque type for IndexFlat1D"] - #[doc = ""] - #[doc = " optimized version for 1D \"vectors\""] - pub fn faiss_IndexFlat1D_new(p_index: *mut *mut FaissIndexFlat1D) -> ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissIDSelectorOr_H { + _unused: [u8; 0], } +pub type FaissIDSelectorOr = FaissIDSelectorOr_H; extern "C" { - pub fn faiss_IndexFlat1D_new_with( - p_index: *mut *mut FaissIndexFlat1D, - continuous_update: ::std::os::raw::c_int, + pub fn faiss_IDSelectorOr_new( + p_sel: *mut *mut FaissIDSelectorOr, + lhs_sel: *const FaissIDSelector, + rhs_sel: *const FaissIDSelector, ) -> ::std::os::raw::c_int; } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissIDSelectorXOr_H { + _unused: [u8; 0], +} +pub type FaissIDSelectorXOr = FaissIDSelectorXOr_H; extern "C" { - pub fn faiss_IndexFlat1D_update_permutation( - index: *mut FaissIndexFlat1D, + pub fn faiss_IDSelectorXOr_new( + p_sel: *mut *mut FaissIDSelectorXOr, + lhs_sel: *const FaissIDSelector, + rhs_sel: *const FaissIDSelector, ) -> ::std::os::raw::c_int; } -pub type FaissIndexIVFFlat = FaissIndex_H; -extern "C" { - pub fn faiss_IndexIVFFlat_free(obj: *mut FaissIndexIVFFlat); +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissBufferList_H { + _unused: [u8; 0], } +pub type FaissBufferList = FaissBufferList_H; extern "C" { - pub fn faiss_IndexIVFFlat_cast(arg1: *mut FaissIndex) -> *mut FaissIndexIVFFlat; + pub fn faiss_BufferList_free(obj: *mut FaissBufferList); } extern "C" { - pub fn faiss_IndexIVFFlat_nlist(arg1: *const FaissIndexIVFFlat) -> usize; + pub fn faiss_BufferList_buffer_size(arg1: *const FaissBufferList) -> usize; } extern "C" { - pub fn faiss_IndexIVFFlat_nprobe(arg1: *const FaissIndexIVFFlat) -> usize; + pub fn faiss_BufferList_wp(arg1: *const FaissBufferList) -> usize; } -extern "C" { - pub fn faiss_IndexIVFFlat_set_nprobe(arg1: *mut FaissIndexIVFFlat, arg2: usize); +#[doc = " List of temporary buffers used to store results before they are\n copied to the RangeSearchResult object."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissBuffer { + pub ids: *mut idx_t, + pub dis: *mut f32, +} +#[test] +fn bindgen_test_layout_FaissBuffer() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(FaissBuffer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(FaissBuffer)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ids) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(FaissBuffer), + "::", + stringify!(ids) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dis) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(FaissBuffer), + "::", + stringify!(dis) + ) + ); } extern "C" { - pub fn faiss_IndexIVFFlat_quantizer(arg1: *const FaissIndexIVFFlat) -> *mut FaissIndex; + pub fn faiss_BufferList_append_buffer(bl: *mut FaissBufferList) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IndexIVFFlat_quantizer_trains_alone( - arg1: *const FaissIndexIVFFlat, - ) -> ::std::os::raw::c_char; + pub fn faiss_BufferList_new( + p_bl: *mut *mut FaissBufferList, + buffer_size: usize, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IndexIVFFlat_own_fields(arg1: *const FaissIndexIVFFlat) -> ::std::os::raw::c_int; + pub fn faiss_BufferList_add( + bl: *mut FaissBufferList, + id: idx_t, + dis: f32, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IndexIVFFlat_set_own_fields( - arg1: *mut FaissIndexIVFFlat, - arg2: ::std::os::raw::c_int, - ); + #[doc = " copy elemnts ofs:ofs+n-1 seen as linear data in the buffers to\n tables dest_ids, dest_dis"] + pub fn faiss_BufferList_copy_range( + bl: *mut FaissBufferList, + ofs: usize, + n: usize, + dest_ids: *mut idx_t, + dest_dis: *mut f32, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissRangeSearchPartialResult_H { + _unused: [u8; 0], } +pub type FaissRangeSearchPartialResult = FaissRangeSearchPartialResult_H; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissRangeQueryResult_H { + _unused: [u8; 0], +} +pub type FaissRangeQueryResult = FaissRangeQueryResult_H; extern "C" { - #[doc = " whether object owns the quantizer"] - pub fn faiss_IndexIVFFlat_new(p_index: *mut *mut FaissIndexIVFFlat) -> ::std::os::raw::c_int; + pub fn faiss_RangeQueryResult_qno(arg1: *const FaissRangeQueryResult) -> idx_t; } extern "C" { - pub fn faiss_IndexIVFFlat_new_with( - p_index: *mut *mut FaissIndexIVFFlat, - quantizer: *mut FaissIndex, - d: usize, - nlist: usize, + pub fn faiss_RangeQueryResult_nres(arg1: *const FaissRangeQueryResult) -> usize; +} +extern "C" { + pub fn faiss_RangeQueryResult_pres( + arg1: *const FaissRangeQueryResult, + ) -> *mut FaissRangeSearchPartialResult; +} +extern "C" { + #[doc = " result structure for a single query"] + pub fn faiss_RangeQueryResult_add( + qr: *mut FaissRangeQueryResult, + dis: f32, + id: idx_t, ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IndexIVFFlat_new_with_metric( - p_index: *mut *mut FaissIndexIVFFlat, - quantizer: *mut FaissIndex, - d: usize, - nlist: usize, + pub fn faiss_RangeSearchPartialResult_res( + arg1: *const FaissRangeSearchPartialResult, + ) -> *mut FaissRangeSearchResult; +} +extern "C" { + pub fn faiss_RangeSearchPartialResult_new( + p_res: *mut *mut FaissRangeSearchPartialResult, + res_in: *mut FaissRangeSearchResult, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_RangeSearchPartialResult_finalize( + res: *mut FaissRangeSearchPartialResult, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " called by range_search before do_allocation"] + pub fn faiss_RangeSearchPartialResult_set_lims( + res: *mut FaissRangeSearchPartialResult, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_RangeSearchPartialResult_new_result( + res: *mut FaissRangeSearchPartialResult, + qno: idx_t, + qr: *mut *mut FaissRangeQueryResult, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissDistanceComputer_H { + _unused: [u8; 0], +} +pub type FaissDistanceComputer = FaissDistanceComputer_H; +extern "C" { + #[doc = " called before computing distances"] + pub fn faiss_DistanceComputer_set_query( + dc: *mut FaissDistanceComputer, + x: *const f32, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Compute distance of vector i to current query.\n This function corresponds to the function call operator:\n DistanceComputer::operator()"] + pub fn faiss_DistanceComputer_vector_to_query_dis( + dc: *mut FaissDistanceComputer, + i: idx_t, + qd: *mut f32, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " compute distance between two stored vectors"] + pub fn faiss_DistanceComputer_symmetric_dis( + dc: *mut FaissDistanceComputer, + i: idx_t, + j: idx_t, + vd: *mut f32, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_DistanceComputer_free(obj: *mut FaissDistanceComputer); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissIndexBinary_H { + _unused: [u8; 0], +} +pub type FaissIndexBinary = FaissIndexBinary_H; +extern "C" { + pub fn faiss_IndexBinary_free(obj: *mut FaissIndexBinary); +} +extern "C" { + pub fn faiss_IndexBinary_d(arg1: *const FaissIndexBinary) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexBinary_is_trained(arg1: *const FaissIndexBinary) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexBinary_ntotal(arg1: *const FaissIndexBinary) -> idx_t; +} +extern "C" { + pub fn faiss_IndexBinary_metric_type(arg1: *const FaissIndexBinary) -> FaissMetricType; +} +extern "C" { + pub fn faiss_IndexBinary_verbose(arg1: *const FaissIndexBinary) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexBinary_set_verbose(arg1: *mut FaissIndexBinary, arg2: ::std::os::raw::c_int); +} +extern "C" { + #[doc = " Perform training on a representative set of vectors\n\n @param index opaque pointer to index object\n @param n nb of training vectors\n @param x training vectors, size n * d"] + pub fn faiss_IndexBinary_train( + index: *mut FaissIndexBinary, + n: idx_t, + x: *const u8, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Add n vectors of dimension d to the index.\n\n Vectors are implicitly assigned labels ntotal .. ntotal + n - 1\n This function slices the input vectors in chunks smaller than\n blocksize_add and calls add_core.\n @param index opaque pointer to index object\n @param x input matrix, size n * d"] + pub fn faiss_IndexBinary_add( + index: *mut FaissIndexBinary, + n: idx_t, + x: *const u8, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Same as add, but stores xids instead of sequential ids.\n\n The default implementation fails with an assertion, as it is\n not supported by all indexes.\n\n @param index opaque pointer to index object\n @param xids if non-null, ids to store for the vectors (size n)"] + pub fn faiss_IndexBinary_add_with_ids( + index: *mut FaissIndexBinary, + n: idx_t, + x: *const u8, + xids: *const idx_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " query n vectors of dimension d to the index.\n\n return at most k vectors. If there are not enough results for a\n query, the result array is padded with -1s.\n\n @param index opaque pointer to index object\n @param x input vectors to search, size n * d\n @param labels output labels of the NNs, size n*k\n @param distances output pairwise distances, size n*k"] + pub fn faiss_IndexBinary_search( + index: *const FaissIndexBinary, + n: idx_t, + x: *const u8, + k: idx_t, + distances: *mut i32, + labels: *mut idx_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " query n vectors of dimension d to the index.\n\n return all vectors with distance < radius. Note that many\n indexes do not implement the range_search (only the k-NN search\n is mandatory).\n\n @param index opaque pointer to index object\n @param x input vectors to search, size n * d\n @param radius search radius\n @param result result table"] + pub fn faiss_IndexBinary_range_search( + index: *const FaissIndexBinary, + n: idx_t, + x: *const u8, + radius: ::std::os::raw::c_int, + result: *mut FaissRangeSearchResult, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " return the indexes of the k vectors closest to the query x.\n\n This function is identical as search but only return labels of neighbors.\n @param index opaque pointer to index object\n @param x input vectors to search, size n * d\n @param labels output labels of the NNs, size n*k"] + pub fn faiss_IndexBinary_assign( + index: *mut FaissIndexBinary, + n: idx_t, + x: *const u8, + labels: *mut idx_t, + k: idx_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " removes all elements from the database.\n @param index opaque pointer to index object"] + pub fn faiss_IndexBinary_reset(index: *mut FaissIndexBinary) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " removes IDs from the index. Not supported by all indexes\n @param index opaque pointer to index object\n @param nremove output for the number of IDs removed"] + pub fn faiss_IndexBinary_remove_ids( + index: *mut FaissIndexBinary, + sel: *const FaissIDSelector, + n_removed: *mut usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Reconstruct a stored vector (or an approximation if lossy coding)\n\n this function may not be defined for some indexes\n @param index opaque pointer to index object\n @param key id of the vector to reconstruct\n @param recons reconstructed vector (size d)"] + pub fn faiss_IndexBinary_reconstruct( + index: *const FaissIndexBinary, + key: idx_t, + recons: *mut u8, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Reconstruct vectors i0 to i0 + ni - 1\n\n this function may not be defined for some indexes\n @param index opaque pointer to index object\n @param recons reconstructed vector (size ni * d)"] + pub fn faiss_IndexBinary_reconstruct_n( + index: *const FaissIndexBinary, + i0: idx_t, + ni: idx_t, + recons: *mut u8, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Build and index with the sequence of processing steps described in\n the string."] + pub fn faiss_index_factory( + p_index: *mut *mut FaissIndex, + d: ::std::os::raw::c_int, + description: *const ::std::os::raw::c_char, metric: FaissMetricType, ) -> ::std::os::raw::c_int; } +pub type FaissIndexFlat = FaissIndex_H; extern "C" { - pub fn faiss_IndexIVFFlat_add_core( - index: *mut FaissIndexIVFFlat, + #[doc = " Opaque type for IndexFlat"] + pub fn faiss_IndexFlat_new(p_index: *mut *mut FaissIndexFlat) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexFlat_new_with( + p_index: *mut *mut FaissIndexFlat, + d: idx_t, + metric: FaissMetricType, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " get a pointer to the index's internal data (the `xb` field). The outputs\n become invalid after any data addition or removal operation.\n\n @param index opaque pointer to index object\n @param p_xb output, the pointer to the beginning of `xb`.\n @param p_size output, the current size of `sb` in number of float values."] + pub fn faiss_IndexFlat_xb(index: *mut FaissIndexFlat, p_xb: *mut *mut f32, p_size: *mut usize); +} +extern "C" { + pub fn faiss_IndexFlat_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlat; +} +extern "C" { + pub fn faiss_IndexFlat_free(obj: *mut FaissIndexFlat); +} +extern "C" { + #[doc = " compute distance with a subset of vectors\n\n @param index opaque pointer to index object\n @param x query vectors, size n * d\n @param labels indices of the vectors that should be compared\n for each query vector, size n * k\n @param distances\n corresponding output distances, size n * k"] + pub fn faiss_IndexFlat_compute_distance_subset( + index: *mut FaissIndex, n: idx_t, x: *const f32, - xids: *const idx_t, - precomputed_idx: *const i64, + k: idx_t, + distances: *mut f32, + labels: *const idx_t, ) -> ::std::os::raw::c_int; } +pub type FaissIndexFlatIP = FaissIndex_H; extern "C" { - #[doc = " Update a subset of vectors."] - #[doc = ""] - #[doc = " The index must have a direct_map"] - #[doc = ""] - #[doc = " @param nv nb of vectors to update"] - #[doc = " @param idx vector indices to update, size nv"] - #[doc = " @param v vectors of new values, size nv*d"] - pub fn faiss_IndexIVFFlat_update_vectors( - index: *mut FaissIndexIVFFlat, - nv: ::std::os::raw::c_int, - idx: *mut idx_t, - v: *const f32, + pub fn faiss_IndexFlatIP_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlatIP; +} +extern "C" { + pub fn faiss_IndexFlatIP_free(obj: *mut FaissIndexFlatIP); +} +extern "C" { + #[doc = " Opaque type for IndexFlatIP"] + pub fn faiss_IndexFlatIP_new(p_index: *mut *mut FaissIndexFlatIP) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexFlatIP_new_with( + p_index: *mut *mut FaissIndexFlatIP, + d: idx_t, + ) -> ::std::os::raw::c_int; +} +pub type FaissIndexFlatL2 = FaissIndex_H; +extern "C" { + pub fn faiss_IndexFlatL2_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlatL2; +} +extern "C" { + pub fn faiss_IndexFlatL2_free(obj: *mut FaissIndexFlatL2); +} +extern "C" { + #[doc = " Opaque type for IndexFlatL2"] + pub fn faiss_IndexFlatL2_new(p_index: *mut *mut FaissIndexFlatL2) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexFlatL2_new_with( + p_index: *mut *mut FaissIndexFlatL2, + d: idx_t, + ) -> ::std::os::raw::c_int; +} +pub type FaissIndexRefineFlat = FaissIndex_H; +extern "C" { + #[doc = " Opaque type for IndexRefineFlat\n\n Index that queries in a base_index (a fast one) and refines the\n results with an exact search, hopefully improving the results."] + pub fn faiss_IndexRefineFlat_new( + p_index: *mut *mut FaissIndexRefineFlat, + base_index: *mut FaissIndex, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexRefineFlat_free(obj: *mut FaissIndexRefineFlat); +} +extern "C" { + pub fn faiss_IndexRefineFlat_cast(arg1: *mut FaissIndex) -> *mut FaissIndexRefineFlat; +} +extern "C" { + pub fn faiss_IndexRefineFlat_own_fields( + arg1: *const FaissIndexRefineFlat, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexRefineFlat_set_own_fields( + arg1: *mut FaissIndexRefineFlat, + arg2: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn faiss_IndexRefineFlat_k_factor(arg1: *const FaissIndexRefineFlat) -> f32; +} +extern "C" { + pub fn faiss_IndexRefineFlat_set_k_factor(arg1: *mut FaissIndexRefineFlat, arg2: f32); +} +pub type FaissIndexFlat1D = FaissIndex_H; +extern "C" { + pub fn faiss_IndexFlat1D_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlat1D; +} +extern "C" { + pub fn faiss_IndexFlat1D_free(obj: *mut FaissIndexFlat1D); +} +extern "C" { + #[doc = " Opaque type for IndexFlat1D\n\n optimized version for 1D \"vectors\""] + pub fn faiss_IndexFlat1D_new(p_index: *mut *mut FaissIndexFlat1D) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexFlat1D_new_with( + p_index: *mut *mut FaissIndexFlat1D, + continuous_update: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexFlat1D_update_permutation( + index: *mut FaissIndexFlat1D, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Write index to a file.\n This is equivalent to `faiss::write_index` when a file descriptor is\n provided."] + pub fn faiss_write_index(idx: *const FaissIndex, f: *mut FILE) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Write index to a file.\n This is equivalent to `faiss::write_index` when a file path is provided."] + pub fn faiss_write_index_fname( + idx: *const FaissIndex, + fname: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Read index from a file.\n This is equivalent to `faiss:read_index` when a file descriptor is given."] + pub fn faiss_read_index( + f: *mut FILE, + io_flags: ::std::os::raw::c_int, + p_out: *mut *mut FaissIndex, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Read index from a file.\n This is equivalent to `faiss:read_index` when a file path is given."] + pub fn faiss_read_index_fname( + fname: *const ::std::os::raw::c_char, + io_flags: ::std::os::raw::c_int, + p_out: *mut *mut FaissIndex, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Write index to a file.\n This is equivalent to `faiss::write_index_binary` when a file descriptor is\n provided."] + pub fn faiss_write_index_binary( + idx: *const FaissIndexBinary, + f: *mut FILE, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Write index to a file.\n This is equivalent to `faiss::write_index_binary` when a file path is\n provided."] + pub fn faiss_write_index_binary_fname( + idx: *const FaissIndexBinary, + fname: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Read index from a file.\n This is equivalent to `faiss:read_index_binary` when a file descriptor is\n given."] + pub fn faiss_read_index_binary( + f: *mut FILE, + io_flags: ::std::os::raw::c_int, + p_out: *mut *mut FaissIndexBinary, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Read index from a file.\n This is equivalent to `faiss:read_index_binary` when a file path is given."] + pub fn faiss_read_index_binary_fname( + fname: *const ::std::os::raw::c_char, + io_flags: ::std::os::raw::c_int, + p_out: *mut *mut FaissIndexBinary, + ) -> ::std::os::raw::c_int; +} +pub type FaissSearchParametersIVF = FaissSearchParameters_H; +extern "C" { + pub fn faiss_SearchParametersIVF_free(obj: *mut FaissSearchParametersIVF); +} +extern "C" { + pub fn faiss_SearchParametersIVF_cast( + arg1: *mut FaissSearchParameters, + ) -> *mut FaissSearchParametersIVF; +} +extern "C" { + pub fn faiss_SearchParametersIVF_new( + p_sp: *mut *mut FaissSearchParametersIVF, ) -> ::std::os::raw::c_int; } +extern "C" { + pub fn faiss_SearchParametersIVF_new_with( + p_sp: *mut *mut FaissSearchParametersIVF, + sel: *mut FaissIDSelector, + nprobe: usize, + max_codes: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_SearchParametersIVF_sel( + arg1: *const FaissSearchParametersIVF, + ) -> *const FaissIDSelector; +} +extern "C" { + pub fn faiss_SearchParametersIVF_nprobe(arg1: *const FaissSearchParametersIVF) -> usize; +} +extern "C" { + pub fn faiss_SearchParametersIVF_set_nprobe(arg1: *mut FaissSearchParametersIVF, arg2: usize); +} +extern "C" { + pub fn faiss_SearchParametersIVF_max_codes(arg1: *const FaissSearchParametersIVF) -> usize; +} +extern "C" { + pub fn faiss_SearchParametersIVF_set_max_codes( + arg1: *mut FaissSearchParametersIVF, + arg2: usize, + ); +} pub type FaissIndexIVF = FaissIndex_H; extern "C" { pub fn faiss_IndexIVF_free(obj: *mut FaissIndexIVF); @@ -882,9 +1298,7 @@ extern "C" { pub fn faiss_IndexIVF_set_own_fields(arg1: *mut FaissIndexIVF, arg2: ::std::os::raw::c_int); } extern "C" { - #[doc = " moves the entries from another dataset to self. On output,"] - #[doc = " other is empty. add_id is added to all moved ids (for"] - #[doc = " sequential ids, this would be this->ntotal"] + #[doc = " moves the entries from another dataset to self. On output,\n other is empty. add_id is added to all moved ids (for\n sequential ids, this would be this->ntotal"] pub fn faiss_IndexIVF_merge_from( index: *mut FaissIndexIVF, other: *mut FaissIndexIVF, @@ -892,12 +1306,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " copy a subset of the entries index to the other index"] - #[doc = ""] - #[doc = " if subset_type == 0: copies ids in [a1, a2)"] - #[doc = " if subset_type == 1: copies ids if id % a1 == a2"] - #[doc = " if subset_type == 2: copies inverted lists such that a1"] - #[doc = " elements are left before and a2 elements are after"] + #[doc = " copy a subset of the entries index to the other index\n\n if subset_type == 0: copies ids in [a1, a2)\n if subset_type == 1: copies ids if id % a1 == a2\n if subset_type == 2: copies inverted lists such that a1\n elements are left before and a2 elements are after"] pub fn faiss_IndexIVF_copy_subset_to( index: *const FaissIndexIVF, other: *mut FaissIndexIVF, @@ -907,21 +1316,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " search a set of vectors, that are pre-quantized by the IVF"] - #[doc = " quantizer. Fill in the corresponding heaps with the query"] - #[doc = " results. search() calls this."] - #[doc = ""] - #[doc = " @param n nb of vectors to query"] - #[doc = " @param x query vectors, size nx * d"] - #[doc = " @param assign coarse quantization indices, size nx * nprobe"] - #[doc = " @param centroid_dis"] - #[doc = " distances to coarse centroids, size nx * nprobe"] - #[doc = " @param distance"] - #[doc = " output distances, size n * k"] - #[doc = " @param labels output labels, size n * k"] - #[doc = " @param store_pairs store inv list index + inv list offset"] - #[doc = " instead in upper/lower 32 bit of result,"] - #[doc = " instead of ids (used for reranking)."] + #[doc = " search a set of vectors, that are pre-quantized by the IVF\n quantizer. Fill in the corresponding heaps with the query\n results. search() calls this.\n\n @param n nb of vectors to query\n @param x query vectors, size nx * d\n @param assign coarse quantization indices, size nx * nprobe\n @param centroid_dis\n distances to coarse centroids, size nx * nprobe\n @param distance\n output distances, size n * k\n @param labels output labels, size n * k\n @param store_pairs store inv list index + inv list offset\n instead in upper/lower 32 bit of result,\n instead of ids (used for reranking)."] pub fn faiss_IndexIVF_search_preassigned( index: *const FaissIndexIVF, n: idx_t, @@ -938,19 +1333,14 @@ extern "C" { pub fn faiss_IndexIVF_get_list_size(index: *const FaissIndexIVF, list_no: usize) -> usize; } extern "C" { - #[doc = " initialize a direct map"] - #[doc = ""] - #[doc = " @param new_maintain_direct_map if true, create a direct map,"] - #[doc = " else clear it"] + #[doc = " initialize a direct map\n\n @param new_maintain_direct_map if true, create a direct map,\n else clear it"] pub fn faiss_IndexIVF_make_direct_map( index: *mut FaissIndexIVF, new_maintain_direct_map: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Check the inverted lists' imbalance factor."] - #[doc = ""] - #[doc = " 1= perfectly balanced, >1: imbalanced"] + #[doc = " Check the inverted lists' imbalance factor.\n\n 1= perfectly balanced, >1: imbalanced"] pub fn faiss_IndexIVF_imbalance_factor(index: *const FaissIndexIVF) -> f64; } extern "C" { @@ -958,20 +1348,21 @@ extern "C" { pub fn faiss_IndexIVF_print_stats(index: *const FaissIndexIVF); } extern "C" { - #[doc = " Get the IDs in an inverted list. IDs are written to `invlist`, which must be"] - #[doc = " large enough"] - #[doc = " to accommodate the full list."] - #[doc = ""] - #[doc = " @param list_no the list ID"] - #[doc = " @param invlist output pointer to a slice of memory, at least as long as the"] - #[doc = " list's size"] - #[doc = " @see faiss_IndexIVF_get_list_size(size_t)"] + #[doc = " Get the IDs in an inverted list. IDs are written to `invlist`, which must be\n large enough\n to accommodate the full list.\n\n @param list_no the list ID\n @param invlist output pointer to a slice of memory, at least as long as the\n list's size\n @see faiss_IndexIVF_get_list_size(size_t)"] pub fn faiss_IndexIVF_invlists_get_ids( index: *const FaissIndexIVF, list_no: usize, invlist: *mut idx_t, ); } +extern "C" { + pub fn faiss_IndexIVF_train_encoder( + index: *mut FaissIndexIVF, + n: idx_t, + x: *const f32, + assign: *const idx_t, + ) -> ::std::os::raw::c_int; +} #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct FaissIndexIVFStats { @@ -984,6 +1375,8 @@ pub struct FaissIndexIVFStats { } #[test] fn bindgen_test_layout_FaissIndexIVFStats() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 48usize, @@ -995,7 +1388,7 @@ fn bindgen_test_layout_FaissIndexIVFStats() { concat!("Alignment of ", stringify!(FaissIndexIVFStats)) ); assert_eq!( - unsafe { &(*(::std::ptr::null::())).nq as *const _ as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).nq) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", @@ -1005,7 +1398,7 @@ fn bindgen_test_layout_FaissIndexIVFStats() { ) ); assert_eq!( - unsafe { &(*(::std::ptr::null::())).nlist as *const _ as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).nlist) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", @@ -1015,7 +1408,7 @@ fn bindgen_test_layout_FaissIndexIVFStats() { ) ); assert_eq!( - unsafe { &(*(::std::ptr::null::())).ndis as *const _ as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).ndis) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", @@ -1025,9 +1418,7 @@ fn bindgen_test_layout_FaissIndexIVFStats() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nheap_updates as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).nheap_updates) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", @@ -1037,9 +1428,7 @@ fn bindgen_test_layout_FaissIndexIVFStats() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).quantization_time as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).quantization_time) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", @@ -1049,7 +1438,7 @@ fn bindgen_test_layout_FaissIndexIVFStats() { ) ); assert_eq!( - unsafe { &(*(::std::ptr::null::())).search_time as *const _ as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).search_time) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", @@ -1060,11 +1449,83 @@ fn bindgen_test_layout_FaissIndexIVFStats() { ); } extern "C" { - pub fn faiss_IndexIVFStats_reset(stats: *mut FaissIndexIVFStats); + pub fn faiss_IndexIVFStats_reset(stats: *mut FaissIndexIVFStats); +} +extern "C" { + #[doc = " global var that collects all statists"] + pub fn faiss_get_indexIVF_stats() -> *mut FaissIndexIVFStats; +} +pub type FaissIndexIVFFlat = FaissIndex_H; +extern "C" { + pub fn faiss_IndexIVFFlat_free(obj: *mut FaissIndexIVFFlat); +} +extern "C" { + pub fn faiss_IndexIVFFlat_cast(arg1: *mut FaissIndex) -> *mut FaissIndexIVFFlat; +} +extern "C" { + pub fn faiss_IndexIVFFlat_nlist(arg1: *const FaissIndexIVFFlat) -> usize; +} +extern "C" { + pub fn faiss_IndexIVFFlat_nprobe(arg1: *const FaissIndexIVFFlat) -> usize; +} +extern "C" { + pub fn faiss_IndexIVFFlat_set_nprobe(arg1: *mut FaissIndexIVFFlat, arg2: usize); +} +extern "C" { + pub fn faiss_IndexIVFFlat_quantizer(arg1: *const FaissIndexIVFFlat) -> *mut FaissIndex; +} +extern "C" { + pub fn faiss_IndexIVFFlat_quantizer_trains_alone( + arg1: *const FaissIndexIVFFlat, + ) -> ::std::os::raw::c_char; +} +extern "C" { + pub fn faiss_IndexIVFFlat_own_fields(arg1: *const FaissIndexIVFFlat) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexIVFFlat_set_own_fields( + arg1: *mut FaissIndexIVFFlat, + arg2: ::std::os::raw::c_int, + ); +} +extern "C" { + #[doc = " whether object owns the quantizer"] + pub fn faiss_IndexIVFFlat_new(p_index: *mut *mut FaissIndexIVFFlat) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexIVFFlat_new_with( + p_index: *mut *mut FaissIndexIVFFlat, + quantizer: *mut FaissIndex, + d: usize, + nlist: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexIVFFlat_new_with_metric( + p_index: *mut *mut FaissIndexIVFFlat, + quantizer: *mut FaissIndex, + d: usize, + nlist: usize, + metric: FaissMetricType, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexIVFFlat_add_core( + index: *mut FaissIndexIVFFlat, + n: idx_t, + x: *const f32, + xids: *const idx_t, + precomputed_idx: *const i64, + ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " global var that collects all statists"] - pub fn faiss_get_indexIVF_stats() -> *mut FaissIndexIVFStats; + #[doc = " Update a subset of vectors.\n\n The index must have a direct_map\n\n @param nv nb of vectors to update\n @param idx vector indices to update, size nv\n @param v vectors of new values, size nv*d"] + pub fn faiss_IndexIVFFlat_update_vectors( + index: *mut FaissIndexIVFFlat, + nv: ::std::os::raw::c_int, + idx: *mut idx_t, + v: *const f32, + ) -> ::std::os::raw::c_int; } pub type FaissIndexLSH = FaissIndex_H; extern "C" { @@ -1123,11 +1584,7 @@ extern "C" { pub fn faiss_VectorTransform_d_out(arg1: *const FaissVectorTransform) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Perform training on a representative set of vectors"] - #[doc = ""] - #[doc = " @param vt opaque pointer to VectorTransform object"] - #[doc = " @param n nb of training vectors"] - #[doc = " @param x training vectors, size n * d"] + #[doc = " Perform training on a representative set of vectors\n\n @param vt opaque pointer to VectorTransform object\n @param n nb of training vectors\n @param x training vectors, size n * d"] pub fn faiss_VectorTransform_train( vt: *mut FaissVectorTransform, n: idx_t, @@ -1135,9 +1592,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " apply the random rotation, return new allocated matrix"] - #[doc = " @param x size n * d_in"] - #[doc = " @return size n * d_out"] + #[doc = " apply the random rotation, return new allocated matrix\n @param x size n * d_in\n @return size n * d_out"] pub fn faiss_VectorTransform_apply( vt: *const FaissVectorTransform, n: idx_t, @@ -1145,9 +1600,7 @@ extern "C" { ) -> *mut f32; } extern "C" { - #[doc = " apply transformation and result is pre-allocated"] - #[doc = " @param x size n * d_in"] - #[doc = " @param xt size n * d_out"] + #[doc = " apply transformation and result is pre-allocated\n @param x size n * d_in\n @param xt size n * d_out"] pub fn faiss_VectorTransform_apply_noalloc( vt: *const FaissVectorTransform, n: idx_t, @@ -1156,8 +1609,7 @@ extern "C" { ); } extern "C" { - #[doc = " reverse transformation. May not be implemented or may return"] - #[doc = " approximate result"] + #[doc = " reverse transformation. May not be implemented or may return\n approximate result"] pub fn faiss_VectorTransform_reverse_transform( vt: *const FaissVectorTransform, n: idx_t, @@ -1170,8 +1622,7 @@ extern "C" { pub fn faiss_LinearTransform_free(obj: *mut FaissLinearTransform); } extern "C" { - #[doc = " compute x = A^T * (x - b)"] - #[doc = " is reverse transform if A has orthonormal lines"] + #[doc = " compute x = A^T * (x - b)\n is reverse transform if A has orthonormal lines"] pub fn faiss_LinearTransform_transform_transpose( vt: *const FaissLinearTransform, n: idx_t, @@ -1339,8 +1790,7 @@ extern "C" { ); } extern "C" { - #[doc = " Index that applies a LinearTransform transform on vectors before"] - #[doc = " handing them over to a sub-index"] + #[doc = " Index that applies a LinearTransform transform on vectors before\n handing them over to a sub-index"] pub fn faiss_IndexPreTransform_new( p_index: *mut *mut FaissIndexPreTransform, ) -> ::std::os::raw::c_int; @@ -1494,484 +1944,153 @@ extern "C" { ); } extern "C" { - pub fn faiss_IndexIVFScalarQuantizer_quantizer( - arg1: *const FaissIndexIVFScalarQuantizer, - ) -> *mut FaissIndex; -} -extern "C" { - pub fn faiss_IndexIVFScalarQuantizer_own_fields( - arg1: *const FaissIndexIVFScalarQuantizer, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexIVFScalarQuantizer_set_own_fields( - arg1: *mut FaissIndexIVFScalarQuantizer, - arg2: ::std::os::raw::c_int, - ); -} -extern "C" { - #[doc = " whether object owns the quantizer"] - pub fn faiss_IndexIVFScalarQuantizer_add_core( - index: *mut FaissIndexIVFScalarQuantizer, - n: idx_t, - x: *const f32, - xids: *const idx_t, - precomputed_idx: *const idx_t, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexIVFScalarQuantizer_train_residual( - index: *mut FaissIndexIVFScalarQuantizer, - n: idx_t, - x: *const f32, - ) -> ::std::os::raw::c_int; -} -pub type FaissIndexShards = FaissIndex_H; -extern "C" { - pub fn faiss_IndexShards_free(obj: *mut FaissIndexShards); -} -extern "C" { - pub fn faiss_IndexShards_own_fields(arg1: *const FaissIndexShards) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexShards_set_own_fields( - arg1: *mut FaissIndexShards, - arg2: ::std::os::raw::c_int, - ); -} -extern "C" { - pub fn faiss_IndexShards_successive_ids(arg1: *const FaissIndexShards) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexShards_set_successive_ids( - arg1: *mut FaissIndexShards, - arg2: ::std::os::raw::c_int, - ); -} -extern "C" { - #[doc = " Index that concatenates the results from several sub-indexes"] - pub fn faiss_IndexShards_new( - p_index: *mut *mut FaissIndexShards, - d: idx_t, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexShards_new_with_options( - p_index: *mut *mut FaissIndexShards, - d: idx_t, - threaded: ::std::os::raw::c_int, - successive_ids: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexShards_add_shard( - index: *mut FaissIndexShards, - shard: *mut FaissIndex, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexShards_remove_shard( - index: *mut FaissIndexShards, - shard: *mut FaissIndex, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexShards_at( - index: *mut FaissIndexShards, - i: ::std::os::raw::c_int, - ) -> *mut FaissIndex; -} -pub type FaissIndexIDMap = FaissIndex_H; -extern "C" { - pub fn faiss_IndexIDMap_own_fields(arg1: *const FaissIndexIDMap) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexIDMap_set_own_fields(arg1: *mut FaissIndexIDMap, arg2: ::std::os::raw::c_int); -} -extern "C" { - #[doc = " Index that translates search results to ids"] - pub fn faiss_IndexIDMap_new( - p_index: *mut *mut FaissIndexIDMap, - index: *mut FaissIndex, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexIDMap_cast(arg1: *mut FaissIndex) -> *mut FaissIndexIDMap; -} -extern "C" { - #[doc = " get a pointer to the index map's internal ID vector (the `id_map` field)."] - #[doc = " The outputs of this function become invalid after any operation that can"] - #[doc = " modify the index."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param p_id_map output, the pointer to the beginning of `id_map`."] - #[doc = " @param p_size output, the current length of `id_map`."] - pub fn faiss_IndexIDMap_id_map( - index: *mut FaissIndexIDMap, - p_id_map: *mut *mut idx_t, - p_size: *mut usize, - ); -} -extern "C" { - #[doc = " get a pointer to the sub-index (the `index` field)."] - #[doc = " The outputs of this function become invalid after any operation that can"] - #[doc = " modify the index."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - pub fn faiss_IndexIDMap_sub_index(index: *mut FaissIndexIDMap) -> *mut FaissIndex; -} -pub type FaissIndexIDMap2 = FaissIndex_H; -extern "C" { - pub fn faiss_IndexIDMap2_own_fields(arg1: *const FaissIndexIDMap2) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexIDMap2_set_own_fields( - arg1: *mut FaissIndexIDMap2, - arg2: ::std::os::raw::c_int, - ); -} -extern "C" { - #[doc = " same as IndexIDMap but also provides an efficient reconstruction"] - #[doc = "implementation via a 2-way index"] - pub fn faiss_IndexIDMap2_new( - p_index: *mut *mut FaissIndexIDMap2, - index: *mut FaissIndex, - ) -> ::std::os::raw::c_int; -} -extern "C" { - #[doc = " make the rev_map from scratch"] - pub fn faiss_IndexIDMap2_construct_rev_map( - index: *mut FaissIndexIDMap2, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexIDMap2_cast(arg1: *mut FaissIndex) -> *mut FaissIndexIDMap2; -} -extern "C" { - #[doc = " get a pointer to the index map's internal ID vector (the `id_map` field)."] - #[doc = " The outputs of this function become invalid after any operation that can"] - #[doc = " modify the index."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param p_id_map output, the pointer to the beginning of `id_map`."] - #[doc = " @param p_size output, the current length of `id_map`."] - pub fn faiss_IndexIDMap2_id_map( - index: *mut FaissIndexIDMap2, - p_id_map: *mut *mut idx_t, - p_size: *mut usize, - ); -} -extern "C" { - #[doc = " get a pointer to the sub-index (the `index` field)."] - #[doc = " The outputs of this function become invalid after any operation that can"] - #[doc = " modify the index."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - pub fn faiss_IndexIDMap2_sub_index(index: *mut FaissIndexIDMap2) -> *mut FaissIndex; -} -pub type FILE = [u64; 27usize]; -extern "C" { - #[doc = " Clone an index. This is equivalent to `faiss::clone_index`"] - pub fn faiss_clone_index( - arg1: *const FaissIndex, - p_out: *mut *mut FaissIndex, - ) -> ::std::os::raw::c_int; -} -#[doc = " No error"] -pub const FaissErrorCode_OK: FaissErrorCode = 0; -#[doc = " Any exception other than Faiss or standard C++ library exceptions"] -pub const FaissErrorCode_UNKNOWN_EXCEPT: FaissErrorCode = -1; -#[doc = " Faiss library exception"] -pub const FaissErrorCode_FAISS_EXCEPT: FaissErrorCode = -2; -#[doc = " Standard C++ library exception"] -pub const FaissErrorCode_STD_EXCEPT: FaissErrorCode = -4; -#[doc = " An error code which depends on the exception thrown from the previous"] -#[doc = " operation. See `faiss_get_last_error` to retrieve the error message."] -pub type FaissErrorCode = ::std::os::raw::c_int; -extern "C" { - #[doc = " Get the error message of the last failed operation performed by Faiss."] - #[doc = " The given pointer is only invalid until another Faiss function is"] - #[doc = " called."] - pub fn faiss_get_last_error() -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn faiss_RangeSearchResult_nq(arg1: *const FaissRangeSearchResult) -> usize; -} -extern "C" { - pub fn faiss_RangeSearchResult_new( - p_rsr: *mut *mut FaissRangeSearchResult, - nq: idx_t, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_RangeSearchResult_new_with( - p_rsr: *mut *mut FaissRangeSearchResult, - nq: idx_t, - alloc_lims: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - #[doc = " called when lims contains the nb of elements result entries"] - #[doc = " for each query"] - pub fn faiss_RangeSearchResult_do_allocation( - rsr: *mut FaissRangeSearchResult, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_RangeSearchResult_free(obj: *mut FaissRangeSearchResult); -} -extern "C" { - pub fn faiss_RangeSearchResult_buffer_size(arg1: *const FaissRangeSearchResult) -> usize; -} -extern "C" { - #[doc = " getter for lims: size (nq + 1)"] - pub fn faiss_RangeSearchResult_lims(rsr: *mut FaissRangeSearchResult, lims: *mut *mut usize); -} -extern "C" { - #[doc = " getter for labels and respective distances (not sorted):"] - #[doc = " result for query i is labels[lims[i]:lims[i+1]]"] - pub fn faiss_RangeSearchResult_labels( - rsr: *mut FaissRangeSearchResult, - labels: *mut *mut idx_t, - distances: *mut *mut f32, - ); -} -extern "C" { - pub fn faiss_IDSelector_free(obj: *mut FaissIDSelector); -} -extern "C" { - #[doc = " Encapsulates a set of ids to remove."] - pub fn faiss_IDSelector_is_member( - sel: *const FaissIDSelector, - id: idx_t, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct FaissIDSelectorRange_H { - _unused: [u8; 0], -} -pub type FaissIDSelectorRange = FaissIDSelectorRange_H; -extern "C" { - pub fn faiss_IDSelectorRange_free(obj: *mut FaissIDSelectorRange); -} -extern "C" { - pub fn faiss_IDSelectorRange_imin(arg1: *const FaissIDSelectorRange) -> idx_t; -} -extern "C" { - pub fn faiss_IDSelectorRange_imax(arg1: *const FaissIDSelectorRange) -> idx_t; -} -extern "C" { - #[doc = " remove ids between [imni, imax)"] - pub fn faiss_IDSelectorRange_new( - p_sel: *mut *mut FaissIDSelectorRange, - imin: idx_t, - imax: idx_t, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct FaissIDSelectorBatch_H { - _unused: [u8; 0], + pub fn faiss_IndexIVFScalarQuantizer_quantizer( + arg1: *const FaissIndexIVFScalarQuantizer, + ) -> *mut FaissIndex; } -pub type FaissIDSelectorBatch = FaissIDSelectorBatch_H; extern "C" { - pub fn faiss_IDSelectorBatch_nbits(arg1: *const FaissIDSelectorBatch) -> ::std::os::raw::c_int; + pub fn faiss_IndexIVFScalarQuantizer_own_fields( + arg1: *const FaissIndexIVFScalarQuantizer, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IDSelectorBatch_mask(arg1: *const FaissIDSelectorBatch) -> idx_t; + pub fn faiss_IndexIVFScalarQuantizer_set_own_fields( + arg1: *mut FaissIndexIVFScalarQuantizer, + arg2: ::std::os::raw::c_int, + ); } extern "C" { - #[doc = " Remove ids from a set. Repetitions of ids in the indices set"] - #[doc = " passed to the constructor does not hurt performance. The hash"] - #[doc = " function used for the bloom filter and GCC's implementation of"] - #[doc = " unordered_set are just the least significant bits of the id. This"] - #[doc = " works fine for random ids or ids in sequences but will produce many"] - #[doc = " hash collisions if lsb's are always the same"] - pub fn faiss_IDSelectorBatch_new( - p_sel: *mut *mut FaissIDSelectorBatch, - n: usize, - indices: *const idx_t, + #[doc = " whether object owns the quantizer"] + pub fn faiss_IndexIVFScalarQuantizer_add_core( + index: *mut FaissIndexIVFScalarQuantizer, + n: idx_t, + x: *const f32, + xids: *const idx_t, + precomputed_idx: *const idx_t, ) -> ::std::os::raw::c_int; } -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct FaissBufferList_H { - _unused: [u8; 0], -} -pub type FaissBufferList = FaissBufferList_H; +pub type FaissIndexShards = FaissIndex_H; extern "C" { - pub fn faiss_BufferList_free(obj: *mut FaissBufferList); + pub fn faiss_IndexShards_free(obj: *mut FaissIndexShards); } extern "C" { - pub fn faiss_BufferList_buffer_size(arg1: *const FaissBufferList) -> usize; + pub fn faiss_IndexShards_own_fields(arg1: *const FaissIndexShards) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_BufferList_wp(arg1: *const FaissBufferList) -> usize; + pub fn faiss_IndexShards_set_own_fields( + arg1: *mut FaissIndexShards, + arg2: ::std::os::raw::c_int, + ); } -#[doc = " List of temporary buffers used to store results before they are"] -#[doc = " copied to the RangeSearchResult object."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct FaissBuffer { - pub ids: *mut idx_t, - pub dis: *mut f32, +extern "C" { + pub fn faiss_IndexShards_successive_ids(arg1: *const FaissIndexShards) + -> ::std::os::raw::c_int; } -#[test] -fn bindgen_test_layout_FaissBuffer() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(FaissBuffer)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(FaissBuffer)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).ids as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(FaissBuffer), - "::", - stringify!(ids) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).dis as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(FaissBuffer), - "::", - stringify!(dis) - ) +extern "C" { + pub fn faiss_IndexShards_set_successive_ids( + arg1: *mut FaissIndexShards, + arg2: ::std::os::raw::c_int, ); } extern "C" { - pub fn faiss_BufferList_append_buffer(bl: *mut FaissBufferList) -> ::std::os::raw::c_int; + #[doc = " Index that concatenates the results from several sub-indexes"] + pub fn faiss_IndexShards_new( + p_index: *mut *mut FaissIndexShards, + d: idx_t, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_BufferList_new( - p_bl: *mut *mut FaissBufferList, - buffer_size: usize, + pub fn faiss_IndexShards_new_with_options( + p_index: *mut *mut FaissIndexShards, + d: idx_t, + threaded: ::std::os::raw::c_int, + successive_ids: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_BufferList_add( - bl: *mut FaissBufferList, - id: idx_t, - dis: f32, + pub fn faiss_IndexShards_add_shard( + index: *mut FaissIndexShards, + shard: *mut FaissIndex, ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " copy elemnts ofs:ofs+n-1 seen as linear data in the buffers to"] - #[doc = " tables dest_ids, dest_dis"] - pub fn faiss_BufferList_copy_range( - bl: *mut FaissBufferList, - ofs: usize, - n: usize, - dest_ids: *mut idx_t, - dest_dis: *mut f32, + pub fn faiss_IndexShards_remove_shard( + index: *mut FaissIndexShards, + shard: *mut FaissIndex, ) -> ::std::os::raw::c_int; } -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct FaissRangeSearchPartialResult_H { - _unused: [u8; 0], -} -pub type FaissRangeSearchPartialResult = FaissRangeSearchPartialResult_H; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct FaissRangeQueryResult_H { - _unused: [u8; 0], -} -pub type FaissRangeQueryResult = FaissRangeQueryResult_H; extern "C" { - pub fn faiss_RangeQueryResult_qno(arg1: *const FaissRangeQueryResult) -> idx_t; + pub fn faiss_IndexShards_at( + index: *mut FaissIndexShards, + i: ::std::os::raw::c_int, + ) -> *mut FaissIndex; } +pub type FaissIndexIDMap = FaissIndex_H; extern "C" { - pub fn faiss_RangeQueryResult_nres(arg1: *const FaissRangeQueryResult) -> usize; + pub fn faiss_IndexIDMap_own_fields(arg1: *const FaissIndexIDMap) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_RangeQueryResult_pres( - arg1: *const FaissRangeQueryResult, - ) -> *mut FaissRangeSearchPartialResult; + pub fn faiss_IndexIDMap_set_own_fields(arg1: *mut FaissIndexIDMap, arg2: ::std::os::raw::c_int); } extern "C" { - #[doc = " result structure for a single query"] - pub fn faiss_RangeQueryResult_add( - qr: *mut FaissRangeQueryResult, - dis: f32, - id: idx_t, + #[doc = " Index that translates search results to ids"] + pub fn faiss_IndexIDMap_new( + p_index: *mut *mut FaissIndexIDMap, + index: *mut FaissIndex, ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_RangeSearchPartialResult_res( - arg1: *const FaissRangeSearchPartialResult, - ) -> *mut FaissRangeSearchResult; + pub fn faiss_IndexIDMap_cast(arg1: *mut FaissIndex) -> *mut FaissIndexIDMap; } extern "C" { - pub fn faiss_RangeSearchPartialResult_new( - p_res: *mut *mut FaissRangeSearchPartialResult, - res_in: *mut FaissRangeSearchResult, - ) -> ::std::os::raw::c_int; + #[doc = " get a pointer to the index map's internal ID vector (the `id_map` field).\n The outputs of this function become invalid after any operation that can\n modify the index.\n\n @param index opaque pointer to index object\n @param p_id_map output, the pointer to the beginning of `id_map`.\n @param p_size output, the current length of `id_map`."] + pub fn faiss_IndexIDMap_id_map( + index: *mut FaissIndexIDMap, + p_id_map: *mut *mut idx_t, + p_size: *mut usize, + ); } extern "C" { - pub fn faiss_RangeSearchPartialResult_finalize( - res: *mut FaissRangeSearchPartialResult, - ) -> ::std::os::raw::c_int; + #[doc = " get a pointer to the sub-index (the `index` field).\n The outputs of this function become invalid after any operation that can\n modify the index.\n\n @param index opaque pointer to index object"] + pub fn faiss_IndexIDMap_sub_index(index: *mut FaissIndexIDMap) -> *mut FaissIndex; } +pub type FaissIndexIDMap2 = FaissIndex_H; extern "C" { - #[doc = " called by range_search before do_allocation"] - pub fn faiss_RangeSearchPartialResult_set_lims( - res: *mut FaissRangeSearchPartialResult, - ) -> ::std::os::raw::c_int; + pub fn faiss_IndexIDMap2_own_fields(arg1: *const FaissIndexIDMap2) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_RangeSearchPartialResult_new_result( - res: *mut FaissRangeSearchPartialResult, - qno: idx_t, - qr: *mut *mut FaissRangeQueryResult, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct FaissDistanceComputer_H { - _unused: [u8; 0], + pub fn faiss_IndexIDMap2_set_own_fields( + arg1: *mut FaissIndexIDMap2, + arg2: ::std::os::raw::c_int, + ); } -pub type FaissDistanceComputer = FaissDistanceComputer_H; extern "C" { - #[doc = " called before computing distances"] - pub fn faiss_DistanceComputer_set_query( - dc: *mut FaissDistanceComputer, - x: *const f32, + #[doc = " same as IndexIDMap but also provides an efficient reconstruction\nimplementation via a 2-way index"] + pub fn faiss_IndexIDMap2_new( + p_index: *mut *mut FaissIndexIDMap2, + index: *mut FaissIndex, ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Compute distance of vector i to current query."] - #[doc = " This function corresponds to the function call operator:"] - #[doc = " DistanceComputer::operator()"] - pub fn faiss_DistanceComputer_vector_to_query_dis( - dc: *mut FaissDistanceComputer, - i: idx_t, - qd: *mut f32, + #[doc = " make the rev_map from scratch"] + pub fn faiss_IndexIDMap2_construct_rev_map( + index: *mut FaissIndexIDMap2, ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " compute distance between two stored vectors"] - pub fn faiss_DistanceComputer_symmetric_dis( - dc: *mut FaissDistanceComputer, - i: idx_t, - j: idx_t, - vd: *mut f32, - ) -> ::std::os::raw::c_int; + pub fn faiss_IndexIDMap2_cast(arg1: *mut FaissIndex) -> *mut FaissIndexIDMap2; } extern "C" { - pub fn faiss_DistanceComputer_free(obj: *mut FaissDistanceComputer); + #[doc = " get a pointer to the index map's internal ID vector (the `id_map` field).\n The outputs of this function become invalid after any operation that can\n modify the index.\n\n @param index opaque pointer to index object\n @param p_id_map output, the pointer to the beginning of `id_map`.\n @param p_size output, the current length of `id_map`."] + pub fn faiss_IndexIDMap2_id_map( + index: *mut FaissIndexIDMap2, + p_id_map: *mut *mut idx_t, + p_size: *mut usize, + ); +} +extern "C" { + #[doc = " get a pointer to the sub-index (the `index` field).\n The outputs of this function become invalid after any operation that can\n modify the index.\n\n @param index opaque pointer to index object"] + pub fn faiss_IndexIDMap2_sub_index(index: *mut FaissIndexIDMap2) -> *mut FaissIndex; } extern "C" { #[doc = " Compute pairwise distances between sets of vectors"] @@ -1988,11 +2107,7 @@ extern "C" { ); } extern "C" { - #[doc = " Compute pairwise distances between sets of vectors"] - #[doc = " arguments from \"faiss_pairwise_L2sqr\""] - #[doc = " ldq equal -1 by default"] - #[doc = " ldb equal -1 by default"] - #[doc = " ldd equal -1 by default"] + #[doc = " Compute pairwise distances between sets of vectors\n arguments from \"faiss_pairwise_L2sqr\"\n ldq equal -1 by default\n ldb equal -1 by default\n ldd equal -1 by default"] pub fn faiss_pairwise_L2sqr_with_defaults( d: i64, nq: i64, @@ -2033,13 +2148,11 @@ extern "C" { pub fn faiss_fvec_renorm_L2(d: usize, nx: usize, x: *mut f32); } extern "C" { - #[doc = " Setter of threshold value on nx above which we switch to BLAS to compute"] - #[doc = " distances"] + #[doc = " Setter of threshold value on nx above which we switch to BLAS to compute\n distances"] pub fn faiss_set_distance_compute_blas_threshold(value: ::std::os::raw::c_int); } extern "C" { - #[doc = " Getter of threshold value on nx above which we switch to BLAS to compute"] - #[doc = " distances"] + #[doc = " Getter of threshold value on nx above which we switch to BLAS to compute\n distances"] pub fn faiss_get_distance_compute_blas_threshold() -> ::std::os::raw::c_int; } extern "C" { @@ -2059,54 +2172,10 @@ extern "C" { pub fn faiss_get_distance_compute_blas_database_bs() -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Setter of number of results we switch to a reservoir to collect results"] - #[doc = " rather than a heap"] + #[doc = " Setter of number of results we switch to a reservoir to collect results\n rather than a heap"] pub fn faiss_set_distance_compute_min_k_reservoir(value: ::std::os::raw::c_int); } extern "C" { - #[doc = " Getter of number of results we switch to a reservoir to collect results"] - #[doc = " rather than a heap"] + #[doc = " Getter of number of results we switch to a reservoir to collect results\n rather than a heap"] pub fn faiss_get_distance_compute_min_k_reservoir() -> ::std::os::raw::c_int; } -extern "C" { - #[doc = " Build and index with the sequence of processing steps described in"] - #[doc = " the string."] - pub fn faiss_index_factory( - p_index: *mut *mut FaissIndex, - d: ::std::os::raw::c_int, - description: *const ::std::os::raw::c_char, - metric: FaissMetricType, - ) -> ::std::os::raw::c_int; -} -extern "C" { - #[doc = " Write index to a file."] - #[doc = " This is equivalent to `faiss::write_index` when a file descriptor is"] - #[doc = " provided."] - pub fn faiss_write_index(idx: *const FaissIndex, f: *mut FILE) -> ::std::os::raw::c_int; -} -extern "C" { - #[doc = " Write index to a file."] - #[doc = " This is equivalent to `faiss::write_index` when a file path is provided."] - pub fn faiss_write_index_fname( - idx: *const FaissIndex, - fname: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - #[doc = " Read index from a file."] - #[doc = " This is equivalent to `faiss:read_index` when a file descriptor is given."] - pub fn faiss_read_index( - f: *mut FILE, - io_flags: ::std::os::raw::c_int, - p_out: *mut *mut FaissIndex, - ) -> ::std::os::raw::c_int; -} -extern "C" { - #[doc = " Read index from a file."] - #[doc = " This is equivalent to `faiss:read_index` when a file path is given."] - pub fn faiss_read_index_fname( - fname: *const ::std::os::raw::c_char, - io_flags: ::std::os::raw::c_int, - p_out: *mut *mut FaissIndex, - ) -> ::std::os::raw::c_int; -} diff --git a/faiss-sys/src/bindings_gpu.rs b/faiss-sys/src/bindings_gpu.rs index b6d2fe0..996ad28 100644 --- a/faiss-sys/src/bindings_gpu.rs +++ b/faiss-sys/src/bindings_gpu.rs @@ -1,6 +1,5 @@ -/* automatically generated by rust-bindgen 0.59.2 */ +/* automatically generated by rust-bindgen 0.69.4 */ -pub type __int64_t = ::std::os::raw::c_long; pub type faiss_idx_t = i64; pub type idx_t = faiss_idx_t; #[repr(C)] @@ -31,11 +30,25 @@ pub const FaissMetricType_METRIC_Canberra: FaissMetricType = 20; pub const FaissMetricType_METRIC_BrayCurtis: FaissMetricType = 21; #[doc = " some additional metrics defined in scipy.spatial.distance"] pub const FaissMetricType_METRIC_JensenShannon: FaissMetricType = 22; -#[doc = " Some algorithms support both an inner product version and a L2 search"] -#[doc = " version."] +#[doc = " Some algorithms support both an inner product version and a L2 search\n version."] pub type FaissMetricType = ::std::os::raw::c_uint; #[repr(C)] #[derive(Debug, Copy, Clone)] +pub struct FaissSearchParameters_H { + _unused: [u8; 0], +} +pub type FaissSearchParameters = FaissSearchParameters_H; +extern "C" { + pub fn faiss_SearchParameters_free(obj: *mut FaissSearchParameters); +} +extern "C" { + pub fn faiss_SearchParameters_new( + p_sp: *mut *mut FaissSearchParameters, + sel: *mut FaissIDSelector, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] pub struct FaissIndex_H { _unused: [u8; 0], } @@ -62,11 +75,7 @@ extern "C" { pub fn faiss_Index_set_verbose(arg1: *mut FaissIndex, arg2: ::std::os::raw::c_int); } extern "C" { - #[doc = " Perform training on a representative set of vectors"] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param n nb of training vectors"] - #[doc = " @param x training vectors, size n * d"] + #[doc = " Perform training on a representative set of vectors\n\n @param index opaque pointer to index object\n @param n nb of training vectors\n @param x training vectors, size n * d"] pub fn faiss_Index_train( index: *mut FaissIndex, n: idx_t, @@ -74,13 +83,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Add n vectors of dimension d to the index."] - #[doc = ""] - #[doc = " Vectors are implicitly assigned labels ntotal .. ntotal + n - 1"] - #[doc = " This function slices the input vectors in chunks smaller than"] - #[doc = " blocksize_add and calls add_core."] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param x input matrix, size n * d"] + #[doc = " Add n vectors of dimension d to the index.\n\n Vectors are implicitly assigned labels ntotal .. ntotal + n - 1\n This function slices the input vectors in chunks smaller than\n blocksize_add and calls add_core.\n @param index opaque pointer to index object\n @param x input matrix, size n * d"] pub fn faiss_Index_add( index: *mut FaissIndex, n: idx_t, @@ -88,13 +91,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Same as add, but stores xids instead of sequential ids."] - #[doc = ""] - #[doc = " The default implementation fails with an assertion, as it is"] - #[doc = " not supported by all indexes."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param xids if non-null, ids to store for the vectors (size n)"] + #[doc = " Same as add, but stores xids instead of sequential ids.\n\n The default implementation fails with an assertion, as it is\n not supported by all indexes.\n\n @param index opaque pointer to index object\n @param xids if non-null, ids to store for the vectors (size n)"] pub fn faiss_Index_add_with_ids( index: *mut FaissIndex, n: idx_t, @@ -103,15 +100,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " query n vectors of dimension d to the index."] - #[doc = ""] - #[doc = " return at most k vectors. If there are not enough results for a"] - #[doc = " query, the result array is padded with -1s."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param x input vectors to search, size n * d"] - #[doc = " @param labels output labels of the NNs, size n*k"] - #[doc = " @param distances output pairwise distances, size n*k"] + #[doc = " query n vectors of dimension d to the index.\n\n return at most k vectors. If there are not enough results for a\n query, the result array is padded with -1s.\n\n @param index opaque pointer to index object\n @param x input vectors to search, size n * d\n @param labels output labels of the NNs, size n*k\n @param distances output pairwise distances, size n*k"] pub fn faiss_Index_search( index: *const FaissIndex, n: idx_t, @@ -122,16 +111,19 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " query n vectors of dimension d to the index."] - #[doc = ""] - #[doc = " return all vectors with distance < radius. Note that many"] - #[doc = " indexes do not implement the range_search (only the k-NN search"] - #[doc = " is mandatory)."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param x input vectors to search, size n * d"] - #[doc = " @param radius search radius"] - #[doc = " @param result result table"] + #[doc = " query n vectors of dimension d with search parameters to the index.\n\n return at most k vectors. If there are not enough results for a query,\n the result is padded with -1s.\n\n @param index opaque pointer to index object\n @param x input vectors to search, size n * d\n @param params input params to modify how search is done\n @param labels output labels of the NNs, size n*k\n @param distances output pairwise distances, size n*k"] + pub fn faiss_Index_search_with_params( + index: *const FaissIndex, + n: idx_t, + x: *const f32, + k: idx_t, + params: *const FaissSearchParameters, + distances: *mut f32, + labels: *mut idx_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " query n vectors of dimension d to the index.\n\n return all vectors with distance < radius. Note that many\n indexes do not implement the range_search (only the k-NN search\n is mandatory).\n\n @param index opaque pointer to index object\n @param x input vectors to search, size n * d\n @param radius search radius\n @param result result table"] pub fn faiss_Index_range_search( index: *const FaissIndex, n: idx_t, @@ -141,12 +133,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " return the indexes of the k vectors closest to the query x."] - #[doc = ""] - #[doc = " This function is identical as search but only return labels of neighbors."] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param x input vectors to search, size n * d"] - #[doc = " @param labels output labels of the NNs, size n*k"] + #[doc = " return the indexes of the k vectors closest to the query x.\n\n This function is identical as search but only return labels of neighbors.\n @param index opaque pointer to index object\n @param x input vectors to search, size n * d\n @param labels output labels of the NNs, size n*k"] pub fn faiss_Index_assign( index: *mut FaissIndex, n: idx_t, @@ -156,14 +143,11 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " removes all elements from the database."] - #[doc = " @param index opaque pointer to index object"] + #[doc = " removes all elements from the database.\n @param index opaque pointer to index object"] pub fn faiss_Index_reset(index: *mut FaissIndex) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " removes IDs from the index. Not supported by all indexes"] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param nremove output for the number of IDs removed"] + #[doc = " removes IDs from the index. Not supported by all indexes\n @param index opaque pointer to index object\n @param nremove output for the number of IDs removed"] pub fn faiss_Index_remove_ids( index: *mut FaissIndex, sel: *const FaissIDSelector, @@ -171,12 +155,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Reconstruct a stored vector (or an approximation if lossy coding)"] - #[doc = ""] - #[doc = " this function may not be defined for some indexes"] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param key id of the vector to reconstruct"] - #[doc = " @param recons reconstructed vector (size d)"] + #[doc = " Reconstruct a stored vector (or an approximation if lossy coding)\n\n this function may not be defined for some indexes\n @param index opaque pointer to index object\n @param key id of the vector to reconstruct\n @param recons reconstructed vector (size d)"] pub fn faiss_Index_reconstruct( index: *const FaissIndex, key: idx_t, @@ -184,11 +163,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Reconstruct vectors i0 to i0 + ni - 1"] - #[doc = ""] - #[doc = " this function may not be defined for some indexes"] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param recons reconstructed vector (size ni * d)"] + #[doc = " Reconstruct vectors i0 to i0 + ni - 1\n\n this function may not be defined for some indexes\n @param index opaque pointer to index object\n @param recons reconstructed vector (size ni * d)"] pub fn faiss_Index_reconstruct_n( index: *const FaissIndex, i0: idx_t, @@ -197,17 +172,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Computes a residual vector after indexing encoding."] - #[doc = ""] - #[doc = " The residual vector is the difference between a vector and the"] - #[doc = " reconstruction that can be decoded from its representation in"] - #[doc = " the index. The residual can be used for multiple-stage indexing"] - #[doc = " methods, like IndexIVF's methods."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param x input vector, size d"] - #[doc = " @param residual output residual vector, size d"] - #[doc = " @param key encoded index, as returned by search and assign"] + #[doc = " Computes a residual vector after indexing encoding.\n\n The residual vector is the difference between a vector and the\n reconstruction that can be decoded from its representation in\n the index. The residual can be used for multiple-stage indexing\n methods, like IndexIVF's methods.\n\n @param index opaque pointer to index object\n @param x input vector, size d\n @param residual output residual vector, size d\n @param key encoded index, as returned by search and assign"] pub fn faiss_Index_compute_residual( index: *const FaissIndex, x: *const f32, @@ -216,18 +181,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Computes a residual vector after indexing encoding."] - #[doc = ""] - #[doc = " The residual vector is the difference between a vector and the"] - #[doc = " reconstruction that can be decoded from its representation in"] - #[doc = " the index. The residual can be used for multiple-stage indexing"] - #[doc = " methods, like IndexIVF's methods."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param n number of vectors"] - #[doc = " @param x input vector, size (n x d)"] - #[doc = " @param residuals output residual vectors, size (n x d)"] - #[doc = " @param keys encoded index, as returned by search and assign"] + #[doc = " Computes a residual vector after indexing encoding.\n\n The residual vector is the difference between a vector and the\n reconstruction that can be decoded from its representation in\n the index. The residual can be used for multiple-stage indexing\n methods, like IndexIVF's methods.\n\n @param index opaque pointer to index object\n @param n number of vectors\n @param x input vector, size (n x d)\n @param residuals output residual vectors, size (n x d)\n @param keys encoded index, as returned by search and assign"] pub fn faiss_Index_compute_residual_n( index: *const FaissIndex, n: idx_t, @@ -236,6 +190,31 @@ extern "C" { keys: *const idx_t, ) -> ::std::os::raw::c_int; } +extern "C" { + #[doc = " The size of the produced codes in bytes.\n\n @param index opaque pointer to index object\n @param size the returned size in bytes"] + pub fn faiss_Index_sa_code_size( + index: *const FaissIndex, + size: *mut usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " encode a set of vectors\n\n @param index opaque pointer to index object\n @param n number of vectors\n @param x input vectors, size n * d\n @param bytes output encoded vectors, size n * sa_code_size()"] + pub fn faiss_Index_sa_encode( + index: *const FaissIndex, + n: idx_t, + x: *const f32, + bytes: *mut u8, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " decode a set of vectors\n\n @param index opaque pointer to index object\n @param n number of vectors\n @param bytes input encoded vectors, size n * sa_code_size()\n @param x output vectors, size n * d"] + pub fn faiss_Index_sa_decode( + index: *const FaissIndex, + n: idx_t, + bytes: *const u8, + x: *mut f32, + ) -> ::std::os::raw::c_int; +} #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct FaissParameterRange_H { @@ -248,8 +227,7 @@ extern "C" { ) -> *const ::std::os::raw::c_char; } extern "C" { - #[doc = " Getter for the values in the range. The output values are invalidated"] - #[doc = " upon any other modification of the range."] + #[doc = " Getter for the values in the range. The output values are invalidated\n upon any other modification of the range."] pub fn faiss_ParameterRange_values( arg1: *mut FaissParameterRange, arg2: *mut *mut f64, @@ -274,9 +252,7 @@ extern "C" { pub fn faiss_ParameterSpace_n_combinations(arg1: *const FaissParameterSpace) -> usize; } extern "C" { - #[doc = " get string representation of the combination"] - #[doc = " by writing it to the given character buffer."] - #[doc = " A buffer size of 1000 ensures that the full name is collected."] + #[doc = " get string representation of the combination\n by writing it to the given character buffer.\n A buffer size of 1000 ensures that the full name is collected."] pub fn faiss_ParameterSpace_combination_name( arg1: *const FaissParameterSpace, arg2: usize, @@ -321,8 +297,15 @@ extern "C" { arg3: *mut *mut FaissParameterRange, ) -> ::std::os::raw::c_int; } -#[doc = " Class for the clustering parameters. Can be passed to the"] -#[doc = " constructor of the Clustering object."] +pub type FILE = [u64; 27usize]; +extern "C" { + #[doc = " Clone an index. This is equivalent to `faiss::clone_index`"] + pub fn faiss_clone_index( + arg1: *const FaissIndex, + p_out: *mut *mut FaissIndex, + ) -> ::std::os::raw::c_int; +} +#[doc = " Class for the clustering parameters. Can be passed to the\n constructor of the Clustering object."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct FaissClusteringParameters { @@ -338,8 +321,7 @@ pub struct FaissClusteringParameters { pub int_centroids: ::std::os::raw::c_int, #[doc = "< (bool) update index after each iteration?"] pub update_index: ::std::os::raw::c_int, - #[doc = "< (bool) use the centroids provided as input and do"] - #[doc = "< not change them during iterations"] + #[doc = "< (bool) use the centroids provided as input and do\n< not change them during iterations"] pub frozen_centroids: ::std::os::raw::c_int, #[doc = "< otherwise you get a warning"] pub min_points_per_centroid: ::std::os::raw::c_int, @@ -352,6 +334,9 @@ pub struct FaissClusteringParameters { } #[test] fn bindgen_test_layout_FaissClusteringParameters() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 48usize, @@ -363,7 +348,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { concat!("Alignment of ", stringify!(FaissClusteringParameters)) ); assert_eq!( - unsafe { &(*(::std::ptr::null::())).niter as *const _ as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).niter) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", @@ -373,7 +358,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { &(*(::std::ptr::null::())).nredo as *const _ as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).nredo) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", @@ -383,9 +368,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).verbose as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).verbose) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", @@ -395,9 +378,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).spherical as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).spherical) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", @@ -407,9 +388,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).int_centroids as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).int_centroids) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", @@ -419,9 +398,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_index as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).update_index) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", @@ -431,10 +408,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).frozen_centroids as *const _ - as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).frozen_centroids) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", @@ -444,10 +418,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).min_points_per_centroid - as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).min_points_per_centroid) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", @@ -457,10 +428,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).max_points_per_centroid - as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).max_points_per_centroid) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", @@ -470,7 +438,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { &(*(::std::ptr::null::())).seed as *const _ as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).seed) as usize - ptr as usize }, 36usize, concat!( "Offset of field: ", @@ -480,10 +448,7 @@ fn bindgen_test_layout_FaissClusteringParameters() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).decode_block_size as *const _ - as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).decode_block_size) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", @@ -618,15 +583,7 @@ extern "C" { pub fn faiss_Clustering_free(clustering: *mut FaissClustering); } extern "C" { - #[doc = " simplified interface"] - #[doc = ""] - #[doc = " @param d dimension of the data"] - #[doc = " @param n nb of training vectors"] - #[doc = " @param k nb of output centroids"] - #[doc = " @param x training set (size n * d)"] - #[doc = " @param centroids output centroids (size k * d)"] - #[doc = " @param q_error final quantization error"] - #[doc = " @return error code"] + #[doc = " simplified interface\n\n @param d dimension of the data\n @param n nb of training vectors\n @param k nb of output centroids\n @param x training set (size n * d)\n @param centroids output centroids (size k * d)\n @param q_error final quantization error\n @return error code"] pub fn faiss_kmeans_clustering( d: usize, n: usize, @@ -636,221 +593,680 @@ extern "C" { q_error: *mut f32, ) -> ::std::os::raw::c_int; } -pub type FaissIndexFlat = FaissIndex_H; +#[doc = " No error"] +pub const FaissErrorCode_OK: FaissErrorCode = 0; +#[doc = " Any exception other than Faiss or standard C++ library exceptions"] +pub const FaissErrorCode_UNKNOWN_EXCEPT: FaissErrorCode = -1; +#[doc = " Faiss library exception"] +pub const FaissErrorCode_FAISS_EXCEPT: FaissErrorCode = -2; +#[doc = " Standard C++ library exception"] +pub const FaissErrorCode_STD_EXCEPT: FaissErrorCode = -4; +#[doc = " An error code which depends on the exception thrown from the previous\n operation. See `faiss_get_last_error` to retrieve the error message."] +pub type FaissErrorCode = ::std::os::raw::c_int; extern "C" { - #[doc = " Opaque type for IndexFlat"] - pub fn faiss_IndexFlat_new(p_index: *mut *mut FaissIndexFlat) -> ::std::os::raw::c_int; + #[doc = " Get the error message of the last failed operation performed by Faiss.\n The given pointer is only invalid until another Faiss function is\n called."] + pub fn faiss_get_last_error() -> *const ::std::os::raw::c_char; } extern "C" { - pub fn faiss_IndexFlat_new_with( - p_index: *mut *mut FaissIndexFlat, - d: idx_t, - metric: FaissMetricType, + pub fn faiss_RangeSearchResult_nq(arg1: *const FaissRangeSearchResult) -> usize; +} +extern "C" { + pub fn faiss_RangeSearchResult_new( + p_rsr: *mut *mut FaissRangeSearchResult, + nq: idx_t, ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " get a pointer to the index's internal data (the `xb` field). The outputs"] - #[doc = " become invalid after any data addition or removal operation."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param p_xb output, the pointer to the beginning of `xb`."] - #[doc = " @param p_size output, the current size of `sb` in number of float values."] - pub fn faiss_IndexFlat_xb(index: *mut FaissIndexFlat, p_xb: *mut *mut f32, p_size: *mut usize); + pub fn faiss_RangeSearchResult_new_with( + p_rsr: *mut *mut FaissRangeSearchResult, + nq: idx_t, + alloc_lims: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IndexFlat_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlat; + #[doc = " called when lims contains the nb of elements result entries\n for each query"] + pub fn faiss_RangeSearchResult_do_allocation( + rsr: *mut FaissRangeSearchResult, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IndexFlat_free(obj: *mut FaissIndexFlat); + pub fn faiss_RangeSearchResult_free(obj: *mut FaissRangeSearchResult); } extern "C" { - #[doc = " compute distance with a subset of vectors"] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param x query vectors, size n * d"] - #[doc = " @param labels indices of the vectors that should be compared"] - #[doc = " for each query vector, size n * k"] - #[doc = " @param distances"] - #[doc = " corresponding output distances, size n * k"] - pub fn faiss_IndexFlat_compute_distance_subset( - index: *mut FaissIndex, - n: idx_t, - x: *const f32, - k: idx_t, - distances: *mut f32, - labels: *const idx_t, - ) -> ::std::os::raw::c_int; + pub fn faiss_RangeSearchResult_buffer_size(arg1: *const FaissRangeSearchResult) -> usize; } -pub type FaissIndexFlatIP = FaissIndex_H; extern "C" { - pub fn faiss_IndexFlatIP_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlatIP; + #[doc = " getter for lims: size (nq + 1)"] + pub fn faiss_RangeSearchResult_lims(rsr: *mut FaissRangeSearchResult, lims: *mut *mut usize); } extern "C" { - pub fn faiss_IndexFlatIP_free(obj: *mut FaissIndexFlatIP); + #[doc = " getter for labels and respective distances (not sorted):\n result for query i is labels[lims[i]:lims[i+1]]"] + pub fn faiss_RangeSearchResult_labels( + rsr: *mut FaissRangeSearchResult, + labels: *mut *mut idx_t, + distances: *mut *mut f32, + ); } extern "C" { - #[doc = " Opaque type for IndexFlatIP"] - pub fn faiss_IndexFlatIP_new(p_index: *mut *mut FaissIndexFlatIP) -> ::std::os::raw::c_int; + pub fn faiss_IDSelector_free(obj: *mut FaissIDSelector); } extern "C" { - pub fn faiss_IndexFlatIP_new_with( - p_index: *mut *mut FaissIndexFlatIP, - d: idx_t, + #[doc = " Encapsulates a set of ids to remove."] + pub fn faiss_IDSelector_is_member( + sel: *const FaissIDSelector, + id: idx_t, ) -> ::std::os::raw::c_int; } -pub type FaissIndexFlatL2 = FaissIndex_H; -extern "C" { - pub fn faiss_IndexFlatL2_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlatL2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissIDSelectorRange_H { + _unused: [u8; 0], } +pub type FaissIDSelectorRange = FaissIDSelectorRange_H; extern "C" { - pub fn faiss_IndexFlatL2_free(obj: *mut FaissIndexFlatL2); + pub fn faiss_IDSelectorRange_free(obj: *mut FaissIDSelectorRange); } extern "C" { - #[doc = " Opaque type for IndexFlatL2"] - pub fn faiss_IndexFlatL2_new(p_index: *mut *mut FaissIndexFlatL2) -> ::std::os::raw::c_int; + pub fn faiss_IDSelectorRange_imin(arg1: *const FaissIDSelectorRange) -> idx_t; } extern "C" { - pub fn faiss_IndexFlatL2_new_with( - p_index: *mut *mut FaissIndexFlatL2, - d: idx_t, - ) -> ::std::os::raw::c_int; + pub fn faiss_IDSelectorRange_imax(arg1: *const FaissIDSelectorRange) -> idx_t; } -pub type FaissIndexRefineFlat = FaissIndex_H; extern "C" { - #[doc = " Opaque type for IndexRefineFlat"] - #[doc = ""] - #[doc = " Index that queries in a base_index (a fast one) and refines the"] - #[doc = " results with an exact search, hopefully improving the results."] - pub fn faiss_IndexRefineFlat_new( - p_index: *mut *mut FaissIndexRefineFlat, - base_index: *mut FaissIndex, + #[doc = " remove ids between [imni, imax)"] + pub fn faiss_IDSelectorRange_new( + p_sel: *mut *mut FaissIDSelectorRange, + imin: idx_t, + imax: idx_t, ) -> ::std::os::raw::c_int; } -extern "C" { - pub fn faiss_IndexRefineFlat_free(obj: *mut FaissIndexRefineFlat); +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissIDSelectorBatch_H { + _unused: [u8; 0], } +pub type FaissIDSelectorBatch = FaissIDSelectorBatch_H; extern "C" { - pub fn faiss_IndexRefineFlat_cast(arg1: *mut FaissIndex) -> *mut FaissIndexRefineFlat; + pub fn faiss_IDSelectorBatch_nbits(arg1: *const FaissIDSelectorBatch) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IndexRefineFlat_own_fields( - arg1: *const FaissIndexRefineFlat, - ) -> ::std::os::raw::c_int; + pub fn faiss_IDSelectorBatch_mask(arg1: *const FaissIDSelectorBatch) -> idx_t; } extern "C" { - pub fn faiss_IndexRefineFlat_set_own_fields( - arg1: *mut FaissIndexRefineFlat, - arg2: ::std::os::raw::c_int, - ); + #[doc = " Remove ids from a set. Repetitions of ids in the indices set\n passed to the constructor does not hurt performance. The hash\n function used for the bloom filter and GCC's implementation of\n unordered_set are just the least significant bits of the id. This\n works fine for random ids or ids in sequences but will produce many\n hash collisions if lsb's are always the same"] + pub fn faiss_IDSelectorBatch_new( + p_sel: *mut *mut FaissIDSelectorBatch, + n: usize, + indices: *const idx_t, + ) -> ::std::os::raw::c_int; } -extern "C" { - pub fn faiss_IndexRefineFlat_k_factor(arg1: *const FaissIndexRefineFlat) -> f32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissIDSelectorNot_H { + _unused: [u8; 0], } +pub type FaissIDSelectorNot = FaissIDSelectorNot_H; extern "C" { - pub fn faiss_IndexRefineFlat_set_k_factor(arg1: *mut FaissIndexRefineFlat, arg2: f32); + pub fn faiss_IDSelectorNot_new( + p_sel: *mut *mut FaissIDSelectorNot, + sel: *const FaissIDSelector, + ) -> ::std::os::raw::c_int; } -pub type FaissIndexFlat1D = FaissIndex_H; -extern "C" { - pub fn faiss_IndexFlat1D_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlat1D; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissIDSelectorAnd_H { + _unused: [u8; 0], } +pub type FaissIDSelectorAnd = FaissIDSelectorAnd_H; extern "C" { - pub fn faiss_IndexFlat1D_free(obj: *mut FaissIndexFlat1D); + pub fn faiss_IDSelectorAnd_new( + p_sel: *mut *mut FaissIDSelectorAnd, + lhs_sel: *const FaissIDSelector, + rhs_sel: *const FaissIDSelector, + ) -> ::std::os::raw::c_int; } -extern "C" { - #[doc = " Opaque type for IndexFlat1D"] - #[doc = ""] - #[doc = " optimized version for 1D \"vectors\""] - pub fn faiss_IndexFlat1D_new(p_index: *mut *mut FaissIndexFlat1D) -> ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissIDSelectorOr_H { + _unused: [u8; 0], } +pub type FaissIDSelectorOr = FaissIDSelectorOr_H; extern "C" { - pub fn faiss_IndexFlat1D_new_with( - p_index: *mut *mut FaissIndexFlat1D, - continuous_update: ::std::os::raw::c_int, + pub fn faiss_IDSelectorOr_new( + p_sel: *mut *mut FaissIDSelectorOr, + lhs_sel: *const FaissIDSelector, + rhs_sel: *const FaissIDSelector, ) -> ::std::os::raw::c_int; } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissIDSelectorXOr_H { + _unused: [u8; 0], +} +pub type FaissIDSelectorXOr = FaissIDSelectorXOr_H; extern "C" { - pub fn faiss_IndexFlat1D_update_permutation( - index: *mut FaissIndexFlat1D, + pub fn faiss_IDSelectorXOr_new( + p_sel: *mut *mut FaissIDSelectorXOr, + lhs_sel: *const FaissIDSelector, + rhs_sel: *const FaissIDSelector, ) -> ::std::os::raw::c_int; } -pub type FaissIndexIVFFlat = FaissIndex_H; -extern "C" { - pub fn faiss_IndexIVFFlat_free(obj: *mut FaissIndexIVFFlat); +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissBufferList_H { + _unused: [u8; 0], } +pub type FaissBufferList = FaissBufferList_H; extern "C" { - pub fn faiss_IndexIVFFlat_cast(arg1: *mut FaissIndex) -> *mut FaissIndexIVFFlat; + pub fn faiss_BufferList_free(obj: *mut FaissBufferList); } extern "C" { - pub fn faiss_IndexIVFFlat_nlist(arg1: *const FaissIndexIVFFlat) -> usize; + pub fn faiss_BufferList_buffer_size(arg1: *const FaissBufferList) -> usize; } extern "C" { - pub fn faiss_IndexIVFFlat_nprobe(arg1: *const FaissIndexIVFFlat) -> usize; + pub fn faiss_BufferList_wp(arg1: *const FaissBufferList) -> usize; } -extern "C" { - pub fn faiss_IndexIVFFlat_set_nprobe(arg1: *mut FaissIndexIVFFlat, arg2: usize); +#[doc = " List of temporary buffers used to store results before they are\n copied to the RangeSearchResult object."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissBuffer { + pub ids: *mut idx_t, + pub dis: *mut f32, +} +#[test] +fn bindgen_test_layout_FaissBuffer() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(FaissBuffer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(FaissBuffer)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ids) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(FaissBuffer), + "::", + stringify!(ids) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).dis) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(FaissBuffer), + "::", + stringify!(dis) + ) + ); } extern "C" { - pub fn faiss_IndexIVFFlat_quantizer(arg1: *const FaissIndexIVFFlat) -> *mut FaissIndex; + pub fn faiss_BufferList_append_buffer(bl: *mut FaissBufferList) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IndexIVFFlat_quantizer_trains_alone( - arg1: *const FaissIndexIVFFlat, - ) -> ::std::os::raw::c_char; + pub fn faiss_BufferList_new( + p_bl: *mut *mut FaissBufferList, + buffer_size: usize, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IndexIVFFlat_own_fields(arg1: *const FaissIndexIVFFlat) -> ::std::os::raw::c_int; + pub fn faiss_BufferList_add( + bl: *mut FaissBufferList, + id: idx_t, + dis: f32, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IndexIVFFlat_set_own_fields( - arg1: *mut FaissIndexIVFFlat, - arg2: ::std::os::raw::c_int, - ); + #[doc = " copy elemnts ofs:ofs+n-1 seen as linear data in the buffers to\n tables dest_ids, dest_dis"] + pub fn faiss_BufferList_copy_range( + bl: *mut FaissBufferList, + ofs: usize, + n: usize, + dest_ids: *mut idx_t, + dest_dis: *mut f32, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissRangeSearchPartialResult_H { + _unused: [u8; 0], } +pub type FaissRangeSearchPartialResult = FaissRangeSearchPartialResult_H; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissRangeQueryResult_H { + _unused: [u8; 0], +} +pub type FaissRangeQueryResult = FaissRangeQueryResult_H; extern "C" { - #[doc = " whether object owns the quantizer"] - pub fn faiss_IndexIVFFlat_new(p_index: *mut *mut FaissIndexIVFFlat) -> ::std::os::raw::c_int; + pub fn faiss_RangeQueryResult_qno(arg1: *const FaissRangeQueryResult) -> idx_t; } extern "C" { - pub fn faiss_IndexIVFFlat_new_with( - p_index: *mut *mut FaissIndexIVFFlat, - quantizer: *mut FaissIndex, - d: usize, - nlist: usize, + pub fn faiss_RangeQueryResult_nres(arg1: *const FaissRangeQueryResult) -> usize; +} +extern "C" { + pub fn faiss_RangeQueryResult_pres( + arg1: *const FaissRangeQueryResult, + ) -> *mut FaissRangeSearchPartialResult; +} +extern "C" { + #[doc = " result structure for a single query"] + pub fn faiss_RangeQueryResult_add( + qr: *mut FaissRangeQueryResult, + dis: f32, + id: idx_t, ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IndexIVFFlat_new_with_metric( - p_index: *mut *mut FaissIndexIVFFlat, - quantizer: *mut FaissIndex, - d: usize, - nlist: usize, + pub fn faiss_RangeSearchPartialResult_res( + arg1: *const FaissRangeSearchPartialResult, + ) -> *mut FaissRangeSearchResult; +} +extern "C" { + pub fn faiss_RangeSearchPartialResult_new( + p_res: *mut *mut FaissRangeSearchPartialResult, + res_in: *mut FaissRangeSearchResult, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_RangeSearchPartialResult_finalize( + res: *mut FaissRangeSearchPartialResult, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " called by range_search before do_allocation"] + pub fn faiss_RangeSearchPartialResult_set_lims( + res: *mut FaissRangeSearchPartialResult, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_RangeSearchPartialResult_new_result( + res: *mut FaissRangeSearchPartialResult, + qno: idx_t, + qr: *mut *mut FaissRangeQueryResult, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissDistanceComputer_H { + _unused: [u8; 0], +} +pub type FaissDistanceComputer = FaissDistanceComputer_H; +extern "C" { + #[doc = " called before computing distances"] + pub fn faiss_DistanceComputer_set_query( + dc: *mut FaissDistanceComputer, + x: *const f32, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Compute distance of vector i to current query.\n This function corresponds to the function call operator:\n DistanceComputer::operator()"] + pub fn faiss_DistanceComputer_vector_to_query_dis( + dc: *mut FaissDistanceComputer, + i: idx_t, + qd: *mut f32, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " compute distance between two stored vectors"] + pub fn faiss_DistanceComputer_symmetric_dis( + dc: *mut FaissDistanceComputer, + i: idx_t, + j: idx_t, + vd: *mut f32, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_DistanceComputer_free(obj: *mut FaissDistanceComputer); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct FaissIndexBinary_H { + _unused: [u8; 0], +} +pub type FaissIndexBinary = FaissIndexBinary_H; +extern "C" { + pub fn faiss_IndexBinary_free(obj: *mut FaissIndexBinary); +} +extern "C" { + pub fn faiss_IndexBinary_d(arg1: *const FaissIndexBinary) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexBinary_is_trained(arg1: *const FaissIndexBinary) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexBinary_ntotal(arg1: *const FaissIndexBinary) -> idx_t; +} +extern "C" { + pub fn faiss_IndexBinary_metric_type(arg1: *const FaissIndexBinary) -> FaissMetricType; +} +extern "C" { + pub fn faiss_IndexBinary_verbose(arg1: *const FaissIndexBinary) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexBinary_set_verbose(arg1: *mut FaissIndexBinary, arg2: ::std::os::raw::c_int); +} +extern "C" { + #[doc = " Perform training on a representative set of vectors\n\n @param index opaque pointer to index object\n @param n nb of training vectors\n @param x training vectors, size n * d"] + pub fn faiss_IndexBinary_train( + index: *mut FaissIndexBinary, + n: idx_t, + x: *const u8, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Add n vectors of dimension d to the index.\n\n Vectors are implicitly assigned labels ntotal .. ntotal + n - 1\n This function slices the input vectors in chunks smaller than\n blocksize_add and calls add_core.\n @param index opaque pointer to index object\n @param x input matrix, size n * d"] + pub fn faiss_IndexBinary_add( + index: *mut FaissIndexBinary, + n: idx_t, + x: *const u8, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Same as add, but stores xids instead of sequential ids.\n\n The default implementation fails with an assertion, as it is\n not supported by all indexes.\n\n @param index opaque pointer to index object\n @param xids if non-null, ids to store for the vectors (size n)"] + pub fn faiss_IndexBinary_add_with_ids( + index: *mut FaissIndexBinary, + n: idx_t, + x: *const u8, + xids: *const idx_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " query n vectors of dimension d to the index.\n\n return at most k vectors. If there are not enough results for a\n query, the result array is padded with -1s.\n\n @param index opaque pointer to index object\n @param x input vectors to search, size n * d\n @param labels output labels of the NNs, size n*k\n @param distances output pairwise distances, size n*k"] + pub fn faiss_IndexBinary_search( + index: *const FaissIndexBinary, + n: idx_t, + x: *const u8, + k: idx_t, + distances: *mut i32, + labels: *mut idx_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " query n vectors of dimension d to the index.\n\n return all vectors with distance < radius. Note that many\n indexes do not implement the range_search (only the k-NN search\n is mandatory).\n\n @param index opaque pointer to index object\n @param x input vectors to search, size n * d\n @param radius search radius\n @param result result table"] + pub fn faiss_IndexBinary_range_search( + index: *const FaissIndexBinary, + n: idx_t, + x: *const u8, + radius: ::std::os::raw::c_int, + result: *mut FaissRangeSearchResult, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " return the indexes of the k vectors closest to the query x.\n\n This function is identical as search but only return labels of neighbors.\n @param index opaque pointer to index object\n @param x input vectors to search, size n * d\n @param labels output labels of the NNs, size n*k"] + pub fn faiss_IndexBinary_assign( + index: *mut FaissIndexBinary, + n: idx_t, + x: *const u8, + labels: *mut idx_t, + k: idx_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " removes all elements from the database.\n @param index opaque pointer to index object"] + pub fn faiss_IndexBinary_reset(index: *mut FaissIndexBinary) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " removes IDs from the index. Not supported by all indexes\n @param index opaque pointer to index object\n @param nremove output for the number of IDs removed"] + pub fn faiss_IndexBinary_remove_ids( + index: *mut FaissIndexBinary, + sel: *const FaissIDSelector, + n_removed: *mut usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Reconstruct a stored vector (or an approximation if lossy coding)\n\n this function may not be defined for some indexes\n @param index opaque pointer to index object\n @param key id of the vector to reconstruct\n @param recons reconstructed vector (size d)"] + pub fn faiss_IndexBinary_reconstruct( + index: *const FaissIndexBinary, + key: idx_t, + recons: *mut u8, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Reconstruct vectors i0 to i0 + ni - 1\n\n this function may not be defined for some indexes\n @param index opaque pointer to index object\n @param recons reconstructed vector (size ni * d)"] + pub fn faiss_IndexBinary_reconstruct_n( + index: *const FaissIndexBinary, + i0: idx_t, + ni: idx_t, + recons: *mut u8, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Build and index with the sequence of processing steps described in\n the string."] + pub fn faiss_index_factory( + p_index: *mut *mut FaissIndex, + d: ::std::os::raw::c_int, + description: *const ::std::os::raw::c_char, metric: FaissMetricType, ) -> ::std::os::raw::c_int; } +pub type FaissIndexFlat = FaissIndex_H; extern "C" { - pub fn faiss_IndexIVFFlat_add_core( - index: *mut FaissIndexIVFFlat, + #[doc = " Opaque type for IndexFlat"] + pub fn faiss_IndexFlat_new(p_index: *mut *mut FaissIndexFlat) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexFlat_new_with( + p_index: *mut *mut FaissIndexFlat, + d: idx_t, + metric: FaissMetricType, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " get a pointer to the index's internal data (the `xb` field). The outputs\n become invalid after any data addition or removal operation.\n\n @param index opaque pointer to index object\n @param p_xb output, the pointer to the beginning of `xb`.\n @param p_size output, the current size of `sb` in number of float values."] + pub fn faiss_IndexFlat_xb(index: *mut FaissIndexFlat, p_xb: *mut *mut f32, p_size: *mut usize); +} +extern "C" { + pub fn faiss_IndexFlat_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlat; +} +extern "C" { + pub fn faiss_IndexFlat_free(obj: *mut FaissIndexFlat); +} +extern "C" { + #[doc = " compute distance with a subset of vectors\n\n @param index opaque pointer to index object\n @param x query vectors, size n * d\n @param labels indices of the vectors that should be compared\n for each query vector, size n * k\n @param distances\n corresponding output distances, size n * k"] + pub fn faiss_IndexFlat_compute_distance_subset( + index: *mut FaissIndex, n: idx_t, x: *const f32, - xids: *const idx_t, - precomputed_idx: *const i64, + k: idx_t, + distances: *mut f32, + labels: *const idx_t, ) -> ::std::os::raw::c_int; } +pub type FaissIndexFlatIP = FaissIndex_H; extern "C" { - #[doc = " Update a subset of vectors."] - #[doc = ""] - #[doc = " The index must have a direct_map"] - #[doc = ""] - #[doc = " @param nv nb of vectors to update"] - #[doc = " @param idx vector indices to update, size nv"] - #[doc = " @param v vectors of new values, size nv*d"] - pub fn faiss_IndexIVFFlat_update_vectors( - index: *mut FaissIndexIVFFlat, - nv: ::std::os::raw::c_int, - idx: *mut idx_t, - v: *const f32, + pub fn faiss_IndexFlatIP_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlatIP; +} +extern "C" { + pub fn faiss_IndexFlatIP_free(obj: *mut FaissIndexFlatIP); +} +extern "C" { + #[doc = " Opaque type for IndexFlatIP"] + pub fn faiss_IndexFlatIP_new(p_index: *mut *mut FaissIndexFlatIP) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexFlatIP_new_with( + p_index: *mut *mut FaissIndexFlatIP, + d: idx_t, + ) -> ::std::os::raw::c_int; +} +pub type FaissIndexFlatL2 = FaissIndex_H; +extern "C" { + pub fn faiss_IndexFlatL2_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlatL2; +} +extern "C" { + pub fn faiss_IndexFlatL2_free(obj: *mut FaissIndexFlatL2); +} +extern "C" { + #[doc = " Opaque type for IndexFlatL2"] + pub fn faiss_IndexFlatL2_new(p_index: *mut *mut FaissIndexFlatL2) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexFlatL2_new_with( + p_index: *mut *mut FaissIndexFlatL2, + d: idx_t, + ) -> ::std::os::raw::c_int; +} +pub type FaissIndexRefineFlat = FaissIndex_H; +extern "C" { + #[doc = " Opaque type for IndexRefineFlat\n\n Index that queries in a base_index (a fast one) and refines the\n results with an exact search, hopefully improving the results."] + pub fn faiss_IndexRefineFlat_new( + p_index: *mut *mut FaissIndexRefineFlat, + base_index: *mut FaissIndex, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexRefineFlat_free(obj: *mut FaissIndexRefineFlat); +} +extern "C" { + pub fn faiss_IndexRefineFlat_cast(arg1: *mut FaissIndex) -> *mut FaissIndexRefineFlat; +} +extern "C" { + pub fn faiss_IndexRefineFlat_own_fields( + arg1: *const FaissIndexRefineFlat, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexRefineFlat_set_own_fields( + arg1: *mut FaissIndexRefineFlat, + arg2: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn faiss_IndexRefineFlat_k_factor(arg1: *const FaissIndexRefineFlat) -> f32; +} +extern "C" { + pub fn faiss_IndexRefineFlat_set_k_factor(arg1: *mut FaissIndexRefineFlat, arg2: f32); +} +pub type FaissIndexFlat1D = FaissIndex_H; +extern "C" { + pub fn faiss_IndexFlat1D_cast(arg1: *mut FaissIndex) -> *mut FaissIndexFlat1D; +} +extern "C" { + pub fn faiss_IndexFlat1D_free(obj: *mut FaissIndexFlat1D); +} +extern "C" { + #[doc = " Opaque type for IndexFlat1D\n\n optimized version for 1D \"vectors\""] + pub fn faiss_IndexFlat1D_new(p_index: *mut *mut FaissIndexFlat1D) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexFlat1D_new_with( + p_index: *mut *mut FaissIndexFlat1D, + continuous_update: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexFlat1D_update_permutation( + index: *mut FaissIndexFlat1D, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Write index to a file.\n This is equivalent to `faiss::write_index` when a file descriptor is\n provided."] + pub fn faiss_write_index(idx: *const FaissIndex, f: *mut FILE) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Write index to a file.\n This is equivalent to `faiss::write_index` when a file path is provided."] + pub fn faiss_write_index_fname( + idx: *const FaissIndex, + fname: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Read index from a file.\n This is equivalent to `faiss:read_index` when a file descriptor is given."] + pub fn faiss_read_index( + f: *mut FILE, + io_flags: ::std::os::raw::c_int, + p_out: *mut *mut FaissIndex, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Read index from a file.\n This is equivalent to `faiss:read_index` when a file path is given."] + pub fn faiss_read_index_fname( + fname: *const ::std::os::raw::c_char, + io_flags: ::std::os::raw::c_int, + p_out: *mut *mut FaissIndex, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Write index to a file.\n This is equivalent to `faiss::write_index_binary` when a file descriptor is\n provided."] + pub fn faiss_write_index_binary( + idx: *const FaissIndexBinary, + f: *mut FILE, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Write index to a file.\n This is equivalent to `faiss::write_index_binary` when a file path is\n provided."] + pub fn faiss_write_index_binary_fname( + idx: *const FaissIndexBinary, + fname: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Read index from a file.\n This is equivalent to `faiss:read_index_binary` when a file descriptor is\n given."] + pub fn faiss_read_index_binary( + f: *mut FILE, + io_flags: ::std::os::raw::c_int, + p_out: *mut *mut FaissIndexBinary, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[doc = " Read index from a file.\n This is equivalent to `faiss:read_index_binary` when a file path is given."] + pub fn faiss_read_index_binary_fname( + fname: *const ::std::os::raw::c_char, + io_flags: ::std::os::raw::c_int, + p_out: *mut *mut FaissIndexBinary, + ) -> ::std::os::raw::c_int; +} +pub type FaissSearchParametersIVF = FaissSearchParameters_H; +extern "C" { + pub fn faiss_SearchParametersIVF_free(obj: *mut FaissSearchParametersIVF); +} +extern "C" { + pub fn faiss_SearchParametersIVF_cast( + arg1: *mut FaissSearchParameters, + ) -> *mut FaissSearchParametersIVF; +} +extern "C" { + pub fn faiss_SearchParametersIVF_new( + p_sp: *mut *mut FaissSearchParametersIVF, ) -> ::std::os::raw::c_int; } +extern "C" { + pub fn faiss_SearchParametersIVF_new_with( + p_sp: *mut *mut FaissSearchParametersIVF, + sel: *mut FaissIDSelector, + nprobe: usize, + max_codes: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_SearchParametersIVF_sel( + arg1: *const FaissSearchParametersIVF, + ) -> *const FaissIDSelector; +} +extern "C" { + pub fn faiss_SearchParametersIVF_nprobe(arg1: *const FaissSearchParametersIVF) -> usize; +} +extern "C" { + pub fn faiss_SearchParametersIVF_set_nprobe(arg1: *mut FaissSearchParametersIVF, arg2: usize); +} +extern "C" { + pub fn faiss_SearchParametersIVF_max_codes(arg1: *const FaissSearchParametersIVF) -> usize; +} +extern "C" { + pub fn faiss_SearchParametersIVF_set_max_codes( + arg1: *mut FaissSearchParametersIVF, + arg2: usize, + ); +} pub type FaissIndexIVF = FaissIndex_H; extern "C" { pub fn faiss_IndexIVF_free(obj: *mut FaissIndexIVF); @@ -882,9 +1298,7 @@ extern "C" { pub fn faiss_IndexIVF_set_own_fields(arg1: *mut FaissIndexIVF, arg2: ::std::os::raw::c_int); } extern "C" { - #[doc = " moves the entries from another dataset to self. On output,"] - #[doc = " other is empty. add_id is added to all moved ids (for"] - #[doc = " sequential ids, this would be this->ntotal"] + #[doc = " moves the entries from another dataset to self. On output,\n other is empty. add_id is added to all moved ids (for\n sequential ids, this would be this->ntotal"] pub fn faiss_IndexIVF_merge_from( index: *mut FaissIndexIVF, other: *mut FaissIndexIVF, @@ -892,12 +1306,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " copy a subset of the entries index to the other index"] - #[doc = ""] - #[doc = " if subset_type == 0: copies ids in [a1, a2)"] - #[doc = " if subset_type == 1: copies ids if id % a1 == a2"] - #[doc = " if subset_type == 2: copies inverted lists such that a1"] - #[doc = " elements are left before and a2 elements are after"] + #[doc = " copy a subset of the entries index to the other index\n\n if subset_type == 0: copies ids in [a1, a2)\n if subset_type == 1: copies ids if id % a1 == a2\n if subset_type == 2: copies inverted lists such that a1\n elements are left before and a2 elements are after"] pub fn faiss_IndexIVF_copy_subset_to( index: *const FaissIndexIVF, other: *mut FaissIndexIVF, @@ -907,21 +1316,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " search a set of vectors, that are pre-quantized by the IVF"] - #[doc = " quantizer. Fill in the corresponding heaps with the query"] - #[doc = " results. search() calls this."] - #[doc = ""] - #[doc = " @param n nb of vectors to query"] - #[doc = " @param x query vectors, size nx * d"] - #[doc = " @param assign coarse quantization indices, size nx * nprobe"] - #[doc = " @param centroid_dis"] - #[doc = " distances to coarse centroids, size nx * nprobe"] - #[doc = " @param distance"] - #[doc = " output distances, size n * k"] - #[doc = " @param labels output labels, size n * k"] - #[doc = " @param store_pairs store inv list index + inv list offset"] - #[doc = " instead in upper/lower 32 bit of result,"] - #[doc = " instead of ids (used for reranking)."] + #[doc = " search a set of vectors, that are pre-quantized by the IVF\n quantizer. Fill in the corresponding heaps with the query\n results. search() calls this.\n\n @param n nb of vectors to query\n @param x query vectors, size nx * d\n @param assign coarse quantization indices, size nx * nprobe\n @param centroid_dis\n distances to coarse centroids, size nx * nprobe\n @param distance\n output distances, size n * k\n @param labels output labels, size n * k\n @param store_pairs store inv list index + inv list offset\n instead in upper/lower 32 bit of result,\n instead of ids (used for reranking)."] pub fn faiss_IndexIVF_search_preassigned( index: *const FaissIndexIVF, n: idx_t, @@ -938,19 +1333,14 @@ extern "C" { pub fn faiss_IndexIVF_get_list_size(index: *const FaissIndexIVF, list_no: usize) -> usize; } extern "C" { - #[doc = " initialize a direct map"] - #[doc = ""] - #[doc = " @param new_maintain_direct_map if true, create a direct map,"] - #[doc = " else clear it"] + #[doc = " initialize a direct map\n\n @param new_maintain_direct_map if true, create a direct map,\n else clear it"] pub fn faiss_IndexIVF_make_direct_map( index: *mut FaissIndexIVF, new_maintain_direct_map: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Check the inverted lists' imbalance factor."] - #[doc = ""] - #[doc = " 1= perfectly balanced, >1: imbalanced"] + #[doc = " Check the inverted lists' imbalance factor.\n\n 1= perfectly balanced, >1: imbalanced"] pub fn faiss_IndexIVF_imbalance_factor(index: *const FaissIndexIVF) -> f64; } extern "C" { @@ -958,20 +1348,21 @@ extern "C" { pub fn faiss_IndexIVF_print_stats(index: *const FaissIndexIVF); } extern "C" { - #[doc = " Get the IDs in an inverted list. IDs are written to `invlist`, which must be"] - #[doc = " large enough"] - #[doc = " to accommodate the full list."] - #[doc = ""] - #[doc = " @param list_no the list ID"] - #[doc = " @param invlist output pointer to a slice of memory, at least as long as the"] - #[doc = " list's size"] - #[doc = " @see faiss_IndexIVF_get_list_size(size_t)"] + #[doc = " Get the IDs in an inverted list. IDs are written to `invlist`, which must be\n large enough\n to accommodate the full list.\n\n @param list_no the list ID\n @param invlist output pointer to a slice of memory, at least as long as the\n list's size\n @see faiss_IndexIVF_get_list_size(size_t)"] pub fn faiss_IndexIVF_invlists_get_ids( index: *const FaissIndexIVF, list_no: usize, invlist: *mut idx_t, ); } +extern "C" { + pub fn faiss_IndexIVF_train_encoder( + index: *mut FaissIndexIVF, + n: idx_t, + x: *const f32, + assign: *const idx_t, + ) -> ::std::os::raw::c_int; +} #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct FaissIndexIVFStats { @@ -984,6 +1375,8 @@ pub struct FaissIndexIVFStats { } #[test] fn bindgen_test_layout_FaissIndexIVFStats() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 48usize, @@ -995,7 +1388,7 @@ fn bindgen_test_layout_FaissIndexIVFStats() { concat!("Alignment of ", stringify!(FaissIndexIVFStats)) ); assert_eq!( - unsafe { &(*(::std::ptr::null::())).nq as *const _ as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).nq) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", @@ -1005,7 +1398,7 @@ fn bindgen_test_layout_FaissIndexIVFStats() { ) ); assert_eq!( - unsafe { &(*(::std::ptr::null::())).nlist as *const _ as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).nlist) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", @@ -1015,7 +1408,7 @@ fn bindgen_test_layout_FaissIndexIVFStats() { ) ); assert_eq!( - unsafe { &(*(::std::ptr::null::())).ndis as *const _ as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).ndis) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", @@ -1025,9 +1418,7 @@ fn bindgen_test_layout_FaissIndexIVFStats() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nheap_updates as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).nheap_updates) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", @@ -1037,9 +1428,7 @@ fn bindgen_test_layout_FaissIndexIVFStats() { ) ); assert_eq!( - unsafe { - &(*(::std::ptr::null::())).quantization_time as *const _ as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).quantization_time) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", @@ -1049,7 +1438,7 @@ fn bindgen_test_layout_FaissIndexIVFStats() { ) ); assert_eq!( - unsafe { &(*(::std::ptr::null::())).search_time as *const _ as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).search_time) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", @@ -1060,11 +1449,83 @@ fn bindgen_test_layout_FaissIndexIVFStats() { ); } extern "C" { - pub fn faiss_IndexIVFStats_reset(stats: *mut FaissIndexIVFStats); + pub fn faiss_IndexIVFStats_reset(stats: *mut FaissIndexIVFStats); +} +extern "C" { + #[doc = " global var that collects all statists"] + pub fn faiss_get_indexIVF_stats() -> *mut FaissIndexIVFStats; +} +pub type FaissIndexIVFFlat = FaissIndex_H; +extern "C" { + pub fn faiss_IndexIVFFlat_free(obj: *mut FaissIndexIVFFlat); +} +extern "C" { + pub fn faiss_IndexIVFFlat_cast(arg1: *mut FaissIndex) -> *mut FaissIndexIVFFlat; +} +extern "C" { + pub fn faiss_IndexIVFFlat_nlist(arg1: *const FaissIndexIVFFlat) -> usize; +} +extern "C" { + pub fn faiss_IndexIVFFlat_nprobe(arg1: *const FaissIndexIVFFlat) -> usize; +} +extern "C" { + pub fn faiss_IndexIVFFlat_set_nprobe(arg1: *mut FaissIndexIVFFlat, arg2: usize); +} +extern "C" { + pub fn faiss_IndexIVFFlat_quantizer(arg1: *const FaissIndexIVFFlat) -> *mut FaissIndex; +} +extern "C" { + pub fn faiss_IndexIVFFlat_quantizer_trains_alone( + arg1: *const FaissIndexIVFFlat, + ) -> ::std::os::raw::c_char; +} +extern "C" { + pub fn faiss_IndexIVFFlat_own_fields(arg1: *const FaissIndexIVFFlat) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexIVFFlat_set_own_fields( + arg1: *mut FaissIndexIVFFlat, + arg2: ::std::os::raw::c_int, + ); +} +extern "C" { + #[doc = " whether object owns the quantizer"] + pub fn faiss_IndexIVFFlat_new(p_index: *mut *mut FaissIndexIVFFlat) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexIVFFlat_new_with( + p_index: *mut *mut FaissIndexIVFFlat, + quantizer: *mut FaissIndex, + d: usize, + nlist: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexIVFFlat_new_with_metric( + p_index: *mut *mut FaissIndexIVFFlat, + quantizer: *mut FaissIndex, + d: usize, + nlist: usize, + metric: FaissMetricType, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn faiss_IndexIVFFlat_add_core( + index: *mut FaissIndexIVFFlat, + n: idx_t, + x: *const f32, + xids: *const idx_t, + precomputed_idx: *const i64, + ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " global var that collects all statists"] - pub fn faiss_get_indexIVF_stats() -> *mut FaissIndexIVFStats; + #[doc = " Update a subset of vectors.\n\n The index must have a direct_map\n\n @param nv nb of vectors to update\n @param idx vector indices to update, size nv\n @param v vectors of new values, size nv*d"] + pub fn faiss_IndexIVFFlat_update_vectors( + index: *mut FaissIndexIVFFlat, + nv: ::std::os::raw::c_int, + idx: *mut idx_t, + v: *const f32, + ) -> ::std::os::raw::c_int; } pub type FaissIndexLSH = FaissIndex_H; extern "C" { @@ -1123,11 +1584,7 @@ extern "C" { pub fn faiss_VectorTransform_d_out(arg1: *const FaissVectorTransform) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Perform training on a representative set of vectors"] - #[doc = ""] - #[doc = " @param vt opaque pointer to VectorTransform object"] - #[doc = " @param n nb of training vectors"] - #[doc = " @param x training vectors, size n * d"] + #[doc = " Perform training on a representative set of vectors\n\n @param vt opaque pointer to VectorTransform object\n @param n nb of training vectors\n @param x training vectors, size n * d"] pub fn faiss_VectorTransform_train( vt: *mut FaissVectorTransform, n: idx_t, @@ -1135,9 +1592,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " apply the random rotation, return new allocated matrix"] - #[doc = " @param x size n * d_in"] - #[doc = " @return size n * d_out"] + #[doc = " apply the random rotation, return new allocated matrix\n @param x size n * d_in\n @return size n * d_out"] pub fn faiss_VectorTransform_apply( vt: *const FaissVectorTransform, n: idx_t, @@ -1145,9 +1600,7 @@ extern "C" { ) -> *mut f32; } extern "C" { - #[doc = " apply transformation and result is pre-allocated"] - #[doc = " @param x size n * d_in"] - #[doc = " @param xt size n * d_out"] + #[doc = " apply transformation and result is pre-allocated\n @param x size n * d_in\n @param xt size n * d_out"] pub fn faiss_VectorTransform_apply_noalloc( vt: *const FaissVectorTransform, n: idx_t, @@ -1156,8 +1609,7 @@ extern "C" { ); } extern "C" { - #[doc = " reverse transformation. May not be implemented or may return"] - #[doc = " approximate result"] + #[doc = " reverse transformation. May not be implemented or may return\n approximate result"] pub fn faiss_VectorTransform_reverse_transform( vt: *const FaissVectorTransform, n: idx_t, @@ -1170,8 +1622,7 @@ extern "C" { pub fn faiss_LinearTransform_free(obj: *mut FaissLinearTransform); } extern "C" { - #[doc = " compute x = A^T * (x - b)"] - #[doc = " is reverse transform if A has orthonormal lines"] + #[doc = " compute x = A^T * (x - b)\n is reverse transform if A has orthonormal lines"] pub fn faiss_LinearTransform_transform_transpose( vt: *const FaissLinearTransform, n: idx_t, @@ -1339,8 +1790,7 @@ extern "C" { ); } extern "C" { - #[doc = " Index that applies a LinearTransform transform on vectors before"] - #[doc = " handing them over to a sub-index"] + #[doc = " Index that applies a LinearTransform transform on vectors before\n handing them over to a sub-index"] pub fn faiss_IndexPreTransform_new( p_index: *mut *mut FaissIndexPreTransform, ) -> ::std::os::raw::c_int; @@ -1494,484 +1944,153 @@ extern "C" { ); } extern "C" { - pub fn faiss_IndexIVFScalarQuantizer_quantizer( - arg1: *const FaissIndexIVFScalarQuantizer, - ) -> *mut FaissIndex; -} -extern "C" { - pub fn faiss_IndexIVFScalarQuantizer_own_fields( - arg1: *const FaissIndexIVFScalarQuantizer, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexIVFScalarQuantizer_set_own_fields( - arg1: *mut FaissIndexIVFScalarQuantizer, - arg2: ::std::os::raw::c_int, - ); -} -extern "C" { - #[doc = " whether object owns the quantizer"] - pub fn faiss_IndexIVFScalarQuantizer_add_core( - index: *mut FaissIndexIVFScalarQuantizer, - n: idx_t, - x: *const f32, - xids: *const idx_t, - precomputed_idx: *const idx_t, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexIVFScalarQuantizer_train_residual( - index: *mut FaissIndexIVFScalarQuantizer, - n: idx_t, - x: *const f32, - ) -> ::std::os::raw::c_int; -} -pub type FaissIndexShards = FaissIndex_H; -extern "C" { - pub fn faiss_IndexShards_free(obj: *mut FaissIndexShards); -} -extern "C" { - pub fn faiss_IndexShards_own_fields(arg1: *const FaissIndexShards) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexShards_set_own_fields( - arg1: *mut FaissIndexShards, - arg2: ::std::os::raw::c_int, - ); -} -extern "C" { - pub fn faiss_IndexShards_successive_ids(arg1: *const FaissIndexShards) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexShards_set_successive_ids( - arg1: *mut FaissIndexShards, - arg2: ::std::os::raw::c_int, - ); -} -extern "C" { - #[doc = " Index that concatenates the results from several sub-indexes"] - pub fn faiss_IndexShards_new( - p_index: *mut *mut FaissIndexShards, - d: idx_t, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexShards_new_with_options( - p_index: *mut *mut FaissIndexShards, - d: idx_t, - threaded: ::std::os::raw::c_int, - successive_ids: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexShards_add_shard( - index: *mut FaissIndexShards, - shard: *mut FaissIndex, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexShards_remove_shard( - index: *mut FaissIndexShards, - shard: *mut FaissIndex, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexShards_at( - index: *mut FaissIndexShards, - i: ::std::os::raw::c_int, - ) -> *mut FaissIndex; -} -pub type FaissIndexIDMap = FaissIndex_H; -extern "C" { - pub fn faiss_IndexIDMap_own_fields(arg1: *const FaissIndexIDMap) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexIDMap_set_own_fields(arg1: *mut FaissIndexIDMap, arg2: ::std::os::raw::c_int); -} -extern "C" { - #[doc = " Index that translates search results to ids"] - pub fn faiss_IndexIDMap_new( - p_index: *mut *mut FaissIndexIDMap, - index: *mut FaissIndex, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexIDMap_cast(arg1: *mut FaissIndex) -> *mut FaissIndexIDMap; -} -extern "C" { - #[doc = " get a pointer to the index map's internal ID vector (the `id_map` field)."] - #[doc = " The outputs of this function become invalid after any operation that can"] - #[doc = " modify the index."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param p_id_map output, the pointer to the beginning of `id_map`."] - #[doc = " @param p_size output, the current length of `id_map`."] - pub fn faiss_IndexIDMap_id_map( - index: *mut FaissIndexIDMap, - p_id_map: *mut *mut idx_t, - p_size: *mut usize, - ); -} -extern "C" { - #[doc = " get a pointer to the sub-index (the `index` field)."] - #[doc = " The outputs of this function become invalid after any operation that can"] - #[doc = " modify the index."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - pub fn faiss_IndexIDMap_sub_index(index: *mut FaissIndexIDMap) -> *mut FaissIndex; -} -pub type FaissIndexIDMap2 = FaissIndex_H; -extern "C" { - pub fn faiss_IndexIDMap2_own_fields(arg1: *const FaissIndexIDMap2) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexIDMap2_set_own_fields( - arg1: *mut FaissIndexIDMap2, - arg2: ::std::os::raw::c_int, - ); -} -extern "C" { - #[doc = " same as IndexIDMap but also provides an efficient reconstruction"] - #[doc = "implementation via a 2-way index"] - pub fn faiss_IndexIDMap2_new( - p_index: *mut *mut FaissIndexIDMap2, - index: *mut FaissIndex, - ) -> ::std::os::raw::c_int; -} -extern "C" { - #[doc = " make the rev_map from scratch"] - pub fn faiss_IndexIDMap2_construct_rev_map( - index: *mut FaissIndexIDMap2, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_IndexIDMap2_cast(arg1: *mut FaissIndex) -> *mut FaissIndexIDMap2; -} -extern "C" { - #[doc = " get a pointer to the index map's internal ID vector (the `id_map` field)."] - #[doc = " The outputs of this function become invalid after any operation that can"] - #[doc = " modify the index."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - #[doc = " @param p_id_map output, the pointer to the beginning of `id_map`."] - #[doc = " @param p_size output, the current length of `id_map`."] - pub fn faiss_IndexIDMap2_id_map( - index: *mut FaissIndexIDMap2, - p_id_map: *mut *mut idx_t, - p_size: *mut usize, - ); -} -extern "C" { - #[doc = " get a pointer to the sub-index (the `index` field)."] - #[doc = " The outputs of this function become invalid after any operation that can"] - #[doc = " modify the index."] - #[doc = ""] - #[doc = " @param index opaque pointer to index object"] - pub fn faiss_IndexIDMap2_sub_index(index: *mut FaissIndexIDMap2) -> *mut FaissIndex; -} -pub type FILE = [u64; 27usize]; -extern "C" { - #[doc = " Clone an index. This is equivalent to `faiss::clone_index`"] - pub fn faiss_clone_index( - arg1: *const FaissIndex, - p_out: *mut *mut FaissIndex, - ) -> ::std::os::raw::c_int; -} -#[doc = " No error"] -pub const FaissErrorCode_OK: FaissErrorCode = 0; -#[doc = " Any exception other than Faiss or standard C++ library exceptions"] -pub const FaissErrorCode_UNKNOWN_EXCEPT: FaissErrorCode = -1; -#[doc = " Faiss library exception"] -pub const FaissErrorCode_FAISS_EXCEPT: FaissErrorCode = -2; -#[doc = " Standard C++ library exception"] -pub const FaissErrorCode_STD_EXCEPT: FaissErrorCode = -4; -#[doc = " An error code which depends on the exception thrown from the previous"] -#[doc = " operation. See `faiss_get_last_error` to retrieve the error message."] -pub type FaissErrorCode = ::std::os::raw::c_int; -extern "C" { - #[doc = " Get the error message of the last failed operation performed by Faiss."] - #[doc = " The given pointer is only invalid until another Faiss function is"] - #[doc = " called."] - pub fn faiss_get_last_error() -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn faiss_RangeSearchResult_nq(arg1: *const FaissRangeSearchResult) -> usize; -} -extern "C" { - pub fn faiss_RangeSearchResult_new( - p_rsr: *mut *mut FaissRangeSearchResult, - nq: idx_t, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_RangeSearchResult_new_with( - p_rsr: *mut *mut FaissRangeSearchResult, - nq: idx_t, - alloc_lims: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - #[doc = " called when lims contains the nb of elements result entries"] - #[doc = " for each query"] - pub fn faiss_RangeSearchResult_do_allocation( - rsr: *mut FaissRangeSearchResult, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn faiss_RangeSearchResult_free(obj: *mut FaissRangeSearchResult); -} -extern "C" { - pub fn faiss_RangeSearchResult_buffer_size(arg1: *const FaissRangeSearchResult) -> usize; -} -extern "C" { - #[doc = " getter for lims: size (nq + 1)"] - pub fn faiss_RangeSearchResult_lims(rsr: *mut FaissRangeSearchResult, lims: *mut *mut usize); -} -extern "C" { - #[doc = " getter for labels and respective distances (not sorted):"] - #[doc = " result for query i is labels[lims[i]:lims[i+1]]"] - pub fn faiss_RangeSearchResult_labels( - rsr: *mut FaissRangeSearchResult, - labels: *mut *mut idx_t, - distances: *mut *mut f32, - ); -} -extern "C" { - pub fn faiss_IDSelector_free(obj: *mut FaissIDSelector); -} -extern "C" { - #[doc = " Encapsulates a set of ids to remove."] - pub fn faiss_IDSelector_is_member( - sel: *const FaissIDSelector, - id: idx_t, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct FaissIDSelectorRange_H { - _unused: [u8; 0], -} -pub type FaissIDSelectorRange = FaissIDSelectorRange_H; -extern "C" { - pub fn faiss_IDSelectorRange_free(obj: *mut FaissIDSelectorRange); -} -extern "C" { - pub fn faiss_IDSelectorRange_imin(arg1: *const FaissIDSelectorRange) -> idx_t; -} -extern "C" { - pub fn faiss_IDSelectorRange_imax(arg1: *const FaissIDSelectorRange) -> idx_t; -} -extern "C" { - #[doc = " remove ids between [imni, imax)"] - pub fn faiss_IDSelectorRange_new( - p_sel: *mut *mut FaissIDSelectorRange, - imin: idx_t, - imax: idx_t, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct FaissIDSelectorBatch_H { - _unused: [u8; 0], + pub fn faiss_IndexIVFScalarQuantizer_quantizer( + arg1: *const FaissIndexIVFScalarQuantizer, + ) -> *mut FaissIndex; } -pub type FaissIDSelectorBatch = FaissIDSelectorBatch_H; extern "C" { - pub fn faiss_IDSelectorBatch_nbits(arg1: *const FaissIDSelectorBatch) -> ::std::os::raw::c_int; + pub fn faiss_IndexIVFScalarQuantizer_own_fields( + arg1: *const FaissIndexIVFScalarQuantizer, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_IDSelectorBatch_mask(arg1: *const FaissIDSelectorBatch) -> idx_t; + pub fn faiss_IndexIVFScalarQuantizer_set_own_fields( + arg1: *mut FaissIndexIVFScalarQuantizer, + arg2: ::std::os::raw::c_int, + ); } extern "C" { - #[doc = " Remove ids from a set. Repetitions of ids in the indices set"] - #[doc = " passed to the constructor does not hurt performance. The hash"] - #[doc = " function used for the bloom filter and GCC's implementation of"] - #[doc = " unordered_set are just the least significant bits of the id. This"] - #[doc = " works fine for random ids or ids in sequences but will produce many"] - #[doc = " hash collisions if lsb's are always the same"] - pub fn faiss_IDSelectorBatch_new( - p_sel: *mut *mut FaissIDSelectorBatch, - n: usize, - indices: *const idx_t, + #[doc = " whether object owns the quantizer"] + pub fn faiss_IndexIVFScalarQuantizer_add_core( + index: *mut FaissIndexIVFScalarQuantizer, + n: idx_t, + x: *const f32, + xids: *const idx_t, + precomputed_idx: *const idx_t, ) -> ::std::os::raw::c_int; } -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct FaissBufferList_H { - _unused: [u8; 0], -} -pub type FaissBufferList = FaissBufferList_H; +pub type FaissIndexShards = FaissIndex_H; extern "C" { - pub fn faiss_BufferList_free(obj: *mut FaissBufferList); + pub fn faiss_IndexShards_free(obj: *mut FaissIndexShards); } extern "C" { - pub fn faiss_BufferList_buffer_size(arg1: *const FaissBufferList) -> usize; + pub fn faiss_IndexShards_own_fields(arg1: *const FaissIndexShards) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_BufferList_wp(arg1: *const FaissBufferList) -> usize; + pub fn faiss_IndexShards_set_own_fields( + arg1: *mut FaissIndexShards, + arg2: ::std::os::raw::c_int, + ); } -#[doc = " List of temporary buffers used to store results before they are"] -#[doc = " copied to the RangeSearchResult object."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct FaissBuffer { - pub ids: *mut idx_t, - pub dis: *mut f32, +extern "C" { + pub fn faiss_IndexShards_successive_ids(arg1: *const FaissIndexShards) + -> ::std::os::raw::c_int; } -#[test] -fn bindgen_test_layout_FaissBuffer() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(FaissBuffer)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(FaissBuffer)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).ids as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(FaissBuffer), - "::", - stringify!(ids) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).dis as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(FaissBuffer), - "::", - stringify!(dis) - ) +extern "C" { + pub fn faiss_IndexShards_set_successive_ids( + arg1: *mut FaissIndexShards, + arg2: ::std::os::raw::c_int, ); } extern "C" { - pub fn faiss_BufferList_append_buffer(bl: *mut FaissBufferList) -> ::std::os::raw::c_int; + #[doc = " Index that concatenates the results from several sub-indexes"] + pub fn faiss_IndexShards_new( + p_index: *mut *mut FaissIndexShards, + d: idx_t, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_BufferList_new( - p_bl: *mut *mut FaissBufferList, - buffer_size: usize, + pub fn faiss_IndexShards_new_with_options( + p_index: *mut *mut FaissIndexShards, + d: idx_t, + threaded: ::std::os::raw::c_int, + successive_ids: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_BufferList_add( - bl: *mut FaissBufferList, - id: idx_t, - dis: f32, + pub fn faiss_IndexShards_add_shard( + index: *mut FaissIndexShards, + shard: *mut FaissIndex, ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " copy elemnts ofs:ofs+n-1 seen as linear data in the buffers to"] - #[doc = " tables dest_ids, dest_dis"] - pub fn faiss_BufferList_copy_range( - bl: *mut FaissBufferList, - ofs: usize, - n: usize, - dest_ids: *mut idx_t, - dest_dis: *mut f32, + pub fn faiss_IndexShards_remove_shard( + index: *mut FaissIndexShards, + shard: *mut FaissIndex, ) -> ::std::os::raw::c_int; } -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct FaissRangeSearchPartialResult_H { - _unused: [u8; 0], -} -pub type FaissRangeSearchPartialResult = FaissRangeSearchPartialResult_H; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct FaissRangeQueryResult_H { - _unused: [u8; 0], -} -pub type FaissRangeQueryResult = FaissRangeQueryResult_H; extern "C" { - pub fn faiss_RangeQueryResult_qno(arg1: *const FaissRangeQueryResult) -> idx_t; + pub fn faiss_IndexShards_at( + index: *mut FaissIndexShards, + i: ::std::os::raw::c_int, + ) -> *mut FaissIndex; } +pub type FaissIndexIDMap = FaissIndex_H; extern "C" { - pub fn faiss_RangeQueryResult_nres(arg1: *const FaissRangeQueryResult) -> usize; + pub fn faiss_IndexIDMap_own_fields(arg1: *const FaissIndexIDMap) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_RangeQueryResult_pres( - arg1: *const FaissRangeQueryResult, - ) -> *mut FaissRangeSearchPartialResult; + pub fn faiss_IndexIDMap_set_own_fields(arg1: *mut FaissIndexIDMap, arg2: ::std::os::raw::c_int); } extern "C" { - #[doc = " result structure for a single query"] - pub fn faiss_RangeQueryResult_add( - qr: *mut FaissRangeQueryResult, - dis: f32, - id: idx_t, + #[doc = " Index that translates search results to ids"] + pub fn faiss_IndexIDMap_new( + p_index: *mut *mut FaissIndexIDMap, + index: *mut FaissIndex, ) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_RangeSearchPartialResult_res( - arg1: *const FaissRangeSearchPartialResult, - ) -> *mut FaissRangeSearchResult; + pub fn faiss_IndexIDMap_cast(arg1: *mut FaissIndex) -> *mut FaissIndexIDMap; } extern "C" { - pub fn faiss_RangeSearchPartialResult_new( - p_res: *mut *mut FaissRangeSearchPartialResult, - res_in: *mut FaissRangeSearchResult, - ) -> ::std::os::raw::c_int; + #[doc = " get a pointer to the index map's internal ID vector (the `id_map` field).\n The outputs of this function become invalid after any operation that can\n modify the index.\n\n @param index opaque pointer to index object\n @param p_id_map output, the pointer to the beginning of `id_map`.\n @param p_size output, the current length of `id_map`."] + pub fn faiss_IndexIDMap_id_map( + index: *mut FaissIndexIDMap, + p_id_map: *mut *mut idx_t, + p_size: *mut usize, + ); } extern "C" { - pub fn faiss_RangeSearchPartialResult_finalize( - res: *mut FaissRangeSearchPartialResult, - ) -> ::std::os::raw::c_int; + #[doc = " get a pointer to the sub-index (the `index` field).\n The outputs of this function become invalid after any operation that can\n modify the index.\n\n @param index opaque pointer to index object"] + pub fn faiss_IndexIDMap_sub_index(index: *mut FaissIndexIDMap) -> *mut FaissIndex; } +pub type FaissIndexIDMap2 = FaissIndex_H; extern "C" { - #[doc = " called by range_search before do_allocation"] - pub fn faiss_RangeSearchPartialResult_set_lims( - res: *mut FaissRangeSearchPartialResult, - ) -> ::std::os::raw::c_int; + pub fn faiss_IndexIDMap2_own_fields(arg1: *const FaissIndexIDMap2) -> ::std::os::raw::c_int; } extern "C" { - pub fn faiss_RangeSearchPartialResult_new_result( - res: *mut FaissRangeSearchPartialResult, - qno: idx_t, - qr: *mut *mut FaissRangeQueryResult, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct FaissDistanceComputer_H { - _unused: [u8; 0], + pub fn faiss_IndexIDMap2_set_own_fields( + arg1: *mut FaissIndexIDMap2, + arg2: ::std::os::raw::c_int, + ); } -pub type FaissDistanceComputer = FaissDistanceComputer_H; extern "C" { - #[doc = " called before computing distances"] - pub fn faiss_DistanceComputer_set_query( - dc: *mut FaissDistanceComputer, - x: *const f32, + #[doc = " same as IndexIDMap but also provides an efficient reconstruction\nimplementation via a 2-way index"] + pub fn faiss_IndexIDMap2_new( + p_index: *mut *mut FaissIndexIDMap2, + index: *mut FaissIndex, ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Compute distance of vector i to current query."] - #[doc = " This function corresponds to the function call operator:"] - #[doc = " DistanceComputer::operator()"] - pub fn faiss_DistanceComputer_vector_to_query_dis( - dc: *mut FaissDistanceComputer, - i: idx_t, - qd: *mut f32, + #[doc = " make the rev_map from scratch"] + pub fn faiss_IndexIDMap2_construct_rev_map( + index: *mut FaissIndexIDMap2, ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " compute distance between two stored vectors"] - pub fn faiss_DistanceComputer_symmetric_dis( - dc: *mut FaissDistanceComputer, - i: idx_t, - j: idx_t, - vd: *mut f32, - ) -> ::std::os::raw::c_int; + pub fn faiss_IndexIDMap2_cast(arg1: *mut FaissIndex) -> *mut FaissIndexIDMap2; } extern "C" { - pub fn faiss_DistanceComputer_free(obj: *mut FaissDistanceComputer); + #[doc = " get a pointer to the index map's internal ID vector (the `id_map` field).\n The outputs of this function become invalid after any operation that can\n modify the index.\n\n @param index opaque pointer to index object\n @param p_id_map output, the pointer to the beginning of `id_map`.\n @param p_size output, the current length of `id_map`."] + pub fn faiss_IndexIDMap2_id_map( + index: *mut FaissIndexIDMap2, + p_id_map: *mut *mut idx_t, + p_size: *mut usize, + ); +} +extern "C" { + #[doc = " get a pointer to the sub-index (the `index` field).\n The outputs of this function become invalid after any operation that can\n modify the index.\n\n @param index opaque pointer to index object"] + pub fn faiss_IndexIDMap2_sub_index(index: *mut FaissIndexIDMap2) -> *mut FaissIndex; } extern "C" { #[doc = " Compute pairwise distances between sets of vectors"] @@ -1988,11 +2107,7 @@ extern "C" { ); } extern "C" { - #[doc = " Compute pairwise distances between sets of vectors"] - #[doc = " arguments from \"faiss_pairwise_L2sqr\""] - #[doc = " ldq equal -1 by default"] - #[doc = " ldb equal -1 by default"] - #[doc = " ldd equal -1 by default"] + #[doc = " Compute pairwise distances between sets of vectors\n arguments from \"faiss_pairwise_L2sqr\"\n ldq equal -1 by default\n ldb equal -1 by default\n ldd equal -1 by default"] pub fn faiss_pairwise_L2sqr_with_defaults( d: i64, nq: i64, @@ -2033,13 +2148,11 @@ extern "C" { pub fn faiss_fvec_renorm_L2(d: usize, nx: usize, x: *mut f32); } extern "C" { - #[doc = " Setter of threshold value on nx above which we switch to BLAS to compute"] - #[doc = " distances"] + #[doc = " Setter of threshold value on nx above which we switch to BLAS to compute\n distances"] pub fn faiss_set_distance_compute_blas_threshold(value: ::std::os::raw::c_int); } extern "C" { - #[doc = " Getter of threshold value on nx above which we switch to BLAS to compute"] - #[doc = " distances"] + #[doc = " Getter of threshold value on nx above which we switch to BLAS to compute\n distances"] pub fn faiss_get_distance_compute_blas_threshold() -> ::std::os::raw::c_int; } extern "C" { @@ -2059,57 +2172,13 @@ extern "C" { pub fn faiss_get_distance_compute_blas_database_bs() -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Setter of number of results we switch to a reservoir to collect results"] - #[doc = " rather than a heap"] + #[doc = " Setter of number of results we switch to a reservoir to collect results\n rather than a heap"] pub fn faiss_set_distance_compute_min_k_reservoir(value: ::std::os::raw::c_int); } extern "C" { - #[doc = " Getter of number of results we switch to a reservoir to collect results"] - #[doc = " rather than a heap"] + #[doc = " Getter of number of results we switch to a reservoir to collect results\n rather than a heap"] pub fn faiss_get_distance_compute_min_k_reservoir() -> ::std::os::raw::c_int; } -extern "C" { - #[doc = " Build and index with the sequence of processing steps described in"] - #[doc = " the string."] - pub fn faiss_index_factory( - p_index: *mut *mut FaissIndex, - d: ::std::os::raw::c_int, - description: *const ::std::os::raw::c_char, - metric: FaissMetricType, - ) -> ::std::os::raw::c_int; -} -extern "C" { - #[doc = " Write index to a file."] - #[doc = " This is equivalent to `faiss::write_index` when a file descriptor is"] - #[doc = " provided."] - pub fn faiss_write_index(idx: *const FaissIndex, f: *mut FILE) -> ::std::os::raw::c_int; -} -extern "C" { - #[doc = " Write index to a file."] - #[doc = " This is equivalent to `faiss::write_index` when a file path is provided."] - pub fn faiss_write_index_fname( - idx: *const FaissIndex, - fname: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - #[doc = " Read index from a file."] - #[doc = " This is equivalent to `faiss:read_index` when a file descriptor is given."] - pub fn faiss_read_index( - f: *mut FILE, - io_flags: ::std::os::raw::c_int, - p_out: *mut *mut FaissIndex, - ) -> ::std::os::raw::c_int; -} -extern "C" { - #[doc = " Read index from a file."] - #[doc = " This is equivalent to `faiss:read_index` when a file path is given."] - pub fn faiss_read_index_fname( - fname: *const ::std::os::raw::c_char, - io_flags: ::std::os::raw::c_int, - p_out: *mut *mut FaissIndex, - ) -> ::std::os::raw::c_int; -} #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct CUstream_st { @@ -2136,20 +2205,14 @@ extern "C" { pub fn faiss_gpu_profiler_stop() -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Synchronizes the CPU against all devices (equivalent to"] - #[doc = " cudaDeviceSynchronize for each device)"] + #[doc = " Synchronizes the CPU against all devices (equivalent to\n cudaDeviceSynchronize for each device)"] pub fn faiss_gpu_sync_all_devices() -> ::std::os::raw::c_int; } -#[doc = " The user indices are only stored on the CPU; the GPU returns"] -#[doc = " (inverted list, offset) to the CPU which is then translated to"] -#[doc = " the real user index."] +#[doc = " The user indices are only stored on the CPU; the GPU returns\n (inverted list, offset) to the CPU which is then translated to\n the real user index."] pub const FaissIndicesOptions_INDICES_CPU: FaissIndicesOptions = 0; -#[doc = " The indices are not stored at all, on either the CPU or"] -#[doc = " GPU. Only (inverted list, offset) is returned to the user as the"] -#[doc = " index."] +#[doc = " The indices are not stored at all, on either the CPU or\n GPU. Only (inverted list, offset) is returned to the user as the\n index."] pub const FaissIndicesOptions_INDICES_IVF: FaissIndicesOptions = 1; -#[doc = " Indices are stored as 32 bit integers on the GPU, but returned"] -#[doc = " as 64 bit integers"] +#[doc = " Indices are stored as 32 bit integers on the GPU, but returned\n as 64 bit integers"] pub const FaissIndicesOptions_INDICES_32_BIT: FaissIndicesOptions = 2; #[doc = " Indices are stored as 64 bit integers on the GPU"] pub const FaissIndicesOptions_INDICES_64_BIT: FaissIndicesOptions = 3; @@ -2299,9 +2362,7 @@ extern "C" { pub fn faiss_GpuResources_free(obj: *mut FaissGpuResources); } extern "C" { - #[doc = " Call to pre-allocate resources for a particular device. If this is"] - #[doc = " not called, then resources will be allocated at the first time"] - #[doc = " of demand"] + #[doc = " Call to pre-allocate resources for a particular device. If this is\n not called, then resources will be allocated at the first time\n of demand"] pub fn faiss_GpuResources_initializeForDevice( arg1: *mut FaissGpuResources, arg2: ::std::os::raw::c_int, @@ -2316,8 +2377,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Returns the stream that we order all computation on for the"] - #[doc = " given device"] + #[doc = " Returns the stream that we order all computation on for the\n given device"] pub fn faiss_GpuResources_getDefaultStream( arg1: *mut FaissGpuResources, arg2: ::std::os::raw::c_int, @@ -2355,8 +2415,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Synchronizes the CPU with respect to the default stream for the"] - #[doc = " given device"] + #[doc = " Synchronizes the CPU with respect to the default stream for the\n given device"] pub fn faiss_GpuResources_syncDefaultStream( arg1: *mut FaissGpuResources, arg2: ::std::os::raw::c_int, @@ -2450,23 +2509,20 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Disable allocation of temporary memory; all temporary memory"] - #[doc = " requests will call cudaMalloc / cudaFree at the point of use"] + #[doc = " Disable allocation of temporary memory; all temporary memory\n requests will call cudaMalloc / cudaFree at the point of use"] pub fn faiss_StandardGpuResources_noTempMemory( arg1: *mut FaissStandardGpuResources, ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Specify that we wish to use a certain fixed size of memory on"] - #[doc = " all devices as temporary memory"] + #[doc = " Specify that we wish to use a certain fixed size of memory on\n all devices as temporary memory"] pub fn faiss_StandardGpuResources_setTempMemory( arg1: *mut FaissStandardGpuResources, size: usize, ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Set amount of pinned memory to allocate, for async GPU <-> CPU"] - #[doc = " transfers"] + #[doc = " Set amount of pinned memory to allocate, for async GPU <-> CPU\n transfers"] pub fn faiss_StandardGpuResources_setPinnedMemory( arg1: *mut FaissStandardGpuResources, size: usize, @@ -2481,8 +2537,7 @@ extern "C" { ) -> ::std::os::raw::c_int; } extern "C" { - #[doc = " Called to change the work ordering streams to the null stream"] - #[doc = " for all devices"] + #[doc = " Called to change the work ordering streams to the null stream\n for all devices"] pub fn faiss_StandardGpuResources_setDefaultNullStreamAllDevices( arg1: *mut FaissStandardGpuResources, ) -> ::std::os::raw::c_int; From f0820cb8dd6060c8097089fc88051f68971918d2 Mon Sep 17 00:00:00 2001 From: Eduardo Pinho Date: Sun, 24 Mar 2024 10:42:38 +0000 Subject: [PATCH 2/2] (break) Remove train_residual method - no longer exists in Faiss 1.8.0 --- src/index/scalar_quantizer.rs | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/src/index/scalar_quantizer.rs b/src/index/scalar_quantizer.rs index 468dfdd..2249552 100644 --- a/src/index/scalar_quantizer.rs +++ b/src/index/scalar_quantizer.rs @@ -257,18 +257,6 @@ where faiss_IndexIVFScalarQuantizer_set_nprobe(self.inner_ptr(), value as usize); } } - - pub fn train_residual(&mut self, x: &[f32]) -> Result<()> { - unsafe { - let n = x.len() / self.d() as usize; - faiss_try(faiss_IndexIVFScalarQuantizer_train_residual( - self.inner_ptr(), - n as i64, - x.as_ptr(), - ))?; - Ok(()) - } - } } impl NativeIndex for IVFScalarQuantizerIndexImpl {