@datagrok-libraries/statistics 1.1.8 → 1.2.1

package/src/fit/fit-curve.js

@@ -0,0 +1,422 @@
+/* eslint-disable no-multi-spaces */
+import * as DG from 'datagrok-api/dg';
+import { Property } from 'datagrok-api/src/entities';
+import { TYPE } from 'datagrok-api/src/const';
+import { limitedMemoryBFGS } from '../../lbfgs/lbfgs';
+//@ts-ignore: no types
+import * as jStat from 'jstat';
+export var FitErrorModel;
+(function (FitErrorModel) {
+    FitErrorModel[FitErrorModel["Constant"] = 0] = "Constant";
+    FitErrorModel[FitErrorModel["Proportional"] = 1] = "Proportional";
+})(FitErrorModel || (FitErrorModel = {}));
+/**
+ *  Datagrok curve fitting
+ *
+ * - Fitting: computing parameters of the specified function to best fit the data
+ *   - Uses BFGS optimization algorithm (multi-threading for performance).
+ *     For dose-response curves, we are typically fitting the sigmoid function
+ *   - Ability to dynamically register custom fitting functions
+ *     - Automatic fit function determination
+ *     - Caching of custom fitting functions
+ *   - Ability to get fitting performance characteristics (r-squared, classification, etc)
+ * - Deep integration with the Datagrok grid
+ *   - Either fitting on the fly, or using the supplied function + parameters
+ *   - Multiple series in one cell
+ *   - Candlesticks, confidence intervals, and droplines drawing
+ *   - Ability to define chart, marker, or fitting options (such as fit function or marker color)
+ *     on the column level, with the ability to override it on a grid cell or point level
+ *   - Clicking a point in a chart within a grid makes it an outlier -> curve is re-fitted on the fly
+ *   - Ability to specify a chart as "reference" so that it is shown on every other chart for comparison
+ * - Ability to overlay curves from multiple grid cells (special viewer)
+ * - Work with series stored in multiple formats (binary for performance, json for flexibility, etc)
+*/
+export const FIT_SEM_TYPE = 'fit';
+export const FIT_CELL_TYPE = 'fit';
+export const TAG_FIT = '.fit';
+export const CONFIDENCE_INTERVAL_STROKE_COLOR = 'rgba(255,191,63,0.4)';
+export const CONFIDENCE_INTERVAL_FILL_COLOR = 'rgba(255,238,204,0.3)';
+export const CURVE_CONFIDENCE_INTERVAL_BOUNDS = {
+    TOP: 'top',
+    BOTTOM: 'bottom',
+};
+export const DROPLINES = ['IC50'];
+/** Class that implements {@link IFitChartData} interface */
+export class FitChartData {
+    constructor() {
+        this.chartOptions = {};
+        this.seriesOptions = {}; // Default series options. Individual series can override it.
+        this.series = [];
+    }
+}
+// TODO: show labels in property panel if present, color by default from series
+/** Properties that describe {@link FitStatistics}. Useful for editing, initialization, transformations, etc. */
+export const statisticsProperties = [
+    Property.js('rSquared', TYPE.FLOAT, { userEditable: false }),
+    Property.js('auc', TYPE.FLOAT, { userEditable: false }),
+    Property.js('interceptY', TYPE.FLOAT, { userEditable: false }),
+    Property.js('interceptX', TYPE.FLOAT, { userEditable: false }),
+    Property.js('slope', TYPE.FLOAT, { userEditable: false }),
+    Property.js('top', TYPE.FLOAT, { userEditable: false }),
+    Property.js('bottom', TYPE.FLOAT, { userEditable: false }),
+];
+/** Properties that describe {@link IFitChartOptions}. Useful for editing, initialization, transformations, etc. */
+export const fitChartDataProperties = [
+    // Style and zoom
+    Property.js('minX', TYPE.FLOAT, { description: 'Minimum value of the X axis', nullable: true }),
+    Property.js('minY', TYPE.FLOAT, { description: 'Minimum value of the Y axis', nullable: true }),
+    Property.js('maxX', TYPE.FLOAT, { description: 'Maximum value of the X axis', nullable: true }),
+    Property.js('maxY', TYPE.FLOAT, { description: 'Maximum value of the Y axis', nullable: true }),
+    Property.js('xAxisName', TYPE.STRING, { description: 'Label to show on the X axis. If not specified, corresponding data column name is used', nullable: true }),
+    Property.js('yAxisName', TYPE.STRING, { description: 'Label to show on the Y axis. If not specified, corresponding data column name is used', nullable: true }),
+    Property.js('logX', TYPE.BOOL, { defaultValue: false }),
+    Property.js('logY', TYPE.BOOL, { defaultValue: false }),
+    Property.js('showStatistics', TYPE.STRING_LIST, { choices: statisticsProperties.map((frp) => frp.name),
+        inputType: 'MultiChoice' }),
+];
+/** Properties that describe {@link IFitSeriesOptions}. Useful for editing, initialization, transformations, etc. */
+export const fitSeriesProperties = [
+    Property.js('name', TYPE.STRING),
+    Property.js('fitFunction', TYPE.STRING, { category: 'Fitting', choices: ['sigmoid', 'linear'], defaultValue: 'sigmoid' }),
+    Property.js('pointColor', TYPE.STRING, { category: 'Rendering', defaultValue: DG.Color.toHtml(DG.Color.scatterPlotMarker), nullable: true,
+        inputType: 'Color' }),
+    Property.js('fitLineColor', TYPE.STRING, { category: 'Rendering', defaultValue: DG.Color.toHtml(DG.Color.scatterPlotMarker), nullable: true,
+        inputType: 'Color' }),
+    Property.js('clickToToggle', TYPE.BOOL, { category: 'Fitting', description: 'If true, clicking on the point toggles its outlier status and causes curve refitting', nullable: true, defaultValue: false }),
+    Property.js('showFitLine', TYPE.BOOL, { category: 'Fitting', description: 'Whether the fit line should be rendered', defaultValue: true }),
+    Property.js('showPoints', TYPE.STRING, { category: 'Fitting', description: 'Whether points/candlesticks/none should be rendered',
+        defaultValue: 'points', choices: ['points', 'candlesticks', 'both'] }),
+    Property.js('showCurveConfidenceInterval', TYPE.BOOL, { category: 'Fitting', description: 'Whether confidence intervals should be rendered', defaultValue: false }),
+    Property.js('markerType', TYPE.STRING, { category: 'Rendering', description: 'Marker type used when rendering',
+        defaultValue: 'circle', choices: ['asterisk', 'circle', 'cross border', 'diamond', 'square', 'star',
+            'triangle bottom', 'triangle left', 'triangle right', 'triangle top'], nullable: false }),
+    Property.js('droplines', TYPE.STRING_LIST, { choices: DROPLINES, inputType: 'MultiChoice' }),
+];
+export const FIT_FUNCTION_SIGMOID = 'sigmoid';
+export const FIT_FUNCTION_LINEAR = 'linear';
+export const FIT_STATS_RSQUARED = 'rSquared';
+export const FIT_STATS_AUC = 'auc';
+// TODO?: add method to return parameters - get parameters from fit function
+/** Class for the fit functions */
+export class FitFunction {
+}
+/** Class that implements the linear function */
+export class LinearFunction extends FitFunction {
+    get name() {
+        return FIT_FUNCTION_LINEAR;
+    }
+    get parameterNames() {
+        return ['Slope', 'Intercept'];
+    }
+    y(params, x) {
+        throw new Error('Not implemented');
+    }
+    getInitialParameters(x, y) {
+        throw new Error('Not implemented');
+    }
+}
+/** Class that implements the sigmoid function */
+export class SigmoidFunction extends FitFunction {
+    get name() {
+        return FIT_FUNCTION_SIGMOID;
+    }
+    get parameterNames() {
+        return ['Top', 'Bottom', 'Slope', 'IC50'];
+    }
+    y(params, x) {
+        return sigmoid(params, x);
+    }
+    getInitialParameters(x, y) {
+        const dataBounds = DG.Rect.fromXYArrays(x, y);
+        const medY = (dataBounds.bottom - dataBounds.top) / 2 + dataBounds.top;
+        let maxYInterval = dataBounds.bottom - dataBounds.top;
+        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.2 : -1.2;
+        // params are: [max, tan, IC50, min]
+        return [dataBounds.bottom, slope, xAtMedY, dataBounds.top];
+    }
+}
+/** Class that implements user JS functions */
+export class JsFunction extends FitFunction {
+    constructor(name, yFunc, getInitParamsFunc, parameterNames) {
+        super();
+        this._name = name;
+        this._parameterNames = parameterNames;
+        this.y = yFunc;
+        this.getInitialParameters = getInitParamsFunc;
+    }
+    get name() {
+        return this._name;
+    }
+    get parameterNames() {
+        return this._parameterNames;
+    }
+    y(params, x) {
+        throw new Error('Not implemented');
+    }
+    getInitialParameters(x, y) {
+        throw new Error('Not implemented');
+    }
+}
+// Object with fit functions
+export const fitFunctions = {
+    'linear': new LinearFunction(),
+    'sigmoid': new SigmoidFunction(),
+};
+function createObjectiveFunction(errorModel) {
+    let of;
+    switch (errorModel) {
+        case FitErrorModel.Constant:
+            of = objectiveNormalConstant;
+            break;
+        case FitErrorModel.Proportional:
+            of = objectiveNormalProportional;
+            break;
+        default:
+            of = objectiveNormalConstant;
+            break;
+    }
+    return of;
+}
+function createOptimizable(data, curveFunction, of, fixed) {
+    return {
+        getValue: (parameters) => {
+            return of(curveFunction, data, parameters).value;
+        },
+        getGradient: (parameters, gradient) => {
+            for (let i = 0; i < parameters.length; i++)
+                gradient[i] = fixed.includes(i) ? 0 : getObjectiveDerivative(of, curveFunction, data, parameters, i);
+            return gradient;
+        },
+    };
+}
+export function getOrCreateFitFunction(seriesFitFunc) {
+    if (typeof seriesFitFunc === 'string')
+        return fitFunctions[seriesFitFunc];
+    else if (!fitFunctions[seriesFitFunc.name]) {
+        const name = seriesFitFunc.name;
+        const paramNames = seriesFitFunc.parameterNames;
+        const fitFunctionParts = seriesFitFunc.function.split('=>').map((elem) => elem.trim());
+        const getInitParamsParts = seriesFitFunc.getInitialParameters.split('=>').map((elem) => elem.trim());
+        const fitFunction = new Function(fitFunctionParts[0].slice(1, fitFunctionParts[0].length - 1), `${fitFunctionParts[1].includes(';') ? '' : 'return '}${fitFunctionParts[1]}`);
+        const getInitParamsFunc = new Function(getInitParamsParts[0].slice(1, getInitParamsParts[0].length - 1), `return ${getInitParamsParts[1]}`);
+        const fitFunc = new JsFunction(name, fitFunction, getInitParamsFunc, paramNames);
+        fitFunctions[name] = fitFunc;
+    }
+    return fitFunctions[seriesFitFunc.name];
+}
+export function fitData(data, fitFunction, errorModel, parameterBounds) {
+    var _a, _b;
+    const curveFunction = fitFunction.y;
+    const paramValues = fitFunction.getInitialParameters(data.x, data.y);
+    const of = createObjectiveFunction(errorModel);
+    const fixed = [];
+    let overLimits = true;
+    while (overLimits) {
+        const optimizable = createOptimizable(data, curveFunction, of, fixed);
+        limitedMemoryBFGS(optimizable, paramValues);
+        limitedMemoryBFGS(optimizable, paramValues);
+        overLimits = false;
+        if (!parameterBounds)
+            break;
+        for (let i = 0; i < parameterBounds.length; i++) {
+            if (((_a = parameterBounds[i]) === null || _a === void 0 ? void 0 : _a.maxBound) !== undefined && paramValues[i] > parameterBounds[i].maxBound) {
+                overLimits = true;
+                fixed.push(i);
+                paramValues[i] = parameterBounds[i].maxBound;
+                break;
+            }
+            if (((_b = parameterBounds[i]) === null || _b === void 0 ? void 0 : _b.minBound) !== undefined && paramValues[i] < parameterBounds[i].minBound) {
+                overLimits = true;
+                fixed.push(i);
+                paramValues[i] = parameterBounds[i].minBound;
+                break;
+            }
+        }
+    }
+    const fittedCurve = getFittedCurve(curveFunction, paramValues);
+    return {
+        fittedCurve: fittedCurve,
+        parameters: paramValues,
+    };
+}
+export function getFittedCurve(curveFunction, paramValues) {
+    return (x) => {
+        return curveFunction(paramValues, x);
+    };
+}
+export function getCurveConfidenceIntervals(data, paramValues, curveFunction, confidenceLevel = 0.05, errorModel) {
+    const of = createObjectiveFunction(errorModel);
+    const error = errorModel === FitErrorModel.Proportional ?
+        of(curveFunction, data, paramValues).mult :
+        of(curveFunction, data, paramValues).const;
+    const quantile = jStat.normal.inv(1 - confidenceLevel / 2, 0, 1);
+    const top = (x) => {
+        const value = curveFunction(paramValues, x);
+        if (errorModel === FitErrorModel.Constant)
+            return value + quantile * error;
+        else
+            return value + quantile * Math.abs(value) * error;
+    };
+    const bottom = (x) => {
+        const value = curveFunction(paramValues, x);
+        if (errorModel === FitErrorModel.Constant)
+            return value - quantile * error;
+        else
+            return value - quantile * Math.abs(value) * error;
+    };
+    return { confidenceTop: top, confidenceBottom: bottom };
+}
+export function getStatistics(data, paramValues, curveFunction, statistics = true) {
+    const fittedCurve = getFittedCurve(curveFunction, paramValues);
+    return {
+        rSquared: statistics ? getDetCoeff(fittedCurve, data) : undefined,
+        auc: statistics ? getAuc(fittedCurve, data) : undefined,
+        interceptX: paramValues[2],
+        interceptY: fittedCurve(paramValues[2]),
+        slope: paramValues[1],
+        top: paramValues[0],
+        bottom: paramValues[3],
+    };
+}
+export function getInvertedFunctions(data, paramValues, confidenceLevel = 0.05, statistics = true) {
+    const studentQ = jStat.studentt.inv(1 - confidenceLevel / 2, data.x.length - paramValues.length);
+    let inv = (y) => {
+        return 0;
+    };
+    let invTop = (y) => {
+        return 0;
+    };
+    let invBottom = (y) => {
+        return 0;
+    };
+    if (statistics) {
+        inv = (y) => {
+            //should check if more than bottom and less than top
+            return paramValues[2] / Math.pow((paramValues[0] - y) / (y - paramValues[3]), 1 / paramValues[1]);
+        };
+        const error = getInvError(inv, data);
+        invTop = (y) => {
+            const value = inv(y);
+            return value + studentQ * error / Math.sqrt(data.y.length);
+        };
+        invBottom = (y) => {
+            const value = inv(y);
+            return value - studentQ * error / Math.sqrt(data.y.length);
+        };
+        return {
+            inverted: inv,
+            invertedTop: invTop,
+            invertedBottom: invBottom,
+        };
+    }
+    return null;
+}
+export function sigmoid(params, x) {
+    const A = params[0];
+    const B = params[1];
+    const C = params[2];
+    const D = params[3];
+    return (D + (A - D) / (1 + Math.pow(10, (x - C) * B)));
+}
+export function getAuc(fittedCurve, data) {
+    let auc = 0;
+    const min = Math.min(...data.x);
+    const max = Math.max(...data.x);
+    const integrationStep = (max - min) / 1000;
+    for (let x = min; x < max; x += integrationStep)
+        auc += integrationStep * fittedCurve(x);
+    return auc;
+}
+export function getDetCoeff(fittedCurve, data) {
+    let ssRes = 0;
+    let ssTot = 0;
+    const yMean = jStat.mean(data.y);
+    for (let i = 0; i < data.x.length; i++) {
+        ssRes += Math.pow(data.y[i] - fittedCurve(data.x[i]), 2);
+        ssTot += Math.pow(data.y[i] - yMean, 2);
+    }
+    return 1 - ssRes / ssTot;
+}
+function getInvError(targetFunc, data) {
+    let sigma = 0;
+    let sigmaSq = 0;
+    const residuesSquares = new Float32Array(data.y.length);
+    for (let i = 0; i < data.y.length; i++) {
+        const obs = data.x[i];
+        const pred = targetFunc(data.y[i]);
+        residuesSquares[i] = Math.pow(obs - pred, 2);
+    }
+    for (let i = 0; i < residuesSquares.length; i++)
+        sigmaSq += residuesSquares[i];
+    sigmaSq /= residuesSquares.length;
+    sigma = Math.sqrt(sigmaSq);
+    return sigma;
+}
+function getObjectiveDerivative(of, curveFunction, data, params, selectedParam) {
+    const step = (params[selectedParam] * 0.0001) === 0 ? 0.001 : (params[selectedParam] * 0.0001);
+    const paramsTop = [];
+    const paramsBottom = [];
+    for (let i = 0; i < params.length; i++) {
+        if (i === selectedParam) {
+            paramsTop.push(params[i] + step);
+            paramsBottom.push(params[i] - step);
+        }
+        else {
+            paramsTop.push(params[i]);
+            paramsBottom.push(params[i]);
+        }
+    }
+    const drvTop = of(curveFunction, data, paramsTop).value;
+    const drvBottom = of(curveFunction, data, paramsBottom).value;
+    return (drvTop - drvBottom) / (2 * step);
+}
+function objectiveNormalConstant(targetFunc, data, params) {
+    //assure observed and args same length
+    const pi = Math.PI;
+    let sigma = 0;
+    let sigmaSq = 0;
+    let likelihood = 0;
+    const residuesSquares = new Float32Array(data.x.length);
+    for (let i = 0; i < data.x.length; i++) {
+        const obs = data.y[i];
+        const pred = targetFunc(params, data.x[i]);
+        residuesSquares[i] = Math.pow(obs - pred, 2);
+    }
+    for (let i = 0; i < residuesSquares.length; i++)
+        sigmaSq += residuesSquares[i];
+    sigmaSq /= residuesSquares.length;
+    sigma = Math.sqrt(sigmaSq);
+    for (let i = 0; i < residuesSquares.length; i++)
+        likelihood += residuesSquares[i] / sigmaSq + Math.log(2 * pi * sigmaSq);
+    return { value: -likelihood, const: sigma, mult: 0 };
+}
+function objectiveNormalProportional(targetFunc, data, params) {
+    //assure observed and args same length
+    const pi = Math.PI;
+    let sigma = 0;
+    let sigmaSq = 0;
+    let likelihood = 0;
+    const residuesSquares = new Float32Array(data.x.length);
+    for (let i = 0; i < data.x.length; i++) {
+        const obs = data.y[i];
+        const pred = targetFunc(params, data.x[i]);
+        residuesSquares[i] = Math.pow(obs - pred, 2);
+    }
+    for (let i = 0; i < residuesSquares.length; i++)
+        sigmaSq += residuesSquares[i];
+    sigmaSq /= residuesSquares.length;
+    sigma = Math.sqrt(sigmaSq);
+    for (let i = 0; i < residuesSquares.length; i++)
+        likelihood += residuesSquares[i] / sigmaSq + Math.log(2 * pi * sigmaSq);
+    return { value: -likelihood, const: sigma, mult: 0 };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fit-curve.js","sourceRoot":"","sources":["fit-curve.ts"],"names":[],"mappings":"AAAA,oCAAoC;AACpC,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACtC,OAAO,EAAC,QAAQ,EAAC,MAAM,2BAA2B,CAAC;AACnD,OAAO,EAAC,IAAI,EAAC,MAAM,wBAAwB,CAAC;AAE5C,OAAO,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AACpD,sBAAsB;AACtB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAiB/B,MAAM,CAAN,IAAY,aAGX;AAHD,WAAY,aAAa;IACvB,yDAAQ,CAAA;IACR,iEAAY,CAAA;AACd,CAAC,EAHW,aAAa,KAAb,aAAa,QAGxB;AA0CD;;;;;;;;;;;;;;;;;;;;EAoBE;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG,KAAK,CAAC;AAClC,MAAM,CAAC,MAAM,aAAa,GAAG,KAAK,CAAC;AACnC,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC;AAE9B,MAAM,CAAC,MAAM,gCAAgC,GAAG,sBAAsB,CAAC;AACvE,MAAM,CAAC,MAAM,8BAA8B,GAAG,uBAAuB,CAAC;AAEtE,MAAM,CAAC,MAAM,gCAAgC,GAAG;IAC9C,GAAG,EAAE,KAAK;IACV,MAAM,EAAE,QAAQ;CACjB,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC;AAqDlC,4DAA4D;AAC5D,MAAM,OAAO,YAAY;IAAzB;QACE,iBAAY,GAAqB,EAAE,CAAC;QACpC,kBAAa,GAAsB,EAAE,CAAC,CAAE,6DAA6D;QACrG,WAAM,GAAiB,EAAE,CAAC;IAC5B,CAAC;CAAA;AAmBD,+EAA+E;AAG/E,gHAAgH;AAChH,MAAM,CAAC,MAAM,oBAAoB,GAAe;IAC9C,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,IAAI,CAAC,KAAK,EAAE,EAAC,YAAY,EAAE,KAAK,EAAC,CAAC;IAC1D,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,EAAC,YAAY,EAAE,KAAK,EAAC,CAAC;IACrD,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,IAAI,CAAC,KAAK,EAAE,EAAC,YAAY,EAAE,KAAK,EAAC,CAAC;IAC5D,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,IAAI,CAAC,KAAK,EAAE,EAAC,YAAY,EAAE,KAAK,EAAC,CAAC;IAC5D,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,EAAE,EAAC,YAAY,EAAE,KAAK,EAAC,CAAC;IACvD,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,EAAC,YAAY,EAAE,KAAK,EAAC,CAAC;IACrD,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,EAAE,EAAC,YAAY,EAAE,KAAK,EAAC,CAAC;CACzD,CAAC;AAEF,mHAAmH;AACnH,MAAM,CAAC,MAAM,sBAAsB,GAAe;IAChD,iBAAiB;IACjB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,EAAE,EAAC,WAAW,EAAE,6BAA6B,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC;IAC7F,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,EAAE,EAAC,WAAW,EAAE,6BAA6B,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC;IAC7F,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,EAAE,EAAC,WAAW,EAAE,6BAA6B,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC;IAC7F,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,EAAE,EAAC,WAAW,EAAE,6BAA6B,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC;IAC7F,QAAQ,CAAC,EAAE,CAAC,WAAW,EAAE,IAAI,CAAC,MAAM,EAAE,EAAC,WAAW,EAChD,uFAAuF,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC;IAC3G,QAAQ,CAAC,EAAE,CAAC,WAAW,EAAE,IAAI,CAAC,MAAM,EAAE,EAAC,WAAW,EAChD,uFAAuF,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC;IAC3G,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,EAAE,EAAC,YAAY,EAAE,KAAK,EAAC,CAAC;IACrD,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,EAAE,EAAC,YAAY,EAAE,KAAK,EAAC,CAAC;IACrD,QAAQ,CAAC,EAAE,CAAC,gBAAgB,EAAE,IAAI,CAAC,WAAW,EAAE,EAAC,OAAO,EAAE,oBAAoB,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC;QACnG,SAAS,EAAE,aAAa,EAAC,CAAC;CAC7B,CAAC;AAEF,oHAAoH;AACpH,MAAM,CAAC,MAAM,mBAAmB,GAAe;IAC7C,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC;IAChC,QAAQ,CAAC,EAAE,CAAC,aAAa,EAAE,IAAI,CAAC,MAAM,EACpC,EAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC,EAAE,YAAY,EAAE,SAAS,EAAC,CAAC;IACjF,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,IAAI,CAAC,MAAM,EACnC,EAAC,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,IAAI;QAC/F,SAAS,EAAE,OAAO,EAAC,CAAC;IACxB,QAAQ,CAAC,EAAE,CAAC,cAAc,EAAE,IAAI,CAAC,MAAM,EACrC,EAAC,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,IAAI;QAC/F,SAAS,EAAE,OAAO,EAAC,CAAC;IACxB,QAAQ,CAAC,EAAE,CAAC,eAAe,EAAE,IAAI,CAAC,IAAI,EAAE,EAAC,QAAQ,EAAE,SAAS,EAAE,WAAW,EACvE,sFAAsF,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAC,CAAC;IAC/H,QAAQ,CAAC,EAAE,CAAC,aAAa,EAAE,IAAI,CAAC,IAAI,EAClC,EAAC,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,yCAAyC,EAAE,YAAY,EAAE,IAAI,EAAC,CAAC;IACpG,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,IAAI,CAAC,MAAM,EACnC,EAAC,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,qDAAqD;QACtF,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,QAAQ,EAAE,cAAc,EAAE,MAAM,CAAC,EAAC,CAAC;IACzE,QAAQ,CAAC,EAAE,CAAC,6BAA6B,EAAE,IAAI,CAAC,IAAI,EAClD,EAAC,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,iDAAiD,EAAE,YAAY,EAAE,KAAK,EAAC,CAAC;IAC7G,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,IAAI,CAAC,MAAM,EAAE,EAAC,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,iCAAiC;QAC3G,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,UAAU,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM;YACjG,iBAAiB,EAAE,eAAe,EAAE,gBAAgB,EAAE,cAAc,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAC,CAAC;IAC5F,QAAQ,CAAC,EAAE,CAAC,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,EAAC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAC,CAAC;CAC3F,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,SAAS,CAAC;AAC9C,MAAM,CAAC,MAAM,mBAAmB,GAAG,QAAQ,CAAC;AAE5C,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;AAC7C,MAAM,CAAC,MAAM,aAAa,GAAG,KAAK,CAAC;AAGnC,4EAA4E;AAC5E,kCAAkC;AAClC,MAAM,OAAgB,WAAW;CAKhC;AAED,gDAAgD;AAChD,MAAM,OAAO,cAAe,SAAQ,WAAW;IAC7C,IAAI,IAAI;QACN,OAAO,mBAAmB,CAAC;IAC7B,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IAChC,CAAC;IAED,CAAC,CAAC,MAAgB,EAAE,CAAS;QAC3B,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;IAED,oBAAoB,CAAC,CAAW,EAAE,CAAW;QAC3C,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;CACF;AAED,iDAAiD;AACjD,MAAM,OAAO,eAAgB,SAAQ,WAAW;IAC9C,IAAI,IAAI;QACN,OAAO,oBAAoB,CAAC;IAC9B,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAC5C,CAAC;IAED,CAAC,CAAC,MAAgB,EAAE,CAAS;QAC3B,OAAO,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAC5B,CAAC;IAED,oBAAoB,CAAC,CAAW,EAAE,CAAW;QAC3C,MAAM,UAAU,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC9C,MAAM,IAAI,GAAG,CAAC,UAAU,CAAC,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC;QACvE,IAAI,YAAY,GAAG,UAAU,CAAC,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC;QACtD,IAAI,aAAa,GAAG,CAAC,CAAC;QACtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACjC,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;YAC9C,IAAI,eAAe,GAAG,YAAY,EAAE;gBAClC,YAAY,GAAG,eAAe,CAAC;gBAC/B,aAAa,GAAG,CAAC,CAAC;aACnB;SACF;QACD,MAAM,OAAO,GAAG,CAAC,CAAC,aAAa,CAAC,CAAC;QACjC,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;QAElD,oCAAoC;QACpC,OAAO,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC;IAC7D,CAAC;CACF;AAED,8CAA8C;AAC9C,MAAM,OAAO,UAAW,SAAQ,WAAW;IAIzC,YAAY,IAAY,EAAE,KAA8C,EACtE,iBAAyD,EAAE,cAAwB;QACnF,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC;QAEtC,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC;QACf,IAAI,CAAC,oBAAoB,GAAG,iBAAiB,CAAC;IAChD,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED,CAAC,CAAC,MAAgB,EAAE,CAAS;QAC3B,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;IAED,oBAAoB,CAAC,CAAW,EAAE,CAAW;QAC3C,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;CACF;AAED,4BAA4B;AAC5B,MAAM,CAAC,MAAM,YAAY,GAAmC;IAC1D,QAAQ,EAAE,IAAI,cAAc,EAAE;IAC9B,SAAS,EAAE,IAAI,eAAe,EAAE;CACjC,CAAC;AASF,SAAS,uBAAuB,CAAC,UAAyB;IACxD,IAAI,EAAqB,CAAC;IAE1B,QAAQ,UAAU,EAAE;QACpB,KAAK,aAAa,CAAC,QAAQ;YACzB,EAAE,GAAG,uBAAuB,CAAC;YAC7B,MAAM;QACR,KAAK,aAAa,CAAC,YAAY;YAC7B,EAAE,GAAG,2BAA2B,CAAC;YACjC,MAAM;QACR;YACE,EAAE,GAAG,uBAAuB,CAAC;YAC7B,MAAM;KACP;IAED,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,SAAS,iBAAiB,CAAC,IAAgC,EAAE,aAAsD,EACjH,EAAqB,EAAE,KAAe;IACtC,OAAO;QACL,QAAQ,EAAE,CAAC,UAAoB,EAAE,EAAE;YACjC,OAAO,EAAE,CAAC,aAAa,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,KAAK,CAAC;QACnD,CAAC;QACD,WAAW,EAAE,CAAC,UAAoB,EAAE,QAAkB,EAAE,EAAE;YACxD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE;gBACxC,QAAQ,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,sBAAsB,CAAC,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC;YAEvG,OAAO,QAAQ,CAAC;QAClB,CAAC;KACF,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,aAA+C;IACpF,IAAI,OAAO,aAAa,KAAK,QAAQ;QACnC,OAAO,YAAY,CAAC,aAAa,CAAC,CAAC;SAChC,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE;QAC1C,MAAM,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC;QAChC,MAAM,UAAU,GAAG,aAAa,CAAC,cAAc,CAAC;QAChD,MAAM,gBAAgB,GAAG,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACvF,MAAM,kBAAkB,GAAG,aAAa,CAAC,oBAAoB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACrG,MAAM,WAAW,GAAG,IAAI,QAAQ,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,EAC3F,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,GAAG,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACjF,MAAM,iBAAiB,GAAG,IAAI,QAAQ,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,EACrG,UAAU,kBAAkB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACrC,MAAM,OAAO,GAAG,IAAI,UAAU,CAAC,IAAI,EAAG,WAAuD,EAC1F,iBAA4D,EAAE,UAAU,CAAC,CAAC;QAC7E,YAAY,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC;KAC9B;IAED,OAAO,YAAY,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,IAAgC,EAAE,WAAwB,EAAE,UAAyB,EAC3G,eAAkC;;IAClC,MAAM,aAAa,GAAG,WAAW,CAAC,CAAC,CAAC;IACpC,MAAM,WAAW,GAAG,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IAErE,MAAM,EAAE,GAAG,uBAAuB,CAAC,UAAU,CAAC,CAAC;IAC/C,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,UAAU,GAAG,IAAI,CAAC;IAEtB,OAAO,UAAU,EAAE;QACjB,MAAM,WAAW,GAAG,iBAAiB,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QACtE,iBAAiB,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;QAC5C,iBAAiB,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;QAE5C,UAAU,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,eAAe;YAClB,MAAM;QAER,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC/C,IAAI,CAAA,MAAA,eAAe,CAAC,CAAC,CAAC,0CAAE,QAAQ,MAAK,SAAS,IAAI,WAAW,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,QAAS,EAAE;gBAC/F,UAAU,GAAG,IAAI,CAAC;gBAClB,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACd,WAAW,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,QAAS,CAAC;gBAC9C,MAAM;aACP;YACD,IAAI,CAAA,MAAA,eAAe,CAAC,CAAC,CAAC,0CAAE,QAAQ,MAAK,SAAS,IAAI,WAAW,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,QAAS,EAAE;gBAC/F,UAAU,GAAG,IAAI,CAAC;gBAClB,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACd,WAAW,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,QAAS,CAAC;gBAC9C,MAAM;aACP;SACF;KACF;IAED,MAAM,WAAW,GAAG,cAAc,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;IAE/D,OAAO;QACL,WAAW,EAAE,WAAW;QACxB,UAAU,EAAE,WAAW;KACxB,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,aAAsD,EAAE,WAAqB;IAE1G,OAAO,CAAC,CAAS,EAAE,EAAE;QACnB,OAAO,aAAa,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;IACvC,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,2BAA2B,CAAC,IAAgC,EAAE,WAAqB,EACjG,aAAsD,EAAE,kBAA0B,IAAI,EAAE,UAAyB;IAEjH,MAAM,EAAE,GAAG,uBAAuB,CAAC,UAAU,CAAC,CAAC;IAE/C,MAAM,KAAK,GAAG,UAAU,KAAK,aAAa,CAAC,YAAY,CAAC,CAAC;QACvD,EAAE,CAAC,aAAa,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC;QAC3C,EAAE,CAAC,aAAa,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,KAAK,CAAC;IAE7C,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,eAAe,GAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAE/D,MAAM,GAAG,GAAG,CAAC,CAAS,EAAE,EAAE;QACxB,MAAM,KAAK,GAAG,aAAa,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;QAC5C,IAAI,UAAU,KAAK,aAAa,CAAC,QAAQ;YACvC,OAAO,KAAK,GAAG,QAAQ,GAAG,KAAK,CAAC;;YAEhC,OAAO,KAAK,GAAG,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;IACtD,CAAC,CAAC;IAEF,MAAM,MAAM,GAAG,CAAC,CAAS,EAAE,EAAE;QAC3B,MAAM,KAAK,GAAG,aAAa,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;QAC5C,IAAI,UAAU,KAAK,aAAa,CAAC,QAAQ;YACvC,OAAO,KAAK,GAAG,QAAQ,GAAG,KAAK,CAAC;;YAEhC,OAAO,KAAK,GAAG,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;IACtD,CAAC,CAAC;IAEF,OAAO,EAAC,aAAa,EAAE,GAAG,EAAE,gBAAgB,EAAE,MAAM,EAAC,CAAC;AACxD,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,IAAgC,EAAE,WAAqB,EACnF,aAAsD,EAAE,aAAsB,IAAI;IAClF,MAAM,WAAW,GAAG,cAAc,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;IAE/D,OAAO;QACL,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS;QACjE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS;QACvD,UAAU,EAAE,WAAW,CAAC,CAAC,CAAC;QAC1B,UAAU,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACvC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC;QACrB,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC;QACnB,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;KACvB,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,IAAgC,EAAE,WAAqB,EAC1F,kBAA0B,IAAI,EAAE,aAAsB,IAAI;IAC1D,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,eAAe,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;IAEjG,IAAI,GAAG,GAA0B,CAAC,CAAS,EAAE,EAAE;QAC7C,OAAO,CAAC,CAAC;IACX,CAAC,CAAC;IACF,IAAI,MAAM,GAA0B,CAAC,CAAS,EAAE,EAAE;QAChD,OAAO,CAAC,CAAC;IACX,CAAC,CAAC;IACF,IAAI,SAAS,GAA0B,CAAC,CAAS,EAAE,EAAE;QACnD,OAAO,CAAC,CAAC;IACX,CAAC,CAAC;IAEF,IAAI,UAAU,EAAE;QACd,GAAG,GAAG,CAAC,CAAS,EAAE,EAAE;YAClB,oDAAoD;YACpD,OAAO,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QACpG,CAAC,CAAC;QAEF,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAErC,MAAM,GAAG,CAAC,CAAS,EAAE,EAAE;YACrB,MAAM,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;YACrB,OAAO,KAAK,GAAG,QAAQ,GAAG,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAC7D,CAAC,CAAC;QAEF,SAAS,GAAG,CAAC,CAAS,EAAE,EAAE;YACxB,MAAM,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;YACrB,OAAO,KAAK,GAAG,QAAQ,GAAG,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAC7D,CAAC,CAAC;QAEF,OAAO;YACL,QAAQ,EAAE,GAAG;YACb,WAAW,EAAE,MAAM;YACnB,cAAc,EAAE,SAAS;SAC1B,CAAC;KACH;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,MAAgB,EAAE,CAAS;IACjD,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACpB,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACpB,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACpB,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACzD,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,WAAkC,EAAE,IAAgC;IACzF,IAAI,GAAG,GAAG,CAAC,CAAC;IAEZ,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IAChC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IAChC,MAAM,eAAe,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC;IAE3C,KAAK,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,IAAG,eAAe;QAC5C,GAAG,IAAI,eAAe,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;IAE1C,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,WAAkC,EAAE,IAAgC;IAC9F,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAEjC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACtC,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACzD,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC;KACzC;IAED,OAAO,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC;AAC3B,CAAC;AAED,SAAS,WAAW,CAAC,UAAiC,EAAE,IAAgC;IACtF,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,OAAO,GAAG,CAAC,CAAC;IAEhB,MAAM,eAAe,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IACxD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACtC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACtB,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACnC,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC;KAC9C;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE;QAC7C,OAAO,IAAI,eAAe,CAAC,CAAC,CAAC,CAAC;IAEhC,OAAO,IAAI,eAAe,CAAC,MAAM,CAAC;IAClC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAE3B,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,sBAAsB,CAAC,EAAqB,EAAE,aAAsD,EAC3G,IAAgC,EAAE,MAAgB,EAAE,aAAqB;IACzE,MAAM,IAAI,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,MAAM,CAAC,CAAC;IAC/F,MAAM,SAAS,GAAa,EAAE,CAAC;IAC/B,MAAM,YAAY,GAAa,EAAE,CAAC;IAClC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACtC,IAAI,CAAC,KAAK,aAAa,EAAE;YACvB,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;YACjC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;SACrC;aAAM;YACL,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1B,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;SAC9B;KACF;IACD,MAAM,MAAM,GAAG,EAAE,CAAC,aAAa,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC,KAAK,CAAC;IACxD,MAAM,SAAS,GAAG,EAAE,CAAC,aAAa,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,KAAK,CAAC;IAE9D,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;AAC3C,CAAC;AAED,SAAS,uBAAuB,CAAC,UAAmD,EAClF,IAAgC,EAAE,MAAgB;IAClD,sCAAsC;IACtC,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;IACnB,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,IAAI,UAAU,GAAG,CAAC,CAAC;IAEnB,MAAM,eAAe,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IACxD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACtC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACtB,MAAM,IAAI,GAAG,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3C,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC;KAC9C;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE;QAC7C,OAAO,IAAI,eAAe,CAAC,CAAC,CAAC,CAAC;IAEhC,OAAO,IAAI,eAAe,CAAC,MAAM,CAAC;IAClC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAE3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE;QAC7C,UAAU,IAAI,eAAe,CAAC,CAAC,CAAC,GAAG,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC;IAE1E,OAAO,EAAC,KAAK,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,EAAC,CAAC;AACrD,CAAC;AAED,SAAS,2BAA2B,CAAC,UAAmD,EACtF,IAAgC,EAAE,MAAgB;IAClD,sCAAsC;IACtC,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;IACnB,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,IAAI,UAAU,GAAG,CAAC,CAAC;IAEnB,MAAM,eAAe,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IACxD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACtC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACtB,MAAM,IAAI,GAAG,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3C,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC;KAC9C;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE;QAC7C,OAAO,IAAI,eAAe,CAAC,CAAC,CAAC,CAAC;IAEhC,OAAO,IAAI,eAAe,CAAC,MAAM,CAAC;IAClC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAE3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE;QAC7C,UAAU,IAAI,eAAe,CAAC,CAAC,CAAC,GAAG,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC;IAE1E,OAAO,EAAC,KAAK,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,EAAC,CAAC;AACrD,CAAC","sourcesContent":["/* eslint-disable no-multi-spaces */\nimport * as DG from 'datagrok-api/dg';\nimport {Property} from 'datagrok-api/src/entities';\nimport {TYPE} from 'datagrok-api/src/const';\n\nimport {limitedMemoryBFGS} from '../../lbfgs/lbfgs';\n//@ts-ignore: no types\nimport * as jStat from 'jstat';\n\n\ntype Optimizable = {\n  getValue: (parameters: number[]) => number,\n  getGradient: (parameters: number[], gradient: number[]) => number[],\n}\n\ntype Likelihood = {\n  value: number,\n  const: number,\n  mult: number\n};\n\ntype ObjectiveFunction = (targetFunc: (params: number[], x: number) => number,\n  data: {x: number[], y: number[]}, params: number[]) => Likelihood;\n\nexport enum FitErrorModel {\n  Constant,\n  Proportional\n}\n\nexport type FitParamBounds = {\n  minBound?: number;\n  maxBound?: number;\n};\n\n/** Fit function description. Applies to custom user fit functions.\n * Requires JS arrow functions for the fit functions and initial parameters. */\nexport interface IFitFunctionDescription {\n  name: string;\n  function: string;\n  getInitialParameters: string;\n  parameterNames: string[];\n}\n\nexport type FitCurve = {\n  fittedCurve: (x: number) => number;\n  parameters: number[];\n};\n\nexport type FitConfidenceIntervals = {\n  confidenceTop: (x: number) => number;\n  confidenceBottom: (x: number) => number;\n};\n\nexport type FitStatistics = {\n  rSquared?: number,\n  auc?: number,\n  interceptX: number, // parameters[2]\n  interceptY: number, // fittedCurve[parameters[2]]\n  slope: number, // parameters[1]\n  top: number, // parameters[0]\n  bottom: number, // parameters[3]\n};\n\nexport type FitInvertedFunctions = {\n  inverted: (y: number) => number,\n  invertedTop: (y: number) => number,\n  invertedBottom: (y: number) => number,\n};\n\n/**\n *  Datagrok curve fitting\n *\n * - Fitting: computing parameters of the specified function to best fit the data\n *   - Uses BFGS optimization algorithm (multi-threading for performance).\n *     For dose-response curves, we are typically fitting the sigmoid function\n *   - Ability to dynamically register custom fitting functions\n *     - Automatic fit function determination\n *     - Caching of custom fitting functions\n *   - Ability to get fitting performance characteristics (r-squared, classification, etc)\n * - Deep integration with the Datagrok grid\n *   - Either fitting on the fly, or using the supplied function + parameters\n *   - Multiple series in one cell\n *   - Candlesticks, confidence intervals, and droplines drawing\n *   - Ability to define chart, marker, or fitting options (such as fit function or marker color)\n *     on the column level, with the ability to override it on a grid cell or point level\n *   - Clicking a point in a chart within a grid makes it an outlier -> curve is re-fitted on the fly\n *   - Ability to specify a chart as \"reference\" so that it is shown on every other chart for comparison\n * - Ability to overlay curves from multiple grid cells (special viewer)\n * - Work with series stored in multiple formats (binary for performance, json for flexibility, etc)\n*/\n\nexport const FIT_SEM_TYPE = 'fit';\nexport const FIT_CELL_TYPE = 'fit';\nexport const TAG_FIT = '.fit';\n\nexport const CONFIDENCE_INTERVAL_STROKE_COLOR = 'rgba(255,191,63,0.4)';\nexport const CONFIDENCE_INTERVAL_FILL_COLOR = 'rgba(255,238,204,0.3)';\n\nexport const CURVE_CONFIDENCE_INTERVAL_BOUNDS = {\n  TOP: 'top',\n  BOTTOM: 'bottom',\n};\n\nexport const DROPLINES = ['IC50'];\n\nexport type FitMarkerType = 'asterisk' | 'circle' | 'cross border' | 'diamond' | 'square' | 'star' | 'triangle bottom' |\n  'triangle left' | 'triangle right' | 'triangle top';\n\n/** A point in the fit series. Only x and y are required. Can override some fields defined in IFitSeriesOptions. */\nexport interface IFitPoint {\n  x: number;\n  y: number;\n  outlier?: boolean;       // if true, renders as 'x' and gets ignored for curve fitting\n  minY?: number;           // when defined, the marker renders as a candlestick with whiskers [minY, maxY]\n  maxY?: number;           // when defined, the marker renders as a candlestick with whiskers [minY, maxY]\n  marker?: FitMarkerType;  // overrides the marker type defined in IFitSeriesOptions\n  color?: string;          // overrides the marker color defined in IFitSeriesOptions\n}\n\n/** A series consists of points, has a name, and options.\n * If defined, seriesOptions are merged with {@link IFitChartData.seriesOptions} */\nexport interface IFitSeries extends IFitSeriesOptions {\n  points: IFitPoint[];\n}\n\n/** Chart labels options. Controls the chart labels. */\nexport interface IFitChartLabelOptions {\n  visible: boolean;         // if true, renders the label on the plot\n  color: string;            // defines the label color\n  name: string;             // defines the label name\n}\n\n/** Chart options. For fitted curves, this object is stored in the grid column tags and is used by the renderer. */\nexport interface IFitChartOptions {\n  minX?: number;\n  minY?: number;\n  maxX?: number;\n  maxY?: number;\n\n  xAxisName?: string;        // defines the x axis name. If the plot size is enough, will render it.\n  yAxisName?: string;        // defines the Y axis name. If the plot size is enough, will render it.\n\n  logX?: boolean;            // defines whether the x data should be logarithmic or not\n  logY?: boolean;            // defines whether the y data should be logarithmic or not\n\n  showStatistics?: string[]; // defines the statistics that would be shown on the plot\n  labelOptions?: IFitChartLabelOptions[]; // controls the plot labels\n}\n\n/** Data for the fit chart. */\nexport interface IFitChartData {\n  chartOptions?: IFitChartOptions;\n  seriesOptions?: IFitSeriesOptions;  // Default series options. Individual series can override it.\n  series?: IFitSeries[];\n}\n\n/** Class that implements {@link IFitChartData} interface */\nexport class FitChartData implements IFitChartData {\n  chartOptions: IFitChartOptions = {};\n  seriesOptions: IFitSeriesOptions = {};  // Default series options. Individual series can override it.\n  series: IFitSeries[] = [];\n}\n\n/** Series options can be either applied globally on a column level, or partially overridden in particular series */\nexport interface IFitSeriesOptions {\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 series parameter bounds during the fit\n  markerType?: FitMarkerType;           // defines the series marker type\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  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  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}\n// TODO: show labels in property panel if present, color by default from series\n\n\n/** Properties that describe {@link FitStatistics}. Useful for editing, initialization, transformations, etc. */\nexport const statisticsProperties: Property[] = [\n  Property.js('rSquared', TYPE.FLOAT, {userEditable: false}),\n  Property.js('auc', TYPE.FLOAT, {userEditable: false}),\n  Property.js('interceptY', TYPE.FLOAT, {userEditable: false}),\n  Property.js('interceptX', TYPE.FLOAT, {userEditable: false}),\n  Property.js('slope', TYPE.FLOAT, {userEditable: false}),\n  Property.js('top', TYPE.FLOAT, {userEditable: false}),\n  Property.js('bottom', TYPE.FLOAT, {userEditable: false}),\n];\n\n/** Properties that describe {@link IFitChartOptions}. Useful for editing, initialization, transformations, etc. */\nexport const fitChartDataProperties: Property[] = [\n  // Style and zoom\n  Property.js('minX', TYPE.FLOAT, {description: 'Minimum value of the X axis', nullable: true}),\n  Property.js('minY', TYPE.FLOAT, {description: 'Minimum value of the Y axis', nullable: true}),\n  Property.js('maxX', TYPE.FLOAT, {description: 'Maximum value of the X axis', nullable: true}),\n  Property.js('maxY', TYPE.FLOAT, {description: 'Maximum value of the Y axis', nullable: true}),\n  Property.js('xAxisName', TYPE.STRING, {description:\n    'Label to show on the X axis. If not specified, corresponding data column name is used', nullable: true}),\n  Property.js('yAxisName', TYPE.STRING, {description:\n    'Label to show on the Y axis. If not specified, corresponding data column name is used', nullable: true}),\n  Property.js('logX', TYPE.BOOL, {defaultValue: false}),\n  Property.js('logY', TYPE.BOOL, {defaultValue: false}),\n  Property.js('showStatistics', TYPE.STRING_LIST, {choices: statisticsProperties.map((frp) => frp.name),\n    inputType: 'MultiChoice'}),\n];\n\n/** Properties that describe {@link IFitSeriesOptions}. Useful for editing, initialization, transformations, etc. */\nexport const fitSeriesProperties: Property[] = [\n  Property.js('name', TYPE.STRING),\n  Property.js('fitFunction', TYPE.STRING,\n    {category: 'Fitting', choices: ['sigmoid', 'linear'], defaultValue: 'sigmoid'}),\n  Property.js('pointColor', TYPE.STRING,\n    {category: 'Rendering', defaultValue: DG.Color.toHtml(DG.Color.scatterPlotMarker), nullable: true,\n      inputType: 'Color'}),\n  Property.js('fitLineColor', TYPE.STRING,\n    {category: 'Rendering', defaultValue: DG.Color.toHtml(DG.Color.scatterPlotMarker), nullable: true,\n      inputType: 'Color'}),\n  Property.js('clickToToggle', TYPE.BOOL, {category: 'Fitting', description:\n    'If true, clicking on the point toggles its outlier status and causes curve refitting', nullable: true, defaultValue: false}),\n  Property.js('showFitLine', TYPE.BOOL,\n    {category: 'Fitting', description: 'Whether the fit line should be rendered', defaultValue: true}),\n  Property.js('showPoints', TYPE.STRING,\n    {category: 'Fitting', description: 'Whether points/candlesticks/none should be rendered',\n      defaultValue: 'points', choices: ['points', 'candlesticks', 'both']}),\n  Property.js('showCurveConfidenceInterval', TYPE.BOOL,\n    {category: 'Fitting', description: 'Whether confidence intervals should be rendered', defaultValue: false}),\n  Property.js('markerType', TYPE.STRING, {category: 'Rendering', description: 'Marker type used when rendering',\n    defaultValue: 'circle', choices: ['asterisk', 'circle', 'cross border', 'diamond', 'square', 'star',\n      'triangle bottom', 'triangle left', 'triangle right', 'triangle top'], nullable: false}),\n  Property.js('droplines', TYPE.STRING_LIST, {choices: DROPLINES, inputType: 'MultiChoice'}),\n];\n\nexport const FIT_FUNCTION_SIGMOID = 'sigmoid';\nexport const FIT_FUNCTION_LINEAR = 'linear';\n\nexport const FIT_STATS_RSQUARED = 'rSquared';\nexport const FIT_STATS_AUC = 'auc';\n\n\n// TODO?: add method to return parameters - get parameters from fit function\n/** Class for the fit functions */\nexport abstract class FitFunction {\n  abstract get name(): string;\n  abstract get parameterNames(): string[];\n  abstract y(params: number[], x: number): number;\n  abstract getInitialParameters(x: number[], y: number[]): number[];\n}\n\n/** Class that implements the linear function */\nexport class LinearFunction extends FitFunction {\n  get name(): string {\n    return FIT_FUNCTION_LINEAR;\n  }\n\n  get parameterNames(): string[] {\n    return ['Slope', 'Intercept'];\n  }\n\n  y(params: number[], x: number): number {\n    throw new Error('Not implemented');\n  }\n\n  getInitialParameters(x: number[], y: number[]): number[] {\n    throw new Error('Not implemented');\n  }\n}\n\n/** Class that implements the sigmoid function */\nexport class SigmoidFunction extends FitFunction {\n  get name(): string {\n    return FIT_FUNCTION_SIGMOID;\n  }\n\n  get parameterNames(): string[] {\n    return ['Top', 'Bottom', 'Slope', 'IC50'];\n  }\n\n  y(params: number[], x: number): number {\n    return sigmoid(params, x);\n  }\n\n  getInitialParameters(x: number[], y: number[]): number[] {\n    const dataBounds = DG.Rect.fromXYArrays(x, y);\n    const medY = (dataBounds.bottom - dataBounds.top) / 2 + dataBounds.top;\n    let maxYInterval = dataBounds.bottom - dataBounds.top;\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.2 : -1.2;\n\n    // params are: [max, tan, IC50, min]\n    return [dataBounds.bottom, slope, xAtMedY, dataBounds.top];\n  }\n}\n\n/** Class that implements user JS functions */\nexport class JsFunction extends FitFunction {\n  private _name: string;\n  private _parameterNames: string[];\n\n  constructor(name: string, yFunc: (params: number[], x: number) => number,\n    getInitParamsFunc: (x: number[], y: number[]) => number[], parameterNames: string[]) {\n    super();\n\n    this._name = name;\n    this._parameterNames = parameterNames;\n\n    this.y = yFunc;\n    this.getInitialParameters = getInitParamsFunc;\n  }\n\n  get name(): string {\n    return this._name;\n  }\n\n  get parameterNames(): string[] {\n    return this._parameterNames;\n  }\n\n  y(params: number[], x: number): number {\n    throw new Error('Not implemented');\n  }\n\n  getInitialParameters(x: number[], y: number[]): number[] {\n    throw new Error('Not implemented');\n  }\n}\n\n// Object with fit functions\nexport const fitFunctions: {[index: string]: FitFunction} = {\n  'linear': new LinearFunction(),\n  'sigmoid': new SigmoidFunction(),\n};\n\nexport interface IFitOptions {\n  errorModel: FitErrorModel;\n  confidenceLevel: number;\n  statistics: boolean;\n}\n\n\nfunction createObjectiveFunction(errorModel: FitErrorModel): ObjectiveFunction {\n  let of: ObjectiveFunction;\n\n  switch (errorModel) {\n  case FitErrorModel.Constant:\n    of = objectiveNormalConstant;\n    break;\n  case FitErrorModel.Proportional:\n    of = objectiveNormalProportional;\n    break;\n  default:\n    of = objectiveNormalConstant;\n    break;\n  }\n\n  return of;\n}\n\nfunction createOptimizable(data: {x: number[], y: number[]}, curveFunction: (params: number[], x: number) => number,\n  of: ObjectiveFunction, fixed: number[]): Optimizable {\n  return {\n    getValue: (parameters: number[]) => {\n      return of(curveFunction, data, parameters).value;\n    },\n    getGradient: (parameters: number[], gradient: number[]) => {\n      for (let i = 0; i < parameters.length; i++)\n        gradient[i] = fixed.includes(i) ? 0 : getObjectiveDerivative(of, curveFunction, data, parameters, i);\n\n      return gradient;\n    },\n  };\n}\n\nexport function getOrCreateFitFunction(seriesFitFunc: string | IFitFunctionDescription): FitFunction {\n  if (typeof seriesFitFunc === 'string')\n    return fitFunctions[seriesFitFunc];\n  else if (!fitFunctions[seriesFitFunc.name]) {\n    const name = seriesFitFunc.name;\n    const paramNames = seriesFitFunc.parameterNames;\n    const fitFunctionParts = seriesFitFunc.function.split('=>').map((elem) => elem.trim());\n    const getInitParamsParts = seriesFitFunc.getInitialParameters.split('=>').map((elem) => elem.trim());\n    const fitFunction = new Function(fitFunctionParts[0].slice(1, fitFunctionParts[0].length - 1),\n      `${fitFunctionParts[1].includes(';') ? '' : 'return '}${fitFunctionParts[1]}`);\n    const getInitParamsFunc = new Function(getInitParamsParts[0].slice(1, getInitParamsParts[0].length - 1),\n      `return ${getInitParamsParts[1]}`);\n    const fitFunc = new JsFunction(name, (fitFunction as (params: number[], x: number) => number),\n      (getInitParamsFunc as (x: number[], y: number[]) => number[]), paramNames);\n    fitFunctions[name] = fitFunc;\n  }\n\n  return fitFunctions[seriesFitFunc.name];\n}\n\nexport function fitData(data: {x: number[], y: number[]}, fitFunction: FitFunction, errorModel: FitErrorModel,\n  parameterBounds?: FitParamBounds[]): FitCurve {\n  const curveFunction = fitFunction.y;\n  const paramValues = fitFunction.getInitialParameters(data.x, data.y);\n\n  const of = createObjectiveFunction(errorModel);\n  const fixed: number[] = [];\n  let overLimits = true;\n\n  while (overLimits) {\n    const optimizable = createOptimizable(data, curveFunction, of, fixed);\n    limitedMemoryBFGS(optimizable, paramValues);\n    limitedMemoryBFGS(optimizable, paramValues);\n\n    overLimits = false;\n    if (!parameterBounds)\n      break;\n\n    for (let i = 0; i < parameterBounds.length; i++) {\n      if (parameterBounds[i]?.maxBound !== undefined && paramValues[i] > parameterBounds[i].maxBound!) {\n        overLimits = true;\n        fixed.push(i);\n        paramValues[i] = parameterBounds[i].maxBound!;\n        break;\n      }\n      if (parameterBounds[i]?.minBound !== undefined && paramValues[i] < parameterBounds[i].minBound!) {\n        overLimits = true;\n        fixed.push(i);\n        paramValues[i] = parameterBounds[i].minBound!;\n        break;\n      }\n    }\n  }\n\n  const fittedCurve = getFittedCurve(curveFunction, paramValues);\n\n  return {\n    fittedCurve: fittedCurve,\n    parameters: paramValues,\n  };\n}\n\nexport function getFittedCurve(curveFunction: (params: number[], x: number) => number, paramValues: number[]):\n (x: number) => number {\n  return (x: number) => {\n    return curveFunction(paramValues, x);\n  };\n}\n\nexport function getCurveConfidenceIntervals(data: {x: number[], y: number[]}, paramValues: number[],\n  curveFunction: (params: number[], x: number) => number, confidenceLevel: number = 0.05, errorModel: FitErrorModel):\n  FitConfidenceIntervals {\n  const of = createObjectiveFunction(errorModel);\n\n  const error = errorModel === FitErrorModel.Proportional ?\n    of(curveFunction, data, paramValues).mult :\n    of(curveFunction, data, paramValues).const;\n\n  const quantile = jStat.normal.inv(1 - confidenceLevel/2, 0, 1);\n\n  const top = (x: number) => {\n    const value = curveFunction(paramValues, x);\n    if (errorModel === FitErrorModel.Constant)\n      return value + quantile * error;\n    else\n      return value + quantile * Math.abs(value) * error;\n  };\n\n  const bottom = (x: number) => {\n    const value = curveFunction(paramValues, x);\n    if (errorModel === FitErrorModel.Constant)\n      return value - quantile * error;\n    else\n      return value - quantile * Math.abs(value) * error;\n  };\n\n  return {confidenceTop: top, confidenceBottom: bottom};\n}\n\nexport function getStatistics(data: {x: number[], y: number[]}, paramValues: number[],\n  curveFunction: (params: number[], x: number) => number, statistics: boolean = true): FitStatistics {\n  const fittedCurve = getFittedCurve(curveFunction, paramValues);\n\n  return {\n    rSquared: statistics ? getDetCoeff(fittedCurve, data) : undefined,\n    auc: statistics ? getAuc(fittedCurve, data) : undefined,\n    interceptX: paramValues[2],\n    interceptY: fittedCurve(paramValues[2]),\n    slope: paramValues[1],\n    top: paramValues[0],\n    bottom: paramValues[3],\n  };\n}\n\nexport function getInvertedFunctions(data: {x: number[], y: number[]}, paramValues: number[],\n  confidenceLevel: number = 0.05, statistics: boolean = true): FitInvertedFunctions | null {\n  const studentQ = jStat.studentt.inv(1 - confidenceLevel / 2, data.x.length - paramValues.length);\n\n  let inv: (y: number) => number = (y: number) => {\n    return 0;\n  };\n  let invTop: (y: number) => number = (y: number) => {\n    return 0;\n  };\n  let invBottom: (y: number) => number = (y: number) => {\n    return 0;\n  };\n\n  if (statistics) {\n    inv = (y: number) => {\n      //should check if more than bottom and less than top\n      return paramValues[2] / Math.pow((paramValues[0] - y) / (y - paramValues[3]), 1 / paramValues[1]);\n    };\n\n    const error = getInvError(inv, data);\n\n    invTop = (y: number) => {\n      const value = inv(y);\n      return value + studentQ * error / Math.sqrt(data.y.length);\n    };\n\n    invBottom = (y: number) => {\n      const value = inv(y);\n      return value - studentQ * error / Math.sqrt(data.y.length);\n    };\n\n    return {\n      inverted: inv,\n      invertedTop: invTop,\n      invertedBottom: invBottom,\n    };\n  }\n\n  return null;\n}\n\nexport function sigmoid(params: number[], x: number): number {\n  const A = params[0];\n  const B = params[1];\n  const C = params[2];\n  const D = params[3];\n  return (D + (A - D) / (1 + Math.pow(10, (x - C) * B)));\n}\n\nexport function getAuc(fittedCurve: (x: number) => number, data: {x: number[], y: number[]}): number {\n  let auc = 0;\n\n  const min = Math.min(...data.x);\n  const max = Math.max(...data.x);\n  const integrationStep = (max - min) / 1000;\n\n  for (let x = min; x < max; x+= integrationStep)\n    auc += integrationStep * fittedCurve(x);\n\n  return auc;\n}\n\nexport function getDetCoeff(fittedCurve: (x: number) => number, data: {x: number[], y: number[]}): number {\n  let ssRes = 0;\n  let ssTot = 0;\n\n  const yMean = jStat.mean(data.y);\n\n  for (let i = 0; i < data.x.length; i++) {\n    ssRes += Math.pow(data.y[i] - fittedCurve(data.x[i]), 2);\n    ssTot += Math.pow(data.y[i] - yMean, 2);\n  }\n\n  return 1 - ssRes / ssTot;\n}\n\nfunction getInvError(targetFunc: (y: number) => number, data: {y: number[], x: number[]}): number {\n  let sigma = 0;\n  let sigmaSq = 0;\n\n  const residuesSquares = new Float32Array(data.y.length);\n  for (let i = 0; i < data.y.length; i++) {\n    const obs = data.x[i];\n    const pred = targetFunc(data.y[i]);\n    residuesSquares[i] = Math.pow(obs - pred, 2);\n  }\n\n  for (let i = 0; i < residuesSquares.length; i++)\n    sigmaSq += residuesSquares[i];\n\n  sigmaSq /= residuesSquares.length;\n  sigma = Math.sqrt(sigmaSq);\n\n  return sigma;\n}\n\nfunction getObjectiveDerivative(of: ObjectiveFunction, curveFunction: (params: number[], x: number) => number,\n  data: {x: number[], y: number[]}, params: number[], selectedParam: number): number {\n  const step = (params[selectedParam] * 0.0001) === 0 ? 0.001 : (params[selectedParam] * 0.0001);\n  const paramsTop: number[] = [];\n  const paramsBottom: number[] = [];\n  for (let i = 0; i < params.length; i++) {\n    if (i === selectedParam) {\n      paramsTop.push(params[i] + step);\n      paramsBottom.push(params[i] - step);\n    } else {\n      paramsTop.push(params[i]);\n      paramsBottom.push(params[i]);\n    }\n  }\n  const drvTop = of(curveFunction, data, paramsTop).value;\n  const drvBottom = of(curveFunction, data, paramsBottom).value;\n\n  return (drvTop - drvBottom) / (2 * step);\n}\n\nfunction objectiveNormalConstant(targetFunc: (params: number[], x: number) => number,\n  data: {y: number[], x: number[]}, params: number[]): Likelihood {\n  //assure observed and args same length\n  const pi = Math.PI;\n  let sigma = 0;\n  let sigmaSq = 0;\n  let likelihood = 0;\n\n  const residuesSquares = new Float32Array(data.x.length);\n  for (let i = 0; i < data.x.length; i++) {\n    const obs = data.y[i];\n    const pred = targetFunc(params, data.x[i]);\n    residuesSquares[i] = Math.pow(obs - pred, 2);\n  }\n\n  for (let i = 0; i < residuesSquares.length; i++)\n    sigmaSq += residuesSquares[i];\n\n  sigmaSq /= residuesSquares.length;\n  sigma = Math.sqrt(sigmaSq);\n\n  for (let i = 0; i < residuesSquares.length; i++)\n    likelihood += residuesSquares[i] / sigmaSq + Math.log(2 * pi * sigmaSq);\n\n  return {value: -likelihood, const: sigma, mult: 0};\n}\n\nfunction objectiveNormalProportional(targetFunc: (params: number[], x: number) => number,\n  data: {y: number[], x: number[]}, params: number[]): Likelihood {\n  //assure observed and args same length\n  const pi = Math.PI;\n  let sigma = 0;\n  let sigmaSq = 0;\n  let likelihood = 0;\n\n  const residuesSquares = new Float32Array(data.x.length);\n  for (let i = 0; i < data.x.length; i++) {\n    const obs = data.y[i];\n    const pred = targetFunc(params, data.x[i]);\n    residuesSquares[i] = Math.pow(obs - pred, 2);\n  }\n\n  for (let i = 0; i < residuesSquares.length; i++)\n    sigmaSq += residuesSquares[i];\n\n  sigmaSq /= residuesSquares.length;\n  sigma = Math.sqrt(sigmaSq);\n\n  for (let i = 0; i < residuesSquares.length; i++)\n    likelihood += residuesSquares[i] / sigmaSq + Math.log(2 * pi * sigmaSq);\n\n  return {value: -likelihood, const: sigma, mult: 0};\n}\n"]}

package/src/fit/fit-data.d.ts

@@ -0,0 +1,28 @@
+import * as DG from 'datagrok-api/dg';
+import { FitFunction, FitStatistics, FitConfidenceIntervals, FitCurve, IFitPoint, IFitChartData, IFitSeries } from './fit-curve';
+export declare type LogOptions = {
+    logX: boolean | undefined;
+    logY: boolean | undefined;
+};
+/** Creates default {@link IFitChartData} object */
+export declare function createDefaultChartData(): IFitChartData;
+/** Returns existing, or creates new column default chart options. */
+export declare function getColumnChartOptions(gridColumn: DG.GridColumn): IFitChartData;
+/** Returns points arrays from {@link IFitPoint} array */
+export declare function getPointsArrays(points: IFitPoint[]): {
+    xs: number[];
+    ys: number[];
+};
+/** Returns the bounds of an {@link IFitChartData} object */
+export declare function getChartBounds(chartData: IFitChartData): DG.Rect;
+/** Returns series fit function */
+export declare function getSeriesFitFunction(series: IFitSeries): FitFunction;
+/** Returns a curve function, either using the pre-computed parameters or by fitting on-the-fly */
+export declare function getCurve(series: IFitSeries, fitFunc: FitFunction): (x: number) => number;
+/** Fits the series data according to the series fitting settings */
+export declare function fitSeries(series: IFitSeries, fitFunc: FitFunction, logOptions?: LogOptions): FitCurve;
+/** Returns series confidence interval functions */
+export declare function getSeriesConfidenceInterval(series: IFitSeries, fitFunc: FitFunction, userParamsFlag: boolean): FitConfidenceIntervals;
+/** Returns series statistics */
+export declare function getSeriesStatistics(series: IFitSeries, fitFunc: FitFunction): FitStatistics;
+//# sourceMappingURL=fit-data.d.ts.map

package/src/fit/fit-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fit-data.d.ts","sourceRoot":"","sources":["fit-data.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAEtC,OAAO,EAKL,WAAW,EAEX,aAAa,EACb,sBAAsB,EACtB,QAAQ,EAER,SAAS,EACT,aAAa,EACb,UAAU,EAIX,MAAM,aAAa,CAAC;AAErB,oBAAY,UAAU,GAAG;IACvB,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;IAC1B,IAAI,EAAE,OAAO,GAAG,SAAS,CAAA;CAC1B,CAAC;AAcF,mDAAmD;AACnD,wBAAgB,sBAAsB,IAAI,aAAa,CAKtD;AAED,qEAAqE;AACrE,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,aAAa,CAE9E;AAED,yDAAyD;AACzD,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG;IAAC,EAAE,EAAE,MAAM,EAAE,CAAC;IAAC,EAAE,EAAE,MAAM,EAAE,CAAA;CAAC,CAQjF;AAED,4DAA4D;AAC5D,wBAAgB,cAAc,CAAC,SAAS,EAAE,aAAa,GAAG,EAAE,CAAC,IAAI,CAehE;AAED,kCAAkC;AAClC,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,UAAU,GAAG,WAAW,CAEpE;AAED,kGAAkG;AAClG,wBAAgB,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAExF;AAED,oEAAoE;AACpE,wBAAgB,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,QAAQ,CAIrG;AAED,mDAAmD;AACnD,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,EAClF,cAAc,EAAE,OAAO,GAAG,sBAAsB,CAOjD;AAED,gCAAgC;AAChC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,GAAG,aAAa,CAM3F"}