{"version":3,"sources":["webpack:///ml-optimize-lorentzian/webpack/universalModuleDefinition","webpack:///ml-optimize-lorentzian/ml-optimize-lorentzian.min.js","webpack:///ml-optimize-lorentzian/webpack/bootstrap afd5ef68c4344c45f394","webpack:///ml-optimize-lorentzian/./src/index.js","webpack:///ml-optimize-lorentzian/./~/ml-curve-fitting/src/index.js","webpack:///ml-optimize-lorentzian/./~/ml-curve-fitting/src/LM.js","webpack:///ml-optimize-lorentzian/./~/ml-matrix/src/index.js","webpack:///ml-optimize-lorentzian/./~/ml-matrix/src/matrix.js","webpack:///ml-optimize-lorentzian/./~/ml-matrix/src/decompositions.js","webpack:///ml-optimize-lorentzian/./~/ml-matrix/src/dc/svd.js","webpack:///ml-optimize-lorentzian/./~/ml-matrix/src/dc/util.js","webpack:///ml-optimize-lorentzian/./~/ml-matrix/src/dc/evd.js","webpack:///ml-optimize-lorentzian/./~/ml-matrix/src/dc/lu.js","webpack:///ml-optimize-lorentzian/./~/ml-matrix/src/dc/qr.js","webpack:///ml-optimize-lorentzian/./~/ml-matrix/src/dc/cholesky.js","webpack:///ml-optimize-lorentzian/./~/ml-curve-fitting/src/algebra.js"],"names":["root","factory","exports","module","define","amd","this","modules","__webpack_require__","moduleId","installedModules","id","loaded","call","m","c","p","sumOfLorentzians","t","factor","i","j","p2","nL","length","cols","rows","result","Matrix","zeros","Math","pow","singleLorentzian","columns","singleGaussian","factor2","exp","optimizeSingleLorentzian","xy","peak","opts","xy2","parseData","y_data","maxY","nbPoints","weight","sqrt","dot","Object","create","consts","dt","abs","dx","p_init","x","width","p_min","p_max","p_fit","LM","optimize","optimizeSingleGaussian","optimizeLorentzianSum","group","math","Array","optimizeGaussianSum","k","y","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","push","Nfit","stop","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","n","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","splice","Aconcat","concat","from1DArray","newRows","newColumns","newData","data","rowVector","columnVector","l","vector","empty","fill","rand","jj","random","indices","from","to","stack","arg1","isMatrix","arguments","r","current","setRow","expand","base","count","expansion","checkMatrix","klass","get","checkRowIndex","index","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",{"end":{"file":"ml-optimize-lorentzian.min.js","comments_before":[],"nlb":false,"endpos":93001,"endcol":18,"endline":2852,"pos":92992,"col":9,"line":2852,"value":"condition","type":"name","_comments_dumped":true},"start":{"file":"ml-optimize-lorentzian.min.js","comments_before":[],"nlb":false,"endpos":93001,"endcol":18,"endline":2852,"pos":92992,"col":9,"line":2852,"value":"condition","type":"name","_comments_dumped":true},"name":"condition"},"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"],"mappings":"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","file":"ml-optimize-lorentzian.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[\"mlOptimizeLorentzian\"] = factory();\n\telse\n\t\troot[\"mlOptimizeLorentzian\"] = 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[\"mlOptimizeLorentzian\"] = factory();\n\telse\n\t\troot[\"mlOptimizeLorentzian\"] = 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'use strict';\n\t\n\tvar LM = __webpack_require__(1);\n\tvar math = LM.Matrix.algebra;\n\tvar Matrix = __webpack_require__(3);\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/* 1 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tmodule.exports = __webpack_require__(2);\n\tmodule.exports.Matrix = __webpack_require__(3);\n\tmodule.exports.Matrix.algebra = __webpack_require__(12);\n\n\n/***/ },\n/* 2 */\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__(3);\n\tvar math = __webpack_require__(12);\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/* 3 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tmodule.exports = __webpack_require__(4);\n\tmodule.exports.Decompositions = module.exports.DC = __webpack_require__(5);\n\n\n/***/ },\n/* 4 */\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/* 5 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar Matrix = __webpack_require__(4);\n\t\n\tvar SingularValueDecomposition = __webpack_require__(6);\n\tvar EigenvalueDecomposition = __webpack_require__(8);\n\tvar LuDecomposition = __webpack_require__(9);\n\tvar QrDecomposition = __webpack_require__(10);\n\tvar CholeskyDecomposition = __webpack_require__(11);\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/* 6 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar Matrix = __webpack_require__(4);\n\tvar hypotenuse = __webpack_require__(7).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/* 7 */\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/* 8 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar Matrix = __webpack_require__(4);\n\tvar hypotenuse = __webpack_require__(7).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/* 9 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar Matrix = __webpack_require__(4);\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/* 10 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar Matrix = __webpack_require__(4);\n\tvar hypotenuse = __webpack_require__(7).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/* 11 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar Matrix = __webpack_require__(4);\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/* 12 */\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__(3);\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/******/ ])\n});\n;\n\n\n/** WEBPACK FOOTER **\n ** ml-optimize-lorentzian.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 afd5ef68c4344c45f394\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 ** ./src/index.js\n ** module id = 0\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 = 1\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 = 2\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 = 3\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 = 4\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 = 5\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 = 6\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 = 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/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 = 8\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 = 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/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 = 10\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 = 11\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 = 12\n ** module chunks = 0\n **/"],"sourceRoot":""}