ta-crypto 0.3.0 → 0.3.2

package/README.md

@@ -73,12 +73,21 @@ ws.on("message", (tick) => {
 ## Examples
 
 Real-world entry points live in `examples/`:
-- `examples/rsi-strategy.ts`
-- `examples/vwap-session.ts`
-- `examples/funding-arbitrage.ts`
+- `examples/rsi-strategy.mjs`
+- `examples/vwap-session.mjs`
+- `examples/funding-arbitrage.mjs`
+- `examples/rsi-technicalindicators-check.mjs` (external reference check)
 
 If you're using ta-crypto in production or experiments, feel free to add your example here.
 
+Run examples:
+
+```bash
+npm run example:all
+```
+
+Detailed commands and expected outputs: `examples/README.md`
+
 ## Compatibility
 
 `ta-crypto` now ships golden tests (`test/fixtures/golden.json`) to lock behavior across releases.
@@ -295,6 +304,10 @@ npm run version:patch
 npm run release
 ```
 
+## Trust and Verification
+
+For release integrity, compatibility policy, and verification workflow, see `docs/trust.md`.
+
 ## License
 
 MIT

package/dist/core/overlap.js

@@ -1,12 +1,9 @@
-import { assertSameLength, isNum, makeSeries, mean, stdev } from "./math.js";
+import { assertSameLength, isNum, makeSeries, mean } from "./math.js";
+import { rollingMean, rollingMeanStdDev } from "./rolling.js";
 export function sma(values, length = 14) {
-    const out = makeSeries(values.length);
     if (length <= 0)
-        return out;
-    for (let i = length - 1; i < values.length; i++) {
-        out[i] = mean(values, i - length + 1, i);
-    }
-    return out;
+        return makeSeries(values.length);
+    return rollingMean(values, length);
 }
 export function ema(values, length = 14) {
     const out = makeSeries(values.length);
@@ -90,11 +87,19 @@ export function vwap(high, low, close, volume, length) {
     return out;
 }
 export function bbands(values, length = 20, std = 2) {
-    const basis = sma(values, length);
-    const upper = makeSeries(values.length);
+    if (length <= 0) {
+        return {
+            basis: makeSeries(values.length),
+            upper: makeSeries(values.length),
+            lower: makeSeries(values.length)
+        };
+    }
+    const { mean: basis, stdDev: upper } = rollingMeanStdDev(values, length);
     const lower = makeSeries(values.length);
-    for (let i = length - 1; i < values.length; i++) {
-        const s = stdev(values, i - length + 1, i);
+    for (let i = 0; i < values.length; i++) {
+        const s = upper[i];
+        if (s === null)
+            continue;
         upper[i] = basis[i] + std * s;
         lower[i] = basis[i] - std * s;
     }

package/dist/core/rolling.d.ts

@@ -0,0 +1,62 @@
+export type RollingValue = number | null;
+export declare class RollingWindow {
+    readonly period: number;
+    private readonly values;
+    private cursor;
+    private count;
+    constructor(period: number);
+    get size(): number;
+    get ready(): boolean;
+    push(value: number): number | null;
+    reset(): void;
+}
+export declare class RollingSum {
+    private readonly window;
+    private total;
+    constructor(period: number);
+    get ready(): boolean;
+    next(value: number): RollingValue;
+    reset(): void;
+}
+export declare class RollingMean {
+    readonly period: number;
+    private readonly sum;
+    constructor(period: number);
+    next(value: number): RollingValue;
+    reset(): void;
+}
+export declare class RollingStdDev {
+    readonly period: number;
+    private readonly window;
+    private total;
+    private totalSquares;
+    constructor(period: number);
+    next(value: number): RollingValue;
+    reset(): void;
+}
+declare class RollingExtremum {
+    private readonly period;
+    private readonly compare;
+    private readonly deque;
+    private head;
+    private index;
+    constructor(period: number, compare: (candidate: number, tail: number) => boolean);
+    next(value: number): RollingValue;
+    reset(): void;
+}
+export declare class RollingMin extends RollingExtremum {
+    constructor(period: number);
+}
+export declare class RollingMax extends RollingExtremum {
+    constructor(period: number);
+}
+export declare function rollingSum(values: number[], period: number): RollingValue[];
+export declare function rollingMean(values: number[], period: number): RollingValue[];
+export declare function rollingStdDev(values: number[], period: number): RollingValue[];
+export declare function rollingMeanStdDev(values: number[], period: number): {
+    mean: RollingValue[];
+    stdDev: RollingValue[];
+};
+export declare function rollingMin(values: number[], period: number): RollingValue[];
+export declare function rollingMax(values: number[], period: number): RollingValue[];
+export {};

package/dist/core/rolling.js

@@ -0,0 +1,214 @@
+function assertPeriod(period) {
+    if (!Number.isInteger(period) || period <= 0) {
+        throw new Error("period must be a positive integer");
+    }
+}
+function assertValue(value) {
+    if (!Number.isFinite(value)) {
+        throw new Error("value must be a finite number");
+    }
+}
+export class RollingWindow {
+    constructor(period) {
+        this.cursor = 0;
+        this.count = 0;
+        assertPeriod(period);
+        this.period = period;
+        this.values = new Array(period);
+    }
+    get size() {
+        return this.count;
+    }
+    get ready() {
+        return this.count === this.period;
+    }
+    push(value) {
+        assertValue(value);
+        const removed = this.ready ? this.values[this.cursor] : null;
+        this.values[this.cursor] = value;
+        this.cursor = (this.cursor + 1) % this.period;
+        if (this.count < this.period)
+            this.count += 1;
+        return removed;
+    }
+    reset() {
+        this.cursor = 0;
+        this.count = 0;
+    }
+}
+export class RollingSum {
+    constructor(period) {
+        this.total = 0;
+        this.window = new RollingWindow(period);
+    }
+    get ready() {
+        return this.window.ready;
+    }
+    next(value) {
+        const removed = this.window.push(value);
+        this.total += value - (removed ?? 0);
+        return this.ready ? this.total : null;
+    }
+    reset() {
+        this.window.reset();
+        this.total = 0;
+    }
+}
+export class RollingMean {
+    constructor(period) {
+        assertPeriod(period);
+        this.period = period;
+        this.sum = new RollingSum(period);
+    }
+    next(value) {
+        const total = this.sum.next(value);
+        return total === null ? null : total / this.period;
+    }
+    reset() {
+        this.sum.reset();
+    }
+}
+export class RollingStdDev {
+    constructor(period) {
+        this.total = 0;
+        this.totalSquares = 0;
+        assertPeriod(period);
+        this.period = period;
+        this.window = new RollingWindow(period);
+    }
+    next(value) {
+        const removed = this.window.push(value);
+        this.total += value - (removed ?? 0);
+        this.totalSquares += value * value - (removed === null ? 0 : removed * removed);
+        if (!this.window.ready)
+            return null;
+        const mean = this.total / this.period;
+        const variance = Math.max(0, this.totalSquares / this.period - mean * mean);
+        return Math.sqrt(variance);
+    }
+    reset() {
+        this.window.reset();
+        this.total = 0;
+        this.totalSquares = 0;
+    }
+}
+class RollingExtremum {
+    constructor(period, compare) {
+        this.deque = [];
+        this.head = 0;
+        this.index = -1;
+        assertPeriod(period);
+        this.period = period;
+        this.compare = compare;
+    }
+    next(value) {
+        assertValue(value);
+        this.index += 1;
+        const firstValid = this.index - this.period + 1;
+        while (this.head < this.deque.length && this.deque[this.head].index < firstValid)
+            this.head += 1;
+        while (this.deque.length > this.head && this.compare(value, this.deque[this.deque.length - 1].value)) {
+            this.deque.pop();
+        }
+        this.deque.push({ index: this.index, value });
+        if (this.head > 64 && this.head * 2 > this.deque.length) {
+            this.deque.splice(0, this.head);
+            this.head = 0;
+        }
+        return this.index + 1 < this.period ? null : this.deque[this.head].value;
+    }
+    reset() {
+        this.deque.length = 0;
+        this.head = 0;
+        this.index = -1;
+    }
+}
+export class RollingMin extends RollingExtremum {
+    constructor(period) {
+        super(period, (candidate, tail) => candidate <= tail);
+    }
+}
+export class RollingMax extends RollingExtremum {
+    constructor(period) {
+        super(period, (candidate, tail) => candidate >= tail);
+    }
+}
+function collect(values, engine) {
+    return values.map(value => engine.next(value));
+}
+export function rollingSum(values, period) {
+    assertPeriod(period);
+    const out = new Array(values.length).fill(null);
+    let total = 0;
+    for (let i = 0; i < values.length; i++) {
+        total += values[i];
+        if (i >= period)
+            total -= values[i - period];
+        if (i >= period - 1)
+            out[i] = total;
+    }
+    return out;
+}
+export function rollingMean(values, period) {
+    assertPeriod(period);
+    const out = new Array(values.length).fill(null);
+    let total = 0;
+    for (let i = 0; i < values.length; i++) {
+        total += values[i];
+        if (i >= period)
+            total -= values[i - period];
+        if (i >= period - 1)
+            out[i] = total / period;
+    }
+    return out;
+}
+export function rollingStdDev(values, period) {
+    assertPeriod(period);
+    const out = new Array(values.length).fill(null);
+    let total = 0;
+    let totalSquares = 0;
+    for (let i = 0; i < values.length; i++) {
+        const value = values[i];
+        total += value;
+        totalSquares += value * value;
+        if (i >= period) {
+            const removed = values[i - period];
+            total -= removed;
+            totalSquares -= removed * removed;
+        }
+        if (i >= period - 1) {
+            const mean = total / period;
+            out[i] = Math.sqrt(Math.max(0, totalSquares / period - mean * mean));
+        }
+    }
+    return out;
+}
+export function rollingMeanStdDev(values, period) {
+    assertPeriod(period);
+    const mean = new Array(values.length).fill(null);
+    const stdDev = new Array(values.length).fill(null);
+    let total = 0;
+    let totalSquares = 0;
+    for (let i = 0; i < values.length; i++) {
+        const value = values[i];
+        total += value;
+        totalSquares += value * value;
+        if (i >= period) {
+            const removed = values[i - period];
+            total -= removed;
+            totalSquares -= removed * removed;
+        }
+        if (i >= period - 1) {
+            const currentMean = total / period;
+            mean[i] = currentMean;
+            stdDev[i] = Math.sqrt(Math.max(0, totalSquares / period - currentMean * currentMean));
+        }
+    }
+    return { mean, stdDev };
+}
+export function rollingMin(values, period) {
+    return collect(values, new RollingMin(period));
+}
+export function rollingMax(values, period) {
+    return collect(values, new RollingMax(period));
+}

package/dist/stateful.js

@@ -1,27 +1,18 @@
+import { RollingMean } from "./core/rolling.js";
 export function createSMA(period = 14) {
     if (period <= 0) {
         throw new Error("period must be > 0");
     }
-    const window = [];
-    let sum = 0;
+    const rolling = new RollingMean(period);
     return {
         next(value) {
             if (!Number.isFinite(value)) {
                 throw new Error("value must be a finite number");
             }
-            window.push(value);
-            sum += value;
-            if (window.length < period) {
-                return null;
-            }
-            if (window.length > period) {
-                sum -= window.shift();
-            }
-            return sum / period;
+            return rolling.next(value);
         },
         reset() {
-            window.length = 0;
-            sum = 0;
+            rolling.reset();
         }
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ta-crypto",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Technical analysis for crypto markets in Node.js",
   "type": "module",
   "license": "MIT",
@@ -50,11 +50,17 @@
     "generate:golden": "npm run build && node ./scripts/generate-golden.js",
     "generate:compat": "npm run build && node ./scripts/export-compat-vectors.js",
     "bench": "npm run build && node ./scripts/bench.js",
+    "bench:rolling": "npm run build && node ./scripts/bench-rolling.js",
     "test": "npm run build && node --test test/*.test.mjs",
     "test:golden": "npm run build && node --test test/golden.test.mjs",
     "test:compat:technicalindicators": "npm run generate:compat && node ./scripts/compare-technicalindicators.js",
     "test:compat:python": "npm run generate:compat && python ./scripts/compare-python-refs.py",
-    "test:compat": "npm run test:compat:technicalindicators && npm run test:compat:python"
+    "test:compat": "npm run test:compat:technicalindicators && npm run test:compat:python",
+    "example:rsi": "npm run build && node ./examples/rsi-strategy.mjs",
+    "example:vwap": "npm run build && node ./examples/vwap-session.mjs",
+    "example:funding": "npm run build && node ./examples/funding-arbitrage.mjs",
+    "example:rsi:compat": "npm run build && node ./examples/rsi-technicalindicators-check.mjs",
+    "example:all": "npm run example:rsi && npm run example:vwap && npm run example:funding && npm run example:rsi:compat"
   },
   "devDependencies": {
     "rimraf": "^5.0.5",