@danielsimonjr/mathts-functions 0.75.0 → 0.75.1

package/dist/index.js

@@ -45879,24 +45879,85 @@ function legendrePair(n, x) {
 	}
 	return [pCurr, pPrev];
 }
+const SPLIT = 134217729;
+function legendreWeightTermsDD(n, x) {
+	const cx = SPLIT * x;
+	const xh = cx - (cx - x);
+	const xl = x - xh;
+	let ph = 1;
+	let pl = 0;
+	let ch = x;
+	let cl = 0;
+	for (let k = 2; k <= n; k++) {
+		const a = 2 * k - 1;
+		let uh = ch * a;
+		let ul = cl * a + twoProdErr(ch, a, uh);
+		let s = uh + ul;
+		ul = ul - (s - uh);
+		uh = s;
+		let vh = uh * x;
+		let vl = ul * x + twoProdErrSplit(uh, vh, xh, xl);
+		s = vh + vl;
+		vl = vl - (s - vh);
+		vh = s;
+		const m = -(k - 1);
+		const wh = ph * m;
+		const wl = pl * m + twoProdErr(ph, m, wh);
+		const sh = vh + wh;
+		const bb = sh - vh;
+		let sl = vh - (sh - bb) + (wh - bb) + vl + wl;
+		const th = sh + sl;
+		sl = sl - (th - sh);
+		const q1 = th / k;
+		const ph2 = q1 * k;
+		const q2 = (th - ph2 - twoProdErr(q1, k, ph2) + sl) / k;
+		const nh = q1 + q2;
+		const nl = q2 - (nh - q1);
+		ph = ch;
+		pl = cl;
+		ch = nh;
+		cl = nl;
+	}
+	const yh = ch * x;
+	const yl = cl * x + twoProdErrSplit(ch, yh, xh, xl);
+	const s = ph - yh;
+	const bb = s - ph;
+	const tl = ph - (s - bb) + (-yh - bb) + pl - yl;
+	return [ch + cl, s + tl];
+}
+function twoProdErr(a, b, p) {
+	const ca = SPLIT * a;
+	const ah = ca - (ca - a);
+	const al = a - ah;
+	const cb = SPLIT * b;
+	const bh = cb - (cb - b);
+	const bl = b - bh;
+	return ah * bh - p + ah * bl + al * bh + al * bl;
+}
+function twoProdErrSplit(a, p, xh, xl) {
+	const ca = SPLIT * a;
+	const ah = ca - (ca - a);
+	const al = a - ah;
+	return ah * xh - p + ah * xl + al * xh + al * xl;
+}
 function rootsLegendre(n) {
 	if (!Number.isInteger(n) || n < 1) throw new Error("rootsLegendre: n must be a positive integer");
 	const nodes = [];
 	const weights = [];
 	for (let i = 0; i < n; i++) {
 		let x = Math.cos(Math.PI * (i + .75) / (n + .5));
-		let pn;
-		let dpn = 0;
 		for (let iter = 0; iter < NEWTON_MAX_ITERATIONS; iter++) {
 			const [pCurr, pPrev] = legendrePair(n, x);
-			pn = pCurr;
-			dpn = n * (x * pCurr - pPrev) / (x * x - 1);
-			const dx = pn / dpn;
+			const dx = pCurr / (n * (x * pCurr - pPrev) / (x * x - 1));
 			x -= dx;
 			if (Math.abs(dx) < NEWTON_TOLERANCE) break;
 		}
 		nodes.push(x);
-		weights.push(2 / ((1 - x * x) * dpn * dpn));
+		const [pn, t] = legendreWeightTermsDD(n, x);
+		const om = (1 - x) * (1 + x);
+		const d = n * t / om;
+		const w0 = 2 / (om * d * d);
+		weights.push(w0 * (1 + 2 * x * pn / (om * d)));
 	}
 	nodes.reverse();
 	weights.reverse();

package/dist/numeric/gauss-nodes.d.ts

@@ -21,7 +21,9 @@ export interface RootsLegendreResult {
  *
  * Nodes are the roots of the degree-n Legendre polynomial P_n, refined by
  * Newton's method from the standard asymptotic initial guess
- * `cos(pi*(i+0.75)/(n+0.5))`. Weights are `2 / ((1-x_i^2) * P'_n(x_i)^2)`.
+ * `cos(pi*(i+0.75)/(n+0.5))`. Weights are `2 / ((1-x_i^2) * P'_n(x_i)^2)`,
+ * evaluated in double-double at the final node and corrected to the exact
+ * root, so each weight is within 1e-15 relative for n up to 64.
  *
  * @param n - Number of quadrature points (positive integer)
  * @returns Nodes (ascending) and matching weights

package/dist/numeric/gauss-nodes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gauss-nodes.d.ts","sourceRoot":"","sources":["../../src/numeric/gauss-nodes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,yFAAyF;AACzF,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAuBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,mBAAmB,CA+B5D"}
+{"version":3,"file":"gauss-nodes.d.ts","sourceRoot":"","sources":["../../src/numeric/gauss-nodes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,yFAAyF;AACzF,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAsGD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,mBAAmB,CAmC5D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-functions",
-  "version": "0.75.0",
+  "version": "0.75.1",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",