time-to-botec

Discrete.js (7342B)

---

 import * as Continuous from "./Continuous.js";
 import * as Result from "../utility/result.js";
 import * as MixedPoint from "./MixedPoint.js";
 import * as Common from "./Common.js";
 import { ContinuousShape } from "./Continuous.js";
 import * as XYShape from "../XYShape.js";
 import { convolutionOperationToFn, } from "./PointSet.js";
 import { epsilon_float } from "../magicNumbers.js";
 import { random_sample } from "../utility/math.js";
 import { MixedShape } from "./Mixed.js";
 export class DiscreteShape {
     constructor(args) {
         this.xyShape = args.xyShape;
         this._integralSumCache = args.integralSumCache;
         this._integralCache = args.integralCache;
     }
     get integralCache() {
         return this._integralCache;
     }
     get integralSumCache() {
         return this._integralSumCache;
     }
     withAdjustedIntegralSum(integralSumCache) {
         return new DiscreteShape({
             xyShape: this.xyShape,
             integralSumCache,
             integralCache: this.integralCache,
         });
     }
     shapeMap(fn) {
         return new DiscreteShape({
             xyShape: fn(this.xyShape),
             integralSumCache: this.integralSumCache,
             integralCache: this.integralCache,
         });
     }
     integral() {
         if (!this._integralCache) {
             if (XYShape.T.isEmpty(this.xyShape)) {
                 this._integralCache = emptyIntegral();
             }
             else {
                 const ts = this.xyShape;
                 const firstX = XYShape.T.minX(ts);
                 const prependedZeroPoint = {
                     xs: [firstX - epsilon_float],
                     ys: [0],
                 };
                 const integralShape = XYShape.T.accumulateYs(XYShape.T.concat(prependedZeroPoint, ts), (a, b) => a + b);
                 this._integralCache = Continuous.stepwiseToLinear(new ContinuousShape({
                     xyShape: integralShape,
                     interpolation: "Stepwise",
                 }));
             }
         }
         return this._integralCache;
     }
     integralSum() {
         return (this._integralSumCache ??= this.integral().lastY());
     }
     integralXtoY(f) {
         return XYShape.XtoY.linear(this.integral().xyShape, f);
     }
     integralYtoX(f) {
         return XYShape.YtoX.linear(this.integral().xyShape, f);
     }
     minX() {
         return XYShape.T.minX(this.xyShape);
     }
     maxX() {
         return XYShape.T.maxX(this.xyShape);
     }
     toDiscreteProbabilityMassFraction() {
         return 1;
     }
     isEqual(t) {
         return XYShape.T.isEqual(this.xyShape, t.xyShape);
     }
     mapY(fn, integralSumCacheFn, integralCacheFn) {
         return new DiscreteShape({
             xyShape: XYShape.T.mapY(this.xyShape, fn),
             integralSumCache: this.integralSumCache === undefined
                 ? undefined
                 : integralSumCacheFn?.(this.integralSumCache),
             integralCache: this.integralCache === undefined
                 ? undefined
                 : integralCacheFn?.(this.integralCache),
         });
     }
     mapYResult(fn, integralSumCacheFn, integralCacheFn) {
         const result = XYShape.T.mapYResult(this.xyShape, fn);
         if (!result.ok) {
             return result;
         }
         return Result.Ok(new DiscreteShape({
             xyShape: result.value,
             integralSumCache: this.integralSumCache === undefined
                 ? undefined
                 : integralSumCacheFn?.(this.integralSumCache),
             integralCache: this.integralCache === undefined
                 ? undefined
                 : integralCacheFn?.(this.integralCache),
         }));
     }
     isEmpty() {
         return this.xyShape.xs.length === 0;
     }
     toContinuous() {
         return undefined;
     }
     toDiscrete() {
         return this;
     }
     toMixed() {
         return new MixedShape({
             continuous: Continuous.empty(),
             discrete: this,
             integralSumCache: this.integralSumCache,
             integralCache: this.integralCache,
         });
     }
     scaleBy(scale) {
         return this.mapY((r) => r * scale, (sum) => sum * scale, (cache) => cache.scaleBy(scale));
     }
     normalize() {
         return this.scaleBy(1 / this.integralSum()).withAdjustedIntegralSum(1);
     }
     downsample(i) {
         const currentLength = XYShape.T.length(this.xyShape);
         if (i < currentLength && i >= 1 && currentLength > 1) {
             const sortedByY = XYShape.Zipped.sortByY(XYShape.T.zip(this.xyShape));
             const picked = [...sortedByY].reverse().slice(0, i);
             return new DiscreteShape({
                 xyShape: XYShape.T.fromZippedArray(XYShape.Zipped.sortByX(picked)),
             });
         }
         else {
             return this;
         }
     }
     truncate(leftCutoff, rightCutoff) {
         return new DiscreteShape({
             xyShape: XYShape.T.fromZippedArray(XYShape.Zipped.filterByX(XYShape.T.zip(this.xyShape), (x) => x >= (leftCutoff ?? -Infinity) && x <= (rightCutoff ?? Infinity))),
         });
     }
     xToY(f) {
         return MixedPoint.makeDiscrete(XYShape.XtoY.stepwiseIfAtX(this.xyShape, f) ?? 0);
     }
     mean() {
         const s = this.xyShape;
         return s.xs.reduce((acc, x, i) => acc + x * s.ys[i], 0);
     }
     variance() {
         return XYShape.Analysis.getVarianceDangerously(this, (t) => t.mean(), (t) => t.shapeMap(XYShape.T.square).mean());
     }
 }
 const emptyIntegral = () => new ContinuousShape({
     xyShape: { xs: [-Infinity], ys: [0] },
     interpolation: "Stepwise",
     integralSumCache: 0,
     integralCache: undefined,
 });
 export const empty = () => new DiscreteShape({
     xyShape: XYShape.T.empty,
     integralSumCache: 0,
     integralCache: emptyIntegral(),
 });
 export const isFloat = (t) => {
     if (t.xyShape.ys.length === 1 && t.xyShape.ys[0] === 1) {
         return true;
     }
     return false;
 };
 export const getShape = (t) => t.xyShape;
 export const combinePointwise = (t1, t2, fn, integralSumCachesFn = () => undefined) => {
     const combiner = XYShape.PointwiseCombination.combine;
     return Result.fmap(combiner(XYShape.XtoY.discreteInterpolator, fn, t1.xyShape, t2.xyShape), (x) => new DiscreteShape({ xyShape: x }));
 };
 export const combineAlgebraically = (op, t1, t2) => {
     const t1s = t1.xyShape;
     const t2s = t2.xyShape;
     const t1n = XYShape.T.length(t1s);
     const t2n = XYShape.T.length(t2s);
     const combinedIntegralSum = Common.combineIntegralSums((s1, s2) => s1 * s2, t1.integralSumCache, t2.integralSumCache);
     const fn = convolutionOperationToFn(op);
     const xToYMap = new Map();
     for (let i = 0; i <= t1n - 1; i++) {
         for (let j = 0; j <= t2n - 1; j++) {
             const x = fn(t1s.xs[i], t2s.xs[j]);
             const cv = xToYMap.get(x) ?? 0;
             const my = t1s.ys[i] * t2s.ys[j];
             xToYMap.set(x, cv + my);
         }
     }
     const rxys = XYShape.Zipped.sortByX([...xToYMap.entries()]);
     const combinedShape = XYShape.T.fromZippedArray(rxys);
     return new DiscreteShape({
         xyShape: combinedShape,
         integralSumCache: combinedIntegralSum,
     });
 };
 export const sampleN = (t, n) => {
     const normalized = t.normalize().xyShape;
     return random_sample(normalized.xs, { probs: normalized.ys, size: n });
 };
 //# sourceMappingURL=Discrete.js.map