struktura 1.7.2

Predict failure before it happens. Detects when a signal's structure changes — before thresholds fire. Spacecraft, finance, text, IoT. 85x faster than Python. no_std.
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

use pyo3::prelude::*;
use pyo3::types::PyList;
use crate::{dfa, analyze, compare, anomaly_scores, health_check, HealthVerdict};

#[pyclass]
#[derive(Clone)]
pub struct PyDfaResult {
    #[pyo3(get)]
    pub alpha: f64,
    #[pyo3(get)]
    pub r_squared: f64,
}

#[pymethods]
impl PyDfaResult {
    fn __repr__(&self) -> String {
        format!("DfaResult(alpha={:.4}, r_squared={:.4})", self.alpha, self.r_squared)
    }
}

#[pyclass]
#[derive(Clone)]
pub struct PyAnalysis {
    #[pyo3(get)]
    pub alpha: f64,
    #[pyo3(get)]
    pub r_squared: f64,
    #[pyo3(get)]
    pub hurst: f64,
    #[pyo3(get)]
    pub mean: f64,
    #[pyo3(get)]
    pub std_dev: f64,
    #[pyo3(get)]
    pub kurtosis: f64,
    #[pyo3(get)]
    pub n: usize,
    #[pyo3(get)]
    pub quality: String,
}

#[pymethods]
impl PyAnalysis {
    fn __repr__(&self) -> String {
        format!("Analysis(alpha={:.4}, R²={:.4}, quality={})", self.alpha, self.r_squared, self.quality)
    }
}

#[pyfunction]
fn py_dfa(values: Vec<f64>) -> PyDfaResult {
    let r = dfa(&values);
    PyDfaResult { alpha: r.alpha, r_squared: r.r_squared }
}

#[pyfunction]
fn py_analyze(values: Vec<f64>) -> PyAnalysis {
    let law = analyze(&values);
    PyAnalysis {
        alpha: law.dfa.alpha,
        r_squared: law.dfa.r_squared,
        hurst: law.hurst,
        mean: law.mean,
        std_dev: law.std_dev,
        kurtosis: law.kurtosis,
        n: law.n,
        quality: format!("{}", law.quality),
    }
}

#[pyfunction]
fn py_compare(baseline: Vec<f64>, current: Vec<f64>) -> String {
    let r = compare(&baseline, &current);
    format!("{}", r)
}

#[pyfunction]
fn py_anomaly_scores(values: Vec<f64>, window: usize, step: usize, threshold: f64) -> Vec<f64> {
    anomaly_scores(&values, window, step, threshold)
}

#[pyfunction]
fn py_is_degraded(baseline: Vec<f64>, current: Vec<f64>) -> bool {
    crate::is_degraded(&baseline, &current)
}

#[pymodule]
fn struktura(m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(py_dfa, m)?)?;
    m.add_function(wrap_pyfunction!(py_analyze, m)?)?;
    m.add_function(wrap_pyfunction!(py_compare, m)?)?;
    m.add_function(wrap_pyfunction!(py_anomaly_scores, m)?)?;
    m.add_function(wrap_pyfunction!(py_is_degraded, m)?)?;
    m.add_class::<PyDfaResult>()?;
    m.add_class::<PyAnalysis>()?;
    Ok(())
}