time-to-botec

Benchmark sampling in different programming languages
Log | Files | Refs | README

XYShape.d.ts (4188B)

      1 import * as Result from "./utility/result.js";
      2 export type XYShape = {
      3     readonly xs: number[];
      4     readonly ys: number[];
      5 };
      6 export type XYShapeError = {
      7     tag: "NotSorted";
      8     property: string;
      9 } | {
     10     tag: "IsEmpty";
     11     property: string;
     12 } | {
     13     tag: "NotFinite";
     14     property: string;
     15     value: number;
     16 } | {
     17     tag: "DifferentLengths";
     18     p1Name: string;
     19     p2Name: string;
     20     p1Length: number;
     21     p2Length: number;
     22 } | {
     23     tag: "MultipleErrors";
     24     errors: XYShapeError[];
     25 };
     26 export declare const XYShapeError: {
     27     mapErrorArrayToError(errors: XYShapeError[]): XYShapeError | undefined;
     28     toString(t: XYShapeError): string;
     29 };
     30 export type InterpolationStrategy = "Stepwise" | "Linear";
     31 type ExtrapolationStrategy = "UseZero" | "UseOutermostPoints";
     32 type Interpolator = (shape: XYShape, leftIndex: number, x: number) => number;
     33 export declare const T: {
     34     length(t: XYShape): number;
     35     empty: XYShape;
     36     isEmpty(t: XYShape): boolean;
     37     minX(t: XYShape): number;
     38     maxX(t: XYShape): number;
     39     firstY(t: XYShape): number;
     40     lastY(t: XYShape): number;
     41     xTotalRange(t: XYShape): number;
     42     mapX(t: XYShape, fn: (x: number) => number): XYShape;
     43     mapY(t: XYShape, fn: (y: number) => number): XYShape;
     44     mapYResult<E>(t: XYShape, fn: (y: number) => Result.result<number, E>): Result.result<XYShape, E>;
     45     square(t: XYShape): XYShape;
     46     zip({ xs, ys }: XYShape): [number, number][];
     47     fromArray([xs, ys]: [number[], number[]]): XYShape;
     48     fromArrays(xs: number[], ys: number[]): XYShape;
     49     accumulateYs(p: XYShape, fn: (y1: number, y2: number) => number): XYShape;
     50     concat(t1: XYShape, t2: XYShape): XYShape;
     51     isEqual(t1: XYShape, t2: XYShape): boolean;
     52     fromZippedArray(pairs: [number, number][]): XYShape;
     53     equallyDividedXs(t: XYShape, newLength: number): number[];
     54     Validator: {
     55         notSortedError(p: string): XYShapeError;
     56         notFiniteError(p: string, exampleValue: number): XYShapeError;
     57         isEmptyError(propertyName: string): XYShapeError;
     58         differentLengthsError(t: XYShape): XYShapeError;
     59         areXsSorted(t: XYShape): boolean;
     60         areXsEmpty(t: XYShape): boolean;
     61         getNonFiniteXs(t: XYShape): number | undefined;
     62         getNonFiniteYs(t: XYShape): number | undefined;
     63         validate(t: XYShape): XYShapeError | undefined;
     64     };
     65     make(xs: number[], ys: number[]): Result.result<XYShape, XYShapeError>;
     66     makeFromZipped(values: readonly (readonly [number, number])[]): Result.result<XYShape, XYShapeError>;
     67 };
     68 export declare const YtoX: {
     69     linear(t: XYShape, y: number): number;
     70 };
     71 export declare const XtoY: {
     72     stepwiseIncremental(t: XYShape, x: number): number | undefined;
     73     stepwiseIfAtX(t: XYShape, f: number): number | undefined;
     74     linear(t: XYShape, x: number): number;
     75     continuousInterpolator(interpolation: InterpolationStrategy, extrapolation: ExtrapolationStrategy): Interpolator;
     76     discreteInterpolator: Interpolator;
     77 };
     78 export declare const XsConversion: {
     79     _replaceWithXs(newXs: number[], t: XYShape): XYShape;
     80     equallyDivideXByMass(integral: XYShape, newLength: number): number[];
     81     proportionEquallyOverX(t: XYShape, newLength: number): XYShape;
     82     proportionByProbabilityMass(t: XYShape, newLength: number, integral: XYShape): XYShape;
     83 };
     84 type Zipped = [number, number][];
     85 export declare const Zipped: {
     86     sortByY(t: Zipped): [number, number][];
     87     sortByX(t: Zipped): [number, number][];
     88     filterByX(t: Zipped, testFn: (x: number) => boolean): [number, number][];
     89 };
     90 export declare const PointwiseCombination: {
     91     combine<E>(interpolator: Interpolator, fn: (a: number, b: number) => Result.result<number, E>, t1: XYShape, t2: XYShape): Result.result<XYShape, E>;
     92     addCombine(interpolator: Interpolator, t1: XYShape, t2: XYShape): XYShape;
     93 };
     94 export declare const Range: {
     95     integrateWithTriangles({ xs, ys }: XYShape): {
     96         xs: number[];
     97         ys: number[];
     98     };
     99     stepwiseToLinear({ xs, ys }: XYShape): XYShape;
    100 };
    101 export declare const Analysis: {
    102     getVarianceDangerously<T>(t: T, mean: (t: T) => number, getMeanOfSquares: (t: T) => number): number;
    103 };
    104 export {};
    105 //# sourceMappingURL=XYShape.d.ts.map