use super::dist::par_lower_fold;
use super::lengthscale::{validate_lengthscale, validate_log_lengthscale};
use super::simd::stationary::{PeriodicScales, try_apply_periodic, try_weighted_periodic};
use super::{
Triangle, finite_dist, validate_log_positive, validate_positive_finite, write_dense,
write_rect_from_coords, write_square_from_coords, write_triangle,
};
use crate::error::GprError;
use crate::kernel::KernelScalar;
use crate::math::KernelMath;
use crate::param::{BoundedParam, Interval};
use faer::reborrow::ReborrowMut;
use faer::{MatMut, MatRef};
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PeriodicKernel {
lengthscale: BoundedParam,
period: BoundedParam,
}
impl PeriodicKernel {
pub fn new(lengthscale: f64, period: f64) -> Result<Self, GprError> {
validate_lengthscale(lengthscale)?;
validate_positive_finite(period, "period")?;
Ok(Self {
lengthscale: BoundedParam::default_positive(lengthscale)?,
period: BoundedParam::default_positive(period)?,
})
}
pub fn from_log(log_lengthscale: f64, log_period: f64) -> Result<Self, GprError> {
Ok(Self {
lengthscale: BoundedParam::default_positive(
validate_log_lengthscale(log_lengthscale)?.exp(),
)?,
period: BoundedParam::default_positive(
validate_log_positive(log_period, "period")?.exp(),
)?,
})
}
pub fn lengthscale(&self) -> f64 {
self.lengthscale.value()
}
pub fn log_lengthscale(&self) -> f64 {
self.lengthscale.ln()
}
pub fn period(&self) -> f64 {
self.period.value()
}
pub fn log_period(&self) -> f64 {
self.period.ln()
}
pub fn lengthscale_bounds(&self) -> Interval {
self.lengthscale.interval()
}
pub fn period_bounds(&self) -> Interval {
self.period.interval()
}
pub fn with_bounds(
self,
lengthscale: Interval,
period: Interval,
) -> Result<Self, crate::IntervalError> {
Ok(Self {
lengthscale: self.lengthscale.with_interval(lengthscale)?,
period: self.period.with_interval(period)?,
})
}
pub fn num_params(&self) -> usize {
2
}
pub fn get_params(&self, out: &mut [f64]) -> Result<(), GprError> {
expect_two_params(out.len())?;
out[0] = self.lengthscale.ln();
out[1] = self.period.ln();
Ok(())
}
pub fn set_params(&mut self, params: &[f64]) -> Result<(), GprError> {
expect_two_params(params.len())?;
let ell = validate_log_lengthscale(params[0])?.exp();
let period = validate_log_positive(params[1], "period")?.exp();
let lengthscale = BoundedParam::new(ell, self.lengthscale.interval())?;
let period = BoundedParam::new(period, self.period.interval())?;
self.lengthscale = lengthscale;
self.period = period;
Ok(())
}
pub fn apply<T: KernelScalar>(
&self,
dist: MatRef<'_, T>,
out: MatMut<'_, T>,
uplo: Triangle,
) -> Result<(), GprError> {
self.apply_math::<crate::math::Accurate, _>(dist, out, uplo)
}
pub(crate) fn apply_math<M: KernelMath, T: KernelScalar>(
&self,
dist: MatRef<'_, T>,
mut out: MatMut<'_, T>,
uplo: Triangle,
) -> Result<(), GprError> {
if try_apply_periodic::<M, T>(dist, out.rb_mut(), uplo, self.simd_scales())? {
return Ok(());
}
let ell = T::from_f64(self.lengthscale());
let period = T::from_f64(self.period());
write_triangle(dist, out, uplo, |d| {
periodic_from_sq_dist::<M, _>(d, ell, period)
})
}
fn simd_scales(&self) -> PeriodicScales {
let ell = self.lengthscale();
PeriodicScales {
pi_over_period: std::f64::consts::PI / self.period(),
two_inv_ell_sq: 2.0 / (ell * ell),
}
}
pub fn apply_cross<T: KernelScalar>(
&self,
dist: MatRef<'_, T>,
out: MatMut<'_, T>,
) -> Result<(), GprError> {
self.apply_cross_math::<crate::math::Accurate, _>(dist, out)
}
pub(crate) fn apply_cross_math<M: KernelMath, T: KernelScalar>(
&self,
dist: MatRef<'_, T>,
out: MatMut<'_, T>,
) -> Result<(), GprError> {
let ell = T::from_f64(self.lengthscale());
let period = T::from_f64(self.period());
write_dense(dist, out, |d| periodic_from_sq_dist::<M, _>(d, ell, period))
}
pub fn fill_diag<T: KernelScalar>(&self, out: &mut [T]) {
out.fill(T::from_f64(1.0));
}
pub fn grad<T: KernelScalar>(
&self,
dist: MatRef<'_, T>,
d_k: MatMut<'_, T>,
param_idx: usize,
uplo: Triangle,
) -> Result<(), GprError> {
if param_idx > 1 {
return Err(GprError::IndexOutOfRange {
reason: format!("periodic kernel parameter index {param_idx} is out of range"),
});
}
self.grad_math::<crate::math::Accurate, _>(dist, d_k, param_idx, uplo)
}
pub(crate) fn grad_math<M: KernelMath, T: KernelScalar>(
&self,
dist: MatRef<'_, T>,
d_k: MatMut<'_, T>,
param_idx: usize,
uplo: Triangle,
) -> Result<(), GprError> {
if param_idx > 1 {
return Err(GprError::IndexOutOfRange {
reason: format!("periodic kernel parameter index {param_idx} is out of range"),
});
}
let ell = T::from_f64(self.lengthscale());
let period = T::from_f64(self.period());
write_triangle(dist, d_k, uplo, |d| {
periodic_grad_from_sq_dist::<M, _>(d, ell, period, param_idx)
})
}
pub(crate) fn weighted_grads_dist<M: KernelMath, T: KernelScalar>(
&self,
dist: MatRef<'_, T>,
k: Option<MatRef<'_, T>>,
weight: MatRef<'_, T>,
out: &mut [f64],
) -> Result<f64, GprError> {
if let Some(value) =
try_weighted_periodic::<M, T>(dist, k, weight, self.simd_scales(), out)?
{
return Ok(value);
}
let ell = T::from_f64(self.lengthscale());
let period = T::from_f64(self.period());
let inv_ell_sq = T::from_f64(1.0) / (ell * ell);
let pi = T::from_f64(std::f64::consts::PI);
let (two, four) = (T::from_f64(2.0), T::from_f64(4.0));
let n = dist.nrows();
let [g_ell, g_period, value] = par_lower_fold(
n,
&|start, end| {
let mut sums = [0.0; 3];
for col in start..end {
for row in col..n {
let r = euclidean_from_sq(dist[(row, col)])?;
let alpha = pi * r / period;
let (s, c) = (alpha.sin(), alpha.cos());
let (kv, e) = match (M::ACCURATE, k) {
(true, Some(k)) => (k[(row, col)], k[(row, col)]),
(true, None) => {
let e = (-two * s * s * inv_ell_sq).exp();
(e, e)
}
(false, _) => {
let jet = M::jet(-two * s * s * inv_ell_sq);
(jet.v, jet.d1)
}
};
let dk_ell = finite_kernel(e * four * s * s * inv_ell_sq)?;
let dk_period = finite_kernel(e * four * s * c * alpha * inv_ell_sq)?;
let w = weight[(row, col)].to_f64() * if row == col { 1.0 } else { 2.0 };
sums[0] += w * dk_ell.to_f64();
sums[1] += w * dk_period.to_f64();
sums[2] += w * kv.to_f64();
}
}
Ok::<_, GprError>(sums)
},
&|a: [f64; 3], b: [f64; 3]| [a[0] + b[0], a[1] + b[1], a[2] + b[2]],
)?;
out[0] = g_ell;
out[1] = g_period;
Ok(value)
}
pub(crate) fn apply_from_coords<M: KernelMath, T: KernelScalar>(
&self,
x: MatRef<'_, T>,
out: MatMut<'_, T>,
uplo: Triangle,
) -> Result<(), GprError> {
let ell = T::from_f64(self.lengthscale());
let period = T::from_f64(self.period());
write_square_from_coords(x, out, uplo, |d| {
periodic_from_sq_dist::<M, _>(d, ell, period)
})
}
pub(crate) fn grad_from_coords<M: KernelMath, T: KernelScalar>(
&self,
x: MatRef<'_, T>,
d_k: MatMut<'_, T>,
param_idx: usize,
uplo: Triangle,
) -> Result<(), GprError> {
if param_idx > 1 {
return Err(GprError::IndexOutOfRange {
reason: format!("periodic kernel parameter index {param_idx} is out of range"),
});
}
let ell = T::from_f64(self.lengthscale());
let period = T::from_f64(self.period());
write_square_from_coords(x, d_k, uplo, |d| {
periodic_grad_from_sq_dist::<M, _>(d, ell, period, param_idx)
})
}
pub fn hess<T: KernelScalar>(
&self,
dist: MatRef<'_, T>,
d2_k: MatMut<'_, T>,
i: usize,
j: usize,
uplo: Triangle,
) -> Result<(), GprError> {
self.hess_math::<crate::math::Accurate, _>(dist, d2_k, i, j, uplo)
}
pub(crate) fn hess_math<M: KernelMath, T: KernelScalar>(
&self,
dist: MatRef<'_, T>,
d2_k: MatMut<'_, T>,
i: usize,
j: usize,
uplo: Triangle,
) -> Result<(), GprError> {
require_periodic_hess_idx(i, j)?;
let ell = T::from_f64(self.lengthscale());
let period = T::from_f64(self.period());
write_triangle(dist, d2_k, uplo, |d| {
periodic_hess_from_sq_dist::<M, _>(d, ell, period, i, j)
})
}
pub(crate) fn grad_cross_dist<M: KernelMath, T: KernelScalar>(
&self,
dist: MatRef<'_, T>,
d_k: MatMut<'_, T>,
param_idx: usize,
) -> Result<(), GprError> {
if param_idx > 1 {
return Err(GprError::IndexOutOfRange {
reason: format!("periodic kernel parameter index {param_idx} is out of range"),
});
}
let ell = T::from_f64(self.lengthscale());
let period = T::from_f64(self.period());
write_dense(dist, d_k, |d| {
periodic_grad_from_sq_dist::<M, _>(d, ell, period, param_idx)
})
}
pub(crate) fn hess_cross_dist<M: KernelMath, T: KernelScalar>(
&self,
dist: MatRef<'_, T>,
d2_k: MatMut<'_, T>,
i: usize,
j: usize,
) -> Result<(), GprError> {
require_periodic_hess_idx(i, j)?;
let ell = T::from_f64(self.lengthscale());
let period = T::from_f64(self.period());
write_dense(dist, d2_k, |d| {
periodic_hess_from_sq_dist::<M, _>(d, ell, period, i, j)
})
}
pub(crate) fn hess_from_coords<M: KernelMath, T: KernelScalar>(
&self,
x: MatRef<'_, T>,
d2_k: MatMut<'_, T>,
i: usize,
j: usize,
uplo: Triangle,
) -> Result<(), GprError> {
require_periodic_hess_idx(i, j)?;
let ell = T::from_f64(self.lengthscale());
let period = T::from_f64(self.period());
write_square_from_coords(x, d2_k, uplo, |d| {
periodic_hess_from_sq_dist::<M, _>(d, ell, period, i, j)
})
}
pub(crate) fn apply_cross_from_coords<M: KernelMath, T: KernelScalar>(
&self,
x1: MatRef<'_, T>,
x2: MatRef<'_, T>,
out: MatMut<'_, T>,
) -> Result<(), GprError> {
let ell = T::from_f64(self.lengthscale());
let period = T::from_f64(self.period());
write_rect_from_coords(x1, x2, out, |d| {
periodic_from_sq_dist::<M, _>(d, ell, period)
})
}
pub(crate) fn grad_cross_from_coords<M: KernelMath, T: KernelScalar>(
&self,
x1: MatRef<'_, T>,
x2: MatRef<'_, T>,
d_k: MatMut<'_, T>,
param_idx: usize,
) -> Result<(), GprError> {
if param_idx > 1 {
return Err(GprError::IndexOutOfRange {
reason: format!("periodic kernel parameter index {param_idx} is out of range"),
});
}
let ell = T::from_f64(self.lengthscale());
let period = T::from_f64(self.period());
write_rect_from_coords(x1, x2, d_k, |d| {
periodic_grad_from_sq_dist::<M, _>(d, ell, period, param_idx)
})
}
pub(crate) fn hess_cross_from_coords<M: KernelMath, T: KernelScalar>(
&self,
x1: MatRef<'_, T>,
x2: MatRef<'_, T>,
d2_k: MatMut<'_, T>,
i: usize,
j: usize,
) -> Result<(), GprError> {
require_periodic_hess_idx(i, j)?;
let ell = T::from_f64(self.lengthscale());
let period = T::from_f64(self.period());
write_rect_from_coords(x1, x2, d2_k, |d| {
periodic_hess_from_sq_dist::<M, _>(d, ell, period, i, j)
})
}
}
fn expect_two_params(len: usize) -> Result<(), GprError> {
if len == 2 {
Ok(())
} else {
Err(GprError::LengthMismatch {
reason: format!("expected 2 periodic parameters, got {len}"),
})
}
}
fn euclidean_from_sq<T: KernelScalar>(sq_dist: T) -> Result<T, GprError> {
let d = finite_dist(sq_dist)?;
Ok(d.max(T::from_f64(0.0)).sqrt())
}
fn periodic_from_r<M: KernelMath, T: KernelScalar>(r: T, ell: T, period: T) -> T {
let s = (T::from_f64(std::f64::consts::PI) * r / period).sin();
let inv_ell = T::from_f64(1.0) / ell;
M::exp(-T::from_f64(2.0) * s * s * inv_ell * inv_ell)
}
fn periodic_from_sq_dist<M: KernelMath, T: KernelScalar>(
sq_dist: T,
ell: T,
period: T,
) -> Result<T, GprError> {
let r = euclidean_from_sq(sq_dist)?;
finite_kernel(periodic_from_r::<M, _>(r, ell, period))
}
fn periodic_grad_from_sq_dist<M: KernelMath, T: KernelScalar>(
sq_dist: T,
ell: T,
period: T,
param_idx: usize,
) -> Result<T, GprError> {
let r = euclidean_from_sq(sq_dist)?;
let alpha = T::from_f64(std::f64::consts::PI) * r / period;
let s = alpha.sin();
let inv_ell_sq = T::from_f64(1.0) / (ell * ell);
let z = -T::from_f64(2.0) * s * s * inv_ell_sq;
let beta = T::from_f64(4.0) * s * s * inv_ell_sq;
let gamma = T::from_f64(4.0) * s * alpha.cos() * alpha * inv_ell_sq;
let dk = if M::ACCURATE {
let k = z.exp();
if param_idx == 0 { k * beta } else { k * gamma }
} else {
let d1 = M::jet(z).d1;
if param_idx == 0 {
d1 * beta
} else {
d1 * gamma
}
};
finite_kernel(dk)
}
fn periodic_hess_from_sq_dist<M: KernelMath, T: KernelScalar>(
sq_dist: T,
ell: T,
period: T,
i: usize,
j: usize,
) -> Result<T, GprError> {
let r = euclidean_from_sq(sq_dist)?;
let alpha = T::from_f64(std::f64::consts::PI) * r / period;
let s = alpha.sin();
let c = alpha.cos();
let inv_ell_sq = T::from_f64(1.0) / (ell * ell);
let z = -T::from_f64(2.0) * s * s * inv_ell_sq;
let beta = T::from_f64(4.0) * s * s * inv_ell_sq;
let gamma = T::from_f64(4.0) * s * c * alpha * inv_ell_sq;
let (a, b) = if i <= j { (i, j) } else { (j, i) };
let h = if M::ACCURATE {
let k = z.exp();
match (a, b) {
(0, 0) => k * beta * (beta - T::from_f64(2.0)),
(0, 1) => k * gamma * (beta - T::from_f64(2.0)),
(1, 1) => {
let dgamma = T::from_f64(4.0)
* inv_ell_sq
* (-alpha * alpha * c * c + alpha * alpha * s * s - alpha * s * c);
k * gamma * gamma + k * dgamma
}
_ => T::from_f64(0.0),
}
} else {
let jet = M::jet(z);
match (a, b) {
(0, 0) => beta * (jet.d2 * beta - T::from_f64(2.0) * jet.d1),
(0, 1) => gamma * (jet.d2 * beta - T::from_f64(2.0) * jet.d1),
(1, 1) => {
let dgamma = T::from_f64(4.0)
* inv_ell_sq
* (-alpha * alpha * c * c + alpha * alpha * s * s - alpha * s * c);
jet.d2 * gamma * gamma + jet.d1 * dgamma
}
_ => T::from_f64(0.0),
}
};
finite_kernel(h)
}
fn require_periodic_hess_idx(i: usize, j: usize) -> Result<(), GprError> {
if i <= 1 && j <= 1 {
Ok(())
} else {
Err(GprError::IndexOutOfRange {
reason: format!("periodic kernel parameter pair ({i}, {j}) is out of range"),
})
}
}
fn finite_kernel<T: KernelScalar>(value: T) -> Result<T, GprError> {
if value.is_finite() {
Ok(value)
} else {
Err(GprError::NonFiniteKernelValue)
}
}
#[cfg(test)]
mod tests {
use super::PeriodicKernel;
use crate::error::GprError;
use crate::kernel::Triangle;
use faer::{Mat, mat};
const TOL: f64 = 1e-8;
use crate::test_check::{assert_close, assert_lower_close, assert_send_sync, fill, sq_dist_1d};
#[test]
fn is_send_sync() {
assert_send_sync::<PeriodicKernel>();
}
#[test]
fn diagonal_is_one_and_period_repeats() {
let period = 2.0;
let kernel = PeriodicKernel::new(1.25, period).expect("valid");
let dist = sq_dist_1d(&[0.0, 0.5, period]);
let mut k = fill(3, f64::NAN);
kernel
.apply(dist.as_ref(), k.as_mut(), Triangle::Full)
.expect("shape");
assert_close(k[(0, 0)], 1.0, TOL);
assert_close(k[(1, 1)], 1.0, TOL);
assert_close(k[(2, 2)], 1.0, TOL);
assert_close(k[(0, 2)], 1.0, TOL);
}
#[test]
fn known_value_at_half_period() {
let ell = 1.5;
let period = 4.0;
let half = period / 2.0;
let kernel = PeriodicKernel::new(ell, period).expect("valid");
let dist = mat![[0.0, half * half], [half * half, 0.0]];
let mut k = fill(2, 0.0);
kernel
.apply(dist.as_ref(), k.as_mut(), Triangle::Full)
.expect("shape");
assert_close(k[(0, 1)], (-2.0 / (ell * ell)).exp(), TOL);
}
#[test]
fn full_is_symmetric() {
let kernel = PeriodicKernel::new(0.8, 3.0).expect("valid");
let dist = sq_dist_1d(&[0.0, 0.4, 1.1, 2.7]);
let mut k = fill(4, 0.0);
kernel
.apply(dist.as_ref(), k.as_mut(), Triangle::Full)
.expect("shape");
for col in 0..4 {
for row in 0..4 {
assert_close(k[(row, col)], k[(col, row)], TOL);
}
}
}
#[test]
fn lower_matches_full_and_leaves_upper() {
let kernel = PeriodicKernel::new(1.0, 2.5).expect("valid");
let dist = sq_dist_1d(&[0.0, 0.7, 1.4]);
let mut full = fill(3, 0.0);
kernel
.apply(dist.as_ref(), full.as_mut(), Triangle::Full)
.expect("shape");
let sentinel = 42.0;
let mut lower = fill(3, sentinel);
kernel
.apply(dist.as_ref(), lower.as_mut(), Triangle::Lower)
.expect("shape");
assert_lower_close(lower.as_ref(), full.as_ref(), TOL);
assert_close(lower[(0, 1)], sentinel, TOL);
assert_close(lower[(0, 2)], sentinel, TOL);
assert_close(lower[(1, 2)], sentinel, TOL);
}
#[test]
fn upper_matches_full() {
let kernel = PeriodicKernel::new(1.0, 2.0).expect("valid");
let dist = sq_dist_1d(&[0.0, 1.0, 1.5]);
let mut full = fill(3, 0.0);
let mut upper = fill(3, -1.0);
kernel
.apply(dist.as_ref(), full.as_mut(), Triangle::Full)
.expect("shape");
kernel
.apply(dist.as_ref(), upper.as_mut(), Triangle::Upper)
.expect("shape");
for col in 0..3 {
for row in 0..=col {
assert_close(upper[(row, col)], full[(row, col)], TOL);
}
}
assert_close(upper[(1, 0)], -1.0, TOL);
}
#[test]
fn hess_matches_finite_difference_of_grad() {
let kernel = PeriodicKernel::from_log(-0.15, 0.4).expect("valid");
let mut theta = [0.0; 2];
kernel.get_params(&mut theta).expect("len 2");
let h = 1e-6;
let dist = sq_dist_1d(&[0.0, 0.7, 1.4]);
for i in 0..2 {
for j in 0..2 {
let mut plus_th = theta;
let mut minus_th = theta;
plus_th[j] += h;
minus_th[j] -= h;
let plus = PeriodicKernel::from_log(plus_th[0], plus_th[1]).expect("valid");
let minus = PeriodicKernel::from_log(minus_th[0], minus_th[1]).expect("valid");
let mut g_plus = fill(3, 0.0);
let mut g_minus = fill(3, 0.0);
let mut d2 = fill(3, 0.0);
plus.grad(dist.as_ref(), g_plus.as_mut(), i, Triangle::Full)
.expect("plus");
minus
.grad(dist.as_ref(), g_minus.as_mut(), i, Triangle::Full)
.expect("minus");
kernel
.hess(dist.as_ref(), d2.as_mut(), i, j, Triangle::Full)
.expect("pair");
for col in 0..3 {
for row in 0..3 {
let fd = (g_plus[(row, col)] - g_minus[(row, col)]) / (2.0 * h);
assert_close(d2[(row, col)], fd, TOL);
}
}
}
}
}
#[test]
fn grad_matches_finite_difference() {
let kernel = PeriodicKernel::from_log(-0.2, 0.4).expect("valid");
let mut theta = [0.0; 2];
kernel.get_params(&mut theta).expect("len 2");
let h = 1e-6;
let dist = sq_dist_1d(&[0.0, 0.9, 1.7]);
for idx in 0..2 {
let mut plus_th = theta;
let mut minus_th = theta;
plus_th[idx] += h;
minus_th[idx] -= h;
let plus = PeriodicKernel::from_log(plus_th[0], plus_th[1]).expect("valid");
let minus = PeriodicKernel::from_log(minus_th[0], minus_th[1]).expect("valid");
let mut k_plus = fill(3, 0.0);
let mut k_minus = fill(3, 0.0);
let mut dk = fill(3, 0.0);
plus.apply(dist.as_ref(), k_plus.as_mut(), Triangle::Full)
.expect("plus");
minus
.apply(dist.as_ref(), k_minus.as_mut(), Triangle::Full)
.expect("minus");
kernel
.grad(dist.as_ref(), dk.as_mut(), idx, Triangle::Full)
.expect("idx");
for col in 0..3 {
for row in 0..3 {
let fd = (k_plus[(row, col)] - k_minus[(row, col)]) / (2.0 * h);
assert_close(dk[(row, col)], fd, TOL);
}
}
}
}
#[test]
fn grad_lower_matches_full() {
let kernel = PeriodicKernel::new(1.0, 2.0).expect("valid");
let dist = sq_dist_1d(&[0.0, 0.8, 1.6]);
let mut full = fill(3, 0.0);
let mut lower = fill(3, 99.0);
kernel
.grad(dist.as_ref(), full.as_mut(), 1, Triangle::Full)
.expect("period");
kernel
.grad(dist.as_ref(), lower.as_mut(), 1, Triangle::Lower)
.expect("period");
assert_lower_close(lower.as_ref(), full.as_ref(), TOL);
assert_close(lower[(0, 1)], 99.0, TOL);
}
#[test]
fn get_set_params_roundtrip_and_atomic() {
let mut kernel = PeriodicKernel::new(2.0, 3.0).expect("valid");
let mut params = [0.0; 2];
kernel.get_params(&mut params).expect("len 2");
assert_close(params[0], 2.0_f64.ln(), TOL);
assert_close(params[1], 3.0_f64.ln(), TOL);
params[0] = 0.5_f64.ln();
kernel.set_params(¶ms).expect("len 2");
assert_close(kernel.lengthscale(), 0.5, TOL);
let before = kernel;
assert!(kernel.set_params(&[0.0, f64::INFINITY]).is_err());
assert_eq!(kernel, before);
}
#[test]
fn apply_cross_and_diag() {
let kernel = PeriodicKernel::new(1.0, 2.0).expect("valid");
let dist = mat![[0.0, 1.0], [4.0, 0.0]];
let mut out = Mat::zeros(2, 2);
kernel
.apply_cross(dist.as_ref(), out.as_mut())
.expect("rect");
let mut square = fill(2, 0.0);
kernel
.apply(dist.as_ref(), square.as_mut(), Triangle::Full)
.expect("square");
assert_close(out[(0, 1)], square[(0, 1)], TOL);
let mut diag = [0.0, 0.0];
kernel.fill_diag(&mut diag);
assert_close(diag[0], 1.0, TOL);
}
#[test]
fn rejects_non_positive_and_bad_index() {
assert!(matches!(
PeriodicKernel::new(0.0, 1.0),
Err(GprError::InvalidHyperparameter { .. })
));
assert!(matches!(
PeriodicKernel::new(1.0, 0.0),
Err(GprError::InvalidHyperparameter { .. })
));
let kernel = PeriodicKernel::new(1.0, 2.0).expect("valid");
let dist = sq_dist_1d(&[0.0, 1.0]);
let mut dk = fill(2, 0.0);
assert!(matches!(
kernel.grad(dist.as_ref(), dk.as_mut(), 2, Triangle::Lower),
Err(GprError::IndexOutOfRange { .. })
));
}
#[test]
fn apply_rejects_non_finite_dist() {
let kernel = PeriodicKernel::new(1.0, 2.0).expect("valid");
let dist = mat![[0.0, f64::NAN], [f64::NAN, 0.0]];
let mut k = fill(2, 0.0);
assert!(matches!(
kernel.apply(dist.as_ref(), k.as_mut(), Triangle::Full),
Err(GprError::NonFiniteInput)
));
}
}