time-to-botec

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

genericDist.js (6564B)

      1 import * as SymbolicDist from "../dist/SymbolicDist.js";
      2 import { algebraicCumProd, algebraicCumSum, algebraicDiff, algebraicProduct, algebraicSum, } from "../dist/distOperations/binaryOperations.js";
      3 import { binaryOperations, } from "../dist/distOperations/index.js";
      4 import { makeDefinition } from "../library/registry/fnDefinition.js";
      5 import { frArray, frDist, frDistOrNumber, frNumber, } from "../library/registry/frTypes.js";
      6 import { FnFactory, distResultToValue, distsResultToValue, parseDistFromDistOrNumber, unpackDistResult, } from "../library/registry/helpers.js";
      7 import * as magicNumbers from "../magicNumbers.js";
      8 import { vArray, vNumber } from "../value/index.js";
      9 const maker = new FnFactory({
     10     nameSpace: "",
     11     requiresNamespace: false,
     12 });
     13 const algebraicOps = [
     14     ["add", binaryOperations.algebraicAdd],
     15     ["multiply", binaryOperations.algebraicMultiply],
     16     ["subtract", binaryOperations.algebraicSubtract],
     17     ["divide", binaryOperations.algebraicDivide],
     18     ["pow", binaryOperations.algebraicPower],
     19     ["log", binaryOperations.algebraicLogarithm],
     20 ];
     21 const pointwiseOps = [
     22     ["dotAdd", binaryOperations.pointwiseAdd],
     23     ["dotMultiply", binaryOperations.pointwiseMultiply],
     24     ["dotSubtract", binaryOperations.pointwiseSubtract],
     25     ["dotDivide", binaryOperations.pointwiseDivide],
     26     ["dotPow", binaryOperations.pointwisePower],
     27 ];
     28 const makeOperationFns = () => {
     29     const fns = [];
     30     for (const [name, op] of [...algebraicOps, ...pointwiseOps]) {
     31         fns.push(maker.make({
     32             name,
     33             definitions: [
     34                 makeDefinition([frDist, frNumber], ([dist, n], { environment }) => distResultToValue(op(dist, new SymbolicDist.PointMass(n), { env: environment }))),
     35                 makeDefinition([frNumber, frDist], ([n, dist], { environment }) => distResultToValue(op(new SymbolicDist.PointMass(n), dist, { env: environment }))),
     36                 makeDefinition([frDist, frDist], ([dist1, dist2], { environment }) => distResultToValue(op(dist1, dist2, { env: environment }))),
     37             ],
     38         }));
     39     }
     40     return fns;
     41 };
     42 export const library = [
     43     maker.d2s({
     44         name: "sparkline",
     45         fn: (d, env) => unpackDistResult(d.toSparkline(magicNumbers.Environment.sparklineLength, env)),
     46     }),
     47     maker.dn2s({
     48         name: "sparkline",
     49         fn: (d, n, env) => unpackDistResult(d.toSparkline(n | 0, env)),
     50     }),
     51     maker.d2n({
     52         name: "mean",
     53         fn: (d) => d.mean(),
     54     }),
     55     maker.d2n({ name: "stdev", fn: (d) => unpackDistResult(d.stdev()) }),
     56     maker.d2n({ name: "variance", fn: (d) => unpackDistResult(d.variance()) }),
     57     maker.d2n({ name: "min", fn: (d) => d.min() }),
     58     maker.d2n({ name: "max", fn: (d) => d.max() }),
     59     maker.d2n({ name: "mode", fn: (d) => unpackDistResult(d.mode()) }),
     60     maker.d2n({ name: "sample", fn: (d) => d.sample() }),
     61     maker.d2n({ name: "integralSum", fn: (d) => d.integralSum() }),
     62     maker.fromDefinition("sampleN", makeDefinition([frDist, frNumber], ([dist, n]) => {
     63         return vArray(dist.sampleN(n | 0).map(vNumber));
     64     })),
     65     maker.d2d({
     66         name: "exp",
     67         fn: (dist, env) => {
     68             return unpackDistResult(binaryOperations.algebraicPower(new SymbolicDist.PointMass(Math.E), dist, {
     69                 env,
     70             }));
     71         },
     72     }),
     73     maker.d2d({
     74         name: "normalize",
     75         fn: (d) => d.normalize(),
     76     }),
     77     maker.d2b({
     78         name: "isNormalized",
     79         fn: (d) => d.isNormalized(),
     80     }),
     81     maker.d2d({
     82         name: "toPointSet",
     83         fn: (d, env) => unpackDistResult(d.toPointSetDist(env)),
     84     }),
     85     maker.dn2n({
     86         name: "cdf",
     87         fn: (d, x) => d.cdf(x),
     88     }),
     89     maker.dn2n({
     90         name: "pdf",
     91         fn: (d, x, env) => unpackDistResult(d.pdf(x, { env })),
     92     }),
     93     maker.dn2n({
     94         name: "inv",
     95         fn: (d, x) => d.inv(x),
     96     }),
     97     maker.dn2n({
     98         name: "quantile",
     99         fn: (d, x) => d.inv(x),
    100     }),
    101     maker.dn2d({
    102         name: "truncateLeft",
    103         fn: (dist, x, env) => unpackDistResult(dist.truncate(x, undefined, { env })),
    104     }),
    105     maker.dn2d({
    106         name: "truncateRight",
    107         fn: (dist, x, env) => unpackDistResult(dist.truncate(undefined, x, { env })),
    108     }),
    109     maker.fromDefinition("truncate", makeDefinition([frDist, frNumber, frNumber], ([dist, left, right], { environment }) => distResultToValue(dist.truncate(left, right, { env: environment })))),
    110     maker.make({
    111         name: "sum",
    112         definitions: [
    113             makeDefinition([frArray(frDistOrNumber)], ([dists], { environment }) => distResultToValue(algebraicSum(dists.map(parseDistFromDistOrNumber), environment))),
    114         ],
    115     }),
    116     maker.make({
    117         name: "product",
    118         definitions: [
    119             makeDefinition([frArray(frDistOrNumber)], ([dists], { environment }) => distResultToValue(algebraicProduct(dists.map(parseDistFromDistOrNumber), environment))),
    120         ],
    121     }),
    122     maker.make({
    123         name: "cumsum",
    124         definitions: [
    125             makeDefinition([frArray(frDistOrNumber)], ([dists], { environment }) => distsResultToValue(algebraicCumSum(dists.map(parseDistFromDistOrNumber), environment))),
    126         ],
    127     }),
    128     maker.make({
    129         name: "cumprod",
    130         definitions: [
    131             makeDefinition([frArray(frDistOrNumber)], ([dists], { environment }) => distsResultToValue(algebraicCumProd(dists.map(parseDistFromDistOrNumber), environment))),
    132         ],
    133     }),
    134     maker.make({
    135         name: "diff",
    136         definitions: [
    137             makeDefinition([frArray(frDistOrNumber)], ([dists], { environment }) => distsResultToValue(algebraicDiff(dists.map(parseDistFromDistOrNumber), environment))),
    138         ],
    139     }),
    140     maker.d2d({
    141         name: "log",
    142         fn: (dist, env) => unpackDistResult(binaryOperations.algebraicLogarithm(dist, new SymbolicDist.PointMass(Math.E), { env })),
    143     }),
    144     maker.d2d({
    145         name: "log10",
    146         fn: (dist, env) => unpackDistResult(binaryOperations.algebraicLogarithm(dist, new SymbolicDist.PointMass(10), {
    147             env,
    148         })),
    149     }),
    150     maker.d2d({
    151         name: "unaryMinus",
    152         fn: (dist, env) => unpackDistResult(binaryOperations.algebraicMultiply(dist, new SymbolicDist.PointMass(-1), {
    153             env,
    154         })),
    155     }),
    156     maker.d2d({
    157         name: "dotExp",
    158         fn: (dist, env) => unpackDistResult(binaryOperations.pointwisePower(new SymbolicDist.PointMass(Math.E), dist, {
    159             env,
    160         })),
    161     }),
    162     ...makeOperationFns(),
    163 ];
    164 //# sourceMappingURL=genericDist.js.map