time-to-botec

SqPlot.js (6156B)

---

 import { SampleSetDist } from "../../dist/SampleSetDist/index.js";
 import * as Result from "../../utility/result.js";
 import { vPlot } from "../../value/index.js";
 import { SqOtherError } from "../SqError.js";
 import { SqSampleSetDistribution, wrapDistribution, } from "./SqDistribution/index.js";
 import { SqLambda } from "./SqLambda.js";
 import { wrapScale } from "./SqScale.js";
 import { SqPlotValue } from "./index.js";
 export function wrapPlot(value, context) {
     switch (value.type) {
         case "distributions":
             return new SqDistributionsPlot(value, context);
         case "numericFn":
             return new SqNumericFnPlot(value, context);
         case "distFn":
             return new SqDistFnPlot(value, context);
         case "scatter":
             return new SqScatterPlot(value, context);
         case "relativeValues":
             return new SqRelativeValuesPlot(value, context);
     }
 }
 class SqAbstractPlot {
     constructor(_value, context) {
         this._value = _value;
         this.context = context;
     }
     toString() {
         return vPlot(this._value).toString();
     }
     get asValue() {
         return new SqPlotValue(vPlot(this._value), this.context);
     }
     get title() {
         return this._value.title;
     }
 }
 export class SqDistributionsPlot extends SqAbstractPlot {
     constructor() {
         super(...arguments);
         this.tag = "distributions";
     }
     static create({ distribution, xScale, yScale, showSummary, title, }) {
         return new SqDistributionsPlot({
             type: "distributions",
             distributions: [{ distribution: distribution._value }],
             xScale: xScale._value,
             yScale: yScale._value,
             showSummary,
             title,
         });
     }
     get distributions() {
         return this._value.distributions.map(({ name, distribution }) => ({
             name,
             distribution: wrapDistribution(distribution),
         }));
     }
     get showSummary() {
         return this._value.showSummary;
     }
     get xScale() {
         return wrapScale(this._value.xScale);
     }
     get yScale() {
         return wrapScale(this._value.yScale);
     }
 }
 export class SqNumericFnPlot extends SqAbstractPlot {
     constructor() {
         super(...arguments);
         this.tag = "numericFn";
         this.createdProgrammatically = false;
     }
     static create({ fn, xScale, yScale, points, title, }) {
         const result = new SqNumericFnPlot({
             type: "numericFn",
             fn: fn._value,
             xScale: xScale._value,
             yScale: yScale._value,
             title: title,
             points,
         }, fn.context);
         result.createdProgrammatically = true;
         return result;
     }
     get fn() {
         return new SqLambda(this._value.fn, this.context
             ? this.createdProgrammatically
                 ? this.context
                 : this.context.extend({ type: "string", value: "fn" })
             : undefined);
     }
     get xScale() {
         return wrapScale(this._value.xScale);
     }
     get yScale() {
         return wrapScale(this._value.yScale);
     }
     get points() {
         return this._value.points;
     }
     toString() {
         return this.fn.toString();
     }
 }
 export class SqDistFnPlot extends SqAbstractPlot {
     constructor() {
         super(...arguments);
         this.tag = "distFn";
         this.createdProgrammatically = false;
     }
     static create({ fn, xScale, yScale, distXScale, title, points, }) {
         const result = new SqDistFnPlot({
             type: "distFn",
             fn: fn._value,
             xScale: xScale._value,
             yScale: yScale._value,
             distXScale: distXScale._value,
             title: title,
             points,
         }, fn.context);
         result.createdProgrammatically = true;
         return result;
     }
     get fn() {
         return new SqLambda(this._value.fn, this.context
             ? this.createdProgrammatically
                 ? this.context
                 : this.context.extend({ type: "string", value: "fn" })
             : undefined);
     }
     get xScale() {
         return wrapScale(this._value.xScale);
     }
     get yScale() {
         return wrapScale(this._value.yScale);
     }
     get distXScale() {
         return wrapScale(this._value.distXScale);
     }
     get points() {
         return this._value.points;
     }
     toString() {
         return this.fn.toString();
     }
 }
 export class SqScatterPlot extends SqAbstractPlot {
     constructor() {
         super(...arguments);
         this.tag = "scatter";
     }
     buildSampleSetDist(dist, env) {
         const sampleSetResult = SampleSetDist.fromDist(dist, env);
         if (!sampleSetResult.ok) {
             return Result.Err(new SqOtherError("Conversion to SampleSet failed"));
         }
         return Result.Ok(new SqSampleSetDistribution(sampleSetResult.value));
     }
     xDist(env) {
         return this.buildSampleSetDist(this._value.xDist, env);
     }
     yDist(env) {
         return this.buildSampleSetDist(this._value.yDist, env);
     }
     get xScale() {
         const scale = this._value.xScale;
         return scale ? wrapScale(scale) : undefined;
     }
     get yScale() {
         const scale = this._value.yScale;
         return scale ? wrapScale(scale) : undefined;
     }
     static zipToPoints(xDist, yDist) {
         const xSamples = xDist.getSamples();
         const ySamples = yDist.getSamples();
         if (xSamples.length !== ySamples.length) {
             throw new Error("Sample count mismatch");
         }
         const points = [];
         for (let i = 0; i < xSamples.length; i++) {
             points.push({ x: xSamples[i], y: ySamples[i] });
         }
         return points;
     }
 }
 export class SqRelativeValuesPlot extends SqAbstractPlot {
     constructor() {
         super(...arguments);
         this.tag = "relativeValues";
     }
     get ids() {
         return this._value.ids;
     }
     get fn() {
         return new SqLambda(this._value.fn, this.context
             ? this.context.extend({ type: "string", value: "fn" })
             : undefined);
     }
 }
 //# sourceMappingURL=SqPlot.js.map