@dominicstop/utils/lib/module/tests/Vector.test.js

Yet another event emitter written in typescript.

import { Vector2D, Angle } from "../geometry";
describe("Vector", () => {
    test("constructor === asValue", () => {
        const v = new Vector2D({ dx: 3, dy: 4 });
        expect(v.asValue).toEqual({ dx: 3, dy: 4 });
    });
    test("magnitude", () => {
        const v = new Vector2D({ dx: 3, dy: 4 });
        expect(v.magnitude).toBeCloseTo(5);
    });
    test("normalized", () => {
        const v = new Vector2D({ dx: 3, dy: 4 });
        const n = v.normalized;
        expect(n.magnitude).toBeCloseTo(1);
    });
    test("isZero === isUnit", () => {
        const zero = new Vector2D({ dx: 0, dy: 0 });
        const unit = new Vector2D({ dx: 1, dy: 0 });
        expect(zero.isZero).toBe(true);
        expect(unit.isUnit).toBe(true);
    });
    test("perpendicular", () => {
        const v = new Vector2D({ dx: 1, dy: 0 });
        const p = v.perpendicular;
        expect(p.dx).toBeCloseTo(0);
        expect(p.dy).toBeCloseTo(1);
    });
    test("inverse", () => {
        const v = new Vector2D({ dx: 1, dy: -2 });
        const inv = v.inverse;
        expect(inv.dx).toBeCloseTo(-1);
        expect(inv.dy).toBeCloseTo(2);
    });
    test("computeDistanceFromOtherVector", () => {
        const a = new Vector2D({ dx: 0, dy: 0 });
        const b = new Vector2D({ dx: 3, dy: 4 });
        expect(a.computeDistanceFromOtherVector(b)).toBeCloseTo(5);
    });
    test("isEqualToOtherVector", () => {
        const a = new Vector2D({ dx: 1, dy: 1 });
        const b = new Vector2D({ dx: 1.00001, dy: 1.00001 });
        expect(a.isEqualToOtherVector(b, 0.001)).toBe(true);
    });
    test("addWithOtherVector", () => {
        const a = new Vector2D({ dx: 1, dy: 2 });
        const b = new Vector2D({ dx: 3, dy: 4 });
        expect(a.addedWithOther(b).asValue).toEqual({ dx: 4, dy: 6 });
    });
    test("subtractWithOtherVector", () => {
        const a = new Vector2D({ dx: 1, dy: 2 });
        const b = new Vector2D({ dx: 3, dy: 4 });
        expect(b.subtractedWithOther(a).asValue).toEqual({ dx: 2, dy: 2 });
    });
    test("multipliedByScalar", () => {
        const v = new Vector2D({ dx: 2, dy: 4 });
        expect(v.multipliedByScalar(2).asValue).toEqual({ dx: 4, dy: 8 });
    });
    test("dividedByScalar", () => {
        const v = new Vector2D({ dx: 2, dy: 4 });
        expect(v.dividedByScalar(2).asValue).toEqual({ dx: 1, dy: 2 });
    });
    test("dotProductWithOtherVector", () => {
        const a = new Vector2D({ dx: 1, dy: 2 });
        const b = new Vector2D({ dx: 3, dy: 4 });
        expect(a.dotProductWithOtherVector(b)).toBeCloseTo(11);
    });
    test("crossProductWithOtherVector", () => {
        const a = new Vector2D({ dx: 1, dy: 2 });
        const b = new Vector2D({ dx: 3, dy: 4 });
        expect(a.crossProductWithOtherVector(b)).toBeCloseTo(-2);
    });
    test("projectOntoOtherVector", () => {
        const a = new Vector2D({ dx: 3, dy: 4 });
        const b = new Vector2D({ dx: 1, dy: 0 });
        const proj = a.projectOntoOtherVector(b);
        expect(proj.dy).toBeCloseTo(0);
    });
    test("angleBetweenOtherVector", () => {
        const a = new Vector2D({ dx: 1, dy: 0 });
        const b = new Vector2D({ dx: 0, dy: 1 });
        const angle = a.angleBetweenOtherVector(b);
        expect(angle.degrees).toBeCloseTo(90);
    });
    test("reflectOverOtherVector", () => {
        const a = new Vector2D({ dx: 1, dy: 1 });
        const b = new Vector2D({ dx: 1, dy: 0 });
        const reflected = a.reflectOverOtherVector(b);
        expect(reflected.dy).toBeCloseTo(-1);
    });
    test("limit magnitude", () => {
        const v = new Vector2D({ dx: 3, dy: 4 });
        const limited = v.limit(2);
        expect(limited.magnitude).toBeCloseTo(2);
    });
    test("static alias equality", () => {
        expect(Vector2D.zero.asValue).toEqual({ dx: 0, dy: 0 });
        expect(Vector2D.unitX.asValue).toEqual({ dx: 1, dy: 0 });
        expect(Vector2D.unitY.asValue).toEqual({ dx: 0, dy: 1 });
    });
    test("initFromAngle", () => {
        const angle = Angle.initFromDegrees(0);
        const v = Vector2D.initFromAngle(angle, 5);
        expect(v.dx).toBeCloseTo(5);
        expect(v.dy).toBeCloseTo(0);
    });
    test("initFromPoints", () => {
        const v = Vector2D.initFromPoints({ x: 1, y: 2 }, { x: 4, y: 6 });
        expect(v.asValue).toEqual({ dx: 3, dy: 4 });
    });
    test("computeAverage", () => {
        const a = new Vector2D({ dx: 1, dy: 2 });
        const b = new Vector2D({ dx: 3, dy: 4 });
        const avg = Vector2D.computeAverage([a, b]);
        expect(avg.asValue).toEqual({ dx: 2, dy: 3 });
    });
    test("distanceBetweenTwoVectors", () => {
        const a = new Vector2D({ dx: 0, dy: 0 });
        const b = new Vector2D({ dx: 3, dy: 4 });
        expect(Vector2D.distanceBetweenTwoVectors(a, b)).toBeCloseTo(5);
    });
});