use super::{PersistenceOptions, RepresentativeRequest};
use crate::algebra::PrimeField;
use crate::diagram::PersistenceResult;
use crate::execution::{Execution, WorkBudget};
use crate::{Error, Result};
type Compute<S> = fn(
&S,
&PersistenceOptions,
&[RepresentativeRequest],
&mut WorkBudget<'_>,
) -> Result<PersistenceResult>;
pub struct PersistenceBuilder<'s, 'r, S> {
source: &'s S,
compute: Compute<S>,
dimension: usize,
cutoff: Option<f64>,
field: PrimeField,
requests: &'r [RepresentativeRequest],
signed_scale: bool,
}
impl<'s, S> PersistenceBuilder<'s, 'static, S> {
pub(super) fn new(source: &'s S, compute: Compute<S>) -> Self {
Self {
source,
compute,
dimension: 1,
cutoff: None,
field: PrimeField::default(),
requests: &[],
signed_scale: false,
}
}
}
impl<'s, S: crate::complex::FilteredComplex> PersistenceBuilder<'s, 'static, S> {
pub fn from_complex(source: &'s S) -> Self {
Self::new_filtered(source, super::filtered::compute::<S>)
}
}
impl<'s, S> PersistenceBuilder<'s, 'static, S> {
pub(super) fn new_filtered(source: &'s S, compute: Compute<S>) -> Self {
let mut result = Self::new(source, compute);
result.signed_scale = true;
result
}
}
impl<'s, S> PersistenceBuilder<'s, '_, S> {
pub fn max_homology_dimension(mut self, dimension: usize) -> Self {
self.dimension = dimension;
self
}
pub fn field(mut self, field: PrimeField) -> Self {
self.field = field;
self
}
pub fn max_filtration_value(mut self, value: f64) -> Self {
self.cutoff = Some(value);
self
}
pub fn available_range(mut self) -> Self {
self.cutoff = None;
self
}
pub fn representatives<'r>(
self,
requests: &'r [RepresentativeRequest],
) -> PersistenceBuilder<'s, 'r, S> {
PersistenceBuilder {
source: self.source,
compute: self.compute,
dimension: self.dimension,
cutoff: self.cutoff,
field: self.field,
requests,
signed_scale: self.signed_scale,
}
}
pub fn compute(self) -> Result<PersistenceResult> {
self.compute_with(&Execution::default())
}
pub fn compute_with(self, execution: &Execution<'_>) -> Result<PersistenceResult> {
let options = if self.signed_scale {
PersistenceOptions::for_filtration(self.dimension, self.cutoff)
} else {
PersistenceOptions::new(self.dimension, self.cutoff)
}?
.with_field(self.field);
for request in self.requests {
if request.dimension() > self.dimension {
return Err(Error::DimensionNotComputed {
requested: request.dimension(),
computed_max: self.dimension,
});
}
}
(self.compute)(
self.source,
&options,
self.requests,
&mut WorkBudget::new(execution)?,
)
}
}