@itwin/core-geometry 3.6.0-dev.47 → 3.6.0-dev.50

package/lib/esm/geometry3d/Matrix3d.js

@@ -47,7 +47,7 @@ export class PackedMatrix3dOps {
         dest[8] = a22;
     }
     /**
-     * * multiply 3x3 matrix `a*b`, store in c.
+     * Multiply 3x3 matrix `a*b`, store in `result`.
      * * All params assumed length 9, allocated by caller.
      * * c may alias either input.
      */
@@ -58,7 +58,7 @@ export class PackedMatrix3dOps {
         return result;
     }
     /**
-     * * multiply 3x3 matrix `a*bTranspose`, store in c.
+     * Multiply 3x3 matrix `a*bTranspose`, store in `result`.
      * * All params assumed length 9, allocated by caller.
      * * c may alias either input.
      */
@@ -69,7 +69,7 @@ export class PackedMatrix3dOps {
         return result;
     }
     /**
-     * * multiply 3x3 matrix `a*bTranspose`, store in c.
+     * Multiply 3x3 matrix `aTranspose*b`, store in `result`.
      * * All params assumed length 9, allocated by caller.
      * * c may alias either input.
      */
@@ -79,7 +79,7 @@ export class PackedMatrix3dOps {
         PackedMatrix3dOps.loadMatrix(result, (a[0] * b[0] + a[3] * b[3] + a[6] * b[6]), (a[0] * b[1] + a[3] * b[4] + a[6] * b[7]), (a[0] * b[2] + a[3] * b[5] + a[6] * b[8]), (a[1] * b[0] + a[4] * b[3] + a[7] * b[6]), (a[1] * b[1] + a[4] * b[4] + a[7] * b[7]), (a[1] * b[2] + a[4] * b[5] + a[7] * b[8]), (a[2] * b[0] + a[5] * b[3] + a[8] * b[6]), (a[2] * b[1] + a[5] * b[4] + a[8] * b[7]), (a[2] * b[2] + a[5] * b[5] + a[8] * b[8]));
         return result;
     }
-    /** transpose 3x3 coefficients in place */
+    /** Transpose 3x3 matrix `a` in place */
     static transposeInPlace(a) {
         let q = a[1];
         a[1] = a[3];
@@ -91,10 +91,14 @@ export class PackedMatrix3dOps {
         a[5] = a[7];
         a[7] = q;
     }
-    /** transpose 3x3 coefficients in place */
+    /**
+     * Returns the transpose of 3x3 matrix `a`
+     * * If `dest` is passed as argument, then the function copies the transpose of 3x3 matrix `a` into `dest`
+     * * `a` is not changed unless also passed as the dest, i.e., copyTransposed(a,a) transposes `a` in place
+     */
     static copyTransposed(a, dest) {
         if (dest === a) {
-            PackedMatrix3dOps.transposeInPlace(a);
+            PackedMatrix3dOps.transposeInPlace(dest);
         }
         else {
             if (!dest)
@@ -111,7 +115,7 @@ export class PackedMatrix3dOps {
         }
         return dest;
     }
-    /** transpose 3x3 coefficients in place */
+    /** Copy matrix `a` entries into `dest` */
     static copy(a, dest) {
         if (dest !== a) {
             dest[0] = a[0];
@@ -129,29 +133,31 @@ export class PackedMatrix3dOps {
 }
 /** A Matrix3d is tagged indicating one of the following states:
  * * unknown: it is not know if the matrix is invertible.
- * * inverseStored: the matrix has its inverse stored
+ * * inverseStored: the matrix has its inverse stored.
  * * singular: the matrix is known to be singular.
  * @public
  */
 export var InverseMatrixState;
 (function (InverseMatrixState) {
     /**
-     * * The invertibility of the  `coffs` array has not been determined.
-     * * Any `inverseCoffs` contents are random.
+     * The invertibility of the `coffs` array has not been determined.
+     * Any `inverseCoffs` contents are random.
      */
     InverseMatrixState[InverseMatrixState["unknown"] = 0] = "unknown";
-    /** An inverse was computed and stored as the `inverseCoffs` */
+    /**
+     * An inverse was computed and stored as the `inverseCoffs`
+     */
     InverseMatrixState[InverseMatrixState["inverseStored"] = 1] = "inverseStored";
     /**
-     * * The `coffs` array is known to be singular.
-     * * Any `inverseCoffs` contents are random.
+     * The `coffs` array is known to be singular.
+     * Any `inverseCoffs` contents are random.
      */
     InverseMatrixState[InverseMatrixState["singular"] = 2] = "singular";
 })(InverseMatrixState || (InverseMatrixState = {}));
 /** A Matrix3d is a 3x3 matrix.
  * * A very common use is to hold a rigid body rotation (which has no scaling or skew), but the 3x3 contents can
  * also hold scaling and skewing.
- * * The matrix with 2-dimensional layout
+ * * The matrix with 2-dimensional layout (note: a 2d array can be shown by a matrix)
  * ```
  * equation
  *      \matrixXY{A}
@@ -163,19 +169,21 @@ export var InverseMatrixState;
  * ```
  * * If the matrix inverse is known it is stored in the inverseCoffs array.
  * * The inverse status (`unknown`, `inverseStored`, `singular`) status is indicated by the `inverseState` property.
- * * construction methods that are able to trivially construct the inverse store it immediately and note that in the inverseState.
- * * constructions (e.g. createRowValues) for which the inverse is not immediately known mark the
- *     inverseState as unknown.
- * * Later queries for the inverse trigger full computation if needed at that time.
+ * * Construction methods that are able to trivially construct the inverse, store it immediately and note that in
+ * the inverseState.
+ * * Constructions (e.g. createRowValues) for which the inverse is not immediately known mark the inverseState as
+ * unknown.
+ * * Later queries for the inverse, trigger full computation if needed at that time.
  * * Most matrix queries are present with both "column" and "row" variants.
- * * Usage elsewhere in the library is typically "column" based.  For example, in a Transform
- *     that carries a coordinate frame the matrix columns are the unit vectors for the axes.
+ * * Usage elsewhere in the library is typically "column" based.  For example, in a Transform that carries a
+ * coordinate frame, the matrix columns are the unit vectors for the axes.
  * @public
  */
 export class Matrix3d {
     /**
-     *
-     * @param coffs optional coefficient array. This is captured.
+     * Constructor
+     * @param coffs optional coefficient array.
+     * * **WARNING:** coffs is captured (i.e., is now owned by the Matrix3d object and can be modified by it).
      */
     constructor(coffs) {
         this.coffs = coffs ? coffs : new Float64Array(9);
@@ -193,14 +201,16 @@ export class Matrix3d {
     /** Freeze this Matrix3d. */
     freeze() {
         this.computeCachedInverse(true);
-        /* hm.. can't freeze the Float64Arrays . . .
+        /*
+        hm.. can't freeze the Float64Arrays..
         Object.freeze(this.coffs);
         if (this.inverseCoffs)
           Object.freeze(this.inverseCoffs);
         */
         return Object.freeze(this);
     }
-    /** Return a json object containing the 9 numeric entries as a single array in row major order,
+    /**
+     * Return a json object containing the 9 numeric entries as a single array in row major order,
      * `[ [1, 2, 3],[ 4, 5, 6], [7, 8, 9] ]`
      */
     toJSON() {
@@ -208,46 +218,81 @@ export class Matrix3d {
             [this.coffs[3], this.coffs[4], this.coffs[5]],
             [this.coffs[6], this.coffs[7], this.coffs[8]]];
     }
-    /** copy data from various input forms to this matrix.
+    /**
+     * Copy data from various input forms to this matrix.
      * The source can be:
      * * Another `Matrix3d`
      * * An array of 3 arrays, each of which has the 3 numbers for a row of the matrix.
-     * * An array of 9 numbers in row major order.
+     * * An array of 4 or 9 numbers in row major order.
+     * * **WARNING:** if json is an array of numbers but size is not 4 or 9, the matrix is set to zeros.
      */
     setFromJSON(json) {
         this.inverseCoffs = undefined;
+        // if no json is passed
         if (!json) {
             this.setRowValues(0, 0, 0, 0, 0, 0, 0, 0, 0);
             return;
         }
+        // if json is Matrix3d
         if (!Array.isArray(json)) {
             if (json instanceof Matrix3d)
                 this.setFrom(json);
             return;
         }
+        // if json is Matrix3dProps and is an array of arrays
         if (Geometry.isArrayOfNumberArray(json, 3, 3)) {
             const data = json;
             this.setRowValues(data[0][0], data[0][1], data[0][2], data[1][0], data[1][1], data[1][2], data[2][0], data[2][1], data[2][2]);
             return;
         }
+        // if json is Matrix3dProps and is an array of numbers
         if (json.length === 9) {
             const data = json;
             this.setRowValues(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8]);
+            return;
         }
         else if (json.length === 4) {
             const data = json;
             this.setRowValues(data[0], data[1], 0, data[2], data[3], 0, 0, 0, 1);
+            return;
         }
+        // if json is Matrix3dProps but is not the right size
+        this.setRowValues(0, 0, 0, 0, 0, 0, 0, 0, 0);
+        return;
+    }
+    /** Return a new Matrix3d constructed from contents of the json value. See `setFromJSON` for layout rules */
+    static fromJSON(json) {
+        const result = Matrix3d.createIdentity();
+        result.setFromJSON(json);
+        return result;
     }
-    /** Return a new Matrix3d constructed from contents of the json value. Se `setFromJSON` for layout rules */
-    static fromJSON(json) { const result = Matrix3d.createIdentity(); result.setFromJSON(json); return result; }
-    /** Test if this Matrix3d and other are within tolerance in all numeric entries.
+    /**
+     * Test if `this` and `other` are within tolerance in all numeric entries.
      * @param tol optional tolerance for comparisons by Geometry.isDistanceWithinTol
      */
     isAlmostEqual(other, tol) {
         return Geometry.isDistanceWithinTol(this.maxDiff(other), tol);
     }
-    /** Test if `this` and `other` have almost equal Z column and have X and Y columns differing only by a rotation around that Z.
+    /**
+     * Test if `this` and `other` are within tolerance in the column entries specified by `columnIndex`.
+     * @param tol optional tolerance for comparisons by Geometry.isDistanceWithinTol
+     */
+    isAlmostEqualColumn(columnIndex, other, tol) {
+        const max = Geometry.maxAbsXYZ(this.coffs[columnIndex] - other.coffs[columnIndex], this.coffs[columnIndex + 3] - other.coffs[columnIndex + 3], this.coffs[columnIndex + 6] - other.coffs[columnIndex + 6]);
+        return Geometry.isDistanceWithinTol(max, tol);
+    }
+    /**
+     * Test if column (specified by `columnIndex`) entries of `this` and [ax,ay,az] are within tolerance.
+     * @param tol optional tolerance for comparisons by Geometry.isDistanceWithinTol
+     */
+    isAlmostEqualColumnXYZ(columnIndex, ax, ay, az, tol) {
+        const max = Geometry.maxAbsXYZ(this.coffs[columnIndex] - ax, this.coffs[columnIndex + 3] - ay, this.coffs[columnIndex + 6] - az);
+        return Geometry.isDistanceWithinTol(max, tol);
+    }
+    /**
+     * Test if `this` and `other` have almost equal Z column and have X and Y columns differing only by a
+     * rotation of the same angle around that Z.
+     * * **WARNING:** X and Y columns have to be perpendicular to Z column in both `this` and `other`.
      * @param tol optional tolerance for comparisons by Geometry.isDistanceWithinTol
      */
     isAlmostEqualAllowZRotation(other, tol) {
@@ -255,10 +300,15 @@ export class Matrix3d {
             return true;
         if (this.isAlmostEqualColumn(AxisIndex.Z, other, tol)) {
             const radians = Angle.radiansBetweenVectorsXYZ(this.coffs[0], this.coffs[3], this.coffs[6], other.coffs[0], other.coffs[3], other.coffs[6]);
-            const angle = Angle.createRadians(radians);
+            const angle = Angle.createRadians(radians); // angle between X columns in `this` and `other`
             const columnX = this.columnX();
             const columnY = this.columnY();
             const columnZ = this.columnZ();
+            /**
+             * Here we rotate this.columnX() around this.columnZ() by "angle" and expect to get other.columnX().
+             * Then we rotate this.columnY() around this.columnZ() by the same "angle" and if we get other.columnY(),
+             * that means this` and `other` have X and Y columns differing only by a rotation around that Z.
+             */
             let column = Vector3d.createRotateVectorAroundVector(columnX, columnZ, angle);
             if (other.isAlmostEqualColumnXYZ(0, column.x, column.y, column.z, tol)) {
                 column = Vector3d.createRotateVectorAroundVector(columnY, columnZ, angle);
@@ -267,16 +317,10 @@ export class Matrix3d {
         }
         return false;
     }
-    isAlmostEqualColumn(columnIndex, other, tol) {
-        const a = Geometry.maxAbsXYZ(this.coffs[columnIndex] - other.coffs[columnIndex], this.coffs[columnIndex + 3] - other.coffs[columnIndex + 3], this.coffs[columnIndex + 6] - other.coffs[columnIndex + 6]);
-        return Geometry.isDistanceWithinTol(a, tol);
-    }
-    isAlmostEqualColumnXYZ(columnIndex, ax, ay, az, tol) {
-        const a = Geometry.maxAbsXYZ(this.coffs[columnIndex] - ax, this.coffs[columnIndex + 3] - ay, this.coffs[columnIndex + 6] - az);
-        return Geometry.isDistanceWithinTol(a, tol);
-    }
     /** Test for exact (bitwise) equality with other. */
-    isExactEqual(other) { return this.maxDiff(other) === 0.0; }
+    isExactEqual(other) {
+        return this.maxDiff(other) === 0.0;
+    }
     /** test if all entries in the z row and column are exact 001, i.e. the matrix only acts in 2d */
     get isXY() {
         return this.coffs[2] === 0.0
@@ -285,10 +329,16 @@ export class Matrix3d {
             && this.coffs[7] === 0.0
             && this.coffs[8] === 1.0;
     }
-    // !! does not clear supplied result !!
-    static _create(result) { return result ? result : new Matrix3d(); }
-    /** Returns a Matrix3d populated by numeric values given in row-major order.
-     *  set all entries in the matrix from call parameters appearing in row - major order, i.e.
+    /**
+     * If result is not provided, then the method returns a new (zeroed) matrix; otherwise the result is
+     * not zeroed first and is just returned as-is.
+     */
+    static _create(result) {
+        return result ? result : new Matrix3d();
+    }
+    /**
+     * Returns a Matrix3d populated by numeric values given in row-major order.
+     * Sets all entries in the matrix from call parameters appearing in row-major order, i.e.
      * ```
      * equation
      * \begin{bmatrix}a_{xx}\ a_{xy}\ a_{xz}\\ a_{yx}\ a_{yy}\ a_{yz}\\ a_{zx}\ a_{zy}\ a_{zz}\end{bmatrix}
@@ -319,7 +369,7 @@ export class Matrix3d {
     }
     /**
      * Create a Matrix3d with caller-supplied coefficients and optional inverse coefficients.
-     * * The inputs are captured into the new Matrix3d.
+     * * The inputs are captured into (i.e., owned by) the new Matrix3d.
      * * The caller is responsible for validity of the inverse coefficients.
      * @param coffs (required) array of 9 coefficients.
      * @param inverseCoffs (optional) array of 9 coefficients.
@@ -337,12 +387,15 @@ export class Matrix3d {
         return result;
     }
     /**
-     * create a matrix by distributing vectors to columns in one of 6 orders.
+     * Create a matrix by distributing vectors to columns in one of 6 orders.
      * @param axisOrder identifies where the columns are placed.
-     * @param columnA vector to place in the first column named by the axis order.
-     * @param columnB vector to place in the second column named by the axis order.
-     * @param columnC vector to place in the third column named by the axis order.
-     * @param result
+     * @param columnA vector to place in the column specified by first letter in the AxisOrder name.
+     * @param columnB vector to place in the column specified by second letter in the AxisOrder name.
+     * @param columnC vector to place in the column specified by third letter in the AxisOrder name.
+     * @param result optional result matrix3d
+     * * Example: If you pass AxisOrder.YZX, then result will be [columnC, columnA, columnB] because
+     * first letter Y means columnA should go to the second column, second letter Z means columnB should
+     * go to the third column, and third letter X means columnC should go to the first column.
      */
     static createColumnsInAxisOrder(axisOrder, columnA, columnB, columnC, result) {
         if (!result)
@@ -362,13 +415,26 @@ export class Matrix3d {
         else if (axisOrder === AxisOrder.ZYX) {
             result.setColumns(columnC, columnB, columnA);
         }
-        else { // fallthrough should only happen for AxisOrder.XYZ
+        else { // AxisOrder.XYZ
             result.setColumns(columnA, columnB, columnC);
         }
         return result;
     }
     /**
-     *  set all entries in the matrix from call parameters appearing in row-major order.
+   * Copy the transpose of the coffs to the inverseCoffs.
+   * * Mark the matrix as inverseStored.
+   */
+    setupInverseTranspose() {
+        const coffs = this.coffs;
+        this.inverseState = InverseMatrixState.inverseStored;
+        this.inverseCoffs = Float64Array.from([
+            coffs[0], coffs[3], coffs[6],
+            coffs[1], coffs[4], coffs[7],
+            coffs[2], coffs[5], coffs[8],
+        ]);
+    }
+    /**
+     * Set all entries in the matrix from call parameters appearing in row-major order.
      * @param axx Row x, column x (0,0) entry
      * @param axy Row x, column y (0,1) entry
      * @param axz Row x, column z (0,2) entry
@@ -392,15 +458,22 @@ export class Matrix3d {
         this.inverseState = InverseMatrixState.unknown;
     }
     /** Set the matrix to an identity. */
-    setIdentity() { this.setRowValues(1, 0, 0, 0, 1, 0, 0, 0, 1); this.setupInverseTranspose(); }
+    setIdentity() {
+        this.setRowValues(1, 0, 0, 0, 1, 0, 0, 0, 1);
+        this.setupInverseTranspose();
+    }
     /** Set the matrix to all zeros. */
-    setZero() { this.setRowValues(0, 0, 0, 0, 0, 0, 0, 0, 0); this.inverseState = InverseMatrixState.singular; }
-    /** copy contents from another matrix. */
+    setZero() {
+        this.setRowValues(0, 0, 0, 0, 0, 0, 0, 0, 0);
+        this.inverseState = InverseMatrixState.singular;
+    }
+    /** Copy contents from another matrix. */
     setFrom(other) {
         if (other === undefined) {
             this.setIdentity();
+            return;
         }
-        else if (other !== this) {
+        if (other !== this) {
             for (let i = 0; i < 9; i++)
                 this.coffs[i] = other.coffs[i];
             if (other.inverseState === InverseMatrixState.inverseStored && other.inverseCoffs !== undefined) {
@@ -412,28 +485,29 @@ export class Matrix3d {
             else if (other.inverseState !== InverseMatrixState.inverseStored) {
                 this.inverseState = other.inverseState;
             }
-            else { // This is reached of other says stored but does not have coffs.  This should not happen.
+            else { // This is reached when other says stored but does not have coffs. This should not happen.
                 this.inverseState = InverseMatrixState.unknown;
             }
         }
     }
-    /** return a clone of this matrix.
-     * * coefficients are copied.
-     * * inverse coefficients are NOT copied.
-     * * inverse status is set to unknown
+    /**
+     * Return a clone of this matrix.
+     * * Coefficients are copied.
+     * * Inverse coefficients and inverse status are copied if stored by `this`.
      */
     clone(result) {
         result = result ? result : new Matrix3d();
         result.setFrom(this);
         return result;
     }
-    /** create a matrix with all zeros.
+    /**
+     * Create a matrix with all zeros.
      * * Note that for geometry transformations "all zeros" is not a useful default state.
-     * * Hence almost always use `createIdentity` for graphics transformations.
-     * * "all zeros" is appropriate for summing moment data.
+     * * Hence, almost always use `createIdentity` for graphics transformations.
+     * * "All zeros" is appropriate for summing moment data.
      * ```
      * equation
-     * \begin{bmatrix}0 0 0 \\ 0 0 0 \\ 0 0 0\end{bmatrix}
+     * \begin{bmatrix}0 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0\end{bmatrix}
      * ```
      */
     static createZero() {
@@ -441,13 +515,14 @@ export class Matrix3d {
         retVal.inverseState = InverseMatrixState.singular;
         return retVal;
     }
-    /** create an identity matrix.
-     * * all diagonal entries (xx,yy,zz) are one
-     * * all others are zero.
-     * * This (rather than all zeros) is the useful state for most graphics transformations.
+    /**
+     * Create an identity matrix.
+     * * All diagonal entries (xx,yy,zz) are one
+     * * All others are zero.
+     * * This (rather than "all zeros") is the useful state for most graphics transformations.
      * ```
      * equation
-     * \begin{bmatrix}1 0 0 \\ 0 1 0 \\ 0 0 1\end{bmatrix}
+     * \begin{bmatrix}1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1\end{bmatrix}
      * ```
      *
      */
@@ -457,55 +532,7 @@ export class Matrix3d {
         return result;
     }
     /**
-     * Create a matrix with uniform scale factors.
-     * For scale factor _s_,
-     * ```
-     * equation
-     * \begin{bmatrix}s & 0 & 0 \\ 0 & s & 0\\ 0 & 0 & s\end{bmatrix}
-     * ```
-     */
-    static createUniformScale(scaleFactor) {
-        return Matrix3d.createScale(scaleFactor, scaleFactor, scaleFactor);
-    }
-    /**
-     * Construct a rigid matrix using createPerpendicularVectorFavorXYPlane to generate a vector perpendicular to vectorA.
-     * *
-     */
-    static createRigidHeadsUp(vectorA, axisOrder = AxisOrder.ZXY, result) {
-        const vectorB = Matrix3d.createPerpendicularVectorFavorXYPlane(vectorA);
-        const matrix = Matrix3d.createRigidFromColumns(vectorA, vectorB, axisOrder, result);
-        if (matrix) {
-            matrix.setupInverseTranspose();
-            return matrix;
-        }
-        return Matrix3d.createIdentity(result);
-    }
-    /**
-     * return a vector that is perpendicular to the input direction.
-     * * Among the infinite number of perpendiculars possible, this method
-     * favors having one in the xy plane.
-     * * Hence, when vectorA is NOT close to the Z axis, the returned vector is Z cross vectorA.
-     * * But vectorA is close to the Z axis, the returned vector is unitY cross vectorA.
-     */
-    static createPerpendicularVectorFavorXYPlane(vector, result) {
-        const a = vector.magnitude();
-        const b = a / 64.0; // A constant from the dawn of time in the CAD industry.
-        if (Math.abs(vector.x) < b && Math.abs(vector.y) < b) {
-            return Vector3d.createCrossProduct(vector.x, vector.y, vector.z, 0, -1, 0, result);
-        }
-        return Vector3d.createCrossProduct(0, 0, 1, vector.x, vector.y, vector.z, result);
-    }
-    /**
-     * return a vector that is perpendicular to the input direction.
-     * * Among the infinite number of perpendiculars possible, this method
-     * favors having one near the Z.
-     * That is achieved by crossing "this" vector with the result of createPerpendicularVectorFavorXYPlane.
-     */
-    static createPerpendicularVectorFavorPlaneContainingZ(vector, result) {
-        result = Matrix3d.createPerpendicularVectorFavorXYPlane(vector, result);
-        return vector.crossProduct(result, result);
-    }
-    /** Create a matrix with distinct x,y,z diagonal (scale) entries.
+     * Create a matrix with distinct x,y,z diagonal (scale) entries.
      * ```
      * equation
      * \begin{bmatrix}s_x & 0 & 0 \\ 0 & s_y & 0\\ 0 & 0 & s_z\end{bmatrix}
@@ -530,7 +557,101 @@ export class Matrix3d {
         }
         return result;
     }
-    /** return a rotation of specified angle around an axis */
+    /**
+     * Create a matrix with uniform scale factors for scale factor "s"
+     * ```
+     * equation
+     * \begin{bmatrix}s & 0 & 0 \\ 0 & s & 0\\ 0 & 0 & s\end{bmatrix}
+     * ```
+     */
+    static createUniformScale(scaleFactor) {
+        return Matrix3d.createScale(scaleFactor, scaleFactor, scaleFactor);
+    }
+    /**
+     * Return a vector that is perpendicular to the input `vectorA`.
+     * * Among the infinite number of perpendiculars possible, this method favors having one in the xy plane.
+     * * Hence, when `vectorA` is close to the Z axis, the returned vector is `vectorA cross -unitY`
+     * but when `vectorA` is NOT close to the Z axis, the returned vector is `unitZ cross vectorA`.
+     */
+    static createPerpendicularVectorFavorXYPlane(vectorA, result) {
+        const a = vectorA.magnitude();
+        const scale = 64.0; // A constant from the dawn of time in the CAD industry
+        const b = a / scale;
+        // if vectorA is close to the Z axis
+        if (Math.abs(vectorA.x) < b && Math.abs(vectorA.y) < b) {
+            return Vector3d.createCrossProduct(vectorA.x, vectorA.y, vectorA.z, 0, -1, 0, result);
+        }
+        // if vectorA is NOT close to the Z axis
+        return Vector3d.createCrossProduct(0, 0, 1, vectorA.x, vectorA.y, vectorA.z, result);
+    }
+    /**
+     * Return a vector that is perpendicular to the input `vectorA`.
+     * * Among the infinite number of perpendiculars possible, this method favors having one near the plane
+     * containing Z.
+     * That is achieved by cross product of `this` vector with the result of createPerpendicularVectorFavorXYPlane.
+     */
+    static createPerpendicularVectorFavorPlaneContainingZ(vectorA, result) {
+        /**
+         * vectorA, result (below), and "vectorA cross result" form a coordinate system where "result" is located on
+         * the XY-plane. Once you've got a coordinate system with an axis in the XY-plane, your other two axes form
+         * a plane that includes the z-axis.
+         */
+        result = Matrix3d.createPerpendicularVectorFavorXYPlane(vectorA, result);
+        return vectorA.crossProduct(result, result);
+    }
+    /**
+     * Create a matrix from column vectors, shuffled into place per axisOrder
+     * For example, if axisOrder = XYZ then it returns [vectorU, vectorV, vectorW]
+     * Another example, if axisOrder = YZX then it returns [vectorW, vectorU, vectorV] because
+     * Y is at index 0 so vectorU goes to the column Y (column 2), Z is at index 1 so vectorV goes
+     * to the column Z (column 3), and X is at index 2 so vectorW goes to the column X (column 1)
+     */
+    static createShuffledColumns(vectorU, vectorV, vectorW, axisOrder, result) {
+        const target = Matrix3d._create(result);
+        target.setColumn(Geometry.axisOrderToAxis(axisOrder, 0), vectorU);
+        target.setColumn(Geometry.axisOrderToAxis(axisOrder, 1), vectorV);
+        target.setColumn(Geometry.axisOrderToAxis(axisOrder, 2), vectorW);
+        return target;
+    }
+    /**
+     * Create a new orthogonal matrix (perpendicular columns, unit length, transpose is inverse).
+     * * `vectorA1 = Normalized vectorA` is placed in the column specified by **first** letter in
+     * the AxisOrder name.
+     * * Normalized `vectorC1 = vectorA1 cross vectorB` is placed in the column specified by **third**
+     * letter in the AxisOrder name.
+     * * Normalized  `vectorC1 cross vectorA` is placed in the column specified by **second**
+     * letter in the AxisOrder name.
+     * * This function internally uses createShuffledColumns.
+     */
+    static createRigidFromColumns(vectorA, vectorB, axisOrder, result) {
+        const vectorA1 = vectorA.normalize();
+        if (vectorA1) {
+            const vectorC1 = vectorA1.unitCrossProduct(vectorB);
+            if (vectorC1) {
+                const vectorB1 = vectorC1.unitCrossProduct(vectorA);
+                if (vectorB1) {
+                    const retVal = Matrix3d.createShuffledColumns(vectorA1, vectorB1, vectorC1, axisOrder, result);
+                    retVal.setupInverseTranspose();
+                    return retVal;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Construct a rigid matrix using vectorA and its 2 perpendicular.
+     * * This function internally uses createPerpendicularVectorFavorXYPlane and createRigidFromColumns.
+     */
+    static createRigidHeadsUp(vectorA, axisOrder = AxisOrder.ZXY, result) {
+        const vectorB = Matrix3d.createPerpendicularVectorFavorXYPlane(vectorA);
+        const matrix = Matrix3d.createRigidFromColumns(vectorA, vectorB, axisOrder, result);
+        if (matrix) {
+            matrix.setupInverseTranspose();
+            return matrix;
+        }
+        return Matrix3d.createIdentity(result);
+    }
+    /** Return the matrix for rotation of `angle` around `axis` */
     static createRotationAroundVector(axis, angle, result) {
         // Rodriguez formula (matrix form), https://mathworld.wolfram.com/RodriguesRotationFormula.html
         const c = angle.cos();
@@ -548,6 +669,7 @@ export class Matrix3d {
      * @param axisIndex index of axis (AxisIndex.X, AxisIndex.Y, AxisIndex.Z) kept fixed by the rotation.
      * @param angle angle of rotation
      * @param result optional result matrix.
+     * * Math details of 3d rotation matrices derivation can be found at docs/learning/geometry/Angle.md
      */
     static createRotationAroundAxisIndex(axisIndex, angle, result) {
         const c = angle.cos();
@@ -565,27 +687,77 @@ export class Matrix3d {
         myResult.setupInverseTranspose();
         return myResult;
     }
+    /**
+   * Replace current columns Ui and Uj with (c*Ui - s*Uj) and (c*Uj + s*Ui).
+   * * There is no checking for i,j being 0,1,2.
+   * * This is used in compute intensive inner loops
+   * @param i first row index. **must be 0,1,2** (unchecked)
+   * @param j second row index. **must be 0,1,2** (unchecked)
+   * @param c fist coefficient
+   * @param s second coefficient
+   */
+    applyGivensColumnOp(i, j, c, s) {
+        const limit = i + 9;
+        for (; i < limit; i += 3, j += 3) {
+            const a = this.coffs[i];
+            const b = this.coffs[j];
+            this.coffs[i] = a * c + b * s;
+            this.coffs[j] = -a * s + b * c;
+        }
+    }
+    /**
+   * Create a matrix from column vectors.
+   * ```
+   * equation
+   * \begin{bmatrix}U_x & V_x & W_x \\ U_y & V_y & W_y \\ U_z & V_z & W_z \end{bmatrix}
+   * ```
+   */
+    static createColumns(vectorU, vectorV, vectorW, result) {
+        return Matrix3d.createRowValues(vectorU.x, vectorV.x, vectorW.x, vectorU.y, vectorV.y, vectorW.y, vectorU.z, vectorV.z, vectorW.z, result);
+    }
+    /** Create a matrix with each column's _x,y_ parts given `XAndY` and separate numeric z values.
+     * ```
+     * equation
+     * \begin{bmatrix}U_x & V_x & W_x \\ U_y & V_y & W_y \\ u & v & w \end{bmatrix}
+     * ```
+     */
+    static createColumnsXYW(vectorU, u, vectorV, v, vectorW, w, result) {
+        return Matrix3d.createRowValues(vectorU.x, vectorV.x, vectorW.x, vectorU.y, vectorV.y, vectorW.y, u, v, w, result);
+    }
     /** Create a matrix from "as viewed" right and up vectors.
      * * ColumnX points in the rightVector direction
-     * * ColumnY points in in the upVectorDirection
-     * * ColumnZ is a unit cross product.
-     * Optionally rotate the standard cube by 45 to bring its left or right vertical edge to center
-     * * leftNoneRight = [-1,0,1] respectively for left edge, no rotation, or right edge
-     * * bottomNoneTop = [-1,0,1] respectively for isometric rotation to view the bottom, no isometric rotation, and isometric rotation to view the top
-     * This is expected to be used with various principal unit vectors that are perpendicular to each other.
-     *  * STANDARD TOP VIEW: (Vector3d.UnitX (), Vector3d.UnitY (), 0, 0)
-     *  * STANDARD FRONT VIEW: (Vector3d.UnitX (), Vector3d.UnitZ (), 0, 0)
-     *  * STANDARD BACK VIEW: (Vector3d.UnitX (-1), Vector3d.UnitZ (), 0, 0)
-     *  * STANDARD RIGHT VIEW: (Vector3d.UnitY (1), Vector3d.UnitZ (), 0, 0)
-     *  * STANDARD LEFT VIEW: (Vector3d.UnitY (-1), Vector3d.UnitZ (), 0, 0)
-     *  * STANDARD BOTTOM VIEW: (Vector3d.UnitX (1), Vector3d.UnitY (-1), 0, 0)
-     * @param leftNoneRight Normally one of {-1,0,1}, where (-1) indicates the left vertical is rotated to center and (1) for right.  Other numbers are used as multiplier for this 45 degree rotation
-     * @returns undefined if columnX, columnY are coplanar.
+     * * ColumnY points in the upVector direction
+     * * ColumnZ is a unit cross product of ColumnX and ColumnY.
+     * * Optionally rotate the standard cube by 45 degrees ccw around Y to bring its left or right vertical edge to center.
+     * * Optionally rotate the standard cube by 35.264 degrees ccw around X (isometric rotation).
+     * * This is expected to be used with various principal unit vectors that are perpendicular to each other.
+     * * STANDARD TOP VIEW: createViewedAxes(Vector3d.unitX(), Vector3d.unitY(), 0, 0)
+     * * STANDARD FRONT VIEW: createViewedAxes(Vector3d.unitX(), Vector3d.unitZ(), 0, 0)
+     * * STANDARD BACK VIEW: createViewedAxes(Vector3d.unitX(-1), Vector3d.unitZ(), 0, 0)
+     * * STANDARD RIGHT VIEW: createViewedAxes(Vector3d.unitY(), Vector3d.unitZ(), 0, 0)
+     * * STANDARD LEFT VIEW: createViewedAxes(Vector3d.unitY(-1), Vector3d.unitZ(), 0, 0)
+     * * STANDARD BOTTOM VIEW: createViewedAxes(Vector3d.unitX(), Vector3d.unitY(-1), 0, 0)
+     * * Note: createViewedAxes is column-based so always returns local to world
+     *
+     * @param rightVector ColumnX of the returned matrix. Expected to be perpendicular to upVector.
+     * @param upVector ColumnY of the returned matrix. Expected to be perpendicular to rightVector.
+     * @param leftNoneRight Specifies the ccw rotation around Y axis. Normally one of "-1", "0", and "1", where
+     * "-1" indicates rotation by 45 degrees to bring the left vertical edge to center, "0" means no rotation,
+     * and "1" indicates rotation by 45 degrees to bring the right vertical edge to center. Other numbers are
+     * used as multiplier for this 45 degree rotation.
+     * @param topNoneBottom Specifies the ccw rotation around X axis. Normally one of "-1", "0", and "1", where
+     * "-1" indicates isometric rotation (35.264 degrees) to bring the bottom upward, "0" means no rotation,
+     * and "1" indicates isometric rotation (35.264 degrees) to bring the top downward. Other numbers are
+     * used as multiplier for the 35.264 degree rotation.
+     * @returns matrix = [rightVector, upVector, rightVector cross upVector] with the applied rotations specified
+     * by leftNoneRight and topNoneBottom. Returns undefined if rightVector and upVector are parallel.
      */
     static createViewedAxes(rightVector, upVector, leftNoneRight = 0, topNoneBottom = 0) {
         const columnZ = rightVector.crossProduct(upVector);
         if (columnZ.normalizeInPlace()) {
-            const geometry = Matrix3d.createColumns(rightVector, upVector, columnZ);
+            // matrix = [rightVector, upVector, rightVector cross upVector]
+            const matrix = Matrix3d.createColumns(rightVector, upVector, columnZ);
+            // "45 degrees * leftNoneRight" rotation around Y
             if (leftNoneRight !== 0.0) {
                 let c = Math.sqrt(0.5);
                 let s = leftNoneRight < 0.0 ? -c : c;
@@ -594,51 +766,63 @@ export class Matrix3d {
                     c = Math.cos(radians);
                     s = Math.sin(radians);
                 }
-                geometry.applyGivensColumnOp(2, 0, c, s); // rotate around Y
+                matrix.applyGivensColumnOp(2, 0, c, s); // rotate around Y (equivalent to matrix*rotationY)
             }
+            // "35.264 degrees * topNoneBottom" rotation around X
             if (topNoneBottom !== 0.0) {
                 const theta = topNoneBottom * Math.atan(Math.sqrt(0.5));
                 const c = Math.cos(theta);
                 const s = Math.sin(theta);
-                geometry.applyGivensColumnOp(1, 2, c, -s); // rotate around X
+                matrix.applyGivensColumnOp(1, 2, c, -s); // rotate around X (equivalent to matrix*rotationX)
             }
-            return geometry;
+            return matrix;
         }
         return undefined;
     }
     /**
      * Create a rotation matrix for one of the 8 standard views.
-     * * With `invert === false` the return is such that `matrix.multiply(worldVector)` returns the vector as seen in the xy (projected) coordinates of the view.
-     * * With invert === true the matrix is transposed so that `matrix.multiply(viewVector` maps the "in view" vector to a world vector.
+     * * Default is TOP view (`local X = world X`, `local Y = world Y`, `local Z = world Z`).
+     * * To change view from the TOP to one of the other 7 standard views, we need to multiply "world data" to
+     * the corresponding matrix1 provided by `createStandardWorldToView(index, false)` and then
+     * `matrix1.multiply(world data)` will returns "local data".
+     * * To change view back to the TOP, we need to multiply "local data" to the corresponding matrix2 provided
+     * by `createStandardWorldToView(index, true)` and then `matrix2.multiply(local data)` will returns "world data".
      *
-     * @param index standard view index `StandardViewIndex.Top, Bottom, LEft, Right, Front, Back, Iso, LeftIso`
-     * @param invert if false (default), the returned Matrix3d "projects" world vectors into XY view vectors.  If true, it is inverted to map view vectors to world.
+     * @param index standard view index `StandardViewIndex.Top, Bottom, Left, Right, Front, Back, Iso, RightIso`
+     * @param invert if false (default), the return matrix is world to local (view) and if true, the the return
+     * matrix is local (view) to world.
      * @param result optional result.
      */
     static createStandardWorldToView(index, invert = false, result) {
         switch (index) {
+            // start with TOP view, ccw rotation by 180 degrees around X
             case StandardViewIndex.Bottom:
                 result = Matrix3d.createRowValues(1, 0, 0, 0, -1, 0, 0, 0, -1);
                 break;
+            // start with TOP view, ccw rotation by -90 degrees around X and by 90 degrees around Z
             case StandardViewIndex.Left:
                 result = Matrix3d.createRowValues(0, -1, 0, 0, 0, 1, -1, 0, 0);
                 break;
+            // start with TOP view, ccw rotation by -90 degrees around X and by -90 degrees around Z
             case StandardViewIndex.Right:
                 result = Matrix3d.createRowValues(0, 1, 0, 0, 0, 1, 1, 0, 0);
                 break;
-            case StandardViewIndex.Front: // 0-based 4
+            // start with TOP view, ccw rotation by -90 degrees around X
+            case StandardViewIndex.Front:
                 result = Matrix3d.createRowValues(1, 0, 0, 0, 0, 1, 0, -1, 0);
                 break;
-            case StandardViewIndex.Back: // 0-based 5
+            // start with TOP view, ccw rotation by -90 degrees around X and by 180 degrees around Z
+            case StandardViewIndex.Back:
                 result = Matrix3d.createRowValues(-1, 0, 0, 0, 0, 1, 0, 1, 0);
                 break;
             case StandardViewIndex.Iso:
+                // start with FRONT view, ccw rotation by -45 degrees around Y and by 35.264 degrees around X
                 result = Matrix3d.createRowValues(0.707106781186548, -0.70710678118654757, 0.00000000000000000, 0.408248290463863, 0.40824829046386302, 0.81649658092772603, -0.577350269189626, -0.57735026918962573, 0.57735026918962573);
                 break;
             case StandardViewIndex.RightIso:
                 result = Matrix3d.createRowValues(0.707106781186548, 0.70710678118654757, 0.00000000000000000, -0.408248290463863, 0.40824829046386302, 0.81649658092772603, 0.577350269189626, -0.57735026918962573, 0.57735026918962573);
                 break;
-            case StandardViewIndex.Top:
+            case StandardViewIndex.Top: // no rotation
             default:
                 result = Matrix3d.createIdentity(result);
         }
@@ -715,7 +899,7 @@ export class Matrix3d {
   */
     /**
      * Compute the (unit vector) axis and angle of rotation.
-     * @returns Returns with result.ok === true when the conversion succeeded.
+     * @returns Returns axis and angle of rotation with result.ok === true when the conversion succeeded.
      */
     getAxisAndAngleOfRotation() {
         const trace = this.coffs[0] + this.coffs[4] + this.coffs[8];
@@ -898,7 +1082,7 @@ export class Matrix3d {
     columnZCrossVector(vector, result) {
         return Geometry.crossProductXYZXYZ(this.coffs[2], this.coffs[5], this.coffs[8], vector.x, vector.y, vector.z, result);
     }
-    /**
+    /*
      * Replace current rows Ui Uj with (c*Ui - s*Uj) and (c*Uj + s*Ui).
      * @param i first row index.  must be 0,1,2 (unchecked)
      * @param j second row index. must be 0,1,2 (unchecked)
@@ -916,23 +1100,6 @@ export class Matrix3d {
             this.coffs[jj] = -a * s + b * c;
         }
     }
-    /**
-     * Replace current columns Ui Uj with (c*Ui - s*Uj) and (c*Uj + s*Ui).
-     * * This is used in compute intensive inner loops -- there is no checking for i,j being 0,1,2.
-     * @param i first row index.  must be 0,1,2 (unchecked)
-     * @param j second row index. must be 0,1,2 (unchecked)
-     * @param c fist coefficient
-     * @param s second coefficient
-     */
-    applyGivensColumnOp(i, j, c, s) {
-        const limit = i + 9;
-        for (; i < limit; i += 3, j += 3) {
-            const a = this.coffs[i];
-            const b = this.coffs[j];
-            this.coffs[i] = a * c + b * s;
-            this.coffs[j] = -a * s + b * c;
-        }
-    }
     /**
      * create a rigid coordinate frame column z parallel to (_x_,_y_,_z_) and column x in the xy plane.
      * * column z points from origin to x,y,z
@@ -1165,33 +1332,14 @@ export class Matrix3d {
         }
         return false;
     }
-    /**
-     * Create a matrix from column vectors.
-     * ```
-     * equation
-     * \begin{bmatrix}U_x & V_x & W_x \\ U_y & V_y & W_y \\ U_z & V_z & W_z \end{bmatrix}
-     * ```
-     */
-    static createColumns(vectorU, vectorV, vectorW, result) {
-        return Matrix3d.createRowValues(vectorU.x, vectorV.x, vectorW.x, vectorU.y, vectorV.y, vectorW.y, vectorU.z, vectorV.z, vectorW.z, result);
-    }
-    /** Create a matrix with each column's _x,y_ parts given `XAndY` and separate numeric z values.
-     * ```
-     * equation
-     * \begin{bmatrix}U_x & V_x & W_x \\ U_y & V_y & W_y \\ u & v & w \end{bmatrix}
-     * ```
-     */
-    static createColumnsXYW(vectorU, u, vectorV, v, vectorW, w, result) {
-        return Matrix3d.createRowValues(vectorU.x, vectorV.x, vectorW.x, vectorU.y, vectorV.y, vectorW.y, u, v, w, result);
-    }
     /** Install data from xyz parts of Point4d  (w part of Point4d ignored) */
     setColumnsPoint4dXYZ(vectorU, vectorV, vectorW) {
         this.inverseState = InverseMatrixState.unknown;
         this.setRowValues(vectorU.x, vectorV.x, vectorW.x, vectorU.y, vectorV.y, vectorW.y, vectorU.z, vectorV.z, vectorW.z);
     }
     /**
-     * set entries in one column of the matrix.
-     * @param columnIndex column index. this is interpreted cyclically.
+     * Set entries in one column of the matrix.
+     * @param columnIndex column index (this is interpreted cyclically. See Geometry.cyclic3dAxis for more info).
      * @param value x,yz, values for column.  If undefined, zeros are installed.
      */
     setColumn(columnIndex, value) {
@@ -1240,14 +1388,6 @@ export class Matrix3d {
         const index = 3 * Geometry.cyclic3dAxis(columnIndex);
         return Vector3d.create(this.coffs[index], this.coffs[index + 1], this.coffs[index + 2], result);
     }
-    /** Create a matrix from column vectors, shuffled into place per AxisTriple */
-    static createShuffledColumns(vectorU, vectorV, vectorW, axisOrder, result) {
-        const target = Matrix3d._create(result);
-        target.setColumn(Geometry.axisOrderToAxis(axisOrder, 0), vectorU);
-        target.setColumn(Geometry.axisOrderToAxis(axisOrder, 1), vectorV);
-        target.setColumn(Geometry.axisOrderToAxis(axisOrder, 2), vectorW);
-        return target;
-    }
     /** Create a matrix from row vectors.
      * ```
      * equation
@@ -1679,7 +1819,11 @@ export class Matrix3d {
         this.multiplyMatrixMatrix(other.matrix, result.matrix);
         return result;
     }
-    /** return a transposed matrix. `this` is not changed unless also passed as the result. */
+    /**
+     * Return the transpose of `this` matrix.
+     * If `result` is passed as argument, then the function copies the transpose of `this` into `result`
+     * `this` is not changed unless also passed as the result, i.e., this.transpose(this) transposes `this` in place
+     */
     transpose(result) {
         if (!result)
             result = new Matrix3d();
@@ -1694,8 +1838,8 @@ export class Matrix3d {
         }
         return result;
     }
-    /** transpose this matrix in place.
-     *
+    /**
+     * Transpose this matrix in place.
      */
     transposeInPlace() {
         PackedMatrix3dOps.transposeInPlace(this.coffs);
@@ -1726,18 +1870,6 @@ export class Matrix3d {
         result.inverseState = this.inverseState;
         return result;
     }
-    /** copy the transpose of the coffs to the inverseCoffs.
-     * * mark the matrix as inverseStored.
-     */
-    setupInverseTranspose() {
-        const coffs = this.coffs;
-        this.inverseState = InverseMatrixState.inverseStored;
-        this.inverseCoffs = Float64Array.from([
-            coffs[0], coffs[3], coffs[6],
-            coffs[1], coffs[4], coffs[7],
-            coffs[2], coffs[5], coffs[8]
-        ]);
-    }
     /* Alternate implementation of computedCachedInverse - more direct addressing of arrays.
        This is indeed 10% faster than using static work areas. */
     // take the cross product of two rows of source.
@@ -1845,8 +1977,10 @@ export class Matrix3d {
     markSingular() {
         this.inverseState = InverseMatrixState.singular;
     }
-    /** Create the inverseCoffs member (filled with zeros)
-     * This is for use by matrix * matrix multiplications which need to be sure the member is there to be filled with method-specific content.
+    /**
+     * Create the inverseCoffs member (filled with zeros)
+     * This is for use by matrix * matrix multiplications which need to be sure the member is there to be
+     * filled with method-specific content.
      */
     createInverseCoffsWithZeros() {
         if (!this.inverseCoffs) {
@@ -1995,7 +2129,7 @@ export class Matrix3d {
     /**
      * add scaled values from other Matrix3d to this Matrix3d
      * @param other Matrix3d with values to be added
-     * @param scale scale factor to apply to th eadded values.
+     * @param scale scale factor to apply to the added values.
      */
     addScaledInPlace(other, scale) {
         for (let i = 0; i < 9; i++)
@@ -2058,18 +2192,18 @@ export class Matrix3d {
     /** Return the sum of squares of all entries */
     sumSquares() {
         let i = 0;
-        let a = 0;
+        let sum = 0;
         for (i = 0; i < 9; i++)
-            a += this.coffs[i] * this.coffs[i];
-        return a;
+            sum += this.coffs[i] * this.coffs[i];
+        return sum;
     }
     /** Return the sum of squares of diagonal entries */
     sumDiagonalSquares() {
         let i = 0;
-        let a = 0;
+        let sum = 0;
         for (i = 0; i < 9; i += 4)
-            a += this.coffs[i] * this.coffs[i];
-        return a;
+            sum += this.coffs[i] * this.coffs[i];
+        return sum;
     }
     /** Return the sum of diagonal entries (also known as the trace) */
     sumDiagonal() {
@@ -2078,18 +2212,18 @@ export class Matrix3d {
     /** Return the Maximum absolute value of any single entry */
     maxAbs() {
         let i = 0;
-        let a = 0;
+        let max = 0;
         for (i = 0; i < 9; i++)
-            a = Math.max(a, Math.abs(this.coffs[i]));
-        return a;
+            max = Math.max(max, Math.abs(this.coffs[i]));
+        return max;
     }
-    /** Return the maximum absolute difference between corresponding entries */
+    /** Return the maximum absolute difference between corresponding entries of `this` and `other` */
     maxDiff(other) {
         let i = 0;
-        let a = 0;
+        let max = 0;
         for (i = 0; i < 9; i++)
-            a = Math.max(a, Math.abs(this.coffs[i] - other.coffs[i]));
-        return a;
+            max = Math.max(max, Math.abs(this.coffs[i] - other.coffs[i]));
+        return max;
     }
     /** Test if the matrix is (very near to) an identity */
     get isIdentity() {
@@ -2180,25 +2314,6 @@ export class Matrix3d {
         const product = this.multiplyMatrixMatrixTranspose(this);
         return product.isIdentity;
     }
-    /** create a new orthogonal matrix (perpendicular columns, unit length, transpose is inverse).
-     * vectorA is placed in the first column of the axis order.
-     * vectorB is projected perpendicular to vectorA within their plane and placed in the second column.
-     */
-    static createRigidFromColumns(vectorA, vectorB, axisOrder, result) {
-        const vectorA1 = vectorA.normalize();
-        if (vectorA1) {
-            const vectorC1 = vectorA1.unitCrossProduct(vectorB);
-            if (vectorC1) {
-                const vectorB1 = vectorC1.unitCrossProduct(vectorA);
-                if (vectorB1) {
-                    const retVal = Matrix3d.createShuffledColumns(vectorA1, vectorB1, vectorC1, axisOrder, result);
-                    retVal.setupInverseTranspose();
-                    return retVal;
-                }
-            }
-        }
-        return undefined;
-    }
     /** Adjust the matrix in place so that:
      * * columns are perpendicular and have unit length
      * * transpose equals inverse
@@ -2239,8 +2354,8 @@ export class Matrix3d {
         return coff;
     }
     /** create a matrix from a quaternion.
-     * WARNING: There is frequent confusion over whether a "from quaternion" matrix is organized by rows and columns.
-     * WARNING: If you find that the matrix seems to rotate by the opposite angle expect it, transpose it.
+     * **WARNING:** There is frequent confusion over whether a "from quaternion" matrix is organized by rows and columns.
+     * **WARNING:** If you find that the matrix seems to rotate by the opposite angle expect it, transpose it.
      */
     static createFromQuaternion(quat) {
         const qqx = quat.x * quat.x;
@@ -2259,8 +2374,8 @@ export class Matrix3d {
     }
     /** convert the matrix to a quaternion.
      * @note This calculation requires the matrix to have unit length rows and columns.
-     * WARNING: There is frequent confusion over whether a "from quaternion" matrix is organized by rows and columns.
-     * WARNING: If you find that the matrix seems to rotate by the opposite angle expect it, transpose it.
+     * **WARNING:** There is frequent confusion over whether a "from quaternion" matrix is organized by rows and columns.
+     * **WARNING:** If you find that the matrix seems to rotate by the opposite angle expect it, transpose it.
      */
     toQuaternion() {
         const result = Point4d.createZero();
@@ -2314,9 +2429,9 @@ export class Matrix3d {
 }
 /** Control flag for whether this class uses cached inverse of matrices. */
 Matrix3d.useCachedInverse = true; // cached inverse can be suppressed for testing.
-/** total number of times a cached inverse was used to avoid recompute */
+/** Total number of times a cached inverse was used to avoid recompute */
 Matrix3d.numUseCache = 0;
-/** total number of times a cached inverse was computed. */
+/** Total number of times a cached inverse was computed. */
 Matrix3d.numComputeCache = 0;
 Matrix3d._productBuffer = new Float64Array(9);
 //# sourceMappingURL=Matrix3d.js.map