added quick sort

Author: zAlweNy26

src/dim_red/dim_red.ts

@@ -104,4 +104,13 @@ export abstract class DimRed<P extends DimRedParams> {
     get seed() {
         return this._params.seed
     }
+
+    /**
+     * Gets the parameters used for the algorithm.
+     */
+    get parameters() {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { metric, seed, dimensionality, ...rest } = this._params
+        return rest
+    }
 }

src/dim_red/tsne.ts

@@ -18,6 +18,7 @@ export class TSNE extends DimRed<TSNEParams> {
             epsilon: 10,
             dimensionality: 2,
             metric: euclideanSquared,
+            seed: 1212,
             ...params
         })
         this._result = new Matrix(this._data.rows, this.dimensionality, () => this._randomizer.randomGauss() * 1e-4)
@@ -51,7 +52,7 @@ export class TSNE extends DimRed<TSNEParams> {
         const P = new Matrix(n, n, 0)
 
         // search for fitting sigma
-        const targetH = Math.log(this.perplexity)
+        const targetH = Math.log(this._params.perplexity)
         for (let i = 0; i < n; ++i) {
             const nDist = delta.getRow(i)
             const pRow = P.getRow(i)
@@ -186,20 +187,4 @@ export class TSNE extends DimRed<TSNEParams> {
 
         return this._result
     }
-
-    /**
-     * Returns the perplexity value used in t-SNE algorithm.
-     * @returns The value of the perplexity parameter.
-     */
-    get perplexity() {
-        return this._params.perplexity
-    }
-
-    /**
-     * Returns the epsilon value used in t-SNE algorithm.
-     * @returns The value of the epsilon parameter.
-     */
-    get epsilon() {
-        return this._params.epsilon
-    }
 }

src/sortings/index.ts

@@ -1,3 +1,4 @@
-// 2023-10-10 13:12:20
+// 2023-10-25 12:32:42
 
 export * from './merge';
+export * from './quick';

src/sortings/merge.ts

@@ -1,29 +1,41 @@
-import { isRightArray } from "../utils"
+import { getLCP } from "../utils"
 
 /**
- * Sorts an array of numbers or strings using the merge sort algorithm.
+ * Sorts an array of numbers using the merge sort algorithm.
  * @param array The array to be sorted.
  * @returns The sorted array.
  */
-export function mergeSort(array: number[]): number[]
-export function mergeSort(array: string[]): string[]
-export function mergeSort(array: number[] | string[]) {
+export function mergeSortNum(array: number[]) {
     if (array.length <= 1) return array
 
     const middle = Math.floor(array.length / 2)
 
-    let left = array.slice(0, middle) as never
-    let right = array.slice(middle) as never
+    let left = array.slice(0, middle)
+    let right = array.slice(middle)
 
-    left = mergeSort(left) as never
-    right = mergeSort(right) as never
+    left = mergeSortNum(left)
+    right = mergeSortNum(right)
 
-    let result: number[] | string[] = []
+    return mergeNumbers(left, right)
+}
 
-    if (isRightArray<string>(array)) result = mergeStrings(left, right)
-    else if (isRightArray<number>(array)) result = mergeNumbers(left, right)
+/**
+ * Sorts an array of strings using the merge sort algorithm.
+ * @param array The array to be sorted.
+ * @returns The sorted array.
+ */
+export function mergeSortStr(array: string[]) {
+    if (array.length <= 1) return array
 
-    return result
+    const middle = Math.floor(array.length / 2)
+    
+    let left = array.slice(0, middle)
+    let right = array.slice(middle)
+
+    left = mergeSortStr(left)
+    right = mergeSortStr(right)
+
+    return mergeStrings(left, right)
 }
 
 function mergeNumbers(left: number[], right: number[]) {
@@ -48,7 +60,7 @@ function mergeStrings(left: string[], right: string[]) {
     let result: string[] = []
 
     while (left.length > 0 && right.length > 0) {
-        if (compareLCP(left[0], right[0]) <= 0) {
+        if (getLCP(left[0], right[0]) <= 0) {
             result.push(left[0])
             left.shift()
         } else {
@@ -60,10 +72,4 @@ function mergeStrings(left: string[], right: string[]) {
     result = [...result, ...left, ...right]
 
     return result
-}
-
-function compareLCP(str1: string, str2: string) {
-    let lcp = 0
-    while (lcp < Math.min(str1.length, str2.length) && str1[lcp] === str2[lcp]) lcp++
-    return lcp
 }

src/sortings/quick.ts

@@ -0,0 +1,87 @@
+import { getLCP } from "../utils"
+
+/**
+ * Sorts an array of numbers using the quick sort algorithm.
+ * @param array The array to be sorted.
+ * @returns The sorted array.
+ */
+export function quickSortNum(array: number[]) {
+    if (array.length <= 1) return array
+
+    const result = [...array]
+
+    const qs = (arr: number[], low: number, high: number) => {
+        if (low < high) {
+            const pi = partitionNumbers(arr, low, high)
+
+            qs(arr, low, pi - 1)
+            qs(arr, pi + 1, high)
+        }
+    }
+
+    qs(result, 0, result.length - 1)
+
+    return result
+}
+
+/**
+ * Sorts an array of strings using the quick sort algorithm.
+ * @param array The array to be sorted.
+ * @returns The sorted array.
+ */
+export function quickSortStr(array: string[]) {
+    if (array.length <= 1) return array
+
+    const result = [...array]
+
+    const qs = (arr: string[], low: number, high: number) => {
+        if (low < high) {
+            const pi = partitionStrings(arr, low, high)
+
+            qs(arr, low, pi - 1)
+            qs(arr, pi + 1, high)
+        }
+    }
+
+    qs(result, 0, result.length - 1)
+
+    return result
+}
+
+function partitionNumbers(arr: number[], low: number, high: number) {
+    const pivot = arr[high]
+    let i = low - 1
+
+    for (let j = low; j <= high - 1; j++) {
+        if (arr[j] < pivot) {
+            i++;
+            [arr[i], arr[j]] = [arr[j], arr[i]];
+        }
+    }
+
+    [arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
+    
+    return i + 1
+}
+
+function partitionStrings(arr: string[], low: number, high: number) {
+    const pivot = arr[high]
+    let i = low - 1
+
+    for (let j = low; j <= high - 1; j++) {
+        const lcp = getLCP(arr[j], pivot)
+        if (lcp < 0) {
+            i++;
+            [arr[i], arr[j]] = [arr[j], arr[i]];
+        } else if (arr[j] === pivot) {
+            if (lcp === arr[j].length || lcp === pivot.length || arr[j][lcp] < pivot[lcp]) {
+                i++;
+                [arr[i], arr[j]] = [arr[j], arr[i]];
+            }
+        }
+    }
+
+    [arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
+
+    return i + 1
+}

src/utils/helpers.ts

@@ -28,6 +28,18 @@ export function isArray2D<T>(array: unknown[][]): array is T[][] {
     return isRightArray(array) && array?.every(item => isRightArray(item))
 }
 
+/**
+ * Returns the length of the longest common prefix between two strings.
+ * @param str1 - The first string to compare.
+ * @param str2 - The second string to compare.
+ * @returns The length of the longest common prefix between the two strings.
+ */
+export function getLCP(str1: string, str2: string) {
+    let lcp = 0
+    while (lcp < Math.min(str1.length, str2.length) && str1[lcp] === str2[lcp]) lcp++
+    return lcp
+}
+
 /**
  * Measures the time it takes for a function to execute.
  * @param func - The function to measure the execution time of.