@itwin/core-geometry 3.3.0-dev.9 → 3.4.0-dev.10

package/lib/esm/curve/spiral/TransitionSpiral3d.js

@@ -11,6 +11,7 @@ import { Transform } from "../../geometry3d/Transform";
 import { Geometry } from "../../Geometry";
 import { CurveOffsetXYHandler } from "../internalContexts/CurveOffsetXYHandler";
 import { OffsetOptions } from "../internalContexts/PolygonOffsetContext";
+import { Range3d } from "../../geometry3d/Range";
 /**
  * TransitionSpiral3d is a base class for multiple variants of spirals.
  * * The menagerie of spiral types have 2 broad categories:
@@ -131,5 +132,21 @@ export class TransitionSpiral3d extends CurvePrimitive {
         this.emitStrokableParts(handler, options.strokeOptions);
         return handler.claimResult();
     }
+    /** extend the range by the strokes of the spiral */
+    extendRange(rangeToExtend, transform) {
+        const myRange = this.rangeBetweenFractions(0.0, 1.0, transform);
+        rangeToExtend.extendRange(myRange);
+    }
+    /** return the range of spiral between fractions of the activeStrokes.
+     * * Use activeStrokes point count times interval factor for initial evaluation count, but do at least 5
+     */
+    rangeBetweenFractions(fractionA, fractionB, transform) {
+        const strokes = this.activeStrokes;
+        if (undefined === strokes)
+            return Range3d.createNull();
+        let count = Math.ceil(strokes.numPoints() * Math.abs(fractionB - fractionA));
+        count = Geometry.clamp(5, count, 30);
+        return this.rangeBetweenFractionsByCount(fractionA, fractionB, count, transform, 0.5);
+    }
 }
 //# sourceMappingURL=TransitionSpiral3d.js.map

package/lib/esm/curve/spiral/TransitionSpiral3d.js.map

@@ -1 +1 @@
-{"version":3,"file":"TransitionSpiral3d.js","sourceRoot":"","sources":["../../../../src/curve/spiral/TransitionSpiral3d.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 Curve\r\n */\r\n\r\nimport { CurvePrimitive } from \"../CurvePrimitive\";\r\nimport { Matrix3d } from \"../../geometry3d/Matrix3d\";\r\nimport { Segment1d } from \"../../geometry3d/Segment1d\";\r\nimport { Transform } from \"../../geometry3d/Transform\";\r\nimport { TransitionConditionalProperties } from \"./TransitionConditionalProperties\";\r\nimport { Geometry } from \"../../Geometry\";\r\nimport { LineString3d } from \"../LineString3d\";\r\nimport { CurveOffsetXYHandler } from \"../internalContexts/CurveOffsetXYHandler\";\r\nimport { OffsetOptions } from \"../internalContexts/PolygonOffsetContext\";\r\n/**\r\n * This is the set of valid type names for \"integrated\" spirals\r\n * * Behavior is expressed by a `NormalizedTransition` snap function.\r\n * * The snap function varies smoothly from f(0)=0 to f(1)=1\r\n * * The various snap functions are:\r\n *   * clothoid: linear\r\n *   * biquadratic: 2 quadratics pieced together, joining with 1st derivative continuity at f(0.) = 0.5, with zero slope f'(0)=0 and f'(1)= 0\r\n *   * bloss: A single cubic with zero slope at 0 and 1\r\n *   * cosine: half of a cosine wave, centered around 0.5\r\n *   * sine: full period of a sine wave added to the line f(u)=u\r\n * *\r\n * @public\r\n */\r\nexport type IntegratedSpiralTypeName = \"clothoid\" | \"bloss\" | \"biquadratic\" | \"cosine\" | \"sine\";\r\n\r\n/**\r\n * This is the set of valid type names for \"direct\" spirals.\r\n * \"Direct\" spirals can evaluate fractionToPoint by direct equations, i.e. not requiring the numeric integrations in \"Integrated\" spiral types.\r\n * @public\r\n */\r\nexport type DirectSpiralTypeName =\r\n   \"JapaneseCubic\"  // 1 term from each of the X,Y clothoid series expansions:  y = x^3 / (6RL)\r\n  | \"Arema\"       // 2 terms from each of the X,Y clothoid series expansions.  Identical to ChineseCubic!\r\n  | \"ChineseCubic\"  // Identical to Arema!\r\n  | \"HalfCosine\"  // high continuity cosine variation from quadratic.\r\n  | \"AustralianRailCorp\" // cubic with high accuracy distance series\r\n  | \"WesternAustralian\"  // simple cubic -- 2 terms of x series, 1 term of y series.\r\n  | \"Czech\"  // simple cubic with two term distance approximation\r\n  | \"MXCubicAlongArc\"  // x obtained from fractional distance via 2-terms from series, y = x^3/ (6RL)\r\n  | \"Polish\"\r\n  | \"Italian\"\r\n  ;\r\n\r\n/**\r\n * TransitionSpiral3d is a base class for multiple variants of spirals.\r\n * * The menagerie of spiral types have 2 broad categories:\r\n *   * IntegratedSpiral3d -- a spiral whose direct function for curvature versus distance must be integrated to determine x,y\r\n *     * The IntegratedSpiral3d types are enumerated in `IntegratedSpiralTypes`\r\n *   * DirectSpiral3d -- a spiral implemented with direct calculation of x,y from fractional position along the spiral.\r\n *     * The direct spiral types are enumerated in the `DirectSpiralType`\r\n * * The method set for CurvePrimitive support includes a `handleTransitionSpiral(g: TransitionSpiral3d)` which receives all the spiral types.\r\n * * The spiral class may impose expectations that its inflection is at the origin, with tangent along the x axis.\r\n *   * This is generally necessary for direct spirals.\r\n *   * This is not necessary for integrated spirals.\r\n * @public\r\n */\r\nexport abstract class TransitionSpiral3d extends CurvePrimitive {\r\n  /** string name of spiral type */\r\n  protected _spiralType: string;\r\n  /** Original defining properties. */\r\n  protected _designProperties: TransitionConditionalProperties | undefined;\r\n\r\n  /** Fractional interval for the \"active\" part of a containing spiral.\r\n   * (The radius, angle, and length conditions define a complete spiral, and some portion of it is \"active\")\r\n   */\r\n  protected _activeFractionInterval: Segment1d;\r\n  /** Return (reference to) the active portion of the reference spiral. */\r\n  public get activeFractionInterval(): Segment1d { return this._activeFractionInterval; }\r\n  /** strokes in the active portion */\r\n  public abstract get activeStrokes(): LineString3d;\r\n  /** Placement transform */\r\n  protected _localToWorld: Transform;\r\n  /** (reference to) placement transform. */\r\n  public get localToWorld(): Transform { return this._localToWorld; }\r\n\r\n  protected constructor(spiralType: string | undefined, localToWorld: Transform, activeFractionInterval: Segment1d | undefined, designProperties: TransitionConditionalProperties | undefined) {\r\n    super();\r\n    this._spiralType = spiralType ? spiralType : \"unknownSpiralType\";\r\n    this._designProperties = designProperties;\r\n    this._localToWorld = localToWorld;\r\n    this._activeFractionInterval = activeFractionInterval ? activeFractionInterval : Segment1d.create(0, 1);\r\n  }\r\n\r\n  public get spiralType(): string { return this._spiralType; }\r\n  /** Return 1/r with convention that if true zero is given as radius it represents infinite radius (0 curvature, straight line) */\r\n  public static radiusToCurvature(radius: number): number { return (radius === 0.0) ? 0.0 : 1.0 / radius; }\r\n\r\n  /** Return 1/k with convention that if near-zero is given as curvature, its infinite radius is returned as 0 */\r\n  public static curvatureToRadius(curvature: number): number {\r\n    if (Math.abs(curvature) < Geometry.smallAngleRadians)\r\n      return 0.0;\r\n    return 1.0 / curvature;\r\n  }\r\n\r\n  /** Return a deep clone. */\r\n  public abstract override clone(): TransitionSpiral3d;\r\n\r\n  /** Recompute strokes */\r\n  public abstract refreshComputedProperties(): void;\r\n\r\n  /** Return (if possible) a spiral which is a portion of this curve. */\r\n  public override clonePartialCurve(fractionA: number, fractionB: number): TransitionSpiral3d {\r\n    const spiralB = this.clone();\r\n    const globalFractionA = this._activeFractionInterval.fractionToPoint(fractionA);\r\n    const globalFractionB = this._activeFractionInterval.fractionToPoint(fractionB);\r\n    spiralB._activeFractionInterval.set(globalFractionA, globalFractionB);\r\n    spiralB.refreshComputedProperties();\r\n    return spiralB;\r\n  }\r\n\r\n  /** Clone with a transform applied  */\r\n  public override cloneTransformed(transform: Transform): TransitionSpiral3d {\r\n    const result = this.clone();\r\n    result.tryTransformInPlace(transform); // ok, we're confident it will always work.\r\n    return result;\r\n  }\r\n\r\n  /** Return the average of the start and end curvatures. */\r\n  public static averageCurvature(radiusLimits: Segment1d): number {\r\n    return 0.5 * (TransitionSpiral3d.radiusToCurvature(radiusLimits.x0) + TransitionSpiral3d.radiusToCurvature(radiusLimits.x1));\r\n  }\r\n  /**\r\n   * Given two radii (or zeros for 0 curvature) return the average curvature\r\n   * @param r0 start radius, or 0 for line\r\n   * @param r1 end radius, or 0 for line\r\n   */\r\n  public static averageCurvatureR0R1(r0: number, r1: number): number {\r\n    return 0.5 * (TransitionSpiral3d.radiusToCurvature(r0) + TransitionSpiral3d.radiusToCurvature(r1));\r\n  }\r\n  /**\r\n   * Given two radii (or zeros for 0 curvature) return the average curvature\r\n   * @param r0 start radius, or 0 for line\r\n   * @param r1 end radius, or 0 for line\r\n   */\r\n  public static interpolateCurvatureR0R1(r0: number, fraction: number, r1: number): number {\r\n    return Geometry.interpolate(TransitionSpiral3d.radiusToCurvature(r0), fraction, TransitionSpiral3d.radiusToCurvature(r1));\r\n  }\r\n\r\n  /** Return the arc length of a transition spiral with given sweep and radius pair. */\r\n  public static radiusRadiusSweepRadiansToArcLength(radius0: number, radius1: number, sweepRadians: number): number {\r\n    return Math.abs(sweepRadians / TransitionSpiral3d.averageCurvatureR0R1(radius0, radius1));\r\n  }\r\n\r\n  /** Return the turn angle for spiral of given length between two radii */\r\n  public static radiusRadiusLengthToSweepRadians(radius0: number, radius1: number, arcLength: number): number {\r\n    return TransitionSpiral3d.averageCurvatureR0R1(radius0, radius1) * arcLength;\r\n  }\r\n\r\n  /** Return the end radius for spiral of given start radius, length, and turn angle. */\r\n  public static radius0LengthSweepRadiansToRadius1(radius0: number, arcLength: number, sweepRadians: number) {\r\n    return TransitionSpiral3d.curvatureToRadius((2.0 * sweepRadians / arcLength) - TransitionSpiral3d.radiusToCurvature(radius0));\r\n  }\r\n  /** Return the start radius for spiral of given end radius, length, and turn angle. */\r\n  public static radius1LengthSweepRadiansToRadius0(radius1: number, arcLength: number, sweepRadians: number) {\r\n    return TransitionSpiral3d.curvatureToRadius((2.0 * sweepRadians / arcLength) - TransitionSpiral3d.radiusToCurvature(radius1));\r\n  }\r\n  /** Return the original defining properties (if any) saved by the constructor. */\r\n  public get designProperties(): TransitionConditionalProperties | undefined { return this._designProperties; }\r\n  /**\r\n   * * If transformA is rigid with uniform scale, apply the rigid part of transformA to the localToWorld transform and return the scale and rigid separation.\r\n   * * If not rigid, do nothing and return undefined.\r\n   * * Also apply the scale factor to the designProperties.\r\n   * @param transformA\r\n   */\r\n  protected applyRigidPartOfTransform(transformA: Transform): { rigidAxes: Matrix3d, scale: number } | undefined {\r\n    const rigidData = transformA.matrix.factorRigidWithSignedScale();\r\n    if (rigidData !== undefined) {\r\n      // [sQ a][R b] = [sQ*R sQb+a]\r\n      // but we save it as [Q*R sQb+a] with spiral data scaled by s.\r\n      const transformC0 = transformA.multiplyTransformTransform(this.localToWorld);\r\n      // BUT pull the scale part out of the matrix ...\r\n      const matrixC = rigidData.rigidAxes.multiplyMatrixMatrix(this.localToWorld.matrix);\r\n      this._localToWorld = Transform.createOriginAndMatrix(transformC0.origin, matrixC);\r\n      if (this.designProperties)\r\n        this.designProperties.applyScaleFactor(rigidData.scale);\r\n\r\n      return rigidData;\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  /**\r\n   * Construct an offset of the instance curve as viewed in the xy-plane (ignoring z).\r\n   * * No attempt is made to join the offsets of smaller constituent primitives. To construct a fully joined offset\r\n   *   for an aggregate instance (e.g., LineString3d, CurveChainWithDistanceIndex), use RegionOps.constructCurveXYOffset() instead.\r\n   * @param offsetDistanceOrOptions offset distance (positive to left of the instance curve), or options object\r\n   */\r\n  public override constructOffsetXY(offsetDistanceOrOptions: number | OffsetOptions): CurvePrimitive | CurvePrimitive[] | undefined {\r\n    const options = OffsetOptions.create(offsetDistanceOrOptions);\r\n    const handler = new CurveOffsetXYHandler(this, options.leftOffsetDistance);\r\n    this.emitStrokableParts(handler, options.strokeOptions);\r\n    return handler.claimResult();\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"TransitionSpiral3d.js","sourceRoot":"","sources":["../../../../src/curve/spiral/TransitionSpiral3d.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 Curve\r\n */\r\n\r\nimport { CurvePrimitive } from \"../CurvePrimitive\";\r\nimport { Matrix3d } from \"../../geometry3d/Matrix3d\";\r\nimport { Segment1d } from \"../../geometry3d/Segment1d\";\r\nimport { Transform } from \"../../geometry3d/Transform\";\r\nimport { TransitionConditionalProperties } from \"./TransitionConditionalProperties\";\r\nimport { Geometry } from \"../../Geometry\";\r\nimport { LineString3d } from \"../LineString3d\";\r\nimport { CurveOffsetXYHandler } from \"../internalContexts/CurveOffsetXYHandler\";\r\nimport { OffsetOptions } from \"../internalContexts/PolygonOffsetContext\";\r\nimport { Range3d } from \"../../geometry3d/Range\";\r\n/**\r\n * This is the set of valid type names for \"integrated\" spirals\r\n * * Behavior is expressed by a `NormalizedTransition` snap function.\r\n * * The snap function varies smoothly from f(0)=0 to f(1)=1\r\n * * The various snap functions are:\r\n *   * clothoid: linear\r\n *   * biquadratic: 2 quadratics pieced together, joining with 1st derivative continuity at f(0.) = 0.5, with zero slope f'(0)=0 and f'(1)= 0\r\n *   * bloss: A single cubic with zero slope at 0 and 1\r\n *   * cosine: half of a cosine wave, centered around 0.5\r\n *   * sine: full period of a sine wave added to the line f(u)=u\r\n * *\r\n * @public\r\n */\r\nexport type IntegratedSpiralTypeName = \"clothoid\" | \"bloss\" | \"biquadratic\" | \"cosine\" | \"sine\";\r\n\r\n/**\r\n * This is the set of valid type names for \"direct\" spirals.\r\n * \"Direct\" spirals can evaluate fractionToPoint by direct equations, i.e. not requiring the numeric integrations in \"Integrated\" spiral types.\r\n * @public\r\n */\r\nexport type DirectSpiralTypeName =\r\n   \"JapaneseCubic\"  // 1 term from each of the X,Y clothoid series expansions:  y = x^3 / (6RL)\r\n  | \"Arema\"       // 2 terms from each of the X,Y clothoid series expansions.  Identical to ChineseCubic!\r\n  | \"ChineseCubic\"  // Identical to Arema!\r\n  | \"HalfCosine\"  // high continuity cosine variation from quadratic.\r\n  | \"AustralianRailCorp\" // cubic with high accuracy distance series\r\n  | \"WesternAustralian\"  // simple cubic -- 2 terms of x series, 1 term of y series.\r\n  | \"Czech\"  // simple cubic with two term distance approximation\r\n  | \"MXCubicAlongArc\"  // x obtained from fractional distance via 2-terms from series, y = x^3/ (6RL)\r\n  | \"Polish\"\r\n  | \"Italian\"\r\n  ;\r\n\r\n/**\r\n * TransitionSpiral3d is a base class for multiple variants of spirals.\r\n * * The menagerie of spiral types have 2 broad categories:\r\n *   * IntegratedSpiral3d -- a spiral whose direct function for curvature versus distance must be integrated to determine x,y\r\n *     * The IntegratedSpiral3d types are enumerated in `IntegratedSpiralTypes`\r\n *   * DirectSpiral3d -- a spiral implemented with direct calculation of x,y from fractional position along the spiral.\r\n *     * The direct spiral types are enumerated in the `DirectSpiralType`\r\n * * The method set for CurvePrimitive support includes a `handleTransitionSpiral(g: TransitionSpiral3d)` which receives all the spiral types.\r\n * * The spiral class may impose expectations that its inflection is at the origin, with tangent along the x axis.\r\n *   * This is generally necessary for direct spirals.\r\n *   * This is not necessary for integrated spirals.\r\n * @public\r\n */\r\nexport abstract class TransitionSpiral3d extends CurvePrimitive {\r\n  /** string name of spiral type */\r\n  protected _spiralType: string;\r\n  /** Original defining properties. */\r\n  protected _designProperties: TransitionConditionalProperties | undefined;\r\n\r\n  /** Fractional interval for the \"active\" part of a containing spiral.\r\n   * (The radius, angle, and length conditions define a complete spiral, and some portion of it is \"active\")\r\n   */\r\n  protected _activeFractionInterval: Segment1d;\r\n  /** Return (reference to) the active portion of the reference spiral. */\r\n  public get activeFractionInterval(): Segment1d { return this._activeFractionInterval; }\r\n  /** strokes in the active portion */\r\n  public abstract get activeStrokes(): LineString3d;\r\n  /** Placement transform */\r\n  protected _localToWorld: Transform;\r\n  /** (reference to) placement transform. */\r\n  public get localToWorld(): Transform { return this._localToWorld; }\r\n\r\n  protected constructor(spiralType: string | undefined, localToWorld: Transform, activeFractionInterval: Segment1d | undefined, designProperties: TransitionConditionalProperties | undefined) {\r\n    super();\r\n    this._spiralType = spiralType ? spiralType : \"unknownSpiralType\";\r\n    this._designProperties = designProperties;\r\n    this._localToWorld = localToWorld;\r\n    this._activeFractionInterval = activeFractionInterval ? activeFractionInterval : Segment1d.create(0, 1);\r\n  }\r\n\r\n  public get spiralType(): string { return this._spiralType; }\r\n  /** Return 1/r with convention that if true zero is given as radius it represents infinite radius (0 curvature, straight line) */\r\n  public static radiusToCurvature(radius: number): number { return (radius === 0.0) ? 0.0 : 1.0 / radius; }\r\n\r\n  /** Return 1/k with convention that if near-zero is given as curvature, its infinite radius is returned as 0 */\r\n  public static curvatureToRadius(curvature: number): number {\r\n    if (Math.abs(curvature) < Geometry.smallAngleRadians)\r\n      return 0.0;\r\n    return 1.0 / curvature;\r\n  }\r\n\r\n  /** Return a deep clone. */\r\n  public abstract override clone(): TransitionSpiral3d;\r\n\r\n  /** Recompute strokes */\r\n  public abstract refreshComputedProperties(): void;\r\n\r\n  /** Return (if possible) a spiral which is a portion of this curve. */\r\n  public override clonePartialCurve(fractionA: number, fractionB: number): TransitionSpiral3d {\r\n    const spiralB = this.clone();\r\n    const globalFractionA = this._activeFractionInterval.fractionToPoint(fractionA);\r\n    const globalFractionB = this._activeFractionInterval.fractionToPoint(fractionB);\r\n    spiralB._activeFractionInterval.set(globalFractionA, globalFractionB);\r\n    spiralB.refreshComputedProperties();\r\n    return spiralB;\r\n  }\r\n\r\n  /** Clone with a transform applied  */\r\n  public override cloneTransformed(transform: Transform): TransitionSpiral3d {\r\n    const result = this.clone();\r\n    result.tryTransformInPlace(transform); // ok, we're confident it will always work.\r\n    return result;\r\n  }\r\n\r\n  /** Return the average of the start and end curvatures. */\r\n  public static averageCurvature(radiusLimits: Segment1d): number {\r\n    return 0.5 * (TransitionSpiral3d.radiusToCurvature(radiusLimits.x0) + TransitionSpiral3d.radiusToCurvature(radiusLimits.x1));\r\n  }\r\n  /**\r\n   * Given two radii (or zeros for 0 curvature) return the average curvature\r\n   * @param r0 start radius, or 0 for line\r\n   * @param r1 end radius, or 0 for line\r\n   */\r\n  public static averageCurvatureR0R1(r0: number, r1: number): number {\r\n    return 0.5 * (TransitionSpiral3d.radiusToCurvature(r0) + TransitionSpiral3d.radiusToCurvature(r1));\r\n  }\r\n  /**\r\n   * Given two radii (or zeros for 0 curvature) return the average curvature\r\n   * @param r0 start radius, or 0 for line\r\n   * @param r1 end radius, or 0 for line\r\n   */\r\n  public static interpolateCurvatureR0R1(r0: number, fraction: number, r1: number): number {\r\n    return Geometry.interpolate(TransitionSpiral3d.radiusToCurvature(r0), fraction, TransitionSpiral3d.radiusToCurvature(r1));\r\n  }\r\n\r\n  /** Return the arc length of a transition spiral with given sweep and radius pair. */\r\n  public static radiusRadiusSweepRadiansToArcLength(radius0: number, radius1: number, sweepRadians: number): number {\r\n    return Math.abs(sweepRadians / TransitionSpiral3d.averageCurvatureR0R1(radius0, radius1));\r\n  }\r\n\r\n  /** Return the turn angle for spiral of given length between two radii */\r\n  public static radiusRadiusLengthToSweepRadians(radius0: number, radius1: number, arcLength: number): number {\r\n    return TransitionSpiral3d.averageCurvatureR0R1(radius0, radius1) * arcLength;\r\n  }\r\n\r\n  /** Return the end radius for spiral of given start radius, length, and turn angle. */\r\n  public static radius0LengthSweepRadiansToRadius1(radius0: number, arcLength: number, sweepRadians: number) {\r\n    return TransitionSpiral3d.curvatureToRadius((2.0 * sweepRadians / arcLength) - TransitionSpiral3d.radiusToCurvature(radius0));\r\n  }\r\n  /** Return the start radius for spiral of given end radius, length, and turn angle. */\r\n  public static radius1LengthSweepRadiansToRadius0(radius1: number, arcLength: number, sweepRadians: number) {\r\n    return TransitionSpiral3d.curvatureToRadius((2.0 * sweepRadians / arcLength) - TransitionSpiral3d.radiusToCurvature(radius1));\r\n  }\r\n  /** Return the original defining properties (if any) saved by the constructor. */\r\n  public get designProperties(): TransitionConditionalProperties | undefined { return this._designProperties; }\r\n  /**\r\n   * * If transformA is rigid with uniform scale, apply the rigid part of transformA to the localToWorld transform and return the scale and rigid separation.\r\n   * * If not rigid, do nothing and return undefined.\r\n   * * Also apply the scale factor to the designProperties.\r\n   * @param transformA\r\n   */\r\n  protected applyRigidPartOfTransform(transformA: Transform): { rigidAxes: Matrix3d, scale: number } | undefined {\r\n    const rigidData = transformA.matrix.factorRigidWithSignedScale();\r\n    if (rigidData !== undefined) {\r\n      // [sQ a][R b] = [sQ*R sQb+a]\r\n      // but we save it as [Q*R sQb+a] with spiral data scaled by s.\r\n      const transformC0 = transformA.multiplyTransformTransform(this.localToWorld);\r\n      // BUT pull the scale part out of the matrix ...\r\n      const matrixC = rigidData.rigidAxes.multiplyMatrixMatrix(this.localToWorld.matrix);\r\n      this._localToWorld = Transform.createOriginAndMatrix(transformC0.origin, matrixC);\r\n      if (this.designProperties)\r\n        this.designProperties.applyScaleFactor(rigidData.scale);\r\n\r\n      return rigidData;\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  /**\r\n   * Construct an offset of the instance curve as viewed in the xy-plane (ignoring z).\r\n   * * No attempt is made to join the offsets of smaller constituent primitives. To construct a fully joined offset\r\n   *   for an aggregate instance (e.g., LineString3d, CurveChainWithDistanceIndex), use RegionOps.constructCurveXYOffset() instead.\r\n   * @param offsetDistanceOrOptions offset distance (positive to left of the instance curve), or options object\r\n   */\r\n  public override constructOffsetXY(offsetDistanceOrOptions: number | OffsetOptions): CurvePrimitive | CurvePrimitive[] | undefined {\r\n    const options = OffsetOptions.create(offsetDistanceOrOptions);\r\n    const handler = new CurveOffsetXYHandler(this, options.leftOffsetDistance);\r\n    this.emitStrokableParts(handler, options.strokeOptions);\r\n    return handler.claimResult();\r\n  }\r\n  /** extend the range by the strokes of the spiral */\r\n  public override extendRange(rangeToExtend: Range3d, transform?: Transform): void {\r\n    const myRange = this.rangeBetweenFractions (0.0, 1.0, transform);\r\n    rangeToExtend.extendRange (myRange);\r\n  }\r\n\r\n  /** return the range of spiral between fractions of the activeStrokes.\r\n   * * Use activeStrokes point count times interval factor for initial evaluation count, but do at least 5\r\n   */\r\n   public override rangeBetweenFractions(fractionA: number, fractionB: number, transform?: Transform): Range3d {\r\n    const strokes = this.activeStrokes;\r\n    if (undefined === strokes)\r\n      return Range3d.createNull ();\r\n    let count = Math.ceil (strokes.numPoints() * Math.abs (fractionB - fractionA));\r\n    count = Geometry.clamp (5, count, 30);\r\n    return this.rangeBetweenFractionsByCount (fractionA, fractionB, count, transform, 0.5);\r\n  }\r\n}\r\n"]}

package/lib/esm/geometry3d/GrowableBlockedArray.d.ts

@@ -16,13 +16,42 @@ export declare class GrowableBlockedArray {
      * * If viewing the array as a two dimensional array, this is the row size.
      */
     protected _blockSize: number;
-    constructor(blockSize: number, initialBlocks?: number);
+    /**
+     * multiplier used by ensureBlockCapacity to expand requested reallocation size
+     */
+    protected _growthFactor: number;
+    /**
+     * Construct an array whose contents are in blocked (row-major) order, possibly with extra capacity.
+     * * Total capacity is `this._data.length`
+     * * Actual in-use count is `this._inUse * this._blockSize`
+     * @param blockSize number of entries in each block, i.e., row size
+     * @param initialBlocks initial capacity in blocks (default 8)
+     * @param growthFactor used by ensureBlockCapacity to expand requested reallocation size (default 1.5)
+     */
+    constructor(blockSize: number, initialBlocks?: number, growthFactor?: number);
+    /** Copy data from source array. Does not reallocate or change active block count.
+     * @param source array to copy from
+     * @param sourceCount copy the first sourceCount blocks; all blocks if undefined
+     * @param destOffset copy to instance array starting at this block index; zero if undefined
+     * @return count and offset of blocks copied
+     */
+    protected copyData(source: Float64Array | number[], sourceCount?: number, destOffset?: number): {
+        count: number;
+        offset: number;
+    };
+    /**
+     * Make a copy of the (active) blocks in this array.
+     * (The clone does NOT get excess capacity)
+     */
+    clone(): GrowableBlockedArray;
+    /** computed property: length (in blocks, not doubles) */
+    get length(): number;
     /** computed property: length (in blocks, not doubles) */
     get numBlocks(): number;
     /** property: number of data values per block */
     get numPerBlock(): number;
     /**
-     * Return a single value indexed within a block
+     * Return a single value indexed within a block. Indices are unchecked.
      * @param blockIndex index of block to read
      * @param indexInBlock  offset within the block
      */
@@ -32,7 +61,7 @@ export declare class GrowableBlockedArray {
     /** Return the capacity in blocks (not doubles) */
     blockCapacity(): number;
     /** ensure capacity (in blocks, not doubles) */
-    ensureBlockCapacity(blockCapacity: number): void;
+    ensureBlockCapacity(blockCapacity: number, applyGrowthFactor?: boolean): void;
     /** Add a new block of data.
      * * If newData has fewer than numPerBlock entries, the remaining part of the new block is zeros.
      * * If newData has more entries, only the first numPerBlock are taken.

package/lib/esm/geometry3d/GrowableBlockedArray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GrowableBlockedArray.d.ts","sourceRoot":"","sources":["../../../src/geometry3d/GrowableBlockedArray.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;;;GAIG;AACH,qBAAa,oBAAoB;IAC/B,+CAA+C;IAC/C,SAAS,CAAC,KAAK,EAAE,YAAY,CAAC;IAC9B,6CAA6C;IAC7C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB;;OAEG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC;gBACV,SAAS,EAAE,MAAM,EAAE,aAAa,GAAE,MAAU;IAS/D,yDAAyD;IACzD,IAAW,SAAS,IAAI,MAAM,CAAwB;IACtD,gDAAgD;IAChD,IAAW,WAAW,IAAI,MAAM,CAA4B;IAC5D;;;;OAIG;IACI,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,MAAM;IAG3E,uEAAuE;IAChE,KAAK;IACZ,kDAAkD;IAC3C,aAAa;IAGpB,+CAA+C;IACxC,mBAAmB,CAAC,aAAa,EAAE,MAAM;IAShD;;;OAGG;IACI,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE;IAQjC;;;;;;OAMG;IACH,SAAS,CAAC,aAAa,IAAI,MAAM;IASjC,qCAAqC;IAC9B,QAAQ;IAIf,gFAAgF;IAChF,SAAS,CAAC,uBAAuB,CAAC,UAAU,EAAE,MAAM;IACpD,wHAAwH;IACjH,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKvF,oFAAoF;IAC7E,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM;IAGpE;;;;;OAKG;WACW,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAWxG,+EAA+E;IACxE,kBAAkB,CAAC,aAAa,GAAE,uBAAkE,GAAG,WAAW;IAezH,qFAAqF;IAC9E,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM;IAa9E,2HAA2H;IACpH,wBAAwB,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;CAYhH"}
+{"version":3,"file":"GrowableBlockedArray.d.ts","sourceRoot":"","sources":["../../../src/geometry3d/GrowableBlockedArray.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;;;GAIG;AACH,qBAAa,oBAAoB;IAC/B,+CAA+C;IAC/C,SAAS,CAAC,KAAK,EAAE,YAAY,CAAC;IAC9B,6CAA6C;IAC7C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB;;OAEG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC;IAC7B;;OAEG;IACH,SAAS,CAAC,aAAa,EAAE,MAAM,CAAC;IAEhC;;;;;;;OAOG;gBACgB,SAAS,EAAE,MAAM,EAAE,aAAa,GAAE,MAAU,EAAE,YAAY,CAAC,EAAE,MAAM;IAOtF;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC;IA2B/H;;;OAGG;IACI,KAAK,IAAI,oBAAoB;IAOpC,yDAAyD;IACzD,IAAW,MAAM,IAAI,MAAM,CAAwB;IACnD,yDAAyD;IACzD,IAAW,SAAS,IAAI,MAAM,CAAwB;IACtD,gDAAgD;IAChD,IAAW,WAAW,IAAI,MAAM,CAA4B;IAC5D;;;;OAIG;IACI,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,MAAM;IAG3E,uEAAuE;IAChE,KAAK;IACZ,kDAAkD;IAC3C,aAAa;IAGpB,+CAA+C;IACxC,mBAAmB,CAAC,aAAa,EAAE,MAAM,EAAE,iBAAiB,GAAE,OAAc;IASnF;;;OAGG;IACI,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE;IAQjC;;;;;;OAMG;IACH,SAAS,CAAC,aAAa,IAAI,MAAM;IASjC,qCAAqC;IAC9B,QAAQ;IAIf,gFAAgF;IAChF,SAAS,CAAC,uBAAuB,CAAC,UAAU,EAAE,MAAM;IACpD,wHAAwH;IACjH,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKvF,oFAAoF;IAC7E,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM;IAGpE;;;;;OAKG;WACW,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAWxG,+EAA+E;IACxE,kBAAkB,CAAC,aAAa,GAAE,uBAAkE,GAAG,WAAW;IAezH,qFAAqF;IAC9E,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM;IAa9E,2HAA2H;IACpH,wBAAwB,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;CAYhH"}

package/lib/esm/geometry3d/GrowableBlockedArray.js

@@ -11,21 +11,70 @@
  * @public
  */
 export class GrowableBlockedArray {
-    constructor(blockSize, initialBlocks = 8) {
-        /** array contents in blocked (row-major) order, possibly with extra capacity
-         * Total capacity is `this._data.length`
-         * Actual in-use count is `this._inUse * this._blockSize`
-         */
+    /**
+     * Construct an array whose contents are in blocked (row-major) order, possibly with extra capacity.
+     * * Total capacity is `this._data.length`
+     * * Actual in-use count is `this._inUse * this._blockSize`
+     * @param blockSize number of entries in each block, i.e., row size
+     * @param initialBlocks initial capacity in blocks (default 8)
+     * @param growthFactor used by ensureBlockCapacity to expand requested reallocation size (default 1.5)
+     */
+    constructor(blockSize, initialBlocks = 8, growthFactor) {
         this._data = new Float64Array(initialBlocks * blockSize);
         this._inUse = 0;
-        this._blockSize = blockSize;
+        this._blockSize = blockSize > 0 ? blockSize : 1;
+        this._growthFactor = (undefined !== growthFactor && growthFactor >= 1.0) ? growthFactor : 1.5;
+    }
+    /** Copy data from source array. Does not reallocate or change active block count.
+     * @param source array to copy from
+     * @param sourceCount copy the first sourceCount blocks; all blocks if undefined
+     * @param destOffset copy to instance array starting at this block index; zero if undefined
+     * @return count and offset of blocks copied
+     */
+    copyData(source, sourceCount, destOffset) {
+        // validate inputs and convert from blocks to entries
+        let myOffset = (undefined !== destOffset) ? destOffset * this.numPerBlock : 0;
+        if (myOffset < 0)
+            myOffset = 0;
+        if (myOffset >= this._data.length)
+            return { count: 0, offset: 0 };
+        let myCount = (undefined !== sourceCount) ? sourceCount * this.numPerBlock : source.length;
+        if (myCount > 0) {
+            if (myCount > source.length)
+                myCount = source.length;
+            if (myOffset + myCount > this._data.length)
+                myCount = this._data.length - myOffset;
+            if (myCount % this.numPerBlock !== 0)
+                myCount -= myCount % this.numPerBlock;
+        }
+        if (myCount <= 0)
+            return { count: 0, offset: 0 };
+        if (myCount === source.length)
+            this._data.set(source, myOffset);
+        else if (source instanceof Float64Array)
+            this._data.set(source.subarray(0, myCount), myOffset);
+        else
+            this._data.set(source.slice(0, myCount), myOffset);
+        return { count: myCount / this.numPerBlock, offset: myOffset / this.numPerBlock };
     }
+    /**
+     * Make a copy of the (active) blocks in this array.
+     * (The clone does NOT get excess capacity)
+     */
+    clone() {
+        const newBlocks = new GrowableBlockedArray(this.numPerBlock, this.numBlocks, this._growthFactor);
+        newBlocks.copyData(this._data, this.numBlocks);
+        newBlocks._inUse = this.numBlocks;
+        return newBlocks;
+    }
+    /** computed property: length (in blocks, not doubles) */
+    get length() { return this._inUse; }
     /** computed property: length (in blocks, not doubles) */
     get numBlocks() { return this._inUse; }
     /** property: number of data values per block */
     get numPerBlock() { return this._blockSize; }
     /**
-     * Return a single value indexed within a block
+     * Return a single value indexed within a block. Indices are unchecked.
      * @param blockIndex index of block to read
      * @param indexInBlock  offset within the block
      */
@@ -39,13 +88,13 @@ export class GrowableBlockedArray {
         return this._data.length / this._blockSize;
     }
     /** ensure capacity (in blocks, not doubles) */
-    ensureBlockCapacity(blockCapacity) {
+    ensureBlockCapacity(blockCapacity, applyGrowthFactor = true) {
         if (blockCapacity > this.blockCapacity()) {
-            const newData = new Float64Array(blockCapacity * this._blockSize);
-            for (let i = 0; i < this._data.length; i++) {
-                newData[i] = this._data[i];
-            }
-            this._data = newData;
+            if (applyGrowthFactor)
+                blockCapacity *= this._growthFactor;
+            const prevData = this._data;
+            this._data = new Float64Array(blockCapacity * this._blockSize);
+            this.copyData(prevData, this._inUse);
         }
     }
     /** Add a new block of data.
@@ -70,7 +119,7 @@ export class GrowableBlockedArray {
     newBlockIndex() {
         const index = this._blockSize * this._inUse;
         if ((index + 1) > this._data.length)
-            this.ensureBlockCapacity(1 + 2 * this._inUse);
+            this.ensureBlockCapacity(1 + this._inUse);
         this._inUse++;
         for (let i = index; i < index + this._blockSize; i++)
             this._data[i] = 0.0;

package/lib/esm/geometry3d/GrowableBlockedArray.js.map

@@ -1 +1 @@
-{"version":3,"file":"GrowableBlockedArray.js","sourceRoot":"","sources":["../../../src/geometry3d/GrowableBlockedArray.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/** @packageDocumentation\r\n * @module ArraysAndInterfaces\r\n */\r\n\r\nimport { BlockComparisonFunction } from \"./GrowableFloat64Array\";\r\n\r\n/**\r\n * Array of contiguous doubles, indexed by block number and index within block.\r\n * * This is essentially a rectangular matrix (two dimensional array), with each block being a row of the matrix.\r\n * @public\r\n */\r\nexport class GrowableBlockedArray {\r\n  /** underlying contiguous, oversized buffer. */\r\n  protected _data: Float64Array;\r\n  /** Number of blocks (matrix rows) in use. */\r\n  protected _inUse: number;\r\n  /** number of numbers per block in the array.\r\n   * * If viewing the array as a two dimensional array, this is the row size.\r\n   */\r\n  protected _blockSize: number;  // positive integer !!!\r\n  public constructor(blockSize: number, initialBlocks: number = 8) {\r\n    /** array contents in blocked (row-major) order, possibly with extra capacity\r\n     * Total capacity is `this._data.length`\r\n     * Actual in-use count is `this._inUse * this._blockSize`\r\n     */\r\n    this._data = new Float64Array(initialBlocks * blockSize);\r\n    this._inUse = 0;\r\n    this._blockSize = blockSize;\r\n  }\r\n  /** computed property: length (in blocks, not doubles) */\r\n  public get numBlocks(): number { return this._inUse; }\r\n  /** property: number of data values per block */\r\n  public get numPerBlock(): number { return this._blockSize; }\r\n  /**\r\n   * Return a single value indexed within a block\r\n   * @param blockIndex index of block to read\r\n   * @param indexInBlock  offset within the block\r\n   */\r\n  public getWithinBlock(blockIndex: number, indexWithinBlock: number): number {\r\n    return this._data[blockIndex * this._blockSize + indexWithinBlock];\r\n  }\r\n  /** clear the block count to zero, but maintain the allocated memory */\r\n  public clear() { this._inUse = 0; }\r\n  /** Return the capacity in blocks (not doubles) */\r\n  public blockCapacity() {\r\n    return this._data.length / this._blockSize;\r\n  }\r\n  /** ensure capacity (in blocks, not doubles) */\r\n  public ensureBlockCapacity(blockCapacity: number) {\r\n    if (blockCapacity > this.blockCapacity()) {\r\n      const newData = new Float64Array(blockCapacity * this._blockSize);\r\n      for (let i = 0; i < this._data.length; i++) {\r\n        newData[i] = this._data[i];\r\n      }\r\n      this._data = newData;\r\n    }\r\n  }\r\n  /** Add a new block of data.\r\n   * * If newData has fewer than numPerBlock entries, the remaining part of the new block is zeros.\r\n   * * If newData has more entries, only the first numPerBlock are taken.\r\n   */\r\n  public addBlock(newData: number[]) {\r\n    const k0 = this.newBlockIndex();\r\n    let numValue = newData.length;\r\n    if (numValue > this._blockSize)\r\n      numValue = this._blockSize;\r\n    for (let i = 0; i < numValue; i++)\r\n      this._data[k0 + i] = newData[i];\r\n  }\r\n  /**\r\n   * Return the starting index of a block of (zero-initialized) doubles at the end.\r\n   *\r\n   * * this.data is reallocated if needed to include the new block.\r\n   * * The inUse count is incremented to include the new block.\r\n   * * The returned block is an index to the Float64Array (not a block index)\r\n   */\r\n  protected newBlockIndex(): number {\r\n    const index = this._blockSize * this._inUse;\r\n    if ((index + 1) > this._data.length)\r\n      this.ensureBlockCapacity(1 + 2 * this._inUse);\r\n    this._inUse++;\r\n    for (let i = index; i < index + this._blockSize; i++)\r\n      this._data[i] = 0.0;\r\n    return index;\r\n  }\r\n  /** reduce the block count by one. */\r\n  public popBlock() {\r\n    if (this._inUse > 0)\r\n      this._inUse--;\r\n  }\r\n  /** convert a block index to the simple index to the underlying Float64Array. */\r\n  protected blockIndexToDoubleIndex(blockIndex: number) { return this._blockSize * blockIndex; }\r\n  /** Access a single double at offset within a block, with index checking and return undefined if indexing is invalid. */\r\n  public checkedComponent(blockIndex: number, componentIndex: number): number | undefined {\r\n    if (blockIndex >= this._inUse || blockIndex < 0 || componentIndex < 0 || componentIndex >= this._blockSize)\r\n      return undefined;\r\n    return this._data[this._blockSize * blockIndex + componentIndex];\r\n  }\r\n  /** Access a single double at offset within a block.  This has no index checking. */\r\n  public component(blockIndex: number, componentIndex: number): number {\r\n    return this._data[this._blockSize * blockIndex + componentIndex];\r\n  }\r\n  /** compare two blocks in simple lexical order.\r\n   * @param data data array\r\n   * @param blockSize number of items to compare\r\n   * @param ia raw index (not block index) of first block\r\n   * @param ib raw index (not block index) of second block\r\n   */\r\n  public static compareLexicalBlock(data: Float64Array, blockSize: number, ia: number, ib: number): number {\r\n    let ax = 0;\r\n    let bx = 0;\r\n    for (let i = 0; i < blockSize; i++) {\r\n      ax = data[ia + i];\r\n      bx = data[ib + i];\r\n      if (ax > bx) return 1;\r\n      if (ax < bx) return -1;\r\n    }\r\n    return ia - ib; // so original order is maintained among duplicates !!!!\r\n  }\r\n  /** Return an array of block indices sorted per compareLexicalBlock function */\r\n  public sortIndicesLexical(compareBlocks: BlockComparisonFunction = GrowableBlockedArray.compareLexicalBlock): Uint32Array {\r\n    const n = this._inUse;\r\n    // let numCompare = 0;\r\n    const result = new Uint32Array(n);\r\n    const data = this._data;\r\n    const blockSize = this._blockSize;\r\n    for (let i = 0; i < n; i++)result[i] = i;\r\n    result.sort(\r\n      (blockIndexA: number, blockIndexB: number) => {\r\n        // numCompare++;\r\n        return compareBlocks(data, blockSize, blockIndexA * blockSize, blockIndexB * blockSize);\r\n      });\r\n    // console.log (n, numCompare);\r\n    return result;\r\n  }\r\n  /** Return the distance (hypotenuse=sqrt(summed squares)) between indicated blocks */\r\n  public distanceBetweenBlocks(blockIndexA: number, blockIndexB: number): number {\r\n    let dd = 0.0;\r\n    let iA = this.blockIndexToDoubleIndex(blockIndexA);\r\n    let iB = this.blockIndexToDoubleIndex(blockIndexB);\r\n    let a = 0;\r\n    const data = this._data;\r\n    for (let i = 0; i < this._blockSize; i++) {\r\n      a = data[iA++] - data[iB++];\r\n      dd += a * a;\r\n    }\r\n    return Math.sqrt(dd);\r\n  }\r\n\r\n  /** Return the distance (hypotenuse=sqrt(summed squares)) between block entries `iBegin <= i < iEnd` of indicated blocks */\r\n  public distanceBetweenSubBlocks(blockIndexA: number, blockIndexB: number, iBegin: number, iEnd: number): number {\r\n    let dd = 0.0;\r\n    const iA = this.blockIndexToDoubleIndex(blockIndexA);\r\n    const iB = this.blockIndexToDoubleIndex(blockIndexB);\r\n    let a = 0;\r\n    const data = this._data;\r\n    for (let i = iBegin; i < iEnd; i++) {\r\n      a = data[iA + i] - data[iB + i];\r\n      dd += a * a;\r\n    }\r\n    return Math.sqrt(dd);\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"GrowableBlockedArray.js","sourceRoot":"","sources":["../../../src/geometry3d/GrowableBlockedArray.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/** @packageDocumentation\r\n * @module ArraysAndInterfaces\r\n */\r\n\r\nimport { BlockComparisonFunction } from \"./GrowableFloat64Array\";\r\n\r\n/**\r\n * Array of contiguous doubles, indexed by block number and index within block.\r\n * * This is essentially a rectangular matrix (two dimensional array), with each block being a row of the matrix.\r\n * @public\r\n */\r\nexport class GrowableBlockedArray {\r\n  /** underlying contiguous, oversized buffer. */\r\n  protected _data: Float64Array;\r\n  /** Number of blocks (matrix rows) in use. */\r\n  protected _inUse: number;\r\n  /** number of numbers per block in the array.\r\n   * * If viewing the array as a two dimensional array, this is the row size.\r\n   */\r\n  protected _blockSize: number;  // positive integer !!!\r\n  /**\r\n   * multiplier used by ensureBlockCapacity to expand requested reallocation size\r\n   */\r\n  protected _growthFactor: number;\r\n\r\n  /**\r\n   * Construct an array whose contents are in blocked (row-major) order, possibly with extra capacity.\r\n   * * Total capacity is `this._data.length`\r\n   * * Actual in-use count is `this._inUse * this._blockSize`\r\n   * @param blockSize number of entries in each block, i.e., row size\r\n   * @param initialBlocks initial capacity in blocks (default 8)\r\n   * @param growthFactor used by ensureBlockCapacity to expand requested reallocation size (default 1.5)\r\n   */\r\n  public constructor(blockSize: number, initialBlocks: number = 8, growthFactor?: number) {\r\n    this._data = new Float64Array(initialBlocks * blockSize);\r\n    this._inUse = 0;\r\n    this._blockSize = blockSize > 0 ? blockSize : 1;\r\n    this._growthFactor = (undefined !== growthFactor && growthFactor >= 1.0) ? growthFactor : 1.5;\r\n  }\r\n\r\n  /** Copy data from source array. Does not reallocate or change active block count.\r\n   * @param source array to copy from\r\n   * @param sourceCount copy the first sourceCount blocks; all blocks if undefined\r\n   * @param destOffset copy to instance array starting at this block index; zero if undefined\r\n   * @return count and offset of blocks copied\r\n   */\r\n  protected copyData(source: Float64Array | number[], sourceCount?: number, destOffset?: number): {count: number, offset: number} {\r\n    // validate inputs and convert from blocks to entries\r\n    let myOffset = (undefined !== destOffset) ? destOffset * this.numPerBlock : 0;\r\n    if (myOffset < 0)\r\n      myOffset = 0;\r\n    if (myOffset >= this._data.length)\r\n      return {count: 0, offset: 0};\r\n    let myCount = (undefined !== sourceCount) ? sourceCount * this.numPerBlock : source.length;\r\n    if (myCount > 0) {\r\n      if (myCount > source.length)\r\n        myCount = source.length;\r\n      if (myOffset + myCount > this._data.length)\r\n        myCount = this._data.length - myOffset;\r\n      if (myCount % this.numPerBlock !== 0)\r\n        myCount -= myCount % this.numPerBlock;\r\n    }\r\n    if (myCount <= 0)\r\n      return {count: 0, offset: 0};\r\n    if (myCount === source.length)\r\n      this._data.set(source, myOffset);\r\n    else if (source instanceof Float64Array)\r\n      this._data.set(source.subarray(0, myCount), myOffset);\r\n    else\r\n      this._data.set(source.slice(0, myCount), myOffset);\r\n    return {count: myCount / this.numPerBlock, offset: myOffset / this.numPerBlock};\r\n  }\r\n\r\n  /**\r\n   * Make a copy of the (active) blocks in this array.\r\n   * (The clone does NOT get excess capacity)\r\n   */\r\n  public clone(): GrowableBlockedArray {\r\n    const newBlocks = new GrowableBlockedArray(this.numPerBlock, this.numBlocks, this._growthFactor);\r\n    newBlocks.copyData(this._data, this.numBlocks);\r\n    newBlocks._inUse = this.numBlocks;\r\n    return newBlocks;\r\n  }\r\n\r\n  /** computed property: length (in blocks, not doubles) */\r\n  public get length(): number { return this._inUse; }\r\n  /** computed property: length (in blocks, not doubles) */\r\n  public get numBlocks(): number { return this._inUse; }\r\n  /** property: number of data values per block */\r\n  public get numPerBlock(): number { return this._blockSize; }\r\n  /**\r\n   * Return a single value indexed within a block. Indices are unchecked.\r\n   * @param blockIndex index of block to read\r\n   * @param indexInBlock  offset within the block\r\n   */\r\n  public getWithinBlock(blockIndex: number, indexWithinBlock: number): number {\r\n    return this._data[blockIndex * this._blockSize + indexWithinBlock];\r\n  }\r\n  /** clear the block count to zero, but maintain the allocated memory */\r\n  public clear() { this._inUse = 0; }\r\n  /** Return the capacity in blocks (not doubles) */\r\n  public blockCapacity() {\r\n    return this._data.length / this._blockSize;\r\n  }\r\n  /** ensure capacity (in blocks, not doubles) */\r\n  public ensureBlockCapacity(blockCapacity: number, applyGrowthFactor: boolean = true) {\r\n    if (blockCapacity > this.blockCapacity()) {\r\n      if (applyGrowthFactor)\r\n        blockCapacity *= this._growthFactor;\r\n      const prevData = this._data;\r\n      this._data = new Float64Array(blockCapacity * this._blockSize);\r\n      this.copyData(prevData, this._inUse);\r\n      }\r\n  }\r\n  /** Add a new block of data.\r\n   * * If newData has fewer than numPerBlock entries, the remaining part of the new block is zeros.\r\n   * * If newData has more entries, only the first numPerBlock are taken.\r\n   */\r\n  public addBlock(newData: number[]) {\r\n    const k0 = this.newBlockIndex();\r\n    let numValue = newData.length;\r\n    if (numValue > this._blockSize)\r\n      numValue = this._blockSize;\r\n    for (let i = 0; i < numValue; i++)\r\n      this._data[k0 + i] = newData[i];\r\n  }\r\n  /**\r\n   * Return the starting index of a block of (zero-initialized) doubles at the end.\r\n   *\r\n   * * this.data is reallocated if needed to include the new block.\r\n   * * The inUse count is incremented to include the new block.\r\n   * * The returned block is an index to the Float64Array (not a block index)\r\n   */\r\n  protected newBlockIndex(): number {\r\n    const index = this._blockSize * this._inUse;\r\n    if ((index + 1) > this._data.length)\r\n      this.ensureBlockCapacity(1 + this._inUse);\r\n    this._inUse++;\r\n    for (let i = index; i < index + this._blockSize; i++)\r\n      this._data[i] = 0.0;\r\n    return index;\r\n  }\r\n  /** reduce the block count by one. */\r\n  public popBlock() {\r\n    if (this._inUse > 0)\r\n      this._inUse--;\r\n  }\r\n  /** convert a block index to the simple index to the underlying Float64Array. */\r\n  protected blockIndexToDoubleIndex(blockIndex: number) { return this._blockSize * blockIndex; }\r\n  /** Access a single double at offset within a block, with index checking and return undefined if indexing is invalid. */\r\n  public checkedComponent(blockIndex: number, componentIndex: number): number | undefined {\r\n    if (blockIndex >= this._inUse || blockIndex < 0 || componentIndex < 0 || componentIndex >= this._blockSize)\r\n      return undefined;\r\n    return this._data[this._blockSize * blockIndex + componentIndex];\r\n  }\r\n  /** Access a single double at offset within a block.  This has no index checking. */\r\n  public component(blockIndex: number, componentIndex: number): number {\r\n    return this._data[this._blockSize * blockIndex + componentIndex];\r\n  }\r\n  /** compare two blocks in simple lexical order.\r\n   * @param data data array\r\n   * @param blockSize number of items to compare\r\n   * @param ia raw index (not block index) of first block\r\n   * @param ib raw index (not block index) of second block\r\n   */\r\n  public static compareLexicalBlock(data: Float64Array, blockSize: number, ia: number, ib: number): number {\r\n    let ax = 0;\r\n    let bx = 0;\r\n    for (let i = 0; i < blockSize; i++) {\r\n      ax = data[ia + i];\r\n      bx = data[ib + i];\r\n      if (ax > bx) return 1;\r\n      if (ax < bx) return -1;\r\n    }\r\n    return ia - ib; // so original order is maintained among duplicates !!!!\r\n  }\r\n  /** Return an array of block indices sorted per compareLexicalBlock function */\r\n  public sortIndicesLexical(compareBlocks: BlockComparisonFunction = GrowableBlockedArray.compareLexicalBlock): Uint32Array {\r\n    const n = this._inUse;\r\n    // let numCompare = 0;\r\n    const result = new Uint32Array(n);\r\n    const data = this._data;\r\n    const blockSize = this._blockSize;\r\n    for (let i = 0; i < n; i++)result[i] = i;\r\n    result.sort(\r\n      (blockIndexA: number, blockIndexB: number) => {\r\n        // numCompare++;\r\n        return compareBlocks(data, blockSize, blockIndexA * blockSize, blockIndexB * blockSize);\r\n      });\r\n    // console.log (n, numCompare);\r\n    return result;\r\n  }\r\n  /** Return the distance (hypotenuse=sqrt(summed squares)) between indicated blocks */\r\n  public distanceBetweenBlocks(blockIndexA: number, blockIndexB: number): number {\r\n    let dd = 0.0;\r\n    let iA = this.blockIndexToDoubleIndex(blockIndexA);\r\n    let iB = this.blockIndexToDoubleIndex(blockIndexB);\r\n    let a = 0;\r\n    const data = this._data;\r\n    for (let i = 0; i < this._blockSize; i++) {\r\n      a = data[iA++] - data[iB++];\r\n      dd += a * a;\r\n    }\r\n    return Math.sqrt(dd);\r\n  }\r\n\r\n  /** Return the distance (hypotenuse=sqrt(summed squares)) between block entries `iBegin <= i < iEnd` of indicated blocks */\r\n  public distanceBetweenSubBlocks(blockIndexA: number, blockIndexB: number, iBegin: number, iEnd: number): number {\r\n    let dd = 0.0;\r\n    const iA = this.blockIndexToDoubleIndex(blockIndexA);\r\n    const iB = this.blockIndexToDoubleIndex(blockIndexB);\r\n    let a = 0;\r\n    const data = this._data;\r\n    for (let i = iBegin; i < iEnd; i++) {\r\n      a = data[iA + i] - data[iB + i];\r\n      dd += a * a;\r\n    }\r\n    return Math.sqrt(dd);\r\n  }\r\n}\r\n"]}

package/lib/esm/geometry3d/GrowableFloat64Array.d.ts

@@ -23,7 +23,22 @@ export declare type BlockComparisonFunction = (data: Float64Array, blockSize: nu
 export declare class GrowableFloat64Array {
     private _data;
     private _inUse;
-    constructor(initialCapacity?: number);
+    private _growthFactor;
+    /** Construct a GrowableFloat64Array.
+     * @param initialCapacity initial capacity (default 8)
+     * @param growthFactor used by ensureCapacity to expand requested reallocation size (default 1.5)
+     */
+    constructor(initialCapacity?: number, growthFactor?: number);
+    /** Copy data from source array. Does not reallocate or change active entry count.
+     * @param source array to copy from
+     * @param sourceCount copy the first sourceCount entries; all entries if undefined
+     * @param destOffset copy to instance array starting at this index; zero if undefined
+     * @return count and offset of entries copied
+     */
+    protected copyData(source: Float64Array | number[], sourceCount?: number, destOffset?: number): {
+        count: number;
+        offset: number;
+    };
     /**
      * Create a GrowableFloat64Array with given contents.
      * @param contents data to copy into the array
@@ -74,7 +89,7 @@ export declare class GrowableFloat64Array {
      * @param data array of values to push
      */
     pushArray(data: Float64Array | number[]): void;
-    /** Push a `numToCopy` consecutive values starting at `copyFromIndex` to the end of the array. */
+    /** Push `numToCopy` consecutive values starting at `copyFromIndex`. */
     pushBlockCopy(copyFromIndex: number, numToCopy: number): void;
     /** Clear the array to 0 length.  The underlying memory remains allocated for reuse. */
     clear(): void;
@@ -84,14 +99,15 @@ export declare class GrowableFloat64Array {
      */
     capacity(): number;
     /**
-     * * If the capacity (Float64Array length) is less than or equal to the requested newCapacity, do nothing
-     * * If the requested newCapacity is larger than the existing capacity, reallocate (and copy existing values) with the larger capacity.
-     * @param newCapacity
+     * * If the capacity (Float64Array length) is less than or equal to the requested newCapacity, do nothing.
+     * * If the requested newCapacity is larger than the existing capacity, reallocate to larger capacity, and copy existing values.
+     * @param newCapacity size of new array
+     * @param applyGrowthFactor whether to apply the growth factor to newCapacity when reallocating
      */
-    ensureCapacity(newCapacity: number): void;
+    ensureCapacity(newCapacity: number, applyGrowthFactor?: boolean): void;
     /**
-     * * If newLength is less than current (active) length, just set (active) length.
-     * * If newLength is greater, ensureCapacity (newSize) and pad with padValue up to newSize;
+     * * If newLength is less than current length, just reset current length to newLength, effectively trimming active entries but preserving original capacity.
+     * * If newLength is greater than current length, reallocate to (exactly) newLength, copy existing entries, and pad with padValue up to newLength.
      * @param newLength new data count
      * @param padValue value to use for padding if the length increases.
      */

package/lib/esm/geometry3d/GrowableFloat64Array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GrowableFloat64Array.d.ts","sourceRoot":"","sources":["../../../src/geometry3d/GrowableFloat64Array.ts"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;GAGG;AACH,oBAAY,4BAA4B,GAAG,oBAAoB,GAAG,SAAS,CAAC;AAC5E;;;GAGG;AACH,oBAAY,uBAAuB,GAAG,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;AACxH;;;;;;;;GAQG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,MAAM,CAAS;gBACX,eAAe,GAAE,MAAU;IAIvC;;;OAGG;WACW,MAAM,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,EAAE,GAAG,oBAAoB;IAO7E;;;;;OAKG;WACW,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM;IAG7C;;;OAGG;IACI,KAAK,CAAC,sBAAsB,GAAE,OAAe,GAAG,oBAAoB;IAQ3E;;;OAGG;IACH,IAAW,MAAM,WAEhB;IACD;;;;OAIG;IACI,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAIvD;;;;OAIG;IACI,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAGhC;;;;OAIG;IACI,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAMhC;;;OAGG;IACI,IAAI,CAAC,MAAM,EAAE,MAAM;IAe1B;;;OAGG;IACI,SAAS,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,EAAE;IAG9C,iGAAiG;IAC1F,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAO7D,uFAAuF;IAChF,KAAK;IAIZ;;;OAGG;IACI,QAAQ;IAGf;;;;OAIG;IACI,cAAc,CAAC,WAAW,EAAE,MAAM;IASzC;;;;;OAKG;IACI,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAU;IAYrD;;;;OAIG;IACI,GAAG;IAOV,4CAA4C;IACrC,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAG9C,sDAAsD;IAC/C,KAAK;IAGZ,oDAAoD;IAC7C,IAAI;IAGX,2BAA2B;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAI5C;;;;OAIG;IACI,IAAI,CAAC,aAAa,GAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,KAAK,MAAqC;IAapF;;;;;OAKG;IACI,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAa9C;;;OAGG;IACI,0BAA0B,CAAC,SAAS,GAAE,MAAY;CAmB1D"}
+{"version":3,"file":"GrowableFloat64Array.d.ts","sourceRoot":"","sources":["../../../src/geometry3d/GrowableFloat64Array.ts"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;GAGG;AACH,oBAAY,4BAA4B,GAAG,oBAAoB,GAAG,SAAS,CAAC;AAC5E;;;GAGG;AACH,oBAAY,uBAAuB,GAAG,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;AACxH;;;;;;;;GAQG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,aAAa,CAAS;IAE9B;;;OAGG;gBACS,eAAe,GAAE,MAAU,EAAE,YAAY,CAAC,EAAE,MAAM;IAM9D;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC;IAwB/H;;;OAGG;WACW,MAAM,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,EAAE,GAAG,oBAAoB;IAM7E;;;;;OAKG;WACW,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM;IAG7C;;;OAGG;IACI,KAAK,CAAC,sBAAsB,GAAE,OAAe,GAAG,oBAAoB;IAM3E;;;OAGG;IACH,IAAW,MAAM,WAEhB;IACD;;;;OAIG;IACI,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAIvD;;;;OAIG;IACI,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAGhC;;;;OAIG;IACI,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAMhC;;;OAGG;IACI,IAAI,CAAC,MAAM,EAAE,MAAM;IAK1B;;;OAGG;IACI,SAAS,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,EAAE;IAK9C,uEAAuE;IAChE,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAO7D,uFAAuF;IAChF,KAAK;IAGZ;;;OAGG;IACI,QAAQ;IAGf;;;;;OAKG;IACI,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,iBAAiB,GAAE,OAAc;IAS5E;;;;;OAKG;IACI,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAU;IASrD;;;;OAIG;IACI,GAAG;IAOV,4CAA4C;IACrC,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAG9C,sDAAsD;IAC/C,KAAK;IAGZ,oDAAoD;IAC7C,IAAI;IAGX,2BAA2B;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAI5C;;;;OAIG;IACI,IAAI,CAAC,aAAa,GAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,KAAK,MAAqC;IAapF;;;;;OAKG;IACI,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAa9C;;;OAGG;IACI,0BAA0B,CAAC,SAAS,GAAE,MAAY;CAmB1D"}

package/lib/esm/geometry3d/GrowableFloat64Array.js

@@ -12,20 +12,53 @@
  * @public
  */
 export class GrowableFloat64Array {
-    constructor(initialCapacity = 8) {
+    /** Construct a GrowableFloat64Array.
+     * @param initialCapacity initial capacity (default 8)
+     * @param growthFactor used by ensureCapacity to expand requested reallocation size (default 1.5)
+     */
+    constructor(initialCapacity = 8, growthFactor) {
         this._data = new Float64Array(initialCapacity);
         this._inUse = 0;
+        this._growthFactor = (undefined !== growthFactor && growthFactor >= 1.0) ? growthFactor : 1.5;
+    }
+    /** Copy data from source array. Does not reallocate or change active entry count.
+     * @param source array to copy from
+     * @param sourceCount copy the first sourceCount entries; all entries if undefined
+     * @param destOffset copy to instance array starting at this index; zero if undefined
+     * @return count and offset of entries copied
+     */
+    copyData(source, sourceCount, destOffset) {
+        let myOffset = destOffset !== null && destOffset !== void 0 ? destOffset : 0;
+        if (myOffset < 0)
+            myOffset = 0;
+        if (myOffset >= this._data.length)
+            return { count: 0, offset: 0 };
+        let myCount = sourceCount !== null && sourceCount !== void 0 ? sourceCount : source.length;
+        if (myCount > 0) {
+            if (myCount > source.length)
+                myCount = source.length;
+            if (myOffset + myCount > this._data.length)
+                myCount = this._data.length - myOffset;
+        }
+        if (myCount <= 0)
+            return { count: 0, offset: 0 };
+        if (myCount === source.length)
+            this._data.set(source, myOffset);
+        else if (source instanceof Float64Array)
+            this._data.set(source.subarray(0, myCount), myOffset);
+        else
+            this._data.set(source.slice(0, myCount), myOffset);
+        return { count: myCount, offset: myOffset };
     }
     /**
      * Create a GrowableFloat64Array with given contents.
      * @param contents data to copy into the array
      */
     static create(contents) {
-        const result = new GrowableFloat64Array(contents.length);
-        for (const a of contents) {
-            result.push(a);
-        }
-        return result;
+        const out = new GrowableFloat64Array(contents.length);
+        out.copyData(contents);
+        out._inUse = contents.length;
+        return out;
     }
     /** sort-compatible comparison.
      * * Returns `(a-b)` which is
@@ -41,11 +74,9 @@ export class GrowableFloat64Array {
      * * optionally trimmed capacity to the active length or replicate the capacity and unused space.
      */
     clone(maintainExcessCapacity = false) {
-        const n = this._inUse;
-        const data = this._data;
-        const out = new GrowableFloat64Array(maintainExcessCapacity ? this.capacity() : n);
-        for (let i = 0; i < n; i++)
-            out.push(data[i]);
+        const out = new GrowableFloat64Array(maintainExcessCapacity ? this.capacity() : this._inUse);
+        out.copyData(this._data, this._inUse);
+        out._inUse = this._inUse;
         return out;
     }
     /**
@@ -86,41 +117,30 @@ export class GrowableFloat64Array {
      * @param toPush value to append to the active array.
      */
     push(toPush) {
-        if (this._inUse + 1 <= this._data.length) {
-            this._data[this._inUse] = toPush;
-            this._inUse++;
-        }
-        else {
-            // Make new array (double size), copy values, then push toPush
-            const newData = new Float64Array(4 + this._inUse * 2);
-            for (let i = 0; i < this._inUse; i++) {
-                newData[i] = this._data[i];
-            }
-            this._data = newData;
-            this._data[this._inUse] = toPush;
-            this._inUse++;
-        }
+        this.ensureCapacity(this._inUse + 1);
+        this._data[this._inUse] = toPush;
+        this._inUse++;
     }
     /**
      * Push each value from an array.
      * @param data array of values to push
      */
     pushArray(data) {
-        for (const a of data)
-            this.push(a);
+        this.ensureCapacity(this._inUse + data.length);
+        this.copyData(data, data.length, this._inUse);
+        this._inUse += data.length;
     }
-    /** Push a `numToCopy` consecutive values starting at `copyFromIndex` to the end of the array. */
+    /** Push `numToCopy` consecutive values starting at `copyFromIndex`. */
     pushBlockCopy(copyFromIndex, numToCopy) {
-        const newLength = this._inUse + numToCopy;
-        this.ensureCapacity(newLength);
-        const limit = copyFromIndex + numToCopy;
-        for (let i = copyFromIndex; i < limit; i++)
-            this._data[this._inUse++] = this._data[i];
+        if (copyFromIndex >= 0 && copyFromIndex < this._inUse && numToCopy > 0 && copyFromIndex + numToCopy <= this._inUse) {
+            this.ensureCapacity(this._inUse + numToCopy);
+            this._data.copyWithin(this._inUse, copyFromIndex, copyFromIndex + numToCopy);
+            this._inUse += numToCopy;
+        }
     }
     /** Clear the array to 0 length.  The underlying memory remains allocated for reuse. */
     clear() {
-        while (this._inUse > 0)
-            this.pop();
+        this._inUse = 0;
     }
     /**
      * Returns the number of entries in the supporting Float64Array buffer.
@@ -130,36 +150,34 @@ export class GrowableFloat64Array {
         return this._data.length;
     }
     /**
-     * * If the capacity (Float64Array length) is less than or equal to the requested newCapacity, do nothing
-     * * If the requested newCapacity is larger than the existing capacity, reallocate (and copy existing values) with the larger capacity.
-     * @param newCapacity
+     * * If the capacity (Float64Array length) is less than or equal to the requested newCapacity, do nothing.
+     * * If the requested newCapacity is larger than the existing capacity, reallocate to larger capacity, and copy existing values.
+     * @param newCapacity size of new array
+     * @param applyGrowthFactor whether to apply the growth factor to newCapacity when reallocating
      */
-    ensureCapacity(newCapacity) {
+    ensureCapacity(newCapacity, applyGrowthFactor = true) {
         if (newCapacity > this.capacity()) {
-            const oldInUse = this._inUse;
-            const newData = new Float64Array(newCapacity);
-            for (let i = 0; i < oldInUse; i++)
-                newData[i] = this._data[i];
-            this._data = newData;
+            if (applyGrowthFactor)
+                newCapacity *= this._growthFactor;
+            const prevData = this._data;
+            this._data = new Float64Array(newCapacity);
+            this.copyData(prevData, this._inUse);
         }
     }
     /**
-     * * If newLength is less than current (active) length, just set (active) length.
-     * * If newLength is greater, ensureCapacity (newSize) and pad with padValue up to newSize;
+     * * If newLength is less than current length, just reset current length to newLength, effectively trimming active entries but preserving original capacity.
+     * * If newLength is greater than current length, reallocate to (exactly) newLength, copy existing entries, and pad with padValue up to newLength.
      * @param newLength new data count
      * @param padValue value to use for padding if the length increases.
      */
     resize(newLength, padValue = 0) {
-        // quick out for easy case ...
-        if (newLength <= this._inUse) {
+        if (newLength >= 0 && newLength < this._inUse)
+            this._inUse = newLength;
+        else if (newLength > this._inUse) {
+            this.ensureCapacity(newLength, false);
+            this._data.fill(padValue, this._inUse);
             this._inUse = newLength;
-            return;
         }
-        const oldLength = this._inUse;
-        this.ensureCapacity(newLength);
-        for (let i = oldLength; i < newLength; i++)
-            this._data[i] = padValue;
-        this._inUse = newLength;
     }
     /**
      * * Reduce the length by one.