Implementing A-Star algorithm. Help please? - javascript
I am trying to implement an A* algorithm for my pathfinding robot in JavaScript. The only problem is that I do not understand what does it mean to find all adjacent squares. I am using the Manhattan Distance formula as I cannot let my bot go diagonally. Here is my code (for now):
var open = new Array();
var closed = new Array();
start = [9,18]; //do not take this literally
goal = [1,0]; //again don't
open.push(start);
while (open.length != 0) {
for(var x = 0; x < open.length; x++) {
heuristicValue[x] = computeHeuristicV(maplayout, start[0], start[1], open[x][0], open[x][1], goal[0], goal[1]);
}
minimum = Math.min(100000,heuristicValue[0]);
for(var x = 1; x < open.length; x++) {
minimum = Math.min(minimum, heuristicValue[x]);
}
for(var x = 0; x < open.length; x++) {
if (minimum == heuristicValue[x]) {
current = [open[x][0], open[x][1]];
}
}
closed.push(current);
//INCOMPLETE
}
The computeHeuristicV function computes the heuristic value in the code above.
"All adjacent squares" means every possible next hop on the path.
A* is a great algorithm to master and use. The two key elements are finding neighbors and the heuristic. A heuristic is used to estimate the distance between your current location, and the end. Also, the statement "find all adjacent squares" is referencing a neighbors function. For example, you might have the following:
var heuristic = function(state) {
var endLocation = MyGame.getEndLocation();
return Math.abs(state.x - endLocation.x) + Math.abs(state.y - endLocation.y)
}
var neighbors = function(state){
var neighborStates = [];
MyGame.setPlayer({
x: state.x,
y: state.y
});
neighborStates.push(MyGame.moveUp.getState());
neighborStates.push(MyGame.moveRight.getState());
neighborStates.push(MyGame.moveDown.getState());
neighborStates.push(MyGame.moveLeft.getState());
return neighborStates;
}
So, getting the "adjacent squares" is just asking you for the neighboring states or options. Personal plug: I just authored a simple a-star algorithm here: https://github.com/tssweeney/async-astar. Reading the description might help you to better understand the problem.
Related
Efficiently find every combination of assigning smaller bins to larger bins
Let's say I have 7 small bins, each bin has the following number of marbles in it: var smallBins = [1, 5, 10, 20, 30, 4, 10]; I assign these small bins to 2 large bins, each with the following maximum capacity: var largeBins = [40, 50]; I want to find EVERY combination of how the small bins can be distributed across the big bins without exceeding capacity (eg put small bins #4,#5 in large bin #2, the rest in #1). Constraints: Each small bin must be assigned to a large bin. A large bin can be left empty This problem is easy to solve in O(n^m) O(2^n) time (see below): just try every combination and if capacity is not exceeded, save the solution. I'd like something faster, that can handle a variable number of bins. What obscure graph theory algorithm can I use to reduce the search space? //Brute force var smallBins = [1, 5, 10, 20, 30, 4, 10]; var largeBins = [40, 50]; function getLegitCombos(smallBins, largeBins) { var legitCombos = []; var assignmentArr = new Uint32Array(smallBins.length); var i = smallBins.length-1; while (true) { var isValid = validate(assignmentArr, smallBins, largeBins); if (isValid) legitCombos.push(new Uint32Array(assignmentArr)); var allDone = increment(assignmentArr, largeBins.length,i); if (allDone === true) break; } return legitCombos; } function increment(assignmentArr, max, i) { while (i >= 0) { if (++assignmentArr[i] >= max) { assignmentArr[i] = 0; i--; } else { return i; } } return true; } function validate(assignmentArr, smallBins, largeBins) { var totals = new Uint32Array(largeBins.length); for (var i = 0; i < smallBins.length; i++) { var assignedBin = assignmentArr[i]; totals[assignedBin] += smallBins[i]; if (totals[assignedBin] > largeBins[assignedBin]) { return false; } } return true; } getLegitCombos(smallBins, largeBins);
Here's my cumbersome recursive attempt to avoid duplicates and exit early from too large sums. The function assumes duplicate elements as well as bin sizes are presented grouped and counted in the input. Rather than place each element in each bin, each element is placed in only one of duplicate bins; and each element with duplicates is partitioned distinctly. For example, in my results, the combination, [[[1,10,20]],[[4,5,10,30]]] appears once; while in the SAS example in Leo's answer, twice: once as IN[1]={1,3,4} IN[2]={2,5,6,7} and again as IN[1]={1,4,7} IN[2]={2,3,5,6}. Can't vouch for efficiency or smooth-running, however, as it is hardly tested. Perhaps stacking the calls rather than recursing could weigh lighter on the browser. JavaScript code: function f (as,bs){ // i is the current element index, c its count; // l is the lower-bound index of partitioned element function _f(i,c,l,sums,res){ for (var j=l; j<sums.length; j++){ // find next available duplicate bin to place the element in var k=0; while (sums[j][k] + as[i][0] > bs[j][0]){ k++; } // a place for the element was found if (sums[j][k] !== undefined){ var temp = JSON.stringify(sums), _sums = JSON.parse(temp); _sums[j][k] += as[i][0]; temp = JSON.stringify(res); var _res = JSON.parse(temp); _res[j][k].push(as[i][0]); // all elements were placed if (i == as.length - 1 && c == 1){ result.push(_res); return; // duplicate elements were partitioned, continue to next element } else if (c == 1){ _f(i + 1,as[i + 1][1],0,_sums,_res); // otherwise, continue partitioning the same element with duplicates } else { _f(i,c - 1,j,_sums,_res); } } } } // initiate variables for the recursion var sums = [], res = [] result = []; for (var i=0; i<bs.length; i++){ sums[i] = []; res[i] = []; for (var j=0; j<bs[i][1]; j++){ sums[i][j] = 0; res[i][j] = []; } } _f(0,as[0][1],0,sums,res); return result; } Output: console.log(JSON.stringify(f([[1,1],[4,1],[5,1],[10,2],[20,1],[30,1]], [[40,1],[50,1]]))); /* [[[[1,4,5,10,10]],[[20,30]]],[[[1,4,5,10,20]],[[10,30]]],[[[1,4,5,20]],[[10,10,30]]] ,[[[1,4,5,30]],[[10,10,20]]],[[[1,4,10,20]],[[5,10,30]]],[[[1,4,30]],[[5,10,10,20]]] ,[[[1,5,10,20]],[[4,10,30]]],[[[1,5,30]],[[4,10,10,20]]],[[[1,10,20]],[[4,5,10,30]]] ,[[[1,30]],[[4,5,10,10,20]]],[[[4,5,10,20]],[[1,10,30]]],[[[4,5,30]],[[1,10,10,20]]] ,[[[4,10,20]],[[1,5,10,30]]],[[[4,30]],[[1,5,10,10,20]]],[[[5,10,20]],[[1,4,10,30]]] ,[[[5,30]],[[1,4,10,10,20]]],[[[10,10,20]],[[1,4,5,30]]],[[[10,20]],[[1,4,5,10,30]]] ,[[[10,30]],[[1,4,5,10,20]]],[[[30]],[[1,4,5,10,10,20]]]] */ console.log(JSON.stringify(f([[1,1],[4,1],[5,1],[10,2],[20,1],[30,1]], [[20,2],[50,1]]))); /* [[[[1,4,5,10],[10]],[[20,30]]],[[[1,4,5,10],[20]],[[10,30]]],[[[1,4,5],[20]],[[10,10,30]]] ,[[[1,4,10],[20]],[[5,10,30]]],[[[1,5,10],[20]],[[4,10,30]]],[[[1,10],[20]],[[4,5,10,30]]] ,[[[4,5,10],[20]],[[1,10,30]]],[[[4,10],[20]],[[1,5,10,30]]],[[[5,10],[20]],[[1,4,10,30]]] ,[[[10,10],[20]],[[1,4,5,30]]],[[[10],[20]],[[1,4,5,10,30]]]] */ Here's a second, simpler version that only attempts to terminate the thread when an element cannot be placed: function f (as,bs){ var stack = [], sums = [], res = [] result = []; for (var i=0; i<bs.length; i++){ res[i] = []; sums[i] = 0; } stack.push([0,sums,res]); while (stack[0] !== undefined){ var params = stack.pop(), i = params[0], sums = params[1], res = params[2]; for (var j=0; j<sums.length; j++){ if (sums[j] + as[i] <= bs[j]){ var _sums = sums.slice(); _sums[j] += as[i]; var temp = JSON.stringify(res); var _res = JSON.parse(temp); _res[j].push(i); if (i == as.length - 1){ result.push(_res); } else { stack.push([i + 1,_sums,_res]); } } } } return result; } Output: var r = f([1,5,10,20,30,4,10,3,4,5,1,1,2],[40,50,30]); console.log(r.length) console.log(JSON.stringify(f([1,4,5,10,10,20,30], [40,50]))); 162137 [[[30],[1,4,5,10,10,20]],[[10,30],[1,4,5,10,20]],[[10,20],[1,4,5,10,30]] ,[[10,30],[1,4,5,10,20]],[[10,20],[1,4,5,10,30]],[[10,10,20],[1,4,5,30]] ,[[5,30],[1,4,10,10,20]],[[5,10,20],[1,4,10,30]],[[5,10,20],[1,4,10,30]] ,[[4,30],[1,5,10,10,20]],[[4,10,20],[1,5,10,30]],[[4,10,20],[1,5,10,30]] ,[[4,5,30],[1,10,10,20]],[[4,5,10,20],[1,10,30]],[[4,5,10,20],[1,10,30]] ,[[1,30],[4,5,10,10,20]],[[1,10,20],[4,5,10,30]],[[1,10,20],[4,5,10,30]] ,[[1,5,30],[4,10,10,20]],[[1,5,10,20],[4,10,30]],[[1,5,10,20],[4,10,30]] ,[[1,4,30],[5,10,10,20]],[[1,4,10,20],[5,10,30]],[[1,4,10,20],[5,10,30]] ,[[1,4,5,30],[10,10,20]],[[1,4,5,20],[10,10,30]],[[1,4,5,10,20],[10,30]] ,[[1,4,5,10,20],[10,30]],[[1,4,5,10,10],[20,30]]]
This problem is seen often enough that most Constraint Logic Programming systems include a predicate to model it explicitly. In OPTMODEL and CLP, we call it pack: proc optmodel; set SMALL init 1 .. 7, LARGE init 1 .. 2; num size {SMALL} init [1 5 10 20 30 4 10]; num capacity{LARGE} init [40 50]; var WhichBin {i in SMALL} integer >= 1 <= card(LARGE); var SpaceUsed{i in LARGE} integer >= 0 <= capacity[i]; con pack( WhichBin, size, SpaceUsed ); solve with clp / findall; num soli; set IN{li in LARGE} = {si in SMALL: WhichBin[si].sol[soli] = li}; do soli = 1 .. _nsol_; put IN[*]=; end; quit; This code produces all the solutions in 0.06 seconds on my laptop: IN[1]={1,2,3,4,6} IN[2]={5,7} IN[1]={1,2,3,4} IN[2]={5,6,7} IN[1]={1,2,3,6,7} IN[2]={4,5} IN[1]={1,2,5,6} IN[2]={3,4,7} IN[1]={1,2,5} IN[2]={3,4,6,7} IN[1]={1,2,4,6,7} IN[2]={3,5} IN[1]={1,2,4,7} IN[2]={3,5,6} IN[1]={1,2,4,6} IN[2]={3,5,7} IN[1]={1,3,4,6} IN[2]={2,5,7} IN[1]={1,3,4} IN[2]={2,5,6,7} IN[1]={1,5,6} IN[2]={2,3,4,7} IN[1]={1,5} IN[2]={2,3,4,6,7} IN[1]={1,4,6,7} IN[2]={2,3,5} IN[1]={1,4,7} IN[2]={2,3,5,6} IN[1]={2,3,4,6} IN[2]={1,5,7} IN[1]={2,3,4} IN[2]={1,5,6,7} IN[1]={2,5,6} IN[2]={1,3,4,7} IN[1]={2,5} IN[2]={1,3,4,6,7} IN[1]={2,4,6,7} IN[2]={1,3,5} IN[1]={2,4,7} IN[2]={1,3,5,6} IN[1]={3,5} IN[2]={1,2,4,6,7} IN[1]={3,4,7} IN[2]={1,2,5,6} IN[1]={3,4,6} IN[2]={1,2,5,7} IN[1]={3,4} IN[2]={1,2,5,6,7} IN[1]={5,7} IN[2]={1,2,3,4,6} IN[1]={5,6} IN[2]={1,2,3,4,7} IN[1]={5} IN[2]={1,2,3,4,6,7} IN[1]={4,6,7} IN[2]={1,2,3,5} IN[1]={4,7} IN[2]={1,2,3,5,6} Just change the first 3 lines to solve for other instances. However, as others have pointed out, this problem is NP-Hard. So it can switch from very fast to very slow suddenly. You could also solve the version where not every small item needs to be assigned to a large bin by creating a dummy large bin with enough capacity to fit the entire collection of small items. As you can see from the "Details" section in the manual, the algorithms that solve practical problems quickly are not simple, and their implementation details make a big difference. I am unaware of any CLP libraries written in Javascript. Your best bet may be to wrap CLP in a web service and invoke that service from your Javascript code.
jquery flot chart highlight dot when near point
I am making a chart using jQuery flot (plot) https://jsfiddle.net/5gtqwkjg/2/ var updateLegendTimeout = null; var latestPosition = null; function updateLegend() { updateLegendTimeout = null; var pos = latestPosition; var axes = plot.getAxes(); if (pos.x < axes.xaxis.min || pos.x > axes.xaxis.max || pos.y < axes.yaxis.min || pos.y > axes.yaxis.max) { return; } /* var o = plot.pointOffset({ x: pos.x, y: -1.25 }); var ctx = plot.getCanvas().getContext("2d"); ctx.beginPath(); ctx.moveTo(o.left, o.top); o.top = 0; ctx.lineTo(o.left, o.top); ctx.stroke(); */ var i, j, dataset = plot.getData(); var halfDist = (dataset[0].data[1][0] - dataset[0].data[0][0]) / 2; for (i = 0; i < dataset.length; ++i) { var series = dataset[i]; // Find the nearest points, x-wise for (j = 0; j < series.data.length; ++j) { if (series.data[j][0] - halfDist > pos.x) { break; } } // Now Interpolate var y, p1 = series.data[j - 1], p2 = series.data[j]; if (p1 == null) y = p2[1]; else if (p2 == null) y = p1[1]; else y = p1[1]; legends.eq(i).text(series.label.replace(/=.*/, "= " + y.toFixed(2))); //dataset[i].highlightColor = "#abcdef"; //plot.highlight(dataset[0].series, dataset[0].datapoint); } } $("#placeholder").bind("plothover", function (event, pos, item) { latestPosition = pos; if (!updateLegendTimeout) { updateLegendTimeout = setTimeout(updateLegend, 50); } }); I want to add in a functionality that when the user moves the mouse along the x-axis the dot will highlight to indicate what point they are hovering nearest to. I already have the legend reflect the values but how would I highlight the dots? EDIT: Very helpful answers guys! Here is the finished result if anyone is interested https://jsfiddle.net/5gtqwkjg/4/
You can make use of the highlight and unhighlight functions provided by Flot. highlight(series, datapoint) Highlight a specific datapoint in the data series. You can either specify the actual objects, e.g. if you got them from a "plotclick" event, or you can specify the indices, e.g. highlight(1, 3) to highlight the fourth point in the second series (remember, zero-based indexing). unhighlight(series, datapoint) or unhighlight() Remove the highlighting of the point, same parameters as highlight. If you call unhighlight with no parameters, e.g. as plot.unhighlight(), all current highlights are removed. See https://github.com/flot/flot/blob/master/API.md#plot-methods for reference. Applying that logic to your question, I think I managed to create the desired result you were looking for. I first start by unhighlighting everything, just to make sure nothing slips past us when we do highlight points. for (i = 0; i < dataset.length; ++i) { plot.unhighlight(); // Unhighlight everything! var series = dataset[i]; Next up we go do the fun part, highlight all the points! (Just the ones we actually want to highlight) In your "Find the nearest points, x-wise" loop I added another loop! for (j = 0; j < series.data.length; ++j) { if (series.data[j][0] - halfDist > pos.x) { for(a = 0; a < dataset.length; a++) { // <-- The added loop // You might want to optimize the way this is done // The way you were storing the series data didn't seem to work like I.. // ..wanted it do, so I had to iterate the dataset variable again. // The yellow line won't highlight if you change dataset[a] to series. plot.highlight(dataset[a], series.data[j][0]); } break; } } The result https://jsfiddle.net/qj3068zn/6/, for ease of use. Do note, none of this is optimized. You're probably better off restructuring your code to provide a more general way to approach this and increase reusability and readability.
Using the highlight() function like Michel de Nijs in his answer, but a simpler version: 1) Put the plot.unhighlight(); at the start of your updateLegend function (you might also want to rename that since it not longer only updates the legend). 2) Add plot.highlight(i, j-1); after your for (j ...) loop. See this fiddle for the code.
Obtaining driving length between stops in ArcGIS
How can I obtain driving length between two stops in ArcGIS? I'm placing route from RouteTask service on a map and want to get lengths from that response too. I've thought about doing some iteration in DirectionsFeatureSet, but I already see that what I'm doing is complete nonsense. var directions = solveResult[0].directions; console.log(directions); var length = 0; var location = 0; var obj = {}; $.each(directions.features, function (ind, val) { var txt = val.attributes.text; var indexOfLocation = txt.indexOf('Location'); if (indexOfLocation != -1) { var digitTransform = txt.substring(indexOfLocation + 9); var digit = ""; for (var i = 0; i < digitTransform.length; i++) { var char = digitTransform[i]; if (isNumber(char)) { digit += char; } else break; } } }); That's what I already did and that makes no sense. In Google Maps API it's clear - every leg has it's own length. In ArcGIS responses I see no such easy approach.
The length is available as an attribute of each returned feature. So, given your directions variable, the following would give you the length of the first leg of the route: directions.features[0].attributes.length
How could I generate random locations with distances between each other in javascript?
I want to design a function that can generate a 'map' of sorts. For example: Location A is created, it is located at some position X Location B is created, it is located at some position Y, we know the distance between X, Y Location C is created, we know the distance from C to B, how do we calculate C to A? Using a triangle method, I suppose I could also assign a random angle and calculate the third side, but what would I do if I added a Location D, E, F randomly? Would I be calculating multiple triangles that get exponentially worse with every addition?
Say you want to generate a list of locations L[1..n], you just randomly pick next location and scan over the L to guarantee the distance is over a threshold, otherwise, pick again. Then, push this into your list L. So the total run time of generating a n elements list is O(n^2). When n < 1000, this is fast enough. The following method is guaranteed to terminate, which is designed for a relatively small read-to-pick list, say up to 1,000,000. function generateList(orgList, numberToOutput) { if (orgList.length < numberToOutput) return false; var orgListClone = orgList.slice(0); var L = []; while (L.length < numberToOutput && orgListClone.length > 0) { var n = parseInt(Math.random() * orgListClone.length); // Assume we pick n-th element in the list. var ok = true; for (var j = 0; j < L.length; j++) if (distance(orgListClone[n], L[j]) < kThreshold) { // n is not an option, swap orgListClone[n] with the last element and pop it out. orgListClone[n] = orgListClone[orgListClone.length - 1]; orgListClone.pop(); ok = false; break; } if (ok) { // All tests passed L.push(orgListClone[n]); orgListClone[n] = orgListClone[orgListClone.length - 1]; orgListClone.pop(); } } if (L.length == numberToOutput) return L; // Failed to find the list return null; } Another solution is to calcuate distances between each of the locations ahead, and make a list of too close locations for each location. So that after each pick, just merge the too close locations to the current set, which takes O(n). And then pick another location which is not included in this set. This method only works when the read-to-pick list is large enough, so that the probability (1 - |too close list| / |read-to-pick list|) of choosing a location not included in the set is large. This will take up to O(nm) in total, where m is the average |too close list|. function generateList(orgList, numberToOutput) { if (orgList.length < numberToOutput) return false; var tooCloseSet = {}; var L = []; var lastLengthOfL = 0; var repickCount = 0; for (L.length < numberToOutput) { if (l.length == lastLengthOfL) { if (++repickCount > 10) return false; } else { lastLengthOfL = l.length; repickCount = 0; } var n = parseInt(Math.random() * orgList.length); if (n in tooCloseSet) continue; L.push(orgList[n]); mergeSet(tooCloseSet, orgList[n].tooCloseList); } return L; }
You could try something like this, I haven't tested it, so it's just conceptual at this point. You could just generate an array of randomly placed points, and each point could hold it's own array of distances, calculated using basic trigonometry. function Point(x, y) { return { x: x, y:y, addRelative: function(pt) { this.realtivePoints[pt] = abs(sqrt(pow((this.x-pt.x),2) + pow((this.y-pt.y),2))); }, relativePoints: {} }; var randPoints = []; // Lets assume this has a collection of random Point objects for(var i=0; i<randPoints.length; i++) { for(var j=0; j<randPoints.length; j++) { randPoint[i].addRelative(randPoints[j]); } } randPoints[0].relativePoints[randPoints[1]]; // Dist from first to second point.
Yes, it gets geometrically more complicated with each point you add. The problem is that even if you know the lengths of all three sides of a triangle, you still don't know the orientation. To illustrate your example: You're defining ABC by specifying distances dAB and dBC (which gives you dAC). But you actually have two possible triangles, ABC and ABC'. Which means if you add a fourth point, D, by specifying it's distance to one of the points on ABC (e.g. dCD), you've added a 2nd triangle, which can also have one of two orientations, making for a total of four possible solutions. As you can see, orientation doesn't matter for determining distance between two points on the same triangle, but for determining distances between points on different triangles, it does.
Javascript equivalent functions to Matlab Functions: Polyfit/Polyval?
Desperately need a Javascript equivalent to polyval and polyfit functions that exist in Matlab. Essentially those functions in matlab do a curve fit based on two equally sized arrays depending on a specified polynomial. I need to do some calculations that involve curve fitting in javascript and can't for the life of me find an equivalent function. This is MatLab's explanation of the function polyfit "P = POLYFIT(X,Y,N) finds the coefficients of a polynomial P(X) of degree N that fits the data Y best in a least-squares sense. P is a row vector of length N+1 containing the polynomial coefficients in descending powers, P(1)*X^N + P(2)*X^(N-1) +...+ P(N)*X + P(N+1)." This is MatLab's explanation of polyval. "POLYVAL Evaluate polynomial. Y = POLYVAL(P,X) returns the value of a polynomial P evaluated at X. P is a vector of length N+1 whose elements are the coefficients of the polynomial in descending powers. Y = P(1)*X^N + P(2)*X^(N-1) + ... + P(N)*X + P(N+1)" Any help would be super. Regards,
numericjs may help you get started.
POLYFIT performs a least-square polynomial fitting which comes down to solving a system of linear equations. I did a quick search, but I couldn't find a basic linear algebra Javascript library that solves such systems... The easiest method would be to implement the Gaussian elimination algorithm yourself. POLYVAL is simply evaluating the polynomial at the points X by substituting the coefficients in the equation.
perhaps this code might help someone function _prepare(_mat) { _mat=[[]].concat(_mat) for(i=0;i<_mat.length;++i) _mat[i]=[0].concat(_mat[i]) return _mat } function linear(_mat){ _mat=_prepare(_mat) return _solve(_mat) } function _solve(_mat){ var c=new Array(),d=new Array() var n=_mat.length-1 for(i=0;i<=n+1;i++) { d[i]=new Array(); c[i]=0 for(j=0;j<=n+1;++j) d[i][j]=0 } // mission impossible // calculate all the determinants of the system for(m=2; m<=n ; ++m) { for(i=m;i<=n;++i) for(j = m-1;j<=n+1;++j) d[i][j] = [_mat[i][j] * _mat[m-1][m-1] , _mat[i][m-1]] for(i=m;i<=n;++i) for(j=m-1;j<=n+1;++j) { _mat[i][j] = d[i][j][0]-d[i][j][1]*_mat[m-1][j] if(Math.abs(_mat[i][j])<1e-25) _mat[i][j]=0 // i have to add this line } } // now the coefficients of equation (not exactly) for(i=n;i>=1;--i) { c[i-1] = _mat[i][n+1] if (i!=n) for(j=n; j>=i+1;--j) c[i-1] = c[i-1] -_mat[i][j] * c[j-1] if(_mat[i][i]!=0) c[i-1]=c[i-1] / _mat[i][i] else c[i-1]=0 if(Math.abs(c[i-1])<1e-25) c[i-1]=0 } c.length=n return c } function fitpoly(e,b){ var a=new Array() var n = 1+b,e=[[0,0]].concat(e),ns=e.length-1 for(i=0;i<=n+1;i++) { a[i]=new Array(); for(j=0;j<=n+1;++j) a[i][j]=0 } for(m=1;m <= n;m++) for(i=1;i<= m;i++) { j = m - i + 1; for(ii=1;ii <= ns;ii++) a[i][j] = a[i][j] + Math.pow(e[ii][0], m-1) } for(i=1;i<= n;++i) for(ii=1;ii<=ns;++ii) a[i][n+1] = a[i][n+1] +e[ii][1]*Math.pow(e[ii][0],i-1) for(m = n+2 ; m <= 2*n ; ++m) for(i = m-n; i<= n;++i) { j= m -i for(ii=1; ii<=ns;++ii) a[i][j] = a[i][j] + Math.pow(e[ii][0],m-2) // coefficients of system } a.length=a.length-1 return _solve(a) } //and then poly_degree = 6 points= [[2,2],[2,4],[4,6],[6,4],[8,2]] // coefficients of polynome console.log(fitpoly(points, poly_degree)) // or solve a linear system. Here with six variables solution = linear([[1,2,3,-2,-3,-26,52],[3,2,5,-2,4,30,-60],[6,1,-4,-1,5,94,-188],[-1,2,4,3,4,30,-60],[-1,4,2,-1,2,26,-52],[3,-3,11,-7,-2,-1,-95]]) console.log(solution)
Give this gist a try, it uses numeric.js: function polyfit(xArray, yArray, order) { if (xArray.length <= order) console.warn("Warning: Polyfit may be poorly conditioned.") let xMatrix = [] let yMatrix = numeric.transpose([yArray]) for (let i = 0; i < xArray.length; i++) { let temp = [] for (let j = 0; j <= order; j++) { temp.push(Math.pow(xArray[i], j)) } xMatrix.push(temp) } let xMatrixT = numeric.transpose(xMatrix) let dot1 = numeric.dot(xMatrixT, xMatrix) let dot2 = numeric.dot(xMatrixT, yMatrix) let dotInv = numeric.inv(dot1) let coefficients = numeric.dot(dotInv, dot2) return coefficients }