@itwin/core-geometry 4.3.0-dev.2 → 4.3.0-dev.20

package/lib/cjs/numerics/Newton.js

@@ -13,27 +13,28 @@ const Plane3dByOriginAndVectors_1 = require("../geometry3d/Plane3dByOriginAndVec
 const Point2dVector2d_1 = require("../geometry3d/Point2dVector2d");
 const Polynomials_1 = require("./Polynomials");
 // cspell:word currentdFdX
-/** base class for Newton iterations in various dimensions.
- * Dimension-specific classes carry all dimension-related data and answer generalized queries
- * from this base class.
+/**
+ * Base class for Newton iterations in various dimensions.
+ * Dimension-specific classes carry all dimension-related data and answer generalized queries from this base class.
  * @internal
  */
 class AbstractNewtonIterator {
     /**
+     * The constructor.
      * @param stepSizeTarget tolerance to consider a single step converged.
-     * This number should be "moderately" strict.   Because 2 successive convergences are required,
+     * This number should be "moderately" strict. Because 2 successive convergences are required,
      * it is expected that a first "accept" for (say) 10 to 14 digit step will be followed by another
-     * iteration.   A well behaved newton would then hypothetically double the number of digits to
-     * 20 to 28.  Since the IEEE double only carries 16 digits, this second-convergence step will
+     * iteration. A well behaved newton would then hypothetically double the number of digits to
+     * 20 to 28. Since the IEEE double only carries 16 digits, this second-convergence step will
      * typically achieve full precision.
      * @param successiveConvergenceTarget number of successive convergences required for acceptance.
-     * @param maxIterations max number of iterations.   A typical newton step converges in 3 to 6 iterations.
-     *     Allow 15 to 20 to catch difficult cases.
+     * @param maxIterations max number of iterations. A typical newton step converges in 3 to 6 iterations.
+     * Allow 15 to 20 to catch difficult cases.
      */
     constructor(stepSizeTolerance = 1.0e-11, successiveConvergenceTarget = 2, maxIterations = 15) {
-        /** Number of consecutive steps which passed convergence condition */
+        /** Number of consecutive steps which passed convergence condition. */
         this._numAccepted = 0;
-        /** number of iterations (incremented at each step) */
+        /** Number of iterations (incremented at each step). */
         this.numIterations = 0;
         this._stepSizeTolerance = stepSizeTolerance;
         this._successiveConvergenceTarget = successiveConvergenceTarget;
@@ -41,8 +42,9 @@ class AbstractNewtonIterator {
     }
     /**
      * Test if a step is converged.
-     * * Convergence is accepted with enough (_successiveConvergenceTarget) small steps (according to _stepSizeTolerance) occur in succession.
-     * @param delta step size as reported by currentStepSize
+     * * Convergence is accepted with enough (_successiveConvergenceTarget) small steps (according to _stepSizeTolerance)
+     * occur in succession.
+     * @param delta step size as reported by currentStepSize.
      */
     testConvergence(delta) {
         if (Math.abs(delta) < this._stepSizeTolerance) {
@@ -55,16 +57,15 @@ class AbstractNewtonIterator {
     /**
      * Run iterations, calling various methods from base and derived classes:
      * * computeStep -- typically evaluate derivatives and solve linear system.
-     * * currentStepSize -- return numeric measure of the step just computed by computeStep
+     * * currentStepSize -- return numeric measure of the step just computed by computeStep.
      * * testConvergence -- test if the step from currentStepSize (along with recent steps) is converged.
-     * * applyCurrentStep -- apply the step to the independent variables
+     * * applyCurrentStep -- apply the step to the independent variables.
      */
     runIterations() {
         this._numAccepted = 0;
         this.numIterations = 0;
         while (this.numIterations++ < this._maxIterations && this.computeStep()) {
-            if (this.testConvergence(this.currentStepSize())
-                && this.applyCurrentStep(true)) {
+            if (this.testConvergence(this.currentStepSize()) && this.applyCurrentStep(true)) {
                 return true;
             }
             this.applyCurrentStep(false);
@@ -73,7 +74,8 @@ class AbstractNewtonIterator {
     }
 }
 exports.AbstractNewtonIterator = AbstractNewtonIterator;
-/** object to evaluate a newton function.  The object must retain most-recent function and derivative
+/**
+ * Object to evaluate a newton function. The object must retain most-recent function and derivative
  * values for immediate query.
  * @internal
  */
@@ -82,26 +84,39 @@ class NewtonEvaluatorRtoRD {
 exports.NewtonEvaluatorRtoRD = NewtonEvaluatorRtoRD;
 /**
  * Newton iterator for use when both function and derivative can be evaluated.
+ * To solve `f(x) = 0`, the Newton iteration is `x_{n+1} = x_n - dx = x_n - f(x_n)/f'(x_n)`.
+ * To solve `f(x) = target` which is equivalent to solving  `g(x) = f(x) - target = 0`, the Newton iteration is
+ * `x_{n+1} = x_n - dx = x_n - g(x_n)/g'(x_n) = x_n - (f(x_n)-target)/f'(x_n)`.
  * @internal
  */
 class Newton1dUnbounded extends AbstractNewtonIterator {
     /**
-     * Constructor for 1D newton iteration with approximate derivatives.
-     * @param func function that returns both function and derivative.
+     * Constructor for 1D newton iteration with derivatives.
+     * @param func function that returns both function value and derivative.
      */
     constructor(func) {
         super();
         this._func = func;
         this.setTarget(0);
     }
-    /** Set the independent variable */
-    setX(x) { this._currentX = x; return true; }
-    /** Get the independent variable */
-    getX() { return this._currentX; }
-    /** Set the target function value */
-    setTarget(y) { this._target = y; }
-    /** move the current X by the just-computed step */
-    applyCurrentStep() { return this.setX(this._currentX - this._currentStep); }
+    /** Set the independent variable, i.e., x_n. */
+    setX(x) {
+        this._currentX = x;
+        return true;
+    }
+    /** Get the independent variable, i.e., x_n. */
+    getX() {
+        return this._currentX;
+    }
+    /** Set the target function value. */
+    setTarget(y) {
+        this._target = y;
+    }
+    /** Move the current X by the just-computed step, i.e., `x_n - dx`. */
+    applyCurrentStep() {
+        // console.log(this._currentX - this._currentStep); // print approximations for debug
+        return this.setX(this._currentX - this._currentStep);
+    }
     /** Compute the univariate newton step. */
     computeStep() {
         if (this._func.evaluate(this._currentX)) {
@@ -113,43 +128,56 @@ class Newton1dUnbounded extends AbstractNewtonIterator {
         }
         return false;
     }
-    /** Return the current step size as a relative number. */
+    /** Return the current step size as a relative number, i.e., `|dx / (1 + |x_n|)|`. */
     currentStepSize() {
         return Math.abs(this._currentStep / (1.0 + Math.abs(this._currentX)));
     }
 }
 exports.Newton1dUnbounded = Newton1dUnbounded;
-/** object to evaluate a newton function (without derivative).  The object must retain most-recent function value.
+/**
+ * Object to evaluate a newton function (without derivative). The object must retain most-recent function value.
  * @internal
  */
 class NewtonEvaluatorRtoR {
 }
 exports.NewtonEvaluatorRtoR = NewtonEvaluatorRtoR;
-/** Newton iteration for a univariate function, using approximate derivatives.
+/**
+ * Newton iteration for a univariate function, using approximate derivatives.
+ * To approximate the derivatives we use a small step `h`, i.e., `f'(x_n) = (f(x_n + h) - f(x_n)) / h`.
+ * Therefore, to solve `f(x) = 0`, the iteration is
+ * `x_{n+1} = x_n - dx = x_n - f(x_n)/f'(x_n) = x_n - f(x_n) * h / (f(x_n + h) - f(x_n))`.
  * @internal
  */
 class Newton1dUnboundedApproximateDerivative extends AbstractNewtonIterator {
     /**
      * Constructor for 1D newton iteration with approximate derivatives.
-     * @param func function that returns both function and derivative.
+     * @param func function that only returns function value (and not derivative).
      */
     constructor(func) {
         super();
         this._func = func;
         this.derivativeH = 1.0e-8;
     }
-    /** Set the x (independent, iterated) value */
-    setX(x) { this._currentX = x; return true; }
-    /** Get the independent variable */
-    getX() { return this._currentX; }
-    /** move the current X by the just-computed step */
-    applyCurrentStep() { return this.setX(this._currentX - this._currentStep); }
-    /** Univariate newton step computed with APPROXIMATE derivative. */
+    /** Set the independent variable, i.e., x_n. */
+    setX(x) {
+        this._currentX = x;
+        return true;
+    }
+    /** Get the independent variable, i.e., x_n. */
+    getX() {
+        return this._currentX;
+    }
+    /** Move the current X by the just-computed step, i.e., `x_n - dx`. */
+    applyCurrentStep() {
+        // console.log(this._currentX - this._currentStep); // print approximations for debug
+        return this.setX(this._currentX - this._currentStep);
+    }
+    /** Univariate newton step computed with approximate derivative. */
     computeStep() {
         if (this._func.evaluate(this._currentX)) {
-            const fA = this._func.currentF;
+            const fA = this._func.currentF; // f(x_n)
             if (this._func.evaluate(this._currentX + this.derivativeH)) {
-                const fB = this._func.currentF;
+                const fB = this._func.currentF; // f(x_n + h)
                 const dx = Geometry_1.Geometry.conditionalDivideFraction(fA, (fB - fA) / this.derivativeH);
                 if (dx !== undefined) {
                     this._currentStep = dx;
@@ -159,18 +187,19 @@ class Newton1dUnboundedApproximateDerivative extends AbstractNewtonIterator {
         }
         return false;
     }
-    /** Return the current step size as a relative number. */
+    /** Return the current step size as a relative number, i.e., `|dx / (1 + |x_n|)|`. */
     currentStepSize() {
         return Math.abs(this._currentStep / (1.0 + Math.abs(this._currentX)));
     }
 }
 exports.Newton1dUnboundedApproximateDerivative = Newton1dUnboundedApproximateDerivative;
-/** object to evaluate a 2-parameter newton function (with derivatives!!).
+/**
+ * Object to evaluate a 2-parameter newton function with derivatives.
  * @internal
  */
 class NewtonEvaluatorRRtoRRD {
     /**
-     * constructor.
+     * Constructor.
      * * This creates a currentF object to (repeatedly) receive function and derivatives.
      */
     constructor() {
@@ -180,36 +209,61 @@ class NewtonEvaluatorRRtoRRD {
 exports.NewtonEvaluatorRRtoRRD = NewtonEvaluatorRRtoRRD;
 /**
  * Implement evaluation steps for newton iteration in 2 dimensions, using caller supplied NewtonEvaluatorRRtoRRD object.
+ * * Suppose we want to find the roots of `F(u,v) := (x(u,v), y(u,v))`. Writing `X := (u,v)` and `F(X)` as column vectors,
+ *  the 2D Newton's iteration to find a root of `F` is given by:
+ * `X_{n+1} = X_n - dX = X_n - JInv(X_n)F(X_n)`, where `JInv` is the inverse of the Jacobian matrix `J`, and `J` is
+ * defined as:
+ *
+ * `[dx/du   dx/dv]`
+ *
+ * `[dy/du   dy/dv]`
  * @internal
  */
 class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {
+    /**
+     * Constructor for 2D newton iteration with derivatives.
+     * @param func function that returns both function value and derivative.
+     */
     constructor(func) {
         super();
         this._func = func;
         this._currentStep = Point2dVector2d_1.Vector2d.createZero();
         this._currentUV = Point2dVector2d_1.Point2d.createZero();
     }
-    /** Set the current uv coordinates for current iteration */
-    setUV(x, y) { this._currentUV.set(x, y); return true; }
-    /** Get the current u coordinate */
-    getU() { return this._currentUV.x; }
-    /** Get the current v coordinate */
-    getV() { return this._currentUV.y; }
-    /** Move the currentUV coordinate by currentStep. */
-    applyCurrentStep() { return this.setUV(this._currentUV.x - this._currentStep.x, this._currentUV.y - this._currentStep.y); }
-    /** Evaluate the functions and derivatives at this._currentUV
-     * Invert the jacobian and compute the this._currentStep.
+    /** Set the current uv parameters, i.e., `X_n = (u_n, v_n)`. */
+    setUV(u, v) {
+        this._currentUV.set(u, v);
+        return true;
+    }
+    /** Get the current u parameter of X_n, i.e., u_n. */
+    getU() {
+        return this._currentUV.x;
+    }
+    /** Get the current v parameter of X_n, i.e., v_n. */
+    getV() {
+        return this._currentUV.y;
+    }
+    /** Update the current uv parameter by currentStep, i.e., compute `X_{n+1} := X_n - dX = (u_n - du, v_n - dv)`. */
+    applyCurrentStep() {
+        // print approximations for debug
+        // console.log("(" + (this._currentUV.x - this._currentStep.x) + "," + (this._currentUV.y - this._currentStep.y) + ")");
+        return this.setUV(this._currentUV.x - this._currentStep.x, this._currentUV.y - this._currentStep.y);
+    }
+    /**
+     * Evaluate the functions and derivatives at `X_n = (u_n, v_n)`, and solve the Jacobian matrix equation to
+     * compute `dX = (du, dv)`.
      */
     computeStep() {
         if (this._func.evaluate(this._currentUV.x, this._currentUV.y)) {
             const fA = this._func.currentF;
-            if (Polynomials_1.SmallSystem.linearSystem2d(fA.vectorU.x, fA.vectorV.x, fA.vectorU.y, fA.vectorV.y, fA.origin.x, fA.origin.y, this._currentStep))
+            if ( // Given X_{n+1} = X_n - dX = X_n - JInv(X_n) F(X_n), we solve J(X_n) dX = F(X_n) for dX:
+            Polynomials_1.SmallSystem.linearSystem2d(fA.vectorU.x, fA.vectorV.x, fA.vectorU.y, fA.vectorV.y, fA.origin.x, fA.origin.y, this._currentStep))
                 return true;
         }
         return false;
     }
     /**
-     * Return the largest relative step of the x,y, components of the current step.
+     * Return the current relative step size, i.e., the larger absolute component of `dX / (1 + |X_n|)`
      */
     currentStepSize() {
         return Geometry_1.Geometry.maxAbsXY(this._currentStep.x / (1.0 + Math.abs(this._currentUV.x)), this._currentStep.y / (1.0 + Math.abs(this._currentUV.y)));
@@ -217,15 +271,18 @@ class Newton2dUnboundedWithDerivative extends AbstractNewtonIterator {
 }
 exports.Newton2dUnboundedWithDerivative = Newton2dUnboundedWithDerivative;
 /**
- * SimpleNewton has static methods for newton methods with evaluated functions presented as immediate arguments (not function object)
+ * SimpleNewton has static methods for newton methods with evaluated functions presented as immediate arguments
+ * (not function object).
  * @internal
  */
 class SimpleNewton {
-    /** Run a one-dimensional newton iteration with separate functions for function and derivative.
-     * * completion is at 2 (TWO) successive passes at (absoluteTolerance + relTol * abs (x)), where relTol is chosen internally.
-     * * absoluteTolerance is usually aggressively tight -- should come into play only for x near zero.
-     * * The relTol is fluffy (for instance around 1e-11) but in properly converging cases the extra pass after first success
-     *    normally moves to full machine precision.
+    /**
+     * Run a one-dimensional newton iteration with separate functions for function and derivative.
+     * * Completion is at 2 (TWO) successive passes at `absoluteTolerance + relTol * abs(x)`, where relTol is
+     * chosen internally.
+     * * `absoluteTolerance` is usually aggressively tight -- should come into play only for x near zero.
+     * * The `relTol` is fluffy (for instance around 1e-11) but in properly converging cases the extra pass after
+     * first success normally moves to full machine precision.
      * * This is an open-loop newton -- it just runs, and returns undefined if anything bad happens.
      */
     static runNewton1D(x, func, derivative, absoluteTolerance = Geometry_1.Geometry.smallFloatingPoint) {
@@ -240,10 +297,11 @@ class SimpleNewton {
                 if (dx === undefined)
                     return undefined;
                 x -= dx;
+                // console.log(x); // print approximations for debug
                 tolerance = absoluteTolerance + Math.abs(x) * relTol;
                 if (Math.abs(dx) < tolerance) {
                     numConverged++;
-                    if (dx === 0.0 || numConverged > 1) // bypass convergence count on true 0 dx !
+                    if (dx === 0.0 || numConverged > 1) // bypass convergence count on true 0 dx
                         return x;
                 }
                 else {

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

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

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

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

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

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

package/lib/cjs/numerics/PascalCoefficients.js

@@ -41,13 +41,11 @@ class PascalCoefficients {
         }
         return allRows[row];
     }
-    /** Return an array with Bezier weighted pascal coefficients
-     * @param row row index in the pascal triangle.  (`row+1` entries)
+    /**
+     * Return an array with Bezier weighted pascal coefficients
+     * @param order output size. The index of the row of the Pascal triangle supplying weights is `order - 1`.
      * @param u parameter value
-     * @param result optional destination array.
-     * @note if the destination array is undefined or too small, a new Float64Array is allocated.
-     * @note if the destination array is larger than needed, its leading `row+1` values are filled,
-     *     and the array is returned.
+     * @param result optional destination array of length `order`. If the destination array is too small, a new Float64Array is allocated.
      */
     static getBezierBasisValues(order, u, result) {
         const row = order - 1;
@@ -69,15 +67,15 @@ class PascalCoefficients {
         }
         return result;
     }
-    /** Return an array with derivatives of Bezier weighted pascal coefficients
-     * @param row row index in the pascal triangle.  (`row+1` entries)
+    /**
+     * Return an array with derivatives of Bezier weighted pascal coefficients
+     * @param order output size. The index of the row of the Pascal triangle supplying weights is `order - 2`.
      * @param u parameter value
-     * @param result optional destination array.
-     * @note if the destination array is undefined or too small, a new Float64Array is allocated.
-     * @note if the destination array is larger than needed, its leading `row+1` values are filled,
-     *     and the array is returned.
+     * @param result optional destination array of length `order`. If the destination array is too small, a new Float64Array is allocated.
      */
     static getBezierBasisDerivatives(order, u, result) {
+        if (result === undefined || result.length < order)
+            result = new Float64Array(order);
         result = this.getBezierBasisValues(order - 1, u, result);
         // derivative is df/du = (order-1 ) * sum ( q[i+1] - q[i])   summed on 0 <= i < order - 1.\
         // evaluate lower order basis, overwrite in place from right to left

package/lib/cjs/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  /** Return an array with Bezier weighted pascal coefficients\r\n   * @param row row index in the pascal triangle.  (`row+1` entries)\r\n   * @param u parameter value\r\n   * @param result optional destination array.\r\n   * @note if the destination array is undefined or too small, a new Float64Array is allocated.\r\n   * @note if the destination array is larger than needed, its leading `row+1` values are filled,\r\n   *     and the array is returned.\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  /** Return an array with derivatives of Bezier weighted pascal coefficients\r\n   * @param row row index in the pascal triangle.  (`row+1` entries)\r\n   * @param u parameter value\r\n   * @param result optional destination array.\r\n   * @note if the destination array is undefined or too small, a new Float64Array is allocated.\r\n   * @note if the destination array is larger than needed, its leading `row+1` values are filled,\r\n   *     and the array is returned.\r\n   */\r\n  public static getBezierBasisDerivatives(order: number, u: number, result?: Float64Array): Float64Array {\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":["/*---------------------------------------------------------------------------------------------\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"]}

package/lib/cjs/numerics/Polynomials.d.ts

@@ -486,7 +486,7 @@ export declare class SmallSystem {
     static ray3dXYZUVWClosestApproachUnbounded(ax: number, ay: number, az: number, au: number, av: number, aw: number, bx: number, by: number, bz: number, bu: number, bv: number, bw: number, result: Vector2d): boolean;
     /**
      * Solve the pair of linear equations
-     * * `ux * x + vx + y = cx`
+     * * `ux * x + vx * y = cx`
      * * `uy * x + vy * y = cy`
      * @param ux xx coefficient
      * @param vx xy coefficient
@@ -494,7 +494,7 @@ export declare class SmallSystem {
      * @param vy yy coefficient
      * @param cx x right hand side
      * @param cy y right hand side
-     * @param result (x,y) solution.  (MUST be preallocated by caller)
+     * @param result (x,y) solution (MUST be preallocated by caller)
      */
     static linearSystem2d(ux: number, vx: number, // first row of matrix
     uy: number, vy: number, // second row of matrix