@princedev/calculate/dist/calculate.esm.js

Fast, lightweight, and extinsible mathematical and statistical functions.

/**
 * @name leastArguments
 *
 * @description - Throws error when number of arguments recieved did not meet expected minimum.
 *
 * @param {number} required required number of arguments.
 * @param {Array<any>} argument arguments received.
 */
function leastArguments(required, argument) {
  if (argument.length < required) {
    throw new TypeError(required + " argument" + (required > 1 ? 's' : '') + " required, but only " + argument.length + " is present");
  }
}

/**
 * @name sum
 * @summary Returns the sum.
 *
 * @description Adds given numbers from left to right.
 *
 * @example
 * // Normal usage
 * let return sum(10,20,30);
 * // => 60
 *
 * // Using an array
 * let return sum(...[10,20,30]);
 * // => 60
 *
 * @param {Array<number>} args numbers to be added.
 * @returns {number} the resulting sum.
 *
 * @function pure
 */

function sum() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  leastArguments(2, arguments);
  return args.reduce(function (a, b) {
    return a + b;
  });
}

/**
 * @name difference
 * @summary Returns the difference.
 *
 * @description Subtracts given numbers from left to right.
 *
 * @example
 * // Normal usage
 * let result = difference(120,200,-40);
 * // => -40
 *
 * // Using an array
 * let result = difference(...[120,200,-40]);
 * // => -40
 *
 * @param {Array<number>} args numbers to be subtracted.
 * @returns {number} the resulting difference.
 *
 * @function pure
 */

function difference() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  leastArguments(2, arguments);
  return args.reduce(function (a, b) {
    return a - b;
  });
}

/**
 * @name product
 * @summary Returns the product.
 *
 * @description Multiplies given numbers from left to right.
 *
 * @example
 * // Normal usage
 * let result = product(-2,-4,6);
 * // => 48
 *
 * // Using an array
 * let result = product(...[-2,-4,6]);
 * // => 48
 *
 * @param {Array<number>} args numbers to be multiplied.
 * @returns {number} the resulting product.
 *
 * @function pure
 */

function product() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  leastArguments(2, arguments);
  return args.reduce(function (a, b) {
    return a * b;
  });
}

/**
 * @name quotient
 * @summary Returns the quotient.
 *
 * @description Divides given numbers from left to right.
 *
 * @example
 * // Normal usage
 * let result = quotient(8,4,2);
 * // => 1
 *
 * // Using an array
 * let result = quotient(...[8,4,2]);
 * // => 1
 *
 * @param {Array<number>} args numbers to be divided
 * @returns {number} the resulting quotient.
 *
 * @function pure
 */

function quotient() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  leastArguments(2, arguments);
  return args.reduce(function (a, b) {
    return a / b;
  });
}

/**
 * @name remainder
 * @summary Returns the remainder.
 *
 * @description Divides given numbers from left to right and gets its remainder.
 *
 * @example
 * // Normal usage
 * let result = remainder(8,4,2);
 * // => 0
 *
 * // Using an array
 * let result = remainder(...[8,4,2]);
 * // => 0
 *
 * @param {Array<number>} args numbers given.
 * @returns {number} the resulting remainder.
 *
 * @function pure
 */

function remainder() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  leastArguments(2, arguments);
  return args.reduce(function (a, b) {
    return a % b;
  });
}

/**
 * @name exactArguments
 *
 * @description - Throws error when number of arguments recieved did not meet exact number.
 *
 * @param {number} required required number of arguments.
 * @param {Array<any>} argument arguments received.
 */
function exactArguments(required, argument) {
  if (argument.length !== required) {
    throw new TypeError(required + " argument" + (required > 1 ? 's' : '') + " required, but " + argument.length + " is present");
  }
}

/**
 * @name sqaureRoot
 * @summary Returns the sqaure root of a number.
 *
 * @description Returns the sqaure root of a number.
 *
 * @example
 * // Normal usage
 * let result = sqaureRoot(16);
 * // => 4
 *
 * @param {numberr} a number to be solved.
 * @returns {number}
 *
 * @function pure
 */

function sqaureRoot(a) {
  exactArguments(1, arguments);
  return Math.pow(a, 0.5);
}

/**
 * @name square
 * @summary Returns the square of a number.
 *
 * @description Returns the square of a number.
 *
 * @example
 * // Normal usage
 * let result = sqaure(4);
 * // => 16
 *
 * @param {numberr} a number to be squared.
 * @returns {number}
 *
 * @function pure
 */

function square(a) {
  exactArguments(1, arguments);
  return Math.pow(a, 2);
}

/**
 * @name cube
 * @summary Returns the cube of a number.
 *
 * @description Returns the cube of a number.
 *
 * @example
 * // Normal usage
 * let result = cube(2);
 * // => 8
 *
 * @param {numberr} a - number to be cubed.
 * @returns {number}
 *
 * @function pure
 */

function cube(a) {
  exactArguments(1, arguments);
  return Math.pow(a, 3);
}

/**
 * @name power
 * @summary Returns the power.
 *
 * @description Returns the power of given base (left most) raise to its succeeding numbers.
 *
 * @example
 * // Normal usage
 * let result = power(2,5,2); // the same as ((2)^5)^2
 * // => 1024
 *
 * @param {Array<number>} args given numbers.
 * @returns {number} the power
 *
 * @function pure
 */

function power() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  leastArguments(2, arguments);
  return args.reduce(function (a, b) {
    return Math.pow(a, b);
  });
}

/**
 * @name factorial
 * @summary Returns the factorial of a number.
 *
 * @description Returns the factorial of a number.
 *
 * @example
 * // Normal usage
 * let result = factorial(4);
 * // => 24
 *
 * @param {numberr} a numbers given.
 * @returns {number}
 *
 * @function pure
 */

function factorial(a) {
  exactArguments(1, arguments);
  return factorialStep(a);
}

function factorialStep(a) {
  if (a === 1 || a === 0) {
    return 1;
  }

  return a * factorialStep(a - 1);
}

/**
 * @name negate
 * @summary Returns the negated value.
 *
 * @description Returns a same number with an opposite sign.
 *
 * @example
 * // Normal usage
 * let result = negate(2);
 * // => -2
 *
 * let result = negate(-4);
 * // => 4
 *
 * @param {number} a given number.
 * @returns {number} the negated value
 *
 * @function pure
 */

function negate(a) {
  exactArguments(1, arguments);
  return -a;
}

/**
 * @name absolute
 * @summary Returns the absolute number.
 *
 * @description Returns the absolute number.
 *
 * @example
 * // Normal usage
 * let result = absolute(-6);
 * // => 6;
 *
 * @param {number} arg number given.
 * @returns {number} absolute number of given.
 *
 * @function pure
 */

function min(x) {
  exactArguments(1, arguments);
  return Math.abs(x);
}

/**
 * @name notAllowed
 *
 * @description - Throws error when number of arguments recieved did not meet expected minimum.
 *
 * @param {{ [key: string]: number }} variable variable to be compared.
 * @param {number} value value which the variable must not equal to.
 */
function notAllowed(variable, value) {
  if (Object.values(variable)[0] === value) {
    throw new TypeError(Object.keys(variable)[0] + " must not be equal to " + value);
  }
}

/**
 * @name quadratic
 * @summary Returns the root.
 *
 * @description Returns the first and second root of a quadratice equation
 *
 * @example
 * // Normal usage
 * let result = root(4,4,1);
 * // => {firstRoot: -0.5, secondRoot: -0.5}
 *
 * @param {number} a
 * @param {number} b
 * @param {number} c
 * @returns {IRoot} the resulting root.
 *
 * @function pure
 */

function quadratic(a, b, c) {
  exactArguments(3, arguments);
  notAllowed({
    a: a
  }, 0);
  var bSquared = b * b;
  var fourAC = 4 * a * c;
  var twiceA = a * 2;
  var rSquareRoot = sqaureRoot(bSquared - fourAC);
  return {
    firstRoot: (-b + rSquareRoot) / twiceA,
    secondRoot: (-b - rSquareRoot) / twiceA
  };
}

/**
 * @name mean
 * @summary Returns the mean (average).
 *
 * @description Adds given numbers from left to right and divides the sum by the amount of the numbers.
 *
 * @example
 * // Normal usage
 * let result = mean(10,20,30);
 * // => 30
 *
 * // Using an array
 * let result = mean(...[10,20,30]);
 * // => 30
 *
 * @param {Array<number>} args numbers to be averaged..
 * @returns {number} the resulting mean.
 *
 * @function pure
 */

function mean() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  leastArguments(2, arguments);
  return sum.apply(void 0, args) / arguments.length;
}

/**
 * @name immutableSort
 *
 * @description - Accepts an array and returns a new array that is sorted. (numbers only)
 *
 * @param {Array<number>} required array to be sorted.
 * @param {Array<number>} argument new sorted array.
 */
function immutableSort(arr) {
  return [].concat(arr).sort(function (a, b) {
    return a - b;
  });
}

/**
 * @name median
 * @summary Returns the median.
 *
 * @description Arranges the numbers in order and gets the number halfway the list.
 *
 * @example
 * // Normal usage
 * let result = median(21,4,8,6);
 * // => 7
 *
 * // Using an array
 * let result = median(...[21,4,8,6]);
 * // => 7
 *
 * @param {Array<number>} args given numbers.
 * @returns {number} the resulting median.
 *
 * @function pure
 */

function median() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  var sortedArr = immutableSort(args);
  var length = sortedArr.length;

  if (length % 2 === 0) {
    var halfLength = length / 2;
    return (sortedArr[halfLength - 1] + sortedArr[halfLength]) / 2;
  }

  return sortedArr[(length - 1) / 2];
}

/**
 * @name mode
 * @summary Returns the mode.
 *
 * @description Returns the highest occuring number/s in a given numbers.
 *
 * @example
 * // Normal usage
 * let result = mode(2, 1, 8, 3, 2, 7, 4, 2, 6, 8);
 * // => [2]
 *
 * // Using an array
 * let result = mode(...[2, 1, 8, 3, 2, 7, 4, 2, 6, 8]);
 * // => [2]
 *
 * @param {Array<number>} args given numbers.
 * @returns {Array<number>} the resulting mode.
 *
 * @function pure
 */
function mode() {
  var count = {};
  var result = [];

  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  args.forEach(function (num) {
    if (!count[num]) {
      count[num] = 1;
      return;
    }

    count[num] += 1;
  });
  var highest = Math.max.apply(null, Object.values(count));
  Object.entries(count).forEach(function (_ref) {
    var key = _ref[0],
        value = _ref[1];

    if (value === highest) {
      result.push(parseInt(key, 10));
    }
  });
  return result;
}

/**
 * @name range
 * @summary Returns the range
 *
 * @description Returns the difference of the highest and lowest number in the given numbers
 *
 * @example
 * // Normal usage
 * let result = range(10,20,30);
 * // => 20
 * // Using an array
 * let result = range(...[10,20,30]);
 * // => 20
 *
 * @param {Array<number>} args given numbers
 * @returns {number} the resulting range
 *
 * @function pure
 */

function range() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  var sortedArr = immutableSort(args);
  var lastIndex = sortedArr.length - 1;
  return sortedArr[lastIndex] - sortedArr[0];
}

/**
 * @name max
 * @summary Returns the largest number.
 *
 * @description Returns the largest number.
 *
 * @example
 * // Normal usage
 * let result = max(2,4,6);
 * // => 6;
 *
 * @param {number} args numbers given.
 * @returns {number} largest number
 *
 * @function pure
 */

function max() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  leastArguments(1, arguments);
  var sortedArray = immutableSort(args);
  return sortedArray[sortedArray.length - 1];
}

/**
 * @name min
 * @summary Returns the smallest number.
 *
 * @description Returns the smallest number.
 *
 * @example
 * // Normal usage
 * let result = min(2,4,6);
 * // => 2;
 *
 * @param {number} args numbers given.
 * @returns {number} smallest number
 *
 * @function pure
 */

function min$1() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  leastArguments(1, arguments);
  var sortedArray = immutableSort(args);
  return sortedArray[0];
}

/**
 * @name distance
 * @summary Returns the distance between two points.
 *
 * @description Returns the distance between two points in a cartesian plane.
 *
 * @example
 * // Normal usage
 * let result = distance(2,4,6,8);
 * // => 2.8284271247461903
 *
 * @param {number} x1
 * @param {number} x2
 * @param {number} y1
 * * @param {number} y2
 * @returns {number} the resulting distance.
 *
 * @function pure
 */

function distance(x1, x2, y1, y2) {
  exactArguments(4, arguments);
  return sqaureRoot(square(x1 - x2) + square(y1 - y2));
}

export { min as absolute, cube, difference, distance, factorial, max, mean, median, min$1 as min, mode, negate, power, product, quadratic, quotient, range, remainder, square, sqaureRoot as squareRoot, sum };
//# sourceMappingURL=calculate.esm.js.map