use crate::device::WgpuDevice;
use crate::error::{BarracudaError, Result};
use crate::linalg::cholesky::cholesky_f64;
use crate::ops::linalg::BatchedEighGpu;
use std::sync::Arc;
#[derive(Debug, Clone)]
pub struct GenEighDecompositionGpu {
pub eigenvalues: Vec<f64>,
pub eigenvectors: Vec<f64>,
pub n: usize,
}
impl GenEighDecompositionGpu {
#[must_use]
pub fn eigenvector(&self, i: usize) -> Option<Vec<f64>> {
if i >= self.n {
return None;
}
let mut v = vec![0.0; self.n];
for (row, v_row) in v.iter_mut().enumerate() {
*v_row = self.eigenvectors[row * self.n + i];
}
Some(v)
}
pub fn sort_descending(&mut self) {
let n = self.n;
let mut indices: Vec<usize> = (0..n).collect();
indices.sort_by(|&a, &b| {
self.eigenvalues[b]
.partial_cmp(&self.eigenvalues[a])
.unwrap_or(std::cmp::Ordering::Equal)
});
let old_eigenvalues = self.eigenvalues.clone();
let old_eigenvectors = self.eigenvectors.clone();
for (new_idx, &old_idx) in indices.iter().enumerate() {
self.eigenvalues[new_idx] = old_eigenvalues[old_idx];
for row in 0..n {
self.eigenvectors[row * n + new_idx] = old_eigenvectors[row * n + old_idx];
}
}
}
#[must_use]
pub fn verify(&self, a: &[f64], b: &[f64]) -> f64 {
let n = self.n;
let mut max_residual: f64 = 0.0;
for i in 0..n {
let lambda = self.eigenvalues[i];
let x: Vec<f64> = (0..n).map(|row| self.eigenvectors[row * n + i]).collect();
let mut ax = vec![0.0; n];
for row in 0..n {
for col in 0..n {
ax[row] = a[row * n + col].mul_add(x[col], ax[row]);
}
}
let mut lbx = vec![0.0; n];
for row in 0..n {
for col in 0..n {
lbx[row] = (lambda * b[row * n + col]).mul_add(x[col], lbx[row]);
}
}
let residual_norm: f64 = ax
.iter()
.zip(lbx.iter())
.map(|(a, b)| (a - b).powi(2))
.sum::<f64>()
.sqrt();
let x_norm: f64 = x.iter().map(|v| v.powi(2)).sum::<f64>().sqrt();
let relative_residual = residual_norm / x_norm.max(1e-15);
max_residual = max_residual.max(relative_residual);
}
max_residual
}
}
pub struct GenEighGpu;
impl GenEighGpu {
pub fn execute_f64(
device: Arc<WgpuDevice>,
a: &[f64],
b: &[f64],
n: usize,
max_sweeps: u32,
) -> Result<GenEighDecompositionGpu> {
let expected_len = n * n;
if a.len() != expected_len {
return Err(BarracudaError::InvalidInput {
message: format!(
"Matrix A has wrong size: expected {}, got {}",
expected_len,
a.len()
),
});
}
if b.len() != expected_len {
return Err(BarracudaError::InvalidInput {
message: format!(
"Matrix B has wrong size: expected {}, got {}",
expected_len,
b.len()
),
});
}
let chol = cholesky_f64(device.clone(), b, n)?;
let l = &chol.l;
let l_inv_a = solve_lower_triangular_matrix(l, a, n);
let c = compute_symmetric_transform(l, &l_inv_a, n);
let (eigenvalues, eigenvectors_c) = BatchedEighGpu::execute_f64(
device, &c, n, 1, max_sweeps,
)?;
let eigenvectors = back_transform_eigenvectors(l, &eigenvectors_c, n);
Ok(GenEighDecompositionGpu {
eigenvalues,
eigenvectors,
n,
})
}
pub fn execute_batch_f64(
device: Arc<WgpuDevice>,
a_batch: &[f64],
b_batch: &[f64],
n: usize,
batch_size: usize,
max_sweeps: u32,
) -> Result<Vec<GenEighDecompositionGpu>> {
let expected_len = batch_size * n * n;
if a_batch.len() != expected_len {
return Err(BarracudaError::InvalidInput {
message: format!(
"A batch has wrong size: expected {}, got {}",
expected_len,
a_batch.len()
),
});
}
if b_batch.len() != expected_len {
return Err(BarracudaError::InvalidInput {
message: format!(
"B batch has wrong size: expected {}, got {}",
expected_len,
b_batch.len()
),
});
}
let mut c_batch = vec![0.0; expected_len];
let mut l_batch = vec![0.0; expected_len];
for i in 0..batch_size {
let offset = i * n * n;
let a = &a_batch[offset..offset + n * n];
let b = &b_batch[offset..offset + n * n];
let chol = cholesky_f64(device.clone(), b, n)?;
let l = &chol.l;
l_batch[offset..offset + n * n].copy_from_slice(l);
let l_inv_a = solve_lower_triangular_matrix(l, a, n);
let c = compute_symmetric_transform(l, &l_inv_a, n);
c_batch[offset..offset + n * n].copy_from_slice(&c);
}
let (eigenvalues_batch, eigenvectors_c_batch) =
BatchedEighGpu::execute_f64(device, &c_batch, n, batch_size, max_sweeps)?;
let mut results = Vec::with_capacity(batch_size);
for i in 0..batch_size {
let offset = i * n * n;
let eig_offset = i * n;
let l = &l_batch[offset..offset + n * n];
let eigenvectors_c = &eigenvectors_c_batch[offset..offset + n * n];
let eigenvalues: Vec<f64> = eigenvalues_batch[eig_offset..eig_offset + n].to_vec();
let eigenvectors = back_transform_eigenvectors(l, eigenvectors_c, n);
results.push(GenEighDecompositionGpu {
eigenvalues,
eigenvectors,
n,
});
}
Ok(results)
}
}
fn solve_lower_triangular_matrix(l: &[f64], a: &[f64], n: usize) -> Vec<f64> {
let mut result = vec![0.0; n * n];
for col in 0..n {
let mut y = vec![0.0; n];
for row in 0..n {
y[row] = a[row * n + col];
}
for i in 0..n {
let mut sum = y[i];
for j in 0..i {
sum = l[i * n + j].mul_add(-y[j], sum);
}
let diag = l[i * n + i];
y[i] = if diag.abs() > 1e-15 { sum / diag } else { 0.0 };
}
for row in 0..n {
result[row * n + col] = y[row];
}
}
result
}
fn compute_symmetric_transform(l: &[f64], l_inv_a: &[f64], n: usize) -> Vec<f64> {
let mut l_inv = vec![0.0; n * n];
for i in 0..n {
let mut x = vec![0.0; n];
x[i] = 1.0;
for row in 0..n {
let mut sum = if row == i { 1.0 } else { 0.0 };
for k in 0..row {
sum = l[row * n + k].mul_add(-x[k], sum);
}
let diag = l[row * n + row];
x[row] = if diag.abs() > 1e-15 { sum / diag } else { 0.0 };
}
for row in 0..n {
l_inv[row * n + i] = x[row];
}
}
let mut c = vec![0.0; n * n];
for i in 0..n {
for j in 0..n {
let mut sum = 0.0;
for k in 0..n {
sum = l_inv_a[i * n + k].mul_add(l_inv[j * n + k], sum);
}
c[i * n + j] = sum;
}
}
c
}
fn back_transform_eigenvectors(l: &[f64], eigenvectors_c: &[f64], n: usize) -> Vec<f64> {
let mut result = vec![0.0; n * n];
for col in 0..n {
let mut y = vec![0.0; n];
for row in 0..n {
y[row] = eigenvectors_c[row * n + col];
}
let mut x = vec![0.0; n];
for i in (0..n).rev() {
let mut sum = y[i];
for j in (i + 1)..n {
sum = l[j * n + i].mul_add(-x[j], sum);
}
let diag = l[i * n + i];
x[i] = if diag.abs() > 1e-15 { sum / diag } else { 0.0 };
}
for row in 0..n {
result[row * n + col] = x[row];
}
}
result
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_solve_lower_triangular() {
let l = vec![2.0, 0.0, 1.0, 3.0];
let a = vec![1.0, 0.0, 0.0, 1.0];
let n = 2;
let result = solve_lower_triangular_matrix(&l, &a, n);
assert!((result[0] - 0.5).abs() < 1e-10);
assert!((result[1] - 0.0).abs() < 1e-10);
assert!((result[2] - (-1.0 / 6.0)).abs() < 1e-10);
assert!((result[3] - (1.0 / 3.0)).abs() < 1e-10);
}
#[test]
fn test_back_transform() {
let l = vec![2.0, 0.0, 0.0, 2.0];
let eigenvectors = vec![1.0, 0.0, 0.0, 1.0];
let n = 2;
let result = back_transform_eigenvectors(&l, &eigenvectors, n);
assert!((result[0] - 0.5).abs() < 1e-10);
assert!((result[1] - 0.0).abs() < 1e-10);
assert!((result[2] - 0.0).abs() < 1e-10);
assert!((result[3] - 0.5).abs() < 1e-10);
}
}