@itwin/core-geometry 4.10.0-dev.8 → 5.0.0-dev.0

package/lib/esm/numerics/Polynomials.js

@@ -5,17 +5,16 @@
 /** @packageDocumentation
  * @module Numerics
  */
+import { assert } from "@itwin/core-bentley";
 import { Geometry } from "../Geometry";
 import { Angle } from "../geometry3d/Angle";
 import { AngleSweep } from "../geometry3d/AngleSweep";
 import { GrowableFloat64Array } from "../geometry3d/GrowableFloat64Array";
 import { LongitudeLatitudeNumber } from "../geometry3d/LongitudeLatitudeAltitude";
-import { Point2d, Vector2d } from "../geometry3d/Point2dVector2d";
+import { Point2d } from "../geometry3d/Point2dVector2d";
 import { Point3d, Vector3d } from "../geometry3d/Point3dVector3d";
 import { Range1d, Range3d } from "../geometry3d/Range";
-// cspell:word Cardano
-// cspell:word CCminusSS
-/* eslint-disable @typescript-eslint/naming-convention */
+// cspell:words Cardano internaldocs
 /**
  * degree 2 (quadratic) polynomial in for y = c0 + c1*x + c2*x^2
  * @internal
@@ -676,8 +675,8 @@ export class AnalyticRoots {
             return;
         }
         else if (D > 0) {
-            const sqrt_D = Math.sqrt(D);
-            this.append2Solutions(sqrt_D - p, -sqrt_D - p, values);
+            const sqrtD = Math.sqrt(D);
+            this.append2Solutions(sqrtD - p, -sqrtD - p, values);
             return;
         }
         return;
@@ -743,7 +742,7 @@ export class AnalyticRoots {
      */
     /*
     private static _appendCubicRootsUnsorted(c: Float64Array | number[], results: GrowableFloat64Array) {
-      let sq_A: number;
+      let AA: number;
       let p: number;
       let q: number;
   
@@ -764,9 +763,9 @@ export class AnalyticRoots {
       //    f' = 3y^2 + p
       //        local min/max at Y = +-sqrt (-p)
       //        f(+Y) = -p sqrt(-p) + 3p sqrt (-p) + 2q = 2 p sqrt (-p) + 2q
-      sq_A = A * A;
-      p = (3.0 * B - sq_A) / 9.0;
-      q = 1.0 / 2 * (2.0 / 27 * A * sq_A - 1.0 / 3 * A * B + C);
+      AA = A * A;
+      p = (3.0 * B - AA) / 9.0;
+      q = 1.0 / 2 * (2.0 / 27 * A * AA - 1.0 / 3 * A * B + C);
   
       // Use Cardano formula
       const cb_p: number = p * p * p;
@@ -804,9 +803,9 @@ export class AnalyticRoots {
   
         return;
       } else {    // One real solution
-        const sqrt_D = Math.sqrt(D);
-        const u = this.cbrt(sqrt_D - q);
-        const v = -(this.cbrt(sqrt_D + q));
+        const sqrtD = Math.sqrt(D);
+        const u = this.cbrt(sqrtD - q);
+        const v = -(this.cbrt(sqrtD + q));
         results.push(origin + u + v);
         this.improveRoots(c, 3, results, false);
         return;
@@ -820,7 +819,7 @@ export class AnalyticRoots {
             // EDL April 5, 2020 replace classic GraphicsGems solver by RWDNickalls.
             // Don't know if improveRoots is needed.
             // Breaks in AnalyticRoots.test.ts checkQuartic suggest it indeed converts many e-16 errors to zero.
-            //  e-13 cases are unaffected
+            // e-13 cases are unaffected
             this.improveRoots(c, 3, results, false);
         }
         else {
@@ -829,49 +828,46 @@ export class AnalyticRoots {
         // this.appendCubicRootsUnsorted(c, results);
         results.sort();
     }
-    /** Compute roots of quartic 'c[0] + c[1] * x + c[2] * x^2 + c[3] * x^3 + c[4] * x^4 */
+    /** Compute roots of quartic `c[0] + c[1] * x + c[2] * x^2 + c[3] * x^3 + c[4] * x^4` */
     static appendQuarticRoots(c, results) {
-        const coffs = new Float64Array(4); // at various times .. coefficients of quadratic an cubic intermediates.
+        // for details, see core\geometry\internaldocs\quarticRoots.md
+        const coffs = new Float64Array(4);
         let u;
         let v;
-        // normal form: x^4 + Ax^3 + Bx^2 + Cx + D = 0
         const coffScale = new Float64Array(1);
         if (!this.safeDivide(coffScale, 1.0, c[4], 0.0, 0)) {
             this.appendCubicRoots(c, results);
             return;
         }
+        // normal form: x^4 + Ax^3 + Bx^2 + Cx + D = 0
         const A = c[3] * coffScale[0];
         const B = c[2] * coffScale[0];
         const C = c[1] * coffScale[0];
         const D = c[0] * coffScale[0];
         const origin = -0.25 * A;
-        /*  substitute x = y - A/4 to eliminate cubic term:
-            x^4 + px^2 + qx + r = 0 */
-        const sq_A = A * A;
-        const p = -3.0 / 8 * sq_A + B;
-        const q = 0.125 * sq_A * A - 0.5 * A * B + C;
-        const r = -3.0 / 256 * sq_A * sq_A + 1.0 / 16 * sq_A * B - 1.0 / 4 * A * C + D;
-        const tempStack = new GrowableFloat64Array();
-        if (this.isZero(r)) {
-            // no absolute term: y(y^3 + py + q) = 0
+        // substitute x = y - A/4 to eliminate cubic term: y^4 + py^2 + qy + r = 0
+        const AA = A * A;
+        const p = -0.375 * AA + B;
+        const q = 0.125 * AA * A - 0.5 * A * B + C;
+        const r = -0.01171875 * AA * AA + 0.0625 * AA * B - 0.25 * A * C + D;
+        const cubicSolutions = new GrowableFloat64Array();
+        if (this.isZero(r)) { // no absolute term: y(y^3 + py + q) = 0
             coffs[0] = q;
             coffs[1] = p;
             coffs[2] = 0;
             coffs[3] = 1;
             this.appendCubicRoots(coffs, results);
-            results.push(0); // APPLY ORIGIN ....
-            this.addConstant(origin, results);
+            results.push(0);
+            this.addConstant(origin, results); // apply origin
             return;
         }
-        else {
-            // Solve the resolvent cubic
-            coffs[0] = 1.0 / 2 * r * p - 1.0 / 8 * q * q;
+        else { // solve the resolvent cubic
+            coffs[0] = 0.5 * r * p - 0.125 * q * q;
             coffs[1] = -r;
-            coffs[2] = -1.0 / 2 * p;
+            coffs[2] = -0.5 * p;
             coffs[3] = 1;
-            this.appendCubicRoots(coffs, tempStack);
-            const z = this.mostDistantFromMean(tempStack);
-            // ... to build two quadric equations
+            this.appendCubicRoots(coffs, cubicSolutions);
+            const z = this.mostDistantFromMean(cubicSolutions);
             u = z * z - r;
             v = 2 * z - p;
             if (this.isSmallRatio(u, r)) {
@@ -890,11 +886,9 @@ export class AnalyticRoots {
                 v = Math.sqrt(v);
             }
             else {
-                for (let i = 0; i < tempStack.length; i++) {
-                    results.push(tempStack.atUncheckedIndex(i));
-                }
                 return;
             }
+            // the two quadratic equations
             coffs[0] = z - u;
             coffs[1] = ((q < 0) ? (-v) : (v));
             coffs[2] = 1;
@@ -904,8 +898,7 @@ export class AnalyticRoots {
             coffs[2] = 1;
             this.appendQuadraticRoots(coffs, results);
         }
-        // substitute
-        this.addConstant(origin, results);
+        this.addConstant(origin, results); // apply origin
         results.sort();
         this.improveRoots(c, 4, results, true);
         return;
@@ -1009,19 +1002,17 @@ export class PowerPolynomial {
         return this.degreeKnownEvaluate(coff, degree, x);
     }
     /**
-     * * Accumulate Q*scale into P. Both are treated as full degree.
-     * * (Expect Address exceptions if P is smaller than Q)
-     * * Returns degree of result as determined by comparing trailing coefficients to zero
+     * Accumulate `coffQ*scaleQ` into `coffP`.
+     * * The length of `coffP` must be at least length of `coffQ`.
+     * * Returns degree of result as determined by comparing trailing coefficients to zero.
      */
     static accumulate(coffP, coffQ, scaleQ) {
         let degreeP = coffP.length - 1;
         const degreeQ = coffQ.length - 1;
-        for (let i = 0; i <= degreeQ; i++) {
+        for (let i = 0; i <= degreeQ; i++)
             coffP[i] += scaleQ * coffQ[i];
-        }
-        while (degreeP >= 0 && coffP[degreeP] === 0.0) {
+        while (degreeP >= 0 && coffP[degreeP] === 0.0)
             degreeP--;
-        }
         return degreeP;
     }
     /** Zero all coefficients */
@@ -1037,17 +1028,17 @@ export class PowerPolynomial {
  */
 export class TrigPolynomial {
     /**
-     *  Solve a polynomial created from trigonometric condition using
-     * Trig.S, Trig.C, Trig.W.  Solution logic includes inferring angular roots
-     * corresponding zero leading coefficients (roots at infinity)
-     * @param coff Coefficients
-     * @param nominalDegree degree of the polynomial under most complex
-     *     root case.  If there are any zero coefficients up to this degree, a single root
-     *     "at infinity" is recorded as its corresponding angular parameter at negative pi/2
-     * @param referenceCoefficient A number which represents the size of coefficients
-     *     at various stages of computation.  A small fraction of this will be used as a zero
-     *     tolerance
-     * @param radians Roots are placed here
+     * Find the roots of a univariate polynomial created from substituting the rational parameterization of the unit
+     * circle into a trigonometric polynomial. Roots are returned as radian angles.
+     * * Currently implemented for polynomials of degree <= 4.
+     * * For example, the ellipse-ellipse intersection problem reduces to finding the roots of a quartic polynomial:
+     * `p(t) = coff[0] + coff[1] t + coff[2] t^2 + coff[3] t^3 + coff[4] t^4`.
+     * * Particular care is given to report a root at t = +/-infinity, which corresponds to the returned angle -pi/2.
+     * @param coff coefficients in the power basis
+     * @param nominalDegree degree of the polynomial under the most complex root case.
+     * @param referenceCoefficient a number which represents the size of coefficients at various stages of computation.
+     * A small fraction of this number will be used as a zero tolerance.
+     * @param radians roots are placed here.
      * @return false if equation is all zeros. This usually means any angle is a solution.
      */
     static solveAngles(coff, nominalDegree, referenceCoefficient, radians) {
@@ -1057,31 +1048,23 @@ export class TrigPolynomial {
         const relTol = this._smallAngle;
         for (let i = 0; i <= nominalDegree; i++) {
             a = Math.abs(coff[i]);
-            if (a > maxCoff) {
+            if (a > maxCoff)
                 maxCoff = a;
-            }
         }
         const coffTol = relTol * maxCoff;
         let degree = nominalDegree;
-        while (degree > 0 && (Math.abs(coff[degree]) <= coffTol)) {
+        while (degree > 0 && (Math.abs(coff[degree]) <= coffTol))
             degree--;
-        }
-        // let status = false;
         const roots = new GrowableFloat64Array();
         if (degree === -1) {
-            // Umm.   Dunno.   Nothing there.
-            // status = false;
+            // do nothing
         }
         else {
-            // status = true;
             if (degree === 0) {
-                // p(t) is a nonzero constant
-                // No roots, but not degenerate.
-                // status = true;
+                // p(t) is a nonzero constant; no roots but not degenerate.
             }
             else if (degree === 1) {
-                // p(t) = coff[1] * t + coff[0]
-                roots.push(-coff[0] / coff[1]);
+                roots.push(-coff[0] / coff[1]); // p(t) = coff[0] + coff[1] * t
             }
             else if (degree === 2) {
                 AnalyticRoots.appendQuadraticRoots(coff, roots);
@@ -1093,70 +1076,68 @@ export class TrigPolynomial {
                 AnalyticRoots.appendQuarticRoots(coff, roots);
             }
             else {
-                // TODO: WILL WORK WITH BEZIER SOLVER
-                // status = false;
+                // TODO: WORK WITH BEZIER SOLVER
+                assert(false, "Unimplemented degree in trig solver");
             }
             if (roots.length > 0) {
-                // Each solution t represents an angle with
-                //  Math.Cos(theta)=C(t)/W(t),  ,sin(theta)=S(t)/W(t)
-                // Division by W has no effect on Atan2 calculations, so we just compute S(t),C(t)
+                // each solution t represents an angle with Math.Cos(theta) = C(t)/W(t) and sin(theta) = S(t)/W(t)
+                // division by W has no effect on atan2 calculations, so we just compute S(t),C(t)
                 for (let i = 0; i < roots.length; i++) {
                     const ss = PowerPolynomial.evaluate(this.S, roots.atUncheckedIndex(i));
                     const cc = PowerPolynomial.evaluate(this.C, roots.atUncheckedIndex(i));
                     radians.push(Math.atan2(ss, cc));
                 }
-                // Each leading zero at the front of the coefficients corresponds to a root at -PI/2.
-                // Only make one entry....
-                // for (int i = degree; i < nominalDegree; i++)
-                if (degree < nominalDegree) {
-                    radians.push(-0.5 * Math.PI);
-                }
             }
+            // If the tail of the coff array is zero, we solved a polynomial of lesser degree above, and
+            // we report the skipped "root at infinity" as the corresponding angle -pi/2 (without multiplicity).
+            // See core\geometry\internaldocs\unitCircleEllipseIntersection.md for details.
+            if (degree < nominalDegree)
+                radians.push(-0.5 * Math.PI);
         }
         return radians.length > 0;
     }
     /**
-     * Compute intersections of unit circle `x^2 + y^2 = 1` with general quadric
-     * `axx * x^2 + axy * x * y + ayy * y^2 + ax * x + ay * y + a1 = 0`
-     * Solutions are returned as angles. Sine and Cosine of the angles are the x, y results.
-     * @param axx  Coefficient of x^2
-     * @param axy  Coefficient of xy
-     * @param ayy  Coefficient of y^2
-     * @param ax  Coefficient of x
-     * @param ay  Coefficient of y
-     * @param a1  Constant coefficient
-     * @param radians  solution angles
+     * Compute intersections of the unit circle `x^2 + y^2 = 1` with the general quadric (conic)
+     * `axx x^2 + axy xy + ayy y^2 + ax x + ay y + a = 0`.
+     * @param axx coefficient of x^2
+     * @param axy coefficient of xy
+     * @param ayy coefficient of y^2
+     * @param ax coefficient of x
+     * @param ay coefficient of y
+     * @param a constant coefficient
+     * @param radians up to 4 solution angles t in the quadric parameterization: x = cos(t), y = sin(t)
      */
-    static solveUnitCircleImplicitQuadricIntersection(axx, axy, ayy, ax, ay, a1, radians) {
-        const Coffs = new Float64Array(5);
-        PowerPolynomial.zero(Coffs);
+    static solveUnitCircleImplicitQuadricIntersection(axx, axy, ayy, ax, ay, a, radians) {
+        const coffs = new Float64Array(5);
+        PowerPolynomial.zero(coffs);
         let degree;
-        if (Geometry.hypotenuseXYZ(axx, axy, ayy) > TrigPolynomial._coefficientRelTol * Geometry.hypotenuseXYZ(ax, ay, a1)) {
-            PowerPolynomial.accumulate(Coffs, this.CW, ax);
-            PowerPolynomial.accumulate(Coffs, this.SW, ay);
-            PowerPolynomial.accumulate(Coffs, this.WW, a1);
-            PowerPolynomial.accumulate(Coffs, this.SS, ayy);
-            PowerPolynomial.accumulate(Coffs, this.CC, axx);
-            PowerPolynomial.accumulate(Coffs, this.SC, axy);
+        // see core\geometry\internaldocs\unitCircleEllipseIntersection.md for derivation of these coefficients
+        if (Geometry.hypotenuseXYZ(axx, axy, ayy) > TrigPolynomial._coefficientRelTol * Geometry.hypotenuseXYZ(ax, ay, a)) {
+            PowerPolynomial.accumulate(coffs, this.CW, ax);
+            PowerPolynomial.accumulate(coffs, this.SW, ay);
+            PowerPolynomial.accumulate(coffs, this.WW, a);
+            PowerPolynomial.accumulate(coffs, this.SS, ayy);
+            PowerPolynomial.accumulate(coffs, this.CC, axx);
+            PowerPolynomial.accumulate(coffs, this.SC, axy);
             degree = 4;
         }
         else {
-            PowerPolynomial.accumulate(Coffs, this.C, ax);
-            PowerPolynomial.accumulate(Coffs, this.S, ay);
-            PowerPolynomial.accumulate(Coffs, this.W, a1);
+            PowerPolynomial.accumulate(coffs, this.C, ax);
+            PowerPolynomial.accumulate(coffs, this.S, ay);
+            PowerPolynomial.accumulate(coffs, this.W, a);
             degree = 2;
         }
-        let maxCoff = 0.0;
-        maxCoff = Math.max(maxCoff, Math.abs(axx), Math.abs(ayy), Math.abs(axy), Math.abs(ax), Math.abs(ay), Math.abs(a1));
-        const b = this.solveAngles(Coffs, degree, maxCoff, radians);
+        const maxCoff = Math.max(Math.abs(axx), Math.abs(ayy), Math.abs(axy), Math.abs(ax), Math.abs(ay), Math.abs(a));
+        const b = this.solveAngles(coffs, degree, maxCoff, radians);
         /*
         for (const theta of angles) {
           const c = theta.cos();
           const s = theta.sin();
           GeometryCoreTestIO.consoleLog({
             angle: theta, co: c, si: s,
-            f: axx * c * c + axy * c * s + ayy * s * s + ax * c + ay * s + a1});
-      } */
+            f: axx * c * c + axy * c * s + ayy * s * s + ax * c + ay * s + a,
+          });
+        } */
         return b;
     }
     /**
@@ -1174,13 +1155,14 @@ export class TrigPolynomial {
      */
     static solveUnitCircleEllipseIntersection(cx, cy, ux, uy, vx, vy, ellipseRadians, circleRadians) {
         circleRadians.length = 0;
+        // see core\geometry\internaldocs\unitCircleEllipseIntersection.md for derivation of these coefficients:
         const acc = ux * ux + uy * uy;
         const acs = 2.0 * (ux * vx + uy * vy);
         const ass = vx * vx + vy * vy;
         const ac = 2.0 * (ux * cx + uy * cy);
-        const asi = 2.0 * (vx * cx + vy * cy);
+        const as = 2.0 * (vx * cx + vy * cy);
         const a = cx * cx + cy * cy - 1.0;
-        const status = this.solveUnitCircleImplicitQuadricIntersection(acc, acs, ass, ac, asi, a, ellipseRadians);
+        const status = this.solveUnitCircleImplicitQuadricIntersection(acc, acs, ass, ac, as, a, ellipseRadians);
         for (const radians of ellipseRadians) {
             const cc = Math.cos(radians);
             const ss = Math.sin(radians);
@@ -1191,7 +1173,7 @@ export class TrigPolynomial {
         return status;
     }
     /**
-     * Compute intersections of unit circle `x^2 + y^2 = w^2` with the ellipse
+     * Compute intersections of unit circle `x^2 + y^2 = w^2` (in homogeneous coordinates) with the ellipse
      * `F(t) = (cx + ux cos(t) + vx sin(t), cy + uy cos(t) + vy sin(t)) / (cw + uw cos(t) + vw sin(t))`.
      * @param cx center x
      * @param cy center y
@@ -1207,13 +1189,14 @@ export class TrigPolynomial {
      */
     static solveUnitCircleHomogeneousEllipseIntersection(cx, cy, cw, ux, uy, uw, vx, vy, vw, ellipseRadians, circleRadians) {
         circleRadians.length = 0;
+        // see core\geometry\internaldocs\unitCircleEllipseIntersection.md for derivation of these coefficients:
         const acc = ux * ux + uy * uy - uw * uw;
         const acs = 2.0 * (ux * vx + uy * vy - uw * vw);
         const ass = vx * vx + vy * vy - vw * vw;
         const ac = 2.0 * (ux * cx + uy * cy - uw * cw);
-        const asi = 2.0 * (vx * cx + vy * cy - vw * cw);
+        const as = 2.0 * (vx * cx + vy * cy - vw * cw);
         const a = cx * cx + cy * cy - cw * cw;
-        const status = this.solveUnitCircleImplicitQuadricIntersection(acc, acs, ass, ac, asi, a, ellipseRadians);
+        const status = this.solveUnitCircleImplicitQuadricIntersection(acc, acs, ass, ac, as, a, ellipseRadians);
         for (const radians of ellipseRadians) {
             const cc = Math.cos(radians);
             const ss = Math.sin(radians);
@@ -1226,326 +1209,62 @@ export class TrigPolynomial {
 }
 // tolerance for small angle decision.
 TrigPolynomial._smallAngle = 1.0e-11;
-/** Standard Basis coefficients for rational sine numerator. */
+// see core\geometry\internaldocs\unitCircleEllipseIntersection.md for derivation of these coefficients.
+/** Standard Basis coefficients for the numerator of the y-coordinate y(t) = S(t)/W(t) in the rational semicircle parameterization. */
 TrigPolynomial.S = Float64Array.from([0.0, 2.0, -2.0]);
-/** Standard Basis coefficients for rational cosine numerator. */
+/** Standard Basis coefficients for the numerator of the x-coordinate x(t) = C(t)/W(t) in the rational semicircle parameterization. */
 TrigPolynomial.C = Float64Array.from([1.0, -2.0]);
-/** Standard Basis coefficients for rational denominator. */
+/** Standard Basis coefficients for the denominator of x(t) and y(t) in the rational semicircle parameterization. */
 TrigPolynomial.W = Float64Array.from([1.0, -2.0, 2.0]);
-/** Standard Basis coefficients for cosine*weight numerator */
+/** Standard Basis coefficients for C(t) * W(t). */
 TrigPolynomial.CW = Float64Array.from([1.0, -4.0, 6.0, -4.0]);
-/** Standard Basis coefficients for sine*weight numerator */
+/** Standard Basis coefficients for S(t) * W(t). */
 TrigPolynomial.SW = Float64Array.from([0.0, 2.0, -6.0, 8.0, -4.0]);
-/** Standard Basis coefficients for sine*cosine numerator */
+/** Standard Basis coefficients for S(t) * C(t). */
 TrigPolynomial.SC = Float64Array.from([0.0, 2.0, -6.0, 4.0]);
-/** Standard Basis coefficients for sine^2 numerator */
+/** Standard Basis coefficients for S(t) * S(t). */
 TrigPolynomial.SS = Float64Array.from([0.0, 0.0, 4.0, -8.0, 4.0]);
-/** Standard Basis coefficients for cosine^2 numerator */
+/** Standard Basis coefficients for C(t) * C(t). */
 TrigPolynomial.CC = Float64Array.from([1.0, -4.0, 4.0]);
-/** Standard Basis coefficients for weight^2 */
+/** Standard Basis coefficients for W(t) * W(t). */
 TrigPolynomial.WW = Float64Array.from([1.0, -4.0, 8.0, -8.0, 4.0]);
-/** Standard Basis coefficients for (Math.Cos^2 - sine^2) numerator */
-TrigPolynomial.CCminusSS = Float64Array.from([1.0, -4.0, 0.0, 8.0, -4.0]);
+/** Standard Basis coefficients for C(t) * C(t) - S(t) * S(t). */
+TrigPolynomial.CCMinusSS = Float64Array.from([1.0, -4.0, 0.0, 8.0, -4.0]); // eslint-disable-line @typescript-eslint/naming-convention
 TrigPolynomial._coefficientRelTol = 1.0e-12;
 /**
- * static methods for commonly appearing sets of equations in 2 or 3 variables
- * @public
+ * * bilinear expression
+ * * `f(u,v) = a + b * u * c * v + d * u * v`
+ * @internal
  */
-export class SmallSystem {
-    /**
-     * Return true if lines (a0,a1) to (b0, b1) have a simple intersection.
-     * Return the fractional (not xy) coordinates in result.x, result.y
-     * @param a0 start point of line a
-     * @param a1  end point of line a
-     * @param b0  start point of line b
-     * @param b1 end point of line b
-     * @param result point to receive fractional coordinates of intersection.   result.x is fraction on line a. result.y is fraction on line b.
-     */
-    static lineSegment2dXYTransverseIntersectionUnbounded(a0, a1, b0, b1, result) {
-        const ux = a1.x - a0.x;
-        const uy = a1.y - a0.y;
-        const vx = b1.x - b0.x;
-        const vy = b1.y - b0.y;
-        const cx = b0.x - a0.x;
-        const cy = b0.y - a0.y;
-        const uv = Geometry.crossProductXYXY(ux, uy, vx, vy);
-        const cv = Geometry.crossProductXYXY(cx, cy, vx, vy);
-        const cu = Geometry.crossProductXYXY(ux, uy, cx, cy);
-        const s = Geometry.conditionalDivideFraction(cv, uv);
-        const t = Geometry.conditionalDivideFraction(cu, uv);
-        if (s !== undefined && t !== undefined) {
-            result.set(s, -t);
-            return true;
-        }
-        result.set(0, 0);
-        return false;
-    }
-    /**
-     * * (ax0,ay0) to (ax0+ux,ay0+uy) are line A.
-     * * (bx0,by0) to (bx0+vx,by0+vy) are lineB.
-     * * Return true if the lines have a simple intersection.
-     * * Return the fractional (not xy) coordinates in result.x, result.y
-     * @param result point to receive fractional coordinates of intersection.   result.x is fraction on line a. result.y is fraction on line b.
-     */
-    static lineSegmentXYUVTransverseIntersectionUnbounded(ax0, ay0, ux, uy, bx0, by0, vx, vy, result) {
-        const cx = bx0 - ax0;
-        const cy = by0 - ay0;
-        const uv = Geometry.crossProductXYXY(ux, uy, vx, vy);
-        const cv = Geometry.crossProductXYXY(cx, cy, vx, vy);
-        const cu = Geometry.crossProductXYXY(ux, uy, cx, cy);
-        const s = Geometry.conditionalDivideFraction(cv, uv);
-        const t = Geometry.conditionalDivideFraction(cu, uv);
-        if (s !== undefined && t !== undefined) {
-            result.set(s, -t);
-            return true;
-        }
-        result.set(0, 0);
-        return false;
-    }
-    /**
-     * Return true if lines (a0,a1) to (b0, b1) have a simple intersection using only xy parts
-     * Return the fractional (not xy) coordinates in result.x, result.y
-     * @param a0 start point of line a
-     * @param a1  end point of line a
-     * @param b0  start point of line b
-     * @param b1 end point of line b
-     * @param result point to receive fractional coordinates of intersection.   result.x is fraction on line a. result.y is fraction on line b.
-     */
-    static lineSegment3dXYTransverseIntersectionUnbounded(a0, a1, b0, b1, result) {
-        const ux = a1.x - a0.x;
-        const uy = a1.y - a0.y;
-        const vx = b1.x - b0.x;
-        const vy = b1.y - b0.y;
-        const cx = b0.x - a0.x;
-        const cy = b0.y - a0.y;
-        const uv = Geometry.crossProductXYXY(ux, uy, vx, vy);
-        const cv = Geometry.crossProductXYXY(cx, cy, vx, vy);
-        const cu = Geometry.crossProductXYXY(ux, uy, cx, cy);
-        const s = Geometry.conditionalDivideFraction(cv, uv);
-        const t = Geometry.conditionalDivideFraction(cu, uv);
-        if (s !== undefined && t !== undefined) {
-            result.set(s, -t);
-            return true;
-        }
-        result.set(0, 0);
-        return false;
-    }
-    /**
-     * Return true if lines (a0,a1) to (b0, b1) have a simple intersection using only xy parts of WEIGHTED 4D Points
-     * Return the fractional (not xy) coordinates in result.x, result.y
-     * @param hA0 homogeneous start point of line a
-     * @param hA1 homogeneous end point of line a
-     * @param hB0 homogeneous start point of line b
-     * @param hB1 homogeneous end point of line b
-     * @param result point to receive fractional coordinates of intersection.   result.x is fraction on line a. result.y is fraction on line b.
-     */
-    static lineSegment3dHXYTransverseIntersectionUnbounded(hA0, hA1, hB0, hB1, result) {
-        // Considering only x,y,w parts....
-        // Point Q along B is (in full homogeneous)  `(1-lambda) B0 + lambda 1`
-        // PointQ is colinear with A0,A1 when the determinant det (A0,A1,Q) is zero.  (Each column takes xyw parts)
-        const alpha0 = Geometry.tripleProduct(hA0.x, hA1.x, hB0.x, hA0.y, hA1.y, hB0.y, hA0.w, hA1.w, hB0.w);
-        const alpha1 = Geometry.tripleProduct(hA0.x, hA1.x, hB1.x, hA0.y, hA1.y, hB1.y, hA0.w, hA1.w, hB1.w);
-        const fractionB = Geometry.conditionalDivideFraction(-alpha0, alpha1 - alpha0);
-        if (fractionB !== undefined) {
-            const beta0 = Geometry.tripleProduct(hB0.x, hB1.x, hA0.x, hB0.y, hB1.y, hA0.y, hB0.w, hB1.w, hA0.w);
-            const beta1 = Geometry.tripleProduct(hB0.x, hB1.x, hA1.x, hB0.y, hB1.y, hA1.y, hB0.w, hB1.w, hA1.w);
-            const fractionA = Geometry.conditionalDivideFraction(-beta0, beta1 - beta0);
-            if (fractionA !== undefined)
-                return Vector2d.create(fractionA, fractionB, result);
-        }
-        return undefined;
-    }
-    /**
-     * Return the line fraction at which the (homogeneous) line is closest to a space point as viewed in xy only.
-     * @param hA0 homogeneous start point of line a
-     * @param hA1 homogeneous end point of line a
-     * @param spacePoint homogeneous point in space
-     */
-    static lineSegment3dHXYClosestPointUnbounded(hA0, hA1, spacePoint) {
-        // Considering only x,y,w parts....
-        // weighted difference of (A1 w0 - A0 w1) is (cartesian) tangent vector along the line as viewed.
-        // The perpendicular (pure vector) W = (-y,x) flip is the direction of projection
-        // Point Q along A is (in full homogeneous)  `(1-lambda) A0 + lambda 1 A1`
-        // PointQ is colinear with spacePoint and and W when the xyw homogeneous determinant | Q W spacePoint | is zero.
-        const tx = hA1.x * hA0.w - hA0.x * hA1.w;
-        const ty = hA1.y * hA0.w - hA0.y * hA1.w;
-        const det0 = Geometry.tripleProduct(hA0.x, -ty, spacePoint.x, hA0.y, tx, spacePoint.y, hA0.w, 0, spacePoint.w);
-        const det1 = Geometry.tripleProduct(hA1.x, -ty, spacePoint.x, hA1.y, tx, spacePoint.y, hA1.w, 0, spacePoint.w);
-        return Geometry.conditionalDivideFraction(-det0, det1 - det0);
-    }
-    /**
-     * Return the line fraction at which the line is closest to a space point as viewed in xy only.
-     * @param pointA0 start point
-     * @param pointA1 end point
-     * @param spacePoint point in space
-     */
-    static lineSegment3dXYClosestPointUnbounded(pointA0, pointA1, spacePoint) {
-        // Considering only x,y parts....
-        const ux = pointA1.x - pointA0.x;
-        const uy = pointA1.y - pointA0.y;
-        const uu = ux * ux + uy * uy;
-        const vx = spacePoint.x - pointA0.x;
-        const vy = spacePoint.y - pointA0.y;
-        const uv = ux * vx + uy * vy;
-        return Geometry.conditionalDivideFraction(uv, uu);
-    }
-    /**
-     * Return the line fraction at which the line is closest to a space point
-     * @param pointA0 start point
-     * @param pointA1 end point
-     * @param spacePoint point in space
-     */
-    static lineSegment3dClosestPointUnbounded(pointA0, pointA1, spacePoint) {
-        const ux = pointA1.x - pointA0.x;
-        const uy = pointA1.y - pointA0.y;
-        const uz = pointA1.z - pointA0.z;
-        const uu = ux * ux + uy * uy + uz * uz;
-        const vx = spacePoint.x - pointA0.x;
-        const vy = spacePoint.y - pointA0.y;
-        const vz = spacePoint.z - pointA0.z;
-        const uv = ux * vx + uy * vy + uz * vz;
-        return Geometry.conditionalDivideFraction(uv, uu);
-    }
-    /**
-     * Return true if lines (a0,a1) to (b0, b1) have closest approach (go by each other) in 3d
-     * Return the fractional (not xy) coordinates in result.x, result.y
-     * @param a0 start point of line a
-     * @param a1  end point of line a
-     * @param b0  start point of line b
-     * @param b1 end point of line b
-     * @param result point to receive fractional coordinates of intersection.   result.x is fraction on line a. result.y is fraction on line b.
-     */
-    static lineSegment3dClosestApproachUnbounded(a0, a1, b0, b1, result) {
-        return this.ray3dXYZUVWClosestApproachUnbounded(a0.x, a0.y, a0.z, a1.x - a0.x, a1.y - a0.y, a1.z - a0.z, b0.x, b0.y, b0.z, b1.x - b0.x, b1.y - b0.y, b1.z - b0.z, result);
-    }
-    /**
-     * Return true if the given rays have closest approach (go by each other) in 3d
-     * Return the fractional (not xy) coordinates as x and y parts of a Point2d.
-     * @param ax x-coordinate of the origin of the first ray
-     * @param ay y-coordinate of the origin of the first ray
-     * @param az z-coordinate of the origin of the first ray
-     * @param au x-coordinate of the direction vector of the first ray
-     * @param av y-coordinate of the direction vector of the first ray
-     * @param aw z-coordinate of the direction vector of the first ray
-     * @param bx x-coordinate of the origin of the second ray
-     * @param by y-coordinate of the origin of the second ray
-     * @param bz z-coordinate of the origin of the second ray
-     * @param bu x-coordinate of the direction vector of the second ray
-     * @param bv y-coordinate of the direction vector of the second ray
-     * @param bw z-coordinate of the direction vector of the second ray
-     * @param result point to receive fractional coordinates of intersection.   result.x is fraction on line a. result.y is fraction on line b.
-     */
-    static ray3dXYZUVWClosestApproachUnbounded(ax, ay, az, au, av, aw, bx, by, bz, bu, bv, bw, result) {
-        const cx = bx - ax;
-        const cy = by - ay;
-        const cz = bz - az;
-        const uu = Geometry.hypotenuseSquaredXYZ(au, av, aw);
-        const vv = Geometry.hypotenuseSquaredXYZ(bu, bv, bw);
-        const uv = Geometry.dotProductXYZXYZ(au, av, aw, bu, bv, bw);
-        const cu = Geometry.dotProductXYZXYZ(cx, cy, cz, au, av, aw);
-        const cv = Geometry.dotProductXYZXYZ(cx, cy, cz, bu, bv, bw);
-        return SmallSystem.linearSystem2d(uu, -uv, uv, -vv, cu, cv, result);
-    }
-    /**
-     * Solve the pair of linear equations
-     * * `ux * x + vx * y = cx`
-     * * `uy * x + vy * y = cy`
-     * @param ux xx coefficient
-     * @param vx xy coefficient
-     * @param uy yx coefficient
-     * @param vy yy coefficient
-     * @param cx x right hand side
-     * @param cy y right hand side
-     * @param result (x,y) solution (MUST be preallocated by caller)
-     */
-    static linearSystem2d(ux, vx, // first row of matrix
-    uy, vy, // second row of matrix
-    cx, cy, // right side
-    result) {
-        const uv = Geometry.crossProductXYXY(ux, uy, vx, vy);
-        const cv = Geometry.crossProductXYXY(cx, cy, vx, vy);
-        const cu = Geometry.crossProductXYXY(ux, uy, cx, cy);
-        const s = Geometry.conditionalDivideFraction(cv, uv);
-        const t = Geometry.conditionalDivideFraction(cu, uv);
-        if (s !== undefined && t !== undefined) {
-            result.set(s, t);
-            return true;
-        }
-        result.set(0, 0);
-        return false;
-    }
+export class BilinearPolynomial {
     /**
-     * Solve a linear system:
-     * * x equation: `axx * u + axy * v + axz * w = cx`
-     * * y equation: `ayx * u + ayy * v + ayz * w = cy`
-     * * z equation: `azx * u + azy * v + azz * w = cz`
-     * @param axx row 0, column 0 coefficient
-     * @param axy row 0, column 1 coefficient
-     * @param axz row 0, column 1 coefficient
-     * @param ayx row 1, column 0 coefficient
-     * @param ayy row 1, column 1 coefficient
-     * @param ayz row 1, column 2 coefficient
-     * @param azx row 2, column 0 coefficient
-     * @param azy row 2, column 1 coefficient
-     * @param azz row 2, column 2 coefficient
-     * @param cx right hand side row 0 coefficient
-     * @param cy right hand side row 1 coefficient
-     * @param cz right hand side row 2 coefficient
-     * @param result optional result.
-     * @returns solution vector (u,v,w) or `undefined` if system is singular.
+     *
+     * @param a constant coefficient
+     * @param b `u` coefficient
+     * @param c `v` coefficient
+     * @param d `u*v` coefficient
      */
-    static linearSystem3d(axx, axy, axz, // first row of matrix
-    ayx, ayy, ayz, // second row of matrix
-    azx, azy, azz, // second row of matrix
-    cx, cy, cz, // right side
-    result) {
-        // determinants of various combinations of columns ...
-        const detXYZ = Geometry.tripleProduct(axx, ayx, azx, axy, ayy, azy, axz, ayz, azz);
-        const detCYZ = Geometry.tripleProduct(cx, cy, cz, axy, ayy, azy, axz, ayz, azz);
-        const detXCZ = Geometry.tripleProduct(axx, ayx, azx, cx, cy, cz, axz, ayz, azz);
-        const detXYC = Geometry.tripleProduct(axx, ayx, azx, axy, ayy, azy, cx, cy, cz);
-        const s = Geometry.conditionalDivideFraction(detCYZ, detXYZ);
-        const t = Geometry.conditionalDivideFraction(detXCZ, detXYZ);
-        const u = Geometry.conditionalDivideFraction(detXYC, detXYZ);
-        if (s !== undefined && t !== undefined && u !== undefined) {
-            return Vector3d.create(s, t, u, result);
-        }
-        return undefined;
+    constructor(a, b, c, d) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+        this.d = d;
     }
     /**
-     * Compute the intersection of three planes.
-     * @param xyzA point on the first plane
-     * @param normalA normal of the first plane
-     * @param xyzB point on the second plane
-     * @param normalB normal of the second plane
-     * @param xyzC point on the third plane
-     * @param normalC normal of the third plane
-     * @param result optional result
-     * @returns intersection point of the three planes (as a Vector3d), or undefined if at least two planes are parallel.
+     * Evaluate the bilinear expression at u,v
      */
-    static intersect3Planes(xyzA, normalA, xyzB, normalB, xyzC, normalC, result) {
-        return this.linearSystem3d(normalA.x, normalA.y, normalA.z, normalB.x, normalB.y, normalB.z, normalC.x, normalC.y, normalC.z, Geometry.dotProductXYZXYZ(xyzA.x, xyzA.y, xyzA.z, normalA.x, normalA.y, normalA.z), Geometry.dotProductXYZXYZ(xyzB.x, xyzB.y, xyzB.z, normalB.x, normalB.y, normalB.z), Geometry.dotProductXYZXYZ(xyzC.x, xyzC.y, xyzC.z, normalC.x, normalC.y, normalC.z), result);
+    evaluate(u, v) {
+        return this.a + this.b * u + v * (this.c + this.d * u);
     }
-    /**
-     * * in rowB, replace `rowB[j] += a * rowB[pivot] * rowA[j] / rowA[pivot]` for `j>pivot`
-     * @param rowA row that does not change
-     * @param pivotIndex index of pivot (divisor) in rowA.
-     * @param rowB row where elimination occurs.
+    /** Create a bilinear polynomial z=f(u,v) given z values at 00, 10, 01, 11.
      */
-    static eliminateFromPivot(rowA, pivotIndex, rowB, a) {
-        const n = rowA.length;
-        let q = Geometry.conditionalDivideFraction(rowB[pivotIndex], rowA[pivotIndex]);
-        if (q === undefined)
-            return false;
-        q *= a;
-        for (let j = pivotIndex + 1; j < n; j++)
-            rowB[j] += q * rowA[j];
-        return true;
+    static createUnitSquareValues(f00, f10, f01, f11) {
+        return new BilinearPolynomial(f00, f10, f10, f11 - f10 - f01);
     }
     /**
      * Solve a pair of bilinear equations
      * * First equation: `a0 + b0 * u + c0 * v + d0 * u * v = 0`
-     * * Second equation: `a0 + b0 * u + c0 * v + d0 * u * v = 0`
+     * * Second equation: `a1 + b1 * u + c1 * v + d1 * u * v = 0`
      */
     static solveBilinearPair(a0, b0, c0, d0, a1, b1, c1, d1) {
         // constant linear, and quadratic coefficients for c0 + c1 * u + c2 * u*u = 0
@@ -1566,37 +1285,6 @@ export class SmallSystem {
         }
         return uv;
     }
-}
-/**
- * * bilinear expression
- * * `f(u,v) = a + b * u * c * v + d * u * v`
- * @internal
- */
-export class BilinearPolynomial {
-    /**
-     *
-     * @param a constant coefficient
-     * @param b `u` coefficient
-     * @param c `v` coefficient
-     * @param d `u*v` coefficient
-     */
-    constructor(a, b, c, d) {
-        this.a = a;
-        this.b = b;
-        this.c = c;
-        this.d = d;
-    }
-    /**
-     * Evaluate the bilinear expression at u,v
-     */
-    evaluate(u, v) {
-        return this.a + this.b * u + v * (this.c + this.d * u);
-    }
-    /** Create a bilinear polynomial z=f(u,v) given z values at 00, 10, 01, 11.
-     */
-    static createUnitSquareValues(f00, f10, f01, f11) {
-        return new BilinearPolynomial(f00, f10, f10, f11 - f10 - f01);
-    }
     /**
      * Solve the simultaneous equations
      * * `p(u,v) = pValue`
@@ -1607,7 +1295,7 @@ export class BilinearPolynomial {
      * @param qValue
      */
     static solvePair(p, pValue, q, qValue) {
-        return SmallSystem.solveBilinearPair(p.a - pValue, p.b, p.c, p.d, q.a - qValue, q.b, q.c, q.d);
+        return BilinearPolynomial.solveBilinearPair(p.a - pValue, p.b, p.c, p.d, q.a - qValue, q.b, q.c, q.d);
     }
 }
 /**