{"version":3,"sources":["webpack:///ml-gsd/webpack/universalModuleDefinition","webpack:///ml-gsd/ml-gsd.min.js","webpack:///ml-gsd/webpack/bootstrap f1e62a1df3d56321b98b","webpack:///ml-gsd/./src/index.js","webpack:///ml-gsd/./src/optimize.js","webpack:///ml-gsd/./~/ml-optimize-lorentzian/src/index.js","webpack:///ml-gsd/./~/ml-curve-fitting/src/index.js","webpack:///ml-gsd/./~/ml-curve-fitting/src/LM.js","webpack:///ml-gsd/./~/ml-matrix/src/index.js","webpack:///ml-gsd/./~/ml-matrix/src/matrix.js","webpack:///ml-gsd/./~/ml-matrix/src/decompositions.js","webpack:///ml-gsd/./~/ml-matrix/src/dc/svd.js","webpack:///ml-gsd/./~/ml-matrix/src/dc/util.js","webpack:///ml-gsd/./~/ml-matrix/src/dc/evd.js","webpack:///ml-gsd/./~/ml-matrix/src/dc/lu.js","webpack:///ml-gsd/./~/ml-matrix/src/dc/qr.js","webpack:///ml-gsd/./~/ml-matrix/src/dc/cholesky.js","webpack:///ml-gsd/./~/ml-curve-fitting/src/algebra.js","webpack:///ml-gsd/./src/gsd.js"],"names":["root","factory","exports","module","define","amd","this","modules","__webpack_require__","moduleId","installedModules","id","loaded","call","m","c","p","optimize","gsd","sampleFunction","from","to","x","y","lastIndex","nbPoints","length","sampleX","sampleY","direction","Math","sign","delta","abs","mid","stop","index","push","optimizePeaks","peakList","n","fnType","i","j","groups","groupPeaks","result","factor","peaks","group","sampling","limits","error","width","opts","optPeaks","Opt","optimizeGaussianSum","optimizeLorentzianSum","optPeak","optimizeSingleGaussian","optimizeSingleLorentzian","nL","upperLimit","lowerLimit","splice","sumOfLorentzians","t","p2","cols","rows","Matrix","zeros","pow","singleLorentzian","columns","singleGaussian","factor2","exp","xy","peak","xy2","parseData","y_data","maxY","weight","sqrt","dot","Object","create","consts","dt","dx","p_init","p_min","p_max","p_fit","LM","math","Array","k","nbSeries","SizeException","algebra","func","y_dat","dp","tensor_parameter","iteration","eps","Npar","Npnt","p_old","y_old","X2","X2_old","J","console","log","length_t","length_y_dat","multiply","transpose","prnt","MaxIter","epsilon_1","epsilon_4","lambda_0","lambda_UP_fac","lambda_DN_fac","Update_Type","dp_array","idx","Nfit","weight_sq","tmp","ones","dotMultiply","lm_matx","JtWJ","JtWdy","Chi_sq","y_hat","max","lambda","diag","nu","h","solve","add","eye","hidx","p_try","min","delta_y","subtract","X2_try","JtWdy_th","alpha","inv","mat","rho","dX2","apply","lm_FD_J","ps","clone","del","y1","column","dotDivide","lm_Broyden_J","h_t","div","Jt","Decompositions","DC","slice","arr","ii","nRows","nColumns","matrix","newInstance","isArray","TypeError","RangeError","defineProperty","writable","value","__proto__","prototype","Asplice","Aconcat","concat","from1DArray","newRows","newColumns","newData","data","rowVector","columnVector","l","vector","empty","fill","rand","jj","random","indices","stack","arg1","isMatrix","arguments","r","current","setRow","expand","base","count","expansion","checkMatrix","klass","get","checkRowIndex","checkColumnIndex","checkDimensions","otherMatrix","callback","to2DArray","to1DArray","copy","isRowVector","isColumnVector","isVector","isSquare","isSymmetric","set","rowIndex","columnIndex","neg","mulS","addS","addM","sub","subS","subM","mul","mulM","divS","divM","getRow","getRowVector","array","removeRow","addRow","swapRows","row1","row2","temp","getColumn","getColumnVector","setColumn","removeColumn","addColumn","swapColumns","column1","column2","row","checkRowVector","checkColumnVector","addRowVector","subRowVector","mulRowVector","divRowVector","addColumnVector","subColumnVector","mulColumnVector","divColumnVector","mulRow","mulColumn","v","Infinity","maxIndex","minIndex","maxRow","maxRowIndex","minRow","minRowIndex","maxColumn","maxColumnIndex","minColumn","minColumnIndex","sum","mean","size","prod","cumulativeSum","other","vector1","vector2","mmul","warn","Bcolj","Arowi","s","sortRows","compareFunction","sort","sortColumns","subMatrix","startRow","endRow","startColumn","endColumn","newMatrix","subMatrixRow","X","subMatrixColumn","trace","inverse","leftHandSide","rightHandSide","LuDecomposition","QrDecomposition","SingularValueDecomposition","EigenvalueDecomposition","CholeskyDecomposition","SVD","EVD","LU","QR","CHO","options","a","wantu","wantv","computeLeftSingularVectors","computeRightSingularVectors","autoTranspose","swapped","aux","ks","f","cs","sn","kase","scale","sp","spm1","epm1","sk","ek","b","shift","g","U","V","e","work","nct","nrt","hypotenuse","pp","iter","condition","norm2","rank","tol","diagonal","threshold","leftSingularVectors","rightSingularVectors","diagonalMatrix","Y","scols","Ls","VL","vrows","urows","VLU","solveForDiagonal","vcols","ucols","Error","d","tred2","tql2","H","ort","orthes","hqr2","hh","dl1","c2","c3","el1","s2","tst1","low","high","nn","w","ra","sa","vr","vi","notlast","cdivres","exshift","norm","q","z","cdiv","xr","xi","yr","yi","realEigenvalues","imaginaryEigenvalues","eigenvectorMatrix","LUrowi","LUcolj","kmax","lu","pivotVector","pivotSign","isSingular","col","determinant","lowerTriangularFactor","upperTriangularFactor","pivotPermutationVector","qr","rdiag","nrm","Rdiag","isFullRank","orthogonalFactor","dimension","positiveDefinite","Lrowj","Lrowk","L","leftTriangularFactor","B","A","dotPow","undefined","minMaxRatio","broadRatio","noiseLevel","maxCriteria","smoothY","dY","ddY","maxDdy","minddY","intervals","lastMax","lastMin","broadMask","realTopDetection","signals","frequency","possible","inter","linewidth","height","broadLines","Number","MAX_VALUE","maxI","candidates","isPartOf","rangeX","fitted","beta","gamma","currentPoint","log10"],"mappings":"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","file":"ml-gsd.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"GSD\"] = factory();\n\telse\n\t\troot[\"GSD\"] = factory();\n})(this, function() {\nreturn \n\n\n/** WEBPACK FOOTER **\n ** webpack/universalModuleDefinition\n **/","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"GSD\"] = factory();\n\telse\n\t\troot[\"GSD\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\n\tmodule.exports.optimize = __webpack_require__(1);\n\tmodule.exports.gsd = __webpack_require__(15);\n\n\n/***/ },\n/* 1 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/**\n\t * Created by acastillo on 9/6/15.\n\t */\n\tvar Opt = __webpack_require__(2);\n\t\n\tfunction sampleFunction(from, to, x, y, lastIndex){\n\t    var nbPoints = x.length;\n\t    var sampleX = [];\n\t    var sampleY = [];\n\t    var direction = Math.sign(x[1]-x[0]);//Direction of the derivative\n\t    if(direction==-1){\n\t        lastIndex[0]= x.length-1;\n\t    }\n\t\n\t    var delta = Math.abs(to-from)/2;\n\t    var mid = (from+to)/2;\n\t    var stop = false;\n\t    var index = lastIndex[0];\n\t    while(!stop&&index<nbPoints&&index>=0){\n\t        if(Math.abs(x[index]-mid)<=delta){\n\t            sampleX.push(x[index]);\n\t            sampleY.push(y[index]);\n\t            index+=direction;\n\t        }\n\t        //It is outside the range.\n\t        else{\n\t\n\t            if(Math.sign(mid-x[index])==1){\n\t                //We'll reach the mid going in the current direction\n\t                index+=direction;\n\t            }\n\t            else{\n\t                //There is not more peaks in the current range\n\t                stop=true;\n\t            }\n\t        }\n\t        //console.log(sampleX);\n\t    }\n\t    lastIndex[0]=index;\n\t    return [sampleX, sampleY];\n\t}\n\t\n\tfunction optimizePeaks(peakList,x,y,n, fnType){\n\t    var i, j, lastIndex=[0];\n\t    var groups = groupPeaks(peakList,n);\n\t    var result = [];\n\t    var factor = 1;\n\t    if(fnType==\"gaussian\")\n\t        factor = 1.17741;//From https://en.wikipedia.org/wiki/Gaussian_function#Properties\n\t    for(i=0;i<groups.length;i++){\n\t        var peaks = groups[i].group;\n\t        if(peaks.length>1){\n\t            //Multiple peaks\n\t            //console.log(\"Pending group of overlaped peaks \"+peaks.length);\n\t            //console.log(\"here1\");\n\t            //console.log(groups[i].limits);\n\t            var sampling = sampleFunction(groups[i].limits[0]-groups[i].limits[1],groups[i].limits[0]+groups[i].limits[1],x,y,lastIndex);\n\t            //console.log(sampling);\n\t            if(sampling[0].length>5){\n\t                var error = peaks[0].width/1000;\n\t                var opts = [  3,    100, error, error, error, error*10, error*10,    11,    9,        1 ];\n\t                //var gauss = Opt.optimizeSingleGaussian(sampling[0], sampling[1], opts, peaks);\n\t                var optPeaks = [];\n\t                if(fnType==\"gaussian\")\n\t                    optPeaks = Opt.optimizeGaussianSum(sampling, peaks, opts);\n\t                else{\n\t                    if(fnType==\"lorentzian\"){\n\t                        optPeaks = Opt.optimizeLorentzianSum(sampling, peaks, opts);\n\t                    }\n\t                }\n\t                //console.log(optPeak);\n\t                for(j=0;j<optPeaks.length;j++){\n\t                    result.push({x:optPeaks[j][0][0],y:optPeaks[j][1][0],width:optPeaks[j][2][0]*factor});\n\t                }\n\t            }\n\t        }\n\t        else{\n\t            //Single peak\n\t            peaks = peaks[0];\n\t            var sampling = sampleFunction(peaks.x-n*peaks.width,\n\t                peaks.x+n*peaks.width,x,y,lastIndex);\n\t            //console.log(\"here2\");\n\t            //console.log(groups[i].limits);\n\t            if(sampling[0].length>5){\n\t                var error = peaks.width/1000;\n\t                var opts = [  3,    100, error, error, error, error*10, error*10,    11,    9,        1 ];\n\t                //var gauss = Opt.optimizeSingleGaussian(sampling[0], sampling[1], opts, peaks);\n\t                //var gauss = Opt.optimizeSingleGaussian([sampling[0],sampling[1]], peaks, opts);\n\t                var optPeak = [];\n\t                if(fnType==\"gaussian\")\n\t                    var optPeak = Opt.optimizeSingleGaussian([sampling[0],sampling[1]], peaks,  opts);\n\t                else{\n\t                    if(fnType==\"lorentzian\"){\n\t                        var optPeak = Opt.optimizeSingleLorentzian([sampling[0],sampling[1]], peaks,  opts);\n\t                    }\n\t                }\n\t                //console.log(optPeak);\n\t                result.push({x:optPeak[0][0],y:optPeak[1][0],width:optPeak[2][0]*factor}); // From https://en.wikipedia.org/wiki/Gaussian_function#Properties}\n\t            }\n\t        }\n\t\n\t    }\n\t    return result;\n\t}\n\t\n\tfunction groupPeaks(peakList,nL){\n\t    var group = [];\n\t    var groups = [];\n\t    var i, j;\n\t    var limits = [peakList[0].x,nL*peakList[0].width];\n\t    var upperLimit, lowerLimit;\n\t    //Merge forward\n\t    for(i=0;i<peakList.length;i++){\n\t        //If the 2 things overlaps\n\t        if(Math.abs(peakList[i].x-limits[0])<(nL*peakList[i].width+limits[1])){\n\t            //Add the peak to the group\n\t            group.push(peakList[i]);\n\t            //Update the group limits\n\t            upperLimit = limits[0]+limits[1];\n\t            if(peakList[i].x+nL*peakList[i].width>upperLimit){\n\t                upperLimit = peakList[i].x+nL*peakList[i].width;\n\t            }\n\t            lowerLimit = limits[0]-limits[1];\n\t            if(peakList[i].x-nL*peakList[i].width<lowerLimit){\n\t                lowerLimit = peakList[i].x-nL*peakList[i].width;\n\t            }\n\t            limits = [(upperLimit+lowerLimit)/2,Math.abs(upperLimit-lowerLimit)/2];\n\t\n\t        }\n\t        else{\n\t            groups.push({limits:limits,group:group});\n\t            //var optmimalPeak = fitSpectrum(group,limits,spectrum);\n\t            group=[peakList[i]];\n\t            limits = [peakList[i].x,nL*peakList[i].width];\n\t        }\n\t    }\n\t    groups.push({limits:limits,group:group});\n\t    //Merge backward\n\t    for(i =groups.length-2;i>=0;i--){\n\t        //The groups overlaps\n\t        if(Math.abs(groups[i].limits[0]-groups[i+1].limits[0])<\n\t            (groups[i].limits[1]+groups[i+1].limits[1])/2){\n\t            for(j=0;j<groups[i+1].group.length;j++){\n\t                groups[i].group.push(groups[i+1].group[j]);\n\t            }\n\t            upperLimit = groups[i].limits[0]+groups[i].limits[1];\n\t            if(groups[i+1].limits[0]+groups[i+1].limits[1]>upperLimit){\n\t                upperLimit = groups[i+1].limits[0]+groups[i+1].limits[1];\n\t            }\n\t            lowerLimit = groups[i].limits[0]-groups[i].limits[1];\n\t            if(groups[i+1].limits[0]-groups[i+1].limits[1]<lowerLimit){\n\t                lowerLimit = groups[i+1].limits[0]-groups[i+1].limits[1];\n\t            }\n\t            //console.log(limits);\n\t            groups[i].limits = [(upperLimit+lowerLimit)/2,Math.abs(upperLimit-lowerLimit)/2];\n\t\n\t            groups.splice(i+1,1);\n\t        }\n\t    }\n\t    return groups;\n\t}\n\t\n\tmodule.exports=optimizePeaks;\n\t\n\n\n/***/ },\n/* 2 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar LM = __webpack_require__(3);\n\tvar math = LM.Matrix.algebra;\n\tvar Matrix = __webpack_require__(5);\n\t\n\t/**\n\t * This function calculates the spectrum as a sum of lorentzian functions. The Lorentzian\n\t * parameters are divided in 3 batches. 1st: centers; 2nd: heights; 3th: widths;\n\t * @param t Ordinate values\n\t * @param p Lorentzian parameters\n\t * @param c Constant parameters(Not used)\n\t * @returns {*}\n\t */\n\tfunction sumOfLorentzians(t,p,c){\n\t    var nL = p.length/3,factor,i, j,p2, cols = t.rows;\n\t    var result = Matrix.zeros(t.length,1);\n\t\n\t    for(i=0;i<nL;i++){\n\t        p2 = Math.pow(p[i+nL*2][0]/2,2);\n\t        factor = p[i+nL][0]*p2;\n\t        for(j=0;j<cols;j++){\n\t            result[j][0]+=factor/(Math.pow(t[j][0]-p[i][0],2)+p2);\n\t        }\n\t    }\n\t    return result;\n\t}\n\t\n\t/**\n\t * This function calculates the spectrum as a sum of gaussian functions. The Gaussian\n\t * parameters are divided in 3 batches. 1st: centers; 2nd: height; 3th: std's;\n\t * @param t Ordinate values\n\t * @param p Gaussian parameters\n\t * @param c Constant parameters(Not used)\n\t * @returns {*}\n\t */\n\tfunction sumOfGaussians(t,p,c){\n\t    var nL = p.length/3,factor,i, j, cols = t.rows;\n\t    var result = Matrix.zeros(t.length,1);\n\t\n\t    for(i=0;i<nL;i++){\n\t        factor = p[i+nL*2][0]*p[i+nL*2][0]/2;\n\t        for(j=0;j<cols;j++){\n\t            result[j][0]+=p[i+nL][0]*Math.exp(-(t[i][0]-p[i][0])*(t[i][0]-p[i][0])/factor);\n\t        }\n\t    }\n\t    return result;\n\t}\n\t/**\n\t * Single 4 parameter lorentzian function\n\t * @param t Ordinate values\n\t * @param p Lorentzian parameters\n\t * @param c Constant parameters(Not used)\n\t * @returns {*}\n\t */\n\tfunction singleLorentzian(t,p,c){\n\t    var factor = p[1][0]*Math.pow(p[2][0]/2,2);\n\t    var rows = t.rows;\n\t    var result = new Matrix(t.rows, t.columns);\n\t    for(var i=0;i<rows;i++){\n\t        result[i][0]=factor/(Math.pow(t[i][0]-p[0][0],2)+Math.pow(p[2][0]/2,2));\n\t    }\n\t    return result;\n\t}\n\t\n\t/**\n\t * Single 3 parameter gaussian function\n\t * @param t Ordinate values\n\t * @param p Gaussian parameters [mean, height, std]\n\t * @param c Constant parameters(Not used)\n\t * @returns {*}\n\t */\n\tfunction singleGaussian(t,p,c){\n\t    var factor2 = p[2][0]*p[2][0]/2;\n\t    var rows = t.rows;\n\t    var result = new Matrix(t.rows, t.columns);\n\t    for(var i=0;i<rows;i++){\n\t        result[i][0]=p[1][0]*Math.exp(-(t[i][0]-p[0][0])*(t[i][0]-p[0][0])/factor2);\n\t    }\n\t    return result;\n\t}\n\t\n\t/**\n\t * * Fits a set of points to a Lorentzian function. Returns the center of the peak, the width at half height, and the height of the signal.\n\t * @param data,[y]\n\t * @returns {*[]}\n\t */\n\tfunction optimizeSingleLorentzian(xy, peak, opts) {\n\t    var xy2 = parseData(xy);\n\t    var t = xy2[0];\n\t    var y_data = xy2[1];\n\t    var maxY = xy2[2];\n\t    var nbPoints = t.columns, i;\n\t\n\t    var weight = [nbPoints / Math.sqrt(y_data.dot(y_data))];\n\t\n\t    var opts=Object.create(opts || [  3,    100, 1e-3, 1e-3, 1e-3, 1e-2, 1e-2,    11,    9,        1 ]);\n\t    //var opts = [  3,    100, 1e-3, 1e-3, 1e-3, 1e-2, 1e-2,    11,    9,        1 ];\n\t    var consts = [ ];\n\t    var dt = Math.abs(t[0][0]-t[1][0]);// optional vector of constants\n\t    var dx = new Matrix([[-dt/10000],[-1e-3],[-dt/10000]]);//-Math.abs(t[0][0]-t[1][0])/100;\n\t    var p_init = new Matrix([[peak.x],[1],[peak.width]]);\n\t    var p_min = new Matrix([[peak.x-dt],[0.75],[peak.width/4]]);\n\t    var p_max = new Matrix([[peak.x+dt],[1.25],[peak.width*4]]);\n\t\n\t    var p_fit = LM.optimize(singleLorentzian,p_init,t,y_data,weight,dx,p_min,p_max,consts,opts);\n\t\n\t\n\t    p_fit = p_fit.p;\n\t    return [p_fit[0],[p_fit[1][0]*maxY],p_fit[2]];\n\t\n\t}\n\t\n\t/**\n\t * Fits a set of points to a gaussian bell. Returns the mean of the peak, the std and the height of the signal.\n\t * @param data,[y]\n\t * @returns {*[]}\n\t */\n\tfunction optimizeSingleGaussian(xy, peak, opts) {\n\t    var xy2 = parseData(xy);\n\t    var t = xy2[0];\n\t    var y_data = xy2[1];\n\t    var maxY = xy2[2];\n\t\n\t    var nbPoints = t.columns, i;\n\t\n\t    var weight = [nbPoints / Math.sqrt(y_data.dot(y_data))];\n\t\n\t    var opts=Object.create(opts || [  3,    100, 1e-3, 1e-3, 1e-3, 1e-2, 1e-2,    11,    9,        1 ]);\n\t    //var opts = [  3,    100, 1e-3, 1e-3, 1e-3, 1e-2, 1e-2,    11,    9,        1 ];\n\t    var consts = [ ];                         // optional vector of constants\n\t    var dt = Math.abs(t[0][0]-t[1][0]);\n\t    var dx = new Matrix([[-dt/10000],[-1e-3],[-dt/10000]]);//-Math.abs(t[0][0]-t[1][0])/100;\n\t\n\t    var dx = new Matrix([[-Math.abs(t[0][0]-t[1][0])/1000],[-1e-3],[-peak.width/1000]]);\n\t    var p_init = new Matrix([[peak.x],[1],[peak.width]]);\n\t    var p_min = new Matrix([[peak.x-dt],[0.75],[peak.width/4]]);\n\t    var p_max = new Matrix([[peak.x+dt],[1.25],[peak.width*4]]);\n\t    //var p_min = new Matrix([[peak.x-peak.width/4],[0.75],[peak.width/3]]);\n\t    //var p_max = new Matrix([[peak.x+peak.width/4],[1.25],[peak.width*3]]);\n\t\n\t    var p_fit = LM.optimize(singleGaussian,p_init,t,y_data,weight,dx,p_min,p_max,consts,opts);\n\t    p_fit = p_fit.p;\n\t    return [p_fit[0],[p_fit[1][0]*maxY],p_fit[2]];\n\t}\n\t\n\t\n\t/**\n\t *\n\t * @param xy A two column matrix containing the x and y data to be fitted\n\t * @param group A set of initial lorentzian parameters to be optimized [center, heigth, half_width_at_half_height]\n\t * @returns {Array} A set of final lorentzian parameters [center, heigth, hwhh*2]\n\t */\n\tfunction optimizeLorentzianSum(xy, group, opts){\n\t    var xy2 = parseData(xy);\n\t    var t = xy2[0];\n\t    var y_data = xy2[1];\n\t    var maxY = xy2[2];\n\t    var nbPoints = t.columns, i;\n\t\n\t    var weight = [nbPoints / math.sqrt(y_data.dot(y_data))];\n\t    var opts=Object.create(opts || [  3,    100, 1e-3, 1e-3, 1e-3, 1e-2, 1e-2,    11,    9,        1 ]);\n\t    var consts = [ ];// optional vector of constants\n\t\n\t    var nL = group.length;\n\t    var p_init = new Matrix(nL*3,1);\n\t    var p_min =  new Matrix(nL*3,1);\n\t    var p_max =  new Matrix(nL*3,1);\n\t    var dx = new Matrix(nL*3,1);\n\t    var dt = Math.abs(t[0][0]-t[1][0]);\n\t    for( i=0;i<nL;i++){\n\t        p_init[i][0] = group[i].x;\n\t        p_init[i+nL][0] = 1;\n\t        p_init[i+2*nL][0] = group[i].width;\n\t\n\t        p_min[i][0] = group[i].x-dt;//-group[i].width/4;\n\t        p_min[i+nL][0] = 0;\n\t        p_min[i+2*nL][0] = group[i].width/4;\n\t\n\t        p_max[i][0] = group[i].x+dt;//+group[i].width/4;\n\t        p_max[i+nL][0] = 1.5;\n\t        p_max[i+2*nL][0] = group[i].width*4;\n\t\n\t        dx[i][0] = -dt/1000;\n\t        dx[i+nL][0] = -1e-3;\n\t        dx[i+2*nL][0] = -dt/1000;\n\t    }\n\t\n\t    var dx = -Math.abs(t[0][0]-t[1][0])/10000;\n\t    var p_fit = LM.optimize(sumOfLorentzians, p_init, t, y_data, weight, dx, p_min, p_max, consts, opts);\n\t    p_fit=p_fit.p;\n\t    //Put back the result in the correct format\n\t    var result = new Array(nL);\n\t    for( i=0;i<nL;i++){\n\t        result[i]=[p_fit[i],[p_fit[i+nL][0]*maxY],p_fit[i+2*nL]];\n\t    }\n\t\n\t    return result;\n\t\n\t}\n\t\n\t/**\n\t *\n\t * @param xy A two column matrix containing the x and y data to be fitted\n\t * @param group A set of initial lorentzian parameters to be optimized [center, heigth, half_width_at_half_height]\n\t * @returns {Array} A set of final lorentzian parameters [center, heigth, hwhh*2]\n\t */\n\tfunction optimizeGaussianSum(xy, group, opts){\n\t    var xy2 = parseData(xy);\n\t    var t = xy2[0];\n\t    var y_data = xy2[1];\n\t    var maxY = xy2[2];\n\t    var nbPoints = t.rows,i;\n\t\n\t    var weight = new Matrix(nbPoints,1);//[nbPoints / math.sqrt(y_data.dot(y_data))];\n\t    var k = nbPoints / math.sqrt(y_data.dot(y_data));\n\t    for(i=0;i<nbPoints;i++){\n\t        weight[i][0]=k;///(y_data[i][0]);\n\t        //weight[i][0]=k*(2-y_data[i][0]);\n\t    }\n\t\n\t    var opts=Object.create(opts || [  3,    100, 1e-3, 1e-3, 1e-3, 1e-2, 1e-2,    11,    9,        2 ]);\n\t    //var opts=[  3,    100, 1e-5, 1e-6, 1e-6, 1e-6, 1e-6,    11,    9,        1 ];\n\t    var consts = [ ];// optional vector of constants\n\t\n\t    var nL = group.length;\n\t    var p_init = new Matrix(nL*3,1);\n\t    var p_min =  new Matrix(nL*3,1);\n\t    var p_max =  new Matrix(nL*3,1);\n\t    var dx = new Matrix(nL*3,1);\n\t    var dt = Math.abs(t[0][0]-t[1][0]);\n\t    for( i=0;i<nL;i++){\n\t        p_init[i][0] = group[i].x;\n\t        p_init[i+nL][0] = group[i].y/maxY;\n\t        p_init[i+2*nL][0] = group[i].width;\n\t\n\t        p_min[i][0] = group[i].x-dt;\n\t        p_min[i+nL][0] = group[i].y*0.8/maxY;\n\t        p_min[i+2*nL][0] = group[i].width/2;\n\t\n\t        p_max[i][0] = group[i].x+dt;\n\t        p_max[i+nL][0] = group[i].y*1.2/maxY;\n\t        p_max[i+2*nL][0] = group[i].width*2;\n\t\n\t        dx[i][0] = -dt/1000;\n\t        dx[i+nL][0] = -1e-3;\n\t        dx[i+2*nL][0] = -dt/1000;\n\t    }\n\t    //console.log(t);\n\t    var p_fit = LM.optimize(sumOfLorentzians,p_init,t,y_data,weight,dx,p_min,p_max,consts,opts);\n\t    p_fit = p_fit.p;\n\t    //Put back the result in the correct format\n\t    var result = new Array(nL);\n\t    for( i=0;i<nL;i++){\n\t        result[i]=[p_fit[i],[p_fit[i+nL][0]*maxY],p_fit[i+2*nL]];\n\t    }\n\t\n\t    return result;\n\t\n\t}\n\t/**\n\t *\n\t * Converts the given input to the required x, y column matrices. y data is normalized to max(y)=1\n\t * @param xy\n\t * @returns {*[]}\n\t */\n\tfunction parseData(xy){\n\t    var nbSeries = xy.length;\n\t    var t = null;\n\t    var y_data = null, x,y;\n\t    var maxY = 0, i,j;\n\t\n\t    if(nbSeries==2){\n\t        //Looks like row wise matrix [x,y]\n\t        var nbPoints = xy[0].length;\n\t        if(nbPoints<3)\n\t            throw new SizeException(nbPoints);\n\t        else{\n\t            t = new Matrix(nbPoints,1);\n\t            y_data = new Matrix(nbPoints,1);\n\t            x = xy[0];\n\t            y = xy[1];\n\t            if(typeof x[0] === \"number\"){\n\t                for(i=0;i<nbPoints;i++){\n\t                    t[i][0]=x[i];\n\t                    y_data[i][0]=y[i];\n\t                    if(y[i]>maxY)\n\t                        maxY = y[i];\n\t                }\n\t            }\n\t            else{\n\t                //It is a colum matrix\n\t                if(typeof x[0] === \"object\"){\n\t                    for(i=0;i<nbPoints;i++){\n\t                        t[i][0]=x[i][0];\n\t                        y_data[i][0]=y[i][0];\n\t                        if(y[i][0]>maxY)\n\t                            maxY = y[i][0];\n\t                    }\n\t                }\n\t\n\t            }\n\t\n\t        }\n\t    }\n\t    else{\n\t        //Looks like a column wise matrix [[x],[y]]\n\t        var nbPoints = nbSeries;\n\t        if(nbPoints<3)\n\t            throw new SizeException(nbPoints);\n\t        else {\n\t            t = new Matrix(nbPoints, 1);\n\t            y_data = new Matrix(nbPoints, 1);\n\t            for (i = 0; i < nbPoints; i++) {\n\t                t[i][0] = xy[i][0];\n\t                y_data[i][0] = xy[i][1];\n\t                if(y_data[i][0]>maxY)\n\t                    maxY = y_data[i][0];\n\t            }\n\t        }\n\t    }\n\t    for (i = 0; i < nbPoints; i++) {\n\t        y_data[i][0]/=maxY;\n\t    }\n\t    return [t,y_data,maxY];\n\t}\n\t\n\tfunction sizeException(nbPoints) {\n\t    return new RangeError(\"Not enough points to perform the optimization: \"+nbPoints +\"< 3\");\n\t}\n\t\n\tmodule.exports.optimizeSingleLorentzian = optimizeSingleLorentzian;\n\tmodule.exports.optimizeLorentzianSum = optimizeLorentzianSum;\n\tmodule.exports.optimizeSingleGaussian = optimizeSingleGaussian;\n\tmodule.exports.optimizeGaussianSum = optimizeGaussianSum;\n\tmodule.exports.singleGaussian = singleGaussian;\n\tmodule.exports.singleLorentzian = singleLorentzian;\n\n/***/ },\n/* 3 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tmodule.exports = __webpack_require__(4);\n\tmodule.exports.Matrix = __webpack_require__(5);\n\tmodule.exports.Matrix.algebra = __webpack_require__(14);\n\n\n/***/ },\n/* 4 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/**\n\t * Created by acastillo on 8/5/15.\n\t */\n\tvar Matrix = __webpack_require__(5);\n\tvar math = __webpack_require__(14);\n\t\n\tvar DEBUG = false;\n\t/** Levenberg Marquardt curve-fitting: minimize sum of weighted squared residuals\n\t ----------  INPUT  VARIABLES  -----------\n\t func   = function of n independent variables, 't', and m parameters, 'p',\n\t returning the simulated model: y_hat = func(t,p,c)\n\t p      = n-vector of initial guess of parameter values\n\t t      = m-vectors or matrix of independent variables (used as arg to func)\n\t y_dat  = m-vectors or matrix of data to be fit by func(t,p)\n\t weight = weighting vector for least squares fit ( weight >= 0 ) ...\n\t inverse of the standard measurement errors\n\t Default:  sqrt(d.o.f. / ( y_dat' * y_dat ))\n\t dp     = fractional increment of 'p' for numerical derivatives\n\t dp(j)>0 central differences calculated\n\t dp(j)<0 one sided 'backwards' differences calculated\n\t dp(j)=0 sets corresponding partials to zero; i.e. holds p(j) fixed\n\t Default:  0.001;\n\t p_min  = n-vector of lower bounds for parameter values\n\t p_max  = n-vector of upper bounds for parameter values\n\t c      = an optional matrix of values passed to func(t,p,c)\n\t opts   = vector of algorithmic parameters\n\t parameter    defaults    meaning\n\t opts(1)  =  prnt            3        >1 intermediate results; >2 plots\n\t opts(2)  =  MaxIter      10*Npar     maximum number of iterations\n\t opts(3)  =  epsilon_1       1e-3     convergence tolerance for gradient\n\t opts(4)  =  epsilon_2       1e-3     convergence tolerance for parameters\n\t opts(5)  =  epsilon_3       1e-3     convergence tolerance for Chi-square\n\t opts(6)  =  epsilon_4       1e-2     determines acceptance of a L-M step\n\t opts(7)  =  lambda_0        1e-2     initial value of L-M paramter\n\t opts(8)  =  lambda_UP_fac   11       factor for increasing lambda\n\t opts(9)  =  lambda_DN_fac    9       factor for decreasing lambda\n\t opts(10) =  Update_Type      1       1: Levenberg-Marquardt lambda update\n\t 2: Quadratic update\n\t 3: Nielsen's lambda update equations\n\t\n\t ----------  OUTPUT  VARIABLES  -----------\n\t p       = least-squares optimal estimate of the parameter values\n\t X2      = Chi squared criteria\n\t sigma_p = asymptotic standard error of the parameters\n\t sigma_y = asymptotic standard error of the curve-fit\n\t corr    = correlation matrix of the parameters\n\t R_sq    = R-squared cofficient of multiple determination\n\t cvg_hst = convergence history\n\t\n\t Henri Gavin, Dept. Civil & Environ. Engineering, Duke Univ. 22 Sep 2013\n\t modified from: http://octave.sourceforge.net/optim/function/leasqr.html\n\t using references by\n\t Press, et al., Numerical Recipes, Cambridge Univ. Press, 1992, Chapter 15.\n\t Sam Roweis       http://www.cs.toronto.edu/~roweis/notes/lm.pdf\n\t Manolis Lourakis http://www.ics.forth.gr/~lourakis/levmar/levmar.pdf\n\t Hans Nielson     http://www2.imm.dtu.dk/~hbn/publ/TR9905.ps\n\t Mathworks        optimization toolbox reference manual\n\t K. Madsen, H.B., Nielsen, and O. Tingleff\n\t http://www2.imm.dtu.dk/pubdb/views/edoc_download.php/3215/pdf/imm3215.pdf\n\t */\n\tvar LM = {\n\t\n\t    optimize: function(func,p,t,y_dat,weight,dp,p_min,p_max,c,opts){\n\t\n\t        var tensor_parameter = 0;\t\t\t// set to 1 of parameter is a tensor\n\t\n\t        var iteration  = 0;\t\t\t// iteration counter\n\t        //func_calls = 0;\t\t\t// running count of function evaluations\n\t\n\t        if((typeof p[0])!=\"object\"){\n\t            for(var i=0;i< p.length;i++){\n\t                p[i]=[p[i]];\n\t            }\n\t\n\t        }\n\t        //p = p(:); y_dat = y_dat(:);\t\t// make column vectors\n\t        var i,k;\n\t        var eps = 2^-52;\n\t        var Npar   = p.length;//length(p); \t\t\t// number of parameters\n\t        var Npnt   = y_dat.length;//length(y_dat);\t\t// number of data points\n\t        var p_old  = Matrix.zeros(Npar,1);\t\t// previous set of parameters\n\t        var y_old  = Matrix.zeros(Npnt,1);\t\t// previous model, y_old = y_hat(t;p_old)\n\t        var X2     = 1e-2/eps;\t\t\t// a really big initial Chi-sq value\n\t        var X2_old = 1e-2/eps;\t\t\t// a really big initial Chi-sq value\n\t        var J =  Matrix.zeros(Npnt,Npar);\n\t\n\t\n\t        if (t.length != y_dat.length) {\n\t            console.log('lm.m error: the length of t must equal the length of y_dat');\n\t\n\t            length_t = t.length;\n\t            length_y_dat = y_dat.length;\n\t            var X2 = 0, corr = 0, sigma_p = 0, sigma_y = 0, R_sq = 0, cvg_hist = 0;\n\t            if (!tensor_parameter) {\n\t                return;\n\t            }\n\t        }\n\t\n\t        weight = weight||Math.sqrt((Npnt-Npar+1)/(math.multiply(math.transpose(y_dat),y_dat)));\n\t        dp = dp || 0.001;\n\t        p_min   = p_min || math.multiply(Math.abs(p),-100);\n\t        p_max   = p_max || math.multiply(Math.abs(p),100);\n\t        c = c || 1;\n\t        // Algorithmic Paramters\n\t        //prnt MaxIter  eps1  eps2  epx3  eps4  lam0  lamUP lamDN UpdateType\n\t        opts = opts ||[  3,10*Npar, 1e-3, 1e-3, 1e-3, 1e-2, 1e-2, 11, 9, 1 ];\n\t\n\t        var prnt          = opts[0];\t// >1 intermediate results; >2 plots\n\t        var MaxIter       = opts[1];\t// maximum number of iterations\n\t        var epsilon_1     = opts[2];\t// convergence tolerance for gradient\n\t        var epsilon_2     = opts[3];\t// convergence tolerance for parameter\n\t        var epsilon_3     = opts[4];\t// convergence tolerance for Chi-square\n\t        var epsilon_4     = opts[5];\t// determines acceptance of a L-M step\n\t        var lambda_0      = opts[6];\t// initial value of damping paramter, lambda\n\t        var lambda_UP_fac = opts[7];\t// factor for increasing lambda\n\t        var lambda_DN_fac = opts[8];\t// factor for decreasing lambda\n\t        var Update_Type   = opts[9];\t// 1: Levenberg-Marquardt lambda update\n\t        // 2: Quadratic update\n\t        // 3: Nielsen's lambda update equations\n\t\n\t        if ( tensor_parameter && prnt == 3 ) prnt = 2;\n\t\n\t\n\t        if(!dp.length || dp.length == 1){\n\t            var dp_array = new Array(Npar);\n\t            for(var i=0;i<Npar;i++)\n\t                dp_array[i]=[dp];\n\t            dp=dp_array;\n\t        }\n\t\n\t        // indices of the parameters to be fit\n\t        var idx   = [];\n\t        for(i=0;i<dp.length;i++){\n\t            if(dp[i][0]!=0){\n\t                idx.push(i);\n\t            }\n\t        }\n\t\n\t        var Nfit = idx.length;\t\t\t// number of parameters to fit\n\t        var stop = false;\t\t\t\t// termination flag\n\t\n\t        var weight_sq = null;\n\t        //console.log(weight);\n\t        if ( !weight.length || weight.length < Npnt )\t{\n\t            // squared weighting vector\n\t            //weight_sq = ( weight(1)*ones(Npnt,1) ).^2;\n\t            //console.log(\"weight[0] \"+typeof weight[0]);\n\t            var tmp = math.multiply(Matrix.ones(Npnt,1),weight[0]);\n\t            weight_sq = math.dotMultiply(tmp,tmp);\n\t        }\n\t        else{\n\t            //weight_sq = (weight(:)).^2;\n\t            weight_sq = math.dotMultiply(weight,weight);\n\t        }\n\t\n\t\n\t        // initialize Jacobian with finite difference calculation\n\t        //console.log(\"J \"+weight_sq);\n\t        var result = this.lm_matx(func,t,p_old,y_old,1,J,p,y_dat,weight_sq,dp,c);\n\t        var JtWJ = result.JtWJ,JtWdy=result.JtWdy,X2=result.Chi_sq,y_hat=result.y_hat,J=result.J;\n\t        //[JtWJ,JtWdy,X2,y_hat,J] = this.lm_matx(func,t,p_old,y_old,1,J,p,y_dat,weight_sq,dp,c);\n\t        //console.log(JtWJ);\n\t\n\t        if ( Math.max(Math.abs(JtWdy)) < epsilon_1 ){\n\t            console.log(' *** Your Initial Guess is Extremely Close to Optimal ***')\n\t            console.log(' *** epsilon_1 = ', epsilon_1);\n\t            stop = true;\n\t        }\n\t\n\t\n\t        switch(Update_Type){\n\t            case 1: // Marquardt: init'l lambda\n\t                lambda  = lambda_0;\n\t                break;\n\t            default:    // Quadratic and Nielsen\n\t                lambda  = lambda_0 * Math.max(math.diag(JtWJ));\n\t                nu=2;\n\t        }\n\t        //console.log(X2);\n\t        X2_old = X2; // previous value of X2\n\t        //console.log(MaxIter+\" \"+Npar);\n\t        //var cvg_hst = Matrix.ones(MaxIter,Npar+3);\t\t// initialize convergence history\n\t        var h = null;\n\t        while ( !stop && iteration <= MaxIter ) {\t\t// --- Main Loop\n\t            iteration = iteration + 1;\n\t            // incremental change in parameters\n\t            switch(Update_Type){\n\t                case 1:\t\t\t\t\t// Marquardt\n\t                    //h = ( JtWJ + lambda * math.diag(math.diag(JtWJ)) ) \\ JtWdy;\n\t                    //h = math.multiply(math.inv(JtWdy),math.add(JtWJ,math.multiply(lambda,math.diag(math.diag(Npar)))));\n\t                    h = math.solve(math.add(JtWJ,math.multiply(math.diag(math.diag(JtWJ)),lambda)),JtWdy);\n\t                    break;\n\t                default:\t\t\t\t\t// Quadratic and Nielsen\n\t                    //h = ( JtWJ + lambda * math.eye(Npar) ) \\ JtWdy;\n\t\n\t                    h = math.solve(math.add(JtWJ,math.multiply( Matrix.eye(Npar),lambda)),JtWdy);\n\t            }\n\t\n\t            /*for(var k=0;k< h.length;k++){\n\t             h[k]=[h[k]];\n\t             }*/\n\t            //console.log(\"h \"+h);\n\t            //h=math.matrix(h);\n\t            //  big = max(abs(h./p)) > 2;\n\t            //this is a big step\n\t            // --- Are parameters [p+h] much better than [p] ?\n\t            var hidx = new Array(idx.length);\n\t            for(k=0;k<idx.length;k++){\n\t                hidx[k]=h[idx[k]];\n\t            }\n\t            var p_try = math.add(p, hidx);// update the [idx] elements\n\t\n\t            for(k=0;k<p_try.length;k++){\n\t                p_try[k][0]=Math.min(Math.max(p_min[k][0],p_try[k][0]),p_max[k][0]);\n\t            }\n\t            // p_try = Math.min(Math.max(p_min,p_try),p_max);           // apply constraints\n\t\n\t            var delta_y = math.subtract(y_dat, func(t,p_try,c));       // residual error using p_try\n\t            //func_calls = func_calls + 1;\n\t            //X2_try = delta_y' * ( delta_y .* weight_sq );  // Chi-squared error criteria\n\t\n\t            var X2_try = math.multiply(math.transpose(delta_y),math.dotMultiply(delta_y,weight_sq));\n\t\n\t            if ( Update_Type == 2 ){  \t\t\t  // Quadratic\n\t                //    One step of quadratic line update in the h direction for minimum X2\n\t                //var alpha =  JtWdy'*h / ( (X2_try - X2)/2 + 2*JtWdy'*h ) ;\n\t                var JtWdy_th = math.multiply(math.transpose(JtWdy),h);\n\t                var alpha =  math.multiply(JtWdy_th,math.inv(math.add(math.multiply(math.subtract(X2_try - X2),1/2)),math.multiply(JtWdy_th,2)));//JtWdy'*h / ( (X2_try - X2)/2 + 2*JtWdy'*h ) ;\n\t\n\t                h = math.multiply(alpha, h);\n\t                for(var k=0;k<idx.length;k++){\n\t                    hidx[k]=h[idx[k]];\n\t                }\n\t\n\t                p_try = math.add(p ,hidx);                     // update only [idx] elements\n\t                p_try = math.min(math.max(p_min,p_try),p_max);          // apply constraints\n\t\n\t                delta_y = math.subtract(y_dat, func(t,p_try,c));      // residual error using p_try\n\t                // func_calls = func_calls + 1;\n\t                //X2_try = delta_y' * ( delta_y .* weight_sq ); // Chi-squared error criteria\n\t                X2_try = math.multiply(math.transpose(delta_y), mat.dotMultiply(delta_y, weight_sq));\n\t            }\n\t\n\t            //rho = (X2 - X2_try) / ( 2*h' * (lambda * h + JtWdy) ); // Nielsen\n\t            var rho = (X2-X2_try)/math.multiply(math.multiply(math.transpose(h),2),math.add(math.multiply(lambda, h),JtWdy));\n\t            //console.log(\"rho \"+rho);\n\t            if ( rho > epsilon_4 ) {\t\t// it IS significantly better\n\t                //console.log(\"Here\");\n\t                dX2 = X2 - X2_old;\n\t                X2_old = X2;\n\t                p_old = p;\n\t                y_old = y_hat;\n\t                p = p_try;\t\t\t// accept p_try\n\t\n\t                result = this.lm_matx(func, t, p_old, y_old, dX2, J, p, y_dat, weight_sq, dp, c);\n\t                JtWJ = result.JtWJ,JtWdy=result.JtWdy,X2=result.Chi_sq,y_hat=result.y_hat,J=result.J;\n\t                // decrease lambda ==> Gauss-Newton method\n\t\n\t                switch (Update_Type) {\n\t                    case 1:\t\t\t\t\t\t\t// Levenberg\n\t                        lambda = Math.max(lambda / lambda_DN_fac, 1.e-7);\n\t                        break;\n\t                    case 2:\t\t\t\t\t\t\t// Quadratic\n\t                        lambda = Math.max(lambda / (1 + alpha), 1.e-7);\n\t                        break;\n\t                    case 3:\t\t\t\t\t\t\t// Nielsen\n\t                        lambda = math.multiply(Math.max(1 / 3, 1 - (2 * rho - 1) ^ 3),lambda);\n\t                        nu = 2;\n\t                        break;\n\t                }\n\t            }\n\t            else {\t\t\t\t\t// it IS NOT better\n\t                X2 = X2_old;\t\t\t// do not accept p_try\n\t                if (iteration%(2 * Npar)==0) {\t// rank-1 update of Jacobian\n\t                    result = this.lm_matx(func, t, p_old, y_old, -1, J, p, y_dat, weight_sq, dp, c);\n\t                    JtWJ = result.JtWJ,JtWdy=result.JtWdy,dX2=result.Chi_sq,y_hat=result.y_hat,J=result.J;\n\t                }\n\t\n\t                // increase lambda  ==> gradient descent method\n\t                switch (Update_Type) {\n\t                    case 1:\t\t\t\t\t\t\t// Levenberg\n\t                        lambda = Math.min(lambda * lambda_UP_fac, 1.e7);\n\t                        break;\n\t                    case 2:\t\t\t\t\t\t\t// Quadratic\n\t                        lambda = lambda + Math.abs((X2_try - X2) / 2 / alpha);\n\t                        break;\n\t                    case 3:\t\t\t\t\t\t// Nielsen\n\t                        lambda = lambda * nu;\n\t                        nu = 2 * nu;\n\t                        break;\n\t                }\n\t            }\n\t        }// --- End of Main Loop\n\t\n\t        // --- convergence achieved, find covariance and confidence intervals\n\t\n\t        // equal weights for paramter error analysis\n\t        weight_sq = math.multiply(math.multiply(math.transpose(delta_y),delta_y), Matrix.ones(Npnt,1));\n\t\n\t        weight_sq.apply(function(i,j){\n\t            weight_sq[i][j] = (Npnt-Nfit+1)/weight_sq[i][j];\n\t        });\n\t        //console.log(weight_sq);\n\t        result = this.lm_matx(func,t,p_old,y_old,-1,J,p,y_dat,weight_sq,dp,c);\n\t        JtWJ = result.JtWJ,JtWdy=result.JtWdy,X2=result.Chi_sq,y_hat=result.y_hat,J=result.J;\n\t\n\t        /*if nargout > 2\t\t\t\t// standard error of parameters\n\t         covar = inv(JtWJ);\n\t         sigma_p = sqrt(diag(covar));\n\t         end\n\t\n\t         if nargout > 3\t\t\t\t// standard error of the fit\n\t         //  sigma_y = sqrt(diag(J * covar * J'));\t// slower version of below\n\t         sigma_y = zeros(Npnt,1);\n\t         for i=1:Npnt\n\t         sigma_y(i) = J(i,:) * covar * J(i,:)';\n\t         end\n\t         sigma_y = sqrt(sigma_y);\n\t         end\n\t\n\t         if nargout > 4\t\t\t\t// parameter correlation matrix\n\t         corr = covar ./ [sigma_p*sigma_p'];\n\t         end\n\t\n\t         if nargout > 5\t\t\t\t// coefficient of multiple determination\n\t         R_sq = corrcoef([y_dat y_hat]);\n\t         R_sq = R_sq(1,2).^2;\n\t         end\n\t\n\t         if nargout > 6\t\t\t\t// convergence history\n\t         cvg_hst = cvg_hst(1:iteration,:);\n\t         end*/\n\t\n\t        // endfunction  # ---------------------------------------------------------- LM\n\t\n\t        return { p:p, X2:X2};\n\t    },\n\t\n\t    lm_FD_J:function(func,t,p,y,dp,c) {\n\t        // J = lm_FD_J(func,t,p,y,{dp},{c})\n\t        //\n\t        // partial derivatives (Jacobian) dy/dp for use with lm.m\n\t        // computed via Finite Differences\n\t        // Requires n or 2n function evaluations, n = number of nonzero values of dp\n\t        // -------- INPUT VARIABLES ---------\n\t        // func = function of independent variables, 't', and parameters, 'p',\n\t        //        returning the simulated model: y_hat = func(t,p,c)\n\t        // t  = m-vector of independent variables (used as arg to func)\n\t        // p  = n-vector of current parameter values\n\t        // y  = func(t,p,c) n-vector initialised by user before each call to lm_FD_J\n\t        // dp = fractional increment of p for numerical derivatives\n\t        //      dp(j)>0 central differences calculated\n\t        //      dp(j)<0 one sided differences calculated\n\t        //      dp(j)=0 sets corresponding partials to zero; i.e. holds p(j) fixed\n\t        //      Default:  0.001;\n\t        // c  = optional vector of constants passed to y_hat = func(t,p,c)\n\t        //---------- OUTPUT VARIABLES -------\n\t        // J  = Jacobian Matrix J(i,j)=dy(i)/dp(j)\ti=1:n; j=1:m\n\t\n\t        //   Henri Gavin, Dept. Civil & Environ. Engineering, Duke Univ. November 2005\n\t        //   modified from: ftp://fly.cnuce.cnr.it/pub/software/octave/leasqr/\n\t        //   Press, et al., Numerical Recipes, Cambridge Univ. Press, 1992, Chapter 15.\n\t\n\t        var m = y.length;\t\t\t// number of data points\n\t        var n = p.length;\t\t\t// number of parameters\n\t\n\t        dp = dp || math.multiply( Matrix.ones(n, 1), 0.001);\n\t\n\t        var ps = p.clone();//JSON.parse(JSON.stringify(p));\n\t        //var ps = $.extend(true, [], p);\n\t        var J = new Matrix(m,n), del =new Array(n);         // initialize Jacobian to Zero\n\t\n\t        for (var j = 0;j < n; j++) {\n\t            //console.log(j+\" \"+dp[j]+\" \"+p[j]+\" \"+ps[j]+\" \"+del[j]);\n\t            del[j] = dp[j]*(1+Math.abs(p[j][0]));  // parameter perturbation\n\t            p[j] = [ps[j][0]+del[j]];\t      // perturb parameter p(j)\n\t            //console.log(j+\" \"+dp[j]+\" \"+p[j]+\" \"+ps[j]+\" \"+del[j]);\n\t\n\t            if (del[j] != 0){\n\t                y1 = func(t, p, c);\n\t                //func_calls = func_calls + 1;\n\t                if (dp[j][0] < 0) {\t\t// backwards difference\n\t                    //J(:,j) = math.dotDivide(math.subtract(y1, y),del[j]);//. / del[j];\n\t                    //console.log(del[j]);\n\t                    //console.log(y);\n\t                    var column = math.dotDivide(math.subtract(y1, y),del[j]);\n\t                    for(var k=0;k< m;k++){\n\t                        J[k][j]=column[k][0];\n\t                    }\n\t                    //console.log(column);\n\t                }\n\t                else{\n\t                    p[j][0] = ps[j][0] - del[j];\n\t                    //J(:,j) = (y1 - feval(func, t, p, c)). / (2. * del[j]);\n\t                    var column = math.dotDivide(math.subtract(y1,func(t,p,c)),2*del[j]);\n\t                    for(var k=0;k< m;k++){\n\t                        J[k][j]=column[k][0];\n\t                    }\n\t\n\t                }\t\t\t// central difference, additional func call\n\t            }\n\t\n\t            p[j] = ps[j];\t\t// restore p(j)\n\t\n\t        }\n\t        //console.log(\"lm_FD_J: \"+ JSON.stringify(J));\n\t        return J;\n\t\n\t    },\n\t\n\t    // endfunction # -------------------------------------------------- LM_FD_J\n\t    lm_Broyden_J: function(p_old,y_old,J,p,y){\n\t        // J = lm_Broyden_J(p_old,y_old,J,p,y)\n\t        // carry out a rank-1 update to the Jacobian matrix using Broyden's equation\n\t        //---------- INPUT VARIABLES -------\n\t        // p_old = previous set of parameters\n\t        // y_old = model evaluation at previous set of parameters, y_hat(t;p_old)\n\t        // J  = current version of the Jacobian matrix\n\t        // p     = current  set of parameters\n\t        // y     = model evaluation at current  set of parameters, y_hat(t;p)\n\t        //---------- OUTPUT VARIABLES -------\n\t        // J = rank-1 update to Jacobian Matrix J(i,j)=dy(i)/dp(j)\ti=1:n; j=1:m\n\t        //console.log(p+\" X \"+ p_old)\n\t        var h  = math.subtract(p, p_old);\n\t\n\t        //console.log(\"hhh \"+h);\n\t        var h_t = math.transpose(h);\n\t        h_t.div(math.multiply(h_t,h));\n\t\n\t        //console.log(h_t);\n\t        //J = J + ( y - y_old - J*h )*h' / (h'*h);\t// Broyden rank-1 update eq'n\n\t        J = math.add(J, math.multiply(math.subtract(y, math.add(y_old,math.multiply(J,h))),h_t));\n\t        return J;\n\t        // endfunction # ---------------------------------------------- LM_Broyden_J\n\t    },\n\t\n\t    lm_matx : function (func,t,p_old,y_old,dX2,J,p,y_dat,weight_sq,dp,c,iteration){\n\t        // [JtWJ,JtWdy,Chi_sq,y_hat,J] = this.lm_matx(func,t,p_old,y_old,dX2,J,p,y_dat,weight_sq,{da},{c})\n\t        //\n\t        // Evaluate the linearized fitting matrix, JtWJ, and vector JtWdy,\n\t        // and calculate the Chi-squared error function, Chi_sq\n\t        // Used by Levenberg-Marquard algorithm, lm.m\n\t        // -------- INPUT VARIABLES ---------\n\t        // func   = function ofpn independent variables, p, and m parameters, p,\n\t        //         returning the simulated model: y_hat = func(t,p,c)\n\t        // t      = m-vectors or matrix of independent variables (used as arg to func)\n\t        // p_old  = n-vector of previous parameter values\n\t        // y_old  = m-vector of previous model ... y_old = y_hat(t;p_old);\n\t        // dX2    = previous change in Chi-squared criteria\n\t        // J   = m-by-n Jacobian of model, y_hat, with respect to parameters, p\n\t        // p      = n-vector of current  parameter values\n\t        // y_dat  = n-vector of data to be fit by func(t,p,c)\n\t        // weight_sq = square of the weighting vector for least squares fit ...\n\t        //\t    inverse of the standard measurement errors\n\t        // dp     = fractional increment of 'p' for numerical derivatives\n\t        //          dp(j)>0 central differences calculated\n\t        //          dp(j)<0 one sided differences calculated\n\t        //          dp(j)=0 sets corresponding partials to zero; i.e. holds p(j) fixed\n\t        //          Default:  0.001;\n\t        // c      = optional vector of constants passed to y_hat = func(t,p,c)\n\t        //---------- OUTPUT VARIABLES -------\n\t        // JtWJ\t = linearized Hessian matrix (inverse of covariance matrix)\n\t        // JtWdy   = linearized fitting vector\n\t        // Chi_sq = Chi-squared criteria: weighted sum of the squared residuals WSSR\n\t        // y_hat  = model evaluated with parameters 'p'\n\t        // J   = m-by-n Jacobian of model, y_hat, with respect to parameters, p\n\t\n\t        //   Henri Gavin, Dept. Civil & Environ. Engineering, Duke Univ. November 2005\n\t        //   modified from: ftp://fly.cnuce.cnr.it/pub/software/octave/leasqr/\n\t        //   Press, et al., Numerical Recipes, Cambridge Univ. Press, 1992, Chapter 15.\n\t\n\t\n\t        var Npnt = y_dat.length;\t\t// number of data points\n\t        var Npar = p.length;\t\t// number of parameters\n\t\n\t        dp = dp || 0.001;\n\t\n\t\n\t        //var JtWJ = new Matrix.zeros(Npar);\n\t        //var JtWdy  = new Matrix.zeros(Npar,1);\n\t\n\t        var y_hat = func(t,p,c);\t// evaluate model using parameters 'p'\n\t        //func_calls = func_calls + 1;\n\t        //console.log(J);\n\t        if ( (iteration%(2*Npar))==0 || dX2 > 0 ) {\n\t            //console.log(\"Par\");\n\t            J = this.lm_FD_J(func, t, p, y_hat, dp, c);\t\t// finite difference\n\t        }\n\t        else{\n\t            //console.log(\"ImPar\");\n\t            J = this.lm_Broyden_J(p_old, y_old, J, p, y_hat); // rank-1 update\n\t        }\n\t        var delta_y = math.subtract(y_dat, y_hat);\t// residual error between model and data\n\t        //console.log(delta_y[0][0]);\n\t        //console.log(delta_y.rows+\" \"+delta_y.columns+\" \"+JSON.stringify(weight_sq));\n\t        //var Chi_sq = delta_y' * ( delta_y .* weight_sq ); \t// Chi-squared error criteria\n\t        var Chi_sq = math.multiply(math.transpose(delta_y),math.dotMultiply(delta_y,weight_sq));\n\t        //JtWJ  = J' * ( J .* ( weight_sq * ones(1,Npar) ) );\n\t        var Jt = math.transpose(J);\n\t\n\t        //console.log(weight_sq);\n\t\n\t        var JtWJ = math.multiply(Jt, math.dotMultiply(J,math.multiply(weight_sq, Matrix.ones(1,Npar))));\n\t\n\t        //JtWdy = J' * ( weight_sq .* delta_y );\n\t        var JtWdy = math.multiply(Jt, math.dotMultiply(weight_sq,delta_y));\n\t\n\t\n\t        return {JtWJ:JtWJ,JtWdy:JtWdy,Chi_sq:Chi_sq,y_hat:y_hat,J:J};\n\t        // endfunction  # ------------------------------------------------------ LM_MATX\n\t    }\n\t\n\t\n\t\n\t};\n\t\n\tmodule.exports = LM;\n\n/***/ },\n/* 5 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tmodule.exports = __webpack_require__(6);\n\tmodule.exports.Decompositions = module.exports.DC = __webpack_require__(7);\n\n\n/***/ },\n/* 6 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tvar Asplice = Array.prototype.splice,\n\t    Aconcat = Array.prototype.concat;\n\t\n\t// For performance : http://jsperf.com/clone-array-slice-vs-while-vs-for\n\tfunction slice(arr) {\n\t    var i = 0,\n\t        ii = arr.length,\n\t        result = new Array(ii);\n\t    for (; i < ii; i++) {\n\t        result[i] = arr[i];\n\t    }\n\t    return result;\n\t}\n\t\n\t/**\n\t * Real matrix.\n\t * @constructor\n\t * @param {number|Array} nRows - Number of rows of the new matrix or a 2D array containing the data.\n\t * @param {number|boolean} [nColumns] - Number of columns of the new matrix or a boolean specifying if the input array should be cloned\n\t */\n\tfunction Matrix(nRows, nColumns) {\n\t    var i = 0, rows, columns, matrix, newInstance;\n\t    if (Array.isArray(nRows)) {\n\t        newInstance = nColumns;\n\t        matrix = newInstance ? slice(nRows) : nRows;\n\t        nRows = matrix.length;\n\t        nColumns = matrix[0].length;\n\t        if (typeof nColumns === 'undefined') {\n\t            throw new TypeError('Data must be a 2D array');\n\t        }\n\t        if (nRows > 0 && nColumns > 0) {\n\t            for (; i < nRows; i++) {\n\t                if (matrix[i].length !== nColumns) {\n\t                    throw new RangeError('Inconsistent array dimensions');\n\t                } else if (newInstance) {\n\t                    matrix[i] = slice(matrix[i]);\n\t                }\n\t            }\n\t        } else {\n\t            throw new RangeError('Invalid dimensions: ' + nRows + 'x' + nColumns);\n\t        }\n\t    } else if (typeof nRows === 'number') { // Create empty matrix\n\t        if (nRows > 0 && nColumns > 0) {\n\t            matrix = new Array(nRows);\n\t            for (; i < nRows; i++) {\n\t                matrix[i] = new Array(nColumns);\n\t            }\n\t        } else {\n\t            throw new RangeError('Invalid dimensions: ' + nRows + 'x' + nColumns);\n\t        }\n\t    } else {\n\t        throw new TypeError('Invalid arguments');\n\t    }\n\t\n\t    Object.defineProperty(matrix, 'rows', {writable: true, value: nRows});\n\t    Object.defineProperty(matrix, 'columns', {writable: true, value: nColumns});\n\t\n\t    matrix.__proto__ = Matrix.prototype;\n\t\n\t    return matrix;\n\t}\n\t\n\t/**\n\t * Constructs a Matrix with the chosen dimensions from a 1D array.\n\t * @param {number} newRows - Number of rows\n\t * @param {number} newColumns - Number of columns\n\t * @param {Array} newData - A 1D array containing data for the matrix\n\t * @returns {Matrix} - The new matrix\n\t */\n\tMatrix.from1DArray = function from1DArray(newRows, newColumns, newData) {\n\t    var length, data, i = 0;\n\t\n\t    length = newRows * newColumns;\n\t    if (length !== newData.length)\n\t        throw new RangeError('Data length does not match given dimensions');\n\t\n\t    data = new Array(newRows);\n\t    for (; i < newRows; i++) {\n\t        data[i] = newData.slice(i * newColumns, (i + 1) * newColumns);\n\t    }\n\t    return new Matrix(data);\n\t};\n\t\n\t/**\n\t * Creates a row vector, a matrix with only one row.\n\t * @param {Array} newData - A 1D array containing data for the vector\n\t * @returns {Matrix} - The new matrix\n\t */\n\tMatrix.rowVector = function rowVector(newData) {\n\t    return new Matrix([newData]);\n\t};\n\t\n\t/**\n\t * Creates a column vector, a matrix with only one column.\n\t * @param {Array} newData - A 1D array containing data for the vector\n\t * @returns {Matrix} - The new matrix\n\t */\n\tMatrix.columnVector = function columnVector(newData) {\n\t    var l = newData.length, vector = new Array(l);\n\t    for (var i = 0; i < l; i++)\n\t        vector[i] = [newData[i]];\n\t    return new Matrix(vector);\n\t};\n\t\n\t/**\n\t * Creates an empty matrix with the given dimensions. Values will be undefined. Same as using new Matrix(rows, columns).\n\t * @param {number} rows - Number of rows\n\t * @param {number} columns - Number of columns\n\t * @returns {Matrix} - The new matrix\n\t */\n\tMatrix.empty = function empty(rows, columns) {\n\t    return new Matrix(rows, columns);\n\t};\n\t\n\t/**\n\t * Creates a matrix with the given dimensions. Values will be set to zero.\n\t * @param {number} rows - Number of rows\n\t * @param {number} columns - Number of columns\n\t * @returns {Matrix} - The new matrix\n\t */\n\tMatrix.zeros = function zeros(rows, columns) {\n\t    return Matrix.empty(rows, columns).fill(0);\n\t};\n\t\n\t/**\n\t * Creates a matrix with the given dimensions. Values will be set to one.\n\t * @param {number} rows - Number of rows\n\t * @param {number} columns - Number of columns\n\t * @returns {Matrix} - The new matrix\n\t */\n\tMatrix.ones = function ones(rows, columns) {\n\t    return Matrix.empty(rows, columns).fill(1);\n\t};\n\t\n\t/**\n\t * Creates a matrix with the given dimensions. Values will be randomly set using Math.random().\n\t * @param {number} rows - Number of rows\n\t * @param {number} columns - Number of columns\n\t * @returns {Matrix} The new matrix\n\t */\n\tMatrix.rand = function rand(rows, columns) {\n\t    var matrix = Matrix.empty(rows, columns);\n\t    for (var i = 0, ii = matrix.rows; i < ii; i++) {\n\t        for (var j = 0, jj = matrix.columns; j < jj; j++) {\n\t            matrix[i][j] = Math.random();\n\t        }\n\t    }\n\t    return matrix;\n\t};\n\t\n\t/**\n\t * Creates an identity matrix with the given dimension. Values of the diagonal will be 1 and other will be 0.\n\t * @param {number} n - Number of rows and columns\n\t * @returns {Matrix} - The new matrix\n\t */\n\tMatrix.eye = function eye(n) {\n\t    var matrix = Matrix.zeros(n, n), l = matrix.rows;\n\t    for (var i = 0; i < l; i++) {\n\t        matrix[i][i] = 1;\n\t    }\n\t    return matrix;\n\t};\n\t\n\t/**\n\t * Creates a diagonal matrix based on the given array.\n\t * @param {Array} data - Array containing the data for the diagonal\n\t * @returns {Matrix} - The new matrix\n\t */\n\tMatrix.diag = function diag(data) {\n\t    var l = data.length, matrix = Matrix.zeros(l, l);\n\t    for (var i = 0; i < l; i++) {\n\t        matrix[i][i] = data[i];\n\t    }\n\t    return matrix;\n\t};\n\t\n\t/**\n\t * Creates an array of indices between two values\n\t * @param {number} from\n\t * @param {number} to\n\t * @returns {Array}\n\t */\n\tMatrix.indices = function indices(from, to) {\n\t    var vector = new Array(to - from);\n\t    for (var i = 0; i < vector.length; i++)\n\t        vector[i] = from++;\n\t    return vector;\n\t};\n\t\n\t// TODO DOC\n\tMatrix.stack = function stack(arg1) {\n\t    var i, j, k;\n\t    if (Matrix.isMatrix(arg1)) {\n\t        var rows = 0,\n\t            cols = 0;\n\t        for (i = 0; i < arguments.length; i++) {\n\t            rows += arguments[i].rows;\n\t            if (arguments[i].columns > cols)\n\t                cols = arguments[i].columns;\n\t        }\n\t\n\t        var r = Matrix.zeros(rows, cols);\n\t        var c = 0;\n\t        for (i = 0; i < arguments.length; i++) {\n\t            var current = arguments[i];\n\t            for (j = 0; j < current.rows; j++) {\n\t                for (k = 0; k < current.columns; k++)\n\t                    r[c][k] = current[j][k];\n\t                c++;\n\t            }\n\t        }\n\t        return r;\n\t    }\n\t    else if (Array.isArray(arg1)) {\n\t        var matrix = Matrix.empty(arguments.length, arg1.length);\n\t        for (i = 0; i < arguments.length; i++)\n\t            matrix.setRow(i, arguments[i]);\n\t        return matrix;\n\t    }\n\t};\n\t\n\t// TODO DOC\n\tMatrix.expand = function expand(base, count) {\n\t    var expansion = [];\n\t    for (var i = 0; i < count.length; i++)\n\t        for (var j = 0; j < count[i]; j++)\n\t            expansion.push(base[i]);\n\t    return new Matrix(expansion);\n\t};\n\t\n\t/**\n\t * Check that the provided value is a Matrix and tries to instantiate one if not\n\t * @param value - The value to check\n\t * @returns {Matrix}\n\t * @throws {TypeError}\n\t */\n\tMatrix.checkMatrix = function checkMatrix(value) {\n\t    if (!value) {\n\t        throw new TypeError('Argument has to be a matrix');\n\t    }\n\t    if (value.klass !== 'Matrix') {\n\t        value = new Matrix(value);\n\t    }\n\t    return value;\n\t};\n\t\n\t/**\n\t * Returns true if the argument is a Matrix, false otherwise\n\t * @param value - The value to check\n\t * @returns {boolean}\n\t */\n\tMatrix.isMatrix = function isMatrix(value) {\n\t    return value ? value.klass === 'Matrix' : false;\n\t};\n\t\n\t/**\n\t * @property {string} - The name of this class.\n\t */\n\tObject.defineProperty(Matrix.prototype, 'klass', {\n\t    get: function klass() {\n\t        return 'Matrix';\n\t    }\n\t});\n\t\n\t/**\n\t * @property {number} - The number of elements in the matrix.\n\t */\n\tObject.defineProperty(Matrix.prototype, 'size', {\n\t    get: function size() {\n\t        return this.rows * this.columns;\n\t    }\n\t});\n\t\n\t/**\n\t * @private\n\t * Internal check that a row index is not out of bounds\n\t * @param {number} index\n\t */\n\tMatrix.prototype.checkRowIndex = function checkRowIndex(index) {\n\t    if (index < 0 || index > this.rows - 1)\n\t        throw new RangeError('Row index out of range.');\n\t};\n\t\n\t/**\n\t * @private\n\t * Internal check that a column index is not out of bounds\n\t * @param {number} index\n\t */\n\tMatrix.prototype.checkColumnIndex = function checkColumnIndex(index) {\n\t    if (index < 0 || index > this.columns - 1)\n\t        throw new RangeError('Column index out of range.');\n\t};\n\t\n\t/**\n\t * @private\n\t * Internal check that two matrices have the same dimensions\n\t * @param {Matrix} otherMatrix\n\t */\n\tMatrix.prototype.checkDimensions = function checkDimensions(otherMatrix) {\n\t    if ((this.rows !== otherMatrix.rows) || (this.columns !== otherMatrix.columns))\n\t        throw new RangeError('Matrices dimensions must be equal.');\n\t};\n\t\n\t/**\n\t * Applies a callback for each element of the matrix. The function is called in the matrix (this) context.\n\t * @param {function} callback - Function that will be called with two parameters : i (row) and j (column)\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.apply = function apply(callback) {\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            callback.call(this, i, j);\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Creates an exact and independent copy of the matrix\n\t * @returns {Matrix}\n\t */\n\tMatrix.prototype.clone = function clone() {\n\t    return new Matrix(this.to2DArray());\n\t};\n\t\n\t/**\n\t * Returns a new 1D array filled row by row with the matrix values\n\t * @returns {Array}\n\t */\n\tMatrix.prototype.to1DArray = function to1DArray() {\n\t    return Aconcat.apply([], this);\n\t};\n\t\n\t/**\n\t * Returns a 2D array containing a copy of the data\n\t * @returns {Array}\n\t */\n\tMatrix.prototype.to2DArray = function to2DArray() {\n\t    var l = this.rows, copy = new Array(l);\n\t    for (var i = 0; i < l; i++) {\n\t        copy[i] = slice(this[i]);\n\t    }\n\t    return copy;\n\t};\n\t\n\t/**\n\t * @returns {boolean} true if the matrix has one row\n\t */\n\tMatrix.prototype.isRowVector = function isRowVector() {\n\t    return this.rows === 1;\n\t};\n\t\n\t/**\n\t * @returns {boolean} true if the matrix has one column\n\t */\n\tMatrix.prototype.isColumnVector = function isColumnVector() {\n\t    return this.columns === 1;\n\t};\n\t\n\t/**\n\t * @returns {boolean} true if the matrix has one row or one column\n\t */\n\tMatrix.prototype.isVector = function isVector() {\n\t    return (this.rows === 1) || (this.columns === 1);\n\t};\n\t\n\t/**\n\t * @returns {boolean} true if the matrix has the same number of rows and columns\n\t */\n\tMatrix.prototype.isSquare = function isSquare() {\n\t    return this.rows === this.columns;\n\t};\n\t\n\t/**\n\t * @returns {boolean} true if the matrix is square and has the same values on both sides of the diagonal\n\t */\n\tMatrix.prototype.isSymmetric = function isSymmetric() {\n\t    if (this.isSquare()) {\n\t        var l = this.rows;\n\t        for (var i = 0; i < l; i++) {\n\t            for (var j = 0; j <= i; j++) {\n\t                if (this[i][j] !== this[j][i]) {\n\t                    return false;\n\t                }\n\t            }\n\t        }\n\t        return true;\n\t    }\n\t    return false;\n\t};\n\t\n\t/**\n\t * Sets a given element of the matrix. mat.set(3,4,1) is equivalent to mat[3][4]=1\n\t * @param {number} rowIndex - Index of the row\n\t * @param {number} columnIndex - Index of the column\n\t * @param {number} value - The new value for the element\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.set = function set(rowIndex, columnIndex, value) {\n\t    this[rowIndex][columnIndex] = value;\n\t    return this;\n\t};\n\t\n\t/**\n\t * Returns the given element of the matrix. mat.get(3,4) is equivalent to matrix[3][4]\n\t * @param {number} rowIndex - Index of the row\n\t * @param {number} columnIndex - Index of the column\n\t * @returns {number}\n\t */\n\tMatrix.prototype.get = function get(rowIndex, columnIndex) {\n\t    return this[rowIndex][columnIndex];\n\t};\n\t\n\t/**\n\t * Fills the matrix with a given value. All elements will be set to this value.\n\t * @param {number} value - New value\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.fill = function fill(value) {\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] = value;\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Negates the matrix. All elements will be multiplied by (-1)\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.neg = function neg() {\n\t    return this.mulS(-1);\n\t};\n\t\n\t/**\n\t * Adds a scalar or values from another matrix (in place)\n\t * @param {number|Matrix} value\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.add = function add(value) {\n\t    if (typeof value === 'number')\n\t        return this.addS(value);\n\t    value = Matrix.checkMatrix(value);\n\t        return this.addM(value);\n\t};\n\t\n\t/**\n\t * Adds a scalar to each element of the matrix\n\t * @param {number} value\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.addS = function addS(value) {\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] += value;\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Adds the value of each element of matrix to the corresponding element of this\n\t * @param {Matrix} matrix\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.addM = function addM(matrix) {\n\t    this.checkDimensions(matrix);\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] += matrix[i][j];\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Subtracts a scalar or values from another matrix (in place)\n\t * @param {number|Matrix} value\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.sub = function sub(value) {\n\t    if (typeof value === 'number')\n\t        return this.subS(value);\n\t    value = Matrix.checkMatrix(value);\n\t        return this.subM(value);\n\t};\n\t\n\t/**\n\t * Subtracts a scalar from each element of the matrix\n\t * @param {number} value\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.subS = function subS(value) {\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] -= value;\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Subtracts the value of each element of matrix from the corresponding element of this\n\t * @param {Matrix} matrix\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.subM = function subM(matrix) {\n\t    this.checkDimensions(matrix);\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] -= matrix[i][j];\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Multiplies a scalar or values from another matrix (in place)\n\t * @param {number|Matrix} value\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.mul = function mul(value) {\n\t    if (typeof value === 'number')\n\t        return this.mulS(value);\n\t    value = Matrix.checkMatrix(value);\n\t        return this.mulM(value);\n\t};\n\t\n\t/**\n\t * Multiplies a scalar with each element of the matrix\n\t * @param {number} value\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.mulS = function mulS(value) {\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] *= value;\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Multiplies the value of each element of matrix with the corresponding element of this\n\t * @param {Matrix} matrix\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.mulM = function mulM(matrix) {\n\t    this.checkDimensions(matrix);\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] *= matrix[i][j];\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Divides by a scalar or values from another matrix (in place)\n\t * @param {number|Matrix} value\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.div = function div(value) {\n\t    if (typeof value === 'number')\n\t        return this.divS(value);\n\t    value = Matrix.checkMatrix(value);\n\t        return this.divM(value);\n\t};\n\t\n\t/**\n\t * Divides each element of the matrix by a scalar\n\t * @param {number} value\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.divS = function divS(value) {\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] /= value;\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Divides each element of this by the corresponding element of matrix\n\t * @param {Matrix} matrix\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.divM = function divM(matrix) {\n\t    this.checkDimensions(matrix);\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] /= matrix[i][j];\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Returns a new array from the given row index\n\t * @param {number} index - Row index\n\t * @returns {Array}\n\t */\n\tMatrix.prototype.getRow = function getRow(index) {\n\t    this.checkRowIndex(index);\n\t    return slice(this[index]);\n\t};\n\t\n\t/**\n\t * Returns a new row vector from the given row index\n\t * @param {number} index - Row index\n\t * @returns {Matrix}\n\t */\n\tMatrix.prototype.getRowVector = function getRowVector(index) {\n\t    return Matrix.rowVector(this.getRow(index));\n\t};\n\t\n\t/**\n\t * Sets a row at the given index\n\t * @param {number} index - Row index\n\t * @param {Array|Matrix} array - Array or vector\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.setRow = function setRow(index, array) {\n\t    this.checkRowIndex(index);\n\t    if (Matrix.isMatrix(array)) array = array.to1DArray();\n\t    if (array.length !== this.columns)\n\t        throw new RangeError('Invalid row size');\n\t    this[index] = slice(array);\n\t    return this;\n\t};\n\t\n\t/**\n\t * Removes a row from the given index\n\t * @param {number} index - Row index\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.removeRow = function removeRow(index) {\n\t    this.checkRowIndex(index);\n\t    if (this.rows === 1)\n\t        throw new RangeError('A matrix cannot have less than one row');\n\t    Asplice.call(this, index, 1);\n\t    this.rows -= 1;\n\t    return this;\n\t};\n\t\n\t/**\n\t * Adds a row at the given index\n\t * @param {number} [index = this.rows] - Row index\n\t * @param {Array|Matrix} array - Array or vector\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.addRow = function addRow(index, array) {\n\t    if (typeof array === 'undefined') {\n\t        array = index;\n\t        index = this.rows;\n\t    }\n\t    if (index < 0 || index > this.rows)\n\t        throw new RangeError('Row index out of range.');\n\t    if (Matrix.isMatrix(array)) array = array.to1DArray();\n\t    if (array.length !== this.columns)\n\t        throw new RangeError('Invalid row size');\n\t    Asplice.call(this, index, 0, slice(array));\n\t    this.rows += 1;\n\t    return this;\n\t};\n\t\n\t/**\n\t * Swaps two rows\n\t * @param {number} row1 - First row index\n\t * @param {number} row2 - Second row index\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.swapRows = function swapRows(row1, row2) {\n\t    this.checkRowIndex(row1);\n\t    this.checkRowIndex(row2);\n\t    var temp = this[row1];\n\t    this[row1] = this[row2];\n\t    this[row2] = temp;\n\t    return this;\n\t};\n\t\n\t/**\n\t * Returns a new array from the given column index\n\t * @param {number} index - Column index\n\t * @returns {Array}\n\t */\n\tMatrix.prototype.getColumn = function getColumn(index) {\n\t    this.checkColumnIndex(index);\n\t    var l = this.rows, column = new Array(l);\n\t    for (var i = 0; i < l; i++) {\n\t        column[i] = this[i][index];\n\t    }\n\t    return column;\n\t};\n\t\n\t/**\n\t * Returns a new column vector from the given column index\n\t * @param {number} index - Column index\n\t * @returns {Matrix}\n\t */\n\tMatrix.prototype.getColumnVector = function getColumnVector(index) {\n\t    return Matrix.columnVector(this.getColumn(index));\n\t};\n\t\n\t/**\n\t * Sets a column at the given index\n\t * @param {number} index - Column index\n\t * @param {Array|Matrix} array - Array or vector\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.setColumn = function setColumn(index, array) {\n\t    this.checkColumnIndex(index);\n\t    if (Matrix.isMatrix(array)) array = array.to1DArray();\n\t    var l = this.rows;\n\t    if (array.length !== l)\n\t        throw new RangeError('Invalid column size');\n\t    for (var i = 0; i < l; i++) {\n\t        this[i][index] = array[i];\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Removes a column from the given index\n\t * @param {number} index - Column index\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.removeColumn = function removeColumn(index) {\n\t    this.checkColumnIndex(index);\n\t    if (this.columns === 1)\n\t        throw new RangeError('A matrix cannot have less than one column');\n\t    for (var i = 0, ii = this.rows; i < ii; i++) {\n\t        this[i].splice(index, 1);\n\t    }\n\t    this.columns -= 1;\n\t    return this;\n\t};\n\t\n\t/**\n\t * Adds a column at the given index\n\t * @param {number} [index = this.columns] - Column index\n\t * @param {Array|Matrix} array - Array or vector\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.addColumn = function addColumn(index, array) {\n\t    if (typeof array === 'undefined') {\n\t        array = index;\n\t        index = this.columns;\n\t    }\n\t    if (index < 0 || index > this.columns)\n\t        throw new RangeError('Column index out of range.');\n\t    if (Matrix.isMatrix(array)) array = array.to1DArray();\n\t    var l = this.rows;\n\t    if (array.length !== l)\n\t        throw new RangeError('Invalid column size');\n\t    for (var i = 0; i < l; i++) {\n\t        this[i].splice(index, 0, array[i]);\n\t    }\n\t    this.columns += 1;\n\t    return this;\n\t};\n\t\n\t/**\n\t * Swaps two columns\n\t * @param {number} column1 - First column index\n\t * @param {number} column2 - Second column index\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.swapColumns = function swapColumns(column1, column2) {\n\t    this.checkRowIndex(column1);\n\t    this.checkRowIndex(column2);\n\t    var l = this.rows, temp, row;\n\t    for (var i = 0; i < l; i++) {\n\t        row = this[i];\n\t        temp = row[column1];\n\t        row[column1] = row[column2];\n\t        row[column2] = temp;\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * @private\n\t * Internal check that the provided vector is an array with the right length\n\t * @param {Array|Matrix} vector\n\t * @returns {Array}\n\t * @throws {RangeError}\n\t */\n\tMatrix.prototype.checkRowVector = function checkRowVector(vector) {\n\t    if (Matrix.isMatrix(vector))\n\t        vector = vector.to1DArray();\n\t    if (vector.length !== this.columns)\n\t        throw new RangeError('vector size must be the same as the number of columns');\n\t    return vector;\n\t};\n\t\n\t/**\n\t * @private\n\t * Internal check that the provided vector is an array with the right length\n\t * @param {Array|Matrix} vector\n\t * @returns {Array}\n\t * @throws {RangeError}\n\t */\n\tMatrix.prototype.checkColumnVector = function checkColumnVector(vector) {\n\t    if (Matrix.isMatrix(vector))\n\t        vector = vector.to1DArray();\n\t    if (vector.length !== this.rows)\n\t        throw new RangeError('vector size must be the same as the number of rows');\n\t    return vector;\n\t};\n\t\n\t/**\n\t * Adds the values of a vector to each row\n\t * @param {Array|Matrix} vector - Array or vector\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.addRowVector = function addRowVector(vector) {\n\t    vector = this.checkRowVector(vector);\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] += vector[j];\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Subtracts the values of a vector from each row\n\t * @param {Array|Matrix} vector - Array or vector\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.subRowVector = function subRowVector(vector) {\n\t    vector = this.checkRowVector(vector);\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] -= vector[j];\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Multiplies the values of a vector with each row\n\t * @param {Array|Matrix} vector - Array or vector\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.mulRowVector = function mulRowVector(vector) {\n\t    vector = this.checkRowVector(vector);\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] *= vector[j];\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Divides the values of each row by those of a vector\n\t * @param {Array|Matrix} vector - Array or vector\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.divRowVector = function divRowVector(vector) {\n\t    vector = this.checkRowVector(vector);\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] /= vector[j];\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Adds the values of a vector to each column\n\t * @param {Array|Matrix} vector - Array or vector\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.addColumnVector = function addColumnVector(vector) {\n\t    vector = this.checkColumnVector(vector);\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] += vector[i];\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Subtracts the values of a vector from each column\n\t * @param {Array|Matrix} vector - Array or vector\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.subColumnVector = function subColumnVector(vector) {\n\t    vector = this.checkColumnVector(vector);\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] -= vector[i];\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Multiplies the values of a vector with each column\n\t * @param {Array|Matrix} vector - Array or vector\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.mulColumnVector = function mulColumnVector(vector) {\n\t    vector = this.checkColumnVector(vector);\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] *= vector[i];\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Divides the values of each column by those of a vector\n\t * @param {Array|Matrix} vector - Array or vector\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.divColumnVector = function divColumnVector(vector) {\n\t    vector = this.checkColumnVector(vector);\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] /= vector[i];\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Multiplies the values of a row with a scalar\n\t * @param {number} index - Row index\n\t * @param {number} value\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.mulRow = function mulRow(index, value) {\n\t    this.checkRowIndex(index);\n\t    var i = 0, l = this.columns;\n\t    for (; i < l; i++) {\n\t        this[index][i] *= value;\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Multiplies the values of a column with a scalar\n\t * @param {number} index - Column index\n\t * @param {number} value\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.mulColumn = function mulColumn(index, value) {\n\t    this.checkColumnIndex(index);\n\t    var i = 0, l = this.rows;\n\t    for (; i < l; i++) {\n\t        this[i][index] *= value;\n\t    }\n\t};\n\t\n\t/**\n\t * A matrix index\n\t * @typedef {Object} MatrixIndex\n\t * @property {number} row\n\t * @property {number} column\n\t */\n\t\n\t/**\n\t * Returns the maximum value of the matrix\n\t * @returns {number}\n\t */\n\tMatrix.prototype.max = function max() {\n\t    var v = -Infinity;\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            if (this[i][j] > v) {\n\t                v = this[i][j];\n\t            }\n\t        }\n\t    }\n\t    return v;\n\t};\n\t\n\t/**\n\t * Returns the index of the maximum value\n\t * @returns {MatrixIndex}\n\t */\n\tMatrix.prototype.maxIndex = function maxIndex() {\n\t    var v = -Infinity;\n\t    var idx = {};\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            if (this[i][j] > v) {\n\t                v = this[i][j];\n\t                idx.row = i;\n\t                idx.column = j;\n\t            }\n\t        }\n\t    }\n\t    return idx;\n\t};\n\t\n\t/**\n\t * Returns the minimum value of the matrix\n\t * @returns {number}\n\t */\n\tMatrix.prototype.min = function min() {\n\t    var v = Infinity;\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            if (this[i][j] < v) {\n\t                v = this[i][j];\n\t            }\n\t        }\n\t    }\n\t    return v;\n\t};\n\t\n\t/**\n\t * Returns the index of the minimum value\n\t * @returns {MatrixIndex}\n\t */\n\tMatrix.prototype.minIndex = function minIndex() {\n\t    var v = Infinity;\n\t    var idx = {};\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            if (this[i][j] < v) {\n\t                v = this[i][j];\n\t                idx.row = i;\n\t                idx.column = j;\n\t            }\n\t        }\n\t    }\n\t    return idx;\n\t};\n\t\n\t/**\n\t * Returns the maximum value of one row\n\t * @param {number} index - Row index\n\t * @returns {number}\n\t */\n\tMatrix.prototype.maxRow = function maxRow(index) {\n\t    this.checkRowIndex(index);\n\t    var v = -Infinity;\n\t    for (var i = 0, ii = this.columns; i < ii; i++) {\n\t        if (this[index][i] > v) {\n\t            v = this[index][i];\n\t        }\n\t    }\n\t    return v;\n\t};\n\t\n\t/**\n\t * Returns the index of the maximum value of one row\n\t * @param {number} index - Row index\n\t * @returns {MatrixIndex}\n\t */\n\tMatrix.prototype.maxRowIndex = function maxRowIndex(index) {\n\t    this.checkRowIndex(index);\n\t    var v = -Infinity;\n\t    var idx = {\n\t            row: index\n\t        };\n\t    for (var i = 0, ii = this.columns; i < ii; i++) {\n\t        if (this[index][i] > v) {\n\t            v = this[index][i];\n\t            idx.column = i;\n\t        }\n\t    }\n\t    return idx;\n\t};\n\t\n\t/**\n\t * Returns the minimum value of one row\n\t * @param {number} index - Row index\n\t * @returns {number}\n\t */\n\tMatrix.prototype.minRow = function minRow(index) {\n\t    this.checkRowIndex(index);\n\t    var v = Infinity;\n\t    for (var i = 0, ii = this.columns; i < ii; i++) {\n\t        if (this[index][i] < v) {\n\t            v = this[index][i];\n\t        }\n\t    }\n\t    return v;\n\t};\n\t\n\t/**\n\t * Returns the index of the maximum value of one row\n\t * @param {number} index - Row index\n\t * @returns {MatrixIndex}\n\t */\n\tMatrix.prototype.minRowIndex = function minRowIndex(index) {\n\t    this.checkRowIndex(index);\n\t    var v = Infinity;\n\t    var idx = {\n\t        row: index,\n\t        column: 0\n\t    };\n\t    for (var i = 0, ii = this.columns; i < ii; i++) {\n\t        if (this[index][i] < v) {\n\t            v = this[index][i];\n\t            idx.column = i;\n\t        }\n\t    }\n\t    return idx;\n\t};\n\t\n\t/**\n\t * Returns the maximum value of one column\n\t * @param {number} index - Column index\n\t * @returns {number}\n\t */\n\tMatrix.prototype.maxColumn = function maxColumn(index) {\n\t    this.checkColumnIndex(index);\n\t    var v = -Infinity;\n\t    for (var i = 0, ii = this.rows; i < ii; i++) {\n\t        if (this[i][index] > v) {\n\t            v = this[i][index];\n\t        }\n\t    }\n\t    return v;\n\t};\n\t\n\t/**\n\t * Returns the index of the maximum value of one column\n\t * @param {number} index - Column index\n\t * @returns {MatrixIndex}\n\t */\n\tMatrix.prototype.maxColumnIndex = function maxColumnIndex(index) {\n\t    this.checkColumnIndex(index);\n\t    var v = -Infinity;\n\t    var idx = {\n\t        row: 0,\n\t        column: index\n\t    };\n\t    for (var i = 0, ii = this.rows; i < ii; i++) {\n\t        if (this[i][index] > v) {\n\t            v = this[i][index];\n\t            idx.row = i;\n\t        }\n\t    }\n\t    return idx;\n\t};\n\t\n\t/**\n\t * Returns the minimum value of one column\n\t * @param {number} index - Column index\n\t * @returns {number}\n\t */\n\tMatrix.prototype.minColumn = function minColumn(index) {\n\t    this.checkColumnIndex(index);\n\t    var v = Infinity;\n\t    for (var i = 0, ii = this.rows; i < ii; i++) {\n\t        if (this[i][index] < v) {\n\t            v = this[i][index];\n\t        }\n\t    }\n\t    return v;\n\t};\n\t\n\t/**\n\t * Returns the index of the minimum value of one column\n\t * @param {number} index - Column index\n\t * @returns {MatrixIndex}\n\t */\n\tMatrix.prototype.minColumnIndex = function minColumnIndex(index) {\n\t    this.checkColumnIndex(index);\n\t    var v = Infinity;\n\t    var idx = {\n\t        row: 0,\n\t        column: index\n\t    };\n\t    for (var i = 0, ii = this.rows; i < ii; i++) {\n\t        if (this[i][index] < v) {\n\t            v = this[i][index];\n\t            idx.row = i;\n\t        }\n\t    }\n\t    return idx;\n\t};\n\t\n\t/**\n\t * Returns an array containing the diagonal values of the matrix\n\t * @returns {Array}\n\t */\n\tMatrix.prototype.diag = function diag() {\n\t    if (!this.isSquare())\n\t        throw new TypeError('Only square matrices have a diagonal.');\n\t    var diag = new Array(this.rows);\n\t    for (var i = 0, ii = this.rows; i < ii; i++) {\n\t        diag[i] = this[i][i];\n\t    }\n\t    return diag;\n\t};\n\t\n\t/**\n\t * Returns the sum of all elements of the matrix\n\t * @returns {number}\n\t */\n\tMatrix.prototype.sum = function sum() {\n\t    var v = 0;\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            v += this[i][j];\n\t        }\n\t    }\n\t    return v;\n\t};\n\t\n\t/**\n\t * Returns the mean of all elements of the matrix\n\t * @returns {number}\n\t */\n\tMatrix.prototype.mean = function mean() {\n\t    return this.sum() / this.size;\n\t};\n\t\n\t/**\n\t * Returns the product of all elements of the matrix\n\t * @returns {number}\n\t */\n\tMatrix.prototype.prod = function prod() {\n\t    var prod = 1;\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            prod *= this[i][j];\n\t        }\n\t    }\n\t    return prod;\n\t};\n\t\n\t/**\n\t * Computes the cumulative sum of the matrix elements (in place, row by row)\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.cumulativeSum = function cumulativeSum() {\n\t    var sum = 0;\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            sum += this[i][j];\n\t            this[i][j] = sum;\n\t        }\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Computes the dot (scalar) product between the matrix and another\n\t * @param {Matrix} other vector\n\t * @returns {number}\n\t */\n\tMatrix.prototype.dot = function dot(other) {\n\t    if (this.size !== other.size)\n\t        throw new RangeError('vectors do not have the same size');\n\t    var vector1 = this.to1DArray();\n\t    var vector2 = other.to1DArray();\n\t    var dot = 0, l = vector1.length;\n\t    for (var i = 0; i < l; i++) {\n\t        dot += vector1[i] * vector2[i];\n\t    }\n\t    return dot;\n\t};\n\t\n\t/**\n\t * Returns the matrix product between this and other\n\t * @returns {Matrix}\n\t */\n\tMatrix.prototype.mmul = function mmul(other) {\n\t    if (!Matrix.isMatrix(other))\n\t        throw new TypeError('parameter \"other\" must be a matrix');\n\t    if (this.columns !== other.rows)\n\t        console.warn('Number of columns of left matrix are not equal to number of rows of right matrix.');\n\t\n\t    var m = this.rows, n = this.columns, p = other.columns;\n\t    var result = new Matrix(m, p);\n\t\n\t    var Bcolj = new Array(n);\n\t    var i, j, k;\n\t    for (j = 0; j < p; j++) {\n\t        for (k = 0; k < n; k++)\n\t            Bcolj[k] = other[k][j];\n\t\n\t        for (i = 0; i < m; i++) {\n\t            var Arowi = this[i];\n\t\n\t            var s = 0;\n\t            for (k = 0; k < n; k++)\n\t                s += Arowi[k] * Bcolj[k];\n\t\n\t            result[i][j] = s;\n\t        }\n\t    }\n\t    return result;\n\t};\n\t\n\t/**\n\t * Sorts the rows (in place)\n\t * @param {function} compareFunction - usual Array.prototype.sort comparison function\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.sortRows = function sortRows(compareFunction) {\n\t    for (var i = 0, ii = this.rows; i < ii; i++) {\n\t        this[i].sort(compareFunction);\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Sorts the columns (in place)\n\t * @param {function} compareFunction - usual Array.prototype.sort comparison function\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.sortColumns = function sortColumns(compareFunction) {\n\t    for (var i = 0, ii = this.columns; i < ii; i++) {\n\t        this.setColumn(i, this.getColumn(i).sort(compareFunction));\n\t    }\n\t    return this;\n\t};\n\t\n\t/**\n\t * Transposes the matrix and returns a new one containing the result\n\t * @returns {Matrix}\n\t */\n\tMatrix.prototype.transpose = function transpose() {\n\t    var result = new Matrix(this.columns, this.rows);\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            result[j][i] = this[i][j];\n\t        }\n\t    }\n\t    return result;\n\t};\n\t\n\t/**\n\t * Returns a subset of the matrix\n\t * @param {number} startRow - First row index\n\t * @param {number} endRow - Last row index\n\t * @param {number} startColumn - First column index\n\t * @param {number} endColumn - Last column index\n\t * @returns {Matrix}\n\t */\n\tMatrix.prototype.subMatrix = function subMatrix(startRow, endRow, startColumn, endColumn) {\n\t    if ((startRow > endRow) || (startColumn > endColumn) || (startRow < 0) || (startRow >= this.rows) || (endRow < 0) || (endRow >= this.rows) || (startColumn < 0) || (startColumn >= this.columns) || (endColumn < 0) || (endColumn >= this.columns))\n\t        throw new RangeError('Argument out of range');\n\t    var newMatrix = new Matrix(endRow - startRow + 1, endColumn - startColumn + 1);\n\t    for (var i = startRow; i <= endRow; i++) {\n\t        for (var j = startColumn; j <= endColumn; j++) {\n\t            newMatrix[i - startRow][j - startColumn] = this[i][j];\n\t        }\n\t    }\n\t    return newMatrix;\n\t};\n\t\n\t/**\n\t * Returns a subset of the matrix based on an array of row indices\n\t * @param {Array} indices - Array containing the row indices\n\t * @param {number} [startColumn = 0] - First column index\n\t * @param {number} [endColumn = this.columns-1] - Last column index\n\t * @returns {Matrix}\n\t */\n\tMatrix.prototype.subMatrixRow = function subMatrixRow(indices, startColumn, endColumn) {\n\t    if (typeof startColumn === 'undefined') {\n\t        startColumn = 0;\n\t        endColumn = this.columns - 1;\n\t    } else if (typeof endColumn === 'undefined') {\n\t        endColumn = this.columns - 1;\n\t    }\n\t    if ((startColumn > endColumn) || (startColumn < 0) || (startColumn >= this.columns) || (endColumn < 0) || (endColumn >= this.columns))\n\t        throw new RangeError('Argument out of range.');\n\t    var l = indices.length, rows = this.rows,\n\t        X = new Matrix(l, endColumn - startColumn + 1);\n\t    for (var i = 0; i < l; i++) {\n\t        for (var j = startColumn; j <= endColumn; j++) {\n\t            if ((indices[i] < 0) || (indices[i] >= rows))\n\t                throw new RangeError('Argument out of range.');\n\t            X[i][j - startColumn] = this[indices[i]][j];\n\t        }\n\t    }\n\t    return X;\n\t};\n\t\n\t/**\n\t * Returns a subset of the matrix based on an array of column indices\n\t * @param {Array} indices - Array containing the column indices\n\t * @param {number} [startRow = 0] - First row index\n\t * @param {number} [endRow = this.rows-1] - Last row index\n\t * @returns {Matrix}\n\t */\n\tMatrix.prototype.subMatrixColumn = function subMatrixColumn(indices, startRow, endRow) {\n\t    if (typeof startRow === 'undefined') {\n\t        startRow = 0;\n\t        endRow = this.rows - 1;\n\t    } else if (typeof endRow === 'undefined') {\n\t        endRow = this.rows - 1;\n\t    }\n\t    if ((startRow > endRow) || (startRow < 0) || (startRow >= this.rows) || (endRow < 0) || (endRow >= this.rows))\n\t        throw new RangeError('Argument out of range.');\n\t    var l = indices.length, columns = this.columns,\n\t        X = new Matrix(endRow - startRow + 1, l);\n\t    for (var i = 0; i < l; i++) {\n\t        for (var j = startRow; j <= endRow; j++) {\n\t            if ((indices[i] < 0) || (indices[i] >= columns))\n\t                throw new RangeError('Argument out of range.');\n\t            X[j - startRow][i] = this[j][indices[i]];\n\t        }\n\t    }\n\t    return X;\n\t};\n\t\n\t/**\n\t * Returns the trace of the matrix (sum of the diagonal elements)\n\t * @returns {number}\n\t */\n\tMatrix.prototype.trace = function trace() {\n\t    if (!this.isSquare())\n\t        throw new TypeError('The matrix is not square');\n\t    var trace = 0, i = 0, l = this.rows;\n\t    for (; i < l; i++) {\n\t        trace += this[i][i];\n\t    }\n\t    return trace;\n\t};\n\t\n\t/**\n\t * Sets each element of the matrix to its absolute value\n\t * @returns {Matrix} this\n\t */\n\tMatrix.prototype.abs = function abs() {\n\t    var ii = this.rows, jj = this.columns;\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            this[i][j] = Math.abs(this[i][j]);\n\t        }\n\t    }\n\t};\n\t\n\tmodule.exports = Matrix;\n\n\n/***/ },\n/* 7 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar Matrix = __webpack_require__(6);\n\t\n\tvar SingularValueDecomposition = __webpack_require__(8);\n\tvar EigenvalueDecomposition = __webpack_require__(10);\n\tvar LuDecomposition = __webpack_require__(11);\n\tvar QrDecomposition = __webpack_require__(12);\n\tvar CholeskyDecomposition = __webpack_require__(13);\n\t\n\tfunction inverse(matrix) {\n\t    return solve(matrix, Matrix.eye(matrix.rows));\n\t}\n\t\n\tMatrix.prototype.inverse = function () {\n\t    return inverse(this);\n\t};\n\t\n\tfunction solve(leftHandSide, rightHandSide) {\n\t    return leftHandSide.isSquare() ? new LuDecomposition(leftHandSide).solve(rightHandSide) : new QrDecomposition(leftHandSide).solve(rightHandSide);\n\t}\n\t\n\tMatrix.prototype.solve = function (other) {\n\t    return solve(this, other);\n\t};\n\t\n\tmodule.exports = {\n\t    SingularValueDecomposition: SingularValueDecomposition,\n\t    SVD: SingularValueDecomposition,\n\t    EigenvalueDecomposition: EigenvalueDecomposition,\n\t    EVD: EigenvalueDecomposition,\n\t    LuDecomposition: LuDecomposition,\n\t    LU: LuDecomposition,\n\t    QrDecomposition: QrDecomposition,\n\t    QR: QrDecomposition,\n\t    CholeskyDecomposition: CholeskyDecomposition,\n\t    CHO: CholeskyDecomposition,\n\t    inverse: inverse,\n\t    solve: solve\n\t};\n\n\n/***/ },\n/* 8 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar Matrix = __webpack_require__(6);\n\tvar hypotenuse = __webpack_require__(9).hypotenuse;\n\t\n\t// https://github.com/lutzroeder/Mapack/blob/master/Source/SingularValueDecomposition.cs\n\tfunction SingularValueDecomposition(value, options) {\n\t    if (!(this instanceof SingularValueDecomposition)) {\n\t        return new SingularValueDecomposition(value, options);\n\t    }\n\t    value = Matrix.checkMatrix(value);\n\t\n\t    options = options || {};\n\t\n\t    var a = value.clone(),\n\t        m = value.rows,\n\t        n = value.columns,\n\t        nu = Math.min(m, n);\n\t\n\t    var wantu = true, wantv = true;\n\t    if (options.computeLeftSingularVectors === false)\n\t        wantu = false;\n\t    if (options.computeRightSingularVectors === false)\n\t        wantv = false;\n\t    var autoTranspose = options.autoTranspose === true;\n\t\n\t    var swapped = false;\n\t    if (m < n) {\n\t        if (!autoTranspose) {\n\t            console.warn('Computing SVD on a matrix with more columns than rows. Consider enabling autoTranspose');\n\t        } else {\n\t            a = a.transpose();\n\t            m = a.rows;\n\t            n = a.columns;\n\t            swapped = true;\n\t            var aux = wantu;\n\t            wantu = wantv;\n\t            wantv = aux;\n\t        }\n\t    }\n\t\n\t    var s = new Array(Math.min(m + 1, n)),\n\t        U = Matrix.zeros(m, nu),\n\t        V = Matrix.zeros(n, n),\n\t        e = new Array(n),\n\t        work = new Array(m);\n\t\n\t    var nct = Math.min(m - 1, n);\n\t    var nrt = Math.max(0, Math.min(n - 2, m));\n\t\n\t    var i, j, k, p, t, ks, f, cs, sn, max, kase,\n\t        scale, sp, spm1, epm1, sk, ek, b, c, shift, g;\n\t\n\t    for (k = 0, max = Math.max(nct, nrt); k < max; k++) {\n\t        if (k < nct) {\n\t            s[k] = 0;\n\t            for (i = k; i < m; i++) {\n\t                s[k] = hypotenuse(s[k], a[i][k]);\n\t            }\n\t            if (s[k] !== 0) {\n\t                if (a[k][k] < 0) {\n\t                    s[k] = -s[k];\n\t                }\n\t                for (i = k; i < m; i++) {\n\t                    a[i][k] /= s[k];\n\t                }\n\t                a[k][k] += 1;\n\t            }\n\t            s[k] = -s[k];\n\t        }\n\t\n\t        for (j = k + 1; j < n; j++) {\n\t            if ((k < nct) && (s[k] !== 0)) {\n\t                t = 0;\n\t                for (i = k; i < m; i++) {\n\t                    t += a[i][k] * a[i][j];\n\t                }\n\t                t = -t / a[k][k];\n\t                for (i = k; i < m; i++) {\n\t                    a[i][j] += t * a[i][k];\n\t                }\n\t            }\n\t            e[j] = a[k][j];\n\t        }\n\t\n\t        if (wantu && (k < nct)) {\n\t            for (i = k; i < m; i++) {\n\t                U[i][k] = a[i][k];\n\t            }\n\t        }\n\t\n\t        if (k < nrt) {\n\t            e[k] = 0;\n\t            for (i = k + 1; i < n; i++) {\n\t                e[k] = hypotenuse(e[k], e[i]);\n\t            }\n\t            if (e[k] !== 0) {\n\t                if (e[k + 1] < 0)\n\t                    e[k] = -e[k];\n\t                for (i = k + 1; i < n; i++) {\n\t                    e[i] /= e[k];\n\t                }\n\t                e[k + 1] += 1;\n\t            }\n\t            e[k] = -e[k];\n\t            if ((k + 1 < m) && (e[k] !== 0)) {\n\t                for (i = k + 1; i < m; i++) {\n\t                    work[i] = 0;\n\t                }\n\t                for (j = k + 1; j < n; j++) {\n\t                    for (i = k + 1; i < m; i++) {\n\t                        work[i] += e[j] * a[i][j];\n\t                    }\n\t                }\n\t                for (j = k + 1; j < n; j++) {\n\t                    t = -e[j] / e[k + 1];\n\t                    for (i = k + 1; i < m; i++) {\n\t                        a[i][j] += t * work[i];\n\t                    }\n\t                }\n\t            }\n\t            if (wantv) {\n\t                for (i = k + 1; i < n; i++) {\n\t                    V[i][k] = e[i];\n\t                }\n\t            }\n\t        }\n\t    }\n\t\n\t    p = Math.min(n, m + 1);\n\t    if (nct < n) {\n\t        s[nct] = a[nct][nct];\n\t    }\n\t    if (m < p) {\n\t        s[p - 1] = 0;\n\t    }\n\t    if (nrt + 1 < p) {\n\t        e[nrt] = a[nrt][p - 1];\n\t    }\n\t    e[p - 1] = 0;\n\t\n\t    if (wantu) {\n\t        for (j = nct; j < nu; j++) {\n\t            for (i = 0; i < m; i++) {\n\t                U[i][j] = 0;\n\t            }\n\t            U[j][j] = 1;\n\t        }\n\t        for (k = nct - 1; k >= 0; k--) {\n\t            if (s[k] !== 0) {\n\t                for (j = k + 1; j < nu; j++) {\n\t                    t = 0;\n\t                    for (i = k; i < m; i++) {\n\t                        t += U[i][k] * U[i][j];\n\t                    }\n\t                    t = -t / U[k][k];\n\t                    for (i = k; i < m; i++) {\n\t                        U[i][j] += t * U[i][k];\n\t                    }\n\t                }\n\t                for (i = k; i < m; i++) {\n\t                    U[i][k] = -U[i][k];\n\t                }\n\t                U[k][k] = 1 + U[k][k];\n\t                for (i = 0; i < k - 1; i++) {\n\t                    U[i][k] = 0;\n\t                }\n\t            } else {\n\t                for (i = 0; i < m; i++) {\n\t                    U[i][k] = 0;\n\t                }\n\t                U[k][k] = 1;\n\t            }\n\t        }\n\t    }\n\t\n\t    if (wantv) {\n\t        for (k = n - 1; k >= 0; k--) {\n\t            if ((k < nrt) && (e[k] !== 0)) {\n\t                for (j = k + 1; j < n; j++) {\n\t                    t = 0;\n\t                    for (i = k + 1; i < n; i++) {\n\t                        t += V[i][k] * V[i][j];\n\t                    }\n\t                    t = -t / V[k + 1][k];\n\t                    for (i = k + 1; i < n; i++) {\n\t                        V[i][j] += t * V[i][k];\n\t                    }\n\t                }\n\t            }\n\t            for (i = 0; i < n; i++) {\n\t                V[i][k] = 0;\n\t            }\n\t            V[k][k] = 1;\n\t        }\n\t    }\n\t\n\t    var pp = p - 1,\n\t        iter = 0,\n\t        eps = Math.pow(2, -52);\n\t    while (p > 0) {\n\t        for (k = p - 2; k >= -1; k--) {\n\t            if (k === -1) {\n\t                break;\n\t            }\n\t            if (Math.abs(e[k]) <= eps * (Math.abs(s[k]) + Math.abs(s[k + 1]))) {\n\t                e[k] = 0;\n\t                break;\n\t            }\n\t        }\n\t        if (k === p - 2) {\n\t            kase = 4;\n\t        } else {\n\t            for (ks = p - 1; ks >= k; ks--) {\n\t                if (ks === k) {\n\t                    break;\n\t                }\n\t                t = (ks !== p ? Math.abs(e[ks]) : 0) + (ks !== k + 1 ? Math.abs(e[ks - 1]) : 0);\n\t                if (Math.abs(s[ks]) <= eps * t) {\n\t                    s[ks] = 0;\n\t                    break;\n\t                }\n\t            }\n\t            if (ks === k) {\n\t                kase = 3;\n\t            } else if (ks === p - 1) {\n\t                kase = 1;\n\t            } else {\n\t                kase = 2;\n\t                k = ks;\n\t            }\n\t        }\n\t\n\t        k++;\n\t\n\t        switch (kase) {\n\t            case 1: {\n\t                f = e[p - 2];\n\t                e[p - 2] = 0;\n\t                for (j = p - 2; j >= k; j--) {\n\t                    t = hypotenuse(s[j], f);\n\t                    cs = s[j] / t;\n\t                    sn = f / t;\n\t                    s[j] = t;\n\t                    if (j !== k) {\n\t                        f = -sn * e[j - 1];\n\t                        e[j - 1] = cs * e[j - 1];\n\t                    }\n\t                    if (wantv) {\n\t                        for (i = 0; i < n; i++) {\n\t                            t = cs * V[i][j] + sn * V[i][p - 1];\n\t                            V[i][p - 1] = -sn * V[i][j] + cs * V[i][p - 1];\n\t                            V[i][j] = t;\n\t                        }\n\t                    }\n\t                }\n\t                break;\n\t            }\n\t            case 2 : {\n\t                f = e[k - 1];\n\t                e[k - 1] = 0;\n\t                for (j = k; j < p; j++) {\n\t                    t = hypotenuse(s[j], f);\n\t                    cs = s[j] / t;\n\t                    sn = f / t;\n\t                    s[j] = t;\n\t                    f = -sn * e[j];\n\t                    e[j] = cs * e[j];\n\t                    if (wantu) {\n\t                        for (i = 0; i < m; i++) {\n\t                            t = cs * U[i][j] + sn * U[i][k - 1];\n\t                            U[i][k - 1] = -sn * U[i][j] + cs * U[i][k - 1];\n\t                            U[i][j] = t;\n\t                        }\n\t                    }\n\t                }\n\t                break;\n\t            }\n\t            case 3 : {\n\t                scale = Math.max(Math.max(Math.max(Math.max(Math.abs(s[p - 1]), Math.abs(s[p - 2])), Math.abs(e[p - 2])), Math.abs(s[k])), Math.abs(e[k]));\n\t                sp = s[p - 1] / scale;\n\t                spm1 = s[p - 2] / scale;\n\t                epm1 = e[p - 2] / scale;\n\t                sk = s[k] / scale;\n\t                ek = e[k] / scale;\n\t                b = ((spm1 + sp) * (spm1 - sp) + epm1 * epm1) / 2;\n\t                c = (sp * epm1) * (sp * epm1);\n\t                shift = 0;\n\t                if ((b !== 0) || (c !== 0)) {\n\t                    shift = Math.sqrt(b * b + c);\n\t                    if (b < 0) {\n\t                        shift = -shift;\n\t                    }\n\t                    shift = c / (b + shift);\n\t                }\n\t                f = (sk + sp) * (sk - sp) + shift;\n\t                g = sk * ek;\n\t                for (j = k; j < p - 1; j++) {\n\t                    t = hypotenuse(f, g);\n\t                    cs = f / t;\n\t                    sn = g / t;\n\t                    if (j !== k) {\n\t                        e[j - 1] = t;\n\t                    }\n\t                    f = cs * s[j] + sn * e[j];\n\t                    e[j] = cs * e[j] - sn * s[j];\n\t                    g = sn * s[j + 1];\n\t                    s[j + 1] = cs * s[j + 1];\n\t                    if (wantv) {\n\t                        for (i = 0; i < n; i++) {\n\t                            t = cs * V[i][j] + sn * V[i][j + 1];\n\t                            V[i][j + 1] = -sn * V[i][j] + cs * V[i][j + 1];\n\t                            V[i][j] = t;\n\t                        }\n\t                    }\n\t                    t = hypotenuse(f, g);\n\t                    cs = f / t;\n\t                    sn = g / t;\n\t                    s[j] = t;\n\t                    f = cs * e[j] + sn * s[j + 1];\n\t                    s[j + 1] = -sn * e[j] + cs * s[j + 1];\n\t                    g = sn * e[j + 1];\n\t                    e[j + 1] = cs * e[j + 1];\n\t                    if (wantu && (j < m - 1)) {\n\t                        for (i = 0; i < m; i++) {\n\t                            t = cs * U[i][j] + sn * U[i][j + 1];\n\t                            U[i][j + 1] = -sn * U[i][j] + cs * U[i][j + 1];\n\t                            U[i][j] = t;\n\t                        }\n\t                    }\n\t                }\n\t                e[p - 2] = f;\n\t                iter = iter + 1;\n\t                break;\n\t            }\n\t            case 4: {\n\t                if (s[k] <= 0) {\n\t                    s[k] = (s[k] < 0 ? -s[k] : 0);\n\t                    if (wantv) {\n\t                        for (i = 0; i <= pp; i++) {\n\t                            V[i][k] = -V[i][k];\n\t                        }\n\t                    }\n\t                }\n\t                while (k < pp) {\n\t                    if (s[k] >= s[k + 1]) {\n\t                        break;\n\t                    }\n\t                    t = s[k];\n\t                    s[k] = s[k + 1];\n\t                    s[k + 1] = t;\n\t                    if (wantv && (k < n - 1)) {\n\t                        for (i = 0; i < n; i++) {\n\t                            t = V[i][k + 1];\n\t                            V[i][k + 1] = V[i][k];\n\t                            V[i][k] = t;\n\t                        }\n\t                    }\n\t                    if (wantu && (k < m - 1)) {\n\t                        for (i = 0; i < m; i++) {\n\t                            t = U[i][k + 1];\n\t                            U[i][k + 1] = U[i][k];\n\t                            U[i][k] = t;\n\t                        }\n\t                    }\n\t                    k++;\n\t                }\n\t                iter = 0;\n\t                p--;\n\t                break;\n\t            }\n\t        }\n\t    }\n\t\n\t    if (swapped) {\n\t        var tmp = V;\n\t        V = U;\n\t        U = tmp;\n\t    }\n\t\n\t    this.m = m;\n\t    this.n = n;\n\t    this.s = s;\n\t    this.U = U;\n\t    this.V = V;\n\t}\n\t\n\tSingularValueDecomposition.prototype = {\n\t    get condition() {\n\t        return this.s[0] / this.s[Math.min(this.m, this.n) - 1];\n\t    },\n\t    get norm2() {\n\t        return this.s[0];\n\t    },\n\t    get rank() {\n\t        var eps = Math.pow(2, -52),\n\t            tol = Math.max(this.m, this.n) * this.s[0] * eps,\n\t            r = 0,\n\t            s = this.s;\n\t        for (var i = 0, ii = s.length; i < ii; i++) {\n\t            if (s[i] > tol) {\n\t                r++;\n\t            }\n\t        }\n\t        return r;\n\t    },\n\t    get diagonal() {\n\t        return this.s;\n\t    },\n\t    // https://github.com/accord-net/framework/blob/development/Sources/Accord.Math/Decompositions/SingularValueDecomposition.cs\n\t    get threshold() {\n\t        return (Math.pow(2, -52) / 2) * Math.max(this.m, this.n) * this.s[0];\n\t    },\n\t    get leftSingularVectors() {\n\t        return this.U;\n\t    },\n\t    get rightSingularVectors() {\n\t        return this.V;\n\t    },\n\t    get diagonalMatrix() {\n\t        return Matrix.diag(this.s);\n\t    },\n\t    solve: function (value) {\n\t\n\t        var Y = value,\n\t            e = this.threshold,\n\t            scols = this.s.length,\n\t            Ls = Matrix.zeros(scols, scols),\n\t            i;\n\t\n\t        for (i = 0; i < scols; i++) {\n\t            if (Math.abs(this.s[i]) <= e) {\n\t                Ls[i][i] = 0;\n\t            } else {\n\t                Ls[i][i] = 1 / this.s[i];\n\t            }\n\t        }\n\t\n\t\n\t        var VL = this.V.mmul(Ls),\n\t            vrows = this.V.rows,\n\t            urows = this.U.rows,\n\t            VLU = Matrix.zeros(vrows, urows),\n\t            j, k, sum;\n\t\n\t        for (i = 0; i < vrows; i++) {\n\t            for (j = 0; j < urows; j++) {\n\t                sum = 0;\n\t                for (k = 0; k < scols; k++) {\n\t                    sum += VL[i][k] * this.U[j][k];\n\t                }\n\t                VLU[i][j] = sum;\n\t            }\n\t        }\n\t\n\t        return VLU.mmul(Y);\n\t    },\n\t    solveForDiagonal: function (value) {\n\t        return this.solve(Matrix.diag(value));\n\t    },\n\t    inverse: function () {\n\t        var e = this.threshold,\n\t            vrows = this.V.rows,\n\t            vcols = this.V.columns,\n\t            X = new Matrix(vrows, this.s.length),\n\t            i, j;\n\t\n\t        for (i = 0; i < vrows; i++) {\n\t            for (j = 0; j < vcols; j++) {\n\t                if (Math.abs(this.s[j]) > e) {\n\t                    X[i][j] = this.V[i][j] / this.s[j];\n\t                } else {\n\t                    X[i][j] = 0;\n\t                }\n\t            }\n\t        }\n\t\n\t        var urows = this.U.rows,\n\t            ucols = this.U.columns,\n\t            Y = new Matrix(vrows, urows),\n\t            k, sum;\n\t\n\t        for (i = 0; i < vrows; i++) {\n\t            for (j = 0; j < urows; j++) {\n\t                sum = 0;\n\t                for (k = 0; k < ucols; k++) {\n\t                    sum += X[i][k] * this.U[j][k];\n\t                }\n\t                Y[i][j] = sum;\n\t            }\n\t        }\n\t\n\t        return Y;\n\t    }\n\t};\n\t\n\tmodule.exports = SingularValueDecomposition;\n\n\n/***/ },\n/* 9 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\texports.hypotenuse = function hypotenuse(a, b) {\n\t    var r;\n\t    if (Math.abs(a) > Math.abs(b)) {\n\t        r = b / a;\n\t        return Math.abs(a) * Math.sqrt(1 + r * r);\n\t    }\n\t    if (b !== 0) {\n\t        r = a / b;\n\t        return Math.abs(b) * Math.sqrt(1 + r * r);\n\t    }\n\t    return 0;\n\t};\n\n\n/***/ },\n/* 10 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar Matrix = __webpack_require__(6);\n\tvar hypotenuse = __webpack_require__(9).hypotenuse;\n\t\n\t// https://github.com/lutzroeder/Mapack/blob/master/Source/EigenvalueDecomposition.cs\n\tfunction EigenvalueDecomposition(matrix) {\n\t    if (!(this instanceof EigenvalueDecomposition)) {\n\t        return new EigenvalueDecomposition(matrix);\n\t    }\n\t    matrix = Matrix.checkMatrix(matrix);\n\t    if (!matrix.isSquare()) {\n\t        throw new Error('Matrix is not a square matrix');\n\t    }\n\t\n\t    var n = matrix.columns,\n\t        V = Matrix.zeros(n, n),\n\t        d = new Array(n),\n\t        e = new Array(n),\n\t        value = matrix,\n\t        i, j;\n\t\n\t    if (matrix.isSymmetric()) {\n\t        for (i = 0; i < n; i++) {\n\t            for (j = 0; j < n; j++) {\n\t                V[i][j] = value[i][j];\n\t            }\n\t        }\n\t        tred2(n, e, d, V);\n\t        tql2(n, e, d, V);\n\t    }\n\t    else {\n\t        var H = Matrix.zeros(n, n),\n\t            ort = new Array(n);\n\t        for (j = 0; j < n; j++) {\n\t            for (i = 0; i < n; i++) {\n\t                H[i][j] = value[i][j];\n\t            }\n\t        }\n\t        orthes(n, H, ort, V);\n\t        hqr2(n, e, d, V, H);\n\t    }\n\t\n\t    this.n = n;\n\t    this.e = e;\n\t    this.d = d;\n\t    this.V = V;\n\t}\n\t\n\tEigenvalueDecomposition.prototype = {\n\t    get realEigenvalues() {\n\t        return this.d;\n\t    },\n\t    get imaginaryEigenvalues() {\n\t        return this.e;\n\t    },\n\t    get eigenvectorMatrix() {\n\t        return this.V;\n\t    },\n\t    get diagonalMatrix() {\n\t        var n = this.n,\n\t            e = this.e,\n\t            d = this.d,\n\t            X = new Matrix(n, n),\n\t            i, j;\n\t        for (i = 0; i < n; i++) {\n\t            for (j = 0; j < n; j++) {\n\t                X[i][j] = 0;\n\t            }\n\t            X[i][i] = d[i];\n\t            if (e[i] > 0) {\n\t                X[i][i + 1] = e[i];\n\t            }\n\t            else if (e[i] < 0) {\n\t                X[i][i - 1] = e[i];\n\t            }\n\t        }\n\t        return X;\n\t    }\n\t};\n\t\n\tfunction tred2(n, e, d, V) {\n\t\n\t    var f, g, h, i, j, k,\n\t        hh, scale;\n\t\n\t    for (j = 0; j < n; j++) {\n\t        d[j] = V[n - 1][j];\n\t    }\n\t\n\t    for (i = n - 1; i > 0; i--) {\n\t        scale = 0;\n\t        h = 0;\n\t        for (k = 0; k < i; k++) {\n\t            scale = scale + Math.abs(d[k]);\n\t        }\n\t\n\t        if (scale === 0) {\n\t            e[i] = d[i - 1];\n\t            for (j = 0; j < i; j++) {\n\t                d[j] = V[i - 1][j];\n\t                V[i][j] = 0;\n\t                V[j][i] = 0;\n\t            }\n\t        } else {\n\t            for (k = 0; k < i; k++) {\n\t                d[k] /= scale;\n\t                h += d[k] * d[k];\n\t            }\n\t\n\t            f = d[i - 1];\n\t            g = Math.sqrt(h);\n\t            if (f > 0) {\n\t                g = -g;\n\t            }\n\t\n\t            e[i] = scale * g;\n\t            h = h - f * g;\n\t            d[i - 1] = f - g;\n\t            for (j = 0; j < i; j++) {\n\t                e[j] = 0;\n\t            }\n\t\n\t            for (j = 0; j < i; j++) {\n\t                f = d[j];\n\t                V[j][i] = f;\n\t                g = e[j] + V[j][j] * f;\n\t                for (k = j + 1; k <= i - 1; k++) {\n\t                    g += V[k][j] * d[k];\n\t                    e[k] += V[k][j] * f;\n\t                }\n\t                e[j] = g;\n\t            }\n\t\n\t            f = 0;\n\t            for (j = 0; j < i; j++) {\n\t                e[j] /= h;\n\t                f += e[j] * d[j];\n\t            }\n\t\n\t            hh = f / (h + h);\n\t            for (j = 0; j < i; j++) {\n\t                e[j] -= hh * d[j];\n\t            }\n\t\n\t            for (j = 0; j < i; j++) {\n\t                f = d[j];\n\t                g = e[j];\n\t                for (k = j; k <= i - 1; k++) {\n\t                    V[k][j] -= (f * e[k] + g * d[k]);\n\t                }\n\t                d[j] = V[i - 1][j];\n\t                V[i][j] = 0;\n\t            }\n\t        }\n\t        d[i] = h;\n\t    }\n\t\n\t    for (i = 0; i < n - 1; i++) {\n\t        V[n - 1][i] = V[i][i];\n\t        V[i][i] = 1;\n\t        h = d[i + 1];\n\t        if (h !== 0) {\n\t            for (k = 0; k <= i; k++) {\n\t                d[k] = V[k][i + 1] / h;\n\t            }\n\t\n\t            for (j = 0; j <= i; j++) {\n\t                g = 0;\n\t                for (k = 0; k <= i; k++) {\n\t                    g += V[k][i + 1] * V[k][j];\n\t                }\n\t                for (k = 0; k <= i; k++) {\n\t                    V[k][j] -= g * d[k];\n\t                }\n\t            }\n\t        }\n\t\n\t        for (k = 0; k <= i; k++) {\n\t            V[k][i + 1] = 0;\n\t        }\n\t    }\n\t\n\t    for (j = 0; j < n; j++) {\n\t        d[j] = V[n - 1][j];\n\t        V[n - 1][j] = 0;\n\t    }\n\t\n\t    V[n - 1][n - 1] = 1;\n\t    e[0] = 0;\n\t}\n\t\n\tfunction tql2(n, e, d, V) {\n\t\n\t    var g, h, i, j, k, l, m, p, r,\n\t        dl1, c, c2, c3, el1, s, s2,\n\t        iter;\n\t\n\t    for (i = 1; i < n; i++) {\n\t        e[i - 1] = e[i];\n\t    }\n\t\n\t    e[n - 1] = 0;\n\t\n\t    var f = 0,\n\t        tst1 = 0,\n\t        eps = Math.pow(2, -52);\n\t\n\t    for (l = 0; l < n; l++) {\n\t        tst1 = Math.max(tst1, Math.abs(d[l]) + Math.abs(e[l]));\n\t        m = l;\n\t        while (m < n) {\n\t            if (Math.abs(e[m]) <= eps * tst1) {\n\t                break;\n\t            }\n\t            m++;\n\t        }\n\t\n\t        if (m > l) {\n\t            iter = 0;\n\t            do {\n\t                iter = iter + 1;\n\t\n\t                g = d[l];\n\t                p = (d[l + 1] - g) / (2 * e[l]);\n\t                r = hypotenuse(p, 1);\n\t                if (p < 0) {\n\t                    r = -r;\n\t                }\n\t\n\t                d[l] = e[l] / (p + r);\n\t                d[l + 1] = e[l] * (p + r);\n\t                dl1 = d[l + 1];\n\t                h = g - d[l];\n\t                for (i = l + 2; i < n; i++) {\n\t                    d[i] -= h;\n\t                }\n\t\n\t                f = f + h;\n\t\n\t                p = d[m];\n\t                c = 1;\n\t                c2 = c;\n\t                c3 = c;\n\t                el1 = e[l + 1];\n\t                s = 0;\n\t                s2 = 0;\n\t                for (i = m - 1; i >= l; i--) {\n\t                    c3 = c2;\n\t                    c2 = c;\n\t                    s2 = s;\n\t                    g = c * e[i];\n\t                    h = c * p;\n\t                    r = hypotenuse(p, e[i]);\n\t                    e[i + 1] = s * r;\n\t                    s = e[i] / r;\n\t                    c = p / r;\n\t                    p = c * d[i] - s * g;\n\t                    d[i + 1] = h + s * (c * g + s * d[i]);\n\t\n\t                    for (k = 0; k < n; k++) {\n\t                        h = V[k][i + 1];\n\t                        V[k][i + 1] = s * V[k][i] + c * h;\n\t                        V[k][i] = c * V[k][i] - s * h;\n\t                    }\n\t                }\n\t\n\t                p = -s * s2 * c3 * el1 * e[l] / dl1;\n\t                e[l] = s * p;\n\t                d[l] = c * p;\n\t\n\t            }\n\t            while (Math.abs(e[l]) > eps * tst1);\n\t        }\n\t        d[l] = d[l] + f;\n\t        e[l] = 0;\n\t    }\n\t\n\t    for (i = 0; i < n - 1; i++) {\n\t        k = i;\n\t        p = d[i];\n\t        for (j = i + 1; j < n; j++) {\n\t            if (d[j] < p) {\n\t                k = j;\n\t                p = d[j];\n\t            }\n\t        }\n\t\n\t        if (k !== i) {\n\t            d[k] = d[i];\n\t            d[i] = p;\n\t            for (j = 0; j < n; j++) {\n\t                p = V[j][i];\n\t                V[j][i] = V[j][k];\n\t                V[j][k] = p;\n\t            }\n\t        }\n\t    }\n\t}\n\t\n\tfunction orthes(n, H, ort, V) {\n\t\n\t    var low = 0,\n\t        high = n - 1,\n\t        f, g, h, i, j, m,\n\t        scale;\n\t\n\t    for (m = low + 1; m <= high - 1; m++) {\n\t        scale = 0;\n\t        for (i = m; i <= high; i++) {\n\t            scale = scale + Math.abs(H[i][m - 1]);\n\t        }\n\t\n\t        if (scale !== 0) {\n\t            h = 0;\n\t            for (i = high; i >= m; i--) {\n\t                ort[i] = H[i][m - 1] / scale;\n\t                h += ort[i] * ort[i];\n\t            }\n\t\n\t            g = Math.sqrt(h);\n\t            if (ort[m] > 0) {\n\t                g = -g;\n\t            }\n\t\n\t            h = h - ort[m] * g;\n\t            ort[m] = ort[m] - g;\n\t\n\t            for (j = m; j < n; j++) {\n\t                f = 0;\n\t                for (i = high; i >= m; i--) {\n\t                    f += ort[i] * H[i][j];\n\t                }\n\t\n\t                f = f / h;\n\t                for (i = m; i <= high; i++) {\n\t                    H[i][j] -= f * ort[i];\n\t                }\n\t            }\n\t\n\t            for (i = 0; i <= high; i++) {\n\t                f = 0;\n\t                for (j = high; j >= m; j--) {\n\t                    f += ort[j] * H[i][j];\n\t                }\n\t\n\t                f = f / h;\n\t                for (j = m; j <= high; j++) {\n\t                    H[i][j] -= f * ort[j];\n\t                }\n\t            }\n\t\n\t            ort[m] = scale * ort[m];\n\t            H[m][m - 1] = scale * g;\n\t        }\n\t    }\n\t\n\t    for (i = 0; i < n; i++) {\n\t        for (j = 0; j < n; j++) {\n\t            V[i][j] = (i === j ? 1 : 0);\n\t        }\n\t    }\n\t\n\t    for (m = high - 1; m >= low + 1; m--) {\n\t        if (H[m][m - 1] !== 0) {\n\t            for (i = m + 1; i <= high; i++) {\n\t                ort[i] = H[i][m - 1];\n\t            }\n\t\n\t            for (j = m; j <= high; j++) {\n\t                g = 0;\n\t                for (i = m; i <= high; i++) {\n\t                    g += ort[i] * V[i][j];\n\t                }\n\t\n\t                g = (g / ort[m]) / H[m][m - 1];\n\t                for (i = m; i <= high; i++) {\n\t                    V[i][j] += g * ort[i];\n\t                }\n\t            }\n\t        }\n\t    }\n\t}\n\t\n\tfunction hqr2(nn, e, d, V, H) {\n\t    var n = nn - 1,\n\t        low = 0,\n\t        high = nn - 1,\n\t        eps = Math.pow(2, -52),\n\t        exshift = 0,\n\t        norm = 0,\n\t        p = 0,\n\t        q = 0,\n\t        r = 0,\n\t        s = 0,\n\t        z = 0,\n\t        iter = 0,\n\t        i, j, k, l, m, t, w, x, y,\n\t        ra, sa, vr, vi,\n\t        notlast, cdivres;\n\t\n\t    for (i = 0; i < nn; i++) {\n\t        if (i < low || i > high) {\n\t            d[i] = H[i][i];\n\t            e[i] = 0;\n\t        }\n\t\n\t        for (j = Math.max(i - 1, 0); j < nn; j++) {\n\t            norm = norm + Math.abs(H[i][j]);\n\t        }\n\t    }\n\t\n\t    while (n >= low) {\n\t        l = n;\n\t        while (l > low) {\n\t            s = Math.abs(H[l - 1][l - 1]) + Math.abs(H[l][l]);\n\t            if (s === 0) {\n\t                s = norm;\n\t            }\n\t            if (Math.abs(H[l][l - 1]) < eps * s) {\n\t                break;\n\t            }\n\t            l--;\n\t        }\n\t\n\t        if (l === n) {\n\t            H[n][n] = H[n][n] + exshift;\n\t            d[n] = H[n][n];\n\t            e[n] = 0;\n\t            n--;\n\t            iter = 0;\n\t        } else if (l === n - 1) {\n\t            w = H[n][n - 1] * H[n - 1][n];\n\t            p = (H[n - 1][n - 1] - H[n][n]) / 2;\n\t            q = p * p + w;\n\t            z = Math.sqrt(Math.abs(q));\n\t            H[n][n] = H[n][n] + exshift;\n\t            H[n - 1][n - 1] = H[n - 1][n - 1] + exshift;\n\t            x = H[n][n];\n\t\n\t            if (q >= 0) {\n\t                z = (p >= 0) ? (p + z) : (p - z);\n\t                d[n - 1] = x + z;\n\t                d[n] = d[n - 1];\n\t                if (z !== 0) {\n\t                    d[n] = x - w / z;\n\t                }\n\t                e[n - 1] = 0;\n\t                e[n] = 0;\n\t                x = H[n][n - 1];\n\t                s = Math.abs(x) + Math.abs(z);\n\t                p = x / s;\n\t                q = z / s;\n\t                r = Math.sqrt(p * p + q * q);\n\t                p = p / r;\n\t                q = q / r;\n\t\n\t                for (j = n - 1; j < nn; j++) {\n\t                    z = H[n - 1][j];\n\t                    H[n - 1][j] = q * z + p * H[n][j];\n\t                    H[n][j] = q * H[n][j] - p * z;\n\t                }\n\t\n\t                for (i = 0; i <= n; i++) {\n\t                    z = H[i][n - 1];\n\t                    H[i][n - 1] = q * z + p * H[i][n];\n\t                    H[i][n] = q * H[i][n] - p * z;\n\t                }\n\t\n\t                for (i = low; i <= high; i++) {\n\t                    z = V[i][n - 1];\n\t                    V[i][n - 1] = q * z + p * V[i][n];\n\t                    V[i][n] = q * V[i][n] - p * z;\n\t                }\n\t            } else {\n\t                d[n - 1] = x + p;\n\t                d[n] = x + p;\n\t                e[n - 1] = z;\n\t                e[n] = -z;\n\t            }\n\t\n\t            n = n - 2;\n\t            iter = 0;\n\t        } else {\n\t            x = H[n][n];\n\t            y = 0;\n\t            w = 0;\n\t            if (l < n) {\n\t                y = H[n - 1][n - 1];\n\t                w = H[n][n - 1] * H[n - 1][n];\n\t            }\n\t\n\t            if (iter === 10) {\n\t                exshift += x;\n\t                for (i = low; i <= n; i++) {\n\t                    H[i][i] -= x;\n\t                }\n\t                s = Math.abs(H[n][n - 1]) + Math.abs(H[n - 1][n - 2]);\n\t                x = y = 0.75 * s;\n\t                w = -0.4375 * s * s;\n\t            }\n\t\n\t            if (iter === 30) {\n\t                s = (y - x) / 2;\n\t                s = s * s + w;\n\t                if (s > 0) {\n\t                    s = Math.sqrt(s);\n\t                    if (y < x) {\n\t                        s = -s;\n\t                    }\n\t                    s = x - w / ((y - x) / 2 + s);\n\t                    for (i = low; i <= n; i++) {\n\t                        H[i][i] -= s;\n\t                    }\n\t                    exshift += s;\n\t                    x = y = w = 0.964;\n\t                }\n\t            }\n\t\n\t            iter = iter + 1;\n\t\n\t            m = n - 2;\n\t            while (m >= l) {\n\t                z = H[m][m];\n\t                r = x - z;\n\t                s = y - z;\n\t                p = (r * s - w) / H[m + 1][m] + H[m][m + 1];\n\t                q = H[m + 1][m + 1] - z - r - s;\n\t                r = H[m + 2][m + 1];\n\t                s = Math.abs(p) + Math.abs(q) + Math.abs(r);\n\t                p = p / s;\n\t                q = q / s;\n\t                r = r / s;\n\t                if (m === l) {\n\t                    break;\n\t                }\n\t                if (Math.abs(H[m][m - 1]) * (Math.abs(q) + Math.abs(r)) < eps * (Math.abs(p) * (Math.abs(H[m - 1][m - 1]) + Math.abs(z) + Math.abs(H[m + 1][m + 1])))) {\n\t                    break;\n\t                }\n\t                m--;\n\t            }\n\t\n\t            for (i = m + 2; i <= n; i++) {\n\t                H[i][i - 2] = 0;\n\t                if (i > m + 2) {\n\t                    H[i][i - 3] = 0;\n\t                }\n\t            }\n\t\n\t            for (k = m; k <= n - 1; k++) {\n\t                notlast = (k !== n - 1);\n\t                if (k !== m) {\n\t                    p = H[k][k - 1];\n\t                    q = H[k + 1][k - 1];\n\t                    r = (notlast ? H[k + 2][k - 1] : 0);\n\t                    x = Math.abs(p) + Math.abs(q) + Math.abs(r);\n\t                    if (x !== 0) {\n\t                        p = p / x;\n\t                        q = q / x;\n\t                        r = r / x;\n\t                    }\n\t                }\n\t\n\t                if (x === 0) {\n\t                    break;\n\t                }\n\t\n\t                s = Math.sqrt(p * p + q * q + r * r);\n\t                if (p < 0) {\n\t                    s = -s;\n\t                }\n\t\n\t                if (s !== 0) {\n\t                    if (k !== m) {\n\t                        H[k][k - 1] = -s * x;\n\t                    } else if (l !== m) {\n\t                        H[k][k - 1] = -H[k][k - 1];\n\t                    }\n\t\n\t                    p = p + s;\n\t                    x = p / s;\n\t                    y = q / s;\n\t                    z = r / s;\n\t                    q = q / p;\n\t                    r = r / p;\n\t\n\t                    for (j = k; j < nn; j++) {\n\t                        p = H[k][j] + q * H[k + 1][j];\n\t                        if (notlast) {\n\t                            p = p + r * H[k + 2][j];\n\t                            H[k + 2][j] = H[k + 2][j] - p * z;\n\t                        }\n\t\n\t                        H[k][j] = H[k][j] - p * x;\n\t                        H[k + 1][j] = H[k + 1][j] - p * y;\n\t                    }\n\t\n\t                    for (i = 0; i <= Math.min(n, k + 3); i++) {\n\t                        p = x * H[i][k] + y * H[i][k + 1];\n\t                        if (notlast) {\n\t                            p = p + z * H[i][k + 2];\n\t                            H[i][k + 2] = H[i][k + 2] - p * r;\n\t                        }\n\t\n\t                        H[i][k] = H[i][k] - p;\n\t                        H[i][k + 1] = H[i][k + 1] - p * q;\n\t                    }\n\t\n\t                    for (i = low; i <= high; i++) {\n\t                        p = x * V[i][k] + y * V[i][k + 1];\n\t                        if (notlast) {\n\t                            p = p + z * V[i][k + 2];\n\t                            V[i][k + 2] = V[i][k + 2] - p * r;\n\t                        }\n\t\n\t                        V[i][k] = V[i][k] - p;\n\t                        V[i][k + 1] = V[i][k + 1] - p * q;\n\t                    }\n\t                }\n\t            }\n\t        }\n\t    }\n\t\n\t    if (norm === 0) {\n\t        return;\n\t    }\n\t\n\t    for (n = nn - 1; n >= 0; n--) {\n\t        p = d[n];\n\t        q = e[n];\n\t\n\t        if (q === 0) {\n\t            l = n;\n\t            H[n][n] = 1;\n\t            for (i = n - 1; i >= 0; i--) {\n\t                w = H[i][i] - p;\n\t                r = 0;\n\t                for (j = l; j <= n; j++) {\n\t                    r = r + H[i][j] * H[j][n];\n\t                }\n\t\n\t                if (e[i] < 0) {\n\t                    z = w;\n\t                    s = r;\n\t                } else {\n\t                    l = i;\n\t                    if (e[i] === 0) {\n\t                        H[i][n] = (w !== 0) ? (-r / w) : (-r / (eps * norm));\n\t                    } else {\n\t                        x = H[i][i + 1];\n\t                        y = H[i + 1][i];\n\t                        q = (d[i] - p) * (d[i] - p) + e[i] * e[i];\n\t                        t = (x * s - z * r) / q;\n\t                        H[i][n] = t;\n\t                        H[i + 1][n] = (Math.abs(x) > Math.abs(z)) ? ((-r - w * t) / x) : ((-s - y * t) / z);\n\t                    }\n\t\n\t                    t = Math.abs(H[i][n]);\n\t                    if ((eps * t) * t > 1) {\n\t                        for (j = i; j <= n; j++) {\n\t                            H[j][n] = H[j][n] / t;\n\t                        }\n\t                    }\n\t                }\n\t            }\n\t        } else if (q < 0) {\n\t            l = n - 1;\n\t\n\t            if (Math.abs(H[n][n - 1]) > Math.abs(H[n - 1][n])) {\n\t                H[n - 1][n - 1] = q / H[n][n - 1];\n\t                H[n - 1][n] = -(H[n][n] - p) / H[n][n - 1];\n\t            } else {\n\t                cdivres = cdiv(0, -H[n - 1][n], H[n - 1][n - 1] - p, q);\n\t                H[n - 1][n - 1] = cdivres[0];\n\t                H[n - 1][n] = cdivres[1];\n\t            }\n\t\n\t            H[n][n - 1] = 0;\n\t            H[n][n] = 1;\n\t            for (i = n - 2; i >= 0; i--) {\n\t                ra = 0;\n\t                sa = 0;\n\t                for (j = l; j <= n; j++) {\n\t                    ra = ra + H[i][j] * H[j][n - 1];\n\t                    sa = sa + H[i][j] * H[j][n];\n\t                }\n\t\n\t                w = H[i][i] - p;\n\t\n\t                if (e[i] < 0) {\n\t                    z = w;\n\t                    r = ra;\n\t                    s = sa;\n\t                } else {\n\t                    l = i;\n\t                    if (e[i] === 0) {\n\t                        cdivres = cdiv(-ra, -sa, w, q);\n\t                        H[i][n - 1] = cdivres[0];\n\t                        H[i][n] = cdivres[1];\n\t                    } else {\n\t                        x = H[i][i + 1];\n\t                        y = H[i + 1][i];\n\t                        vr = (d[i] - p) * (d[i] - p) + e[i] * e[i] - q * q;\n\t                        vi = (d[i] - p) * 2 * q;\n\t                        if (vr === 0 && vi === 0) {\n\t                            vr = eps * norm * (Math.abs(w) + Math.abs(q) + Math.abs(x) + Math.abs(y) + Math.abs(z));\n\t                        }\n\t                        cdivres = cdiv(x * r - z * ra + q * sa, x * s - z * sa - q * ra, vr, vi);\n\t                        H[i][n - 1] = cdivres[0];\n\t                        H[i][n] = cdivres[1];\n\t                        if (Math.abs(x) > (Math.abs(z) + Math.abs(q))) {\n\t                            H[i + 1][n - 1] = (-ra - w * H[i][n - 1] + q * H[i][n]) / x;\n\t                            H[i + 1][n] = (-sa - w * H[i][n] - q * H[i][n - 1]) / x;\n\t                        } else {\n\t                            cdivres = cdiv(-r - y * H[i][n - 1], -s - y * H[i][n], z, q);\n\t                            H[i + 1][n - 1] = cdivres[0];\n\t                            H[i + 1][n] = cdivres[1];\n\t                        }\n\t                    }\n\t\n\t                    t = Math.max(Math.abs(H[i][n - 1]), Math.abs(H[i][n]));\n\t                    if ((eps * t) * t > 1) {\n\t                        for (j = i; j <= n; j++) {\n\t                            H[j][n - 1] = H[j][n - 1] / t;\n\t                            H[j][n] = H[j][n] / t;\n\t                        }\n\t                    }\n\t                }\n\t            }\n\t        }\n\t    }\n\t\n\t    for (i = 0; i < nn; i++) {\n\t        if (i < low || i > high) {\n\t            for (j = i; j < nn; j++) {\n\t                V[i][j] = H[i][j];\n\t            }\n\t        }\n\t    }\n\t\n\t    for (j = nn - 1; j >= low; j--) {\n\t        for (i = low; i <= high; i++) {\n\t            z = 0;\n\t            for (k = low; k <= Math.min(j, high); k++) {\n\t                z = z + V[i][k] * H[k][j];\n\t            }\n\t            V[i][j] = z;\n\t        }\n\t    }\n\t}\n\t\n\tfunction cdiv(xr, xi, yr, yi) {\n\t    var r, d;\n\t    if (Math.abs(yr) > Math.abs(yi)) {\n\t        r = yi / yr;\n\t        d = yr + r * yi;\n\t        return [(xr + r * xi) / d, (xi - r * xr) / d];\n\t    }\n\t    else {\n\t        r = yr / yi;\n\t        d = yi + r * yr;\n\t        return [(r * xr + xi) / d, (r * xi - xr) / d];\n\t    }\n\t}\n\t\n\tmodule.exports = EigenvalueDecomposition;\n\n\n/***/ },\n/* 11 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar Matrix = __webpack_require__(6);\n\t\n\t// https://github.com/lutzroeder/Mapack/blob/master/Source/LuDecomposition.cs\n\tfunction LuDecomposition(matrix) {\n\t    if (!(this instanceof LuDecomposition)) {\n\t        return new LuDecomposition(matrix);\n\t    }\n\t    matrix = Matrix.checkMatrix(matrix);\n\t\n\t    var lu = matrix.clone(),\n\t        rows = lu.rows,\n\t        columns = lu.columns,\n\t        pivotVector = new Array(rows),\n\t        pivotSign = 1,\n\t        i, j, k, p, s, t, v,\n\t        LUrowi, LUcolj, kmax;\n\t\n\t    for (i = 0; i < rows; i++) {\n\t        pivotVector[i] = i;\n\t    }\n\t\n\t    LUcolj = new Array(rows);\n\t\n\t    for (j = 0; j < columns; j++) {\n\t\n\t        for (i = 0; i < rows; i++) {\n\t            LUcolj[i] = lu[i][j];\n\t        }\n\t\n\t        for (i = 0; i < rows; i++) {\n\t            LUrowi = lu[i];\n\t            kmax = Math.min(i, j);\n\t            s = 0;\n\t            for (k = 0; k < kmax; k++) {\n\t                s += LUrowi[k] * LUcolj[k];\n\t            }\n\t            LUrowi[j] = LUcolj[i] -= s;\n\t        }\n\t\n\t        p = j;\n\t        for (i = j + 1; i < rows; i++) {\n\t            if (Math.abs(LUcolj[i]) > Math.abs(LUcolj[p])) {\n\t                p = i;\n\t            }\n\t        }\n\t\n\t        if (p !== j) {\n\t            for (k = 0; k < columns; k++) {\n\t                t = lu[p][k];\n\t                lu[p][k] = lu[j][k];\n\t                lu[j][k] = t;\n\t            }\n\t\n\t            v = pivotVector[p];\n\t            pivotVector[p] = pivotVector[j];\n\t            pivotVector[j] = v;\n\t\n\t            pivotSign = -pivotSign;\n\t        }\n\t\n\t        if (j < rows && lu[j][j] !== 0) {\n\t            for (i = j + 1; i < rows; i++) {\n\t                lu[i][j] /= lu[j][j];\n\t            }\n\t        }\n\t    }\n\t\n\t    this.LU = lu;\n\t    this.pivotVector = pivotVector;\n\t    this.pivotSign = pivotSign;\n\t}\n\t\n\tLuDecomposition.prototype = {\n\t    isSingular: function () {\n\t        var data = this.LU,\n\t            col = data.columns;\n\t        for (var j = 0; j < col; j++) {\n\t            if (data[j][j] === 0) {\n\t                return true;\n\t            }\n\t        }\n\t        return false;\n\t    },\n\t    get determinant() {\n\t        var data = this.LU;\n\t        if (!data.isSquare())\n\t            throw new Error('Matrix must be square');\n\t        var determinant = this.pivotSign, col = data.columns;\n\t        for (var j = 0; j < col; j++)\n\t            determinant *= data[j][j];\n\t        return determinant;\n\t    },\n\t    get lowerTriangularFactor() {\n\t        var data = this.LU,\n\t            rows = data.rows,\n\t            columns = data.columns,\n\t            X = new Matrix(rows, columns);\n\t        for (var i = 0; i < rows; i++) {\n\t            for (var j = 0; j < columns; j++) {\n\t                if (i > j) {\n\t                    X[i][j] = data[i][j];\n\t                } else if (i === j) {\n\t                    X[i][j] = 1;\n\t                } else {\n\t                    X[i][j] = 0;\n\t                }\n\t            }\n\t        }\n\t        return X;\n\t    },\n\t    get upperTriangularFactor() {\n\t        var data = this.LU,\n\t            rows = data.rows,\n\t            columns = data.columns,\n\t            X = new Matrix(rows, columns);\n\t        for (var i = 0; i < rows; i++) {\n\t            for (var j = 0; j < columns; j++) {\n\t                if (i <= j) {\n\t                    X[i][j] = data[i][j];\n\t                } else {\n\t                    X[i][j] = 0;\n\t                }\n\t            }\n\t        }\n\t        return X;\n\t    },\n\t    get pivotPermutationVector() {\n\t        return this.pivotVector.slice();\n\t    },\n\t    solve: function (value) {\n\t        value = Matrix.checkMatrix(value);\n\t\n\t        var lu = this.LU,\n\t            rows = lu.rows;\n\t\n\t        if (rows !== value.rows)\n\t            throw new Error('Invalid matrix dimensions');\n\t        if (this.isSingular())\n\t            throw new Error('LU matrix is singular');\n\t\n\t        var count = value.columns,\n\t            X = value.subMatrixRow(this.pivotVector, 0, count - 1),\n\t            columns = lu.columns,\n\t            i, j, k;\n\t\n\t        for (k = 0; k < columns; k++) {\n\t            for (i = k + 1; i < columns; i++) {\n\t                for (j = 0; j < count; j++) {\n\t                    X[i][j] -= X[k][j] * lu[i][k];\n\t                }\n\t            }\n\t        }\n\t        for (k = columns - 1; k >= 0; k--) {\n\t            for (j = 0; j < count; j++) {\n\t                X[k][j] /= lu[k][k];\n\t            }\n\t            for (i = 0; i < k; i++) {\n\t                for (j = 0; j < count; j++) {\n\t                    X[i][j] -= X[k][j] * lu[i][k];\n\t                }\n\t            }\n\t        }\n\t        return X;\n\t    }\n\t};\n\t\n\tmodule.exports = LuDecomposition;\n\n\n/***/ },\n/* 12 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar Matrix = __webpack_require__(6);\n\tvar hypotenuse = __webpack_require__(9).hypotenuse;\n\t\n\t//https://github.com/lutzroeder/Mapack/blob/master/Source/QrDecomposition.cs\n\tfunction QrDecomposition(value) {\n\t    if (!(this instanceof QrDecomposition)) {\n\t        return new QrDecomposition(value);\n\t    }\n\t    value = Matrix.checkMatrix(value);\n\t\n\t    var qr = value.clone(),\n\t        m = value.rows,\n\t        n = value.columns,\n\t        rdiag = new Array(n),\n\t        i, j, k, s;\n\t\n\t    for (k = 0; k < n; k++) {\n\t        var nrm = 0;\n\t        for (i = k; i < m; i++) {\n\t            nrm = hypotenuse(nrm, qr[i][k]);\n\t        }\n\t        if (nrm !== 0) {\n\t            if (qr[k][k] < 0) {\n\t                nrm = -nrm;\n\t            }\n\t            for (i = k; i < m; i++) {\n\t                qr[i][k] /= nrm;\n\t            }\n\t            qr[k][k] += 1;\n\t            for (j = k + 1; j < n; j++) {\n\t                s = 0;\n\t                for (i = k; i < m; i++) {\n\t                    s += qr[i][k] * qr[i][j];\n\t                }\n\t                s = -s / qr[k][k];\n\t                for (i = k; i < m; i++) {\n\t                    qr[i][j] += s * qr[i][k];\n\t                }\n\t            }\n\t        }\n\t        rdiag[k] = -nrm;\n\t    }\n\t\n\t    this.QR = qr;\n\t    this.Rdiag = rdiag;\n\t}\n\t\n\tQrDecomposition.prototype = {\n\t    solve: function (value) {\n\t        value = Matrix.checkMatrix(value);\n\t\n\t        var qr = this.QR,\n\t            m = qr.rows;\n\t\n\t        if (value.rows !== m)\n\t            throw new Error('Matrix row dimensions must agree');\n\t        if (!this.isFullRank())\n\t            throw new Error('Matrix is rank deficient');\n\t\n\t        var count = value.columns,\n\t            X = value.clone(),\n\t            n = qr.columns,\n\t            i, j, k, s;\n\t\n\t        for (k = 0; k < n; k++) {\n\t            for (j = 0; j < count; j++) {\n\t                s = 0;\n\t                for (i = k; i < m; i++) {\n\t                    s += qr[i][k] * X[i][j];\n\t                }\n\t                s = -s / qr[k][k];\n\t                for (i = k; i < m; i++) {\n\t                    X[i][j] += s * qr[i][k];\n\t                }\n\t            }\n\t        }\n\t        for (k = n - 1; k >= 0; k--) {\n\t            for (j = 0; j < count; j++) {\n\t                X[k][j] /= this.Rdiag[k];\n\t            }\n\t            for (i = 0; i < k; i++) {\n\t                for (j = 0; j < count; j++) {\n\t                    X[i][j] -= X[k][j] * qr[i][k];\n\t                }\n\t            }\n\t        }\n\t\n\t        return X.subMatrix(0, n - 1, 0, count - 1);\n\t    },\n\t    isFullRank: function () {\n\t        var columns = this.QR.columns;\n\t        for (var i = 0; i < columns; i++) {\n\t            if (this.Rdiag[i] === 0) {\n\t                return false;\n\t            }\n\t        }\n\t        return true;\n\t    },\n\t    get upperTriangularFactor() {\n\t        var qr = this.QR,\n\t            n = qr.columns,\n\t            X = new Matrix(n, n),\n\t            i, j;\n\t        for (i = 0; i < n; i++) {\n\t            for (j = 0; j < n; j++) {\n\t                if (i < j) {\n\t                    X[i][j] = qr[i][j];\n\t                } else if (i === j) {\n\t                    X[i][j] = this.Rdiag[i];\n\t                } else {\n\t                    X[i][j] = 0;\n\t                }\n\t            }\n\t        }\n\t        return X;\n\t    },\n\t    get orthogonalFactor() {\n\t        var qr = this.QR,\n\t            rows = qr.rows,\n\t            columns = qr.columns,\n\t            X = new Matrix(rows, columns),\n\t            i, j, k, s;\n\t\n\t        for (k = columns - 1; k >= 0; k--) {\n\t            for (i = 0; i < rows; i++) {\n\t                X[i][k] = 0;\n\t            }\n\t            X[k][k] = 1;\n\t            for (j = k; j < columns; j++) {\n\t                if (qr[k][k] !== 0) {\n\t                    s = 0;\n\t                    for (i = k; i < rows; i++) {\n\t                        s += qr[i][k] * X[i][j];\n\t                    }\n\t\n\t                    s = -s / qr[k][k];\n\t\n\t                    for (i = k; i < rows; i++) {\n\t                        X[i][j] += s * qr[i][k];\n\t                    }\n\t                }\n\t            }\n\t        }\n\t        return X;\n\t    }\n\t};\n\t\n\tmodule.exports = QrDecomposition;\n\n\n/***/ },\n/* 13 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar Matrix = __webpack_require__(6);\n\t\n\t// https://github.com/lutzroeder/Mapack/blob/master/Source/CholeskyDecomposition.cs\n\tfunction CholeskyDecomposition(value) {\n\t    if (!(this instanceof CholeskyDecomposition)) {\n\t        return new CholeskyDecomposition(value);\n\t    }\n\t    value = Matrix.checkMatrix(value);\n\t    if (!value.isSymmetric())\n\t        throw new Error('Matrix is not symmetric');\n\t\n\t    var a = value,\n\t        dimension = a.rows,\n\t        l = new Matrix(dimension, dimension),\n\t        positiveDefinite = true,\n\t        i, j, k;\n\t\n\t    for (j = 0; j < dimension; j++) {\n\t        var Lrowj = l[j];\n\t        var d = 0;\n\t        for (k = 0; k < j; k++) {\n\t            var Lrowk = l[k];\n\t            var s = 0;\n\t            for (i = 0; i < k; i++) {\n\t                s += Lrowk[i] * Lrowj[i];\n\t            }\n\t            Lrowj[k] = s = (a[j][k] - s) / l[k][k];\n\t            d = d + s * s;\n\t        }\n\t\n\t        d = a[j][j] - d;\n\t\n\t        positiveDefinite &= (d > 0);\n\t        l[j][j] = Math.sqrt(Math.max(d, 0));\n\t        for (k = j + 1; k < dimension; k++) {\n\t            l[j][k] = 0;\n\t        }\n\t    }\n\t\n\t    if (!positiveDefinite) {\n\t        throw new Error('Matrix is not positive definite');\n\t    }\n\t\n\t    this.L = l;\n\t}\n\t\n\tCholeskyDecomposition.prototype = {\n\t    get leftTriangularFactor() {\n\t        return this.L;\n\t    },\n\t    solve: function (value) {\n\t        value = Matrix.checkMatrix(value);\n\t\n\t        var l = this.L,\n\t            dimension = l.rows;\n\t\n\t        if (value.rows !== dimension) {\n\t            throw new Error('Matrix dimensions do not match');\n\t        }\n\t\n\t        var count = value.columns,\n\t            B = value.clone(),\n\t            i, j, k;\n\t\n\t        for (k = 0; k < dimension; k++) {\n\t            for (j = 0; j < count; j++) {\n\t                for (i = 0; i < k; i++) {\n\t                    B[k][j] -= B[i][j] * l[k][i];\n\t                }\n\t                B[k][j] /= l[k][k];\n\t            }\n\t        }\n\t\n\t        for (k = dimension - 1; k >= 0; k--) {\n\t            for (j = 0; j < count; j++) {\n\t                for (i = k + 1; i < dimension; i++) {\n\t                    B[k][j] -= B[i][j] * l[i][k];\n\t                }\n\t                B[k][j] /= l[k][k];\n\t            }\n\t        }\n\t\n\t        return B;\n\t    }\n\t};\n\t\n\tmodule.exports = CholeskyDecomposition;\n\n\n/***/ },\n/* 14 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/**\n\t * Created by acastillo on 8/24/15.\n\t */\n\t/**\n\t * Non in-place function definitions, compatible with mathjs code *\n\t */\n\t\n\t'use strict';\n\t\n\tvar Matrix = __webpack_require__(5);\n\t\n\tfunction matrix(A,B){\n\t    return new Matrix(A,B);\n\t}\n\t\n\tfunction ones(rows, cols){\n\t    return Matrix.ones(rows,cols);\n\t}\n\t\n\tfunction eye(rows, cols){\n\t    return Matrix.eye(rows, cols);\n\t}\n\t\n\tfunction zeros(rows, cols){\n\t    return Matrix.zeros(rows, cols);\n\t}\n\t\n\tfunction random(rows, cols){\n\t    return Matrix.rand(rows,cols);\n\t}\n\t\n\tfunction transpose(A){\n\t    if(typeof A == 'number')\n\t        return A;\n\t    var result = A.clone();\n\t    return result.transpose();\n\t}\n\t\n\tfunction add(A, B){\n\t    if(typeof A == 'number'&&typeof B === 'number')\n\t        return A+B;\n\t    if(typeof A == 'number')\n\t        return this.add(B,A);\n\t\n\t    var result = A.clone();\n\t    return result.add(B);\n\t\n\t}\n\t\n\tfunction subtract(A, B){\n\t    if(typeof A == 'number'&&typeof B === 'number')\n\t        return A-B;\n\t    if(typeof A == 'number')\n\t        return this.subtract(B,A);\n\t    var result = A.clone();\n\t    return result.sub(B);\n\t}\n\t\n\tfunction multiply(A, B){\n\t    if(typeof A == 'number'&&typeof B === 'number')\n\t        return A*B;\n\t    if(typeof A == 'number')\n\t        return this.multiply(B,A);\n\t\n\t    var result = A.clone();\n\t\n\t    if(typeof B === 'number')\n\t        result.mul(B);\n\t    else\n\t        result = result.mmul(B);\n\t\n\t    if(result.rows==1&&result.columns==1)\n\t        return result[0][0];\n\t    else\n\t        return result;\n\t\n\t}\n\t\n\tfunction dotMultiply(A, B){\n\t    var result = A.clone();\n\t    return result.mul(B);\n\t}\n\t\n\tfunction dotDivide(A, B){\n\t    var result = A.clone();\n\t    return result.div(B);\n\t}\n\t\n\tfunction diag(A){\n\t    var diag = null;\n\t    var rows = A.rows, cols = A.columns, j, r;\n\t    //It is an array\n\t    if(typeof cols === \"undefined\" && (typeof A)=='object'){\n\t        if(A[0]&&A[0].length){\n\t            rows = A.length;\n\t            cols = A[0].length;\n\t            r = Math.min(rows,cols);\n\t            diag = Matrix.zeros(cols, cols);\n\t            for (j = 0; j < cols; j++) {\n\t                diag[j][j]=A[j][j];\n\t            }\n\t        }\n\t        else{\n\t            cols = A.length;\n\t            diag = Matrix.zeros(cols, cols);\n\t            for (j = 0; j < cols; j++) {\n\t                diag[j][j]=A[j];\n\t            }\n\t        }\n\t\n\t    }\n\t    if(rows == 1){\n\t        diag = Matrix.zeros(cols, cols);\n\t        for (j = 0; j < cols; j++) {\n\t            diag[j][j]=A[0][j];\n\t        }\n\t    }\n\t    else{\n\t        if(rows>0 && cols > 0){\n\t            r = Math.min(rows,cols);\n\t            diag = new Array(r);\n\t            for (j = 0; j < r; j++) {\n\t                diag[j] = A[j][j];\n\t            }\n\t        }\n\t    }\n\t    return diag;\n\t}\n\t\n\tfunction min(A, B){\n\t    if(typeof A==='number' && typeof B ==='number')\n\t        return Math.min(A,B);\n\t    var ii = A.rows, jj = A.columns;\n\t    var result = new Matrix(ii,jj);\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            if (A[i][j] < B[i][j]) {\n\t                result[i][j] = A[i][j];\n\t            }\n\t            else{\n\t                result[i][j] = B[i][j];\n\t            }\n\t        }\n\t    }\n\t    return result;\n\t}\n\t\n\tfunction max(A, B){\n\t    if(typeof A==='number' && typeof B ==='number')\n\t        return Math.max(A,B);\n\t    var ii = A.rows, jj = A.columns;\n\t    var result = new Matrix(ii,jj);\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            if (A[i][j] > B[i][j]) {\n\t                result[i][j] = A[i][j];\n\t            }\n\t            else{\n\t                result[i][j] = B[i][j];\n\t            }\n\t        }\n\t    }\n\t    return result;\n\t}\n\t\n\tfunction sqrt(A){\n\t    if(typeof A==='number' )\n\t        return Math.sqrt(A);\n\t    var ii = A.rows, jj = A.columns;\n\t    var result = new Matrix(ii,jj);\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            result[i][j] = Math.sqrt(A[i][j]);\n\t\n\t        }\n\t    }\n\t    return result;\n\t}\n\t\n\tfunction abs(A){\n\t    if(typeof A==='number' )\n\t        return Math.abs(A);\n\t    var ii = A.rows, jj = A.columns;\n\t    var result = new Matrix(ii,jj);\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            result[i][j] = Math.abs(A[i][j]);\n\t\n\t        }\n\t    }\n\t    return result;\n\t}\n\t\n\tfunction exp(A){\n\t    if(typeof A==='number' )\n\t        return Math.sqrt(A);\n\t    var ii = A.rows, jj = A.columns;\n\t    var result = new Matrix(ii,jj);\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            result[i][j] = Math.exp(A[i][j]);\n\t        }\n\t    }\n\t    return result;\n\t}\n\t\n\tfunction dotPow(A, b){\n\t    if(typeof A==='number' )\n\t        return Math.pow(A,b);\n\t    //console.log(A);\n\t    var ii = A.rows, jj = A.columns;\n\t    var result = new Matrix(ii,jj);\n\t    for (var i = 0; i < ii; i++) {\n\t        for (var j = 0; j < jj; j++) {\n\t            result[i][j] = Math.pow(A[i][j],b);\n\t        }\n\t    }\n\t    return result;\n\t}\n\t\n\tfunction solve(A, B){\n\t    return A.solve(B);\n\t}\n\t\n\tfunction inv(A){\n\t    if(typeof A ===\"number\")\n\t        return 1/A;\n\t    return A.inverse();\n\t}\n\t\n\tmodule.exports = {\n\t    transpose:transpose,\n\t    add:add,\n\t    subtract:subtract,\n\t    multiply:multiply,\n\t    dotMultiply:dotMultiply,\n\t    dotDivide:dotDivide,\n\t    diag:diag,\n\t    min:min,\n\t    max:max,\n\t    solve:solve,\n\t    inv:inv,\n\t    sqrt:sqrt,\n\t    exp:exp,\n\t    dotPow:dotPow,\n\t    abs:abs,\n\t    matrix:matrix,\n\t    ones:ones,\n\t    zeros:zeros,\n\t    random:random,\n\t    eye:eye\n\t};\n\n\n/***/ },\n/* 15 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Opt = __webpack_require__(2);\n\t\n\tfunction gsd(x, y, options){\n\t    var options=Object.create(options || {});\n\t    if (options.minMaxRatio===undefined) options.minMaxRatio=0.00025;\n\t    if (options.broadRatio===undefined) options.broadRatio=0.00;\n\t    if (options.noiseLevel===undefined) options.noiseLevel=0;\n\t    if (options.maxCriteria===undefined) options.maxCriteria=true;\n\t    if (options.smoothY===undefined) options.smoothY=true;\n\t\n\t\n\t    if (options.noiseLevel>0) {\n\t        y=[].concat(y);\n\t        for (var i=0; i<y.length; i++){\n\t            if(Math.abs(y[i])<options.noiseLevel) {\n\t                y[i]=0;\n\t            }\n\t        }\n\t    }\n\t\n\t    // fill convolution frequency axis\n\t    var X = [];//x[2:(x.length-2)];\n\t\n\t    // fill Savitzky-Golay polynomes\n\t    var size= x.length-4;\n\t    var Y = new Array(size);\n\t    var dY = new Array(size);\n\t    var ddY = new Array(size);\n\t    //var dX = new Array(size);\n\t    var dx = x[1]-x[0];\n\t\n\t    for (var j = 2; j < size+2; j++) {\n\t        dx = x[j]-x[j-1];\n\t        if(options.smoothY)\n\t            Y[j-2]=(1/35.0)*(-3*y[j-2] + 12*y[j-1] + 17*y[j] + 12*y[j+1] - 3*y[j+2]);\n\t        else\n\t            Y[j-2]=y[j];\n\t        X[j-2]=x[j];\n\t        dY[j-2]=(1/(12*dx))*(y[j-2] - 8*y[j-1] + 8*y[j+1] - y[j+2]);\n\t        ddY[j-2]=(1/(7*dx*dx))*(2*y[j-2] - y[j-1] - 2*y[j] - y[j+1] + 2*y[j+2]);\n\t    }\n\t\n\t    var maxDdy=0;\n\t    var maxY = 0;\n\t    //console.log(Y.length);\n\t    for (var i = 0; i < Y.length ; i++){\n\t        if(Math.abs(ddY[i])>maxDdy){\n\t            maxDdy = Math.abs(ddY[i]);\n\t        }\n\t        if(Math.abs(Y[i])>maxY){\n\t            maxY = Math.abs(Y[i]);\n\t        }\n\t    }\n\t    //console.log(maxY+\"x\"+maxDy+\"x\"+maxDdy);\n\t    var minddY = [];\n\t    var intervals = [];\n\t    var lastMax = null;\n\t    var lastMin = null;\n\t    var broadMask = new Array();\n\t    //console.log(dx);\n\t    //By the intermediate value theorem We cannot find 2 consecutive maxima or minima\n\t    for (var i = 1; i < Y.length -1 ; i++){\n\t        //console.log(dY[i]);\n\t        if ((dY[i] < dY[i-1]) && (dY[i] <= dY[i+1])||\n\t            (dY[i] <= dY[i-1]) && (dY[i] < dY[i+1])) {\n\t            lastMin = X[i];\n\t            //console.log(\"min \"+lastMin);\n\t            if(dx>0&&lastMax!=null){\n\t                intervals.push( [lastMax , lastMin] );\n\t            }\n\t        }\n\t\n\t        if ((dY[i] >= dY[i-1]) && (dY[i] > dY[i+1])||\n\t            (dY[i] > dY[i-1]) && (dY[i] >= dY[i+1])) {\n\t            lastMax = X[i];\n\t            //console.log(\"max \"+lastMax);\n\t            if(dx<0&&lastMin!=null){\n\t                intervals.push( [lastMax , lastMin] );\n\t            }\n\t        }\n\t\n\t        if(options.maxCriteria){\n\t            if ((ddY[i] < ddY[i-1]) && (ddY[i] < ddY[i+1])) {\n\t                minddY.push( [X[i], Y[i], i] );  // TODO should we change this to have 3 arrays ? Huge overhead creating arrays\n\t                if(Math.abs(ddY[i])>options.broadRatio*maxDdy){ // TODO should this be a parameter =\n\t                    broadMask.push(false);\n\t                }\n\t                else{\n\t                    broadMask.push(true);\n\t                }\n\t            }\n\t        }\n\t        else{\n\t            if ((ddY[i] > ddY[i-1]) && (ddY[i] > ddY[i+1])) {\n\t                minddY.push( [X[i], Y[i], i] );  // TODO should we change this to have 3 arrays ? Huge overhead creating arrays\n\t                if(Math.abs(ddY[i])>options.broadRatio*maxDdy){ // TODO should this be a parameter =\n\t                    broadMask.push(false);\n\t                }\n\t                else{\n\t                    broadMask.push(true);\n\t                }\n\t            }\n\t        }\n\t\n\t    }\n\t    realTopDetection(minddY,X,Y);\n\t    //console.log(intervals);\n\t    //console.log(minddY);\n\t    var signals = [];\n\t\n\t    for (var j = 0; j < minddY.length; j++){\n\t        var f = minddY[j];\n\t        var frequency = f[0];\n\t        var possible = [];\n\t        for (var k=0; k<intervals.length; k++){\n\t            var i = intervals[k];\n\t            if(Math.abs(frequency-(i[0]+i[1])/2)<Math.abs(i[0]-i[1])/2)\n\t                possible.push(i);\n\t        }\n\t        //console.log(\"possible \"+possible.length);\n\t        if (possible.length > 0)\n\t            if (possible.length == 1)\n\t            {\n\t                var inter = possible[0];\n\t                var linewidth = Math.abs(inter[1] - inter[0]);\n\t                var height = f[1];\n\t                //console.log(height);\n\t                if (Math.abs(height) > options.minMaxRatio*maxY) {\n\t                    signals.push({\n\t                        x: frequency,\n\t                        y: height,\n\t                        width: linewidth//*widthCorrection\n\t                    })\n\t                }\n\t            }\n\t            else\n\t            {\n\t                //TODO: nested peaks\n\t                // console.log(\"Nested \"+possible);\n\t            }\n\t    }\n\t    if(options.broadRatio>0){\n\t        var broadLines=[[Number.MAX_VALUE,0,0]];\n\t        //Optimize the possible broad lines\n\t        var max=0, maxI=0,count=0;\n\t        var candidates = [],broadLinesS=[];\n\t        var isPartOf = false;\n\t\n\t        for(var i=broadLines.length-1;i>0;i--){\n\t            //console.log(broadLines[i][0]+\" \"+rangeX+\" \"+Math.abs(broadLines[i-1][0]-broadLines[i][0]));\n\t            if(Math.abs(broadLines[i-1][0]-broadLines[i][0])<rangeX){\n\t\n\t                candidates.push(broadLines[i]);\n\t                if(broadLines[i][1]>max){\n\t                    max = broadLines[i][1];\n\t                    maxI = i;\n\t                }\n\t                count++;\n\t            }\n\t            else{\n\t                isPartOf = true;\n\t                if(count>30){ // TODO, an options ?\n\t                    isPartOf = false;\n\t                    //for(var j=0;j<signals.length;j++){\n\t                    //    if(Math.abs(broadLines[maxI][0]-signals[j][0])<rangeX)\n\t                    //       isPartOf = true;\n\t                    //    }\n\t                    //console.log(\"Was part of \"+isPartOf);\n\t                }\n\t                if(isPartOf){\n\t                    for(var j=0;j<candidates.length;j++){\n\t                        signals.push([candidates[j][0], candidates[j][1], dx]);\n\t                    }\n\t                }\n\t                else{\n\t                    var fitted =  Opt.optimizeSingleLorentzian(candidates,{x:candidates[maxI][0],\n\t                        width:Math.abs(candidates[0][0]-candidates[candidates.length-1][0])},\n\t                        []);\n\t                    //console.log(fitted);\n\t                    signals.push([fitted[0][0],fitted[0][1],fitted[0][2]]);\n\t                }\n\t                candidates = [];\n\t                max = 0;\n\t                maxI = 0;\n\t                count = 0;\n\t            }\n\t        }\n\t    }\n\t\n\t    signals.sort(function (a, b) {\n\t        return a.x - b.x;\n\t    });\n\t\n\t\n\t    return signals;\n\t}\n\t\n\tfunction realTopDetection(peakList, x, y){\n\t    var listP = [];\n\t    var alpha, beta, gamma, p,currentPoint;\n\t    for(var j=0;j<peakList.length;j++){\n\t        currentPoint = peakList[j][2];\n\t        //The detected peak could be moved 1 or 2 unit to left or right.\n\t        if(y[currentPoint-1]>=y[currentPoint-2]\n\t            &&y[currentPoint-1]>=y[currentPoint]) {\n\t            currentPoint--;\n\t        }\n\t        else{\n\t            if(y[currentPoint+1]>=y[currentPoint]\n\t                &&y[currentPoint+1]>=y[currentPoint+2]) {\n\t                currentPoint++;\n\t            }\n\t            else{\n\t                if(y[currentPoint-2]>=y[currentPoint-3]\n\t                    &&y[currentPoint-2]>=y[currentPoint-1]) {\n\t                    currentPoint-=2;\n\t                }\n\t                else{\n\t                    if(y[currentPoint+2]>=y[currentPoint+1]\n\t                        &&y[currentPoint+2]>=y[currentPoint+3]) {\n\t                        currentPoint+=2;\n\t                    }\n\t                }\n\t            }\n\t        }\n\t        if(y[currentPoint-1]>0&&y[currentPoint+1]>0\n\t            &&y[currentPoint]>=y[currentPoint-1]\n\t            &&y[currentPoint]>=y[currentPoint+1]) {\n\t            alpha = 20 * Math.log10(y[currentPoint - 1]);\n\t            beta = 20 * Math.log10(y[currentPoint]);\n\t            gamma = 20 * Math.log10(y[currentPoint + 1]);\n\t            p = 0.5 * (alpha - gamma) / (alpha - 2 * beta + gamma);\n\t\n\t            peakList[j][0] = x[currentPoint] + (x[currentPoint]-x[currentPoint-1])*p;\n\t            peakList[j][1] = y[currentPoint] - 0.25 * (y[currentPoint - 1]\n\t                - [currentPoint + 1]) * p;//signal.peaks[j].intensity);\n\t        }\n\t    }\n\t}\n\t\n\tmodule.exports=gsd;\n\n\n/***/ }\n/******/ ])\n});\n;\n\n\n/** WEBPACK FOOTER **\n ** ml-gsd.min.js\n **/"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n/** WEBPACK FOOTER **\n ** webpack/bootstrap f1e62a1df3d56321b98b\n **/","\nmodule.exports.optimize = require(\"../src/optimize\");\nmodule.exports.gsd = require(\"../src/gsd\");\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./src/index.js\n ** module id = 0\n ** module chunks = 0\n **/","/**\n * Created by acastillo on 9/6/15.\n */\nvar Opt = require(\"ml-optimize-lorentzian\");\n\nfunction sampleFunction(from, to, x, y, lastIndex){\n    var nbPoints = x.length;\n    var sampleX = [];\n    var sampleY = [];\n    var direction = Math.sign(x[1]-x[0]);//Direction of the derivative\n    if(direction==-1){\n        lastIndex[0]= x.length-1;\n    }\n\n    var delta = Math.abs(to-from)/2;\n    var mid = (from+to)/2;\n    var stop = false;\n    var index = lastIndex[0];\n    while(!stop&&index<nbPoints&&index>=0){\n        if(Math.abs(x[index]-mid)<=delta){\n            sampleX.push(x[index]);\n            sampleY.push(y[index]);\n            index+=direction;\n        }\n        //It is outside the range.\n        else{\n\n            if(Math.sign(mid-x[index])==1){\n                //We'll reach the mid going in the current direction\n                index+=direction;\n            }\n            else{\n                //There is not more peaks in the current range\n                stop=true;\n            }\n        }\n        //console.log(sampleX);\n    }\n    lastIndex[0]=index;\n    return [sampleX, sampleY];\n}\n\nfunction optimizePeaks(peakList,x,y,n, fnType){\n    var i, j, lastIndex=[0];\n    var groups = groupPeaks(peakList,n);\n    var result = [];\n    var factor = 1;\n    if(fnType==\"gaussian\")\n        factor = 1.17741;//From https://en.wikipedia.org/wiki/Gaussian_function#Properties\n    for(i=0;i<groups.length;i++){\n        var peaks = groups[i].group;\n        if(peaks.length>1){\n            //Multiple peaks\n            //console.log(\"Pending group of overlaped peaks \"+peaks.length);\n            //console.log(\"here1\");\n            //console.log(groups[i].limits);\n            var sampling = sampleFunction(groups[i].limits[0]-groups[i].limits[1],groups[i].limits[0]+groups[i].limits[1],x,y,lastIndex);\n            //console.log(sampling);\n            if(sampling[0].length>5){\n                var error = peaks[0].width/1000;\n                var opts = [  3,    100, error, error, error, error*10, error*10,    11,    9,        1 ];\n                //var gauss = Opt.optimizeSingleGaussian(sampling[0], sampling[1], opts, peaks);\n                var optPeaks = [];\n                if(fnType==\"gaussian\")\n                    optPeaks = Opt.optimizeGaussianSum(sampling, peaks, opts);\n                else{\n                    if(fnType==\"lorentzian\"){\n                        optPeaks = Opt.optimizeLorentzianSum(sampling, peaks, opts);\n                    }\n                }\n                //console.log(optPeak);\n                for(j=0;j<optPeaks.length;j++){\n                    result.push({x:optPeaks[j][0][0],y:optPeaks[j][1][0],width:optPeaks[j][2][0]*factor});\n                }\n            }\n        }\n        else{\n            //Single peak\n            peaks = peaks[0];\n            var sampling = sampleFunction(peaks.x-n*peaks.width,\n                peaks.x+n*peaks.width,x,y,lastIndex);\n            //console.log(\"here2\");\n            //console.log(groups[i].limits);\n            if(sampling[0].length>5){\n                var error = peaks.width/1000;\n                var opts = [  3,    100, error, error, error, error*10, error*10,    11,    9,        1 ];\n                //var gauss = Opt.optimizeSingleGaussian(sampling[0], sampling[1], opts, peaks);\n                //var gauss = Opt.optimizeSingleGaussian([sampling[0],sampling[1]], peaks, opts);\n                var optPeak = [];\n                if(fnType==\"gaussian\")\n                    var optPeak = Opt.optimizeSingleGaussian([sampling[0],sampling[1]], peaks,  opts);\n                else{\n                    if(fnType==\"lorentzian\"){\n                        var optPeak = Opt.optimizeSingleLorentzian([sampling[0],sampling[1]], peaks,  opts);\n                    }\n                }\n                //console.log(optPeak);\n                result.push({x:optPeak[0][0],y:optPeak[1][0],width:optPeak[2][0]*factor}); // From https://en.wikipedia.org/wiki/Gaussian_function#Properties}\n            }\n        }\n\n    }\n    return result;\n}\n\nfunction groupPeaks(peakList,nL){\n    var group = [];\n    var groups = [];\n    var i, j;\n    var limits = [peakList[0].x,nL*peakList[0].width];\n    var upperLimit, lowerLimit;\n    //Merge forward\n    for(i=0;i<peakList.length;i++){\n        //If the 2 things overlaps\n        if(Math.abs(peakList[i].x-limits[0])<(nL*peakList[i].width+limits[1])){\n            //Add the peak to the group\n            group.push(peakList[i]);\n            //Update the group limits\n            upperLimit = limits[0]+limits[1];\n            if(peakList[i].x+nL*peakList[i].width>upperLimit){\n                upperLimit = peakList[i].x+nL*peakList[i].width;\n            }\n            lowerLimit = limits[0]-limits[1];\n            if(peakList[i].x-nL*peakList[i].width<lowerLimit){\n                lowerLimit = peakList[i].x-nL*peakList[i].width;\n            }\n            limits = [(upperLimit+lowerLimit)/2,Math.abs(upperLimit-lowerLimit)/2];\n\n        }\n        else{\n            groups.push({limits:limits,group:group});\n            //var optmimalPeak = fitSpectrum(group,limits,spectrum);\n            group=[peakList[i]];\n            limits = [peakList[i].x,nL*peakList[i].width];\n        }\n    }\n    groups.push({limits:limits,group:group});\n    //Merge backward\n    for(i =groups.length-2;i>=0;i--){\n        //The groups overlaps\n        if(Math.abs(groups[i].limits[0]-groups[i+1].limits[0])<\n            (groups[i].limits[1]+groups[i+1].limits[1])/2){\n            for(j=0;j<groups[i+1].group.length;j++){\n                groups[i].group.push(groups[i+1].group[j]);\n            }\n            upperLimit = groups[i].limits[0]+groups[i].limits[1];\n            if(groups[i+1].limits[0]+groups[i+1].limits[1]>upperLimit){\n                upperLimit = groups[i+1].limits[0]+groups[i+1].limits[1];\n            }\n            lowerLimit = groups[i].limits[0]-groups[i].limits[1];\n            if(groups[i+1].limits[0]-groups[i+1].limits[1]<lowerLimit){\n                lowerLimit = groups[i+1].limits[0]-groups[i+1].limits[1];\n            }\n            //console.log(limits);\n            groups[i].limits = [(upperLimit+lowerLimit)/2,Math.abs(upperLimit-lowerLimit)/2];\n\n            groups.splice(i+1,1);\n        }\n    }\n    return groups;\n}\n\nmodule.exports=optimizePeaks;\n\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./src/optimize.js\n ** module id = 1\n ** module chunks = 0\n **/","'use strict';\n\nvar LM = require('ml-curve-fitting');\nvar math = LM.Matrix.algebra;\nvar Matrix = require('ml-matrix');\n\n/**\n * This function calculates the spectrum as a sum of lorentzian functions. The Lorentzian\n * parameters are divided in 3 batches. 1st: centers; 2nd: heights; 3th: widths;\n * @param t Ordinate values\n * @param p Lorentzian parameters\n * @param c Constant parameters(Not used)\n * @returns {*}\n */\nfunction sumOfLorentzians(t,p,c){\n    var nL = p.length/3,factor,i, j,p2, cols = t.rows;\n    var result = Matrix.zeros(t.length,1);\n\n    for(i=0;i<nL;i++){\n        p2 = Math.pow(p[i+nL*2][0]/2,2);\n        factor = p[i+nL][0]*p2;\n        for(j=0;j<cols;j++){\n            result[j][0]+=factor/(Math.pow(t[j][0]-p[i][0],2)+p2);\n        }\n    }\n    return result;\n}\n\n/**\n * This function calculates the spectrum as a sum of gaussian functions. The Gaussian\n * parameters are divided in 3 batches. 1st: centers; 2nd: height; 3th: std's;\n * @param t Ordinate values\n * @param p Gaussian parameters\n * @param c Constant parameters(Not used)\n * @returns {*}\n */\nfunction sumOfGaussians(t,p,c){\n    var nL = p.length/3,factor,i, j, cols = t.rows;\n    var result = Matrix.zeros(t.length,1);\n\n    for(i=0;i<nL;i++){\n        factor = p[i+nL*2][0]*p[i+nL*2][0]/2;\n        for(j=0;j<cols;j++){\n            result[j][0]+=p[i+nL][0]*Math.exp(-(t[i][0]-p[i][0])*(t[i][0]-p[i][0])/factor);\n        }\n    }\n    return result;\n}\n/**\n * Single 4 parameter lorentzian function\n * @param t Ordinate values\n * @param p Lorentzian parameters\n * @param c Constant parameters(Not used)\n * @returns {*}\n */\nfunction singleLorentzian(t,p,c){\n    var factor = p[1][0]*Math.pow(p[2][0]/2,2);\n    var rows = t.rows;\n    var result = new Matrix(t.rows, t.columns);\n    for(var i=0;i<rows;i++){\n        result[i][0]=factor/(Math.pow(t[i][0]-p[0][0],2)+Math.pow(p[2][0]/2,2));\n    }\n    return result;\n}\n\n/**\n * Single 3 parameter gaussian function\n * @param t Ordinate values\n * @param p Gaussian parameters [mean, height, std]\n * @param c Constant parameters(Not used)\n * @returns {*}\n */\nfunction singleGaussian(t,p,c){\n    var factor2 = p[2][0]*p[2][0]/2;\n    var rows = t.rows;\n    var result = new Matrix(t.rows, t.columns);\n    for(var i=0;i<rows;i++){\n        result[i][0]=p[1][0]*Math.exp(-(t[i][0]-p[0][0])*(t[i][0]-p[0][0])/factor2);\n    }\n    return result;\n}\n\n/**\n * * Fits a set of points to a Lorentzian function. Returns the center of the peak, the width at half height, and the height of the signal.\n * @param data,[y]\n * @returns {*[]}\n */\nfunction optimizeSingleLorentzian(xy, peak, opts) {\n    var xy2 = parseData(xy);\n    var t = xy2[0];\n    var y_data = xy2[1];\n    var maxY = xy2[2];\n    var nbPoints = t.columns, i;\n\n    var weight = [nbPoints / Math.sqrt(y_data.dot(y_data))];\n\n    var opts=Object.create(opts || [  3,    100, 1e-3, 1e-3, 1e-3, 1e-2, 1e-2,    11,    9,        1 ]);\n    //var opts = [  3,    100, 1e-3, 1e-3, 1e-3, 1e-2, 1e-2,    11,    9,        1 ];\n    var consts = [ ];\n    var dt = Math.abs(t[0][0]-t[1][0]);// optional vector of constants\n    var dx = new Matrix([[-dt/10000],[-1e-3],[-dt/10000]]);//-Math.abs(t[0][0]-t[1][0])/100;\n    var p_init = new Matrix([[peak.x],[1],[peak.width]]);\n    var p_min = new Matrix([[peak.x-dt],[0.75],[peak.width/4]]);\n    var p_max = new Matrix([[peak.x+dt],[1.25],[peak.width*4]]);\n\n    var p_fit = LM.optimize(singleLorentzian,p_init,t,y_data,weight,dx,p_min,p_max,consts,opts);\n\n\n    p_fit = p_fit.p;\n    return [p_fit[0],[p_fit[1][0]*maxY],p_fit[2]];\n\n}\n\n/**\n * Fits a set of points to a gaussian bell. Returns the mean of the peak, the std and the height of the signal.\n * @param data,[y]\n * @returns {*[]}\n */\nfunction optimizeSingleGaussian(xy, peak, opts) {\n    var xy2 = parseData(xy);\n    var t = xy2[0];\n    var y_data = xy2[1];\n    var maxY = xy2[2];\n\n    var nbPoints = t.columns, i;\n\n    var weight = [nbPoints / Math.sqrt(y_data.dot(y_data))];\n\n    var opts=Object.create(opts || [  3,    100, 1e-3, 1e-3, 1e-3, 1e-2, 1e-2,    11,    9,        1 ]);\n    //var opts = [  3,    100, 1e-3, 1e-3, 1e-3, 1e-2, 1e-2,    11,    9,        1 ];\n    var consts = [ ];                         // optional vector of constants\n    var dt = Math.abs(t[0][0]-t[1][0]);\n    var dx = new Matrix([[-dt/10000],[-1e-3],[-dt/10000]]);//-Math.abs(t[0][0]-t[1][0])/100;\n\n    var dx = new Matrix([[-Math.abs(t[0][0]-t[1][0])/1000],[-1e-3],[-peak.width/1000]]);\n    var p_init = new Matrix([[peak.x],[1],[peak.width]]);\n    var p_min = new Matrix([[peak.x-dt],[0.75],[peak.width/4]]);\n    var p_max = new Matrix([[peak.x+dt],[1.25],[peak.width*4]]);\n    //var p_min = new Matrix([[peak.x-peak.width/4],[0.75],[peak.width/3]]);\n    //var p_max = new Matrix([[peak.x+peak.width/4],[1.25],[peak.width*3]]);\n\n    var p_fit = LM.optimize(singleGaussian,p_init,t,y_data,weight,dx,p_min,p_max,consts,opts);\n    p_fit = p_fit.p;\n    return [p_fit[0],[p_fit[1][0]*maxY],p_fit[2]];\n}\n\n\n/**\n *\n * @param xy A two column matrix containing the x and y data to be fitted\n * @param group A set of initial lorentzian parameters to be optimized [center, heigth, half_width_at_half_height]\n * @returns {Array} A set of final lorentzian parameters [center, heigth, hwhh*2]\n */\nfunction optimizeLorentzianSum(xy, group, opts){\n    var xy2 = parseData(xy);\n    var t = xy2[0];\n    var y_data = xy2[1];\n    var maxY = xy2[2];\n    var nbPoints = t.columns, i;\n\n    var weight = [nbPoints / math.sqrt(y_data.dot(y_data))];\n    var opts=Object.create(opts || [  3,    100, 1e-3, 1e-3, 1e-3, 1e-2, 1e-2,    11,    9,        1 ]);\n    var consts = [ ];// optional vector of constants\n\n    var nL = group.length;\n    var p_init = new Matrix(nL*3,1);\n    var p_min =  new Matrix(nL*3,1);\n    var p_max =  new Matrix(nL*3,1);\n    var dx = new Matrix(nL*3,1);\n    var dt = Math.abs(t[0][0]-t[1][0]);\n    for( i=0;i<nL;i++){\n        p_init[i][0] = group[i].x;\n        p_init[i+nL][0] = 1;\n        p_init[i+2*nL][0] = group[i].width;\n\n        p_min[i][0] = group[i].x-dt;//-group[i].width/4;\n        p_min[i+nL][0] = 0;\n        p_min[i+2*nL][0] = group[i].width/4;\n\n        p_max[i][0] = group[i].x+dt;//+group[i].width/4;\n        p_max[i+nL][0] = 1.5;\n        p_max[i+2*nL][0] = group[i].width*4;\n\n        dx[i][0] = -dt/1000;\n        dx[i+nL][0] = -1e-3;\n        dx[i+2*nL][0] = -dt/1000;\n    }\n\n    var dx = -Math.abs(t[0][0]-t[1][0])/10000;\n    var p_fit = LM.optimize(sumOfLorentzians, p_init, t, y_data, weight, dx, p_min, p_max, consts, opts);\n    p_fit=p_fit.p;\n    //Put back the result in the correct format\n    var result = new Array(nL);\n    for( i=0;i<nL;i++){\n        result[i]=[p_fit[i],[p_fit[i+nL][0]*maxY],p_fit[i+2*nL]];\n    }\n\n    return result;\n\n}\n\n/**\n *\n * @param xy A two column matrix containing the x and y data to be fitted\n * @param group A set of initial lorentzian parameters to be optimized [center, heigth, half_width_at_half_height]\n * @returns {Array} A set of final lorentzian parameters [center, heigth, hwhh*2]\n */\nfunction optimizeGaussianSum(xy, group, opts){\n    var xy2 = parseData(xy);\n    var t = xy2[0];\n    var y_data = xy2[1];\n    var maxY = xy2[2];\n    var nbPoints = t.rows,i;\n\n    var weight = new Matrix(nbPoints,1);//[nbPoints / math.sqrt(y_data.dot(y_data))];\n    var k = nbPoints / math.sqrt(y_data.dot(y_data));\n    for(i=0;i<nbPoints;i++){\n        weight[i][0]=k;///(y_data[i][0]);\n        //weight[i][0]=k*(2-y_data[i][0]);\n    }\n\n    var opts=Object.create(opts || [  3,    100, 1e-3, 1e-3, 1e-3, 1e-2, 1e-2,    11,    9,        2 ]);\n    //var opts=[  3,    100, 1e-5, 1e-6, 1e-6, 1e-6, 1e-6,    11,    9,        1 ];\n    var consts = [ ];// optional vector of constants\n\n    var nL = group.length;\n    var p_init = new Matrix(nL*3,1);\n    var p_min =  new Matrix(nL*3,1);\n    var p_max =  new Matrix(nL*3,1);\n    var dx = new Matrix(nL*3,1);\n    var dt = Math.abs(t[0][0]-t[1][0]);\n    for( i=0;i<nL;i++){\n        p_init[i][0] = group[i].x;\n        p_init[i+nL][0] = group[i].y/maxY;\n        p_init[i+2*nL][0] = group[i].width;\n\n        p_min[i][0] = group[i].x-dt;\n        p_min[i+nL][0] = group[i].y*0.8/maxY;\n        p_min[i+2*nL][0] = group[i].width/2;\n\n        p_max[i][0] = group[i].x+dt;\n        p_max[i+nL][0] = group[i].y*1.2/maxY;\n        p_max[i+2*nL][0] = group[i].width*2;\n\n        dx[i][0] = -dt/1000;\n        dx[i+nL][0] = -1e-3;\n        dx[i+2*nL][0] = -dt/1000;\n    }\n    //console.log(t);\n    var p_fit = LM.optimize(sumOfLorentzians,p_init,t,y_data,weight,dx,p_min,p_max,consts,opts);\n    p_fit = p_fit.p;\n    //Put back the result in the correct format\n    var result = new Array(nL);\n    for( i=0;i<nL;i++){\n        result[i]=[p_fit[i],[p_fit[i+nL][0]*maxY],p_fit[i+2*nL]];\n    }\n\n    return result;\n\n}\n/**\n *\n * Converts the given input to the required x, y column matrices. y data is normalized to max(y)=1\n * @param xy\n * @returns {*[]}\n */\nfunction parseData(xy){\n    var nbSeries = xy.length;\n    var t = null;\n    var y_data = null, x,y;\n    var maxY = 0, i,j;\n\n    if(nbSeries==2){\n        //Looks like row wise matrix [x,y]\n        var nbPoints = xy[0].length;\n        if(nbPoints<3)\n            throw new SizeException(nbPoints);\n        else{\n            t = new Matrix(nbPoints,1);\n            y_data = new Matrix(nbPoints,1);\n            x = xy[0];\n            y = xy[1];\n            if(typeof x[0] === \"number\"){\n                for(i=0;i<nbPoints;i++){\n                    t[i][0]=x[i];\n                    y_data[i][0]=y[i];\n                    if(y[i]>maxY)\n                        maxY = y[i];\n                }\n            }\n            else{\n                //It is a colum matrix\n                if(typeof x[0] === \"object\"){\n                    for(i=0;i<nbPoints;i++){\n                        t[i][0]=x[i][0];\n                        y_data[i][0]=y[i][0];\n                        if(y[i][0]>maxY)\n                            maxY = y[i][0];\n                    }\n                }\n\n            }\n\n        }\n    }\n    else{\n        //Looks like a column wise matrix [[x],[y]]\n        var nbPoints = nbSeries;\n        if(nbPoints<3)\n            throw new SizeException(nbPoints);\n        else {\n            t = new Matrix(nbPoints, 1);\n            y_data = new Matrix(nbPoints, 1);\n            for (i = 0; i < nbPoints; i++) {\n                t[i][0] = xy[i][0];\n                y_data[i][0] = xy[i][1];\n                if(y_data[i][0]>maxY)\n                    maxY = y_data[i][0];\n            }\n        }\n    }\n    for (i = 0; i < nbPoints; i++) {\n        y_data[i][0]/=maxY;\n    }\n    return [t,y_data,maxY];\n}\n\nfunction sizeException(nbPoints) {\n    return new RangeError(\"Not enough points to perform the optimization: \"+nbPoints +\"< 3\");\n}\n\nmodule.exports.optimizeSingleLorentzian = optimizeSingleLorentzian;\nmodule.exports.optimizeLorentzianSum = optimizeLorentzianSum;\nmodule.exports.optimizeSingleGaussian = optimizeSingleGaussian;\nmodule.exports.optimizeGaussianSum = optimizeGaussianSum;\nmodule.exports.singleGaussian = singleGaussian;\nmodule.exports.singleLorentzian = singleLorentzian;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/ml-optimize-lorentzian/src/index.js\n ** module id = 2\n ** module chunks = 0\n **/","'use strict';\n\nmodule.exports = require('./LM');\nmodule.exports.Matrix = require('ml-matrix');\nmodule.exports.Matrix.algebra = require('./algebra');\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/ml-curve-fitting/src/index.js\n ** module id = 3\n ** module chunks = 0\n **/","/**\n * Created by acastillo on 8/5/15.\n */\nvar Matrix = require(\"ml-matrix\");\nvar math = require(\"./algebra\");\n\nvar DEBUG = false;\n/** Levenberg Marquardt curve-fitting: minimize sum of weighted squared residuals\n ----------  INPUT  VARIABLES  -----------\n func   = function of n independent variables, 't', and m parameters, 'p',\n returning the simulated model: y_hat = func(t,p,c)\n p      = n-vector of initial guess of parameter values\n t      = m-vectors or matrix of independent variables (used as arg to func)\n y_dat  = m-vectors or matrix of data to be fit by func(t,p)\n weight = weighting vector for least squares fit ( weight >= 0 ) ...\n inverse of the standard measurement errors\n Default:  sqrt(d.o.f. / ( y_dat' * y_dat ))\n dp     = fractional increment of 'p' for numerical derivatives\n dp(j)>0 central differences calculated\n dp(j)<0 one sided 'backwards' differences calculated\n dp(j)=0 sets corresponding partials to zero; i.e. holds p(j) fixed\n Default:  0.001;\n p_min  = n-vector of lower bounds for parameter values\n p_max  = n-vector of upper bounds for parameter values\n c      = an optional matrix of values passed to func(t,p,c)\n opts   = vector of algorithmic parameters\n parameter    defaults    meaning\n opts(1)  =  prnt            3        >1 intermediate results; >2 plots\n opts(2)  =  MaxIter      10*Npar     maximum number of iterations\n opts(3)  =  epsilon_1       1e-3     convergence tolerance for gradient\n opts(4)  =  epsilon_2       1e-3     convergence tolerance for parameters\n opts(5)  =  epsilon_3       1e-3     convergence tolerance for Chi-square\n opts(6)  =  epsilon_4       1e-2     determines acceptance of a L-M step\n opts(7)  =  lambda_0        1e-2     initial value of L-M paramter\n opts(8)  =  lambda_UP_fac   11       factor for increasing lambda\n opts(9)  =  lambda_DN_fac    9       factor for decreasing lambda\n opts(10) =  Update_Type      1       1: Levenberg-Marquardt lambda update\n 2: Quadratic update\n 3: Nielsen's lambda update equations\n\n ----------  OUTPUT  VARIABLES  -----------\n p       = least-squares optimal estimate of the parameter values\n X2      = Chi squared criteria\n sigma_p = asymptotic standard error of the parameters\n sigma_y = asymptotic standard error of the curve-fit\n corr    = correlation matrix of the parameters\n R_sq    = R-squared cofficient of multiple determination\n cvg_hst = convergence history\n\n Henri Gavin, Dept. Civil & Environ. Engineering, Duke Univ. 22 Sep 2013\n modified from: http://octave.sourceforge.net/optim/function/leasqr.html\n using references by\n Press, et al., Numerical Recipes, Cambridge Univ. Press, 1992, Chapter 15.\n Sam Roweis       http://www.cs.toronto.edu/~roweis/notes/lm.pdf\n Manolis Lourakis http://www.ics.forth.gr/~lourakis/levmar/levmar.pdf\n Hans Nielson     http://www2.imm.dtu.dk/~hbn/publ/TR9905.ps\n Mathworks        optimization toolbox reference manual\n K. Madsen, H.B., Nielsen, and O. Tingleff\n http://www2.imm.dtu.dk/pubdb/views/edoc_download.php/3215/pdf/imm3215.pdf\n */\nvar LM = {\n\n    optimize: function(func,p,t,y_dat,weight,dp,p_min,p_max,c,opts){\n\n        var tensor_parameter = 0;\t\t\t// set to 1 of parameter is a tensor\n\n        var iteration  = 0;\t\t\t// iteration counter\n        //func_calls = 0;\t\t\t// running count of function evaluations\n\n        if((typeof p[0])!=\"object\"){\n            for(var i=0;i< p.length;i++){\n                p[i]=[p[i]];\n            }\n\n        }\n        //p = p(:); y_dat = y_dat(:);\t\t// make column vectors\n        var i,k;\n        var eps = 2^-52;\n        var Npar   = p.length;//length(p); \t\t\t// number of parameters\n        var Npnt   = y_dat.length;//length(y_dat);\t\t// number of data points\n        var p_old  = Matrix.zeros(Npar,1);\t\t// previous set of parameters\n        var y_old  = Matrix.zeros(Npnt,1);\t\t// previous model, y_old = y_hat(t;p_old)\n        var X2     = 1e-2/eps;\t\t\t// a really big initial Chi-sq value\n        var X2_old = 1e-2/eps;\t\t\t// a really big initial Chi-sq value\n        var J =  Matrix.zeros(Npnt,Npar);\n\n\n        if (t.length != y_dat.length) {\n            console.log('lm.m error: the length of t must equal the length of y_dat');\n\n            length_t = t.length;\n            length_y_dat = y_dat.length;\n            var X2 = 0, corr = 0, sigma_p = 0, sigma_y = 0, R_sq = 0, cvg_hist = 0;\n            if (!tensor_parameter) {\n                return;\n            }\n        }\n\n        weight = weight||Math.sqrt((Npnt-Npar+1)/(math.multiply(math.transpose(y_dat),y_dat)));\n        dp = dp || 0.001;\n        p_min   = p_min || math.multiply(Math.abs(p),-100);\n        p_max   = p_max || math.multiply(Math.abs(p),100);\n        c = c || 1;\n        // Algorithmic Paramters\n        //prnt MaxIter  eps1  eps2  epx3  eps4  lam0  lamUP lamDN UpdateType\n        opts = opts ||[  3,10*Npar, 1e-3, 1e-3, 1e-3, 1e-2, 1e-2, 11, 9, 1 ];\n\n        var prnt          = opts[0];\t// >1 intermediate results; >2 plots\n        var MaxIter       = opts[1];\t// maximum number of iterations\n        var epsilon_1     = opts[2];\t// convergence tolerance for gradient\n        var epsilon_2     = opts[3];\t// convergence tolerance for parameter\n        var epsilon_3     = opts[4];\t// convergence tolerance for Chi-square\n        var epsilon_4     = opts[5];\t// determines acceptance of a L-M step\n        var lambda_0      = opts[6];\t// initial value of damping paramter, lambda\n        var lambda_UP_fac = opts[7];\t// factor for increasing lambda\n        var lambda_DN_fac = opts[8];\t// factor for decreasing lambda\n        var Update_Type   = opts[9];\t// 1: Levenberg-Marquardt lambda update\n        // 2: Quadratic update\n        // 3: Nielsen's lambda update equations\n\n        if ( tensor_parameter && prnt == 3 ) prnt = 2;\n\n\n        if(!dp.length || dp.length == 1){\n            var dp_array = new Array(Npar);\n            for(var i=0;i<Npar;i++)\n                dp_array[i]=[dp];\n            dp=dp_array;\n        }\n\n        // indices of the parameters to be fit\n        var idx   = [];\n        for(i=0;i<dp.length;i++){\n            if(dp[i][0]!=0){\n                idx.push(i);\n            }\n        }\n\n        var Nfit = idx.length;\t\t\t// number of parameters to fit\n        var stop = false;\t\t\t\t// termination flag\n\n        var weight_sq = null;\n        //console.log(weight);\n        if ( !weight.length || weight.length < Npnt )\t{\n            // squared weighting vector\n            //weight_sq = ( weight(1)*ones(Npnt,1) ).^2;\n            //console.log(\"weight[0] \"+typeof weight[0]);\n            var tmp = math.multiply(Matrix.ones(Npnt,1),weight[0]);\n            weight_sq = math.dotMultiply(tmp,tmp);\n        }\n        else{\n            //weight_sq = (weight(:)).^2;\n            weight_sq = math.dotMultiply(weight,weight);\n        }\n\n\n        // initialize Jacobian with finite difference calculation\n        //console.log(\"J \"+weight_sq);\n        var result = this.lm_matx(func,t,p_old,y_old,1,J,p,y_dat,weight_sq,dp,c);\n        var JtWJ = result.JtWJ,JtWdy=result.JtWdy,X2=result.Chi_sq,y_hat=result.y_hat,J=result.J;\n        //[JtWJ,JtWdy,X2,y_hat,J] = this.lm_matx(func,t,p_old,y_old,1,J,p,y_dat,weight_sq,dp,c);\n        //console.log(JtWJ);\n\n        if ( Math.max(Math.abs(JtWdy)) < epsilon_1 ){\n            console.log(' *** Your Initial Guess is Extremely Close to Optimal ***')\n            console.log(' *** epsilon_1 = ', epsilon_1);\n            stop = true;\n        }\n\n\n        switch(Update_Type){\n            case 1: // Marquardt: init'l lambda\n                lambda  = lambda_0;\n                break;\n            default:    // Quadratic and Nielsen\n                lambda  = lambda_0 * Math.max(math.diag(JtWJ));\n                nu=2;\n        }\n        //console.log(X2);\n        X2_old = X2; // previous value of X2\n        //console.log(MaxIter+\" \"+Npar);\n        //var cvg_hst = Matrix.ones(MaxIter,Npar+3);\t\t// initialize convergence history\n        var h = null;\n        while ( !stop && iteration <= MaxIter ) {\t\t// --- Main Loop\n            iteration = iteration + 1;\n            // incremental change in parameters\n            switch(Update_Type){\n                case 1:\t\t\t\t\t// Marquardt\n                    //h = ( JtWJ + lambda * math.diag(math.diag(JtWJ)) ) \\ JtWdy;\n                    //h = math.multiply(math.inv(JtWdy),math.add(JtWJ,math.multiply(lambda,math.diag(math.diag(Npar)))));\n                    h = math.solve(math.add(JtWJ,math.multiply(math.diag(math.diag(JtWJ)),lambda)),JtWdy);\n                    break;\n                default:\t\t\t\t\t// Quadratic and Nielsen\n                    //h = ( JtWJ + lambda * math.eye(Npar) ) \\ JtWdy;\n\n                    h = math.solve(math.add(JtWJ,math.multiply( Matrix.eye(Npar),lambda)),JtWdy);\n            }\n\n            /*for(var k=0;k< h.length;k++){\n             h[k]=[h[k]];\n             }*/\n            //console.log(\"h \"+h);\n            //h=math.matrix(h);\n            //  big = max(abs(h./p)) > 2;\n            //this is a big step\n            // --- Are parameters [p+h] much better than [p] ?\n            var hidx = new Array(idx.length);\n            for(k=0;k<idx.length;k++){\n                hidx[k]=h[idx[k]];\n            }\n            var p_try = math.add(p, hidx);// update the [idx] elements\n\n            for(k=0;k<p_try.length;k++){\n                p_try[k][0]=Math.min(Math.max(p_min[k][0],p_try[k][0]),p_max[k][0]);\n            }\n            // p_try = Math.min(Math.max(p_min,p_try),p_max);           // apply constraints\n\n            var delta_y = math.subtract(y_dat, func(t,p_try,c));       // residual error using p_try\n            //func_calls = func_calls + 1;\n            //X2_try = delta_y' * ( delta_y .* weight_sq );  // Chi-squared error criteria\n\n            var X2_try = math.multiply(math.transpose(delta_y),math.dotMultiply(delta_y,weight_sq));\n\n            if ( Update_Type == 2 ){  \t\t\t  // Quadratic\n                //    One step of quadratic line update in the h direction for minimum X2\n                //var alpha =  JtWdy'*h / ( (X2_try - X2)/2 + 2*JtWdy'*h ) ;\n                var JtWdy_th = math.multiply(math.transpose(JtWdy),h);\n                var alpha =  math.multiply(JtWdy_th,math.inv(math.add(math.multiply(math.subtract(X2_try - X2),1/2)),math.multiply(JtWdy_th,2)));//JtWdy'*h / ( (X2_try - X2)/2 + 2*JtWdy'*h ) ;\n\n                h = math.multiply(alpha, h);\n                for(var k=0;k<idx.length;k++){\n                    hidx[k]=h[idx[k]];\n                }\n\n                p_try = math.add(p ,hidx);                     // update only [idx] elements\n                p_try = math.min(math.max(p_min,p_try),p_max);          // apply constraints\n\n                delta_y = math.subtract(y_dat, func(t,p_try,c));      // residual error using p_try\n                // func_calls = func_calls + 1;\n                //X2_try = delta_y' * ( delta_y .* weight_sq ); // Chi-squared error criteria\n                X2_try = math.multiply(math.transpose(delta_y), mat.dotMultiply(delta_y, weight_sq));\n            }\n\n            //rho = (X2 - X2_try) / ( 2*h' * (lambda * h + JtWdy) ); // Nielsen\n            var rho = (X2-X2_try)/math.multiply(math.multiply(math.transpose(h),2),math.add(math.multiply(lambda, h),JtWdy));\n            //console.log(\"rho \"+rho);\n            if ( rho > epsilon_4 ) {\t\t// it IS significantly better\n                //console.log(\"Here\");\n                dX2 = X2 - X2_old;\n                X2_old = X2;\n                p_old = p;\n                y_old = y_hat;\n                p = p_try;\t\t\t// accept p_try\n\n                result = this.lm_matx(func, t, p_old, y_old, dX2, J, p, y_dat, weight_sq, dp, c);\n                JtWJ = result.JtWJ,JtWdy=result.JtWdy,X2=result.Chi_sq,y_hat=result.y_hat,J=result.J;\n                // decrease lambda ==> Gauss-Newton method\n\n                switch (Update_Type) {\n                    case 1:\t\t\t\t\t\t\t// Levenberg\n                        lambda = Math.max(lambda / lambda_DN_fac, 1.e-7);\n                        break;\n                    case 2:\t\t\t\t\t\t\t// Quadratic\n                        lambda = Math.max(lambda / (1 + alpha), 1.e-7);\n                        break;\n                    case 3:\t\t\t\t\t\t\t// Nielsen\n                        lambda = math.multiply(Math.max(1 / 3, 1 - (2 * rho - 1) ^ 3),lambda);\n                        nu = 2;\n                        break;\n                }\n            }\n            else {\t\t\t\t\t// it IS NOT better\n                X2 = X2_old;\t\t\t// do not accept p_try\n                if (iteration%(2 * Npar)==0) {\t// rank-1 update of Jacobian\n                    result = this.lm_matx(func, t, p_old, y_old, -1, J, p, y_dat, weight_sq, dp, c);\n                    JtWJ = result.JtWJ,JtWdy=result.JtWdy,dX2=result.Chi_sq,y_hat=result.y_hat,J=result.J;\n                }\n\n                // increase lambda  ==> gradient descent method\n                switch (Update_Type) {\n                    case 1:\t\t\t\t\t\t\t// Levenberg\n                        lambda = Math.min(lambda * lambda_UP_fac, 1.e7);\n                        break;\n                    case 2:\t\t\t\t\t\t\t// Quadratic\n                        lambda = lambda + Math.abs((X2_try - X2) / 2 / alpha);\n                        break;\n                    case 3:\t\t\t\t\t\t// Nielsen\n                        lambda = lambda * nu;\n                        nu = 2 * nu;\n                        break;\n                }\n            }\n        }// --- End of Main Loop\n\n        // --- convergence achieved, find covariance and confidence intervals\n\n        // equal weights for paramter error analysis\n        weight_sq = math.multiply(math.multiply(math.transpose(delta_y),delta_y), Matrix.ones(Npnt,1));\n\n        weight_sq.apply(function(i,j){\n            weight_sq[i][j] = (Npnt-Nfit+1)/weight_sq[i][j];\n        });\n        //console.log(weight_sq);\n        result = this.lm_matx(func,t,p_old,y_old,-1,J,p,y_dat,weight_sq,dp,c);\n        JtWJ = result.JtWJ,JtWdy=result.JtWdy,X2=result.Chi_sq,y_hat=result.y_hat,J=result.J;\n\n        /*if nargout > 2\t\t\t\t// standard error of parameters\n         covar = inv(JtWJ);\n         sigma_p = sqrt(diag(covar));\n         end\n\n         if nargout > 3\t\t\t\t// standard error of the fit\n         //  sigma_y = sqrt(diag(J * covar * J'));\t// slower version of below\n         sigma_y = zeros(Npnt,1);\n         for i=1:Npnt\n         sigma_y(i) = J(i,:) * covar * J(i,:)';\n         end\n         sigma_y = sqrt(sigma_y);\n         end\n\n         if nargout > 4\t\t\t\t// parameter correlation matrix\n         corr = covar ./ [sigma_p*sigma_p'];\n         end\n\n         if nargout > 5\t\t\t\t// coefficient of multiple determination\n         R_sq = corrcoef([y_dat y_hat]);\n         R_sq = R_sq(1,2).^2;\n         end\n\n         if nargout > 6\t\t\t\t// convergence history\n         cvg_hst = cvg_hst(1:iteration,:);\n         end*/\n\n        // endfunction  # ---------------------------------------------------------- LM\n\n        return { p:p, X2:X2};\n    },\n\n    lm_FD_J:function(func,t,p,y,dp,c) {\n        // J = lm_FD_J(func,t,p,y,{dp},{c})\n        //\n        // partial derivatives (Jacobian) dy/dp for use with lm.m\n        // computed via Finite Differences\n        // Requires n or 2n function evaluations, n = number of nonzero values of dp\n        // -------- INPUT VARIABLES ---------\n        // func = function of independent variables, 't', and parameters, 'p',\n        //        returning the simulated model: y_hat = func(t,p,c)\n        // t  = m-vector of independent variables (used as arg to func)\n        // p  = n-vector of current parameter values\n        // y  = func(t,p,c) n-vector initialised by user before each call to lm_FD_J\n        // dp = fractional increment of p for numerical derivatives\n        //      dp(j)>0 central differences calculated\n        //      dp(j)<0 one sided differences calculated\n        //      dp(j)=0 sets corresponding partials to zero; i.e. holds p(j) fixed\n        //      Default:  0.001;\n        // c  = optional vector of constants passed to y_hat = func(t,p,c)\n        //---------- OUTPUT VARIABLES -------\n        // J  = Jacobian Matrix J(i,j)=dy(i)/dp(j)\ti=1:n; j=1:m\n\n        //   Henri Gavin, Dept. Civil & Environ. Engineering, Duke Univ. November 2005\n        //   modified from: ftp://fly.cnuce.cnr.it/pub/software/octave/leasqr/\n        //   Press, et al., Numerical Recipes, Cambridge Univ. Press, 1992, Chapter 15.\n\n        var m = y.length;\t\t\t// number of data points\n        var n = p.length;\t\t\t// number of parameters\n\n        dp = dp || math.multiply( Matrix.ones(n, 1), 0.001);\n\n        var ps = p.clone();//JSON.parse(JSON.stringify(p));\n        //var ps = $.extend(true, [], p);\n        var J = new Matrix(m,n), del =new Array(n);         // initialize Jacobian to Zero\n\n        for (var j = 0;j < n; j++) {\n            //console.log(j+\" \"+dp[j]+\" \"+p[j]+\" \"+ps[j]+\" \"+del[j]);\n            del[j] = dp[j]*(1+Math.abs(p[j][0]));  // parameter perturbation\n            p[j] = [ps[j][0]+del[j]];\t      // perturb parameter p(j)\n            //console.log(j+\" \"+dp[j]+\" \"+p[j]+\" \"+ps[j]+\" \"+del[j]);\n\n            if (del[j] != 0){\n                y1 = func(t, p, c);\n                //func_calls = func_calls + 1;\n                if (dp[j][0] < 0) {\t\t// backwards difference\n                    //J(:,j) = math.dotDivide(math.subtract(y1, y),del[j]);//. / del[j];\n                    //console.log(del[j]);\n                    //console.log(y);\n                    var column = math.dotDivide(math.subtract(y1, y),del[j]);\n                    for(var k=0;k< m;k++){\n                        J[k][j]=column[k][0];\n                    }\n                    //console.log(column);\n                }\n                else{\n                    p[j][0] = ps[j][0] - del[j];\n                    //J(:,j) = (y1 - feval(func, t, p, c)). / (2. * del[j]);\n                    var column = math.dotDivide(math.subtract(y1,func(t,p,c)),2*del[j]);\n                    for(var k=0;k< m;k++){\n                        J[k][j]=column[k][0];\n                    }\n\n                }\t\t\t// central difference, additional func call\n            }\n\n            p[j] = ps[j];\t\t// restore p(j)\n\n        }\n        //console.log(\"lm_FD_J: \"+ JSON.stringify(J));\n        return J;\n\n    },\n\n    // endfunction # -------------------------------------------------- LM_FD_J\n    lm_Broyden_J: function(p_old,y_old,J,p,y){\n        // J = lm_Broyden_J(p_old,y_old,J,p,y)\n        // carry out a rank-1 update to the Jacobian matrix using Broyden's equation\n        //---------- INPUT VARIABLES -------\n        // p_old = previous set of parameters\n        // y_old = model evaluation at previous set of parameters, y_hat(t;p_old)\n        // J  = current version of the Jacobian matrix\n        // p     = current  set of parameters\n        // y     = model evaluation at current  set of parameters, y_hat(t;p)\n        //---------- OUTPUT VARIABLES -------\n        // J = rank-1 update to Jacobian Matrix J(i,j)=dy(i)/dp(j)\ti=1:n; j=1:m\n        //console.log(p+\" X \"+ p_old)\n        var h  = math.subtract(p, p_old);\n\n        //console.log(\"hhh \"+h);\n        var h_t = math.transpose(h);\n        h_t.div(math.multiply(h_t,h));\n\n        //console.log(h_t);\n        //J = J + ( y - y_old - J*h )*h' / (h'*h);\t// Broyden rank-1 update eq'n\n        J = math.add(J, math.multiply(math.subtract(y, math.add(y_old,math.multiply(J,h))),h_t));\n        return J;\n        // endfunction # ---------------------------------------------- LM_Broyden_J\n    },\n\n    lm_matx : function (func,t,p_old,y_old,dX2,J,p,y_dat,weight_sq,dp,c,iteration){\n        // [JtWJ,JtWdy,Chi_sq,y_hat,J] = this.lm_matx(func,t,p_old,y_old,dX2,J,p,y_dat,weight_sq,{da},{c})\n        //\n        // Evaluate the linearized fitting matrix, JtWJ, and vector JtWdy,\n        // and calculate the Chi-squared error function, Chi_sq\n        // Used by Levenberg-Marquard algorithm, lm.m\n        // -------- INPUT VARIABLES ---------\n        // func   = function ofpn independent variables, p, and m parameters, p,\n        //         returning the simulated model: y_hat = func(t,p,c)\n        // t      = m-vectors or matrix of independent variables (used as arg to func)\n        // p_old  = n-vector of previous parameter values\n        // y_old  = m-vector of previous model ... y_old = y_hat(t;p_old);\n        // dX2    = previous change in Chi-squared criteria\n        // J   = m-by-n Jacobian of model, y_hat, with respect to parameters, p\n        // p      = n-vector of current  parameter values\n        // y_dat  = n-vector of data to be fit by func(t,p,c)\n        // weight_sq = square of the weighting vector for least squares fit ...\n        //\t    inverse of the standard measurement errors\n        // dp     = fractional increment of 'p' for numerical derivatives\n        //          dp(j)>0 central differences calculated\n        //          dp(j)<0 one sided differences calculated\n        //          dp(j)=0 sets corresponding partials to zero; i.e. holds p(j) fixed\n        //          Default:  0.001;\n        // c      = optional vector of constants passed to y_hat = func(t,p,c)\n        //---------- OUTPUT VARIABLES -------\n        // JtWJ\t = linearized Hessian matrix (inverse of covariance matrix)\n        // JtWdy   = linearized fitting vector\n        // Chi_sq = Chi-squared criteria: weighted sum of the squared residuals WSSR\n        // y_hat  = model evaluated with parameters 'p'\n        // J   = m-by-n Jacobian of model, y_hat, with respect to parameters, p\n\n        //   Henri Gavin, Dept. Civil & Environ. Engineering, Duke Univ. November 2005\n        //   modified from: ftp://fly.cnuce.cnr.it/pub/software/octave/leasqr/\n        //   Press, et al., Numerical Recipes, Cambridge Univ. Press, 1992, Chapter 15.\n\n\n        var Npnt = y_dat.length;\t\t// number of data points\n        var Npar = p.length;\t\t// number of parameters\n\n        dp = dp || 0.001;\n\n\n        //var JtWJ = new Matrix.zeros(Npar);\n        //var JtWdy  = new Matrix.zeros(Npar,1);\n\n        var y_hat = func(t,p,c);\t// evaluate model using parameters 'p'\n        //func_calls = func_calls + 1;\n        //console.log(J);\n        if ( (iteration%(2*Npar))==0 || dX2 > 0 ) {\n            //console.log(\"Par\");\n            J = this.lm_FD_J(func, t, p, y_hat, dp, c);\t\t// finite difference\n        }\n        else{\n            //console.log(\"ImPar\");\n            J = this.lm_Broyden_J(p_old, y_old, J, p, y_hat); // rank-1 update\n        }\n        var delta_y = math.subtract(y_dat, y_hat);\t// residual error between model and data\n        //console.log(delta_y[0][0]);\n        //console.log(delta_y.rows+\" \"+delta_y.columns+\" \"+JSON.stringify(weight_sq));\n        //var Chi_sq = delta_y' * ( delta_y .* weight_sq ); \t// Chi-squared error criteria\n        var Chi_sq = math.multiply(math.transpose(delta_y),math.dotMultiply(delta_y,weight_sq));\n        //JtWJ  = J' * ( J .* ( weight_sq * ones(1,Npar) ) );\n        var Jt = math.transpose(J);\n\n        //console.log(weight_sq);\n\n        var JtWJ = math.multiply(Jt, math.dotMultiply(J,math.multiply(weight_sq, Matrix.ones(1,Npar))));\n\n        //JtWdy = J' * ( weight_sq .* delta_y );\n        var JtWdy = math.multiply(Jt, math.dotMultiply(weight_sq,delta_y));\n\n\n        return {JtWJ:JtWJ,JtWdy:JtWdy,Chi_sq:Chi_sq,y_hat:y_hat,J:J};\n        // endfunction  # ------------------------------------------------------ LM_MATX\n    }\n\n\n\n};\n\nmodule.exports = LM;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/ml-curve-fitting/src/LM.js\n ** module id = 4\n ** module chunks = 0\n **/","'use strict';\n\nmodule.exports = require('./matrix');\nmodule.exports.Decompositions = module.exports.DC = require('./decompositions');\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/ml-matrix/src/index.js\n ** module id = 5\n ** module chunks = 0\n **/","'use strict';\n\nvar Asplice = Array.prototype.splice,\n    Aconcat = Array.prototype.concat;\n\n// For performance : http://jsperf.com/clone-array-slice-vs-while-vs-for\nfunction slice(arr) {\n    var i = 0,\n        ii = arr.length,\n        result = new Array(ii);\n    for (; i < ii; i++) {\n        result[i] = arr[i];\n    }\n    return result;\n}\n\n/**\n * Real matrix.\n * @constructor\n * @param {number|Array} nRows - Number of rows of the new matrix or a 2D array containing the data.\n * @param {number|boolean} [nColumns] - Number of columns of the new matrix or a boolean specifying if the input array should be cloned\n */\nfunction Matrix(nRows, nColumns) {\n    var i = 0, rows, columns, matrix, newInstance;\n    if (Array.isArray(nRows)) {\n        newInstance = nColumns;\n        matrix = newInstance ? slice(nRows) : nRows;\n        nRows = matrix.length;\n        nColumns = matrix[0].length;\n        if (typeof nColumns === 'undefined') {\n            throw new TypeError('Data must be a 2D array');\n        }\n        if (nRows > 0 && nColumns > 0) {\n            for (; i < nRows; i++) {\n                if (matrix[i].length !== nColumns) {\n                    throw new RangeError('Inconsistent array dimensions');\n                } else if (newInstance) {\n                    matrix[i] = slice(matrix[i]);\n                }\n            }\n        } else {\n            throw new RangeError('Invalid dimensions: ' + nRows + 'x' + nColumns);\n        }\n    } else if (typeof nRows === 'number') { // Create empty matrix\n        if (nRows > 0 && nColumns > 0) {\n            matrix = new Array(nRows);\n            for (; i < nRows; i++) {\n                matrix[i] = new Array(nColumns);\n            }\n        } else {\n            throw new RangeError('Invalid dimensions: ' + nRows + 'x' + nColumns);\n        }\n    } else {\n        throw new TypeError('Invalid arguments');\n    }\n\n    Object.defineProperty(matrix, 'rows', {writable: true, value: nRows});\n    Object.defineProperty(matrix, 'columns', {writable: true, value: nColumns});\n\n    matrix.__proto__ = Matrix.prototype;\n\n    return matrix;\n}\n\n/**\n * Constructs a Matrix with the chosen dimensions from a 1D array.\n * @param {number} newRows - Number of rows\n * @param {number} newColumns - Number of columns\n * @param {Array} newData - A 1D array containing data for the matrix\n * @returns {Matrix} - The new matrix\n */\nMatrix.from1DArray = function from1DArray(newRows, newColumns, newData) {\n    var length, data, i = 0;\n\n    length = newRows * newColumns;\n    if (length !== newData.length)\n        throw new RangeError('Data length does not match given dimensions');\n\n    data = new Array(newRows);\n    for (; i < newRows; i++) {\n        data[i] = newData.slice(i * newColumns, (i + 1) * newColumns);\n    }\n    return new Matrix(data);\n};\n\n/**\n * Creates a row vector, a matrix with only one row.\n * @param {Array} newData - A 1D array containing data for the vector\n * @returns {Matrix} - The new matrix\n */\nMatrix.rowVector = function rowVector(newData) {\n    return new Matrix([newData]);\n};\n\n/**\n * Creates a column vector, a matrix with only one column.\n * @param {Array} newData - A 1D array containing data for the vector\n * @returns {Matrix} - The new matrix\n */\nMatrix.columnVector = function columnVector(newData) {\n    var l = newData.length, vector = new Array(l);\n    for (var i = 0; i < l; i++)\n        vector[i] = [newData[i]];\n    return new Matrix(vector);\n};\n\n/**\n * Creates an empty matrix with the given dimensions. Values will be undefined. Same as using new Matrix(rows, columns).\n * @param {number} rows - Number of rows\n * @param {number} columns - Number of columns\n * @returns {Matrix} - The new matrix\n */\nMatrix.empty = function empty(rows, columns) {\n    return new Matrix(rows, columns);\n};\n\n/**\n * Creates a matrix with the given dimensions. Values will be set to zero.\n * @param {number} rows - Number of rows\n * @param {number} columns - Number of columns\n * @returns {Matrix} - The new matrix\n */\nMatrix.zeros = function zeros(rows, columns) {\n    return Matrix.empty(rows, columns).fill(0);\n};\n\n/**\n * Creates a matrix with the given dimensions. Values will be set to one.\n * @param {number} rows - Number of rows\n * @param {number} columns - Number of columns\n * @returns {Matrix} - The new matrix\n */\nMatrix.ones = function ones(rows, columns) {\n    return Matrix.empty(rows, columns).fill(1);\n};\n\n/**\n * Creates a matrix with the given dimensions. Values will be randomly set using Math.random().\n * @param {number} rows - Number of rows\n * @param {number} columns - Number of columns\n * @returns {Matrix} The new matrix\n */\nMatrix.rand = function rand(rows, columns) {\n    var matrix = Matrix.empty(rows, columns);\n    for (var i = 0, ii = matrix.rows; i < ii; i++) {\n        for (var j = 0, jj = matrix.columns; j < jj; j++) {\n            matrix[i][j] = Math.random();\n        }\n    }\n    return matrix;\n};\n\n/**\n * Creates an identity matrix with the given dimension. Values of the diagonal will be 1 and other will be 0.\n * @param {number} n - Number of rows and columns\n * @returns {Matrix} - The new matrix\n */\nMatrix.eye = function eye(n) {\n    var matrix = Matrix.zeros(n, n), l = matrix.rows;\n    for (var i = 0; i < l; i++) {\n        matrix[i][i] = 1;\n    }\n    return matrix;\n};\n\n/**\n * Creates a diagonal matrix based on the given array.\n * @param {Array} data - Array containing the data for the diagonal\n * @returns {Matrix} - The new matrix\n */\nMatrix.diag = function diag(data) {\n    var l = data.length, matrix = Matrix.zeros(l, l);\n    for (var i = 0; i < l; i++) {\n        matrix[i][i] = data[i];\n    }\n    return matrix;\n};\n\n/**\n * Creates an array of indices between two values\n * @param {number} from\n * @param {number} to\n * @returns {Array}\n */\nMatrix.indices = function indices(from, to) {\n    var vector = new Array(to - from);\n    for (var i = 0; i < vector.length; i++)\n        vector[i] = from++;\n    return vector;\n};\n\n// TODO DOC\nMatrix.stack = function stack(arg1) {\n    var i, j, k;\n    if (Matrix.isMatrix(arg1)) {\n        var rows = 0,\n            cols = 0;\n        for (i = 0; i < arguments.length; i++) {\n            rows += arguments[i].rows;\n            if (arguments[i].columns > cols)\n                cols = arguments[i].columns;\n        }\n\n        var r = Matrix.zeros(rows, cols);\n        var c = 0;\n        for (i = 0; i < arguments.length; i++) {\n            var current = arguments[i];\n            for (j = 0; j < current.rows; j++) {\n                for (k = 0; k < current.columns; k++)\n                    r[c][k] = current[j][k];\n                c++;\n            }\n        }\n        return r;\n    }\n    else if (Array.isArray(arg1)) {\n        var matrix = Matrix.empty(arguments.length, arg1.length);\n        for (i = 0; i < arguments.length; i++)\n            matrix.setRow(i, arguments[i]);\n        return matrix;\n    }\n};\n\n// TODO DOC\nMatrix.expand = function expand(base, count) {\n    var expansion = [];\n    for (var i = 0; i < count.length; i++)\n        for (var j = 0; j < count[i]; j++)\n            expansion.push(base[i]);\n    return new Matrix(expansion);\n};\n\n/**\n * Check that the provided value is a Matrix and tries to instantiate one if not\n * @param value - The value to check\n * @returns {Matrix}\n * @throws {TypeError}\n */\nMatrix.checkMatrix = function checkMatrix(value) {\n    if (!value) {\n        throw new TypeError('Argument has to be a matrix');\n    }\n    if (value.klass !== 'Matrix') {\n        value = new Matrix(value);\n    }\n    return value;\n};\n\n/**\n * Returns true if the argument is a Matrix, false otherwise\n * @param value - The value to check\n * @returns {boolean}\n */\nMatrix.isMatrix = function isMatrix(value) {\n    return value ? value.klass === 'Matrix' : false;\n};\n\n/**\n * @property {string} - The name of this class.\n */\nObject.defineProperty(Matrix.prototype, 'klass', {\n    get: function klass() {\n        return 'Matrix';\n    }\n});\n\n/**\n * @property {number} - The number of elements in the matrix.\n */\nObject.defineProperty(Matrix.prototype, 'size', {\n    get: function size() {\n        return this.rows * this.columns;\n    }\n});\n\n/**\n * @private\n * Internal check that a row index is not out of bounds\n * @param {number} index\n */\nMatrix.prototype.checkRowIndex = function checkRowIndex(index) {\n    if (index < 0 || index > this.rows - 1)\n        throw new RangeError('Row index out of range.');\n};\n\n/**\n * @private\n * Internal check that a column index is not out of bounds\n * @param {number} index\n */\nMatrix.prototype.checkColumnIndex = function checkColumnIndex(index) {\n    if (index < 0 || index > this.columns - 1)\n        throw new RangeError('Column index out of range.');\n};\n\n/**\n * @private\n * Internal check that two matrices have the same dimensions\n * @param {Matrix} otherMatrix\n */\nMatrix.prototype.checkDimensions = function checkDimensions(otherMatrix) {\n    if ((this.rows !== otherMatrix.rows) || (this.columns !== otherMatrix.columns))\n        throw new RangeError('Matrices dimensions must be equal.');\n};\n\n/**\n * Applies a callback for each element of the matrix. The function is called in the matrix (this) context.\n * @param {function} callback - Function that will be called with two parameters : i (row) and j (column)\n * @returns {Matrix} this\n */\nMatrix.prototype.apply = function apply(callback) {\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            callback.call(this, i, j);\n        }\n    }\n    return this;\n};\n\n/**\n * Creates an exact and independent copy of the matrix\n * @returns {Matrix}\n */\nMatrix.prototype.clone = function clone() {\n    return new Matrix(this.to2DArray());\n};\n\n/**\n * Returns a new 1D array filled row by row with the matrix values\n * @returns {Array}\n */\nMatrix.prototype.to1DArray = function to1DArray() {\n    return Aconcat.apply([], this);\n};\n\n/**\n * Returns a 2D array containing a copy of the data\n * @returns {Array}\n */\nMatrix.prototype.to2DArray = function to2DArray() {\n    var l = this.rows, copy = new Array(l);\n    for (var i = 0; i < l; i++) {\n        copy[i] = slice(this[i]);\n    }\n    return copy;\n};\n\n/**\n * @returns {boolean} true if the matrix has one row\n */\nMatrix.prototype.isRowVector = function isRowVector() {\n    return this.rows === 1;\n};\n\n/**\n * @returns {boolean} true if the matrix has one column\n */\nMatrix.prototype.isColumnVector = function isColumnVector() {\n    return this.columns === 1;\n};\n\n/**\n * @returns {boolean} true if the matrix has one row or one column\n */\nMatrix.prototype.isVector = function isVector() {\n    return (this.rows === 1) || (this.columns === 1);\n};\n\n/**\n * @returns {boolean} true if the matrix has the same number of rows and columns\n */\nMatrix.prototype.isSquare = function isSquare() {\n    return this.rows === this.columns;\n};\n\n/**\n * @returns {boolean} true if the matrix is square and has the same values on both sides of the diagonal\n */\nMatrix.prototype.isSymmetric = function isSymmetric() {\n    if (this.isSquare()) {\n        var l = this.rows;\n        for (var i = 0; i < l; i++) {\n            for (var j = 0; j <= i; j++) {\n                if (this[i][j] !== this[j][i]) {\n                    return false;\n                }\n            }\n        }\n        return true;\n    }\n    return false;\n};\n\n/**\n * Sets a given element of the matrix. mat.set(3,4,1) is equivalent to mat[3][4]=1\n * @param {number} rowIndex - Index of the row\n * @param {number} columnIndex - Index of the column\n * @param {number} value - The new value for the element\n * @returns {Matrix} this\n */\nMatrix.prototype.set = function set(rowIndex, columnIndex, value) {\n    this[rowIndex][columnIndex] = value;\n    return this;\n};\n\n/**\n * Returns the given element of the matrix. mat.get(3,4) is equivalent to matrix[3][4]\n * @param {number} rowIndex - Index of the row\n * @param {number} columnIndex - Index of the column\n * @returns {number}\n */\nMatrix.prototype.get = function get(rowIndex, columnIndex) {\n    return this[rowIndex][columnIndex];\n};\n\n/**\n * Fills the matrix with a given value. All elements will be set to this value.\n * @param {number} value - New value\n * @returns {Matrix} this\n */\nMatrix.prototype.fill = function fill(value) {\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] = value;\n        }\n    }\n    return this;\n};\n\n/**\n * Negates the matrix. All elements will be multiplied by (-1)\n * @returns {Matrix} this\n */\nMatrix.prototype.neg = function neg() {\n    return this.mulS(-1);\n};\n\n/**\n * Adds a scalar or values from another matrix (in place)\n * @param {number|Matrix} value\n * @returns {Matrix} this\n */\nMatrix.prototype.add = function add(value) {\n    if (typeof value === 'number')\n        return this.addS(value);\n    value = Matrix.checkMatrix(value);\n        return this.addM(value);\n};\n\n/**\n * Adds a scalar to each element of the matrix\n * @param {number} value\n * @returns {Matrix} this\n */\nMatrix.prototype.addS = function addS(value) {\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] += value;\n        }\n    }\n    return this;\n};\n\n/**\n * Adds the value of each element of matrix to the corresponding element of this\n * @param {Matrix} matrix\n * @returns {Matrix} this\n */\nMatrix.prototype.addM = function addM(matrix) {\n    this.checkDimensions(matrix);\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] += matrix[i][j];\n        }\n    }\n    return this;\n};\n\n/**\n * Subtracts a scalar or values from another matrix (in place)\n * @param {number|Matrix} value\n * @returns {Matrix} this\n */\nMatrix.prototype.sub = function sub(value) {\n    if (typeof value === 'number')\n        return this.subS(value);\n    value = Matrix.checkMatrix(value);\n        return this.subM(value);\n};\n\n/**\n * Subtracts a scalar from each element of the matrix\n * @param {number} value\n * @returns {Matrix} this\n */\nMatrix.prototype.subS = function subS(value) {\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] -= value;\n        }\n    }\n    return this;\n};\n\n/**\n * Subtracts the value of each element of matrix from the corresponding element of this\n * @param {Matrix} matrix\n * @returns {Matrix} this\n */\nMatrix.prototype.subM = function subM(matrix) {\n    this.checkDimensions(matrix);\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] -= matrix[i][j];\n        }\n    }\n    return this;\n};\n\n/**\n * Multiplies a scalar or values from another matrix (in place)\n * @param {number|Matrix} value\n * @returns {Matrix} this\n */\nMatrix.prototype.mul = function mul(value) {\n    if (typeof value === 'number')\n        return this.mulS(value);\n    value = Matrix.checkMatrix(value);\n        return this.mulM(value);\n};\n\n/**\n * Multiplies a scalar with each element of the matrix\n * @param {number} value\n * @returns {Matrix} this\n */\nMatrix.prototype.mulS = function mulS(value) {\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] *= value;\n        }\n    }\n    return this;\n};\n\n/**\n * Multiplies the value of each element of matrix with the corresponding element of this\n * @param {Matrix} matrix\n * @returns {Matrix} this\n */\nMatrix.prototype.mulM = function mulM(matrix) {\n    this.checkDimensions(matrix);\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] *= matrix[i][j];\n        }\n    }\n    return this;\n};\n\n/**\n * Divides by a scalar or values from another matrix (in place)\n * @param {number|Matrix} value\n * @returns {Matrix} this\n */\nMatrix.prototype.div = function div(value) {\n    if (typeof value === 'number')\n        return this.divS(value);\n    value = Matrix.checkMatrix(value);\n        return this.divM(value);\n};\n\n/**\n * Divides each element of the matrix by a scalar\n * @param {number} value\n * @returns {Matrix} this\n */\nMatrix.prototype.divS = function divS(value) {\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] /= value;\n        }\n    }\n    return this;\n};\n\n/**\n * Divides each element of this by the corresponding element of matrix\n * @param {Matrix} matrix\n * @returns {Matrix} this\n */\nMatrix.prototype.divM = function divM(matrix) {\n    this.checkDimensions(matrix);\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] /= matrix[i][j];\n        }\n    }\n    return this;\n};\n\n/**\n * Returns a new array from the given row index\n * @param {number} index - Row index\n * @returns {Array}\n */\nMatrix.prototype.getRow = function getRow(index) {\n    this.checkRowIndex(index);\n    return slice(this[index]);\n};\n\n/**\n * Returns a new row vector from the given row index\n * @param {number} index - Row index\n * @returns {Matrix}\n */\nMatrix.prototype.getRowVector = function getRowVector(index) {\n    return Matrix.rowVector(this.getRow(index));\n};\n\n/**\n * Sets a row at the given index\n * @param {number} index - Row index\n * @param {Array|Matrix} array - Array or vector\n * @returns {Matrix} this\n */\nMatrix.prototype.setRow = function setRow(index, array) {\n    this.checkRowIndex(index);\n    if (Matrix.isMatrix(array)) array = array.to1DArray();\n    if (array.length !== this.columns)\n        throw new RangeError('Invalid row size');\n    this[index] = slice(array);\n    return this;\n};\n\n/**\n * Removes a row from the given index\n * @param {number} index - Row index\n * @returns {Matrix} this\n */\nMatrix.prototype.removeRow = function removeRow(index) {\n    this.checkRowIndex(index);\n    if (this.rows === 1)\n        throw new RangeError('A matrix cannot have less than one row');\n    Asplice.call(this, index, 1);\n    this.rows -= 1;\n    return this;\n};\n\n/**\n * Adds a row at the given index\n * @param {number} [index = this.rows] - Row index\n * @param {Array|Matrix} array - Array or vector\n * @returns {Matrix} this\n */\nMatrix.prototype.addRow = function addRow(index, array) {\n    if (typeof array === 'undefined') {\n        array = index;\n        index = this.rows;\n    }\n    if (index < 0 || index > this.rows)\n        throw new RangeError('Row index out of range.');\n    if (Matrix.isMatrix(array)) array = array.to1DArray();\n    if (array.length !== this.columns)\n        throw new RangeError('Invalid row size');\n    Asplice.call(this, index, 0, slice(array));\n    this.rows += 1;\n    return this;\n};\n\n/**\n * Swaps two rows\n * @param {number} row1 - First row index\n * @param {number} row2 - Second row index\n * @returns {Matrix} this\n */\nMatrix.prototype.swapRows = function swapRows(row1, row2) {\n    this.checkRowIndex(row1);\n    this.checkRowIndex(row2);\n    var temp = this[row1];\n    this[row1] = this[row2];\n    this[row2] = temp;\n    return this;\n};\n\n/**\n * Returns a new array from the given column index\n * @param {number} index - Column index\n * @returns {Array}\n */\nMatrix.prototype.getColumn = function getColumn(index) {\n    this.checkColumnIndex(index);\n    var l = this.rows, column = new Array(l);\n    for (var i = 0; i < l; i++) {\n        column[i] = this[i][index];\n    }\n    return column;\n};\n\n/**\n * Returns a new column vector from the given column index\n * @param {number} index - Column index\n * @returns {Matrix}\n */\nMatrix.prototype.getColumnVector = function getColumnVector(index) {\n    return Matrix.columnVector(this.getColumn(index));\n};\n\n/**\n * Sets a column at the given index\n * @param {number} index - Column index\n * @param {Array|Matrix} array - Array or vector\n * @returns {Matrix} this\n */\nMatrix.prototype.setColumn = function setColumn(index, array) {\n    this.checkColumnIndex(index);\n    if (Matrix.isMatrix(array)) array = array.to1DArray();\n    var l = this.rows;\n    if (array.length !== l)\n        throw new RangeError('Invalid column size');\n    for (var i = 0; i < l; i++) {\n        this[i][index] = array[i];\n    }\n    return this;\n};\n\n/**\n * Removes a column from the given index\n * @param {number} index - Column index\n * @returns {Matrix} this\n */\nMatrix.prototype.removeColumn = function removeColumn(index) {\n    this.checkColumnIndex(index);\n    if (this.columns === 1)\n        throw new RangeError('A matrix cannot have less than one column');\n    for (var i = 0, ii = this.rows; i < ii; i++) {\n        this[i].splice(index, 1);\n    }\n    this.columns -= 1;\n    return this;\n};\n\n/**\n * Adds a column at the given index\n * @param {number} [index = this.columns] - Column index\n * @param {Array|Matrix} array - Array or vector\n * @returns {Matrix} this\n */\nMatrix.prototype.addColumn = function addColumn(index, array) {\n    if (typeof array === 'undefined') {\n        array = index;\n        index = this.columns;\n    }\n    if (index < 0 || index > this.columns)\n        throw new RangeError('Column index out of range.');\n    if (Matrix.isMatrix(array)) array = array.to1DArray();\n    var l = this.rows;\n    if (array.length !== l)\n        throw new RangeError('Invalid column size');\n    for (var i = 0; i < l; i++) {\n        this[i].splice(index, 0, array[i]);\n    }\n    this.columns += 1;\n    return this;\n};\n\n/**\n * Swaps two columns\n * @param {number} column1 - First column index\n * @param {number} column2 - Second column index\n * @returns {Matrix} this\n */\nMatrix.prototype.swapColumns = function swapColumns(column1, column2) {\n    this.checkRowIndex(column1);\n    this.checkRowIndex(column2);\n    var l = this.rows, temp, row;\n    for (var i = 0; i < l; i++) {\n        row = this[i];\n        temp = row[column1];\n        row[column1] = row[column2];\n        row[column2] = temp;\n    }\n    return this;\n};\n\n/**\n * @private\n * Internal check that the provided vector is an array with the right length\n * @param {Array|Matrix} vector\n * @returns {Array}\n * @throws {RangeError}\n */\nMatrix.prototype.checkRowVector = function checkRowVector(vector) {\n    if (Matrix.isMatrix(vector))\n        vector = vector.to1DArray();\n    if (vector.length !== this.columns)\n        throw new RangeError('vector size must be the same as the number of columns');\n    return vector;\n};\n\n/**\n * @private\n * Internal check that the provided vector is an array with the right length\n * @param {Array|Matrix} vector\n * @returns {Array}\n * @throws {RangeError}\n */\nMatrix.prototype.checkColumnVector = function checkColumnVector(vector) {\n    if (Matrix.isMatrix(vector))\n        vector = vector.to1DArray();\n    if (vector.length !== this.rows)\n        throw new RangeError('vector size must be the same as the number of rows');\n    return vector;\n};\n\n/**\n * Adds the values of a vector to each row\n * @param {Array|Matrix} vector - Array or vector\n * @returns {Matrix} this\n */\nMatrix.prototype.addRowVector = function addRowVector(vector) {\n    vector = this.checkRowVector(vector);\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] += vector[j];\n        }\n    }\n    return this;\n};\n\n/**\n * Subtracts the values of a vector from each row\n * @param {Array|Matrix} vector - Array or vector\n * @returns {Matrix} this\n */\nMatrix.prototype.subRowVector = function subRowVector(vector) {\n    vector = this.checkRowVector(vector);\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] -= vector[j];\n        }\n    }\n    return this;\n};\n\n/**\n * Multiplies the values of a vector with each row\n * @param {Array|Matrix} vector - Array or vector\n * @returns {Matrix} this\n */\nMatrix.prototype.mulRowVector = function mulRowVector(vector) {\n    vector = this.checkRowVector(vector);\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] *= vector[j];\n        }\n    }\n    return this;\n};\n\n/**\n * Divides the values of each row by those of a vector\n * @param {Array|Matrix} vector - Array or vector\n * @returns {Matrix} this\n */\nMatrix.prototype.divRowVector = function divRowVector(vector) {\n    vector = this.checkRowVector(vector);\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] /= vector[j];\n        }\n    }\n    return this;\n};\n\n/**\n * Adds the values of a vector to each column\n * @param {Array|Matrix} vector - Array or vector\n * @returns {Matrix} this\n */\nMatrix.prototype.addColumnVector = function addColumnVector(vector) {\n    vector = this.checkColumnVector(vector);\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] += vector[i];\n        }\n    }\n    return this;\n};\n\n/**\n * Subtracts the values of a vector from each column\n * @param {Array|Matrix} vector - Array or vector\n * @returns {Matrix} this\n */\nMatrix.prototype.subColumnVector = function subColumnVector(vector) {\n    vector = this.checkColumnVector(vector);\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] -= vector[i];\n        }\n    }\n    return this;\n};\n\n/**\n * Multiplies the values of a vector with each column\n * @param {Array|Matrix} vector - Array or vector\n * @returns {Matrix} this\n */\nMatrix.prototype.mulColumnVector = function mulColumnVector(vector) {\n    vector = this.checkColumnVector(vector);\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] *= vector[i];\n        }\n    }\n    return this;\n};\n\n/**\n * Divides the values of each column by those of a vector\n * @param {Array|Matrix} vector - Array or vector\n * @returns {Matrix} this\n */\nMatrix.prototype.divColumnVector = function divColumnVector(vector) {\n    vector = this.checkColumnVector(vector);\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] /= vector[i];\n        }\n    }\n    return this;\n};\n\n/**\n * Multiplies the values of a row with a scalar\n * @param {number} index - Row index\n * @param {number} value\n * @returns {Matrix} this\n */\nMatrix.prototype.mulRow = function mulRow(index, value) {\n    this.checkRowIndex(index);\n    var i = 0, l = this.columns;\n    for (; i < l; i++) {\n        this[index][i] *= value;\n    }\n    return this;\n};\n\n/**\n * Multiplies the values of a column with a scalar\n * @param {number} index - Column index\n * @param {number} value\n * @returns {Matrix} this\n */\nMatrix.prototype.mulColumn = function mulColumn(index, value) {\n    this.checkColumnIndex(index);\n    var i = 0, l = this.rows;\n    for (; i < l; i++) {\n        this[i][index] *= value;\n    }\n};\n\n/**\n * A matrix index\n * @typedef {Object} MatrixIndex\n * @property {number} row\n * @property {number} column\n */\n\n/**\n * Returns the maximum value of the matrix\n * @returns {number}\n */\nMatrix.prototype.max = function max() {\n    var v = -Infinity;\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            if (this[i][j] > v) {\n                v = this[i][j];\n            }\n        }\n    }\n    return v;\n};\n\n/**\n * Returns the index of the maximum value\n * @returns {MatrixIndex}\n */\nMatrix.prototype.maxIndex = function maxIndex() {\n    var v = -Infinity;\n    var idx = {};\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            if (this[i][j] > v) {\n                v = this[i][j];\n                idx.row = i;\n                idx.column = j;\n            }\n        }\n    }\n    return idx;\n};\n\n/**\n * Returns the minimum value of the matrix\n * @returns {number}\n */\nMatrix.prototype.min = function min() {\n    var v = Infinity;\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            if (this[i][j] < v) {\n                v = this[i][j];\n            }\n        }\n    }\n    return v;\n};\n\n/**\n * Returns the index of the minimum value\n * @returns {MatrixIndex}\n */\nMatrix.prototype.minIndex = function minIndex() {\n    var v = Infinity;\n    var idx = {};\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            if (this[i][j] < v) {\n                v = this[i][j];\n                idx.row = i;\n                idx.column = j;\n            }\n        }\n    }\n    return idx;\n};\n\n/**\n * Returns the maximum value of one row\n * @param {number} index - Row index\n * @returns {number}\n */\nMatrix.prototype.maxRow = function maxRow(index) {\n    this.checkRowIndex(index);\n    var v = -Infinity;\n    for (var i = 0, ii = this.columns; i < ii; i++) {\n        if (this[index][i] > v) {\n            v = this[index][i];\n        }\n    }\n    return v;\n};\n\n/**\n * Returns the index of the maximum value of one row\n * @param {number} index - Row index\n * @returns {MatrixIndex}\n */\nMatrix.prototype.maxRowIndex = function maxRowIndex(index) {\n    this.checkRowIndex(index);\n    var v = -Infinity;\n    var idx = {\n            row: index\n        };\n    for (var i = 0, ii = this.columns; i < ii; i++) {\n        if (this[index][i] > v) {\n            v = this[index][i];\n            idx.column = i;\n        }\n    }\n    return idx;\n};\n\n/**\n * Returns the minimum value of one row\n * @param {number} index - Row index\n * @returns {number}\n */\nMatrix.prototype.minRow = function minRow(index) {\n    this.checkRowIndex(index);\n    var v = Infinity;\n    for (var i = 0, ii = this.columns; i < ii; i++) {\n        if (this[index][i] < v) {\n            v = this[index][i];\n        }\n    }\n    return v;\n};\n\n/**\n * Returns the index of the maximum value of one row\n * @param {number} index - Row index\n * @returns {MatrixIndex}\n */\nMatrix.prototype.minRowIndex = function minRowIndex(index) {\n    this.checkRowIndex(index);\n    var v = Infinity;\n    var idx = {\n        row: index,\n        column: 0\n    };\n    for (var i = 0, ii = this.columns; i < ii; i++) {\n        if (this[index][i] < v) {\n            v = this[index][i];\n            idx.column = i;\n        }\n    }\n    return idx;\n};\n\n/**\n * Returns the maximum value of one column\n * @param {number} index - Column index\n * @returns {number}\n */\nMatrix.prototype.maxColumn = function maxColumn(index) {\n    this.checkColumnIndex(index);\n    var v = -Infinity;\n    for (var i = 0, ii = this.rows; i < ii; i++) {\n        if (this[i][index] > v) {\n            v = this[i][index];\n        }\n    }\n    return v;\n};\n\n/**\n * Returns the index of the maximum value of one column\n * @param {number} index - Column index\n * @returns {MatrixIndex}\n */\nMatrix.prototype.maxColumnIndex = function maxColumnIndex(index) {\n    this.checkColumnIndex(index);\n    var v = -Infinity;\n    var idx = {\n        row: 0,\n        column: index\n    };\n    for (var i = 0, ii = this.rows; i < ii; i++) {\n        if (this[i][index] > v) {\n            v = this[i][index];\n            idx.row = i;\n        }\n    }\n    return idx;\n};\n\n/**\n * Returns the minimum value of one column\n * @param {number} index - Column index\n * @returns {number}\n */\nMatrix.prototype.minColumn = function minColumn(index) {\n    this.checkColumnIndex(index);\n    var v = Infinity;\n    for (var i = 0, ii = this.rows; i < ii; i++) {\n        if (this[i][index] < v) {\n            v = this[i][index];\n        }\n    }\n    return v;\n};\n\n/**\n * Returns the index of the minimum value of one column\n * @param {number} index - Column index\n * @returns {MatrixIndex}\n */\nMatrix.prototype.minColumnIndex = function minColumnIndex(index) {\n    this.checkColumnIndex(index);\n    var v = Infinity;\n    var idx = {\n        row: 0,\n        column: index\n    };\n    for (var i = 0, ii = this.rows; i < ii; i++) {\n        if (this[i][index] < v) {\n            v = this[i][index];\n            idx.row = i;\n        }\n    }\n    return idx;\n};\n\n/**\n * Returns an array containing the diagonal values of the matrix\n * @returns {Array}\n */\nMatrix.prototype.diag = function diag() {\n    if (!this.isSquare())\n        throw new TypeError('Only square matrices have a diagonal.');\n    var diag = new Array(this.rows);\n    for (var i = 0, ii = this.rows; i < ii; i++) {\n        diag[i] = this[i][i];\n    }\n    return diag;\n};\n\n/**\n * Returns the sum of all elements of the matrix\n * @returns {number}\n */\nMatrix.prototype.sum = function sum() {\n    var v = 0;\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            v += this[i][j];\n        }\n    }\n    return v;\n};\n\n/**\n * Returns the mean of all elements of the matrix\n * @returns {number}\n */\nMatrix.prototype.mean = function mean() {\n    return this.sum() / this.size;\n};\n\n/**\n * Returns the product of all elements of the matrix\n * @returns {number}\n */\nMatrix.prototype.prod = function prod() {\n    var prod = 1;\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            prod *= this[i][j];\n        }\n    }\n    return prod;\n};\n\n/**\n * Computes the cumulative sum of the matrix elements (in place, row by row)\n * @returns {Matrix} this\n */\nMatrix.prototype.cumulativeSum = function cumulativeSum() {\n    var sum = 0;\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            sum += this[i][j];\n            this[i][j] = sum;\n        }\n    }\n    return this;\n};\n\n/**\n * Computes the dot (scalar) product between the matrix and another\n * @param {Matrix} other vector\n * @returns {number}\n */\nMatrix.prototype.dot = function dot(other) {\n    if (this.size !== other.size)\n        throw new RangeError('vectors do not have the same size');\n    var vector1 = this.to1DArray();\n    var vector2 = other.to1DArray();\n    var dot = 0, l = vector1.length;\n    for (var i = 0; i < l; i++) {\n        dot += vector1[i] * vector2[i];\n    }\n    return dot;\n};\n\n/**\n * Returns the matrix product between this and other\n * @returns {Matrix}\n */\nMatrix.prototype.mmul = function mmul(other) {\n    if (!Matrix.isMatrix(other))\n        throw new TypeError('parameter \"other\" must be a matrix');\n    if (this.columns !== other.rows)\n        console.warn('Number of columns of left matrix are not equal to number of rows of right matrix.');\n\n    var m = this.rows, n = this.columns, p = other.columns;\n    var result = new Matrix(m, p);\n\n    var Bcolj = new Array(n);\n    var i, j, k;\n    for (j = 0; j < p; j++) {\n        for (k = 0; k < n; k++)\n            Bcolj[k] = other[k][j];\n\n        for (i = 0; i < m; i++) {\n            var Arowi = this[i];\n\n            var s = 0;\n            for (k = 0; k < n; k++)\n                s += Arowi[k] * Bcolj[k];\n\n            result[i][j] = s;\n        }\n    }\n    return result;\n};\n\n/**\n * Sorts the rows (in place)\n * @param {function} compareFunction - usual Array.prototype.sort comparison function\n * @returns {Matrix} this\n */\nMatrix.prototype.sortRows = function sortRows(compareFunction) {\n    for (var i = 0, ii = this.rows; i < ii; i++) {\n        this[i].sort(compareFunction);\n    }\n    return this;\n};\n\n/**\n * Sorts the columns (in place)\n * @param {function} compareFunction - usual Array.prototype.sort comparison function\n * @returns {Matrix} this\n */\nMatrix.prototype.sortColumns = function sortColumns(compareFunction) {\n    for (var i = 0, ii = this.columns; i < ii; i++) {\n        this.setColumn(i, this.getColumn(i).sort(compareFunction));\n    }\n    return this;\n};\n\n/**\n * Transposes the matrix and returns a new one containing the result\n * @returns {Matrix}\n */\nMatrix.prototype.transpose = function transpose() {\n    var result = new Matrix(this.columns, this.rows);\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            result[j][i] = this[i][j];\n        }\n    }\n    return result;\n};\n\n/**\n * Returns a subset of the matrix\n * @param {number} startRow - First row index\n * @param {number} endRow - Last row index\n * @param {number} startColumn - First column index\n * @param {number} endColumn - Last column index\n * @returns {Matrix}\n */\nMatrix.prototype.subMatrix = function subMatrix(startRow, endRow, startColumn, endColumn) {\n    if ((startRow > endRow) || (startColumn > endColumn) || (startRow < 0) || (startRow >= this.rows) || (endRow < 0) || (endRow >= this.rows) || (startColumn < 0) || (startColumn >= this.columns) || (endColumn < 0) || (endColumn >= this.columns))\n        throw new RangeError('Argument out of range');\n    var newMatrix = new Matrix(endRow - startRow + 1, endColumn - startColumn + 1);\n    for (var i = startRow; i <= endRow; i++) {\n        for (var j = startColumn; j <= endColumn; j++) {\n            newMatrix[i - startRow][j - startColumn] = this[i][j];\n        }\n    }\n    return newMatrix;\n};\n\n/**\n * Returns a subset of the matrix based on an array of row indices\n * @param {Array} indices - Array containing the row indices\n * @param {number} [startColumn = 0] - First column index\n * @param {number} [endColumn = this.columns-1] - Last column index\n * @returns {Matrix}\n */\nMatrix.prototype.subMatrixRow = function subMatrixRow(indices, startColumn, endColumn) {\n    if (typeof startColumn === 'undefined') {\n        startColumn = 0;\n        endColumn = this.columns - 1;\n    } else if (typeof endColumn === 'undefined') {\n        endColumn = this.columns - 1;\n    }\n    if ((startColumn > endColumn) || (startColumn < 0) || (startColumn >= this.columns) || (endColumn < 0) || (endColumn >= this.columns))\n        throw new RangeError('Argument out of range.');\n    var l = indices.length, rows = this.rows,\n        X = new Matrix(l, endColumn - startColumn + 1);\n    for (var i = 0; i < l; i++) {\n        for (var j = startColumn; j <= endColumn; j++) {\n            if ((indices[i] < 0) || (indices[i] >= rows))\n                throw new RangeError('Argument out of range.');\n            X[i][j - startColumn] = this[indices[i]][j];\n        }\n    }\n    return X;\n};\n\n/**\n * Returns a subset of the matrix based on an array of column indices\n * @param {Array} indices - Array containing the column indices\n * @param {number} [startRow = 0] - First row index\n * @param {number} [endRow = this.rows-1] - Last row index\n * @returns {Matrix}\n */\nMatrix.prototype.subMatrixColumn = function subMatrixColumn(indices, startRow, endRow) {\n    if (typeof startRow === 'undefined') {\n        startRow = 0;\n        endRow = this.rows - 1;\n    } else if (typeof endRow === 'undefined') {\n        endRow = this.rows - 1;\n    }\n    if ((startRow > endRow) || (startRow < 0) || (startRow >= this.rows) || (endRow < 0) || (endRow >= this.rows))\n        throw new RangeError('Argument out of range.');\n    var l = indices.length, columns = this.columns,\n        X = new Matrix(endRow - startRow + 1, l);\n    for (var i = 0; i < l; i++) {\n        for (var j = startRow; j <= endRow; j++) {\n            if ((indices[i] < 0) || (indices[i] >= columns))\n                throw new RangeError('Argument out of range.');\n            X[j - startRow][i] = this[j][indices[i]];\n        }\n    }\n    return X;\n};\n\n/**\n * Returns the trace of the matrix (sum of the diagonal elements)\n * @returns {number}\n */\nMatrix.prototype.trace = function trace() {\n    if (!this.isSquare())\n        throw new TypeError('The matrix is not square');\n    var trace = 0, i = 0, l = this.rows;\n    for (; i < l; i++) {\n        trace += this[i][i];\n    }\n    return trace;\n};\n\n/**\n * Sets each element of the matrix to its absolute value\n * @returns {Matrix} this\n */\nMatrix.prototype.abs = function abs() {\n    var ii = this.rows, jj = this.columns;\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            this[i][j] = Math.abs(this[i][j]);\n        }\n    }\n};\n\nmodule.exports = Matrix;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/ml-matrix/src/matrix.js\n ** module id = 6\n ** module chunks = 0\n **/","'use strict';\n\nvar Matrix = require('./matrix');\n\nvar SingularValueDecomposition = require('./dc/svd');\nvar EigenvalueDecomposition = require('./dc/evd');\nvar LuDecomposition = require('./dc/lu');\nvar QrDecomposition = require('./dc/qr');\nvar CholeskyDecomposition = require('./dc/cholesky');\n\nfunction inverse(matrix) {\n    return solve(matrix, Matrix.eye(matrix.rows));\n}\n\nMatrix.prototype.inverse = function () {\n    return inverse(this);\n};\n\nfunction solve(leftHandSide, rightHandSide) {\n    return leftHandSide.isSquare() ? new LuDecomposition(leftHandSide).solve(rightHandSide) : new QrDecomposition(leftHandSide).solve(rightHandSide);\n}\n\nMatrix.prototype.solve = function (other) {\n    return solve(this, other);\n};\n\nmodule.exports = {\n    SingularValueDecomposition: SingularValueDecomposition,\n    SVD: SingularValueDecomposition,\n    EigenvalueDecomposition: EigenvalueDecomposition,\n    EVD: EigenvalueDecomposition,\n    LuDecomposition: LuDecomposition,\n    LU: LuDecomposition,\n    QrDecomposition: QrDecomposition,\n    QR: QrDecomposition,\n    CholeskyDecomposition: CholeskyDecomposition,\n    CHO: CholeskyDecomposition,\n    inverse: inverse,\n    solve: solve\n};\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/ml-matrix/src/decompositions.js\n ** module id = 7\n ** module chunks = 0\n **/","'use strict';\n\nvar Matrix = require('../matrix');\nvar hypotenuse = require('./util').hypotenuse;\n\n// https://github.com/lutzroeder/Mapack/blob/master/Source/SingularValueDecomposition.cs\nfunction SingularValueDecomposition(value, options) {\n    if (!(this instanceof SingularValueDecomposition)) {\n        return new SingularValueDecomposition(value, options);\n    }\n    value = Matrix.checkMatrix(value);\n\n    options = options || {};\n\n    var a = value.clone(),\n        m = value.rows,\n        n = value.columns,\n        nu = Math.min(m, n);\n\n    var wantu = true, wantv = true;\n    if (options.computeLeftSingularVectors === false)\n        wantu = false;\n    if (options.computeRightSingularVectors === false)\n        wantv = false;\n    var autoTranspose = options.autoTranspose === true;\n\n    var swapped = false;\n    if (m < n) {\n        if (!autoTranspose) {\n            console.warn('Computing SVD on a matrix with more columns than rows. Consider enabling autoTranspose');\n        } else {\n            a = a.transpose();\n            m = a.rows;\n            n = a.columns;\n            swapped = true;\n            var aux = wantu;\n            wantu = wantv;\n            wantv = aux;\n        }\n    }\n\n    var s = new Array(Math.min(m + 1, n)),\n        U = Matrix.zeros(m, nu),\n        V = Matrix.zeros(n, n),\n        e = new Array(n),\n        work = new Array(m);\n\n    var nct = Math.min(m - 1, n);\n    var nrt = Math.max(0, Math.min(n - 2, m));\n\n    var i, j, k, p, t, ks, f, cs, sn, max, kase,\n        scale, sp, spm1, epm1, sk, ek, b, c, shift, g;\n\n    for (k = 0, max = Math.max(nct, nrt); k < max; k++) {\n        if (k < nct) {\n            s[k] = 0;\n            for (i = k; i < m; i++) {\n                s[k] = hypotenuse(s[k], a[i][k]);\n            }\n            if (s[k] !== 0) {\n                if (a[k][k] < 0) {\n                    s[k] = -s[k];\n                }\n                for (i = k; i < m; i++) {\n                    a[i][k] /= s[k];\n                }\n                a[k][k] += 1;\n            }\n            s[k] = -s[k];\n        }\n\n        for (j = k + 1; j < n; j++) {\n            if ((k < nct) && (s[k] !== 0)) {\n                t = 0;\n                for (i = k; i < m; i++) {\n                    t += a[i][k] * a[i][j];\n                }\n                t = -t / a[k][k];\n                for (i = k; i < m; i++) {\n                    a[i][j] += t * a[i][k];\n                }\n            }\n            e[j] = a[k][j];\n        }\n\n        if (wantu && (k < nct)) {\n            for (i = k; i < m; i++) {\n                U[i][k] = a[i][k];\n            }\n        }\n\n        if (k < nrt) {\n            e[k] = 0;\n            for (i = k + 1; i < n; i++) {\n                e[k] = hypotenuse(e[k], e[i]);\n            }\n            if (e[k] !== 0) {\n                if (e[k + 1] < 0)\n                    e[k] = -e[k];\n                for (i = k + 1; i < n; i++) {\n                    e[i] /= e[k];\n                }\n                e[k + 1] += 1;\n            }\n            e[k] = -e[k];\n            if ((k + 1 < m) && (e[k] !== 0)) {\n                for (i = k + 1; i < m; i++) {\n                    work[i] = 0;\n                }\n                for (j = k + 1; j < n; j++) {\n                    for (i = k + 1; i < m; i++) {\n                        work[i] += e[j] * a[i][j];\n                    }\n                }\n                for (j = k + 1; j < n; j++) {\n                    t = -e[j] / e[k + 1];\n                    for (i = k + 1; i < m; i++) {\n                        a[i][j] += t * work[i];\n                    }\n                }\n            }\n            if (wantv) {\n                for (i = k + 1; i < n; i++) {\n                    V[i][k] = e[i];\n                }\n            }\n        }\n    }\n\n    p = Math.min(n, m + 1);\n    if (nct < n) {\n        s[nct] = a[nct][nct];\n    }\n    if (m < p) {\n        s[p - 1] = 0;\n    }\n    if (nrt + 1 < p) {\n        e[nrt] = a[nrt][p - 1];\n    }\n    e[p - 1] = 0;\n\n    if (wantu) {\n        for (j = nct; j < nu; j++) {\n            for (i = 0; i < m; i++) {\n                U[i][j] = 0;\n            }\n            U[j][j] = 1;\n        }\n        for (k = nct - 1; k >= 0; k--) {\n            if (s[k] !== 0) {\n                for (j = k + 1; j < nu; j++) {\n                    t = 0;\n                    for (i = k; i < m; i++) {\n                        t += U[i][k] * U[i][j];\n                    }\n                    t = -t / U[k][k];\n                    for (i = k; i < m; i++) {\n                        U[i][j] += t * U[i][k];\n                    }\n                }\n                for (i = k; i < m; i++) {\n                    U[i][k] = -U[i][k];\n                }\n                U[k][k] = 1 + U[k][k];\n                for (i = 0; i < k - 1; i++) {\n                    U[i][k] = 0;\n                }\n            } else {\n                for (i = 0; i < m; i++) {\n                    U[i][k] = 0;\n                }\n                U[k][k] = 1;\n            }\n        }\n    }\n\n    if (wantv) {\n        for (k = n - 1; k >= 0; k--) {\n            if ((k < nrt) && (e[k] !== 0)) {\n                for (j = k + 1; j < n; j++) {\n                    t = 0;\n                    for (i = k + 1; i < n; i++) {\n                        t += V[i][k] * V[i][j];\n                    }\n                    t = -t / V[k + 1][k];\n                    for (i = k + 1; i < n; i++) {\n                        V[i][j] += t * V[i][k];\n                    }\n                }\n            }\n            for (i = 0; i < n; i++) {\n                V[i][k] = 0;\n            }\n            V[k][k] = 1;\n        }\n    }\n\n    var pp = p - 1,\n        iter = 0,\n        eps = Math.pow(2, -52);\n    while (p > 0) {\n        for (k = p - 2; k >= -1; k--) {\n            if (k === -1) {\n                break;\n            }\n            if (Math.abs(e[k]) <= eps * (Math.abs(s[k]) + Math.abs(s[k + 1]))) {\n                e[k] = 0;\n                break;\n            }\n        }\n        if (k === p - 2) {\n            kase = 4;\n        } else {\n            for (ks = p - 1; ks >= k; ks--) {\n                if (ks === k) {\n                    break;\n                }\n                t = (ks !== p ? Math.abs(e[ks]) : 0) + (ks !== k + 1 ? Math.abs(e[ks - 1]) : 0);\n                if (Math.abs(s[ks]) <= eps * t) {\n                    s[ks] = 0;\n                    break;\n                }\n            }\n            if (ks === k) {\n                kase = 3;\n            } else if (ks === p - 1) {\n                kase = 1;\n            } else {\n                kase = 2;\n                k = ks;\n            }\n        }\n\n        k++;\n\n        switch (kase) {\n            case 1: {\n                f = e[p - 2];\n                e[p - 2] = 0;\n                for (j = p - 2; j >= k; j--) {\n                    t = hypotenuse(s[j], f);\n                    cs = s[j] / t;\n                    sn = f / t;\n                    s[j] = t;\n                    if (j !== k) {\n                        f = -sn * e[j - 1];\n                        e[j - 1] = cs * e[j - 1];\n                    }\n                    if (wantv) {\n                        for (i = 0; i < n; i++) {\n                            t = cs * V[i][j] + sn * V[i][p - 1];\n                            V[i][p - 1] = -sn * V[i][j] + cs * V[i][p - 1];\n                            V[i][j] = t;\n                        }\n                    }\n                }\n                break;\n            }\n            case 2 : {\n                f = e[k - 1];\n                e[k - 1] = 0;\n                for (j = k; j < p; j++) {\n                    t = hypotenuse(s[j], f);\n                    cs = s[j] / t;\n                    sn = f / t;\n                    s[j] = t;\n                    f = -sn * e[j];\n                    e[j] = cs * e[j];\n                    if (wantu) {\n                        for (i = 0; i < m; i++) {\n                            t = cs * U[i][j] + sn * U[i][k - 1];\n                            U[i][k - 1] = -sn * U[i][j] + cs * U[i][k - 1];\n                            U[i][j] = t;\n                        }\n                    }\n                }\n                break;\n            }\n            case 3 : {\n                scale = Math.max(Math.max(Math.max(Math.max(Math.abs(s[p - 1]), Math.abs(s[p - 2])), Math.abs(e[p - 2])), Math.abs(s[k])), Math.abs(e[k]));\n                sp = s[p - 1] / scale;\n                spm1 = s[p - 2] / scale;\n                epm1 = e[p - 2] / scale;\n                sk = s[k] / scale;\n                ek = e[k] / scale;\n                b = ((spm1 + sp) * (spm1 - sp) + epm1 * epm1) / 2;\n                c = (sp * epm1) * (sp * epm1);\n                shift = 0;\n                if ((b !== 0) || (c !== 0)) {\n                    shift = Math.sqrt(b * b + c);\n                    if (b < 0) {\n                        shift = -shift;\n                    }\n                    shift = c / (b + shift);\n                }\n                f = (sk + sp) * (sk - sp) + shift;\n                g = sk * ek;\n                for (j = k; j < p - 1; j++) {\n                    t = hypotenuse(f, g);\n                    cs = f / t;\n                    sn = g / t;\n                    if (j !== k) {\n                        e[j - 1] = t;\n                    }\n                    f = cs * s[j] + sn * e[j];\n                    e[j] = cs * e[j] - sn * s[j];\n                    g = sn * s[j + 1];\n                    s[j + 1] = cs * s[j + 1];\n                    if (wantv) {\n                        for (i = 0; i < n; i++) {\n                            t = cs * V[i][j] + sn * V[i][j + 1];\n                            V[i][j + 1] = -sn * V[i][j] + cs * V[i][j + 1];\n                            V[i][j] = t;\n                        }\n                    }\n                    t = hypotenuse(f, g);\n                    cs = f / t;\n                    sn = g / t;\n                    s[j] = t;\n                    f = cs * e[j] + sn * s[j + 1];\n                    s[j + 1] = -sn * e[j] + cs * s[j + 1];\n                    g = sn * e[j + 1];\n                    e[j + 1] = cs * e[j + 1];\n                    if (wantu && (j < m - 1)) {\n                        for (i = 0; i < m; i++) {\n                            t = cs * U[i][j] + sn * U[i][j + 1];\n                            U[i][j + 1] = -sn * U[i][j] + cs * U[i][j + 1];\n                            U[i][j] = t;\n                        }\n                    }\n                }\n                e[p - 2] = f;\n                iter = iter + 1;\n                break;\n            }\n            case 4: {\n                if (s[k] <= 0) {\n                    s[k] = (s[k] < 0 ? -s[k] : 0);\n                    if (wantv) {\n                        for (i = 0; i <= pp; i++) {\n                            V[i][k] = -V[i][k];\n                        }\n                    }\n                }\n                while (k < pp) {\n                    if (s[k] >= s[k + 1]) {\n                        break;\n                    }\n                    t = s[k];\n                    s[k] = s[k + 1];\n                    s[k + 1] = t;\n                    if (wantv && (k < n - 1)) {\n                        for (i = 0; i < n; i++) {\n                            t = V[i][k + 1];\n                            V[i][k + 1] = V[i][k];\n                            V[i][k] = t;\n                        }\n                    }\n                    if (wantu && (k < m - 1)) {\n                        for (i = 0; i < m; i++) {\n                            t = U[i][k + 1];\n                            U[i][k + 1] = U[i][k];\n                            U[i][k] = t;\n                        }\n                    }\n                    k++;\n                }\n                iter = 0;\n                p--;\n                break;\n            }\n        }\n    }\n\n    if (swapped) {\n        var tmp = V;\n        V = U;\n        U = tmp;\n    }\n\n    this.m = m;\n    this.n = n;\n    this.s = s;\n    this.U = U;\n    this.V = V;\n}\n\nSingularValueDecomposition.prototype = {\n    get condition() {\n        return this.s[0] / this.s[Math.min(this.m, this.n) - 1];\n    },\n    get norm2() {\n        return this.s[0];\n    },\n    get rank() {\n        var eps = Math.pow(2, -52),\n            tol = Math.max(this.m, this.n) * this.s[0] * eps,\n            r = 0,\n            s = this.s;\n        for (var i = 0, ii = s.length; i < ii; i++) {\n            if (s[i] > tol) {\n                r++;\n            }\n        }\n        return r;\n    },\n    get diagonal() {\n        return this.s;\n    },\n    // https://github.com/accord-net/framework/blob/development/Sources/Accord.Math/Decompositions/SingularValueDecomposition.cs\n    get threshold() {\n        return (Math.pow(2, -52) / 2) * Math.max(this.m, this.n) * this.s[0];\n    },\n    get leftSingularVectors() {\n        return this.U;\n    },\n    get rightSingularVectors() {\n        return this.V;\n    },\n    get diagonalMatrix() {\n        return Matrix.diag(this.s);\n    },\n    solve: function (value) {\n\n        var Y = value,\n            e = this.threshold,\n            scols = this.s.length,\n            Ls = Matrix.zeros(scols, scols),\n            i;\n\n        for (i = 0; i < scols; i++) {\n            if (Math.abs(this.s[i]) <= e) {\n                Ls[i][i] = 0;\n            } else {\n                Ls[i][i] = 1 / this.s[i];\n            }\n        }\n\n\n        var VL = this.V.mmul(Ls),\n            vrows = this.V.rows,\n            urows = this.U.rows,\n            VLU = Matrix.zeros(vrows, urows),\n            j, k, sum;\n\n        for (i = 0; i < vrows; i++) {\n            for (j = 0; j < urows; j++) {\n                sum = 0;\n                for (k = 0; k < scols; k++) {\n                    sum += VL[i][k] * this.U[j][k];\n                }\n                VLU[i][j] = sum;\n            }\n        }\n\n        return VLU.mmul(Y);\n    },\n    solveForDiagonal: function (value) {\n        return this.solve(Matrix.diag(value));\n    },\n    inverse: function () {\n        var e = this.threshold,\n            vrows = this.V.rows,\n            vcols = this.V.columns,\n            X = new Matrix(vrows, this.s.length),\n            i, j;\n\n        for (i = 0; i < vrows; i++) {\n            for (j = 0; j < vcols; j++) {\n                if (Math.abs(this.s[j]) > e) {\n                    X[i][j] = this.V[i][j] / this.s[j];\n                } else {\n                    X[i][j] = 0;\n                }\n            }\n        }\n\n        var urows = this.U.rows,\n            ucols = this.U.columns,\n            Y = new Matrix(vrows, urows),\n            k, sum;\n\n        for (i = 0; i < vrows; i++) {\n            for (j = 0; j < urows; j++) {\n                sum = 0;\n                for (k = 0; k < ucols; k++) {\n                    sum += X[i][k] * this.U[j][k];\n                }\n                Y[i][j] = sum;\n            }\n        }\n\n        return Y;\n    }\n};\n\nmodule.exports = SingularValueDecomposition;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/ml-matrix/src/dc/svd.js\n ** module id = 8\n ** module chunks = 0\n **/","'use strict';\n\nexports.hypotenuse = function hypotenuse(a, b) {\n    var r;\n    if (Math.abs(a) > Math.abs(b)) {\n        r = b / a;\n        return Math.abs(a) * Math.sqrt(1 + r * r);\n    }\n    if (b !== 0) {\n        r = a / b;\n        return Math.abs(b) * Math.sqrt(1 + r * r);\n    }\n    return 0;\n};\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/ml-matrix/src/dc/util.js\n ** module id = 9\n ** module chunks = 0\n **/","'use strict';\n\nvar Matrix = require('../matrix');\nvar hypotenuse = require('./util').hypotenuse;\n\n// https://github.com/lutzroeder/Mapack/blob/master/Source/EigenvalueDecomposition.cs\nfunction EigenvalueDecomposition(matrix) {\n    if (!(this instanceof EigenvalueDecomposition)) {\n        return new EigenvalueDecomposition(matrix);\n    }\n    matrix = Matrix.checkMatrix(matrix);\n    if (!matrix.isSquare()) {\n        throw new Error('Matrix is not a square matrix');\n    }\n\n    var n = matrix.columns,\n        V = Matrix.zeros(n, n),\n        d = new Array(n),\n        e = new Array(n),\n        value = matrix,\n        i, j;\n\n    if (matrix.isSymmetric()) {\n        for (i = 0; i < n; i++) {\n            for (j = 0; j < n; j++) {\n                V[i][j] = value[i][j];\n            }\n        }\n        tred2(n, e, d, V);\n        tql2(n, e, d, V);\n    }\n    else {\n        var H = Matrix.zeros(n, n),\n            ort = new Array(n);\n        for (j = 0; j < n; j++) {\n            for (i = 0; i < n; i++) {\n                H[i][j] = value[i][j];\n            }\n        }\n        orthes(n, H, ort, V);\n        hqr2(n, e, d, V, H);\n    }\n\n    this.n = n;\n    this.e = e;\n    this.d = d;\n    this.V = V;\n}\n\nEigenvalueDecomposition.prototype = {\n    get realEigenvalues() {\n        return this.d;\n    },\n    get imaginaryEigenvalues() {\n        return this.e;\n    },\n    get eigenvectorMatrix() {\n        return this.V;\n    },\n    get diagonalMatrix() {\n        var n = this.n,\n            e = this.e,\n            d = this.d,\n            X = new Matrix(n, n),\n            i, j;\n        for (i = 0; i < n; i++) {\n            for (j = 0; j < n; j++) {\n                X[i][j] = 0;\n            }\n            X[i][i] = d[i];\n            if (e[i] > 0) {\n                X[i][i + 1] = e[i];\n            }\n            else if (e[i] < 0) {\n                X[i][i - 1] = e[i];\n            }\n        }\n        return X;\n    }\n};\n\nfunction tred2(n, e, d, V) {\n\n    var f, g, h, i, j, k,\n        hh, scale;\n\n    for (j = 0; j < n; j++) {\n        d[j] = V[n - 1][j];\n    }\n\n    for (i = n - 1; i > 0; i--) {\n        scale = 0;\n        h = 0;\n        for (k = 0; k < i; k++) {\n            scale = scale + Math.abs(d[k]);\n        }\n\n        if (scale === 0) {\n            e[i] = d[i - 1];\n            for (j = 0; j < i; j++) {\n                d[j] = V[i - 1][j];\n                V[i][j] = 0;\n                V[j][i] = 0;\n            }\n        } else {\n            for (k = 0; k < i; k++) {\n                d[k] /= scale;\n                h += d[k] * d[k];\n            }\n\n            f = d[i - 1];\n            g = Math.sqrt(h);\n            if (f > 0) {\n                g = -g;\n            }\n\n            e[i] = scale * g;\n            h = h - f * g;\n            d[i - 1] = f - g;\n            for (j = 0; j < i; j++) {\n                e[j] = 0;\n            }\n\n            for (j = 0; j < i; j++) {\n                f = d[j];\n                V[j][i] = f;\n                g = e[j] + V[j][j] * f;\n                for (k = j + 1; k <= i - 1; k++) {\n                    g += V[k][j] * d[k];\n                    e[k] += V[k][j] * f;\n                }\n                e[j] = g;\n            }\n\n            f = 0;\n            for (j = 0; j < i; j++) {\n                e[j] /= h;\n                f += e[j] * d[j];\n            }\n\n            hh = f / (h + h);\n            for (j = 0; j < i; j++) {\n                e[j] -= hh * d[j];\n            }\n\n            for (j = 0; j < i; j++) {\n                f = d[j];\n                g = e[j];\n                for (k = j; k <= i - 1; k++) {\n                    V[k][j] -= (f * e[k] + g * d[k]);\n                }\n                d[j] = V[i - 1][j];\n                V[i][j] = 0;\n            }\n        }\n        d[i] = h;\n    }\n\n    for (i = 0; i < n - 1; i++) {\n        V[n - 1][i] = V[i][i];\n        V[i][i] = 1;\n        h = d[i + 1];\n        if (h !== 0) {\n            for (k = 0; k <= i; k++) {\n                d[k] = V[k][i + 1] / h;\n            }\n\n            for (j = 0; j <= i; j++) {\n                g = 0;\n                for (k = 0; k <= i; k++) {\n                    g += V[k][i + 1] * V[k][j];\n                }\n                for (k = 0; k <= i; k++) {\n                    V[k][j] -= g * d[k];\n                }\n            }\n        }\n\n        for (k = 0; k <= i; k++) {\n            V[k][i + 1] = 0;\n        }\n    }\n\n    for (j = 0; j < n; j++) {\n        d[j] = V[n - 1][j];\n        V[n - 1][j] = 0;\n    }\n\n    V[n - 1][n - 1] = 1;\n    e[0] = 0;\n}\n\nfunction tql2(n, e, d, V) {\n\n    var g, h, i, j, k, l, m, p, r,\n        dl1, c, c2, c3, el1, s, s2,\n        iter;\n\n    for (i = 1; i < n; i++) {\n        e[i - 1] = e[i];\n    }\n\n    e[n - 1] = 0;\n\n    var f = 0,\n        tst1 = 0,\n        eps = Math.pow(2, -52);\n\n    for (l = 0; l < n; l++) {\n        tst1 = Math.max(tst1, Math.abs(d[l]) + Math.abs(e[l]));\n        m = l;\n        while (m < n) {\n            if (Math.abs(e[m]) <= eps * tst1) {\n                break;\n            }\n            m++;\n        }\n\n        if (m > l) {\n            iter = 0;\n            do {\n                iter = iter + 1;\n\n                g = d[l];\n                p = (d[l + 1] - g) / (2 * e[l]);\n                r = hypotenuse(p, 1);\n                if (p < 0) {\n                    r = -r;\n                }\n\n                d[l] = e[l] / (p + r);\n                d[l + 1] = e[l] * (p + r);\n                dl1 = d[l + 1];\n                h = g - d[l];\n                for (i = l + 2; i < n; i++) {\n                    d[i] -= h;\n                }\n\n                f = f + h;\n\n                p = d[m];\n                c = 1;\n                c2 = c;\n                c3 = c;\n                el1 = e[l + 1];\n                s = 0;\n                s2 = 0;\n                for (i = m - 1; i >= l; i--) {\n                    c3 = c2;\n                    c2 = c;\n                    s2 = s;\n                    g = c * e[i];\n                    h = c * p;\n                    r = hypotenuse(p, e[i]);\n                    e[i + 1] = s * r;\n                    s = e[i] / r;\n                    c = p / r;\n                    p = c * d[i] - s * g;\n                    d[i + 1] = h + s * (c * g + s * d[i]);\n\n                    for (k = 0; k < n; k++) {\n                        h = V[k][i + 1];\n                        V[k][i + 1] = s * V[k][i] + c * h;\n                        V[k][i] = c * V[k][i] - s * h;\n                    }\n                }\n\n                p = -s * s2 * c3 * el1 * e[l] / dl1;\n                e[l] = s * p;\n                d[l] = c * p;\n\n            }\n            while (Math.abs(e[l]) > eps * tst1);\n        }\n        d[l] = d[l] + f;\n        e[l] = 0;\n    }\n\n    for (i = 0; i < n - 1; i++) {\n        k = i;\n        p = d[i];\n        for (j = i + 1; j < n; j++) {\n            if (d[j] < p) {\n                k = j;\n                p = d[j];\n            }\n        }\n\n        if (k !== i) {\n            d[k] = d[i];\n            d[i] = p;\n            for (j = 0; j < n; j++) {\n                p = V[j][i];\n                V[j][i] = V[j][k];\n                V[j][k] = p;\n            }\n        }\n    }\n}\n\nfunction orthes(n, H, ort, V) {\n\n    var low = 0,\n        high = n - 1,\n        f, g, h, i, j, m,\n        scale;\n\n    for (m = low + 1; m <= high - 1; m++) {\n        scale = 0;\n        for (i = m; i <= high; i++) {\n            scale = scale + Math.abs(H[i][m - 1]);\n        }\n\n        if (scale !== 0) {\n            h = 0;\n            for (i = high; i >= m; i--) {\n                ort[i] = H[i][m - 1] / scale;\n                h += ort[i] * ort[i];\n            }\n\n            g = Math.sqrt(h);\n            if (ort[m] > 0) {\n                g = -g;\n            }\n\n            h = h - ort[m] * g;\n            ort[m] = ort[m] - g;\n\n            for (j = m; j < n; j++) {\n                f = 0;\n                for (i = high; i >= m; i--) {\n                    f += ort[i] * H[i][j];\n                }\n\n                f = f / h;\n                for (i = m; i <= high; i++) {\n                    H[i][j] -= f * ort[i];\n                }\n            }\n\n            for (i = 0; i <= high; i++) {\n                f = 0;\n                for (j = high; j >= m; j--) {\n                    f += ort[j] * H[i][j];\n                }\n\n                f = f / h;\n                for (j = m; j <= high; j++) {\n                    H[i][j] -= f * ort[j];\n                }\n            }\n\n            ort[m] = scale * ort[m];\n            H[m][m - 1] = scale * g;\n        }\n    }\n\n    for (i = 0; i < n; i++) {\n        for (j = 0; j < n; j++) {\n            V[i][j] = (i === j ? 1 : 0);\n        }\n    }\n\n    for (m = high - 1; m >= low + 1; m--) {\n        if (H[m][m - 1] !== 0) {\n            for (i = m + 1; i <= high; i++) {\n                ort[i] = H[i][m - 1];\n            }\n\n            for (j = m; j <= high; j++) {\n                g = 0;\n                for (i = m; i <= high; i++) {\n                    g += ort[i] * V[i][j];\n                }\n\n                g = (g / ort[m]) / H[m][m - 1];\n                for (i = m; i <= high; i++) {\n                    V[i][j] += g * ort[i];\n                }\n            }\n        }\n    }\n}\n\nfunction hqr2(nn, e, d, V, H) {\n    var n = nn - 1,\n        low = 0,\n        high = nn - 1,\n        eps = Math.pow(2, -52),\n        exshift = 0,\n        norm = 0,\n        p = 0,\n        q = 0,\n        r = 0,\n        s = 0,\n        z = 0,\n        iter = 0,\n        i, j, k, l, m, t, w, x, y,\n        ra, sa, vr, vi,\n        notlast, cdivres;\n\n    for (i = 0; i < nn; i++) {\n        if (i < low || i > high) {\n            d[i] = H[i][i];\n            e[i] = 0;\n        }\n\n        for (j = Math.max(i - 1, 0); j < nn; j++) {\n            norm = norm + Math.abs(H[i][j]);\n        }\n    }\n\n    while (n >= low) {\n        l = n;\n        while (l > low) {\n            s = Math.abs(H[l - 1][l - 1]) + Math.abs(H[l][l]);\n            if (s === 0) {\n                s = norm;\n            }\n            if (Math.abs(H[l][l - 1]) < eps * s) {\n                break;\n            }\n            l--;\n        }\n\n        if (l === n) {\n            H[n][n] = H[n][n] + exshift;\n            d[n] = H[n][n];\n            e[n] = 0;\n            n--;\n            iter = 0;\n        } else if (l === n - 1) {\n            w = H[n][n - 1] * H[n - 1][n];\n            p = (H[n - 1][n - 1] - H[n][n]) / 2;\n            q = p * p + w;\n            z = Math.sqrt(Math.abs(q));\n            H[n][n] = H[n][n] + exshift;\n            H[n - 1][n - 1] = H[n - 1][n - 1] + exshift;\n            x = H[n][n];\n\n            if (q >= 0) {\n                z = (p >= 0) ? (p + z) : (p - z);\n                d[n - 1] = x + z;\n                d[n] = d[n - 1];\n                if (z !== 0) {\n                    d[n] = x - w / z;\n                }\n                e[n - 1] = 0;\n                e[n] = 0;\n                x = H[n][n - 1];\n                s = Math.abs(x) + Math.abs(z);\n                p = x / s;\n                q = z / s;\n                r = Math.sqrt(p * p + q * q);\n                p = p / r;\n                q = q / r;\n\n                for (j = n - 1; j < nn; j++) {\n                    z = H[n - 1][j];\n                    H[n - 1][j] = q * z + p * H[n][j];\n                    H[n][j] = q * H[n][j] - p * z;\n                }\n\n                for (i = 0; i <= n; i++) {\n                    z = H[i][n - 1];\n                    H[i][n - 1] = q * z + p * H[i][n];\n                    H[i][n] = q * H[i][n] - p * z;\n                }\n\n                for (i = low; i <= high; i++) {\n                    z = V[i][n - 1];\n                    V[i][n - 1] = q * z + p * V[i][n];\n                    V[i][n] = q * V[i][n] - p * z;\n                }\n            } else {\n                d[n - 1] = x + p;\n                d[n] = x + p;\n                e[n - 1] = z;\n                e[n] = -z;\n            }\n\n            n = n - 2;\n            iter = 0;\n        } else {\n            x = H[n][n];\n            y = 0;\n            w = 0;\n            if (l < n) {\n                y = H[n - 1][n - 1];\n                w = H[n][n - 1] * H[n - 1][n];\n            }\n\n            if (iter === 10) {\n                exshift += x;\n                for (i = low; i <= n; i++) {\n                    H[i][i] -= x;\n                }\n                s = Math.abs(H[n][n - 1]) + Math.abs(H[n - 1][n - 2]);\n                x = y = 0.75 * s;\n                w = -0.4375 * s * s;\n            }\n\n            if (iter === 30) {\n                s = (y - x) / 2;\n                s = s * s + w;\n                if (s > 0) {\n                    s = Math.sqrt(s);\n                    if (y < x) {\n                        s = -s;\n                    }\n                    s = x - w / ((y - x) / 2 + s);\n                    for (i = low; i <= n; i++) {\n                        H[i][i] -= s;\n                    }\n                    exshift += s;\n                    x = y = w = 0.964;\n                }\n            }\n\n            iter = iter + 1;\n\n            m = n - 2;\n            while (m >= l) {\n                z = H[m][m];\n                r = x - z;\n                s = y - z;\n                p = (r * s - w) / H[m + 1][m] + H[m][m + 1];\n                q = H[m + 1][m + 1] - z - r - s;\n                r = H[m + 2][m + 1];\n                s = Math.abs(p) + Math.abs(q) + Math.abs(r);\n                p = p / s;\n                q = q / s;\n                r = r / s;\n                if (m === l) {\n                    break;\n                }\n                if (Math.abs(H[m][m - 1]) * (Math.abs(q) + Math.abs(r)) < eps * (Math.abs(p) * (Math.abs(H[m - 1][m - 1]) + Math.abs(z) + Math.abs(H[m + 1][m + 1])))) {\n                    break;\n                }\n                m--;\n            }\n\n            for (i = m + 2; i <= n; i++) {\n                H[i][i - 2] = 0;\n                if (i > m + 2) {\n                    H[i][i - 3] = 0;\n                }\n            }\n\n            for (k = m; k <= n - 1; k++) {\n                notlast = (k !== n - 1);\n                if (k !== m) {\n                    p = H[k][k - 1];\n                    q = H[k + 1][k - 1];\n                    r = (notlast ? H[k + 2][k - 1] : 0);\n                    x = Math.abs(p) + Math.abs(q) + Math.abs(r);\n                    if (x !== 0) {\n                        p = p / x;\n                        q = q / x;\n                        r = r / x;\n                    }\n                }\n\n                if (x === 0) {\n                    break;\n                }\n\n                s = Math.sqrt(p * p + q * q + r * r);\n                if (p < 0) {\n                    s = -s;\n                }\n\n                if (s !== 0) {\n                    if (k !== m) {\n                        H[k][k - 1] = -s * x;\n                    } else if (l !== m) {\n                        H[k][k - 1] = -H[k][k - 1];\n                    }\n\n                    p = p + s;\n                    x = p / s;\n                    y = q / s;\n                    z = r / s;\n                    q = q / p;\n                    r = r / p;\n\n                    for (j = k; j < nn; j++) {\n                        p = H[k][j] + q * H[k + 1][j];\n                        if (notlast) {\n                            p = p + r * H[k + 2][j];\n                            H[k + 2][j] = H[k + 2][j] - p * z;\n                        }\n\n                        H[k][j] = H[k][j] - p * x;\n                        H[k + 1][j] = H[k + 1][j] - p * y;\n                    }\n\n                    for (i = 0; i <= Math.min(n, k + 3); i++) {\n                        p = x * H[i][k] + y * H[i][k + 1];\n                        if (notlast) {\n                            p = p + z * H[i][k + 2];\n                            H[i][k + 2] = H[i][k + 2] - p * r;\n                        }\n\n                        H[i][k] = H[i][k] - p;\n                        H[i][k + 1] = H[i][k + 1] - p * q;\n                    }\n\n                    for (i = low; i <= high; i++) {\n                        p = x * V[i][k] + y * V[i][k + 1];\n                        if (notlast) {\n                            p = p + z * V[i][k + 2];\n                            V[i][k + 2] = V[i][k + 2] - p * r;\n                        }\n\n                        V[i][k] = V[i][k] - p;\n                        V[i][k + 1] = V[i][k + 1] - p * q;\n                    }\n                }\n            }\n        }\n    }\n\n    if (norm === 0) {\n        return;\n    }\n\n    for (n = nn - 1; n >= 0; n--) {\n        p = d[n];\n        q = e[n];\n\n        if (q === 0) {\n            l = n;\n            H[n][n] = 1;\n            for (i = n - 1; i >= 0; i--) {\n                w = H[i][i] - p;\n                r = 0;\n                for (j = l; j <= n; j++) {\n                    r = r + H[i][j] * H[j][n];\n                }\n\n                if (e[i] < 0) {\n                    z = w;\n                    s = r;\n                } else {\n                    l = i;\n                    if (e[i] === 0) {\n                        H[i][n] = (w !== 0) ? (-r / w) : (-r / (eps * norm));\n                    } else {\n                        x = H[i][i + 1];\n                        y = H[i + 1][i];\n                        q = (d[i] - p) * (d[i] - p) + e[i] * e[i];\n                        t = (x * s - z * r) / q;\n                        H[i][n] = t;\n                        H[i + 1][n] = (Math.abs(x) > Math.abs(z)) ? ((-r - w * t) / x) : ((-s - y * t) / z);\n                    }\n\n                    t = Math.abs(H[i][n]);\n                    if ((eps * t) * t > 1) {\n                        for (j = i; j <= n; j++) {\n                            H[j][n] = H[j][n] / t;\n                        }\n                    }\n                }\n            }\n        } else if (q < 0) {\n            l = n - 1;\n\n            if (Math.abs(H[n][n - 1]) > Math.abs(H[n - 1][n])) {\n                H[n - 1][n - 1] = q / H[n][n - 1];\n                H[n - 1][n] = -(H[n][n] - p) / H[n][n - 1];\n            } else {\n                cdivres = cdiv(0, -H[n - 1][n], H[n - 1][n - 1] - p, q);\n                H[n - 1][n - 1] = cdivres[0];\n                H[n - 1][n] = cdivres[1];\n            }\n\n            H[n][n - 1] = 0;\n            H[n][n] = 1;\n            for (i = n - 2; i >= 0; i--) {\n                ra = 0;\n                sa = 0;\n                for (j = l; j <= n; j++) {\n                    ra = ra + H[i][j] * H[j][n - 1];\n                    sa = sa + H[i][j] * H[j][n];\n                }\n\n                w = H[i][i] - p;\n\n                if (e[i] < 0) {\n                    z = w;\n                    r = ra;\n                    s = sa;\n                } else {\n                    l = i;\n                    if (e[i] === 0) {\n                        cdivres = cdiv(-ra, -sa, w, q);\n                        H[i][n - 1] = cdivres[0];\n                        H[i][n] = cdivres[1];\n                    } else {\n                        x = H[i][i + 1];\n                        y = H[i + 1][i];\n                        vr = (d[i] - p) * (d[i] - p) + e[i] * e[i] - q * q;\n                        vi = (d[i] - p) * 2 * q;\n                        if (vr === 0 && vi === 0) {\n                            vr = eps * norm * (Math.abs(w) + Math.abs(q) + Math.abs(x) + Math.abs(y) + Math.abs(z));\n                        }\n                        cdivres = cdiv(x * r - z * ra + q * sa, x * s - z * sa - q * ra, vr, vi);\n                        H[i][n - 1] = cdivres[0];\n                        H[i][n] = cdivres[1];\n                        if (Math.abs(x) > (Math.abs(z) + Math.abs(q))) {\n                            H[i + 1][n - 1] = (-ra - w * H[i][n - 1] + q * H[i][n]) / x;\n                            H[i + 1][n] = (-sa - w * H[i][n] - q * H[i][n - 1]) / x;\n                        } else {\n                            cdivres = cdiv(-r - y * H[i][n - 1], -s - y * H[i][n], z, q);\n                            H[i + 1][n - 1] = cdivres[0];\n                            H[i + 1][n] = cdivres[1];\n                        }\n                    }\n\n                    t = Math.max(Math.abs(H[i][n - 1]), Math.abs(H[i][n]));\n                    if ((eps * t) * t > 1) {\n                        for (j = i; j <= n; j++) {\n                            H[j][n - 1] = H[j][n - 1] / t;\n                            H[j][n] = H[j][n] / t;\n                        }\n                    }\n                }\n            }\n        }\n    }\n\n    for (i = 0; i < nn; i++) {\n        if (i < low || i > high) {\n            for (j = i; j < nn; j++) {\n                V[i][j] = H[i][j];\n            }\n        }\n    }\n\n    for (j = nn - 1; j >= low; j--) {\n        for (i = low; i <= high; i++) {\n            z = 0;\n            for (k = low; k <= Math.min(j, high); k++) {\n                z = z + V[i][k] * H[k][j];\n            }\n            V[i][j] = z;\n        }\n    }\n}\n\nfunction cdiv(xr, xi, yr, yi) {\n    var r, d;\n    if (Math.abs(yr) > Math.abs(yi)) {\n        r = yi / yr;\n        d = yr + r * yi;\n        return [(xr + r * xi) / d, (xi - r * xr) / d];\n    }\n    else {\n        r = yr / yi;\n        d = yi + r * yr;\n        return [(r * xr + xi) / d, (r * xi - xr) / d];\n    }\n}\n\nmodule.exports = EigenvalueDecomposition;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/ml-matrix/src/dc/evd.js\n ** module id = 10\n ** module chunks = 0\n **/","'use strict';\n\nvar Matrix = require('../matrix');\n\n// https://github.com/lutzroeder/Mapack/blob/master/Source/LuDecomposition.cs\nfunction LuDecomposition(matrix) {\n    if (!(this instanceof LuDecomposition)) {\n        return new LuDecomposition(matrix);\n    }\n    matrix = Matrix.checkMatrix(matrix);\n\n    var lu = matrix.clone(),\n        rows = lu.rows,\n        columns = lu.columns,\n        pivotVector = new Array(rows),\n        pivotSign = 1,\n        i, j, k, p, s, t, v,\n        LUrowi, LUcolj, kmax;\n\n    for (i = 0; i < rows; i++) {\n        pivotVector[i] = i;\n    }\n\n    LUcolj = new Array(rows);\n\n    for (j = 0; j < columns; j++) {\n\n        for (i = 0; i < rows; i++) {\n            LUcolj[i] = lu[i][j];\n        }\n\n        for (i = 0; i < rows; i++) {\n            LUrowi = lu[i];\n            kmax = Math.min(i, j);\n            s = 0;\n            for (k = 0; k < kmax; k++) {\n                s += LUrowi[k] * LUcolj[k];\n            }\n            LUrowi[j] = LUcolj[i] -= s;\n        }\n\n        p = j;\n        for (i = j + 1; i < rows; i++) {\n            if (Math.abs(LUcolj[i]) > Math.abs(LUcolj[p])) {\n                p = i;\n            }\n        }\n\n        if (p !== j) {\n            for (k = 0; k < columns; k++) {\n                t = lu[p][k];\n                lu[p][k] = lu[j][k];\n                lu[j][k] = t;\n            }\n\n            v = pivotVector[p];\n            pivotVector[p] = pivotVector[j];\n            pivotVector[j] = v;\n\n            pivotSign = -pivotSign;\n        }\n\n        if (j < rows && lu[j][j] !== 0) {\n            for (i = j + 1; i < rows; i++) {\n                lu[i][j] /= lu[j][j];\n            }\n        }\n    }\n\n    this.LU = lu;\n    this.pivotVector = pivotVector;\n    this.pivotSign = pivotSign;\n}\n\nLuDecomposition.prototype = {\n    isSingular: function () {\n        var data = this.LU,\n            col = data.columns;\n        for (var j = 0; j < col; j++) {\n            if (data[j][j] === 0) {\n                return true;\n            }\n        }\n        return false;\n    },\n    get determinant() {\n        var data = this.LU;\n        if (!data.isSquare())\n            throw new Error('Matrix must be square');\n        var determinant = this.pivotSign, col = data.columns;\n        for (var j = 0; j < col; j++)\n            determinant *= data[j][j];\n        return determinant;\n    },\n    get lowerTriangularFactor() {\n        var data = this.LU,\n            rows = data.rows,\n            columns = data.columns,\n            X = new Matrix(rows, columns);\n        for (var i = 0; i < rows; i++) {\n            for (var j = 0; j < columns; j++) {\n                if (i > j) {\n                    X[i][j] = data[i][j];\n                } else if (i === j) {\n                    X[i][j] = 1;\n                } else {\n                    X[i][j] = 0;\n                }\n            }\n        }\n        return X;\n    },\n    get upperTriangularFactor() {\n        var data = this.LU,\n            rows = data.rows,\n            columns = data.columns,\n            X = new Matrix(rows, columns);\n        for (var i = 0; i < rows; i++) {\n            for (var j = 0; j < columns; j++) {\n                if (i <= j) {\n                    X[i][j] = data[i][j];\n                } else {\n                    X[i][j] = 0;\n                }\n            }\n        }\n        return X;\n    },\n    get pivotPermutationVector() {\n        return this.pivotVector.slice();\n    },\n    solve: function (value) {\n        value = Matrix.checkMatrix(value);\n\n        var lu = this.LU,\n            rows = lu.rows;\n\n        if (rows !== value.rows)\n            throw new Error('Invalid matrix dimensions');\n        if (this.isSingular())\n            throw new Error('LU matrix is singular');\n\n        var count = value.columns,\n            X = value.subMatrixRow(this.pivotVector, 0, count - 1),\n            columns = lu.columns,\n            i, j, k;\n\n        for (k = 0; k < columns; k++) {\n            for (i = k + 1; i < columns; i++) {\n                for (j = 0; j < count; j++) {\n                    X[i][j] -= X[k][j] * lu[i][k];\n                }\n            }\n        }\n        for (k = columns - 1; k >= 0; k--) {\n            for (j = 0; j < count; j++) {\n                X[k][j] /= lu[k][k];\n            }\n            for (i = 0; i < k; i++) {\n                for (j = 0; j < count; j++) {\n                    X[i][j] -= X[k][j] * lu[i][k];\n                }\n            }\n        }\n        return X;\n    }\n};\n\nmodule.exports = LuDecomposition;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/ml-matrix/src/dc/lu.js\n ** module id = 11\n ** module chunks = 0\n **/","'use strict';\n\nvar Matrix = require('../matrix');\nvar hypotenuse = require('./util').hypotenuse;\n\n//https://github.com/lutzroeder/Mapack/blob/master/Source/QrDecomposition.cs\nfunction QrDecomposition(value) {\n    if (!(this instanceof QrDecomposition)) {\n        return new QrDecomposition(value);\n    }\n    value = Matrix.checkMatrix(value);\n\n    var qr = value.clone(),\n        m = value.rows,\n        n = value.columns,\n        rdiag = new Array(n),\n        i, j, k, s;\n\n    for (k = 0; k < n; k++) {\n        var nrm = 0;\n        for (i = k; i < m; i++) {\n            nrm = hypotenuse(nrm, qr[i][k]);\n        }\n        if (nrm !== 0) {\n            if (qr[k][k] < 0) {\n                nrm = -nrm;\n            }\n            for (i = k; i < m; i++) {\n                qr[i][k] /= nrm;\n            }\n            qr[k][k] += 1;\n            for (j = k + 1; j < n; j++) {\n                s = 0;\n                for (i = k; i < m; i++) {\n                    s += qr[i][k] * qr[i][j];\n                }\n                s = -s / qr[k][k];\n                for (i = k; i < m; i++) {\n                    qr[i][j] += s * qr[i][k];\n                }\n            }\n        }\n        rdiag[k] = -nrm;\n    }\n\n    this.QR = qr;\n    this.Rdiag = rdiag;\n}\n\nQrDecomposition.prototype = {\n    solve: function (value) {\n        value = Matrix.checkMatrix(value);\n\n        var qr = this.QR,\n            m = qr.rows;\n\n        if (value.rows !== m)\n            throw new Error('Matrix row dimensions must agree');\n        if (!this.isFullRank())\n            throw new Error('Matrix is rank deficient');\n\n        var count = value.columns,\n            X = value.clone(),\n            n = qr.columns,\n            i, j, k, s;\n\n        for (k = 0; k < n; k++) {\n            for (j = 0; j < count; j++) {\n                s = 0;\n                for (i = k; i < m; i++) {\n                    s += qr[i][k] * X[i][j];\n                }\n                s = -s / qr[k][k];\n                for (i = k; i < m; i++) {\n                    X[i][j] += s * qr[i][k];\n                }\n            }\n        }\n        for (k = n - 1; k >= 0; k--) {\n            for (j = 0; j < count; j++) {\n                X[k][j] /= this.Rdiag[k];\n            }\n            for (i = 0; i < k; i++) {\n                for (j = 0; j < count; j++) {\n                    X[i][j] -= X[k][j] * qr[i][k];\n                }\n            }\n        }\n\n        return X.subMatrix(0, n - 1, 0, count - 1);\n    },\n    isFullRank: function () {\n        var columns = this.QR.columns;\n        for (var i = 0; i < columns; i++) {\n            if (this.Rdiag[i] === 0) {\n                return false;\n            }\n        }\n        return true;\n    },\n    get upperTriangularFactor() {\n        var qr = this.QR,\n            n = qr.columns,\n            X = new Matrix(n, n),\n            i, j;\n        for (i = 0; i < n; i++) {\n            for (j = 0; j < n; j++) {\n                if (i < j) {\n                    X[i][j] = qr[i][j];\n                } else if (i === j) {\n                    X[i][j] = this.Rdiag[i];\n                } else {\n                    X[i][j] = 0;\n                }\n            }\n        }\n        return X;\n    },\n    get orthogonalFactor() {\n        var qr = this.QR,\n            rows = qr.rows,\n            columns = qr.columns,\n            X = new Matrix(rows, columns),\n            i, j, k, s;\n\n        for (k = columns - 1; k >= 0; k--) {\n            for (i = 0; i < rows; i++) {\n                X[i][k] = 0;\n            }\n            X[k][k] = 1;\n            for (j = k; j < columns; j++) {\n                if (qr[k][k] !== 0) {\n                    s = 0;\n                    for (i = k; i < rows; i++) {\n                        s += qr[i][k] * X[i][j];\n                    }\n\n                    s = -s / qr[k][k];\n\n                    for (i = k; i < rows; i++) {\n                        X[i][j] += s * qr[i][k];\n                    }\n                }\n            }\n        }\n        return X;\n    }\n};\n\nmodule.exports = QrDecomposition;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/ml-matrix/src/dc/qr.js\n ** module id = 12\n ** module chunks = 0\n **/","'use strict';\n\nvar Matrix = require('../matrix');\n\n// https://github.com/lutzroeder/Mapack/blob/master/Source/CholeskyDecomposition.cs\nfunction CholeskyDecomposition(value) {\n    if (!(this instanceof CholeskyDecomposition)) {\n        return new CholeskyDecomposition(value);\n    }\n    value = Matrix.checkMatrix(value);\n    if (!value.isSymmetric())\n        throw new Error('Matrix is not symmetric');\n\n    var a = value,\n        dimension = a.rows,\n        l = new Matrix(dimension, dimension),\n        positiveDefinite = true,\n        i, j, k;\n\n    for (j = 0; j < dimension; j++) {\n        var Lrowj = l[j];\n        var d = 0;\n        for (k = 0; k < j; k++) {\n            var Lrowk = l[k];\n            var s = 0;\n            for (i = 0; i < k; i++) {\n                s += Lrowk[i] * Lrowj[i];\n            }\n            Lrowj[k] = s = (a[j][k] - s) / l[k][k];\n            d = d + s * s;\n        }\n\n        d = a[j][j] - d;\n\n        positiveDefinite &= (d > 0);\n        l[j][j] = Math.sqrt(Math.max(d, 0));\n        for (k = j + 1; k < dimension; k++) {\n            l[j][k] = 0;\n        }\n    }\n\n    if (!positiveDefinite) {\n        throw new Error('Matrix is not positive definite');\n    }\n\n    this.L = l;\n}\n\nCholeskyDecomposition.prototype = {\n    get leftTriangularFactor() {\n        return this.L;\n    },\n    solve: function (value) {\n        value = Matrix.checkMatrix(value);\n\n        var l = this.L,\n            dimension = l.rows;\n\n        if (value.rows !== dimension) {\n            throw new Error('Matrix dimensions do not match');\n        }\n\n        var count = value.columns,\n            B = value.clone(),\n            i, j, k;\n\n        for (k = 0; k < dimension; k++) {\n            for (j = 0; j < count; j++) {\n                for (i = 0; i < k; i++) {\n                    B[k][j] -= B[i][j] * l[k][i];\n                }\n                B[k][j] /= l[k][k];\n            }\n        }\n\n        for (k = dimension - 1; k >= 0; k--) {\n            for (j = 0; j < count; j++) {\n                for (i = k + 1; i < dimension; i++) {\n                    B[k][j] -= B[i][j] * l[i][k];\n                }\n                B[k][j] /= l[k][k];\n            }\n        }\n\n        return B;\n    }\n};\n\nmodule.exports = CholeskyDecomposition;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/ml-matrix/src/dc/cholesky.js\n ** module id = 13\n ** module chunks = 0\n **/","/**\n * Created by acastillo on 8/24/15.\n */\n/**\n * Non in-place function definitions, compatible with mathjs code *\n */\n\n'use strict';\n\nvar Matrix = require('ml-matrix');\n\nfunction matrix(A,B){\n    return new Matrix(A,B);\n}\n\nfunction ones(rows, cols){\n    return Matrix.ones(rows,cols);\n}\n\nfunction eye(rows, cols){\n    return Matrix.eye(rows, cols);\n}\n\nfunction zeros(rows, cols){\n    return Matrix.zeros(rows, cols);\n}\n\nfunction random(rows, cols){\n    return Matrix.rand(rows,cols);\n}\n\nfunction transpose(A){\n    if(typeof A == 'number')\n        return A;\n    var result = A.clone();\n    return result.transpose();\n}\n\nfunction add(A, B){\n    if(typeof A == 'number'&&typeof B === 'number')\n        return A+B;\n    if(typeof A == 'number')\n        return this.add(B,A);\n\n    var result = A.clone();\n    return result.add(B);\n\n}\n\nfunction subtract(A, B){\n    if(typeof A == 'number'&&typeof B === 'number')\n        return A-B;\n    if(typeof A == 'number')\n        return this.subtract(B,A);\n    var result = A.clone();\n    return result.sub(B);\n}\n\nfunction multiply(A, B){\n    if(typeof A == 'number'&&typeof B === 'number')\n        return A*B;\n    if(typeof A == 'number')\n        return this.multiply(B,A);\n\n    var result = A.clone();\n\n    if(typeof B === 'number')\n        result.mul(B);\n    else\n        result = result.mmul(B);\n\n    if(result.rows==1&&result.columns==1)\n        return result[0][0];\n    else\n        return result;\n\n}\n\nfunction dotMultiply(A, B){\n    var result = A.clone();\n    return result.mul(B);\n}\n\nfunction dotDivide(A, B){\n    var result = A.clone();\n    return result.div(B);\n}\n\nfunction diag(A){\n    var diag = null;\n    var rows = A.rows, cols = A.columns, j, r;\n    //It is an array\n    if(typeof cols === \"undefined\" && (typeof A)=='object'){\n        if(A[0]&&A[0].length){\n            rows = A.length;\n            cols = A[0].length;\n            r = Math.min(rows,cols);\n            diag = Matrix.zeros(cols, cols);\n            for (j = 0; j < cols; j++) {\n                diag[j][j]=A[j][j];\n            }\n        }\n        else{\n            cols = A.length;\n            diag = Matrix.zeros(cols, cols);\n            for (j = 0; j < cols; j++) {\n                diag[j][j]=A[j];\n            }\n        }\n\n    }\n    if(rows == 1){\n        diag = Matrix.zeros(cols, cols);\n        for (j = 0; j < cols; j++) {\n            diag[j][j]=A[0][j];\n        }\n    }\n    else{\n        if(rows>0 && cols > 0){\n            r = Math.min(rows,cols);\n            diag = new Array(r);\n            for (j = 0; j < r; j++) {\n                diag[j] = A[j][j];\n            }\n        }\n    }\n    return diag;\n}\n\nfunction min(A, B){\n    if(typeof A==='number' && typeof B ==='number')\n        return Math.min(A,B);\n    var ii = A.rows, jj = A.columns;\n    var result = new Matrix(ii,jj);\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            if (A[i][j] < B[i][j]) {\n                result[i][j] = A[i][j];\n            }\n            else{\n                result[i][j] = B[i][j];\n            }\n        }\n    }\n    return result;\n}\n\nfunction max(A, B){\n    if(typeof A==='number' && typeof B ==='number')\n        return Math.max(A,B);\n    var ii = A.rows, jj = A.columns;\n    var result = new Matrix(ii,jj);\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            if (A[i][j] > B[i][j]) {\n                result[i][j] = A[i][j];\n            }\n            else{\n                result[i][j] = B[i][j];\n            }\n        }\n    }\n    return result;\n}\n\nfunction sqrt(A){\n    if(typeof A==='number' )\n        return Math.sqrt(A);\n    var ii = A.rows, jj = A.columns;\n    var result = new Matrix(ii,jj);\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            result[i][j] = Math.sqrt(A[i][j]);\n\n        }\n    }\n    return result;\n}\n\nfunction abs(A){\n    if(typeof A==='number' )\n        return Math.abs(A);\n    var ii = A.rows, jj = A.columns;\n    var result = new Matrix(ii,jj);\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            result[i][j] = Math.abs(A[i][j]);\n\n        }\n    }\n    return result;\n}\n\nfunction exp(A){\n    if(typeof A==='number' )\n        return Math.sqrt(A);\n    var ii = A.rows, jj = A.columns;\n    var result = new Matrix(ii,jj);\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            result[i][j] = Math.exp(A[i][j]);\n        }\n    }\n    return result;\n}\n\nfunction dotPow(A, b){\n    if(typeof A==='number' )\n        return Math.pow(A,b);\n    //console.log(A);\n    var ii = A.rows, jj = A.columns;\n    var result = new Matrix(ii,jj);\n    for (var i = 0; i < ii; i++) {\n        for (var j = 0; j < jj; j++) {\n            result[i][j] = Math.pow(A[i][j],b);\n        }\n    }\n    return result;\n}\n\nfunction solve(A, B){\n    return A.solve(B);\n}\n\nfunction inv(A){\n    if(typeof A ===\"number\")\n        return 1/A;\n    return A.inverse();\n}\n\nmodule.exports = {\n    transpose:transpose,\n    add:add,\n    subtract:subtract,\n    multiply:multiply,\n    dotMultiply:dotMultiply,\n    dotDivide:dotDivide,\n    diag:diag,\n    min:min,\n    max:max,\n    solve:solve,\n    inv:inv,\n    sqrt:sqrt,\n    exp:exp,\n    dotPow:dotPow,\n    abs:abs,\n    matrix:matrix,\n    ones:ones,\n    zeros:zeros,\n    random:random,\n    eye:eye\n};\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/ml-curve-fitting/src/algebra.js\n ** module id = 14\n ** module chunks = 0\n **/","var Opt = require(\"ml-optimize-lorentzian\");\n\nfunction gsd(x, y, options){\n    var options=Object.create(options || {});\n    if (options.minMaxRatio===undefined) options.minMaxRatio=0.00025;\n    if (options.broadRatio===undefined) options.broadRatio=0.00;\n    if (options.noiseLevel===undefined) options.noiseLevel=0;\n    if (options.maxCriteria===undefined) options.maxCriteria=true;\n    if (options.smoothY===undefined) options.smoothY=true;\n\n\n    if (options.noiseLevel>0) {\n        y=[].concat(y);\n        for (var i=0; i<y.length; i++){\n            if(Math.abs(y[i])<options.noiseLevel) {\n                y[i]=0;\n            }\n        }\n    }\n\n    // fill convolution frequency axis\n    var X = [];//x[2:(x.length-2)];\n\n    // fill Savitzky-Golay polynomes\n    var size= x.length-4;\n    var Y = new Array(size);\n    var dY = new Array(size);\n    var ddY = new Array(size);\n    //var dX = new Array(size);\n    var dx = x[1]-x[0];\n\n    for (var j = 2; j < size+2; j++) {\n        dx = x[j]-x[j-1];\n        if(options.smoothY)\n            Y[j-2]=(1/35.0)*(-3*y[j-2] + 12*y[j-1] + 17*y[j] + 12*y[j+1] - 3*y[j+2]);\n        else\n            Y[j-2]=y[j];\n        X[j-2]=x[j];\n        dY[j-2]=(1/(12*dx))*(y[j-2] - 8*y[j-1] + 8*y[j+1] - y[j+2]);\n        ddY[j-2]=(1/(7*dx*dx))*(2*y[j-2] - y[j-1] - 2*y[j] - y[j+1] + 2*y[j+2]);\n    }\n\n    var maxDdy=0;\n    var maxY = 0;\n    //console.log(Y.length);\n    for (var i = 0; i < Y.length ; i++){\n        if(Math.abs(ddY[i])>maxDdy){\n            maxDdy = Math.abs(ddY[i]);\n        }\n        if(Math.abs(Y[i])>maxY){\n            maxY = Math.abs(Y[i]);\n        }\n    }\n    //console.log(maxY+\"x\"+maxDy+\"x\"+maxDdy);\n    var minddY = [];\n    var intervals = [];\n    var lastMax = null;\n    var lastMin = null;\n    var broadMask = new Array();\n    //console.log(dx);\n    //By the intermediate value theorem We cannot find 2 consecutive maxima or minima\n    for (var i = 1; i < Y.length -1 ; i++){\n        //console.log(dY[i]);\n        if ((dY[i] < dY[i-1]) && (dY[i] <= dY[i+1])||\n            (dY[i] <= dY[i-1]) && (dY[i] < dY[i+1])) {\n            lastMin = X[i];\n            //console.log(\"min \"+lastMin);\n            if(dx>0&&lastMax!=null){\n                intervals.push( [lastMax , lastMin] );\n            }\n        }\n\n        if ((dY[i] >= dY[i-1]) && (dY[i] > dY[i+1])||\n            (dY[i] > dY[i-1]) && (dY[i] >= dY[i+1])) {\n            lastMax = X[i];\n            //console.log(\"max \"+lastMax);\n            if(dx<0&&lastMin!=null){\n                intervals.push( [lastMax , lastMin] );\n            }\n        }\n\n        if(options.maxCriteria){\n            if ((ddY[i] < ddY[i-1]) && (ddY[i] < ddY[i+1])) {\n                minddY.push( [X[i], Y[i], i] );  // TODO should we change this to have 3 arrays ? Huge overhead creating arrays\n                if(Math.abs(ddY[i])>options.broadRatio*maxDdy){ // TODO should this be a parameter =\n                    broadMask.push(false);\n                }\n                else{\n                    broadMask.push(true);\n                }\n            }\n        }\n        else{\n            if ((ddY[i] > ddY[i-1]) && (ddY[i] > ddY[i+1])) {\n                minddY.push( [X[i], Y[i], i] );  // TODO should we change this to have 3 arrays ? Huge overhead creating arrays\n                if(Math.abs(ddY[i])>options.broadRatio*maxDdy){ // TODO should this be a parameter =\n                    broadMask.push(false);\n                }\n                else{\n                    broadMask.push(true);\n                }\n            }\n        }\n\n    }\n    realTopDetection(minddY,X,Y);\n    //console.log(intervals);\n    //console.log(minddY);\n    var signals = [];\n\n    for (var j = 0; j < minddY.length; j++){\n        var f = minddY[j];\n        var frequency = f[0];\n        var possible = [];\n        for (var k=0; k<intervals.length; k++){\n            var i = intervals[k];\n            if(Math.abs(frequency-(i[0]+i[1])/2)<Math.abs(i[0]-i[1])/2)\n                possible.push(i);\n        }\n        //console.log(\"possible \"+possible.length);\n        if (possible.length > 0)\n            if (possible.length == 1)\n            {\n                var inter = possible[0];\n                var linewidth = Math.abs(inter[1] - inter[0]);\n                var height = f[1];\n                //console.log(height);\n                if (Math.abs(height) > options.minMaxRatio*maxY) {\n                    signals.push({\n                        x: frequency,\n                        y: height,\n                        width: linewidth//*widthCorrection\n                    })\n                }\n            }\n            else\n            {\n                //TODO: nested peaks\n                // console.log(\"Nested \"+possible);\n            }\n    }\n    if(options.broadRatio>0){\n        var broadLines=[[Number.MAX_VALUE,0,0]];\n        //Optimize the possible broad lines\n        var max=0, maxI=0,count=0;\n        var candidates = [],broadLinesS=[];\n        var isPartOf = false;\n\n        for(var i=broadLines.length-1;i>0;i--){\n            //console.log(broadLines[i][0]+\" \"+rangeX+\" \"+Math.abs(broadLines[i-1][0]-broadLines[i][0]));\n            if(Math.abs(broadLines[i-1][0]-broadLines[i][0])<rangeX){\n\n                candidates.push(broadLines[i]);\n                if(broadLines[i][1]>max){\n                    max = broadLines[i][1];\n                    maxI = i;\n                }\n                count++;\n            }\n            else{\n                isPartOf = true;\n                if(count>30){ // TODO, an options ?\n                    isPartOf = false;\n                    //for(var j=0;j<signals.length;j++){\n                    //    if(Math.abs(broadLines[maxI][0]-signals[j][0])<rangeX)\n                    //       isPartOf = true;\n                    //    }\n                    //console.log(\"Was part of \"+isPartOf);\n                }\n                if(isPartOf){\n                    for(var j=0;j<candidates.length;j++){\n                        signals.push([candidates[j][0], candidates[j][1], dx]);\n                    }\n                }\n                else{\n                    var fitted =  Opt.optimizeSingleLorentzian(candidates,{x:candidates[maxI][0],\n                        width:Math.abs(candidates[0][0]-candidates[candidates.length-1][0])},\n                        []);\n                    //console.log(fitted);\n                    signals.push([fitted[0][0],fitted[0][1],fitted[0][2]]);\n                }\n                candidates = [];\n                max = 0;\n                maxI = 0;\n                count = 0;\n            }\n        }\n    }\n\n    signals.sort(function (a, b) {\n        return a.x - b.x;\n    });\n\n\n    return signals;\n}\n\nfunction realTopDetection(peakList, x, y){\n    var listP = [];\n    var alpha, beta, gamma, p,currentPoint;\n    for(var j=0;j<peakList.length;j++){\n        currentPoint = peakList[j][2];\n        //The detected peak could be moved 1 or 2 unit to left or right.\n        if(y[currentPoint-1]>=y[currentPoint-2]\n            &&y[currentPoint-1]>=y[currentPoint]) {\n            currentPoint--;\n        }\n        else{\n            if(y[currentPoint+1]>=y[currentPoint]\n                &&y[currentPoint+1]>=y[currentPoint+2]) {\n                currentPoint++;\n            }\n            else{\n                if(y[currentPoint-2]>=y[currentPoint-3]\n                    &&y[currentPoint-2]>=y[currentPoint-1]) {\n                    currentPoint-=2;\n                }\n                else{\n                    if(y[currentPoint+2]>=y[currentPoint+1]\n                        &&y[currentPoint+2]>=y[currentPoint+3]) {\n                        currentPoint+=2;\n                    }\n                }\n            }\n        }\n        if(y[currentPoint-1]>0&&y[currentPoint+1]>0\n            &&y[currentPoint]>=y[currentPoint-1]\n            &&y[currentPoint]>=y[currentPoint+1]) {\n            alpha = 20 * Math.log10(y[currentPoint - 1]);\n            beta = 20 * Math.log10(y[currentPoint]);\n            gamma = 20 * Math.log10(y[currentPoint + 1]);\n            p = 0.5 * (alpha - gamma) / (alpha - 2 * beta + gamma);\n\n            peakList[j][0] = x[currentPoint] + (x[currentPoint]-x[currentPoint-1])*p;\n            peakList[j][1] = y[currentPoint] - 0.25 * (y[currentPoint - 1]\n                - [currentPoint + 1]) * p;//signal.peaks[j].intensity);\n        }\n    }\n}\n\nmodule.exports=gsd;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./src/gsd.js\n ** module id = 15\n ** module chunks = 0\n **/"],"sourceRoot":""}