use std::cmp::Ordering;
use super::interval::{IntervalEnd, PersistenceInterval, finite_scale};
use crate::{Error, Result};
use super::ComputedDimensions;
use crate::filtration::Coverage;
#[derive(Clone, Debug, PartialEq)]
pub struct PersistenceDiagram {
dimensions: ComputedDimensions,
coverage: Coverage,
intervals: Vec<PersistenceInterval>,
}
impl PersistenceDiagram {
pub fn new(
max_dimension: usize,
coverage: Coverage,
intervals: Vec<PersistenceInterval>,
) -> Result<Self> {
Self::with_dimensions(
ComputedDimensions::through(max_dimension),
coverage,
intervals,
)
}
pub fn with_dimensions(
dimensions: ComputedDimensions,
coverage: Coverage,
mut intervals: Vec<PersistenceInterval>,
) -> Result<Self> {
let coverage = match coverage {
Coverage::Complete => Coverage::Complete,
Coverage::Through(value) => Coverage::Through(finite_scale(value, "coverage")?),
};
for (index, interval) in intervals.iter().enumerate() {
if !dimensions.contains(interval.dimension()) {
return Err(Error::DimensionNotComputed {
requested: interval.dimension(),
computed_max: dimensions.max(),
});
}
validate_coverage(interval, coverage, index)?;
}
intervals.sort_unstable_by(compare_intervals);
Ok(Self {
dimensions,
coverage,
intervals,
})
}
pub fn max_dimension(&self) -> usize {
self.dimensions.max()
}
pub fn computed_dimensions(&self) -> &ComputedDimensions {
&self.dimensions
}
pub fn coverage(&self) -> Coverage {
self.coverage
}
pub fn len(&self) -> usize {
self.intervals.len()
}
pub fn is_empty(&self) -> bool {
self.intervals.is_empty()
}
pub fn intervals(&self) -> impl Iterator<Item = PersistenceInterval> + '_ {
self.intervals.iter().copied()
}
pub fn interval(&self, index: usize) -> Option<PersistenceInterval> {
self.intervals.get(index).copied()
}
pub fn dimension(&self, dimension: usize) -> Result<DiagramDimension<'_>> {
if !self.dimensions.contains(dimension) {
return Err(Error::DimensionNotComputed {
requested: dimension,
computed_max: self.dimensions.max(),
});
}
let start = self
.intervals
.partition_point(|interval| interval.dimension() < dimension);
let end = self
.intervals
.partition_point(|interval| interval.dimension() <= dimension);
Ok(DiagramDimension {
dimension,
intervals: &self.intervals[start..end],
})
}
}
#[derive(Debug)]
pub struct DiagramDimension<'a> {
dimension: usize,
intervals: &'a [PersistenceInterval],
}
impl DiagramDimension<'_> {
pub fn dimension(&self) -> usize {
self.dimension
}
pub fn len(&self) -> usize {
self.intervals.len()
}
pub fn is_empty(&self) -> bool {
self.intervals.is_empty()
}
pub fn iter(&self) -> impl Iterator<Item = PersistenceInterval> + '_ {
self.intervals.iter().copied()
}
}
fn validate_coverage(
interval: &PersistenceInterval,
coverage: Coverage,
index: usize,
) -> Result<()> {
let reason = match coverage {
Coverage::Complete => match interval.end() {
IntervalEnd::RightCensored { .. } => {
Some("complete coverage cannot contain censored intervals")
}
_ => None,
},
Coverage::Through(cutoff) => {
if interval.birth() > cutoff {
Some("birth exceeds the computation cutoff")
} else {
match interval.end() {
IntervalEnd::Essential => {
Some("truncated coverage cannot certify an essential interval")
}
IntervalEnd::Finite(death) if death > cutoff => {
Some("death exceeds the computation cutoff")
}
IntervalEnd::RightCensored { through } if through != cutoff => {
Some("interval and diagram censoring cutoffs differ")
}
_ => None,
}
}
}
};
match reason {
Some(reason) => Err(Error::InconsistentDiagram {
interval: index,
reason,
}),
None => Ok(()),
}
}
fn compare_intervals(a: &PersistenceInterval, b: &PersistenceInterval) -> Ordering {
a.dimension()
.cmp(&b.dimension())
.then_with(|| a.birth().total_cmp(&b.birth()))
.then_with(|| compare_ends(a.end(), b.end()))
}
fn compare_ends(a: IntervalEnd, b: IntervalEnd) -> Ordering {
match (a, b) {
(IntervalEnd::Finite(a), IntervalEnd::Finite(b)) => a.total_cmp(&b),
(IntervalEnd::Essential, IntervalEnd::Essential) => Ordering::Equal,
(IntervalEnd::RightCensored { through: a }, IntervalEnd::RightCensored { through: b }) => {
a.total_cmp(&b)
}
(IntervalEnd::Finite(_), _)
| (IntervalEnd::Essential, IntervalEnd::RightCensored { .. }) => Ordering::Less,
_ => Ordering::Greater,
}
}