@benev/math 0.0.0-0

package/s/concepts/vec3.ts

@@ -0,0 +1,439 @@
+
+import {Scalar} from "./scalar.js"
+
+export type Vec3Array = [number, number, number]
+export type Xyz = {x: number, y: number, z: number}
+
+/** https://github.com/microsoft/TypeScript/issues/5863 */
+type TsHack<T> = {new(...a: ConstructorParameters<typeof Vec3>): T}
+
+export class Vec3 {
+	constructor(
+		public x: number,
+		public y: number,
+		public z: number,
+	) {}
+
+	///////////////////////////////////////////////////////////////////////
+
+	static new<T extends Vec3>(this: TsHack<T>, x: number, y: number, z: number) {
+		return new this(x, y, z)
+	}
+
+	static zero<T extends Vec3>(this: TsHack<T>) {
+		return new this(0, 0, 0)
+	}
+
+	static all<T extends Vec3>(this: TsHack<T>, value: number) {
+		return new this(value, value, value)
+	}
+
+	static array<T extends Vec3>(this: TsHack<T>, v: Vec3Array) {
+		return new this(...v)
+	}
+
+	static import<T extends Vec3>(this: TsHack<T>, {x, y, z}: Xyz): Vec3 {
+		return new this(x, y, z)
+	}
+
+	static from(v: Vec3Array | Xyz) {
+		return Array.isArray(v)
+			? this.array(v)
+			: this.import(v)
+	}
+
+	static magnitudeSquared(x: number, y: number, z: number) {
+		return (x ** 2) + (y ** 2) + (z ** 2)
+	}
+
+	static magnitude(x: number, y: number, z: number) {
+		return Math.sqrt(this.magnitudeSquared(x, y, z))
+	}
+
+	static average(...vecs: Xyz[]) {
+		return this.zero()
+			.add(...vecs)
+			.divideBy(vecs.length)
+	}
+
+	static min(...vecs: Vec3[]) {
+		return new Vec3(
+			Math.min(...vecs.map(v => v.x)),
+			Math.min(...vecs.map(v => v.y)),
+			Math.min(...vecs.map(v => v.z)),
+		)
+	}
+
+	static max(...vecs: Vec3[]) {
+		return new Vec3(
+			Math.max(...vecs.map(v => v.x)),
+			Math.max(...vecs.map(v => v.y)),
+			Math.max(...vecs.map(v => v.z)),
+		)
+	}
+
+	static hexColor(hex: string): Vec3 {
+		if (hex.startsWith("#") && hex.length === 7) {
+			const r = parseInt(hex.slice(1, 3), 16) / 255
+			const g = parseInt(hex.slice(3, 5), 16) / 255
+			const b = parseInt(hex.slice(5, 7), 16) / 255
+			return new this(r, g, b)
+		} else {
+			throw new Error("invalid hex color format")
+		}
+	}
+
+	///////////////////////////////////////////////////////////////////////
+
+	clone() {
+		return new Vec3(this.x, this.y, this.z)
+	}
+
+	array(): Vec3Array {
+		return [this.x, this.y, this.z]
+	}
+
+	toString() {
+		return `(Vec3 x${this.x.toFixed(2)}, y${this.y.toFixed(2)}, z${this.z.toFixed(2)})`
+	}
+
+	set_(x: number, y: number, z: number) {
+		this.x = x
+		this.y = y
+		this.z = z
+		return this
+	}
+
+	set({x, y, z}: Xyz) {
+		this.x = x
+		this.y = y
+		this.z = z
+		return this
+	}
+
+	///////////////////////////////////////////////////////////////////////
+
+	magnitudeSquared() {
+		return Vec3.magnitudeSquared(this.x, this.y, this.z)
+	}
+
+	magnitude() {
+		return Vec3.magnitude(this.x, this.y, this.z)
+	}
+
+	hexColor() {
+		const to255 = (val: number) => Math.round(val * 255)
+		const toHex = (val: number) => to255(val).toString(16).padStart(2, '0')
+		return `#${toHex(this.x)}${toHex(this.y)}${toHex(this.z)}`
+	}
+
+	///////////////////////////////////////////////////////////////////////
+
+	equals_(x: number, y: number, z: number) {
+		return (
+			this.x === x &&
+			this.y === y &&
+			this.z === z
+		)
+	}
+
+	equals(...vecs: Xyz[]) {
+		return vecs.every(v => this.equals_(v.x, v.y, v.z))
+	}
+
+	distanceSquared_(x: number, y: number, z: number) {
+		const dx = this.x - x
+		const dy = this.y - y
+		const dz = this.z - z
+		return (dx ** 2) + (dy ** 2) + (dz ** 2)
+	}
+
+	distanceSquared({x, y, z}: Xyz) {
+		return this.distanceSquared_(x, y, z)
+	}
+
+	distance_(x: number, y: number, z: number) {
+		return Math.sqrt(this.distanceSquared_(x, y, z))
+	}
+
+	distance({x, y, z}: Xyz) {
+		return this.distance_(x, y, z)
+	}
+
+	dot_(x: number, y: number, z: number) {
+		return (this.x * x) + (this.y * y) + (this.z * z)
+	}
+
+	dot({x, y, z}: Xyz) {
+		return this.dot_(x, y, z)
+	}
+
+	inRange_(x: number, y: number, z: number, radius: number) {
+		const d2 = this.distanceSquared_(x, y, z)
+		return d2 < (radius ** 2)
+	}
+
+	inRange({x, y, z}: Xyz, radius: number) {
+		return this.inRange_(x, y, z, radius)
+	}
+
+	angleBetween_(x: number, y: number, z: number) {
+		const dotProduct = this.dot_(x, y, z)
+		const magnitudes = this.magnitude() * Vec3.new(x, y, z).magnitude()
+		return Math.acos(dotProduct / magnitudes)
+	}
+
+	angleBetween({x, y, z}: Xyz) {
+		return this.angleBetween_(x, y, z)
+	}
+
+	///////////////////////////////////////////////////////////////////////
+
+	/** mutator */
+	add_(x: number, y: number, z: number) {
+		this.x += x
+		this.y += y
+		this.z += z
+		return this
+	}
+
+	/** mutator */
+	add(...vecs: Xyz[]) {
+		for (const {x, y, z} of vecs) this.add_(x, y, z)
+		return this
+	}
+
+	/** mutator */
+	subtract_(x: number, y: number, z: number) {
+		this.x -= x
+		this.y -= y
+		this.z -= z
+		return this
+	}
+
+	/** mutator */
+	subtract(...vecs: Xyz[]) {
+		for (const {x, y, z} of vecs) this.subtract_(x, y, z)
+		return this
+	}
+
+	/** mutator */
+	multiply_(x: number, y: number, z: number) {
+		this.x *= x
+		this.y *= y
+		this.z *= z
+		return this
+	}
+
+	/** mutator */
+	multiply(...vecs: Vec3[]) {
+		for (const {x, y, z} of vecs) this.multiply_(x, y, z)
+		return this
+	}
+
+	/** mutator */
+	divide_(x: number, y: number, z: number) {
+		this.x /= x
+		this.y /= y
+		this.z /= z
+		return this
+	}
+
+	/** mutator */
+	divide(...vecs: Vec3[]) {
+		for (const {x, y, z} of vecs) this.divide_(x, y, z)
+		return this
+	}
+
+	///////////////////////////////////////////////////////////////////////
+
+	/** mutator */
+	half() {
+		return this.divideBy(2)
+	}
+
+	/** mutator */
+	double() {
+		return this.multiplyBy(2)
+	}
+
+	/** mutator */
+	abs() {
+		return this.map(x => Math.abs(x))
+	}
+
+	/** mutator */
+	map(fn: (a: number, index: number) => number) {
+		this.x = fn(this.x, 0)
+		this.y = fn(this.y, 1)
+		this.z = fn(this.z, 2)
+		return this
+	}
+
+	/** mutator */
+	negate() {
+		this.x = -this.x
+		this.y = -this.y
+		this.z = -this.z
+		return this
+	}
+
+	/** mutator */
+	addBy(delta: number) {
+		this.x += delta
+		this.y += delta
+		this.z += delta
+		return this
+	}
+
+	/** mutator */
+	multiplyBy(delta: number) {
+		this.x *= delta
+		this.y *= delta
+		this.z *= delta
+		return this
+	}
+
+	/** mutator */
+	divideBy(divisor: number) {
+		if (divisor === 0) return this
+		this.x /= divisor
+		this.y /= divisor
+		this.z /= divisor
+		return this
+	}
+
+	/** mutator */
+	normalize() {
+		return this.divideBy(this.magnitude())
+	}
+
+	/** mutator */
+	clampMagnitude(max: number) {
+		const magnitude = this.magnitude()
+		if (magnitude > max) this.normalize().multiplyBy(max)
+		return this
+	}
+
+	/** mutator */
+	floor(): this {
+		this.x = Math.floor(this.x)
+		this.y = Math.floor(this.y)
+		this.z = Math.floor(this.z)
+		return this
+	}
+
+	/** mutator */
+	ceil(): this {
+		this.x = Math.ceil(this.x)
+		this.y = Math.ceil(this.y)
+		this.z = Math.ceil(this.z)
+		return this
+	}
+
+	/** mutator */
+	round(): this {
+		this.x = Math.round(this.x)
+		this.y = Math.round(this.y)
+		this.z = Math.round(this.z)
+		return this
+	}
+
+	///////////////////////////////////////////////////////////////////////
+
+	/** mutator */
+	cross_(x2: number, y2: number, z2: number) {
+		const {x: x1, y: y1, z: z1} = this
+		this.x = (y1 * z2) - (z1 * y2)
+		this.y = (z1 * x2) - (x1 * z2)
+		this.z = (x1 * y2) - (y1 * x2)
+		return this
+	}
+
+	/** mutator */
+	cross({x, y, z}: Xyz) {
+		return this.cross_(x, y, z)
+	}
+
+	/** mutator */
+	lerp_(x: number, y: number, z: number, fraction: number): this {
+		this.x += (x - this.x) * fraction
+		this.y += (y - this.y) * fraction
+		this.z += (z - this.z) * fraction
+		return this
+	}
+
+	/** mutator */
+	lerp({x, y, z}: Xyz, fraction: number) {
+		return this.lerp_(x, y, z, fraction)
+	}
+
+	approach_(x: number, y: number, z: number, speed: number, deltaTime: number, speedLimit?: number) {
+		this.x = Scalar.approach(this.x, x, speed, deltaTime, speedLimit)
+		this.y = Scalar.approach(this.y, y, speed, deltaTime, speedLimit)
+		this.z = Scalar.approach(this.z, z, speed, deltaTime, speedLimit)
+		return this
+	}
+
+	approach({x, y, z}: Xyz, speed: number, deltaTime: number, speedLimit?: number) {
+		return this.approach_(x, y, z, speed, deltaTime, speedLimit)
+	}
+
+	/** mutator */
+	projectOnto_(x: number, y: number, z: number) {
+		const scalar = this.dot_(x, y, z) / Vec3.magnitudeSquared(x, y, z)
+		this.x = scalar * x
+		this.y = scalar * y
+		this.z = scalar * z
+		return this
+	}
+
+	/** mutator */
+	projectOnto({x, y, z}: Vec3) {
+		return this.projectOnto_(x, y, z)
+	}
+
+	/** mutator */
+	reflect_(x: number, y: number, z: number) {
+		const dot = this.dot_(x, y, z) * 2
+		this.x -= dot * x
+		this.y -= dot * y
+		this.z -= dot * z
+		return this
+	}
+
+	/** mutator */
+	reflect({x, y, z}: Xyz) {
+		return this.reflect_(x, y, z)
+	}
+
+	/** mutator */
+	rotateAroundAxis_(ux: number, uy: number, uz: number, angle: number): this {
+		const cos = Math.cos(angle)
+		const sin = Math.sin(angle)
+		const {x, y, z} = this
+		this.x = (cos + (1 - cos) * ux * ux) * x + ((1 - cos) * ux * uy - uz * sin) * y + ((1 - cos) * ux * uz + uy * sin) * z
+		this.y = ((1 - cos) * uy * ux + uz * sin) * x + (cos + (1 - cos) * uy * uy) * y + ((1 - cos) * uy * uz - ux * sin) * z
+		this.z = ((1 - cos) * uz * ux - uy * sin) * x + ((1 - cos) * uz * uy + ux * sin) * y + (cos + (1 - cos) * uz * uz) * z
+		return this
+	}
+
+	/** mutator */
+	rotateAroundAxis({x, y, z}: Xyz, angle: number) {
+		return this.rotateAroundAxis_(x, y, z, angle)
+	}
+
+	/** mutator */
+	smooth_(x: number, y: number, z: number, smoothing: number) {
+		this.x = Scalar.smooth(this.x, x, smoothing)
+		this.y = Scalar.smooth(this.y, y, smoothing)
+		this.z = Scalar.smooth(this.z, z, smoothing)
+		return this
+	}
+
+	/** mutator */
+	smooth({x, y, z}: Xyz, smoothing: number) {
+		return this.smooth_(x, y, z, smoothing)
+	}
+}
+

package/s/concepts/vec4.ts

@@ -0,0 +1,74 @@
+
+import {Xyzw} from "./quat.js"
+
+export type Vec4Array = [number, number, number, number]
+
+export class Vec4 {
+	constructor(
+		public x: number,
+		public y: number,
+		public z: number,
+		public w: number,
+	) {}
+
+	static new(x: number, y: number, z: number, w: number) {
+		return new this(x, y, z, w)
+	}
+
+	static zero() {
+		return new this(0, 0, 0, 0)
+	}
+
+	static array(v: Vec4Array) {
+		return new this(...v)
+	}
+
+	static import({x, y, z, w}: Xyzw) {
+		return new this(x, y, z, w)
+	}
+
+	static from(v: Vec4Array | Xyzw) {
+		return Array.isArray(v)
+			? this.array(v)
+			: this.import(v)
+	}
+
+	array(): Vec4Array {
+		const {x, y, z, w} = this
+		return [x, y, z, w]
+	}
+
+	toString() {
+		return `(Vec4 x${this.x.toFixed(2)}, y${this.y.toFixed(2)}, z${this.z.toFixed(2)}, w${this.w.toFixed(2)})`
+	}
+
+	clone() {
+		return new Vec4(...this.array())
+	}
+
+	set_(x: number, y: number, z: number, w: number) {
+		this.x = x
+		this.y = y
+		this.z = z
+		this.w = w
+		return this
+	}
+
+	set({x, y, z, w}: Xyzw) {
+		this.x = x
+		this.y = y
+		this.z = z
+		this.w = w
+		return this
+	}
+
+	/** mutator */
+	map(fn: (a: number, index: number) => number) {
+		this.x = fn(this.x, 0)
+		this.y = fn(this.y, 1)
+		this.z = fn(this.z, 2)
+		this.w = fn(this.w, 3)
+		return this
+	}
+}
+

package/s/index.ts

@@ -0,0 +1,12 @@
+
+export * from "./concepts/angles.js"
+export * from "./concepts/circular.js"
+export * from "./concepts/noise.js"
+export * from "./concepts/quat.js"
+export * from "./concepts/randy.js"
+export * from "./concepts/scalar.js"
+export * from "./concepts/spline.js"
+export * from "./concepts/vec2.js"
+export * from "./concepts/vec3.js"
+export * from "./concepts/vec4.js"
+

package/x/concepts/angles.d.ts

@@ -0,0 +1,29 @@
+export declare const Radians: {
+    pi: number;
+    circle: number;
+    /** @deprecated use Radians.toDegrees instead */
+    to: {
+        degrees(r: number): number;
+        arcseconds(r: number): number;
+        turns(r: number): number;
+    };
+    /** @deprecated use Degrees.toRadians instead */
+    from: {
+        turns(t: number): number;
+        degrees(d: number): number;
+        arcseconds(a: number): number;
+    };
+    toDegrees(r: number): number;
+    toArcseconds(r: number): number;
+    toTurns(r: number): number;
+    circleDistance(radiansA: number, radiansB: number): number;
+};
+export declare const Turns: {
+    toRadians(t: number): number;
+};
+export declare const Arcseconds: {
+    toRadians(a: number): number;
+};
+export declare const Degrees: {
+    toRadians(d: number): number;
+};

package/x/concepts/angles.js

@@ -0,0 +1,62 @@
+import { Scalar } from "./scalar.js";
+const pi = Math.PI;
+const circle = 2 * Math.PI;
+const to = {
+    degrees(r) {
+        return r * (180 / pi);
+    },
+    arcseconds(r) {
+        return to.degrees(r) * 3600;
+    },
+    turns(r) {
+        return r / circle;
+    },
+};
+const from = {
+    turns(t) {
+        return t * circle;
+    },
+    degrees(d) {
+        return d * (pi / 180);
+    },
+    arcseconds(a) {
+        return from.degrees(a / 3600);
+    }
+};
+export const Radians = {
+    pi,
+    circle,
+    /** @deprecated use Radians.toDegrees instead */
+    to,
+    /** @deprecated use Degrees.toRadians instead */
+    from,
+    toDegrees(r) {
+        return r * (180 / pi);
+    },
+    toArcseconds(r) {
+        return to.degrees(r) * 3600;
+    },
+    toTurns(r) {
+        return r / circle;
+    },
+    circleDistance(radiansA, radiansB) {
+        const diff = Math.abs(Scalar.wrap(radiansA - radiansB, 0, Radians.circle));
+        return Math.min(diff, Radians.circle - diff);
+    },
+};
+export const Turns = {
+    toRadians(t) {
+        return t * circle;
+    },
+};
+export const Arcseconds = {
+    toRadians(a) {
+        return from.degrees(a / 3600);
+    },
+};
+export const Degrees = {
+    toRadians(d) {
+        return d * (pi / 180);
+    },
+};
+//# sourceMappingURL=angles.js.map

package/x/concepts/angles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"angles.js","sourceRoot":"","sources":["../../s/concepts/angles.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,MAAM,EAAC,MAAM,aAAa,CAAA;AAElC,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,CAAA;AAClB,MAAM,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,CAAA;AAE1B,MAAM,EAAE,GAAG;IACV,OAAO,CAAC,CAAS;QAChB,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC,CAAA;IACtB,CAAC;IACD,UAAU,CAAC,CAAS;QACnB,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;IAC5B,CAAC;IACD,KAAK,CAAC,CAAS;QACd,OAAO,CAAC,GAAG,MAAM,CAAA;IAClB,CAAC;CACD,CAAA;AAED,MAAM,IAAI,GAAG;IACZ,KAAK,CAAC,CAAS;QACd,OAAO,CAAC,GAAG,MAAM,CAAA;IAClB,CAAC;IACD,OAAO,CAAC,CAAS;QAChB,OAAO,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAA;IACtB,CAAC;IACD,UAAU,CAAC,CAAS;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAA;IAC9B,CAAC;CACD,CAAA;AAED,MAAM,CAAC,MAAM,OAAO,GAAG;IACtB,EAAE;IACF,MAAM;IAEN,gDAAgD;IAChD,EAAE;IAEF,gDAAgD;IAChD,IAAI;IAEJ,SAAS,CAAC,CAAS;QAClB,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC,CAAA;IACtB,CAAC;IACD,YAAY,CAAC,CAAS;QACrB,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;IAC5B,CAAC;IACD,OAAO,CAAC,CAAS;QAChB,OAAO,CAAC,GAAG,MAAM,CAAA;IAClB,CAAC;IAED,cAAc,CAAC,QAAgB,EAAE,QAAgB;QAChD,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,GAAG,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAA;QAC1E,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAC7C,CAAC;CACD,CAAA;AAED,MAAM,CAAC,MAAM,KAAK,GAAG;IACpB,SAAS,CAAC,CAAS;QAClB,OAAO,CAAC,GAAG,MAAM,CAAA;IAClB,CAAC;CACD,CAAA;AAED,MAAM,CAAC,MAAM,UAAU,GAAG;IACzB,SAAS,CAAC,CAAS;QAClB,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAA;IAC9B,CAAC;CACD,CAAA;AAED,MAAM,CAAC,MAAM,OAAO,GAAG;IACtB,SAAS,CAAC,CAAS;QAClB,OAAO,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAA;IACtB,CAAC;CACD,CAAA"}

package/x/concepts/circular.d.ts

@@ -0,0 +1,17 @@
+export declare class Circular {
+    x: number;
+    constructor(x: number);
+    clone(): Circular;
+    set(x: number): this;
+    static value(x: number | Circular): number;
+    static normalize(x: number): number;
+    normalize(): this;
+    static difference(x: number, y: number): number;
+    difference(y: number | Circular): number;
+    static lerp(x: number, y: number, fraction: number, max?: number): number;
+    lerp(y: number | Circular, fraction: number, max?: number): this;
+    static step(x: number, y: number, delta: number): number;
+    step(y: number | Circular, delta: number): this;
+    static approach(x: number, y: number, speed: number, deltaTime: number, speedLimit?: number): number;
+    approach(y: number | Circular, speed: number, deltaTime: number, speedLimit?: number): this;
+}

package/x/concepts/circular.js

@@ -0,0 +1,70 @@
+import { Scalar } from "./scalar.js";
+export class Circular {
+    x;
+    constructor(x) {
+        this.x = x;
+    }
+    clone() {
+        return new Circular(this.x);
+    }
+    set(x) {
+        this.x = x;
+        return this;
+    }
+    static value(x) {
+        return typeof x === "number"
+            ? x
+            : x.x;
+    }
+    static normalize(x) {
+        return Scalar.wrap(x, 0, 2 * Math.PI);
+    }
+    normalize() {
+        this.x = Circular.normalize(this.x);
+        return this;
+    }
+    static difference(x, y) {
+        x = this.normalize(x);
+        y = this.normalize(y);
+        let delta = y - x;
+        if (delta > Math.PI)
+            delta -= 2 * Math.PI;
+        if (delta < -Math.PI)
+            delta += 2 * Math.PI;
+        return delta;
+    }
+    difference(y) {
+        return Circular.difference(this.x, Circular.value(y));
+    }
+    static lerp(x, y, fraction, max) {
+        const difference = this.difference(x, y);
+        let delta = difference * fraction;
+        if (max !== undefined && Math.abs(delta) > max)
+            delta = Math.sign(delta) * max;
+        return this.normalize(x + delta);
+    }
+    lerp(y, fraction, max) {
+        this.x = Circular.lerp(this.x, Circular.value(y), fraction, max);
+        return this;
+    }
+    static step(x, y, delta) {
+        const difference = this.difference(x, y);
+        return this.normalize(Math.abs(difference) <= delta
+            ? y
+            : x + (Math.sign(difference) * delta));
+    }
+    step(y, delta) {
+        this.x = Circular.step(this.x, Circular.value(y), delta);
+        return this;
+    }
+    static approach(x, y, speed, deltaTime, speedLimit) {
+        const difference = this.difference(x, y);
+        const change = Scalar.creep(difference, speed, deltaTime, speedLimit);
+        return this.normalize(x + change);
+    }
+    approach(y, speed, deltaTime, speedLimit) {
+        this.x = Circular.approach(this.x, Circular.value(y), speed, deltaTime, speedLimit);
+        return this;
+    }
+}
+//# sourceMappingURL=circular.js.map