use super::chase::{Chase, Oriented};
use super::rotation::{givens, TransposedFactors};
use crate::application::linalg::scaling::KernelWindow;
use crate::application::linalg::thresholds;
use crate::domain::real::RealScalar;
fn deflation_floor<T: RealScalar>() -> T {
thresholds::safe_min::<T>()
}
#[derive(Clone, Copy)]
pub(super) struct Deflation<T> {
tol: T,
pub(super) thresh: T,
order: usize,
}
impl<T: RealScalar> Deflation<T> {
pub(super) fn new(d: &[T], e: &[T], k: usize) -> Self {
let eps = thresholds::machine_epsilon::<T>();
let eighth_root = T::ONE.div(eps).sqrt().sqrt().sqrt();
let (ten, hundred) = (T::from_count(10), T::from_count(100));
let capped = if eighth_root < hundred {
eighth_root
} else {
hundred
};
let tolmul = if capped > ten { capped } else { ten };
let tol = tolmul.mul(eps);
let mut sminoa = d[0].abs();
let mut mu = sminoa;
for i in 1..k {
if sminoa == T::ZERO {
break;
}
mu = d[i].abs().mul(mu.div(mu.add(e[i - 1].abs())));
if mu < sminoa {
sminoa = mu;
}
}
let sminoa = sminoa.div(T::from_count(k).sqrt());
let relative = tol.mul(sminoa);
let floor = deflation_floor::<T>();
Self {
tol,
thresh: if relative > floor { relative } else { floor },
order: k,
}
}
pub(super) fn shift_ruins_accuracy<C: Chase>(self, block: &Oriented<'_, T, C>) -> bool {
let (p, q) = block.bounds();
let largest = block.largest_entry();
if largest == T::ZERO {
return false;
}
let mut mu = block.d(p).abs();
let mut smallest = mu;
for i in p..q {
mu = block.d(i + 1).abs().mul(mu.div(mu.add(block.e(i).abs())));
if mu < smallest {
smallest = mu;
}
}
let eps = thresholds::machine_epsilon::<T>();
let hundredth = self.tol.div(T::from_count(100));
let bound = if eps > hundredth { eps } else { hundredth };
T::from_count(self.order)
.mul(self.tol)
.mul(smallest.div(largest))
<= bound
}
pub(super) fn split<C: Chase>(self, block: &Oriented<'_, T, C>) -> Option<usize> {
let (p, q) = block.bounds();
if block.e(q - 1).abs() <= self.tol.mul(block.d(q).abs()) {
return Some(block.stored_superdiagonal(q - 1));
}
let mut mu = block.d(p).abs();
for i in p..q {
if block.e(i).abs() <= self.tol.mul(mu) {
return Some(block.stored_superdiagonal(i));
}
mu = block.d(i + 1).abs().mul(mu.div(mu.add(block.e(i).abs())));
}
None
}
}
#[inline]
pub(super) fn diagonal_is_negligible<T: RealScalar>(
d: &[T],
e: &[T],
i: usize,
p: usize,
q: usize,
) -> bool {
let below = if i > p { e[i - 1].abs() } else { T::ZERO };
let above = if i < q { e[i].abs() } else { T::ZERO };
let scale = below.add(above);
scale.add(d[i].abs()) == scale
}
pub(super) fn chase_negligible_diagonal_row<T: RealScalar, const VEC: bool>(
d: &mut [T],
e: &mut [T],
i: usize,
q: usize,
factors: &mut TransposedFactors<'_, T>,
rotation: KernelWindow<T>,
) {
d[i] = T::ZERO;
let mut fill = e[i];
e[i] = T::ZERO;
for j in (i + 1)..=q {
let (c, s, r) = givens(d[j], fill, rotation);
if VEC {
factors.rotate_left(j, i, c, s);
}
d[j] = r;
if j < q {
fill = s.mul(e[j]).neg();
e[j] = c.mul(e[j]);
}
}
}
pub(super) fn chase_negligible_diagonal_column<T: RealScalar, const VEC: bool>(
d: &mut [T],
e: &mut [T],
p: usize,
q: usize,
factors: &mut TransposedFactors<'_, T>,
rotation: KernelWindow<T>,
) {
d[q] = T::ZERO;
let mut fill = e[q - 1];
e[q - 1] = T::ZERO;
let mut j = q - 1;
loop {
let (c, s, r) = givens(d[j], fill, rotation);
if VEC {
factors.rotate_right(j, q, c, s);
}
d[j] = r;
if j == p {
return;
}
fill = s.mul(e[j - 1]).neg();
e[j - 1] = c.mul(e[j - 1]);
j -= 1;
}
}