@benev/math 0.2.0-0 → 0.2.0-1

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()
 	}
 }
 

package/s/shapes/3d/box.ts

@@ -1,38 +1,83 @@
 
-import {Vec3} from "../../primitives/vec3.js"
+import {Vec3, XyzArray, Xyz} from "../../core/vec3.js"
+
+export type BoxJson = [min: XyzArray, max: XyzArray]
+export type BoxLike = {min: Xyz, max: Xyz}
 
 export class Box {
 	constructor(
-			public center: Vec3,
-			public extent: Vec3,
-		) {
-		if (extent.x < 0 || extent.y < 0 || extent.z < 0)
-			throw new Error(`invalid negative extent, ${extent.toString()}`)
+		public min: Vec3,
+		public max: Vec3,
+	) {}
+
+	static from(data: BoxJson | BoxLike) {
+		return Array.isArray(data)
+			? new this(Vec3.from(data[0]), Vec3.from(data[1]))
+			: new this(Vec3.from(data.min), Vec3.from(data.max))
 	}
 
-	static fromCorner(min: Vec3, extent: Vec3) {
-		return new this(
-			min.clone().add(extent.clone().half()),
-			extent,
-		)
+	static fromCorner(min: Vec3, size: Vec3) {
+		return new this(min, min.clone().add(size))
 	}
 
-	get min() {
-		return this.center.clone()
-			.subtract(this.extent.clone().half())
+	static fromCenter(center: Vec3, size: Vec3) {
+		const halfSize = size.clone().half()
+		const min = center.clone().subtract(halfSize)
+		const max = center.clone().add(halfSize)
+		return new this(min, max)
 	}
 
-	get max() {
-		return this.center.clone()
-			.add(this.extent.clone().half())
+	toJSON(): BoxJson {
+		return [this.min.toJSON(), this.max.toJSON()]
 	}
 
 	clone() {
-		return new Box(this.center.clone(), this.extent.clone())
+		return new Box(this.min.clone(), this.max.clone())
+	}
+
+	set(box: BoxLike) {
+		this.min.set(box.min)
+		this.max.set(box.max)
+	}
+
+	size() {
+		return this.max.clone().subtract(this.min)
+	}
+
+	center() {
+		return this.min.clone().add(this.size().half())
+	}
+
+	normalize() {
+		const {min, max} = this
+		this.min.set(Vec3.min(min, max))
+		this.max.set(Vec3.max(min, max))
+		return this
+	}
+
+	translate_(x: number, y: number, z: number) {
+		this.min.add_(x, y, z)
+		this.max.add_(x, y, z)
+		return this
+	}
+
+	translate(delta: Vec3) {
+		this.min.add(delta)
+		this.max.add(delta)
+		return this
+	}
+
+	grow(increase: Vec3) {
+		const halfIncrease = increase.clone().half()
+		this.min.subtract(halfIncrease)
+		this.max.add(halfIncrease)
+		return this
 	}
 
-	grow(increase: number) {
-		this.extent.addBy(increase)
+	growBy(increase: number) {
+		const halfIncrease = increase / 2
+		this.min.subtractBy(halfIncrease)
+		this.max.addBy(halfIncrease)
 		return this
 	}
 }

package/s/shapes/3d/segment.ts

@@ -1,5 +1,5 @@
 
-import {Vec3} from "../../primitives/vec3.js"
+import {Vec3} from "../../core/vec3.js"
 
 export class Segment {
 	constructor(
@@ -7,18 +7,18 @@ export class Segment {
 		public end: Vec3,
 	) {}
 
-	get vector() {
+	vector() {
 		return this.end.clone().subtract(this.start)
 	}
 
-	get length() {
+	length() {
 		return this.start.distance(this.end)
 	}
 
-	get center() {
+	center() {
 		return this.start.clone()
 			.add(this.end)
-			.divideBy(2)
+			.half()
 	}
 
 	clone() {
@@ -29,18 +29,20 @@ export class Segment {
 	}
 
 	fromStart(length: number) {
-		const direction = this.vector.normalize()
+		const direction = this.vector().normalize()
 		return this.start.clone().add(direction.multiplyBy(length))
 	}
 
 	point(fraction: number) {
-		return this.start.clone().add(this.vector.multiplyBy(fraction))
+		return this.start.clone().add(this.vector().multiplyBy(fraction))
 	}
 
 	scale(fraction: number) {
-		const newHalfVector = this.vector.multiplyBy(fraction / 2)
-		this.start.set(this.center.subtract(newHalfVector))
-		this.end.set(this.center.add(newHalfVector))
+		const {center} = this
+		const newHalfVector = this.vector().multiplyBy(fraction / 2)
+		this.start.set(center().subtract(newHalfVector))
+		this.end.set(center().add(newHalfVector))
+		return this
 	}
 }
 

package/s/{utils → tools}/angles.ts

@@ -1,5 +1,5 @@
 
-import {Scalar} from "../primitives/scalar.js"
+import {Scalar} from "./scalar.js"
 
 const pi = Math.PI
 
@@ -27,6 +27,9 @@ export const Turns = {
 	toRadians(t: number) {
 		return t * Radians.circle
 	},
+	toDegrees(t: number) {
+		return Radians.toDegrees(Turns.toRadians(t))
+	},
 }
 
 export const Arcseconds = {
@@ -39,5 +42,8 @@ export const Degrees = {
 	toRadians(d: number) {
 		return d * (pi / 180)
 	},
+	toTurns(d: number) {
+		return Radians.toTurns(Degrees.toRadians(d))
+	},
 }
 

package/s/{primitives → tools}/circular.ts

@@ -1,6 +1,8 @@
 
 import {Scalar} from "./scalar.js"
 
+const circle = 2 * Math.PI
+
 export class Circular {
 	constructor(public x: number) {}
 
@@ -20,7 +22,7 @@ export class Circular {
 	}
 
 	static normalize(x: number) {
-		return Scalar.wrap(x, 0, 2 * Math.PI)
+		return Scalar.wrap(x, 0, circle)
 	} normalize() {
 		this.x = Circular.normalize(this.x)
 		return this
@@ -30,8 +32,8 @@ export class Circular {
 		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
+		if (delta > Math.PI) delta -= circle
+		if (delta < -Math.PI) delta += circle
 		return delta
 	} difference(y: number | Circular) {
 		return Circular.difference(this.x, Circular.value(y))

package/s/{primitives → tools}/scalar.ts

@@ -43,7 +43,7 @@ export class Scalar {
 			x += n
 		return x
 	} add(...nums: number[]) {
-		this.x = Scalar.add(...nums)
+		this.x = Scalar.add(this.x, ...nums)
 		return this
 	}
 
@@ -53,23 +53,23 @@ export class Scalar {
 		return this
 	}
 
-	static min(x: number, minimum: number = 0) {
-		return Math.max(x, minimum)
-	} min(minimum: number = 0) {
-		this.x = Scalar.min(this.x, minimum)
+	static atLeast(x: number, least: number = 0) {
+		return Math.max(x, least)
+	} atLeast(least: number = 0) {
+		this.x = Scalar.atLeast(this.x, least)
 		return this
 	}
 
-	static max(x: number, maximum: number = 1) {
-		return Math.min(x, maximum)
-	} max(maximum: number = 1) {
-		this.x = Scalar.max(this.x, maximum)
+	static atMost(x: number, most: number = 1) {
+		return Math.min(x, most)
+	} atMost(most: number = 1) {
+		this.x = Scalar.atMost(this.x, most)
 		return this
 	}
 
 	static clamp(x: number, a: number = 0, b: number = 1) {
-		x = Scalar.min(x, Math.min(a, b))
-		x = Scalar.max(x, Math.max(a, b))
+		x = Scalar.atLeast(x, Math.min(a, b))
+		x = Scalar.atMost(x, Math.max(a, b))
 		return x
 	} clamp(a: number = 0, b: number = 1) {
 		this.x = Scalar.clamp(this.x, a, b)