openalgo-script 0.1.0-alpha.1 → 0.4.0

package/dist/core/accounting/monthly.js

@@ -0,0 +1,99 @@
+/**
+ * The months a run passed through, in the order it passed through them.
+ *
+ * **A month holds the change in equity across the closes inside it.** The first
+ * point of the curve has nothing before it to be compared with, so it opens the
+ * table rather than contributing to it, and every later point contributes what
+ * it moved from the point before. The consequence is an identity rather than a
+ * claim: the months add up to the equity at the last point less the equity at
+ * the first, and nothing that happened during the warmup is attributed to a
+ * month it did not happen in.
+ *
+ * `returnPercent` is that change over the equity at the month's first bar,
+ * which is the basis this table states and the reason the figure is a fraction
+ * rather than a fraction times a hundred: `drawdownPercent` beside it is
+ * `drawdown / peak`, and one report with two conventions is a report a reader
+ * has to check every figure of.
+ *
+ * `trades` counts the trades that closed inside the month, by the time they
+ * closed. An open trade is in no month, because the month it will be counted in
+ * is not decided yet.
+ *
+ * **A point with no time is in no month.** A bucket is a calendar fact and a
+ * bar with no time states no calendar, so such a point carries its change into
+ * the month in force rather than opening one, and where none is in force it is
+ * outside the table altogether. That is the honest reading: bucketing it by the
+ * month that happened to come before would put money in a month on the strength
+ * of nothing.
+ */
+export function monthlyOver(equity, trades) {
+    const buckets = [];
+    let previous;
+    let current;
+    for (const point of equity) {
+        const at = monthOf(point.time);
+        if (at !== null && (current === undefined || current.year !== at.year || current.month !== at.month)) {
+            // The equity this month started from, which is where the previous month
+            // left the account and not where this one's first bar closed. Taking the
+            // opening point's own equity put the month's first move into the
+            // numerator and into the denominator at once: a February that doubled a
+            // thousand pounds reported fifty percent, because the gain was divided by
+            // the two thousand it had already produced.
+            current = {
+                year: at.year,
+                month: at.month,
+                netProfit: 0,
+                basis: previous === undefined ? point.equity : previous.equity,
+                trades: 0,
+            };
+            buckets.push(current);
+        }
+        if (previous !== undefined && current !== undefined) {
+            current.netProfit += point.equity - previous.equity;
+        }
+        previous = point;
+    }
+    for (const trade of trades) {
+        const at = monthOf(trade.closedAt);
+        if (at === null)
+            continue;
+        const bucket = buckets.find((one) => one.year === at.year && one.month === at.month);
+        if (bucket !== undefined)
+            bucket.trades += 1;
+    }
+    return buckets.map((one) => ({
+        year: one.year,
+        month: one.month,
+        netProfit: one.netProfit,
+        returnPercent: one.basis > 0 ? one.netProfit / one.basis : 0,
+        trades: one.trades,
+    }));
+}
+/**
+ * The calendar month an instant falls in, in UTC and in no other zone.
+ *
+ * Decomposed rather than formatted, so no locale, no zone table and no library
+ * is involved: the same instant produces the same month on every machine this
+ * ever runs on.
+ */
+function monthOf(time) {
+    if (time === null || !Number.isFinite(time) || Math.abs(time) > LATEST_INSTANT)
+        return null;
+    const at = new Date(time);
+    return { year: at.getUTCFullYear(), month: at.getUTCMonth() + 1 };
+}
+/**
+ * The furthest either way an instant can be and still name a month.
+ *
+ * A finite number outside it decomposes to NaN rather than throwing, and a NaN
+ * year never equals the next one, so every point opened a bucket of its own and
+ * a fifty thousand bar run produced fifty thousand rows of NaN. The canonical
+ * writer then threw a bare error with no code on them, out of core, on a path a
+ * host could not tell from an internal fault. The mistake that gets here is
+ * ordinary: bar times supplied in nanoseconds rather than milliseconds.
+ *
+ * A point whose time names no month contributes to no month, which is what an
+ * absent time already did.
+ */
+const LATEST_INSTANT = 8.64e15;
+//# sourceMappingURL=monthly.js.map

package/dist/core/accounting/monthly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"monthly.js","sourceRoot":"","sources":["../../../src/core/accounting/monthly.ts"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,WAAW,CACzB,MAA8B,EAC9B,MAAwB;IAExB,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,IAAI,QAAiC,CAAC;IACtC,IAAI,OAA2B,CAAC;IAEhC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,EAAE,KAAK,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,IAAI,IAAI,OAAO,CAAC,KAAK,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;YACrG,wEAAwE;YACxE,yEAAyE;YACzE,iEAAiE;YACjE,wEAAwE;YACxE,0EAA0E;YAC1E,4CAA4C;YAC5C,OAAO,GAAG;gBACR,IAAI,EAAE,EAAE,CAAC,IAAI;gBACb,KAAK,EAAE,EAAE,CAAC,KAAK;gBACf,SAAS,EAAE,CAAC;gBACZ,KAAK,EAAE,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM;gBAC9D,MAAM,EAAE,CAAC;aACV,CAAC;YACF,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACxB,CAAC;QACD,IAAI,QAAQ,KAAK,SAAS,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YACpD,OAAO,CAAC,SAAS,IAAI,KAAK,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;QACtD,CAAC;QACD,QAAQ,GAAG,KAAK,CAAC;IACnB,CAAC;IAED,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACnC,IAAI,EAAE,KAAK,IAAI;YAAE,SAAS;QAC1B,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,EAAE,CAAC,IAAI,IAAI,GAAG,CAAC,KAAK,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;QACrF,IAAI,MAAM,KAAK,SAAS;YAAE,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;IAC/C,CAAC;IAED,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QAC3B,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,aAAa,EAAE,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC5D,MAAM,EAAE,GAAG,CAAC,MAAM;KACnB,CAAC,CAAC,CAAC;AACN,CAAC;AAYD;;;;;;GAMG;AACH,SAAS,OAAO,CAAC,IAAmB;IAClC,IAAI,IAAI,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,cAAc;QAAE,OAAO,IAAI,CAAC;IAC5F,MAAM,EAAE,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1B,OAAO,EAAE,IAAI,EAAE,EAAE,CAAC,cAAc,EAAE,EAAE,KAAK,EAAE,EAAE,CAAC,WAAW,EAAE,GAAG,CAAC,EAAE,CAAC;AACpE,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,cAAc,GAAG,OAAO,CAAC"}

package/dist/core/accounting/report.d.ts

@@ -0,0 +1,38 @@
+import type { ChargeSchedule } from './charges.js';
+import type { EquityPoint } from './equity.js';
+import type { MonthlyReturn } from './monthly.js';
+import type { TradeMarker } from './markers.js';
+import type { BarMark, Contract, Money, RecordedFill } from './shapes.js';
+import type { Summary } from './statistics.js';
+import type { Trade } from './trades.js';
+/** Everything a run is reported as, and nothing a chart has to compute. */
+export interface Report {
+    readonly summary: Summary;
+    readonly trades: readonly Trade[];
+    readonly equity: readonly EquityPoint[];
+    readonly monthly: readonly MonthlyReturn[];
+    readonly markers: readonly TradeMarker[];
+}
+/**
+ * The whole report, folded from the fills, the bar closes and the schedule.
+ *
+ * **One pass, in one order, and the order is the result.** The fills are put in
+ * `seq` order once, here, and every fold below reads that same list: the
+ * charges are computed in it, the trades are built from it, the curve is marked
+ * along it and the markers come off it. A second ordering anywhere would be a
+ * report that is right to eleven digits and different in the twelfth on
+ * somebody else's engine, which is the failure this module is shaped to make
+ * impossible rather than unlikely.
+ *
+ * **A charge belongs to the fill that incurred it.** `chargeFor` rounds one
+ * fill's total once, and nothing here rounds it again or re-sums the collection
+ * in another order, so `sum(trade.charges)` and `summary.charges` are the same
+ * money and a test asserts it rather than a page claiming it.
+ *
+ * A run carried out under no schedule at all is charged nothing, which is a
+ * study of the strategy before costs and is a thing worth being able to ask
+ * for. It is not a default: `scheduleFromDeclaration` is what a run under the
+ * declaration's own commission uses, and the caller states which it wants.
+ */
+export declare function reportOf(fills: readonly RecordedFill[], marks: readonly BarMark[], schedule: ChargeSchedule | null, contract: Contract, capital: Money): Report;
+//# sourceMappingURL=report.d.ts.map

package/dist/core/accounting/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/core/accounting/report.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE1E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,2EAA2E;AAC3E,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,KAAK,EAAE,SAAS,OAAO,EAAE,EACzB,QAAQ,EAAE,cAAc,GAAG,IAAI,EAC/B,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,KAAK,GACb,MAAM,CAiBR"}

package/dist/core/accounting/report.js

@@ -0,0 +1,63 @@
+/**
+ * The report: what a run came to, folded from its fills and its bar closes.
+ *
+ * **The evaluation order is fixed here and nowhere else**, because a report
+ * that is right to eleven digits and different in the twelfth fails a
+ * conformance comparison months later on somebody else's engine, and the cause
+ * is always a line nobody thought was arithmetic. Fills in `seq` order, charge
+ * lines in declaration order, one rounding per fill total, no collection
+ * re-summed in another order, no dependence on a map's iteration order, no wall
+ * clock and no random number generator anywhere in this module.
+ *
+ * **What the report is not is read by a script.** The money entries of the
+ * `pos` namespace stay planned and go on refusing at the call. The moment a
+ * script can read its own equity mid-run, the money layer joins the execution
+ * path, and therefore joins the conformance surface, and every formula in this
+ * module has to be agreed by a second engine before a script may branch on it.
+ * This module computes the money after the fact from a record; whether a script
+ * may read it is a later decision. That this module imports no engine is the
+ * structural half of keeping that decision open: when it is taken, the engine
+ * calls this, and there is no second implementation to disagree with.
+ */
+import { chargeFor } from './charges.js';
+import { equityOver } from './equity.js';
+import { monthlyOver } from './monthly.js';
+import { markersOf } from './markers.js';
+import { summaryOf } from './statistics.js';
+import { tradesOf } from './trades.js';
+/**
+ * The whole report, folded from the fills, the bar closes and the schedule.
+ *
+ * **One pass, in one order, and the order is the result.** The fills are put in
+ * `seq` order once, here, and every fold below reads that same list: the
+ * charges are computed in it, the trades are built from it, the curve is marked
+ * along it and the markers come off it. A second ordering anywhere would be a
+ * report that is right to eleven digits and different in the twelfth on
+ * somebody else's engine, which is the failure this module is shaped to make
+ * impossible rather than unlikely.
+ *
+ * **A charge belongs to the fill that incurred it.** `chargeFor` rounds one
+ * fill's total once, and nothing here rounds it again or re-sums the collection
+ * in another order, so `sum(trade.charges)` and `summary.charges` are the same
+ * money and a test asserts it rather than a page claiming it.
+ *
+ * A run carried out under no schedule at all is charged nothing, which is a
+ * study of the strategy before costs and is a thing worth being able to ask
+ * for. It is not a default: `scheduleFromDeclaration` is what a run under the
+ * declaration's own commission uses, and the caller states which it wants.
+ */
+export function reportOf(fills, marks, schedule, contract, capital) {
+    const ordered = fills.slice().sort((a, b) => a.seq - b.seq);
+    const charges = ordered.map((fill) => schedule === null ? 0 : chargeFor(schedule, fill, contract).total);
+    const trades = tradesOf(ordered, charges, marks, contract);
+    const equity = equityOver(trades, marks, contract, capital);
+    const summary = summaryOf(trades, equity, contract, capital);
+    return {
+        summary,
+        trades,
+        equity,
+        monthly: monthlyOver(equity, trades),
+        markers: markersOf(ordered, trades),
+    };
+}
+//# sourceMappingURL=report.js.map

package/dist/core/accounting/report.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.js","sourceRoot":"","sources":["../../../src/core/accounting/report.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAYvC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,QAAQ,CACtB,KAA8B,EAC9B,KAAyB,EACzB,QAA+B,EAC/B,QAAkB,EAClB,OAAc;IAEd,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IAC5D,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACnC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,KAAK,CAClE,CAAC;IAEF,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC3D,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC5D,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAE7D,OAAO;QACL,OAAO;QACP,MAAM;QACN,MAAM;QACN,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC;QACpC,OAAO,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;KACpC,CAAC;AACJ,CAAC"}

package/dist/core/accounting/shapes.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The atoms the money is folded from: a fill, a contract and a bar's close.
+ *
+ * **Everything in this module is portable data.** No class, no function, no
+ * object reference, no absent field, no map and no date: a shape here is what
+ * `JSON.parse` gives back, so a report can be computed here, stored by a
+ * platform, sent to another process and recomputed there without this
+ * implementation being present. That is not a convenience. A run record is the
+ * conformance case a second engine is handed, and a case that can only be read
+ * by the engine that wrote it proves nothing about either.
+ *
+ * **A fill is the only thing money is folded from.** Not a position, not a
+ * ledger row, not a running total the engine happened to be holding: the fills
+ * the engine settled, in the order it settled them, each naming the position
+ * reference it moved and the size of that reference either side of the
+ * settlement. Every figure in a report is a function of that list and of the
+ * bars it is marked against, which is what makes a report reproducible from a
+ * record with no engine in the room.
+ */
+/**
+ * Money, in the contract's own currency.
+ *
+ * A number rather than a type of its own, because a type of its own would be a
+ * class and a class does not survive `JSON.parse`. The rounding is stated once,
+ * on the contract, and applied once per fill total.
+ */
+export type Money = number;
+/**
+ * The instrument facts a run was carried out under, as the host stated them.
+ *
+ * A snapshot rather than a reference. An instrument's lot size and tick size
+ * change, and a report recomputed months later under today's facts would be a
+ * different study wearing the same name, so the facts travel with the run.
+ */
+export interface Contract {
+    readonly symbol: string | null;
+    readonly exchange: string | null;
+    readonly currency: string;
+    readonly tickSize: number | null;
+    readonly lotSize: number | null;
+    /** Money per 1.0 of price per unit; 1 when the host states none. */
+    readonly pointValue: number;
+    /** Money rounding digits, half to even, once per fill total. */
+    readonly digits: number;
+}
+/** One settled fill. Every money figure is folded from these and nothing else. */
+export interface RecordedFill {
+    readonly seq: number;
+    readonly intentId: number;
+    readonly orderRef: string;
+    readonly tag: string;
+    readonly positionRef: number;
+    readonly side: 'buy' | 'sell';
+    /** Positive, this fill's own quantity. */
+    readonly units: number;
+    readonly price: number;
+    readonly barIndex: number;
+    readonly barTime: number | null;
+    readonly refSizeBefore: number;
+    readonly refSizeAfter: number;
+}
+/** One bar as the report marks against it. Close only: 17.4 marks to the close. */
+export interface BarMark {
+    readonly barIndex: number;
+    readonly time: number | null;
+    readonly close: number | null;
+    /** False for a warmup bar. */
+    readonly inReport: boolean;
+}
+//# sourceMappingURL=shapes.d.ts.map

package/dist/core/accounting/shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapes.d.ts","sourceRoot":"","sources":["../../../src/core/accounting/shapes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC;AAE3B;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,oEAAoE;IACpE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,kFAAkF;AAClF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;IAC9B,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,mFAAmF;AACnF,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,8BAA8B;IAC9B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B"}

package/dist/core/accounting/shapes.js

@@ -0,0 +1,21 @@
+/**
+ * The atoms the money is folded from: a fill, a contract and a bar's close.
+ *
+ * **Everything in this module is portable data.** No class, no function, no
+ * object reference, no absent field, no map and no date: a shape here is what
+ * `JSON.parse` gives back, so a report can be computed here, stored by a
+ * platform, sent to another process and recomputed there without this
+ * implementation being present. That is not a convenience. A run record is the
+ * conformance case a second engine is handed, and a case that can only be read
+ * by the engine that wrote it proves nothing about either.
+ *
+ * **A fill is the only thing money is folded from.** Not a position, not a
+ * ledger row, not a running total the engine happened to be holding: the fills
+ * the engine settled, in the order it settled them, each naming the position
+ * reference it moved and the size of that reference either side of the
+ * settlement. Every figure in a report is a function of that list and of the
+ * bars it is marked against, which is what makes a report reproducible from a
+ * record with no engine in the room.
+ */
+export {};
+//# sourceMappingURL=shapes.js.map

package/dist/core/accounting/shapes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapes.js","sourceRoot":"","sources":["../../../src/core/accounting/shapes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG"}

package/dist/core/accounting/statistics.d.ts

@@ -0,0 +1,75 @@
+import type { EquityPoint } from './equity.js';
+import type { Contract, Money } from './shapes.js';
+import type { Trade } from './trades.js';
+/** What the whole run came to. */
+export interface Summary {
+    readonly capital: Money;
+    readonly currency: string;
+    readonly netProfit: Money;
+    /** Sum of winning trades, before charges. */
+    readonly grossProfit: Money;
+    /**
+     * The losing trades' gross, as a magnitude, and it can come out at or below
+     * zero.
+     *
+     * A trade wins or loses on its net after charges and contributes its gross
+     * here, so a trade whose gross was positive and whose charges took it under
+     * lands in the losses carrying a positive gross, which lowers this figure and
+     * with few enough trades beside it takes it to zero or past it. `tallyOf`
+     * says why that is preferred to counting one trade as a loser in one figure
+     * and a winner in another. It is written here because it was documented as a
+     * positive magnitude and is not one, and a reader dividing by it was handed a
+     * negative profit factor with nothing saying that could happen.
+     */
+    readonly grossLoss: Money;
+    readonly charges: Money;
+    /** `netProfit / capital`, a fraction and not a figure times a hundred. */
+    readonly returnPercent: number;
+    /** Closed only. */
+    readonly tradeCount: number;
+    readonly openTradeCount: number;
+    readonly wins: number;
+    readonly losses: number;
+    /** Exactly zero net. */
+    readonly scratches: number;
+    /** wins / (wins + losses), null when none closed. */
+    readonly winRate: number | null;
+    readonly averageWin: Money;
+    /** Positive magnitude. */
+    readonly averageLoss: Money;
+    /** Money per closed trade. */
+    readonly expectancy: Money;
+    readonly expectancyStandardError: Money;
+    /**
+     * Gross profit over gross loss, or null where there is no ratio to take.
+     *
+     * Null when the gross loss is not above zero: a run with no losing trade has
+     * nothing to divide by, and one whose losses cost less in gross than their
+     * charges has a denominator at or below zero. A profit factor is a
+     * non-negative ratio everywhere it is used, so a negative one is not a
+     * surprising value, it is a number nobody can act on. It used to be
+     * reported: two trades, one charged into a loss on a positive gross, gave a
+     * profit factor of -0.5.
+     */
+    readonly profitFactor: number | null;
+    /** Zero or negative, the same sign the curve states it with. */
+    readonly maxDrawdown: Money;
+    /** The deepest point's own fraction, not the worst fraction of any point. */
+    readonly maxDrawdownPercent: number;
+    /** A bar time, never an index. */
+    readonly maxDrawdownAt: number | null;
+    readonly longestDrawdownBars: number;
+    readonly averageBarsHeld: number | null;
+    readonly barsInMarket: number;
+    readonly barCount: number;
+}
+/**
+ * The whole run in one shape, folded from its trades and its own curve.
+ *
+ * The curve is passed in rather than recomputed, because a summary that folded
+ * its own would be a second equity curve with a second set of rounding, and the
+ * first disagreement between them would be a drawdown figure that no point in
+ * the reported curve ever reached.
+ */
+export declare function summaryOf(trades: readonly Trade[], equity: readonly EquityPoint[], contract: Contract, capital: Money): Summary;
+//# sourceMappingURL=statistics.d.ts.map

package/dist/core/accounting/statistics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.d.ts","sourceRoot":"","sources":["../../../src/core/accounting/statistics.ts"],"names":[],"mappings":"AA6DA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,kCAAkC;AAClC,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;IAC1B,6CAA6C;IAC7C,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;IAC5B;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,mBAAmB;IACnB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wBAAwB;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,qDAAqD;IACrD,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;IAC3B,0BAA0B;IAC1B,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;IAC5B,8BAA8B;IAC9B,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;IAC3B,QAAQ,CAAC,uBAAuB,EAAE,KAAK,CAAC;IACxC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,gEAAgE;IAChE,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;IAC5B,6EAA6E;IAC7E,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,kCAAkC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AA2BD;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,KAAK,GACb,OAAO,CAuCT"}

package/dist/core/accounting/statistics.js

@@ -0,0 +1,246 @@
+/**
+ * The summary, and the two figures in it that decide whether a run means
+ * anything.
+ *
+ * **Win rate is over closed trades, on net profit after charges**, and a trade
+ * whose net is exactly zero is a scratch counted in neither half. It is null
+ * where nothing closed rather than zero, because zero is a number a reader
+ * compares against and "nothing has closed yet" is not a losing run.
+ *
+ * **Expectancy is money per closed trade**, and it has two spellings that must
+ * agree: the win rate against the average win and the average loss, and the net
+ * profit over the trade count. Two spellings of one figure that disagree is how
+ * a report loses its reader, so one of them is the computation and the other is
+ * a test, and the test says which sequence of roundings it allows for.
+ *
+ * **And its standard error is what answers the question a comparison asks.**
+ * The sample standard deviation of per-trade net over the square root of the
+ * trade count is what turns "this run made more" into "this run made more than
+ * the noise", and without it a difference of two percent over eleven trades
+ * reads like a result.
+ *
+ * Bar times rather than bar indices, wherever a figure addresses a bar: loading
+ * more history shifts every index, so a report that addresses a bar by index
+ * changes when the warmup changes.
+ *
+ * ## Which trades a figure is counted over, which is three different answers
+ *
+ * A summary folds a list holding closed trades and open ones together, and
+ * almost every defect this file can have is a figure counted over the wrong
+ * half of it.
+ *
+ * - **Net profit, and everything derived from it**, is over closed trades. An
+ *   open trade's net is its charges so far with no gross against them, so
+ *   counting it would report a run holding a winner as having lost money.
+ * - **Charges are over every trade**, open ones included, because the money
+ *   left the account whether or not the position came back. This is the figure
+ *   the equity curve's last point carries, and the two are asserted equal.
+ * - **The drawdown figures are over the curve** and not over the trades at all.
+ *   A drawdown is a thing equity did between two trades as often as during one.
+ *
+ * ## The cases where a statistic is not a number
+ *
+ * Every one of them is a division, and every one of them is answered here
+ * rather than left to arrive as a value JSON turns into `null`:
+ *
+ * - **Nothing closed.** The win rate is null, which is a different claim from
+ *   zero. Expectancy and its error are zero, because the type is money and
+ *   money is not nullable, and `tradeCount` beside them is the field that says
+ *   whether they mean anything.
+ * - **One closed trade.** A sample of one has no spread, so the standard error
+ *   is zero. Zero here means not measurable, never measured: anything dividing
+ *   by it checks the trade count first.
+ * - **Every closed trade a scratch.** There is no denominator for a win rate,
+ *   so it is null for the same reason as nothing closed.
+ * - **Nothing lost.** The profit factor is null rather than an infinity, which
+ *   is the same decision `spec/conformance.md` takes about absence: a value
+ *   that does not survive being written down is not a value a report may hold.
+ * - **Everything lost.** The profit factor is zero, expectancy is negative, the
+ *   average win is zero, and none of the four is a division by zero.
+ */
+import { barsInMarketOver, ratioOf } from './equity.js';
+/**
+ * The whole run in one shape, folded from its trades and its own curve.
+ *
+ * The curve is passed in rather than recomputed, because a summary that folded
+ * its own would be a second equity curve with a second set of rounding, and the
+ * first disagreement between them would be a drawdown figure that no point in
+ * the reported curve ever reached.
+ */
+export function summaryOf(trades, equity, contract, capital) {
+    const tally = tallyOf(trades);
+    const depth = depthOf(equity);
+    const decided = tally.wins + tally.losses;
+    // Net over the closed count, and nothing else, because this is the figure the
+    // other spelling is checked against. The win rate spelling divides by the
+    // decided trades instead, so the two are the same number exactly when no
+    // trade scratched, and `tests/accounting/statistics.test.ts` asserts both the
+    // agreement and the one case that parts them.
+    const expectancy = tally.tradeCount === 0 ? 0 : tally.netProfit / tally.tradeCount;
+    return {
+        capital,
+        currency: contract.currency,
+        netProfit: tally.netProfit,
+        grossProfit: tally.grossProfit,
+        grossLoss: tally.grossLoss,
+        charges: tally.charges,
+        returnPercent: ratioOf(tally.netProfit, capital),
+        tradeCount: tally.tradeCount,
+        openTradeCount: tally.openTradeCount,
+        wins: tally.wins,
+        losses: tally.losses,
+        scratches: tally.scratches,
+        winRate: decided === 0 ? null : tally.wins / decided,
+        averageWin: tally.wins === 0 ? 0 : tally.winTotal / tally.wins,
+        averageLoss: tally.losses === 0 ? 0 : -tally.lossTotal / tally.losses,
+        expectancy,
+        expectancyStandardError: standardErrorOf(trades, expectancy, tally.tradeCount),
+        profitFactor: tally.grossLoss > 0 ? tally.grossProfit / tally.grossLoss : null,
+        maxDrawdown: depth.maxDrawdown,
+        maxDrawdownPercent: depth.maxDrawdownPercent,
+        maxDrawdownAt: depth.maxDrawdownAt,
+        longestDrawdownBars: depth.longestDrawdownBars,
+        averageBarsHeld: tally.heldCount === 0 ? null : tally.heldTotal / tally.heldCount,
+        barsInMarket: barsInMarketOver(trades, equity),
+        barCount: equity.length,
+    };
+}
+/**
+ * One pass over the trades, in the order they are given.
+ *
+ * A trade wins or loses on its net after charges, and its gross is what it
+ * contributes to the gross figures: "the sum of the winning trades, before
+ * charges" is two statements and this is where they meet. The one arrangement
+ * that reads oddly is a trade whose gross was positive and whose charges took
+ * it under, which lands in the losses and takes its positive gross with it,
+ * lowering the gross loss. That is on purpose. The alternative is a trade
+ * counted as a loser in one figure and a winner in another, and a profit factor
+ * whose two halves are counted over different sets is worse than one whose
+ * magnitude is odd on a trade that barely moved.
+ *
+ * What is not on purpose, and is why `profitFactor` is null rather than a ratio
+ * whenever this figure is not above zero: enough of those trades and the gross
+ * loss reaches zero or goes under, and dividing by it reported a profit factor
+ * of minus a half. A statistic being odd is a thing a reader can weigh. A
+ * statistic being negative where every use of it is a non-negative ratio is a
+ * number nobody can act on.
+ */
+function tallyOf(trades) {
+    let netProfit = 0;
+    let grossProfit = 0;
+    let grossLoss = 0;
+    let charges = 0;
+    let tradeCount = 0;
+    let openTradeCount = 0;
+    let wins = 0;
+    let losses = 0;
+    let scratches = 0;
+    let winTotal = 0;
+    let lossTotal = 0;
+    let heldTotal = 0;
+    let heldCount = 0;
+    for (const trade of trades) {
+        charges += trade.charges;
+        if (trade.isOpen) {
+            openTradeCount += 1;
+            continue;
+        }
+        tradeCount += 1;
+        netProfit += trade.netProfit;
+        if (trade.barsHeld !== null) {
+            heldTotal += trade.barsHeld;
+            heldCount += 1;
+        }
+        if (trade.netProfit > 0) {
+            wins += 1;
+            winTotal += trade.netProfit;
+            grossProfit += trade.grossProfit;
+        }
+        else if (trade.netProfit < 0) {
+            losses += 1;
+            lossTotal += trade.netProfit;
+            grossLoss -= trade.grossProfit;
+        }
+        else {
+            scratches += 1;
+        }
+    }
+    return {
+        netProfit,
+        grossProfit,
+        grossLoss,
+        charges,
+        tradeCount,
+        openTradeCount,
+        wins,
+        losses,
+        scratches,
+        winTotal,
+        lossTotal,
+        heldTotal,
+        heldCount,
+    };
+}
+/**
+ * The deepest the curve went, named as one point rather than as three figures.
+ *
+ * The money, the fraction and the time all come from the same point, and the
+ * point is the deepest in money with the earliest one winning a tie. Taking the
+ * worst fraction from one bar and the worst money from another would describe a
+ * moment the run never had, and a reader comparing the two figures would find
+ * them inconsistent with every point in the curve they were drawn from.
+ *
+ * `longestDrawdownBars` is the longest run of consecutive bars under a peak: it
+ * starts at the first bar below one and ends at the bar before the recovery, so
+ * a run still under water at the last bar counts to the end. It is often the
+ * figure that actually stops a trader, and it is not the total number of bars
+ * spent under water, which is a different and much larger number.
+ */
+function depthOf(equity) {
+    let maxDrawdown = 0;
+    let maxDrawdownPercent = 0;
+    let maxDrawdownAt = null;
+    let longestDrawdownBars = 0;
+    let under = 0;
+    for (const point of equity) {
+        if (point.drawdown < maxDrawdown) {
+            maxDrawdown = point.drawdown;
+            maxDrawdownPercent = point.drawdownPercent;
+            maxDrawdownAt = point.time;
+        }
+        if (point.drawdown < 0) {
+            under += 1;
+            if (under > longestDrawdownBars)
+                longestDrawdownBars = under;
+        }
+        else {
+            under = 0;
+        }
+    }
+    return { maxDrawdown, maxDrawdownPercent, maxDrawdownAt, longestDrawdownBars };
+}
+/**
+ * The standard error of the expectancy: the sample deviation over the root of
+ * the count.
+ *
+ * The sample deviation, with the count less one under it, and not the
+ * population one. The trades a run took are a sample of the trades the strategy
+ * would take, which is the whole reason this figure is here, and the population
+ * spelling understates the spread by exactly the amount that matters on the
+ * short runs where the question is asked.
+ *
+ * Fewer than two closed trades has no spread to measure and gives zero.
+ */
+function standardErrorOf(trades, expectancy, tradeCount) {
+    if (tradeCount < 2)
+        return 0;
+    let squares = 0;
+    for (const trade of trades) {
+        if (trade.isOpen)
+            continue;
+        const away = trade.netProfit - expectancy;
+        squares += away * away;
+    }
+    return Math.sqrt(squares / (tradeCount - 1) / tradeCount);
+}
+//# sourceMappingURL=statistics.js.map

package/dist/core/accounting/statistics.js.map

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