diskann-quantization 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

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

pub use sealed::Length;

/// A type for dynamically sized slices.
#[derive(Debug, Clone, Copy)]
pub struct Dynamic(pub usize);

/// Allow integers to be converted into `Dynamic`.
impl From<usize> for Dynamic {
    fn from(value: usize) -> Dynamic {
        Dynamic(value)
    }
}

/// A type for statically sized slices (slices with a length known at compile-time).
#[derive(Debug, Clone, Copy)]
pub struct Static<const N: usize>;

// SAFETY: `value` returns the same value for all copies of `self`.
unsafe impl Length for Dynamic {
    #[inline(always)]
    fn value(self) -> usize {
        self.0
    }
}

// SAFETY: `value` always returns the same value.
unsafe impl<const N: usize> Length for Static<N> {
    #[inline(always)]
    fn value(self) -> usize {
        N
    }
}

mod sealed {
    /// A trait allowing a type to yield a value.
    ///
    /// This allows the lengths of `BitSlice`s to be either static or dynamic.
    ///
    /// # Safety
    ///
    /// Implementations must ensure that `self.value()` always returns the same value for a
    /// given instance and that this value is preserved across all copies obtained from `self`.
    pub unsafe trait Length: Copy {
        fn value(self) -> usize;
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_length() {
        for i in 0..100 {
            assert_eq!(Dynamic(i).value(), i);
        }

        assert_eq!(Static::<0>.value(), 0);
        assert_eq!(Static::<10>.value(), 10);
        assert_eq!(Static::<20>.value(), 20);
        assert_eq!(Static::<37>.value(), 37);
    }
}