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).
91 lines
2.5 KiB
C
91 lines
2.5 KiB
C
/* Shared OHLCV CSV loader for the Wickra C examples.
|
|
*
|
|
* The C ABI exposes only the indicators, not the wickra-data IO layer, so the
|
|
* examples read CSV themselves. This header-only helper is the C counterpart of
|
|
* `wickra_data::csv::CandleReader` used by the Rust examples: it parses the
|
|
* standard `timestamp,open,high,low,close,volume` files shipped under
|
|
* `examples/data/`.
|
|
*
|
|
* Header-only: define WICKRA_CSV_IMPL in exactly one translation unit (each
|
|
* example is a single .c file, so it just defines it before including this).
|
|
*/
|
|
#ifndef WICKRA_CSV_H
|
|
#define WICKRA_CSV_H
|
|
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
|
|
typedef struct WickraBar {
|
|
int64_t timestamp;
|
|
double open;
|
|
double high;
|
|
double low;
|
|
double close;
|
|
double volume;
|
|
} WickraBar;
|
|
|
|
/* Load an OHLCV CSV into a malloc'd array. Returns the candle count and stores
|
|
* the array in *out (caller frees with free()). Returns 0 and leaves *out NULL
|
|
* on any error (missing file, no parseable rows). A leading header line whose
|
|
* first field is non-numeric is skipped. */
|
|
size_t wickra_load_csv(const char *path, WickraBar **out);
|
|
|
|
#ifdef WICKRA_CSV_IMPL
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
size_t wickra_load_csv(const char *path, WickraBar **out) {
|
|
*out = NULL;
|
|
FILE *f = fopen(path, "r");
|
|
if (f == NULL) {
|
|
fprintf(stderr, "wickra_load_csv: cannot open %s\n", path);
|
|
return 0;
|
|
}
|
|
|
|
size_t cap = 1024;
|
|
size_t n = 0;
|
|
WickraBar *rows = (WickraBar *)malloc(cap * sizeof(*rows));
|
|
if (rows == NULL) {
|
|
fclose(f);
|
|
return 0;
|
|
}
|
|
|
|
char line[512];
|
|
while (fgets(line, (int)sizeof(line), f) != NULL) {
|
|
WickraBar c;
|
|
long long ts = 0;
|
|
/* sscanf returns the number of fields successfully matched. A header
|
|
* row ("timestamp,...") matches 0 and is skipped. */
|
|
int matched = sscanf(line, "%lld,%lf,%lf,%lf,%lf,%lf", &ts, &c.open,
|
|
&c.high, &c.low, &c.close, &c.volume);
|
|
if (matched != 6) {
|
|
continue;
|
|
}
|
|
c.timestamp = (int64_t)ts;
|
|
|
|
if (n == cap) {
|
|
cap *= 2;
|
|
WickraBar *grown = (WickraBar *)realloc(rows, cap * sizeof(*rows));
|
|
if (grown == NULL) {
|
|
free(rows);
|
|
fclose(f);
|
|
return 0;
|
|
}
|
|
rows = grown;
|
|
}
|
|
rows[n++] = c;
|
|
}
|
|
fclose(f);
|
|
|
|
if (n == 0) {
|
|
free(rows);
|
|
return 0;
|
|
}
|
|
*out = rows;
|
|
return n;
|
|
}
|
|
|
|
#endif /* WICKRA_CSV_IMPL */
|
|
#endif /* WICKRA_CSV_H */
|