mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-07-28 09:47:43 +00:00
Miha Kralj
130 lines
2.9 KiB
Markdown
130 lines
2.9 KiB
Markdown
# Usage Guides
|
|
|
|
QuanTAlib supports four distinct operating modes to handle different architectural requirements.
|
|
|
|
## 1. Span Mode (High Performance)
|
|
|
|
**Best for:** Backtesting, batch processing, research.
|
|
|
|
Operates directly on `Span<double>` or arrays. Zero allocations, maximum speed.
|
|
|
|
```csharp
|
|
using QuanTAlib;
|
|
|
|
// 1. Prepare data
|
|
double[] prices = GetPrices(); // Your data source
|
|
double[] results = new double[prices.Length];
|
|
|
|
// 2. Calculate
|
|
// Sma.Calculate(source, destination, period)
|
|
Sma.Calculate(prices, results, 14);
|
|
|
|
// 3. Use results
|
|
Console.WriteLine($"Last SMA: {results[^1]}");
|
|
```
|
|
|
|
## 2. Streaming Mode (Real-Time)
|
|
|
|
**Best for:** Live trading, tick-by-tick analysis.
|
|
|
|
Updates one value at a time. Maintains internal state.
|
|
|
|
```csharp
|
|
using QuanTAlib;
|
|
|
|
// 1. Initialize
|
|
var sma = new Sma(period: 14);
|
|
|
|
// 2. Update loop (e.g., connected to a feed)
|
|
void OnData(double price)
|
|
{
|
|
// Update returns a TValue struct { Time, Value, IsHot }
|
|
TValue result = sma.Update(new TValue(DateTime.UtcNow, price));
|
|
|
|
if (result.IsHot)
|
|
{
|
|
Console.WriteLine($"SMA: {result.Value}");
|
|
}
|
|
}
|
|
|
|
// 3. Handle bar updates (correction)
|
|
// If your feed sends updates for the *same* bar multiple times:
|
|
sma.Update(new TValue(time, openPrice), isNew: true); // New bar opens
|
|
sma.Update(new TValue(time, currentPrice), isNew: false); // Price changes within bar
|
|
```
|
|
|
|
## 3. Batch Mode (TSeries)
|
|
|
|
**Best for:** Exploratory analysis, notebooks.
|
|
|
|
Wraps calculations in `TSeries` objects that handle timestamps and alignment.
|
|
|
|
```csharp
|
|
using QuanTAlib;
|
|
|
|
// 1. Create series
|
|
TSeries prices = new TSeries();
|
|
prices.Add(DateTime.Now, 100.0);
|
|
prices.Add(DateTime.Now.AddMinutes(1), 101.0);
|
|
// ... add more data ...
|
|
|
|
// 2. Calculate
|
|
// Returns a new TSeries aligned with input
|
|
TSeries smaSeries = new Sma(prices, period: 14);
|
|
|
|
// 3. Access
|
|
Console.WriteLine($"Last Value: {smaSeries.Last.Value}");
|
|
Console.WriteLine($"Value at index 5: {smaSeries[5].Value}");
|
|
```
|
|
|
|
## 4. Event-Driven Architecture
|
|
|
|
**Best for:** Complex reactive systems.
|
|
|
|
Indicators can subscribe to other indicators or data sources.
|
|
|
|
```csharp
|
|
using QuanTAlib;
|
|
|
|
// 1. Setup chain
|
|
var source = new TSeries();
|
|
var smaFast = new Sma(source, 10);
|
|
var smaSlow = new Sma(source, 20);
|
|
|
|
// 2. Subscribe to events
|
|
smaFast.Pub += (sender, args) => {
|
|
Console.WriteLine($"Fast SMA updated: {args.Tick.Value}");
|
|
};
|
|
|
|
// 3. Feed data
|
|
// This triggers the chain: source -> smaFast -> event handler
|
|
source.Add(DateTime.UtcNow, 105.0);
|
|
```
|
|
|
|
## Common Patterns
|
|
|
|
### Handling Warmup
|
|
|
|
Always check `IsHot` or `Count` before using values.
|
|
|
|
```csharp
|
|
var rsi = new Rsi(14);
|
|
// ... feed data ...
|
|
if (rsi.IsHot) {
|
|
// Safe to use rsi.Value
|
|
}
|
|
```
|
|
|
|
### Combining Indicators
|
|
|
|
You can feed the output of one indicator into another.
|
|
|
|
```csharp
|
|
var ema = new Ema(period: 12);
|
|
var rsiOfEma = new Rsi(period: 14);
|
|
|
|
void OnData(double price) {
|
|
var emaResult = ema.Update(new TValue(DateTime.UtcNow, price));
|
|
var finalResult = rsiOfEma.Update(emaResult);
|
|
}
|