math-utils.js

math-utils-beta.js

"Se A é o total, e tenho B, quantos correspondem a 50?"
"Se 'a' é um valor e 'b' é o total, qual a porcentagem que 'a' representa de 'b'?"

// CANSEI CONTINUAR DEPOIS
// math-utils.js v1
Math.avg = (...numbers) => Math.sum(...numbers) / numbers.length
Math.distance = (a, b) => Math.abs(a - b)
Math.isApproximate = (a, b, tolerance = 0) => Math.abs(a - b) <= tolerance
Math.isBetween = (number, min, max) => number >= min && number <= max
Math.isEven = number => number % 2 === 0
Math.isOdd = number => number % 2 !== 0
Math.limiter = (number, min, max) => Math.max(min, Math.min(number, max))
Math.percentOf = (a, b) => (a / b) * 100
Math.proportion = (a, b) => a / b
Math.randomBetween = (min, max) => min + Math.floor(Math.random() * (max + 1 - min))
Math.ruleOfThree = (a, b, c) => c * b / a
Math.toNumber = (...numbers) => numbers.length > 1 ? numbers.map(number => Number(number)) : Number(numbers)
Math.sort = (...numbers) => numbers.sort((a, b) => a >= b ? 1 : -1)
Math.sum = (...numbers) => numbers.reduce((a, b) => a + b, 0)
Math.toFixed = (numbers, decimalPlaces) => numbers.map(n => n.toFixed(decimalPlaces))

Math.toPrecision = (numbers, precision) => {
	if (Array.isArray(numbers)) {
		return numbers.map(number => Number(numbers.toPrecision(precision)))
	}
	return Number(numbers.toPrecision(precision))
}

// alias
Math.roundUp = numbers => {
	if (Array.isArray(numbers)) {
		return numbers.map(number => Math.ceil(number))
	}
	return Math.ceil(numbers)
}

Math.roundDown = numbers => {
	if (Array.isArray(numbers)) {
		return numbers.map(number => Math.floor(number))
	}
	return Math.floor(numbers)
}

Math.findMin = (...numbers) => {
	if (Array.isArray(numbers[0])) {
		return numbers[0].map(number => Math.min(...numbers))
	}
	return Math.min(...numbers)
}

Math.findMax = (...numbers) => {
	if (Array.isArray(numbers[0])) {
		return numbers[0].map(number => Math.max(...numbers))
	}
	return Math.max(...numbers)
}


function isInteger(value) {
    return Number.isInteger(value);
}

math-utils-old.js

// math-utils.js v1.0.5
// math-sum.js v2
Math.sum = Math.sum || function(numbers) { // arguments or one array
	if (typeof(numbers) === 'number') {
		numbers = Array.prototype.slice.call(arguments);
	};
	let sum = 0;
	for (let i = 0; i < numbers.length; i++) {
		sum += numbers[i];
	};
	return sum;
};

// math-avg.js v2, dependencies: Math.sum
Math.avg = Math.avg || function(numbers) { // arguments or one array
	if (typeof(numbers) === 'number') {
		numbers = Array.prototype.slice.call(arguments);
	};
	const sum = Math.sum(numbers);
	const avg = sum / arguments.length;
	return avg;
};

// math-sort.js v1
Math.sort = Math.sort || function(numbers) { // arguments or one array
	if (typeof(numbers) === 'number') {
		numbers = Array.prototype.slice.call(arguments);
	};
	return numbers.sort(function(a, b) {
		return a > b ? 1 : a === b ? 0 : -1;
	});
};

// math-approximate.js v1, dependencies: Math.sort
Math.approximate = Math.approximate || function(value, numbers, preference) { // number, array, 0-1 (smaller or biggest)
	if (preference === undefined) {
		preference = 0;
	};
	if (numbers === undefined || numbers.length === 0) {
		return null;
	};
	numbers.push(value);
	numbers = Math.sort(numbers);
	let indexOf = numbers.indexOf(value);
	numbers = numbers.slice(Math.max(0, indexOf - 1), Math.min(numbers.length, indexOf + 2))
	switch (numbers.length) {
		case 1:
			return numbers[0];
			break;
		case 2:
			indexOf = numbers.indexOf(value);
			return indexOf === 0 ? numbers[1] : numbers[0];
			break;
		case 3:
			const diff1 = numbers[1] - numbers[0];
			const diff2 = numbers[2] - numbers[1];
			if (diff1 === diff2) {
				return preference ? numbers[2] : numbers[0];
			};
			return diff1 < diff2 ? numbers[0] : numbers[2];
	};
};

// math-limiter.js v1
Math.limiter = Math.limiter || function(value, min, max) {
	const tmp = min
	min = Math.min(min, max)
	max = Math.max(tmp, max)
	return Math.max(min, Math.min(value, max))
};

// math-between.js v1
Math.between = Math.between || function(value, min, max) {
	return value >= Math.min(min, max) && value <= Math.max(min, max);
};

// math-random-between.js v1
Math.randomBetween = Math.randomBetween || function(min, max) {
	[min, max] = [Math.min(min, max), Math.max(min, max)];
	max = max + 1 - min;
	return min + Math.floor(Math.random() * max);
}

// math-is-odd.js v1
Math.isOdd = Math.isOdd || function(value) {
	return value % 2 !== 0;
};

// math-is-even.js v1
Math.isEven = Math.isEven || function(value) {
	return value % 2 === 0;
};

Math.sum
Math.avg
Math.sort
Math.approximate
Math.limiter