use lazymatrix::RawColumns;
use crate::{FitError, HybridStep, Preprocessing, ProximalFit, StoppingCriterion, Termination};
#[derive(Clone, Debug)]
#[must_use]
pub struct HybridFit {
working_set: crate::WorkingSetDiagnostics,
fit: ProximalFit,
labels: Vec<usize>,
values: Vec<f64>,
signs: Vec<f64>,
pg_steps: usize,
coordinate_sweeps: usize,
diagnostic_checks: usize,
backtracks: usize,
step_policy: HybridStep,
outer_iterations: usize,
outer_backtracks: usize,
}
impl HybridFit {
pub fn working_set_diagnostics(&self) -> &crate::WorkingSetDiagnostics {
&self.working_set
}
pub fn coefficients(&self) -> &[f64] {
self.fit.coefficients()
}
pub fn intercept(&self) -> f64 {
self.fit.intercept()
}
pub fn preprocessing(&self) -> &Preprocessing {
self.fit.preprocessing()
}
pub fn termination(&self) -> Termination {
self.fit.termination()
}
pub fn iterations(&self) -> usize {
self.fit.iterations()
}
pub fn objective(&self) -> f64 {
self.fit.objective()
}
pub fn dual_certificate(&self) -> Option<&[f64]> {
self.fit.dual_certificate()
}
pub fn dual_objective(&self) -> Option<f64> {
self.fit.dual_objective()
}
pub fn duality_gap(&self) -> Option<f64> {
self.fit.duality_gap()
}
pub fn screening_diagnostics(&self) -> &crate::screening::ScreeningDiagnostics {
self.fit.screening_diagnostics()
}
pub fn stopping_criterion(&self) -> StoppingCriterion {
self.fit.stopping_criterion()
}
pub fn stopping_value(&self) -> f64 {
self.fit.stopping_value()
}
pub fn stopping_threshold(&self) -> f64 {
self.fit.stopping_threshold()
}
pub fn step_size(&self) -> f64 {
self.fit.step_size()
}
pub fn step_policy(&self) -> HybridStep {
self.step_policy
}
pub fn pg_steps(&self) -> usize {
self.pg_steps
}
pub fn coordinate_sweeps(&self) -> usize {
self.coordinate_sweeps
}
pub fn diagnostic_checks(&self) -> usize {
self.diagnostic_checks
}
pub fn backtracks(&self) -> usize {
self.backtracks
}
pub fn outer_iterations(&self) -> usize {
self.outer_iterations
}
pub fn outer_backtracks(&self) -> usize {
self.outer_backtracks
}
pub fn cluster_labels(&self) -> &[usize] {
&self.labels
}
pub fn cluster_values(&self) -> &[f64] {
&self.values
}
pub fn coefficient_signs(&self) -> &[f64] {
&self.signs
}
pub fn predict<M: RawColumns<f64> + ?Sized>(&self, x: &M) -> Result<Vec<f64>, FitError> {
self.fit.predict(x)
}
pub(crate) fn from_solution<E>(
solution: crate::solver::hybrid::Solution,
preprocessing: Preprocessing,
) -> Result<Self, FitError<E>> {
let signs = solution
.proximal
.coefficients
.iter()
.map(|&value| if value == 0.0 { 0.0 } else { value.signum() })
.collect();
Ok(Self {
working_set: solution.working_set,
fit: ProximalFit::from_solution(solution.proximal, preprocessing)?,
labels: solution.labels,
values: solution.values,
signs,
pg_steps: solution.pg_steps,
coordinate_sweeps: solution.coordinate_sweeps,
diagnostic_checks: solution.diagnostic_checks,
backtracks: solution.backtracks,
step_policy: solution.step_policy,
outer_iterations: solution.outer_iterations,
outer_backtracks: solution.outer_backtracks,
})
}
}