Skip to content

Commit 14b05c9

Browse files
luisleo526claude
andauthored
Pine adapter: TradingView's exit-child order at one point and the callback lifecycle (trail tolerance, revived exits, tick-built limit reach) (#328)
* Pine adapter: same-point global exit children in TradingView's entry-id order, and the newborn stop When one path point triggers the children of a strategy.exit that names no entry, TradingView fills them one at a time in the order of its entry-id table (a java.util.HashMap over the entry ids: String.hashCode spread over 16 buckets, 32 once the keys pass 13, the newest key first in a bucket; keys are entry ids from their first fill plus one per waiting close order). Each child is a transaction of its entry's quantity, settled against its own entry under close_entries_rule ANY and against the oldest lots first otherwise, one row per settled slice with its share of the ten-significant-digit fees. The kernel fills such a leg once for the whole position. The host now re-cuts that one fill's rows, while they are still the last rows and not final, into the children's rows. Every shape the TradingView tapes do not reach keeps the kernel's rows: a fill that is not the tail or leaves part of the position open, a trailing leg, fewer than two ids, calc_on_order_fills, process_orders_on_close or an intrabar feed, a non-unit account rate, a cash-per-order or negative fee, a live leg of any other exit the price also reaches, a table past 32 buckets or with a tie in a grown table, a waiting strategy.order market order that would size the table differently, and a lot quantity off ten significant digits. A re-cut that adds rows re-counts strategy.wintrades / losstrades / eventrades and the gross sums; each kernel member it writes has an ADR-0001 row. A named stop whose limit entry fills at a point where the stop is already through now fills at once at the entry's fill with the stop's slippage, not at the level the bar crossed before the entry (no calc_on_order_fills, no intrabar feed). The entry-id table is hashed adapter state once it holds two ids or its peak passes 13 keys, and is cleared per run. Nine source-layer witnesses are re-pinned: seven hash-only, and two fuzz runs each move one trade by the newborn-stop rule (quiet-bar Random28 with the magnifier off, publication Config16). tests/test_global_exit_children_tapes.cpp replays all 127 TradingView tapes of the synthetic scripts: 93 asserted row for row, 34 recorded known divergences with the rule each needs and the first departure, and six unreached shapes pinned at the previous engine's own rows. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]> * Pine adapter: mintick trail tolerance, a killed exit revived on re-issue, and tick-built callback limit reach Three TradingView rules, taped on synthetic scripts (4 identical exports each), each behind its own switch in src/source/pine_n6_rules.hpp (`PineN6Rule`, `set_pine_n6_rule` / `pine_n6_rule`, atomic flags, all on; no public API, C ABI or strategy input, and no new durable state): - trail_points become ceil(trail_points - 8e-3 * mintick) ticks: the tolerance scales with mintick (ETH 0.01, XAUUSD 0.001, EURUSD 1e-5) instead of the constant 5e-5 ticks, which stays as the no-mintick fallback. Applied at every trail conversion site. - A declined reversal kills the held position's stop and limit exits; a later re-issue is a new live order. The replacement path already started fresh legs for a changed re-issue; the unchanged-reissue shortcuts kept the killed row. The revive applies to every side, sizing and stop or limit exit, and only to the kill: a row held behind the entry/close pair barrier keeps it. An exit issued once stays dead, as the declined-reversal trail-leg tests pin. calc_on_order_fills keeps its own decline path. - A limit exit born in a mid-leg calc_on_order_fills recalculation reaches its leg's end only on that waypoint's tick-built print; the level stays raw. tests/fixtures/n6_callback_lifecycle commits all 82 tapes with their generated strategies, plus five TradingView controls predicted before export (the short mirror, a partial stop, fixed and cash sizing, and the entry/close pair hold). test_n6_callback_lifecycle_tapes builds them into one module, replays them row for row (66 equal, 21 known divergences with their reason and first departure in known_divergences.json), clears each switch in turn and requires exactly the departures rule_off_departures.json records, and reads the pair-hold control's book to require that the stop re-issued in the pair's calculation stays behind the barrier. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]> * Neutral names for the callback-lifecycle rule switches and tapes A pure rename and comment rewording; no behaviour changes. - The rule switches become PineCallbackLifecycleRule, kPineCallbackLifecycleRuleCount, set_pine_callback_lifecycle_rule and pine_callback_lifecycle_rule, with their storage callback_lifecycle_rules. Their header moves to the private src/compat/pine/callback_lifecycle_rules.hpp, so the compat unit that reads one no longer includes a src/source header; the adapter includes it from there. - The tape module, its generated include, entry-point prefixes, exported test hooks, CMake variables, the ctest row and the fixture directory become callback_lifecycle_tapes, callback_lifecycle_<tape>__, callback_lifecycle_tapes_set_rule / _rule_count, _pf_clt_*, test_callback_lifecycle_tapes and tests/fixtures/callback_lifecycle. - Comments, fixture READMEs, generated fixture headers and the free-text provenance fields name the TradingView tapes instead of internal campaign labels. Every edited line keeps its place, so no documentation anchor moves. The bytes TradingView ran (each tape's strategy.pine, its exports and the metrics that pin their hashes) are unchanged. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]> --------- Co-authored-by: Claude Opus 5.5 (1M context) <[email protected]>
1 parent 54b3996 commit 14b05c9

1,073 files changed

Lines changed: 94207 additions & 661 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎docs/adr/0001-kernel-adapter-boundary.md‎

Lines changed: 44 additions & 43 deletions
Large diffs are not rendered by default.

‎docs/design/native-feature-parity.md‎

Lines changed: 107 additions & 107 deletions
Large diffs are not rendered by default.

‎docs/native-refactor-progress.md‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -173,7 +173,7 @@ them for the record only. "Linux aarch64" is the maintainers' Cortex-A725 host.
173173

174174
| Item | What it is | Measured size | Deferred by | Prototype and evidence | Reopens when |
175175
| --- | --- | --- | --- | --- | --- |
176-
| D2-B, the quiet-bar protocol and one receipt read per bar | PERF-D2's lane: a per-bar bar-open request, a bulk fold of quiet driver points, the adapter's quiet-open predicate with lazy open bookkeeping, and a gate before the receipt poll. D2-A landed the hook declarations and the O(1) `has_command_after` (`src/native_execution_consumer.hpp:269`). PERF-L4 gated the read inside `observe_terminal_receipts` (`src/source/pine_adapter.cpp:5629`), which still runs about three times a bar | PERF-D2, Linux aarch64 (Cortex-A725), callgrind and GBench: about ×0.88 on the 14 probes (an estimate from a measured −13 to −14 % floor bound for the bar-open request alone); after PB the receipt poll still costs about 250 instructions a bar on the no-order floor. On this tree the quiet-bar probe asks the receipt gate 40,996 times and each once-per-bar-open gate 13,248 times: 3.09 reads a bar, 82 % of them stopped at the gate (macOS arm64, AppleClang 17, Release) | "R5 PERF-D2 DONE 2026-09-24 19:56" (D2-B after V19-D); "R5 SUPERVISOR RULING 2026-09-25 00:15 Taipei": "D2-B (quiet-bar protocol) waits for PERF-D3's verdict"; TRIAGE1 §D | An unpublished prototype branch and its patches. PERF-D3's S1 (next row) prototyped the request and the lazy opening | A post-release performance epoch. Done when the receipt gate is asked as often as the once-per-bar gates |
176+
| D2-B, the quiet-bar protocol and one receipt read per bar | PERF-D2's lane: a per-bar bar-open request, a bulk fold of quiet driver points, the adapter's quiet-open predicate with lazy open bookkeeping, and a gate before the receipt poll. D2-A landed the hook declarations and the O(1) `has_command_after` (`src/native_execution_consumer.hpp:269`). PERF-L4 gated the read inside `observe_terminal_receipts` (`src/source/pine_adapter.cpp:5863`), which still runs about three times a bar | PERF-D2, Linux aarch64 (Cortex-A725), callgrind and GBench: about ×0.88 on the 14 probes (an estimate from a measured −13 to −14 % floor bound for the bar-open request alone); after PB the receipt poll still costs about 250 instructions a bar on the no-order floor. On this tree the quiet-bar probe asks the receipt gate 40,996 times and each once-per-bar-open gate 13,248 times: 3.09 reads a bar, 82 % of them stopped at the gate (macOS arm64, AppleClang 17, Release) | "R5 PERF-D2 DONE 2026-09-24 19:56" (D2-B after V19-D); "R5 SUPERVISOR RULING 2026-09-25 00:15 Taipei": "D2-B (quiet-bar protocol) waits for PERF-D3's verdict"; TRIAGE1 §D | An unpublished prototype branch and its patches. PERF-D3's S1 (next row) prototyped the request and the lazy opening | A post-release performance epoch. Done when the receipt gate is asked as often as the once-per-bar gates |
177177
| S1a, kernel quiet-bar driving (PERF-D3) | A bar with nothing live, a flat book and a declined opening is driven in a quiet form: the kernel writes the bookkeeping its four price points would leave (ordinals, the last two driver marks, the floor, the point epochs) without walking them or calling the bar-open callback. Additive host cadence declarations; C hosts declare from their callback table; one C symbol under the PF_API checklist | PERF-D3, Linux aarch64 (Cortex-A725), GBench time and `perf stat` instructions, on the L3 tree `b33ea659`, S1a with S1b: no-order floor 0.764 / 0.660 in time (0.718 / 0.656 in instructions), 14 probes 0.958 / 0.921 (0.892 / 0.856), 100 slots 0.972 / 0.956 per slot. A bare kernel host that opts in: idle 0.545× (35 % fewer instructions a bar), market 0.81×, bracket 0.92×. Byte-identical: corpus 312/312, the 132-configuration battery with its hash columns | "FINDING PERF-D3 (filed for a post-release epoch per the owner's cap)" (ledger, 2026-09-24 16:58 UTC); "OWNER DECISION 2026-09-25 00:20 Taipei"; TRIAGE1 §D: "PERF-D3 S1/S2 (post-release epoch)" | An unpublished prototype branch (five commits on L3's tree) and its patches | The post-release epoch, with the owner calls PERF-D3 lists (the API under the existing ruling, the restated gate count) |
178178
| S1b, the Pine lazy opening | The Pine host records what its skipped opening and its uncalled input callback would have written, at the bar's first host callback. Member functions only, no layout change | Measured with S1a. A quiet bar then asks 15 gates, not 30, so the quiet-bar cost check `CHECK(asked >= 20 * o.boundary.size())` (`tests/test_adapter_quiet_bar.cpp:1054`) must be restated | As S1a | As S1a. The in-script hash witnesses caught the prototype's one miss (`awaiting_legacy_script_open_ms_`) | As S1a |
179179
| S1c, the held-position wake band | S1 for bars that hold a position with nothing live, 41 % of the median public slot's bars. The host declares a price band, and the kernel calls the opening only when the bar's range leaves it. The adapter derives the band from its margin model and declines when it cannot bound it | PERF-D3, a measurement-only upper bound without the band, which is not sound in general: 100 slots 0.776 / 0.716 per slot, 14 probes 0.830 / 0.761, cumulative against L3 with S1, S2 and D2-A | As S1a; the owner call "Fund the price band" | An unpublished measurement-only script | As S1a. Size L, parity risk high: TradingView's margin money rules |
@@ -183,7 +183,7 @@ them for the record only. "Linux aarch64" is the maintainers' Cortex-A725 host.
183183
| Compact journal records and a history ring buffer (L3) | Smaller command records and a ring buffer for the request core's history. `WorkingRequestCore::history` (`include/pineforge/native_order.hpp:1709`) hands out the whole vector and the core holds `history_` (`include/pineforge/native_order.hpp:2197`) inside `native_order_v7`, so both are a layout and API change | L3, Linux aarch64 (Cortex-A725), `perf` call graphs, inclusive shares: at most 3.68 % of bracket, 11.99 % of re-issue, 4.26 % of market and 3.42 % of the 14 probes (retiring the history alone: 1.64, 4.51, 2.53 and 1.00 %); only part is realisable, since records must still be written | "R5 L3 DONE + ACCEPTED 2026-09-24 22:10 Taipei", ruling 1: "DEFERRED to the PERF-D3 structural plan"; TRIAGE1 §D: "compact journal records" | Lane L3's code, merged by INT22 (#285); its profiles are unpublished | A `native_order` layout epoch |
184184
| A checked-values handoff for executions (L3) | `execution_values` runs twice, in `check_execution` (`src/native_order.cpp:4791`) and again in `apply_execution` (`src/native_order.cpp:4805`); handing the checked values across needs a public type, an API addition with no layout change | L3, as above: 2.21 % of bracket for the two together, about 1.1 % recoverable | L3 ruling 2: "a public checked-values handoff for executions (~1.1% bracket) -> DEFERRED" | As above | An owner decision on the API addition |
185185
| A chunked `trades_` store (L3) | Closed trades in chunks rather than one vector; `trades_` (`include/pineforge/engine.hpp:546`) is protected `BacktestEngine` state, so script ABI | L3, as above: on bracket, vector growth 0.64 %, `Trade` moves 0.74 % and `record_close_trade` 0.43 % (at most about 1.4 %); at most 0.35 % on the 14 probes | L3 ruling 4: "chunked trades_ store (ABI) -> DEFERRED" | As above | An `engine_script_run` epoch that changes the engine's protected layout |
186-
| A zoned chart-day memo (D2-D finding 4) | On a chart with a timezone, `libc_chart_day_key` (`src/source/pine_adapter.cpp:15383`) takes the process timezone lock through `ScopedTimezone` and calls `localtime_r` on every bar, because `on_bar_open` (`src/source/pine_adapter.cpp:18692`) reads `chart_day_key` (`src/source/pine_adapter.cpp:18913`) unconditionally. The non-UTC monthly Sharpe/Sortino walk, `month_key_local` (`src/engine_metrics.cpp:33`), pays one `localtime_r` per equity point. UTC charts use D2-D's memo, `civil_chart_day_key` (`src/source/pine_adapter.cpp:15367`) | Not measured on a zoned chart. The UTC path cost 134 instructions a bar before D2-D's memo and 68 after (D2-D, Linux aarch64, callgrind on the floor). PERF-K1: `ScopedTimezone` copies the zone name, which allocates for names of 16 or more characters under libstdc++ | TRIAGE1 §D: "D2-D finding 4 (the timezone `localtime_r` memo)", under the owner's cap. D2-D's report: an exact zoned memo "would need the zone's transition table, which belongs in `timezone.cpp`" | None; the UTC memo's witness is `tests/test_chart_day_memo.cpp` | A lane that owns `src/timezone.cpp` and builds an exact zone-transition memo (PERF-K1's Sitka case shows why a shortcut is not exact), byte-identical, with the zoned keys of `test_chart_day_memo` still equal to the computed ones |
186+
| A zoned chart-day memo (D2-D finding 4) | On a chart with a timezone, `libc_chart_day_key` (`src/source/pine_adapter.cpp:15685`) takes the process timezone lock through `ScopedTimezone` and calls `localtime_r` on every bar, because `on_bar_open` (`src/source/pine_adapter.cpp:18994`) reads `chart_day_key` (`src/source/pine_adapter.cpp:19215`) unconditionally. The non-UTC monthly Sharpe/Sortino walk, `month_key_local` (`src/engine_metrics.cpp:33`), pays one `localtime_r` per equity point. UTC charts use D2-D's memo, `civil_chart_day_key` (`src/source/pine_adapter.cpp:15669`) | Not measured on a zoned chart. The UTC path cost 134 instructions a bar before D2-D's memo and 68 after (D2-D, Linux aarch64, callgrind on the floor). PERF-K1: `ScopedTimezone` copies the zone name, which allocates for names of 16 or more characters under libstdc++ | TRIAGE1 §D: "D2-D finding 4 (the timezone `localtime_r` memo)", under the owner's cap. D2-D's report: an exact zoned memo "would need the zone's transition table, which belongs in `timezone.cpp`" | None; the UTC memo's witness is `tests/test_chart_day_memo.cpp` | A lane that owns `src/timezone.cpp` and builds an exact zone-transition memo (PERF-K1's Sitka case shows why a shortcut is not exact), byte-identical, with the zoned keys of `test_chart_day_memo` still equal to the computed ones |
187187
| Thread-local reads that remain per call | D2-C moved the three scopes' writes onto the pump's block, `pump_ambient` (`src/native_execution_consumer.hpp:444`). A reader still reaches the block through `tl_runtime_ambient` (`src/ta_extremes_volume.cpp:29`): `bar_context` (`src/ta_extremes_volume.cpp:82`), read by every `ExtremeRing::update` (`src/ta_extremes_volume.cpp:117`), which backs `ta.highest`, `ta.lowest`, `ta.highestbars` and `ta.lowestbars` and, through an embedded `Highest` and `Lowest`, `ta.stoch`, `ta.wpr` and `ta.range`; and `matching_day_partition` (`src/timeframe.cpp:605`), read by the default-anchored `ta.vwap` through `session_day_index`, by `crosses_boundary` on a DAY period (`timeframe.change("D")`) and by the session-period helpers. `decompose_ms_local` (`src/session_time.cpp:250`) reads two thread-locals per call on a zoned clock, and the prepared order storage's `free_blocks` (`src/native_order.cpp:605`) one per prepared mutation. `ema_na_warmup_flag` is read once per EMA, at its first compute | One thread-local access per reader call. AUDIT4, macOS arm64, a dlopen'd tutorial-MACD probe, counted by `_tlv_get_addr` breakpoints and by descriptor patching: 1.000 a bar for one `ta::Highest` and for one default `ta::VWAP`, 1.999 for one `pine_hour` on a New York clock, 0.000 on the no-order floor and with orders. On Linux a TLS-descriptor call costs about 20 instructions: D2-C's 13 → 4 calls a bar was 260 → 80 instructions (Linux aarch64, GCC 13, callgrind). INT23: 2.00 a bar on the zoned probe 064, 0.08 on probe 008 | None for the TA and day-partition readers: "RULING: INT23 ACCEPTED" (ledger, 2026-09-24 23:30 UTC) reads "dlopen TLS 13->0/bar", and INT23's report names only the timezone and order-core residuals. This row is their record | Unpublished (AUDIT4's scratch) | A byte-identical lane that hands these readers the pump's block without a thread-local read. `ta::bar_context()` is script ABI, so its public declaration stays as it is |
188188
| "audit-off mode", "LTO", "data-oriented layout" | Named in "OWNER DECISION 2026-09-25 00:20 Taipei" among the post-release structural items: "S1 bulk quiet bars, S2 per-strategy specialization, audit-off mode, LTO+PGO, data-oriented layout". No engine or campaign document defines, designs or measures the three | None | The owner decision | None | Struck from this inventory until a design note defines one of them |
189189

@@ -199,7 +199,7 @@ unless the retention is Full, and `presize_logs`
199199
(`src/native_execution_consumer.cpp:9460-9471`) sizes no journal under Window.
200200
`NativeRunSpec::event_retention` (`include/pineforge/native_run_spec.hpp:714`)
201201
defaults to Window, and the Pine adapter declares
202-
`NativeEventRetention::Window` (`src/source/pine_adapter.cpp:2506`). K4 still
202+
`NativeEventRetention::Window` (`src/source/pine_adapter.cpp:2615`). K4 still
203203
sizes Full runs (driver log and journal) and Commands runs (journal), and its
204204
witness, `tests/test_native_batch_log_presize.cpp`, runs under Full. PERF-K24's
205205
replay figure (14.9 % less CPU on Linux aarch64) describes the tree before V19-B. In
@@ -210,7 +210,7 @@ or more, and the same run under Full holds 66,000 points in one block of
210210
**PERF-L4 reads the receipts about three times a bar, not once.** PERF-L4's
211211
brief asked it to "read the receipts ONCE per bar instead of three times". The
212212
lane gated the read instead: `observe_terminal_receipts`
213-
(`src/source/pine_adapter.cpp:5629`) returns at its receipt gate when no
213+
(`src/source/pine_adapter.cpp:5863`) returns at its receipt gate when no
214214
command lies above its cursor. `every_gate_is_taken_both_ways`
215215
(`tests/test_adapter_quiet_bar.cpp:1061`) prints
216216
`gate ReceiptRead asked 40996 quiet 33552 live 7444`, against `asked 13248`
@@ -241,7 +241,7 @@ Mac's 489 and 412 and 1003 of 1249, and no Mac output moved.
241241

242242
- **PERF-L4's retired reader slots.** `event_high_water_reader_` and
243243
`terminal_receipt_high_water_reader_`
244-
(`include/pineforge/source/pine_adapter.hpp:2028-2029`), with their type
244+
(`include/pineforge/source/pine_adapter.hpp:2039-2040`), with their type
245245
`ReceiptHighWaterReader`, are storage nothing reads or writes since PERF-L4:
246246
they keep `PineExecutionAdapter`'s layout, which is part of
247247
`PineStrategyHost`'s and so of the generated script's ABI. They go at the next

‎docs/pages/native-engine.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1496,7 +1496,7 @@ adapter answers `margin_check_allowed` with TradingView's scheduling — which
14961496
includes the post-exit re-size: when a priced bracket leg of the script bar
14971497
fills, the slice resting at that bar's adverse extreme was sized on the
14981498
pre-exit book, and the legacy broker cancelled and re-scheduled it there
1499-
(`margin_check_allowed` `pine_adapter.cpp:15794-15827`), so the adapter admits
1499+
(`margin_check_allowed` `pine_adapter.cpp:16099-16132`), so the adapter admits
15001500
the kernel's own point for that driver point while (and only while) a slice
15011501
rests —
15021502
`resolve_margin_requirement` with its ten-significant-digit money and
@@ -3150,7 +3150,7 @@ These are existing refusals, not implied future features:
31503150
- In-session gaps on a realtime stream, and in a `Canonical` stream warmup
31513151
- Source `calc_on_every_tick` / `calc_on_order_fills` enabled (the runner
31523152
rejects an explicit true override, and the Pine host refuses a stream begin
3153-
with `calc_on_order_fills`, `pine_strategy_host.cpp:212-215`). This is a
3153+
with `calc_on_order_fills`, `pine_strategy_host.cpp:213-216`). This is a
31543154
**source-route** refusal, not a limit on the native hooks: `on_native_tick`
31553155
and `on_native_applied` are delivered on a stream, and a native host's own
31563156
`NativeRunSpec::calculation` is accepted there, where `EveryModeledPoint`

‎include/pineforge/compat/pine/trail_ticks.hpp‎

Lines changed: 24 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -33,13 +33,36 @@ namespace pineforge::compat::pine {
3333
// 08-18 03:30Z @115208.79 (235120 ticks); std::ceil gave 235121 -> .78.
3434
// The ceil tolerance is bounded in [1e-5, 1e-4) by the 14.00001 / 14.0001
3535
// pair; 5e-5 sits in the middle. Round 5's sub-tick pins hold: 0.0006 ->
36-
// 1 tick, offsets 0 / 0.5 / 0.9 -> 0, 1.4 -> 1.
36+
// 1 tick, offsets 0 / 0.5 / 0.9 -> 0, 1.4 -> 1. This constant is
37+
// only the fallback for a run without a usable mintick: TradingView's
38+
// tolerance is c * mintick ticks (the two-argument overload below), which
39+
// at mintick 0.01 also satisfies every pin above.
3740
constexpr double kTrailPointsCeilEps = 5e-5;
3841

3942
inline double trail_points_to_ticks(double trail_points) {
4043
return std::ceil(trail_points - kTrailPointsCeilEps); // NaN stays NaN
4144
}
4245

46+
// The tolerance is not a constant number of ticks: it is c * mintick ticks.
47+
// Pinned with `lab tv` synthetics (4 identical exports each; the
48+
// callback-lifecycle test tapes, *-trailpts-*), each long's trail
49+
// filling at its activation:
50+
// BINANCE:ETHUSDT.P (0.01): 24.000057417376482 -> 24, 24.00001 -> 24,
51+
// 24.0001 / 24.001 / 24.4 / 24.6 -> 25
52+
// OANDA:XAUUSD (0.001): 1000.0 / 1000.000003 -> 1000, 1000.00003 -> 1001
53+
// OANDA:EURUSD (1e-5): 20.0 -> 20, 20.000001 / 20.00003 / 20.02 / 20.2 -> 21
54+
// The ETH pair bounds c to (5.7417e-3, 1e-2); the XAU and EUR rows refute
55+
// any constant tick or price tolerance, and 8e-3 sits inside the interval.
56+
// At mintick 0.01 the tolerance is 8e-5 ticks, so every F and BTC pin above
57+
// still holds. Without a usable mintick the constant rule applies.
58+
constexpr double kTrailPointsCeilMintickScale = 8e-3;
59+
60+
inline double trail_points_to_ticks(double trail_points, double mintick) {
61+
if (!(mintick > 0.0) || !std::isfinite(mintick))
62+
return trail_points_to_ticks(trail_points);
63+
return std::ceil(trail_points - kTrailPointsCeilMintickScale * mintick);
64+
}
65+
4366
inline double trail_offset_to_ticks(double trail_offset) {
4467
return std::floor(trail_offset); // exact; NaN stays NaN
4568
}

‎include/pineforge/pineforge.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1136,7 +1136,7 @@ PF_API int strategy_pending_order_level_resolved(pf_strategy_t s, int index);
11361136
* path: `limit = entry + dir * profit_ticks * mintick`, `stop = entry -
11371137
* dir * loss_ticks * mintick` (dir = +1 long, -1 short; both
11381138
* `level_on_price_grid`), and `trail_activation = entry +/- ceil(
1139-
* trail_points - 5e-5) * mintick` snapped to the tick grid
1139+
* trail_points - 8e-3 * mintick) * mintick` snapped to the tick grid
11401140
* (`trail_points` wins over `trail_price` when both are set, as in
11411141
* the trail activation rule). NaN for a leg that is unset or not yet
11421142
* resolvable. Returns 0; -1 with nothing written when @p s is NULL,

0 commit comments

Comments
 (0)