diskann-providers 0.51.0

DiskANN is a fast approximate nearest neighbor search library for high dimensional data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

/*
 * Copyright (c) Microsoft Corporation.
 * Licensed under the MIT license.
 */

use diskann::ANNError;
use diskann_utils::views;

use crate::utils::Bridge;

// Compatibility with ANNError.
impl From<Bridge<diskann_quantization::views::ChunkOffsetError>> for ANNError {
    #[track_caller]
    fn from(value: Bridge<diskann_quantization::views::ChunkOffsetError>) -> Self {
        ANNError::log_pq_error(value.into_inner())
    }
}

// Compatibility with ANNError.
impl From<Bridge<diskann_quantization::views::ChunkViewError>> for ANNError {
    #[track_caller]
    fn from(value: Bridge<diskann_quantization::views::ChunkViewError>) -> Self {
        ANNError::log_pq_error(value.into_inner())
    }
}

// Compatibility with ANNError.
impl<T: views::DenseData> From<Bridge<views::TryFromError<T>>> for ANNError {
    #[track_caller]
    fn from(value: Bridge<views::TryFromError<T>>) -> Self {
        ANNError::log_pq_error(value.into_inner())
    }
}

///////////
// Tests //
///////////

#[cfg(test)]
mod tests {
    use diskann::ANNErrorKind;

    use super::*;
    use crate::utils::BridgeErr;

    fn test_error<F, E>(f: F)
    where
        F: FnOnce() -> E,
        E: std::error::Error,
        ANNError: From<E>,
    {
        let err = f();
        let message = format!("{}", err);

        let ann = ANNError::from(err);
        assert_eq!(ann.kind(), ANNErrorKind::PQError);
        let formatted = ann.to_string();
        assert!(formatted.contains(&message));
    }

    #[test]
    fn test_chunk_offsets_error() {
        // Offsets not monotonic.
        let offsets = [0, 1, 1, 5];
        test_error(|| {
            diskann_quantization::views::ChunkOffsetsView::new(&offsets)
                .bridge_err()
                .unwrap_err()
        });
    }

    #[test]
    fn test_chunk_view_error() {
        let offsets = [0, 1, 2, 5];
        // Data is too long.
        let data = vec![0; offsets.last().unwrap() + 1];

        test_error(|| {
            let offsets = diskann_quantization::views::ChunkOffsetsView::new(&offsets).unwrap();
            diskann_quantization::views::ChunkView::new(data.as_slice(), offsets)
                .bridge_err()
                .unwrap_err()
        });
    }

    #[test]
    fn test_try_from() {
        let ncols = 5;
        let nrows = 3;
        let data = vec![0; ncols * nrows];

        test_error(|| {
            views::MatrixView::try_from(&*data, nrows, ncols + 1)
                .bridge_err()
                .unwrap_err()
        });
    }
}