time-to-botec

XYShape.js (15013B)

---

 import sortBy from "lodash/sortBy.js";
 import { epsilon_float } from "./magicNumbers.js";
 import * as E_A from "./utility/E_A.js";
 import * as E_A_Floats from "./utility/E_A_Floats.js";
 import * as E_A_Sorted from "./utility/E_A_Sorted.js";
 import * as Result from "./utility/result.js";
 export const XYShapeError = {
     mapErrorArrayToError(errors) {
         if (errors.length === 0) {
             return undefined;
         }
         else if (errors.length === 1) {
             return errors[0];
         }
         else {
             return {
                 tag: "MultipleErrors",
                 errors,
             };
         }
     },
     toString(t) {
         switch (t.tag) {
             case "NotSorted":
                 return `${t.property} is not sorted`;
             case "IsEmpty":
                 return `${t.property} is empty`;
             case "NotFinite":
                 return `${t.property} is not finite. Example value: ${t.value}`;
             case "DifferentLengths":
                 return `${t.p1Name} and ${t.p2Name} have different lengths. ${t.p1Name} has length ${t.p1Length} and ${t.p2Name} has length ${t.p2Length}`;
             case "MultipleErrors":
                 return `Multiple Errors: ${t.errors
                     .map(XYShapeError.toString)
                     .map((r) => `[${r}]`)
                     .join(", ")}`;
         }
     },
 };
 const interpolate = (xMin, xMax, yMin, yMax, xIntended) => {
     const minProportion = (xMax - xIntended) / (xMax - xMin);
     const maxProportion = (xIntended - xMin) / (xMax - xMin);
     return yMin * minProportion + yMax * maxProportion;
 };
 const extImp = (value) => {
     if (value === undefined) {
         throw new Error("Tried to perform an operation on an empty XYShape.");
     }
     return value;
 };
 export const T = {
     length(t) {
         return t.xs.length;
     },
     empty: { xs: [], ys: [] },
     isEmpty(t) {
         return T.length(t) === 0;
     },
     minX(t) {
         return extImp(t.xs[0]);
     },
     maxX(t) {
         return extImp(t.xs[t.xs.length - 1]);
     },
     firstY(t) {
         return extImp(t.ys[0]);
     },
     lastY(t) {
         return extImp(t.ys[t.ys.length - 1]);
     },
     xTotalRange(t) {
         return T.maxX(t) - T.minX(t);
     },
     mapX(t, fn) {
         return { xs: t.xs.map(fn), ys: t.ys };
     },
     mapY(t, fn) {
         return { xs: t.xs, ys: t.ys.map(fn) };
     },
     mapYResult(t, fn) {
         const mappedYs = [];
         for (const y of t.ys) {
             const mappedY = fn(y);
             if (!mappedY.ok) {
                 return mappedY;
             }
             mappedYs.push(mappedY.value);
         }
         return Result.Ok({
             xs: t.xs,
             ys: mappedYs,
         });
     },
     square(t) {
         return T.mapX(t, (x) => x ** 2);
     },
     zip({ xs, ys }) {
         return E_A.zip(xs, ys);
     },
     fromArray([xs, ys]) {
         return { xs, ys };
     },
     fromArrays(xs, ys) {
         return { xs, ys };
     },
     accumulateYs(p, fn) {
         return T.fromArray([p.xs, E_A.accumulate(p.ys, fn)]);
     },
     concat(t1, t2) {
         const cxs = [...t1.xs, ...t2.xs];
         const cys = [...t1.ys, ...t2.ys];
         return { xs: cxs, ys: cys };
     },
     isEqual(t1, t2) {
         return E_A.isEqual(t1.xs, t2.xs) && E_A.isEqual(t1.ys, t2.ys);
     },
     fromZippedArray(pairs) {
         return T.fromArray(E_A.unzip(pairs));
     },
     equallyDividedXs(t, newLength) {
         return E_A_Floats.range(T.minX(t), T.maxX(t), newLength);
     },
     Validator: {
         notSortedError(p) {
             return {
                 tag: "NotSorted",
                 property: p,
             };
         },
         notFiniteError(p, exampleValue) {
             return {
                 tag: "NotFinite",
                 property: p,
                 value: exampleValue,
             };
         },
         isEmptyError(propertyName) {
             return { tag: "IsEmpty", property: propertyName };
         },
         differentLengthsError(t) {
             return {
                 tag: "DifferentLengths",
                 p1Name: "Xs",
                 p2Name: "Ys",
                 p1Length: t.xs.length,
                 p2Length: t.ys.length,
             };
         },
         areXsSorted(t) {
             return E_A_Floats.isSorted(t.xs);
         },
         areXsEmpty(t) {
             return t.xs.length === 0;
         },
         getNonFiniteXs(t) {
             return t.xs.find((v) => !Number.isFinite(v));
         },
         getNonFiniteYs(t) {
             return t.ys.find((v) => !Number.isFinite(v));
         },
         validate(t) {
             const errors = [];
             if (!T.Validator.areXsSorted(t)) {
                 errors.push(T.Validator.notSortedError("Xs"));
             }
             if (T.Validator.areXsEmpty(t)) {
                 errors.push(T.Validator.isEmptyError("Xs"));
             }
             if (t.xs.length !== t.ys.length) {
                 errors.push(T.Validator.differentLengthsError(t));
             }
             const nonFiniteX = T.Validator.getNonFiniteXs(t);
             if (nonFiniteX !== undefined) {
                 errors.push(T.Validator.notFiniteError("Xs", nonFiniteX));
             }
             const nonFiniteY = T.Validator.getNonFiniteYs(t);
             if (nonFiniteY !== undefined) {
                 errors.push(T.Validator.notFiniteError("Ys", nonFiniteY));
             }
             return XYShapeError.mapErrorArrayToError(errors);
         },
     },
     make(xs, ys) {
         const attempt = { xs, ys };
         const maybeError = T.Validator.validate(attempt);
         if (maybeError) {
             return Result.Err(maybeError);
         }
         else {
             return Result.Ok(attempt);
         }
     },
     makeFromZipped(values) {
         const [xs, ys] = E_A.unzip(values);
         return T.make(xs, ys);
     },
 };
 const Pairs = {
     first(t) {
         return [T.minX(t), T.firstY(t)];
     },
     last(t) {
         return [T.maxX(t), T.lastY(t)];
     },
     getBy(t, fn) {
         return T.zip(t).find(fn);
     },
     firstAtOrBeforeXValue(t, xValue) {
         const firstGreaterIndex = E_A_Sorted.firstGreaterIndex(t.xs, xValue);
         if (firstGreaterIndex === 0) {
             return;
         }
         return [t.xs[firstGreaterIndex - 1], t.ys[firstGreaterIndex - 1]];
     },
 };
 export const YtoX = {
     linear(t, y) {
         const firstHigherIndex = E_A_Sorted.firstGreaterIndex(t.ys, y);
         if (firstHigherIndex === t.ys.length) {
             return T.maxX(t);
         }
         else if (firstHigherIndex === 0) {
             return T.minX(t);
         }
         else {
             const lowerOrEqualIndex = firstHigherIndex - 1;
             if (t.ys[lowerOrEqualIndex] === y) {
                 return t.xs[lowerOrEqualIndex];
             }
             else {
                 return interpolate(t.ys[lowerOrEqualIndex], t.ys[firstHigherIndex], t.xs[lowerOrEqualIndex], t.xs[firstHigherIndex], y);
             }
         }
     },
 };
 export const XtoY = {
     stepwiseIncremental(t, x) {
         return Pairs.firstAtOrBeforeXValue(t, x)?.[1];
     },
     stepwiseIfAtX(t, f) {
         return Pairs.getBy(t, ([x]) => x === f)?.[1];
     },
     linear(t, x) {
         const firstHigherIndex = E_A_Sorted.firstGreaterIndex(t.xs, x);
         if (firstHigherIndex === t.xs.length) {
             return T.lastY(t);
         }
         else if (firstHigherIndex === 0) {
             return T.firstY(t);
         }
         else {
             const lowerOrEqualIndex = firstHigherIndex - 1;
             if (t.xs[lowerOrEqualIndex] === x) {
                 return t.ys[lowerOrEqualIndex];
             }
             else {
                 return interpolate(t.xs[lowerOrEqualIndex], t.xs[firstHigherIndex], t.ys[lowerOrEqualIndex], t.ys[firstHigherIndex], x);
             }
         }
     },
     continuousInterpolator(interpolation, extrapolation) {
         if (interpolation === "Linear" && extrapolation === "UseZero") {
             return (t, leftIndex, x) => {
                 if (leftIndex < 0) {
                     return 0;
                 }
                 else if (leftIndex >= T.length(t) - 1) {
                     return 0;
                 }
                 else {
                     const x1 = t.xs[leftIndex];
                     const x2 = t.xs[leftIndex + 1];
                     const y1 = t.ys[leftIndex];
                     const y2 = t.ys[leftIndex + 1];
                     const fraction = (x - x1) / (x2 - x1);
                     return y1 * (1 - fraction) + y2 * fraction;
                 }
             };
         }
         else if (interpolation === "Linear" &&
             extrapolation === "UseOutermostPoints") {
             return (t, leftIndex, x) => {
                 if (leftIndex < 0) {
                     return t.ys[0];
                 }
                 else if (leftIndex >= T.length(t) - 1) {
                     return t.ys[T.length(t) - 1];
                 }
                 else {
                     const x1 = t.xs[leftIndex];
                     const x2 = t.xs[leftIndex + 1];
                     const y1 = t.ys[leftIndex];
                     const y2 = t.ys[leftIndex + 1];
                     const fraction = (x - x1) / (x2 - x1);
                     return y1 * (1 - fraction) + y2 * fraction;
                 }
             };
         }
         else if (interpolation === "Stepwise" && extrapolation === "UseZero") {
             return (t, leftIndex, _x) => {
                 if (leftIndex < 0) {
                     return 0;
                 }
                 else if (leftIndex >= T.length(t) - 1) {
                     return 0;
                 }
                 else {
                     return t.ys[leftIndex];
                 }
             };
         }
         else if (interpolation === "Stepwise" &&
             extrapolation === "UseOutermostPoints") {
             return (t, leftIndex, _x) => {
                 if (leftIndex < 0) {
                     return t.ys[0];
                 }
                 else if (leftIndex >= T.length(t) - 1) {
                     return t.ys[T.length(t) - 1];
                 }
                 else {
                     return t.ys[leftIndex];
                 }
             };
         }
         else {
             throw new Error("Implementation error: invalid interpolation/extrapolation strategy combination");
         }
     },
     discreteInterpolator: (() => 0),
 };
 export const XsConversion = {
     _replaceWithXs(newXs, t) {
         const newYs = newXs.map((x) => XtoY.linear(t, x));
         return { xs: newXs, ys: newYs };
     },
     equallyDivideXByMass(integral, newLength) {
         return E_A_Floats.range(0, 1, newLength).map((y) => YtoX.linear(integral, y));
     },
     proportionEquallyOverX(t, newLength) {
         return XsConversion._replaceWithXs(T.equallyDividedXs(t, newLength), t);
     },
     proportionByProbabilityMass(t, newLength, integral) {
         return XsConversion._replaceWithXs(XsConversion.equallyDivideXByMass(integral, newLength), t);
     },
 };
 export const Zipped = {
     sortByY(t) {
         return sortBy(t, [([x, y]) => y]);
     },
     sortByX(t) {
         return sortBy(t, [([x, y]) => x]);
     },
     filterByX(t, testFn) {
         return t.filter(([x]) => testFn(x));
     },
 };
 export const PointwiseCombination = {
     combine(interpolator, fn, t1, t2) {
         const t1n = t1.xs.length;
         const t2n = t2.xs.length;
         const outX = [];
         const outY = [];
         let i1 = 0, i2 = 0;
         while (i1 < t1n || i2 < t2n) {
             let x, y1, y2;
             if (i1 > 0 && i1 === t1n && i2 === 0) {
                 x = t1.xs[i1 - 1] + Number.EPSILON * t1.xs[i1 - 1];
                 y1 = interpolator(t1, t1n, x);
                 y2 = interpolator(t2, -1, x);
                 i1++;
             }
             else if (i1 === t1n + 1 && i2 === 0) {
                 x = t2.xs[0] - Number.EPSILON * t2.xs[0];
                 y1 = interpolator(t1, t1n, x);
                 y2 = interpolator(t2, -1, x);
                 i1++;
             }
             else if (i2 > 0 && i2 === t2n && i1 === 0) {
                 x = t2.xs[i2 - 1] + Number.EPSILON * t2.xs[i2 - 1];
                 y1 = interpolator(t1, -1, x);
                 y2 = interpolator(t2, t2n, x);
                 i2++;
             }
             else if (i2 === t2n + 1 && i1 === 0) {
                 x = t1.xs[0] - Number.EPSILON * t1.xs[0];
                 y1 = interpolator(t1, -1, x);
                 y2 = interpolator(t2, t2n, x);
                 i2++;
             }
             else if (i2 >= t2n || (i1 < t1n && t1.xs[i1] < t2.xs[i2])) {
                 x = t1.xs[i1];
                 y1 = t1.ys[i1];
                 y2 = interpolator(t2, i2 - 1, x);
                 i1++;
             }
             else if (i1 >= t1n || (i2 < t2n && t1.xs[i1] > t2.xs[i2])) {
                 x = t2.xs[i2];
                 y1 = interpolator(t1, i1 - 1, x);
                 y2 = t2.ys[i2];
                 i2++;
             }
             else if (i1 < t1n && i2 < t2n && t1.xs[i1] === t2.xs[i2]) {
                 x = t1.xs[i1];
                 y1 = t1.ys[i1];
                 y2 = t2.ys[i2];
                 i1++;
                 i2++;
             }
             else {
                 throw new Error(`PointwiseCombination error: ${i1}, ${i2}`);
             }
             outX.push(x);
             const newY = fn(y1, y2);
             if (!newY.ok) {
                 return newY;
             }
             outY.push(newY.value);
         }
         return Result.Ok({ xs: outX, ys: outY });
     },
     addCombine(interpolator, t1, t2) {
         const result = PointwiseCombination.combine(interpolator, (a, b) => Result.Ok(a + b), t1, t2);
         if (!result.ok) {
             throw new Error("Add operation should never fail");
         }
         return result.value;
     },
 };
 export const Range = {
     integrateWithTriangles({ xs, ys }) {
         const length = xs.length;
         const cumulativeY = new Array(length).fill(0);
         for (let x = 0; x <= length - 2; x++) {
             cumulativeY[x + 1] =
                 (xs[x + 1] - xs[x]) * ((ys[x] + ys[x + 1]) / 2) + cumulativeY[x];
         }
         return { xs, ys: cumulativeY };
     },
     stepwiseToLinear({ xs, ys }) {
         const length = xs.length;
         const newXs = new Array(2 * length);
         const newYs = new Array(2 * length);
         newXs[0] = xs[0] - epsilon_float;
         newYs[0] = 0;
         newXs[1] = xs[0];
         newYs[1] = ys[0];
         for (let i = 1; i <= length - 1; i++) {
             newXs[i * 2] = xs[i] - epsilon_float;
             newYs[i * 2] = ys[i - 1];
             newXs[i * 2 + 1] = xs[i];
             newYs[i * 2 + 1] = ys[i];
         }
         return { xs: newXs, ys: newYs };
     },
 };
 export const Analysis = {
     getVarianceDangerously(t, mean, getMeanOfSquares) {
         const meanSquared = mean(t) ** 2;
         const meanOfSquares = getMeanOfSquares(t);
         return meanOfSquares - meanSquared;
     },
 };
 //# sourceMappingURL=XYShape.js.map