use alloc::vec;
use alloc::vec::Vec;
use deep_causality_algebra::{ConjugateScalar, Real};
use deep_causality_num::{One, Zero};
type Re<T> = <T as ConjugateScalar>::Real;
const MAX_SWEEPS: usize = 100;
pub(crate) fn sym_eig<T: ConjugateScalar>(mat: &[T], n: usize) -> (Vec<T>, Vec<T>) {
let mut a = mat.to_vec();
let mut v = vec![T::zero(); n * n];
for i in 0..n {
v[i * n + i] = T::one();
}
let one = Re::<T>::one();
let two = one + one;
let eps2 = Re::<T>::epsilon() * Re::<T>::epsilon();
let norm_sq = a
.iter()
.fold(Re::<T>::zero(), |acc, x| acc + x.modulus_squared());
let threshold = if norm_sq.is_finite() {
eps2 * norm_sq
} else {
eps2
};
for _ in 0..MAX_SWEEPS {
let mut off = Re::<T>::zero();
for p in 0..n {
for q in (p + 1)..n {
off += a[p * n + q].modulus_squared();
}
}
if off <= threshold {
break;
}
for p in 0..n {
for q in (p + 1)..n {
let apq = a[p * n + q];
let gmod = apq.modulus(); if gmod <= Re::<T>::zero() {
continue;
}
let app = a[p * n + p].real_part();
let aqq = a[q * n + q].real_part();
let zeta = (app - aqq) / (two * gmod);
let t = if zeta == Re::<T>::zero() {
one
} else {
let sgn = if zeta < Re::<T>::zero() { -one } else { one };
sgn / (zeta.abs() + (zeta * zeta + one).sqrt())
};
let c = one / (t * t + one).sqrt();
let s = t * c;
let rho = apq * T::from_real(one / gmod);
let ct = T::from_real(c);
let cs = T::from_real(s);
let conj_rho = rho.conjugate();
let srho = conj_rho * cs;
let crho = conj_rho * ct;
let rs = rho * cs;
let rc = rho * ct;
for i in 0..n {
let aip = a[i * n + p];
let aiq = a[i * n + q];
a[i * n + p] = ct * aip + srho * aiq;
a[i * n + q] = crho * aiq - cs * aip;
}
for j in 0..n {
let apj = a[p * n + j];
let aqj = a[q * n + j];
a[p * n + j] = ct * apj + rs * aqj;
a[q * n + j] = rc * aqj - cs * apj;
}
for i in 0..n {
let vip = v[i * n + p];
let viq = v[i * n + q];
v[i * n + p] = ct * vip + srho * viq;
v[i * n + q] = crho * viq - cs * vip;
}
}
}
}
let evals: Vec<T> = (0..n).map(|i| a[i * n + i]).collect();
(evals, v)
}
pub(crate) fn householder_qr<T: ConjugateScalar>(
a_in: &[T],
m: usize,
n: usize,
) -> (Vec<T>, Vec<T>, usize) {
let k = m.min(n);
let mut r = a_in.to_vec();
let mut q = vec![T::zero(); m * m];
for i in 0..m {
q[i * m + i] = T::one();
}
let eps = Re::<T>::epsilon();
let mut frob_sq = Re::<T>::zero();
for x in &r {
frob_sq += x.modulus_squared();
}
let floor = frob_sq * eps * eps;
for j in 0..k {
let mut norm_sq = Re::<T>::zero();
for i in j..m {
norm_sq += r[i * n + j].modulus_squared();
}
if norm_sq <= floor {
continue;
}
let norm = norm_sq.sqrt();
let pivot = r[j * n + j];
let pmod = pivot.modulus();
let phase = if pmod > Re::<T>::zero() {
pivot * T::from_real(Re::<T>::one() / pmod)
} else {
T::one()
};
let alpha = -(phase * T::from_real(norm));
let mut v = vec![T::zero(); m];
for i in j..m {
v[i] = r[i * n + j];
}
v[j] -= alpha;
let mut v_norm_sq = Re::<T>::zero();
for vi in v.iter().skip(j) {
v_norm_sq += vi.modulus_squared();
}
if v_norm_sq <= Re::<T>::zero() {
continue;
}
let beta = (Re::<T>::one() + Re::<T>::one()) / v_norm_sq;
for col in j..n {
let mut dot = T::zero();
for i in j..m {
dot += v[i].conjugate() * r[i * n + col];
}
let factor = T::from_real(beta) * dot;
for i in j..m {
r[i * n + col] -= factor * v[i];
}
}
for row in 0..m {
let mut dot = T::zero();
for i in j..m {
dot += q[row * m + i] * v[i];
}
let factor = T::from_real(beta) * dot;
for i in j..m {
q[row * m + i] -= factor * v[i].conjugate();
}
}
}
let mut q_thin = vec![T::zero(); m * k];
for i in 0..m {
for c in 0..k {
q_thin[i * k + c] = q[i * m + c];
}
}
let mut r_thin = vec![T::zero(); k * n];
for i in 0..k {
for col in 0..n {
r_thin[i * n + col] = if col < i { T::zero() } else { r[i * n + col] };
}
}
(q_thin, r_thin, k)
}
pub(crate) fn conj_transpose<T: ConjugateScalar>(data: &[T], rows: usize, cols: usize) -> Vec<T> {
let mut out = vec![T::zero(); rows * cols];
for i in 0..rows {
for j in 0..cols {
out[j * rows + i] = data[i * cols + j].conjugate();
}
}
out
}
pub(crate) fn jacobi_svd<T>(mut u: Vec<T>, rows: usize, cols: usize) -> (Vec<T>, Vec<Re<T>>, Vec<T>)
where
T: ConjugateScalar,
{
let two = Re::<T>::one() + Re::<T>::one();
let mut tol = Re::<T>::epsilon();
for _ in 0..6 {
tol = tol + tol; }
let max_sweeps = 60usize;
let mut v = vec![T::zero(); cols * cols];
for i in 0..cols {
v[i * cols + i] = T::one();
}
let eps = Re::<T>::epsilon();
let mut max_abs = Re::<T>::zero();
for x in u.iter() {
let m = x.modulus();
if m > max_abs {
max_abs = m;
}
}
let mut scale = Re::<T>::one();
const MAX_RESCALE_STEPS: usize = 4096;
if max_abs > Re::<T>::zero() && max_abs.is_finite() {
let half = Re::<T>::one() / two;
let mut steps = 0usize;
while max_abs < Re::<T>::one() && steps < MAX_RESCALE_STEPS {
max_abs = max_abs + max_abs;
scale = scale + scale;
steps += 1;
}
while max_abs >= two && steps < MAX_RESCALE_STEPS {
max_abs *= half;
scale *= half;
steps += 1;
}
}
if scale != Re::<T>::one() {
let f = T::from_real(scale);
for entry in u.iter_mut() {
*entry *= f;
}
}
let mut max_diag = Re::<T>::zero();
for j in 0..cols {
let mut nrm = Re::<T>::zero();
for i in 0..rows {
nrm += u[i * cols + j].modulus_squared();
}
if nrm > max_diag {
max_diag = nrm;
}
}
let floor = max_diag * eps * eps;
for _sweep in 0..max_sweeps {
let mut max_off = Re::<T>::zero();
for p in 0..cols {
for q in (p + 1)..cols {
let mut alpha = Re::<T>::zero();
let mut beta = Re::<T>::zero();
let mut gamma = T::zero();
for i in 0..rows {
let uip = u[i * cols + p];
let uiq = u[i * cols + q];
alpha += uip.modulus_squared();
beta += uiq.modulus_squared();
gamma += uip.conjugate() * uiq;
}
if alpha <= floor || beta <= floor {
continue;
}
let gmod = gamma.modulus();
let denom = (alpha * beta).sqrt();
if denom > Re::<T>::zero() {
let rel = gmod / denom;
if rel > max_off {
max_off = rel;
}
if rel <= tol {
continue;
}
} else {
continue;
}
let zeta = (beta - alpha) / (two * gmod);
let sign = if zeta < Re::<T>::zero() {
-Re::<T>::one()
} else {
Re::<T>::one()
};
let az = zeta.abs();
let root = if az > Re::<T>::one() {
let inv = Re::<T>::one() / az;
az * (Re::<T>::one() + inv * inv).sqrt()
} else {
(Re::<T>::one() + zeta * zeta).sqrt()
};
let t = sign / (az + root);
let c = Re::<T>::one() / (Re::<T>::one() + t * t).sqrt();
let s = c * t;
let rho = gamma * T::from_real(Re::<T>::one() / gmod);
let ct = T::from_real(c);
let es = rho * T::from_real(s);
let conj_es = rho.conjugate() * T::from_real(s);
for i in 0..rows {
let uip = u[i * cols + p];
let uiq = u[i * cols + q];
u[i * cols + p] = ct * uip - conj_es * uiq;
u[i * cols + q] = es * uip + ct * uiq;
}
for i in 0..cols {
let vip = v[i * cols + p];
let viq = v[i * cols + q];
v[i * cols + p] = ct * vip - conj_es * viq;
v[i * cols + q] = es * vip + ct * viq;
}
}
}
if max_off <= tol {
break;
}
}
let mut sigma = vec![Re::<T>::zero(); cols];
for j in 0..cols {
let mut norm_sq = Re::<T>::zero();
for i in 0..rows {
norm_sq += u[i * cols + j].modulus_squared();
}
let norm = norm_sq.sqrt();
sigma[j] = norm / scale;
if norm > Re::<T>::zero() {
let inv_norm = T::from_real(Re::<T>::one() / norm);
for i in 0..rows {
u[i * cols + j] *= inv_norm;
}
}
}
(u, sigma, v)
}