├── .gitignore
├── .travis.yml
├── README.md
├── docs
    └── images
    │   └── poly.png
├── index.js
├── package.json
└── test
    └── test.js


/.gitignore:
--------------------------------------------------------------------------------
 1 | lib-cov
 2 | *.seed
 3 | *.log
 4 | *.csv
 5 | *.dat
 6 | *.out
 7 | *.pid
 8 | *.gz
 9 | 
10 | pids
11 | logs
12 | results
13 | 
14 | npm-debug.log
15 | node_modules/*
16 | 
17 | obsolete
18 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - "0.12"
4 |   - "0.11"
5 |   - "0.10"
6 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # poly-roots
2 | 
3 | This module has been deprecated in favor of [durand-kerner](https://github.com/scijs/durand-kerner), which is a faster and more robust implementation all around.
4 | 
5 | See [history](https://github.com/scijs/poly-roots/blob/930c0b5eff0d4ca37d8f94f075fa75e27197d621/README.md) for a more complete readme.
6 | 


--------------------------------------------------------------------------------
/docs/images/poly.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/scijs/poly-roots/28c3ae1bbb6962c7ffc554b0b7d26bc430e40f96/docs/images/poly.png


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | /*function show(a,b) {
  4 |   var i,nums;
  5 |   nums = [];
  6 |   for(i=0; i<a.length; i++) {
  7 |     nums.push('('+a[i]+'+'+b[i]+'i)');
  8 |   }
  9 |   return '['+nums.join(', ')+']';
 10 | }
 11 | 
 12 | function showPoly(n,a,b) {
 13 |   var i, terms;
 14 |   if( b===undefined ) {
 15 |     terms = [];
 16 |     for(i=0; i<n; i++) {
 17 |       terms.push(''+a[i]+' * z^' + (n-i-1));
 18 |     }
 19 |     return terms.join(' + ');
 20 |   } else {
 21 |     terms = [];
 22 |     for(i=0; i<n; i++) {
 23 |       terms.push('( '+a[i]+' + '+b[i]+'*%i ) * z^' + (n-i-1));
 24 |     }
 25 |     return terms.join(' + ');
 26 |   }
 27 | }
 28 | function showPolyPython(n,a,b) {
 29 |   var i, terms;
 30 |   if( b===undefined ) {
 31 |     terms = [];
 32 |     for(i=0; i<n; i++) {
 33 |       terms.push(''+a[i]+' * z^' + (n-i-1));
 34 |     }
 35 |     return terms.join(' + ');
 36 |   } else {
 37 |     terms = [];
 38 |     for(i=0; i<n; i++) {
 39 |       terms.push(a[i]+' + '+b[i]+'j');
 40 |     }
 41 |     return '[' + terms.join(', ') + ']';
 42 |   }
 43 | }*/
 44 | 
 45 | function polyev ( nn, sr, si, pr, pi, qr, qi, pvri ) {
 46 |   //
 47 |   // Evaluates a polynomial P at s by the Horner recurrence, placing the
 48 |   // partial sums in Q and the computed value in pvri, which for JS is
 49 |   // obviously an array since we can't pass by ref.
 50 |   //
 51 |   var i,t,pvr,pvi;
 52 | 
 53 |   pvr = qr[0] = pr[0];
 54 |   pvi = qi[0] = pi[0];
 55 | 
 56 |   for(i=1; i<nn; i++) {
 57 |     t = pvr * sr - pvi * si + pr[i];
 58 |     pvi = pvr * si + pvi * sr + pi[i];
 59 |     pvr = t;
 60 |     qr[i] = pvr;
 61 |     qi[i] = pvi;
 62 |   }
 63 |   pvri[0] = pvr;
 64 |   pvri[1] = pvi;
 65 | }
 66 | 
 67 | function calct( nn, sr, si, hr, hi, qhr, qhi, pvri, tri ) {
 68 |   // Computes t = -P(s)/H(s)
 69 |   // Returns 
 70 | 
 71 |   var bool, tmp;
 72 |   var n = nn - 1;
 73 |   var hvri = new Float64Array(2);
 74 | 
 75 |   polyev( n, sr, si, hr, hi, qhr, qhi, hvri );
 76 | 
 77 |   var m1 = Math.sqrt(hvri[0]*hvri[0]+hvri[0]*hvri[0]);
 78 |   var m2 = Math.sqrt(hr[n-1]*hr[n-1]+hi[n-1]*hi[n-1]);
 79 |   bool = (m1 <= 1e-15 * m2);
 80 | 
 81 |   if( ! bool ) {
 82 |     tmp = hvri[0]*hvri[0] + hvri[1]*hvri[1];
 83 |     tri[0] = - ( pvri[0]*hvri[0] + pvri[1]*hvri[1] ) / tmp;
 84 |     tri[1] = - ( pvri[1]*hvri[0] - pvri[0]*hvri[1] ) / tmp;
 85 |     return bool;
 86 |   }
 87 | 
 88 |   tri[0] = 0;
 89 |   tri[1] = 0;
 90 | 
 91 |   return bool;
 92 | }
 93 | 
 94 | function nexth( nn, bool, qhr, qhi, qpr, qpi, hr, hi, tri ) {
 95 |   // Calculates the next shifted H polynomial
 96 |   // return true if H(s) is essentially zero
 97 |   var t1, t2, j;
 98 |   var n = nn - 1;
 99 |   
100 |   if( ! bool ) {
101 |     for(j=1; j<n; j++) {
102 |       t1 = qhr[j-1];
103 |       t2 = qhi[j-1];
104 |       hr[j] = tri[0] * t1 - tri[1] * t2 + qpr[j];
105 |       hi[j] = tri[0] * t2 + tri[1] * t1 + qpi[j];
106 |     }
107 |     hr[0] = qpr[0];
108 |     hi[0] = qpi[0];
109 |     return;
110 |   }
111 | 
112 |   // If H(s) is zero, replace h with qh:
113 |   for(j=1; j<n; j++) {
114 |     hr[j] = qhr[j-1];
115 |     hi[j] = qhi[j-1];
116 |   }
117 |   hr[0] = 0;
118 |   hi[0] = 0;
119 | }
120 | 
121 | function errev ( nn, qr, qi, ms, mp ) {
122 |   // Bounds the error in evaluating the polynomial by Horner recurrence
123 |   // qr, qi: the partial sums
124 |   // ms: modulus of the point
125 |   // mp: modulus of the polynomial value
126 |   // are, mre: error bounds on complex addition and multiplication
127 | 
128 |   var e, i;
129 |   var are = 1.1e-16;
130 |   var mre = 3.11e-16;
131 | 
132 |   e = Math.sqrt(qr[0]*qr[0]+qi[0]*qi[0]) * mre / (are + mre);
133 |   for(i=0;i<nn;i++) {
134 |     e = e * ms + Math.sqrt(qr[i]*qr[i]+qi[i]*qi[i]);
135 |   }
136 |   return e * (are + mre) - mp * mre;
137 | }
138 | 
139 | function cauchy (nn, pt, q ) {
140 |   // Cauchy computs a lower bound on the moduli ofthe zeros of a polynomial.
141 |   // pt is the modulus of the coefficients.
142 |   //
143 |   // The lower bound of the modulus of the zeros is given by the roots of the polynomial:
144 |   //
145 |   //   n         n-1
146 |   //  z  + |a | z    + ... + |a   | z - |a |
147 |   //         1                 n-1        n
148 |   //
149 |   var x, dx, df, i, n, xm, f;
150 | 
151 |   // The sign of the last coefficient is reversed:
152 |   pt[nn-1] = -pt[nn-1];
153 | 
154 |   // Compute upper estimate of bound:
155 |   n = nn - 1;
156 |   x = Math.exp((Math.log(-pt[nn-1]) - Math.log(pt[0])) / n);
157 | 
158 |   if( pt[n-1] !== 0 ) {
159 |     xm = - pt[nn-1] / pt[n-1];
160 |     if( xm < x ) {
161 |       x = xm;
162 |     }
163 |   }
164 | 
165 |   // Chop the interval (0,x) until f <= 0
166 |   while( true ) {
167 |     xm = x * 0.1;
168 |     f = pt[0];
169 |     for(i=1; i<nn; i++) {
170 |       f = f * xm + pt[i];
171 |     }
172 |     if( f > 0 ) {
173 |       x = xm;
174 |     } else {
175 |       break;
176 |     }
177 |   }
178 |   dx = x;
179 | 
180 |   // Do newton iteration until x converges to two decimal places
181 |   while( Math.abs(dx/x) > 0.005 ) {
182 |     q[0] = pt[0];
183 |     for(i=1; i<nn; i++) {
184 |       q[i] = q[i-1] * x + pt[i];
185 |     }
186 |     f = q[nn-1];
187 |     df = q[0];
188 |     for(i=1; i<n; i++) {
189 |       df = df * x + q[i];
190 |     }
191 |     dx = f / df;
192 |     x -= dx;
193 |   }
194 | 
195 |   return x;
196 | }
197 | 
198 | function noshft (l1, nn, hr, hi, pr, pi) {
199 |   var i, j, jj, nm1, n, tr, ti;
200 |   var xni, t1, t2, tmp;
201 | 
202 |   //console.log('begin stage 1');
203 | 
204 |   n = nn - 1;
205 |   nm1 = n - 1;
206 | 
207 |   // From Eqn. 9.3 for the 'scaled recurrence', calculate
208 |   //
209 |   //  _ (0)        1
210 |   //  H    (z)  =  - P' (z)
211 |   //               n
212 |   //
213 |   // In my copy of the paper, the 'P' appears to be missing a prime. Since the
214 |   // leading coefficient is constrained to be 1, this makes H a monic polynomial.
215 |   for(i=0; i<n; i++) {
216 |     xni = nn - i - 1;
217 |     hr[i] = xni * pr[i] / n;
218 |     hi[i] = xni * pi[i] / n;
219 |   }
220 | 
221 |   for(jj=0; jj<l1; jj++) {
222 |     //console.log('No shift iteration #',jj+1,'H =',showPolyPython(n,hr,hi));
223 |     //console.log('No shift iteration #',jj+1,'P =',showPolyPython(n,pr,pi));
224 | 
225 |     // Compare the trailing coefficient of H to that of P:
226 |     //console.log( Math.sqrt(hr[nm1]*hr[nm1]+hi[nm1]*hi[nm1]));
227 |     //console.log( Math.sqrt(pr[n]*pr[n]+pi[n]*pi[n]));
228 |     if( (hr[nm1]*hr[nm1]+hi[nm1]*hi[nm1]) > 1e-30 * (pr[n]*pr[n]+pi[n]*pi[n]) ) {
229 | 
230 |       // t = - p[n] / h[nm1]
231 |       tmp = - (hr[nm1]*hr[nm1]+hi[nm1]*hi[nm1]);
232 |       tr = ( pr[n]*hr[nm1]+pi[n]*hi[nm1] ) / tmp;
233 |       ti = ( pi[n]*hr[nm1]-pr[n]*hi[nm1] ) / tmp;
234 | 
235 |       // Calculate the new polynomial using the horner recurrence:
236 |       for(j=nm1; j>0; j--) {
237 |         t1 = hr[j-1];
238 |         t2 = hi[j-1];
239 |         hr[j] = tr * t1 - ti * t2 + pr[j];
240 |         hi[j] = tr * t2 + ti * t1 + pi[j];
241 |       }
242 |       hr[0] = pr[0];
243 |       hi[0] = pi[0];
244 | 
245 |     } else {
246 |       //console.log('edge case');
247 | 
248 |       // If the constant term is essentially zero, shift h coefficients
249 |       for(i=n-1; i>0; i--) {
250 |         //console.log("shifting",i);
251 |         hr[i] = hr[i-1];
252 |         hi[i] = hi[i-1];
253 |       }
254 |       hr[0] = 0;
255 |       hi[0] = 0;
256 |       //console.log('shifted H =',showPolyPython(nm1,hr,hi));
257 |     }
258 |   }
259 | }
260 | 
261 | function vrshft (l3, nn, zri, sri, hr, hi, pr, pi, qpr, qpi, qhr, qhi, shr, shi, pvri, tri) {
262 | 
263 |   var mp, ms, omp, relstp, r1, r2, tp, bool, i, j;
264 |   
265 |   //console.log('begin stage 3');
266 | 
267 |   var conv = false;
268 |   var b = false;
269 | 
270 |   sri[0] = zri[0];
271 |   sri[1] = zri[1];
272 |   var eta = 1.1e-16;
273 | 
274 | 
275 |   // Main loop for stage three
276 |   for(i=0; i<l3; i++) {
277 |     //console.log('variable shift iteration #',i+1, ', H =',showPolyPython(nn-1,hr,hi));
278 | 
279 |     // Evaluate P at s and test for convergence
280 |     polyev( nn, sri[0], sri[1], pr, pi, qpr, qpi, pvri );
281 |     mp = Math.sqrt( pvri[0]*pvri[0] + pvri[1]*pvri[1] );
282 |     ms = Math.sqrt( sri[0]*sri[0] + sri[1]*sri[1] );
283 |     var err = errev(nn, qpr, qpi, ms, mp);
284 |     //console.log('compare mp=',mp,' to err=',err);
285 |     if( mp < 20 * err ) {
286 |       // Polynomial value is smaller in value than a bound on the error in evaluating P,
287 |       // terminate the iteration
288 |       conv = true;
289 |       zri[0] = sri[0];
290 |       zri[1] = sri[1];
291 |       //console.log('converged to',zri[0],'+',zri[1]+'i');
292 |       return conv;
293 |     }
294 | 
295 |     if( i !== 0 ) {
296 |       if( ! ( b || mp < omp || relstp >= 0.5 ) ) {
297 |         // Iteration has stalled. Probably a cluster of zeros. Do 5 fixed
298 |         // shift steps into the cluster to force one zero to dominate.
299 |         tp = relstp;
300 |         b = true;
301 |         if( relstp < eta ) {
302 |           tp = eta;
303 |         }
304 |         r1 = Math.sqrt(tp);
305 |         r2 = sri[0] * (1+r1) - sri[1] * r1;
306 |         sri[1] = sri[0] * r1 + sri[1] * (1+r1);
307 |         sri[0] = r2;
308 |         polyev( nn, sri[0], sri[1], pr, pi, qpr, qpi, pvri );
309 |         for(j=1; j<5; j++) {
310 |           calct( nn, sri[0], sri[1], hr, hi, qhr, qhi, pvri, tri );
311 |           nexth( nn, bool, qhr, qhi, qpr, qpi, hr, hi, tri );
312 |         }
313 |         omp = Infinity;
314 |       }
315 |       if( mp * 0.1 > omp ) {
316 |         return conv;
317 |       }
318 |     }
319 |     omp = mp;
320 | 
321 |     bool = calct( nn, sri[0], sri[1], hr, hi, qhr, qhi, pvri, tri );
322 |     bool = nexth( nn, bool, qhr, qhi, qpr, qpi, hr, hi, tri );
323 |     bool = calct( nn, sri[0], sri[1], hr, hi, qhr, qhi, pvri, tri );
324 |     if( ! bool ) {
325 |       relstp = Math.sqrt(tri[0]*tri[0]+tri[1]*tri[1]) / Math.sqrt(sri[0]*sri[0]+sri[1]*sri[1]);
326 |       sri[0] += tri[0];
327 |       sri[1] += tri[1];
328 |     }
329 |   }
330 |   return conv;
331 | }
332 | 
333 | function fxshft (l2, nn, zri, sri, hr, hi, pr, pi, qpr, qpi, qhr, qhi, shr, shi, pvri, tri) {
334 |   var i, j, n, conv;
335 |   var otr, oti, bool, svsr, svsi;
336 | 
337 |   n = nn - 1;
338 | 
339 |   //console.log('begin stage 2');
340 | 
341 |   //console.log('np.polyval(',showPolyPython(nn,pr,pi)+', '+sr+'+'+si+'j)');
342 |   //console.log('np.polyval(',showPolyPython(n,hr,hi)+', '+sr+'+'+si+'j)');
343 | 
344 |   // Evaluate P at s:
345 |   polyev( nn, sri[0], sri[1], pr, pi, qpr, qpi, pvri );
346 |   var test = true;
347 |   var pasd = false;
348 | 
349 |   // Calculate first t = -P(s)/H(s):
350 |   bool = calct( nn, sri[0], sri[1], hr, hi, qhr, qhi, pvri, tri );
351 |   zri[0] = sri[0] + tri[0];
352 |   zri[1] = sri[1] + tri[1];
353 | 
354 |   // Main loop for one second stage step
355 |   for(j=0; j<l2; j++) {
356 |     //console.log('fixed shift iteration #',j+1,' H =',showPolyPython(n,hr,hi));
357 |     otr = tri[0];
358 |     oti = tri[1];
359 | 
360 |     // Compute next h polynomial and new t:
361 |     nexth( nn, bool, qhr, qhi, qpr, qpi, hr, hi, tri );
362 |     bool = calct( nn, sri[0], sri[1], hr, hi, qhr, qhi, pvri, tri );
363 |     zri[0] = sri[0] + tri[0];
364 |     zri[1] = sri[1] + tri[1];
365 | 
366 | 
367 |     // Test for convergence unless stage 3 has failed once or this is the last H polynomial
368 |     if( ! ( bool || !test || j === l2-1) ) {
369 |       var tmpi = tri[0] - otr;
370 |       var tmpr = tri[1] - oti;
371 |       var m1 = Math.sqrt(tmpr*tmpr + tmpi*tmpi);
372 |       var m2 = Math.sqrt(zri[0]*zri[0] + zri[1]*zri[1]);
373 |       if( m1 < 0.5 * m2 ) {
374 |         if( pasd ) {
375 |           //console.log('weak convergence passed twice');
376 |           // The weak convergence test has been passed twice, start the third stage
377 |           // iteration, after saving the current H polynomial and shift
378 |           for(i=0; i<n; i++) {
379 |             shr[i] = hr[i];
380 |             shi[i] = hi[i];
381 |           }
382 |           svsr = sri[0];
383 |           svsi = sri[1];
384 | 
385 |           conv = vrshft( 10, nn, zri, sri, hr, hi, pr, pi, qpr, qpi, qhr, qhi, shr, shi, pvri, tri );
386 |           if( conv ) {
387 |             return conv;
388 |           }
389 | 
390 |           // The iteration failed to converge. Turn off testing and restore H, S, PV, and T.
391 |           //console.log('iteration failed to converge. Turn off testing & restore H, S, PV, T');
392 |           test = false;
393 |           for(i=0; i<n; i++) {
394 |             hr[i] = shr[i];
395 |             hi[i] = shi[i];
396 |           }
397 |           sri[0] = svsr;
398 |           sri[1] = svsi;
399 |           polyev( nn, sri[0], sri[1], pr, pi, qpr, qpi, pvri );
400 |           bool = calct( nn, sri[0], sri[1], hr, hi, qhr, qhi, pvri, tri );
401 |           continue;
402 |         } 
403 |         pasd = true;
404 |       } else {
405 |         pasd = false;
406 |       }
407 |     }
408 |   }
409 | 
410 |   conv = vrshft( 10, nn, zri, sri, hr, hi, pr, pi, qpr, qpi, qhr, qhi, shr, shi, pvri, tri );
411 | 
412 |   return conv;
413 | }
414 | 
415 | var cpoly = function cpoly ( opr, opi ) {
416 |   var i, bound, xxx, conv, cnt1, cnt2, tmp, idnn2;
417 | 
418 |   if( opi === undefined ) {
419 |     opi = new Float64Array( opr.length );
420 |   }
421 | 
422 |   if( opr.length !== opi.length ) {
423 |     throw new TypeError('cpoly: error: real/complex polynomial coefficient input length mismatch');
424 |   }
425 | 
426 |   var degree = opr.length - 1;
427 | 
428 |   // Initialization of constants
429 |   var xx = 0.7071067811865475,
430 |       yy = -xx,
431 |       cosr = -0.06975647374412534,
432 |       sinr = 0.9975640502598242,
433 |       nn = degree + 1;
434 | 
435 |   // Output:
436 |   var zeror = new Float64Array(degree),
437 |       zeroi = new Float64Array(degree);
438 | 
439 |   // Allocate arrays
440 |   var pr = new Float64Array(nn),
441 |       pi = new Float64Array(nn),
442 |       hr = new Float64Array(degree),
443 |       hi = new Float64Array(degree),
444 |       qpr = new Float64Array(nn),
445 |       qpi = new Float64Array(nn),
446 |       qhr = new Float64Array(degree),
447 |       qhi = new Float64Array(degree),
448 |       shr = new Float64Array(nn),
449 |       shi = new Float64Array(nn),
450 |       zri = new Float64Array(2), // for pasing around zeros since js doesn't do by reference;
451 |       pvri = new Float64Array(2),  // for passing around the polynomial value, reason = ditto
452 |       tri = new Float64Array(2),   // for passing around T = -P(S)/H(S)
453 |       sri = new Float64Array(2);   // for passing around current s
454 |   
455 |   //console.log('degree =',degree);
456 |   //console.log('nn =',nn);
457 |   // Remove the zeros at the origin if any
458 |   while( opr[nn] === 0 && opi[nn] === 0 ) {
459 |     idnn2 = degree - nn + 1;
460 |     zeror[idnn2] = 0;
461 |     zeroi[idnn2] = 0;
462 |     nn--;
463 |   }
464 | 
465 |   // Make a copy of the coefficients
466 |   for(i=0; i<nn; i++) {
467 |     pr[i] = opr[i];
468 |     pi[i] = opi[i];
469 |     shr[i] = Math.sqrt(pr[i]*pr[i]+pi[i]*pi[i]);
470 |   }
471 | 
472 |   // Skip scaling the polynomial for unusually large
473 |   // or small coefficients. Caveat emptor.
474 | 
475 |   // Start the algorithm for one zero
476 |   while( nn > 2 ) {
477 | 
478 |     // Calculate bound, a lower bound on the modulus of the zeros:
479 |     for(i=0; i<nn; i++) {
480 |       shr[i] = Math.sqrt(pr[i]*pr[i] + pi[i]*pi[i]);
481 |     }
482 |     bound = cauchy( nn, shr, shi);
483 | 
484 |     // Outer loop to control two major passes with different sequences of shifts
485 |     for(cnt1=0; cnt1<2; cnt1++) {
486 |       //console.log("BEGIN OUTER LOOP");
487 | 
488 |       noshft(5, nn, hr, hi, pr, pi);
489 | 
490 |       // Inner loop to select a shift
491 |       for(cnt2=0; cnt2<9; cnt2++) {
492 |         //console.log("BEGIN INNER LOOP");
493 | 
494 |         // rotate shift angle xx and yy:
495 |         xxx = cosr * xx - sinr * yy;
496 |         yy = sinr * xx + cosr * yy;
497 |         xx = xxx;
498 | 
499 |         // Calculate the new shift:
500 |         sri[0] = bound * xx;
501 |         sri[1] = bound * yy;
502 | 
503 |         conv = fxshft( 10*cnt2, nn, zri, sri, hr, hi, pr, pi, qpr, qpi, qhr, qhi, shr, shi, pvri, tri );
504 | 
505 |         if( conv ) {
506 |           //console.log('MAIN LOOP CONVERGENCE. STORE ZERO');
507 |           idnn2 = degree - nn + 1;
508 |           zeror[idnn2] = zri[0];
509 |           zeroi[idnn2] = zri[1];
510 |           nn--;
511 |           //console.log('nn-- = ',nn);
512 | 
513 |           for(i=0; i<nn; i++) {
514 |             pr[i] = qpr[i];
515 |             pi[i] = qpi[i];
516 |           }
517 |           cnt1 = 3; // exit from the cnt2 loop also
518 |           break;
519 |         }
520 |       }
521 |     }
522 |   }
523 | 
524 |   if( nn <= 2 ) {
525 |     //console.log('END LOOP CONVERGENCE. STORE ZERO');
526 |     // Calculate the final zero and return ( - p[1] / p[0] ):
527 |     tmp = pr[0]*pr[0] + pi[0]*pi[0];
528 |     zeror[degree-1] = - ( pr[1]*pr[0] + pi[1]*pi[0] ) / tmp;
529 |     zeroi[degree-1] = - ( pi[1]*pr[0] - pr[1]*pi[0] ) / tmp;
530 |   }
531 | 
532 |   return [zeror, zeroi];
533 | };
534 | 
535 | module.exports = cpoly;
536 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "poly-roots",
 3 |   "version": "1.0.8",
 4 |   "description": "Find all roots of a polynomial using the Jenkins-Traub method",
 5 |   "main": "index.js",
 6 |   "author": "Ricky Reusser",
 7 |   "license": "MIT",
 8 |   "readmeFilename": "README.md",
 9 |   "scripts": {
10 |     "test": "node test/**",
11 |     "lint": "jshint *.js"
12 |   },
13 |   "repository": {
14 |     "type": "git",
15 |     "url": "git://github.com/scijs/poly-roots.git"
16 |   },
17 |   "keywords": [
18 |     "polynomial",
19 |     "scijs",
20 |     "roots",
21 |     "algebra",
22 |     "math"
23 |   ],
24 |   "dependencies": {
25 |   },
26 |   "devDependencies": {
27 |     "jshint": "^2.7.0",
28 |     "tape": "^4.0.0"
29 |   }
30 | }
31 | 


--------------------------------------------------------------------------------
/test/test.js:
--------------------------------------------------------------------------------
  1 | var test = require('tape'),
  2 |     cpoly = require('../index.js');
  3 | 
  4 | // Search epected real/imag for observed real/imag pairs:
  5 | function assertContainsCloseTo( t, er, ei, or, oi, tol ) {
  6 |   var hits = [];
  7 |   var i,j,idx;
  8 |   for(i=0; i<er.length; i++) {
  9 |     idx = null;
 10 |     for(j=0; j<oi.length; j++) {
 11 |       if( i in hits ) continue;
 12 |       var err = Math.sqrt(Math.pow(er[i]-or[j],2) + Math.pow(ei[i]-oi[j],2));
 13 |       if( err < tol ) {
 14 |         hits.push(j);
 15 |         idx = j;
 16 |         break;
 17 |       }
 18 |     }
 19 |     if( idx === null ) {
 20 |       t.assert(false,'did not contain root ' + er[i] + ' + ' + ei[i] + 'i');
 21 |     }
 22 |   }
 23 |   t.assert(hits.length = er.length);
 24 | }
 25 | 
 26 | test("factor z - 6", function(t) {
 27 |   var roots = cpoly([1,-6]);
 28 |   assertContainsCloseTo( t, [6],[0], roots[0],roots[1], 1e-13 );
 29 |   t.end();
 30 | });
 31 | 
 32 | test("factor 2z - 12", function(t) {
 33 |   var roots = cpoly([2,-12]);
 34 |   assertContainsCloseTo( t, [6],[0], roots[0],roots[1], 1e-13 );
 35 |   t.end();
 36 | });
 37 | 
 38 | test("factor z - 6i", function(t) {
 39 |   var roots = cpoly([1,0],[0,-6]);
 40 |   assertContainsCloseTo( t, [0],[6], roots[0],roots[1], 1e-13 );
 41 |   t.end();
 42 | });
 43 | 
 44 | test("factor z^2 + 2z - 3", function(t) {
 45 |   var roots = cpoly([1,2,-3]);
 46 |   assertContainsCloseTo( t, [-3,1],[0,0], roots[0],roots[1], 1e-13 );
 47 |   t.end();
 48 | });
 49 | 
 50 | test("factor z^2 + 1", function(t) {
 51 |   var roots = cpoly([1,0,1]);
 52 |   assertContainsCloseTo( t, [0,0],[1,-1], roots[0],roots[1], 1e-13 );
 53 |   t.end();
 54 | });
 55 | 
 56 | test("factor z^3 - 4z^2 + z + 6", function(t) {
 57 |   // Calculate roots of
 58 |   //                                3      2
 59 |   //   (z - 3) (z - 2) (z + 1)  =  z  - 4 z  + z + 6
 60 |   //
 61 |   var a_r = new Float64Array([1,-4, 1, 6]);
 62 | 
 63 |   var roots = cpoly( a_r );
 64 | 
 65 |   assertContainsCloseTo( t, [3,2,-1],[0,0,0], roots[0],roots[1], 1e-13 );
 66 | 
 67 |   t.end();
 68 | });
 69 | 
 70 | test("factor (z-1) * (z+1) * (z + 1 + 1e-4i) * (z + 1 - 1e-4i)",function(t) {
 71 |   // Calculate roots of:
 72 |   //
 73 |   // (z - 1) * (z + 1 + 1e-4i) * (z + 1 - 1e-4i) * (z + 1)  =
 74 |   //
 75 |   //     4      3                        2
 76 |   //    x  + 2 x  + 9.99999993922529e-9 x  - 2 x - 1.00000001
 77 |   //
 78 | 
 79 |   var a_r = new Float64Array([1, 2, 9.99999993922529e-9, -2, -1.00000001 ]);
 80 | 
 81 |   var roots = cpoly( a_r );
 82 | 
 83 |   assertContainsCloseTo( t, [1, -1, -1, -1],[0, 1e-4, -1e-4, 0], roots[0],roots[1], 1e-7 );
 84 | 
 85 |   t.end();
 86 | });
 87 | 
 88 | test("factor z^3 - 4z^2 + z + 6", function(t) {
 89 |   //
 90 |   // Calculate roots of
 91 |   //                                3      2
 92 |   //   (z - 3) (z - 2) (z + 1)  =  z  - 4 z  + z + 6
 93 |   //
 94 |   var a_r = new Float64Array([1,-4, 1, 6]);
 95 | 
 96 |   var roots = cpoly( a_r );
 97 | 
 98 |   assertContainsCloseTo( t, [3,2,-1],[0,0,0], roots[0],roots[1], 1e-13 );
 99 | 
100 |   t.end();
101 | });
102 | 
103 | test("factor z^3 - (4 + i)z^2 + (1 + i)z + (6 + 2i)", function(t) {
104 |   //
105 |   // Calculate roots of
106 |   //                                    3            2
107 |   //   (z - 3 - i) (z - 2) (z + 1)  =  z  - (4 + i) z  + (1 + i) z + (6 + 2i)
108 |   //
109 |   // roots:
110 |   //  3 + i
111 |   //  2
112 |   //  -1
113 |   //
114 |   var a_r = new Float64Array([1,-4,  1,  6]);
115 |   var a_i = new Float64Array([0,-1,  1,  2]);
116 | 
117 |   var roots = cpoly( a_r, a_i );
118 | 
119 |   assertContainsCloseTo( t, [3,2,-1],[1,0,0], roots[0], roots[1], 1e-13 );
120 | 
121 |   t.end();
122 | });
123 | 
124 | test("factor (z-1)*(z-2)*(z-3)*(z-4)*(z-5)*(z-6)*(z-7)*(z-8)*(z-9)*(z-10)",function(t) {
125 |   var a_r = new Float64Array([1,-55,1320,-18150,157773,-902055,3416930,-8409500,12753576,-10628640,3628800]);
126 | 
127 |   var roots = cpoly( a_r );
128 |   
129 |   var rr = [1,2,3,4,5,6,7,8,9,10];
130 |   var ri = [0,0,0,0,0,0,0,0,0,0];
131 | 
132 |   assertContainsCloseTo( t, rr, ri, roots[0], roots[1], 1e-9 );
133 | 
134 |   t.end();
135 | });
136 | 
137 | 
138 | test("factor z^20 + i * z^10 + 1",function(t) {
139 |   var a_r = new Float64Array([1,-55,1320,-18150,157773,-902055,3416930,-8409500,12753576,-10628640,3628800]);
140 | 
141 |   var roots = cpoly(new Float64Array([1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]),
142 |                     new Float64Array([0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]) );
143 |   
144 |   t.end();
145 | });
146 | 


--------------------------------------------------------------------------------