mathleet/es/index.js

Library of helpful math utilities.

/**
 *
 * @param {any[]} items
 * @return {number[]}
 */
export var filterNumbers = function filterNumbers(items) {
  return items.map(function (item) {
    return Number(item);
  }).filter(function (item) {
    return !isNaN(item);
  });
};
/**
 * Calculate sum of key values within an object array.
 *
 * @param {any[]} - items
 * @param {string} - key
 * @return {number}
 */

export var keySum = function keySum(items, key) {
  return filterNumbers(items.map(function (item) {
    return item[key];
  })).reduce(function (acc, cur) {
    return cur + acc;
  }, 0);
};
/**
 * Calculate the average of key values within an object array.
 *
 * @param {any[]} - items
 * @param {string} - key
 * @return {number}
 */

export var keyAvg = function keyAvg(items, key) {
  return keySum(items, key) / items.length;
};
/**
 *
 * @param {any[]} items
 * @return {number}
 */

export var numMin = function numMin(items) {
  var numbers = filterNumbers(items);
  return Math.min.apply(Math, numbers);
};
/**
 *
 * @param {any[]} items
 * @return {number}
 */

export var numMax = function numMax(items) {
  var numbers = filterNumbers(items);
  return Math.max.apply(Math, numbers);
};
/**
 * Sum method that can handle converting items to numbers, and also filtering
 * out NaN values from sum calculation.
 *
 * @param {any[]} items
 * @param {number} offset
 * @return {number}
 */

export var sum = function sum(items, offset) {
  if (offset === void 0) {
    offset = 0;
  }

  return filterNumbers(items).reduce(function (acc, cur) {
    return cur + acc;
  }, offset);
};
/**
 *
 * @param {any[]} items
 * @param {number} offset
 * @return {number}
 */

export var sumAvg = function sumAvg(items, offset) {
  if (offset === void 0) {
    offset = 0;
  }

  return sum(items, offset) / items.length;
};
/**
 * Calculate the average of values that fall within a specific range.
 *
 * @param {any[]} items
 * @param {number} rangeMin
 * @param {number} rangeMax
 * @return {number}
 */

export var rangeAvg = function rangeAvg(items, rangeMin, rangeMax) {
  if (rangeMin === void 0) {
    rangeMin = 0;
  }

  if (rangeMax === void 0) {
    rangeMax = 1;
  }

  var minNum = numMin(items);
  var maxNum = numMax(items);
  var rangeDiff = maxNum - minNum;
  var rangeFloor = minNum + rangeDiff * rangeMin;
  var rangeCeil = minNum + rangeDiff * rangeMax;
  var rangeNums = items.filter(function (item) {
    return item >= rangeFloor && item <= rangeCeil;
  });
  return sumAvg(rangeNums);
};
export var within = function within(value, target, offset) {
  if (offset === void 0) {
    offset = 0;
  }

  return value >= target - offset && value <= target + offset;
};
export var outside = function outside(value, target, offset) {
  if (offset === void 0) {
    offset = 0;
  }

  return value < target - offset || value > target + offset;
};
/**
 *
 * @param {number} value
 * @return {number}
 */

export var degrees = function degrees(value) {
  return value * (180 / Math.PI);
};
/**
 *
 * @param {number} value
 * @return {number}
 */

export var radians = function radians(value) {
  return value * (Math.PI / 180);
};
var DEFAULT_POINT = {
  x: 0,
  y: 0
};
/**
 *
 * @param {{ x: number, y: number }} pointA
 * @param {{ x: number, y: number }} pointB
 * @param {{ x: number, y: number }} pointC
 * @return {number}
 */

export var angle = function angle(pointA, pointB, pointC) {
  if (pointA === void 0) {
    pointA = DEFAULT_POINT;
  }

  if (pointB === void 0) {
    pointB = DEFAULT_POINT;
  }

  if (pointC === void 0) {
    pointC = DEFAULT_POINT;
  }

  // Law of cosines
  var seg1 = Math.sqrt(Math.pow(pointA.x - pointB.x, 2) + Math.pow(pointA.y - pointB.y, 2));
  var seg2 = Math.sqrt(Math.pow(pointA.x - pointC.x, 2) + Math.pow(pointA.y - pointC.y, 2));
  var seg3 = Math.sqrt(Math.pow(pointB.x - pointC.x, 2) + Math.pow(pointB.y - pointC.y, 2));
  var numerator = Math.pow(seg1, 2) + Math.pow(seg3, 2) - Math.pow(seg2, 2);
  var denominator = 2 * seg1 * seg3;
  return degrees(Math.acos(numerator / denominator));
};
/**
 *
 * @param {number} distance
 * @param {number} time
 * @returns
 */

export var velocity = function velocity(distance, time) {
  return distance / time;
};