@benev/math 0.0.0-0

package/s/concepts/spline.ts

@@ -0,0 +1,88 @@
+
+import {Scalar} from "./scalar.js"
+import {Vec2Array} from "./vec2.js"
+
+/** resolve a number within a linear spline. */
+export function linear(x: number, points: Vec2Array[]): number {
+	if (points.length < 2)
+		throw new Error("need at least two points, come on")
+
+	const [first] = points.at(0)!
+	const [last] = points.at(-1)!
+
+	x = Scalar.clamp(x, first, last)
+
+	for (let i = 0; i < points.length - 1; i++) {
+		const [x0, y0] = points[i]
+		const [x1, y1] = points[i + 1]
+
+		if (x >= x0 && x <= x1) {
+			const t = (x - x0) / (x1 - x0)
+			return y0 + t * (y1 - y0)
+		}
+	}
+
+	throw new Error("x is out of bounds, what are you even doing")
+}
+
+/** resolve a number within a catmull-rom spline, that's all smooth-like. */
+export function catmullRom(x: number, points: Vec2Array[]) {
+	if (points.length < 4)
+		throw new Error("need at least four points for this magic")
+
+	x = Scalar.clamp(x)
+
+	// find the segment where 'x' fits
+	for (let i = 1; i < points.length - 2; i++) {
+		const [x1, ] = points[i]
+		const [x2, ] = points[i + 1]
+
+		if (x >= x1 && x <= x2) {
+			const t = (x - x1) / (x2 - x1)
+			return helpers.catmullRom(t, points[i - 1], points[i], points[i + 1], points[i + 2])
+		}
+	}
+
+	throw new Error("x is out of bounds, try again")
+}
+
+export const ez = {
+
+	/** simple linear spline where the control points are equally-spaced based on their array indices (x is expected to be between 0 and 1). */
+	linear(x: number, points: number[]) {
+		if (points.length < 2)
+			throw new Error("need at least two points, come on")
+
+		const points2 = points.map(
+			(p, index): Vec2Array =>
+				[Scalar.clamp(index / (points.length - 1)), p]
+		)
+
+		return linear(Scalar.clamp(x), points2)
+	}
+}
+
+namespace helpers {
+
+	/** internal big-brain maths for the catmull-rom implementation */
+	export function catmullRom(
+			t: number,
+			[,p0]: Vec2Array,
+			[,p1]: Vec2Array,
+			[,p2]: Vec2Array,
+			[,p3]: Vec2Array,
+		) {
+
+		const t2 = t * t
+		const t3 = t2 * t
+
+		// coefficients for the cubic polynomial (Catmull-Rom)
+		const a = -0.5 * p0 + 1.5 * p1 - 1.5 * p2 + 0.5 * p3
+		const b = p0 - 2.5 * p1 + 2 * p2 - 0.5 * p3
+		const c = -0.5 * p0 + 0.5 * p2
+		const d = p1
+
+		return a * t3 + b * t2 + c * t + d
+	}
+}
+

package/s/concepts/vec2.ts

@@ -0,0 +1,392 @@
+
+import {Scalar} from "./scalar.js"
+
+export type Vec2Array = [number, number]
+export type Xy = {x: number, y: number}
+
+/** https://github.com/microsoft/TypeScript/issues/5863 */
+type TsHack<T> = {new(...a: ConstructorParameters<typeof Vec2>): T}
+
+export class Vec2 implements Xy {
+	constructor(
+		public x: number,
+		public y: number,
+	) {}
+
+	///////////////////////////////////////////////////////////////////////
+
+	static new<T extends Vec2>(this: TsHack<T>, x: number, y: number): T {
+		return new this(x, y)
+	}
+
+	static zero<T extends Vec2>(this: TsHack<T>) {
+		return new this(0, 0)
+	}
+
+	static all<T extends Vec2>(this: TsHack<T>, value: number) {
+		return new this(value, value)
+	}
+
+	static array<T extends Vec2>(this: TsHack<T>, v: Vec2Array) {
+		return new this(...v)
+	}
+
+	static import<T extends Vec2>(this: TsHack<T>, {x, y}: Xy) {
+		return new this(x, y)
+	}
+
+	static from(v: Vec2Array | Xy) {
+		return Array.isArray(v)
+			? this.array(v)
+			: this.import(v)
+	}
+
+	static magnitudeSquared(x: number, y: number) {
+		return (x * x) + (y * y)
+	}
+
+	static magnitude(x: number, y: number) {
+		return Math.sqrt(this.magnitudeSquared(x, y))
+	}
+
+	static average(...vectors: Xy[]) {
+		return this.zero()
+			.add(...vectors)
+			.divideBy(vectors.length)
+	}
+
+	static min(...vecs: Vec2[]) {
+		return new Vec2(
+			Math.min(...vecs.map(v => v.x)),
+			Math.min(...vecs.map(v => v.y)),
+		)
+	}
+
+	static max(...vecs: Vec2[]) {
+		return new Vec2(
+			Math.max(...vecs.map(v => v.x)),
+			Math.max(...vecs.map(v => v.y)),
+		)
+	}
+
+	///////////////////////////////////////////////////////////////////////
+
+	clone() {
+		return new Vec2(this.x, this.y)
+	}
+
+	array(): Vec2Array {
+		return [this.x, this.y]
+	}
+
+	toString() {
+		return `(Vec2 x${this.x.toFixed(2)}, y${this.y.toFixed(2)})`
+	}
+
+	/** mutator */
+	set_(x: number, y: number) {
+		this.x = x
+		this.y = y
+		return this
+	}
+
+	/** mutator */
+	set({x, y}: Xy) {
+		this.x = x
+		this.y = y
+		return this
+	}
+
+	///////////////////////////////////////////////////////////////////////
+
+	magnitudeSquared() {
+		return Vec2.magnitudeSquared(this.x, this.y)
+	}
+
+	magnitude() {
+		return Vec2.magnitude(this.x, this.y)
+	}
+
+	rotation() {
+		return Math.atan2(this.y, this.x)
+	}
+
+	equals_(x: number, y: number) {
+		return (
+			this.x === x &&
+			this.y === y
+		)
+	}
+
+	equals(...vecs: Xy[]) {
+		return vecs.every(({x, y}) => this.equals_(x, y))
+	}
+
+	dot_(x: number, y: number) {
+		return (this.x * x) + (this.y * y)
+	}
+
+	dot({x, y}: Xy) {
+		return this.dot_(x, y)
+	}
+
+	distanceSquared_(x: number, y: number) {
+		x = this.x - x
+		y = this.y - y
+		return (x * x) + (y * y)
+	}
+
+	distanceSquared({x, y}: Xy) {
+		return this.distanceSquared_(x, y)
+	}
+
+	distance_(x: number, y: number) {
+		return Math.sqrt(this.distanceSquared_(x, y))
+	}
+
+	distance({x, y}: Xy) {
+		return this.distance_(x, y)
+	}
+
+	angleBetween_(x: number, y: number) {
+		const dot = this.dot_(x, y)
+		const magnitudes = this.magnitude() * Vec2.magnitude(x, y)
+		return Math.acos(dot / magnitudes)
+	}
+
+	angleBetween({x, y}: Xy) {
+		return this.angleBetween_(x, y)
+	}
+
+	///////////////////////////////////////////////////////////////////////
+
+	/** mutator */
+	normalize() {
+		return this.divideBy(this.magnitude())
+	}
+
+	/** mutator */
+	half() {
+		return this.divideBy(2)
+	}
+
+	/** mutator */
+	double() {
+		return this.multiplyBy(2)
+	}
+
+	/** mutator */
+	abs() {
+		return this.map(x => Math.abs(x))
+	}
+
+	/** mutator */
+	rotate(radians: number) {
+		const {x, y} = this
+		this.x = (x * Math.cos(radians)) - (y * Math.sin(radians))
+		this.y = (x * Math.sin(radians)) + (y * Math.cos(radians))
+		return this
+	}
+
+	/** mutator */
+	perpendicular() {
+		const {x, y} = this
+		this.x = -y
+		this.y = x
+		return this
+	}
+
+	/** mutator */
+	clampMagnitude(max: number) {
+		const mag = this.magnitude()
+		if (mag > max)
+			this.normalize().multiplyBy(max)
+		return this
+	}
+
+	/** mutator */
+	floor() {
+		this.x = Math.floor(this.x)
+		this.y = Math.floor(this.y)
+		return this
+	}
+
+	/** mutator */
+	ceil() {
+		this.x = Math.ceil(this.x)
+		this.y = Math.ceil(this.y)
+		return this
+	}
+
+	/** mutator */
+	round() {
+		this.x = Math.round(this.x)
+		this.y = Math.round(this.y)
+		return this
+	}
+
+	/** mutator */
+	map(fn: (a: number, index: number) => number) {
+		this.x = fn(this.x, 0)
+		this.y = fn(this.y, 1)
+		return this
+	}
+
+	/** mutator */
+	clamp(min: number, max: number) {
+		const clamp = (val: number) => Math.max(min, Math.min(max, val))
+		return this.map(clamp)
+	}
+
+	/** mutator */
+	negate() {
+		return this.map(a => a * -1)
+	}
+
+	/** mutator */
+	addBy(delta: number) {
+		this.x += delta
+		this.y += delta
+		return this
+	}
+
+	/** mutator */
+	subtractBy(delta: number) {
+		this.x -= delta
+		this.y -= delta
+		return this
+	}
+
+	/** mutator */
+	multiplyBy(coefficient: number) {
+		this.x *= coefficient
+		this.y *= coefficient
+		return this
+	}
+
+	/** mutator */
+	divideBy(divisor: number) {
+		if (divisor === 0) return this
+		this.x /= divisor
+		this.y /= divisor
+		return this
+	}
+
+	///////////////////////////////////////////////////////////////////////
+
+	/** mutator */
+	add_(x: number, y: number) {
+		this.x += x
+		this.y += y
+		return this
+	}
+
+	/** mutator */
+	add(...vecs: Xy[]) {
+		for (const {x, y} of vecs) this.add_(x, y)
+		return this
+	}
+
+	/** mutator */
+	subtract_(x: number, y: number) {
+		this.x -= x
+		this.y -= y
+		return this
+	}
+
+	/** mutator */
+	subtract(...vecs: Xy[]) {
+		for (const {x, y} of vecs) this.subtract_(x, y)
+		return this
+	}
+
+	/** mutator */
+	multiply_(x: number, y: number) {
+		this.x *= x
+		this.y *= y
+		return this
+	}
+
+	/** mutator */
+	multiply(...vecs: Xy[]) {
+		for (const {x, y} of vecs) this.multiply_(x, y)
+		return this
+	}
+
+	/** mutator */
+	divide_(x: number, y: number) {
+		this.x /= x
+		this.y /= y
+		return this
+	}
+
+	/** mutator */
+	divide(...vecs: Xy[]) {
+		for (const {x, y} of vecs) this.divide_(x, y)
+		return this
+	}
+
+	/** mutator */
+	lerp_(x: number, y: number, fraction: number) {
+		this.x += (x - this.x) * fraction
+		this.y += (y - this.y) * fraction
+		return this
+	}
+
+	/** mutator */
+	lerp({x, y}: Xy, fraction: number) {
+		return this.lerp_(x, y, fraction)
+	}
+
+	approach_(x: number, y: 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)
+		return this
+	}
+
+	approach({x, y}: Xy, speed: number, deltaTime: number, speedLimit?: number) {
+		return this.approach_(x, y, speed, deltaTime, speedLimit)
+	}
+
+	/** mutator */
+	reflect_(x: number, y: number) {
+		const dot = 2 * this.dot_(x, y)
+		this.x -= dot * x
+		this.y -= dot * y
+		return this
+	}
+
+	/** mutator */
+	reflect({x, y}: Xy) {
+		return this.reflect_(x, y)
+	}
+
+	/** mutator */
+	rotateAroundPoint_(x: number, y: number, radians: number) {
+		const dx = this.x - x
+		const dy = this.y - y
+		const cos = Math.cos(radians)
+		const sin = Math.sin(radians)
+		this.x = cos * dx - sin * dy + x
+		this.y = sin * dx + cos * dy + y
+		return this
+	}
+
+	/** mutator */
+	rotateAroundPoint({x, y}: Vec2, radians: number) {
+		return this.rotateAroundPoint_(x, y, radians)
+	}
+
+	/** mutator */
+	smooth_(x: number, y: number, smoothing: number) {
+		this.x = Scalar.smooth(this.x, x, smoothing)
+		this.y = Scalar.smooth(this.y, y, smoothing)
+		return this
+	}
+
+	/** mutator */
+	smooth({x, y}: Xy, smoothing: number) {
+		return this.smooth_(x, y, smoothing)
+	}
+}
+