rain

@zemn.me/math/canvas/element.tsx

@@ -56,7 +56,7 @@ export const Canvas: React.FC<CanvasProps> = ({ draw }) => {
 						d={d}
 						key={d}
 						style={{ fill: 'none', stroke: 'black' }}
-						vectorEffect="none-scaling-stroke"
+						vectorEffect="non-scaling-stroke"
 					/>
 				)
 			})}

@zemn.me/math/cartesian.ts

@@ -1,6 +1,8 @@
 import * as Matrix from './matrix'
-export type Point<T extends number = number> = Matrix.Matrix<1, T>
+export type Vector<T extends number = number> = Matrix.Matrix<1, T>
+export type Point<T extends number = number> = Vector<T>
 export type Point2D = Point<2>
 export type Point3D = Point<3>
 export type Line2D = Point2D[]
 export type Line3D = Point3D[]
+export type Vec3D = Point3D

@zemn.me/math/homog.ts

@@ -5,8 +5,10 @@ type Extends<T1, T2> = T2 extends T1 ? T2 : never
 
 export type Point2D = Matrix.Matrix<1, 3>
 export type Point3D = Matrix.Matrix<1, 4>
-export type Line2D = Point2D[]
-export type Line3D = Point3D[]
+export type Vec3D = Point3D
+export type Vec2D = Point2D
+export type Line2D = readonly Point2D[]
+export type Line3D = readonly Point3D[]
 
 export function pointToCart(p: Point2D): Cart.Point2D
 export function pointToCart(p: Point3D): Cart.Point3D
@@ -23,3 +25,10 @@ export function lineToCart(p: Line3D): Cart.Line3D
 export function lineToCart(line: Line2D | Line3D): Cart.Line2D | Cart.Line3D {
 	return line.map((point: any) => pointToCart(point))
 }
+
+export function fromCart(p: Cart.Point2D): Point2D
+export function fromCart(p: Cart.Point3D): Point3D
+
+export function fromCart(p: Cart.Point2D | Cart.Point3D): any {
+	return [...p, [1]]
+}

@zemn.me/math/math.test.ts

@@ -355,6 +355,19 @@ describe('matrix', () => {
 			expect(matrix.add(a, b)).toEqual(o)
 		})
 	})
+
+	describe('.asVec', () => {
+		test('1', () => {
+			const i = [[1], [2], [3]] as const
+			expect(matrix.asVec(i)).toEqual([1, 2, 3])
+		})
+	})
+	describe('.fromVec', () => {
+		test('1', () => {
+			const i = [[1], [2], [3]] as const
+			expect(i).toEqual(matrix.fromVec(matrix.asVec(i)))
+		})
+	})
 })
 
 describe('vec', () => {
@@ -381,4 +394,24 @@ describe('vec', () => {
 			},
 		)
 	})
+
+	describe('.mag', () => {
+		test('1', () => {
+			expect(vec.mag([4, 4])).toEqual(
+				Math.sqrt(Math.pow(4, 2) + Math.pow(4, 2)),
+			)
+		})
+	})
+
+	/*
+
+	describe('.unit', () => {
+		test('1', () => {
+			expectMatrixSimilar([vec.unit([2, 2])], [[1, 1]])
+		})
+		test('2', () => {
+			expectMatrixSimilar([vec.unit([1, 1])], [[1, 1]])
+		})
+	})
+	*/
 })

@zemn.me/math/matrix.ts

@@ -272,3 +272,9 @@ export const inverse: <IJ extends number>(m: Square<IJ>) => Square<IJ> = <
 
 	return map(transpose(checkerboard(minors(m))), (n) => d * n)
 }
+
+export const asVec = <I extends number>(m: Matrix<1, I>): Vector<I, number> =>
+	[].concat(...(m as any)) as any
+
+export const fromVec = <I extends number>(m: vec.Vector<I>): Matrix<1, I> =>
+	map(New(1, m.length), (_, [i, j]) => m[j])

@zemn.me/math/shape/index.ts

@@ -61,6 +61,19 @@ export class Translate3D<T extends Canvas.Drawable3D>
 	}
 }
 
+export class Group3D<T extends readonly Canvas.Drawable3D[]>
+	implements Canvas.Drawable3D
+{
+	readonly targets: T
+	constructor(...targets: T) {
+		this.targets = targets
+	}
+
+	public lines3D(): Homog.Line3D[] {
+		return [].concat.apply(this.targets.map((t) => t.lines3D()))
+	}
+}
+
 export class Cube implements Canvas.Drawable3D {
 	private readonly square: Square
 	constructor(public readonly diameter: number) {

@zemn.me/math/sim/particle.ts

@@ -0,0 +1,78 @@
+import * as Vec from '@zemn.me/math/vec'
+
+export type Simulation<D extends number = number> = (
+	particles: Particle<D>[],
+	elapsedSeconds: number,
+) => { done?: true } | undefined
+
+export interface Particle<D extends number = number> {
+	/**
+	 * kg
+	 */
+	mass: number
+
+	/**
+	 * m/s
+	 */
+	speed: Vec.Vector<D>
+
+	/**
+	 * m
+	 */
+	displacement: Vec.Vector<D>
+}
+
+export type Force<D extends number = number> = Vec.Vector<D>
+
+export type Field<D extends number = number> = (
+	particle: Particle<number>,
+	globalTime: number,
+) => Force<D>
+
+export const Gravity: Field<number> = ({ mass }) => [0, -mass * 10] as const
+
+/**
+ * @param force (particle) => kg * m/s/s
+ * @param time seconds
+ */
+export const simulate: <D extends number>(
+	p: Particle<D>,
+	timeDelta: number,
+	...fields: Field<D>[]
+) => void = (particle, timeDelta, ...fields) => {
+	const [firstForce, ...otherForces] = fields.map((f) =>
+		f(particle, timeDelta),
+	)
+	const resultantForce = otherForces.reduce(
+		(a, c) => Vec.add(a, c),
+		firstForce,
+	)
+
+	let acc = Vec.div(resultantForce, particle.mass)
+
+	let dx // change in displacement
+	const v0 = particle.speed
+	const a = acc
+	const t = timeDelta
+
+	const timeTravelledDueToExtantSpeed = Vec.mul(t, v0)
+	const timeTravelledDuetoAccel = Vec.mul(0.5 * Math.pow(t, 2), a)
+	const increaseInSpeed = Vec.mul(t, acc)
+
+	dx = Vec.add(timeTravelledDueToExtantSpeed, timeTravelledDuetoAccel)
+
+	particle.displacement = Vec.add(particle.displacement, dx)
+	particle.speed = Vec.add(particle.speed, increaseInSpeed)
+
+	/*console.table({
+        mass: particle.mass,
+        speed: particle.speed,
+        position: particle.displacement,
+        "experienced accel.": acc,
+        "under force": resultantForce,
+        dx,
+        timeDelta,
+timeTravelledDueToExtantSpeed ,
+increaseInSpeed
+    });*/
+}

@zemn.me/math/sim/unit.ts

@@ -0,0 +1,16 @@
+export const kg = 1
+export const kilogram = kg
+export const g = kg / 1000
+export const gram = g
+
+export const second = 1
+export const s = second
+export const millisecond = 1000
+export const ms = millisecond
+
+export const meter = 1
+export const m = meter
+export const millimeter = meter / 1000
+export const mm = millimeter
+export const cm = meter / 100
+export const centimenter = cm

@zemn.me/math/vec.ts

@@ -54,13 +54,28 @@ export const New: <N extends number>(n: number) => Vector<N, undefined> = (n) =>
 export const add: <I extends number>(
 	v1: Vector<I>,
 	v2: Vector<I>,
-) => Vector<I> = (v1, v2) => map(v1, (v, i) => v + v2[i])
+) => Vector<I> = (v1, v2) => {
+	;[v1, v2] = [v1, v2].sort((a, b) => b.length - a.length)
+	return map(v1, (v, i) => v + (i in v2 ? v2[i] : 0))
+}
 
 export const mul: <I extends number>(v1: number, v2: Vector<I>) => Vector<I> = (
 	v1,
 	v2,
 ) => map(v2, (v, i) => v * v1)
 
+export const div: <I extends number>(v1: Vector<I>, v2: number) => Vector<I> = (
+	v2,
+	v1,
+) => map(v2, (v, i) => v / v1)
+
+/*
+export const unit = <T extends number>(vector: Vector<T>): Vector<T> => {
+	const m = mag(vector)
+	return map(vector, (v) => v / m)
+}
+*/
+
 export const dot: (v1: Iterable<number>, v2: Iterable<number>) => number = (
 	v1,
 	v2,
@@ -100,3 +115,6 @@ export const zip: {
 		[T1 | T3, T2 | T3]
 	>
 } = _zip as any
+
+export const mag = (v: Vector<number>): number =>
+	Math.sqrt(sum(map(v, (v) => Math.pow(v, 2))))