ruvnet--RuView/vendor/sublinear-time-solver/src/sublinear/dimension_reduction.rs

//! Dimension reduction techniques for sublinear algorithms

use crate::types::Precision;
use crate::error::{SolverError, Result};
use crate::sublinear::johnson_lindenstrauss::JLEmbedding;
use alloc::{vec::Vec, string::String};

/// Dimension reduction method
#[derive(Debug, Clone, PartialEq)]
pub enum ReductionMethod {
    /// Johnson-Lindenstrauss embedding
    JohnsonLindenstrauss,
    /// Random projection
    RandomProjection,
    /// Principal Component Analysis (simplified)
    PCA,
    /// Sparse random projection
    SparseRandomProjection,
}

/// Dimension reduction engine
#[derive(Debug)]
pub struct DimensionReducer {
    method: ReductionMethod,
    original_dim: usize,
    target_dim: usize,
    jl_embedding: Option<JLEmbedding>,
}

impl DimensionReducer {
    /// Create new dimension reducer
    pub fn new(
        method: ReductionMethod,
        original_dim: usize,
        target_dim: usize,
        distortion: Option<Precision>,
        seed: Option<u64>,
    ) -> Result<Self> {
        if target_dim > original_dim {
            return Err(SolverError::InvalidInput {
                message: "Target dimension must be <= original dimension".to_string(),
                parameter: Some("target_dim".to_string()),
            });
        }

        let jl_embedding = if method == ReductionMethod::JohnsonLindenstrauss {
            Some(JLEmbedding::new(original_dim, distortion.unwrap_or(0.1), seed)?)
        } else {
            None
        };

        Ok(Self {
            method,
            original_dim,
            target_dim,
            jl_embedding,
        })
    }

    /// Reduce dimension of vector
    pub fn reduce_vector(&self, vector: &[Precision]) -> Result<Vec<Precision>> {
        match self.method {
            ReductionMethod::JohnsonLindenstrauss => {
                if let Some(ref jl) = self.jl_embedding {
                    jl.project_vector(vector)
                } else {
                    Err(SolverError::AlgorithmError {
                        algorithm: "dimension_reduction".to_string(),
                        message: "JL embedding not initialized".to_string(),
                        context: vec![],
                    })
                }
            }
            _ => {
                // Simple truncation for other methods
                Ok(vector[..self.target_dim.min(vector.len())].to_vec())
            }
        }
    }

    /// Reconstruct vector in original space
    pub fn reconstruct_vector(&self, reduced: &[Precision]) -> Result<Vec<Precision>> {
        match self.method {
            ReductionMethod::JohnsonLindenstrauss => {
                if let Some(ref jl) = self.jl_embedding {
                    jl.reconstruct_vector(reduced)
                } else {
                    Err(SolverError::AlgorithmError {
                        algorithm: "dimension_reduction".to_string(),
                        message: "JL embedding not initialized".to_string(),
                        context: vec![],
                    })
                }
            }
            _ => {
                // Simple padding for other methods
                let mut reconstructed = reduced.to_vec();
                reconstructed.resize(self.original_dim, 0.0);
                Ok(reconstructed)
            }
        }
    }
}