use crate::error::{finite, invalid};
use crate::{Datafit, DifferentiableDatafit, FitError, Gaussian, SmoothDatafit};
#[derive(Clone, Copy, Debug)]
pub struct MultivariateGaussian<'a> {
response: &'a [f64],
nobs: usize,
nresponses: usize,
fit_intercept: bool,
}
impl<'a> MultivariateGaussian<'a> {
pub fn new(response: &'a [f64], nobs: usize, nresponses: usize) -> Self {
Self {
response,
nobs,
nresponses,
fit_intercept: true,
}
}
pub fn fit_intercept(mut self, enabled: bool) -> Self {
self.fit_intercept = enabled;
self
}
pub fn response(&self) -> &[f64] {
self.response
}
pub fn nobs(&self) -> usize {
self.nobs
}
pub fn nresponses(&self) -> usize {
self.nresponses
}
pub fn fits_intercept(&self) -> bool {
self.fit_intercept
}
pub(crate) fn validate<E>(&self, nrows: usize) -> Result<(), FitError<E>> {
if self.nobs == 0 || self.nresponses == 0 {
return Err(invalid(
"multivariate Gaussian data must have observations and responses",
));
}
if self.nobs != nrows {
return Err(invalid(
"datafit observation count must match training rows",
));
}
let len = self
.nobs
.checked_mul(self.nresponses)
.ok_or_else(|| invalid("response dimensions overflow usize"))?;
if self.response.len() != len {
return Err(invalid(
"response length must match observation and response dimensions",
));
}
for (i, value) in self.response.iter().enumerate() {
if !value.is_finite() {
return Err(invalid(format!(
"response at observation {}, response {} is not finite",
i % self.nobs,
i / self.nobs
)));
}
}
Ok(())
}
fn validate_predictor(&self, predictor: &[f64]) -> Result<(), FitError> {
self.validate(self.nobs)?;
if predictor.len() != self.response.len() {
return Err(invalid("response and predictor lengths must match"));
}
if predictor.iter().any(|value| !value.is_finite()) {
return Err(invalid("predictor values must be finite"));
}
Ok(())
}
pub fn gradient(&self, predictor: &[f64], output: &mut [f64]) -> Result<(), FitError> {
self.validate_predictor(predictor)?;
if output.len() != predictor.len() {
return Err(invalid("predictor and gradient lengths must match"));
}
for ((&eta, &target), derivative) in predictor.iter().zip(self.response).zip(output) {
*derivative = finite(
(eta - target) / self.nobs as f64,
"computing the multivariate predictor gradient",
0,
)?;
}
Ok(())
}
}
impl Datafit for MultivariateGaussian<'_> {
type Error = FitError;
fn value(&self, predictor: &[f64]) -> Result<f64, FitError> {
self.validate_predictor(predictor)?;
Ok(Gaussian::residual_loss(
self.response.iter().zip(predictor).map(|(y, eta)| y - eta),
self.nobs,
0,
)?)
}
}
pub(crate) struct StackedGaussian<'a>(pub(crate) &'a MultivariateGaussian<'a>);
impl Datafit for StackedGaussian<'_> {
type Error = FitError;
fn value(&self, predictor: &[f64]) -> Result<f64, FitError> {
self.0.value(predictor)
}
}
impl SmoothDatafit for StackedGaussian<'_> {}
impl DifferentiableDatafit for StackedGaussian<'_> {
fn n_obs(&self) -> usize {
self.0.response.len()
}
fn fits_intercept(&self) -> bool {
false
}
fn gradient(&self, predictor: &[f64], output: &mut [f64]) -> Result<(), FitError> {
self.0.gradient(predictor, output)
}
}