@onyxim/math 1.0.1

package/math.js

@@ -0,0 +1,141 @@
+(function() {
+  if (typeof module !== "undefined" && module !== null) {
+    module.exports && (module.exports = Math);
+  }
+  /**
+   * @return wheter a Number x, has the same sign as another Number, y.
+   * @example
+   * Math.samesign(1,2)
+   * //-> true
+   * Math.samesign(-3, 4)
+   * //-> false
+   * @test
+   * Math.samesign(5, 6)
+   * //-> false
+   * Math.samesign(-7, -8)
+   * //-> true
+   */
+  Math.samesign = function(x, y) {
+    return (x >= 0) !== (y < 0);
+  };
+  /**
+   * @return {Number} a copy of Number x with the same sign of Number y.
+   * @example
+   * Math.copysign(1, -2)
+   * //-> -1
+   * @test
+   * Math.copysign(-3, 4)
+   * //-> 3
+   * Math.copysign(5, 6)
+   * //-> 5
+   * Math.copysign(-7, -8)
+   * //-> -7
+   */
+  Math.copysign = function(x, y) {
+    if (Math.samesign(x, y)) {
+      return x;
+    } else {
+      return -x;
+    }
+  };
+  /**
+   * @return {Number} sum of two Numbers.
+   * @example
+   * Math.add(1, 2)
+   * //-> 3
+   * @test
+   * Math.add('three', 4)
+   * //-> NaN
+   */
+  Math.add = function(a, b) {
+    return (+a) + (+b);
+  };
+  /**
+   * @return {Number} sum of an Array of Numbers.
+   * @example
+   * Math.sum([1, 2, 3])
+   * //-> 6
+   */
+  Math.sum = function(nums) {
+    return nums.reduce(Math.add);
+  };
+  /**
+   * @return {Number} product of two Numbers.
+   * @example
+   * Math.(2, 3)
+   * //-> 6
+   */
+  Math.mul = function(a, b) {
+    return a * b;
+  };
+  /**
+   * @return {Number} product of an Array of Numbers.
+   * @example
+   * Math.prod(2, 3, 4)
+   * //-> 24
+   */
+  Math.prod = function(nums) {
+    return nums.reduce(Math.mul);
+  };
+  /**
+   * @return {Number} factorial of a Number.
+   * @example
+   * Math.factorial(4)
+   * //-> 24
+   * @test
+   * Math.factorial(3)
+   * //-> 6
+   * Math.factorial(2)
+   * //-> 2
+   * Math.factorial(1)
+   * //-> 1
+   * Math.factorial(0)
+   * //-> 1
+   * Math.factorial(-1)
+   * //-> Infinity
+   */
+  Math.factorial = function(n) {
+    var _i, _results;
+    if (n < 0) {
+      return Infinity;
+    } else if (n === 0) {
+      return 1;
+    } else {
+      return Math.prod.apply(null, (function() {
+        _results = [];
+        for (var _i = 1; 1 <= n ? _i <= n : _i >= n; 1 <= n ? _i++ : _i--){ _results.push(_i); }
+        return _results;
+      }).apply(this, arguments));
+    }
+  };
+  /**
+   * Greatest Common Multipler
+   * @return {Number} greatest common multipler of two Numbers.
+   * @example
+   * Math.gcd(493, 289)
+   * //-> 17
+   * @test
+   * Math.gcd(493, -289)
+   * //-> 17
+   */
+  Math.gcd = function(a, b) {
+    var _ref;
+    while (b) {
+      _ref = [b, a % b], a = _ref[0], b = _ref[1];
+    }
+    return a;
+  };
+  /**
+   * Least Common Multiplier
+   * @return {Number} least common multiplier of two numbers.
+   * @example
+   * Math.lcm(4, 12)
+   * //-> 12
+   * @test
+   * Math.lcm(6, 7)
+   * //-> 42
+   */
+  Math.lcm = function(a, b) {
+    return a / Math.gcd(a, b) * b;
+  };
+}).call(this);

package/package.json

@@ -0,0 +1,26 @@
+{
+  "author": "Ville Laaksonen",
+  "name": "@onyxim/math",
+  "description": "Mathematical Functions",
+  "version": "1.0.1",
+  "main": "math.js",
+  "engines": {
+    "node": "> 0.0.0"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.26.10",
+    "complex.js": "^2.2.5",
+    "decimal.js": "^10.4.3",
+    "escape-latex": "^1.2.0",
+    "fraction.js": "^5.2.1",
+    "javascript-natural-sort": "^0.7.1",
+    "seedrandom": "^3.0.5",
+    "tiny-emitter": "^2.1.0",
+    "typed-function": "^4.2.1"
+  },
+  "devDependencies": {},
+  "homepage": "kaleb.hornsby.ws/js-math",
+  "contributors": [
+    "Ville Laaksonen"
+  ]
+}

package/readme.md

@@ -0,0 +1,38 @@
+# @onyxim/math
+
+a collection of math-related functions
+
+    npm install @onyxim/math
+
+### New functions to implement
+
+##### isEven(n) / isOdd(n)
+Check if the bit for `2^0` is set. If it is, `n must be odd.
+
+##### powermod(a, b, c)
+powermod is a way of computing `(a ^ b) mod c` without having to deal with giant numbers that would loose their precision.
+
+##### slowIsPrime(n)
+Returns if `n` is a prime. Extremely slow, but absolutely accurate.
+
+##### fastIsPrime(n)
+Retuns if a `n` is a prime. Based upon [Fermat's little theorem](http://en.wikipedia.org/wiki/Fermat%27s_little_theorem).
+
+Note: Doesn't take care of carmichael primes, so you probably want to use this in combination with slowIsPrime.
+
+##### isPrime(n)
+Runs both `fastIsPrime` and `slowIsPrime`. This way, it manages to be both (relatively) fast and accurate.
+
+##### randomPrime(length)
+Returns a pseudo-random prime number (based on `Math.random`). `length` defaults to 3.
+
+##### gcd(a, b)
+Returns the greatest common divisor of `a` and `b`. Based on [Euclids algorithm](http://en.wikipedia.org/wiki/Euclid%27s_algorithm)
+
+##### egcd(a, b)
+Computes the [extended Euclidean algorithm](http://en.wikipedia.org/wiki/Extended_Euclidean_algorithm). Returns an array `[d, s, t]`.
+
+    gcd(a, b) = d = s * a + t * b
+
+##### modularInverse(a, b)
+Returns the [modular multiplicative inverse](http://en.wikipedia.org/wiki/Modular_multiplicative_inverse) of `a` and `b`.