@itwin/core-geometry 4.3.0-dev.9 → 4.3.1

package/lib/esm/numerics/Newton.js

@@ -8,29 +8,31 @@
 import { Geometry } from "../Geometry";
 import { Plane3dByOriginAndVectors } from "../geometry3d/Plane3dByOriginAndVectors";
 import { Point2d, Vector2d } from "../geometry3d/Point2dVector2d";
+import { Ray3d } from "../geometry3d/Ray3d";
 import { SmallSystem } from "./Polynomials";
-// cspell:word currentdFdX
-/** base class for Newton iterations in various dimensions.
- * Dimension-specific classes carry all dimension-related data and answer generalized queries
- * from this base class.
+// cspell:word currentdFdX XYRR
+/**
+ * Base class for Newton iterations in various dimensions.
+ * Dimension-specific classes carry all dimension-related data and answer generalized queries from this base class.
  * @internal
  */
 export class AbstractNewtonIterator {
     /**
+     * The constructor.
      * @param stepSizeTarget tolerance to consider a single step converged.
-     * This number should be "moderately" strict.   Because 2 successive convergences are required,
+     * This number should be "moderately" strict. Because 2 successive convergences are required,
      * it is expected that a first "accept" for (say) 10 to 14 digit step will be followed by another
-     * iteration.   A well behaved newton would then hypothetically double the number of digits to
-     * 20 to 28.  Since the IEEE double only carries 16 digits, this second-convergence step will
+     * iteration. A well behaved newton would then hypothetically double the number of digits to
+     * 20 to 28. Since the IEEE double only carries 16 digits, this second-convergence step will
      * typically achieve full precision.
      * @param successiveConvergenceTarget number of successive convergences required for acceptance.
-     * @param maxIterations max number of iterations.   A typical newton step converges in 3 to 6 iterations.
-     *     Allow 15 to 20 to catch difficult cases.
+     * @param maxIterations max number of iterations. A typical newton step converges in 3 to 6 iterations.
+     * Allow 15 to 20 to catch difficult cases.
      */
     constructor(stepSizeTolerance = 1.0e-11, successiveConvergenceTarget = 2, maxIterations = 15) {
-        /** Number of consecutive steps which passed convergence condition */
+        /** Number of consecutive steps which passed convergence condition. */
         this._numAccepted = 0;
-        /** number of iterations (incremented at each step) */
+        /** Number of iterations (incremented at each step). */
         this.numIterations = 0;
         this._stepSizeTolerance = stepSizeTolerance;
         this._successiveConvergenceTarget = successiveConvergenceTarget;
@@ -38,8 +40,9 @@ export class AbstractNewtonIterator {
     }
     /**
      * Test if a step is converged.
-     * * Convergence is accepted with enough (_successiveConvergenceTarget) small steps (according to _stepSizeTolerance) occur in succession.
-     * @param delta step size as reported by currentStepSize
+     * * Convergence is accepted with enough (_successiveConvergenceTarget) small steps (according to _stepSizeTolerance)
+     * occur in succession.
+     * @param delta step size as reported by currentStepSize.
      */
     testConvergence(delta) {
         if (Math.abs(delta) < this._stepSizeTolerance) {
@@ -52,16 +55,16 @@ export class AbstractNewtonIterator {
     /**
      * Run iterations, calling various methods from base and derived classes:
      * * computeStep -- typically evaluate derivatives and solve linear system.
-     * * currentStepSize -- return numeric measure of the step just computed by computeStep
+     * * currentStepSize -- return numeric measure of the step just computed by computeStep.
      * * testConvergence -- test if the step from currentStepSize (along with recent steps) is converged.
-     * * applyCurrentStep -- apply the step to the independent variables
+     * * applyCurrentStep -- apply the step to the independent variables.
      */
     runIterations() {
         this._numAccepted = 0;
         this.numIterations = 0;
         while (this.numIterations++ < this._maxIterations && this.computeStep()) {
-            if (this.testConvergence(this.currentStepSize())
-                && this.applyCurrentStep(true)) {
+            if (this.testConvergence(this.currentStepSize()) && this.applyCurrentStep(true)) {
+                // console.log("iter: " + this.numIterations); // print number of Newton iterations for debug
                 return true;
             }
             this.applyCurrentStep(false);
@@ -69,7 +72,8 @@ export class AbstractNewtonIterator {
         return false;
     }
 }
-/** object to evaluate a newton function.  The object must retain most-recent function and derivative
+/**
+ * Object to evaluate a newton function. The object must retain most-recent function and derivative
  * values for immediate query.
  * @internal
  */
@@ -77,27 +81,40 @@ export class NewtonEvaluatorRtoRD {
 }
 /**
  * Newton iterator for use when both function and derivative can be evaluated.
+ * To solve `f(x) = 0`, the Newton iteration is `x_{n+1} = x_n - dx = x_n - f(x_n)/f'(x_n)`.
+ * To solve `f(x) = target` which is equivalent to solving  `g(x) = f(x) - target = 0`, the Newton iteration is
+ * `x_{n+1} = x_n - dx = x_n - g(x_n)/g'(x_n) = x_n - (f(x_n)-target)/f'(x_n)`.
  * @internal
  */
 export class Newton1dUnbounded extends AbstractNewtonIterator {
     /**
-     * Constructor for 1D newton iteration with approximate derivatives.
-     * @param func function that returns both function and derivative.
+     * Constructor for 1D newton iteration with derivatives.
+     * @param func function that returns both function value and derivative.
      */
     constructor(func) {
         super();
         this._func = func;
         this.setTarget(0);
     }
-    /** Set the independent variable */
-    setX(x) { this._currentX = x; return true; }
-    /** Get the independent variable */
-    getX() { return this._currentX; }
-    /** Set the target function value */
-    setTarget(y) { this._target = y; }
-    /** move the current X by the just-computed step */
-    applyCurrentStep() { return this.setX(this._currentX - this._currentStep); }
-    /** Compute the univariate newton step. */
+    /** Set the independent variable, i.e., x_n. */
+    setX(x) {
+        this._currentX = x;
+        return true;
+    }
+    /** Get the independent variable, i.e., x_n. */
+    getX() {
+        return this._currentX;
+    }
+    /** Set the target function value. */
+    setTarget(y) {
+        this._target = y;
+    }
+    /** Move the current X by the just-computed step, i.e., `x_n - dx`. */
+    applyCurrentStep() {
+        // console.log(this._currentX - this._currentStep); // print approximations for debug
+        return this.setX(this._currentX - this._currentStep);
+    }
+    /** Compute the univariate newton step dx. */
     computeStep() {
         if (this._func.evaluate(this._currentX)) {
             const dx = Geometry.conditionalDivideFraction(this._func.currentF - this._target, this._func.currentdFdX);
@@ -108,41 +125,54 @@ export class Newton1dUnbounded extends AbstractNewtonIterator {
         }
         return false;
     }
-    /** Return the current step size as a relative number. */
+    /** Return the current step size as a relative number, i.e., `|dx / (1 + |x_n|)|`. */
     currentStepSize() {
         return Math.abs(this._currentStep / (1.0 + Math.abs(this._currentX)));
     }
 }
-/** object to evaluate a newton function (without derivative).  The object must retain most-recent function value.
+/**
+ * Object to evaluate a newton function (without derivative). The object must retain most-recent function value.
  * @internal
  */
 export class NewtonEvaluatorRtoR {
 }
-/** Newton iteration for a univariate function, using approximate derivatives.
+/**
+ * Newton iteration for a univariate function, using approximate derivatives.
+ * To approximate the derivatives we use a small step `h`, i.e., `f'(x_n) = (f(x_n + h) - f(x_n)) / h`.
+ * Therefore, to solve `f(x) = 0`, the iteration is
+ * `x_{n+1} = x_n - dx = x_n - f(x_n)/f'(x_n) = x_n - f(x_n) * h / (f(x_n + h) - f(x_n))`.
  * @internal
  */
 export class Newton1dUnboundedApproximateDerivative extends AbstractNewtonIterator {
     /**
      * Constructor for 1D newton iteration with approximate derivatives.
-     * @param func function that returns both function and derivative.
+     * @param func function that only returns function value (and not derivative).
      */
     constructor(func) {
         super();
         this._func = func;
         this.derivativeH = 1.0e-8;
     }
-    /** Set the x (independent, iterated) value */
-    setX(x) { this._currentX = x; return true; }
-    /** Get the independent variable */
-    getX() { return this._currentX; }
-    /** move the current X by the just-computed step */
-    applyCurrentStep() { return this.setX(this._currentX - this._currentStep); }
-    /** Univariate newton step computed with APPROXIMATE derivative. */
+    /** Set the independent variable, i.e., x_n. */
+    setX(x) {
+        this._currentX = x;
+        return true;
+    }
+    /** Get the independent variable, i.e., x_n. */
+    getX() {
+        return this._currentX;
+    }
+    /** Move the current X by the just-computed step, i.e., `x_n - dx`. */
+    applyCurrentStep() {
+        // console.log(this._currentX - this._currentStep); // print approximations for debug
+        return this.setX(this._currentX - this._currentStep);
+    }
+    /** Univariate newton step dx, computed with approximate derivative. */
     computeStep() {
         if (this._func.evaluate(this._currentX)) {
-            const fA = this._func.currentF;
+            const fA = this._func.currentF; // f(x_n)
             if (this._func.evaluate(this._currentX + this.derivativeH)) {
-                const fB = this._func.currentF;
+                const fB = this._func.currentF; // f(x_n + h)
                 const dx = Geometry.conditionalDivideFraction(fA, (fB - fA) / this.derivativeH);
                 if (dx !== undefined) {
                     this._currentStep = dx;
@@ -152,17 +182,18 @@ export class Newton1dUnboundedApproximateDerivative extends AbstractNewtonIterat
         }
         return false;
     }
-    /** Return the current step size as a relative number. */
+    /** Return the current step size as a relative number, i.e., `|dx / (1 + |x_n|)|`. */
     currentStepSize() {
         return Math.abs(this._currentStep / (1.0 + Math.abs(this._currentX)));
     }
 }
-/** object to evaluate a 2-parameter newton function (with derivatives!!).
+/**
+ * Object to evaluate a 2-parameter newton function with derivatives.
  * @internal
  */
 export class NewtonEvaluatorRRtoRRD {
     /**
-     * constructor.
+     * Constructor.
      * * This creates a currentF object to (repeatedly) receive function and derivatives.
      */
     constructor() {
@@ -171,51 +202,83 @@ export class NewtonEvaluatorRRtoRRD {
 }
 /**
  * Implement evaluation steps for newton iteration in 2 dimensions, using caller supplied NewtonEvaluatorRRtoRRD object.
+ * * Suppose we want to find the roots of `F(u,v) := (x(u,v), y(u,v))`. Writing `X := (u,v)` and `F(X)` as column vectors,
+ *  the 2D Newton's iteration to find a root of `F` is given by:
+ * `X_{n+1} = X_n - dX = X_n - JInv(X_n)F(X_n)`, where `JInv` is the inverse of the Jacobian matrix `J`, and `J` is
+ * defined by the partial derivatives of the component functions of F:
+ *
+ * `[dx/du   dx/dv]`
+ *
+ * `[dy/du   dy/dv]`
  * @internal
  */
 export class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {
+    /**
+     * Constructor for 2D newton iteration with derivatives.
+     * @param func function that returns both function value and derivative.
+     */
     constructor(func) {
-        super();
+        const maxIterations = 100; // Was default (15). We observed 49 iters to achieve 1e-11 tol with tangent geometry.
+        super(undefined, undefined, maxIterations);
         this._func = func;
         this._currentStep = Vector2d.createZero();
         this._currentUV = Point2d.createZero();
     }
-    /** Set the current uv coordinates for current iteration */
-    setUV(x, y) { this._currentUV.set(x, y); return true; }
-    /** Get the current u coordinate */
-    getU() { return this._currentUV.x; }
-    /** Get the current v coordinate */
-    getV() { return this._currentUV.y; }
-    /** Move the currentUV coordinate by currentStep. */
-    applyCurrentStep() { return this.setUV(this._currentUV.x - this._currentStep.x, this._currentUV.y - this._currentStep.y); }
-    /** Evaluate the functions and derivatives at this._currentUV
-     * Invert the jacobian and compute the this._currentStep.
+    /** Set the current uv parameters, i.e., `X_n = (u_n, v_n)`. */
+    setUV(u, v) {
+        this._currentUV.set(u, v);
+        return true;
+    }
+    /** Get the current u parameter of X_n, i.e., u_n. */
+    getU() {
+        return this._currentUV.x;
+    }
+    /** Get the current v parameter of X_n, i.e., v_n. */
+    getV() {
+        return this._currentUV.y;
+    }
+    /** Update the current uv parameter by currentStep, i.e., compute `X_{n+1} := X_n - dX = (u_n - du, v_n - dv)`. */
+    applyCurrentStep() {
+        // print approximations for debug
+        // console.log("(" + (this._currentUV.x - this._currentStep.x) + "," + (this._currentUV.y - this._currentStep.y) + ")");
+        return this.setUV(this._currentUV.x - this._currentStep.x, this._currentUV.y - this._currentStep.y);
+    }
+    /**
+     * Evaluate the functions and derivatives at `X_n = (u_n, v_n)`, and solve the Jacobian matrix equation to
+     * compute `dX = (du, dv)`.
      */
     computeStep() {
         if (this._func.evaluate(this._currentUV.x, this._currentUV.y)) {
             const fA = this._func.currentF;
-            if (SmallSystem.linearSystem2d(fA.vectorU.x, fA.vectorV.x, fA.vectorU.y, fA.vectorV.y, fA.origin.x, fA.origin.y, this._currentStep))
+            if ( // Given X_{n+1} = X_n - dX = X_n - JInv(X_n) F(X_n), we solve J(X_n) dX = F(X_n) for dX:
+            SmallSystem.linearSystem2d(fA.vectorU.x, fA.vectorV.x, // x_u(X_n), x_v(X_n): 1st row of J evaluated at X_n
+            fA.vectorU.y, fA.vectorV.y, // y_u(X_n), y_v(X_n): 2nd row of J evaluated at X_n
+            fA.origin.x, fA.origin.y, // F(X_n) := (x(X_n), y(X_n))
+            this._currentStep))
                 return true;
         }
         return false;
     }
     /**
-     * Return the largest relative step of the x,y, components of the current step.
+     * Return the current relative step size, i.e., the larger absolute component of `dX / (1 + |X_n|)`
      */
     currentStepSize() {
         return Geometry.maxAbsXY(this._currentStep.x / (1.0 + Math.abs(this._currentUV.x)), this._currentStep.y / (1.0 + Math.abs(this._currentUV.y)));
     }
 }
 /**
- * SimpleNewton has static methods for newton methods with evaluated functions presented as immediate arguments (not function object)
+ * SimpleNewton has static methods for newton methods with evaluated functions presented as immediate arguments
+ * (not function object).
  * @internal
  */
 export class SimpleNewton {
-    /** Run a one-dimensional newton iteration with separate functions for function and derivative.
-     * * completion is at 2 (TWO) successive passes at (absoluteTolerance + relTol * abs (x)), where relTol is chosen internally.
-     * * absoluteTolerance is usually aggressively tight -- should come into play only for x near zero.
-     * * The relTol is fluffy (for instance around 1e-11) but in properly converging cases the extra pass after first success
-     *    normally moves to full machine precision.
+    /**
+     * Run a one-dimensional newton iteration with separate functions for function and derivative.
+     * * Completion is at 2 (TWO) successive passes at `absoluteTolerance + relTol * abs(x)`, where relTol is
+     * chosen internally.
+     * * `absoluteTolerance` is usually aggressively tight -- should come into play only for x near zero.
+     * * The `relTol` is fluffy (for instance around 1e-11) but in properly converging cases the extra pass after
+     * first success normally moves to full machine precision.
      * * This is an open-loop newton -- it just runs, and returns undefined if anything bad happens.
      */
     static runNewton1D(x, func, derivative, absoluteTolerance = Geometry.smallFloatingPoint) {
@@ -230,10 +293,11 @@ export class SimpleNewton {
                 if (dx === undefined)
                     return undefined;
                 x -= dx;
+                // console.log(x); // print approximations for debug
                 tolerance = absoluteTolerance + Math.abs(x) * relTol;
                 if (Math.abs(dx) < tolerance) {
                     numConverged++;
-                    if (dx === 0.0 || numConverged > 1) // bypass convergence count on true 0 dx !
+                    if (dx === 0.0 || numConverged > 1) // bypass convergence count on true 0 dx
                         return x;
                 }
                 else {
@@ -244,4 +308,104 @@ export class SimpleNewton {
         return undefined;
     }
 }
+/**
+ * Class to evaluate XY intersection between 2 curve primitives using the Newton method.
+ * @internal
+ */
+export class CurveCurveIntersectionXYRRToRRD extends NewtonEvaluatorRRtoRRD {
+    constructor(curveP, curveQ) {
+        super();
+        this._curveP = curveP;
+        this._curveQ = curveQ;
+        this._rayP = Ray3d.createZero();
+        this._rayQ = Ray3d.createZero();
+    }
+    evaluate(fractionU, fractionV) {
+        /**
+         * To find an intersection between xy-curves P(u) = (x_p(u), y_p(u)) and Q(v) = (x_q(v), y_q(v)) we should solve
+         *   F(u,v) := P(u) - Q(v) = (0,0)
+         * Using the Newton method we can find the fractions u and v at the intersection via
+         *   [u_{n+1}]     [u_n]          [x_p'(u_n)  -x_q'(v_n)]    [x_p(u_n) - x_q(v_n)]
+         *              =         -  Inv(                         )
+         *   [v_{n+1}]     [v_n]          [y_p'(u_n)  -y_q'(v_n)]    [y_p(u_n) - y_q(v_n)]
+         * Note that this is xy intersection so we can ignore z.
+         */
+        this._curveP.fractionToPointAndDerivative(fractionU, this._rayP);
+        this._curveQ.fractionToPointAndDerivative(fractionV, this._rayQ);
+        this.currentF.setOriginAndVectorsXYZ(this._rayP.origin.x - this._rayQ.origin.x, this._rayP.origin.y - this._rayQ.origin.y, 0.0, this._rayP.direction.x, this._rayP.direction.y, 0.0, -this._rayQ.direction.x, -this._rayQ.direction.y, 0.0);
+        return true;
+    }
+}
+/**
+ * Class to evaluate XY close approach between a curve primitive and a point using the Newton method.
+ * @internal
+ */
+export class CurvePointCloseApproachXYRtoRD extends NewtonEvaluatorRtoRD {
+    constructor(curveP, pointQ) {
+        super();
+        this._curveP = curveP;
+        this._pointQ = pointQ;
+        this._planeP = Plane3dByOriginAndVectors.createXYPlane();
+    }
+    evaluate(fractionU) {
+        /**
+         * To find a close approach between xy-curve P(u) and xy-point q we should solve
+         *    F(u) := P'(u).(P(u) - q) = 0
+         * For a solution u, the segment S(u) := P(u) - q is perpendicular to the curve tangent P'(u), which means S(u) is a close approach.
+         * Using the Newton method we can find the fractions u at the close approach location via
+         *    u_{n+1} = u_n + F(u_n)/F'(u_n) = u_n + [ P'(u_n).S(u_n) ]/[ P''(u_n).S(u_n) + P'(u_n).P'(u_n) ]
+         * Note that this is xy close approach so we can ignore z.
+         */
+        this._curveP.fractionToPointAnd2Derivatives(fractionU, this._planeP);
+        const segX = this._planeP.origin.x - this._pointQ.x;
+        const segY = this._planeP.origin.y - this._pointQ.y;
+        const pDerivX = this._planeP.vectorU.x;
+        const pDerivY = this._planeP.vectorU.y;
+        const p2DerivX = this._planeP.vectorV.x;
+        const p2DerivY = this._planeP.vectorV.y;
+        this.currentF = pDerivX * segX + pDerivY * segY;
+        this.currentdFdX = p2DerivX * segX + pDerivX * pDerivX + p2DerivY * segY + pDerivY * pDerivY;
+        return true;
+    }
+}
+/**
+ * Class to evaluate XY close approach between 2 curve primitives using the Newton method.
+ * @internal
+ */
+export class CurveCurveCloseApproachXYRRtoRRD extends NewtonEvaluatorRRtoRRD {
+    constructor(curveP, curveQ) {
+        super();
+        this._curveP = curveP;
+        this._curveQ = curveQ;
+        this._planeP = Plane3dByOriginAndVectors.createXYPlane();
+        this._planeQ = Plane3dByOriginAndVectors.createXYPlane();
+    }
+    evaluate(fractionU, fractionV) {
+        /**
+         * To find a close approach between xy-curves P(u) and Q(v) we should solve
+         *    F(u,v) := (P'(u).(P(u) - Q(v)), Q'(v).(P(u) - Q(v))) = (0,0)
+         * For a solution (u,v), the segment S(u,v) := P(u) - Q(v) is perpendicular to the curve tangents P'(u) and Q'(v),
+         * which means S(u,v) is a close approach.
+         * Using the Newton method we can find the fractions u and v at the close approach location via
+         *   [u_{n+1}]     [u_n]          [P''(u_n).S(u_n,v_n) + P'(u_n).P'(u_n)    -P'(u_n).Q'(v_n)]    [P'(u_n).S(u_n,v_n)]
+         *              =         -  Inv(                                                            )
+         *   [v_{n+1}]     [v_n]          [Q'(v_n).P'(u_n)     Q''(v_n).S(u_n,v_n) - Q'(v_n).Q'(v_n)]    [Q'(v_n).S(u_n,v_n)]
+         * Note that this is xy close approach so we can ignore z.
+         */
+        this._curveP.fractionToPointAnd2Derivatives(fractionU, this._planeP);
+        this._curveQ.fractionToPointAnd2Derivatives(fractionV, this._planeQ);
+        const segX = this._planeP.origin.x - this._planeQ.origin.x;
+        const segY = this._planeP.origin.y - this._planeQ.origin.y;
+        const pDerivX = this._planeP.vectorU.x;
+        const pDerivY = this._planeP.vectorU.y;
+        const qDerivX = this._planeQ.vectorU.x;
+        const qDerivY = this._planeQ.vectorU.y;
+        const p2DerivX = this._planeP.vectorV.x;
+        const p2DerivY = this._planeP.vectorV.y;
+        const q2DerivX = this._planeQ.vectorV.x;
+        const q2DerivY = this._planeQ.vectorV.y;
+        this.currentF.setOriginAndVectorsXYZ(pDerivX * segX + pDerivY * segY, qDerivX * segX + qDerivY * segY, 0.0, p2DerivX * segX + p2DerivY * segY + pDerivX * pDerivX + pDerivY * pDerivY, qDerivX * pDerivX + qDerivY * pDerivY, 0.0, -(pDerivX * qDerivX + pDerivY * qDerivY), q2DerivX * segX + q2DerivY * segY - qDerivX * qDerivX - qDerivY * qDerivY, 0.0);
+        return true;
+    }
+}
 //# sourceMappingURL=Newton.js.map

package/lib/esm/numerics/Newton.js.map

@@ -1 +1 @@
-{"version":3,"file":"Newton.js","sourceRoot":"","sources":["../../../src/numerics/Newton.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n\r\n/** @packageDocumentation\r\n * @module Numerics\r\n */\r\n\r\nimport { Geometry } from \"../Geometry\";\r\nimport { Plane3dByOriginAndVectors } from \"../geometry3d/Plane3dByOriginAndVectors\";\r\nimport { Point2d, Vector2d } from \"../geometry3d/Point2dVector2d\";\r\nimport { SmallSystem } from \"./Polynomials\";\r\n\r\n// cspell:word currentdFdX\r\n/** base class for Newton iterations in various dimensions.\r\n * Dimension-specific classes carry all dimension-related data and answer generalized queries\r\n * from this base class.\r\n * @internal\r\n */\r\nexport abstract class AbstractNewtonIterator {\r\n  /** Compute a step.  The current x and function values must be retained for use in later method calls */\r\n  public abstract computeStep(): boolean;\r\n  /** return the current step size, scaled for use in tolerance tests.\r\n   * * This is a single number, typically the max of various per-dimension `dx / (1+x)` for the x and dx of that dimension.\r\n   */\r\n  public abstract currentStepSize(): number;\r\n  /**\r\n   * Apply the current step (in all dimensions)\r\n   * @param isFinalStep true if this is a final step.\r\n   */\r\n  public abstract applyCurrentStep(isFinalStep: boolean): boolean;\r\n  /**\r\n   * @param stepSizeTarget tolerance to consider a single step converged.\r\n   * This number should be \"moderately\" strict.   Because 2 successive convergences are required,\r\n   * it is expected that a first \"accept\" for (say) 10 to 14 digit step will be followed by another\r\n   * iteration.   A well behaved newton would then hypothetically double the number of digits to\r\n   * 20 to 28.  Since the IEEE double only carries 16 digits, this second-convergence step will\r\n   * typically achieve full precision.\r\n   * @param successiveConvergenceTarget number of successive convergences required for acceptance.\r\n   * @param maxIterations max number of iterations.   A typical newton step converges in 3 to 6 iterations.\r\n   *     Allow 15 to 20 to catch difficult cases.\r\n   */\r\n  protected constructor(\r\n    stepSizeTolerance: number = 1.0e-11,\r\n    successiveConvergenceTarget: number = 2,\r\n    maxIterations: number = 15) {\r\n    this._stepSizeTolerance = stepSizeTolerance;\r\n    this._successiveConvergenceTarget = successiveConvergenceTarget;\r\n    this._maxIterations = maxIterations;\r\n  }\r\n  /** Number of consecutive steps which passed convergence condition */\r\n  protected _numAccepted: number = 0;\r\n  /** Target number of successive convergences */\r\n  protected _successiveConvergenceTarget: number;\r\n  /** convergence target (the implementation-specific currentStepSize is compared to this) */\r\n  protected _stepSizeTolerance: number;\r\n  /** Max iterations allowed */\r\n  protected _maxIterations: number;\r\n  /** number of iterations (incremented at each step) */\r\n  public numIterations: number = 0;\r\n  /**\r\n   * Test if a step is converged.\r\n   * * Convergence is accepted with enough (_successiveConvergenceTarget) small steps (according to _stepSizeTolerance) occur in succession.\r\n   * @param delta step size as reported by currentStepSize\r\n   */\r\n  public testConvergence(delta: number): boolean {\r\n    if (Math.abs(delta) < this._stepSizeTolerance) {\r\n      this._numAccepted++;\r\n      return this._numAccepted >= this._successiveConvergenceTarget;\r\n    }\r\n    this._numAccepted = 0;\r\n    return false;\r\n  }\r\n  /**\r\n   * Run iterations, calling various methods from base and derived classes:\r\n   * * computeStep -- typically evaluate derivatives and solve linear system.\r\n   * * currentStepSize -- return numeric measure of the step just computed by computeStep\r\n   * * testConvergence -- test if the step from currentStepSize (along with recent steps) is converged.\r\n   * * applyCurrentStep -- apply the step to the independent variables\r\n   */\r\n  public runIterations(): boolean {\r\n    this._numAccepted = 0;\r\n    this.numIterations = 0;\r\n    while (this.numIterations++ < this._maxIterations && this.computeStep()) {\r\n      if (this.testConvergence(this.currentStepSize())\r\n        && this.applyCurrentStep(true)) {\r\n        return true;\r\n      }\r\n      this.applyCurrentStep(false);\r\n    }\r\n    return false;\r\n  }\r\n}\r\n/** object to evaluate a newton function.  The object must retain most-recent function and derivative\r\n * values for immediate query.\r\n * @internal\r\n */\r\nexport abstract class NewtonEvaluatorRtoRD {\r\n  /** evaluate the function and its derivative at x. */\r\n  public abstract evaluate(x: number): boolean;\r\n  /** most recent function value */\r\n  public currentF!: number;\r\n  /** most recent evaluated derivative */\r\n  public currentdFdX!: number;\r\n}\r\n/**\r\n * Newton iterator for use when both function and derivative can be evaluated.\r\n * @internal\r\n */\r\nexport class Newton1dUnbounded extends AbstractNewtonIterator {\r\n  private _func: NewtonEvaluatorRtoRD;\r\n  private _currentStep!: number;\r\n  private _currentX!: number;\r\n  private _target!: number;\r\n  /**\r\n   * Constructor for 1D newton iteration with approximate derivatives.\r\n   * @param func function that returns both function and derivative.\r\n   */\r\n  public constructor(func: NewtonEvaluatorRtoRD) {\r\n    super();\r\n    this._func = func;\r\n    this.setTarget(0);\r\n  }\r\n  /** Set the independent variable */\r\n  public setX(x: number): boolean { this._currentX = x; return true; }\r\n  /** Get the independent variable */\r\n  public getX(): number { return this._currentX; }\r\n  /** Set the target function value */\r\n  public setTarget(y: number) { this._target = y; }\r\n  /** move the current X by the just-computed step */\r\n  public applyCurrentStep(): boolean { return this.setX(this._currentX - this._currentStep); }\r\n  /** Compute the univariate newton step. */\r\n  public computeStep(): boolean {\r\n    if (this._func.evaluate(this._currentX)) {\r\n      const dx = Geometry.conditionalDivideFraction(this._func.currentF - this._target, this._func.currentdFdX);\r\n      if (dx !== undefined) {\r\n        this._currentStep = dx;\r\n        return true;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n  /** Return the current step size as a relative number. */\r\n  public currentStepSize(): number {\r\n    return Math.abs(this._currentStep / (1.0 + Math.abs(this._currentX)));\r\n  }\r\n}\r\n\r\n/** object to evaluate a newton function (without derivative).  The object must retain most-recent function value.\r\n * @internal\r\n */\r\nexport abstract class NewtonEvaluatorRtoR {\r\n  /** Evaluate function value into member currentF */\r\n  public abstract evaluate(x: number): boolean;\r\n  /** Most recent function evaluation. */\r\n  public currentF!: number;\r\n}\r\n\r\n/** Newton iteration for a univariate function, using approximate derivatives.\r\n * @internal\r\n */\r\nexport class Newton1dUnboundedApproximateDerivative extends AbstractNewtonIterator {\r\n  private _func: NewtonEvaluatorRtoR;\r\n  private _currentStep!: number;\r\n  private _currentX!: number;\r\n  /** Step size for iteration.\r\n   * * Initialized to 1e-8, which is appropriate for iteration in fraction space.\r\n   * * Should be larger for iteration with real distance as x.\r\n   */\r\n  public derivativeH: number; // step size for approximate derivative\r\n\r\n  /**\r\n   * Constructor for 1D newton iteration with approximate derivatives.\r\n   * @param func function that returns both function and derivative.\r\n   */\r\n  public constructor(func: NewtonEvaluatorRtoR) {\r\n    super();\r\n    this._func = func;\r\n    this.derivativeH = 1.0e-8;\r\n  }\r\n  /** Set the x (independent, iterated) value */\r\n  public setX(x: number): boolean { this._currentX = x; return true; }\r\n  /** Get the independent variable */\r\n  public getX(): number { return this._currentX; }\r\n  /** move the current X by the just-computed step */\r\n  public applyCurrentStep(): boolean { return this.setX(this._currentX - this._currentStep); }\r\n  /** Univariate newton step computed with APPROXIMATE derivative. */\r\n  public computeStep(): boolean {\r\n    if (this._func.evaluate(this._currentX)) {\r\n      const fA = this._func.currentF;\r\n      if (this._func.evaluate(this._currentX + this.derivativeH)) {\r\n        const fB = this._func.currentF;\r\n        const dx = Geometry.conditionalDivideFraction(fA, (fB - fA) / this.derivativeH);\r\n        if (dx !== undefined) {\r\n          this._currentStep = dx;\r\n          return true;\r\n        }\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /** Return the current step size as a relative number. */\r\n  public currentStepSize(): number {\r\n    return Math.abs(this._currentStep / (1.0 + Math.abs(this._currentX)));\r\n  }\r\n}\r\n\r\n/** object to evaluate a 2-parameter newton function (with derivatives!!).\r\n * @internal\r\n */\r\nexport abstract class NewtonEvaluatorRRtoRRD {\r\n  /** Iteration controller calls this to ask for evaluation of the function and its two partial derivatives.\r\n   * * The implementation returns true, it must set the currentF object.\r\n   */\r\n  public abstract evaluate(x: number, y: number): boolean;\r\n  /** most recent function evaluation as xy parts of the plane */\r\n  public currentF!: Plane3dByOriginAndVectors;\r\n  /**\r\n   * constructor.\r\n   * * This creates a currentF object to (repeatedly) receive function and derivatives.\r\n   */\r\n  public constructor() {\r\n    this.currentF = Plane3dByOriginAndVectors.createXYPlane();\r\n  }\r\n}\r\n\r\n/**\r\n * Implement evaluation steps for newton iteration in 2 dimensions, using caller supplied NewtonEvaluatorRRtoRRD object.\r\n * @internal\r\n */\r\nexport class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {\r\n  private _func: NewtonEvaluatorRRtoRRD;\r\n  private _currentStep: Vector2d;\r\n  private _currentUV: Point2d;\r\n\r\n  public constructor(func: NewtonEvaluatorRRtoRRD) {\r\n    super();\r\n    this._func = func;\r\n    this._currentStep = Vector2d.createZero();\r\n    this._currentUV = Point2d.createZero();\r\n  }\r\n  /** Set the current uv coordinates for current iteration */\r\n  public setUV(x: number, y: number): boolean { this._currentUV.set(x, y); return true; }\r\n  /** Get the current u coordinate */\r\n  public getU(): number { return this._currentUV.x; }\r\n  /** Get the current v coordinate */\r\n  public getV(): number { return this._currentUV.y; }\r\n  /** Move the currentUV coordinate by currentStep. */\r\n  public applyCurrentStep(): boolean { return this.setUV(this._currentUV.x - this._currentStep.x, this._currentUV.y - this._currentStep.y); }\r\n  /** Evaluate the functions and derivatives at this._currentUV\r\n   * Invert the jacobian and compute the this._currentStep.\r\n   */\r\n  public computeStep(): boolean {\r\n    if (this._func.evaluate(this._currentUV.x, this._currentUV.y)) {\r\n      const fA = this._func.currentF;\r\n      if (SmallSystem.linearSystem2d(\r\n        fA.vectorU.x, fA.vectorV.x,\r\n        fA.vectorU.y, fA.vectorV.y,\r\n        fA.origin.x, fA.origin.y, this._currentStep))\r\n        return true;\r\n    }\r\n    return false;\r\n  }\r\n  /**\r\n   * Return the largest relative step of the x,y, components of the current step.\r\n   */\r\n  public currentStepSize(): number {\r\n    return Geometry.maxAbsXY(\r\n      this._currentStep.x / (1.0 + Math.abs(this._currentUV.x)),\r\n      this._currentStep.y / (1.0 + Math.abs(this._currentUV.y)));\r\n  }\r\n}\r\n/**\r\n * SimpleNewton has static methods for newton methods with evaluated functions presented as immediate arguments (not function object)\r\n * @internal\r\n */\r\nexport class SimpleNewton {\r\n  /** Run a one-dimensional newton iteration with separate functions for function and derivative.\r\n   * * completion is at 2 (TWO) successive passes at (absoluteTolerance + relTol * abs (x)), where relTol is chosen internally.\r\n   * * absoluteTolerance is usually aggressively tight -- should come into play only for x near zero.\r\n   * * The relTol is fluffy (for instance around 1e-11) but in properly converging cases the extra pass after first success\r\n   *    normally moves to full machine precision.\r\n   * * This is an open-loop newton -- it just runs, and returns undefined if anything bad happens.\r\n   */\r\n  public static runNewton1D(\r\n    x: number,\r\n    func: (x: number) => number | undefined,\r\n    derivative: (x: number) => number | undefined,\r\n    absoluteTolerance: number = Geometry.smallFloatingPoint,\r\n  ): number | undefined {\r\n    let numConverged = 0;\r\n    let tolerance: number;\r\n    const relTol = 1.0e-11;\r\n    for (let iteration = 0; iteration < 20; iteration++) {\r\n      const f = func(x);\r\n      const df = derivative(x);\r\n      if (f !== undefined && df !== undefined) {\r\n        const dx = Geometry.conditionalDivideCoordinate(f, df);\r\n        if (dx === undefined)\r\n          return undefined;\r\n        x -= dx;\r\n        tolerance = absoluteTolerance + Math.abs(x) * relTol;\r\n        if (Math.abs(dx) < tolerance) {\r\n          numConverged++;\r\n          if (dx === 0.0 || numConverged > 1)   // bypass convergence count on true 0 dx !\r\n            return x;\r\n        } else {\r\n          numConverged = 0;\r\n        }\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"Newton.js","sourceRoot":"","sources":["../../../src/numerics/Newton.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n\r\n/** @packageDocumentation\r\n * @module Numerics\r\n */\r\n\r\nimport { Geometry } from \"../Geometry\";\r\nimport { CurvePrimitive } from \"../curve/CurvePrimitive\";\r\nimport { Plane3dByOriginAndVectors } from \"../geometry3d/Plane3dByOriginAndVectors\";\r\nimport { Point2d, Vector2d } from \"../geometry3d/Point2dVector2d\";\r\nimport { Point3d } from \"../geometry3d/Point3dVector3d\";\r\nimport { Ray3d } from \"../geometry3d/Ray3d\";\r\nimport { SmallSystem } from \"./Polynomials\";\r\n\r\n// cspell:word currentdFdX XYRR\r\n\r\n/**\r\n * Base class for Newton iterations in various dimensions.\r\n * Dimension-specific classes carry all dimension-related data and answer generalized queries from this base class.\r\n * @internal\r\n */\r\nexport abstract class AbstractNewtonIterator {\r\n  /** Compute a step. The current x and function values must be retained for use in later method calls. */\r\n  public abstract computeStep(): boolean;\r\n  /**\r\n   * Return the current step size, scaled for use in tolerance tests.\r\n   * * This is a single number, typically the max of various per-dimension `dx/(1+x)` for the x and dx of that dimension.\r\n   */\r\n  public abstract currentStepSize(): number;\r\n  /**\r\n   * Apply the current step (in all dimensions).\r\n   * @param isFinalStep true if this is a final step.\r\n   */\r\n  public abstract applyCurrentStep(isFinalStep: boolean): boolean;\r\n  /**\r\n   * The constructor.\r\n   * @param stepSizeTarget tolerance to consider a single step converged.\r\n   * This number should be \"moderately\" strict. Because 2 successive convergences are required,\r\n   * it is expected that a first \"accept\" for (say) 10 to 14 digit step will be followed by another\r\n   * iteration. A well behaved newton would then hypothetically double the number of digits to\r\n   * 20 to 28. Since the IEEE double only carries 16 digits, this second-convergence step will\r\n   * typically achieve full precision.\r\n   * @param successiveConvergenceTarget number of successive convergences required for acceptance.\r\n   * @param maxIterations max number of iterations. A typical newton step converges in 3 to 6 iterations.\r\n   * Allow 15 to 20 to catch difficult cases.\r\n   */\r\n  protected constructor(\r\n    stepSizeTolerance: number = 1.0e-11,\r\n    successiveConvergenceTarget: number = 2,\r\n    maxIterations: number = 15,\r\n  ) {\r\n    this._stepSizeTolerance = stepSizeTolerance;\r\n    this._successiveConvergenceTarget = successiveConvergenceTarget;\r\n    this._maxIterations = maxIterations;\r\n  }\r\n  /** Number of consecutive steps which passed convergence condition. */\r\n  protected _numAccepted: number = 0;\r\n  /** Target number of successive convergences. */\r\n  protected _successiveConvergenceTarget: number;\r\n  /** Convergence target (the implementation-specific currentStepSize is compared to this). */\r\n  protected _stepSizeTolerance: number;\r\n  /** Max iterations allowed. */\r\n  protected _maxIterations: number;\r\n  /** Number of iterations (incremented at each step). */\r\n  public numIterations: number = 0;\r\n  /**\r\n   * Test if a step is converged.\r\n   * * Convergence is accepted with enough (_successiveConvergenceTarget) small steps (according to _stepSizeTolerance)\r\n   * occur in succession.\r\n   * @param delta step size as reported by currentStepSize.\r\n   */\r\n  public testConvergence(delta: number): boolean {\r\n    if (Math.abs(delta) < this._stepSizeTolerance) {\r\n      this._numAccepted++;\r\n      return this._numAccepted >= this._successiveConvergenceTarget;\r\n    }\r\n    this._numAccepted = 0;\r\n    return false;\r\n  }\r\n  /**\r\n   * Run iterations, calling various methods from base and derived classes:\r\n   * * computeStep -- typically evaluate derivatives and solve linear system.\r\n   * * currentStepSize -- return numeric measure of the step just computed by computeStep.\r\n   * * testConvergence -- test if the step from currentStepSize (along with recent steps) is converged.\r\n   * * applyCurrentStep -- apply the step to the independent variables.\r\n   */\r\n  public runIterations(): boolean {\r\n    this._numAccepted = 0;\r\n    this.numIterations = 0;\r\n    while (this.numIterations++ < this._maxIterations && this.computeStep()) {\r\n      if (this.testConvergence(this.currentStepSize()) && this.applyCurrentStep(true)) {\r\n        // console.log(\"iter: \" + this.numIterations); // print number of Newton iterations for debug\r\n        return true;\r\n      }\r\n      this.applyCurrentStep(false);\r\n    }\r\n    return false;\r\n  }\r\n}\r\n/**\r\n * Object to evaluate a newton function. The object must retain most-recent function and derivative\r\n * values for immediate query.\r\n * @internal\r\n */\r\nexport abstract class NewtonEvaluatorRtoRD {\r\n  /** Evaluate the function and its derivative at x. */\r\n  public abstract evaluate(x: number): boolean;\r\n  /** Most recent function value, i.e., f(x_n). */\r\n  public currentF!: number;\r\n  /** Most recent evaluated derivative, i.e., f'(x_n). */\r\n  public currentdFdX!: number;\r\n}\r\n/**\r\n * Newton iterator for use when both function and derivative can be evaluated.\r\n * To solve `f(x) = 0`, the Newton iteration is `x_{n+1} = x_n - dx = x_n - f(x_n)/f'(x_n)`.\r\n * To solve `f(x) = target` which is equivalent to solving  `g(x) = f(x) - target = 0`, the Newton iteration is\r\n * `x_{n+1} = x_n - dx = x_n - g(x_n)/g'(x_n) = x_n - (f(x_n)-target)/f'(x_n)`.\r\n * @internal\r\n */\r\nexport class Newton1dUnbounded extends AbstractNewtonIterator {\r\n  private _func: NewtonEvaluatorRtoRD;\r\n  /** Current step is dx. */\r\n  private _currentStep!: number;\r\n  /** Current X is x_n. */\r\n  private _currentX!: number;\r\n  /** The target */\r\n  private _target!: number;\r\n  /**\r\n   * Constructor for 1D newton iteration with derivatives.\r\n   * @param func function that returns both function value and derivative.\r\n   */\r\n  public constructor(func: NewtonEvaluatorRtoRD) {\r\n    super();\r\n    this._func = func;\r\n    this.setTarget(0);\r\n  }\r\n  /** Set the independent variable, i.e., x_n. */\r\n  public setX(x: number): boolean {\r\n    this._currentX = x;\r\n    return true;\r\n  }\r\n  /** Get the independent variable, i.e., x_n. */\r\n  public getX(): number {\r\n    return this._currentX;\r\n  }\r\n  /** Set the target function value. */\r\n  public setTarget(y: number): void {\r\n    this._target = y;\r\n  }\r\n  /** Move the current X by the just-computed step, i.e., `x_n - dx`. */\r\n  public applyCurrentStep(): boolean {\r\n    // console.log(this._currentX - this._currentStep); // print approximations for debug\r\n    return this.setX(this._currentX - this._currentStep);\r\n  }\r\n  /** Compute the univariate newton step dx. */\r\n  public computeStep(): boolean {\r\n    if (this._func.evaluate(this._currentX)) {\r\n      const dx = Geometry.conditionalDivideFraction(this._func.currentF - this._target, this._func.currentdFdX);\r\n      if (dx !== undefined) {\r\n        this._currentStep = dx;\r\n        return true;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n  /** Return the current step size as a relative number, i.e., `|dx / (1 + |x_n|)|`. */\r\n  public currentStepSize(): number {\r\n    return Math.abs(this._currentStep / (1.0 + Math.abs(this._currentX)));\r\n  }\r\n}\r\n\r\n/**\r\n * Object to evaluate a newton function (without derivative). The object must retain most-recent function value.\r\n * @internal\r\n */\r\nexport abstract class NewtonEvaluatorRtoR {\r\n  /** Evaluate function value into member currentF */\r\n  public abstract evaluate(x: number): boolean;\r\n  /** Most recent function evaluation, i.e., f(x_n). */\r\n  public currentF!: number;\r\n}\r\n\r\n/**\r\n * Newton iteration for a univariate function, using approximate derivatives.\r\n * To approximate the derivatives we use a small step `h`, i.e., `f'(x_n) = (f(x_n + h) - f(x_n)) / h`.\r\n * Therefore, to solve `f(x) = 0`, the iteration is\r\n * `x_{n+1} = x_n - dx = x_n - f(x_n)/f'(x_n) = x_n - f(x_n) * h / (f(x_n + h) - f(x_n))`.\r\n * @internal\r\n */\r\nexport class Newton1dUnboundedApproximateDerivative extends AbstractNewtonIterator {\r\n  private _func: NewtonEvaluatorRtoR;\r\n  /** Current step is dx. */\r\n  private _currentStep!: number;\r\n  /** Current X is x_n. */\r\n  private _currentX!: number;\r\n  /**\r\n   * Step size for approximate derivative for the iteration.\r\n   * * Initialized to 1e-8, which is appropriate for iteration in fraction space.\r\n   * * Should be larger for iteration with real distance as x.\r\n   */\r\n  public derivativeH: number; // h\r\n\r\n  /**\r\n   * Constructor for 1D newton iteration with approximate derivatives.\r\n   * @param func function that only returns function value (and not derivative).\r\n   */\r\n  public constructor(func: NewtonEvaluatorRtoR) {\r\n    super();\r\n    this._func = func;\r\n    this.derivativeH = 1.0e-8;\r\n  }\r\n  /** Set the independent variable, i.e., x_n. */\r\n  public setX(x: number): boolean {\r\n    this._currentX = x;\r\n    return true;\r\n  }\r\n  /** Get the independent variable, i.e., x_n. */\r\n  public getX(): number {\r\n    return this._currentX;\r\n  }\r\n  /** Move the current X by the just-computed step, i.e., `x_n - dx`. */\r\n  public applyCurrentStep(): boolean {\r\n    // console.log(this._currentX - this._currentStep); // print approximations for debug\r\n    return this.setX(this._currentX - this._currentStep);\r\n  }\r\n  /** Univariate newton step dx, computed with approximate derivative. */\r\n  public computeStep(): boolean {\r\n    if (this._func.evaluate(this._currentX)) {\r\n      const fA = this._func.currentF; // f(x_n)\r\n      if (this._func.evaluate(this._currentX + this.derivativeH)) {\r\n        const fB = this._func.currentF; // f(x_n + h)\r\n        const dx = Geometry.conditionalDivideFraction(fA, (fB - fA) / this.derivativeH);\r\n        if (dx !== undefined) {\r\n          this._currentStep = dx;\r\n          return true;\r\n        }\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n  /** Return the current step size as a relative number, i.e., `|dx / (1 + |x_n|)|`. */\r\n  public currentStepSize(): number {\r\n    return Math.abs(this._currentStep / (1.0 + Math.abs(this._currentX)));\r\n  }\r\n}\r\n\r\n/**\r\n * Object to evaluate a 2-parameter newton function with derivatives.\r\n * @internal\r\n */\r\nexport abstract class NewtonEvaluatorRRtoRRD {\r\n  /**\r\n   * Iteration controller calls this to ask for evaluation of the function and its two partial derivatives.\r\n   * * The implementation returns true, it must set the currentF object.\r\n   */\r\n  public abstract evaluate(x: number, y: number): boolean;\r\n  /**\r\n   * Most recent function evaluation as parts of the plane.\r\n   * * See doc of [[Newton2dUnboundedWithDerivative]] class for info on 2d newton method.\r\n   * * For `F(u,v) := (x(u,v), y(u,v))` the returned plane stores the following evaluations at current value `X := (u,v)`:\r\n   * * `origin` = F(X) = (x(X), y(X))\r\n   * * `vectorU` = F_u(X) = partial deriv of F wrt u at X = (x_u(X), y_u(X)) = 1st col of Jacobian matrix evaluated at X\r\n   * * `vectorV` = F_v(X) = partial deriv of F wrt v at X = (x_v(X), y_v(X)) = 2nd col of Jacobian matrix evaluated at X\r\n   */\r\n  public currentF!: Plane3dByOriginAndVectors;\r\n  /**\r\n   * Constructor.\r\n   * * This creates a currentF object to (repeatedly) receive function and derivatives.\r\n   */\r\n  public constructor() {\r\n    this.currentF = Plane3dByOriginAndVectors.createXYPlane();\r\n  }\r\n}\r\n\r\n/**\r\n * Implement evaluation steps for newton iteration in 2 dimensions, using caller supplied NewtonEvaluatorRRtoRRD object.\r\n * * Suppose we want to find the roots of `F(u,v) := (x(u,v), y(u,v))`. Writing `X := (u,v)` and `F(X)` as column vectors,\r\n *  the 2D Newton's iteration to find a root of `F` is given by:\r\n * `X_{n+1} = X_n - dX = X_n - JInv(X_n)F(X_n)`, where `JInv` is the inverse of the Jacobian matrix `J`, and `J` is\r\n * defined by the partial derivatives of the component functions of F:\r\n *\r\n * `[dx/du   dx/dv]`\r\n *\r\n * `[dy/du   dy/dv]`\r\n * @internal\r\n */\r\nexport class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {\r\n  private _func: NewtonEvaluatorRRtoRRD;\r\n  /** Current step, or dX = (du, dv). */\r\n  private _currentStep: Vector2d;\r\n  /** Current uv parameters, or X_n = (u_n, v_n). */\r\n  private _currentUV: Point2d;\r\n  /**\r\n   * Constructor for 2D newton iteration with derivatives.\r\n   * @param func function that returns both function value and derivative.\r\n   */\r\n  public constructor(func: NewtonEvaluatorRRtoRRD) {\r\n    const maxIterations = 100;  // Was default (15). We observed 49 iters to achieve 1e-11 tol with tangent geometry.\r\n    super(undefined, undefined, maxIterations);\r\n    this._func = func;\r\n    this._currentStep = Vector2d.createZero();\r\n    this._currentUV = Point2d.createZero();\r\n  }\r\n  /** Set the current uv parameters, i.e., `X_n = (u_n, v_n)`. */\r\n  public setUV(u: number, v: number): boolean {\r\n    this._currentUV.set(u, v);\r\n    return true;\r\n  }\r\n  /** Get the current u parameter of X_n, i.e., u_n. */\r\n  public getU(): number {\r\n    return this._currentUV.x;\r\n  }\r\n  /** Get the current v parameter of X_n, i.e., v_n. */\r\n  public getV(): number {\r\n    return this._currentUV.y;\r\n  }\r\n  /** Update the current uv parameter by currentStep, i.e., compute `X_{n+1} := X_n - dX = (u_n - du, v_n - dv)`. */\r\n  public applyCurrentStep(): boolean {\r\n    // print approximations for debug\r\n    // console.log(\"(\" + (this._currentUV.x - this._currentStep.x) + \",\" + (this._currentUV.y - this._currentStep.y) + \")\");\r\n    return this.setUV(this._currentUV.x - this._currentStep.x, this._currentUV.y - this._currentStep.y);\r\n  }\r\n  /**\r\n   * Evaluate the functions and derivatives at `X_n = (u_n, v_n)`, and solve the Jacobian matrix equation to\r\n   * compute `dX = (du, dv)`.\r\n   */\r\n  public computeStep(): boolean {\r\n    if (this._func.evaluate(this._currentUV.x, this._currentUV.y)) {\r\n      const fA = this._func.currentF;\r\n      if (  // Given X_{n+1} = X_n - dX = X_n - JInv(X_n) F(X_n), we solve J(X_n) dX = F(X_n) for dX:\r\n        SmallSystem.linearSystem2d(\r\n          fA.vectorU.x, fA.vectorV.x, // x_u(X_n), x_v(X_n): 1st row of J evaluated at X_n\r\n          fA.vectorU.y, fA.vectorV.y, // y_u(X_n), y_v(X_n): 2nd row of J evaluated at X_n\r\n          fA.origin.x, fA.origin.y,   // F(X_n) := (x(X_n), y(X_n))\r\n          this._currentStep,          // dX\r\n        )\r\n      )\r\n        return true;\r\n    }\r\n    return false;\r\n  }\r\n  /**\r\n   * Return the current relative step size, i.e., the larger absolute component of `dX / (1 + |X_n|)`\r\n   */\r\n  public currentStepSize(): number {\r\n    return Geometry.maxAbsXY(\r\n      this._currentStep.x / (1.0 + Math.abs(this._currentUV.x)),\r\n      this._currentStep.y / (1.0 + Math.abs(this._currentUV.y)),\r\n    );\r\n  }\r\n}\r\n/**\r\n * SimpleNewton has static methods for newton methods with evaluated functions presented as immediate arguments\r\n * (not function object).\r\n * @internal\r\n */\r\nexport class SimpleNewton {\r\n  /**\r\n   * Run a one-dimensional newton iteration with separate functions for function and derivative.\r\n   * * Completion is at 2 (TWO) successive passes at `absoluteTolerance + relTol * abs(x)`, where relTol is\r\n   * chosen internally.\r\n   * * `absoluteTolerance` is usually aggressively tight -- should come into play only for x near zero.\r\n   * * The `relTol` is fluffy (for instance around 1e-11) but in properly converging cases the extra pass after\r\n   * first success normally moves to full machine precision.\r\n   * * This is an open-loop newton -- it just runs, and returns undefined if anything bad happens.\r\n   */\r\n  public static runNewton1D(\r\n    x: number,\r\n    func: (x: number) => number | undefined,\r\n    derivative: (x: number) => number | undefined,\r\n    absoluteTolerance: number = Geometry.smallFloatingPoint,\r\n  ): number | undefined {\r\n    let numConverged = 0;\r\n    let tolerance: number;\r\n    const relTol = 1.0e-11;\r\n    for (let iteration = 0; iteration < 20; iteration++) {\r\n      const f = func(x);\r\n      const df = derivative(x);\r\n      if (f !== undefined && df !== undefined) {\r\n        const dx = Geometry.conditionalDivideCoordinate(f, df);\r\n        if (dx === undefined)\r\n          return undefined;\r\n        x -= dx;\r\n        // console.log(x); // print approximations for debug\r\n        tolerance = absoluteTolerance + Math.abs(x) * relTol;\r\n        if (Math.abs(dx) < tolerance) {\r\n          numConverged++;\r\n          if (dx === 0.0 || numConverged > 1)   // bypass convergence count on true 0 dx\r\n            return x;\r\n        } else {\r\n          numConverged = 0;\r\n        }\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n}\r\n\r\n/**\r\n * Class to evaluate XY intersection between 2 curve primitives using the Newton method.\r\n * @internal\r\n */\r\nexport class CurveCurveIntersectionXYRRToRRD extends NewtonEvaluatorRRtoRRD {\r\n  private _curveP: CurvePrimitive;\r\n  private _curveQ: CurvePrimitive;\r\n  private _rayP: Ray3d;\r\n  private _rayQ: Ray3d;\r\n  constructor(curveP: CurvePrimitive, curveQ: CurvePrimitive) {\r\n    super();\r\n    this._curveP = curveP;\r\n    this._curveQ = curveQ;\r\n    this._rayP = Ray3d.createZero();\r\n    this._rayQ = Ray3d.createZero();\r\n  }\r\n  public evaluate(fractionU: number, fractionV: number): boolean {\r\n    /**\r\n     * To find an intersection between xy-curves P(u) = (x_p(u), y_p(u)) and Q(v) = (x_q(v), y_q(v)) we should solve\r\n     *   F(u,v) := P(u) - Q(v) = (0,0)\r\n     * Using the Newton method we can find the fractions u and v at the intersection via\r\n     *   [u_{n+1}]     [u_n]          [x_p'(u_n)  -x_q'(v_n)]    [x_p(u_n) - x_q(v_n)]\r\n     *              =         -  Inv(                         )\r\n     *   [v_{n+1}]     [v_n]          [y_p'(u_n)  -y_q'(v_n)]    [y_p(u_n) - y_q(v_n)]\r\n     * Note that this is xy intersection so we can ignore z.\r\n     */\r\n    this._curveP.fractionToPointAndDerivative(fractionU, this._rayP);\r\n    this._curveQ.fractionToPointAndDerivative(fractionV, this._rayQ);\r\n    this.currentF.setOriginAndVectorsXYZ(\r\n      this._rayP.origin.x - this._rayQ.origin.x, this._rayP.origin.y - this._rayQ.origin.y, 0.0,\r\n      this._rayP.direction.x, this._rayP.direction.y, 0.0,\r\n      -this._rayQ.direction.x, -this._rayQ.direction.y, 0.0,\r\n    );\r\n    return true;\r\n  }\r\n}\r\n\r\n/**\r\n * Class to evaluate XY close approach between a curve primitive and a point using the Newton method.\r\n * @internal\r\n */\r\nexport class CurvePointCloseApproachXYRtoRD extends NewtonEvaluatorRtoRD {\r\n  private _curveP: CurvePrimitive;\r\n  private _pointQ: Point3d;\r\n  private _planeP: Plane3dByOriginAndVectors;\r\n  constructor(curveP: CurvePrimitive, pointQ: Point3d) {\r\n    super();\r\n    this._curveP = curveP;\r\n    this._pointQ = pointQ;\r\n    this._planeP = Plane3dByOriginAndVectors.createXYPlane();\r\n  }\r\n  public evaluate(fractionU: number): boolean {\r\n    /**\r\n     * To find a close approach between xy-curve P(u) and xy-point q we should solve\r\n     *    F(u) := P'(u).(P(u) - q) = 0\r\n     * For a solution u, the segment S(u) := P(u) - q is perpendicular to the curve tangent P'(u), which means S(u) is a close approach.\r\n     * Using the Newton method we can find the fractions u at the close approach location via\r\n     *    u_{n+1} = u_n + F(u_n)/F'(u_n) = u_n + [ P'(u_n).S(u_n) ]/[ P''(u_n).S(u_n) + P'(u_n).P'(u_n) ]\r\n     * Note that this is xy close approach so we can ignore z.\r\n     */\r\n    this._curveP.fractionToPointAnd2Derivatives(fractionU, this._planeP);\r\n    const segX = this._planeP.origin.x - this._pointQ.x;\r\n    const segY = this._planeP.origin.y - this._pointQ.y;\r\n    const pDerivX = this._planeP.vectorU.x;\r\n    const pDerivY = this._planeP.vectorU.y;\r\n    const p2DerivX = this._planeP.vectorV.x;\r\n    const p2DerivY = this._planeP.vectorV.y;\r\n    this.currentF = pDerivX * segX + pDerivY * segY;\r\n    this.currentdFdX = p2DerivX * segX + pDerivX * pDerivX + p2DerivY * segY + pDerivY * pDerivY;\r\n    return true;\r\n  }\r\n}\r\n\r\n/**\r\n * Class to evaluate XY close approach between 2 curve primitives using the Newton method.\r\n * @internal\r\n */\r\nexport class CurveCurveCloseApproachXYRRtoRRD extends NewtonEvaluatorRRtoRRD {\r\n  private _curveP: CurvePrimitive;\r\n  private _curveQ: CurvePrimitive;\r\n  private _planeP: Plane3dByOriginAndVectors;\r\n  private _planeQ: Plane3dByOriginAndVectors;\r\n  constructor(curveP: CurvePrimitive, curveQ: CurvePrimitive) {\r\n    super();\r\n    this._curveP = curveP;\r\n    this._curveQ = curveQ;\r\n    this._planeP = Plane3dByOriginAndVectors.createXYPlane();\r\n    this._planeQ = Plane3dByOriginAndVectors.createXYPlane();\r\n  }\r\n  public evaluate(fractionU: number, fractionV: number): boolean {\r\n    /**\r\n     * To find a close approach between xy-curves P(u) and Q(v) we should solve\r\n     *    F(u,v) := (P'(u).(P(u) - Q(v)), Q'(v).(P(u) - Q(v))) = (0,0)\r\n     * For a solution (u,v), the segment S(u,v) := P(u) - Q(v) is perpendicular to the curve tangents P'(u) and Q'(v),\r\n     * which means S(u,v) is a close approach.\r\n     * Using the Newton method we can find the fractions u and v at the close approach location via\r\n     *   [u_{n+1}]     [u_n]          [P''(u_n).S(u_n,v_n) + P'(u_n).P'(u_n)    -P'(u_n).Q'(v_n)]    [P'(u_n).S(u_n,v_n)]\r\n     *              =         -  Inv(                                                            )\r\n     *   [v_{n+1}]     [v_n]          [Q'(v_n).P'(u_n)     Q''(v_n).S(u_n,v_n) - Q'(v_n).Q'(v_n)]    [Q'(v_n).S(u_n,v_n)]\r\n     * Note that this is xy close approach so we can ignore z.\r\n     */\r\n    this._curveP.fractionToPointAnd2Derivatives(fractionU, this._planeP);\r\n    this._curveQ.fractionToPointAnd2Derivatives(fractionV, this._planeQ);\r\n    const segX = this._planeP.origin.x - this._planeQ.origin.x;\r\n    const segY = this._planeP.origin.y - this._planeQ.origin.y;\r\n    const pDerivX = this._planeP.vectorU.x;\r\n    const pDerivY = this._planeP.vectorU.y;\r\n    const qDerivX = this._planeQ.vectorU.x;\r\n    const qDerivY = this._planeQ.vectorU.y;\r\n    const p2DerivX = this._planeP.vectorV.x;\r\n    const p2DerivY = this._planeP.vectorV.y;\r\n    const q2DerivX = this._planeQ.vectorV.x;\r\n    const q2DerivY = this._planeQ.vectorV.y;\r\n    this.currentF.setOriginAndVectorsXYZ(\r\n      pDerivX * segX + pDerivY * segY,\r\n      qDerivX * segX + qDerivY * segY,\r\n      0.0,\r\n      p2DerivX * segX + p2DerivY * segY + pDerivX * pDerivX + pDerivY * pDerivY,\r\n      qDerivX * pDerivX + qDerivY * pDerivY,\r\n      0.0,\r\n      -(pDerivX * qDerivX + pDerivY * qDerivY),\r\n      q2DerivX * segX + q2DerivY * segY - qDerivX * qDerivX - qDerivY * qDerivY,\r\n      0.0,\r\n    );\r\n    return true;\r\n  }\r\n}\r\n"]}

package/lib/esm/numerics/PascalCoefficients.d.ts

@@ -11,22 +11,18 @@ export declare class PascalCoefficients {
      * * BUT in practice, values 60 create integer entries that are too big for IEEE double.
      */
     static getRow(row: number): Float64Array;
-    /** Return an array with Bezier weighted pascal coefficients
-     * @param row row index in the pascal triangle.  (`row+1` entries)
+    /**
+     * Return an array with Bezier weighted pascal coefficients
+     * @param order output size. The index of the row of the Pascal triangle supplying weights is `order - 1`.
      * @param u parameter value
-     * @param result optional destination array.
-     * @note if the destination array is undefined or too small, a new Float64Array is allocated.
-     * @note if the destination array is larger than needed, its leading `row+1` values are filled,
-     *     and the array is returned.
+     * @param result optional destination array of length `order`. If the destination array is too small, a new Float64Array is allocated.
      */
     static getBezierBasisValues(order: number, u: number, result?: Float64Array): Float64Array;
-    /** Return an array with derivatives of Bezier weighted pascal coefficients
-     * @param row row index in the pascal triangle.  (`row+1` entries)
+    /**
+     * Return an array with derivatives of Bezier weighted pascal coefficients
+     * @param order output size. The index of the row of the Pascal triangle supplying weights is `order - 2`.
      * @param u parameter value
-     * @param result optional destination array.
-     * @note if the destination array is undefined or too small, a new Float64Array is allocated.
-     * @note if the destination array is larger than needed, its leading `row+1` values are filled,
-     *     and the array is returned.
+     * @param result optional destination array of length `order`. If the destination array is too small, a new Float64Array is allocated.
      */
     static getBezierBasisDerivatives(order: number, u: number, result?: Float64Array): Float64Array;
 }

package/lib/esm/numerics/PascalCoefficients.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PascalCoefficients.d.ts","sourceRoot":"","sources":["../../../src/numerics/PascalCoefficients.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAsB;IAC7C;;;;;OAKG;WACW,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY;IA0B/C;;;;;;;OAOG;WACW,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,GAAG,YAAY;IAqBjG;;;;;;;OAOG;WACW,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,GAAG,YAAY;CAYvG"}
+{"version":3,"file":"PascalCoefficients.d.ts","sourceRoot":"","sources":["../../../src/numerics/PascalCoefficients.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAsB;IAC7C;;;;;OAKG;WACW,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY;IA0B/C;;;;;OAKG;WACW,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,GAAG,YAAY;IAqBjG;;;;;OAKG;WACW,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,GAAG,YAAY;CAcvG"}