Struct RipsParams 

#[non_exhaustive]
pub struct RipsParams {

    pub max_dim: usize,
    pub threshold: Option<f64>,
    pub modulus: u32,
    pub threads: usize,
    pub use_emergent_pairs: bool,
    pub use_apparent_pairs: bool,
    pub use_clearing: bool,
    pub use_adjacency_rows: bool,
    pub collapse_edges: bool,
    pub collapse_schedule: CollapseSchedule,
    pub adaptive_collapse: AdaptiveCollapseParams,
    pub engine: Engine,
    pub dense_storage: DenseStorage,
    pub factorization: GraphFactorization,
}

Parameters for crate::rips_persistence.

The engine is dimension-generic. The differential gates cover max_dim <= 2. Stress tests extend through dimension 4.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

max_dim: usize

Highest homology dimension to compute.

threshold: Option<f64>

Filtration threshold. None means the input’s default: the enclosing radius for dense matrices, no threshold for sparse ones.

modulus: u32

Coefficient field Z/p; must be a prime below 32768. Default 2.

threads: usize

Worker threads for the run. 0 and 1 (the default) both run the serial engine. Higher values reduce each dimension concurrently. With RipsParams::collapse_edges set and the ordered or rounds RipsParams::collapse_schedule, threads is the budget for the whole pipeline. The diagram is identical at any thread count.

use_emergent_pairs: bool

Optimization toggle. The diagram is identical with any combination disabled. For differential testing only.

use_apparent_pairs: bool

See RipsParams::use_emergent_pairs.

use_clearing: bool

See RipsParams::use_emergent_pairs.

use_adjacency_rows: bool

See RipsParams::use_emergent_pairs. With this set, and the graph dense enough for the rows to fit their memory budget, the dim-0 apparent test runs on adjacency bitsets instead of the neighbor lists.

collapse_edges: bool

Collapse dominated edges before the engine runs. Off by default. The diagram is identical either way. See collapse.

collapse_schedule: CollapseSchedule

The schedule the collapse uses with collapse_edges set. Default CollapseSchedule::Serial. See CollapseSchedule.

adaptive_collapse: AdaptiveCollapseParams

Objective and deterministic work limit for CollapseSchedule::Adaptive. Other schedules ignore this field.

engine: Engine

Which engine reduces a dense input. Default Engine::Auto. See Engine.

dense_storage: DenseStorage

Which storage form the dense engine reduces from. Default DenseStorage::Auto. See DenseStorage.

factorization: GraphFactorization

Structural decomposition of a sparse terminal graph. Default GraphFactorization::Off. Dense runs use it only after routing to the sparse engine. See GraphFactorization.

Implementations

impl RipsParams

pub fn new(max_dim: usize) -> Self

Defaults with the given max_dim.

The threshold is the input’s default. Reduction shortcuts are on. Edge collapse and structural factorization are off.

pub fn with_threshold(self, threshold: f64) -> Self

Truncate the filtration at threshold.

pub fn with_modulus(self, modulus: u32) -> Self

Compute over Z/p instead of Z/2. modulus must be a prime below 32768.

pub fn with_threads(self, threads: usize) -> Self

Reduce with threads workers. 1 keeps the serial engine. The diagram is identical at any thread count.

pub fn with_edge_collapse(self) -> Self

Collapse dominated edges before the engine runs. The diagram is identical either way. See collapse.

pub fn with_collapse_schedule(self, schedule: CollapseSchedule) -> Self

Collapse dominated edges with the given schedule before the engine runs. Also sets RipsParams::collapse_edges. See CollapseSchedule.

pub fn with_adaptive_collapse(self, params: AdaptiveCollapseParams) -> Self

Collapse with the adaptive version 3 schedule and the given objective and work limit.

pub fn with_engine(self, engine: Engine) -> Self

Choose the engine for a dense input. See Engine.

pub fn with_dense_storage(self, storage: DenseStorage) -> Self

Choose the storage form the dense engine reduces from. See DenseStorage.

pub fn with_factorization(self, factorization: GraphFactorization) -> Self

Choose structural factorization for sparse reduction. See GraphFactorization.

Trait Implementations

impl Clone for RipsParams

fn clone(&self) -> RipsParams

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RipsParams

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RipsParams

fn default() -> Self

Returns the “default value” for a type.