use super::rotation::TransposedFactors;
use crate::domain::real::RealScalar;
use core::marker::PhantomData;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Direction {
Down,
Up,
}
impl Direction {
pub(super) fn of_block<T: RealScalar>(d: &[T], p: usize, q: usize) -> Self {
if d[p].abs() >= d[q].abs() {
Self::Down
} else {
Self::Up
}
}
}
pub(super) trait Chase {
fn diagonal(p: usize, q: usize, j: usize) -> usize;
fn superdiagonal(p: usize, q: usize, j: usize) -> usize;
fn rotate_columns<T: RealScalar>(
factors: &mut TransposedFactors<'_, T>,
p: usize,
q: usize,
a: usize,
b: usize,
rotation: (T, T),
);
fn rotate_rows<T: RealScalar>(
factors: &mut TransposedFactors<'_, T>,
p: usize,
q: usize,
a: usize,
b: usize,
rotation: (T, T),
);
}
pub(super) struct Down;
pub(super) struct Up;
impl Chase for Down {
#[inline]
fn diagonal(_p: usize, _q: usize, j: usize) -> usize {
j
}
#[inline]
fn superdiagonal(_p: usize, _q: usize, j: usize) -> usize {
j
}
#[inline]
fn rotate_columns<T: RealScalar>(
factors: &mut TransposedFactors<'_, T>,
_p: usize,
_q: usize,
a: usize,
b: usize,
(c, s): (T, T),
) {
factors.rotate_right(a, b, c, s);
}
#[inline]
fn rotate_rows<T: RealScalar>(
factors: &mut TransposedFactors<'_, T>,
_p: usize,
_q: usize,
a: usize,
b: usize,
(c, s): (T, T),
) {
factors.rotate_left(a, b, c, s);
}
}
impl Chase for Up {
#[inline]
fn diagonal(p: usize, q: usize, j: usize) -> usize {
p + q - j
}
#[inline]
fn superdiagonal(p: usize, q: usize, j: usize) -> usize {
p + q - 1 - j
}
#[inline]
fn rotate_columns<T: RealScalar>(
factors: &mut TransposedFactors<'_, T>,
p: usize,
q: usize,
a: usize,
b: usize,
(c, s): (T, T),
) {
factors.rotate_left(p + q - a, p + q - b, c, s);
}
#[inline]
fn rotate_rows<T: RealScalar>(
factors: &mut TransposedFactors<'_, T>,
p: usize,
q: usize,
a: usize,
b: usize,
(c, s): (T, T),
) {
factors.rotate_right(p + q - a, p + q - b, c, s);
}
}
pub(super) struct Oriented<'s, T, C> {
d: &'s mut [T],
e: &'s mut [T],
p: usize,
q: usize,
chase: PhantomData<C>,
}
impl<'s, T: RealScalar, C: Chase> Oriented<'s, T, C> {
pub(super) fn new(d: &'s mut [T], e: &'s mut [T], p: usize, q: usize) -> Self {
assert!(p < q, "invariant: an oriented block has at least two rows");
Self {
d,
e,
p,
q,
chase: PhantomData,
}
}
#[inline]
pub(super) fn bounds(&self) -> (usize, usize) {
(self.p, self.q)
}
#[inline]
pub(super) fn d(&self, j: usize) -> T {
self.d[C::diagonal(self.p, self.q, j)]
}
#[inline]
pub(super) fn e(&self, j: usize) -> T {
self.e[C::superdiagonal(self.p, self.q, j)]
}
#[inline]
pub(super) fn set_d(&mut self, j: usize, value: T) {
self.d[C::diagonal(self.p, self.q, j)] = value;
}
#[inline]
pub(super) fn set_e(&mut self, j: usize, value: T) {
self.e[C::superdiagonal(self.p, self.q, j)] = value;
}
pub(super) fn largest_entry(&self) -> T {
let (p, q) = (self.p, self.q);
let mut largest = self.d(p).abs();
for j in p..q {
let e = self.e(j).abs();
if e > largest {
largest = e;
}
let d = self.d(j + 1).abs();
if d > largest {
largest = d;
}
}
largest
}
#[inline]
pub(super) fn stored_superdiagonal(&self, j: usize) -> usize {
C::superdiagonal(self.p, self.q, j)
}
#[inline]
pub(super) fn rotate_columns(
&self,
factors: &mut TransposedFactors<'_, T>,
a: usize,
b: usize,
rotation: (T, T),
) {
C::rotate_columns(factors, self.p, self.q, a, b, rotation);
}
#[inline]
pub(super) fn rotate_rows(
&self,
factors: &mut TransposedFactors<'_, T>,
a: usize,
b: usize,
rotation: (T, T),
) {
C::rotate_rows(factors, self.p, self.q, a, b, rotation);
}
}