DDA Packages

Implementation libraries for Python, Rust, and Julia

dda-py

Python Wrapper for Delay Differential Analysis

Overview

dda-py is the official Python wrapper of Delay Differential Analysis. This package provides tools for time series classification using delay differential equations.

Installation

pip install dda-py

Quick Start

import dda_py

# Initialize with APE binary path
dda_py.init("./run_DDA_AsciiEdf")

# Run DDA analysis
Q, output_path = dda_py.run_dda(
    input_file="data.edf",
    channel_list=["1", "2", "3"]
)

print(f"Result shape: {Q.shape}")  # channels × time windows

Using DDARunner Class

from dda_py import DDARunner

runner = DDARunner("./run_DDA_AsciiEdf")

Q, output_path = runner.run(
    input_file="data.edf",
    channel_list=["1", "2", "3"],
    bounds=(1000, 5000),  # Optional time bounds
    cpu_time=True         # Enable CPU timing
)

Links

View on PyPI Documentation

Features

Time series classification using delay differential equations
Efficient NumPy-based implementation
Compatible with scikit-learn pipelines
Comprehensive documentation and examples

dda-rs

Rust Crate for Delay Differential Analysis

Overview

dda-rs is a high-performance Rust wrapper of Delay Differential Analysis. Built for speed and memory safety, this crate is ideal for production systems requiring efficient time series processing.

Installation

Add to your Cargo.toml:

[dependencies]
dda-rs = "0.1.3"

Quick Start

use dda_rs::{DDARunner, DDARequest, WindowParameters,
             ScaleParameters, TimeRange, PreprocessingOptions,
             AlgorithmSelection};

#[tokio::main]
async fn main() -> Result<(), Box> {
    // Create runner with path to run_DDA_AsciiEdf binary
    let runner = DDARunner::new("/path/to/run_DDA_AsciiEdf")?;

    // Build analysis request
    let request = DDARequest {
        file_path: "/path/to/data.edf".to_string(),
        channels: Some(vec![0, 1]),  // 0-based channel indices
        time_range: TimeRange { start: 0.0, end: 100.0 },
        preprocessing_options: PreprocessingOptions {
            detrending: Some("linear".to_string()),
            highpass: None,
            lowpass: None,
        },
        algorithm_selection: AlgorithmSelection {
            enabled_variants: vec!["standard".to_string()],
        },
        window_parameters: WindowParameters {
            window_length: 1024,
            window_step: 512,
        },
        scale_parameters: ScaleParameters {
            scale_min: 1.0,
            scale_max: 10.0,
            scale_num: 10,
        },
    };

    // Run analysis with sample bounds (start_sample, end_sample)
    let start_bound = 0;  // Start from beginning
    let end_bound = 10000;  // End at sample 10000
    let result = runner.run(&request, start_bound, end_bound).await?;

    // Access results
    println!("Analysis ID: {}", result.id);
    println!("Q matrix shape: {} × {}",
             result.q_matrix.len(), result.q_matrix[0].len());

    Ok(())
}

Links

View on Crates.io Documentation

Features

High-performance implementation with zero-cost abstractions
Memory-safe with Rust's ownership system
Thread-safe concurrent processing
C FFI bindings for integration with other languages

DelayDifferentialAnalysis.jl

Julia Package for Delay Differential Analysis

Overview

DelayDifferentialAnalysis.jl provides a clean, type-safe Julia interface to execute the Delay Differential Analysis (DDA) binary and parse its output. It handles all the complexities of cross-platform APE binary execution, command-line argument construction, output file parsing, and error handling.

Installation

using Pkg
Pkg.add("DelayDifferentialAnalysis")

For development version:

using Pkg
Pkg.add(url="https://github.com/sdraeger/DelayDifferentialAnalysis.jl")

Quick Start

using DelayDifferentialAnalysis

# Create runner with path to run_DDA_AsciiEdf binary
runner = DDARunner("/path/to/run_DDA_AsciiEdf")

# Build analysis request
request = DDARequest(
    "/path/to/data.edf",                     # file_path
    [1, 2],                                  # channels (1-based indices)
    nothing,                                 # bounds (nothing = entire file)
    AlgorithmSelection(
        ["ST"],                               # enabled_variants
        nothing                               # select_mask
    ),
    WindowParameters(
        1024,                                 # window_length
        512,                                  # window_step
        nothing,                              # ct_window_length
        nothing                               # ct_window_step
    ),
    DelayParameters([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
    nothing                                   # ct_channel_pairs
)

# Run analysis
result = run_dda(runner, request)

# Access results
println("Q matrix shape: $(size(result.q_matrix))")

Multi-Channel Analysis with Sample Bounds

using DelayDifferentialAnalysis

runner = DDARunner("./bin/run_DDA_AsciiEdf")

request = DDARequest(
    "data.edf",
    [1, 2, 3],
    Bounds(0, 60000),  # Process samples 0-60000
    AlgorithmSelection(["ST", "CT"], nothing),
    WindowParameters(1024, 512, 2048, 1024),
    DelayParameters(collect(1:15)),  # Delays from 1 to 15
    [[1, 2], [2, 3]]  # CT channel pairs
)

result = run_dda(runner, request)

# Access variant-specific results
if !isnothing(result.variant_results)
    for variant in result.variant_results
        println("$(variant.variant_name): $(size(variant.q_matrix))")
    end
end

Links

View on GitHub Download DDA Binary

Features

Type-safe API with strongly-typed request and response structures
Cross-platform APE binary execution (Windows/macOS/Linux)
Automatic parsing of DDA output into usable matrices
Comprehensive error handling with descriptive error types
Support for multiple DDA variants (ST, CT, CD, DE)