mod cohomology;
mod dispatch;
mod h0;
use super::RepresentativeRequest;
use super::simplicial::finish_zero_born;
pub(super) use dispatch::{compute_dense, compute_graph};
use super::execution::WorkBudget;
use super::{ExecutionLimits, PersistenceOptions};
use crate::Result;
use crate::diagram::{ComputationContext, Coverage, FiltrationKind, PersistenceResult};
use crate::filtration::{FlagFiltration, flag::CliqueAccess};
pub fn compute_flag(
input: &FlagFiltration,
options: &PersistenceOptions,
limits: &ExecutionLimits<'_>,
) -> Result<PersistenceResult> {
compute_flag_with_representatives(input, options, &[], limits)
}
pub fn compute_flag_with_representatives(
input: &FlagFiltration,
options: &PersistenceOptions,
requests: &[RepresentativeRequest],
limits: &ExecutionLimits<'_>,
) -> Result<PersistenceResult> {
let mut budget = WorkBudget::new(limits)?;
compute_flag_budget(input, options, requests, &mut budget)
}
pub(in crate::persistence) fn compute_flag_budget(
input: &FlagFiltration,
options: &PersistenceOptions,
requests: &[RepresentativeRequest],
budget: &mut WorkBudget<'_>,
) -> Result<PersistenceResult> {
let graph = input.graph();
let (cutoff, coverage) = match options.max_edge() {
Some(t) if t < graph.max_edge() => (t, Coverage::Through(t)),
_ => (graph.max_edge(), Coverage::Complete),
};
let (diagram, representatives) = finish_zero_born(
&CliqueAccess::Sparse(graph, cutoff),
options,
requests,
coverage,
budget,
|budget| {
compute_graph(
graph,
options.max_homology_dimension(),
cutoff,
options.field(),
budget,
)
},
)?;
Ok(PersistenceResult::new(
diagram,
ComputationContext::new(
options.field(),
FiltrationKind::SuppliedFlag,
graph.vertex_count(),
options.max_edge(),
None,
None,
),
representatives,
))
}