mathleet/index.js

Library of helpful math utilities.

"use strict";

exports.__esModule = true;
exports.velocity = exports.angle = exports.radians = exports.degrees = exports.outside = exports.within = exports.rangeAvg = exports.sumAvg = exports.sum = exports.numMax = exports.numMin = exports.keyAvg = exports.keySum = exports.filterNumbers = void 0;

/**
 *
 * @param {any[]} items
 * @return {number[]}
 */
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}
 */


exports.filterNumbers = filterNumbers;

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}
 */


exports.keySum = keySum;

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


exports.keyAvg = keyAvg;

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


exports.numMin = numMin;

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}
 */


exports.numMax = numMax;

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}
 */


exports.sum = sum;

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}
 */


exports.sumAvg = sumAvg;

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);
};

exports.rangeAvg = rangeAvg;

var within = function within(value, target, offset) {
  if (offset === void 0) {
    offset = 0;
  }

  return value >= target - offset && value <= target + offset;
};

exports.within = within;

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}
 */


exports.outside = outside;

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


exports.degrees = degrees;

var radians = function radians(value) {
  return value * (Math.PI / 180);
};

exports.radians = radians;
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}
 */

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
 */


exports.angle = angle;

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

exports.velocity = velocity;