gavindiaz/wickra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3a6b5ebae3bb79ced2e2037c15e635f0a2cf34e6
wickra/docs/wiki/TA-Lib-Migration.md
T

94 lines
8.4 KiB
Markdown
Raw Normal View History

docs(wiki): add Cookbook, TA-Lib migration table and FAQ
2026-05-23 00:23:00 +02:00
# Migrating from TA-Lib
A quick lookup table for users porting code from TA-Lib (the C library, or
its Python binding `talib`) to Wickra. Replace `talib.X(...)` with the
matching Wickra expression and the rest of your code keeps working.
## Argument-order conventions
The two libraries take the same numeric arguments but differ in shape:
- **TA-Lib (Python)** is functional and pass-by-array. `talib.RSI(close, n)`
is a *recompute-everything* call: it walks the entire `close` series each
time, even when you only want the latest value.
- **Wickra** is a state machine. `wickra.RSI(n)` returns an *instance*; you
call `.batch(close)` for the full series or `.update(price)` one price at
a time. The same instance, fed one price per minute, drives a live
trading bot — see [Streaming vs Batch](Streaming-vs-Batch.md).
Multi-output indicators (MACD, Bollinger Bands, Stochastic, ADX, Aroon,
Keltner, Donchian, SuperTrend, …) return a tuple from `update` and a 2-D
NumPy array (one column per output) from `batch`.
## Mapping table
| TA-Lib | Wickra (Python) |
|-----------------------------------------------------|--------------------------------------------------------------------------------------------------|
| `talib.SMA(close, n)` | `wickra.SMA(n).batch(close)` |
| `talib.EMA(close, n)` | `wickra.EMA(n).batch(close)` |
| `talib.WMA(close, n)` | `wickra.WMA(n).batch(close)` |
| `talib.DEMA(close, n)` | `wickra.DEMA(n).batch(close)` |
| `talib.TEMA(close, n)` | `wickra.TEMA(n).batch(close)` |
| `talib.KAMA(close, n)` | `wickra.KAMA(n).batch(close)` |
| `talib.T3(close, n, vfactor)` | `wickra.T3(n, vfactor).batch(close)` |
| `talib.RSI(close, n)` | `wickra.RSI(n).batch(close)` |
| `talib.STOCH(high, low, close, k, smooth, d)` | `wickra.Stochastic(k_period, d_period).batch(high, low, close)` → shape `(n, 2)` |
| `talib.STOCHRSI(close, n, k, d)` | `wickra.StochRSI(rsi_period, stoch_period).batch(close)` |
| `talib.CCI(high, low, close, n)` | `wickra.CCI(n).batch(high, low, close)` |
| `talib.WILLR(high, low, close, n)` | `wickra.WilliamsR(n).batch(high, low, close)` |
| `talib.MFI(high, low, close, volume, n)` | `wickra.MFI(n).batch(high, low, close, volume)` |
| `talib.ROC(close, n)` | `wickra.ROC(n).batch(close)` |
| `talib.MOM(close, n)` | `wickra.MOM(n).batch(close)` |
| `talib.CMO(close, n)` | `wickra.CMO(n).batch(close)` |
| `talib.MACD(close, fast, slow, signal)` | `wickra.MACD(fast, slow, signal).batch(close)` → shape `(n, 3)` |
| `talib.PPO(close, fast, slow)` | `wickra.PPO(fast, slow).batch(close)` |
| `talib.APO(close, fast, slow)` | `wickra.PPO(fast, slow).batch(close)` *(PPO is APO scaled to percent)* |
| `talib.TRIX(close, n)` | `wickra.TRIX(n).batch(close)` |
| `talib.ADX(high, low, close, n)` | `wickra.ADX(n).batch(high, low, close)` → shape `(n, 3)` (`+DI`, `−DI`, `ADX`) |
| `talib.AROON(high, low, n)` | `wickra.Aroon(n).batch(high, low, close)` → shape `(n, 2)` |
| `talib.AROONOSC(high, low, n)` | `wickra.AroonOscillator(n).batch(high, low, close)` |
| `talib.BBANDS(close, n, dev_up, dev_dn)` | `wickra.BollingerBands(n, multiplier).batch(close)` → shape `(n, 4)` (`upper`, `middle`, `lower`, `stddev`) |
| `talib.ATR(high, low, close, n)` | `wickra.ATR(n).batch(high, low, close)` |
| `talib.NATR(high, low, close, n)` | `wickra.NATR(n).batch(high, low, close)` |
| `talib.STDDEV(close, n)` | `wickra.StdDev(n).batch(close)` |
| `talib.TRANGE(high, low, close)` | `wickra.TrueRange().batch(high, low, close)` |
| `talib.OBV(close, volume)` | `wickra.OBV().batch(close, volume)` |
| `talib.AD(high, low, close, volume)` | `wickra.ADL().batch(high, low, close, volume)` |
| `talib.ADOSC(high, low, close, volume, fast, slow)` | `wickra.ChaikinOscillator(fast, slow).batch(high, low, close, volume)` |
| `talib.SAR(high, low, accel, max)` | `wickra.PSAR(accel_start, accel_step, accel_max).batch(high, low, close)` |
| `talib.LINEARREG(close, n)` | `wickra.LinearRegression(n).batch(close)` |
| `talib.LINEARREG_SLOPE(close, n)` | `wickra.LinRegSlope(n).batch(close)` |
| `talib.LINEARREG_ANGLE(close, n)` | `wickra.LinRegAngle(n).batch(close)` |
| `talib.TYPPRICE(high, low, close)` | `wickra.TypicalPrice().batch(high, low, close)` |
| `talib.MEDPRICE(high, low)` | `wickra.MedianPrice().batch(high, low, close)` |
| `talib.WCLPRICE(high, low, close)` | `wickra.WeightedClose().batch(high, low, close)` |
| `talib.ULTOSC(high, low, close, p1, p2, p3)` | `wickra.UltimateOscillator(p1, p2, p3).batch(high, low, close)` |
## What Wickra has that TA-Lib does not
- **Trailing stops** — `SuperTrend`, `ChandelierExit`, `ChandeKrollStop`,
`AtrTrailingStop` (TA-Lib only has `SAR`).
- **Volume oscillators** — `ChaikinMoneyFlow`, `ForceIndex`,
`EaseOfMovement`, `VolumePriceTrend`, plus the windowed `RollingVwap`.
- **Other modern indicators** — `Choppiness Index`, `Vertical Horizontal
Filter`, `Coppock`, `PMO`, `Z-Score`, `Mass Index`, `Vortex`, `TSI`,
`Smma`, `Trima`, `Zlema`, `Vwma`, `BollingerBandwidth`, `%B`.
## What TA-Lib has that Wickra does not (yet)
- Pattern recognition (`CDL*` candlestick patterns).
- Hilbert-transform-based indicators (`HT_DCPERIOD`, `HT_TRENDLINE`, …).
- A few trivial transforms (`AVGPRICE`, `MIDPOINT`, `MIDPRICE`).
If you need one of these,
[open an issue](https://github.com/kingchenc/wickra/issues) — most are
short additions on top of the existing engine.
## See also
- [Indicators Overview](Indicators-Overview.md) — every Wickra indicator,
organised by family.
- [Quickstart: Python](Quickstart-Python.md) — concrete Python usage.
- [Streaming vs Batch](Streaming-vs-Batch.md) — why Wickra is fast at
per-tick updates while TA-Lib re-computes the whole series.
Reference in New Issue Copy Permalink