openalgo-script 0.1.0-alpha.0 → 0.2.0

package/dist/core/stdlib/series/statistics.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Order statistics and the two joint statistics.
+ *
+ * `percentile` interpolates linearly between the two ranks either side, which
+ * `stdlib.md` section 9 states. The nearest rank method, which returns an
+ * actual member of the lookback, is the other common choice and gives a visibly
+ * different answer for an even length lookback; it is not what is specified here.
+ *
+ * `covariance` and `correlation` are the population forms, and both are taken
+ * in two passes: the mean first, then the deviations from it. The single pass
+ * arrangement, summing squares and cross products and subtracting at the end,
+ * needs one fewer pass and loses most of its significant digits when the values
+ * are large and their spread is small, which is exactly what a price series is.
+ * `stdlib.md` fixes neither arrangement, so this one is chosen and stated.
+ */
+import type { Series, StateRecord, Tail, Value } from '../values/index.js';
+import type { Pair } from './changes.js';
+/**
+ * `percentile(src, len, p)`: the value at percentile `p` of the lookback,
+ * linearly interpolated, from bar `len - 1`.
+ */
+export declare function percentileStep(state: StateRecord, key: string, value: Value, len: number | null, p: number | null): Value;
+/** `percentile(src, len, p)` as a tail. */
+export declare function percentileTail(len: number, p: number): Tail<Value, Value>;
+/** `percentile(src, len, p)` over a whole series. */
+export declare function percentile(src: Series, len: number, p: number): Value[];
+/**
+ * `median(src, len)`: the middle value of the lookback, from bar `len - 1`.
+ *
+ * The 50th percentile by the same interpolation, so an even length lookback is
+ * the mean of its two middles rather than one of them chosen by a rule nobody
+ * remembers.
+ */
+export declare function medianTail(len: number): Tail<Value, Value>;
+/** `median(src, len)` over a whole series. */
+export declare function median(src: Series, len: number): Value[];
+/**
+ * `percentRank(src, len)`: what percentage of the lookback this bar's value
+ * exceeds, from bar `len - 1`.
+ *
+ * The lookback is the last `len` bars including this one, which is what the
+ * declared warmup of bar `len - 1` says: a lookback of the `len` bars before this
+ * one would not have its first answer until bar `len`. This bar is therefore
+ * one of the values counted, so the reading runs from `100 / len` to 100 rather
+ * than from 0.
+ */
+export declare function percentRankStep(state: StateRecord, key: string, value: Value, len: number | null): Value;
+/** `percentRank(src, len)` as a tail. */
+export declare function percentRankTail(len: number): Tail<Value, Value>;
+/** `percentRank(src, len)` over a whole series. */
+export declare function percentRank(src: Series, len: number): Value[];
+/** `covariance(a, b, len)`: the population covariance, from bar `len - 1`. */
+export declare function covarianceStep(state: StateRecord, key: string, pair: Pair, len: number | null): Value;
+/** `correlation(a, b, len)`: linear correlation, -1 to 1, from bar `len - 1`. */
+export declare function correlationStep(state: StateRecord, key: string, pair: Pair, len: number | null): Value;
+/** `covariance(a, b, len)` as a tail. */
+export declare function covarianceTail(len: number): Tail<Pair, Value>;
+/** `correlation(a, b, len)` as a tail. */
+export declare function correlationTail(len: number): Tail<Pair, Value>;
+/** `covariance(a, b, len)` over whole series. */
+export declare function covariance(a: Series, b: Series, len: number): Value[];
+/** `correlation(a, b, len)` over whole series. */
+export declare function correlation(a: Series, b: Series, len: number): Value[];
+//# sourceMappingURL=statistics.d.ts.map

package/dist/core/stdlib/series/statistics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.d.ts","sourceRoot":"","sources":["../../../../src/core/stdlib/series/statistics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAG3E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AASzC;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,GAAG,IAAI,EAClB,CAAC,EAAE,MAAM,GAAG,IAAI,GACf,KAAK,CAaP;AAED,2CAA2C;AAC3C,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAEzE;AAED,qDAAqD;AACrD,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,EAAE,CAEvE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAE1D;AAED,8CAA8C;AAC9C,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE,CAExD;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,KAAK,CAUP;AAED,yCAAyC;AACzC,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAE/D;AAED,mDAAmD;AACnD,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE,CAE7D;AAmDD,8EAA8E;AAC9E,wBAAgB,cAAc,CAC5B,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,KAAK,CAEP;AAED,iFAAiF;AACjF,wBAAgB,eAAe,CAC7B,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,KAAK,CAEP;AAED,yCAAyC;AACzC,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAE7D;AAED,0CAA0C;AAC1C,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAE9D;AAMD,iDAAiD;AACjD,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE,CAErE;AAED,kDAAkD;AAClD,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE,CAEtE"}

package/dist/core/stdlib/series/statistics.js

@@ -0,0 +1,148 @@
+import { NONE, fold, result, ring, tailOf } from '../values/index.js';
+/** The lookback's values, oldest first, as plain numbers. */
+function ordered(read, len) {
+    const values = [];
+    for (let back = len - 1; back >= 0; back -= 1)
+        values.push(read(back));
+    return values;
+}
+/**
+ * `percentile(src, len, p)`: the value at percentile `p` of the lookback,
+ * linearly interpolated, from bar `len - 1`.
+ */
+export function percentileStep(state, key, value, len, p) {
+    const lookback = ring(state, key, len);
+    lookback.push(value);
+    if (len === null || p === null || !lookback.complete())
+        return NONE;
+    if (!(p >= 0 && p <= 100))
+        return NONE;
+    const sorted = ordered((back) => lookback.at(back), len).sort((a, b) => a - b);
+    const rank = (p / 100) * (len - 1);
+    const below = Math.floor(rank);
+    const above = below + 1;
+    const low = sorted[below];
+    if (above >= len)
+        return result(low);
+    const high = sorted[above];
+    return result(low + (rank - below) * (high - low));
+}
+/** `percentile(src, len, p)` as a tail. */
+export function percentileTail(len, p) {
+    return tailOf((state, value) => percentileStep(state, 'q', value, len, p));
+}
+/** `percentile(src, len, p)` over a whole series. */
+export function percentile(src, len, p) {
+    return fold(percentileTail(len, p), src);
+}
+/**
+ * `median(src, len)`: the middle value of the lookback, from bar `len - 1`.
+ *
+ * The 50th percentile by the same interpolation, so an even length lookback is
+ * the mean of its two middles rather than one of them chosen by a rule nobody
+ * remembers.
+ */
+export function medianTail(len) {
+    return percentileTail(len, 50);
+}
+/** `median(src, len)` over a whole series. */
+export function median(src, len) {
+    return fold(medianTail(len), src);
+}
+/**
+ * `percentRank(src, len)`: what percentage of the lookback this bar's value
+ * exceeds, from bar `len - 1`.
+ *
+ * The lookback is the last `len` bars including this one, which is what the
+ * declared warmup of bar `len - 1` says: a lookback of the `len` bars before this
+ * one would not have its first answer until bar `len`. This bar is therefore
+ * one of the values counted, so the reading runs from `100 / len` to 100 rather
+ * than from 0.
+ */
+export function percentRankStep(state, key, value, len) {
+    const lookback = ring(state, key, len);
+    lookback.push(value);
+    if (len === null || !lookback.complete())
+        return NONE;
+    const current = lookback.at(0);
+    let counted = 0;
+    for (let back = len - 1; back >= 0; back -= 1) {
+        if (lookback.at(back) <= current)
+            counted += 1;
+    }
+    return result((counted * 100) / len);
+}
+/** `percentRank(src, len)` as a tail. */
+export function percentRankTail(len) {
+    return tailOf((state, value) => percentRankStep(state, 'q', value, len));
+}
+/** `percentRank(src, len)` over a whole series. */
+export function percentRank(src, len) {
+    return fold(percentRankTail(len), src);
+}
+function moments(a, b, len) {
+    let sumA = 0;
+    let sumB = 0;
+    for (let index = 0; index < len; index += 1) {
+        sumA += a[index];
+        sumB += b[index];
+    }
+    const meanA = sumA / len;
+    const meanB = sumB / len;
+    let cross = 0;
+    let squaresA = 0;
+    let squaresB = 0;
+    for (let index = 0; index < len; index += 1) {
+        const deviationA = a[index] - meanA;
+        const deviationB = b[index] - meanB;
+        cross += deviationA * deviationB;
+        squaresA += deviationA * deviationA;
+        squaresB += deviationB * deviationB;
+    }
+    return { covariance: cross / len, varianceA: squaresA / len, varianceB: squaresB / len };
+}
+function jointStep(state, key, pair, len, want) {
+    const left = ring(state, `${key}a`, len);
+    const right = ring(state, `${key}b`, len);
+    left.push(pair.a);
+    right.push(pair.b);
+    if (len === null || !left.complete() || !right.complete())
+        return NONE;
+    const a = ordered((back) => left.at(back), len);
+    const b = ordered((back) => right.at(back), len);
+    const m = moments(a, b, len);
+    if (want === 'covariance')
+        return result(m.covariance);
+    const scale = Math.sqrt(m.varianceA) * Math.sqrt(m.varianceB);
+    if (scale === 0)
+        return NONE;
+    return result(m.covariance / scale);
+}
+/** `covariance(a, b, len)`: the population covariance, from bar `len - 1`. */
+export function covarianceStep(state, key, pair, len) {
+    return jointStep(state, key, pair, len, 'covariance');
+}
+/** `correlation(a, b, len)`: linear correlation, -1 to 1, from bar `len - 1`. */
+export function correlationStep(state, key, pair, len) {
+    return jointStep(state, key, pair, len, 'correlation');
+}
+/** `covariance(a, b, len)` as a tail. */
+export function covarianceTail(len) {
+    return tailOf((state, pair) => covarianceStep(state, 'q', pair, len));
+}
+/** `correlation(a, b, len)` as a tail. */
+export function correlationTail(len) {
+    return tailOf((state, pair) => correlationStep(state, 'q', pair, len));
+}
+function pairs(a, b) {
+    return a.map((value, index) => ({ a: value, b: b[index] ?? NONE }));
+}
+/** `covariance(a, b, len)` over whole series. */
+export function covariance(a, b, len) {
+    return fold(covarianceTail(len), pairs(a, b));
+}
+/** `correlation(a, b, len)` over whole series. */
+export function correlation(a, b, len) {
+    return fold(correlationTail(len), pairs(a, b));
+}
+//# sourceMappingURL=statistics.js.map

package/dist/core/stdlib/series/statistics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.js","sourceRoot":"","sources":["../../../../src/core/stdlib/series/statistics.ts"],"names":[],"mappings":"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"}

package/dist/core/stdlib/series/totals.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Totals and counts over a lookback, and the three functions that deliberately
+ * ignore absent bars.
+ *
+ * `sum` propagates absence, as every lookback function does. `sumSkip`,
+ * `avgSkip` and `countPresent` do not, and they say so in their names because
+ * a function that quietly ignored a gap would report a total over a lookback it
+ * never had.
+ */
+import type { Flag, Flags, Series, StateRecord, Tail, Value } from '../values/index.js';
+/** `sum(src, len)`: the total over the lookback, from bar `len - 1`. */
+export declare function sumStep(state: StateRecord, key: string, value: Value, len: number | null): Value;
+/** `sum(src, len)` as a tail. */
+export declare function sumTail(len: number): Tail<Value, Value>;
+/** `sum(src, len)` over a whole series. */
+export declare function sum(src: Series, len: number): Value[];
+/**
+ * `cum(src)`: the running total from the first bar, from bar 0.
+ *
+ * An absent bar produces an absent bar out and leaves the total where it was.
+ * The alternatives are both wrong: treating absence as zero would report a
+ * total over bars that had no value, and propagating it into the total would
+ * end the series permanently at the first gap.
+ */
+export declare function cumStep(state: StateRecord, key: string, value: Value): Value;
+/** `cum(src)` as a tail. */
+export declare function cumTail(): Tail<Value, Value>;
+/** `cum(src)` over a whole series. */
+export declare function cum(src: Series): Value[];
+/**
+ * `count(cond, len)`: how many of the last `len` bars the condition held on,
+ * from bar `len - 1`.
+ *
+ * An absent condition is a condition that did not hold, matching the rule that
+ * absence is false at a branch (`language.md` section 6). Propagating it
+ * instead would make a count over a condition built from an average absent for
+ * a second warmup on top of the average's own.
+ */
+export declare function countStep(state: StateRecord, key: string, cond: Flag, len: number | null): Value;
+/** `count(cond, len)` as a tail. */
+export declare function countTail(len: number): Tail<Flag, Value>;
+/** `count(cond, len)` over a whole series. */
+export declare function count(cond: Flags, len: number): Value[];
+/** `sumSkip(src, len)`: the total over the lookback, ignoring absent bars. */
+export declare function sumSkipStep(state: StateRecord, key: string, value: Value, len: number | null): Value;
+/** `sumSkip(src, len)` as a tail. */
+export declare function sumSkipTail(len: number): Tail<Value, Value>;
+/** `sumSkip(src, len)` over a whole series. */
+export declare function sumSkip(src: Series, len: number): Value[];
+/** `countPresent(src, len)`: how many bars of the lookback had a value. */
+export declare function countPresentStep(state: StateRecord, key: string, value: Value, len: number | null): Value;
+/** `countPresent(src, len)` as a tail. */
+export declare function countPresentTail(len: number): Tail<Value, Value>;
+/** `countPresent(src, len)` over a whole series. */
+export declare function countPresent(src: Series, len: number): Value[];
+/**
+ * `avgSkip(src, len)`: the mean over the lookback, ignoring absent bars.
+ *
+ * A lookback with nothing present in it is absent, not zero: there is no mean of
+ * no values, and a division by zero is absence by the rule of `stdlib.md`
+ * section 2.4.
+ */
+export declare function avgSkipStep(state: StateRecord, key: string, value: Value, len: number | null): Value;
+/** `avgSkip(src, len)` as a tail. */
+export declare function avgSkipTail(len: number): Tail<Value, Value>;
+/** `avgSkip(src, len)` over a whole series. */
+export declare function avgSkip(src: Series, len: number): Value[];
+//# sourceMappingURL=totals.d.ts.map

package/dist/core/stdlib/series/totals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"totals.d.ts","sourceRoot":"","sources":["../../../../src/core/stdlib/series/totals.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAGxF,wEAAwE;AACxE,wBAAgB,OAAO,CACrB,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,KAAK,CAIP;AAED,iCAAiC;AACjC,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAEvD;AAED,2CAA2C;AAC3C,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE,CAErD;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,KAAK,CAK5E;AAED,4BAA4B;AAC5B,wBAAgB,OAAO,IAAI,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAE5C;AAED,sCAAsC;AACtC,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE,CAExC;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,KAAK,CAIP;AAED,oCAAoC;AACpC,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAExD;AAED,8CAA8C;AAC9C,wBAAgB,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE,CAEvD;AAED,8EAA8E;AAC9E,wBAAgB,WAAW,CACzB,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,KAAK,CAIP;AAED,qCAAqC;AACrC,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAE3D;AAED,+CAA+C;AAC/C,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE,CAEzD;AAED,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,KAAK,CAIP;AAED,0CAA0C;AAC1C,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAEhE;AAED,oDAAoD;AACpD,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE,CAE9D;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,KAAK,CAQP;AAED,qCAAqC;AACrC,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAE3D;AAED,+CAA+C;AAC/C,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE,CAEzD"}

package/dist/core/stdlib/series/totals.js

@@ -0,0 +1,115 @@
+import { NONE, fold, isPresent, result, ring, slot, tailOf } from '../values/index.js';
+/** `sum(src, len)`: the total over the lookback, from bar `len - 1`. */
+export function sumStep(state, key, value, len) {
+    const lookback = ring(state, key, len);
+    lookback.push(value);
+    return lookback.sum();
+}
+/** `sum(src, len)` as a tail. */
+export function sumTail(len) {
+    return tailOf((state, value) => sumStep(state, 'q', value, len));
+}
+/** `sum(src, len)` over a whole series. */
+export function sum(src, len) {
+    return fold(sumTail(len), src);
+}
+/**
+ * `cum(src)`: the running total from the first bar, from bar 0.
+ *
+ * An absent bar produces an absent bar out and leaves the total where it was.
+ * The alternatives are both wrong: treating absence as zero would report a
+ * total over bars that had no value, and propagating it into the total would
+ * end the series permanently at the first gap.
+ */
+export function cumStep(state, key, value) {
+    if (!isPresent(value))
+        return NONE;
+    const total = slot(state, key, 0) + value;
+    state[key] = total;
+    return result(total);
+}
+/** `cum(src)` as a tail. */
+export function cumTail() {
+    return tailOf((state, value) => cumStep(state, 't', value));
+}
+/** `cum(src)` over a whole series. */
+export function cum(src) {
+    return fold(cumTail(), src);
+}
+/**
+ * `count(cond, len)`: how many of the last `len` bars the condition held on,
+ * from bar `len - 1`.
+ *
+ * An absent condition is a condition that did not hold, matching the rule that
+ * absence is false at a branch (`language.md` section 6). Propagating it
+ * instead would make a count over a condition built from an average absent for
+ * a second warmup on top of the average's own.
+ */
+export function countStep(state, key, cond, len) {
+    const lookback = ring(state, key, len);
+    lookback.push(cond === true ? 1 : 0);
+    return lookback.sum();
+}
+/** `count(cond, len)` as a tail. */
+export function countTail(len) {
+    return tailOf((state, cond) => countStep(state, 'q', cond, len));
+}
+/** `count(cond, len)` over a whole series. */
+export function count(cond, len) {
+    return fold(countTail(len), cond);
+}
+/** `sumSkip(src, len)`: the total over the lookback, ignoring absent bars. */
+export function sumSkipStep(state, key, value, len) {
+    const lookback = ring(state, key, len);
+    lookback.push(value);
+    return lookback.sumPresent();
+}
+/** `sumSkip(src, len)` as a tail. */
+export function sumSkipTail(len) {
+    return tailOf((state, value) => sumSkipStep(state, 'q', value, len));
+}
+/** `sumSkip(src, len)` over a whole series. */
+export function sumSkip(src, len) {
+    return fold(sumSkipTail(len), src);
+}
+/** `countPresent(src, len)`: how many bars of the lookback had a value. */
+export function countPresentStep(state, key, value, len) {
+    const lookback = ring(state, key, len);
+    lookback.push(value);
+    return lookback.filled() ? lookback.presentCount() : NONE;
+}
+/** `countPresent(src, len)` as a tail. */
+export function countPresentTail(len) {
+    return tailOf((state, value) => countPresentStep(state, 'q', value, len));
+}
+/** `countPresent(src, len)` over a whole series. */
+export function countPresent(src, len) {
+    return fold(countPresentTail(len), src);
+}
+/**
+ * `avgSkip(src, len)`: the mean over the lookback, ignoring absent bars.
+ *
+ * A lookback with nothing present in it is absent, not zero: there is no mean of
+ * no values, and a division by zero is absence by the rule of `stdlib.md`
+ * section 2.4.
+ */
+export function avgSkipStep(state, key, value, len) {
+    const lookback = ring(state, key, len);
+    lookback.push(value);
+    if (!lookback.filled())
+        return NONE;
+    const counted = lookback.presentCount();
+    const total = lookback.sumPresent();
+    if (counted === 0 || !isPresent(total))
+        return NONE;
+    return result(total / counted);
+}
+/** `avgSkip(src, len)` as a tail. */
+export function avgSkipTail(len) {
+    return tailOf((state, value) => avgSkipStep(state, 'q', value, len));
+}
+/** `avgSkip(src, len)` over a whole series. */
+export function avgSkip(src, len) {
+    return fold(avgSkipTail(len), src);
+}
+//# sourceMappingURL=totals.js.map

package/dist/core/stdlib/series/totals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"totals.js","sourceRoot":"","sources":["../../../../src/core/stdlib/series/totals.ts"],"names":[],"mappings":"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"}

package/dist/core/stdlib/trend/directional.d.ts

@@ -0,0 +1,69 @@
+/**
+ * `adx(diLen, adxLen)`, `aroon(len)` and `ichimoku(convLen, baseLen, spanLen)`:
+ * how strong the trend is, which side owns it, and the five line frame.
+ *
+ * Each is written once, as a step over a state region, and its tail is that
+ * step over a region of its own. An engine calls the same step against the
+ * region it holds for the call site, so there is no second arrangement of the
+ * arithmetic anywhere for the two to drift apart in.
+ */
+import type { Bar, StateRecord, Tail, Value } from '../values/index.js';
+import type { Gap } from '../volatility/index.js';
+/**
+ * `adx(diLen, adxLen)`: `[adx, plusDI, minusDI]`, elements 1 and 2 from bar
+ * `diLen` and element 0 from bar `diLen + adxLen - 1`.
+ *
+ * Directional movement is the part of this bar's range that lies outside the
+ * previous bar's, on whichever side is larger. It needs the bar before it, so
+ * the smoothing's lookback is bars 1 to `diLen` and the first reading is at bar
+ * `diLen`. The true range in the denominator uses the gap-aware form for the
+ * same reason, so all three smoothed quantities cover the same bars: seeding
+ * one of them a bar earlier than the other two would bias every reading after
+ * it while still looking entirely plausible.
+ *
+ * The previous bar's two extremes are held in the region, because they are the
+ * arithmetic's own history. The previous close is not: it arrives with the gap,
+ * for the reason `range.ts` sets out.
+ */
+export declare function adxStep(state: StateRecord, key: string, gap: Gap, diLen: number | null, adxLen: number | null): Value[];
+/** `adx(diLen, adxLen)` as a tail. */
+export declare function adxTail(diLen?: number, adxLen?: number): Tail<Bar, Value[]>;
+/** `adx(diLen, adxLen)` over a run of bars. */
+export declare function adx(bars: readonly Bar[], diLen?: number, adxLen?: number): Value[][];
+/**
+ * `aroon(len)`: `[up, down]`, both from bar `len`.
+ *
+ * How recently the lookback's high and low were set, as a percentage: 100 when it
+ * was this bar, 0 when it was `len` bars ago. The lookback is `len + 1` bars
+ * wide, because a reading of 0 has to be reachable and an extreme `len` bars
+ * back has to still be inside the lookback for that. That extra bar is where the
+ * declared warmup of bar `len` rather than bar `len - 1` comes from.
+ */
+export declare function aroonStep(state: StateRecord, key: string, high: Value, low: Value, len: number | null): Value[];
+/** `aroon(len)` as a tail. */
+export declare function aroonTail(len?: number): Tail<Bar, Value[]>;
+/** `aroon(len)` over a run of bars. */
+export declare function aroon(bars: readonly Bar[], len?: number): Value[][];
+/**
+ * `ichimoku(convLen, baseLen, spanLen)`: `[conversion, base, spanA, spanB,
+ * lagging]`, at bars `convLen - 1`, `baseLen - 1`, `baseLen - 1`,
+ * `spanLen - 1` and `baseLen - 1`.
+ *
+ * Each of the first four lines is the midpoint of a lookback's outright high and
+ * low, over a different length. **The spans are returned undisplaced, at the
+ * bar they are computed on**, per `stdlib.md` section 4: a study draws them
+ * forward with the plot's `offset` argument, because a series that has already
+ * been shifted cannot be compared with anything else in the script without
+ * shifting it back.
+ *
+ * The lagging line is this bar's close, and it is drawn backward by the same
+ * plot argument. It is absent until bar `baseLen - 1`, which is the warmup the
+ * specification declares for it, and which is the first bar there is enough
+ * history for the displacement to land on.
+ */
+export declare function ichimokuStep(state: StateRecord, key: string, bar: Bar, convLen: number | null, baseLen: number | null, spanLen: number | null): Value[];
+/** `ichimoku(convLen, baseLen, spanLen)` as a tail. */
+export declare function ichimokuTail(convLen?: number, baseLen?: number, spanLen?: number): Tail<Bar, Value[]>;
+/** `ichimoku(convLen, baseLen, spanLen)` over a run of bars. */
+export declare function ichimoku(bars: readonly Bar[], convLen?: number, baseLen?: number, spanLen?: number): Value[][];
+//# sourceMappingURL=directional.d.ts.map

package/dist/core/stdlib/trend/directional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directional.d.ts","sourceRoot":"","sources":["../../../../src/core/stdlib/trend/directional.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAIxE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAGlD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,MAAM,EAAE,MAAM,GAAG,IAAI,GACpB,KAAK,EAAE,CA4CT;AAED,sCAAsC;AACtC,wBAAgB,OAAO,CAAC,KAAK,SAAK,EAAE,MAAM,SAAK,GAAG,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,CAEnE;AAED,+CAA+C;AAC/C,wBAAgB,GAAG,CAAC,IAAI,EAAE,SAAS,GAAG,EAAE,EAAE,KAAK,SAAK,EAAE,MAAM,SAAK,GAAG,KAAK,EAAE,EAAE,CAE5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,KAAK,EACX,GAAG,EAAE,KAAK,EACV,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,KAAK,EAAE,CAQT;AAED,8BAA8B;AAC9B,wBAAgB,SAAS,CAAC,GAAG,SAAK,GAAG,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,CAEtD;AAED,uCAAuC;AACvC,wBAAgB,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,EAAE,EAAE,GAAG,SAAK,GAAG,KAAK,EAAE,EAAE,CAE/D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,OAAO,EAAE,MAAM,GAAG,IAAI,GACrB,KAAK,EAAE,CAST;AAED,uDAAuD;AACvD,wBAAgB,YAAY,CAAC,OAAO,SAAI,EAAE,OAAO,SAAK,EAAE,OAAO,SAAK,GAAG,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,CAExF;AAED,gEAAgE;AAChE,wBAAgB,QAAQ,CACtB,IAAI,EAAE,SAAS,GAAG,EAAE,EACpB,OAAO,SAAI,EACX,OAAO,SAAK,EACZ,OAAO,SAAK,GACX,KAAK,EAAE,EAAE,CAEX"}

package/dist/core/stdlib/trend/directional.js

@@ -0,0 +1,151 @@
+import { NONE, fold, held, isPresent, result, ring, tailOf } from '../values/index.js';
+import { rmaStep } from '../averages/index.js';
+import { extremeStep } from '../series/index.js';
+import { gapOf, trueRangeOf } from '../volatility/index.js';
+/**
+ * `adx(diLen, adxLen)`: `[adx, plusDI, minusDI]`, elements 1 and 2 from bar
+ * `diLen` and element 0 from bar `diLen + adxLen - 1`.
+ *
+ * Directional movement is the part of this bar's range that lies outside the
+ * previous bar's, on whichever side is larger. It needs the bar before it, so
+ * the smoothing's lookback is bars 1 to `diLen` and the first reading is at bar
+ * `diLen`. The true range in the denominator uses the gap-aware form for the
+ * same reason, so all three smoothed quantities cover the same bars: seeding
+ * one of them a bar earlier than the other two would bias every reading after
+ * it while still looking entirely plausible.
+ *
+ * The previous bar's two extremes are held in the region, because they are the
+ * arithmetic's own history. The previous close is not: it arrives with the gap,
+ * for the reason `range.ts` sets out.
+ */
+export function adxStep(state, key, gap, diLen, adxLen) {
+    const highKey = `${key}h`;
+    const lowKey = `${key}l`;
+    const seenKey = `${key}k`;
+    const beforeHigh = held(state, highKey);
+    const beforeLow = held(state, lowKey);
+    const started = state[seenKey] === true;
+    state[seenKey] = true;
+    state[highKey] = gap.high;
+    state[lowKey] = gap.low;
+    let upMove = NONE;
+    let downMove = NONE;
+    if (started &&
+        isPresent(gap.high) &&
+        isPresent(gap.low) &&
+        isPresent(beforeHigh) &&
+        isPresent(beforeLow)) {
+        const up = gap.high - beforeHigh;
+        const down = beforeLow - gap.low;
+        upMove = up > down && up > 0 ? result(up) : 0;
+        downMove = down > up && down > 0 ? result(down) : 0;
+    }
+    const trueRange = rmaStep(state, `${key}r`, trueRangeOf(gap, false), diLen);
+    const rise = rmaStep(state, `${key}u`, upMove, diLen);
+    const fall = rmaStep(state, `${key}d`, downMove, diLen);
+    let plus = NONE;
+    let minus = NONE;
+    if (isPresent(trueRange) && trueRange !== 0) {
+        if (isPresent(rise))
+            plus = result((rise / trueRange) * 100);
+        if (isPresent(fall))
+            minus = result((fall / trueRange) * 100);
+    }
+    let spread = NONE;
+    if (isPresent(plus) && isPresent(minus)) {
+        const total = plus + minus;
+        spread = total > 0 ? result((Math.abs(plus - minus) / total) * 100) : 0;
+    }
+    return [rmaStep(state, `${key}x`, spread, adxLen), plus, minus];
+}
+/** `adx(diLen, adxLen)` as a tail. */
+export function adxTail(diLen = 14, adxLen = 14) {
+    return tailOf((state, bar) => adxStep(state, '', gapOf(state, 'g', bar), diLen, adxLen));
+}
+/** `adx(diLen, adxLen)` over a run of bars. */
+export function adx(bars, diLen = 14, adxLen = 14) {
+    return fold(adxTail(diLen, adxLen), bars);
+}
+/**
+ * `aroon(len)`: `[up, down]`, both from bar `len`.
+ *
+ * How recently the lookback's high and low were set, as a percentage: 100 when it
+ * was this bar, 0 when it was `len` bars ago. The lookback is `len + 1` bars
+ * wide, because a reading of 0 has to be reachable and an extreme `len` bars
+ * back has to still be inside the lookback for that. That extra bar is where the
+ * declared warmup of bar `len` rather than bar `len - 1` comes from.
+ */
+export function aroonStep(state, key, high, low, len) {
+    const wide = len === null ? null : len + 1;
+    const highAge = extremeStep(state, `${key}h`, high, wide, true, true);
+    const lowAge = extremeStep(state, `${key}l`, low, wide, false, true);
+    if (len === null)
+        return [NONE, NONE];
+    const up = isPresent(highAge) ? result((100 * (len - highAge)) / len) : NONE;
+    const down = isPresent(lowAge) ? result((100 * (len - lowAge)) / len) : NONE;
+    return [up, down];
+}
+/** `aroon(len)` as a tail. */
+export function aroonTail(len = 14) {
+    return tailOf((state, bar) => aroonStep(state, '', bar.high, bar.low, len));
+}
+/** `aroon(len)` over a run of bars. */
+export function aroon(bars, len = 14) {
+    return fold(aroonTail(len), bars);
+}
+/**
+ * `ichimoku(convLen, baseLen, spanLen)`: `[conversion, base, spanA, spanB,
+ * lagging]`, at bars `convLen - 1`, `baseLen - 1`, `baseLen - 1`,
+ * `spanLen - 1` and `baseLen - 1`.
+ *
+ * Each of the first four lines is the midpoint of a lookback's outright high and
+ * low, over a different length. **The spans are returned undisplaced, at the
+ * bar they are computed on**, per `stdlib.md` section 4: a study draws them
+ * forward with the plot's `offset` argument, because a series that has already
+ * been shifted cannot be compared with anything else in the script without
+ * shifting it back.
+ *
+ * The lagging line is this bar's close, and it is drawn backward by the same
+ * plot argument. It is absent until bar `baseLen - 1`, which is the warmup the
+ * specification declares for it, and which is the first bar there is enough
+ * history for the displacement to land on.
+ */
+export function ichimokuStep(state, key, bar, convLen, baseLen, spanLen) {
+    const near = midpointStep(state, `${key}c`, bar, convLen);
+    const middle = midpointStep(state, `${key}b`, bar, baseLen);
+    const leading = isPresent(near) && isPresent(middle) ? result((near + middle) / 2) : NONE;
+    const behind = midpointStep(state, `${key}s`, bar, spanLen);
+    const closes = ring(state, `${key}g`, baseLen);
+    closes.push(bar.close);
+    const lagging = closes.filled() ? closes.at(0) : NONE;
+    return [near, middle, leading, behind, lagging];
+}
+/** `ichimoku(convLen, baseLen, spanLen)` as a tail. */
+export function ichimokuTail(convLen = 9, baseLen = 26, spanLen = 52) {
+    return tailOf((state, bar) => ichimokuStep(state, '', bar, convLen, baseLen, spanLen));
+}
+/** `ichimoku(convLen, baseLen, spanLen)` over a run of bars. */
+export function ichimoku(bars, convLen = 9, baseLen = 26, spanLen = 52) {
+    return fold(ichimokuTail(convLen, baseLen, spanLen), bars);
+}
+/** The midpoint of a lookback's outright high and low. */
+function midpointStep(state, key, bar, len) {
+    const highs = ring(state, `${key}h`, len);
+    const lows = ring(state, `${key}l`, len);
+    highs.push(bar.high);
+    lows.push(bar.low);
+    if (len === null || !highs.complete() || !lows.complete())
+        return NONE;
+    let top = highs.at(len - 1);
+    let bottom = lows.at(len - 1);
+    for (let back = len - 2; back >= 0; back -= 1) {
+        const high = highs.at(back);
+        const low = lows.at(back);
+        if (high > top)
+            top = high;
+        if (low < bottom)
+            bottom = low;
+    }
+    return result((top + bottom) / 2);
+}
+//# sourceMappingURL=directional.js.map