use crate::error::{BarracudaError, Result};
use crate::spectral::lanczos::{lanczos, lanczos_eigenvalues};
use crate::spectral::sparse::SpectralCsrMatrix;
use super::CsrMatrix;
fn to_spectral(matrix: &CsrMatrix) -> Result<SpectralCsrMatrix> {
if matrix.n_rows != matrix.n_cols {
return Err(BarracudaError::InvalidInput {
message: format!(
"sparse_eigh requires square matrix, got {}×{}",
matrix.n_rows, matrix.n_cols
),
});
}
Ok(SpectralCsrMatrix {
n: matrix.n_rows,
row_ptr: matrix.row_ptr.clone(),
col_idx: matrix.col_indices.clone(),
values: matrix.values.clone(),
})
}
#[derive(Debug, Clone)]
pub struct SparseEighResult {
pub eigenvalues: Vec<f64>,
pub iterations: usize,
}
pub fn sparse_eigh(matrix: &CsrMatrix, max_iter: usize, seed: u64) -> Result<SparseEighResult> {
let spectral = to_spectral(matrix)?;
let tridiag = lanczos(&spectral, max_iter, seed);
let eigenvalues = lanczos_eigenvalues(&tridiag);
Ok(SparseEighResult {
eigenvalues,
iterations: tridiag.iterations,
})
}
pub fn sparse_eigh_smallest(matrix: &CsrMatrix, k: usize, seed: u64) -> Result<SparseEighResult> {
let max_iter = (3 * k).min(matrix.n_rows);
let mut result = sparse_eigh(matrix, max_iter, seed)?;
result.eigenvalues.truncate(k);
Ok(result)
}
pub fn sparse_eigh_largest(matrix: &CsrMatrix, k: usize, seed: u64) -> Result<SparseEighResult> {
let max_iter = (3 * k).min(matrix.n_rows);
let mut result = sparse_eigh(matrix, max_iter, seed)?;
let n = result.eigenvalues.len();
if n > k {
result.eigenvalues = result.eigenvalues[n - k..].to_vec();
}
Ok(result)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_sparse_eigh_identity() {
let matrix = CsrMatrix {
n_rows: 3,
n_cols: 3,
values: vec![1.0, 1.0, 1.0],
col_indices: vec![0, 1, 2],
row_ptr: vec![0, 1, 2, 3],
};
let result = sparse_eigh(&matrix, 3, 42).unwrap();
assert!(!result.eigenvalues.is_empty());
for &ev in &result.eigenvalues {
assert!((ev - 1.0).abs() < 1e-10, "expected 1.0, got {ev}");
}
}
#[test]
fn test_sparse_eigh_diagonal() {
let matrix = CsrMatrix {
n_rows: 3,
n_cols: 3,
values: vec![1.0, 3.0, 5.0],
col_indices: vec![0, 1, 2],
row_ptr: vec![0, 1, 2, 3],
};
let result = sparse_eigh(&matrix, 3, 123).unwrap();
assert_eq!(result.eigenvalues.len(), 3);
let expected = [1.0, 3.0, 5.0];
for (ev, &exp) in result.eigenvalues.iter().zip(&expected) {
assert!((ev - exp).abs() < 1e-8, "expected {exp}, got {ev}");
}
}
#[test]
fn test_sparse_eigh_smallest_k() {
let matrix = CsrMatrix {
n_rows: 3,
n_cols: 3,
values: vec![1.0, 3.0, 5.0],
col_indices: vec![0, 1, 2],
row_ptr: vec![0, 1, 2, 3],
};
let result = sparse_eigh_smallest(&matrix, 2, 7).unwrap();
assert_eq!(result.eigenvalues.len(), 2);
assert!((result.eigenvalues[0] - 1.0).abs() < 1e-8);
assert!((result.eigenvalues[1] - 3.0).abs() < 1e-8);
}
#[test]
fn test_non_square_rejected() {
let matrix = CsrMatrix {
n_rows: 2,
n_cols: 3,
values: vec![1.0, 2.0],
col_indices: vec![0, 1],
row_ptr: vec![0, 1, 2],
};
assert!(sparse_eigh(&matrix, 2, 0).is_err());
}
}