math-utils-simple 2.1.0 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-utils-simple",
-  "version": "2.1.0",
+  "version": "4.0.0",
   "description": "A simple math utility library for npm",
   "type": "module",
   "main": "./src/index.js",

package/src/arrays/angleBetweenVectors.js

@@ -0,0 +1,9 @@
+import cosineSimilarity from "./cosineSimilarity.js";
+
+export default function angleBetweenVectors(a, b) {
+  const cosine = cosineSimilarity(a, b);
+
+  return Math.acos(
+    Math.min(1, Math.max(-1, cosine))
+  );
+}

package/src/arrays/cosineSimilarity.js

@@ -0,0 +1,13 @@
+import dotProduct from "./dotProduct.js";
+import vectorMagnitude from "./vectorMagnitude.js";
+
+export default function cosineSimilarity(a, b) {
+  const magA = vectorMagnitude(a);
+  const magB = vectorMagnitude(b);
+
+  if (magA === 0 || magB === 0) {
+    throw new Error("Cannot calculate similarity for a zero vector.");
+  }
+
+  return dotProduct(a, b) / (magA * magB);
+}

package/src/arrays/crossProduct.js

@@ -0,0 +1,15 @@
+export default function crossProduct(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) {
+    throw new TypeError("Expected two arrays.");
+  }
+
+  if (a.length !== 3 || b.length !== 3) {
+    throw new Error("Cross product requires two 3-dimensional vectors.");
+  }
+
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0],
+  ];
+}

package/src/arrays/cumulativeSum.js

@@ -0,0 +1,15 @@
+export default function cumulativeSum(array) {
+  if (!Array.isArray(array)) {
+    throw new TypeError("Expected an array.");
+  }
+
+  const result = [];
+  let sum = 0;
+
+  for (const value of array) {
+    sum += value;
+    result.push(sum);
+  }
+
+  return result;
+}

package/src/arrays/dotProduct.js

@@ -0,0 +1,17 @@
+export default function dotProduct(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) {
+    throw new TypeError("Expected two arrays.");
+  }
+
+  if (a.length !== b.length) {
+    throw new Error("Arrays must have the same length.");
+  }
+
+  let result = 0;
+
+  for (let i = 0; i < a.length; i++) {
+    result += a[i] * b[i];
+  }
+
+  return result;
+}

package/src/arrays/elementWiseAdd.js

@@ -0,0 +1,11 @@
+export default function elementWiseAdd(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) {
+    throw new TypeError("Expected two arrays.");
+  }
+
+  if (a.length !== b.length) {
+    throw new Error("Arrays must have the same length.");
+  }
+
+  return a.map((value, index) => value + b[index]);
+}

package/src/arrays/elementWiseDivide.js

@@ -0,0 +1,13 @@
+export default function elementWiseDivide(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Arrays must have the same length.");
+  }
+
+  return a.map((value, index) => {
+    if (b[index] === 0) {
+      throw new Error("Division by zero.");
+    }
+
+    return value / b[index];
+  });
+}

package/src/arrays/elementWiseMultiply.js

@@ -0,0 +1,11 @@
+export default function elementWiseMultiply(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) {
+    throw new TypeError("Expected two arrays.");
+  }
+
+  if (a.length !== b.length) {
+    throw new Error("Arrays must have the same length.");
+  }
+
+  return a.map((value, index) => value * b[index]);
+}

package/src/arrays/elementWiseSubtract.js

@@ -0,0 +1,7 @@
+export default function elementWiseSubtract(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Arrays must have the same length.");
+  }
+
+  return a.map((value, index) => value - b[index]);
+}

package/src/arrays/matrixMultiply.js

@@ -0,0 +1,26 @@
+export default function matrixMultiply(a, b) {
+  const rowsA = a.length;
+  const colsA = a[0].length;
+
+  const rowsB = b.length;
+  const colsB = b[0].length;
+
+  if (colsA !== rowsB) {
+    throw new Error("Matrix dimensions are incompatible.");
+  }
+
+  const result = Array.from(
+    { length: rowsA },
+    () => Array(colsB).fill(0)
+  );
+
+  for (let i = 0; i < rowsA; i++) {
+    for (let j = 0; j < colsB; j++) {
+      for (let k = 0; k < colsA; k++) {
+        result[i][j] += a[i][k] * b[k][j];
+      }
+    }
+  }
+
+  return result;
+}

package/src/arrays/movingAverage.js

@@ -0,0 +1,23 @@
+export default function movingAverage(array, window) {
+  if (!Array.isArray(array)) {
+    throw new TypeError("Expected an array.");
+  }
+
+  if (window <= 0 || window > array.length) {
+    throw new Error("Invalid window size.");
+  }
+
+  const result = [];
+
+  for (let i = 0; i <= array.length - window; i++) {
+    let sum = 0;
+
+    for (let j = 0; j < window; j++) {
+      sum += array[i + j];
+    }
+
+    result.push(sum / window);
+  }
+
+  return result;
+}

package/src/arrays/normalizeVector.js

@@ -0,0 +1,15 @@
+export default function normalize(array) {
+  if (!Array.isArray(array)) {
+    throw new TypeError("Expected an array.");
+  }
+
+  const magnitude = Math.sqrt(
+    array.reduce((sum, value) => sum + value * value, 0)
+  );
+
+  if (magnitude === 0) {
+    throw new Error("Cannot normalize a zero vector.");
+  }
+
+  return array.map(value => value / magnitude);
+}

package/src/arrays/projectVector.js

@@ -0,0 +1,13 @@
+import dotProduct from "./dotProduct.js";
+
+export default function projectVector(a, b) {
+  const denominator = dotProduct(b, b);
+
+  if (denominator === 0) {
+    throw new Error("Cannot project onto a zero vector.");
+  }
+
+  const scalar = dotProduct(a, b) / denominator;
+
+  return b.map(value => scalar * value);
+}

package/src/arrays/scalarDivide.js

@@ -0,0 +1,7 @@
+export default function scalarDivide(array, scalar) {
+  if (scalar === 0) {
+    throw new Error("Division by zero.");
+  }
+
+  return array.map(value => value / scalar);
+}

package/src/arrays/scalarMultiply.js

@@ -0,0 +1,3 @@
+export default function scalarMultiply(array, scalar) {
+  return array.map(value => value * scalar);
+}

package/src/arrays/transpose.js

@@ -0,0 +1,20 @@
+export default function transpose(matrix) {
+  if (matrix.length === 0) {
+    return [];
+  }
+
+  const rows = matrix.length;
+  const cols = matrix[0].length;
+
+  const result = [];
+
+  for (let col = 0; col < cols; col++) {
+    result[col] = [];
+
+    for (let row = 0; row < rows; row++) {
+      result[col][row] = matrix[row][col];
+    }
+  }
+
+  return result;
+}

package/src/arrays/vectorDistance.js

@@ -0,0 +1,11 @@
+import vectorMagnitude from "./vectorMagnitude.js";
+
+export default function vectorDistance(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Vectors must have the same length.");
+  }
+
+  const difference = a.map((value, index) => value - b[index]);
+
+  return vectorMagnitude(difference);
+}

package/src/arrays/vectorMagnitude.js

@@ -0,0 +1,5 @@
+export default function vectorMagnitude(array) {
+  return Math.sqrt(
+    array.reduce((sum, value) => sum + value * value, 0)
+  );
+}

package/src/index.js

@@ -69,4 +69,39 @@ export { default as markup } from "./percentages/markup.js";
 export { default as profitPercentage } from "./percentages/profitPercentage.js";
 export { default as lossPercentage } from "./percentages/lossPercentage.js";
 export { default as margin } from "./percentages/margin.js";
-export { default as relativeChange } from "./percentages/relativeChange.js";
+export { default as relativeChange } from "./percentages/relativeChange.js";
+
+// STATISTICS
+export { default as sum } from "./statistics/sum.js";
+export { default as average } from "./statistics/average.js";
+export { default as median } from "./statistics/median.js";
+export { default as mode } from "./statistics/mode.js";
+export { default as range } from "./statistics/range.js";
+export { default as variance } from "./statistics/variance.js";
+export { default as standardDeviation } from "./statistics/standardDeviation.js";
+export { default as max } from "./statistics/max.js";
+export { default as min } from "./statistics/min.js";
+export { default as count } from "./statistics/count.js";
+export { default as frequency } from "./statistics/frequency.js";
+export { default as quartiles } from "./statistics/quartiles.js";
+export { default as interQuartileRange } from "./statistics/interQuartileRange.js";
+
+// ARRAYS
+export { default as dotProduct } from "./arrays/dotProduct.js";
+export { default as crossProduct } from "./arrays/crossProduct.js";
+export { default as elementWiseAdd } from "./arrays/elementWiseAdd.js";
+export { default as elementWiseSubtract } from "./arrays/elementWiseSubtract.js";
+export { default as elementWiseMultiply } from "./arrays/elementWiseMultiply.js";
+export { default as elementWiseDivide } from "./arrays/elementWiseDivide.js";
+export { default as scalarMultiply } from "./arrays/scalarMultiply.js";
+export { default as scalarDivide } from "./arrays/scalarDivide.js";
+export { default as normalizeVector } from "./arrays/normalizeVector.js";
+export { default as vectorMagnitude } from "./arrays/vectorMagnitude.js";
+export { default as vectorDistance } from "./arrays/vectorDistance.js";
+export { default as cosineSimilarity } from "./arrays/cosineSimilarity.js";
+export { default as angleBetweenVectors } from "./arrays/angleBetweenVectors.js";
+export { default as projectVector } from "./arrays/projectVector.js";
+export { default as cumulativeSum } from "./arrays/cumulativeSum.js";
+export { default as movingAverage } from "./arrays/movingAverage.js";
+export { default as transpose } from "./arrays/transpose.js";
+export { default as matrixMultiply } from "./arrays/matrixMultiply.js";

package/src/statistics/average.js

@@ -0,0 +1,13 @@
+import sum from "./sum.js";
+
+export default function average(array) {
+  if (!Array.isArray(array)) {
+    throw new TypeError("Expected an array.");
+  }
+
+  if (array.length === 0) {
+    throw new Error("Cannot calculate average of an empty array.");
+  }
+
+  return sum(array) / array.length;
+}

package/src/statistics/count.js

@@ -0,0 +1,7 @@
+export default function count(array) {
+  if (!Array.isArray(array)) {
+    throw new TypeError("Expected an array.");
+  }
+
+  return array.length;
+}

package/src/statistics/frequency.js

@@ -0,0 +1,13 @@
+export default function frequency(array) {
+  if (!Array.isArray(array)) {
+    throw new TypeError("Expected an array.");
+  }
+
+  const result = {};
+
+  for (const value of array) {
+    result[value] = (result[value] || 0) + 1;
+  }
+
+  return result;
+}

package/src/statistics/interQuartileRange.js

@@ -0,0 +1,7 @@
+import quartiles from "./quartiles.js";
+
+export default function interQuartileRange(array) {
+  const { q1, q3 } = quartiles(array);
+
+  return q3 - q1;
+}

package/src/statistics/max.js

@@ -0,0 +1,19 @@
+export default function max(array) {
+  if (!Array.isArray(array)) {
+    throw new TypeError("Expected an array.");
+  }
+
+  if (array.length === 0) {
+    throw new Error("Cannot find maximum of an empty array.");
+  }
+
+  let largest = array[0];
+
+  for (const value of array) {
+    if (value > largest) {
+      largest = value;
+    }
+  }
+
+  return largest;
+}

package/src/statistics/median.js

@@ -0,0 +1,18 @@
+export default function median(array) {
+  if (!Array.isArray(array)) {
+    throw new TypeError("Expected an array.");
+  }
+
+  if (array.length === 0) {
+    throw new Error("Cannot calculate median of an empty array.");
+  }
+
+  const sorted = [...array].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+
+  if (sorted.length % 2 === 0) {
+    return (sorted[middle - 1] + sorted[middle]) / 2;
+  }
+
+  return sorted[middle];
+}

package/src/statistics/min.js

@@ -0,0 +1,19 @@
+export default function min(array) {
+  if (!Array.isArray(array)) {
+    throw new TypeError("Expected an array.");
+  }
+
+  if (array.length === 0) {
+    throw new Error("Cannot find minimum of an empty array.");
+  }
+
+  let smallest = array[0];
+
+  for (const value of array) {
+    if (value < smallest) {
+      smallest = value;
+    }
+  }
+
+  return smallest;
+}

package/src/statistics/mode.js

@@ -0,0 +1,38 @@
+export default function mode(array) {
+  if (!Array.isArray(array)) {
+    throw new TypeError("Expected an array.");
+  }
+
+  if (array.length === 0) {
+    throw new Error("Cannot calculate mode of an empty array.");
+  }
+
+  const counts = new Map();
+
+  for (const value of array) {
+    counts.set(value, (counts.get(value) || 0) + 1);
+  }
+
+  let maxFrequency = 0;
+
+  for (const frequency of counts.values()) {
+    if (frequency > maxFrequency) {
+      maxFrequency = frequency;
+    }
+  }
+
+  // No mode if every value occurs equally often.
+  if (maxFrequency === 1) {
+    return [];
+  }
+
+  const modes = [];
+
+  for (const [value, frequency] of counts) {
+    if (frequency === maxFrequency) {
+      modes.push(value);
+    }
+  }
+
+  return modes.sort((a, b) => a - b);
+}

package/src/statistics/quartiles.js

@@ -0,0 +1,37 @@
+import median from "./median.js";
+
+export default function quartiles(array) {
+  if (!Array.isArray(array)) {
+    throw new TypeError("Expected an array.");
+  }
+
+  if (array.length === 0) {
+    throw new Error("Cannot calculate quartiles of an empty array.");
+  }
+
+  const sorted = [...array].sort((a, b) => a - b);
+
+  const q2 = median(sorted);
+
+  const middle = Math.floor(sorted.length / 2);
+
+  let lowerHalf;
+  let upperHalf;
+
+  if (sorted.length % 2 === 0) {
+    lowerHalf = sorted.slice(0, middle);
+    upperHalf = sorted.slice(middle);
+  } else {
+    lowerHalf = sorted.slice(0, middle);
+    upperHalf = sorted.slice(middle + 1);
+  }
+
+  const q1 = median(lowerHalf);
+  const q3 = median(upperHalf);
+
+  return {
+    q1,
+    q2,
+    q3,
+  };
+}

package/src/statistics/range.js

@@ -0,0 +1,6 @@
+import min from "./min.js";
+import max from "./max.js";
+
+export default function range(array) {
+  return max(array) - min(array);
+}

package/src/statistics/standardDeviation.js

@@ -0,0 +1,5 @@
+import variance from "./variance.js";
+
+export default function standardDeviation(array) {
+  return Math.sqrt(variance(array));
+}

package/src/statistics/sum.js

@@ -0,0 +1,7 @@
+export default function sum(array) {
+  if (!Array.isArray(array)) {
+    throw new TypeError("Expected an array.");
+  }
+
+  return array.reduce((total, value) => total + value, 0);
+}

package/src/statistics/variance.js

@@ -0,0 +1,21 @@
+import average from "./average.js";
+
+export default function variance(array) {
+  if (!Array.isArray(array)) {
+    throw new TypeError("Expected an array.");
+  }
+
+  if (array.length === 0) {
+    throw new Error("Cannot calculate variance of an empty array.");
+  }
+
+  const mean = average(array);
+
+  let sum = 0;
+
+  for (const value of array) {
+    sum += (value - mean) ** 2;
+  }
+
+  return sum / array.length;
+}