TurboQuant

https://docs.rs/turbo-quant/latest/turbo_quant/
Admin
TurboQuant is a Rust implementation of vector quantization algorithms from Google Research that...
Tokens:39,246
Snippets:404
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Quick Start with TurboQuant and PolarQuant

Source: https://docs.rs/turbo-quant/latest/turbo_quant/index.html

Demonstrates how to initialize and use TurboQuantizer and PolarQuantizer for compressing and estimating inner products of high-dimensional vectors. Ensure correct dimensions and parameters are used for production.

```rust
use turbo_quant::{TurboQuantizer, PolarQuantizer};

// Compress 1536-dimensional embeddings (OpenAI/sentence-transformer size).
let dim = 64; // use 1536 in production
let q = TurboQuantizer::new(dim, 8, 32, /* seed */ 42).unwrap();

let database_vector: Vec<f32> = vec![0.1; dim]; // your embedding here
let query_vector: Vec<f32> = vec![0.1; dim];    // your query here

// Compress the database vector (store this, not the raw f32 array).
let code = q.encode(&database_vector).unwrap();

// At query time: estimate inner product without decompressing.
let score = q.inner_product_estimate(&code, &query_vector).unwrap();

// Or just use PolarQuant for a simpler single-stage compressor.
let pq = PolarQuantizer::new(dim, 8, 42).unwrap();
let polar_code = pq.encode(&database_vector).unwrap();
let polar_score = pq.inner_product_estimate(&polar_code, &query_vector).unwrap();
```

--------------------------------

### expect_err() Panic Example

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Shows that calling expect_err() on an Ok variant panics with a custom message and the Ok value.

```rust
let x: Result<u32, &str> = Ok(10);
x.expect_err("Testing expect_err"); // panics with `Testing expect_err: 10`
```

--------------------------------

### Get uncompressed bytes equivalent

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheCompressor.html

Calculates the number of bytes that would be used if keys and values were stored in their uncompressed f32 format.

```rust
pub fn uncompressed_bytes(&self) -> usize
```

--------------------------------

### Result unwrap() Panic Example

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Illustrates that calling unwrap() on an Err variant will cause a panic with the error message.

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.unwrap(); // panics with `emergency failure`
```

--------------------------------

### Providing a Default Value with unwrap_or

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Shows how to use `unwrap_or` to get the contained `Ok` value or a specified default value if the Result is an `Err`.

```APIDOC
## unwrap_or

### Description
Returns the contained `Ok` value or a provided default. Arguments are eagerly evaluated.

### Method Signature
`pub fn unwrap_or(self, default: T) -> T`

### Examples
```rust
let default = 2;
let x: Result<u32, &str> = Ok(9);
assert_eq!(x.unwrap_or(default), 9);

let x: Result<u32, &str> = Err("error");
assert_eq!(x.unwrap_or(default), default);
```
```

--------------------------------

### unwrap_err() on Ok Variant Panic Example

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Demonstrates that calling unwrap_err() on an Ok variant panics with the Ok value.

```rust
let x: Result<u32, &str> = Ok(2);
x.unwrap_err(); // panics with `2`
```

--------------------------------

### Get approximate compressed bytes used

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheCompressor.html

Returns the approximate total number of bytes currently used by all compressed tokens in the cache.

```rust
pub fn compressed_bytes(&self) -> usize
```

--------------------------------

### Get references to Result values

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Use `as_ref()` to obtain a `Result<&T, &E>` from a `&Result<T, E>`, allowing inspection of the contained values without consuming the original Result. `as_mut()` provides mutable references.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

--------------------------------

### Get Dimension of StoredRotation

Source: https://docs.rs/turbo-quant/latest/turbo_quant/rotation/struct.StoredRotation.html

Returns the dimension on which this rotation operates.

```rust
fn dim(&self) -> usize
```

--------------------------------

### Initialize and Use KvCacheCompressor

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/index.html

Demonstrates how to configure, initialize, and use the KvCacheCompressor for compressing tokens and computing attention scores. Ensure the KvCacheConfig matches your model's head dimensions and desired bit budget.

```rust
use turbo_quant::kv::{KvCacheCompressor, KvCacheConfig};

let config = KvCacheConfig {
    head_dim: 64,        // per-attention-head dimension
    bits: 8,             // bit budget for keys and values
    projections: 16,     // QJL sketch projections
    seed: 42,
};

let mut cache = KvCacheCompressor::new(config).unwrap();

// At each generation step, compress the new key and value.
let key = vec![0.1f32; 64];
let value = vec![0.2f32; 64];
cache.compress_token(&key, &value).unwrap();

// At attention time: compute logits against all compressed keys.
let query = vec![0.15f32; 64];
let scores = cache.attention_scores(&query).unwrap();
assert_eq!(scores.len(), 1); // one score per stored token

// Retrieve approximate reconstructed values for the top-k tokens.
let values = cache.decode_values(&[0]).unwrap();
assert_eq!(values.len(), 1);
```

--------------------------------

### Get Seed of StoredRotation

Source: https://docs.rs/turbo-quant/latest/turbo_quant/rotation/struct.StoredRotation.html

Retrieves the seed value that was used to generate this rotation.

```rust
pub fn seed(&self) -> u64
```

--------------------------------

### Create New QjlQuantizer

Source: https://docs.rs/turbo-quant/latest/turbo_quant/qjl/struct.QjlQuantizer.html

Initializes a new QjlQuantizer. Use a higher number of projections (m) to reduce estimation variance. A common rule of thumb is m ≈ d / 4 for good accuracy.

```rust
pub fn new(dim: usize, projections: usize, seed: u64) -> Result<Self>
```

--------------------------------

### Get Input Vector Dimension

Source: https://docs.rs/turbo-quant/latest/turbo_quant/qjl/struct.QjlQuantizer.html

Retrieves the input vector dimension that the QjlQuantizer was configured with.

```rust
pub fn dim(&self) -> usize
```

--------------------------------

### Basic Result Usage

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Demonstrates the basic usage of the Result type, showing how to unwrap a successful Ok value.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

--------------------------------

### Get PolarCode Schema Name

Source: https://docs.rs/turbo-quant/latest/turbo_quant/polar/struct.PolarCode.html

Returns the name of the generated JSON Schema for the PolarCode type.

```rust
fn schema_name() -> String
```

--------------------------------

### Get Number of Projections

Source: https://docs.rs/turbo-quant/latest/turbo_quant/qjl/struct.QjlQuantizer.html

Retrieves the number of random projections (sketch dimension) configured for the QjlQuantizer.

```rust
pub fn projections(&self) -> usize
```

--------------------------------

### PartialEq Implementation for KvCacheConfig

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheConfig.html

Provides methods for comparing KvCacheConfig instances for equality. Use the `==` and `!=` operators to check if two configurations are identical.

```rust
fn eq(&self, other: &KvCacheConfig) -> bool
```

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

--------------------------------

### Get PolarQuantizer Bit Width

Source: https://docs.rs/turbo-quant/latest/turbo_quant/polar/struct.PolarQuantizer.html

Retrieves the angle quantization bit width used by the PolarQuantizer.

```rust
pub fn bits(&self) -> u8
```

--------------------------------

### Create a new KvCacheCompressor

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheCompressor.html

Initializes a new KvCacheCompressor for a single attention head. Requires a KvCacheConfig to be provided.

```rust
pub fn new(config: KvCacheConfig) -> Result<Self>
```

--------------------------------

### Create a New TurboQuantizer

Source: https://docs.rs/turbo-quant/latest/turbo_quant/turbo/struct.TurboQuantizer.html

Initializes a new TurboQuant compressor with specified dimensions, bit budget, projection count, and a deterministic seed. Ensure the vector dimension is even and non-zero.

```rust
pub fn new(dim: usize, bits: u8, projections: usize, seed: u64) -> Result<Self>
```

--------------------------------

### Get Number of Pairs in PolarCode

Source: https://docs.rs/turbo-quant/latest/turbo_quant/polar/struct.PolarCode.html

Calculates the number of pairs, which is half the dimension of the original vector.

```rust
pub fn pair_count(&self) -> usize
```

--------------------------------

### Handling File Metadata with Result

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Shows how to use Result methods to handle potential errors when accessing file metadata. It demonstrates checking for success or failure and extracting error kinds.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

--------------------------------

### Get the number of tokens in KvCacheCompressor

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheCompressor.html

Returns the current number of tokens stored in the cache. This is a simple getter method.

```rust
pub fn len(&self) -> usize
```

--------------------------------

### Get PolarCode Schema ID

Source: https://docs.rs/turbo-quant/latest/turbo_quant/polar/struct.PolarCode.html

Returns a unique string identifier for the JSON Schema produced by the PolarCode type.

```rust
fn schema_id() -> Cow<'static, str>
```

--------------------------------

### into_ok

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Returns the contained Ok value, but never panics. This is an experimental API.

```APIDOC
## into_ok

### Description
Returns the contained `Ok` value, but never panics. This is a nightly-only experimental API. Unlike `unwrap`, this method is known to never panic on the result types it is implemented for. Therefore, it can be used instead of `unwrap` as a maintainability safeguard that will fail to compile if the error type of the `Result` is later changed to an error that can actually occur.

### Method
`into_ok()`

### Parameters
None

### Request Example
```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```

### Response
#### Success Response (Ok value)
- Returns the contained `Ok` value.

#### Response Example
```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok(); // s is "this is fine"
```
```

--------------------------------

### unwrap_err() on Err Variant Example

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Shows how to successfully retrieve the error value from an Err variant using unwrap_err().

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(x.unwrap_err(), "emergency failure");
```

--------------------------------

### KvCacheConfig Methods

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheConfig.html

Provides details on methods available for KvCacheConfig, such as clone_into.

```APIDOC
## fn clone_into(&self, target: &mut T)

### Description
Uses borrowed data to replace owned data, usually by cloning.

### Parameters
- **target** (*&mut T*) - Description of the target mutable reference.
```

--------------------------------

### TurboQuantizer::new

Source: https://docs.rs/turbo-quant/latest/turbo_quant/turbo/struct.TurboQuantizer.html

Creates a new TurboQuant compressor with the specified configuration.

```APIDOC
## TurboQuantizer::new

### Description
Create a new TurboQuant compressor.

### Parameters
* `dim` (usize) - vector dimension (must be even, non-zero)
* `bits` (u8) - total bit budget per scalar (2–16). PolarQuant uses `bits-1`, QJL uses 1 bit on the residual.
* `projections` (usize) - QJL sketch dimension. Rule of thumb: `dim / 4` to `dim / 2`. More projections reduce variance but increase sketch size.
* `seed` (u64) - deterministic seed for all random matrices

### Returns
* `Result<Self>` - A new instance of TurboQuantizer or an error.
```

--------------------------------

### ok

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Converts `Result<T, E>` to `Option<T>`, consuming the result.

```APIDOC
## ok

### Description
Converts `Result<T, E>` to `Option<T>`, consuming `self`. If the result is `Ok`, it returns `Some(T)`. If the result is `Err`, it returns `None`.

### Method
`ok()`

### Parameters
None

### Request Example
```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

### Response
- `Some(T)` if the original result was `Ok(T)`.
- `None` if the original result was `Err(E)`.
```

--------------------------------

### CloneToUninit Trait Implementation (Nightly)

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.CompressedToken.html

Nightly-only experimental API for copying data to uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Rotation Trait Definition

Source: https://docs.rs/turbo-quant/latest/turbo_quant/rotation/trait.Rotation.html

Defines the core methods for a rotation: getting its dimension and applying/inverting it. Implementors must be Send and Sync.

```rust
pub trait Rotation: Send + Sync {
    // Required methods
    fn dim(&self) -> usize;
    fn apply(&self, input: &[f32], output: &mut [f32]) -> Result<()>;
    fn apply_inverse(&self, input: &[f32], output: &mut [f32]) -> Result<()>;
}
```

--------------------------------

### Clone Implementation for QjlSketch

Source: https://docs.rs/turbo-quant/latest/turbo_quant/qjl/struct.QjlSketch.html

Provides the `clone` method for creating a duplicate of a QjlSketch instance.

```rust
fn clone(&self) -> QjlSketch
```

--------------------------------

### VZip Implementation

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheConfig.html

Details the VZip trait implementation for KvCacheConfig, including the vzip method.

```APIDOC
## impl<V, T> VZip<V> for T

### Description
Provides functionality for zipping vectors.

#### fn vzip(self) -> V

### Description
Performs a vector zip operation.

### Returns
The zipped vector.
```

--------------------------------

### TurboCode Clone Implementation

Source: https://docs.rs/turbo-quant/latest/turbo_quant/turbo/struct.TurboCode.html

Provides methods for cloning a TurboCode instance.

```rust
fn clone(&self) -> TurboCode
```

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

--------------------------------

### Clone From Implementation for QjlSketch

Source: https://docs.rs/turbo-quant/latest/turbo_quant/qjl/struct.QjlSketch.html

Implements `clone_from` for performing copy-assignment from one QjlSketch to another.

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

--------------------------------

### Unsafe unwrap_err_unchecked Example

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Demonstrates the `unwrap_err_unchecked` method, which returns the `Err` value without checking if the `Result` is `Ok`. This is unsafe and can lead to undefined behavior if called on an `Ok`.

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(unsafe { x.unwrap_err_unchecked() }, "emergency failure");
```

--------------------------------

### Project Vector to QjlSketch

Source: https://docs.rs/turbo-quant/latest/turbo_quant/qjl/struct.QjlQuantizer.html

Projects a given vector into a QjlSketch. This involves computing the sign of the dot product with random projection vectors, regenerating the projection matrix from the seed.

```rust
pub fn sketch(&self, vector: &[f32]) -> Result<QjlSketch>
```

--------------------------------

### TurboCode PartialEq Implementation

Source: https://docs.rs/turbo-quant/latest/turbo_quant/turbo/struct.TurboCode.html

Provides methods for comparing two TurboCode instances for equality.

```rust
fn eq(&self, other: &TurboCode) -> bool
```

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

--------------------------------

### Unsafe unwrap_unchecked Example

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Illustrates the `unwrap_unchecked` method, which returns the `Ok` value without checking if the `Result` is `Err`. This is unsafe and can lead to undefined behavior if called on an `Err`.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(unsafe { x.unwrap_unchecked() }, 2);
```

--------------------------------

### TryInto Implementation

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheConfig.html

Details the TryInto trait implementation for KvCacheConfig, including error types and conversion methods.

```APIDOC
## impl<T, U> TryInto<U> for T

### Description
Provides the ability to attempt a conversion into another type, returning a Result.

#### type Error = <U as TryFrom<T>>::Error

### Description
The type returned in the event of a conversion error.

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion.

### Returns
A Result containing the converted value or an error.
```

--------------------------------

### Converting Result to Iterator

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Use `into_iter()` to get an iterator that yields the contained value if the Result is Ok, or yields nothing if it's Err. This is useful for chaining operations that expect iterators.

```rust
let x: Result<u32, &str> = Ok(5);
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, [5]);
```

```rust
let x: Result<u32, &str> = Err("nothing!");
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, []);
```

--------------------------------

### Chaining Fallible Operations with and_then

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Demonstrates how to chain operations that return a Result using `and_then`. This is useful for sequential operations where each step might fail.

```APIDOC
## and_then

### Description
Chains fallible operations. If the result is `Ok`, it applies the function to the contained value. If the result is `Err`, it returns the `Err` value.

### Method Signature
`fn and_then<F, T2>(self, op: F) -> Result<T2, E>`
where F: FnOnce(T) -> Result<T2, E>

### Examples
```rust
fn sq_then_to_string(x: u32) -> Result<String, &'static str> {
    x.checked_mul(x).map(|sq| sq.to_string()).ok_or("overflowed")
}

assert_eq!(Ok(2).and_then(sq_then_to_string), Ok("4".to_string()));
assert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err("overflowed"));
assert_eq!(Err("not a number").and_then(sq_then_to_string), Err("not a number"));
```
```

--------------------------------

### TryFrom Implementation

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheConfig.html

Details the TryFrom trait implementation for KvCacheConfig, including error types and conversion methods.

```APIDOC
## impl<T, U> TryFrom<U> for T

### Description
Provides the ability to attempt a conversion from one type to another, returning a Result.

#### type Error = Infallible

### Description
The type returned in the event of a conversion error.

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion.

### Parameters
- **value** (*U*) - The value to convert.

### Returns
A Result containing the converted value or an error.
```

--------------------------------

### Sum of Results from Iterator

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Calculates the sum of elements in an iterator where each element is a Result. If any element is an Err, it's returned immediately. Otherwise, the sum of all Ok values is returned. This example demonstrates summing integers, returning an error for negative numbers.

```rust
let f = |&x: &i32| if x < 0 { Err("Negative element found") } else { Ok(x) };
let v = vec![1, 2];
let res: Result<i32, _> = v.iter().map(f).sum();
assert_eq!(res, Ok(3));
```

```rust
let v = vec![1, -2];
let res: Result<i32, _> = v.iter().map(f).sum();
assert_eq!(res, Err("Negative element found"));
```

--------------------------------

### Debug Implementation for CompressedToken

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.CompressedToken.html

Enables debugging output for CompressedToken instances.

```APIDOC
### impl Debug for CompressedToken

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter.
```

--------------------------------

### Clone Implementation for KvCacheConfig

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheConfig.html

Provides methods to duplicate or copy-assign KvCacheConfig values. Useful for creating copies of existing configurations.

```rust
fn clone(&self) -> KvCacheConfig
```

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

--------------------------------

### Clone Implementation for CompressedToken

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.CompressedToken.html

Provides methods for cloning a CompressedToken instance.

```APIDOC
### impl Clone for CompressedToken

#### fn clone(&self) -> CompressedToken
Returns a duplicate of the value.

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.
```

--------------------------------

### Serialize Implementation for CompressedToken

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.CompressedToken.html

Allows CompressedToken instances to be serialized into a Serde serializer.

```APIDOC
### impl Serialize for CompressedToken

#### fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where __S: Serializer
Serialize this value into the given Serde serializer.
```

--------------------------------

### Any Trait Implementation

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.CompressedToken.html

Provides runtime type information for any type implementing the 'Any' trait.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### QjlQuantizer::new

Source: https://docs.rs/turbo-quant/latest/turbo_quant/qjl/struct.QjlQuantizer.html

Creates a new QJL quantizer with specified dimensions and seed.

```APIDOC
## pub fn new(dim: usize, projections: usize, seed: u64) -> Result<Self>

### Description
Create a new QJL quantizer.

### Parameters
* `dim` (usize): input vector dimension
* `projections` (usize): number of random projections. Higher values reduce estimation variance. Rule of thumb: m ≈ d / 4 for good accuracy.
* `seed` (u64): controls the random projection matrix deterministically
```

--------------------------------

### Serialize Implementation for KvCacheConfig

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheConfig.html

Enables serialization of KvCacheConfig to Serde-compatible data formats. Use this when saving configurations or sending them over a network.

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

--------------------------------

### Calculate Estimated Bytes for QjlSketch

Source: https://docs.rs/turbo-quant/latest/turbo_quant/qjl/struct.QjlSketch.html

Estimates the bytes used by a QjlSketch, considering only the storage for the sign bits.

```rust
pub fn encoded_bytes(&self) -> usize
```

--------------------------------

### map_or_default

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Maps to a `U` using a function for `Ok` or the default value for `U` if `Err`.

```APIDOC
## map_or_default

### Description
Maps a `Result<T, E>` to a `U` by applying a function `f` to the contained value if the result is `Ok`, otherwise if `Err`, returns the default value for the type `U`. This is a nightly-only experimental API.

### Method
`map_or_default<U, F>(self, f: F) -> U` where `F: FnOnce(T) -> U`, `U: Default`

### Parameters
- `f`: A closure that takes the `Ok` value and returns a `U`.

### Request Example
```rust
#![feature(result_option_map_or_default)]

let x: Result<_, &str> = Ok("foo");
let y: Result<&str, _> = Err("bar");

assert_eq!(x.map_or_default(|x| x.len()), 3);
assert_eq!(y.map_or_default(|y| y.len()), 0);
```

### Response
- The result of the closure `f` if the original result was `Ok(T)`.
- The default value of `U` if the original result was `Err(E)`.
```

--------------------------------

### Debug Implementation for CompressedToken

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.CompressedToken.html

Enables formatted output for debugging purposes.

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

--------------------------------

### Clone QjlQuantizer

Source: https://docs.rs/turbo-quant/latest/turbo_quant/qjl/struct.QjlQuantizer.html

Creates a duplicate of the QjlQuantizer instance.

```rust
fn clone(&self) -> QjlQuantizer
```

--------------------------------

### QjlQuantizer::sketch

Source: https://docs.rs/turbo-quant/latest/turbo_quant/qjl/struct.QjlQuantizer.html

Projects a vector to a QJL sketch.

```APIDOC
## pub fn sketch(&self, vector: &[f32]) -> Result<QjlSketch>

### Description
Project `vector` to a `QjlSketch`.
Computes sign(G · x) for random G ~ N(0, 1)^{m×d}, storing only the signs. The projection matrix is regenerated from seed.

### Parameters
* `vector` (&[f32]): The input vector to sketch.
```

--------------------------------

### Product Implementation

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Implements the Product trait for Result, enabling the calculation of the product of elements in an iterator where each element is a Result.

```APIDOC
## `impl<T, U, E> Product<Result<U, E>> for Result<T, E>`

### `product<I>(iter: I) -> Result<T, E>`
where I: Iterator<Item = Result<U, E>>,
Takes each element in the `Iterator`: if it is an `Err`, no further elements are taken, and the `Err` is returned. Should no `Err` occur, the product of all elements is returned.

#### Examples
This multiplies each number in a vector of strings, if a string could not be parsed the operation returns `Err`:
```
let nums = vec!["5", "10", "1", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert_eq!(total, Ok(100));
let nums = vec!["5", "10", "one", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert!(total.is_err());
```
```

--------------------------------

### Compress and store a token pair

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheCompressor.html

Compresses and stores a single (key, value) token pair. This operation takes O(d) time, where d is the dimension of the key/value vectors. It should be called once per generation step.

```rust
pub fn compress_token(&mut self, key: &[f32], value: &[f32]) -> Result<()>
```

--------------------------------

### KvCacheCompressor::new

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheCompressor.html

Creates a new KvCacheCompressor instance for a single attention head.

```APIDOC
## KvCacheCompressor::new

### Description
Creates a new compressor for one attention head.

### Signature
```rust
pub fn new(config: KvCacheConfig) -> Result<Self>
```

### Parameters
* `config` (KvCacheConfig) - Configuration for the KV cache compressor.
```

--------------------------------

### as_ref

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Converts `&Result<T, E>` to `Result<&T, &E>`.

```APIDOC
## as_ref

### Description
Converts a reference to a `Result<T, E>` into a `Result<&T, &E>`, leaving the original `Result` unchanged.

### Method
`as_ref()`

### Parameters
None

### Request Example
```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

### Response
- `Ok(&T)` if the original result was `Ok(T)`.
- `Err(&E)` if the original result was `Err(E)`.
```

--------------------------------

### Serialize Implementation for CompressedToken

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.CompressedToken.html

Allows serialization of CompressedToken to a Serde serializer.

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

--------------------------------

### expect

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Returns the contained Ok value, consuming the self value. Panics if the value is an Err.

```APIDOC
## pub fn expect(self, msg: &str) -> T
where E: Debug

### Description
Returns the contained `Ok` value, consuming the `self` value.
Because this function may panic, its use is generally discouraged. Instead, prefer to use pattern matching and handle the `Err` case explicitly, or call `unwrap_or`, `unwrap_or_else`, or `unwrap_or_default`.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```rust
let x: Result<u32, &str> = Err("emergency failure");
x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
```

### Response
#### Success Response (200)
- None

#### Response Example
- None

### Panics
Panics if the value is an `Err`, with a panic message including the passed message, and the content of the `Err`.
```

--------------------------------

### unwrap

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Returns the contained Ok value, consuming the self value. Panics if the value is an Err.

```APIDOC
## pub fn unwrap(self) -> T
where E: Debug

### Description
Returns the contained `Ok` value, consuming the `self` value.
Because this function may panic, its use is generally discouraged. Panics are meant for unrecoverable errors, and may abort the entire program.
Instead, prefer to use the `?` (try) operator, or pattern matching to handle the `Err` case explicitly, or call `unwrap_or`, `unwrap_or_else`, or `unwrap_or_default`.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
- None

### Response
#### Success Response (200)
- None

#### Response Example
- None
```

--------------------------------

### VZip<V> for T

Source: https://docs.rs/turbo-quant/latest/turbo_quant/qjl/struct.QjlQuantizer.html

Provides the `vzip` method for creating a VZip structure.

```APIDOC
## fn vzip(self) -> V

### Description
Creates a VZip structure.

### Method
`vzip`

### Parameters
- **self** (T) - The value to zip.
```

--------------------------------

### Using or to Provide a Default Error Value

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Illustrates the `or` method, which returns the `Ok` value of `self` if it is `Ok`, otherwise returns the provided `Result`. Arguments to `or` are eagerly evaluated.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Ok(2));

let x: Result<u32, &str> = Err("early error");
let y: Result<u32, &str> = Ok(2);
assert_eq!(x.or(y), Ok(2));

let x: Result<u32, &str> = Err("not a 2");
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Err("late error"));

let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Ok(100);
assert_eq!(x.or(y), Ok(2));
```

--------------------------------

### Type Conversion Operations

Source: https://docs.rs/turbo-quant/latest/turbo_quant/turbo/struct.TurboQuantizer.html

Provides methods for attempting conversions between types using `TryFrom` and `TryInto` traits.

```APIDOC
## type Error = Infallible

The type returned in the event of a conversion error.

## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

## type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
```

--------------------------------

### into_ok() for Infallible Results

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Safely extracts the Ok value from a Result that is guaranteed not to be an Err, preventing potential panics.

```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```

--------------------------------

### Same Trait Implementation

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.CompressedToken.html

Indicates that a type is the same as its output type.

```rust
type Output = T
```

--------------------------------

### Clone TurboQuantizer

Source: https://docs.rs/turbo-quant/latest/turbo_quant/turbo/struct.TurboQuantizer.html

Creates a duplicate of the `TurboQuantizer` instance.

```rust
fn clone(&self) -> TurboQuantizer
```

--------------------------------

### Using unwrap_or_else with a Closure

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Demonstrates `unwrap_or_else`, which returns the contained `Ok` value or computes a default value using a closure if the `Result` is `Err`. This allows for lazy evaluation of the default value.

```rust
fn count(x: &str) -> usize { x.len() }

assert_eq!(Ok(2).unwrap_or_else(count), 2);
assert_eq!(Err("foo").unwrap_or_else(count), 3);
```

--------------------------------

### StructuralPartialEq Implementation for KvCacheConfig

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheConfig.html

Trait implementation for structural partial equality comparison.

--------------------------------

### clone_into

Source: https://docs.rs/turbo-quant/latest/turbo_quant/qjl/struct.QjlSketch.html

Uses borrowed data to replace owned data, usually by cloning.

```APIDOC
## clone_into

### Description
Uses borrowed data to replace owned data, usually by cloning.

### Method
`&self` (method on `QjlSketch`)

### Parameters
- **target** (`&mut T`) - The mutable reference to the owned data to be replaced.

### Returns
None
```

--------------------------------

### unwrap_or_default

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Returns the contained Ok value or a default value if the Result is Err.

```APIDOC
## unwrap_or_default

### Description
Returns the contained `Ok` value or a default value if the `Result` is `Err`. This method consumes the `self` argument.

### Method
`unwrap_or_default()`

### Parameters
None

### Request Example
```rust
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().unwrap_or_default();
let bad_year = bad_year_from_input.parse().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);
```

### Response
#### Success Response (Ok value or Default)
- Returns the contained `Ok` value if the `Result` is `Ok`.
- Returns the default value for the type if the `Result` is `Err`.

#### Response Example
```rust
// Assuming T: Default
let result: Result<T, E> = Ok(some_value);
let value = result.unwrap_or_default(); // value is some_value

let result: Result<T, E> = Err(some_error);
let value = result.unwrap_or_default(); // value is T::default()
```
```

--------------------------------

### KvCacheCompressor::compression_ratio

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.KvCacheCompressor.html

Calculates the compression ratio.

```APIDOC
## KvCacheCompressor::compression_ratio

### Description
Compression ratio: uncompressed / compressed.

### Signature
```rust
pub fn compression_ratio(&self) -> f32
```

### Returns
* `f32` - The compression ratio.
```

--------------------------------

### map_or

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Returns a default value if `Err`, or applies a function to the `Ok` value.

```APIDOC
## map_or

### Description
Returns a provided default value if the `Result` is `Err`, or applies a function to the contained `Ok` value. Arguments are eagerly evaluated.

### Method
`map_or<U, F>(self, default: U, f: F) -> U` where `F: FnOnce(T) -> U`

### Parameters
- `default`: The default value to return if the result is `Err`.
- `f`: A closure that takes the `Ok` value and returns a `U`.

### Request Example
```rust
let x: Result<_, &str> = Ok("foo");
assert_eq!(x.map_or(42, |v| v.len()), 3);

let x: Result<&str, _> = Err("bar");
assert_eq!(x.map_or(42, |v| v.len()), 42);
```

### Response
- The result of the closure `f` if the original result was `Ok(T)`.
- The `default` value if the original result was `Err(E)`.
```

--------------------------------

### unwrap

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Returns the contained Ok value. Panics if the value is an Err, with a panic message provided by the Err's value.

```APIDOC
## unwrap

### Description
Returns the contained `Ok` value. Panics if the value is an `Err`, with a panic message provided by the `Err`’s value.

### Method
`unwrap()`

### Parameters
None

### Request Example
```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

### Response
#### Success Response (Ok value)
- Returns the contained `Ok` value.

#### Response Example
```rust
let x: Result<u32, &str> = Ok(2);
x.unwrap(); // returns 2
```

#### Error Handling
- Panics if the value is an `Err`.

#### Panic Example
```rust
let x: Result<u32, &str> = Err("emergency failure");
x.unwrap(); // panics with `emergency failure`
```
```

--------------------------------

### Ownership and Cloning Operations

Source: https://docs.rs/turbo-quant/latest/turbo_quant/turbo/struct.TurboQuantizer.html

Methods for creating owned data from borrowed data and updating owned data with borrowed data.

```APIDOC
## type Owned = T

The resulting type after obtaining ownership.

## fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

## fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
```

--------------------------------

### Convert Result to Option with Ok value

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

The `ok()` method converts a `Result<T, E>` into an `Option<T>`. If the Result is `Ok(v)`, it returns `Some(v)`. If it's `Err(_)`, it returns `None`. This consumes the Result.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

--------------------------------

### Type Conversion

Source: https://docs.rs/turbo-quant/latest/turbo_quant/polar/struct.PolarQuantizer.html

Methods for performing type conversions using `TryFrom` and `TryInto` traits.

```APIDOC
## impl<T, U> TryFrom<U> for T

### Description
Provides a fallible way to convert one type into another.

#### type Error = Infallible

### Description
The type returned in the event of a conversion error. In this case, the conversion is infallible.

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion from type `U` to type `T`.

### Method
`try_from`

### Parameters
- **value** (`U`): The value to convert.

### Response
- `Result<T, Infallible>`: The converted value of type `T` or an error if the conversion fails (though this specific implementation is infallible).
```

```APIDOC
## impl<T, U> TryInto<U> for T

### Description
Provides a fallible way to convert a type into another type using the `TryInto` trait.

#### type Error = <U as TryFrom<T>>::Error

### Description
The type returned in the event of a conversion error.

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion from type `T` to type `U`.

### Method
`try_into`

### Parameters
- **self** (`T`): The value to convert.

### Response
- `Result<U, <U as TryFrom<T>>::Error>`: The converted value of type `U` or an error if the conversion fails.
```

--------------------------------

### PolarCode Implementations

Source: https://docs.rs/turbo-quant/latest/turbo_quant/polar/struct.PolarCode.html

Provides methods for interacting with PolarCode, such as calculating pair counts, dequantizing angles, and estimating memory usage.

```APIDOC
### impl PolarCode

#### pub fn pair_count(&self) -> usize
Number of pairs (= dim / 2).

#### pub fn dequantize_angle(&self, i: usize) -> f32
Reconstruct the dequantized angle for pair `i` in radians ∈ [−π, π).

#### pub fn encoded_bytes(&self) -> usize
Approximate memory used by this code in bytes.
```

--------------------------------

### as_mut

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Converts `&mut Result<T, E>` to `Result<&mut T, &mut E>`.

```APIDOC
## as_mut

### Description
Converts a mutable reference to a `Result<T, E>` into a `Result<&mut T, &mut E>`, allowing in-place modification of the contained value.

### Method
`as_mut()`

### Parameters
None

### Request Example
```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

### Response
- `Ok(&mut T)` if the original result was `Ok(T)`.
- `Err(&mut E)` if the original result was `Err(E)`.
```

--------------------------------

### Deserialize Implementation for CompressedToken

Source: https://docs.rs/turbo-quant/latest/turbo_quant/kv/struct.CompressedToken.html

Allows CompressedToken instances to be deserialized from a Serde deserializer.

```APIDOC
### impl<'de> Deserialize<'de> for CompressedToken

#### fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where __D: Deserializer<'de>
Deserialize this value from the given Serde deserializer.
```

--------------------------------

### PartialEq Implementation for QjlSketch

Source: https://docs.rs/turbo-quant/latest/turbo_quant/qjl/struct.QjlSketch.html

Implements the `PartialEq` trait for comparing two QjlSketch instances for equality.

```rust
fn eq(&self, other: &QjlSketch) -> bool
```

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

--------------------------------

### QjlSketch Fields Explanation

Source: https://docs.rs/turbo-quant/latest/turbo_quant/qjl/struct.QjlSketch.html

Explains the fields of the QjlSketch struct: `dim` for the original vector dimension, `projections` for the number of random projections, and `signs` for the stored sign bits.

```rust
/// The dimension of the original vector.
    pub dim: usize,
    /// Number of random projections (sketch dimension).
    pub projections: usize,
    /// Sign bits: each entry is +1 or -1.
    pub signs: Vec<i8>,
```

--------------------------------

### impl Result<T, E>: is_ok_and

Source: https://docs.rs/turbo-quant/latest/turbo_quant/error/type.Result.html

Returns `true` if the result is `Ok` and the contained value satisfies a given predicate.

```APIDOC
## impl<T, E> Result<T, E>

### is_ok_and

```rust
pub fn is_ok_and<F>(self, f: F) -> bool
where F: FnOnce(T) -> bool,
```

Returns `true` if the result is `Ok` and the value inside of it matches a predicate.

#### Examples

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```
```

--------------------------------

### PolarCode Trait Implementations

Source: https://docs.rs/turbo-quant/latest/turbo_quant/polar/struct.PolarCode.html

Details the trait implementations for PolarCode, including Clone, Debug, Deserialize, JsonSchema, PartialEq, and Serialize.

```APIDOC
### impl Clone for PolarCode

#### fn clone(&self) -> PolarCode
Returns a duplicate of the value. Read more

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`. Read more

### impl Debug for PolarCode

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more

### impl<'de> Deserialize<'de> for PolarCode

#### fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more

### impl JsonSchema for PolarCode

#### fn schema_name() -> String
The name of the generated JSON Schema. Read more

#### fn schema_id() -> Cow<'static, str>
Returns a string that uniquely identifies the schema produced by this type. Read more

#### fn json_schema(generator: &mut SchemaGenerator) -> Schema
Generates a JSON Schema for this type. Read more

#### fn is_referenceable() -> bool
Whether JSON Schemas generated for this type should be re-used where possible using the `$ref` keyword. Read more

### impl PartialEq for PolarCode

#### fn eq(&self, other: &PolarCode) -> bool
Tests for `self` and `other` values to be equal, and is used by `==`.

#### fn ne(&self, other: &Rhs) -> bool
Tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.

### impl Serialize for PolarCode

#### fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where __S: Serializer,
Serialize this value into the given Serde serializer. Read more
```
Tokens:
Raw