wickra-wasm 0.5.8 → 0.6.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +137 -75
- package/package.json +1 -1
- package/wickra_wasm.d.ts +64 -0
- package/wickra_wasm.js +1 -1
- package/wickra_wasm_bg.js +511 -0
- package/wickra_wasm_bg.wasm +0 -0
package/README.md
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
<p align="center">
|
|
2
|
-
<a href="https://wickra.org"><img src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/wickra-banner.webp?v=
|
|
2
|
+
<a href="https://wickra.org"><img src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/wickra-banner.webp?v=429" alt="Wickra — streaming-first technical indicators" width="100%"></a>
|
|
3
3
|
</p>
|
|
4
4
|
|
|
5
5
|
[](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
|
|
@@ -48,7 +48,7 @@ Full documentation lives at **[docs.wickra.org](https://docs.wickra.org)**:
|
|
|
48
48
|
[Node](https://docs.wickra.org/Quickstart-Node),
|
|
49
49
|
[WASM](https://docs.wickra.org/Quickstart-WASM).
|
|
50
50
|
- **Indicators** — a per-indicator deep dive (formula, parameters, warmup) for
|
|
51
|
-
every one of the
|
|
51
|
+
every one of the 429 indicators; start at the
|
|
52
52
|
[indicators overview](https://docs.wickra.org/Indicators-Overview).
|
|
53
53
|
- **Reference** — [warmup periods](https://docs.wickra.org/Warmup-Periods),
|
|
54
54
|
[streaming vs batch](https://docs.wickra.org/Streaming-vs-Batch),
|
|
@@ -60,83 +60,135 @@ Full documentation lives at **[docs.wickra.org](https://docs.wickra.org)**:
|
|
|
60
60
|
|
|
61
61
|
## Why Wickra exists
|
|
62
62
|
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
|
72
|
-
|
|
73
|
-
|
|
|
74
|
-
|
|
|
75
|
-
|
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
63
|
+
Wickra started as a personal itch. The existing TA libraries never quite fit the
|
|
64
|
+
projects I was building, so I decided to build one from the ground up — partly to
|
|
65
|
+
learn, partly because I genuinely enjoy taking something that already exists and
|
|
66
|
+
trying to do it differently (and, ideally, better). It's open source because the
|
|
67
|
+
useful version of that itch is the one other people can build on too.
|
|
68
|
+
|
|
69
|
+
Plenty of TA libraries are fast. Each one forces a trade-off Wickra does not:
|
|
70
|
+
|
|
71
|
+
| Library | Install | Streaming | Languages | Indicators | Active |
|
|
72
|
+
|------------------|-------------|-------------|-----------------------------|-----------:|--------|
|
|
73
|
+
| **★ Wickra**| **clean** | **yes, O(1)** | **Python · Node · WASM · Rust** | **423** | **yes** |
|
|
74
|
+
| kand | clean | yes | Python · WASM · Rust | ~60 | yes |
|
|
75
|
+
| ta-rs | clean | yes | Rust only | ~30 | stale |
|
|
76
|
+
| yata | clean | partial | Rust only | ~35 | yes |
|
|
77
|
+
| TA-Lib | yes (C deps)| no | many bindings | ~150 | barely |
|
|
78
|
+
| pandas-ta | clean | no | Python | ~130 | slow |
|
|
79
|
+
| finta | clean | no | Python | ~80 | stale |
|
|
80
|
+
| talipp | clean | yes | Python | ~40 | yes |
|
|
81
|
+
|
|
82
|
+
Wickra's edge is **breadth with reach**: 429 indicators that all update in O(1)
|
|
83
|
+
per tick and ship natively to Python, Node.js, WebAssembly and Rust from a
|
|
84
|
+
single engine.
|
|
85
|
+
|
|
86
|
+
**On speed — and why Wickra isn't the fastest.** It deliberately isn't. The
|
|
87
|
+
leaner Rust crates (kand, ta-rs) win several of the micro-benchmarks below, and
|
|
88
|
+
those losses are shown rather than hidden. The gap is a *choice*, not a ceiling:
|
|
89
|
+
every `update` validates its input, runs a real warmup before it emits a value,
|
|
90
|
+
and returns an `Option` so a single bad tick can't silently poison the state.
|
|
91
|
+
ta-rs, by contrast, hands back a bare `f64` from the first tick with no
|
|
92
|
+
validation. If Wickra threw all of that away — raw `f64` out, no checks, no
|
|
93
|
+
warmup contract — it would match or beat the leanest crate on every row. It
|
|
94
|
+
keeps the guarantees instead, and still wins RSI, Bollinger and ATR against kand.
|
|
95
|
+
What no other library matches is the *combination*: catalogue size, native O(1)
|
|
96
|
+
streaming, NaN-safety, and four first-class language targets at once.
|
|
97
|
+
|
|
98
|
+
## Benchmarks
|
|
99
|
+
|
|
100
|
+
Three comparisons, split by layer and mode. Read them as **relative** speedups
|
|
101
|
+
on identical input — absolute µs depend on CPU, memory clock and OS scheduler,
|
|
102
|
+
not a universal contract.
|
|
87
103
|
|
|
88
104
|
- **Reproduced on:** Windows 11 Pro 26200, AMD Ryzen 9 9950X, 64 GB DDR5,
|
|
89
|
-
Rust 1.92 (release
|
|
90
|
-
|
|
91
|
-
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
|
107
|
-
|
|
108
|
-
|
|
|
109
|
-
|
|
|
110
|
-
|
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
|
121
|
-
|
|
122
|
-
|
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
105
|
+
Rust 1.92 (release: `lto = "fat"`, `codegen-units = 1`), Python 3.12.
|
|
106
|
+
- **Reproduce yourself:**
|
|
107
|
+
- Rust core vs Rust crates: `cargo bench -p wickra-bench`
|
|
108
|
+
- Python vs Python libs: `pip install -e bindings/python[bench]` then
|
|
109
|
+
`python -m benchmarks.compare_libraries` (auto-detects installed peers).
|
|
110
|
+
|
|
111
|
+
### 1. Rust core vs the other Rust TA crates
|
|
112
|
+
|
|
113
|
+
Like-for-like, no language-binding overhead, over a 50 000-bar series (µs for
|
|
114
|
+
the whole series, lower = faster). This is the honest engine comparison —
|
|
115
|
+
Wickra wins some and loses some, and both are shown.
|
|
116
|
+
|
|
117
|
+
**Streaming** (one value fed per `update`):
|
|
118
|
+
|
|
119
|
+
| Indicator | **★ Wickra** | kand | ta-rs | yata |
|
|
120
|
+
|------------------|------------------:|-----:|------:|-----:|
|
|
121
|
+
| SMA(20) | 50 | 38 | 47 | 38 |
|
|
122
|
+
| EMA(20) | 154 | 69 | 56 | 69 |
|
|
123
|
+
| RSI(14) | 164 | 216 | 74 | — |
|
|
124
|
+
| MACD(12, 26, 9) | 275 | 143 | 66 | — |
|
|
125
|
+
| Bollinger(20, 2) | **128 ★** | 248 | 168 | — |
|
|
126
|
+
| ATR(14) | 152 | 166 | 61 | — |
|
|
127
|
+
|
|
128
|
+
**Batch** (whole series at once). Only Wickra and kand expose a batch API;
|
|
129
|
+
ta-rs and yata are streaming-only.
|
|
130
|
+
|
|
131
|
+
| Indicator | **★ Wickra** | kand |
|
|
132
|
+
|------------------|------------------:|-----:|
|
|
133
|
+
| SMA(20) | 82 | 42 |
|
|
134
|
+
| EMA(20) | 159 | 74 |
|
|
135
|
+
| RSI(14) | **253 ★** | 274 |
|
|
136
|
+
| MACD(12, 26, 9) | 681 | 283 |
|
|
137
|
+
| Bollinger(20, 2) | **445 ★** | 462 |
|
|
138
|
+
| ATR(14) | 175 | 173 |
|
|
139
|
+
|
|
140
|
+
ta-rs is the per-indicator speed champion on almost every row — it returns a
|
|
141
|
+
bare `f64` with no warmup state and no input validation, trading away the
|
|
142
|
+
`None`-warmup and NaN-safety semantics Wickra keeps. Against kand, Wickra wins
|
|
143
|
+
streaming RSI, Bollinger and ATR (and batch RSI + Bollinger); Bollinger is the
|
|
144
|
+
one row where Wickra is the outright fastest of all four. The leaner crates
|
|
145
|
+
still win the pure recurrences (EMA, MACD) and SMA. yata exposes only SMA/EMA as
|
|
146
|
+
raw-value methods, so its other rows are omitted rather than faked.
|
|
147
|
+
|
|
148
|
+
### 2. Python vs the Python TA ecosystem — batch
|
|
149
|
+
|
|
150
|
+
Full pass over a 20 000-bar series, µs/op (lower = faster). **★** per row.
|
|
151
|
+
|
|
152
|
+
| Indicator | **★ Wickra** | finta | TA-Lib | tulipy |
|
|
153
|
+
|------------------|------------------:|---------------------|--------|--------|
|
|
154
|
+
| SMA(20) | **59.6 ★** | 354.2 (5.9× slower) | ⧗ | ⧗ |
|
|
155
|
+
| EMA(20) | **88.4 ★** | 309.3 (3.5× slower) | ⧗ | ⧗ |
|
|
156
|
+
| RSI(14) | **77.3 ★** | 1 283 (16.6× slower)| ⧗ | ⧗ |
|
|
157
|
+
| MACD(12, 26, 9) | **116.4 ★** | 529.5 (4.6× slower) | ⧗ | ⧗ |
|
|
158
|
+
| Bollinger(20, 2) | **146.0 ★** | 1 246 (8.5× slower) | ⧗ | ⧗ |
|
|
159
|
+
| ATR(14) | **135.8 ★** | 3 812 (28× slower) | ⧗ | ⧗ |
|
|
160
|
+
|
|
161
|
+
> ⧗ = published by the CI Linux job. TA-Lib and tulipy ship C extensions that
|
|
162
|
+
> don't build cleanly on every desktop, so their canonical numbers come from the
|
|
163
|
+
> `cross-library-bench` workflow rather than this local table. pandas-ta needs
|
|
164
|
+
> Python ≥ 3.12 and isn't in the 3.11 CI matrix. The script auto-detects
|
|
165
|
+
> whichever peers are installed in your environment.
|
|
166
|
+
|
|
167
|
+
### 3. Python — streaming (per-tick latency)
|
|
168
|
+
|
|
169
|
+
Seed 5 000 bars, then feed ticks one at a time. talipp is the only Python peer
|
|
170
|
+
with a true incremental API; batch-only libraries like TA-Lib must recompute the
|
|
171
|
+
entire history on every tick — Wickra updates in O(1).
|
|
172
|
+
|
|
173
|
+
| Indicator | **★ Wickra (per tick)** | talipp (per tick) |
|
|
174
|
+
|------------------|------------------------------:|-------------------------|
|
|
175
|
+
| SMA(20) | **0.067 µs ★** | 0.63 µs (9.4× slower) |
|
|
176
|
+
| EMA(20) | **0.051 µs ★** | 0.63 µs (12.2× slower) |
|
|
177
|
+
| RSI(14) | **0.053 µs ★** | 1.00 µs (19.1× slower) |
|
|
178
|
+
| MACD(12, 26, 9) | **0.071 µs ★** | 3.64 µs (51.5× slower) |
|
|
179
|
+
| Bollinger(20, 2) | **0.085 µs ★** | 4.87 µs (57.2× slower) |
|
|
129
180
|
|
|
130
181
|
Run the suite yourself:
|
|
131
182
|
|
|
132
183
|
```bash
|
|
133
|
-
|
|
184
|
+
cargo bench -p wickra-bench # Rust core vs kand / ta-rs / yata
|
|
185
|
+
pip install -e bindings/python[bench] # Python peers
|
|
134
186
|
python -m benchmarks.compare_libraries
|
|
135
187
|
```
|
|
136
188
|
|
|
137
189
|
## Indicators
|
|
138
190
|
|
|
139
|
-
|
|
191
|
+
429 streaming-first indicators across twenty-four families. Every one passes the
|
|
140
192
|
`batch == streaming` equivalence test, reference-value tests, and reset
|
|
141
193
|
semantics tests. Each has a per-indicator deep dive (formula, parameters,
|
|
142
194
|
warmup) at [docs.wickra.org](https://docs.wickra.org/Indicators-Overview).
|
|
@@ -147,7 +199,7 @@ warmup) at [docs.wickra.org](https://docs.wickra.org/Indicators-Overview).
|
|
|
147
199
|
| Momentum Oscillators | RSI (Wilder), Anchored RSI, Stochastic, CCI, ROC, Williams %R, MFI, Awesome Oscillator, MOM, CMO, TSI, PMO, StochRSI, Ultimate Oscillator, RVI, PGO, KST, SMI, Laguerre RSI, Connors RSI, Inertia, ROC Percentage (ROCP), ROC Ratio (ROCR), ROC Ratio 100 (ROCR100), Disparity Index, Fisher RSI, RSX, Dynamic Momentum Index, Stochastic CCI, RMI, Derivative Oscillator, Elder Ray, Intraday Momentum Index, QQE |
|
|
148
200
|
| Trend & Directional | MACD, MACD Fixed (MACDFIX), MACD Extended (MACDEXT), ADX (+DI/-DI), ADXR, Aroon, TRIX, Aroon Oscillator, Vortex, Random Walk Index, Trend Intensity Index, Wave Trend Oscillator, Mass Index, Choppiness Index, Vertical Horizontal Filter, Plus DM, Minus DM, Plus DI, Minus DI, DX, TTM Trend, Trend Strength Index, Qstick, Polarized Fractal Efficiency, Wave PM, Gator Oscillator, Kase Permission Stochastic |
|
|
149
201
|
| Price Oscillators | PPO, DPO, Coppock, Accelerator Oscillator, Balance of Power, APO, AO Histogram, CFO, Zero-Lag MACD, Elder Impulse, STC, TSF Oscillator, MACD Histogram, PPO Histogram |
|
|
150
|
-
| Volatility & Bands | ATR, Bollinger Bands, Keltner Channels, Donchian Channels, NATR, StdDev, Ulcer Index, Historical Volatility, Bollinger Bandwidth, %B, True Range, Chaikin Volatility, RVI (Relative Volatility Index), Parkinson Volatility, Garman-Klass Volatility, Rogers-Satchell Volatility, Yang-Zhang Volatility |
|
|
202
|
+
| Volatility & Bands | ATR, Bollinger Bands, Keltner Channels, Donchian Channels, NATR, StdDev, Ulcer Index, Historical Volatility, Bollinger Bandwidth, %B, True Range, Chaikin Volatility, RVI (Relative Volatility Index), Parkinson Volatility, Garman-Klass Volatility, Rogers-Satchell Volatility, Yang-Zhang Volatility, Volatility Cone |
|
|
151
203
|
| Bands & Channels | MA Envelope, Acceleration Bands, STARC Bands, ATR Bands, Hurst Channel, LinReg Channel, Standard Error Bands, Double Bollinger Bands, TTM Squeeze, Fractal Chaos Bands, VWAP StdDev Bands |
|
|
152
204
|
| Trailing Stops | Parabolic SAR, Parabolic SAR Extended (SAREXT), SuperTrend, Chandelier Exit, Chande Kroll Stop, ATR Trailing Stop, HiLo Activator, Volty Stop, Yo-Yo Exit, Donchian Channel Stop, Percentage Trailing Stop, Step Trailing Stop, Renko Trailing Stop |
|
|
153
205
|
| Volume | OBV, VWAP (cumulative + rolling), ADL, Volume-Price Trend, Chaikin Money Flow, Chaikin Oscillator, Force Index, Ease of Movement, Klinger Volume Oscillator, Volume Oscillator, NVI, PVI, Williams A/D, Anchored VWAP, Demand Index, TSV, VZO, Market Facilitation Index |
|
|
@@ -245,9 +297,10 @@ A Python live-trading example using the public `websockets` package lives at
|
|
|
245
297
|
```
|
|
246
298
|
wickra/
|
|
247
299
|
├── crates/
|
|
248
|
-
│ ├── wickra-core/ core engine + all
|
|
300
|
+
│ ├── wickra-core/ core engine + all 429 indicators
|
|
249
301
|
│ ├── wickra/ top-level facade crate (publishes on crates.io) + benches/
|
|
250
|
-
│
|
|
302
|
+
│ ├── wickra-data/ CSV reader, tick aggregator, live exchange feeds
|
|
303
|
+
│ └── wickra-bench/ internal cross-library benchmark harness (not published)
|
|
251
304
|
├── bindings/
|
|
252
305
|
│ ├── python/ PyO3 + maturin (publishes on PyPI)
|
|
253
306
|
│ ├── node/ napi-rs (publishes on npm)
|
|
@@ -261,9 +314,10 @@ wickra/
|
|
|
261
314
|
└── .github/workflows/ CI and release pipelines
|
|
262
315
|
```
|
|
263
316
|
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
`
|
|
317
|
+
Wickra's own regression benchmarks live in `crates/wickra/benches/`; the
|
|
318
|
+
cross-library comparison against kand, ta-rs and yata lives in the internal
|
|
319
|
+
`crates/wickra-bench/` crate. Runnable Rust examples live in the workspace member
|
|
320
|
+
crate at `examples/rust/`. There is no top-level `benches/` directory.
|
|
267
321
|
|
|
268
322
|
## Building everything from source
|
|
269
323
|
|
|
@@ -271,7 +325,8 @@ in the workspace member crate at `examples/rust/`. There is no top-level
|
|
|
271
325
|
# Rust core + tests
|
|
272
326
|
cargo test --workspace
|
|
273
327
|
cargo clippy --workspace --all-targets -- -D warnings
|
|
274
|
-
cargo bench -p wickra
|
|
328
|
+
cargo bench -p wickra # Wickra's own regression benchmarks
|
|
329
|
+
cargo bench -p wickra-bench # cross-library comparison (kand, ta-rs, yata)
|
|
275
330
|
|
|
276
331
|
# Python binding (requires Rust toolchain + maturin)
|
|
277
332
|
cd bindings/python
|
|
@@ -371,3 +426,10 @@ The library is provided **as is**, without warranty of any kind; see
|
|
|
371
426
|
<p align="center">
|
|
372
427
|
If Wickra saved you time, the cheapest way to say thanks is to ⭐ the repo.
|
|
373
428
|
</p>
|
|
429
|
+
|
|
430
|
+
<p align="center">
|
|
431
|
+
<a href="https://star-history.com/#wickra-lib/wickra&Date">
|
|
432
|
+
<img alt="Wickra star history" width="640"
|
|
433
|
+
src="https://api.star-history.com/svg?repos=wickra-lib/wickra&type=Date&theme=dark">
|
|
434
|
+
</a>
|
|
435
|
+
</p>
|
package/package.json
CHANGED
package/wickra_wasm.d.ts
CHANGED
|
@@ -428,6 +428,17 @@ export class BetaNeutralSpread {
|
|
|
428
428
|
warmupPeriod(): number;
|
|
429
429
|
}
|
|
430
430
|
|
|
431
|
+
export class BipowerVariation {
|
|
432
|
+
free(): void;
|
|
433
|
+
[Symbol.dispose](): void;
|
|
434
|
+
batch(prices: Float64Array): Float64Array;
|
|
435
|
+
isReady(): boolean;
|
|
436
|
+
constructor(period: number);
|
|
437
|
+
reset(): void;
|
|
438
|
+
update(value: number): number | undefined;
|
|
439
|
+
warmupPeriod(): number;
|
|
440
|
+
}
|
|
441
|
+
|
|
431
442
|
export class BodySizePct {
|
|
432
443
|
free(): void;
|
|
433
444
|
[Symbol.dispose](): void;
|
|
@@ -1210,6 +1221,17 @@ export class EveningDojiStar {
|
|
|
1210
1221
|
warmupPeriod(): number;
|
|
1211
1222
|
}
|
|
1212
1223
|
|
|
1224
|
+
export class EwmaVolatility {
|
|
1225
|
+
free(): void;
|
|
1226
|
+
[Symbol.dispose](): void;
|
|
1227
|
+
batch(prices: Float64Array): Float64Array;
|
|
1228
|
+
isReady(): boolean;
|
|
1229
|
+
constructor(lambda: number);
|
|
1230
|
+
reset(): void;
|
|
1231
|
+
update(value: number): number | undefined;
|
|
1232
|
+
warmupPeriod(): number;
|
|
1233
|
+
}
|
|
1234
|
+
|
|
1213
1235
|
export class Expectancy {
|
|
1214
1236
|
free(): void;
|
|
1215
1237
|
[Symbol.dispose](): void;
|
|
@@ -1503,6 +1525,17 @@ export class GapSideBySideWhite {
|
|
|
1503
1525
|
warmupPeriod(): number;
|
|
1504
1526
|
}
|
|
1505
1527
|
|
|
1528
|
+
export class Garch11 {
|
|
1529
|
+
free(): void;
|
|
1530
|
+
[Symbol.dispose](): void;
|
|
1531
|
+
batch(prices: Float64Array): Float64Array;
|
|
1532
|
+
isReady(): boolean;
|
|
1533
|
+
constructor(omega: number, alpha: number, beta: number);
|
|
1534
|
+
reset(): void;
|
|
1535
|
+
update(value: number): number | undefined;
|
|
1536
|
+
warmupPeriod(): number;
|
|
1537
|
+
}
|
|
1538
|
+
|
|
1506
1539
|
export class GarmanKlassVolatility {
|
|
1507
1540
|
free(): void;
|
|
1508
1541
|
[Symbol.dispose](): void;
|
|
@@ -4515,6 +4548,37 @@ export class VerticalHorizontalFilter {
|
|
|
4515
4548
|
warmupPeriod(): number;
|
|
4516
4549
|
}
|
|
4517
4550
|
|
|
4551
|
+
export class VolatilityCone {
|
|
4552
|
+
free(): void;
|
|
4553
|
+
[Symbol.dispose](): void;
|
|
4554
|
+
batch(high: Float64Array, low: Float64Array, close: Float64Array): Float64Array;
|
|
4555
|
+
isReady(): boolean;
|
|
4556
|
+
constructor(window: number, lookback: number);
|
|
4557
|
+
reset(): void;
|
|
4558
|
+
update(high: number, low: number, close: number): any;
|
|
4559
|
+
warmupPeriod(): number;
|
|
4560
|
+
}
|
|
4561
|
+
|
|
4562
|
+
export class VolatilityOfVolatility {
|
|
4563
|
+
free(): void;
|
|
4564
|
+
[Symbol.dispose](): void;
|
|
4565
|
+
batch(prices: Float64Array): Float64Array;
|
|
4566
|
+
isReady(): boolean;
|
|
4567
|
+
constructor(vol_window: number, vov_window: number);
|
|
4568
|
+
reset(): void;
|
|
4569
|
+
update(value: number): number | undefined;
|
|
4570
|
+
warmupPeriod(): number;
|
|
4571
|
+
}
|
|
4572
|
+
|
|
4573
|
+
export class VolatilityRatio {
|
|
4574
|
+
free(): void;
|
|
4575
|
+
[Symbol.dispose](): void;
|
|
4576
|
+
batch(high: Float64Array, low: Float64Array, close: Float64Array): Float64Array;
|
|
4577
|
+
constructor(period: number);
|
|
4578
|
+
reset(): void;
|
|
4579
|
+
update(high: number, low: number, close: number): number | undefined;
|
|
4580
|
+
}
|
|
4581
|
+
|
|
4518
4582
|
export class VoltyStop {
|
|
4519
4583
|
free(): void;
|
|
4520
4584
|
[Symbol.dispose](): void;
|
package/wickra_wasm.js
CHANGED
|
@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./wickra_wasm_bg.js";
|
|
|
5
5
|
__wbg_set_wasm(wasm);
|
|
6
6
|
|
|
7
7
|
export {
|
|
8
|
-
ADL, ADX, ADXR, ALMA, APO, ATR, AVGPRICE, AbandonedBaby, Abcd, AbsoluteBreadthIndex, AccelerationBands, AcceleratorOscillator, AdVolumeLine, AdaptiveCycle, AdaptiveLaguerre, AdvanceBlock, AdvanceDecline, AdvanceDeclineRatio, Alligator, Alpha, AmihudIlliquidity, AnchoredRSI, AnchoredVWAP, Aroon, AroonOscillator, AtrBands, AtrTrailingStop, AutoFib, Autocorrelation, AverageDailyRange, AverageDrawdown, AwesomeOscillator, AwesomeOscillatorHistogram, BalanceOfPower, Bat, BeltHold, Beta, BetaNeutralSpread, BodySizePct, BollingerBands, BollingerBandwidth, BreadthThrust, Breakaway, BullishPercentIndex, Butterfly, CCI, CFO, CMO, CalendarSpread, CalmarRatio, Camarilla, CenterOfGravity, ChaikinMoneyFlow, ChaikinOscillator, ChaikinVolatility, ChandeKrollStop, ChandelierExit, ChoppinessIndex, ClassicPivots, CloseVsOpen, ClosingMarubozu, CoefficientOfVariation, Cointegration, ConcealingBabySwallow, ConditionalValueAtRisk, ConnorsRSI, Coppock, Counterattack, Crab, CumulativeVolumeDelta, CumulativeVolumeIndex, CupAndHandle, CyberneticCycle, Cypher, DEMA, DPO, DX, DayOfWeekProfile, Decycler, DecyclerOscillator, DemandIndex, DemarkPivots, DepthSlope, DerivativeOscillator, DetrendedStdDev, DisparityIndex, DistanceSsd, Doji, DojiStar, Donchian, DonchianStop, DoubleBollinger, DoubleTopBottom, DownsideGapThreeMethods, DragonflyDoji, DrawdownDuration, DynamicMomentumIndex, EHMA, EMA, EVWMA, EaseOfMovement, EffectiveSpread, EhlersStochastic, ElderImpulse, ElderRay, EmpiricalModeDecomposition, Engulfing, EveningDojiStar, Expectancy, FAMA, FRAMA, FallingThreeMethods, FibArcs, FibChannel, FibConfluence, FibExtension, FibFan, FibProjection, FibRetracement, FibTimeZones, FibonacciPivots, FisherRSI, FisherTransform, FlagPennant, Footprint, ForceIndex, FractalChaosBands, FundingBasis, FundingRate, FundingRateMean, FundingRateZScore, GD, GMA, GainLossRatio, GapSideBySideWhite, GarmanKlassVolatility, Gartley, GatorOscillator, GoldenPocket, GrangerCausality, GravestoneDoji, HMA, HT_DCPHASE, HT_PHASOR, HT_TRENDMODE, Hammer, HangingMan, Harami, HeadAndShoulders, HeikinAshi, HiLoActivator, HighLowIndex, HighLowRange, HighWave, Hikkake, HikkakeModified, HilbertDominantCycle, HistoricalVolatility, HoltWinters, HomingPigeon, HurstChannel, HurstExponent, IMI, Ichimoku, IdenticalThreeCrows, InNeck, Inertia, InformationRatio, InitialBalance, InstantaneousTrendline, IntradayVolatilityProfile, InverseFisherTransform, InvertedHammer, JMA, JumpIndicator, KAMA, KST, KVO, KagiBars, KalmanHedgeRatio, KasePermissionStochastic, KellyCriterion, Keltner, Kicking, KickingByLength, Kurtosis, KylesLambda, LINEARREG_INTERCEPT, LadderBottom, LaguerreRSI, LeadLagCrossCorrelation, LinRegAngle, LinRegChannel, LinRegSlope, LinearRegression, LiquidationFeatures, LogReturn, LongLeggedDoji, LongLine, LongShortRatio, MACD, MACDEXT, MACDFIX, MAMA, MFI, MIDPOINT, MIDPRICE, MINUS_DI, MINUS_DM, MOM, MaEnvelope, MacdHistogram, MarketFacilitationIndex, Marubozu, MassIndex, MatHold, MatchingLow, MaxDrawdown, McClellanOscillator, McClellanSummationIndex, McGinleyDynamic, MedianAbsoluteDeviation, MedianMA, MedianPrice, Microprice, MorningDojiStar, MorningEveningStar, NATR, NVI, NewHighsNewLows, OBV, OIPriceDivergence, OIWeighted, OmegaRatio, OnNeck, OpenInterestDelta, OpeningMarubozu, OpeningRange, OrderBookImbalanceFull, OrderBookImbalanceTop1, OrderBookImbalanceTopN, OrderFlowImbalance, OuHalfLife, OvernightGap, OvernightIntradayReturn, PGO, PLUS_DI, PLUS_DM, PMO, POLARIZED_FRACTAL_EFFICIENCY, PPO, PSAR, PVI, PainIndex, PairSpreadZScore, PairwiseBeta, ParkinsonVolatility, PearsonCorrelation, PercentAboveMa, PercentB, PercentageTrailingStop, PiercingDarkCloud, PointAndFigureBars, PpoHistogram, ProfitFactor, QQE, Qstick, QuotedSpread, RMI, ROC, ROCP, ROCR, ROCR100, RSI, RSX, RSquared, RVI, RVIVolatility, RWI, RealizedSpread, RealizedVolatility, RecoveryFactor, RectangleRange, RegimeLabel, RelativeStrengthAB, RenkoBars, RenkoTrailingStop, RickshawMan, RisingThreeMethods, RogersSatchellVolatility, RollMeasure, RollingCorrelation, RollingCovariance, RollingIqr, RollingPercentileRank, RollingQuantile, RollingVWAP, RoofingFilter, SAREXT, SMA, SMI, SMMA, STC, SWMA, SeasonalZScore, SeparatingLines, SessionHighLow, SessionRange, SessionVwap, Shark, SharpeRatio, ShootingStar, ShortLine, SignedVolume, SineWave, Skewness, SortinoRatio, SpearmanCorrelation, SpinningTop, SpreadAr1Coefficient, SpreadBollingerBands, SpreadHurst, StalledPattern, StandardError, StandardErrorBands, StarcBands, StdDev, StepTrailingStop, StickSandwich, StochRSI, Stochastic, StochasticCCI, SuperSmoother, SuperTrend, T3, TDCombo, TDCountdown, TDDeMarker, TDDifferential, TDLines, TDOpen, TDPressure, TDREI, TDRangeProjection, TDRiskLevel, TDSequential, TDSetup, TEMA, TII, TREND_STRENGTH_INDEX, TRIMA, TRIX, TSF, TSI, TSV, TTM_TREND, TakerBuySellRatio, Takuri, TasukiGap, TermStructureBasis, ThreeDrives, ThreeInside, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting, TickIndex, TimeOfDayReturnProfile, TpoProfile, TradeImbalance, TrendLabel, TreynorRatio, Triangle, Trin, TripleTopBottom, TrueRange, TsfOscillator, TtmSqueeze, TurnOfMonth, Tweezer, TwoCrows, TypicalPrice, UlcerIndex, UltimateOscillator, UniqueThreeRiver, UpDownVolumeRatio, UpsideGapThreeMethods, UpsideGapTwoCrows, VIDYA, VWAP, VWMA, VZO, ValueArea, ValueAtRisk, Variance, VarianceRatio, VerticalHorizontalFilter, VoltyStop, VolumeByTimeProfile, VolumeOscillator, VolumePriceTrend, VolumeProfile, Vortex, Vpin, VwapStdDevBands, WAVE_PM, WMA, WaveTrend, Wedge, WeightedClose, WickRatio, WilliamsAD, WilliamsFractals, WilliamsR, WinRate, WoodiePivots, YangZhangVolatility, YoyoExit, ZLEMA, ZScore, ZeroLagMACD, ZigZag, installPanicHook, version
|
|
8
|
+
ADL, ADX, ADXR, ALMA, APO, ATR, AVGPRICE, AbandonedBaby, Abcd, AbsoluteBreadthIndex, AccelerationBands, AcceleratorOscillator, AdVolumeLine, AdaptiveCycle, AdaptiveLaguerre, AdvanceBlock, AdvanceDecline, AdvanceDeclineRatio, Alligator, Alpha, AmihudIlliquidity, AnchoredRSI, AnchoredVWAP, Aroon, AroonOscillator, AtrBands, AtrTrailingStop, AutoFib, Autocorrelation, AverageDailyRange, AverageDrawdown, AwesomeOscillator, AwesomeOscillatorHistogram, BalanceOfPower, Bat, BeltHold, Beta, BetaNeutralSpread, BipowerVariation, BodySizePct, BollingerBands, BollingerBandwidth, BreadthThrust, Breakaway, BullishPercentIndex, Butterfly, CCI, CFO, CMO, CalendarSpread, CalmarRatio, Camarilla, CenterOfGravity, ChaikinMoneyFlow, ChaikinOscillator, ChaikinVolatility, ChandeKrollStop, ChandelierExit, ChoppinessIndex, ClassicPivots, CloseVsOpen, ClosingMarubozu, CoefficientOfVariation, Cointegration, ConcealingBabySwallow, ConditionalValueAtRisk, ConnorsRSI, Coppock, Counterattack, Crab, CumulativeVolumeDelta, CumulativeVolumeIndex, CupAndHandle, CyberneticCycle, Cypher, DEMA, DPO, DX, DayOfWeekProfile, Decycler, DecyclerOscillator, DemandIndex, DemarkPivots, DepthSlope, DerivativeOscillator, DetrendedStdDev, DisparityIndex, DistanceSsd, Doji, DojiStar, Donchian, DonchianStop, DoubleBollinger, DoubleTopBottom, DownsideGapThreeMethods, DragonflyDoji, DrawdownDuration, DynamicMomentumIndex, EHMA, EMA, EVWMA, EaseOfMovement, EffectiveSpread, EhlersStochastic, ElderImpulse, ElderRay, EmpiricalModeDecomposition, Engulfing, EveningDojiStar, EwmaVolatility, Expectancy, FAMA, FRAMA, FallingThreeMethods, FibArcs, FibChannel, FibConfluence, FibExtension, FibFan, FibProjection, FibRetracement, FibTimeZones, FibonacciPivots, FisherRSI, FisherTransform, FlagPennant, Footprint, ForceIndex, FractalChaosBands, FundingBasis, FundingRate, FundingRateMean, FundingRateZScore, GD, GMA, GainLossRatio, GapSideBySideWhite, Garch11, GarmanKlassVolatility, Gartley, GatorOscillator, GoldenPocket, GrangerCausality, GravestoneDoji, HMA, HT_DCPHASE, HT_PHASOR, HT_TRENDMODE, Hammer, HangingMan, Harami, HeadAndShoulders, HeikinAshi, HiLoActivator, HighLowIndex, HighLowRange, HighWave, Hikkake, HikkakeModified, HilbertDominantCycle, HistoricalVolatility, HoltWinters, HomingPigeon, HurstChannel, HurstExponent, IMI, Ichimoku, IdenticalThreeCrows, InNeck, Inertia, InformationRatio, InitialBalance, InstantaneousTrendline, IntradayVolatilityProfile, InverseFisherTransform, InvertedHammer, JMA, JumpIndicator, KAMA, KST, KVO, KagiBars, KalmanHedgeRatio, KasePermissionStochastic, KellyCriterion, Keltner, Kicking, KickingByLength, Kurtosis, KylesLambda, LINEARREG_INTERCEPT, LadderBottom, LaguerreRSI, LeadLagCrossCorrelation, LinRegAngle, LinRegChannel, LinRegSlope, LinearRegression, LiquidationFeatures, LogReturn, LongLeggedDoji, LongLine, LongShortRatio, MACD, MACDEXT, MACDFIX, MAMA, MFI, MIDPOINT, MIDPRICE, MINUS_DI, MINUS_DM, MOM, MaEnvelope, MacdHistogram, MarketFacilitationIndex, Marubozu, MassIndex, MatHold, MatchingLow, MaxDrawdown, McClellanOscillator, McClellanSummationIndex, McGinleyDynamic, MedianAbsoluteDeviation, MedianMA, MedianPrice, Microprice, MorningDojiStar, MorningEveningStar, NATR, NVI, NewHighsNewLows, OBV, OIPriceDivergence, OIWeighted, OmegaRatio, OnNeck, OpenInterestDelta, OpeningMarubozu, OpeningRange, OrderBookImbalanceFull, OrderBookImbalanceTop1, OrderBookImbalanceTopN, OrderFlowImbalance, OuHalfLife, OvernightGap, OvernightIntradayReturn, PGO, PLUS_DI, PLUS_DM, PMO, POLARIZED_FRACTAL_EFFICIENCY, PPO, PSAR, PVI, PainIndex, PairSpreadZScore, PairwiseBeta, ParkinsonVolatility, PearsonCorrelation, PercentAboveMa, PercentB, PercentageTrailingStop, PiercingDarkCloud, PointAndFigureBars, PpoHistogram, ProfitFactor, QQE, Qstick, QuotedSpread, RMI, ROC, ROCP, ROCR, ROCR100, RSI, RSX, RSquared, RVI, RVIVolatility, RWI, RealizedSpread, RealizedVolatility, RecoveryFactor, RectangleRange, RegimeLabel, RelativeStrengthAB, RenkoBars, RenkoTrailingStop, RickshawMan, RisingThreeMethods, RogersSatchellVolatility, RollMeasure, RollingCorrelation, RollingCovariance, RollingIqr, RollingPercentileRank, RollingQuantile, RollingVWAP, RoofingFilter, SAREXT, SMA, SMI, SMMA, STC, SWMA, SeasonalZScore, SeparatingLines, SessionHighLow, SessionRange, SessionVwap, Shark, SharpeRatio, ShootingStar, ShortLine, SignedVolume, SineWave, Skewness, SortinoRatio, SpearmanCorrelation, SpinningTop, SpreadAr1Coefficient, SpreadBollingerBands, SpreadHurst, StalledPattern, StandardError, StandardErrorBands, StarcBands, StdDev, StepTrailingStop, StickSandwich, StochRSI, Stochastic, StochasticCCI, SuperSmoother, SuperTrend, T3, TDCombo, TDCountdown, TDDeMarker, TDDifferential, TDLines, TDOpen, TDPressure, TDREI, TDRangeProjection, TDRiskLevel, TDSequential, TDSetup, TEMA, TII, TREND_STRENGTH_INDEX, TRIMA, TRIX, TSF, TSI, TSV, TTM_TREND, TakerBuySellRatio, Takuri, TasukiGap, TermStructureBasis, ThreeDrives, ThreeInside, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting, TickIndex, TimeOfDayReturnProfile, TpoProfile, TradeImbalance, TrendLabel, TreynorRatio, Triangle, Trin, TripleTopBottom, TrueRange, TsfOscillator, TtmSqueeze, TurnOfMonth, Tweezer, TwoCrows, TypicalPrice, UlcerIndex, UltimateOscillator, UniqueThreeRiver, UpDownVolumeRatio, UpsideGapThreeMethods, UpsideGapTwoCrows, VIDYA, VWAP, VWMA, VZO, ValueArea, ValueAtRisk, Variance, VarianceRatio, VerticalHorizontalFilter, VolatilityCone, VolatilityOfVolatility, VolatilityRatio, VoltyStop, VolumeByTimeProfile, VolumeOscillator, VolumePriceTrend, VolumeProfile, Vortex, Vpin, VwapStdDevBands, WAVE_PM, WMA, WaveTrend, Wedge, WeightedClose, WickRatio, WilliamsAD, WilliamsFractals, WilliamsR, WinRate, WoodiePivots, YangZhangVolatility, YoyoExit, ZLEMA, ZScore, ZeroLagMACD, ZigZag, installPanicHook, version
|
|
9
9
|
} from "./wickra_wasm_bg.js";
|
package/wickra_wasm_bg.js
CHANGED
|
@@ -3179,6 +3179,82 @@ export class BetaNeutralSpread {
|
|
|
3179
3179
|
}
|
|
3180
3180
|
if (Symbol.dispose) BetaNeutralSpread.prototype[Symbol.dispose] = BetaNeutralSpread.prototype.free;
|
|
3181
3181
|
|
|
3182
|
+
export class BipowerVariation {
|
|
3183
|
+
__destroy_into_raw() {
|
|
3184
|
+
const ptr = this.__wbg_ptr;
|
|
3185
|
+
this.__wbg_ptr = 0;
|
|
3186
|
+
BipowerVariationFinalization.unregister(this);
|
|
3187
|
+
return ptr;
|
|
3188
|
+
}
|
|
3189
|
+
free() {
|
|
3190
|
+
const ptr = this.__destroy_into_raw();
|
|
3191
|
+
wasm.__wbg_bipowervariation_free(ptr, 0);
|
|
3192
|
+
}
|
|
3193
|
+
/**
|
|
3194
|
+
* @param {Float64Array} prices
|
|
3195
|
+
* @returns {Float64Array}
|
|
3196
|
+
*/
|
|
3197
|
+
batch(prices) {
|
|
3198
|
+
const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
|
|
3199
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3200
|
+
const ret = wasm.bipowervariation_batch(this.__wbg_ptr, ptr0, len0);
|
|
3201
|
+
return takeObject(ret);
|
|
3202
|
+
}
|
|
3203
|
+
/**
|
|
3204
|
+
* @returns {boolean}
|
|
3205
|
+
*/
|
|
3206
|
+
isReady() {
|
|
3207
|
+
const ret = wasm.bipowervariation_isReady(this.__wbg_ptr);
|
|
3208
|
+
return ret !== 0;
|
|
3209
|
+
}
|
|
3210
|
+
/**
|
|
3211
|
+
* @param {number} period
|
|
3212
|
+
*/
|
|
3213
|
+
constructor(period) {
|
|
3214
|
+
try {
|
|
3215
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3216
|
+
wasm.bipowervariation_new(retptr, period);
|
|
3217
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3218
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3219
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3220
|
+
if (r2) {
|
|
3221
|
+
throw takeObject(r1);
|
|
3222
|
+
}
|
|
3223
|
+
this.__wbg_ptr = r0;
|
|
3224
|
+
BipowerVariationFinalization.register(this, this.__wbg_ptr, this);
|
|
3225
|
+
return this;
|
|
3226
|
+
} finally {
|
|
3227
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3228
|
+
}
|
|
3229
|
+
}
|
|
3230
|
+
reset() {
|
|
3231
|
+
wasm.bipowervariation_reset(this.__wbg_ptr);
|
|
3232
|
+
}
|
|
3233
|
+
/**
|
|
3234
|
+
* @param {number} value
|
|
3235
|
+
* @returns {number | undefined}
|
|
3236
|
+
*/
|
|
3237
|
+
update(value) {
|
|
3238
|
+
try {
|
|
3239
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3240
|
+
wasm.bipowervariation_update(retptr, this.__wbg_ptr, value);
|
|
3241
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3242
|
+
var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
|
|
3243
|
+
return r0 === 0 ? undefined : r2;
|
|
3244
|
+
} finally {
|
|
3245
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3246
|
+
}
|
|
3247
|
+
}
|
|
3248
|
+
/**
|
|
3249
|
+
* @returns {number}
|
|
3250
|
+
*/
|
|
3251
|
+
warmupPeriod() {
|
|
3252
|
+
const ret = wasm.bipowervariation_warmupPeriod(this.__wbg_ptr);
|
|
3253
|
+
return ret >>> 0;
|
|
3254
|
+
}
|
|
3255
|
+
}
|
|
3256
|
+
if (Symbol.dispose) BipowerVariation.prototype[Symbol.dispose] = BipowerVariation.prototype.free;
|
|
3257
|
+
|
|
3182
3258
|
export class BodySizePct {
|
|
3183
3259
|
__destroy_into_raw() {
|
|
3184
3260
|
const ptr = this.__wbg_ptr;
|
|
@@ -8880,6 +8956,82 @@ export class EveningDojiStar {
|
|
|
8880
8956
|
}
|
|
8881
8957
|
if (Symbol.dispose) EveningDojiStar.prototype[Symbol.dispose] = EveningDojiStar.prototype.free;
|
|
8882
8958
|
|
|
8959
|
+
export class EwmaVolatility {
|
|
8960
|
+
__destroy_into_raw() {
|
|
8961
|
+
const ptr = this.__wbg_ptr;
|
|
8962
|
+
this.__wbg_ptr = 0;
|
|
8963
|
+
EwmaVolatilityFinalization.unregister(this);
|
|
8964
|
+
return ptr;
|
|
8965
|
+
}
|
|
8966
|
+
free() {
|
|
8967
|
+
const ptr = this.__destroy_into_raw();
|
|
8968
|
+
wasm.__wbg_ewmavolatility_free(ptr, 0);
|
|
8969
|
+
}
|
|
8970
|
+
/**
|
|
8971
|
+
* @param {Float64Array} prices
|
|
8972
|
+
* @returns {Float64Array}
|
|
8973
|
+
*/
|
|
8974
|
+
batch(prices) {
|
|
8975
|
+
const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
|
|
8976
|
+
const len0 = WASM_VECTOR_LEN;
|
|
8977
|
+
const ret = wasm.ewmavolatility_batch(this.__wbg_ptr, ptr0, len0);
|
|
8978
|
+
return takeObject(ret);
|
|
8979
|
+
}
|
|
8980
|
+
/**
|
|
8981
|
+
* @returns {boolean}
|
|
8982
|
+
*/
|
|
8983
|
+
isReady() {
|
|
8984
|
+
const ret = wasm.ewmavolatility_isReady(this.__wbg_ptr);
|
|
8985
|
+
return ret !== 0;
|
|
8986
|
+
}
|
|
8987
|
+
/**
|
|
8988
|
+
* @param {number} lambda
|
|
8989
|
+
*/
|
|
8990
|
+
constructor(lambda) {
|
|
8991
|
+
try {
|
|
8992
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
8993
|
+
wasm.ewmavolatility_new(retptr, lambda);
|
|
8994
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
8995
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
8996
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
8997
|
+
if (r2) {
|
|
8998
|
+
throw takeObject(r1);
|
|
8999
|
+
}
|
|
9000
|
+
this.__wbg_ptr = r0;
|
|
9001
|
+
EwmaVolatilityFinalization.register(this, this.__wbg_ptr, this);
|
|
9002
|
+
return this;
|
|
9003
|
+
} finally {
|
|
9004
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
9005
|
+
}
|
|
9006
|
+
}
|
|
9007
|
+
reset() {
|
|
9008
|
+
wasm.ewmavolatility_reset(this.__wbg_ptr);
|
|
9009
|
+
}
|
|
9010
|
+
/**
|
|
9011
|
+
* @param {number} value
|
|
9012
|
+
* @returns {number | undefined}
|
|
9013
|
+
*/
|
|
9014
|
+
update(value) {
|
|
9015
|
+
try {
|
|
9016
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
9017
|
+
wasm.ewmavolatility_update(retptr, this.__wbg_ptr, value);
|
|
9018
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
9019
|
+
var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
|
|
9020
|
+
return r0 === 0 ? undefined : r2;
|
|
9021
|
+
} finally {
|
|
9022
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
9023
|
+
}
|
|
9024
|
+
}
|
|
9025
|
+
/**
|
|
9026
|
+
* @returns {number}
|
|
9027
|
+
*/
|
|
9028
|
+
warmupPeriod() {
|
|
9029
|
+
const ret = wasm.ewmavolatility_warmupPeriod(this.__wbg_ptr);
|
|
9030
|
+
return ret >>> 0;
|
|
9031
|
+
}
|
|
9032
|
+
}
|
|
9033
|
+
if (Symbol.dispose) EwmaVolatility.prototype[Symbol.dispose] = EwmaVolatility.prototype.free;
|
|
9034
|
+
|
|
8883
9035
|
export class Expectancy {
|
|
8884
9036
|
__destroy_into_raw() {
|
|
8885
9037
|
const ptr = this.__wbg_ptr;
|
|
@@ -11000,6 +11152,84 @@ export class GapSideBySideWhite {
|
|
|
11000
11152
|
}
|
|
11001
11153
|
if (Symbol.dispose) GapSideBySideWhite.prototype[Symbol.dispose] = GapSideBySideWhite.prototype.free;
|
|
11002
11154
|
|
|
11155
|
+
export class Garch11 {
|
|
11156
|
+
__destroy_into_raw() {
|
|
11157
|
+
const ptr = this.__wbg_ptr;
|
|
11158
|
+
this.__wbg_ptr = 0;
|
|
11159
|
+
Garch11Finalization.unregister(this);
|
|
11160
|
+
return ptr;
|
|
11161
|
+
}
|
|
11162
|
+
free() {
|
|
11163
|
+
const ptr = this.__destroy_into_raw();
|
|
11164
|
+
wasm.__wbg_garch11_free(ptr, 0);
|
|
11165
|
+
}
|
|
11166
|
+
/**
|
|
11167
|
+
* @param {Float64Array} prices
|
|
11168
|
+
* @returns {Float64Array}
|
|
11169
|
+
*/
|
|
11170
|
+
batch(prices) {
|
|
11171
|
+
const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
|
|
11172
|
+
const len0 = WASM_VECTOR_LEN;
|
|
11173
|
+
const ret = wasm.garch11_batch(this.__wbg_ptr, ptr0, len0);
|
|
11174
|
+
return takeObject(ret);
|
|
11175
|
+
}
|
|
11176
|
+
/**
|
|
11177
|
+
* @returns {boolean}
|
|
11178
|
+
*/
|
|
11179
|
+
isReady() {
|
|
11180
|
+
const ret = wasm.garch11_isReady(this.__wbg_ptr);
|
|
11181
|
+
return ret !== 0;
|
|
11182
|
+
}
|
|
11183
|
+
/**
|
|
11184
|
+
* @param {number} omega
|
|
11185
|
+
* @param {number} alpha
|
|
11186
|
+
* @param {number} beta
|
|
11187
|
+
*/
|
|
11188
|
+
constructor(omega, alpha, beta) {
|
|
11189
|
+
try {
|
|
11190
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
11191
|
+
wasm.garch11_new(retptr, omega, alpha, beta);
|
|
11192
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
11193
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
11194
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
11195
|
+
if (r2) {
|
|
11196
|
+
throw takeObject(r1);
|
|
11197
|
+
}
|
|
11198
|
+
this.__wbg_ptr = r0;
|
|
11199
|
+
Garch11Finalization.register(this, this.__wbg_ptr, this);
|
|
11200
|
+
return this;
|
|
11201
|
+
} finally {
|
|
11202
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
11203
|
+
}
|
|
11204
|
+
}
|
|
11205
|
+
reset() {
|
|
11206
|
+
wasm.garch11_reset(this.__wbg_ptr);
|
|
11207
|
+
}
|
|
11208
|
+
/**
|
|
11209
|
+
* @param {number} value
|
|
11210
|
+
* @returns {number | undefined}
|
|
11211
|
+
*/
|
|
11212
|
+
update(value) {
|
|
11213
|
+
try {
|
|
11214
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
11215
|
+
wasm.garch11_update(retptr, this.__wbg_ptr, value);
|
|
11216
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
11217
|
+
var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
|
|
11218
|
+
return r0 === 0 ? undefined : r2;
|
|
11219
|
+
} finally {
|
|
11220
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
11221
|
+
}
|
|
11222
|
+
}
|
|
11223
|
+
/**
|
|
11224
|
+
* @returns {number}
|
|
11225
|
+
*/
|
|
11226
|
+
warmupPeriod() {
|
|
11227
|
+
const ret = wasm.garch11_warmupPeriod(this.__wbg_ptr);
|
|
11228
|
+
return ret >>> 0;
|
|
11229
|
+
}
|
|
11230
|
+
}
|
|
11231
|
+
if (Symbol.dispose) Garch11.prototype[Symbol.dispose] = Garch11.prototype.free;
|
|
11232
|
+
|
|
11003
11233
|
export class GarmanKlassVolatility {
|
|
11004
11234
|
__destroy_into_raw() {
|
|
11005
11235
|
const ptr = this.__wbg_ptr;
|
|
@@ -32712,6 +32942,269 @@ export class VerticalHorizontalFilter {
|
|
|
32712
32942
|
}
|
|
32713
32943
|
if (Symbol.dispose) VerticalHorizontalFilter.prototype[Symbol.dispose] = VerticalHorizontalFilter.prototype.free;
|
|
32714
32944
|
|
|
32945
|
+
export class VolatilityCone {
|
|
32946
|
+
__destroy_into_raw() {
|
|
32947
|
+
const ptr = this.__wbg_ptr;
|
|
32948
|
+
this.__wbg_ptr = 0;
|
|
32949
|
+
VolatilityConeFinalization.unregister(this);
|
|
32950
|
+
return ptr;
|
|
32951
|
+
}
|
|
32952
|
+
free() {
|
|
32953
|
+
const ptr = this.__destroy_into_raw();
|
|
32954
|
+
wasm.__wbg_volatilitycone_free(ptr, 0);
|
|
32955
|
+
}
|
|
32956
|
+
/**
|
|
32957
|
+
* @param {Float64Array} high
|
|
32958
|
+
* @param {Float64Array} low
|
|
32959
|
+
* @param {Float64Array} close
|
|
32960
|
+
* @returns {Float64Array}
|
|
32961
|
+
*/
|
|
32962
|
+
batch(high, low, close) {
|
|
32963
|
+
try {
|
|
32964
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
32965
|
+
const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
|
|
32966
|
+
const len0 = WASM_VECTOR_LEN;
|
|
32967
|
+
const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
|
|
32968
|
+
const len1 = WASM_VECTOR_LEN;
|
|
32969
|
+
const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
|
|
32970
|
+
const len2 = WASM_VECTOR_LEN;
|
|
32971
|
+
wasm.volatilitycone_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
32972
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
32973
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
32974
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
32975
|
+
if (r2) {
|
|
32976
|
+
throw takeObject(r1);
|
|
32977
|
+
}
|
|
32978
|
+
return takeObject(r0);
|
|
32979
|
+
} finally {
|
|
32980
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
32981
|
+
}
|
|
32982
|
+
}
|
|
32983
|
+
/**
|
|
32984
|
+
* @returns {boolean}
|
|
32985
|
+
*/
|
|
32986
|
+
isReady() {
|
|
32987
|
+
const ret = wasm.volatilitycone_isReady(this.__wbg_ptr);
|
|
32988
|
+
return ret !== 0;
|
|
32989
|
+
}
|
|
32990
|
+
/**
|
|
32991
|
+
* @param {number} window
|
|
32992
|
+
* @param {number} lookback
|
|
32993
|
+
*/
|
|
32994
|
+
constructor(window, lookback) {
|
|
32995
|
+
try {
|
|
32996
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
32997
|
+
wasm.volatilitycone_new(retptr, window, lookback);
|
|
32998
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
32999
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
33000
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
33001
|
+
if (r2) {
|
|
33002
|
+
throw takeObject(r1);
|
|
33003
|
+
}
|
|
33004
|
+
this.__wbg_ptr = r0;
|
|
33005
|
+
VolatilityConeFinalization.register(this, this.__wbg_ptr, this);
|
|
33006
|
+
return this;
|
|
33007
|
+
} finally {
|
|
33008
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
33009
|
+
}
|
|
33010
|
+
}
|
|
33011
|
+
reset() {
|
|
33012
|
+
wasm.volatilitycone_reset(this.__wbg_ptr);
|
|
33013
|
+
}
|
|
33014
|
+
/**
|
|
33015
|
+
* @param {number} high
|
|
33016
|
+
* @param {number} low
|
|
33017
|
+
* @param {number} close
|
|
33018
|
+
* @returns {any}
|
|
33019
|
+
*/
|
|
33020
|
+
update(high, low, close) {
|
|
33021
|
+
try {
|
|
33022
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
33023
|
+
wasm.volatilitycone_update(retptr, this.__wbg_ptr, high, low, close);
|
|
33024
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
33025
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
33026
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
33027
|
+
if (r2) {
|
|
33028
|
+
throw takeObject(r1);
|
|
33029
|
+
}
|
|
33030
|
+
return takeObject(r0);
|
|
33031
|
+
} finally {
|
|
33032
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
33033
|
+
}
|
|
33034
|
+
}
|
|
33035
|
+
/**
|
|
33036
|
+
* @returns {number}
|
|
33037
|
+
*/
|
|
33038
|
+
warmupPeriod() {
|
|
33039
|
+
const ret = wasm.volatilitycone_warmupPeriod(this.__wbg_ptr);
|
|
33040
|
+
return ret >>> 0;
|
|
33041
|
+
}
|
|
33042
|
+
}
|
|
33043
|
+
if (Symbol.dispose) VolatilityCone.prototype[Symbol.dispose] = VolatilityCone.prototype.free;
|
|
33044
|
+
|
|
33045
|
+
export class VolatilityOfVolatility {
|
|
33046
|
+
__destroy_into_raw() {
|
|
33047
|
+
const ptr = this.__wbg_ptr;
|
|
33048
|
+
this.__wbg_ptr = 0;
|
|
33049
|
+
VolatilityOfVolatilityFinalization.unregister(this);
|
|
33050
|
+
return ptr;
|
|
33051
|
+
}
|
|
33052
|
+
free() {
|
|
33053
|
+
const ptr = this.__destroy_into_raw();
|
|
33054
|
+
wasm.__wbg_volatilityofvolatility_free(ptr, 0);
|
|
33055
|
+
}
|
|
33056
|
+
/**
|
|
33057
|
+
* @param {Float64Array} prices
|
|
33058
|
+
* @returns {Float64Array}
|
|
33059
|
+
*/
|
|
33060
|
+
batch(prices) {
|
|
33061
|
+
const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
|
|
33062
|
+
const len0 = WASM_VECTOR_LEN;
|
|
33063
|
+
const ret = wasm.volatilityofvolatility_batch(this.__wbg_ptr, ptr0, len0);
|
|
33064
|
+
return takeObject(ret);
|
|
33065
|
+
}
|
|
33066
|
+
/**
|
|
33067
|
+
* @returns {boolean}
|
|
33068
|
+
*/
|
|
33069
|
+
isReady() {
|
|
33070
|
+
const ret = wasm.volatilityofvolatility_isReady(this.__wbg_ptr);
|
|
33071
|
+
return ret !== 0;
|
|
33072
|
+
}
|
|
33073
|
+
/**
|
|
33074
|
+
* @param {number} vol_window
|
|
33075
|
+
* @param {number} vov_window
|
|
33076
|
+
*/
|
|
33077
|
+
constructor(vol_window, vov_window) {
|
|
33078
|
+
try {
|
|
33079
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
33080
|
+
wasm.volatilityofvolatility_new(retptr, vol_window, vov_window);
|
|
33081
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
33082
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
33083
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
33084
|
+
if (r2) {
|
|
33085
|
+
throw takeObject(r1);
|
|
33086
|
+
}
|
|
33087
|
+
this.__wbg_ptr = r0;
|
|
33088
|
+
VolatilityOfVolatilityFinalization.register(this, this.__wbg_ptr, this);
|
|
33089
|
+
return this;
|
|
33090
|
+
} finally {
|
|
33091
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
33092
|
+
}
|
|
33093
|
+
}
|
|
33094
|
+
reset() {
|
|
33095
|
+
wasm.volatilityofvolatility_reset(this.__wbg_ptr);
|
|
33096
|
+
}
|
|
33097
|
+
/**
|
|
33098
|
+
* @param {number} value
|
|
33099
|
+
* @returns {number | undefined}
|
|
33100
|
+
*/
|
|
33101
|
+
update(value) {
|
|
33102
|
+
try {
|
|
33103
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
33104
|
+
wasm.volatilityofvolatility_update(retptr, this.__wbg_ptr, value);
|
|
33105
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
33106
|
+
var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
|
|
33107
|
+
return r0 === 0 ? undefined : r2;
|
|
33108
|
+
} finally {
|
|
33109
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
33110
|
+
}
|
|
33111
|
+
}
|
|
33112
|
+
/**
|
|
33113
|
+
* @returns {number}
|
|
33114
|
+
*/
|
|
33115
|
+
warmupPeriod() {
|
|
33116
|
+
const ret = wasm.volatilityofvolatility_warmupPeriod(this.__wbg_ptr);
|
|
33117
|
+
return ret >>> 0;
|
|
33118
|
+
}
|
|
33119
|
+
}
|
|
33120
|
+
if (Symbol.dispose) VolatilityOfVolatility.prototype[Symbol.dispose] = VolatilityOfVolatility.prototype.free;
|
|
33121
|
+
|
|
33122
|
+
export class VolatilityRatio {
|
|
33123
|
+
__destroy_into_raw() {
|
|
33124
|
+
const ptr = this.__wbg_ptr;
|
|
33125
|
+
this.__wbg_ptr = 0;
|
|
33126
|
+
VolatilityRatioFinalization.unregister(this);
|
|
33127
|
+
return ptr;
|
|
33128
|
+
}
|
|
33129
|
+
free() {
|
|
33130
|
+
const ptr = this.__destroy_into_raw();
|
|
33131
|
+
wasm.__wbg_volatilityratio_free(ptr, 0);
|
|
33132
|
+
}
|
|
33133
|
+
/**
|
|
33134
|
+
* @param {Float64Array} high
|
|
33135
|
+
* @param {Float64Array} low
|
|
33136
|
+
* @param {Float64Array} close
|
|
33137
|
+
* @returns {Float64Array}
|
|
33138
|
+
*/
|
|
33139
|
+
batch(high, low, close) {
|
|
33140
|
+
try {
|
|
33141
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
33142
|
+
const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
|
|
33143
|
+
const len0 = WASM_VECTOR_LEN;
|
|
33144
|
+
const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
|
|
33145
|
+
const len1 = WASM_VECTOR_LEN;
|
|
33146
|
+
const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
|
|
33147
|
+
const len2 = WASM_VECTOR_LEN;
|
|
33148
|
+
wasm.volatilityratio_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
33149
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
33150
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
33151
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
33152
|
+
if (r2) {
|
|
33153
|
+
throw takeObject(r1);
|
|
33154
|
+
}
|
|
33155
|
+
return takeObject(r0);
|
|
33156
|
+
} finally {
|
|
33157
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
33158
|
+
}
|
|
33159
|
+
}
|
|
33160
|
+
/**
|
|
33161
|
+
* @param {number} period
|
|
33162
|
+
*/
|
|
33163
|
+
constructor(period) {
|
|
33164
|
+
try {
|
|
33165
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
33166
|
+
wasm.volatilityratio_new(retptr, period);
|
|
33167
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
33168
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
33169
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
33170
|
+
if (r2) {
|
|
33171
|
+
throw takeObject(r1);
|
|
33172
|
+
}
|
|
33173
|
+
this.__wbg_ptr = r0;
|
|
33174
|
+
VolatilityRatioFinalization.register(this, this.__wbg_ptr, this);
|
|
33175
|
+
return this;
|
|
33176
|
+
} finally {
|
|
33177
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
33178
|
+
}
|
|
33179
|
+
}
|
|
33180
|
+
reset() {
|
|
33181
|
+
wasm.volatilityratio_reset(this.__wbg_ptr);
|
|
33182
|
+
}
|
|
33183
|
+
/**
|
|
33184
|
+
* @param {number} high
|
|
33185
|
+
* @param {number} low
|
|
33186
|
+
* @param {number} close
|
|
33187
|
+
* @returns {number | undefined}
|
|
33188
|
+
*/
|
|
33189
|
+
update(high, low, close) {
|
|
33190
|
+
try {
|
|
33191
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
|
|
33192
|
+
wasm.volatilityratio_update(retptr, this.__wbg_ptr, high, low, close);
|
|
33193
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
33194
|
+
var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
|
|
33195
|
+
var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
|
|
33196
|
+
var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
|
|
33197
|
+
if (r5) {
|
|
33198
|
+
throw takeObject(r4);
|
|
33199
|
+
}
|
|
33200
|
+
return r0 === 0 ? undefined : r2;
|
|
33201
|
+
} finally {
|
|
33202
|
+
wasm.__wbindgen_add_to_stack_pointer(32);
|
|
33203
|
+
}
|
|
33204
|
+
}
|
|
33205
|
+
}
|
|
33206
|
+
if (Symbol.dispose) VolatilityRatio.prototype[Symbol.dispose] = VolatilityRatio.prototype.free;
|
|
33207
|
+
|
|
32715
33208
|
export class VoltyStop {
|
|
32716
33209
|
__destroy_into_raw() {
|
|
32717
33210
|
const ptr = this.__wbg_ptr;
|
|
@@ -35048,6 +35541,9 @@ const BetaFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
|
35048
35541
|
const BetaNeutralSpreadFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
35049
35542
|
? { register: () => {}, unregister: () => {} }
|
|
35050
35543
|
: new FinalizationRegistry(ptr => wasm.__wbg_betaneutralspread_free(ptr, 1));
|
|
35544
|
+
const BipowerVariationFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
35545
|
+
? { register: () => {}, unregister: () => {} }
|
|
35546
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_bipowervariation_free(ptr, 1));
|
|
35051
35547
|
const BodySizePctFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
35052
35548
|
? { register: () => {}, unregister: () => {} }
|
|
35053
35549
|
: new FinalizationRegistry(ptr => wasm.__wbg_bodysizepct_free(ptr, 1));
|
|
@@ -35255,6 +35751,9 @@ const EveningDojiStarFinalization = (typeof FinalizationRegistry === 'undefined'
|
|
|
35255
35751
|
const EVWMAFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
35256
35752
|
? { register: () => {}, unregister: () => {} }
|
|
35257
35753
|
: new FinalizationRegistry(ptr => wasm.__wbg_evwma_free(ptr, 1));
|
|
35754
|
+
const EwmaVolatilityFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
35755
|
+
? { register: () => {}, unregister: () => {} }
|
|
35756
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_ewmavolatility_free(ptr, 1));
|
|
35258
35757
|
const ExpectancyFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
35259
35758
|
? { register: () => {}, unregister: () => {} }
|
|
35260
35759
|
: new FinalizationRegistry(ptr => wasm.__wbg_expectancy_free(ptr, 1));
|
|
@@ -35330,6 +35829,9 @@ const GainLossRatioFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
|
35330
35829
|
const GapSideBySideWhiteFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
35331
35830
|
? { register: () => {}, unregister: () => {} }
|
|
35332
35831
|
: new FinalizationRegistry(ptr => wasm.__wbg_gapsidebysidewhite_free(ptr, 1));
|
|
35832
|
+
const Garch11Finalization = (typeof FinalizationRegistry === 'undefined')
|
|
35833
|
+
? { register: () => {}, unregister: () => {} }
|
|
35834
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_garch11_free(ptr, 1));
|
|
35333
35835
|
const GarmanKlassVolatilityFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
35334
35836
|
? { register: () => {}, unregister: () => {} }
|
|
35335
35837
|
: new FinalizationRegistry(ptr => wasm.__wbg_garmanklassvolatility_free(ptr, 1));
|
|
@@ -36116,6 +36618,15 @@ const VerticalHorizontalFilterFinalization = (typeof FinalizationRegistry === 'u
|
|
|
36116
36618
|
const VIDYAFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
36117
36619
|
? { register: () => {}, unregister: () => {} }
|
|
36118
36620
|
: new FinalizationRegistry(ptr => wasm.__wbg_vidya_free(ptr, 1));
|
|
36621
|
+
const VolatilityConeFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
36622
|
+
? { register: () => {}, unregister: () => {} }
|
|
36623
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_volatilitycone_free(ptr, 1));
|
|
36624
|
+
const VolatilityOfVolatilityFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
36625
|
+
? { register: () => {}, unregister: () => {} }
|
|
36626
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_volatilityofvolatility_free(ptr, 1));
|
|
36627
|
+
const VolatilityRatioFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
36628
|
+
? { register: () => {}, unregister: () => {} }
|
|
36629
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_volatilityratio_free(ptr, 1));
|
|
36119
36630
|
const VoltyStopFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
36120
36631
|
? { register: () => {}, unregister: () => {} }
|
|
36121
36632
|
: new FinalizationRegistry(ptr => wasm.__wbg_voltystop_free(ptr, 1));
|
package/wickra_wasm_bg.wasm
CHANGED
|
Binary file
|