rangebar 0.4.1

High-performance non-lookahead bias range bar construction for Binance UM Futures. Processes 137M+ trades/sec with comprehensive Tier-1 cryptocurrency analysis. Non-lookahead algorithm guarantees temporal integrity for financial backtesting.
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

# rangebar

[![Crates.io](https://img.shields.io/crates/v/rangebar)](https://crates.io/crates/rangebar)
[![Downloads](https://img.shields.io/crates/d/rangebar)](https://crates.io/crates/rangebar)
[![Documentation](https://docs.rs/rangebar/badge.svg)](https://docs.rs/rangebar)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Rust](https://img.shields.io/badge/rust-2024-orange.svg)](https://www.rust-lang.org)
[![CI](https://github.com/Eon-Labs/rangebar/workflows/CI/badge.svg)](https://github.com/Eon-Labs/rangebar/actions)

High-performance non-lookahead bias range bar construction for Binance UM Futures data.

> [!NOTE]
> This crate processes **137M+ trades/second** using fixed-point arithmetic for financial-grade precision.

> [!WARNING]
> Range bars use **non-lookahead bias** - thresholds are computed only from bar opening prices, never from evolving high/low ranges.

## Quick Start

Add this to your `Cargo.toml`:

```toml
[dependencies]
rangebar = "0.4.1"
```

## Basic Usage

```rust
use rangebar::{RangeBarProcessor, AggTrade, FixedPoint};

// Create processor with 0.8% threshold (8000 basis points)
let mut processor = RangeBarProcessor::new(8000);

// Create sample trade data
let trade = AggTrade {
    agg_trade_id: 123456789,
    price: FixedPoint::from_str("50000.12345").unwrap(),
    volume: FixedPoint::from_str("1.50000000").unwrap(),
    first_trade_id: 100,
    last_trade_id: 105,
    timestamp: 1609459200000,
    is_buyer_maker: false,
};

// Process trades into range bars
let trades = vec![trade];
let bars = processor.process_trades(&trades).unwrap();

for bar in bars {
    println!("Bar: O={} H={} L={} C={} V={}",
             bar.open, bar.high, bar.low, bar.close, bar.volume);
}
```

## Algorithm

Range bars close when price moves ±threshold% from the bar's **opening price**:

1. **Non-lookahead bias**: Thresholds computed only from bar open price
2. **Breach inclusion**: Breaching trade included in closing bar
3. **Fixed thresholds**: Never recalculated during bar lifetime

## Features

- **`statistics`** (default): Comprehensive statistical analysis via Polars
- **`data-integrity`** (default): Data validation and checksums
- **`arrow-support`**: Apache Arrow and Parquet export
- **`python-bindings`**: PyO3 Python bindings (optional)

## Performance

- **137M+ trades/second** processing (2025 benchmarks)
- **Fixed-point arithmetic** (no floating-point errors)
- **Memory efficient** streaming processing
- **Zero-copy** design where possible

## Data Source

Designed for [Binance UM Futures](https://binance-docs.github.io/apidocs/futures/en/) aggTrades data:

```rust
// Sample aggTrade format
{
    "a": 123456789,     // Aggregate trade ID
    "p": "50000.12345", // Price
    "q": "1.50000000",  // Quantity
    "f": 100,           // First trade ID
    "l": 105,           // Last trade ID
    "T": 1609459200000, // Timestamp
    "m": false          // Is buyer maker
}
```

## License

MIT license. See [LICENSE](LICENSE) for details.