FloPoly Polynomial Utility

Common errors

• ReferenceError: require is not defined

  cause Attempting to use `require()` to import `flo-poly` in an ESM-only Node.js environment or a browser.
  fix Ensure your project is set up for ESM by adding `"type": "module"` to your `package.json` and using `import { ... } from 'flo-poly';`. If in a browser without a bundler, import from the explicit browser path: `import { ... } from './node_modules/flo-poly/browser/index.min.js';`

• TypeError: (0 , flo_poly__WEBPACK_IMPORTED_MODULE_0__.allRoots) is not a function

  cause This error typically occurs in a bundled environment (e.g., Webpack) when a CommonJS default export is incorrectly imported as a named ESM export, or vice-versa. Although FloPoly is ESM-only, incorrect import syntax can trigger similar errors. It could also happen if a module is incorrectly interpreted as having a default export when it only has named exports.
  fix Verify that `allRoots` is correctly imported as a named export: `import { allRoots } from 'flo-poly';`. FloPoly primarily uses named exports. If the issue persists with a bundler, ensure your bundler configuration correctly handles ESM imports, particularly for TypeScript projects where `resolve-typescript-plugin` might be needed.

• Uncaught SyntaxError: Cannot use import statement outside a module

  cause Attempting to use `import` syntax in a browser `<script>` tag without `type="module"` or in a Node.js environment that is configured for CommonJS.
  fix For browsers, ensure your script tag is `<script type="module">`. For Node.js, ensure your `package.json` includes `"type": "module"` to enable ESM globally, or run with `node --input-type=module` for single files.

Warnings

• breaking FloPoly is an ESM-only package since version 1.0.0 (or possibly earlier, certainly by 7.x.x). This means it cannot be `require()`-d in CommonJS environments without a transpilation step or a dynamic `import()` call, which may be slower.
  Fix: Ensure your project is configured for ESM (e.g., `"type": "module"` in `package.json`) and use `import` statements. If using bundlers like Webpack with TypeScript, specific configurations like `resolve-typescript-plugin` might be necessary.
• gotcha The `allRoots` function does not account for error bounds and can yield inaccurate results for polynomials with high condition numbers.
  Fix: For highly accurate and certified results, especially with ill-conditioned polynomials, use `allRootsCertifiedSimplified` or the more flexible `allRootsCertified` which supports `double-double` and `Shewchuk expansion` coefficients.
• gotcha The library's performance using Rolle's Theorem for root finding becomes asymptotically slower (`O(n²)`) for higher polynomial degrees, typically beyond degree 20, compared to `O(n)` methods like Descartes' Rule of Signs.
  Fix: Consider the degree of polynomials when choosing FloPoly for performance-critical applications, or evaluate alternative libraries if consistently dealing with very high-degree polynomials where `O(n)` methods are critical.
• gotcha Evaluating polynomials with large `|x|` values can lead to floating-point overflow, as standard double-precision numbers have a maximum value of approximately `1.8 x 10^308`.
  Fix: If dealing with extremely large root magnitudes or coefficient values, utilize functions that support arbitrary-precision types like `bigint` or `double-double` where available within the library, or implement scaling pre-processing.

Install

• npm install flo-poly npm
• yarn add flo-poly yarn
• pnpm add flo-poly pnpm

Imports

• allRoots
  wrong:

  const { allRoots } = require('flo-poly');

  correct:

  import { allRoots } from 'flo-poly';

  FloPoly is ESM-only. CommonJS `require` is not supported. Use named ESM imports.
• allRootsCertifiedSimplified
  wrong:

  import allRootsCertifiedSimplified from 'flo-poly';

  correct:

  import { allRootsCertifiedSimplified } from 'flo-poly';

  This is a named export, not a default export. Ensure you destructure it correctly.
• add

  import { add } from 'flo-poly';

  Used for polynomial addition; demonstrates a general polynomial operator import.
• allRoots (browser)
  wrong:

  import { allRoots } from 'flo-poly';

  correct:

  import { allRoots } from './node_modules/flo-poly/browser/index.min.js';

  When using directly in browsers without a bundler, you must import from the pre-bundled path. The bare specifier `flo-poly` only works with bundlers or Node.js module resolution.

Quickstart

Demonstrates basic root finding with `allRoots`, highly accurate certified root finding with `allRootsCertifiedSimplified`, and a simple polynomial addition operation.

import { allRoots, allRootsCertifiedSimplified, add } from 'flo-poly';

// Example 1: Finding roots of a double-precision polynomial
const p1 = [1, -21, 175, -735, 1624, -1764, 720]; // x^6 - 21x^5 + ... + 720
const roots1 = allRoots(p1);
console.log('Roots (approximate):', roots1);

// Example 2: Certified root finding for high accuracy
const p2 = [1, -21, 175, -735, 1624, -1764, 720];
const certifiedRoots = allRootsCertifiedSimplified(p2);
console.log('Roots (certified simplified):', certifiedRoots);

// Example 3: Polynomial addition
const polyA = [1, 2, 3]; // 1x^2 + 2x + 3
const polyB = [3, 4];   // 3x + 4
const sumPoly = add(polyA, polyB);
console.log('Polynomial sum (1x^2 + 2x + 3) + (3x + 4):', sumPoly); // Expected: [1, 5, 7]

if (roots1.length === 6 && sumPoly.length === 3) {
    console.log('FloPoly functions executed successfully! 😁');
} else {
    console.log('Something went wrong. 😥');
}