use crate::application::linalg::scaling::KernelWindow;
use crate::application::linalg::thresholds;
use crate::domain::real::RealScalar;
use leto::ArrayView2;
fn larfg<T: RealScalar>(x: &mut [T], window: KernelWindow<T>) -> (T, T) {
let n = x.len();
if n == 0 {
return (T::ZERO, T::ZERO);
}
if n == 1 {
return (T::ZERO, x[0]);
}
let exponent = window.exponent(x);
let alpha = x[0].scale_binary(-exponent);
let mut xnorm_sq = T::ZERO;
for &xi in &x[1..] {
let xi = xi.scale_binary(-exponent);
xnorm_sq = xnorm_sq.add(xi.mul(xi));
}
if xnorm_sq == T::ZERO {
return (T::ZERO, x[0]);
}
let beta = {
let b = alpha.mul(alpha).add(xnorm_sq).sqrt();
if alpha <= T::ZERO {
b
} else {
T::ZERO.sub(b)
}
};
let tau = beta.sub(alpha).div(beta);
let scal = T::ONE.div(alpha.sub(beta));
for xi in &mut x[1..] {
*xi = xi.scale_binary(-exponent).mul(scal);
}
let beta = beta.scale_binary(exponent);
x[0] = beta;
(tau, beta)
}
pub(super) fn reduce_values<T: RealScalar>(matrix: &ArrayView2<'_, T>) -> (Vec<T>, Vec<T>) {
let [m, n] = matrix.shape();
let mut cm = vec![T::ZERO; m * n];
if let Some(a) = matrix.as_slice() {
for i in 0..m {
let row = &a[i * n..i * n + n];
for (j, &val) in row.iter().enumerate() {
cm[j * m + i] = val;
}
}
} else {
for i in 0..m {
for j in 0..n {
cm[j * m + i] = *matrix.get([i, j]).expect("in bounds");
}
}
}
let window = KernelWindow::new(2, 2, thresholds::ceil_log2_count(m));
let mut d = vec![T::ZERO; n];
let mut e = vec![T::ZERO; n];
let mut vbuf = vec![T::ZERO; m]; let mut w = vec![T::ZERO; n]; let mut aw = vec![T::ZERO; m]; let mut dotbuf = vec![T::ZERO; n];
for k in 0..n {
let vlen = m - k;
let (tau_q, beta_d) = {
let col = &mut cm[k * m + k..k * m + m];
larfg(col, window)
};
d[k] = beta_d;
vbuf[0] = T::ONE;
for r in 1..vlen {
vbuf[r] = cm[k * m + k + r];
}
if tau_q != T::ZERO {
let ntrail = n - k - 1;
if ntrail > 0 {
for slot in dotbuf[..ntrail].iter_mut() {
*slot = T::ZERO;
}
T::gemv_strided(
&cm[(k + 1) * m + k..],
&vbuf[..vlen],
&mut dotbuf[..ntrail],
ntrail,
vlen,
m,
);
for slot in dotbuf[..ntrail].iter_mut() {
*slot = T::ZERO.sub(tau_q.mul(*slot));
}
T::axpy_rows(
&dotbuf[..ntrail],
&vbuf[..vlen],
&mut cm[(k + 1) * m + k..],
m,
ntrail,
vlen,
);
}
}
if k + 1 < n {
let rlen = n - k - 1;
for (idx, j) in ((k + 1)..n).enumerate() {
w[idx] = cm[j * m + k];
}
let (tau_p, beta_e) = larfg(&mut w[..rlen], window);
e[k] = beta_e;
w[0] = T::ONE; if tau_p != T::ZERO {
let rows = m - k - 1; if rows > 0 {
let base = (k + 1) * m + (k + 1);
for v in aw[..rows].iter_mut() {
*v = T::ZERO; }
T::gemv_transpose_strided(
&cm[base..],
&w[..rlen],
&mut aw[..rows],
rlen,
rows,
m,
);
for (idx, slot) in dotbuf[..rlen].iter_mut().enumerate() {
*slot = T::ZERO.sub(tau_p.mul(w[idx]));
}
T::axpy_rows(&dotbuf[..rlen], &aw[..rows], &mut cm[base..], m, rlen, rows);
}
}
}
}
(d, e)
}