use crate::algebra::PrimeField;
use crate::filtration::Coverage;
use crate::geometry::distance::cutoff;
use crate::{Error, Result};
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PersistenceOptions {
max_homology_dimension: usize,
max_edge: Option<f64>,
field: PrimeField,
}
impl PersistenceOptions {
pub fn new(max_homology_dimension: usize, max_edge: Option<f64>) -> Result<Self> {
Ok(Self {
max_homology_dimension,
max_edge: cutoff(max_edge)?,
field: PrimeField::default(),
})
}
pub(super) fn for_filtration(
max_homology_dimension: usize,
value: Option<f64>,
) -> Result<Self> {
Ok(Self {
max_homology_dimension,
max_edge: value.map(finite_scale).transpose()?,
field: PrimeField::default(),
})
}
pub fn with_field(mut self, field: PrimeField) -> Self {
self.field = field;
self
}
pub fn field(&self) -> PrimeField {
self.field
}
pub fn max_homology_dimension(&self) -> usize {
self.max_homology_dimension
}
pub fn max_edge(&self) -> Option<f64> {
self.max_edge
}
}
impl Default for PersistenceOptions {
fn default() -> Self {
Self {
max_homology_dimension: 1,
max_edge: None,
field: PrimeField::default(),
}
}
}
pub(super) fn source_range(
coverage: Coverage,
max_edge: f64,
requested: Option<f64>,
) -> Result<(f64, Coverage)> {
match coverage {
Coverage::Through(through) => {
let cutoff = requested.unwrap_or(through);
if cutoff > through {
return Err(Error::IncompleteFiltration {
requested: cutoff,
through,
});
}
Ok((cutoff, Coverage::Through(cutoff)))
}
Coverage::Complete => match requested {
Some(cutoff) if cutoff < max_edge => Ok((cutoff, Coverage::Through(cutoff))),
_ => Ok((max_edge, Coverage::Complete)),
},
}
}
pub(super) fn finite_scale(value: f64) -> Result<f64> {
if !value.is_finite() {
return Err(Error::NonFiniteValue {
field: "filtration scale",
index: None,
});
}
Ok(crate::canonical_zero(value))
}