@itwin/core-geometry 5.9.0-dev.8 → 5.9.0-dev.9

package/lib/esm/numerics/Newton.js

@@ -8,6 +8,12 @@ import { Point2d, Vector2d } from "../geometry3d/Point2dVector2d";
 import { Ray3d } from "../geometry3d/Ray3d";
 import { SmallSystem } from "./SmallSystem";
 // cspell:word currentdFdX XYRR
+// A note on differences between using derivatives vs. approximate derivatives for Newton:
+// * Converged values are the same under both schemes.
+// * With derivatives, Newton convergence is quadratic rather than power 1.62 with approximate derivatives.
+// * With approximate derivatives:
+//   - the extra iterative cost is incidental for low iteration counts, and may even be offset by simpler computation.
+//   - the step choice is not based on serious analysis, so could be problematic.
 /**
  * Base class for Newton iterations in various dimensions.
  * Dimension-specific classes carry all dimension-related data and answer generalized queries from this base class.
@@ -21,12 +27,12 @@ export class AbstractNewtonIterator {
      * 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
-     * typically achieve full precision.
-     * @param successiveConvergenceTarget number of successive convergences required for acceptance.
+     * typically achieve full precision. Default [[Geometry.smallNewtonStep]].
+     * @param successiveConvergenceTarget number of successive convergences required for acceptance. Default 2.
      * @param maxIterations max number of iterations. A typical newton step converges in 3 to 6 iterations.
-     * Allow 15 to 20 to catch difficult cases.
+     * Allow 15 to 20 to catch difficult cases. Default 15.
      */
-    constructor(stepSizeTolerance = 1.0e-11, successiveConvergenceTarget = 2, maxIterations = 15) {
+    constructor(stepSizeTolerance = Geometry.smallNewtonStep, successiveConvergenceTarget = 2, maxIterations = 15) {
         this._stepSizeTolerance = stepSizeTolerance;
         this._successiveConvergenceTarget = successiveConvergenceTarget;
         this._maxIterations = maxIterations;
@@ -41,6 +47,12 @@ export class AbstractNewtonIterator {
     _maxIterations;
     /** Number of iterations (incremented at each step). */
     numIterations = 0;
+    /** Get the relative tolerance for comparing iterations in [[testConvergence]]. */
+    get stepSizeTolerance() {
+        return this._stepSizeTolerance;
+    }
+    /** Smallest iterate size difference in later iterations. */
+    _leastDelta = Number.MAX_VALUE;
     /**
      * Test if a step is converged.
      * * Convergence is accepted with enough (_successiveConvergenceTarget) small steps (according to _stepSizeTolerance)
@@ -48,6 +60,10 @@ export class AbstractNewtonIterator {
      * @param delta step size as reported by currentStepSize.
      */
     testConvergence(delta) {
+        if (this.cacheCandidate && delta < this._leastDelta && this.numIterations > 0.5 * this._maxIterations) {
+            this._leastDelta = delta;
+            this.cacheCandidate();
+        }
         if (Math.abs(delta) < this._stepSizeTolerance) {
             this._numAccepted++;
             return this._numAccepted >= this._successiveConvergenceTarget;
@@ -65,13 +81,16 @@ export class AbstractNewtonIterator {
     runIterations() {
         this._numAccepted = 0;
         this.numIterations = 0;
+        this._leastDelta = Number.MAX_VALUE;
         while (this.numIterations++ < this._maxIterations && this.computeStep()) {
-            if (this.testConvergence(this.currentStepSize()) && this.applyCurrentStep(true)) {
-                // console.log("iter: " + this.numIterations); // print number of Newton iterations for debug
+            if (this.testConvergence(this.currentStepSize())) {
+                this.applyCurrentStep(true);
                 return true;
             }
             this.applyCurrentStep(false);
         }
+        if (this.restoreCandidate && this.numIterations >= this._maxIterations && Math.abs(this.currentStepSize()) > this._leastDelta)
+            this.restoreCandidate(); // we may have ended up in a late cycle; return our best guess
         return false;
     }
 }
@@ -113,7 +132,6 @@ export class Newton1dUnbounded extends AbstractNewtonIterator {
     /** Set the independent variable, i.e., x_n. */
     setX(x) {
         this._currentX = x;
-        return true;
     }
     /** Get the independent variable, i.e., x_n. */
     getX() {
@@ -125,8 +143,7 @@ export class Newton1dUnbounded extends AbstractNewtonIterator {
     }
     /** 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);
+        this.setX(this._currentX - this._currentStep);
     }
     /** Compute the univariate newton step dx. */
     computeStep() {
@@ -152,6 +169,30 @@ export class NewtonEvaluatorRtoR {
     /** Most recent function evaluation, i.e., f(x_n). */
     currentF;
 }
+/**
+ * Intermediate class for managing the parentCurve announcements from an IStrokeHandler.
+ * @internal
+ */
+export class NewtonRtoRStrokeHandler extends NewtonEvaluatorRtoR {
+    _parentCurvePrimitive;
+    constructor() {
+        super();
+        this._parentCurvePrimitive = undefined;
+    }
+    /**
+     * Retain the parentCurvePrimitive.
+     * * Calling this method tells the handler that the parent curve is to be used for detail searches.
+     * * Example: Transition spiral search is based on linestring first, then the exact spiral.
+     * * Example: CurveChainWithDistanceIndex does NOT do this announcement; the constituents act independently.
+     */
+    startParentCurvePrimitive(curve) {
+        this._parentCurvePrimitive = curve;
+    }
+    /** Forget the parentCurvePrimitive */
+    endParentCurvePrimitive(_curve) {
+        this._parentCurvePrimitive = undefined;
+    }
+}
 /**
  * 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`.
@@ -183,7 +224,6 @@ export class Newton1dUnboundedApproximateDerivative extends AbstractNewtonIterat
     /** Set the independent variable, i.e., x_n. */
     setX(x) {
         this._currentX = x;
-        return true;
     }
     /** Get the independent variable, i.e., x_n. */
     getX() {
@@ -191,8 +231,7 @@ export class Newton1dUnboundedApproximateDerivative extends AbstractNewtonIterat
     }
     /** 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);
+        this.setX(this._currentX - this._currentStep);
     }
     /** Univariate newton step dx, computed with approximate derivative. */
     computeStep() {
@@ -257,9 +296,11 @@ export class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {
     /**
      * Constructor for 2D newton iteration with derivatives.
      * @param func function that returns both function value and derivative.
+     * @param maxIterations max number of iterations. Default 15.
+     * @param stepSizeTolerance tolerance to consider a single step converged. Default [[Geometry.smallNewtonStep]].
      */
-    constructor(func, maxIterations) {
-        super(undefined, undefined, maxIterations);
+    constructor(func, maxIterations, stepSizeTolerance) {
+        super(stepSizeTolerance, undefined, maxIterations);
         this._func = func;
         this._currentStep = Vector2d.createZero();
         this._currentUV = Point2d.createZero();
@@ -267,7 +308,6 @@ export class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {
     /** 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() {
@@ -277,14 +317,9 @@ export class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {
     getV() {
         return this._currentUV.y;
     }
-    /** Get the relative tolerance for comparing iterations in [[testConvergence]]. */
-    get stepSizeTolerance() {
-        return this._stepSizeTolerance;
-    }
     /** Update the current uv parameter by currentStep, i.e., compute `X_{n+1} := X_n - dX = (u_n - du, v_n - dv)`. */
     applyCurrentStep() {
-        // 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);
+        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
@@ -308,6 +343,20 @@ export class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {
     currentStepSize() {
         return Geometry.maxAbsXY(this._currentStep.x / (1.0 + Math.abs(this._currentUV.x)), this._currentStep.y / (1.0 + Math.abs(this._currentUV.y)));
     }
+    /** Candidate solution cache. */
+    _cachedUV;
+    /** The current late iterate has the least delta encountered. Remember it. */
+    cacheCandidate() {
+        if (this._cachedUV)
+            this._cachedUV.setFrom(this._currentUV);
+        else
+            this._cachedUV = this._currentUV.clone();
+    }
+    /** Set Newton result to the cached candidate. */
+    restoreCandidate() {
+        if (this._cachedUV)
+            this.setUV(this._cachedUV.x, this._cachedUV.y);
+    }
 }
 /**
  * SimpleNewton has static methods for newton methods with evaluated functions presented as immediate arguments
@@ -327,7 +376,7 @@ export class SimpleNewton {
     static runNewton1D(x, func, derivative, absoluteTolerance = Geometry.smallFloatingPoint) {
         let numConverged = 0;
         let tolerance;
-        const relTol = 1.0e-11;
+        const relTol = Geometry.smallNewtonStep;
         for (let iteration = 0; iteration < 20; iteration++) {
             const f = func(x);
             const df = derivative(x);

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 { CurvePrimitive } from \"../curve/CurvePrimitive\";\r\nimport { Geometry } from \"../Geometry\";\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 \"./SmallSystem\";\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 stepSizeTolerance 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  /** Get the relative tolerance for comparing iterations in [[testConvergence]]. */\r\n  public get stepSizeTolerance(): number {\r\n    return this._stepSizeTolerance;\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\r\n     * 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":"AAAA;;;+FAG+F;AAO/F,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AACpF,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAElE,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,+BAA+B;AAE/B,0FAA0F;AAC1F,sDAAsD;AACtD,2GAA2G;AAC3G,kCAAkC;AAClC,sHAAsH;AACtH,iFAAiF;AAEjF;;;;GAIG;AACH,MAAM,OAAgB,sBAAsB;IAa1C;;;;;;;;;;;OAWG;IACH,YACE,oBAA4B,QAAQ,CAAC,eAAe,EACpD,8BAAsC,CAAC,EACvC,gBAAwB,EAAE;QAE1B,IAAI,CAAC,kBAAkB,GAAG,iBAAiB,CAAC;QAC5C,IAAI,CAAC,4BAA4B,GAAG,2BAA2B,CAAC;QAChE,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC;IACtC,CAAC;IACD,sEAAsE;IAC5D,YAAY,GAAW,CAAC,CAAC;IACnC,gDAAgD;IACtC,4BAA4B,CAAS;IAC/C,4FAA4F;IAClF,kBAAkB,CAAS;IACrC,8BAA8B;IACpB,cAAc,CAAS;IACjC,uDAAuD;IAChD,aAAa,GAAW,CAAC,CAAC;IACjC,kFAAkF;IAClF,IAAW,iBAAiB;QAC1B,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IACD,4DAA4D;IACpD,WAAW,GAAW,MAAM,CAAC,SAAS,CAAC;IAM/C;;;;;OAKG;IACI,eAAe,CAAC,KAAa;QAClC,IAAI,IAAI,CAAC,cAAc,IAAI,KAAK,GAAG,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,aAAa,GAAG,GAAG,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YACtG,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;YACzB,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,CAAC;QACD,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC9C,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,4BAA4B,CAAC;QAChE,CAAC;QACD,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;QACtB,OAAO,KAAK,CAAC;IACf,CAAC;IACD;;;;;;OAMG;IACI,aAAa;QAClB,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;QACtB,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;QACvB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,SAAS,CAAC;QACpC,OAAO,IAAI,CAAC,aAAa,EAAE,GAAG,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;YACxE,IAAI,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC,EAAE,CAAC;gBACjD,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;gBAC5B,OAAO,IAAI,CAAC;YACd,CAAC;YACD,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;QACD,IAAI,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW;YAC3H,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,8DAA8D;QACzF,OAAO,KAAK,CAAC;IACf,CAAC;CACF;AACD;;;;GAIG;AACH,MAAM,OAAgB,oBAAoB;IAGxC,gDAAgD;IACzC,QAAQ,CAAU;IACzB,uDAAuD;IAChD,WAAW,CAAU;CAC7B;AACD;;;;;;GAMG;AACH,MAAM,OAAO,iBAAkB,SAAQ,sBAAsB;IACnD,KAAK,CAAuB;IACpC,0BAA0B;IAClB,YAAY,CAAU;IAC9B,wBAAwB;IAChB,SAAS,CAAU;IAC3B,iBAAiB;IACT,OAAO,CAAU;IACzB;;;OAGG;IACH,YAAmB,IAA0B,EAAE,aAAsB;QACnE,KAAK,CAAC,SAAS,EAAE,SAAS,EAAE,aAAa,CAAC,CAAC;QAC3C,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACpB,CAAC;IACD,+CAA+C;IACxC,IAAI,CAAC,CAAS;QACnB,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;IACrB,CAAC;IACD,+CAA+C;IACxC,IAAI;QACT,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,qCAAqC;IAC9B,SAAS,CAAC,CAAS;QACxB,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;IACnB,CAAC;IACD,sEAAsE;IAC/D,gBAAgB;QACrB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC;IAChD,CAAC;IACD,6CAA6C;IACtC,WAAW;QAChB,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;YACxC,MAAM,EAAE,GAAG,QAAQ,CAAC,yBAAyB,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;YAC1G,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;gBACrB,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;gBACvB,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,qFAAqF;IAC9E,eAAe;QACpB,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACxE,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAgB,mBAAmB;IAGvC,qDAAqD;IAC9C,QAAQ,CAAU;CAC1B;AAED;;;GAGG;AACH,MAAM,OAAgB,uBAAwB,SAAQ,mBAAmB;IAC7D,qBAAqB,CAA6B;IAC5D;QACE,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,qBAAqB,GAAG,SAAS,CAAC;IACzC,CAAC;IACD;;;;;OAKG;IACI,yBAAyB,CAAC,KAAiC;QAChE,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;IACrC,CAAC;IACD,sCAAsC;IAC/B,uBAAuB,CAAC,MAAkC;QAC/D,IAAI,CAAC,qBAAqB,GAAG,SAAS,CAAC;IACzC,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,OAAO,sCAAuC,SAAQ,sBAAsB;IACxE,KAAK,CAAsB;IACnC,0BAA0B;IAClB,YAAY,CAAU;IAC9B,wBAAwB;IAChB,SAAS,CAAU;IAC3B;;;;OAIG;IACI,WAAW,CAAS,CAAC,IAAI;IAEhC;;;OAGG;IACH,YAAmB,IAAyB,EAAE,aAAsB;QAClE,KAAK,CAAC,SAAS,EAAE,SAAS,EAAE,aAAa,CAAC,CAAC;QAC3C,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;IAC5B,CAAC;IACD,+CAA+C;IACxC,IAAI,CAAC,CAAS;QACnB,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;IACrB,CAAC;IACD,+CAA+C;IACxC,IAAI;QACT,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,sEAAsE;IAC/D,gBAAgB;QACrB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC;IAChD,CAAC;IACD,uEAAuE;IAChE,WAAW;QAChB,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;YACxC,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,SAAS;YACzC,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;gBAC3D,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,aAAa;gBAC7C,MAAM,EAAE,GAAG,QAAQ,CAAC,yBAAyB,CAAC,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC;gBAChF,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;oBACrB,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;oBACvB,OAAO,IAAI,CAAC;gBACd,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,qFAAqF;IAC9E,eAAe;QACpB,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACxE,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAgB,sBAAsB;IAM1C;;;;;;;OAOG;IACI,QAAQ,CAA6B;IAC5C;;;OAGG;IACH;QACE,IAAI,CAAC,QAAQ,GAAG,yBAAyB,CAAC,aAAa,EAAE,CAAC;IAC5D,CAAC;CACF;AAED;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,+BAAgC,SAAQ,sBAAsB;IACjE,KAAK,CAAyB;IACtC,sCAAsC;IAC9B,YAAY,CAAW;IAC/B,kDAAkD;IAC1C,UAAU,CAAU;IAC5B;;;;;OAKG;IACH,YAAmB,IAA4B,EAAE,aAAsB,EAAE,iBAA0B;QACjG,KAAK,CAAC,iBAAiB,EAAE,SAAS,EAAE,aAAa,CAAC,CAAC;QACnD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,UAAU,EAAE,CAAC;QAC1C,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IACzC,CAAC;IACD,+DAA+D;IACxD,KAAK,CAAC,CAAS,EAAE,CAAS;QAC/B,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC5B,CAAC;IACD,qDAAqD;IAC9C,IAAI;QACT,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;IAC3B,CAAC;IACD,qDAAqD;IAC9C,IAAI;QACT,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;IAC3B,CAAC;IACD,kHAAkH;IAC3G,gBAAgB;QACrB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAC/F,CAAC;IACD;;;OAGG;IACI,WAAW;QAChB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;YAC5D,OAAO,KAAK,CAAC;QACf,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;QAC/B,MAAM,KAAK,GAAG,EAAE,CAAC,OAAO,CAAC;QACzB,MAAM,KAAK,GAAG,EAAE,CAAC,OAAO,CAAC;QACzB,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC;QACrB,yFAAyF;QACzF,IAAI,WAAW,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC;YAC/F,OAAO,IAAI,CAAC;QACd,OAAO,KAAK,CAAC;IACf,CAAC;IACD;;OAEG;IACI,eAAe;QACpB,OAAO,QAAQ,CAAC,QAAQ,CACtB,IAAI,CAAC,YAAY,CAAC,CAAC,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EACzD,IAAI,CAAC,YAAY,CAAC,CAAC,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAC1D,CAAC;IACJ,CAAC;IACD,gCAAgC;IACxB,SAAS,CAAsB;IACvC,6EAA6E;IAC1D,cAAc;QAC/B,IAAI,IAAI,CAAC,SAAS;YAChB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;;YAExC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;IAC7C,CAAC;IACD,iDAAiD;IAC9B,gBAAgB;QACjC,IAAI,IAAI,CAAC,SAAS;YAChB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACnD,CAAC;CACF;AACD;;;;GAIG;AACH,MAAM,OAAO,YAAY;IACvB;;;;;;;;OAQG;IACI,MAAM,CAAC,WAAW,CACvB,CAAS,EACT,IAAuC,EACvC,UAA6C,EAC7C,oBAA4B,QAAQ,CAAC,kBAAkB;QAEvD,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,IAAI,SAAiB,CAAC;QACtB,MAAM,MAAM,GAAG,QAAQ,CAAC,eAAe,CAAC;QACxC,KAAK,IAAI,SAAS,GAAG,CAAC,EAAE,SAAS,GAAG,EAAE,EAAE,SAAS,EAAE,EAAE,CAAC;YACpD,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YAClB,MAAM,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;YACzB,IAAI,CAAC,KAAK,SAAS,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;gBACxC,MAAM,EAAE,GAAG,QAAQ,CAAC,2BAA2B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBACvD,IAAI,EAAE,KAAK,SAAS;oBAClB,OAAO,SAAS,CAAC;gBACnB,CAAC,IAAI,EAAE,CAAC;gBACR,oDAAoD;gBACpD,SAAS,GAAG,iBAAiB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;gBACrD,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC;oBAC7B,YAAY,EAAE,CAAC;oBACf,IAAI,EAAE,KAAK,GAAG,IAAI,YAAY,GAAG,CAAC,EAAE,wCAAwC;wBAC1E,OAAO,CAAC,CAAC;gBACb,CAAC;qBAAM,CAAC;oBACN,YAAY,GAAG,CAAC,CAAC;gBACnB,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,+BAAgC,SAAQ,sBAAsB;IACjE,OAAO,CAAiB;IACxB,OAAO,CAAiB;IACxB,KAAK,CAAQ;IACb,KAAK,CAAQ;IACrB,YAAY,MAAsB,EAAE,MAAsB;QACxD,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;QAChC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;IAClC,CAAC;IACM,QAAQ,CAAC,SAAiB,EAAE,SAAiB;QAClD;;;;;;;;WAQG;QACH,IAAI,CAAC,OAAO,CAAC,4BAA4B,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QACjE,IAAI,CAAC,OAAO,CAAC,4BAA4B,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QACjE,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAClC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,EACzF,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,EACnD,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CACtD,CAAC;QACF,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,8BAA+B,SAAQ,oBAAoB;IAC9D,OAAO,CAAiB;IACxB,OAAO,CAAU;IACjB,OAAO,CAA4B;IAC3C,YAAY,MAAsB,EAAE,MAAe;QACjD,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,OAAO,GAAG,yBAAyB,CAAC,aAAa,EAAE,CAAC;IAC3D,CAAC;IACM,QAAQ,CAAC,SAAiB;QAC/B;;;;;;;;WAQG;QACH,IAAI,CAAC,OAAO,CAAC,8BAA8B,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACrE,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QACpD,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QACpD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QACvC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QACxC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QACxC,IAAI,CAAC,QAAQ,GAAG,OAAO,GAAG,IAAI,GAAG,OAAO,GAAG,IAAI,CAAC;QAChD,IAAI,CAAC,WAAW,GAAG,QAAQ,GAAG,IAAI,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,IAAI,GAAG,OAAO,GAAG,OAAO,CAAC;QAC7F,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,gCAAiC,SAAQ,sBAAsB;IAClE,OAAO,CAAiB;IACxB,OAAO,CAAiB;IACxB,OAAO,CAA4B;IACnC,OAAO,CAA4B;IAC3C,YAAY,MAAsB,EAAE,MAAsB;QACxD,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,OAAO,GAAG,yBAAyB,CAAC,aAAa,EAAE,CAAC;QACzD,IAAI,CAAC,OAAO,GAAG,yBAAyB,CAAC,aAAa,EAAE,CAAC;IAC3D,CAAC;IACM,QAAQ,CAAC,SAAiB,EAAE,SAAiB;QAClD;;;;;;;;;;WAUG;QACH,IAAI,CAAC,OAAO,CAAC,8BAA8B,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACrE,IAAI,CAAC,OAAO,CAAC,8BAA8B,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACrE,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;QAC3D,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;QAC3D,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QACvC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QACvC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QACvC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QACxC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QACxC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QACxC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QACxC,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAClC,OAAO,GAAG,IAAI,GAAG,OAAO,GAAG,IAAI,EAC/B,OAAO,GAAG,IAAI,GAAG,OAAO,GAAG,IAAI,EAC/B,GAAG,EACH,QAAQ,GAAG,IAAI,GAAG,QAAQ,GAAG,IAAI,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,EACzE,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,EACrC,GAAG,EACH,CAAC,CAAC,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC,EACxC,QAAQ,GAAG,IAAI,GAAG,QAAQ,GAAG,IAAI,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,EACzE,GAAG,CACJ,CAAC;QACF,OAAO,IAAI,CAAC;IACd,CAAC;CACF","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n\n/** @packageDocumentation\n * @module Numerics\n */\n\nimport { CurvePrimitive } from \"../curve/CurvePrimitive\";\nimport { Geometry } from \"../Geometry\";\nimport { Plane3dByOriginAndVectors } from \"../geometry3d/Plane3dByOriginAndVectors\";\nimport { Point2d, Vector2d } from \"../geometry3d/Point2dVector2d\";\nimport { Point3d } from \"../geometry3d/Point3dVector3d\";\nimport { Ray3d } from \"../geometry3d/Ray3d\";\nimport { SmallSystem } from \"./SmallSystem\";\n\n// cspell:word currentdFdX XYRR\n\n// A note on differences between using derivatives vs. approximate derivatives for Newton:\n// * Converged values are the same under both schemes.\n// * With derivatives, Newton convergence is quadratic rather than power 1.62 with approximate derivatives.\n// * With approximate derivatives:\n//   - the extra iterative cost is incidental for low iteration counts, and may even be offset by simpler computation.\n//   - the step choice is not based on serious analysis, so could be problematic.\n\n/**\n * Base class for Newton iterations in various dimensions.\n * Dimension-specific classes carry all dimension-related data and answer generalized queries from this base class.\n * @internal\n */\nexport abstract class AbstractNewtonIterator {\n  /** Compute a step. The current x and function values must be retained for use in later method calls. */\n  public abstract computeStep(): boolean;\n  /**\n   * Return the current step size, scaled for use in tolerance tests.\n   * * This is a single number, typically the max of various per-dimension `dx/(1+x)` for the x and dx of that dimension.\n   */\n  public abstract currentStepSize(): number;\n  /**\n   * Apply the current step (in all dimensions).\n   * @param isFinalStep true if this is a final step.\n   */\n  public abstract applyCurrentStep(isFinalStep: boolean): void;\n  /**\n   * The constructor.\n   * @param stepSizeTolerance tolerance to consider a single step converged.\n   * This number should be \"moderately\" strict. Because 2 successive convergences are required,\n   * it is expected that a first \"accept\" for (say) 10 to 14 digit step will be followed by another\n   * iteration. A well behaved newton would then hypothetically double the number of digits to\n   * 20 to 28. Since the IEEE double only carries 16 digits, this second-convergence step will\n   * typically achieve full precision. Default [[Geometry.smallNewtonStep]].\n   * @param successiveConvergenceTarget number of successive convergences required for acceptance. Default 2.\n   * @param maxIterations max number of iterations. A typical newton step converges in 3 to 6 iterations.\n   * Allow 15 to 20 to catch difficult cases. Default 15.\n   */\n  protected constructor(\n    stepSizeTolerance: number = Geometry.smallNewtonStep,\n    successiveConvergenceTarget: number = 2,\n    maxIterations: number = 15,\n  ) {\n    this._stepSizeTolerance = stepSizeTolerance;\n    this._successiveConvergenceTarget = successiveConvergenceTarget;\n    this._maxIterations = maxIterations;\n  }\n  /** Number of consecutive steps which passed convergence condition. */\n  protected _numAccepted: number = 0;\n  /** Target number of successive convergences. */\n  protected _successiveConvergenceTarget: number;\n  /** Convergence target (the implementation-specific currentStepSize is compared to this). */\n  protected _stepSizeTolerance: number;\n  /** Max iterations allowed. */\n  protected _maxIterations: number;\n  /** Number of iterations (incremented at each step). */\n  public numIterations: number = 0;\n  /** Get the relative tolerance for comparing iterations in [[testConvergence]]. */\n  public get stepSizeTolerance(): number {\n    return this._stepSizeTolerance;\n  }\n  /** Smallest iterate size difference in later iterations. */\n  private _leastDelta: number = Number.MAX_VALUE;\n  /** The current late iterate has the least delta encountered. Remember it. Implement along with [[restoreCandidate]].*/\n  protected cacheCandidate?(): void;\n  /** Set Newton result to the cached candidate. Implement along with [[cacheCandidate]]. */\n  protected restoreCandidate?(): void;\n\n  /**\n   * Test if a step is converged.\n   * * Convergence is accepted with enough (_successiveConvergenceTarget) small steps (according to _stepSizeTolerance)\n   * occur in succession.\n   * @param delta step size as reported by currentStepSize.\n   */\n  public testConvergence(delta: number): boolean {\n    if (this.cacheCandidate && delta < this._leastDelta && this.numIterations > 0.5 * this._maxIterations) {\n      this._leastDelta = delta;\n      this.cacheCandidate();\n    }\n    if (Math.abs(delta) < this._stepSizeTolerance) {\n      this._numAccepted++;\n      return this._numAccepted >= this._successiveConvergenceTarget;\n    }\n    this._numAccepted = 0;\n    return false;\n  }\n  /**\n   * Run iterations, calling various methods from base and derived classes:\n   * * computeStep -- typically evaluate derivatives and solve linear system.\n   * * currentStepSize -- return numeric measure of the step just computed by computeStep.\n   * * testConvergence -- test if the step from currentStepSize (along with recent steps) is converged.\n   * * applyCurrentStep -- apply the step to the independent variables.\n   */\n  public runIterations(): boolean {\n    this._numAccepted = 0;\n    this.numIterations = 0;\n    this._leastDelta = Number.MAX_VALUE;\n    while (this.numIterations++ < this._maxIterations && this.computeStep()) {\n      if (this.testConvergence(this.currentStepSize())) {\n        this.applyCurrentStep(true);\n        return true;\n      }\n      this.applyCurrentStep(false);\n    }\n    if (this.restoreCandidate && this.numIterations >= this._maxIterations && Math.abs(this.currentStepSize()) > this._leastDelta)\n      this.restoreCandidate(); // we may have ended up in a late cycle; return our best guess\n    return false;\n  }\n}\n/**\n * Object to evaluate a newton function. The object must retain most-recent function and derivative\n * values for immediate query.\n * @internal\n */\nexport abstract class NewtonEvaluatorRtoRD {\n  /** Evaluate the function and its derivative at x. */\n  public abstract evaluate(x: number): boolean;\n  /** Most recent function value, i.e., f(x_n). */\n  public currentF!: number;\n  /** Most recent evaluated derivative, i.e., f'(x_n). */\n  public currentdFdX!: number;\n}\n/**\n * Newton iterator for use when both function and derivative can be evaluated.\n * To solve `f(x) = 0`, the Newton iteration is `x_{n+1} = x_n - dx = x_n - f(x_n)/f'(x_n)`.\n * To solve `f(x) = target` which is equivalent to solving `g(x) = f(x) - target = 0`, the Newton iteration is\n * `x_{n+1} = x_n - dx = x_n - g(x_n)/g'(x_n) = x_n - (f(x_n)-target)/f'(x_n)`.\n * @internal\n */\nexport class Newton1dUnbounded extends AbstractNewtonIterator {\n  private _func: NewtonEvaluatorRtoRD;\n  /** Current step is dx. */\n  private _currentStep!: number;\n  /** Current X is x_n. */\n  private _currentX!: number;\n  /** The target */\n  private _target!: number;\n  /**\n   * Constructor for 1D newton iteration with derivatives.\n   * @param func function that returns both function value and derivative.\n   */\n  public constructor(func: NewtonEvaluatorRtoRD, maxIterations?: number) {\n    super(undefined, undefined, maxIterations);\n    this._func = func;\n    this.setTarget(0);\n  }\n  /** Set the independent variable, i.e., x_n. */\n  public setX(x: number) {\n    this._currentX = x;\n  }\n  /** Get the independent variable, i.e., x_n. */\n  public getX(): number {\n    return this._currentX;\n  }\n  /** Set the target function value. */\n  public setTarget(y: number): void {\n    this._target = y;\n  }\n  /** Move the current X by the just-computed step, i.e., `x_n - dx`. */\n  public applyCurrentStep(): void {\n    this.setX(this._currentX - this._currentStep);\n  }\n  /** Compute the univariate newton step dx. */\n  public computeStep(): boolean {\n    if (this._func.evaluate(this._currentX)) {\n      const dx = Geometry.conditionalDivideFraction(this._func.currentF - this._target, this._func.currentdFdX);\n      if (dx !== undefined) {\n        this._currentStep = dx;\n        return true;\n      }\n    }\n    return false;\n  }\n  /** Return the current step size as a relative number, i.e., `|dx / (1 + |x_n|)|`. */\n  public currentStepSize(): number {\n    return Math.abs(this._currentStep / (1.0 + Math.abs(this._currentX)));\n  }\n}\n\n/**\n * Object to evaluate a newton function (without derivative). The object must retain most-recent function value.\n * @internal\n */\nexport abstract class NewtonEvaluatorRtoR {\n  /** Evaluate function value into member currentF */\n  public abstract evaluate(x: number): boolean;\n  /** Most recent function evaluation, i.e., f(x_n). */\n  public currentF!: number;\n}\n\n/**\n * Intermediate class for managing the parentCurve announcements from an IStrokeHandler.\n * @internal\n */\nexport abstract class NewtonRtoRStrokeHandler extends NewtonEvaluatorRtoR {\n  protected _parentCurvePrimitive: CurvePrimitive | undefined;\n  constructor() {\n    super();\n    this._parentCurvePrimitive = undefined;\n  }\n  /**\n   * Retain the parentCurvePrimitive.\n   * * Calling this method tells the handler that the parent curve is to be used for detail searches.\n   * * Example: Transition spiral search is based on linestring first, then the exact spiral.\n   * * Example: CurveChainWithDistanceIndex does NOT do this announcement; the constituents act independently.\n   */\n  public startParentCurvePrimitive(curve: CurvePrimitive | undefined): void {\n    this._parentCurvePrimitive = curve;\n  }\n  /** Forget the parentCurvePrimitive */\n  public endParentCurvePrimitive(_curve: CurvePrimitive | undefined): void {\n    this._parentCurvePrimitive = undefined;\n  }\n}\n\n/**\n * Newton iteration for a univariate function, using approximate derivatives.\n * To approximate the derivatives we use a small step `h`, i.e., `f'(x_n) = (f(x_n + h) - f(x_n)) / h`.\n * Therefore, to solve `f(x) = 0`, the iteration is\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))`.\n * @internal\n */\nexport class Newton1dUnboundedApproximateDerivative extends AbstractNewtonIterator {\n  private _func: NewtonEvaluatorRtoR;\n  /** Current step is dx. */\n  private _currentStep!: number;\n  /** Current X is x_n. */\n  private _currentX!: number;\n  /**\n   * Step size for approximate derivative for the iteration.\n   * * Initialized to 1e-8, which is appropriate for iteration in fraction space.\n   * * Should be larger for iteration with real distance as x.\n   */\n  public derivativeH: number; // h\n\n  /**\n   * Constructor for 1D newton iteration with approximate derivatives.\n   * @param func function that only returns function value (and not derivative).\n   */\n  public constructor(func: NewtonEvaluatorRtoR, maxIterations?: number) {\n    super(undefined, undefined, maxIterations);\n    this._func = func;\n    this.derivativeH = 1.0e-8;\n  }\n  /** Set the independent variable, i.e., x_n. */\n  public setX(x: number): void {\n    this._currentX = x;\n  }\n  /** Get the independent variable, i.e., x_n. */\n  public getX(): number {\n    return this._currentX;\n  }\n  /** Move the current X by the just-computed step, i.e., `x_n - dx`. */\n  public applyCurrentStep(): void {\n    this.setX(this._currentX - this._currentStep);\n  }\n  /** Univariate newton step dx, computed with approximate derivative. */\n  public computeStep(): boolean {\n    if (this._func.evaluate(this._currentX)) {\n      const fA = this._func.currentF; // f(x_n)\n      if (this._func.evaluate(this._currentX + this.derivativeH)) {\n        const fB = this._func.currentF; // f(x_n + h)\n        const dx = Geometry.conditionalDivideFraction(fA, (fB - fA) / this.derivativeH);\n        if (dx !== undefined) {\n          this._currentStep = dx;\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n  /** Return the current step size as a relative number, i.e., `|dx / (1 + |x_n|)|`. */\n  public currentStepSize(): number {\n    return Math.abs(this._currentStep / (1.0 + Math.abs(this._currentX)));\n  }\n}\n\n/**\n * Object to evaluate a 2-parameter newton function with derivatives.\n * @internal\n */\nexport abstract class NewtonEvaluatorRRtoRRD {\n  /**\n   * Iteration controller calls this to ask for evaluation of the function and its two partial derivatives.\n   * * The implementation returns true, it must set the currentF object.\n   */\n  public abstract evaluate(x: number, y: number): boolean;\n  /**\n   * Most recent function evaluation as parts of the plane.\n   * * See doc of [[Newton2dUnboundedWithDerivative]] class for info on 2d newton method.\n   * * For `F(u,v) := (x(u,v), y(u,v))` the returned plane stores the following evaluations at current value `X := (u,v)`:\n   * * `origin` = F(X) = (x(X), y(X))\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\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\n   */\n  public currentF!: Plane3dByOriginAndVectors;\n  /**\n   * Constructor.\n   * * This creates a currentF object to (repeatedly) receive function and derivatives.\n   */\n  public constructor() {\n    this.currentF = Plane3dByOriginAndVectors.createXYPlane();\n  }\n}\n\n/**\n * Implement evaluation steps for newton iteration in 2 dimensions, using caller supplied NewtonEvaluatorRRtoRRD object.\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,\n *  the 2D Newton's iteration to find a root of `F` is given by:\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\n * defined by the partial derivatives of the component functions of F:\n *\n * `[dx/du   dx/dv]`\n *\n * `[dy/du   dy/dv]`\n * @internal\n */\nexport class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {\n  private _func: NewtonEvaluatorRRtoRRD;\n  /** Current step, or dX = (du, dv). */\n  private _currentStep: Vector2d;\n  /** Current uv parameters, or X_n = (u_n, v_n). */\n  private _currentUV: Point2d;\n  /**\n   * Constructor for 2D newton iteration with derivatives.\n   * @param func function that returns both function value and derivative.\n   * @param maxIterations max number of iterations. Default 15.\n   * @param stepSizeTolerance tolerance to consider a single step converged. Default [[Geometry.smallNewtonStep]].\n   */\n  public constructor(func: NewtonEvaluatorRRtoRRD, maxIterations?: number, stepSizeTolerance?: number) {\n    super(stepSizeTolerance, undefined, maxIterations);\n    this._func = func;\n    this._currentStep = Vector2d.createZero();\n    this._currentUV = Point2d.createZero();\n  }\n  /** Set the current uv parameters, i.e., `X_n = (u_n, v_n)`. */\n  public setUV(u: number, v: number): void {\n    this._currentUV.set(u, v);\n  }\n  /** Get the current u parameter of X_n, i.e., u_n. */\n  public getU(): number {\n    return this._currentUV.x;\n  }\n  /** Get the current v parameter of X_n, i.e., v_n. */\n  public getV(): number {\n    return this._currentUV.y;\n  }\n  /** Update the current uv parameter by currentStep, i.e., compute `X_{n+1} := X_n - dX = (u_n - du, v_n - dv)`. */\n  public applyCurrentStep(): void {\n    this.setUV(this._currentUV.x - this._currentStep.x, this._currentUV.y - this._currentStep.y);\n  }\n  /**\n   * Evaluate the functions and derivatives at `X_n = (u_n, v_n)`, and solve the Jacobian matrix equation to\n   * compute `dX = (du, dv)`.\n   */\n  public computeStep(): boolean {\n    if (!this._func.evaluate(this._currentUV.x, this._currentUV.y))\n      return false;\n    const fA = this._func.currentF;\n    const jCol0 = fA.vectorU;\n    const jCol1 = fA.vectorV;\n    const fX = fA.origin;\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:\n    if (SmallSystem.linearSystem2d(jCol0.x, jCol1.x, jCol0.y, jCol1.y, fX.x, fX.y, this._currentStep))\n      return true;\n    return false;\n  }\n  /**\n   * Return the current relative step size, i.e., the larger absolute component of `dX / (1 + |X_n|)`\n   */\n  public currentStepSize(): number {\n    return Geometry.maxAbsXY(\n      this._currentStep.x / (1.0 + Math.abs(this._currentUV.x)),\n      this._currentStep.y / (1.0 + Math.abs(this._currentUV.y)),\n    );\n  }\n  /** Candidate solution cache. */\n  private _cachedUV: Point2d | undefined;\n  /** The current late iterate has the least delta encountered. Remember it. */\n  protected override cacheCandidate(): void {\n    if (this._cachedUV)\n      this._cachedUV.setFrom(this._currentUV);\n    else\n      this._cachedUV = this._currentUV.clone();\n  }\n  /** Set Newton result to the cached candidate. */\n  protected override restoreCandidate(): void {\n    if (this._cachedUV)\n      this.setUV(this._cachedUV.x, this._cachedUV.y);\n  }\n}\n/**\n * SimpleNewton has static methods for newton methods with evaluated functions presented as immediate arguments\n * (not function object).\n * @internal\n */\nexport class SimpleNewton {\n  /**\n   * Run a one-dimensional newton iteration with separate functions for function and derivative.\n   * * Completion is at 2 (TWO) successive passes at `absoluteTolerance + relTol * abs(x)`, where relTol is\n   * chosen internally.\n   * * `absoluteTolerance` is usually aggressively tight -- should come into play only for x near zero.\n   * * The `relTol` is fluffy (for instance around 1e-11) but in properly converging cases the extra pass after\n   * first success normally moves to full machine precision.\n   * * This is an open-loop newton -- it just runs, and returns undefined if anything bad happens.\n   */\n  public static runNewton1D(\n    x: number,\n    func: (x: number) => number | undefined,\n    derivative: (x: number) => number | undefined,\n    absoluteTolerance: number = Geometry.smallFloatingPoint,\n  ): number | undefined {\n    let numConverged = 0;\n    let tolerance: number;\n    const relTol = Geometry.smallNewtonStep;\n    for (let iteration = 0; iteration < 20; iteration++) {\n      const f = func(x);\n      const df = derivative(x);\n      if (f !== undefined && df !== undefined) {\n        const dx = Geometry.conditionalDivideCoordinate(f, df);\n        if (dx === undefined)\n          return undefined;\n        x -= dx;\n        // console.log(x); // print approximations for debug\n        tolerance = absoluteTolerance + Math.abs(x) * relTol;\n        if (Math.abs(dx) < tolerance) {\n          numConverged++;\n          if (dx === 0.0 || numConverged > 1) // bypass convergence count on true 0 dx\n            return x;\n        } else {\n          numConverged = 0;\n        }\n      }\n    }\n    return undefined;\n  }\n}\n\n/**\n * Class to evaluate XY intersection between 2 curve primitives using the Newton method.\n * @internal\n */\nexport class CurveCurveIntersectionXYRRToRRD extends NewtonEvaluatorRRtoRRD {\n  private _curveP: CurvePrimitive;\n  private _curveQ: CurvePrimitive;\n  private _rayP: Ray3d;\n  private _rayQ: Ray3d;\n  constructor(curveP: CurvePrimitive, curveQ: CurvePrimitive) {\n    super();\n    this._curveP = curveP;\n    this._curveQ = curveQ;\n    this._rayP = Ray3d.createZero();\n    this._rayQ = Ray3d.createZero();\n  }\n  public evaluate(fractionU: number, fractionV: number): boolean {\n    /**\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\n     *   F(u,v) := P(u) - Q(v) = (0,0)\n     * Using the Newton method we can find the fractions u and v at the intersection via\n     *   [u_{n+1}]     [u_n]          [x_p'(u_n)  -x_q'(v_n)]    [x_p(u_n) - x_q(v_n)]\n     *              =         -  Inv(                         )\n     *   [v_{n+1}]     [v_n]          [y_p'(u_n)  -y_q'(v_n)]    [y_p(u_n) - y_q(v_n)]\n     * Note that this is xy intersection so we can ignore z.\n     */\n    this._curveP.fractionToPointAndDerivative(fractionU, this._rayP);\n    this._curveQ.fractionToPointAndDerivative(fractionV, this._rayQ);\n    this.currentF.setOriginAndVectorsXYZ(\n      this._rayP.origin.x - this._rayQ.origin.x, this._rayP.origin.y - this._rayQ.origin.y, 0.0,\n      this._rayP.direction.x, this._rayP.direction.y, 0.0,\n      -this._rayQ.direction.x, -this._rayQ.direction.y, 0.0,\n    );\n    return true;\n  }\n}\n\n/**\n * Class to evaluate XY close approach between a curve primitive and a point using the Newton method.\n * @internal\n */\nexport class CurvePointCloseApproachXYRtoRD extends NewtonEvaluatorRtoRD {\n  private _curveP: CurvePrimitive;\n  private _pointQ: Point3d;\n  private _planeP: Plane3dByOriginAndVectors;\n  constructor(curveP: CurvePrimitive, pointQ: Point3d) {\n    super();\n    this._curveP = curveP;\n    this._pointQ = pointQ;\n    this._planeP = Plane3dByOriginAndVectors.createXYPlane();\n  }\n  public evaluate(fractionU: number): boolean {\n    /**\n     * To find a close approach between xy-curve P(u) and xy-point q we should solve\n     *    F(u) := P'(u).(P(u) - q) = 0\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\n     * a close approach.\n     * Using the Newton method we can find the fractions u at the close approach location via\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) ]\n     * Note that this is xy close approach so we can ignore z.\n     */\n    this._curveP.fractionToPointAnd2Derivatives(fractionU, this._planeP);\n    const segX = this._planeP.origin.x - this._pointQ.x;\n    const segY = this._planeP.origin.y - this._pointQ.y;\n    const pDerivX = this._planeP.vectorU.x;\n    const pDerivY = this._planeP.vectorU.y;\n    const p2DerivX = this._planeP.vectorV.x;\n    const p2DerivY = this._planeP.vectorV.y;\n    this.currentF = pDerivX * segX + pDerivY * segY;\n    this.currentdFdX = p2DerivX * segX + pDerivX * pDerivX + p2DerivY * segY + pDerivY * pDerivY;\n    return true;\n  }\n}\n\n/**\n * Class to evaluate XY close approach between 2 curve primitives using the Newton method.\n * @internal\n */\nexport class CurveCurveCloseApproachXYRRtoRRD extends NewtonEvaluatorRRtoRRD {\n  private _curveP: CurvePrimitive;\n  private _curveQ: CurvePrimitive;\n  private _planeP: Plane3dByOriginAndVectors;\n  private _planeQ: Plane3dByOriginAndVectors;\n  constructor(curveP: CurvePrimitive, curveQ: CurvePrimitive) {\n    super();\n    this._curveP = curveP;\n    this._curveQ = curveQ;\n    this._planeP = Plane3dByOriginAndVectors.createXYPlane();\n    this._planeQ = Plane3dByOriginAndVectors.createXYPlane();\n  }\n  public evaluate(fractionU: number, fractionV: number): boolean {\n    /**\n     * To find a close approach between xy-curves P(u) and Q(v) we should solve\n     *    F(u,v) := (P'(u).(P(u) - Q(v)), Q'(v).(P(u) - Q(v))) = (0,0)\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),\n     * which means S(u,v) is a close approach.\n     * Using the Newton method we can find the fractions u and v at the close approach location via\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)]\n     *              =         -  Inv(                                                            )\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)]\n     * Note that this is xy close approach so we can ignore z.\n     */\n    this._curveP.fractionToPointAnd2Derivatives(fractionU, this._planeP);\n    this._curveQ.fractionToPointAnd2Derivatives(fractionV, this._planeQ);\n    const segX = this._planeP.origin.x - this._planeQ.origin.x;\n    const segY = this._planeP.origin.y - this._planeQ.origin.y;\n    const pDerivX = this._planeP.vectorU.x;\n    const pDerivY = this._planeP.vectorU.y;\n    const qDerivX = this._planeQ.vectorU.x;\n    const qDerivY = this._planeQ.vectorU.y;\n    const p2DerivX = this._planeP.vectorV.x;\n    const p2DerivY = this._planeP.vectorV.y;\n    const q2DerivX = this._planeQ.vectorV.x;\n    const q2DerivY = this._planeQ.vectorV.y;\n    this.currentF.setOriginAndVectorsXYZ(\n      pDerivX * segX + pDerivY * segY,\n      qDerivX * segX + qDerivY * segY,\n      0.0,\n      p2DerivX * segX + p2DerivY * segY + pDerivX * pDerivX + pDerivY * pDerivY,\n      qDerivX * pDerivX + qDerivY * pDerivY,\n      0.0,\n      -(pDerivX * qDerivX + pDerivY * qDerivY),\n      q2DerivX * segX + q2DerivY * segY - qDerivX * qDerivX - qDerivY * qDerivY,\n      0.0,\n    );\n    return true;\n  }\n}\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"PascalCoefficients.js","sourceRoot":"","sources":["../../../src/numerics/PascalCoefficients.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 * PascalCoeffients class has static methods which return rows of the PascalTriangle.\r\n * @internal\r\n */\r\nexport class PascalCoefficients {\r\n  private static _allRows: Float64Array[] = [];\r\n  /**\r\n   * * return a row of the pascal table.\r\n   * * The contents must not be altered by the user !!!\r\n   * * Hypothetically the request row can be any integer.\r\n   * * BUT in practice, values 60 create integer entries that are too big for IEEE double.\r\n   */\r\n  public static getRow(row: number): Float64Array {\r\n    const allRows = PascalCoefficients._allRows;\r\n    if (allRows.length === 0) {\r\n      // seed the table . . .\r\n      allRows.push(new Float64Array([1]));\r\n      allRows.push(new Float64Array([1, 1]));\r\n      allRows.push(new Float64Array([1, 2, 1]));\r\n      allRows.push(new Float64Array([1, 3, 3, 1]));\r\n      allRows.push(new Float64Array([1, 4, 6, 4, 1]));\r\n      allRows.push(new Float64Array([1, 5, 10, 10, 5, 1]));\r\n      allRows.push(new Float64Array([1, 6, 15, 20, 15, 6, 1]));\r\n      allRows.push(new Float64Array([1, 7, 21, 35, 35, 21, 7, 1]));\r\n    }\r\n\r\n    while (allRows.length <= row) {\r\n      const k = allRows.length;\r\n      const oldRow = allRows[k - 1];\r\n      const newRow = new Float64Array(k + 1);\r\n      newRow[0] = 1.0;\r\n      for (let i = 1; i < k; i++)\r\n        newRow[i] = oldRow[i - 1] + oldRow[i];\r\n      newRow[k] = 1.0;\r\n      allRows.push(newRow);\r\n    }\r\n    return allRows[row];\r\n  }\r\n  /**\r\n   * Return an array with Bezier weighted pascal coefficients\r\n   * @param order output size. The index of the row of the Pascal triangle supplying weights is `order - 1`.\r\n   * @param u parameter value\r\n   * @param result optional destination array of length `order`. If the destination array is too small, a new Float64Array is allocated.\r\n   */\r\n  public static getBezierBasisValues(order: number, u: number, result?: Float64Array): Float64Array {\r\n    const row = order - 1;\r\n    const pascalRow = PascalCoefficients.getRow(row);\r\n    if (result === undefined || result.length < order)\r\n      result = new Float64Array(order);\r\n    for (let i = 0; i < order; i++)\r\n      result[i] = pascalRow[i];\r\n    // multiply by increasing powers of u ...\r\n    let p = u;\r\n    for (let i = 1; i < order; i++ , p *= u) {\r\n      result[i] *= p;\r\n    }\r\n    // multiply by powers of (1-u), working from right\r\n    const v = 1.0 - u;\r\n    p = v;\r\n    for (let i = order - 2; i >= 0; i-- , p *= v) {\r\n      result[i] *= p;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Return an array with derivatives of Bezier weighted pascal coefficients\r\n   * @param order output size. The index of the row of the Pascal triangle supplying weights is `order - 2`.\r\n   * @param u parameter value\r\n   * @param result optional destination array of length `order`. If the destination array is too small, a new Float64Array is allocated.\r\n   */\r\n  public static getBezierBasisDerivatives(order: number, u: number, result?: Float64Array): Float64Array {\r\n    if (result === undefined || result.length < order)\r\n      result = new Float64Array(order);\r\n    result = this.getBezierBasisValues(order - 1, u, result);\r\n    // derivative is df/du = (order-1 ) * sum ( q[i+1] - q[i])   summed on 0 <= i < order - 1.\\\r\n    // evaluate lower order basis, overwrite in place from right to left\r\n    const f = order - 1;\r\n    result[order - 1] = f * result[order - 2];\r\n    for (let k = order - 2; k > 0; k--) {\r\n      result[k] = f * (result[k - 1] - result[k]);\r\n    }\r\n    result[0] = - f * result[0];\r\n    return result;\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"PascalCoefficients.js","sourceRoot":"","sources":["../../../src/numerics/PascalCoefficients.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/**\n * PascalCoeffients class has static methods which return rows of the PascalTriangle.\n * @internal\n */\nexport class PascalCoefficients {\n  private static _allRows: Float64Array[] = [];\n  /**\n   * * return a row of the pascal table.\n   * * The contents must not be altered by the user !!!\n   * * Hypothetically the request row can be any integer.\n   * * BUT in practice, values 60 create integer entries that are too big for IEEE double.\n   */\n  public static getRow(row: number): Float64Array {\n    const allRows = PascalCoefficients._allRows;\n    if (allRows.length === 0) {\n      // seed the table . . .\n      allRows.push(new Float64Array([1]));\n      allRows.push(new Float64Array([1, 1]));\n      allRows.push(new Float64Array([1, 2, 1]));\n      allRows.push(new Float64Array([1, 3, 3, 1]));\n      allRows.push(new Float64Array([1, 4, 6, 4, 1]));\n      allRows.push(new Float64Array([1, 5, 10, 10, 5, 1]));\n      allRows.push(new Float64Array([1, 6, 15, 20, 15, 6, 1]));\n      allRows.push(new Float64Array([1, 7, 21, 35, 35, 21, 7, 1]));\n    }\n\n    while (allRows.length <= row) {\n      const k = allRows.length;\n      const oldRow = allRows[k - 1];\n      const newRow = new Float64Array(k + 1);\n      newRow[0] = 1.0;\n      for (let i = 1; i < k; i++)\n        newRow[i] = oldRow[i - 1] + oldRow[i];\n      newRow[k] = 1.0;\n      allRows.push(newRow);\n    }\n    return allRows[row];\n  }\n  /**\n   * Return an array with Bezier weighted pascal coefficients\n   * @param order output size. The index of the row of the Pascal triangle supplying weights is `order - 1`.\n   * @param u parameter value\n   * @param result optional destination array of length `order`. If the destination array is too small, a new Float64Array is allocated.\n   */\n  public static getBezierBasisValues(order: number, u: number, result?: Float64Array): Float64Array {\n    const row = order - 1;\n    const pascalRow = PascalCoefficients.getRow(row);\n    if (result === undefined || result.length < order)\n      result = new Float64Array(order);\n    for (let i = 0; i < order; i++)\n      result[i] = pascalRow[i];\n    // multiply by increasing powers of u ...\n    let p = u;\n    for (let i = 1; i < order; i++ , p *= u) {\n      result[i] *= p;\n    }\n    // multiply by powers of (1-u), working from right\n    const v = 1.0 - u;\n    p = v;\n    for (let i = order - 2; i >= 0; i-- , p *= v) {\n      result[i] *= p;\n    }\n    return result;\n  }\n\n  /**\n   * Return an array with derivatives of Bezier weighted pascal coefficients\n   * @param order output size. The index of the row of the Pascal triangle supplying weights is `order - 2`.\n   * @param u parameter value\n   * @param result optional destination array of length `order`. If the destination array is too small, a new Float64Array is allocated.\n   */\n  public static getBezierBasisDerivatives(order: number, u: number, result?: Float64Array): Float64Array {\n    if (result === undefined || result.length < order)\n      result = new Float64Array(order);\n    result = this.getBezierBasisValues(order - 1, u, result);\n    // derivative is df/du = (order-1 ) * sum ( q[i+1] - q[i])   summed on 0 <= i < order - 1.\\\n    // evaluate lower order basis, overwrite in place from right to left\n    const f = order - 1;\n    result[order - 1] = f * result[order - 2];\n    for (let k = order - 2; k > 0; k--) {\n      result[k] = f * (result[k - 1] - result[k]);\n    }\n    result[0] = - f * result[0];\n    return result;\n  }\n}\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"PolarData.js","sourceRoot":"","sources":["../../../src/numerics/PolarData.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\nimport { Arc3d } from \"../curve/Arc3d\";\r\nimport { CoordinateXYZ } from \"../curve/CoordinateXYZ\";\r\nimport { GeometryQuery } from \"../curve/GeometryQuery\";\r\nimport { LineSegment3d } from \"../curve/LineSegment3d\";\r\nimport { Geometry } from \"../Geometry\";\r\nimport { Angle } from \"../geometry3d/Angle\";\r\nimport { Point3d } from \"../geometry3d/Point3dVector3d\";\r\n\r\n/** Enumeration of how constraints have been resolved\r\n * @internal\r\n */\r\nexport enum ConstraintState {\r\n  unknown = 0,\r\n  singlePoint = 1,\r\n  impossibleValues = -1,\r\n  onCurve = 2,\r\n\r\n}\r\n\r\n/**\r\n * PolarData carries (possibly incomplete) data for converting among polar and cartesian coordinates.\r\n * @internal\r\n */\r\nexport class PolarData {\r\n  private static _defaultRadius = 1.0;\r\n  public static get defaultRadius(): number { return PolarData._defaultRadius; }\r\n  /** x coordinate, possibly unknown */\r\n  public x?: number;\r\n  /** y coordinate, possibly unknown */\r\n  public y?: number;\r\n  /** radius, possibly unknown */\r\n  public r?: number;\r\n  /** angle, possibly unknown */\r\n  public theta?: Angle;\r\n  /** point, line, or arc geometry, as determined by  solveFromScalars */\r\n  public geometry?: GeometryQuery;\r\n  /** enumeration of resolved state validity conditions. */\r\n  public state?: ConstraintState;\r\n  /** Count the number of defined values among x,y,r, theta */\r\n  public get numberOfConstrainedScalars(): number {\r\n    let n = 0;\r\n    if (this.x !== undefined) n++;\r\n    if (this.y !== undefined) n++;\r\n    if (this.r !== undefined) n++;\r\n    if (this.theta !== undefined) n++;\r\n    return n;\r\n  }\r\n  /** Create with any combination of known and unknown scalars. */\r\n  public static createMixedScalars(state?: ConstraintState, x?: number, y?: number, r?: number, theta?: Angle): PolarData {\r\n    const result = new PolarData();\r\n    result.x = x;\r\n    result.y = y;\r\n    result.r = r;\r\n    result.theta = theta !== undefined ? theta.clone() : undefined;\r\n    result.state = state;\r\n    return result;\r\n  }\r\n\r\n  /** Clone the scalar data, replace the state.\r\n   * * Geometry is NOT cloned.\r\n   */\r\n  public cloneScalarsWithState(newState: ConstraintState): PolarData {\r\n    const result = new PolarData();\r\n    result.x = this.x;\r\n    result.y = this.y;\r\n    result.r = this.r;\r\n    result.theta = this.theta !== undefined ? this.theta.clone() : undefined;\r\n    result.state = newState;\r\n    return result;\r\n  }\r\n\r\n  /** Given a possibly incomplete set of x,y,r,theta, determine the possible completions. */\r\n  public static solveFromScalars(known: PolarData): PolarData[] {\r\n    const result = [];\r\n    // .. fill out known combinations (x,y) (x,r) etc.\r\n    // .. any \"singlePoints\" gets created with no geometry, but geometry fills in at end.\r\n    // .. \"free on curve\" has curve filled in, with finite curve range controlled by PolarData.defaultRadius.\r\n    if (known.x !== undefined) {\r\n      if (known.y !== undefined) {\r\n        result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, known.x, known.y, Geometry.hypotenuseXY(known.x, known.y), Angle.createAtan2(known.y, known.x)));\r\n      } else if (known.r !== undefined) {\r\n        const rr = known.r * known.r;\r\n        const xx = known.x * known.x;\r\n        const yy = rr - xx;\r\n        if (yy < 0.0) {\r\n          result.push(known.cloneScalarsWithState(ConstraintState.impossibleValues));\r\n        } else {\r\n          const y = Math.sqrt(yy);\r\n          result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, known.x, y, known.r, Angle.createAtan2(y, known.x)));\r\n          result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, known.x, -y, known.r, Angle.createAtan2(-y, known.x)));\r\n        }\r\n      } else if (known.theta !== undefined) {\r\n        const r = Geometry.conditionalDivideFraction(known.x, known.theta.cos());\r\n        // test 4*theta to isolate either positive or negative PI/2 case ...\r\n        if (r === undefined) {\r\n          // Anywhere on y axis does has x=0, this angle . . .\r\n          const q = known.cloneScalarsWithState(ConstraintState.onCurve);\r\n          q.geometry = LineSegment3d.createXYXY(0, PolarData._defaultRadius, 0, PolarData._defaultRadius);\r\n        } else {\r\n          const y = r * known.theta.sin();\r\n          result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, known.x, y, r, known.theta));\r\n        }\r\n      } else {  // only x known --- fill out a vertical line\r\n        const q = known.cloneScalarsWithState(ConstraintState.onCurve);\r\n        q.geometry = LineSegment3d.createXYZXYZ(known.x, PolarData._defaultRadius, 0, known.x, PolarData._defaultRadius, 0);\r\n      }\r\n    } else if (known.y !== undefined) {   // and we already know x is undefined .....\r\n      if (known.r !== undefined) {\r\n        const rr = known.r * known.r;\r\n        const yy = known.y * known.y;\r\n        const xx = rr - yy;\r\n        if (xx < 0.0) {\r\n          result.push(known.cloneScalarsWithState(ConstraintState.impossibleValues));\r\n        } else {\r\n          const x = Math.sqrt(xx);\r\n          result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, x, known.y, known.r, Angle.createAtan2(known.y, x)));\r\n          result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, -x, known.y, known.r, Angle.createAtan2(known.y, -x)));\r\n        }\r\n      } else if (known.theta !== undefined) {\r\n        const r = Geometry.conditionalDivideFraction(known.y, known.theta.sin());\r\n        // test 4*theta to isolate either positive or negative PI/2 case ...\r\n        if (r === undefined) {\r\n          // Anywhere on y axis does has x=0, this angle . . .\r\n          const q = known.cloneScalarsWithState(ConstraintState.onCurve);\r\n          q.geometry = LineSegment3d.createXYZXYZ(0, PolarData._defaultRadius, 0, 0, PolarData._defaultRadius, 0);\r\n        } else {\r\n          const x = r * known.theta.cos();\r\n          result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, x, known.y, r, known.theta));\r\n        }\r\n      } else {  // only x known --- fill out a horizontal line\r\n        const q = known.cloneScalarsWithState(ConstraintState.onCurve);\r\n        q.geometry = LineSegment3d.createXYZXYZ(PolarData._defaultRadius, known.y, 0, PolarData._defaultRadius, known.y, 0);\r\n      }\r\n    } else if (known.r !== undefined) {\r\n      if (known.theta !== undefined) {\r\n        result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, known.r * known.theta.cos(), known.r * known.theta.sin(), known.r, known.theta));\r\n      } else {\r\n        const q = known.cloneScalarsWithState(ConstraintState.onCurve);\r\n        q.geometry = Arc3d.createXY(Point3d.create(0, 0, 0), known.r);\r\n        result.push(q);\r\n      }\r\n    } else if (known.theta !== undefined) {\r\n      const q = known.cloneScalarsWithState(ConstraintState.onCurve);\r\n      const x = PolarData._defaultRadius * known.theta.cos();\r\n      const y = PolarData._defaultRadius * known.theta.sin();\r\n      q.geometry = LineSegment3d.createXYXY(-x, -y, x, y);\r\n      result.push(q);\r\n    }\r\n    // ----------------------------------------------------------------------------------------\r\n    // add tangible geometry to single points ...\r\n    for (const r of result) {\r\n      if (r.state === ConstraintState.singlePoint && r.geometry === undefined)\r\n        r.geometry = CoordinateXYZ.createXYZ(r.x, r.y, 0.0);\r\n    }\r\n    return result;\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"PolarData.js","sourceRoot":"","sources":["../../../src/numerics/PolarData.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\nimport { Arc3d } from \"../curve/Arc3d\";\nimport { CoordinateXYZ } from \"../curve/CoordinateXYZ\";\nimport { GeometryQuery } from \"../curve/GeometryQuery\";\nimport { LineSegment3d } from \"../curve/LineSegment3d\";\nimport { Geometry } from \"../Geometry\";\nimport { Angle } from \"../geometry3d/Angle\";\nimport { Point3d } from \"../geometry3d/Point3dVector3d\";\n\n/** Enumeration of how constraints have been resolved\n * @internal\n */\nexport enum ConstraintState {\n  unknown = 0,\n  singlePoint = 1,\n  impossibleValues = -1,\n  onCurve = 2,\n\n}\n\n/**\n * PolarData carries (possibly incomplete) data for converting among polar and cartesian coordinates.\n * @internal\n */\nexport class PolarData {\n  private static _defaultRadius = 1.0;\n  public static get defaultRadius(): number { return PolarData._defaultRadius; }\n  /** x coordinate, possibly unknown */\n  public x?: number;\n  /** y coordinate, possibly unknown */\n  public y?: number;\n  /** radius, possibly unknown */\n  public r?: number;\n  /** angle, possibly unknown */\n  public theta?: Angle;\n  /** point, line, or arc geometry, as determined by  solveFromScalars */\n  public geometry?: GeometryQuery;\n  /** enumeration of resolved state validity conditions. */\n  public state?: ConstraintState;\n  /** Count the number of defined values among x,y,r, theta */\n  public get numberOfConstrainedScalars(): number {\n    let n = 0;\n    if (this.x !== undefined) n++;\n    if (this.y !== undefined) n++;\n    if (this.r !== undefined) n++;\n    if (this.theta !== undefined) n++;\n    return n;\n  }\n  /** Create with any combination of known and unknown scalars. */\n  public static createMixedScalars(state?: ConstraintState, x?: number, y?: number, r?: number, theta?: Angle): PolarData {\n    const result = new PolarData();\n    result.x = x;\n    result.y = y;\n    result.r = r;\n    result.theta = theta !== undefined ? theta.clone() : undefined;\n    result.state = state;\n    return result;\n  }\n\n  /** Clone the scalar data, replace the state.\n   * * Geometry is NOT cloned.\n   */\n  public cloneScalarsWithState(newState: ConstraintState): PolarData {\n    const result = new PolarData();\n    result.x = this.x;\n    result.y = this.y;\n    result.r = this.r;\n    result.theta = this.theta !== undefined ? this.theta.clone() : undefined;\n    result.state = newState;\n    return result;\n  }\n\n  /** Given a possibly incomplete set of x,y,r,theta, determine the possible completions. */\n  public static solveFromScalars(known: PolarData): PolarData[] {\n    const result = [];\n    // .. fill out known combinations (x,y) (x,r) etc.\n    // .. any \"singlePoints\" gets created with no geometry, but geometry fills in at end.\n    // .. \"free on curve\" has curve filled in, with finite curve range controlled by PolarData.defaultRadius.\n    if (known.x !== undefined) {\n      if (known.y !== undefined) {\n        result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, known.x, known.y, Geometry.hypotenuseXY(known.x, known.y), Angle.createAtan2(known.y, known.x)));\n      } else if (known.r !== undefined) {\n        const rr = known.r * known.r;\n        const xx = known.x * known.x;\n        const yy = rr - xx;\n        if (yy < 0.0) {\n          result.push(known.cloneScalarsWithState(ConstraintState.impossibleValues));\n        } else {\n          const y = Math.sqrt(yy);\n          result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, known.x, y, known.r, Angle.createAtan2(y, known.x)));\n          result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, known.x, -y, known.r, Angle.createAtan2(-y, known.x)));\n        }\n      } else if (known.theta !== undefined) {\n        const r = Geometry.conditionalDivideFraction(known.x, known.theta.cos());\n        // test 4*theta to isolate either positive or negative PI/2 case ...\n        if (r === undefined) {\n          // Anywhere on y axis does has x=0, this angle . . .\n          const q = known.cloneScalarsWithState(ConstraintState.onCurve);\n          q.geometry = LineSegment3d.createXYXY(0, PolarData._defaultRadius, 0, PolarData._defaultRadius);\n        } else {\n          const y = r * known.theta.sin();\n          result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, known.x, y, r, known.theta));\n        }\n      } else {  // only x known --- fill out a vertical line\n        const q = known.cloneScalarsWithState(ConstraintState.onCurve);\n        q.geometry = LineSegment3d.createXYZXYZ(known.x, PolarData._defaultRadius, 0, known.x, PolarData._defaultRadius, 0);\n      }\n    } else if (known.y !== undefined) {   // and we already know x is undefined .....\n      if (known.r !== undefined) {\n        const rr = known.r * known.r;\n        const yy = known.y * known.y;\n        const xx = rr - yy;\n        if (xx < 0.0) {\n          result.push(known.cloneScalarsWithState(ConstraintState.impossibleValues));\n        } else {\n          const x = Math.sqrt(xx);\n          result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, x, known.y, known.r, Angle.createAtan2(known.y, x)));\n          result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, -x, known.y, known.r, Angle.createAtan2(known.y, -x)));\n        }\n      } else if (known.theta !== undefined) {\n        const r = Geometry.conditionalDivideFraction(known.y, known.theta.sin());\n        // test 4*theta to isolate either positive or negative PI/2 case ...\n        if (r === undefined) {\n          // Anywhere on y axis does has x=0, this angle . . .\n          const q = known.cloneScalarsWithState(ConstraintState.onCurve);\n          q.geometry = LineSegment3d.createXYZXYZ(0, PolarData._defaultRadius, 0, 0, PolarData._defaultRadius, 0);\n        } else {\n          const x = r * known.theta.cos();\n          result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, x, known.y, r, known.theta));\n        }\n      } else {  // only x known --- fill out a horizontal line\n        const q = known.cloneScalarsWithState(ConstraintState.onCurve);\n        q.geometry = LineSegment3d.createXYZXYZ(PolarData._defaultRadius, known.y, 0, PolarData._defaultRadius, known.y, 0);\n      }\n    } else if (known.r !== undefined) {\n      if (known.theta !== undefined) {\n        result.push(PolarData.createMixedScalars(ConstraintState.singlePoint, known.r * known.theta.cos(), known.r * known.theta.sin(), known.r, known.theta));\n      } else {\n        const q = known.cloneScalarsWithState(ConstraintState.onCurve);\n        q.geometry = Arc3d.createXY(Point3d.create(0, 0, 0), known.r);\n        result.push(q);\n      }\n    } else if (known.theta !== undefined) {\n      const q = known.cloneScalarsWithState(ConstraintState.onCurve);\n      const x = PolarData._defaultRadius * known.theta.cos();\n      const y = PolarData._defaultRadius * known.theta.sin();\n      q.geometry = LineSegment3d.createXYXY(-x, -y, x, y);\n      result.push(q);\n    }\n    // ----------------------------------------------------------------------------------------\n    // add tangible geometry to single points ...\n    for (const r of result) {\n      if (r.state === ConstraintState.singlePoint && r.geometry === undefined)\n        r.geometry = CoordinateXYZ.createXYZ(r.x, r.y, 0.0);\n    }\n    return result;\n  }\n}\n"]}