Implement the vector data type

Author: FSou1

README.md

@@ -12,6 +12,7 @@ A data structure is a data organization, management, and storage format that ena
 * [Graph](src/data-structures/graph) - a set of vertices and edges;
 * [Stack](src/data-structures/stack) - a data structure to follow the LIFO principle;
 * [Linked list](src/data-structures/linked-list) - a data structure to follow the FIFO principle;
+* [Vector](src/data-structures/vector) - is used to represent the mathematical vector used in linear algebra;
 
 ## Algorithms
 

src/data-structures/vector/README.md

@@ -0,0 +1,5 @@
+# Vector
+
+A vector, in computing, is generally a one-dimensional array, typically storing numbers. Vectors typically have fixed sizes, unlike lists and queues.
+
+The vector data structure can be used to represent the mathematical vector used in linear algebra. See related pages for mathematical vector operations. Vectors are often used in computing in computer graphics and simulating physical systems.

src/data-structures/vector/__test__/vec2.test.ts

@@ -0,0 +1,96 @@
+import { vec2 } from "../vec2";
+
+describe("vec2", () => {
+  it("resets", () => {
+    const vector = new vec2(1.0, 2.0);
+
+    vector.reset();
+
+    expect(vector.x).toEqual(0);
+    expect(vector.y).toEqual(0);
+  });
+
+  it("copies", () => {
+    const vector1 = new vec2(1.0, 2.0);
+    const vector2 = vector1.copy();
+
+    expect(vector2.x).toEqual(vector1.x);
+    expect(vector2.y).toEqual(vector1.y);
+  });
+
+  it("negates", () => {
+    const vector = new vec2(1.0, 2.0);
+
+    vector.negate();
+
+    expect(vector.x).toEqual(-1.0);
+    expect(vector.y).toEqual(-2.0);
+  });
+
+  it("compares", () => {
+    const vector1 = new vec2(1.0, 2.0);
+    const vector2 = new vec2(1.0, 2.0);
+    const vector3 = new vec2(2.0, 3.0);
+
+    expect(vector1.equals(vector2)).toEqual(true);
+    expect(vector1.equals(vector3)).toEqual(false);
+  });
+
+  it("adds", () => {
+    const vector1 = new vec2(1.0, 2.0);
+    const vector2 = new vec2(2.0, 3.0);
+
+    const result = vector1.add(vector2);
+
+    expect(result.x).toEqual(3.0);
+    expect(result.y).toEqual(5.0);
+  });
+
+  it("subtracts", () => {
+    const vector1 = new vec2(1.0, 2.0);
+    const vector2 = new vec2(2.0, 4.0);
+
+    const result = vector1.subtract(vector2);
+
+    expect(result.x).toEqual(-1.0);
+    expect(result.y).toEqual(-2.0);
+  });
+
+  it("multiplies", () => {
+    const vector1 = new vec2(2.0, 3.0);
+    const vector2 = new vec2(5.0, 6.0);
+
+    const result = vector1.multiply(vector2);
+
+    expect(result.x).toEqual(10.0);
+    expect(result.y).toEqual(18.0);
+  });
+
+  it("divides", () => {
+    const vector1 = new vec2(2.0, 3.0);
+    const vector2 = new vec2(5.0, 6.0);
+
+    const result = vector1.divide(vector2);
+
+    expect(result.x).toEqual(0.4);
+    expect(result.y).toEqual(0.5);
+  });
+
+  it("scales", () => {
+    const vector = new vec2(1.0, 2.0);
+
+    vector.scale(2.0);
+
+    expect(vector.x).toEqual(2.0);
+    expect(vector.y).toEqual(4.0);
+  });
+
+  it("normalizes", () => {
+    const vector = new vec2(1.0, 2.0);
+
+    vector.normalize();
+
+    expect(vector.x).toBeCloseTo(0.44721, 5);
+    expect(vector.y).toBeCloseTo(0.89443, 5);
+  });
+});

src/data-structures/vector/vec2.ts

@@ -0,0 +1,58 @@
+export class vec2 {
+  x: number;
+  y: number;
+
+  constructor(x: number, y: number) {
+    this.x = x;
+    this.y = y;
+  }
+
+  reset() {
+    this.x = 0;
+    this.y = 0;
+  }
+
+  copy() {
+    return new vec2(this.x, this.y);
+  }
+
+  negate() {
+    this.x *= -1;
+    this.y *= -1;
+  }
+
+  equals(vector: vec2) {
+    return this.x === vector.x && this.y === vector.y;
+  }
+
+  add(vector: vec2) {
+    return new vec2(this.x + vector.x, this.y + vector.y);
+  }
+
+  subtract(vector: vec2) {
+    return new vec2(this.x - vector.x, this.y - vector.y);
+  }
+
+  multiply(vector: vec2) {
+    return new vec2(this.x * vector.x, this.y * vector.y);
+  }
+
+  divide(vector: vec2) {
+    return new vec2(this.x / vector.x, this.y / vector.y);
+  }
+
+  scale(value: number) {
+    this.x *= value;
+    this.y *= value;
+  }
+
+  normalize() {
+    const length = this.length();
+    this.x /= length;
+    this.y /= length;
+  }
+
+  length(): number {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+}