use faer::Mat;
use crate::error::{CholeskyStage, GprError};
use crate::kernel::{DistanceSource, KernelScalar};
use crate::linalg::{cholesky_lower_with_retries, llt_scratch, mul_lower_vec};
use crate::policy::JitterPolicy;
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum VarianceKind {
Latent,
#[default]
Observation,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PredictOptions {
pub variance_kind: VarianceKind,
}
impl Default for PredictOptions {
fn default() -> Self {
Self {
variance_kind: VarianceKind::Observation,
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Prediction<T = f64> {
pub mean: Vec<T>,
pub variance: Vec<T>,
pub variance_kind: VarianceKind,
}
#[derive(Clone, Debug, PartialEq)]
pub struct PredictiveCovariance<T = f64> {
pub mean: Vec<T>,
pub covariance: Vec<T>,
pub variance_kind: VarianceKind,
}
impl<T> Default for Prediction<T> {
fn default() -> Self {
Self {
mean: Vec::new(),
variance: Vec::new(),
variance_kind: VarianceKind::default(),
}
}
}
impl<T> Default for PredictiveCovariance<T> {
fn default() -> Self {
Self {
mean: Vec::new(),
covariance: Vec::new(),
variance_kind: VarianceKind::default(),
}
}
}
impl<T: KernelScalar> PredictiveCovariance<T> {
pub(crate) fn draw(
&self,
n_draws: usize,
seed: u64,
jitter: JitterPolicy,
) -> Result<Vec<T>, GprError> {
if n_draws == 0 {
return Ok(Vec::new());
}
let m = self.mean.len();
let mut a = Mat::<T>::zeros(m, m);
for col in 0..m {
for row in 0..m {
a[(row, col)] = self.covariance[col * m + row];
}
}
let mut scratch = llt_scratch::<T>(m);
cholesky_lower_with_retries(
&mut a,
&mut scratch,
jitter.retry_jitters(),
CholeskyStage::Predict,
)?;
let mut rng = crate::rng::seeded_rng(seed);
let zero = T::from_f64(0.0);
let mut out = vec![zero; m * n_draws];
let mut z = vec![zero; m];
let mut lz = vec![zero; m];
for draw in 0..n_draws {
for slot in &mut z {
*slot = T::from_f64(crate::rng::unit_normal(&mut rng));
}
mul_lower_vec(a.as_ref(), &z, &mut lz);
let col = &mut out[draw * m..(draw + 1) * m];
for i in 0..m {
col[i] = self.mean[i] + lz[i];
}
}
Ok(out)
}
}
#[derive(Clone, Copy, Debug)]
pub(crate) struct QueryPoints<'a> {
pub(crate) xs: &'a [f64],
pub(crate) n_cols: usize,
}
impl QueryPoints<'static> {
pub(crate) const NONE: Self = Self { xs: &[], n_cols: 0 };
}
pub(crate) trait DistanceQuery {
type Refine;
fn query_distances<'s>(
&self,
cross: impl IntoIterator<Item = DistanceSource<'s>>,
points: QueryPoints<'_>,
q: usize,
options: PredictOptions,
) -> Result<Prediction<Self::Refine>, GprError>;
fn query_distances_into<'s>(
&mut self,
cross: impl IntoIterator<Item = DistanceSource<'s>>,
points: QueryPoints<'_>,
q: usize,
options: PredictOptions,
out: &mut Prediction<Self::Refine>,
) -> Result<(), GprError>;
fn query_distance_covariance<'s>(
&self,
cross: impl IntoIterator<Item = DistanceSource<'s>>,
square: impl IntoIterator<Item = DistanceSource<'s>>,
points: QueryPoints<'_>,
q: usize,
options: PredictOptions,
) -> Result<PredictiveCovariance<Self::Refine>, GprError>;
fn draw_jitter(&self) -> JitterPolicy;
}
macro_rules! distance_predict {
(
impl [$($gen:tt)*] $model:ty,
refine = $refine:ty,
args = ($($arg:ident: $ty:ty),*),
tail = ($($tail:ident: $tty:ty),*),
points = $points:expr,
count = $count:ident,
cross = { $(#[$cross:meta])* },
reads = { $(#[$reads:meta])* },
predict_doc = { $(#[$pdoc:meta])* },
covariance_doc = { $(#[$cdoc:meta])* },
) => {
impl<$($gen)*> $model {
$(#[$cross])*
$(#[$reads])*
#[doc = concat!("Returns [`GprError::EmptyInput`] if `", stringify!($count), "` is zero,")]
$(#[$pdoc])*
pub fn predict<'s>(
&self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
$($arg: $ty,)*
$count: usize,
$($tail: $tty,)*
) -> Result<Prediction<$refine>, GprError> {
self.predict_with(sources, $($arg,)* $count, $($tail,)* PredictOptions::default())
}
$(#[$pdoc])*
pub fn predict_into<'s>(
&mut self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
$($arg: $ty,)*
$count: usize,
$($tail: $tty,)*
out: &mut Prediction<$refine>,
) -> Result<(), GprError> {
self.predict_with_into(sources, $($arg,)* $count, $($tail,)* PredictOptions::default(), out)
}
$(#[$pdoc])*
pub fn predict_with<'s>(
&self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
$($arg: $ty,)*
$count: usize,
$($tail: $tty,)*
options: PredictOptions,
) -> Result<Prediction<$refine>, GprError> {
$crate::prediction::DistanceQuery::query_distances(
self,
sources,
$points,
$count,
options,
)
}
$(#[$pdoc])*
pub fn predict_with_into<'s>(
&mut self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
$($arg: $ty,)*
$count: usize,
$($tail: $tty,)*
options: PredictOptions,
out: &mut Prediction<$refine>,
) -> Result<(), GprError> {
$crate::prediction::DistanceQuery::query_distances_into(
self,
sources,
$points,
$count,
options,
out,
)
}
$(#[$cross])*
$(#[$reads])*
$(#[$cdoc])*
pub fn predict_covariance<'s>(
&self,
cross: impl IntoIterator<Item = DistanceSource<'s>>,
square: impl IntoIterator<Item = DistanceSource<'s>>,
$($arg: $ty,)*
$count: usize,
$($tail: $tty,)*
) -> Result<PredictiveCovariance<$refine>, GprError> {
self.predict_covariance_with(
cross,
square,
$($arg,)*
$count,
$($tail,)*
PredictOptions::default(),
)
}
$(#[$cdoc])*
pub fn predict_covariance_with<'s>(
&self,
cross: impl IntoIterator<Item = DistanceSource<'s>>,
square: impl IntoIterator<Item = DistanceSource<'s>>,
$($arg: $ty,)*
$count: usize,
$($tail: $tty,)*
options: PredictOptions,
) -> Result<PredictiveCovariance<$refine>, GprError> {
$crate::prediction::DistanceQuery::query_distance_covariance(
self,
cross,
square,
$points,
$count,
options,
)
}
$(#[$cdoc])*
#[allow(clippy::too_many_arguments)]
pub fn sample<'s>(
&self,
cross: impl IntoIterator<Item = DistanceSource<'s>>,
square: impl IntoIterator<Item = DistanceSource<'s>>,
$($arg: $ty,)*
$count: usize,
$($tail: $tty,)*
n_draws: usize,
seed: u64,
) -> Result<Vec<$refine>, GprError> {
self.sample_with(
cross,
square,
$($arg,)*
$count,
$($tail,)*
PredictOptions::default(),
n_draws,
seed,
)
}
$(#[$cdoc])*
#[allow(clippy::too_many_arguments)]
pub fn sample_with<'s>(
&self,
cross: impl IntoIterator<Item = DistanceSource<'s>>,
square: impl IntoIterator<Item = DistanceSource<'s>>,
$($arg: $ty,)*
$count: usize,
$($tail: $tty,)*
options: PredictOptions,
n_draws: usize,
seed: u64,
) -> Result<Vec<$refine>, GprError> {
let jitter = $crate::prediction::DistanceQuery::draw_jitter(self);
self.predict_covariance_with(cross, square, $($arg,)* $count, $($tail,)* options)?
.draw(n_draws, seed, jitter)
}
}
};
}
pub(crate) use distance_predict;