Struct IncoherenceTransform 

pub struct IncoherenceTransform { /* private fields */ }

Aggregate root for incoherence processing in quantization pipelines

This struct manages the lifecycle of incoherence transforms, including:

• Transform creation and caching
• Forward/inverse transform application
• Statistics collection
• Domain event emission

Example

use ruvllm::quantize::incoherence::{IncoherenceTransform, IncoherenceConfig};

// Create transform with default config
let mut transform = IncoherenceTransform::new(IncoherenceConfig::default())?;

// Apply before quantization
let mut weights = vec![1.0, 2.0, 100.0, 4.0]; // Note the outlier
transform.apply_before_quantization(&mut weights)?;

// ... quantize weights here ...

// Restore after dequantization
transform.restore_after_dequantization(&mut weights)?;

Implementations

impl IncoherenceTransform

pub fn new(config: IncoherenceConfig) -> Result<Self>

Create a new IncoherenceTransform with the given configuration

pub fn with_defaults() -> Result<Self>

Create with default configuration

pub fn apply_before_quantization( &mut self, data: &mut Vec<f32>, ) -> Result<usize>

Apply incoherence transform before quantization

This transforms the weight data to spread outliers uniformly, reducing quantization error. The data is modified in-place.

Arguments

• data - Mutable slice of weight values to transform

Returns

The padded dimension (data is resized to this power of 2)

pub fn restore_after_dequantization( &mut self, data: &mut Vec<f32>, original_len: Option<usize>, ) -> Result<()>

Restore original data distribution after dequantization

This applies the inverse transform to recover the original weight distribution. The data must have the same length as after apply_before_quantization.

Arguments

• data - Mutable slice of dequantized values to restore
• original_len - Original length before padding (optional, for truncation)

pub fn apply_batch( &mut self, data: &mut [f32], dim: usize, batch_size: usize, ) -> Result<()>

Apply incoherence to a batch of weight vectors

More efficient than individual transforms due to better cache utilization.

Arguments

• data - Flat buffer containing batch_size vectors of dim elements each
• dim - Dimension of each vector (must be power of 2)
• batch_size - Number of vectors

pub fn restore_batch( &mut self, data: &mut [f32], dim: usize, batch_size: usize, ) -> Result<()>

Restore a batch of weight vectors after dequantization

pub fn stats(&self) -> &IncoherenceStats

Get accumulated statistics

pub fn take_events(&mut self) -> Vec<IncoherenceEvent>

Take and clear emitted events

pub fn events(&self) -> &[IncoherenceEvent]

Peek at emitted events without clearing

pub fn config(&self) -> &IncoherenceConfig

Get configuration

pub fn reset_stats(&mut self)

Reset statistics

pub fn clear_cache(&mut self)

Clear cached transforms (useful for memory management)

pub fn verify(&mut self, dim: usize, tolerance: f32) -> Result<bool>

Verify that the transform is working correctly

This performs a roundtrip test to ensure the implementation is correct.