@datagrok-libraries/statistics 1.0.0 → 1.0.1

package/package.json

@@ -4,7 +4,7 @@
     "access": "public"
   },
   "friendlyName": "statistics",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "",
   "dependencies": {
     "datagrok-api": "1.12.1",

package/src/parameter-estimation/fit-curve.d.ts

@@ -1,59 +1,13 @@
-declare type Likelihood = {
-    value: number;
-    const: number;
-    mult: number;
+declare type FitResult = {
+    parameters: number[];
+    fittedCurve: (x: number) => number;
+    confidenceTop: (x: number) => number;
+    confidenceBottom: (x: number) => number;
 };
-interface ICurveFitter<TArg> {
-    data: {
-        observed: number[];
-        args: TArg[];
-    };
-    params: number[];
-    cf(params: number[], args: TArg): number;
-    of(targetFunc: (params: number[], args: TArg) => number, data: {
-        observed: number[];
-        args: TArg[];
-    }, params: number[]): Likelihood;
-}
-export declare class CurveFitter<TArg> implements ICurveFitter<TArg> {
-    errorModel: string;
-    data: {
-        observed: number[];
-        args: TArg[];
-    };
-    params: number[];
-    cf: (params: number[], args: TArg) => number;
-    of: typeof objectiveNormalConstant;
-    optimizable: {
-        getValue: (parameters: number[]) => number;
-        getGradient: (parameters: number[], gradient: number[]) => number[];
-    };
-    fitHistory: {
-        iterations: number;
-        parameters: {
-            [iteration: number]: number[];
-        };
-        likelihood: {
-            [iteration: number]: number;
-        };
-    };
-    constructor(curveFunction: (params: number[], args: TArg) => number, data: {
-        observed: number[];
-        args: TArg[];
-    }, params: number[], errorModel?: 'constant' | 'proportional');
-    performFit(): void;
-    get parameters(): number[];
-    get curveFunction(): Function;
-    get confidence(): {
-        top: Function;
-        bottom: Function;
-    };
-    private getDerivative;
-}
+export declare function fit(data: {
+    x: number[];
+    y: number[];
+}, params: number[], curveFunction: (params: number[], x: number) => number, errorModel: string): FitResult;
 export declare function sigmoid(params: number[], x: number): number;
-declare function objectiveNormalConstant<TArg>(targetFunc: (params: number[], args: TArg) => number, data: {
-    observed: number[];
-    args: TArg[];
-}, params: number[]): Likelihood;
 export {};
 //# sourceMappingURL=fit-curve.d.ts.map

package/src/parameter-estimation/fit-curve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fit-curve.d.ts","sourceRoot":"","sources":["fit-curve.ts"],"names":[],"mappings":"AAEA,aAAK,UAAU,GAAG;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAA;CACb,CAAC;AAEF,UAAU,YAAY,CAAC,IAAI;IACzB,IAAI,EAAE;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,IAAI,EAAE,CAAA;KAAC,CAAC;IACzC,MAAM,EAAE,MAAM,EAAE,CAAC;IAGjB,EAAE,CAAE,MAAM,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAAA;IAEzC,EAAE,CAAE,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,KAAK,MAAM,EACxB,IAAI,EAAE;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,IAAI,EAAE,CAAA;KAAC,EACxC,MAAM,EAAE,MAAM,EAAE,GAAG,UAAU,CAAA;CAC9D;AAED,qBAAa,WAAW,CAAC,IAAI,CAAE,YAAW,YAAY,CAAC,IAAI,CAAC;IAC1D,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,IAAI,EAAE,CAAA;KAAC,CAAC;IACzC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,EAAE,WAUkC,MAAM,EAAE,QAAQ,IAAI,KAAK,MAAM,CAVhE;IACH,EAAE,iCAAC;IACH,WAAW;+BAoCgB,MAAM,EAAE;kCAGL,MAAM,EAAE,YAAY,MAAM,EAAE;MAvC9C;IACZ,UAAU,EAAE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;SAAC,CAAC;QAC/D,UAAU,EAAE;YAAC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;SAAC,CAAA;KAAC,CAItD;gBAEU,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,KAAK,MAAM,EACvD,IAAI,EAAE;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,IAAI,EAAE,CAAA;KAAC,EACxC,MAAM,EAAE,MAAM,EAAE,EAChB,UAAU,GAAE,UAAU,GAAG,cAA2B;IA2ChE,UAAU,IAAI,IAAI;IAKlB,IAAI,UAAU,IAAI,MAAM,EAAE,CAEzB;IAED,IAAI,aAAa,IAAI,QAAQ,CAQ5B;IAED,IAAI,UAAU,IAAI;QAAC,GAAG,EAAC,QAAQ,CAAC;QAAC,MAAM,EAAE,QAAQ,CAAA;KAAC,CAwBjD;IAGD,OAAO,CAAC,aAAa;CAmBtB;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAO3D;AAED,iBAAS,uBAAuB,CAAC,IAAI,EACG,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,KAAK,MAAM,EACpD,IAAI,EAAE;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,IAAI,EAAE,CAAA;CAAC,EACxC,MAAM,EAAE,MAAM,EAAE,GACrD,UAAU,CAuBZ"}
+{"version":3,"file":"fit-curve.d.ts","sourceRoot":"","sources":["fit-curve.ts"],"names":[],"mappings":"AAQA,aAAK,SAAS,GAAG;IACf,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,WAAW,EAAE,CAAC,CAAC,EAAC,MAAM,KAAI,MAAM,CAAC;IACjC,aAAa,EAAE,CAAC,CAAC,EAAC,MAAM,KAAI,MAAM,CAAC;IACnC,gBAAgB,EAAE,CAAC,CAAC,EAAC,MAAM,KAAI,MAAM,CAAA;CACtC,CAAC;AAEF,wBAAgB,GAAG,CAAE,IAAI,EAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAClD,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,CA2FzG;AA0JD,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAO3D"}

package/src/parameter-estimation/fit-curve.js

@@ -1,82 +1,18 @@
 import { limitedMemoryBFGS } from "../../lbfgs/lbfgs";
-export class CurveFitter {
-    constructor(curveFunction, data, params, errorModel = 'constant') {
-        this.fitHistory = {
-            iterations: 0,
-            parameters: {},
-            likelihood: {}
-        };
-        if (data.observed.length == 0 || data.observed.length != data.args.length)
-            throw new Error('invalid data');
-        this.data = data;
-        this.params = params;
-        this.errorModel = errorModel;
-        this.cf = curveFunction;
-        switch (errorModel) {
-            case 'constant':
-                this.of = objectiveNormalConstant;
-            case 'proportional':
-                this.of = objectiveNormalProportional;
-            // case 'combinational1':
-            //   this.of = objectiveNormalAdditive;
-            // case 'combinational2':
-            //   this.of = objectiveNormalAdditive;
-            default:
-                this.of = objectiveNormalConstant;
-        }
-        this.optimizable = {
-            getValue: (parameters) => {
-                return this.of(this.cf, this.data, parameters).value;
-            },
-            getGradient: (parameters, gradient) => {
-                const length = Object.keys(this.fitHistory.parameters).length;
-                this.fitHistory.iterations++;
-                this.fitHistory.parameters[length] = parameters.slice();
-                this.fitHistory.likelihood[length] = this.of(this.cf, this.data, parameters).value;
-                console.log(parameters.slice());
-                for (let i = 0; i < parameters.length; i++)
-                    gradient[i] = this.getDerivative(parameters, i);
-                return gradient;
-            }
-        };
-    }
-    performFit() {
-        limitedMemoryBFGS(this.optimizable, this.params);
-        limitedMemoryBFGS(this.optimizable, this.params);
-    }
-    get parameters() {
-        return this.params;
+export function fit(data, params, curveFunction, errorModel) {
+    let of;
+    switch (errorModel) {
+        case 'constant':
+            of = objectiveNormalConstant;
+            break;
+        case 'proportional':
+            of = objectiveNormalProportional;
+            break;
+        default:
+            of = objectiveNormalConstant;
+            break;
     }
-    get curveFunction() {
-        let res = (arg) => {
-            let params = this.fitHistory.parameters[this.fitHistory.iterations - 1];
-            return this.cf(params, arg);
-        };
-        return res;
-    }
-    get confidence() {
-        let params = this.fitHistory.parameters[this.fitHistory.iterations - 1];
-        let error = this.errorModel == "constant" ?
-            this.of(this.cf, this.data, params).const :
-            this.of(this.cf, this.data, params).mult;
-        let top = (arg) => {
-            let value = this.cf(params, arg);
-            if (this.errorModel == "constant")
-                return value + 1.4 * error;
-            else
-                return value + 1.4 * (Math.abs(value) * error);
-        };
-        let bottom = (arg) => {
-            let value = this.cf(params, arg);
-            if (this.errorModel == "constant")
-                return value - 1.4 * error;
-            else
-                return value - 1.4 * (Math.abs(value) * error);
-        };
-        return { top: top, bottom: bottom };
-    }
-    //central difference
-    getDerivative(params, selectedParam) {
+    function getDerivative(params, selectedParam) {
         let step = params[selectedParam] * 0.0001;
         step = step == 0 ? 0.001 : step;
         let paramsTop = [];
@@ -91,11 +27,178 @@ export class CurveFitter {
                 paramsBottom.push(params[i]);
             }
         }
-        const drvTop = this.of(this.cf, this.data, paramsTop).value;
-        const drvBottom = this.of(this.cf, this.data, paramsBottom).value;
+        const drvTop = of(curveFunction, data, paramsTop).value;
+        const drvBottom = of(curveFunction, data, paramsBottom).value;
         return (drvTop - drvBottom) / (2 * step);
     }
+    let iterations = 0;
+    let optimizable = {
+        getValue: (parameters) => {
+            return of(curveFunction, data, parameters).value;
+        },
+        getGradient: (parameters, gradient) => {
+            const length = Object.keys(parameters).length;
+            iterations++;
+            console.log(parameters.slice());
+            for (let i = 0; i < parameters.length; i++)
+                gradient[i] = getDerivative(parameters, i);
+            return gradient;
+        }
+    };
+    limitedMemoryBFGS(optimizable, params);
+    limitedMemoryBFGS(optimizable, params);
+    let fittedCurve = (x) => {
+        return curveFunction(params, x);
+    };
+    let top = (x) => {
+        let value = curveFunction(params, x);
+        if (errorModel == "constant")
+            return value + 1.4 * error;
+        else
+            return value + 1.4 * (Math.abs(value) * error);
+    };
+    let error = errorModel == "constant" ?
+        of(curveFunction, data, params).const :
+        of(curveFunction, data, params).mult;
+    let bottom = (x) => {
+        let value = curveFunction(params, x);
+        if (errorModel == "constant")
+            return value - 1.4 * error;
+        else
+            return value - 1.4 * (Math.abs(value) * error);
+    };
+    let fitRes = {
+        parameters: params,
+        fittedCurve: fittedCurve,
+        confidenceTop: top,
+        confidenceBottom: bottom
+    };
+    return fitRes;
 }
+// performFit(): FitResult {
+//   limitedMemoryBFGS(this.optimizable, this.params);
+//   limitedMemoryBFGS(this.optimizable, this.params);
+//   let fit: FitResult = {
+//     parameters = this.parameters;
+//   };
+//   return {parameters: , curveFunction: this.curveFunction, confidence: this.confidence};
+// }
+// interface ICurveFitter<TArg> {
+//   data: {observed: number[], args: TArg[]};
+//   params: number[];
+//   //curve function
+//   cf (params: number[], args: TArg): number
+//   //objective function
+//   of (targetFunc: (params: number[], args: TArg) => number, 
+//                                   data: {observed: number[], args: TArg[]},
+//                                   params: number[]): Likelihood
+// }
+// export class CurveFitter<TArg = number> implements ICurveFitter<TArg> {
+//   errorModel: string;
+//   data: {observed: number[], args: TArg[]};
+//   params: number[];
+//   cf;
+//   of;
+//   optimizable;
+//   fitHistory: {iterations: number, parameters: {[iteration: number]: number[]}, 
+//                 likelihood: {[iteration: number]: number}} = {
+//     iterations: 0,
+//     parameters: {},
+//     likelihood: {}
+//   };
+//   constructor(curveFunction: (params: number[], args: TArg) => number, 
+//               data: {observed: number[], args: TArg[]},
+//               params: number[],
+//               errorModel: 'constant' | 'proportional' = 'constant'//implement as enum
+//               ) {
+//     if(data.observed.length == 0 || data.observed.length != data.args.length)
+//       throw new Error('invalid data');
+//     this.data = data;
+//     this.params = params;
+//     this.errorModel = errorModel;
+//     this.cf = curveFunction;
+//     switch(errorModel) {
+//       case 'constant':
+//         this.of = objectiveNormalConstant;
+//         break;
+//       case 'proportional':
+//         this.of = objectiveNormalProportional;
+//         break;
+//       default:
+//         this.of = objectiveNormalConstant;
+//         break;
+//     }
+//     this.optimizable = {
+//       getValue: (parameters: number[]) => {
+//         return this.of(this.cf, this.data, parameters).value;
+//       },
+//       getGradient: (parameters: number[], gradient: number[]) => {
+//         const length = Object.keys(this.fitHistory.parameters).length;
+//         this.fitHistory.iterations++;
+//         this.fitHistory.parameters[length] = parameters.slice();
+//         this.fitHistory.likelihood[length] = this.of(this.cf, this.data, parameters).value;
+//         console.log(parameters.slice());
+//         for (let i = 0; i < parameters.length; i++)
+//           gradient[i] = this.getDerivative(parameters, i);
+//         return gradient;
+//       }
+//     };
+//   }
+//   performFit(): void {
+//     limitedMemoryBFGS(this.optimizable, this.params);
+//     limitedMemoryBFGS(this.optimizable, this.params);
+//   }
+//   get parameters(): number[] {
+//     return this.params;
+//   }
+//   get curveFunction(): Function {
+//     let res = (arg: TArg) =>{
+//       let params = this.fitHistory.parameters[this.fitHistory.iterations - 1];
+//       return this.cf(params, arg);
+//     }
+//     return res;
+//   }
+//   get confidence(): {top:Function, bottom: Function} {
+//     let params = this.fitHistory.parameters[this.fitHistory.iterations - 1];
+//     let error = this.errorModel == "constant" ?
+//                 this.of(this.cf, this.data, params).const :
+//                 this.of(this.cf, this.data, params).mult;
+//     let top = (arg: TArg) =>{
+//       let value = this.cf(params, arg);
+//       if (this.errorModel == "constant")
+//         return  value + 1.4*error;
+//       else
+//         return  value + 1.4*(Math.abs(value)*error);
+//     }
+//     let bottom = (arg: TArg) =>{
+//       let value = this.cf(params, arg);
+//       if (this.errorModel == "constant")
+//         return  value - 1.4*error;
+//       else
+//         return  value - 1.4*(Math.abs(value)*error);
+//     }
+//     return {top: top, bottom: bottom};
+//   }
+//   //central difference
+//   private getDerivative(params: number[], selectedParam: number): number {
+//     let step = params[selectedParam]*0.0001;
+//     step = step == 0 ? 0.001 : step; 
+//     let paramsTop: number[] = [];
+//     let paramsBottom: number[] = [];
+//     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 = this.of(this.cf, this.data, paramsTop).value;
+//     const drvBottom = this.of(this.cf, this.data, paramsBottom).value;
+//     return (drvTop - drvBottom)/(2*step);
+//   }
+// }
 export function sigmoid(params, x) {
     const A = params[0];
     const B = params[1];
@@ -110,10 +213,10 @@ function objectiveNormalConstant(targetFunc, data, params) {
     let sigma = 0;
     let sigmaSq = 0;
     let likelihood = 0;
-    let residuesSquares = new Float32Array(data.args.length);
-    for (let i = 0; i < data.args.length; i++) {
-        const obs = data.observed[i];
-        const pred = targetFunc(params, data.args[i]);
+    let 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++)
@@ -130,10 +233,10 @@ function objectiveNormalProportional(targetFunc, data, params) {
     let sigma = 0;
     let sigmaSq = 0;
     let likelihood = 0;
-    let residuesSquares = new Float32Array(data.args.length);
-    for (let i = 0; i < data.args.length; i++) {
-        const obs = data.observed[i];
-        const pred = targetFunc(params, data.args[i]);
+    let 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++)
@@ -144,4 +247,52 @@ function objectiveNormalProportional(targetFunc, data, params) {
         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":"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","sourcesContent":["import {limitedMemoryBFGS} from \"../../lbfgs/lbfgs\"\n\ntype Likelihood = {\n  value: number, \n  const: number, \n  mult: number\n};\n\ninterface ICurveFitter<TArg> {\n  data: {observed: number[], args: TArg[]};\n  params: number[];\n\n  //curve function\n  cf (params: number[], args: TArg): number\n  //objective function\n  of (targetFunc: (params: number[], args: TArg) => number, \n                                  data: {observed: number[], args: TArg[]},\n                                  params: number[]): Likelihood\n}\n\nexport class CurveFitter<TArg> implements ICurveFitter<TArg> {\n  errorModel: string;\n  data: {observed: number[], args: TArg[]};\n  params: number[];\n  cf;\n  of;\n  optimizable;\n  fitHistory: {iterations: number, parameters: {[iteration: number]: number[]}, \n                likelihood: {[iteration: number]: number}} = {\n    iterations: 0,\n    parameters: {},\n    likelihood: {}\n  };\n\n  constructor(curveFunction: (params: number[], args: TArg) => number, \n              data: {observed: number[], args: TArg[]},\n              params: number[],\n              errorModel: 'constant' | 'proportional' = 'constant'\n              ) {\n\n    if(data.observed.length == 0 || data.observed.length != data.args.length)\n      throw new Error('invalid data');\n      \n    this.data = data;\n    this.params = params;\n    this.errorModel = errorModel;\n    this.cf = curveFunction;\n\n    switch(errorModel) {\n      case 'constant':\n        this.of = objectiveNormalConstant;\n      case 'proportional':\n        this.of = objectiveNormalProportional;\n      // case 'combinational1':\n      //   this.of = objectiveNormalAdditive;\n      // case 'combinational2':\n      //   this.of = objectiveNormalAdditive;\n      default:\n        this.of = objectiveNormalConstant;\n    }\n\n    this.optimizable = {\n      getValue: (parameters: number[]) => {\n        return this.of(this.cf, this.data, parameters).value;\n      },\n      getGradient: (parameters: number[], gradient: number[]) => {\n        const length = Object.keys(this.fitHistory.parameters).length;\n        this.fitHistory.iterations++;\n        this.fitHistory.parameters[length] = parameters.slice();\n        this.fitHistory.likelihood[length] = this.of(this.cf, this.data, parameters).value;\n        console.log(parameters.slice());\n        \n        for (let i = 0; i < parameters.length; i++)\n          gradient[i] = this.getDerivative(parameters, i);\n\n        return gradient;\n      }\n    };\n  }\n\n  performFit(): void {\n    limitedMemoryBFGS(this.optimizable, this.params);\n    limitedMemoryBFGS(this.optimizable, this.params);\n  }\n\n  get parameters(): number[] {\n    return this.params;\n  }\n\n  get curveFunction(): Function {\n    let res = (arg: TArg) =>{\n      let params = this.fitHistory.parameters[this.fitHistory.iterations - 1];\n\n      return this.cf(params, arg);\n    }\n\n    return res;\n  }\n\n  get confidence(): {top:Function, bottom: Function} {\n    let params = this.fitHistory.parameters[this.fitHistory.iterations - 1];\n\n    let error = this.errorModel == \"constant\" ?\n                this.of(this.cf, this.data, params).const :\n                this.of(this.cf, this.data, params).mult;\n\n    let top = (arg: TArg) =>{\n      let value = this.cf(params, arg);\n      if (this.errorModel == \"constant\")\n        return  value + 1.4*error;\n      else\n        return  value + 1.4*(Math.abs(value)*error);\n    }\n\n    let bottom = (arg: TArg) =>{\n      let value = this.cf(params, arg);\n      if (this.errorModel == \"constant\")\n        return  value - 1.4*error;\n      else\n        return  value - 1.4*(Math.abs(value)*error);\n    }\n\n    return {top: top, bottom: bottom};\n  }\n\n  //central difference\n  private getDerivative(params: number[], selectedParam: number): number {\n    let step = params[selectedParam]*0.0001;\n    step = step == 0 ? 0.001 : step; \n    let paramsTop: number[] = [];\n    let 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 = this.of(this.cf, this.data, paramsTop).value;\n    const drvBottom = this.of(this.cf, this.data, paramsBottom).value;\n\n    return (drvTop - drvBottom)/(2*step);\n  }\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  const res = D + (A - D)/(1 + Math.pow(10, (x - C)*B));\n  return res;\n}\n\nfunction objectiveNormalConstant<TArg> (\n                                        targetFunc: (params: number[], args: TArg) => number, \n                                        data: {observed: number[], args: TArg[]},\n                                        params: number[]\n): 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  let residuesSquares = new Float32Array(data.args.length);\n  for(let i = 0; i < data.args.length; i++) {\n    const obs = data.observed[i];\n    const pred = targetFunc(params, data.args[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  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<TArg> (\n  targetFunc: (params: number[], args: TArg) => number, \n  data: {observed: number[], args: TArg[]},\n  params: number[]\n): Likelihood {\n//assure observed and args same length\nconst pi = Math.PI;\nlet sigma = 0;\nlet sigmaSq = 0;\nlet likelihood = 0;\n\nlet residuesSquares = new Float32Array(data.args.length);\nfor(let i = 0; i < data.args.length; i++) {\nconst obs = data.observed[i];\nconst pred = targetFunc(params, data.args[i])\nresiduesSquares[i] = Math.pow(obs - pred, 2);\n}\n\nfor(let i = 0; i < residuesSquares.length; i++)\nsigmaSq += residuesSquares[i];\nsigmaSq /= residuesSquares.length;\nsigma = Math.sqrt(sigmaSq);\n\nfor(let i = 0; i < residuesSquares.length; i++)\nlikelihood += residuesSquares[i]/sigmaSq + Math.log(2*pi*sigmaSq);\n\nreturn {value: -likelihood, const: sigma, mult: 0};                                              \n}"]}
+// function objectiveNormalConstant<TArg> (
+//                                         targetFunc: (params: number[], args: TArg) => number, 
+//                                         data: {observed: number[], args: TArg[]},
+//                                         params: number[]
+// ): Likelihood {
+//   //assure observed and args same length
+//   const pi = Math.PI;
+//   let sigma = 0;
+//   let sigmaSq = 0;
+//   let likelihood = 0;
+//   let residuesSquares = new Float32Array(data.args.length);
+//   for(let i = 0; i < data.args.length; i++) {
+//     const obs = data.observed[i];
+//     const pred = targetFunc(params, data.args[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<TArg> (
+//   targetFunc: (params: number[], args: TArg) => number, 
+//   data: {observed: number[], args: TArg[]},
+//   params: number[]
+// ): Likelihood {
+// //assure observed and args same length
+// const pi = Math.PI;
+// let sigma = 0;
+// let sigmaSq = 0;
+// let likelihood = 0;
+// let residuesSquares = new Float32Array(data.args.length);
+// for(let i = 0; i < data.args.length; i++) {
+// const obs = data.observed[i];
+// const pred = targetFunc(params, data.args[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":"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","sourcesContent":["import {limitedMemoryBFGS} from \"../../lbfgs/lbfgs\"\n\ntype Likelihood = {\n  value: number, \n  const: number, \n  mult: number\n};\n\ntype FitResult = {\n  parameters: number[],\n  fittedCurve: (x:number)=> number,\n  confidenceTop: (x:number)=> number,\n  confidenceBottom: (x:number)=> number\n};\n\nexport function fit (data:{x: number[], y: number[]}, params: number[],\n                    curveFunction: (params: number[], x: number) => number, errorModel: string): FitResult {\n\n  let of: (targetFunc: (params: number[], x: number) => number, \n  data: {y: number[], x: number[]},\n  params: number[]) => Likelihood;\n  switch(errorModel) {\n    case 'constant':\n      of = objectiveNormalConstant;\n      break;\n    case 'proportional':\n      of = objectiveNormalProportional;\n      break;\n    default:\n      of = objectiveNormalConstant;\n      break;\n  }\n\n  function getDerivative(params: number[], selectedParam: number): number {\n    let step = params[selectedParam]*0.0001;\n    step = step == 0 ? 0.001 : step; \n    let paramsTop: number[] = [];\n    let 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\n\n  let iterations = 0;\n\n  let optimizable = {\n    getValue: (parameters: number[]) => {\n      return of(curveFunction, data, parameters).value;\n    },\n    getGradient: (parameters: number[], gradient: number[]) => {\n      const length = Object.keys(parameters).length;\n      iterations++;\n      console.log(parameters.slice());\n      \n      for (let i = 0; i < parameters.length; i++)\n        gradient[i] = getDerivative(parameters, i);\n\n      return gradient;\n    }\n  };\n\n  limitedMemoryBFGS(optimizable, params);\n  limitedMemoryBFGS(optimizable, params);\n\n  let fittedCurve = (x: number) =>{\n    return curveFunction(params, x);\n  }\n\n  let top = (x: number) =>{\n    let value = curveFunction(params, x);\n    if (errorModel == \"constant\")\n      return  value + 1.4*error;\n    else\n      return  value + 1.4*(Math.abs(value)*error);\n  }\n\n  let error = errorModel == \"constant\" ?\n  of(curveFunction, data, params).const :\n  of(curveFunction, data, params).mult;\n\n  let bottom = (x: number) =>{\n    let value = curveFunction(params, x);\n    if (errorModel == \"constant\")\n      return  value - 1.4*error;\n    else\n      return  value - 1.4*(Math.abs(value)*error);\n  }\n\n  let fitRes: FitResult = {\n    parameters: params,\n    fittedCurve: fittedCurve,\n    confidenceTop: top,\n    confidenceBottom: bottom\n  };\n\n  return fitRes;\n}\n\n\n\n// performFit(): FitResult {\n//   limitedMemoryBFGS(this.optimizable, this.params);\n//   limitedMemoryBFGS(this.optimizable, this.params);\n\n//   let fit: FitResult = {\n//     parameters = this.parameters;\n//   };\n\n//   return {parameters: , curveFunction: this.curveFunction, confidence: this.confidence};\n// }\n\n\n// interface ICurveFitter<TArg> {\n//   data: {observed: number[], args: TArg[]};\n//   params: number[];\n\n//   //curve function\n//   cf (params: number[], args: TArg): number\n//   //objective function\n//   of (targetFunc: (params: number[], args: TArg) => number, \n//                                   data: {observed: number[], args: TArg[]},\n//                                   params: number[]): Likelihood\n// }\n\n// export class CurveFitter<TArg = number> implements ICurveFitter<TArg> {\n//   errorModel: string;\n//   data: {observed: number[], args: TArg[]};\n//   params: number[];\n//   cf;\n//   of;\n//   optimizable;\n//   fitHistory: {iterations: number, parameters: {[iteration: number]: number[]}, \n//                 likelihood: {[iteration: number]: number}} = {\n//     iterations: 0,\n//     parameters: {},\n//     likelihood: {}\n//   };\n\n//   constructor(curveFunction: (params: number[], args: TArg) => number, \n//               data: {observed: number[], args: TArg[]},\n//               params: number[],\n//               errorModel: 'constant' | 'proportional' = 'constant'//implement as enum\n//               ) {\n\n//     if(data.observed.length == 0 || data.observed.length != data.args.length)\n//       throw new Error('invalid data');\n      \n//     this.data = data;\n//     this.params = params;\n//     this.errorModel = errorModel;\n//     this.cf = curveFunction;\n\n//     switch(errorModel) {\n//       case 'constant':\n//         this.of = objectiveNormalConstant;\n//         break;\n//       case 'proportional':\n//         this.of = objectiveNormalProportional;\n//         break;\n//       default:\n//         this.of = objectiveNormalConstant;\n//         break;\n//     }\n\n//     this.optimizable = {\n//       getValue: (parameters: number[]) => {\n//         return this.of(this.cf, this.data, parameters).value;\n//       },\n//       getGradient: (parameters: number[], gradient: number[]) => {\n//         const length = Object.keys(this.fitHistory.parameters).length;\n//         this.fitHistory.iterations++;\n//         this.fitHistory.parameters[length] = parameters.slice();\n//         this.fitHistory.likelihood[length] = this.of(this.cf, this.data, parameters).value;\n//         console.log(parameters.slice());\n        \n//         for (let i = 0; i < parameters.length; i++)\n//           gradient[i] = this.getDerivative(parameters, i);\n\n//         return gradient;\n//       }\n//     };\n//   }\n\n//   performFit(): void {\n//     limitedMemoryBFGS(this.optimizable, this.params);\n//     limitedMemoryBFGS(this.optimizable, this.params);\n//   }\n\n//   get parameters(): number[] {\n//     return this.params;\n//   }\n\n//   get curveFunction(): Function {\n//     let res = (arg: TArg) =>{\n//       let params = this.fitHistory.parameters[this.fitHistory.iterations - 1];\n\n//       return this.cf(params, arg);\n//     }\n\n//     return res;\n//   }\n\n//   get confidence(): {top:Function, bottom: Function} {\n//     let params = this.fitHistory.parameters[this.fitHistory.iterations - 1];\n\n//     let error = this.errorModel == \"constant\" ?\n//                 this.of(this.cf, this.data, params).const :\n//                 this.of(this.cf, this.data, params).mult;\n\n//     let top = (arg: TArg) =>{\n//       let value = this.cf(params, arg);\n//       if (this.errorModel == \"constant\")\n//         return  value + 1.4*error;\n//       else\n//         return  value + 1.4*(Math.abs(value)*error);\n//     }\n\n//     let bottom = (arg: TArg) =>{\n//       let value = this.cf(params, arg);\n//       if (this.errorModel == \"constant\")\n//         return  value - 1.4*error;\n//       else\n//         return  value - 1.4*(Math.abs(value)*error);\n//     }\n\n//     return {top: top, bottom: bottom};\n//   }\n\n//   //central difference\n//   private getDerivative(params: number[], selectedParam: number): number {\n//     let step = params[selectedParam]*0.0001;\n//     step = step == 0 ? 0.001 : step; \n//     let paramsTop: number[] = [];\n//     let 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 = this.of(this.cf, this.data, paramsTop).value;\n//     const drvBottom = this.of(this.cf, this.data, paramsBottom).value;\n\n//     return (drvTop - drvBottom)/(2*step);\n//   }\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  const res = D + (A - D)/(1 + Math.pow(10, (x - C)*B));\n  return res;\n}\n\n\n\nfunction objectiveNormalConstant (\n  targetFunc: (params: number[], x: number) => number, \n  data: {y: number[], x: number[]},\n  params: number[]\n): Likelihood {\n//assure observed and args same length\nconst pi = Math.PI;\nlet sigma = 0;\nlet sigmaSq = 0;\nlet likelihood = 0;\n\nlet residuesSquares = new Float32Array(data.x.length);\nfor(let i = 0; i < data.x.length; i++) {\nconst obs = data.y[i];\nconst pred = targetFunc(params, data.x[i]);\nresiduesSquares[i] = Math.pow(obs - pred, 2);\n}\n\nfor(let i = 0; i < residuesSquares.length; i++)\nsigmaSq += residuesSquares[i];\nsigmaSq /= residuesSquares.length;\nsigma = Math.sqrt(sigmaSq);\n\nfor(let i = 0; i < residuesSquares.length; i++)\nlikelihood += residuesSquares[i]/sigmaSq + Math.log(2 * pi * sigmaSq);\n\nreturn {value: -likelihood, const: sigma, mult: 0};                                              \n}\n\nfunction objectiveNormalProportional (\ntargetFunc: (params: number[], x: number) => number, \ndata: {y: number[], x: number[]},\nparams: number[]\n): Likelihood {\n//assure observed and args same length\nconst pi = Math.PI;\nlet sigma = 0;\nlet sigmaSq = 0;\nlet likelihood = 0;\n\nlet residuesSquares = new Float32Array(data.x.length);\nfor(let i = 0; i < data.x.length; i++) {\nconst obs = data.y[i];\nconst pred = targetFunc(params, data.x[i])\nresiduesSquares[i] = Math.pow(obs - pred, 2);\n}\n\nfor(let i = 0; i < residuesSquares.length; i++)\nsigmaSq += residuesSquares[i];\nsigmaSq /= residuesSquares.length;\nsigma = Math.sqrt(sigmaSq);\n\nfor(let i = 0; i < residuesSquares.length; i++)\nlikelihood += residuesSquares[i]/sigmaSq + Math.log(2*pi*sigmaSq);\n\nreturn {value: -likelihood, const: sigma, mult: 0};                                              \n}\n\n\n\n// function objectiveNormalConstant<TArg> (\n//                                         targetFunc: (params: number[], args: TArg) => number, \n//                                         data: {observed: number[], args: TArg[]},\n//                                         params: number[]\n// ): 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//   let residuesSquares = new Float32Array(data.args.length);\n//   for(let i = 0; i < data.args.length; i++) {\n//     const obs = data.observed[i];\n//     const pred = targetFunc(params, data.args[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//   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\n// function objectiveNormalProportional<TArg> (\n//   targetFunc: (params: number[], args: TArg) => number, \n//   data: {observed: number[], args: TArg[]},\n//   params: number[]\n// ): 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// let residuesSquares = new Float32Array(data.args.length);\n// for(let i = 0; i < data.args.length; i++) {\n// const obs = data.observed[i];\n// const pred = targetFunc(params, data.args[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// 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"]}