rangebar-batch 5.0.0

Batch processing engine for range bar computation
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

# rangebar-batch

High-throughput batch analytics engine with parallel multi-symbol analysis.

## Overview

`rangebar-batch` provides batch processing capabilities for historical range bar analysis with parallel execution via Rayon. Optimized for research, backtesting, and comprehensive market analysis across multiple symbols.

## Features

- **Parallel Processing**: Multi-symbol analysis using Rayon thread pool
- **Comprehensive Statistics**: Price, volume, and trade count analytics
- **Multi-Symbol Support**: Analyze entire market segments simultaneously
- **High Throughput**: Scales linearly with CPU cores
- **In-Memory Operations**: Fast processing with full dataset in memory

## Usage

### Single Symbol Analysis

```rust
use rangebar_batch::BatchAnalysisEngine;

let engine = BatchAnalysisEngine::new();
let report = engine.analyze_single_symbol(&range_bars, "BTCUSDT")?;

println!("Total bars: {}", report.total_bars);
println!("Mean price: {}", report.price_statistics.mean);
println!("Total volume: {}", report.volume_statistics.total);
```

### Multi-Symbol Analysis

```rust
use rangebar_batch::BatchAnalysisEngine;
use std::collections::HashMap;

let engine = BatchAnalysisEngine::new();

// Prepare multi-symbol data
let mut data: HashMap<String, Vec<RangeBar>> = HashMap::new();
data.insert("BTCUSDT".to_string(), btc_bars);
data.insert("ETHUSDT".to_string(), eth_bars);
data.insert("SOLUSDT".to_string(), sol_bars);

// Parallel analysis
let reports = engine.analyze_multiple_symbols(data)?;

for report in reports {
    println!("{}: {} bars, ${:.2} mean",
        report.symbol,
        report.total_bars,
        report.price_statistics.mean
    );
}
```

## Analysis Reports

```rust
pub struct AnalysisReport {
    pub symbol: String,
    pub total_bars: usize,
    pub price_statistics: PriceStats,
    pub volume_statistics: VolumeStats,
    pub time_statistics: TimeStats,
    pub trade_statistics: TradeStats,
}

pub struct PriceStats {
    pub mean: f64,
    pub median: f64,
    pub std_dev: f64,
    pub min: f64,
    pub max: f64,
}

pub struct VolumeStats {
    pub total: f64,
    pub mean: f64,
    pub median: f64,
    pub max: f64,
}
```

## Tier-1 Batch Analysis

Use `rangebar-analyze` binary for comprehensive Tier-1 symbol analysis:

```bash
cargo run --bin rangebar-analyze --release
```

This processes all 18 Tier-1 symbols in parallel with detailed statistics.

## Performance Characteristics

- **Memory Usage**: O(N) for N bars - full dataset in memory
- **Throughput**: High (multi-threaded Rayon parallelism)
- **Parallelism**: Scales linearly with CPU cores (uses N-1 cores)
- **Use Case**: Historical backtesting, research, multi-market analysis

## Batch Configuration

```rust
pub struct BatchConfig {
    pub num_threads: usize,           // Rayon thread pool size
    pub chunk_size: usize,            // Processing chunk size
    pub enable_statistics: bool,      // Compute full statistics
}
```

## Comparison: Batch vs Streaming

| Feature      | Batch                  | Streaming       |
| ------------ | ---------------------- | --------------- |
| Memory Usage | Unbounded              | Bounded         |
| Throughput   | High                   | Moderate        |
| Parallelism  | Multi-threaded (Rayon) | Single-threaded |
| Real-time    | No                     | Yes             |
| Use Case     | Historical analysis    | Live trading    |

## Integration with Polars

`rangebar-batch` integrates with `rangebar-io` for DataFrame operations:

```rust
use rangebar_io::PolarsExporter;

// Export analysis results to Parquet
let exporter = PolarsExporter::new();
exporter.export_parquet(&range_bars, "analysis_output.parquet")?;
```

## Dependencies

- **rangebar-core** - Core algorithm and types
- **rangebar-io** - Polars integration
- **rayon** - Parallel processing
- **serde** - Serialization support

## Version

Current version: **5.0.0** (modular crate architecture)

## Documentation

- Architecture: `../../docs/ARCHITECTURE.md`
- CLI tool: Run `rangebar-analyze` binary

## License

See LICENSE file in the repository root.