data-structure-typed 0.8.18 → 1.12.9

package/src/data-structures/heap/heap.ts

@@ -1,30 +1,18 @@
-import {PriorityQueue} from '../priority-queue';
-
-export interface HeapOptions<T> {
-    priority?: (element: T) => number;
-}
-
-export interface HeapItem<T> {
-    priority: number;
-    element: T | null;
-}
-
-
 /**
- * @copyright 2021 Pablo Rios <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
- *
- * @abstract
- * @class Heap
  */
+import {PriorityQueue} from '../priority-queue';
+import type {HeapItem, HeapOptions} from '../types';
+
 export abstract class Heap<T> {
     protected abstract _pq: PriorityQueue<HeapItem<T>>;
     protected _priorityCb: (element: T) => number;
 
     /**
-     * Creates a priority queue
-     * @public
-     * @params {object} [options]
+     * The function is a constructor for a class that initializes a priority callback function based on the
+     * options provided.
+     * @param [options] - An optional object that contains configuration options for the Heap.
      */
     protected constructor(options?: HeapOptions<T>) {
         if (options) {
@@ -39,44 +27,45 @@ export abstract class Heap<T> {
     }
 
     /**
-     * @public
-     * @returns {number}
+     * The function returns the size of a priority queue.
+     * @returns The size of the priority queue.
      */
     get size(): number {
         return this._pq.size;
     }
 
     /**
-     * @public
-     * @returns {boolean}
+     * The function checks if a priority queue is empty.
+     * @returns {boolean} A boolean value indicating whether the size of the priority queue is less than 1.
      */
     isEmpty(): boolean {
         return this._pq.size < 1;
     }
 
     /**
-     * Returns an element with highest priority in the queue
-     * @public
-     * @returns {object}
+     * The `peek` function returns the top item in the priority queue without removing it.
+     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an element with the highest priority in the queue
      */
     peek(): HeapItem<T> | null {
         return this._pq.peek();
     }
 
     /**
-     * Returns an element with lowest priority in the queue
-     * @public
-     * @returns {object}
+     * The `peekLast` function returns the last item in the heap.
+     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an element with the lowest priority in the queue
      */
     peekLast(): HeapItem<T> | null {
         return this._pq.leaf();
     }
 
     /**
-     * Adds an element to the queue
-     * @public
-     * @param {any} element
-     * @param priority
+     * The `offer` function adds an element to a priority queue with an optional priority value.
+     * @param {T} element - The `element` parameter represents the value that you want to add to the heap. It can be of any
+     * type.
+     * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
+     * element being offered to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
+     * the value of `element`. If the `element` parameter is not a number, then the
+     * @returns The `offer` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
     offer(element: T, priority?: number): Heap<T> {
@@ -105,9 +94,8 @@ export abstract class Heap<T> {
     }
 
     /**
-     * Removes and returns an element with highest priority in the queue
-     * @public
-     * @returns {object}
+     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an element with the highest priority in the queue
+     * @returns either a HeapItem<T> object or null.
      */
     poll(): HeapItem<T> | null {
         const top = this._pq.poll();
@@ -118,17 +106,15 @@ export abstract class Heap<T> {
     }
 
     /**
-     * Returns a sorted list of elements
-     * @public
-     * @returns {array}
+     * The `toArray` function returns an array of `HeapItem<T>` objects.
+     * @returns An array of HeapItem<T> objects.Returns a sorted list of elements
      */
     toArray(): HeapItem<T>[] {
         return this._pq.toArray();
     }
 
     /**
-     * Clears the queue
-     * @public
+     * The clear function clears the priority queue.
      */
     clear(): void {
         this._pq.clear();

package/src/data-structures/heap/max-heap.ts

@@ -1,10 +1,11 @@
 /**
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
 
-import {Heap, HeapItem, HeapOptions} from './heap';
+import {Heap} from './heap';
 import {PriorityQueue} from '../priority-queue';
+import type {HeapItem, HeapOptions} from '../types';
 
 /**
  * @class MaxHeap
@@ -13,6 +14,11 @@ import {PriorityQueue} from '../priority-queue';
 export class MaxHeap<T> extends Heap<T> {
     protected _pq: PriorityQueue<HeapItem<T>>;
 
+    /**
+     * The constructor initializes a PriorityQueue with a custom comparator function.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
+     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     */
     constructor(options?: HeapOptions<T>) {
         super(options);
         this._pq = new PriorityQueue<HeapItem<T>>({

package/src/data-structures/heap/min-heap.ts

@@ -1,10 +1,11 @@
 /**
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
 
-import {Heap, HeapItem, HeapOptions} from './heap';
+import {Heap} from './heap';
 import {PriorityQueue} from '../priority-queue';
+import type {HeapItem, HeapOptions} from '../types';
 
 /**
  * @class MinHeap
@@ -13,6 +14,12 @@ import {PriorityQueue} from '../priority-queue';
 export class MinHeap<T> extends Heap<T> {
     protected _pq: PriorityQueue<HeapItem<T>>;
 
+    /**
+     * The constructor initializes a PriorityQueue with a comparator function that compares the priority of two HeapItem
+     * objects.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
+     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     */
     constructor(options?: HeapOptions<T>) {
         super(options);
         this._pq = new PriorityQueue<HeapItem<T>>({

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -1,10 +1,8 @@
-// 操作      常见名称       Ada           Java        JavaScript     C++          Python      Perl       PHP             Ruby
-// 尾部插入   inject, snoc Append         offerLast   push          push_back    append      push        array_push      push
-// 头部插入   push, cons   Prepend        offerFirst  unshift       push_front   appendleft  unshift     array_unshift   unshift
-// 尾部删除   eject        Delete_Last    pollLast    pop           pop_back     pop         pop         array_pop       pop
-// 头部删除   pop          Delete_First   pollFirst   shift         pop_front    popleft     shift       array_shift     shift
-// 查看尾部                Last_Element   peekLast    [length - 1]  back         [-1]        $array[-1]  end             last
-// 查看头部                First_Element  peekFirst   [0]           front        [0]         $array[0]   reset           first
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+import type {DoublyLinkedListGetBy} from '../types';
 
 export class DoublyLinkedListNode<T> {
     val: T;
@@ -18,8 +16,6 @@ export class DoublyLinkedListNode<T> {
     }
 }
 
-export type DoublyLinkedListGetBy = 'node' | 'val';
-
 export class DoublyLinkedList<T> {
     private _first: DoublyLinkedListNode<T> | null = null;
     private _last: DoublyLinkedListNode<T> | null = null;
@@ -33,8 +29,10 @@ export class DoublyLinkedList<T> {
     }
 
     /**
-     * Adds a node at the beginning of the linked list
-     * @param val Value to be stored at the beginning of the linked list
+     * The function adds a new node with a given value to the beginning of a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the beginning of
+     * the doubly linked list.
+     * @returns A boolean value is being returned.
      */
     offerFirst(val: T): boolean {
         const newNode = new DoublyLinkedListNode(val);
@@ -51,8 +49,10 @@ export class DoublyLinkedList<T> {
     }
 
     /**
-     * Adds a node to the end of the linked list
-     * @param val Value to be stored in the Doubly linked list node
+     * The function adds a new node with a given value to the end of a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the end of the
+     * doubly linked list.
+     * @returns a boolean value, which is always true.
      */
     offerLast(val: T): boolean {
         const newNode = new DoublyLinkedListNode(val);
@@ -71,6 +71,14 @@ export class DoublyLinkedList<T> {
     peekFirst(): T | null;
     peekFirst(by: 'val'): T | null;
     peekFirst(by: 'node'): DoublyLinkedListNode<T> | null;
+    /**
+     * The `peekFirst` function returns the first node or value in a doubly linked list, depending on the specified
+     * parameter.
+     * @param {DoublyLinkedListGetBy} [by] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy. It
+     * is used to specify whether to return the first node, the value of the first node, or the first node itself.
+     * @returns The method `peekFirst` returns either the first node of the doubly linked list (`DoublyLinkedListNode<T>`),
+     * the value of the first node (`T`), or `null` depending on the value of the `by` parameter.
+     */
     peekFirst(by?: DoublyLinkedListGetBy): T | DoublyLinkedListNode<T> | null {
         switch (by) {
             case 'node':
@@ -85,6 +93,13 @@ export class DoublyLinkedList<T> {
     peekLast(): T | null;
     peekLast(by: 'val'): T | null;
     peekLast(by: 'node'): DoublyLinkedListNode<T> | null;
+    /**
+     * The `peekLast` function returns the last node or value in a doubly linked list.
+     * @param {DoublyLinkedListGetBy} [by=val] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy.
+     * It specifies whether to return the last node, the value of the last node, or both. The default value is 'val', which
+     * means that if no value is provided for the "by" parameter, the method
+     * @returns The method `peekLast` returns the last node, value, or null based on the specified `by` parameter.
+     */
     peekLast(by: DoublyLinkedListGetBy = 'val'): T | DoublyLinkedListNode<T> | null {
         switch (by) {
             case 'node':
@@ -100,7 +115,14 @@ export class DoublyLinkedList<T> {
     pollFirst(by: 'val'): T | null;
     pollFirst(by: 'node'): DoublyLinkedListNode<T> | null;
     /**
-     * Removes a node form the beginning of the linked list and will return the node val
+     * The function `pollFirst` removes and returns the first element of a doubly linked list, either as a node or its
+     * value, depending on the specified parameter.
+     * @param {DoublyLinkedListGetBy} [by=val] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy.
+     * It specifies the criteria by which the first element should be retrieved from the doubly linked list. The default
+     * value is 'val', which means the first element will be retrieved by its value. Other possible values for "by
+     * @returns The method `pollFirst` returns either the value of the first node in the doubly linked list, the first node
+     * itself, or null if the list is empty. The specific return type depends on the value of the `by` parameter. If `by`
+     * is set to 'node', the method returns the first node. If `by` is set to 'val', the method returns the value
      */
     pollFirst(by: DoublyLinkedListGetBy = 'val'): T | DoublyLinkedListNode<T> | null {
         if (this._size === 0) return null;
@@ -128,7 +150,14 @@ export class DoublyLinkedList<T> {
     pollLast(by: 'val'): T | null;
     pollLast(by: 'node'): DoublyLinkedListNode<T> | null;
     /**
-     * Removes a node at the end of the linked list and will return the node value
+     * The function `pollLast` removes and returns the last element in a doubly linked list, either as a node or its value,
+     * depending on the specified parameter.
+     * @param {DoublyLinkedListGetBy} [by=val] - The parameter "by" is of type DoublyLinkedListGetBy, which is an enum that
+     * can have two possible values: 'node' or 'val'. It determines the type of value that will be returned by the pollLast
+     * method. If 'node' is specified, the method will return the
+     * @returns The method `pollLast` returns either a `DoublyLinkedListNode<T>`, the value of the node (`T`), or `null`.
+     * The specific type that is returned depends on the value of the `by` parameter. If `by` is set to `'node'`, then a
+     * `DoublyLinkedListNode<T>` is returned. If `by` is set to `'
      */
     pollLast(by: DoublyLinkedListGetBy = 'val'): DoublyLinkedListNode<T> | T | null {
         if (this._size === 0) return null;
@@ -234,8 +263,12 @@ export class DoublyLinkedList<T> {
     }
 
     /**
-     * Removes a node at the specified index and returns its value.
-     * @param index Index at which the node has to be removed.
+     * The `remove` function removes an element at a specified index from a data structure, updating the links between
+     * nodes accordingly.
+     * @param {number} index - The index parameter represents the position of the element to be removed in the data
+     * structure. It is of type number.
+     * @returns The `remove` method returns the value of the removed element (`T`) if the removal is successful, or `null`
+     * if the index is out of bounds.
      */
     remove(index: number): T | null {
         if (index < 0 || index > this._size - 1) return null;

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -1,16 +1,7 @@
-/** Type used for filter and find methods, returning a boolean */
-type TTestFunction<NodeData> = (
-    data: NodeData,
-    index: number,
-    list: SinglyLinkedList<NodeData>,
-) => boolean;
-
-/** Type used for map and forEach methods, returning anything */
-type TMapFunction<NodeData> = (
-    data: any,
-    index: number,
-    list: SinglyLinkedList<NodeData>,
-) => any;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 
 /**
  * The class which represents one link or node in a linked list
@@ -104,6 +95,23 @@ export class SinglyLinkedListNode<NodeData = any> {
  */
 export class SinglyLinkedList<NodeData = any> {
 
+    /** The head of the list, the first node */
+    public head: SinglyLinkedListNode<NodeData> | null;
+    /** The tail of the list, the last node */
+    public tail: SinglyLinkedListNode<NodeData> | null;
+    /** Internal size reference */
+    private size: number;
+
+    constructor(...args: NodeData[]) {
+        this.head = null;
+        this.tail = null;
+        this.size = 0;
+
+        for (let i = 0; i < arguments.length; i++) {
+            this.append(args[i]);
+        }
+    }
+
     /**
      * The length of the list
      */
@@ -123,25 +131,6 @@ export class SinglyLinkedList<NodeData = any> {
         return new SinglyLinkedList(...iterable);
     }
 
-    /** The head of the list, the first node */
-    public head: SinglyLinkedListNode<NodeData> | null;
-
-    /** The tail of the list, the last node */
-    public tail: SinglyLinkedListNode<NodeData> | null;
-
-    /** Internal size reference */
-    private size: number;
-
-    constructor(...args: NodeData[]) {
-        this.head = null;
-        this.tail = null;
-        this.size = 0;
-
-        for (let i = 0; i < arguments.length; i++) {
-            this.append(args[i]);
-        }
-    }
-
     /**
      * Get the node val at a specified index, zero based
      * ```ts
@@ -187,7 +176,11 @@ export class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f A function to be applied to the val of each node
      */
-    public findNodeIndex(f: TTestFunction<NodeData>): ({
+    public findNodeIndex(f: (
+        data: NodeData,
+        index: number,
+        list: SinglyLinkedList<NodeData>,
+    ) => boolean): ({
         node: SinglyLinkedListNode<NodeData>,
         index: number,
     }) | undefined {
@@ -215,7 +208,11 @@ export class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f Function to test val against
      */
-    public findNode(f: TTestFunction<NodeData>): SinglyLinkedListNode<NodeData> | undefined {
+    public findNode(f: (
+        data: NodeData,
+        index: number,
+        list: SinglyLinkedList<NodeData>,
+    ) => boolean): SinglyLinkedListNode<NodeData> | undefined {
         const nodeIndex = this.findNodeIndex(f);
         return nodeIndex !== undefined ? nodeIndex.node : undefined;
     }
@@ -228,7 +225,11 @@ export class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f Function to test val against
      */
-    public find(f: TTestFunction<NodeData>): NodeData | undefined {
+    public find(f: (
+        data: NodeData,
+        index: number,
+        list: SinglyLinkedList<NodeData>,
+    ) => boolean): NodeData | undefined {
         const nodeIndex = this.findNodeIndex(f);
         return nodeIndex !== undefined ? nodeIndex.node.val : undefined;
     }
@@ -241,7 +242,11 @@ export class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f Function to test val against
      */
-    public findIndex(f: TTestFunction<NodeData>): number {
+    public findIndex(f: (
+        data: NodeData,
+        index: number,
+        list: SinglyLinkedList<NodeData>,
+    ) => boolean): number {
         const nodeIndex = this.findNodeIndex(f);
         return nodeIndex !== undefined ? nodeIndex.index : -1;
     }
@@ -615,7 +620,11 @@ export class SinglyLinkedList<NodeData = any> {
      * @param f Function to execute for each element, taking up to three arguments.
      * @param reverse Indicates if the list should be walked in reverse order, default is false
      */
-    public forEach(f: TMapFunction<NodeData>, reverse = false): void {
+    public forEach(f: (
+        data: any,
+        index: number,
+        list: SinglyLinkedList<NodeData>,
+    ) => any, reverse = false): void {
         let currentIndex = reverse ? this.length - 1 : 0;
         let currentNode = reverse ? this.tail : this.head;
         const modifier = reverse ? -1 : 1;
@@ -637,7 +646,11 @@ export class SinglyLinkedList<NodeData = any> {
      * @param reverse Indicates if the list should be mapped in reverse order, default is false
      */
     // eslint-disable-next-line @typescript-eslint/ban-types
-    public map(f: TMapFunction<NodeData>, reverse = false): SinglyLinkedList<NodeData | {}> {
+    public map(f: (
+        data: any,
+        index: number,
+        list: SinglyLinkedList<NodeData>,
+    ) => any, reverse = false): SinglyLinkedList<NodeData | {}> {
         const list = new SinglyLinkedList();
         this.forEach((val, index) => list.append(f(val, index, this)), reverse);
         return list;
@@ -653,7 +666,11 @@ export class SinglyLinkedList<NodeData = any> {
      * @param reverse Indicates if the list should be filtered in reverse order, default is false
      */
     // eslint-disable-next-line @typescript-eslint/ban-types
-    public filter(f: TTestFunction<NodeData>, reverse = false): SinglyLinkedList<NodeData | {}> {
+    public filter(f: (
+        data: NodeData,
+        index: number,
+        list: SinglyLinkedList<NodeData>,
+    ) => boolean, reverse = false): SinglyLinkedList<NodeData | {}> {
         const list = new SinglyLinkedList();
         this.forEach((val, index) => {
             if (f(val, index, this)) {

package/src/data-structures/matrix/matrix.ts

@@ -1,12 +1,23 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 // todo need to be improved
 export class MatrixNTI2D<T = number> {
     private readonly _matrix: Array<Array<T>>;
 
+    /**
+     * The constructor creates a matrix with the specified number of rows and columns, and initializes all elements to a
+     * given initial value or 0 if not provided.
+     * @param options - An object containing the following properties:
+     */
     constructor(options: { row: number, col: number, initialVal?: T }) {
         const {row, col, initialVal} = options;
         this._matrix = new Array(row).fill(undefined).map(() => new Array(col).fill(initialVal || 0));
     }
 
+    /* The `toArray` method returns the matrix as a two-dimensional array. It converts the internal representation of the
+    matrix, which is an array of arrays, into a format that is more commonly used in JavaScript. */
     toArray(): Array<Array<T>> {
         return this._matrix;
     }

package/src/data-structures/matrix/matrix2d.ts

@@ -1,8 +1,18 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 import Vector2D from './vector2d'
 
 export class Matrix2D {
     private readonly _matrix: number[][];
 
+    /**
+     * The constructor function initializes a Matrix2D object with either a default identity matrix, or a provided matrix
+     * or Vector2D object.
+     * @param {number[][] | Vector2D} [value] - The `value` parameter can be either a 2D array of numbers (`number[][]`) or
+     * an instance of the `Vector2D` class.
+     */
     constructor(value?: number[][] | Vector2D) {
         if (typeof value === 'undefined') {
             this._matrix = Matrix2D.identity
@@ -17,22 +27,16 @@ export class Matrix2D {
     }
 
     /**
-     * Return the matrix values
+     * The function returns a 2D array with three empty arrays.
+     * @returns An empty 2-dimensional array with 3 empty arrays inside.
      */
-    public get m(): number[][] {
-        return this._matrix
-    }
-
     public static get empty(): number[][] {
         return [[], [], []]
     }
 
-    public get toVector(): Vector2D {
-        return new Vector2D(this._matrix[0][0], this._matrix[1][0])
-    }
-
     /**
-     * Initialize an identity matrix
+     * The above function returns a 3x3 identity matrix.
+     * @returns The method is returning a 2-dimensional array of numbers representing the identity matrix.
      */
     public static get identity(): number[][] {
         return [
@@ -41,6 +45,31 @@ export class Matrix2D {
             [0, 0, 1]]
     }
 
+    /**
+     * The function returns a two-dimensional array of numbers.
+     * @returns The getter method is returning the value of the private variable `_matrix`, which is a two-dimensional
+     * array of numbers.
+     */
+    public get m(): number[][] {
+        return this._matrix
+    }
+
+    /**
+     * The function "toVector" returns a new Vector2D object with the values from the first and second elements of the
+     * _matrix array.
+     * @returns A new instance of the Vector2D class is being returned. The values of the returned vector are taken from
+     * the first column of the matrix.
+     */
+    public get toVector(): Vector2D {
+        return new Vector2D(this._matrix[0][0], this._matrix[1][0])
+    }
+
+    /**
+     * The function takes two 2D matrices as input and returns their sum as a new 2D matrix.
+     * @param {Matrix2D} matrix1 - Matrix2D - The first matrix to be added.
+     * @param {Matrix2D} matrix2 - The parameter `matrix2` is a Matrix2D object.
+     * @returns a new instance of the Matrix2D class, which is created using the result array.
+     */
     public static add(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D {
         const result = Matrix2D.empty
         for (let i = 0; i < 3; i++) {
@@ -51,6 +80,13 @@ export class Matrix2D {
         return new Matrix2D(result);
     }
 
+    /**
+     * The function subtracts two 2D matrices and returns the result as a new Matrix2D object.
+     * @param {Matrix2D} matrix1 - Matrix2D - The first matrix to subtract from.
+     * @param {Matrix2D} matrix2 - Matrix2D is a class representing a 2D matrix. It has a property `m` which is a 2D array
+     * representing the matrix elements.
+     * @returns a new instance of the Matrix2D class, which is created using the result array.
+     */
     public static subtract(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D {
         const result = Matrix2D.empty
         for (let i = 0; i < 3; i++) {
@@ -61,6 +97,12 @@ export class Matrix2D {
         return new Matrix2D(result);
     }
 
+    /**
+     * The function multiplies two 2D matrices and returns the result as a new Matrix2D object.
+     * @param {Matrix2D} matrix1 - A 2D matrix represented by the Matrix2D class.
+     * @param {Matrix2D} matrix2 - The parameter `matrix2` is a 2D matrix of size 3x3.
+     * @returns a new instance of the Matrix2D class, created using the result array.
+     */
     public static multiply(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D {
         const result = Matrix2D.empty
         for (let i = 0; i < 3; i++) {
@@ -74,6 +116,13 @@ export class Matrix2D {
         return new Matrix2D(result);
     }
 
+    /**
+     * The function multiplies each element of a 2D matrix by a given value and returns the resulting matrix.
+     * @param {Matrix2D} matrix - The `matrix` parameter is an instance of the `Matrix2D` class, which represents a 2D
+     * matrix. It contains a property `m` that is a 2D array representing the matrix elements.
+     * @param {number} value - The `value` parameter is a number that you want to multiply each element of the `matrix` by.
+     * @returns a new instance of the Matrix2D class, which is created using the result array.
+     */
     public static multiplyByValue(matrix: Matrix2D, value: number): Matrix2D {
         const result = Matrix2D.empty
         for (let i = 0; i < 3; i++) {
@@ -84,10 +133,24 @@ export class Matrix2D {
         return new Matrix2D(result);
     }
 
+    /**
+     * The function multiplies a 2D matrix by a 2D vector and returns the result as a 2D vector.
+     * @param {Matrix2D} matrix - The parameter "matrix" is of type Matrix2D. It represents a 2-dimensional matrix.
+     * @param {Vector2D} vector - The "vector" parameter is a 2D vector, represented by an object of type Vector2D.
+     * @returns a Vector2D.
+     */
     public static multiplyByVector(matrix: Matrix2D, vector: Vector2D): Vector2D {
         return Matrix2D.multiply(matrix, new Matrix2D(vector)).toVector
     }
 
+    /**
+     * The function returns a 2D matrix that scales and flips a vector around the center of a given width and height.
+     * @param {number} width - The width parameter represents the width of the view or the canvas. It is a number that
+     * specifies the width in pixels or any other unit of measurement.
+     * @param {number} height - The height parameter represents the height of the view or the canvas. It is used to
+     * calculate the centerY value, which is the vertical center of the view.
+     * @returns a Matrix2D object.
+     */
     public static view(width: number, height: number): Matrix2D {
         const scaleStep = 1 // Scale every vector * scaleStep
         const centerX = width / 2
@@ -100,10 +163,21 @@ export class Matrix2D {
             [0, 0, 1]])
     }
 
+    /**
+     * The function scales a matrix by a given factor.
+     * @param {number} factor - The factor parameter is a number that represents the scaling factor by which the matrix
+     * should be scaled.
+     * @returns the result of multiplying a new instance of Matrix2D by the given factor.
+     */
     public static scale(factor: number) {
         return Matrix2D.multiplyByValue(new Matrix2D(), factor)
     }
 
+    /**
+     * The function "rotate" takes an angle in radians and returns a 2D transformation matrix for rotating objects.
+     * @param {number} radians - The "radians" parameter is the angle in radians by which you want to rotate an object.
+     * @returns The code is returning a new instance of a Matrix2D object.
+     */
     public static rotate(radians: number) {
         const cos = Math.cos(radians)
         const sin = Math.sin(radians)
@@ -114,6 +188,12 @@ export class Matrix2D {
             [0, 0, 1]])
     }
 
+    /**
+     * The translate function takes a 2D vector and returns a 2D matrix that represents a translation transformation.
+     * @param {Vector2D} vector - The parameter "vector" is of type Vector2D. It represents a 2D vector with components x
+     * and y, and an optional w component.
+     * @returns The method is returning a new instance of the Matrix2D class.
+     */
     public static translate(vector: Vector2D): Matrix2D {
         return new Matrix2D([
             [1, 0, vector.x],