math-utils-simple 1.1.0 → 2.0.0

package/package.json

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

package/src/index.js

@@ -1,3 +1,4 @@
+// ARITHMETIC
 export { default as add } from "./arithmetic/add.js";
 export { default as subtract } from "./arithmetic/subtract.js";
 export { default as multiply } from "./arithmetic/multiply.js";
@@ -13,4 +14,44 @@ export { default as increment } from "./arithmetic/increment.js";
 export { default as decrement } from "./arithmetic/decrement.js";
 export { default as square } from "./arithmetic/square.js";
 export { default as cube } from "./arithmetic/cube.js";
-export { default as reciprocal } from "./arithmetic/reciprocal.js";
+export { default as reciprocal } from "./arithmetic/reciprocal.js";
+
+// NUMBER
+export { default as digitalRoot } from "./number/digitalRoot.js";
+export { default as digitCount } from "./number/digitCount.js";
+export { default as divisors } from "./number/divisors.js";
+export { default as factorial } from "./number/factorial.js";
+export { default as factors } from "./number/factors.js";
+export { default as fibonacci } from "./number/fibonacci.js";
+export { default as gcd } from "./number/gcd.js";
+export { default as isArmstrongNumber } from "./number/isArmstrongNumber.js";
+export { default as isEven } from "./number/isEven.js";
+export { default as isOdd } from "./number/isOdd.js";
+export { default as isLeapYear } from "./number/isLeapYear.js";
+export { default as isPalindromeNumber } from "./number/isPalindromeNumber.js";
+export { default as isPerfectCube } from "./number/isPerfectCube.js";
+export { default as isPerfectNumber } from "./number/isPerfectNumber.js";
+export { default as isPerfectSquare } from "./number/isPerfectSquare.js";
+export { default as isPrime } from "./number/isPrime.js";
+export { default as lcm } from "./number/lcm.js";
+export { default as nextPrime } from "./number/nextPrime.js";
+export { default as nthFibonacci } from "./number/nthFibonacci.js";
+export { default as previousPrime } from "./number/previousPrime.js";
+export { default as primeFactors } from "./number/primeFactors.js";
+export { default as reverseNumber } from "./number/reverseNumber.js";
+export { default as sumOfDigits } from "./number/sumOfDigits.js";
+
+// ROUNDING
+export { default as round } from "./rounding/round.js";
+export { default as floor } from "./rounding/floor.js";
+export { default as ceil } from "./rounding/ceil.js";
+export { default as truncate } from "./rounding/truncate.js";
+export { default as roundTo } from "./rounding/roundTo.js";
+export { default as clamp } from "./rounding/clamp.js";
+export { default as roundUpToNearest } from "./rounding/roundUpToNearest.js";
+export { default as roundDownToNearest } from "./rounding/roundDownToNearest.js";
+export { default as roundToNearest } from "./rounding/roundToNearest.js";
+export { default as snap } from "./rounding/snap.js";
+export { default as isBetween } from "./rounding/isBetween.js";
+export { default as wrap } from "./rounding/wrap.js";
+export { default as normalize } from "./rounding/normalize.js";

package/src/number/digitCount.js

@@ -0,0 +1,5 @@
+export default function digitCount(n) {
+  return Math.abs(Math.trunc(n))
+    .toString()
+    .length;
+}

package/src/number/digitalRoot.js

@@ -0,0 +1,12 @@
+export default function digitalRoot(n) {
+  n = Math.abs(Math.trunc(n));
+
+  while (n >= 10) {
+    n = n
+      .toString()
+      .split("")
+      .reduce((sum, digit) => sum + Number(digit), 0);
+  }
+
+  return n;
+}

package/src/number/divisors.js

@@ -0,0 +1,5 @@
+import factors from "./factors.js";
+
+export default function divisors(n) {
+  return factors(n);
+}

package/src/number/factorial.js

@@ -0,0 +1,13 @@
+export default function factorial(n) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new Error("Factorial is only defined for non-negative integers.");
+  }
+
+  let result = 1;
+
+  for (let i = 2; i <= n; i++) {
+    result *= i;
+  }
+
+  return result;
+}

package/src/number/factors.js

@@ -0,0 +1,17 @@
+export default function factors(n) {
+  if (n === 0) return [];
+
+  const result = [];
+
+  for (let i = 1; i <= Math.sqrt(Math.abs(n)); i++) {
+    if (n % i === 0) {
+      result.push(i);
+
+      if (i !== Math.abs(n) / i) {
+        result.push(Math.abs(n) / i);
+      }
+    }
+  }
+
+  return result.sort((a, b) => a - b);
+}

package/src/number/fibonacci.js

@@ -0,0 +1,18 @@
+export default function fibonacci(count) {
+  if (!Number.isInteger(count) || count < 1) {
+    throw new Error("Count must be a positive integer.");
+  }
+
+  if (count === 1) return [0];
+
+  const sequence = [0, 1];
+
+  while (sequence.length < count) {
+    sequence.push(
+      sequence[sequence.length - 1] +
+      sequence[sequence.length - 2]
+    );
+  }
+
+  return sequence;
+}

package/src/{gcd.js → number/gcd.js}

@@ -9,4 +9,4 @@ export default function gcd(a, b) {
   }
 
   return a;
-}
+}

package/src/number/isArmstrongNumber.js

@@ -0,0 +1,12 @@
+export default function isArmstrongNumber(n) {
+  const digits = Math.abs(n).toString().split("");
+
+  const power = digits.length;
+
+  const sum = digits.reduce(
+    (acc, digit) => acc + Math.pow(Number(digit), power),
+    0
+  );
+
+  return sum === Math.abs(n);
+}

package/src/number/isEven.js

@@ -0,0 +1,3 @@
+export default function isEven(n) {
+  return n % 2 === 0;
+}

package/src/number/isLeapYear.js

@@ -0,0 +1,6 @@
+export default function isLeapYear(year) {
+  return (
+    year % 4 === 0 &&
+    (year % 100 !== 0 || year % 400 === 0)
+  );
+}

package/src/number/isOdd.js

@@ -0,0 +1,3 @@
+export default function isOdd(n) {
+  return n % 2 !== 0;
+}

package/src/number/isPalindromeNumber.js

@@ -0,0 +1,5 @@
+export default function isPalindromeNumber(n) {
+  const str = Math.abs(n).toString();
+
+  return str === str.split("").reverse().join("");
+}

package/src/number/isPerfectCube.js

@@ -0,0 +1,3 @@
+export default function isPerfectCube(n) {
+  return Number.isInteger(Math.cbrt(n));
+}

package/src/number/isPerfectNumber.js

@@ -0,0 +1,17 @@
+export default function isPerfectNumber(n) {
+  if (n <= 1) return false;
+
+  let sum = 1;
+
+  for (let i = 2; i <= Math.sqrt(n); i++) {
+    if (n % i === 0) {
+      sum += i;
+
+      if (i !== n / i) {
+        sum += n / i;
+      }
+    }
+  }
+
+  return sum === n;
+}

package/src/number/isPerfectSquare.js

@@ -0,0 +1,5 @@
+export default function isPerfectSquare(n) {
+  if (n < 0) return false;
+
+  return Number.isInteger(Math.sqrt(n));
+}

package/src/number/isPrime.js

@@ -0,0 +1,12 @@
+export default function isPrime(n) {
+  if (!Number.isInteger(n) || n < 2) return false;
+
+  if (n === 2) return true;
+  if (n % 2 === 0) return false;
+
+  for (let i = 3; i <= Math.sqrt(n); i += 2) {
+    if (n % i === 0) return false;
+  }
+
+  return true;
+}

package/src/{lcm.js → number/lcm.js}

@@ -1,8 +1,6 @@
 import gcd from "./gcd.js";
 
 export default function lcm(a, b) {
-  if (a === 0 || b === 0) {
-    return 0;
-  }
+  if (a === 0 || b === 0) return 0;
   return Math.abs(a * b) / gcd(a, b);
 }

package/src/number/nextPrime.js

@@ -0,0 +1,11 @@
+import isPrime from "./isPrime.js";
+
+export default function nextPrime(n) {
+  let candidate = Math.floor(n) + 1;
+
+  while (!isPrime(candidate)) {
+    candidate++;
+  }
+
+  return candidate;
+}

package/src/number/nthFibonacci.js

@@ -0,0 +1,19 @@
+export default function nthFibonacci(n) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new Error("n must be a non-negative integer.");
+  }
+
+  if (n === 0) return 0;
+  if (n === 1) return 1;
+
+  let a = 0;
+  let b = 1;
+
+  for (let i = 2; i <= n; i++) {
+    const next = a + b;
+    a = b;
+    b = next;
+  }
+
+  return b;
+}

package/src/number/previousPrime.js

@@ -0,0 +1,12 @@
+import isPrime from "./isPrime.js";
+
+export default function previousPrime(n) {
+  let candidate = Math.floor(n) - 1;
+
+  while (candidate >= 2) {
+    if (isPrime(candidate)) return candidate;
+    candidate--;
+  }
+
+  return null;
+}

package/src/number/primeFactors.js

@@ -0,0 +1,23 @@
+export default function primeFactors(n) {
+  const factors = [];
+
+  if (n < 2) return factors;
+
+  while (n % 2 === 0) {
+    factors.push(2);
+    n /= 2;
+  }
+
+  for (let i = 3; i <= Math.sqrt(n); i += 2) {
+    while (n % i === 0) {
+      factors.push(i);
+      n /= i;
+    }
+  }
+
+  if (n > 2) {
+    factors.push(n);
+  }
+
+  return factors;
+}

package/src/number/reverseNumber.js

@@ -0,0 +1,11 @@
+export default function reverseNumber(n) {
+  const reversed = Number(
+    Math.abs(Math.trunc(n))
+      .toString()
+      .split("")
+      .reverse()
+      .join("")
+  );
+
+  return n < 0 ? -reversed : reversed;
+}

package/src/number/sumOfDigits.js

@@ -0,0 +1,6 @@
+export default function sumOfDigits(n) {
+  return Math.abs(Math.trunc(n))
+    .toString()
+    .split("")
+    .reduce((sum, digit) => sum + Number(digit), 0);
+}

package/src/rounding/ceil.js

@@ -0,0 +1,3 @@
+export default function ceil(n) {
+  return Math.ceil(n);
+}

package/src/rounding/clamp.js

@@ -0,0 +1,7 @@
+export default function clamp(value, min, max) {
+  if (min > max) {
+    throw new Error("min cannot be greater than max.");
+  }
+
+  return Math.min(Math.max(value, min), max);
+}

package/src/rounding/floor.js

@@ -0,0 +1,3 @@
+export default function floor(n) {
+  return Math.floor(n);
+}

package/src/rounding/isBetween.js

@@ -0,0 +1,11 @@
+export default function isBetween(value, min, max, inclusive = true) {
+  if (min > max) {
+    throw new Error("min cannot be greater than max.");
+  }
+
+  if (inclusive) {
+    return value >= min && value <= max;
+  }
+
+  return value > min && value < max;
+}

package/src/rounding/normalize.js

@@ -0,0 +1,7 @@
+export default function normalize(value, min, max) {
+  if (min === max) {
+    throw new Error("min and max cannot be equal.");
+  }
+
+  return (value - min) / (max - min);
+}

package/src/rounding/round.js

@@ -0,0 +1,3 @@
+export default function round(n) {
+  return Math.round(n);
+}

package/src/rounding/roundDownToNearest.js

@@ -0,0 +1,7 @@
+export default function roundDownToNearest(value, multiple) {
+  if (multiple === 0) {
+    throw new Error("multiple cannot be zero.");
+  }
+
+  return Math.floor(value / multiple) * multiple;
+}

package/src/rounding/roundTo.js

@@ -0,0 +1,4 @@
+export default function roundTo(n, decimals = 0) {
+  const factor = 10 ** decimals;
+  return Math.round(n * factor) / factor;
+}

package/src/rounding/roundToNearest.js

@@ -0,0 +1,7 @@
+export default function roundToNearest(value, multiple) {
+  if (multiple === 0) {
+    throw new Error("multiple cannot be zero.");
+  }
+
+  return Math.round(value / multiple) * multiple;
+}

package/src/rounding/roundUpToNearest.js

@@ -0,0 +1,7 @@
+export default function roundUpToNearest(value, multiple) {
+  if (multiple === 0) {
+    throw new Error("multiple cannot be zero.");
+  }
+
+  return Math.ceil(value / multiple) * multiple;
+}

package/src/rounding/snap.js

@@ -0,0 +1,7 @@
+export default function snap(value, step) {
+  if (step === 0) {
+    throw new Error("step cannot be zero.");
+  }
+
+  return Math.round(value / step) * step;
+}

package/src/rounding/truncate.js

@@ -0,0 +1,3 @@
+export default function truncate(n) {
+  return Math.trunc(n);
+}

package/src/rounding/wrap.js

@@ -0,0 +1,9 @@
+export default function wrap(value, min, max) {
+  if (min >= max) {
+    throw new Error("min must be less than max.");
+  }
+
+  const range = max - min;
+
+  return ((((value - min) % range) + range) % range) + min;
+}

package/src/average.js

@@ -1,11 +0,0 @@
-export default function average(numbers) {
-  if (!Array.isArray(numbers)) {
-    throw new Error("Input must be an array");
-  }
-  if (numbers.length === 0) {
-    throw new Error("Cannot calculate average of an empty array");
-  }
-
-  const sum = numbers.reduce((acc, num) => acc + num, 0);
-  return sum / numbers.length;
-}

package/src/factorial.js

@@ -1,14 +0,0 @@
-export default function factorial(n) {
-  if (n < 0) {
-    throw new Error("Factorial is not defined for negative numbers");
-  }
-  if (!Number.isInteger(n)) {
-    throw new Error("Factorial is only defined for integers");
-  }
-
-  let result = 1;
-  for (let i = 2; i <= n; i++) {
-    result *= i;
-  }
-  return result;
-}