@benev/math 0.2.0-0 → 0.2.0-2

package/s/{primitives → core}/vec3.ts

@@ -1,12 +1,9 @@
 
-import {Scalar} from "./scalar.js"
+import {Scalar} from "../tools/scalar.js"
 
-export type Vec3Array = [number, number, number]
+export type XyzArray = [x: number, y: number, z: 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,
@@ -14,32 +11,22 @@ export class Vec3 {
 		public z: number,
 	) {}
 
-	///////////////////////////////////////////////////////////////////////
-
-	static new<T extends Vec3>(this: TsHack<T>, x: number, y: number, z: number) {
+	static new(x: number, y: number, z: number) {
 		return new this(x, y, z)
 	}
 
-	static zero<T extends Vec3>(this: TsHack<T>) {
+	static zero() {
 		return new this(0, 0, 0)
 	}
 
-	static all<T extends Vec3>(this: TsHack<T>, value: number) {
+	static all(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) {
+	static from(v: XyzArray | Xyz) {
 		return Array.isArray(v)
-			? this.array(v)
-			: this.import(v)
+			? new this(...v)
+			: new this(v.x, v.y, v.z)
 	}
 
 	static magnitudeSquared(x: number, y: number, z: number) {
@@ -56,23 +43,23 @@ export class Vec3 {
 			.divideBy(vecs.length)
 	}
 
-	static min(...vecs: Vec3[]) {
-		return new Vec3(
+	static min(...vecs: Xyz[]) {
+		return new this(
 			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(
+	static max(...vecs: Xyz[]) {
+		return new this(
 			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 {
+	static fromHex(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
@@ -83,13 +70,17 @@ export class Vec3 {
 		}
 	}
 
-	///////////////////////////////////////////////////////////////////////
-
 	clone() {
 		return new Vec3(this.x, this.y, this.z)
 	}
 
-	array(): Vec3Array {
+	*[Symbol.iterator]() {
+		yield this.x
+		yield this.y
+		yield this.z
+	}
+
+	toJSON(): XyzArray {
 		return [this.x, this.y, this.z]
 	}
 
@@ -111,8 +102,6 @@ export class Vec3 {
 		return this
 	}
 
-	///////////////////////////////////////////////////////////////////////
-
 	magnitudeSquared() {
 		return Vec3.magnitudeSquared(this.x, this.y, this.z)
 	}
@@ -121,14 +110,13 @@ export class Vec3 {
 		return Vec3.magnitude(this.x, this.y, this.z)
 	}
 
-	hexColor() {
-		const to255 = (val: number) => Math.round(val * 255)
+	/** rgb values from 0-1 */
+	toHex() {
+		const to255 = (val: number) => Math.round(Scalar.clamp(val * 255, 0, 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 &&
@@ -138,7 +126,19 @@ export class Vec3 {
 	}
 
 	equals(...vecs: Xyz[]) {
-		return vecs.every(v => this.equals_(v.x, v.y, v.z))
+		return vecs.every(({x, y, z}) => this.equals_(x, y, z))
+	}
+
+	near_(x: number, y: number, z: number, epsilon = 1e-6) {
+		return (
+			Math.abs(this.x - x) <= epsilon &&
+			Math.abs(this.y - y) <= epsilon &&
+			Math.abs(this.z - z) <= epsilon
+		)
+	}
+
+	near({x, y, z}: Xyz, epsilon = 1e-6) {
+		return this.near_(x, y, z, epsilon)
 	}
 
 	distanceSquared_(x: number, y: number, z: number) {
@@ -179,16 +179,16 @@ export class Vec3 {
 
 	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)
+		const magnitudes = this.magnitude() * Vec3.magnitude(x, y, z)
+		if (magnitudes === 0) return 0
+		const ratio = Scalar.clamp(dotProduct / magnitudes, -1, 1)
+		return Math.acos(ratio)
 	}
 
 	angleBetween({x, y, z}: Xyz) {
 		return this.angleBetween_(x, y, z)
 	}
 
-	///////////////////////////////////////////////////////////////////////
-
 	/** mutator */
 	add_(x: number, y: number, z: number) {
 		this.x += x
@@ -226,21 +226,21 @@ export class Vec3 {
 	}
 
 	/** mutator */
-	multiply(...vecs: Vec3[]) {
+	multiply(...vecs: Xyz[]) {
 		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
+		if (x !== 0) this.x /= x
+		if (y !== 0) this.y /= y
+		if (z !== 0) this.z /= z
 		return this
 	}
 
 	/** mutator */
-	divide(...vecs: Vec3[]) {
+	divide(...vecs: Xyz[]) {
 		for (const {x, y, z} of vecs) this.divide_(x, y, z)
 		return this
 	}
@@ -278,6 +278,22 @@ export class Vec3 {
 		return this
 	}
 
+	/** mutator */
+	clamp(min: Xyz = {x: 0, y: 0, z: 0}, max: Xyz = {x: 1, y: 1, z: 1}) {
+		this.x = Scalar.clamp(this.x, min.x, max.x)
+		this.y = Scalar.clamp(this.y, min.y, max.y)
+		this.z = Scalar.clamp(this.z, min.z, max.z)
+		return this
+	}
+
+	/** mutator */
+	clampBy(min = 0, max = 1) {
+		this.x = Scalar.clamp(this.x, min, max)
+		this.y = Scalar.clamp(this.y, min, max)
+		this.z = Scalar.clamp(this.z, min, max)
+		return this
+	}
+
 	/** mutator */
 	addBy(delta: number) {
 		this.x += delta
@@ -286,6 +302,14 @@ export class Vec3 {
 		return this
 	}
 
+	/** mutator */
+	subtractBy(delta: number) {
+		this.x -= delta
+		this.y -= delta
+		this.z -= delta
+		return this
+	}
+
 	/** mutator */
 	multiplyBy(delta: number) {
 		this.x *= delta
@@ -381,7 +405,9 @@ export class Vec3 {
 
 	/** mutator */
 	projectOnto_(x: number, y: number, z: number) {
-		const scalar = this.dot_(x, y, z) / Vec3.magnitudeSquared(x, y, z)
+		const m2 = Vec3.magnitudeSquared(x, y, z)
+		if (!m2) return this
+		const scalar = this.dot_(x, y, z) / m2
 		this.x = scalar * x
 		this.y = scalar * y
 		this.z = scalar * z
@@ -389,7 +415,7 @@ export class Vec3 {
 	}
 
 	/** mutator */
-	projectOnto({x, y, z}: Vec3) {
+	projectOnto({x, y, z}: Xyz) {
 		return this.projectOnto_(x, y, z)
 	}
 

package/s/{primitives → core}/vec4.ts

@@ -1,7 +1,5 @@
 
-import {Xyzw} from "./quat.js"
-
-export type Vec4Array = [number, number, number, number]
+import {Xyzw, XyzwArray} from "./quat.js"
 
 export class Vec4 {
 	constructor(
@@ -19,21 +17,24 @@ export class Vec4 {
 		return new this(0, 0, 0, 0)
 	}
 
-	static array(v: Vec4Array) {
-		return new this(...v)
+	static from(v: XyzwArray | Xyzw) {
+		return Array.isArray(v)
+			? new this(...v)
+			: new this(v.x, v.y, v.z, v.w)
 	}
 
-	static import({x, y, z, w}: Xyzw) {
-		return new this(x, y, z, w)
+	clone() {
+		return new Vec4(this.x, this.y, this.z, this.w)
 	}
 
-	static from(v: Vec4Array | Xyzw) {
-		return Array.isArray(v)
-			? this.array(v)
-			: this.import(v)
+	*[Symbol.iterator]() {
+		yield this.x
+		yield this.y
+		yield this.z
+		yield this.w
 	}
 
-	array(): Vec4Array {
+	toJSON(): XyzwArray {
 		const {x, y, z, w} = this
 		return [x, y, z, w]
 	}
@@ -42,10 +43,6 @@ export class Vec4 {
 		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

package/s/index.ts

@@ -1,10 +1,15 @@
 
-export * from "./primitives/circular.js"
-export * from "./primitives/quat.js"
-export * from "./primitives/scalar.js"
-export * from "./primitives/vec2.js"
-export * from "./primitives/vec3.js"
-export * from "./primitives/vec4.js"
+export * from "./core/quat.js"
+export * from "./core/vec2.js"
+export * from "./core/vec3.js"
+export * from "./core/vec4.js"
+
+export * from "./tools/angles.js"
+export * from "./tools/circular.js"
+export * from "./tools/noise.js"
+export * from "./tools/randy.js"
+export * from "./tools/scalar.js"
+export * as spline from "./tools/spline.js"
 
 export * from "./optimizers/hash-map.js"
 export * from "./optimizers/hash-set.js"
@@ -17,12 +22,6 @@ export * as intersect2d from "./physics/2d/intersect2d.js"
 
 export * from "./shapes/2d/index.js"
 export * as shapes2d from "./shapes/2d/index.js"
-
 export * from "./shapes/3d/index.js"
 export * as shapes3d from "./shapes/3d/index.js"
 
-export * from "./utils/angles.js"
-export * from "./utils/noise.js"
-export * from "./utils/randy.js"
-export * as spline from "./utils/spline.js"
-

package/s/optimizers/hash-map.ts

@@ -45,6 +45,10 @@ export class HashMap<Key, Value> {
 		return this.#map.values()
 	}
 
+	[Symbol.iterator]() {
+		return this.entries()
+	}
+
 	*keys() {
 		for (const [key] of this.#map.values())
 			yield key

package/s/optimizers/hash-set.ts

@@ -42,5 +42,9 @@ export class HashSet<Value> {
 	values() {
 		return this.#map.values()
 	}
+
+	[Symbol.iterator]() {
+		return this.values()
+	}
 }
 

package/s/optimizers/zen.ts

@@ -1,7 +1,7 @@
 
 import {MapG} from "@e280/stz"
+import {Vec2} from "../core/vec2.js"
 import {Rect} from "../shapes/2d/rect.js"
-import {Vec2} from "../primitives/vec2.js"
 import {rectVsRect} from "../physics/2d/collide2d.js"
 
 export class Zen<X> {
@@ -9,7 +9,7 @@ export class Zen<X> {
 
 	constructor(
 		public grid: ZenGrid<X>,
-		public box: Rect,
+		public rect: Rect,
 		public item: X,
 	) {}
 
@@ -22,11 +22,12 @@ export class Zen<X> {
 	}
 }
 
-export class ZenZone<X> extends Rect {
+export class ZenZone<X> {
+	rect: Rect
 	zens = new Set<Zen<X>>()
 
-	constructor(public hash: string, center: Vec2, extent: Vec2) {
-		super(center, extent)
+	constructor(public hash: string, center: Vec2, size: Vec2) {
+		this.rect = Rect.fromCenter(center, size)
 	}
 }
 
@@ -42,14 +43,14 @@ export class ZenGrid<X> {
 		return n
 	}
 
-	create(box: Rect, item: X) {
-		const zen = new Zen<X>(this, box, item)
+	create(rect: Rect, item: X) {
+		const zen = new Zen<X>(this, rect, item)
 		this.update(zen)
 		return zen
 	}
 
 	update(zen: Zen<X>) {
-		const wantedZones = this.#selectZones(zen.box)
+		const wantedZones = this.#selectZones(zen.rect)
 
 		// delete stale zones
 		for (const zone of zen.zones) {
@@ -81,38 +82,38 @@ export class ZenGrid<X> {
 			this.#zones.delete(emptyZone.hash)
 	}
 
-	check(box: Rect) {
-		const zones = this.#selectZones(box)
+	check(rect: Rect) {
+		const zones = this.#selectZones(rect)
 
 		for (const zone of zones)
 			for (const zen of zone.zens)
-				if (rectVsRect(box, zen.box))
+				if (rectVsRect(rect, zen.rect))
 					return true
 
 		return false
 	}
 
-	/** return all zens that touch the given box */
-	query(box: Rect) {
-		const zones = this.#selectZones(box)
-		const selected: Zen<X>[] = []
+	/** return set of zens that touch the given rect */
+	query(rect: Rect) {
+		const zones = this.#selectZones(rect)
+		const selected = new Set<Zen<X>>()
 
 		for (const zone of zones)
 			for (const zen of zone.zens)
-				if (rectVsRect(box, zen.box) && !selected.includes(zen))
-					selected.push(zen)
+				if (!selected.has(zen) && rectVsRect(rect, zen.rect))
+					selected.add(zen)
 
 		return selected
 	}
 
-	/** return all zen items that touch the given box */
-	queryItems(box: Rect) {
-		return this.query(box).map(zen => zen.item)
+	/** return all zen items that touch the given rect */
+	queryItems(rect: Rect) {
+		return [...this.query(rect)].map(zen => zen.item)
 	}
 
-	/** return all zen boxes that touch the given box */
-	queryBoxes(box: Rect) {
-		return this.query(box).map(zen => zen.box)
+	/** return all zen rects that touch the given rect */
+	queryRects(rect: Rect) {
+		return [...this.query(rect)].map(zen => zen.rect)
 	}
 
 	#hash(v: Vec2) {
@@ -135,10 +136,10 @@ export class ZenGrid<X> {
 		))
 	}
 
-	#selectZones(box: Rect) {
+	#selectZones(rect: Rect) {
 		const zones = new Set<ZenZone<X>>()
-		const minZoneCorner = this.#calculateZoneCorner(box.min)
-		const maxZoneCorner = this.#calculateZoneCorner(box.max)
+		const minZoneCorner = this.#calculateZoneCorner(rect.min)
+		const maxZoneCorner = this.#calculateZoneCorner(rect.max)
 
 		for (let x = minZoneCorner.x; x <= maxZoneCorner.x; x += this.zoneExtent.x)
 			for (let y = minZoneCorner.y; y <= maxZoneCorner.y; y += this.zoneExtent.y)

package/s/physics/2d/collide2d.ts

@@ -1,7 +1,7 @@
 
-import {Vec2} from "../../primitives/vec2.js"
+import {Vec2} from "../../core/vec2.js"
 import {Rect} from "../../shapes/2d/rect.js"
-import {Scalar} from "../../primitives/scalar.js"
+import {Scalar} from "../../tools/scalar.js"
 import {Circle} from "../../shapes/2d/circle.js"
 
 export function pointVsRect(point: Vec2, box: Rect) {

package/s/physics/2d/intersect2d.ts

@@ -1,7 +1,7 @@
 
-import {Vec2} from "../../primitives/vec2.js"
+import {Vec2} from "../../core/vec2.js"
 import {Rect} from "../../shapes/2d/rect.js"
-import {Scalar} from "../../primitives/scalar.js"
+import {Scalar} from "../../tools/scalar.js"
 import {Circle} from "../../shapes/2d/circle.js"
 import {rectVsCircle, rectVsRect} from "./collide2d.js"
 
@@ -21,14 +21,17 @@ export function intersectRectVsRect(a: Rect, b: Rect) {
 	const overlapY = Math.min(a.max.y - b.min.y, b.max.y - a.min.y)
 	const depth = Math.min(overlapX, overlapY)
 
+	const aCenter = a.center()
+	const bCenter = b.center()
+
 	const contactPoint = new Vec2(
-		Scalar.clamp((a.center.x + b.center.x) / 2, b.min.x, b.max.x),
-		Scalar.clamp((a.center.y + b.center.y) / 2, b.min.y, b.max.y)
+		Scalar.clamp((aCenter.x + bCenter.x) / 2, b.min.x, b.max.x),
+		Scalar.clamp((aCenter.y + bCenter.y) / 2, b.min.y, b.max.y)
 	)
 
 	const normalA = depth === overlapX
-		? new Vec2(b.center.x > a.center.x ? -1 : 1, 0)
-		: new Vec2(0, b.center.y > a.center.y ? -1 : 1)
+		? new Vec2(bCenter.x > aCenter.x ? -1 : 1, 0)
+		: new Vec2(0, bCenter.y > aCenter.y ? -1 : 1)
 
 	const normalB = normalA.clone().multiplyBy(-1)
 

package/s/shapes/2d/circle.ts

@@ -1,6 +1,9 @@
 
 import {Rect} from "./rect.js"
-import {Vec2} from "../../primitives/vec2.js"
+import {Vec2, XyArray, Xy} from "../../core/vec2.js"
+
+export type CircleJson = [center: XyArray, radius: number]
+export type CircleLike = {center: Xy, radius: number}
 
 export class Circle {
 	constructor(
@@ -8,18 +11,33 @@ export class Circle {
 		public radius: number,
 	) {}
 
-	offset(delta: Vec2) {
-		this.center.add(delta)
-		return this
+	static from(data: CircleJson | CircleLike) {
+		return Array.isArray(data)
+			? new this(Vec2.from(data[0]), data[1])
+			: new this(Vec2.from(data.center), data.radius)
 	}
 
-	boundingBox() {
-		const extent = Vec2.all(this.radius * 2)
-		return new Rect(this.center, extent)
+	toJSON(): CircleJson {
+		return [this.center.clone().toJSON(), this.radius]
 	}
 
 	clone() {
 		return new Circle(this.center.clone(), this.radius)
 	}
+
+	set(circle: CircleLike) {
+		this.center.set(circle.center)
+		this.radius = circle.radius
+	}
+
+	translate(delta: Vec2) {
+		this.center.add(delta)
+		return this
+	}
+
+	boundingBox() {
+		const size = Vec2.all(this.radius * 2)
+		return Rect.fromCenter(this.center.clone(), size)
+	}
 }
 

package/s/shapes/2d/rect.ts

@@ -1,36 +1,65 @@
 
-import {Vec2} from "../../primitives/vec2.js"
+import {Vec2, XyArray, Xy} from "../../core/vec2.js"
 import {pointVsRect} from "../../physics/2d/collide2d.js"
 
+export type RectJson = [min: XyArray, max: XyArray]
+export type RectLike = {min: Xy, max: Xy}
+
 export class Rect {
 	constructor(
-			public center: Vec2,
-			public extent: Vec2,
-		) {
-		if (extent.x < 0 || extent.y < 0)
-			throw new Error(`invalid negative extent, ${extent.toString()}`)
+		public min: Vec2,
+		public max: Vec2,
+	) {}
+
+	static from(data: RectJson | RectLike) {
+		return Array.isArray(data)
+			? new this(Vec2.from(data[0]), Vec2.from(data[1]))
+			: new this(Vec2.from(data.min), Vec2.from(data.max))
+	}
+
+	static fromCorner(min: Vec2, size: Vec2) {
+		const max = min.clone().add(size)
+		return new this(min, max)
 	}
 
-	static fromCorner(min: Vec2, extent: Vec2) {
-		return new this(min.add(extent.clone().half()), extent)
+	static fromCenter(center: Vec2, size: Vec2) {
+		const halfSize = size.clone().half()
+		const min = center.clone().subtract(halfSize)
+		const max = center.clone().add(halfSize)
+		return new this(min, max)
+	}
+
+	clone() {
+		return new Rect(this.min.clone(), this.max.clone())
 	}
 
-	get min() {
-		return this.center.clone()
-			.subtract(this.extent.clone().half())
+	toJSON(): RectJson {
+		return [this.min.toJSON(), this.max.toJSON()]
 	}
 
-	get max() {
-		return this.center.clone()
-			.add(this.extent.clone().half())
+	set(rect: RectLike) {
+		this.min.set(rect.min)
+		this.max.set(rect.max)
 	}
 
-	offset(delta: Vec2) {
-		this.center.add(delta)
+	normalize() {
+		const {min, max} = this
+		this.min.set(Vec2.min(min, max))
+		this.max.set(Vec2.max(min, max))
 		return this
 	}
 
-	boundingBox() {
+	size() {
+		return this.max.clone().subtract(this.min)
+	}
+
+	center() {
+		return this.min.clone().add(this.size().half())
+	}
+
+	translate(delta: Vec2) {
+		this.min.add(delta)
+		this.max.add(delta)
 		return this
 	}
 
@@ -38,8 +67,8 @@ export class Rect {
 		return pointVsRect(point, this)
 	}
 
-	clone() {
-		return new Rect(this.center.clone(), this.extent.clone())
+	boundingBox() {
+		return this.clone()
 	}
 }