molstar 3.0.1 → 3.0.2

package/lib/commonjs/mol-math/linear-algebra/3d/minimize-rmsd.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+import { Mat4 } from './mat4';
+import { Vec3 } from './vec3';
+export { MinimizeRmsd };
+declare namespace MinimizeRmsd {
+    interface Result {
+        bTransform: Mat4;
+        rmsd: number;
+    }
+    interface Positions {
+        x: ArrayLike<number>;
+        y: ArrayLike<number>;
+        z: ArrayLike<number>;
+    }
+    namespace Positions {
+        function empty(n: number): {
+            x: Float64Array;
+            y: Float64Array;
+            z: Float64Array;
+        };
+    }
+    interface Input {
+        a: Positions;
+        b: Positions;
+        centerA?: Vec3;
+        centerB?: Vec3;
+    }
+    function compute(data: Input, result?: MinimizeRmsd.Result): Result;
+}

package/lib/commonjs/mol-math/linear-algebra/3d/minimize-rmsd.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinimizeRmsd = void 0;
+var mat4_1 = require("./mat4");
+var evd_1 = require("../matrix/evd");
+var centroid_helper_1 = require("../../../mol-math/geometry/centroid-helper");
+var matrix_1 = require("../matrix/matrix");
+var sphere3d_1 = require("../../geometry/primitives/sphere3d");
+var MinimizeRmsd;
+(function (MinimizeRmsd) {
+    var Positions;
+    (function (Positions) {
+        function empty(n) {
+            return { x: new Float64Array(n), y: new Float64Array(n), z: new Float64Array(n) };
+        }
+        Positions.empty = empty;
+    })(Positions = MinimizeRmsd.Positions || (MinimizeRmsd.Positions = {}));
+    function compute(data, result) {
+        if (typeof result === 'undefined')
+            result = { bTransform: mat4_1.Mat4.zero(), rmsd: 0.0 };
+        findMinimalRmsdTransformImpl(new RmsdTransformState(data, result));
+        return result;
+    }
+    MinimizeRmsd.compute = compute;
+})(MinimizeRmsd || (MinimizeRmsd = {}));
+exports.MinimizeRmsd = MinimizeRmsd;
+var RmsdTransformState = /** @class */ (function () {
+    function RmsdTransformState(data, into) {
+        this.evdCache = evd_1.EVD.createCache(4);
+        this.translateB = mat4_1.Mat4.identity();
+        this.rotateB = mat4_1.Mat4.identity();
+        this.tempMatrix = mat4_1.Mat4.identity();
+        this.a = data.a;
+        this.b = data.b;
+        if (data.centerA)
+            this.centerA = data.centerA;
+        else
+            this.centerA = data.centerA = centroid_helper_1.CentroidHelper.fromArrays(data.a, (0, sphere3d_1.Sphere3D)()).center;
+        if (data.centerB)
+            this.centerB = data.centerB;
+        else
+            this.centerB = data.centerB = centroid_helper_1.CentroidHelper.fromArrays(data.b, (0, sphere3d_1.Sphere3D)()).center;
+        this.result = into;
+    }
+    return RmsdTransformState;
+}());
+function computeN(state) {
+    var N = state.evdCache.matrix;
+    matrix_1.Matrix.makeZero(N);
+    var xsA = state.a.x, ysA = state.a.y, zsA = state.a.z;
+    var xsB = state.b.x, ysB = state.b.y, zsB = state.b.z;
+    var cA = state.centerA;
+    var cB = state.centerB;
+    var sizeSq = 0.0;
+    for (var i = 0, _l = state.a.x.length; i < _l; i++) {
+        var aX = xsA[i] - cA[0], aY = ysA[i] - cA[1], aZ = zsA[i] - cA[2];
+        var bX = xsB[i] - cB[0], bY = ysB[i] - cB[1], bZ = zsB[i] - cB[2];
+        sizeSq += aX * aX + aY * aY + aZ * aZ + bX * bX + bY * bY + bZ * bZ;
+        matrix_1.Matrix.add(N, 0, 0, aX * bX + aY * bY + aZ * bZ);
+        matrix_1.Matrix.add(N, 0, 1, -(aZ * bY) + aY * bZ);
+        matrix_1.Matrix.add(N, 0, 2, aZ * bX - aX * bZ);
+        matrix_1.Matrix.add(N, 0, 3, -(aY * bX) + aX * bY);
+        matrix_1.Matrix.add(N, 1, 0, -(aZ * bY) + aY * bZ);
+        matrix_1.Matrix.add(N, 1, 1, aX * bX - aY * bY - aZ * bZ);
+        matrix_1.Matrix.add(N, 1, 2, aY * bX + aX * bY);
+        matrix_1.Matrix.add(N, 1, 3, aZ * bX + aX * bZ);
+        matrix_1.Matrix.add(N, 2, 0, aZ * bX - aX * bZ);
+        matrix_1.Matrix.add(N, 2, 1, aY * bX + aX * bY);
+        matrix_1.Matrix.add(N, 2, 2, -(aX * bX) + aY * bY - aZ * bZ);
+        matrix_1.Matrix.add(N, 2, 3, aZ * bY + aY * bZ);
+        matrix_1.Matrix.add(N, 3, 0, -(aY * bX) + aX * bY);
+        matrix_1.Matrix.add(N, 3, 1, aZ * bX + aX * bZ);
+        matrix_1.Matrix.add(N, 3, 2, aZ * bY + aY * bZ);
+        matrix_1.Matrix.add(N, 3, 3, -(aX * bX) - aY * bY + aZ * bZ);
+        // conjugate instead of transpose.
+        // var l = new Quaternion(-a.X, -a.Y, -a.Z, 0).RightMultiplicationToMatrix();
+        // l.Transpose();
+        // var r = new Quaternion(b.X, b.Y, b.Z, 0).LeftMultiplicationToMatrix();
+        // N += l * r;
+    }
+    return sizeSq;
+}
+function makeTransformMatrix(state) {
+    var ev = state.evdCache.matrix;
+    var qX = matrix_1.Matrix.get(ev, 1, 3);
+    var qY = matrix_1.Matrix.get(ev, 2, 3);
+    var qZ = matrix_1.Matrix.get(ev, 3, 3);
+    var qW = matrix_1.Matrix.get(ev, 0, 3);
+    var n1 = 2 * qY * qY;
+    var n2 = 2 * qZ * qZ;
+    var n3 = 2 * qX * qX;
+    var n4 = 2 * qX * qY;
+    var n5 = 2 * qW * qZ;
+    var n6 = 2 * qX * qZ;
+    var n7 = 2 * qW * qY;
+    var n8 = 2 * qY * qZ;
+    var n9 = 2 * qW * qX;
+    var m = state.translateB;
+    // translation to center
+    mat4_1.Mat4.setValue(m, 0, 3, -state.centerB[0]);
+    mat4_1.Mat4.setValue(m, 1, 3, -state.centerB[1]);
+    mat4_1.Mat4.setValue(m, 2, 3, -state.centerB[2]);
+    m = state.rotateB;
+    // rotation
+    mat4_1.Mat4.setValue(m, 0, 0, 1 - n1 - n2);
+    mat4_1.Mat4.setValue(m, 0, 1, n4 + n5);
+    mat4_1.Mat4.setValue(m, 0, 2, n6 - n7);
+    mat4_1.Mat4.setValue(m, 1, 0, n4 - n5);
+    mat4_1.Mat4.setValue(m, 1, 1, 1 - n3 - n2);
+    mat4_1.Mat4.setValue(m, 1, 2, n8 + n9);
+    mat4_1.Mat4.setValue(m, 2, 0, n6 + n7);
+    mat4_1.Mat4.setValue(m, 2, 1, n8 - n9);
+    mat4_1.Mat4.setValue(m, 2, 2, 1 - n3 - n1);
+    mat4_1.Mat4.setValue(m, 3, 3, 1);
+    mat4_1.Mat4.mul(state.tempMatrix, state.rotateB, state.translateB);
+    m = state.translateB;
+    // translation to center
+    mat4_1.Mat4.setValue(m, 0, 3, state.centerA[0]);
+    mat4_1.Mat4.setValue(m, 1, 3, state.centerA[1]);
+    mat4_1.Mat4.setValue(m, 2, 3, state.centerA[2]);
+    mat4_1.Mat4.mul(state.result.bTransform, state.translateB, state.tempMatrix);
+}
+function findMinimalRmsdTransformImpl(state) {
+    var sizeSq = computeN(state);
+    evd_1.EVD.compute(state.evdCache);
+    var rmsd = sizeSq - 2.0 * state.evdCache.eigenValues[3];
+    rmsd = rmsd < 0.0 ? 0.0 : Math.sqrt(rmsd / state.a.x.length);
+    makeTransformMatrix(state);
+    state.result.rmsd = rmsd;
+}
+//# sourceMappingURL=minimize-rmsd.js.map

package/lib/commonjs/mol-math/linear-algebra/3d/quat.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Mat3 } from './mat3';
+import { Vec3 } from './vec3';
+import { NumberArray } from '../../../mol-util/type-helpers';
+interface Quat extends Array<number> {
+    [d: number]: number;
+    '@type': 'quat';
+    length: 4;
+}
+interface ReadonlyQuat extends Array<number> {
+    readonly [d: number]: number;
+    '@type': 'quat';
+    length: 4;
+}
+declare function Quat(): Quat;
+declare namespace Quat {
+    function zero(): Quat;
+    function identity(): Quat;
+    function setIdentity(out: Quat): void;
+    function hasNaN(q: Quat): boolean;
+    function create(x: number, y: number, z: number, w: number): Quat;
+    function setAxisAngle(out: Quat, axis: Vec3, rad: number): Quat;
+    /**
+     * Gets the rotation axis and angle for a given
+     *  quaternion. If a quaternion is created with
+     *  setAxisAngle, this method will return the same
+     *  values as providied in the original parameter list
+     *  OR functionally equivalent values.
+     * Example: The quaternion formed by axis [0, 0, 1] and
+     *  angle -90 is the same as the quaternion formed by
+     *  [0, 0, 1] and 270. This method favors the latter.
+     */
+    function getAxisAngle(out_axis: Vec3, q: Quat): number;
+    function multiply(out: Quat, a: Quat, b: Quat): Quat;
+    function rotateX(out: Quat, a: Quat, rad: number): Quat;
+    function rotateY(out: Quat, a: Quat, rad: number): Quat;
+    function rotateZ(out: Quat, a: Quat, rad: number): Quat;
+    /**
+     * Calculates the W component of a quat from the X, Y, and Z components.
+     * Assumes that quaternion is 1 unit in length.
+     * Any existing W component will be ignored.
+     */
+    function calculateW(out: Quat, a: Quat): Quat;
+    /**
+     * Performs a spherical linear interpolation between two quat
+     */
+    function slerp(out: Quat, a: Quat, b: Quat, t: number): Quat;
+    function invert(out: Quat, a: Quat): Quat;
+    /**
+     * Calculates the conjugate of a quat
+     * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.
+     */
+    function conjugate(out: Quat, a: Quat): Quat;
+    /**
+     * Creates a quaternion from the given 3x3 rotation matrix.
+     *
+     * NOTE: The resultant quaternion is not normalized, so you should be sure
+     * to renormalize the quaternion yourself where necessary.
+     */
+    function fromMat3(out: Quat, m: Mat3): Quat;
+    /** Quaternion from two normalized unit vectors. */
+    function fromUnitVec3(out: Quat, a: Vec3, b: Vec3): Quat;
+    function clone(a: Quat): Quat;
+    function toArray(a: Quat, out: NumberArray, offset: number): NumberArray;
+    function fromArray(a: Quat, array: NumberArray, offset: number): Quat;
+    function copy(out: Quat, a: Quat): Quat;
+    function set(out: Quat, x: number, y: number, z: number, w: number): Quat;
+    /**
+     * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)
+     */
+    function exactEquals(a: Quat, b: Quat): boolean;
+    /**
+     * Returns whether or not the quaternions have approximately the same elements in the same position.
+     */
+    function equals(a: Quat, b: Quat): boolean;
+    function add(out: Quat, a: Quat, b: Quat): Quat;
+    function normalize(out: Quat, a: Quat): Quat;
+    function rotationTo(out: Quat, a: Vec3, b: Vec3): Quat;
+    function sqlerp(out: Quat, a: Quat, b: Quat, c: Quat, d: Quat, t: number): Quat;
+    function setAxes(out: Quat, view: Vec3, right: Vec3, up: Vec3): Quat;
+    function toString(a: Quat, precision?: number): string;
+    const Identity: ReadonlyQuat;
+}
+export { Quat };

package/lib/commonjs/mol-math/linear-algebra/3d/quat.js

@@ -0,0 +1,435 @@
+"use strict";
+/**
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Quat = void 0;
+var vec3_1 = require("./vec3");
+var common_1 = require("./common");
+function Quat() {
+    return Quat.zero();
+}
+exports.Quat = Quat;
+(function (Quat) {
+    function zero() {
+        // force double backing array by 0.1.
+        var ret = [0.1, 0, 0, 0];
+        ret[0] = 0.0;
+        return ret;
+    }
+    Quat.zero = zero;
+    function identity() {
+        var out = zero();
+        out[3] = 1;
+        return out;
+    }
+    Quat.identity = identity;
+    function setIdentity(out) {
+        out[0] = 0;
+        out[1] = 0;
+        out[2] = 0;
+        out[3] = 1;
+    }
+    Quat.setIdentity = setIdentity;
+    function hasNaN(q) {
+        return isNaN(q[0]) || isNaN(q[1]) || isNaN(q[2]) || isNaN(q[3]);
+    }
+    Quat.hasNaN = hasNaN;
+    function create(x, y, z, w) {
+        var out = identity();
+        out[0] = x;
+        out[1] = y;
+        out[2] = z;
+        out[3] = w;
+        return out;
+    }
+    Quat.create = create;
+    function setAxisAngle(out, axis, rad) {
+        rad = rad * 0.5;
+        var s = Math.sin(rad);
+        out[0] = s * axis[0];
+        out[1] = s * axis[1];
+        out[2] = s * axis[2];
+        out[3] = Math.cos(rad);
+        return out;
+    }
+    Quat.setAxisAngle = setAxisAngle;
+    /**
+     * Gets the rotation axis and angle for a given
+     *  quaternion. If a quaternion is created with
+     *  setAxisAngle, this method will return the same
+     *  values as providied in the original parameter list
+     *  OR functionally equivalent values.
+     * Example: The quaternion formed by axis [0, 0, 1] and
+     *  angle -90 is the same as the quaternion formed by
+     *  [0, 0, 1] and 270. This method favors the latter.
+     */
+    function getAxisAngle(out_axis, q) {
+        var rad = Math.acos(q[3]) * 2.0;
+        var s = Math.sin(rad / 2.0);
+        if (s !== 0.0) {
+            out_axis[0] = q[0] / s;
+            out_axis[1] = q[1] / s;
+            out_axis[2] = q[2] / s;
+        }
+        else {
+            // If s is zero, return any axis (no rotation - axis does not matter)
+            out_axis[0] = 1;
+            out_axis[1] = 0;
+            out_axis[2] = 0;
+        }
+        return rad;
+    }
+    Quat.getAxisAngle = getAxisAngle;
+    function multiply(out, a, b) {
+        var ax = a[0], ay = a[1], az = a[2], aw = a[3];
+        var bx = b[0], by = b[1], bz = b[2], bw = b[3];
+        out[0] = ax * bw + aw * bx + ay * bz - az * by;
+        out[1] = ay * bw + aw * by + az * bx - ax * bz;
+        out[2] = az * bw + aw * bz + ax * by - ay * bx;
+        out[3] = aw * bw - ax * bx - ay * by - az * bz;
+        return out;
+    }
+    Quat.multiply = multiply;
+    function rotateX(out, a, rad) {
+        rad *= 0.5;
+        var ax = a[0], ay = a[1], az = a[2], aw = a[3];
+        var bx = Math.sin(rad), bw = Math.cos(rad);
+        out[0] = ax * bw + aw * bx;
+        out[1] = ay * bw + az * bx;
+        out[2] = az * bw - ay * bx;
+        out[3] = aw * bw - ax * bx;
+        return out;
+    }
+    Quat.rotateX = rotateX;
+    function rotateY(out, a, rad) {
+        rad *= 0.5;
+        var ax = a[0], ay = a[1], az = a[2], aw = a[3];
+        var by = Math.sin(rad), bw = Math.cos(rad);
+        out[0] = ax * bw - az * by;
+        out[1] = ay * bw + aw * by;
+        out[2] = az * bw + ax * by;
+        out[3] = aw * bw - ay * by;
+        return out;
+    }
+    Quat.rotateY = rotateY;
+    function rotateZ(out, a, rad) {
+        rad *= 0.5;
+        var ax = a[0], ay = a[1], az = a[2], aw = a[3];
+        var bz = Math.sin(rad), bw = Math.cos(rad);
+        out[0] = ax * bw + ay * bz;
+        out[1] = ay * bw - ax * bz;
+        out[2] = az * bw + aw * bz;
+        out[3] = aw * bw - az * bz;
+        return out;
+    }
+    Quat.rotateZ = rotateZ;
+    /**
+     * Calculates the W component of a quat from the X, Y, and Z components.
+     * Assumes that quaternion is 1 unit in length.
+     * Any existing W component will be ignored.
+     */
+    function calculateW(out, a) {
+        var x = a[0], y = a[1], z = a[2];
+        out[0] = x;
+        out[1] = y;
+        out[2] = z;
+        out[3] = Math.sqrt(Math.abs(1.0 - x * x - y * y - z * z));
+        return out;
+    }
+    Quat.calculateW = calculateW;
+    /**
+     * Performs a spherical linear interpolation between two quat
+     */
+    function slerp(out, a, b, t) {
+        // benchmarks:
+        //    http://jsperf.com/quaternion-slerp-implementations
+        var ax = a[0], ay = a[1], az = a[2], aw = a[3];
+        var bx = b[0], by = b[1], bz = b[2], bw = b[3];
+        var omega, cosom, sinom, scale0, scale1;
+        // calc cosine
+        cosom = ax * bx + ay * by + az * bz + aw * bw;
+        // adjust signs (if necessary)
+        if (cosom < 0.0) {
+            cosom = -cosom;
+            bx = -bx;
+            by = -by;
+            bz = -bz;
+            bw = -bw;
+        }
+        // calculate coefficients
+        if ((1.0 - cosom) > 0.000001) {
+            // standard case (slerp)
+            omega = Math.acos(cosom);
+            sinom = Math.sin(omega);
+            scale0 = Math.sin((1.0 - t) * omega) / sinom;
+            scale1 = Math.sin(t * omega) / sinom;
+        }
+        else {
+            // "from" and "to" quaternions are very close
+            //  ... so we can do a linear interpolation
+            scale0 = 1.0 - t;
+            scale1 = t;
+        }
+        // calculate final values
+        out[0] = scale0 * ax + scale1 * bx;
+        out[1] = scale0 * ay + scale1 * by;
+        out[2] = scale0 * az + scale1 * bz;
+        out[3] = scale0 * aw + scale1 * bw;
+        return out;
+    }
+    Quat.slerp = slerp;
+    function invert(out, a) {
+        var a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
+        var dot = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;
+        var invDot = dot ? 1.0 / dot : 0;
+        // TODO: Would be faster to return [0,0,0,0] immediately if dot == 0
+        out[0] = -a0 * invDot;
+        out[1] = -a1 * invDot;
+        out[2] = -a2 * invDot;
+        out[3] = a3 * invDot;
+        return out;
+    }
+    Quat.invert = invert;
+    /**
+     * Calculates the conjugate of a quat
+     * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.
+     */
+    function conjugate(out, a) {
+        out[0] = -a[0];
+        out[1] = -a[1];
+        out[2] = -a[2];
+        out[3] = a[3];
+        return out;
+    }
+    Quat.conjugate = conjugate;
+    /**
+     * Creates a quaternion from the given 3x3 rotation matrix.
+     *
+     * NOTE: The resultant quaternion is not normalized, so you should be sure
+     * to renormalize the quaternion yourself where necessary.
+     */
+    function fromMat3(out, m) {
+        // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes
+        // article "Quaternion Calculus and Fast Animation".
+        var fTrace = m[0] + m[4] + m[8];
+        var fRoot;
+        if (fTrace > 0.0) {
+            // |w| > 1/2, may as well choose w > 1/2
+            fRoot = Math.sqrt(fTrace + 1.0); // 2w
+            out[3] = 0.5 * fRoot;
+            fRoot = 0.5 / fRoot; // 1/(4w)
+            out[0] = (m[5] - m[7]) * fRoot;
+            out[1] = (m[6] - m[2]) * fRoot;
+            out[2] = (m[1] - m[3]) * fRoot;
+        }
+        else {
+            // |w| <= 1/2
+            var i = 0;
+            if (m[4] > m[0])
+                i = 1;
+            if (m[8] > m[i * 3 + i])
+                i = 2;
+            var j = (i + 1) % 3;
+            var k = (i + 2) % 3;
+            fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1.0);
+            out[i] = 0.5 * fRoot;
+            fRoot = 0.5 / fRoot;
+            out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot;
+            out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;
+            out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;
+        }
+        return out;
+    }
+    Quat.fromMat3 = fromMat3;
+    var fromUnitVec3Temp = [0, 0, 0];
+    /** Quaternion from two normalized unit vectors. */
+    function fromUnitVec3(out, a, b) {
+        // assumes a and b are normalized
+        var r = vec3_1.Vec3.dot(a, b) + 1;
+        if (r < common_1.EPSILON) {
+            // If u and v are exactly opposite, rotate 180 degrees
+            // around an arbitrary orthogonal axis. Axis normalisation
+            // can happen later, when we normalise the quaternion.
+            r = 0;
+            if (Math.abs(a[0]) > Math.abs(a[2])) {
+                vec3_1.Vec3.set(fromUnitVec3Temp, -a[1], a[0], 0);
+            }
+            else {
+                vec3_1.Vec3.set(fromUnitVec3Temp, 0, -a[2], a[1]);
+            }
+        }
+        else {
+            // Otherwise, build quaternion the standard way.
+            vec3_1.Vec3.cross(fromUnitVec3Temp, a, b);
+        }
+        out[0] = fromUnitVec3Temp[0];
+        out[1] = fromUnitVec3Temp[1];
+        out[2] = fromUnitVec3Temp[2];
+        out[3] = r;
+        normalize(out, out);
+        return out;
+    }
+    Quat.fromUnitVec3 = fromUnitVec3;
+    function clone(a) {
+        var out = zero();
+        out[0] = a[0];
+        out[1] = a[1];
+        out[2] = a[2];
+        out[3] = a[3];
+        return out;
+    }
+    Quat.clone = clone;
+    function toArray(a, out, offset) {
+        out[offset + 0] = a[0];
+        out[offset + 1] = a[1];
+        out[offset + 2] = a[2];
+        out[offset + 3] = a[3];
+        return out;
+    }
+    Quat.toArray = toArray;
+    function fromArray(a, array, offset) {
+        a[0] = array[offset + 0];
+        a[1] = array[offset + 1];
+        a[2] = array[offset + 2];
+        a[3] = array[offset + 3];
+        return a;
+    }
+    Quat.fromArray = fromArray;
+    function copy(out, a) {
+        out[0] = a[0];
+        out[1] = a[1];
+        out[2] = a[2];
+        out[3] = a[3];
+        return out;
+    }
+    Quat.copy = copy;
+    function set(out, x, y, z, w) {
+        out[0] = x;
+        out[1] = y;
+        out[2] = z;
+        out[3] = w;
+        return out;
+    }
+    Quat.set = set;
+    /**
+     * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)
+     */
+    function exactEquals(a, b) {
+        return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];
+    }
+    Quat.exactEquals = exactEquals;
+    /**
+     * Returns whether or not the quaternions have approximately the same elements in the same position.
+     */
+    function equals(a, b) {
+        var a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
+        var b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
+        return (Math.abs(a0 - b0) <= common_1.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) &&
+            Math.abs(a1 - b1) <= common_1.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) &&
+            Math.abs(a2 - b2) <= common_1.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) &&
+            Math.abs(a3 - b3) <= common_1.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)));
+    }
+    Quat.equals = equals;
+    function add(out, a, b) {
+        out[0] = a[0] + b[0];
+        out[1] = a[1] + b[1];
+        out[2] = a[2] + b[2];
+        out[3] = a[3] + b[3];
+        return out;
+    }
+    Quat.add = add;
+    function normalize(out, a) {
+        var x = a[0];
+        var y = a[1];
+        var z = a[2];
+        var w = a[3];
+        var len = x * x + y * y + z * z + w * w;
+        if (len > 0) {
+            len = 1 / Math.sqrt(len);
+            out[0] = x * len;
+            out[1] = y * len;
+            out[2] = z * len;
+            out[3] = w * len;
+        }
+        return out;
+    }
+    Quat.normalize = normalize;
+    /**
+     * Sets a quaternion to represent the shortest rotation from one
+     * vector to another.
+     *
+     * Both vectors are assumed to be unit length.
+     */
+    var rotTmpVec3 = [0, 0, 0];
+    var rotTmpVec3UnitX = [1, 0, 0];
+    var rotTmpVec3UnitY = [0, 1, 0];
+    function rotationTo(out, a, b) {
+        var dot = vec3_1.Vec3.dot(a, b);
+        if (dot < -0.999999) {
+            vec3_1.Vec3.cross(rotTmpVec3, rotTmpVec3UnitX, a);
+            if (vec3_1.Vec3.magnitude(rotTmpVec3) < 0.000001)
+                vec3_1.Vec3.cross(rotTmpVec3, rotTmpVec3UnitY, a);
+            vec3_1.Vec3.normalize(rotTmpVec3, rotTmpVec3);
+            setAxisAngle(out, rotTmpVec3, Math.PI);
+            return out;
+        }
+        else if (dot > 0.999999) {
+            out[0] = 0;
+            out[1] = 0;
+            out[2] = 0;
+            out[3] = 1;
+            return out;
+        }
+        else {
+            vec3_1.Vec3.cross(rotTmpVec3, a, b);
+            out[0] = rotTmpVec3[0];
+            out[1] = rotTmpVec3[1];
+            out[2] = rotTmpVec3[2];
+            out[3] = 1 + dot;
+            return normalize(out, out);
+        }
+    }
+    Quat.rotationTo = rotationTo;
+    /**
+     * Performs a spherical linear interpolation with two control points
+     */
+    var sqlerpTemp1 = zero();
+    var sqlerpTemp2 = zero();
+    function sqlerp(out, a, b, c, d, t) {
+        slerp(sqlerpTemp1, a, d, t);
+        slerp(sqlerpTemp2, b, c, t);
+        slerp(out, sqlerpTemp1, sqlerpTemp2, 2 * t * (1 - t));
+        return out;
+    }
+    Quat.sqlerp = sqlerp;
+    /**
+     * Sets the specified quaternion with values corresponding to the given
+     * axes. Each axis is a vec3 and is expected to be unit length and
+     * perpendicular to all other specified axes.
+     */
+    var axesTmpMat = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    function setAxes(out, view, right, up) {
+        axesTmpMat[0] = right[0];
+        axesTmpMat[3] = right[1];
+        axesTmpMat[6] = right[2];
+        axesTmpMat[1] = up[0];
+        axesTmpMat[4] = up[1];
+        axesTmpMat[7] = up[2];
+        axesTmpMat[2] = -view[0];
+        axesTmpMat[5] = -view[1];
+        axesTmpMat[8] = -view[2];
+        return normalize(out, fromMat3(out, axesTmpMat));
+    }
+    Quat.setAxes = setAxes;
+    function toString(a, precision) {
+        return "[".concat(a[0].toPrecision(precision), " ").concat(a[1].toPrecision(precision), " ").concat(a[2].toPrecision(precision), "  ").concat(a[3].toPrecision(precision), "]");
+    }
+    Quat.toString = toString;
+    Quat.Identity = identity();
+})(Quat || (Quat = {}));
+exports.Quat = Quat;
+//# sourceMappingURL=quat.js.map