linearly 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Baku Hashimoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# Lienarly
+
+[glMatrix](https://github.com/toji/gl-matrix)-like library but using immutable data structure.

package/lib/common.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Common utilities
+ */
+export declare const EPSILON = 0.000001;
+/**
+ * Symmetric round
+ * see https://www.npmjs.com/package/round-half-up-symmetric#user-content-detailed-background
+ */
+export declare function round(a: number): number;
+export type AngleOrder = 'xyz' | 'xzy' | 'yxz' | 'yzx' | 'zxy' | 'zyx';
+export declare const DEFAULT_ANGLE_ORDER: AngleOrder;

package/lib/common.js

@@ -0,0 +1,16 @@
+/**
+ * Common utilities
+ */
+// Configuration Constants
+export const EPSILON = 0.000001;
+/**
+ * Symmetric round
+ * see https://www.npmjs.com/package/round-half-up-symmetric#user-content-detailed-background
+ */
+export function round(a) {
+    if (a >= 0)
+        return Math.round(a);
+    return a % 0.5 === 0 ? Math.floor(a) : Math.round(a);
+}
+export const DEFAULT_ANGLE_ORDER = 'zyx';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbW1vbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILDBCQUEwQjtBQUMxQixNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsUUFBUSxDQUFBO0FBRS9COzs7R0FHRztBQUNILE1BQU0sVUFBVSxLQUFLLENBQUMsQ0FBUztJQUM5QixJQUFJLENBQUMsSUFBSSxDQUFDO1FBQUUsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBQ2hDLE9BQU8sQ0FBQyxHQUFHLEdBQUcsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUE7QUFDckQsQ0FBQztBQUlELE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFlLEtBQUssQ0FBQSJ9

package/lib/index.d.ts

@@ -0,0 +1,16 @@
+export * as vec2 from './vec2';
+export type { Vec2 } from './vec2';
+export * as vec3 from './vec3';
+export type { Vec3 } from './vec3';
+export * as vec4 from './vec4';
+export type { Vec4 } from './vec4';
+export * as mat2 from './mat2';
+export type { Mat2 } from './mat2';
+export * as mat2d from './mat2d';
+export type { Mat2d } from './mat2d';
+export * as mat3 from './mat3';
+export type { Mat3 } from './mat3';
+export * as mat4 from './mat4';
+export type { Mat4 } from './mat4';
+export * as quat from './quat';
+export type { Quat } from './quat';

package/lib/index.js

@@ -0,0 +1,9 @@
+export * as vec2 from './vec2';
+export * as vec3 from './vec3';
+export * as vec4 from './vec4';
+export * as mat2 from './mat2';
+export * as mat2d from './mat2d';
+export * as mat3 from './mat3';
+export * as mat4 from './mat4';
+export * as quat from './quat';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLElBQUksTUFBTSxRQUFRLENBQUE7QUFHOUIsT0FBTyxLQUFLLElBQUksTUFBTSxRQUFRLENBQUE7QUFHOUIsT0FBTyxLQUFLLElBQUksTUFBTSxRQUFRLENBQUE7QUFHOUIsT0FBTyxLQUFLLElBQUksTUFBTSxRQUFRLENBQUE7QUFHOUIsT0FBTyxLQUFLLEtBQUssTUFBTSxTQUFTLENBQUE7QUFHaEMsT0FBTyxLQUFLLElBQUksTUFBTSxRQUFRLENBQUE7QUFHOUIsT0FBTyxLQUFLLElBQUksTUFBTSxRQUFRLENBQUE7QUFHOUIsT0FBTyxLQUFLLElBQUksTUFBTSxRQUFRLENBQUEifQ==

package/lib/mat2.d.ts

@@ -0,0 +1,78 @@
+import { Vec2 } from './vec2';
+export type Mat2 = readonly [number, number, number, number];
+/**
+ * The identity matrix of mat2
+ *
+ */
+export declare const identity: Mat2;
+/**
+ * Transpose the values of a mat2
+ */
+export declare function transpose(a: Mat2): Mat2;
+/**
+ * Inverts a mat2
+ */
+export declare function invert(a: Mat2): Mat2 | null;
+/**
+ * Calculates the adjugate of a mat2
+ */
+export declare function adjoint(a: Mat2): Mat2;
+/**
+ * Calculates the determinant of a mat2
+ * @returns determinant of a
+ */
+export declare function determinant(a: Mat2): number;
+/**
+ * Multiplies two mat2's
+ */
+export declare function multiply(a: Mat2, b: Mat2): Mat2;
+/**
+ * Rotates a mat2 by the given angle
+ *
+ * @param a the matrix to rotate
+ * @param rad the angle to rotate the matrix by
+ */
+export declare function rotate(a: Mat2, rad: number): Mat2;
+/**
+ * Scales the mat2 by the dimensions in the given vec2
+ **/
+export declare function scale(a: Mat2, v: Vec2): Mat2;
+/**
+ * Creates a matrix from a given angle
+ */
+export declare function fromRotation(rad: number): Mat2;
+/**
+ * Creates a matrix from a vector scaling
+ */
+export declare function fromScaling(v: Vec2): Mat2;
+/**
+ * Returns Frobenius norm of a mat2
+ */
+export declare function frob(a: Mat2): number;
+/**
+ * Adds two mat2's
+ */
+export declare function add(a: Mat2, b: Mat2): Mat2;
+/**
+ * Subtracts matrix b from matrix a
+ */
+export declare function subtract(a: Mat2, b: Mat2): Mat2;
+/**
+ * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
+ */
+export declare function exactEquals(a: Mat2, b: Mat2): boolean;
+/**
+ * Returns whether or not the matrices have approximately the same elements in the same position.
+ */
+export declare function equals(a: Mat2, b: Mat2): boolean;
+/**
+ * Multiply each element of the matrix by a scalar.
+ *
+ * @param a the matrix to scale
+ * @param s amount to scale the matrix's elements by
+ */
+export declare function multiplyScalar(a: Mat2, s: number): Mat2;
+/**
+ * Adds two mat2's after multiplying each element of the second operand by a scalar value.
+ */
+export declare function multiplyScalarAndAdd(a: Mat2, b: Mat2, scale: number): Mat2;

package/lib/mat2.js

@@ -0,0 +1,155 @@
+import * as Common from './common';
+/**
+ * The identity matrix of mat2
+ *
+ */
+export const identity = Object.freeze([1, 0, 0, 1]);
+/**
+ * Transpose the values of a mat2
+ */
+export function transpose(a) {
+    // prettier-ignore
+    return [
+        a[0], a[2],
+        a[1], a[3],
+    ];
+}
+/**
+ * Inverts a mat2
+ */
+export function invert(a) {
+    const [a0, a1, a2, a3] = a;
+    // Calculate the determinant
+    const det = a0 * a3 - a2 * a1;
+    if (!det) {
+        return null;
+    }
+    const detinv = 1 / det;
+    // prettier-ignore
+    return [
+        a3 * detinv, -a1 * detinv,
+        -a2 * detinv, a0 * detinv
+    ];
+}
+/**
+ * Calculates the adjugate of a mat2
+ */
+export function adjoint(a) {
+    // Caching this value is necessary if out == a
+    const a0 = a[0];
+    return [a[3], -a[1], -a[2], a0];
+}
+/**
+ * Calculates the determinant of a mat2
+ * @returns determinant of a
+ */
+export function determinant(a) {
+    return a[0] * a[3] - a[2] * a[1];
+}
+/**
+ * Multiplies two mat2's
+ */
+export function multiply(a, b) {
+    const [a0, a1, a2, a3] = a;
+    const [b0, b1, b2, b3] = b;
+    return [
+        a0 * b0 + a2 * b1,
+        a1 * b0 + a3 * b1,
+        a0 * b2 + a2 * b3,
+        a1 * b2 + a3 * b3,
+    ];
+}
+/**
+ * Rotates a mat2 by the given angle
+ *
+ * @param a the matrix to rotate
+ * @param rad the angle to rotate the matrix by
+ */
+export function rotate(a, rad) {
+    const [a0, a1, a2, a3] = a;
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    return [a0 * c + a2 * s, a1 * c + a3 * s, a0 * -s + a2 * c, a1 * -s + a3 * c];
+}
+/**
+ * Scales the mat2 by the dimensions in the given vec2
+ **/
+export function scale(a, v) {
+    const [a0, a1, a2, a3] = a;
+    const [v0, v1] = v;
+    return [a0 * v0, a1 * v0, a2 * v1, a3 * v1];
+}
+/**
+ * Creates a matrix from a given angle
+ */
+export function fromRotation(rad) {
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    return [c, s, -s, c];
+}
+/**
+ * Creates a matrix from a vector scaling
+ */
+export function fromScaling(v) {
+    return [v[0], 0, 0, v[1]];
+}
+/**
+ * Returns Frobenius norm of a mat2
+ */
+export function frob(a) {
+    return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3]);
+}
+/**
+ * Adds two mat2's
+ */
+export function add(a, b) {
+    return [a[0] + b[0], a[1] + b[1], a[2] + b[2], a[3] + b[3]];
+}
+/**
+ * Subtracts matrix b from matrix a
+ */
+export function subtract(a, b) {
+    return [a[0] - b[0], a[1] - b[1], a[2] - b[2], a[3] - b[3]];
+}
+/**
+ * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
+ */
+export function exactEquals(a, b) {
+    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];
+}
+/**
+ * Returns whether or not the matrices have approximately the same elements in the same position.
+ */
+export function equals(a, b) {
+    const [a0, a1, a2, a3] = a;
+    const [b0, b1, b2, b3] = b;
+    return (Math.abs(a0 - b0) <=
+        Common.EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) &&
+        Math.abs(a1 - b1) <=
+            Common.EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) &&
+        Math.abs(a2 - b2) <=
+            Common.EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)) &&
+        Math.abs(a3 - b3) <=
+            Common.EPSILON * Math.max(1, Math.abs(a3), Math.abs(b3)));
+}
+/**
+ * Multiply each element of the matrix by a scalar.
+ *
+ * @param a the matrix to scale
+ * @param s amount to scale the matrix's elements by
+ */
+export function multiplyScalar(a, s) {
+    return [a[0] * s, a[1] * s, a[2] * s, a[3] * s];
+}
+/**
+ * Adds two mat2's after multiplying each element of the second operand by a scalar value.
+ */
+export function multiplyScalarAndAdd(a, b, scale) {
+    return [
+        a[0] + b[0] * scale,
+        a[1] + b[1] * scale,
+        a[2] + b[2] * scale,
+        a[3] + b[3] * scale,
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mat2d.d.ts

@@ -0,0 +1,89 @@
+import { Vec2 } from './vec2';
+export type Mat2d = readonly [number, number, number, number, number, number];
+/**
+ * 2x3 Matrix
+ * @module mat2d
+ * @description
+ * A mat2d contains six elements defined as:
+ * <pre>
+ * [a, b,
+ *  c, d,
+ *  tx, ty]
+ * </pre>
+ * This is a short form for the 3x3 matrix:
+ * <pre>
+ * [a, b, 0,
+ *  c, d, 0,
+ *  tx, ty, 1]
+ * </pre>
+ * The last column is ignored so the array is shorter and operations are faster.
+ */
+/**
+ * The identity matrix of mat2d
+ */
+export declare const identity: readonly number[];
+/**
+ * Inverts a mat2d
+ */
+export declare function invert(a: Mat2d): Mat2d | null;
+/**
+ * Calculates the determinant of a mat2d
+ */
+export declare function determinant(a: Mat2d): number;
+/**
+ * Multiplies two mat2d's
+ */
+export declare function multiply(a: Mat2d, b: Mat2d): Mat2d;
+/**
+ * Rotates a mat2d by the given angle
+ */
+export declare function rotate(a: Mat2d, rad: number): Mat2d;
+/**
+ * Scales the mat2d by the dimensions in the given vec2
+ **/
+export declare function scale(a: Mat2d, v: Vec2): Mat2d;
+/**
+ * Translates the mat2d by the dimensions in the given vec2
+ **/
+export declare function translate(m: Mat2d, v: Vec2): Mat2d;
+/**
+ * Creates a matrix from a given angle
+ * This is equivalent to (but much faster than):
+ */
+export declare function fromRotation(rad: number): Mat2d;
+/**
+ * Creates a matrix from a vector scaling
+ */
+export declare function fromScaling(v: Vec2): Mat2d;
+/**
+ * Creates a matrix from a vector translation
+ */
+export declare function fromTranslation(v: Vec2): Mat2d;
+/**
+ * Returns Frobenius norm of a mat2d
+ */
+export declare function frob(a: Mat2d): number;
+/**
+ * Adds two mat2d's
+ */
+export declare function add(a: Mat2d, b: Mat2d): Mat2d;
+/**
+ * Subtracts matrix b from matrix a
+ */
+export declare function subtract(a: Mat2d, b: Mat2d): Mat2d;
+/**
+ * Multiply each element of the matrix by a scalar.
+ */
+export declare function multiplyScalar(a: Mat2d, s: number): Mat2d;
+/**
+ * Adds two mat2d's after multiplying each element of the second operand by a scalar value.
+ */
+export declare function multiplyScalarAndAdd(a: Mat2d, b: Mat2d, scale: number): Mat2d;
+/**
+ * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
+ */
+export declare function exactEquals(a: Mat2d, b: Mat2d): boolean;
+/**
+ * Returns whether or not the matrices have approximately the same elements in the same position.
+ */
+export declare function equals(a: Mat2d, b: Mat2d): boolean;

package/lib/mat2d.js

@@ -0,0 +1,238 @@
+import * as Common from './common';
+/**
+ * 2x3 Matrix
+ * @module mat2d
+ * @description
+ * A mat2d contains six elements defined as:
+ * <pre>
+ * [a, b,
+ *  c, d,
+ *  tx, ty]
+ * </pre>
+ * This is a short form for the 3x3 matrix:
+ * <pre>
+ * [a, b, 0,
+ *  c, d, 0,
+ *  tx, ty, 1]
+ * </pre>
+ * The last column is ignored so the array is shorter and operations are faster.
+ */
+/**
+ * The identity matrix of mat2d
+ */
+// prettier-ignore
+export const identity = Object.freeze([
+    1, 0,
+    0, 1,
+    0, 0
+]);
+/**
+ * Inverts a mat2d
+ */
+export function invert(a) {
+    const [aa, ab, ac, ad, atx, aty] = a;
+    const det = aa * ad - ab * ac;
+    if (!det) {
+        return null;
+    }
+    const detinv = 1 / det;
+    // prettier-ignore
+    return [
+        ad * detinv, -ab * detinv,
+        -ac * detinv, aa * detinv,
+        (ac * aty - ad * atx) * detinv,
+        (ab * atx - aa * aty) * detinv,
+    ];
+}
+/**
+ * Calculates the determinant of a mat2d
+ */
+export function determinant(a) {
+    return a[0] * a[3] - a[1] * a[2];
+}
+/**
+ * Multiplies two mat2d's
+ */
+export function multiply(a, b) {
+    const [a0, a1, a2, a3, a4, a5] = a;
+    const [b0, b1, b2, b3, b4, b5] = b;
+    // prettier-ignore
+    return [
+        a0 * b0 + a2 * b1, a1 * b0 + a3 * b1,
+        a0 * b2 + a2 * b3, a1 * b2 + a3 * b3,
+        a0 * b4 + a2 * b5 + a4,
+        a1 * b4 + a3 * b5 + a5,
+    ];
+}
+/**
+ * Rotates a mat2d by the given angle
+ */
+export function rotate(a, rad) {
+    const [a0, a1, a2, a3, tx, ty] = a;
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    // prettier-ignore
+    return [
+        a0 * c + a2 * s, a1 * c + a3 * s,
+        a0 * -s + a2 * c, a1 * -s + a3 * c,
+        tx, ty
+    ];
+}
+/**
+ * Scales the mat2d by the dimensions in the given vec2
+ **/
+export function scale(a, v) {
+    const [a0, a1, a2, a3, tx, ty] = a;
+    const [sx, sy] = v;
+    // prettier-ignore
+    return [
+        a0 * sx, a1 * sx,
+        a2 * sy, a3 * sy,
+        tx, ty
+    ];
+}
+/**
+ * Translates the mat2d by the dimensions in the given vec2
+ **/
+export function translate(m, v) {
+    const [a, b, c, d, tx, ty] = m;
+    const [x, y] = v;
+    // prettier-ignore
+    return [
+        a, b,
+        c, d,
+        a * x + c * y + tx,
+        b * x + d * y + ty
+    ];
+}
+/**
+ * Creates a matrix from a given angle
+ * This is equivalent to (but much faster than):
+ */
+export function fromRotation(rad) {
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    // prettier-ignore
+    return [
+        c, s,
+        -s, c,
+        0, 0,
+    ];
+}
+/**
+ * Creates a matrix from a vector scaling
+ */
+export function fromScaling(v) {
+    const [x, y] = v;
+    // prettier-ignore
+    return [
+        x, 0,
+        0, y,
+        0, 0,
+    ];
+}
+/**
+ * Creates a matrix from a vector translation
+ */
+export function fromTranslation(v) {
+    const [x, y] = v;
+    // prettier-ignore
+    return [
+        1, 0,
+        0, 1,
+        x, y,
+    ];
+}
+/**
+ * Returns Frobenius norm of a mat2d
+ */
+export function frob(a) {
+    // prettier-ignore
+    return Math.sqrt(a[0] ** 2 +
+        a[1] ** 2 +
+        a[2] ** 2 +
+        a[3] ** 2 +
+        a[4] ** 2 +
+        a[5] ** 2 + 1);
+}
+/**
+ * Adds two mat2d's
+ */
+export function add(a, b) {
+    return [
+        a[0] + b[0],
+        a[1] + b[1],
+        a[2] + b[2],
+        a[3] + b[3],
+        a[4] + b[4],
+        a[5] + b[5],
+    ];
+}
+/**
+ * Subtracts matrix b from matrix a
+ */
+export function subtract(a, b) {
+    return [
+        a[0] - b[0],
+        a[1] - b[1],
+        a[2] - b[2],
+        a[3] - b[3],
+        a[4] - b[4],
+        a[5] - b[5],
+    ];
+}
+/**
+ * Multiply each element of the matrix by a scalar.
+ */
+export function multiplyScalar(a, s) {
+    // prettier-ignore
+    return [
+        a[0] * s, a[1] * s,
+        a[2] * s, a[3] * s,
+        a[4] * s, a[5] * s,
+    ];
+}
+/**
+ * Adds two mat2d's after multiplying each element of the second operand by a scalar value.
+ */
+export function multiplyScalarAndAdd(a, b, scale) {
+    return [
+        a[0] + b[0] * scale,
+        a[1] + b[1] * scale,
+        a[2] + b[2] * scale,
+        a[3] + b[3] * scale,
+        a[4] + b[4] * scale,
+        a[5] + b[5] * scale,
+    ];
+}
+/**
+ * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
+ */
+export function exactEquals(a, b) {
+    return (a[0] === b[0] &&
+        a[1] === b[1] &&
+        a[2] === b[2] &&
+        a[3] === b[3] &&
+        a[4] === b[4] &&
+        a[5] === b[5]);
+}
+/**
+ * Returns whether or not the matrices have approximately the same elements in the same position.
+ */
+export function equals(a, b) {
+    const [a0, a1, a2, a3, a4, a5] = a;
+    const [b0, b1, b2, b3, b4, b5] = b;
+    return (Math.abs(a0 - b0) <=
+        Common.EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) &&
+        Math.abs(a1 - b1) <=
+            Common.EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) &&
+        Math.abs(a2 - b2) <=
+            Common.EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)) &&
+        Math.abs(a3 - b3) <=
+            Common.EPSILON * Math.max(1, Math.abs(a3), Math.abs(b3)) &&
+        Math.abs(a4 - b4) <=
+            Common.EPSILON * Math.max(1, Math.abs(a4), Math.abs(b4)) &&
+        Math.abs(a5 - b5) <=
+            Common.EPSILON * Math.max(1, Math.abs(a5), Math.abs(b5)));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mat2d.js","sourceRoot":"","sources":["../src/mat2d.ts"],"names":[],"mappings":"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"}

package/lib/mat2d.test.d.ts

@@ -0,0 +1 @@
+export {};