use super::assemble_diagram;
use crate::Result;
use crate::diagram::{Coverage, PersistenceDiagram};
use crate::geometry::{DissimilarityView, PointCloudView, euclidean_distances};
use super::execution::WorkBudget;
use super::{ExecutionLimits, PersistenceOptions, RepresentativeRequest};
use super::{flag, simplicial};
use crate::filtration::flag::CliqueAccess;
pub(super) mod approximation;
pub(super) mod expanded;
pub use approximation::{
compute_expanded_sparse_rips, compute_expanded_sparse_rips_with_representatives,
compute_sparse_rips, compute_sparse_rips_with_representatives,
};
mod options;
pub use expanded::{compute_expanded_rips, compute_expanded_rips_with_representatives};
pub use options::RipsOptions;
pub fn rips_from_dissimilarities(
input: DissimilarityView<'_>,
options: &RipsOptions,
) -> Result<PersistenceDiagram> {
let (cutoff, coverage) = resolve_rips_range(input, options);
let mut budget = WorkBudget::new(&ExecutionLimits::default())?;
let raw = flag::compute_dense(
input.into(),
options.max_dimension(),
cutoff,
crate::algebra::PrimeField::default(),
&mut budget,
)?;
assemble_diagram(options.max_dimension(), coverage, raw)
}
pub fn rips_from_points(
input: PointCloudView<'_>,
options: &RipsOptions,
) -> Result<PersistenceDiagram> {
let distances = euclidean_distances(input)?;
rips_from_dissimilarities(DissimilarityView::new(&distances, input.len())?, options)
}
pub(super) fn resolve_rips_range(
input: DissimilarityView<'_>,
options: &RipsOptions,
) -> (f64, Coverage) {
match options.max_edge() {
Some(cutoff) if cutoff < input.diameter() => (cutoff, Coverage::Through(cutoff)),
_ => (input.diameter(), Coverage::Complete),
}
}
pub fn compute_rips_from_distances(
input: crate::geometry::DissimilarityMatrixView<'_>,
options: &PersistenceOptions,
limits: &ExecutionLimits<'_>,
) -> Result<crate::diagram::PersistenceResult> {
compute_rips_from_distances_with_representatives(input, options, &[], limits)
}
pub fn compute_rips_from_distances_with_representatives(
input: crate::geometry::DissimilarityMatrixView<'_>,
options: &PersistenceOptions,
requests: &[RepresentativeRequest],
limits: &ExecutionLimits<'_>,
) -> Result<crate::diagram::PersistenceResult> {
let mut budget = WorkBudget::new(limits)?;
compute_rips_from_distances_budget(input, options, requests, &mut budget)
}
pub(in crate::persistence) fn compute_rips_from_distances_budget(
input: crate::geometry::DissimilarityMatrixView<'_>,
options: &PersistenceOptions,
requests: &[RepresentativeRequest],
budget: &mut WorkBudget<'_>,
) -> Result<crate::diagram::PersistenceResult> {
use crate::diagram::{ComputationContext, FiltrationKind, PersistenceResult};
let (cutoff, coverage) = match options.max_edge() {
Some(t) if t < input.diameter() => (t, Coverage::Through(t)),
_ => (input.diameter(), Coverage::Complete),
};
let (diagram, representatives) = simplicial::finish_zero_born(
&CliqueAccess::Dense(input, cutoff),
options,
requests,
coverage,
budget,
|budget| {
flag::compute_dense(
input,
options.max_homology_dimension(),
cutoff,
options.field(),
budget,
)
},
)?;
Ok(PersistenceResult::new(
diagram,
ComputationContext::new(
options.field(),
FiltrationKind::RipsDissimilarities,
input.len(),
options.max_edge(),
None,
None,
),
representatives,
))
}
pub fn compute_threshold_rips(
input: &crate::filtration::ThresholdRips,
options: &PersistenceOptions,
limits: &ExecutionLimits<'_>,
) -> Result<crate::diagram::PersistenceResult> {
compute_threshold_rips_with_representatives(input, options, &[], limits)
}
pub fn compute_threshold_rips_with_representatives(
input: &crate::filtration::ThresholdRips,
options: &PersistenceOptions,
requests: &[RepresentativeRequest],
limits: &ExecutionLimits<'_>,
) -> Result<crate::diagram::PersistenceResult> {
let mut budget = WorkBudget::new(limits)?;
compute_threshold_rips_budget(input, options, requests, &mut budget)
}
pub(in crate::persistence) fn compute_threshold_rips_budget(
input: &crate::filtration::ThresholdRips,
options: &PersistenceOptions,
requests: &[RepresentativeRequest],
budget: &mut WorkBudget<'_>,
) -> Result<crate::diagram::PersistenceResult> {
use crate::diagram::{ComputationContext, FiltrationKind, PersistenceResult};
use crate::filtration::RipsInputKind;
let (cutoff, coverage) = crate::persistence::options::source_range(
input.coverage(),
input.graph().max_edge(),
options.max_edge(),
)?;
let (diagram, representatives) = simplicial::finish_zero_born(
&CliqueAccess::Sparse(input.graph(), cutoff),
options,
requests,
coverage,
budget,
|budget| {
flag::compute_graph(
input.graph(),
options.max_homology_dimension(),
cutoff,
options.field(),
budget,
)
},
)?;
let kind = match input.input_kind() {
RipsInputKind::Dissimilarities => FiltrationKind::RipsDissimilarities,
RipsInputKind::Euclidean => FiltrationKind::RipsEuclidean,
RipsInputKind::Custom => FiltrationKind::RipsCustom,
};
Ok(PersistenceResult::new(
diagram,
ComputationContext::new(
options.field(),
kind,
input.graph().vertex_count(),
options.max_edge(),
input.requested_cutoff(),
None,
),
representatives,
))
}
pub fn compute_rips_from_points(
input: PointCloudView<'_>,
options: &PersistenceOptions,
limits: &ExecutionLimits<'_>,
) -> Result<crate::diagram::PersistenceResult> {
compute_rips_from_points_with_representatives(input, options, &[], limits)
}
pub fn compute_rips_from_points_with_representatives(
input: PointCloudView<'_>,
options: &PersistenceOptions,
requests: &[RepresentativeRequest],
limits: &ExecutionLimits<'_>,
) -> Result<crate::diagram::PersistenceResult> {
WorkBudget::new(limits)?.check()?;
if options.max_edge().is_some() {
let graph = crate::filtration::threshold_rips_from_points(input, options.max_edge())?;
compute_threshold_rips_with_representatives(&graph, options, requests, limits)
} else {
let values = euclidean_distances(input)?;
let result = compute_rips_from_distances_with_representatives(
DissimilarityView::new(&values, input.len())?.into(),
options,
requests,
limits,
)?;
let context = crate::diagram::ComputationContext::new(
options.field(),
crate::diagram::FiltrationKind::RipsEuclidean,
input.len(),
options.max_edge(),
None,
None,
);
Ok(result.with_context(context))
}
}