use crate::{FoldAssignments, PathFit, SelectionRule, ValidationMetric};
#[derive(Clone, Debug)]
pub struct FoldPath<F, P> {
pub(crate) validation_rows: Vec<usize>,
pub(crate) path: PathFit<F, P>,
pub(crate) scores: Vec<f64>,
}
impl<F, P> FoldPath<F, P> {
pub fn validation_rows(&self) -> &[usize] {
&self.validation_rows
}
pub fn path(&self) -> &PathFit<F, P> {
&self.path
}
pub fn scores(&self) -> &[f64] {
&self.scores
}
}
#[derive(Clone, Debug)]
#[must_use]
pub struct CrossValidationFit<F, P> {
pub(crate) assignments: FoldAssignments,
pub(crate) folds: Vec<FoldPath<F, P>>,
pub(crate) refit: PathFit<F, P>,
pub(crate) mean_scores: Vec<f64>,
pub(crate) standard_errors: Vec<f64>,
pub(crate) metric: ValidationMetric,
pub(crate) selection_rule: SelectionRule,
pub(crate) minimum: usize,
pub(crate) one_standard_error: usize,
pub(crate) selected: usize,
pub(crate) relative_strengths: Option<Vec<f64>>,
}
impl<F, P> CrossValidationFit<F, P> {
pub fn assignments(&self) -> &FoldAssignments {
&self.assignments
}
pub fn folds(&self) -> &[FoldPath<F, P>] {
&self.folds
}
pub fn refit_path(&self) -> &PathFit<F, P> {
&self.refit
}
pub fn fit(&self) -> &F {
&self.refit.fits()[self.selected]
}
pub fn penalty(&self) -> &P {
&self.refit.penalties()[self.selected]
}
pub fn lambda(&self) -> Option<f64> {
self.refit.lambdas().map(|s| s[self.selected])
}
pub fn relative_strengths(&self) -> Option<&[f64]> {
self.relative_strengths.as_deref()
}
pub fn mean_scores(&self) -> &[f64] {
&self.mean_scores
}
pub fn standard_errors(&self) -> &[f64] {
&self.standard_errors
}
pub fn metric(&self) -> ValidationMetric {
self.metric
}
pub fn selection_rule(&self) -> SelectionRule {
self.selection_rule
}
pub fn minimum_index(&self) -> usize {
self.minimum
}
pub fn one_standard_error_index(&self) -> usize {
self.one_standard_error
}
pub fn selected_index(&self) -> usize {
self.selected
}
}