kingchenc
8a103ef920
* feat(data-layer): TickAggregator in Node, WASM, Python + C ABI hub First data-layer feature (F2): roll trade ticks up into fixed-timeframe OHLCV candles, exposed natively and over the C ABI. - wickra-data wired as a binding dependency (workspace dep; its wickra-core dep is default-features=false so it never forces rayon into the rayon-free WASM build — native bindings re-enable parallel through their own dependency). - Node `TickAggregator(bucket, gapFill?)` -> `push(price, size, ts): Candle[]`; WASM the same (array of objects); Python `push(...) -> list[tuple]`. - C ABI: `WickraCandle` struct + `wickra_tick_aggregator_new/push/free` (push writes candles into a caller buffer and returns the count), generated via the capi generator's new DATA_LAYER section; cbindgen now parses wickra-data so `TickAggregator` is a forward-declared opaque; header vendored to bindings/go. Verified bit-identical across Node/WASM/Python/C/C++ (o=100 h=101 l=100 c=101 v=3 ts=0 for the shared 3-tick probe). WIP: Go/C#/Java/R generated bindings and the cross-language golden are still pending. * feat(data-layer): TickAggregator in Go, C#, Java, R (lossless push/drain) Complete F2 across all 10 languages: the C-ABI tick aggregator now uses a two-step push/drain so gap-fill candles are never lost, and the four generated bindings expose it idiomatically. - C ABI redesigned: opaque TickAggregator handle (inner aggregator + pending buffer); push consumes a tick and returns the closed-candle count, drain copies them into a count-sized caller buffer. - Go: NewTickAggregator + Push(price,size,ts) []Candle; C#: TickAggregator + Candle[] Push(...); Java: TickAggregator + Candle[] push(...); R: TickAggregator constructor + push() S3 generic returning an (n x 6) numeric matrix. - Candle output record generated per language from WickraCandle. Verified bit-identical to the native bindings (o=100 h=101 l=100 c=101 v=3 ts=0) in Go, C#, Java, and R at runtime; R passes R CMD check (pre-existing doc warnings only). WIP: cross-language data-layer golden + CHANGELOG still pending. * test(data-layer): cross-language golden for the tick aggregator + CHANGELOG gen_golden emits a deterministic tick stream (testdata/golden/data_ticks.csv) and the reference candle streams with and without gap filling (data_candles.csv, data_candles_gap.csv). Every binding replays the shared ticks through its TickAggregator and checks the candles bit-for-bit (fp tolerance) against the Rust reference: - Node / WASM / Python / Go / C# / Java / R: a dedicated parity test each. - C / C++: data_layer_test.c (compiled as both, run as ctest). The gap-fill fixture closes several candles from a single push, exercising the lossless push/drain path. Records the feature under CHANGELOG [Unreleased]. * fix(examples): rename the CSV-loader candle to WickraBar The example CSV helper (wickra_csv.h) defined its own struct WickraCandle, which now collides with the public C ABI WickraCandle (the tick aggregator output) in any example that includes both headers (backtest, multi_timeframe, the strategy examples). The public type owns the name; rename the example loader's bar to WickraBar. The generated golden_test.c is untouched (its only match was the unrelated WickraCandleVolumeOutput).
Wickra — C / C++ examples
The Wickra C ABI is a single shared/static library plus a generated header
(bindings/c/include/wickra.h). Any
C-capable language links against the same artifact; these examples show the
plain-C path.
Build the library
From the workspace root:
cargo build -p wickra-c --release
This produces, in target/release/:
| Platform | Shared library | Link target |
|---|---|---|
| Linux | libwickra.so |
-lwickra |
| macOS | libwickra.dylib |
-lwickra |
| Windows (MSVC) | wickra.dll |
wickra.dll.lib (import lib) |
A static library (libwickra.a / wickra.lib) is emitted alongside.
Build and run the smoke example
With CMake (portable, used by CI)
cmake -S examples/c -B examples/c/build -DWICKRA_LIB_DIR="$PWD/target/release"
cmake --build examples/c/build
ctest --test-dir examples/c/build --output-on-failure
Directly with a compiler
# Linux / macOS
cc examples/c/smoke.c -I bindings/c/include -L target/release -lwickra -lm -o smoke
LD_LIBRARY_PATH=target/release ./smoke # macOS: DYLD_LIBRARY_PATH
# Windows (MinGW gcc, linking the DLL directly)
gcc examples/c/smoke.c -I bindings/c/include target/release/wickra.dll -lm -o smoke.exe
Expected output:
OK: wickra C ABI smoke passed (SMA streaming + batch + reset + NULL-safety + free)
The examples
| Example | What it does |
|---|---|
smoke.c |
Links the boundary and asserts SMA streaming / batch / reset / NULL-safety values. |
streaming.c |
Feeds a synthetic price series through SMA / EMA / RSI / MACD tick by tick. |
backtest.c |
Runs an indicator basket over an OHLCV CSV (defaults to the bundled daily dataset). |
multi_timeframe.c |
Resamples the bundled 1-minute CSV to 5m / 15m / 1h / 4h / 1d and prints indicators per timeframe. |
parallel_assets.c |
Serial vs OpenMP fan-out over a synthetic panel (one handle per asset), with speedup. |
strategy_rsi_mean_reversion.c |
Hourly RSI(14) mean-reversion with a PnL / Sharpe / max-drawdown summary. |
strategy_macd_adx.c |
Hourly MACD crossover gated by ADX(14) > 20. |
strategy_bollinger_squeeze.c |
Daily Bollinger-squeeze breakout with an ATR(14) stop. |
fetch_btcusdt.c |
Downloads BTCUSDT klines from the Binance REST API into examples/data/ (shells out to curl). |
live_binance.c |
Polls the Binance REST klines endpoint via curl and streams closed candles through RSI(14). |
smoke.cpp |
C++ RAII via wickra::Handle from wickra.hpp. |
ctest builds and runs every example except fetch_btcusdt and live_binance,
which reach the network and are built only — run those two by hand. The C ABI
exposes only the indicators, not the wickra-data IO layer, so the examples read
CSV (wickra_csv.h) and resample themselves; the network ones
shell out to the system curl rather than adding an HTTP/TLS dependency.
Usage shape
Every indicator follows the same five-function pattern over an opaque handle:
#include "wickra.h"
struct Sma *sma = wickra_sma_new(14); /* NULL on invalid params */
double v = wickra_sma_update(sma, 42.0); /* NaN during warmup */
wickra_sma_reset(sma); /* back to fresh state */
wickra_sma_free(sma); /* exactly once per _new */
There is no RAII across the C boundary: every wickra_<ind>_new must be paired
with exactly one wickra_<ind>_free. All functions are NULL-safe (a NULL handle
yields NaN / a no-op, never a crash).