@datagrok-libraries/statistics 1.6.0 → 1.8.0

package/src/fit/new-fit-API.js

@@ -0,0 +1,286 @@
+import * as DG from 'datagrok-api/dg';
+import { FIT_FUNCTION_LINEAR, linear, FIT_FUNCTION_SIGMOID, sigmoid, FIT_FUNCTION_LOG_LINEAR, logLinear, FIT_FUNCTION_EXPONENTIAL, exponential, FIT_FUNCTION_4PL_REGRESSION, fourPLRegression, getAuc, getDetCoeff, } from './fit-curve';
+import { fitSeries, getDataPoints } from './fit-data';
+/** Class for the fit functions */
+export class FitFunction {
+}
+export const FitFunctionTypes = {
+    SIGMOID: 'sigmoid',
+    LINEAR: 'linear',
+    LOG_LINEAR: 'log-linear',
+    EXPONENTIAL: 'exponential',
+    FOUR_PL_REGRESSION: '4pl-regression',
+};
+export class Fit {
+    constructor(values, data) {
+        this.auc = values.auc;
+        this.rSquared = values.rSquared;
+        this.series = data;
+    }
+}
+class LinearFit extends Fit {
+    get name() {
+        return FIT_FUNCTION_LINEAR;
+    }
+    constructor(values, data) {
+        super(values, data);
+        this.slope = values.slope;
+        this.intercept = values.intercept;
+    }
+}
+class LogLinearFit extends LinearFit {
+    get name() {
+        return FIT_FUNCTION_LOG_LINEAR;
+    }
+}
+class SigmoidFit extends Fit {
+    get name() {
+        return FIT_FUNCTION_SIGMOID;
+    }
+    constructor(values, data) {
+        super(values, data);
+        this.top = values.top;
+        this.slope = values.slope;
+        this.ic50 = values.ic50;
+        this.bottom = values.bottom;
+    }
+}
+class ExponentialFit extends Fit {
+    get name() {
+        return FIT_FUNCTION_EXPONENTIAL;
+    }
+    constructor(values, data) {
+        super(values, data);
+        this.mantissa = values.mantissa;
+        this.power = values.power;
+    }
+}
+class FourPLRegressionFit extends Fit {
+    get name() {
+        return FIT_FUNCTION_4PL_REGRESSION;
+    }
+    constructor(values, data) {
+        super(values, data);
+        this.top = values.top;
+        this.bottom = values.bottom;
+        this.slope = values.slope;
+        this.ec50 = values.ec50;
+    }
+}
+function getAucAndRsquared(fitCurve, data) {
+    return {
+        auc: getAuc(fitCurve, data),
+        rSquared: getDetCoeff(fitCurve, data),
+    };
+}
+/** Class that implements the linear function */
+export class LinearFunction extends FitFunction {
+    get name() {
+        return FIT_FUNCTION_LINEAR;
+    }
+    get parameterNames() {
+        return ['Slope', 'Intercept'];
+    }
+    fillParams(fitCurve, data) {
+        return new LinearFit({
+            ...getAucAndRsquared(fitCurve.fittedCurve, getDataPoints(data)),
+            slope: fitCurve.parameters[0],
+            intercept: fitCurve.parameters[1],
+        }, data);
+    }
+    y(params, x) {
+        return linear(params, x);
+    }
+    getInitialParameters(x, y) {
+        let minIndex = 0;
+        let maxIndex = 0;
+        for (let i = 1; i < x.length; i++) {
+            if (x[i] < x[minIndex])
+                minIndex = i;
+            if (x[i] > x[maxIndex])
+                maxIndex = i;
+        }
+        const deltaX = x[maxIndex] - x[minIndex];
+        const deltaY = y[maxIndex] - y[minIndex];
+        const A = deltaY / deltaX;
+        const B = y[maxIndex] - A * x[maxIndex];
+        const params = new Float32Array(2);
+        params.set([A, B]);
+        return params;
+    }
+}
+/** Class that implements the sigmoid function */
+export class SigmoidFunction extends FitFunction {
+    get name() {
+        return FIT_FUNCTION_SIGMOID;
+    }
+    get parameterNames() {
+        return ['Top', 'Slope', 'IC50', 'Bottom'];
+    }
+    fillParams(fitCurve, data) {
+        return new SigmoidFit({
+            ...getAucAndRsquared(fitCurve.fittedCurve, getDataPoints(data)),
+            top: fitCurve.parameters[0],
+            slope: fitCurve.parameters[1],
+            ic50: fitCurve.parameters[2],
+            bottom: fitCurve.parameters[3],
+        }, data);
+    }
+    y(params, x) {
+        return sigmoid(params, x);
+    }
+    getInitialParameters(x, y) {
+        const dataBounds = DG.Rect.fromXYArrays(x, y);
+        const medY = (dataBounds.maxY - dataBounds.minY) / 2 + dataBounds.minY;
+        let maxYInterval = dataBounds.maxY - dataBounds.minY;
+        let nearestXIndex = 0;
+        for (let i = 0; i < x.length; i++) {
+            const currentInterval = Math.abs(y[i] - medY);
+            if (currentInterval < maxYInterval) {
+                maxYInterval = currentInterval;
+                nearestXIndex = i;
+            }
+        }
+        const xAtMedY = x[nearestXIndex];
+        const slope = y[0] > y[y.length - 1] ? 1 : -1;
+        // params are: [max, tan, IC50, min]
+        const params = new Float32Array(4);
+        params.set([dataBounds.maxY, slope, xAtMedY, dataBounds.minY]);
+        return params;
+    }
+}
+/** Class that implements the linear logarithmic function */
+export class LogLinearFunction extends FitFunction {
+    get name() {
+        return FIT_FUNCTION_LOG_LINEAR;
+    }
+    get parameterNames() {
+        return ['Slope', 'Intercept'];
+    }
+    fillParams(fitCurve, data) {
+        return new LogLinearFit({
+            ...getAucAndRsquared(fitCurve.fittedCurve, getDataPoints(data)),
+            slope: fitCurve.parameters[0],
+            intercept: fitCurve.parameters[1],
+        }, data);
+    }
+    y(params, x) {
+        return logLinear(params, x);
+    }
+    getInitialParameters(x, y) {
+        const params = new Float32Array(2);
+        params.set([-5, 100]);
+        return params;
+    }
+}
+/** Class that implements the exponential function */
+export class ExponentialFunction extends FitFunction {
+    get name() {
+        return FIT_FUNCTION_EXPONENTIAL;
+    }
+    get parameterNames() {
+        return ['Mantissa', 'Power'];
+    }
+    fillParams(fitCurve, data) {
+        return new ExponentialFit({
+            ...getAucAndRsquared(fitCurve.fittedCurve, getDataPoints(data)),
+            mantissa: fitCurve.parameters[0],
+            power: fitCurve.parameters[1],
+        }, data);
+    }
+    y(params, x) {
+        return exponential(params, x);
+    }
+    getInitialParameters(x, y) {
+        const params = new Float32Array(2);
+        params.set([100, -2]);
+        return params;
+    }
+}
+/** Class that implements the Four Parameter Logistic Regression function */
+export class FourPLRegressionFunction extends FitFunction {
+    get name() {
+        return FIT_FUNCTION_4PL_REGRESSION;
+    }
+    get parameterNames() {
+        return ['Top', 'Slope', 'EC50', 'Bottom'];
+    }
+    fillParams(fitCurve, data) {
+        return new FourPLRegressionFit({
+            ...getAucAndRsquared(fitCurve.fittedCurve, getDataPoints(data)),
+            top: fitCurve.parameters[0],
+            slope: fitCurve.parameters[1],
+            ec50: fitCurve.parameters[2],
+            bottom: fitCurve.parameters[3],
+        }, data);
+    }
+    y(params, x) {
+        return fourPLRegression(params, x);
+    }
+    getInitialParameters(x, y) {
+        const params = new Float32Array(4);
+        const bottom = Math.min(...y);
+        const top = Math.max(...y);
+        const medY = (top - bottom) / 2 + bottom;
+        let maxYInterval = top - bottom;
+        let nearestXIndex = 0;
+        for (let i = 0; i < x.length; i++) {
+            const currentInterval = Math.abs(y[i] - medY);
+            if (currentInterval < maxYInterval) {
+                maxYInterval = currentInterval;
+                nearestXIndex = i;
+            }
+        }
+        const ec50 = x[nearestXIndex];
+        const slope = y[0] > y[y.length - 1] ? -10 : 10;
+        params.set([top, slope, ec50, bottom]);
+        return params;
+    }
+}
+// Object with fit functions
+export const fitFunctions = {
+    'linear': new LinearFunction(),
+    'sigmoid': new SigmoidFunction(),
+    'log-linear': new LogLinearFunction(),
+    'exponential': new ExponentialFunction(),
+    '4pl-regression': new FourPLRegressionFunction(),
+};
+class FitFunctions {
+    constructor(series) {
+        this.series = series;
+    }
+    linear() {
+        return fitFunctions[FIT_FUNCTION_LINEAR]
+            .fillParams(fitSeries(this.series, fitFunctions[FIT_FUNCTION_LINEAR]), this.series);
+    }
+    logLinear() {
+        return fitFunctions[FIT_FUNCTION_LOG_LINEAR]
+            .fillParams(fitSeries(this.series, fitFunctions[FIT_FUNCTION_LOG_LINEAR]), this.series);
+    }
+    sigmoid() {
+        return fitFunctions[FIT_FUNCTION_SIGMOID]
+            .fillParams(fitSeries(this.series, fitFunctions[FIT_FUNCTION_SIGMOID]), this.series);
+    }
+    exponential() {
+        return fitFunctions[FIT_FUNCTION_EXPONENTIAL]
+            .fillParams(fitSeries(this.series, fitFunctions[FIT_FUNCTION_EXPONENTIAL]), this.series);
+    }
+    fourPL() {
+        return fitFunctions[FIT_FUNCTION_4PL_REGRESSION]
+            .fillParams(fitSeries(this.series, fitFunctions[FIT_FUNCTION_4PL_REGRESSION]), this.series);
+    }
+}
+export class FitSeries {
+    constructor(points) {
+        this.points = points;
+        this.fit = new FitFunctions(this);
+    }
+}
+const series = new FitSeries([
+    { 'x': 0, 'y': 0 },
+    { 'x': 1, 'y': 0.5 },
+    { 'x': 2, 'y': 1 },
+    { 'x': 3, 'y': 10, 'outlier': true },
+    { 'x': 4, 'y': 0 },
+]);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"new-fit-API.js","sourceRoot":"","sources":["new-fit-API.ts"],"names":[],"mappings":"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","sourcesContent":["import * as DG from 'datagrok-api/dg';\nimport {\n  FIT_FUNCTION_LINEAR,\n  linear,\n  IFitSeries,\n  IFitPoint,\n  FIT_FUNCTION_SIGMOID,\n  sigmoid,\n  FIT_FUNCTION_LOG_LINEAR,\n  logLinear,\n  FIT_FUNCTION_EXPONENTIAL,\n  exponential,\n  FIT_FUNCTION_4PL_REGRESSION,\n  fourPLRegression,\n  IFitFunctionDescription,\n  FitParamBounds,\n  FitMarkerType,\n  FitOutlierMarkerType,\n  FitLineStyle,\n  FitErrorModelType, FitCurve, getAuc, getDetCoeff,\n} from './fit-curve';\nimport {fitSeries, getDataPoints} from './fit-data';\n\n\n/** Class for the fit functions */\nexport abstract class FitFunction<T> {\n  abstract get name(): string;\n  abstract get parameterNames(): string[];\n  abstract fillParams(fitCurve: FitCurve, data: FitSeries): T;\n  abstract y(params: Float32Array, x: number): number;\n  abstract getInitialParameters(x: number[], y: number[]): Float32Array;\n}\n\nexport const FitFunctionTypes = {\n  SIGMOID: 'sigmoid',\n  LINEAR: 'linear',\n  LOG_LINEAR: 'log-linear',\n  EXPONENTIAL: 'exponential',\n  FOUR_PL_REGRESSION: '4pl-regression',\n} as const;\n\nexport type FitFunctionType = typeof FitFunctionTypes[keyof typeof FitFunctionTypes];\n\ninterface IFit {\n  auc: number;\n  rSquared: number;\n}\n\ninterface ILinearFit extends IFit {\n  slope: number;\n  intercept: number;\n}\n\ninterface ILogLinearFit extends ILinearFit {}\n\ninterface ISigmoidFit extends IFit {\n  top: number;\n  slope: number;\n  ic50: number;\n  bottom: number;\n}\n\ninterface IExponentialFit extends IFit {\n  mantissa: number;\n  power: number;\n}\n\ninterface IFourPLRegressionFit extends IFit {\n  top: number;\n  bottom: number;\n  slope: number;\n  ec50: number;\n}\n\nexport abstract class Fit implements IFit {\n  auc: number;\n  rSquared: number;\n  series: FitSeries;\n\n  abstract get name(): string;\n\n  protected constructor(values: IFit, data: FitSeries) {\n    this.auc = values.auc;\n    this.rSquared = values.rSquared;\n    this.series = data;\n  }\n}\n\nclass LinearFit extends Fit implements ILinearFit {\n  slope: number;\n  intercept: number;\n\n  get name(): string {\n    return FIT_FUNCTION_LINEAR;\n  }\n\n  constructor(values: ILinearFit, data: FitSeries) {\n    super(values, data);\n    this.slope = values.slope;\n    this.intercept = values.intercept;\n  }\n}\n\nclass LogLinearFit extends LinearFit implements ILogLinearFit {\n  get name(): string {\n    return FIT_FUNCTION_LOG_LINEAR;\n  }\n}\n\nclass SigmoidFit extends Fit implements ISigmoidFit {\n  top: number;\n  slope: number;\n  ic50: number;\n  bottom: number;\n\n  get name(): string {\n    return FIT_FUNCTION_SIGMOID;\n  }\n\n  constructor(values: ISigmoidFit, data: FitSeries) {\n    super(values, data);\n    this.top = values.top;\n    this.slope = values.slope;\n    this.ic50 = values.ic50;\n    this.bottom = values.bottom;\n  }\n}\n\nclass ExponentialFit extends Fit implements IExponentialFit {\n  mantissa: number;\n  power: number;\n\n  get name(): string {\n    return FIT_FUNCTION_EXPONENTIAL;\n  }\n\n  constructor(values: IExponentialFit, data: FitSeries) {\n    super(values, data);\n    this.mantissa = values.mantissa;\n    this.power = values.power;\n  }\n}\n\nclass FourPLRegressionFit extends Fit implements IFourPLRegressionFit {\n  top: number;\n  bottom: number;\n  slope: number;\n  ec50: number;\n\n  get name(): string {\n    return FIT_FUNCTION_4PL_REGRESSION;\n  }\n\n  constructor(values: IFourPLRegressionFit, data: FitSeries) {\n    super(values, data);\n    this.top = values.top;\n    this.bottom = values.bottom;\n    this.slope = values.slope;\n    this.ec50 = values.ec50;\n  }\n}\n\nfunction getAucAndRsquared(fitCurve: (x: number) => number, data: {x: number[], y: number[]}): IFit {\n  return {\n    auc: getAuc(fitCurve, data),\n    rSquared: getDetCoeff(fitCurve, data),\n  };\n}\n\n/** Class that implements the linear function */\nexport class LinearFunction extends FitFunction<LinearFit> {\n  get name(): string {\n    return FIT_FUNCTION_LINEAR;\n  }\n\n  get parameterNames(): string[] {\n    return ['Slope', 'Intercept'];\n  }\n\n  fillParams(fitCurve: FitCurve, data: FitSeries): LinearFit {\n    return new LinearFit({\n      ...getAucAndRsquared(fitCurve.fittedCurve, getDataPoints(data)),\n      slope: fitCurve.parameters[0],\n      intercept: fitCurve.parameters[1],\n    }, data);\n  }\n\n  y(params: Float32Array, x: number): number {\n    return linear(params, x);\n  }\n\n  getInitialParameters(x: number[], y: number[]): Float32Array {\n    let minIndex = 0;\n    let maxIndex = 0;\n    for (let i = 1; i < x.length; i++) {\n      if (x[i] < x[minIndex])\n        minIndex = i;\n      if (x[i] > x[maxIndex])\n        maxIndex = i;\n    }\n\n    const deltaX = x[maxIndex] - x[minIndex];\n    const deltaY = y[maxIndex] - y[minIndex];\n    const A = deltaY / deltaX;\n    const B = y[maxIndex] - A * x[maxIndex];\n    const params = new Float32Array(2);\n    params.set([A, B]);\n    return params;\n  }\n}\n\n/** Class that implements the sigmoid function */\nexport class SigmoidFunction extends FitFunction<SigmoidFit> {\n  get name(): string {\n    return FIT_FUNCTION_SIGMOID;\n  }\n\n  get parameterNames(): string[] {\n    return ['Top', 'Slope', 'IC50', 'Bottom'];\n  }\n\n  fillParams(fitCurve: FitCurve, data: FitSeries): SigmoidFit {\n    return new SigmoidFit({\n      ...getAucAndRsquared(fitCurve.fittedCurve, getDataPoints(data)),\n      top: fitCurve.parameters[0],\n      slope: fitCurve.parameters[1],\n      ic50: fitCurve.parameters[2],\n      bottom: fitCurve.parameters[3],\n    }, data);\n  }\n\n  y(params: Float32Array, x: number): number {\n    return sigmoid(params, x);\n  }\n\n  getInitialParameters(x: number[], y: number[]): Float32Array {\n    const dataBounds = DG.Rect.fromXYArrays(x, y);\n    const medY = (dataBounds.maxY - dataBounds.minY) / 2 + dataBounds.minY;\n    let maxYInterval = dataBounds.maxY - dataBounds.minY;\n    let nearestXIndex = 0;\n    for (let i = 0; i < x.length; i++) {\n      const currentInterval = Math.abs(y[i] - medY);\n      if (currentInterval < maxYInterval) {\n        maxYInterval = currentInterval;\n        nearestXIndex = i;\n      }\n    }\n    const xAtMedY = x[nearestXIndex];\n    const slope = y[0] > y[y.length - 1] ? 1 : -1;\n\n    // params are: [max, tan, IC50, min]\n    const params = new Float32Array(4);\n    params.set([dataBounds.maxY, slope, xAtMedY, dataBounds.minY]);\n    return params;\n  }\n}\n\n/** Class that implements the linear logarithmic function */\nexport class LogLinearFunction extends FitFunction<LogLinearFit> {\n  get name(): string {\n    return FIT_FUNCTION_LOG_LINEAR;\n  }\n\n  get parameterNames(): string[] {\n    return ['Slope', 'Intercept'];\n  }\n\n  fillParams(fitCurve: FitCurve, data: FitSeries): LogLinearFit {\n    return new LogLinearFit({\n      ...getAucAndRsquared(fitCurve.fittedCurve, getDataPoints(data)),\n      slope: fitCurve.parameters[0],\n      intercept: fitCurve.parameters[1],\n    }, data);\n  }\n\n  y(params: Float32Array, x: number): number {\n    return logLinear(params, x);\n  }\n\n  getInitialParameters(x: number[], y: number[]): Float32Array {\n    const params = new Float32Array(2);\n    params.set([-5, 100]);\n    return params;\n  }\n}\n\n/** Class that implements the exponential function */\nexport class ExponentialFunction extends FitFunction<ExponentialFit> {\n  get name(): string {\n    return FIT_FUNCTION_EXPONENTIAL;\n  }\n\n  get parameterNames(): string[] {\n    return ['Mantissa', 'Power'];\n  }\n\n  fillParams(fitCurve: FitCurve, data: FitSeries): ExponentialFit {\n    return new ExponentialFit({\n      ...getAucAndRsquared(fitCurve.fittedCurve, getDataPoints(data)),\n      mantissa: fitCurve.parameters[0],\n      power: fitCurve.parameters[1],\n    }, data);\n  }\n\n  y(params: Float32Array, x: number): number {\n    return exponential(params, x);\n  }\n\n  getInitialParameters(x: number[], y: number[]): Float32Array {\n    const params = new Float32Array(2);\n    params.set([100, -2]);\n    return params;\n  }\n}\n\n/** Class that implements the Four Parameter Logistic Regression function */\nexport class FourPLRegressionFunction extends FitFunction<FourPLRegressionFit> {\n  get name(): string {\n    return FIT_FUNCTION_4PL_REGRESSION;\n  }\n\n  get parameterNames(): string[] {\n    return ['Top', 'Slope', 'EC50', 'Bottom'];\n  }\n\n  fillParams(fitCurve: FitCurve, data: FitSeries): FourPLRegressionFit {\n    return new FourPLRegressionFit({\n      ...getAucAndRsquared(fitCurve.fittedCurve, getDataPoints(data)),\n      top: fitCurve.parameters[0],\n      slope: fitCurve.parameters[1],\n      ec50: fitCurve.parameters[2],\n      bottom: fitCurve.parameters[3],\n    }, data);\n  }\n\n  y(params: Float32Array, x: number): number {\n    return fourPLRegression(params, x);\n  }\n\n  getInitialParameters(x: number[], y: number[]): Float32Array {\n    const params = new Float32Array(4);\n    const bottom = Math.min(...y);\n    const top = Math.max(...y);\n    const medY = (top - bottom) / 2 + bottom;\n    let maxYInterval = top -bottom;\n    let nearestXIndex = 0;\n    for (let i = 0; i < x.length; i++) {\n      const currentInterval = Math.abs(y[i] - medY);\n      if (currentInterval < maxYInterval) {\n        maxYInterval = currentInterval;\n        nearestXIndex = i;\n      }\n    }\n    const ec50 = x[nearestXIndex];\n    const slope = y[0] > y[y.length - 1]? -10 : 10;\n    params.set([top, slope, ec50, bottom]);\n    return params;\n  }\n}\n\n\n// Object with fit functions\nexport const fitFunctions = {\n  'linear': new LinearFunction(),\n  'sigmoid': new SigmoidFunction(),\n  'log-linear': new LogLinearFunction(),\n  'exponential': new ExponentialFunction(),\n  '4pl-regression': new FourPLRegressionFunction(),\n};\n\nclass FitFunctions {\n  series: FitSeries;\n\n  constructor(series: FitSeries) {\n    this.series = series;\n  }\n\n  linear(): LinearFit {\n    return fitFunctions[FIT_FUNCTION_LINEAR]\n      .fillParams(fitSeries(this.series, fitFunctions[FIT_FUNCTION_LINEAR]), this.series);\n  }\n\n  logLinear(): LogLinearFit {\n    return fitFunctions[FIT_FUNCTION_LOG_LINEAR]\n      .fillParams(fitSeries(this.series, fitFunctions[FIT_FUNCTION_LOG_LINEAR]), this.series);\n  }\n\n  sigmoid(): SigmoidFit {\n    return fitFunctions[FIT_FUNCTION_SIGMOID]\n      .fillParams(fitSeries(this.series, fitFunctions[FIT_FUNCTION_SIGMOID]), this.series);\n  }\n\n  exponential(): ExponentialFit {\n    return fitFunctions[FIT_FUNCTION_EXPONENTIAL]\n      .fillParams(fitSeries(this.series, fitFunctions[FIT_FUNCTION_EXPONENTIAL]), this.series);\n  }\n\n  fourPL(): FourPLRegressionFit {\n    return fitFunctions[FIT_FUNCTION_4PL_REGRESSION]\n      .fillParams(fitSeries(this.series, fitFunctions[FIT_FUNCTION_4PL_REGRESSION]), this.series);\n  }\n}\n\n\nexport class FitSeries implements IFitSeries {\n  [key: string]: any;\n\n  fit: FitFunctions;\n  points: IFitPoint[];\n\n  constructor(points: IFitPoint[]) {\n    this.points = points;\n    this.fit = new FitFunctions(this);\n  }\n\n  name?: string;                        // controls the series name\n  fitFunction?: string | IFitFunctionDescription; // controls the series fit function\n  parameters?: number[];                // controls the series parameters, auto-fitting when not defined\n  parameterBounds?: FitParamBounds[];   // defines the acceptable range of each parameter, which is taken into account during the fitting. See also `parameters`.\n  markerType?: FitMarkerType;           // defines the series marker type\n  outlierMarkerType?: FitOutlierMarkerType;  // defines the series outlier marker type\n  lineStyle?: FitLineStyle;             // defines the series line style\n  pointColor?: string;                  // overrides the standardized series point color\n  fitLineColor?: string;                // overrides the standardized series fit line color\n  confidenceIntervalColor?: string;     // overrides the standardized series confidence interval color\n  outlierColor?: string;                // overrides the standardized series outlier color\n  connectDots?: boolean;                // defines whether to connect the points with lines or not. If true and showFitLine is false - fitting is disabled - otherwise, it will be rendered accordingly to the parameter value.\n  showFitLine?: boolean;                // defines whether to show the fit line or not\n  showPoints?: string;                  // defines the data display mode\n  showCurveConfidenceInterval?: boolean;    // defines whether to show the confidence intervals or not\n  errorModel?: FitErrorModelType;       // defines the series error model\n  clickToToggle?: boolean;    // if true, clicking on the point toggles its outlier status and causes curve refitting\n  labels?: {[key: string]: string | number | boolean}; // controlled by IFitChartData labelOptions, shows labels\n  droplines?: string[];                 // defines the droplines that would be shown on the plot (IC50)\n  columnName?: string;                  // defines the column name where the series is stored\n}\n\n\nconst series: FitSeries = new FitSeries([\n  {'x': 0, 'y': 0},\n  {'x': 1, 'y': 0.5},\n  {'x': 2, 'y': 1},\n  {'x': 3, 'y': 10, 'outlier': true},\n  {'x': 4, 'y': 0},\n]);\n"]}

package/src/mpo/mpo-line-editor.d.ts

@@ -0,0 +1,10 @@
+import { DesirabilityLine, PropertyDesirability } from './mpo';
+import { Subject } from 'rxjs';
+export declare class MpoDesirabilityLineEditor {
+    root: HTMLDivElement;
+    onChanged: Subject<unknown>;
+    private _prop;
+    constructor(prop: PropertyDesirability, width: number, height: number);
+    get line(): DesirabilityLine;
+}
+//# sourceMappingURL=mpo-line-editor.d.ts.map

package/src/mpo/mpo-line-editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mpo-line-editor.d.ts","sourceRoot":"","sources":["mpo-line-editor.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,gBAAgB,EAAE,oBAAoB,EAAC,MAAM,OAAO,CAAC;AAC7D,OAAO,EAAC,OAAO,EAAC,MAAM,MAAM,CAAC;AAO7B,qBAAa,yBAAyB;IACpC,IAAI,iBAAY;IAChB,SAAS,mBAAiB;IAC1B,OAAO,CAAC,KAAK,CAAuB;gBAExB,IAAI,EAAE,oBAAoB,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IA6PrE,IAAI,IAAI,IAAI,gBAAgB,CAE3B;CACF"}