use lazymatrix::{RawColumn, RawColumns};
use crate::error::{finite, invalid};
use crate::fit::back_transform_in_place;
use crate::problem::validate_matrix;
use crate::solver::proximal::Solution;
use crate::{CoefficientLayout, FitError, Preprocessing, StoppingCriterion, Termination};
#[derive(Clone, Debug)]
#[must_use]
pub struct MultivariateFit {
coefficients: Vec<f64>,
intercepts: Vec<f64>,
layout: CoefficientLayout,
preprocessing: Preprocessing,
termination: Termination,
iterations: usize,
objective: f64,
stopping_criterion: StoppingCriterion,
stopping_value: f64,
stopping_threshold: f64,
step: f64,
}
impl MultivariateFit {
pub fn layout(&self) -> CoefficientLayout {
self.layout
}
pub fn coefficients(&self) -> &[f64] {
&self.coefficients
}
pub fn coefficients_for_response(&self, response: usize) -> Option<&[f64]> {
if response >= self.layout.nresponses() {
return None;
}
let start = response * self.layout.nfeatures();
Some(&self.coefficients[start..start + self.layout.nfeatures()])
}
pub fn intercepts(&self) -> &[f64] {
&self.intercepts
}
pub fn preprocessing(&self) -> &Preprocessing {
&self.preprocessing
}
pub fn termination(&self) -> Termination {
self.termination
}
pub fn iterations(&self) -> usize {
self.iterations
}
pub fn objective(&self) -> f64 {
self.objective
}
pub fn stopping_criterion(&self) -> StoppingCriterion {
self.stopping_criterion
}
pub fn stopping_value(&self) -> f64 {
self.stopping_value
}
pub fn stopping_threshold(&self) -> f64 {
self.stopping_threshold
}
pub fn step_size(&self) -> f64 {
self.step
}
pub fn predict<M: RawColumns<f64> + ?Sized>(&self, x: &M) -> Result<Vec<f64>, FitError> {
if x.ncols() != self.layout.nfeatures() {
return Err(invalid(
"prediction feature count must match the fitted layout",
));
}
let len = x
.nrows()
.checked_mul(self.layout.nresponses())
.ok_or_else(|| invalid("prediction dimensions overflow usize"))?;
validate_matrix(x)?;
let mut output = vec![0.0; len];
for response in 0..self.layout.nresponses() {
let column = &mut output[response * x.nrows()..(response + 1) * x.nrows()];
column.fill(self.intercepts[response]);
let start = response * self.layout.nfeatures();
for (feature, &coefficient) in self.coefficients[start..start + self.layout.nfeatures()]
.iter()
.enumerate()
{
if coefficient != 0.0 {
x.raw_column(feature)
.affine_add_to(coefficient, 0.0, column);
}
}
for &value in column.iter() {
finite(value, "predicting", self.iterations)?;
}
}
Ok(output)
}
pub(crate) fn from_solution<E>(
mut solution: Solution,
preprocessing: Preprocessing,
layout: CoefficientLayout,
fit_intercept: bool,
) -> Result<Self, FitError<E>> {
let mut intercepts = if fit_intercept {
solution.coefficients.split_off(layout.len())
} else {
vec![0.0; layout.nresponses()]
};
for (response, intercept) in intercepts.iter_mut().enumerate() {
let start = response * layout.nfeatures();
back_transform_in_place(
&mut solution.coefficients[start..start + layout.nfeatures()],
intercept,
&preprocessing,
solution.iterations,
)?;
}
Ok(Self {
coefficients: solution.coefficients,
intercepts,
layout,
preprocessing,
termination: solution.termination,
iterations: solution.iterations,
objective: solution.objective,
stopping_criterion: solution.stopping_criterion,
stopping_value: solution.stopping_value,
stopping_threshold: solution.stopping_threshold,
step: solution.step,
})
}
}