scirs2-stats 0.4.1

Statistical functions module for SciRS2 (scirs2-stats)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! # TopologicalConfig - Trait Implementations
//!
//! This module contains trait implementations for `TopologicalConfig`.
//!
//! ## Implemented Traits
//!
//! - `Debug`
//! - `Clone`
//! - `Default`
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

use scirs2_core::numeric::{Float, NumCast, One, Zero};
use scirs2_core::{simd_ops::SimdUnifiedOps, validation::*};
use scirs2_linalg::parallel_dispatch::ParallelConfig;

use super::functions::const_f64;
use super::types::{
    ClusteringMethod, CoeffientField, CoverConfig, CoverType, DistanceMetric, FiltrationConfig,
    FiltrationType, MapperConfig, MergerStrategy, MultipleComparisonsCorrection, MultiscaleConfig,
    NullModel, PersistenceAlgorithm, PersistenceConfig, ScaleDistribution, SimplificationConfig,
    TopologicalConfig, TopologicalInferenceConfig, TopologicalTest,
};

impl<F> std::fmt::Debug for TopologicalConfig<F>
where
    F: std::fmt::Debug,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TopologicalConfig")
            .field("max_dimension", &self.max_dimension)
            .field("filtration_config", &self.filtration_config)
            .field("persistence_config", &self.persistence_config)
            .field("mapper_config", &self.mapper_config)
            .field("multiscale_config", &self.multiscale_config)
            .field("inference_config", &self.inference_config)
            .field("parallel_config", &"<ParallelConfig>")
            .finish()
    }
}

impl<F> Clone for TopologicalConfig<F>
where
    F: Clone,
{
    fn clone(&self) -> Self {
        Self {
            max_dimension: self.max_dimension,
            filtration_config: self.filtration_config.clone(),
            persistence_config: self.persistence_config.clone(),
            mapper_config: self.mapper_config.clone(),
            multiscale_config: self.multiscale_config.clone(),
            inference_config: self.inference_config.clone(),
            parallel_config: ParallelConfig::default(),
        }
    }
}

impl<F> Default for TopologicalConfig<F>
where
    F: Float + NumCast + Copy + std::fmt::Display + SimdUnifiedOps + Send + Sync,
{
    fn default() -> Self {
        Self {
            max_dimension: 2,
            filtration_config: FiltrationConfig {
                filtration_type: FiltrationType::VietorisRips,
                distance_metric: DistanceMetric::Euclidean,
                max_epsilon: const_f64::<F>(1.0),
                num_steps: 100,
                adaptive_steps: false,
            },
            persistence_config: PersistenceConfig {
                algorithm: PersistenceAlgorithm::StandardReduction,
                coefficient_field: CoeffientField::Z2,
                persistence_threshold: const_f64::<F>(0.01),
                compute_entropy: true,
                stability_analysis: false,
            },
            mapper_config: MapperConfig {
                filter_functions: Vec::new(),
                cover_config: CoverConfig {
                    num_intervals: vec![10],
                    overlap_percent: const_f64::<F>(0.3),
                    cover_type: CoverType::UniformInterval,
                },
                clustering_method: ClusteringMethod::SingleLinkage,
                overlap_threshold: const_f64::<F>(0.1),
                simplification: SimplificationConfig {
                    edge_contraction: false,
                    vertex_removal: false,
                    threshold: 0.01,
                },
            },
            multiscale_config: MultiscaleConfig {
                scale_range: (const_f64::<F>(0.1), const_f64::<F>(2.0)),
                num_scales: 10,
                scale_distribution: ScaleDistribution::Linear,
                merger_strategy: MergerStrategy::Union,
            },
            inference_config: TopologicalInferenceConfig {
                bootstrap_samples: 0,
                confidence_level: const_f64::<F>(0.95),
                null_model: NullModel::UniformRandom,
                test_type: TopologicalTest::PersistentRankTest,
                multiple_comparisons: MultipleComparisonsCorrection::BenjaminiHochberg,
            },
            parallel_config: ParallelConfig::default(),
        }
    }
}