use super::Solver;
use crate::error::invalid;
use crate::{FitError, Termination};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum StepKind {
Initial,
Coordinate {
index: usize,
},
Block {
index: usize,
},
Intercept,
ProximalGradient,
CoordinateSweep,
Irls,
Final(Termination),
}
#[derive(Clone, Copy, Debug)]
pub struct SolverStep<'a> {
pub coefficients: &'a [f64],
pub intercept: f64,
pub iteration: usize,
pub kind: StepKind,
}
pub trait SolverObserver {
fn observe(&mut self, step: SolverStep<'_>);
fn observe_inner(&mut self, _step: SolverStep<'_>, _outer_iteration: usize) {}
}
impl<F: for<'a> FnMut(SolverStep<'a>)> SolverObserver for F {
fn observe(&mut self, step: SolverStep<'_>) {
self(step);
}
}
#[derive(Clone, Copy, Debug)]
pub struct InitialPoint<'a> {
pub coefficients: &'a [f64],
pub intercept: f64,
}
impl InitialPoint<'_> {
pub(crate) fn apply<E>(
self,
coefficients: &mut [f64],
intercept: &mut f64,
fits_intercept: bool,
) -> Result<(), FitError<E>> {
self.validate(coefficients.len(), fits_intercept)?;
coefficients.copy_from_slice(self.coefficients);
*intercept = self.intercept;
Ok(())
}
pub(crate) fn validate<E>(self, ncols: usize, fits_intercept: bool) -> Result<(), FitError<E>> {
if self.coefficients.len() != ncols
|| self.coefficients.iter().any(|b| !b.is_finite())
|| !self.intercept.is_finite()
|| (!fits_intercept && self.intercept != 0.0)
{
return Err(invalid(
"initial point must have one finite coefficient per column and a finite intercept, which must be zero when disabled",
));
}
Ok(())
}
}
pub trait ObservedSolver<P>: Solver<P> {
fn solve_with_observer<O: SolverObserver + ?Sized>(
&self,
problem: &P,
observer: &mut O,
) -> Result<Self::Fit, Self::Error> {
self.solve_from_with_observer(problem, None, observer)
}
fn solve_from_with_observer<O: SolverObserver + ?Sized>(
&self,
problem: &P,
initial: Option<InitialPoint<'_>>,
observer: &mut O,
) -> Result<Self::Fit, Self::Error>;
}
pub(crate) struct NoObserver;
impl SolverObserver for NoObserver {
#[inline]
fn observe(&mut self, _: SolverStep<'_>) {}
}
#[inline]
pub(crate) fn notify<O: SolverObserver + ?Sized>(
observer: &mut O,
coefficients: &[f64],
intercept: f64,
iteration: usize,
kind: StepKind,
) {
observer.observe(SolverStep {
coefficients,
intercept,
iteration,
kind,
});
}
#[inline]
pub(crate) fn notify_inner<O: SolverObserver + ?Sized>(
observer: &mut O,
coefficients: &[f64],
intercept: f64,
outer_iteration: usize,
iteration: usize,
kind: StepKind,
) {
observer.observe_inner(
SolverStep {
coefficients,
intercept,
iteration,
kind,
},
outer_iteration,
);
}
pub(crate) struct InnerObserver<'a, O: ?Sized> {
pub(crate) observer: &'a mut O,
pub(crate) outer_iteration: usize,
}
impl<O: SolverObserver + ?Sized> SolverObserver for InnerObserver<'_, O> {
fn observe(&mut self, step: SolverStep<'_>) {
if !matches!(step.kind, StepKind::Initial | StepKind::Final(_)) {
self.observer.observe_inner(step, self.outer_iteration);
}
}
fn observe_inner(&mut self, step: SolverStep<'_>, outer_iteration: usize) {
self.observer.observe_inner(
SolverStep {
iteration: outer_iteration,
..step
},
self.outer_iteration,
);
}
}