@itwin/core-geometry 4.9.0-dev.9 → 4.9.0

package/lib/esm/numerics/Newton.js

@@ -91,8 +91,8 @@ export class Newton1dUnbounded extends AbstractNewtonIterator {
      * Constructor for 1D newton iteration with derivatives.
      * @param func function that returns both function value and derivative.
      */
-    constructor(func) {
-        super();
+    constructor(func, maxIterations) {
+        super(undefined, undefined, maxIterations);
         this._func = func;
         this.setTarget(0);
     }
@@ -148,8 +148,8 @@ export class Newton1dUnboundedApproximateDerivative extends AbstractNewtonIterat
      * Constructor for 1D newton iteration with approximate derivatives.
      * @param func function that only returns function value (and not derivative).
      */
-    constructor(func) {
-        super();
+    constructor(func, maxIterations) {
+        super(undefined, undefined, maxIterations);
         this._func = func;
         this.derivativeH = 1.0e-8;
     }
@@ -217,8 +217,7 @@ export class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {
      * Constructor for 2D newton iteration with derivatives.
      * @param func function that returns both function value and derivative.
      */
-    constructor(func) {
-        const maxIterations = 100; // Was default (15). We observed 49 iters to achieve 1e-11 tol with tangent geometry.
+    constructor(func, maxIterations) {
         super(undefined, undefined, maxIterations);
         this._func = func;
         this._currentStep = Vector2d.createZero();
@@ -239,7 +238,6 @@ export class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {
     }
     /** 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);
     }
@@ -248,15 +246,15 @@ export class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {
      * compute `dX = (du, dv)`.
      */
     computeStep() {
-        if (this._func.evaluate(this._currentUV.x, this._currentUV.y)) {
-            const fA = this._func.currentF;
-            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;
-        }
+        if (!this._func.evaluate(this._currentUV.x, this._currentUV.y))
+            return false;
+        const fA = this._func.currentF;
+        const jCol0 = fA.vectorU;
+        const jCol1 = fA.vectorV;
+        const fX = fA.origin;
+        // 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:
+        if (SmallSystem.linearSystem2d(jCol0.x, jCol1.x, jCol0.y, jCol1.y, fX.x, fX.y, this._currentStep))
+            return true;
         return false;
     }
     /**

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 { 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"]}
+{"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, maxIterations?: number) {\r\n    super(undefined, undefined, maxIterations);\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, maxIterations?: number) {\r\n    super(undefined, undefined, maxIterations);\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, maxIterations?: number) {\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    // 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      return false;\r\n    const fA = this._func.currentF;\r\n    const jCol0 = fA.vectorU;\r\n    const jCol1 = fA.vectorV;\r\n    const fX = fA.origin;\r\n    // 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    if (SmallSystem.linearSystem2d(jCol0.x, jCol1.x, jCol0.y, jCol1.y, fX.x, fX.y, this._currentStep))\r\n      return true;\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/Polynomials.d.ts

@@ -454,14 +454,14 @@ export declare class SmallSystem {
      * 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 homogeneous point in space
+     * @param spacePoint point in space
      */
     static lineSegment3dXYClosestPointUnbounded(pointA0: XAndY, pointA1: XAndY, spacePoint: XAndY): number | undefined;
     /**
      * Return the line fraction at which the line is closest to a space point
      * @param pointA0 start point
      * @param pointA1 end point
-     * @param spacePoint homogeneous point in space
+     * @param spacePoint point in space
      */
     static lineSegment3dClosestPointUnbounded(pointA0: Point3d, pointA1: Point3d, spacePoint: Point3d): number | undefined;
     /**

package/lib/esm/numerics/Polynomials.js

@@ -1377,7 +1377,7 @@ export class SmallSystem {
      * 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 homogeneous point in space
+     * @param spacePoint point in space
      */
     static lineSegment3dXYClosestPointUnbounded(pointA0, pointA1, spacePoint) {
         // Considering only x,y parts....
@@ -1393,7 +1393,7 @@ export class SmallSystem {
      * Return the line fraction at which the line is closest to a space point
      * @param pointA0 start point
      * @param pointA1 end point
-     * @param spacePoint homogeneous point in space
+     * @param spacePoint point in space
      */
     static lineSegment3dClosestPointUnbounded(pointA0, pointA1, spacePoint) {
         const ux = pointA1.x - pointA0.x;