Struct AnnSpec 

#[non_exhaustive]
pub struct AnnSpec {
    pub dim: u32,
    pub distance: u8,
    pub m: u16,
    pub ef: u16,
}

HNSW declaration (immutable once created).

use kevy_index::AnnSpec;
let a = AnnSpec::new(128).with_distance(1).with_m(32);
assert_eq!((a.dim, a.distance, a.m, a.ef), (128, 1, 32, 200));

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

dim: u32

Vector dimensionality (field bytes must be dim×4 f32 LE).

let s = IndexSpec::builder("v", "doc:", IndexKind::Ann, ValType::Vector)
    .with_field("emb")
    .with_ann(AnnSpec::new(3))
    .build()?;
let dim = s.ann().expect("an ann index").dim;
// a stored vector is dim little-endian f32s
let v: Vec<u8> = [0.5f32, 1.0, 2.0].iter().flat_map(|x| x.to_le_bytes()).collect();
assert_eq!(v.len(), dim as usize * 4);

distance: u8

0=cosine 1=l2 2=ip (kevy-vector’s Distance tags).

let s = IndexSpec::builder("v", "doc:", IndexKind::Ann, ValType::Vector)
    .with_field("emb")
    .with_ann(AnnSpec::new(3).with_distance(1))
    .build()?;
assert_eq!(s.ann().map(|a| a.distance), Some(1), "l2");

m: u16

Max links per node per layer.

let s = IndexSpec::builder("v", "doc:", IndexKind::Ann, ValType::Vector)
    .with_field("emb")
    .build();
// the parameters are required on an ann index
assert!(s.is_err());
assert_eq!(kevy_index::AnnSpec::new(3).m, 16, "the IDX.CREATE default");

ef: u16

Construction beam width.

let s = IndexSpec::builder("v", "doc:", IndexKind::Ann, ValType::Vector)
    .with_field("emb")
    .with_ann(AnnSpec::new(3).with_ef(64))
    .build()?;
assert_eq!(s.ann().map(|a| a.ef), Some(64));

Implementations

impl AnnSpec

pub fn new(dim: u32) -> AnnSpec

A dim-dimensional cosine graph with the HNSW defaults (M 16, EF 200), the values IDX.CREATE uses when the options are not given.

let a = kevy_index::AnnSpec::new(4);
assert_eq!((a.distance, a.m, a.ef), (0, 16, 200));

pub fn with_distance(self, distance: u8) -> AnnSpec

This graph under distance tag distance (0 cosine, 1 l2, 2 ip).

assert_eq!(kevy_index::AnnSpec::new(4).with_distance(2).distance, 2);

pub fn with_m(self, m: u16) -> AnnSpec

This graph with at most m links per node per layer.

assert_eq!(kevy_index::AnnSpec::new(4).with_m(8).m, 8);

pub fn with_ef(self, ef: u16) -> AnnSpec

This graph built with beam width ef.

assert_eq!(kevy_index::AnnSpec::new(4).with_ef(64).ef, 64);

Trait Implementations

impl Clone for AnnSpec

fn clone(&self) -> AnnSpec

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for AnnSpec

impl Debug for AnnSpec

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for AnnSpec

impl Hash for AnnSpec

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for AnnSpec

fn eq(&self, other: &AnnSpec) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for AnnSpec