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).
60 lines
2.0 KiB
C#
60 lines
2.0 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using Wickra;
|
|
using Xunit;
|
|
|
|
// Cross-language data-layer parity: replay the shared golden tick stream through
|
|
// the TickAggregator and check the candles against the Rust reference, with and
|
|
// without gap filling.
|
|
public class DataLayerTests
|
|
{
|
|
private static string GoldenDir([System.Runtime.CompilerServices.CallerFilePath] string file = "") =>
|
|
Path.GetFullPath(Path.Combine(Path.GetDirectoryName(file)!, "..", "..", "..", "testdata", "golden"));
|
|
|
|
private static double[][] Read(string name)
|
|
{
|
|
var lines = File.ReadAllLines(Path.Combine(GoldenDir(), name + ".csv"));
|
|
var rows = new List<double[]>();
|
|
for (var i = 1; i < lines.Length; i++)
|
|
{
|
|
if (lines[i].Length == 0)
|
|
{
|
|
continue;
|
|
}
|
|
rows.Add(Array.ConvertAll(lines[i].Split(','), s => double.Parse(s, CultureInfo.InvariantCulture)));
|
|
}
|
|
return rows.ToArray();
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(false, "data_candles")]
|
|
[InlineData(true, "data_candles_gap")]
|
|
public void TickAggregatorMatchesGolden(bool gapFill, string fixture)
|
|
{
|
|
var ticks = Read("data_ticks");
|
|
using var agg = new TickAggregator(1000, gapFill);
|
|
var got = new List<double[]>();
|
|
foreach (var t in ticks)
|
|
{
|
|
foreach (var c in agg.Push(t[0], t[1], (long)t[2]))
|
|
{
|
|
got.Add(new[] { c.Open, c.High, c.Low, c.Close, c.Volume, (double)c.Timestamp });
|
|
}
|
|
}
|
|
var want = Read(fixture);
|
|
Assert.Equal(want.Length, got.Count);
|
|
for (var i = 0; i < got.Count; i++)
|
|
{
|
|
for (var j = 0; j < 6; j++)
|
|
{
|
|
var tol = 1e-9 * Math.Max(1, Math.Abs(want[i][j]));
|
|
Assert.True(
|
|
Math.Abs(got[i][j] - want[i][j]) <= tol,
|
|
$"{fixture} row {i} col {j}: {got[i][j]} vs {want[i][j]}");
|
|
}
|
|
}
|
|
}
|
|
}
|