use crate::domain::real::RealScalar;
pub(crate) struct Reflector<T> {
pub(crate) v: Vec<T>,
pub(crate) beta: T,
}
pub(crate) fn reflector<T: RealScalar>(x: &[T]) -> Option<(Reflector<T>, T)> {
if x.get(1..)
.is_some_and(|tail| tail.iter().all(|&xi| xi == T::ZERO))
{
return None;
}
let mut v = x.to_vec();
let (beta, alpha) = reflect_in_place(&mut v)?;
Some((Reflector { v, beta }, alpha))
}
pub(crate) fn reflect_in_place<T: RealScalar>(x: &mut [T]) -> Option<(T, T)> {
let largest = x.iter().fold(T::ZERO, |acc, &xi| {
let magnitude = xi.abs();
if magnitude > acc {
magnitude
} else {
acc
}
});
if largest == T::ZERO {
return None;
}
let exponent = largest.binary_exponent().unwrap_or(0);
for xi in x.iter_mut() {
*xi = xi.scale_binary(-exponent);
}
let first = *x.first()?;
let mut norm_sq = T::ZERO;
for &xi in x.iter() {
norm_sq = norm_sq.add(xi.mul(xi));
}
let norm = norm_sq.sqrt();
let sign = if first < T::ZERO {
T::ZERO.sub(T::ONE)
} else {
T::ONE
};
let alpha = T::ZERO.sub(sign.mul(norm)); x[0] = first.sub(alpha);
let mut vnorm_sq = T::ZERO;
for &vi in x.iter() {
vnorm_sq = vnorm_sq.add(vi.mul(vi));
}
Some((
T::ONE.add(T::ONE).div(vnorm_sq),
alpha.scale_binary(exponent),
))
}
pub(crate) fn apply_left<T: RealScalar>(
refl: &Reflector<T>,
m: &mut [T],
cols: usize,
base_row: usize,
c0: usize,
c1: usize,
scratch: &mut Vec<T>,
) {
let Reflector { v, beta } = refl;
if c1 <= c0 {
return;
}
let span = c1 - c0;
scratch.clear();
scratch.resize(span, T::ZERO);
let w = scratch.as_mut_slice();
for (i, &vi) in v.iter().enumerate() {
let row = &m[(base_row + i) * cols + c0..(base_row + i) * cols + c1];
T::axpy_slice(vi, row, w); }
for wj in w.iter_mut() {
*wj = beta.mul(*wj);
}
for (i, &vi) in v.iter().enumerate() {
let row = &mut m[(base_row + i) * cols + c0..(base_row + i) * cols + c1];
T::axpy_slice(T::ZERO.sub(vi), w, row); }
}
pub(crate) fn apply_right<T: RealScalar>(
refl: &Reflector<T>,
m: &mut [T],
cols: usize,
base_col: usize,
r0: usize,
r1: usize,
) {
let Reflector { v, beta } = refl;
let len = v.len();
for i in r0..r1 {
let start = i * cols + base_col;
let dot = T::dot_slice(&m[start..start + len], v);
let scale = beta.mul(dot);
T::axpy_slice(T::ZERO.sub(scale), v, &mut m[start..start + len]); }
}
#[cfg(test)]
mod tests {
use super::reflector;
#[test]
fn reflector_skips_a_vector_already_on_e1() {
assert!(reflector(&[3.0_f64, 0.0, 0.0]).is_none());
assert!(reflector(&[3.0_f64]).is_none());
let (_, alpha) = reflector(&[3.0_f64, 4.0]).expect("nonzero tail");
assert_eq!(alpha.abs(), 5.0);
}
}