dda-rs 0.2.0

Pure Rust Delay Differential Analysis engine
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

# dda-rs

Pure Rust Delay Differential Analysis (DDA) engine.

`dda-rs` no longer shells out to the legacy `run_DDA_AsciiEdf` binary. All analysis runs through the Rust engine directly.

## Features

- Pure Rust execution for DDA variants and CCD extensions
- Typed request/response API with `serde`
- Built-in variant metadata and SELECT-mask helpers
- Configurable solver backend:
  - `RobustSvd` for the default numerically stable path
  - `NativeCompatSvd` for the native-compatible SVD path

## Installation

```toml
[dependencies]
dda-rs = "0.2.0"
```

## Quick Start

```rust
use dda_rs::{
    run_request_on_matrix, AlgorithmSelection, DDARequest, DelayParameters, PreprocessingOptions,
    TimeRange, WindowParameters,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let request = DDARequest {
        file_path: "synthetic.csv".to_string(),
        channels: Some(vec![0, 1, 2]),
        time_range: TimeRange {
            start: 0.0,
            end: 511.0,
        },
        preprocessing_options: PreprocessingOptions {
            highpass: None,
            lowpass: None,
        },
        algorithm_selection: AlgorithmSelection {
            enabled_variants: vec!["ST".to_string(), "CD".to_string()],
            select_mask: None,
        },
        window_parameters: WindowParameters {
            window_length: 128,
            window_step: 64,
            ct_window_length: None,
            ct_window_step: None,
        },
        delay_parameters: DelayParameters { delays: vec![1, 2] },
        ct_channel_pairs: None,
        cd_channel_pairs: None,
        model_parameters: None,
        model_terms: None,
        variant_configs: None,
        sampling_rate: None,
    };

    let samples = (0..512)
        .map(|t| {
            let x = t as f64 * 0.03;
            vec![x.sin(), (1.7 * x).cos(), (0.5 * x).sin()]
        })
        .collect::<Vec<_>>();

    let result = run_request_on_matrix(&request, &samples, None)?;
    println!("analysis id: {}", result.id);
    Ok(())
}
```

## Solver Backends

The Rust engine exposes two SVD backends through `PureRustOptions::svd_backend`:

- `SvdBackend::RobustSvd`
  - default
  - uses nalgebra SVD
  - preferred for real analysis
- `SvdBackend::NativeCompatSvd`
  - uses the native-compatible SVD kernel ported into Rust
  - useful when comparing against historical native-binary behavior

## Modules

- `engine`: core DDA and CCD execution
- `types`: request/response structures
- `variants`: variant metadata and SELECT-mask utilities
- `network_motifs`: motif analysis helpers
- `profiling`: profiling helpers
- `error`: error types

## License

MIT