Struct BinaryCoarseQuantizer 

pub struct BinaryCoarseQuantizer {
    pub dim_bits: usize,
    pub num_clusters: u32,
    pub version: u64,
    /* private fields */
}

Global Hamming coarse quantizer shared by every segment of a field.

Fields

dim_bits: usize

num_clusters: u32

version: u64

Implementations

impl BinaryCoarseQuantizer

pub fn train( config: BinaryIvfConfig, codes: &[u8], num_vectors: usize, index_label: &str, ) -> Result<Self>

pub fn byte_len(&self) -> usize

pub fn validate(&self) -> Result<(), String>

pub fn validate_routing(&self, mode: IvfRoutingMode) -> Result<(), String>

pub fn probe( &self, query: &[u8], k: usize, mode: IvfRoutingMode, ) -> Result<IvfProbePlan>

pub fn request_fingerprint( &self, query: &[u8], k: usize, mode: IvfRoutingMode, ) -> u64

Cache key for the default probe policy. This must stay paired with Self::probe: automatic routing and adaptive parent beams are both resolved here before hashing.

pub fn probe_with_parent_beam( &self, query: &[u8], k: usize, mode: IvfRoutingMode, parent_beam_oversample: usize, ) -> Result<IvfProbePlan>

Probe with an explicit two-level parent coverage multiplier.

The routing layer clamps the multiplier to its hard work bound. Flat and HNSW modes ignore it, so a runtime integration can pass one policy uniformly without changing artifacts or exact leaf scoring.

pub fn assign(&self, code: &[u8], mode: IvfRoutingMode) -> Result<u32>

Assign one code to its leaf.

Segment construction routes every vector through here, so this path must stay allocation-free. A code of the wrong width, or a router that cannot produce a leaf, is an error: silently assigning cluster 0 would build a payload that scores as valid but never finds those vectors.

Trait Implementations

impl Clone for BinaryCoarseQuantizer

fn clone(&self) -> BinaryCoarseQuantizer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BinaryCoarseQuantizer

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BinaryCoarseQuantizer

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BinaryCoarseQuantizer

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.