molstar 3.0.0 → 3.0.1

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

@@ -1,33 +0,0 @@
-/**
- * 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

@@ -1,136 +0,0 @@
-"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

@@ -1,89 +0,0 @@
-/**
- * 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

@@ -1,435 +0,0 @@
-"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