use crate::error::GprError;
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
#[non_exhaustive]
pub enum DistanceCachePolicy {
#[default]
Cached,
Uncached,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum CholeskyBuffer {
#[default]
Retain,
Reuse,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
#[non_exhaustive]
pub enum KernelExp {
#[default]
Accurate,
FastApprox,
}
macro_rules! with_kernel_exp {
($mode:expr, $M:ident => $body:expr) => {
match $mode {
$crate::policy::KernelExp::Accurate => {
type $M = $crate::math::Accurate;
$body
}
$crate::policy::KernelExp::FastApprox => {
type $M = $crate::math::FastApprox;
$body
}
}
};
}
pub(crate) use with_kernel_exp;
#[derive(Clone, Copy, Debug, PartialEq)]
#[non_exhaustive]
pub enum JitterPolicy {
Fixed(FixedJitter),
Adaptive(AdaptiveJitter),
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FixedJitter {
jitter: f64,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct AdaptiveJitter {
initial: f64,
multiplier: f64,
max_retries: usize,
max_jitter: f64,
}
impl AdaptiveJitter {
pub(crate) const K_MM_DEFAULT: Self = Self {
initial: 1e-8,
multiplier: 10.0,
max_retries: 5,
max_jitter: 1e-3,
};
}
impl Default for JitterPolicy {
fn default() -> Self {
Self::Fixed(FixedJitter { jitter: 0.0 })
}
}
impl JitterPolicy {
pub fn fixed(jitter: f64) -> Result<Self, GprError> {
if !jitter.is_finite() || jitter < 0.0 {
return Err(GprError::InvalidConfig {
reason: format!("jitter must be finite and non-negative, got {jitter}"),
});
}
Ok(Self::Fixed(FixedJitter { jitter }))
}
pub fn adaptive(
initial: f64,
multiplier: f64,
max_retries: usize,
max_jitter: f64,
) -> Result<Self, GprError> {
if !initial.is_finite() || initial <= 0.0 {
return Err(GprError::InvalidConfig {
reason: format!(
"adaptive initial jitter must be finite and positive, got {initial}"
),
});
}
if !multiplier.is_finite() || multiplier <= 1.0 {
return Err(GprError::InvalidConfig {
reason: format!(
"adaptive jitter multiplier must be finite and greater than 1, got {multiplier}"
),
});
}
if max_retries < 1 {
return Err(GprError::InvalidConfig {
reason: "adaptive jitter max_retries must be at least 1".to_owned(),
});
}
if !max_jitter.is_finite() || max_jitter < initial {
return Err(GprError::InvalidConfig {
reason: format!(
"adaptive max_jitter must be finite and at least initial ({initial}), got {max_jitter}"
),
});
}
Ok(Self::Adaptive(AdaptiveJitter {
initial,
multiplier,
max_retries,
max_jitter,
}))
}
pub(crate) fn retry_jitters(self) -> RetryJitters {
match self {
Self::Fixed(fixed) => {
if fixed.jitter > 0.0 {
RetryJitters {
next: Some(fixed.jitter),
multiplier: 1.0,
remaining: 1,
max_jitter: fixed.jitter,
}
} else {
RetryJitters {
next: None,
multiplier: 1.0,
remaining: 0,
max_jitter: 0.0,
}
}
}
Self::Adaptive(adaptive) => RetryJitters {
next: Some(adaptive.initial),
multiplier: adaptive.multiplier,
remaining: adaptive.max_retries,
max_jitter: adaptive.max_jitter,
},
}
}
}
impl FixedJitter {
pub fn jitter(&self) -> f64 {
self.jitter
}
}
impl AdaptiveJitter {
pub fn initial(&self) -> f64 {
self.initial
}
pub fn multiplier(&self) -> f64 {
self.multiplier
}
pub fn max_retries(&self) -> usize {
self.max_retries
}
pub fn max_jitter(&self) -> f64 {
self.max_jitter
}
}
pub(crate) struct RetryJitters {
next: Option<f64>,
multiplier: f64,
remaining: usize,
max_jitter: f64,
}
impl Iterator for RetryJitters {
type Item = f64;
fn next(&mut self) -> Option<f64> {
if self.remaining == 0 {
return None;
}
let j = self.next?;
if j > self.max_jitter {
return None;
}
self.remaining -= 1;
let grown = j * self.multiplier;
self.next = if grown.is_finite() { Some(grown) } else { None };
Some(j)
}
}