@itwin/core-geometry 3.0.0-dev.76 → 3.0.0-dev.80

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

@@ -0,0 +1 @@
+{"version":3,"file":"Quadrature.js","sourceRoot":"","sources":["../../../src/numerics/Quadrature.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\nimport { Geometry } from \"../Geometry\";\r\n\r\n/** @packageDocumentation\r\n * @module Numerics\r\n */\r\n\r\n/** Support class for quadrature -- approximate integrals by summing weighted function values.\r\n * These are filled with x and weight for quadrature between xA and xB\r\n *\r\n * Since quadrature is done in side tight loops, these methods are structured for minimum object\r\n * allocation.\r\n * For methods names setupGauss<N> (where N is a smallish integer), the CALLER creates arrays xMapped and wMapped\r\n * The method installs particular x and weight values.\r\n * @internal\r\n */\r\nexport class Quadrature {\r\n  /** x value for 1 point gauss rule in 0..1 interval */\r\n  public static readonly gaussX1Interval01 = new Float64Array([0.5]);\r\n  /** weight for 1 point gauss rule in 0..1 interval */\r\n  public static readonly gaussW1Interval01 = new Float64Array([1.0]);\r\n\r\n  /** x value for 2 point gauss rule in 0..1 interval */\r\n  public static readonly gaussX2Interval01 = new Float64Array([0.21132486540518708, 0.7886751345948129]);\r\n  /** weight for 2 point gauss rule in 0..1 interval */\r\n  public static readonly gaussW2Interval01 = new Float64Array([0.5, 0.5]);\r\n\r\n  /** x value for 3 point gauss rule in 0..1 interval */\r\n  public static readonly gaussX3Interval01 = new Float64Array([0.1127016653792583, 0.5, 0.8872983346207417]);\r\n  /** weight for 3 point gauss rule in 0..1 interval */\r\n  public static readonly gaussW3Interval01 = new Float64Array([0.2777777777777778, 0.4444444444444444, 0.2777777777777778]);\r\n\r\n  /** x value for 4 point gauss rule in 0..1 interval */\r\n  public static readonly gaussX4Interval01 = new Float64Array([0.06943184420297371, 0.33000947820757187, 0.6699905217924281, 0.9305681557970262]);\r\n  /** weight for 4 point gauss rule in 0..1 interval */\r\n  public static readonly gaussW4Interval01 = new Float64Array([0.17392742256872692, 0.3260725774312731, 0.3260725774312731, 0.17392742256872692]);\r\n\r\n  /** x value for 5 point gauss rule in 0..1 interval */\r\n  public static readonly gaussX5Interval01 = new Float64Array([0.04691007703066802, 0.23076534494715845, 0.5, 0.7692346550528415, 0.9530899229693319]);\r\n  /** weight for 5 point gauss rule in 0..1 interval */\r\n  public static readonly gaussW5Interval01 = new Float64Array([0.11846344252809454, 0.23931433524968324, 0.28444444444444444, 0.23931433524968324, 0.11846344252809454]);\r\n\r\n  /**\r\n   * Given points and weights in a reference interval (usually 0 to 1):\r\n   *\r\n   * * map each xRef[i] to xA + h * xRef[i];\r\n   * * scale each weight wRef[i] to h * wRef[i]\r\n   * * all arrays are assumed to have xRef.length entries.\r\n   * * the return value is xRef.length\r\n   * @param xA beginning of target interval\r\n   * @param h length of target interval\r\n   * @param xRef x coordinates in reference interval\r\n   * @param wRef weights for integration in the reference interval\r\n   * @param xMapped x coordinates to evaluate integrands\r\n   * @param wMapped weights for evaluated integrands\r\n   */\r\n  public static mapWeights(xA: number, h: number, xRef: Float64Array, wRef: Float64Array, xMapped: Float64Array, wMapped: Float64Array): number {\r\n    const n = xRef.length;\r\n    for (let i = 0; i < n; i++) {\r\n      xMapped[i] = xA + h * xRef[i];\r\n      wMapped[i] = h * wRef[i];\r\n    }\r\n    return n;\r\n  }\r\n\r\n  /** Install 1 (ONE) x and weight values for quadrature from xA to xB. */\r\n  public static setupGauss1(xA: number, xB: number, xMapped: Float64Array, wMapped: Float64Array): number {\r\n    return Quadrature.mapWeights(xA, xB - xA, Quadrature.gaussX1Interval01, Quadrature.gaussW1Interval01, xMapped, wMapped);\r\n  }\r\n\r\n  /** Install 2 (TWO) x and weight values for quadrature from xA to xB. */\r\n  public static setupGauss2(xA: number, xB: number, xMapped: Float64Array, wMapped: Float64Array): number {\r\n    return Quadrature.mapWeights(xA, xB - xA, Quadrature.gaussX2Interval01, Quadrature.gaussW2Interval01, xMapped, wMapped);\r\n    /*  // exact formulas for interval xA..xB:\r\n        const x0 = 0.5 * (xA + xB);\r\n            const h = 0.5 * (xB - xA);\r\n            const dx = h / Math.sqrt(3);\r\n            xMapped[0] = x0 - dx; xMapped[1] = x0 + dx;\r\n            wMapped[0] = wMapped[1] = h;\r\n            */\r\n  }\r\n  /** Install 3 (THREE) x and weight values for quadrature from xA to xB. */\r\n  public static setupGauss3(xA: number, xB: number, xMapped: Float64Array, wMapped: Float64Array): number {\r\n    return Quadrature.mapWeights(xA, xB - xA, Quadrature.gaussX3Interval01, Quadrature.gaussW3Interval01, xMapped, wMapped);\r\n    /*  // exact formulas for interval xA..xB:\r\n    const x0 = 0.5 * (xA + xB);\r\n    const h = 0.5 * (xB - xA);\r\n    const a = Math.sqrt(0.6);\r\n    const b = h * 5.0 / 9.0;\r\n    const dx = a * h;\r\n    xMapped[0] = x0 - dx; xMapped[1] = x0; xMapped[2] = x0 + dx;\r\n    wMapped[0] = wMapped[2] = b;\r\n    wMapped[1] = h * 8.0 / 9.0;\r\n    return 3;\r\n    */\r\n  }\r\n\r\n  /** Install 5 (FIVE) x and weight values for quadrature from xA to xB. */\r\n  public static setupGauss5(xA: number, xB: number, xMapped: Float64Array, wMapped: Float64Array): number {\r\n    return Quadrature.mapWeights(xA, xB - xA, Quadrature.gaussX5Interval01, Quadrature.gaussW5Interval01, xMapped, wMapped);\r\n    /*  // exact formulas for interval xA..xB:\r\n    const x0 = 0.5 * (xA + xB);\r\n    const h = 0.5 * (xB - xA);\r\n    const q = 2.0 * Math.sqrt(10.0 / 7.0);\r\n    const b = 13.0 * Math.sqrt(70.0);\r\n    const a1 = h * Math.sqrt(5.0 - q) / 3.0;\r\n    const a2 = h * Math.sqrt(5.0 + q) / 3.0;\r\n    const w1 = h * (322.0 + b) / 900.0;\r\n    const w2 = h * (322.0 - b) / 900;\r\n    const w0 = h * 128.0 / 225.0;\r\n    xMapped[0] = x0 - a2; xMapped[1] = x0 - a1; xMapped[2] = x0; xMapped[3] = x0 + a1; xMapped[4] = x0 + a2;\r\n    wMapped[0] = w2; wMapped[1] = w1; wMapped[2] = w0; wMapped[3] = w1; wMapped[4] = w2;\r\n    return 5;\r\n    */\r\n  }\r\n\r\n  /** Install 4 (FOUR) x and weight values for quadrature from xA to xB. */\r\n  public static setupGauss4(xA: number, xB: number, xMapped: Float64Array, wMapped: Float64Array): number {\r\n    return Quadrature.mapWeights(xA, xB - xA, Quadrature.gaussX4Interval01, Quadrature.gaussW4Interval01, xMapped, wMapped);\r\n    /*  // exact formulas for interval xA..xB:\r\nconst x0 = 0.5 * (xA + xB);\r\nconst h = 0.5 * (xB - xA);\r\nconst q = 2.0 * Math.sqrt(6.0 / 5.0);\r\nconst r = Math.sqrt(30.0);\r\nconst a1 = h * Math.sqrt((3 - q) / 7.0);\r\nconst w1 = h * (18.0 + r) / 36.0;\r\nconst a2 = h * Math.sqrt((3 + q) / 7.0);\r\nconst w2 = h * (18.0 - r) / 36.0;\r\nxMapped[0] = x0 - a2; xMapped[1] = x0 - a1; xMapped[2] = x0 + a1; xMapped[3] = x0 + a2;\r\nwMapped[0] = w2; wMapped[1] = w1; wMapped[2] = w1; wMapped[3] = w2;\r\nreturn 4;\r\n*/\r\n  }\r\n  /** Sum function values with given weights and x values. */\r\n  public static sum1(\r\n    xx: Float64Array,\r\n    ww: Float64Array,\r\n    n: number,\r\n    f: (x: number) => number): number {\r\n    let sum = 0;\r\n    for (let i = 0; i < n; i++)sum += ww[i] * f(xx[i]);\r\n    return sum;\r\n  }\r\n  /**\r\n   * Do a Guass quadrature integral for a (number)=>number function over an interval, with caller specified sub-interval count and\r\n   * @param x0 start of overall interval\r\n   * @param x1 end of overall interval\r\n   * @param f function to evaluate\r\n   * @param numInterval number of internal intervals\r\n   * @param numGauss number of gauss points.    must be supported by GaussMapper, i.e. 1,2,3,4,5\r\n   */\r\n  public static doGaussIntegral(x0: number, x1: number, f: (x: number) => number, numInterval: number, numGauss: number = 5) {\r\n    const mapper = new GaussMapper(numGauss);\r\n    if (numInterval < 1)\r\n      numInterval = 1;\r\n    const df = 1.0 / numInterval;\r\n    let sum = 0;\r\n    for (let i = 1; i <= numInterval; i++) {\r\n      const xA = Geometry.interpolate(x0, (i - 1) * df, x1);\r\n      const xB = i === numInterval ? x1 : Geometry.interpolate(x0, (i) * df, x1);\r\n      const n = mapper.mapXAndW(xA, xB);\r\n      for (let k = 0; k < n; k++) {\r\n        sum += mapper.gaussW[k] * f(mapper.gaussX[k]);\r\n      }\r\n    }\r\n    return sum;\r\n  }\r\n}\r\n\r\n/**\r\n * This class carries public members as needed for users to have gauss points that are used\r\n * in the callers loops.\r\n * @internal\r\n */\r\nexport class GaussMapper {\r\n  /** x values for integration */\r\n  public gaussX: Float64Array;\r\n  /** weights for integration */\r\n  public gaussW: Float64Array;\r\n  /** function to be called (at each interval) to map integration values */\r\n  public mapXAndWFunction: (xA: number, xB: number, xx: Float64Array, ww: Float64Array) => number;\r\n  /** Execute the mapXAndWFunction to set up arrays for integration from xA to xB */\r\n  public mapXAndW(xA: number, xB: number): number {\r\n    return this.mapXAndWFunction(xA, xB, this.gaussX, this.gaussW);\r\n  }\r\n  /** setup gauss arrays.\r\n   * * Number of gauss points must be 1 to 5 (inclusive)\r\n   * @param numGauss requested number of gauss points.\r\n   */\r\n  public constructor(numGaussPoints: number) {\r\n    const maxGauss = 7;  // (As of Nov 2 2018, 7 is a fluffy over-allocation-- the quadrature class only handles up to 5.)\r\n    this.gaussX = new Float64Array(maxGauss);\r\n    this.gaussW = new Float64Array(maxGauss);\r\n    // This sets the number of gauss points.  This integrates exactly for polynomials of (degree 2*numGauss - 1).\r\n    if (numGaussPoints > 5 || numGaussPoints < 1)\r\n      numGaussPoints = 5;\r\n    switch (numGaussPoints) {\r\n      case 1: this.mapXAndWFunction = Quadrature.setupGauss1; break;\r\n      case 2: this.mapXAndWFunction = Quadrature.setupGauss2; break;\r\n      case 3: this.mapXAndWFunction = Quadrature.setupGauss3; break;\r\n      case 4: this.mapXAndWFunction = Quadrature.setupGauss4; break;\r\n      default: this.mapXAndWFunction = Quadrature.setupGauss5; break;\r\n    }\r\n\r\n  }\r\n}\r\n// someday .... http://www.holoborodko.com/pavel/numerical-methods/numerical-integration/overlapped-newton-cotes-quadratures/\r\n"]}

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

@@ -0,0 +1,80 @@
+import { GrowableFloat64Array } from "../geometry3d/GrowableFloat64Array";
+import { Range1d } from "../geometry3d/Range";
+/**
+ * A Range1d array is a set of intervals, such as occur when a line is clipped to a (nonconvex) polygon
+ * @internal
+ */
+export declare class Range1dArray {
+    /** Internal step: Caller supplies rangeA = interval from left operand of set difference {A - B}
+     *  ib = lowest possible index of overlapping interval of {B}
+     *  Output live parts of rangeA, advancing B over intervals that do not extend beyond {rangeA}
+     *  iB is advanced to the first interval whose high is to the right of {rangeA.high}
+     */
+    private static advanceIntervalDifference;
+    /** Intersect intervals in two pre-sorted sets. Output may NOT be the same as either input. */
+    static differenceSorted(dataA: Range1d[], dataB: Range1d[]): Range1d[];
+    /** Internal step: Caller ensures rangeA is the "lower" interval.
+     *  Look rangeB to decide (a) what output interval to create and (b) which read index to advance.
+     *  Returns true or false to indicate whether the value associated with rangeA or rangeB should be incremented after this function returns
+     */
+    private static advanceIntervalIntersection;
+    /** Boolean intersection among the (presorted) input ranges */
+    static intersectSorted(dataA: Range1d[], dataB: Range1d[]): Range1d[];
+    /** Internal step: Read an interval from the array.
+     *  If it overlaps the work interval, advance the work interval, and return true to notify caller to increment read index.
+     */
+    private static advanceIntervalUnion;
+    /** Boolean union among the (presorted) input ranges */
+    static unionSorted(dataA: Range1d[], dataB: Range1d[]): Range1d[];
+    /** Boolean parity among the (presorted) input ranges */
+    static paritySorted(dataA: Range1d[], dataB: Range1d[]): Range1d[];
+    /** Uses the Range1d specific compare function `compareRange1dLexicalLowHigh` for sorting the array of ranges */
+    static sort(data: Range1d[]): void;
+    /** Cleans up the array, compressing any overlapping ranges. If removeZeroLengthRanges is set to true, will also remove any Ranges in the form (x, x) */
+    static simplifySortUnion(data: Range1d[], removeZeroLengthRanges?: boolean): void;
+    /** Apply parity logic among ranges which are not pre-sorted. */
+    static simplifySortParity(data: Range1d[], removeZeroLengthRanges?: boolean): void;
+    /** test if value is "in" by union rules.
+     * * This considers all intervals-- i.e. does not expect or take advantage of sorting.
+     */
+    static testUnion(data: Range1d[], value: number): boolean;
+    /** test if value is "in" by parity rules.
+     * * This considers all intervals-- i.e. does not expect or take advantage of sorting.
+     */
+    static testParity(data: Range1d[], value: number): boolean;
+    /** linear search to count number of intervals which contain `value`.
+     */
+    static countContainingRanges(data: Range1d[], value: number): number;
+    /** return an array with all the low and high values of all the ranges.
+     * @param data array of ranges.
+     * @param sort optionally request immediate sort.
+     * @param compress optionally request removal of duplicates.
+     */
+    static getBreaks(data: Range1d[], result?: GrowableFloat64Array, sort?: boolean, compress?: boolean, clear?: boolean): GrowableFloat64Array;
+    /**  evaluate a point at an array of given fraction values
+     * @param data array of ranges.
+     * @param initialRangeFraction fraction coordinate applied only to first range. (typically negative)
+     * @param rangeFraction fraction within each range.
+     * @param includeDegenerateRange if false, skip rangeFraction for 0-length ranges.
+     * @param gapFraction fraction within interval from each range high to successor low
+     * @param includeDegenerateGap if false, skip rangeFraction for 0-length gaps.
+     * @param finalRangeFraction fraction coordinate applied only to last range (typically an extrapolation above)
+     * @param result array to receive values
+     */
+    static appendFractionalPoints(data: Range1d[], initialRangeFraction: number | undefined, rangeFraction: number | undefined, includeDegenerateRange: boolean, gapFraction: number | undefined, includeDegenerateGap: boolean, finalRangeFraction: number | undefined, result: GrowableFloat64Array | number[]): GrowableFloat64Array | number[];
+    /** Return a single range constructed with the low of range 0 and high of final range in the set.  */
+    static firstLowToLastHigh(data: Range1d[]): Range1d;
+    /** sum the lengths of all ranges */
+    static sumLengths(data: Range1d[]): number;
+    /**
+     * Test if the low,high values are sorted with no overlap.
+     * @param data array of ranges.
+     * @param strict if true, consider exact high-to-low match as overlap.
+     */
+    static isSorted(data: Range1d[], strict?: boolean): boolean;
+}
+/** Checks low's first, then high's
+ * @internal
+ */
+export declare function compareRange1dLexicalLowHigh(a: Range1d, b: Range1d): number;
+//# sourceMappingURL=Range1dArray.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Range1dArray.d.ts","sourceRoot":"","sources":["../../../src/numerics/Range1dArray.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C;;;GAGG;AACH,qBAAa,YAAY;IACvB;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,yBAAyB;IA2BxC,8FAA8F;WAChF,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE;IAW7E;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,2BAA2B;IAW1C,8DAA8D;WAChD,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE;IAyB5E;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAWnC,uDAAuD;WACzC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE;IA0CxE,wDAAwD;WAC1C,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE;IAezE,gHAAgH;WAClG,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE;IAIlC,wJAAwJ;WAC1I,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,sBAAsB,GAAE,OAAe;IA+BxF,gEAAgE;WAClD,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,sBAAsB,GAAE,OAAe;IAqCzF;;OAEG;WACW,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAGhE;;OAEG;WACW,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IASjE;OACG;WACW,qBAAqB,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IAS3E;;;;OAIG;WACW,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,MAAM,CAAC,EAAE,oBAAoB,EAAE,IAAI,GAAE,OAAe,EAAE,QAAQ,GAAE,OAAe,EAAE,KAAK,GAAE,OAAc,GAAG,oBAAoB;IAetK;;;;;;;;;OASG;WACW,sBAAsB,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,oBAAoB,EAAE,MAAM,GAAG,SAAS,EAAE,aAAa,EAAE,MAAM,GAAG,SAAS,EAAE,sBAAsB,EAAE,OAAO,EAChK,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE,oBAAoB,EAAE,OAAO,EAC9D,kBAAkB,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,oBAAoB,GAAG,MAAM,EAAE,GAAG,oBAAoB,GAAG,MAAM,EAAE;IAiBnH,qGAAqG;WACvF,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO;IAK1D,oCAAoC;WACtB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM;IAQjD;;;;OAIG;WACW,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,MAAM,GAAE,OAAc,GAAG,OAAO;CAezE;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAM3E"}

package/lib/esm/numerics/Range1dArray.js

@@ -0,0 +1,358 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Numerics
+ */
+import { Geometry } from "../Geometry";
+import { GrowableFloat64Array } from "../geometry3d/GrowableFloat64Array";
+import { Range1d } from "../geometry3d/Range";
+/**
+ * A Range1d array is a set of intervals, such as occur when a line is clipped to a (nonconvex) polygon
+ * @internal
+ */
+export class Range1dArray {
+    /** Internal step: Caller supplies rangeA = interval from left operand of set difference {A - B}
+     *  ib = lowest possible index of overlapping interval of {B}
+     *  Output live parts of rangeA, advancing B over intervals that do not extend beyond {rangeA}
+     *  iB is advanced to the first interval whose high is to the right of {rangeA.high}
+     */
+    static advanceIntervalDifference(rangeA, dataB, iB, retVal) {
+        const nB = dataB.length;
+        let low = rangeA.low;
+        let high = rangeA.high;
+        while (iB < nB) {
+            const rangeB = dataB[iB];
+            if (rangeB.high < low) {
+                iB++;
+            }
+            else if (rangeB.high <= high) {
+                if (rangeB.low > low)
+                    retVal.push(Range1d.createXX(low, rangeB.low));
+                low = rangeB.high;
+                iB++;
+            }
+            else {
+                // B ends beyond rangeA...
+                if (rangeB.low < high)
+                    high = rangeB.low;
+                break;
+            }
+        }
+        if (low < high)
+            retVal.push(Range1d.createXX(low, high));
+        return retVal;
+    }
+    /** Intersect intervals in two pre-sorted sets. Output may NOT be the same as either input. */
+    static differenceSorted(dataA, dataB) {
+        const nA = dataA.length;
+        const iB = 0;
+        const retVal = [];
+        for (let iA = 0; iA < nA; iA++) {
+            Range1dArray.advanceIntervalDifference(dataA[iA], dataB, iB, retVal);
+        }
+        return retVal;
+    }
+    /** Internal step: Caller ensures rangeA is the "lower" interval.
+     *  Look rangeB to decide (a) what output interval to create and (b) which read index to advance.
+     *  Returns true or false to indicate whether the value associated with rangeA or rangeB should be incremented after this function returns
+     */
+    static advanceIntervalIntersection(rangeA, rangeB, retVal) {
+        if (rangeB.low > rangeA.high) {
+            return true;
+        }
+        else if (rangeB.high >= rangeA.high) {
+            retVal.push(Range1d.createXX(rangeB.low, rangeA.high));
+            return true;
+        }
+        else {
+            retVal.push(Range1d.createXX(rangeB.low, rangeB.high));
+            return false;
+        }
+    }
+    /** Boolean intersection among the (presorted) input ranges */
+    static intersectSorted(dataA, dataB) {
+        let iA = 0;
+        let iB = 0;
+        const nA = dataA.length;
+        const nB = dataB.length;
+        const retVal = [];
+        while (iA < nA && iB < nB) {
+            const rangeA = dataA[iA];
+            const rangeB = dataB[iB];
+            if (rangeA.low <= rangeB.low) {
+                if (Range1dArray.advanceIntervalIntersection(rangeA, rangeB, retVal))
+                    iA++;
+                else
+                    iB++;
+            }
+            else {
+                if (Range1dArray.advanceIntervalIntersection(rangeB, rangeA, retVal))
+                    iB++;
+                else
+                    iA++;
+            }
+        }
+        return retVal;
+    }
+    /** Internal step: Read an interval from the array.
+     *  If it overlaps the work interval, advance the work interval, and return true to notify caller to increment read index.
+     */
+    static advanceIntervalUnion(workRange, source, readIndex) {
+        if (readIndex >= source.length)
+            return false;
+        const candidate = source[readIndex];
+        if (candidate.low > workRange.high)
+            return false;
+        if (candidate.high > workRange.high)
+            workRange.high = candidate.high;
+        return true;
+    }
+    /** Boolean union among the (presorted) input ranges */
+    static unionSorted(dataA, dataB) {
+        const nA = dataA.length;
+        const nB = dataB.length;
+        let iA = 0;
+        let iB = 0;
+        const retVal = [];
+        while (iA < nA && iB < nB) {
+            const rangeA = dataA[iA];
+            const rangeB = dataB[iB];
+            let workRange;
+            // Pull from the lower of rangeA and rangeB. This always advances exactly one of the indices -- progress towards getting out.
+            if (rangeA.low <= rangeB.low) {
+                workRange = rangeA.clone();
+                iA++;
+            }
+            else {
+                workRange = rangeB.clone();
+                iB++;
+            }
+            let toLoop = true;
+            do {
+                const resultA = Range1dArray.advanceIntervalUnion(workRange, dataA, iA);
+                const resultB = Range1dArray.advanceIntervalUnion(workRange, dataB, iB);
+                if (resultA)
+                    iA++;
+                if (resultB)
+                    iB++;
+                if (!(resultA || resultB))
+                    toLoop = false;
+            } while (toLoop);
+            retVal.push(workRange);
+        }
+        while (iA < nA)
+            retVal.push(dataA[iA++]);
+        while (iB < nB)
+            retVal.push(dataB[iB++]);
+        return retVal;
+    }
+    /** Boolean parity among the (presorted) input ranges */
+    static paritySorted(dataA, dataB) {
+        // Combine the two arrays, and then perform a simplification using simplifySortParity function
+        const retVal = [];
+        for (const range of dataA)
+            retVal.push(range.clone());
+        for (const range of dataB)
+            retVal.push(range.clone());
+        // Sort the array
+        retVal.sort(compareRange1dLexicalLowHigh);
+        Range1dArray.simplifySortParity(retVal, true);
+        return retVal;
+    }
+    /** Uses the Range1d specific compare function `compareRange1dLexicalLowHigh` for sorting the array of ranges */
+    static sort(data) {
+        data.sort(compareRange1dLexicalLowHigh);
+    }
+    /** Cleans up the array, compressing any overlapping ranges. If removeZeroLengthRanges is set to true, will also remove any Ranges in the form (x, x) */
+    static simplifySortUnion(data, removeZeroLengthRanges = false) {
+        if (data.length < 2)
+            return;
+        data.sort(compareRange1dLexicalLowHigh);
+        let currentIndex = 0; // last accepted interval
+        for (let i = 1; i < data.length; i++) {
+            if (data[i].low <= data[currentIndex].high) {
+                // extend the current range
+                if (data[i].high > data[currentIndex].high)
+                    data[currentIndex].high = data[i].high;
+            }
+            else {
+                // data[i] is a new entry.
+                currentIndex++;
+                data[currentIndex].setFrom(data[i]);
+            }
+        }
+        data.length = currentIndex + 1;
+        if (removeZeroLengthRanges) {
+            currentIndex = -1;
+            for (let i = 0; i < data.length; i++) {
+                if (data[i].low < data[i].high) {
+                    if (currentIndex < i)
+                        data[++currentIndex].setFrom(data[i]);
+                }
+            }
+        }
+    }
+    /** Apply parity logic among ranges which are not pre-sorted. */
+    static simplifySortParity(data, removeZeroLengthRanges = false) {
+        const numData = [];
+        for (const range of data) {
+            if (range.low !== range.high) {
+                numData.push(range.low);
+                numData.push(range.high);
+            }
+        }
+        const n = numData.length;
+        numData.sort((a, b) => {
+            if (a < b)
+                return -1;
+            if (a > b)
+                return 1;
+            return 0;
+        });
+        let currIdx = 0;
+        let x0;
+        let x1;
+        for (let i = 0; i < n; i += 2) {
+            x0 = numData[i];
+            x1 = numData[i + 1];
+            if (!removeZeroLengthRanges) {
+                Range1d.createXX(x0, x1, data[currIdx++]);
+            }
+            else {
+                // coalesce intervals that share end and start:
+                while (i + 2 < n && numData[i + 2] === x1) {
+                    i += 2;
+                    x1 = numData[i + 1];
+                }
+                if (x1 > x0)
+                    Range1d.createXX(x0, x1, data[currIdx++]);
+            }
+        }
+        data.length = currIdx;
+    }
+    /** test if value is "in" by union rules.
+     * * This considers all intervals-- i.e. does not expect or take advantage of sorting.
+     */
+    static testUnion(data, value) {
+        return this.countContainingRanges(data, value) > 0;
+    }
+    /** test if value is "in" by parity rules.
+     * * This considers all intervals-- i.e. does not expect or take advantage of sorting.
+     */
+    static testParity(data, value) {
+        let inside = false;
+        for (const range of data) {
+            if (range.containsX(value))
+                inside = !inside;
+        }
+        return inside;
+    }
+    /** linear search to count number of intervals which contain `value`.
+     */
+    static countContainingRanges(data, value) {
+        let n = 0;
+        for (const range of data) {
+            if (range.containsX(value))
+                n++;
+        }
+        return n;
+    }
+    /** return an array with all the low and high values of all the ranges.
+     * @param data array of ranges.
+     * @param sort optionally request immediate sort.
+     * @param compress optionally request removal of duplicates.
+     */
+    static getBreaks(data, result, sort = false, compress = false, clear = true) {
+        if (!result)
+            result = new GrowableFloat64Array(2 * data.length);
+        if (clear)
+            result.clear();
+        for (const range of data) {
+            result.push(range.low);
+            result.push(range.high);
+        }
+        if (sort)
+            result.sort();
+        if (compress)
+            result.compressAdjacentDuplicates();
+        return result;
+    }
+    /**  evaluate a point at an array of given fraction values
+     * @param data array of ranges.
+     * @param initialRangeFraction fraction coordinate applied only to first range. (typically negative)
+     * @param rangeFraction fraction within each range.
+     * @param includeDegenerateRange if false, skip rangeFraction for 0-length ranges.
+     * @param gapFraction fraction within interval from each range high to successor low
+     * @param includeDegenerateGap if false, skip rangeFraction for 0-length gaps.
+     * @param finalRangeFraction fraction coordinate applied only to last range (typically an extrapolation above)
+     * @param result array to receive values
+     */
+    static appendFractionalPoints(data, initialRangeFraction, rangeFraction, includeDegenerateRange, gapFraction, includeDegenerateGap, finalRangeFraction, result) {
+        const numRange = data.length;
+        if (numRange > 0) {
+            if (undefined !== initialRangeFraction)
+                result.push(data[0].fractionToPoint(initialRangeFraction));
+            for (let i = 0; i < numRange; i++) {
+                if (rangeFraction !== undefined && (includeDegenerateRange || data[i].low !== data[i].high))
+                    result.push(data[i].fractionToPoint(rangeFraction));
+                if (i > 1 && gapFraction !== undefined && (includeDegenerateGap || data[i].low !== data[i].high))
+                    result.push(Geometry.interpolate(data[i - 1].high, gapFraction, data[i].low));
+            }
+            if (undefined !== finalRangeFraction)
+                result.push(data[numRange - 1].fractionToPoint(finalRangeFraction));
+        }
+        return result;
+    }
+    /** Return a single range constructed with the low of range 0 and high of final range in the set.  */
+    static firstLowToLastHigh(data) {
+        if (data.length === 0)
+            return Range1d.createNull();
+        return Range1d.createXX(data[0].low, data[data.length - 1].high);
+    }
+    /** sum the lengths of all ranges */
+    static sumLengths(data) {
+        let sum = 0.0;
+        for (const range of data) {
+            sum += range.length();
+        }
+        return sum;
+    }
+    /**
+     * Test if the low,high values are sorted with no overlap.
+     * @param data array of ranges.
+     * @param strict if true, consider exact high-to-low match as overlap.
+     */
+    static isSorted(data, strict = true) {
+        const n = data.length;
+        if (strict) {
+            for (let i = 0; i + 1 < n; i++) {
+                if (data[i].high >= data[i + 1].low)
+                    return false;
+            }
+        }
+        else {
+            for (let i = 0; i + 1 < n; i++) {
+                if (data[i].high > data[i + 1].low)
+                    return false;
+            }
+        }
+        return true;
+    }
+}
+/** Checks low's first, then high's
+ * @internal
+ */
+export function compareRange1dLexicalLowHigh(a, b) {
+    if (a.low < b.low)
+        return -1;
+    if (a.low > b.low)
+        return 1;
+    if (a.high < b.high)
+        return -1;
+    if (a.high > b.high)
+        return 1;
+    return 0;
+}
+//# sourceMappingURL=Range1dArray.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Range1dArray.js","sourceRoot":"","sources":["../../../src/numerics/Range1dArray.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAE/F;;GAEG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C;;;GAGG;AACH,MAAM,OAAO,YAAY;IACvB;;;;OAIG;IACK,MAAM,CAAC,yBAAyB,CAAC,MAAe,EAAE,KAAgB,EAAE,EAAU,EAAE,MAAiB;QACvG,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC;QACxB,IAAI,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC;QACrB,IAAI,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACvB,OAAO,EAAE,GAAG,EAAE,EAAE;YACd,MAAM,MAAM,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;YACzB,IAAI,MAAM,CAAC,IAAI,GAAG,GAAG,EAAE;gBACrB,EAAE,EAAE,CAAC;aACN;iBAAM,IAAI,MAAM,CAAC,IAAI,IAAI,IAAI,EAAE;gBAC9B,IAAI,MAAM,CAAC,GAAG,GAAG,GAAG;oBAClB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;gBACjD,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC;gBAClB,EAAE,EAAE,CAAC;aACN;iBAAM;gBACL,0BAA0B;gBAC1B,IAAI,MAAM,CAAC,GAAG,GAAG,IAAI;oBACnB,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC;gBACpB,MAAM;aACP;SACF;QAED,IAAI,GAAG,GAAG,IAAI;YACZ,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;QAE3C,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,8FAA8F;IACvF,MAAM,CAAC,gBAAgB,CAAC,KAAgB,EAAE,KAAgB;QAC/D,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC;QACxB,MAAM,EAAE,GAAG,CAAC,CAAC;QACb,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE;YAC9B,YAAY,CAAC,yBAAyB,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;SACtE;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;OAGG;IACK,MAAM,CAAC,2BAA2B,CAAC,MAAe,EAAE,MAAe,EAAE,MAAiB;QAC5F,IAAI,MAAM,CAAC,GAAG,GAAG,MAAM,CAAC,IAAI,EAAE;YAC5B,OAAO,IAAI,CAAC;SACb;aAAM,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,EAAE;YACrC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;YACvD,OAAO,IAAI,CAAC;SACb;aAAM;YACL,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;YACvD,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IACD,8DAA8D;IACvD,MAAM,CAAC,eAAe,CAAC,KAAgB,EAAE,KAAgB;QAC9D,IAAI,EAAE,GAAG,CAAC,CAAC;QACX,IAAI,EAAE,GAAG,CAAC,CAAC;QACX,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC;QACxB,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC;QACxB,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;YACzB,MAAM,MAAM,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;YACzB,MAAM,MAAM,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;YACzB,IAAI,MAAM,CAAC,GAAG,IAAI,MAAM,CAAC,GAAG,EAAE;gBAC5B,IAAI,YAAY,CAAC,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;oBAClE,EAAE,EAAE,CAAC;;oBAEL,EAAE,EAAE,CAAC;aACR;iBAAM;gBACL,IAAI,YAAY,CAAC,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;oBAClE,EAAE,EAAE,CAAC;;oBAEL,EAAE,EAAE,CAAC;aACR;SACF;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,oBAAoB,CAAC,SAAkB,EAAE,MAAiB,EAAE,SAAiB;QAC1F,IAAI,SAAS,IAAI,MAAM,CAAC,MAAM;YAC5B,OAAO,KAAK,CAAC;QACf,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;QACpC,IAAI,SAAS,CAAC,GAAG,GAAG,SAAS,CAAC,IAAI;YAChC,OAAO,KAAK,CAAC;QACf,IAAI,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC,IAAI;YACjC,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC;QAClC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,uDAAuD;IAChD,MAAM,CAAC,WAAW,CAAC,KAAgB,EAAE,KAAgB;QAC1D,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC;QACxB,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC;QACxB,IAAI,EAAE,GAAG,CAAC,CAAC;QACX,IAAI,EAAE,GAAG,CAAC,CAAC;QACX,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;YACzB,MAAM,MAAM,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;YACzB,MAAM,MAAM,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;YACzB,IAAI,SAAkB,CAAC;YACvB,6HAA6H;YAC7H,IAAI,MAAM,CAAC,GAAG,IAAI,MAAM,CAAC,GAAG,EAAE;gBAC5B,SAAS,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC;gBAC3B,EAAE,EAAE,CAAC;aACN;iBAAM;gBACL,SAAS,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC;gBAC3B,EAAE,EAAE,CAAC;aACN;YAED,IAAI,MAAM,GAAG,IAAI,CAAC;YAClB,GAAG;gBACD,MAAM,OAAO,GAAG,YAAY,CAAC,oBAAoB,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;gBACxE,MAAM,OAAO,GAAG,YAAY,CAAC,oBAAoB,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;gBACxE,IAAI,OAAO;oBACT,EAAE,EAAE,CAAC;gBACP,IAAI,OAAO;oBACT,EAAE,EAAE,CAAC;gBACP,IAAI,CAAC,CAAC,OAAO,IAAI,OAAO,CAAC;oBACvB,MAAM,GAAG,KAAK,CAAC;aAClB,QAAQ,MAAM,EAAE;YAEjB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;SACxB;QAED,OAAO,EAAE,GAAG,EAAE;YACZ,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QAC3B,OAAO,EAAE,GAAG,EAAE;YACZ,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QAE3B,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,wDAAwD;IACjD,MAAM,CAAC,YAAY,CAAC,KAAgB,EAAE,KAAgB;QAC3D,8FAA8F;QAC9F,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,KAAK,MAAM,KAAK,IAAI,KAAK;YACvB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;QAC7B,KAAK,MAAM,KAAK,IAAI,KAAK;YACvB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;QAE7B,iBAAiB;QACjB,MAAM,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAC;QAE1C,YAAY,CAAC,kBAAkB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC9C,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,gHAAgH;IACzG,MAAM,CAAC,IAAI,CAAC,IAAe;QAChC,IAAI,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAC;IAC1C,CAAC;IAED,wJAAwJ;IACjJ,MAAM,CAAC,iBAAiB,CAAC,IAAe,EAAE,yBAAkC,KAAK;QACtF,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC;YACjB,OAAO;QAET,IAAI,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAC;QAExC,IAAI,YAAY,GAAG,CAAC,CAAC,CAAG,yBAAyB;QACjD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACpC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,IAAI,EAAE;gBAC1C,2BAA2B;gBAC3B,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,IAAI;oBACxC,IAAI,CAAC,YAAY,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;aAC1C;iBAAM;gBACL,0BAA0B;gBAC1B,YAAY,EAAE,CAAC;gBACf,IAAI,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;aACrC;SACF;QAED,IAAI,CAAC,MAAM,GAAG,YAAY,GAAG,CAAC,CAAC;QAC/B,IAAI,sBAAsB,EAAE;YAC1B,YAAY,GAAG,CAAC,CAAC,CAAC;YAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBACpC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;oBAC9B,IAAI,YAAY,GAAG,CAAC;wBAClB,IAAI,CAAC,EAAE,YAAY,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;iBACzC;aACF;SACF;IACH,CAAC;IAED,gEAAgE;IACzD,MAAM,CAAC,kBAAkB,CAAC,IAAe,EAAE,yBAAkC,KAAK;QACvF,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,KAAK,MAAM,KAAK,IAAI,IAAI,EAAE;YACxB,IAAI,KAAK,CAAC,GAAG,KAAK,KAAK,CAAC,IAAI,EAAE;gBAC5B,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBACxB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;aAC1B;SACF;QACD,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;QACzB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAS,EAAE,CAAS,EAAU,EAAE;YAC5C,IAAI,CAAC,GAAG,CAAC;gBAAE,OAAO,CAAC,CAAC,CAAC;YACrB,IAAI,CAAC,GAAG,CAAC;gBAAE,OAAO,CAAC,CAAC;YACpB,OAAO,CAAC,CAAC;QACX,CAAC,CAAC,CAAC;QAEH,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,IAAI,EAAE,CAAC;QACP,IAAI,EAAE,CAAC;QACP,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE;YAC7B,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YAChB,EAAE,GAAG,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACpB,IAAI,CAAC,sBAAsB,EAAE;gBAC3B,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;aAC3C;iBAAM;gBACL,+CAA+C;gBAC/C,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;oBACzC,CAAC,IAAI,CAAC,CAAC;oBACP,EAAE,GAAG,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;iBACrB;gBACD,IAAI,EAAE,GAAG,EAAE;oBACT,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;aAC7C;SACF;QAED,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;IACxB,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,SAAS,CAAC,IAAe,EAAE,KAAa;QACpD,OAAO,IAAI,CAAC,qBAAqB,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACrD,CAAC;IACD;;OAEG;IACI,MAAM,CAAC,UAAU,CAAC,IAAe,EAAE,KAAa;QACrD,IAAI,MAAM,GAAG,KAAK,CAAC;QACnB,KAAK,MAAM,KAAK,IAAI,IAAI,EAAE;YACxB,IAAI,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC;gBACxB,MAAM,GAAG,CAAC,MAAM,CAAC;SACpB;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;OACG;IACI,MAAM,CAAC,qBAAqB,CAAC,IAAe,EAAE,KAAa;QAChE,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,KAAK,MAAM,KAAK,IAAI,IAAI,EAAE;YACxB,IAAI,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC;gBACxB,CAAC,EAAE,CAAC;SACP;QACD,OAAO,CAAC,CAAC;IACX,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,SAAS,CAAC,IAAe,EAAE,MAA6B,EAAE,OAAgB,KAAK,EAAE,WAAoB,KAAK,EAAE,QAAiB,IAAI;QAC7I,IAAI,CAAC,MAAM;YAAE,MAAM,GAAG,IAAI,oBAAoB,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QAChE,IAAI,KAAK;YAAE,MAAM,CAAC,KAAK,EAAE,CAAC;QAC1B,KAAK,MAAM,KAAK,IAAI,IAAI,EAAE;YACxB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YACvB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;SACzB;QACD,IAAI,IAAI;YACN,MAAM,CAAC,IAAI,EAAE,CAAC;QAChB,IAAI,QAAQ;YACV,MAAM,CAAC,0BAA0B,EAAE,CAAC;QAEtC,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;;;;;OASG;IACI,MAAM,CAAC,sBAAsB,CAAC,IAAe,EAAE,oBAAwC,EAAE,aAAiC,EAAE,sBAA+B,EAChK,WAA+B,EAAE,oBAA6B,EAC9D,kBAAsC,EAAE,MAAuC;QAC/E,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC;QAC7B,IAAI,QAAQ,GAAG,CAAC,EAAE;YAChB,IAAI,SAAS,KAAK,oBAAoB;gBACpC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,oBAAoB,CAAC,CAAC,CAAC;YAC7D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,EAAE,CAAC,EAAE,EAAE;gBACjC,IAAI,aAAa,KAAK,SAAS,IAAI,CAAC,sBAAsB,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;oBACzF,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CAAC;gBACtD,IAAI,CAAC,GAAG,CAAC,IAAI,WAAW,KAAK,SAAS,IAAI,CAAC,oBAAoB,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;oBAC9F,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;aACjF;YACD,IAAI,SAAS,KAAK,kBAAkB;gBAClC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC,CAAC;SACvE;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,qGAAqG;IAC9F,MAAM,CAAC,kBAAkB,CAAC,IAAe;QAC9C,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YACnB,OAAO,OAAO,CAAC,UAAU,EAAE,CAAC;QAC9B,OAAO,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACnE,CAAC;IACD,oCAAoC;IAC7B,MAAM,CAAC,UAAU,CAAC,IAAe;QACtC,IAAI,GAAG,GAAG,GAAG,CAAC;QACd,KAAK,MAAM,KAAK,IAAI,IAAI,EAAE;YACxB,GAAG,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;SACvB;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,QAAQ,CAAC,IAAe,EAAE,SAAkB,IAAI;QAC5D,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QACtB,IAAI,MAAM,EAAE;YACV,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;gBAC9B,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG;oBACjC,OAAO,KAAK,CAAC;aAChB;SACF;aAAM;YACL,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;gBAC9B,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG;oBAChC,OAAO,KAAK,CAAC;aAChB;SACF;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAED;;GAEG;AACH,MAAM,UAAU,4BAA4B,CAAC,CAAU,EAAE,CAAU;IACjE,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG;QAAE,OAAO,CAAC,CAAC,CAAC;IAC7B,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG;QAAE,OAAO,CAAC,CAAC;IAC5B,IAAI,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI;QAAE,OAAO,CAAC,CAAC,CAAC;IAC/B,IAAI,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI;QAAE,OAAO,CAAC,CAAC;IAC9B,OAAO,CAAC,CAAC;AACX,CAAC","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 { GrowableFloat64Array } from \"../geometry3d/GrowableFloat64Array\";\r\nimport { Range1d } from \"../geometry3d/Range\";\r\n\r\n/**\r\n * A Range1d array is a set of intervals, such as occur when a line is clipped to a (nonconvex) polygon\r\n * @internal\r\n */\r\nexport class Range1dArray {\r\n  /** Internal step: Caller supplies rangeA = interval from left operand of set difference {A - B}\r\n   *  ib = lowest possible index of overlapping interval of {B}\r\n   *  Output live parts of rangeA, advancing B over intervals that do not extend beyond {rangeA}\r\n   *  iB is advanced to the first interval whose high is to the right of {rangeA.high}\r\n   */\r\n  private static advanceIntervalDifference(rangeA: Range1d, dataB: Range1d[], iB: number, retVal: Range1d[]) {\r\n    const nB = dataB.length;\r\n    let low = rangeA.low;\r\n    let high = rangeA.high;\r\n    while (iB < nB) {\r\n      const rangeB = dataB[iB];\r\n      if (rangeB.high < low) {\r\n        iB++;\r\n      } else if (rangeB.high <= high) {\r\n        if (rangeB.low > low)\r\n          retVal.push(Range1d.createXX(low, rangeB.low));\r\n        low = rangeB.high;\r\n        iB++;\r\n      } else {\r\n        // B ends beyond rangeA...\r\n        if (rangeB.low < high)\r\n          high = rangeB.low;\r\n        break;\r\n      }\r\n    }\r\n\r\n    if (low < high)\r\n      retVal.push(Range1d.createXX(low, high));\r\n\r\n    return retVal;\r\n  }\r\n\r\n  /** Intersect intervals in two pre-sorted sets. Output may NOT be the same as either input. */\r\n  public static differenceSorted(dataA: Range1d[], dataB: Range1d[]): Range1d[] {\r\n    const nA = dataA.length;\r\n    const iB = 0;\r\n    const retVal: Range1d[] = [];\r\n    for (let iA = 0; iA < nA; iA++) {\r\n      Range1dArray.advanceIntervalDifference(dataA[iA], dataB, iB, retVal);\r\n    }\r\n\r\n    return retVal;\r\n  }\r\n\r\n  /** Internal step: Caller ensures rangeA is the \"lower\" interval.\r\n   *  Look rangeB to decide (a) what output interval to create and (b) which read index to advance.\r\n   *  Returns true or false to indicate whether the value associated with rangeA or rangeB should be incremented after this function returns\r\n   */\r\n  private static advanceIntervalIntersection(rangeA: Range1d, rangeB: Range1d, retVal: Range1d[]): boolean {\r\n    if (rangeB.low > rangeA.high) {\r\n      return true;\r\n    } else if (rangeB.high >= rangeA.high) {\r\n      retVal.push(Range1d.createXX(rangeB.low, rangeA.high));\r\n      return true;\r\n    } else {\r\n      retVal.push(Range1d.createXX(rangeB.low, rangeB.high));\r\n      return false;\r\n    }\r\n  }\r\n  /** Boolean intersection among the (presorted) input ranges */\r\n  public static intersectSorted(dataA: Range1d[], dataB: Range1d[]): Range1d[] {\r\n    let iA = 0;\r\n    let iB = 0;\r\n    const nA = dataA.length;\r\n    const nB = dataB.length;\r\n    const retVal: Range1d[] = [];\r\n    while (iA < nA && iB < nB) {\r\n      const rangeA = dataA[iA];\r\n      const rangeB = dataB[iB];\r\n      if (rangeA.low <= rangeB.low) {\r\n        if (Range1dArray.advanceIntervalIntersection(rangeA, rangeB, retVal))\r\n          iA++;\r\n        else\r\n          iB++;\r\n      } else {\r\n        if (Range1dArray.advanceIntervalIntersection(rangeB, rangeA, retVal))\r\n          iB++;\r\n        else\r\n          iA++;\r\n      }\r\n    }\r\n\r\n    return retVal;\r\n  }\r\n\r\n  /** Internal step: Read an interval from the array.\r\n   *  If it overlaps the work interval, advance the work interval, and return true to notify caller to increment read index.\r\n   */\r\n  private static advanceIntervalUnion(workRange: Range1d, source: Range1d[], readIndex: number): boolean {\r\n    if (readIndex >= source.length)\r\n      return false;\r\n    const candidate = source[readIndex];\r\n    if (candidate.low > workRange.high)\r\n      return false;\r\n    if (candidate.high > workRange.high)\r\n      workRange.high = candidate.high;\r\n    return true;\r\n  }\r\n\r\n  /** Boolean union among the (presorted) input ranges */\r\n  public static unionSorted(dataA: Range1d[], dataB: Range1d[]): Range1d[] {\r\n    const nA = dataA.length;\r\n    const nB = dataB.length;\r\n    let iA = 0;\r\n    let iB = 0;\r\n    const retVal: Range1d[] = [];\r\n    while (iA < nA && iB < nB) {\r\n      const rangeA = dataA[iA];\r\n      const rangeB = dataB[iB];\r\n      let workRange: Range1d;\r\n      // Pull from the lower of rangeA and rangeB. This always advances exactly one of the indices -- progress towards getting out.\r\n      if (rangeA.low <= rangeB.low) {\r\n        workRange = rangeA.clone();\r\n        iA++;\r\n      } else {\r\n        workRange = rangeB.clone();\r\n        iB++;\r\n      }\r\n\r\n      let toLoop = true;\r\n      do {\r\n        const resultA = Range1dArray.advanceIntervalUnion(workRange, dataA, iA);\r\n        const resultB = Range1dArray.advanceIntervalUnion(workRange, dataB, iB);\r\n        if (resultA)\r\n          iA++;\r\n        if (resultB)\r\n          iB++;\r\n        if (!(resultA || resultB))\r\n          toLoop = false;\r\n      } while (toLoop);\r\n\r\n      retVal.push(workRange);\r\n    }\r\n\r\n    while (iA < nA)\r\n      retVal.push(dataA[iA++]);\r\n    while (iB < nB)\r\n      retVal.push(dataB[iB++]);\r\n\r\n    return retVal;\r\n  }\r\n\r\n  /** Boolean parity among the (presorted) input ranges */\r\n  public static paritySorted(dataA: Range1d[], dataB: Range1d[]): Range1d[] {\r\n    // Combine the two arrays, and then perform a simplification using simplifySortParity function\r\n    const retVal: Range1d[] = [];\r\n    for (const range of dataA)\r\n      retVal.push(range.clone());\r\n    for (const range of dataB)\r\n      retVal.push(range.clone());\r\n\r\n    // Sort the array\r\n    retVal.sort(compareRange1dLexicalLowHigh);\r\n\r\n    Range1dArray.simplifySortParity(retVal, true);\r\n    return retVal;\r\n  }\r\n\r\n  /** Uses the Range1d specific compare function `compareRange1dLexicalLowHigh` for sorting the array of ranges */\r\n  public static sort(data: Range1d[]) {\r\n    data.sort(compareRange1dLexicalLowHigh);\r\n  }\r\n\r\n  /** Cleans up the array, compressing any overlapping ranges. If removeZeroLengthRanges is set to true, will also remove any Ranges in the form (x, x) */\r\n  public static simplifySortUnion(data: Range1d[], removeZeroLengthRanges: boolean = false) {\r\n    if (data.length < 2)\r\n      return;\r\n\r\n    data.sort(compareRange1dLexicalLowHigh);\r\n\r\n    let currentIndex = 0;   // last accepted interval\r\n    for (let i = 1; i < data.length; i++) {\r\n      if (data[i].low <= data[currentIndex].high) {\r\n        // extend the current range\r\n        if (data[i].high > data[currentIndex].high)\r\n          data[currentIndex].high = data[i].high;\r\n      } else {\r\n        // data[i] is a new entry.\r\n        currentIndex++;\r\n        data[currentIndex].setFrom(data[i]);\r\n      }\r\n    }\r\n\r\n    data.length = currentIndex + 1;\r\n    if (removeZeroLengthRanges) {\r\n      currentIndex = -1;\r\n      for (let i = 0; i < data.length; i++) {\r\n        if (data[i].low < data[i].high) {\r\n          if (currentIndex < i)\r\n            data[++currentIndex].setFrom(data[i]);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /** Apply parity logic among ranges which are not pre-sorted. */\r\n  public static simplifySortParity(data: Range1d[], removeZeroLengthRanges: boolean = false) {\r\n    const numData: number[] = [];\r\n    for (const range of data) {\r\n      if (range.low !== range.high) {\r\n        numData.push(range.low);\r\n        numData.push(range.high);\r\n      }\r\n    }\r\n    const n = numData.length;\r\n    numData.sort((a: number, b: number): number => {\r\n      if (a < b) return -1;\r\n      if (a > b) return 1;\r\n      return 0;\r\n    });\r\n\r\n    let currIdx = 0;\r\n    let x0;\r\n    let x1;\r\n    for (let i = 0; i < n; i += 2) {\r\n      x0 = numData[i];\r\n      x1 = numData[i + 1];\r\n      if (!removeZeroLengthRanges) {\r\n        Range1d.createXX(x0, x1, data[currIdx++]);\r\n      } else {\r\n        // coalesce intervals that share end and start:\r\n        while (i + 2 < n && numData[i + 2] === x1) {\r\n          i += 2;\r\n          x1 = numData[i + 1];\r\n        }\r\n        if (x1 > x0)\r\n          Range1d.createXX(x0, x1, data[currIdx++]);\r\n      }\r\n    }\r\n\r\n    data.length = currIdx;\r\n  }\r\n\r\n  /** test if value is \"in\" by union rules.\r\n   * * This considers all intervals-- i.e. does not expect or take advantage of sorting.\r\n   */\r\n  public static testUnion(data: Range1d[], value: number): boolean {\r\n    return this.countContainingRanges(data, value) > 0;\r\n  }\r\n  /** test if value is \"in\" by parity rules.\r\n   * * This considers all intervals-- i.e. does not expect or take advantage of sorting.\r\n   */\r\n  public static testParity(data: Range1d[], value: number): boolean {\r\n    let inside = false;\r\n    for (const range of data) {\r\n      if (range.containsX(value))\r\n        inside = !inside;\r\n    }\r\n    return inside;\r\n  }\r\n\r\n  /** linear search to count number of intervals which contain `value`.\r\n   */\r\n  public static countContainingRanges(data: Range1d[], value: number): number {\r\n    let n = 0;\r\n    for (const range of data) {\r\n      if (range.containsX(value))\r\n        n++;\r\n    }\r\n    return n;\r\n  }\r\n\r\n  /** return an array with all the low and high values of all the ranges.\r\n   * @param data array of ranges.\r\n   * @param sort optionally request immediate sort.\r\n   * @param compress optionally request removal of duplicates.\r\n   */\r\n  public static getBreaks(data: Range1d[], result?: GrowableFloat64Array, sort: boolean = false, compress: boolean = false, clear: boolean = true): GrowableFloat64Array {\r\n    if (!result) result = new GrowableFloat64Array(2 * data.length);\r\n    if (clear) result.clear();\r\n    for (const range of data) {\r\n      result.push(range.low);\r\n      result.push(range.high);\r\n    }\r\n    if (sort)\r\n      result.sort();\r\n    if (compress)\r\n      result.compressAdjacentDuplicates();\r\n\r\n    return result;\r\n  }\r\n\r\n  /**  evaluate a point at an array of given fraction values\r\n   * @param data array of ranges.\r\n   * @param initialRangeFraction fraction coordinate applied only to first range. (typically negative)\r\n   * @param rangeFraction fraction within each range.\r\n   * @param includeDegenerateRange if false, skip rangeFraction for 0-length ranges.\r\n   * @param gapFraction fraction within interval from each range high to successor low\r\n   * @param includeDegenerateGap if false, skip rangeFraction for 0-length gaps.\r\n   * @param finalRangeFraction fraction coordinate applied only to last range (typically an extrapolation above)\r\n   * @param result array to receive values\r\n   */\r\n  public static appendFractionalPoints(data: Range1d[], initialRangeFraction: number | undefined, rangeFraction: number | undefined, includeDegenerateRange: boolean,\r\n    gapFraction: number | undefined, includeDegenerateGap: boolean,\r\n    finalRangeFraction: number | undefined, result: GrowableFloat64Array | number[]): GrowableFloat64Array | number[] {\r\n    const numRange = data.length;\r\n    if (numRange > 0) {\r\n      if (undefined !== initialRangeFraction)\r\n        result.push(data[0].fractionToPoint(initialRangeFraction));\r\n      for (let i = 0; i < numRange; i++) {\r\n        if (rangeFraction !== undefined && (includeDegenerateRange || data[i].low !== data[i].high))\r\n          result.push(data[i].fractionToPoint(rangeFraction));\r\n        if (i > 1 && gapFraction !== undefined && (includeDegenerateGap || data[i].low !== data[i].high))\r\n          result.push(Geometry.interpolate(data[i - 1].high, gapFraction, data[i].low));\r\n      }\r\n      if (undefined !== finalRangeFraction)\r\n        result.push(data[numRange - 1].fractionToPoint(finalRangeFraction));\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /** Return a single range constructed with the low of range 0 and high of final range in the set.  */\r\n  public static firstLowToLastHigh(data: Range1d[]): Range1d {\r\n    if (data.length === 0)\r\n      return Range1d.createNull();\r\n    return Range1d.createXX(data[0].low, data[data.length - 1].high);\r\n  }\r\n  /** sum the lengths of all ranges */\r\n  public static sumLengths(data: Range1d[]): number {\r\n    let sum = 0.0;\r\n    for (const range of data) {\r\n      sum += range.length();\r\n    }\r\n    return sum;\r\n  }\r\n\r\n  /**\r\n   * Test if the low,high values are sorted with no overlap.\r\n   * @param data array of ranges.\r\n   * @param strict if true, consider exact high-to-low match as overlap.\r\n   */\r\n  public static isSorted(data: Range1d[], strict: boolean = true): boolean {\r\n    const n = data.length;\r\n    if (strict) {\r\n      for (let i = 0; i + 1 < n; i++) {\r\n        if (data[i].high >= data[i + 1].low)\r\n          return false;\r\n      }\r\n    } else {\r\n      for (let i = 0; i + 1 < n; i++) {\r\n        if (data[i].high > data[i + 1].low)\r\n          return false;\r\n      }\r\n    }\r\n    return true;\r\n  }\r\n}\r\n\r\n/** Checks low's first, then high's\r\n * @internal\r\n */\r\nexport function compareRange1dLexicalLowHigh(a: Range1d, b: Range1d): number {\r\n  if (a.low < b.low) return -1;\r\n  if (a.low > b.low) return 1;\r\n  if (a.high < b.high) return -1;\r\n  if (a.high > b.high) return 1;\r\n  return 0;\r\n}\r\n"]}

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

@@ -0,0 +1,51 @@
+import { Point3d } from "../geometry3d/Point3dVector3d";
+/**
+ * Linear system operations on a matrix with data only on the diagonal and its immediate left and right neighbors
+ * @internal
+ */
+export declare class TriDiagonalSystem {
+    private _aLeft;
+    private _aRight;
+    private _aDiag;
+    private _b;
+    private _x;
+    private _dataState;
+    constructor(n: number);
+    /** Reset to RawMatrix state with all coefficients zero */
+    reset(): void;
+    /** Install data in a row of the matrix */
+    setRow(row: number, left: number, diag: number, right: number): void;
+    /** Add to row of matrix */
+    addToRow(row: number, left: number, diag: number, right: number): void;
+    /** Install data in the right side (B) vector */
+    setB(row: number, bb: number): void;
+    /** Add to an entry in the right side (B) vector */
+    addToB(row: number, bb: number): void;
+    /** Access data from the right side (B) vector */
+    getB(row: number): number;
+    /** Install data in the solution (X) vector */
+    setX(row: number, xx: number): void;
+    /** Access data from the solution (X) vector */
+    getX(row: number): number;
+    /** Get method for matrix and vector order */
+    order(): number;
+    /** Compute product of AX and save as B */
+    multiplyAX(): boolean;
+    /** Compute product of AX and save as B */
+    multiplyAXPoints(pointX: Point3d[], pointB: Point3d[]): boolean;
+    /** Multiply the stored factors together to return to plain matrix form */
+    defactor(): boolean;
+    /** Factor the tridiagonal matrix to LU parts. b, x, not altered */
+    factor(): boolean;
+    /** Solve AX=B. A is left in factored state. B unchanged. */
+    factorAndBackSubstitute(): boolean;
+    /** Solve AX=B. A is left in factored state. B unchanged. vectorB and vectorX may be the same array */
+    factorAndBackSubstitutePointArrays(vectorB: Point3d[], vectorX: Point3d[]): boolean;
+    /** Allocate a complete copy */
+    copy(): TriDiagonalSystem;
+    /** return an array form that may be useful for display ... */
+    flatten(): any;
+    /** return an array form that may be useful for display ... */
+    flattenWithPoints(xyzB: Point3d[]): any;
+}
+//# sourceMappingURL=TriDiagonalSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TriDiagonalSystem.d.ts","sourceRoot":"","sources":["../../../src/numerics/TriDiagonalSystem.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAQxD;;;GAGG;AACH,qBAAa,iBAAiB;IAG5B,OAAO,CAAC,MAAM,CAAe;IAE7B,OAAO,CAAC,OAAO,CAAe;IAE9B,OAAO,CAAC,MAAM,CAAe;IAE7B,OAAO,CAAC,EAAE,CAAe;IAEzB,OAAO,CAAC,EAAE,CAAe;IAEzB,OAAO,CAAC,UAAU,CAAa;gBAEnB,CAAC,EAAE,MAAM;IASrB,0DAA0D;IACnD,KAAK;IAOZ,0CAA0C;IACnC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAKpE,2BAA2B;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAKtE,gDAAgD;IACzC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAGnC,mDAAmD;IAC5C,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAGrC,iDAAiD;IAC1C,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAGhC,8CAA8C;IACvC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAGnC,+CAA+C;IACxC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAGhC,6CAA6C;IACtC,KAAK,IAAI,MAAM;IAGtB,0CAA0C;IACnC,UAAU,IAAI,OAAO;IA6B5B,0CAA0C;IACnC,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO;IAsCtE,0EAA0E;IACnE,QAAQ,IAAI,OAAO;IAiB1B,mEAAmE;IAC5D,MAAM,IAAI,OAAO;IAqBxB,4DAA4D;IACrD,uBAAuB,IAAI,OAAO;IAyBzC,sGAAsG;IAC/F,kCAAkC,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,OAAO;IA8C1F,+BAA+B;IACxB,IAAI,IAAI,iBAAiB;IAchC,8DAA8D;IACvD,OAAO,IAAI,GAAG;IAWrB,8DAA8D;IACvD,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,GAAG;CAU/C"}