Merge branch 'develop' of https://github.com/variadicjs/variadic.js into develop

Author: khusbuchandra

.babelrc

@@ -0,0 +1,12 @@
+{
+    "presets": [
+        "babel-preset-env"
+    ],
+    "env": {
+        "production": {
+            "presets": [
+                "minify"
+            ]
+        }
+    }
+}

.eslintrc

@@ -1,5 +1,5 @@
 {
-  "extends": ["airbnb-standard"],
+  "extends": ["airbnb-base"],
   "rules": {
     "strict": 0,
     "no-restricted-syntax": [

.gitattributes

@@ -0,0 +1 @@
+*.js text eol=lf

.gitignore

@@ -63,6 +63,7 @@ typings/
 # coverall token
 .coveralls.yml
 
+dist
 .DS_Store
 untitled.sublime-project
 untitled.sublime-workspace

.npmignore

@@ -0,0 +1 @@
+!dist

index.js

@@ -21,5 +21,6 @@ module.exports = Object.assign(
   require('./lib/populationVariance.js'),
   require('./lib/sampleStandardDeviation.js'),
   require('./lib/sampleVariance.js'),
-  require('./lib/isPositiveInteger.js')
+  require('./lib/isPositiveInteger.js'),
+  require('./lib/isDecimal.js'),
 );

lib/average.js

@@ -1,17 +1,6 @@
 const { sum } = require('./sum');
 const { floatPrecise } = require('./floatPrecise');
 
-exports.average = (...params) => {
-  handleErrors(params);
-
-  const result = sum(...params) / params.length;
-
-  // I couldn't actually find any examples of float imprecision
-  // when dividing a float by a whole number
-  // so this might not be neccessary. I just put it in for safety's sake - jmbothe
-  return floatPrecise(result);
-};
-
 const handleErrors = (params) => {
   if (params.length === 0) throw new Error('Must provide one or more paramters');
   if (params.some(param => typeof param !== 'number')) {
@@ -23,3 +12,15 @@ const handleErrors = (params) => {
     throw new Error('Cannot reliably test primality of numbers larger than 9,007,199,254,740,991 or smaller than -9,007,199,254,740,991');
   }
 };
+
+exports.average = (...params) => {
+  handleErrors(params);
+
+  const result = sum(...params) / params.length;
+
+  // I couldn't actually find any examples of float imprecision
+  // when dividing a float by a whole number
+  // so this might not be neccessary. I just put it in for safety's sake - jmbothe
+  return floatPrecise(result);
+};
+

lib/isDecimal.js

@@ -0,0 +1,10 @@
+
+exports.isDecimal = (...params) => {
+  for (const param of params) {
+    // Only accept floating point numbers, infinite numbers can be allowed ie. repeating decimal
+    // A decimal is a number with digits 0-9, and a decimal point, applies to negative numbers also
+    // without a decimal point a number can be represented as a decimal, but wont use the case here
+    if (Number.isNaN(parseFloat(param)) || !/\d/g.test(param) || !/\./.test(param)) return false;
+  }
+  return true;
+};

lib/isPositiveInteger.js

@@ -8,7 +8,7 @@ exports.isPositiveInteger = (...params) => {
             // Is it positive?
             param <= 0 ||
             // maximum safe integer check
-            /// / https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
+            // / / https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
             param > Number.MAX_SAFE_INTEGER) {
       return false;
     }

lib/isPrime.js

@@ -1,30 +1,3 @@
-exports.isPrime = (...params) => {
-  if (params.length === 0) throw new Error('Must provide one or more paramters');
-  if (params.some(param => Number.isNaN(Number(param)))) throw new Error('One of your parameters does not evaluate to a number');
-  // JS can only safely represent and compare integers
-  // up to Number.MAX_SAFE_INTEGER: i.e., 9,007,199,254,740,991.
-  // This also covers checking if any of the parameters evaluates to Infinity
-  if (params.some(param => param > Number.MAX_SAFE_INTEGER)) {
-    throw new Error('Cannot reliably test primality of numbers larger than 9,007,199,254,740,991');
-  }
-  return params.every(testPrime);
-};
-// This method tests the primality of a number by trial division.
-// In other words, it attempts to divide the test number by a series integers.
-// If any of those integers turn out to be factors of the test number,
-// then we know the test number is composite: i.e., not prime.
-// the most brute force method is to simply divide the test number by every integer
-// smaller than itself, but we can use our knowledge of number properties to greatly
-// reduce the list of potential factors that we need to test against.
-const testPrime = (num) => {
-  // num % 1 checks that num is an integer.
-  // There are no prime numbers less than 2, hence check for num < 2.
-  if (num % 1 || num < 2) return false;
-  // if the least factor of num is itself (aside from 1), then num is prime.
-  if (num === leastFactor(num)) return true;
-  return false;
-};
-
 const leastFactor = (num) => {
   // Check if 2, 3, or 5 is a factor of num AND
   // eliminate from future consideration all possible factors that are multiples of 2, 3, and 5.
@@ -46,3 +19,31 @@ const leastFactor = (num) => {
   }
   return num;
 };
+
+// This method tests the primality of a number by trial division.
+// In other words, it attempts to divide the test number by a series integers.
+// If any of those integers turn out to be factors of the test number,
+// then we know the test number is composite: i.e., not prime.
+// the most brute force method is to simply divide the test number by every integer
+// smaller than itself, but we can use our knowledge of number properties to greatly
+// reduce the list of potential factors that we need to test against.
+const testPrime = (num) => {
+  // num % 1 checks that num is an integer.
+  // There are no prime numbers less than 2, hence check for num < 2.
+  if (num % 1 || num < 2) return false;
+  // if the least factor of num is itself (aside from 1), then num is prime.
+  if (num === leastFactor(num)) return true;
+  return false;
+};
+
+exports.isPrime = (...params) => {
+  if (params.length === 0) throw new Error('Must provide one or more paramters');
+  if (params.some(param => Number.isNaN(Number(param)))) throw new Error('One of your parameters does not evaluate to a number');
+  // JS can only safely represent and compare integers
+  // up to Number.MAX_SAFE_INTEGER: i.e., 9,007,199,254,740,991.
+  // This also covers checking if any of the parameters evaluates to Infinity
+  if (params.some(param => param > Number.MAX_SAFE_INTEGER)) {
+    throw new Error('Cannot reliably test primality of numbers larger than 9,007,199,254,740,991');
+  }
+  return params.every(testPrime);
+};

lib/median.js

@@ -1,5 +1,17 @@
 const { average } = require('./average');
 
+const handleErrors = (params) => {
+  if (params.length === 0) throw new Error('Must provide one or more paramters');
+  if (params.some(param => typeof param !== 'number')) {
+    throw new Error('One of your parameters does not evaluate to a number');
+  }
+  // JS can only safely represent and compare integers between
+  // Number.MAX_SAFE_INTEGER and Number.MAX_SAFE_INTEGER
+  if (params.some(param => param > Number.MAX_SAFE_INTEGER || param < Number.MIN_SAFE_INTEGER)) {
+    throw new Error('Cannot reliably test primality of numbers larger than 9,007,199,254,740,991 or smaller than -9,007,199,254,740,991');
+  }
+};
+
 exports.median = (...params) => {
   handleErrors(params);
 
@@ -8,21 +20,9 @@ exports.median = (...params) => {
 
   // if length of list is even, take the average of the middle two numbers
   if (n % 2 === 0) {
-    return average(sorted[n / 2 - 1], sorted[n / 2]);
+    return average(sorted[(n / 2) - 1], sorted[n / 2]);
   }
 
   // else just return the middle number
   return sorted[Math.floor(n / 2)];
 };
-
-const handleErrors = (params) => {
-  if (params.length === 0) throw new Error('Must provide one or more paramters');
-  if (params.some(param => typeof param !== 'number')) {
-    throw new Error('One of your parameters does not evaluate to a number');
-  }
-  // JS can only safely represent and compare integers between
-  // Number.MAX_SAFE_INTEGER and Number.MAX_SAFE_INTEGER
-  if (params.some(param => param > Number.MAX_SAFE_INTEGER || param < Number.MIN_SAFE_INTEGER)) {
-    throw new Error('Cannot reliably test primality of numbers larger than 9,007,199,254,740,991 or smaller than -9,007,199,254,740,991');
-  }
-};

lib/mode.js

@@ -1,10 +1,26 @@
+const handleErrors = (params) => {
+  if (params.length === 0) throw new Error('Must provide one or more paramters');
+  if (params.some(param => typeof param !== 'number')) {
+    throw new Error('One of your parameters does not evaluate to a number');
+  }
+  // JS can only safely represent and compare integers between
+  // Number.MAX_SAFE_INTEGER and Number.MAX_SAFE_INTEGER
+  if (params.some(param => param > Number.MAX_SAFE_INTEGER || param < Number.MIN_SAFE_INTEGER)) {
+    throw new Error('Cannot reliably test primality of numbers larger than 9,007,199,254,740,991 or smaller than -9,007,199,254,740,991');
+  }
+};
+
 exports.mode = (...params) => {
   handleErrors(params);
 
   // create a list of the values and frequencies of params
   const valFreq = params.reduce((acc, cur) => {
     const num = acc.find(obj => obj.value === cur);
-    num ? num.frequency += 1 : acc.push({ value: cur, frequency: 1 });
+    if (num) {
+      num.frequency += 1;
+    } else {
+      acc.push({ value: cur, frequency: 1 });
+    }
     return acc;
   }, []);
 
@@ -25,14 +41,3 @@ exports.mode = (...params) => {
     .map(num => num.value);
 };
 
-const handleErrors = (params) => {
-  if (params.length === 0) throw new Error('Must provide one or more paramters');
-  if (params.some(param => typeof param !== 'number')) {
-    throw new Error('One of your parameters does not evaluate to a number');
-  }
-  // JS can only safely represent and compare integers between
-  // Number.MAX_SAFE_INTEGER and Number.MAX_SAFE_INTEGER
-  if (params.some(param => param > Number.MAX_SAFE_INTEGER || param < Number.MIN_SAFE_INTEGER)) {
-    throw new Error('Cannot reliably test primality of numbers larger than 9,007,199,254,740,991 or smaller than -9,007,199,254,740,991');
-  }
-};

lib/populationStandardDeviation.js

@@ -1,12 +1,6 @@
 const { populationVariance } = require('./populationVariance');
 const { floatPrecise } = require('./floatPrecise');
 
-exports.populationStandardDeviation = (...params) => {
-  handleErrors(params);
-
-  return floatPrecise(Math.sqrt(populationVariance(...params)));
-};
-
 const handleErrors = (params) => {
   if (params.length <= 1) throw new Error('Must provide two or more paramters');
   if (params.some(param => typeof param !== 'number')) {
@@ -18,3 +12,10 @@ const handleErrors = (params) => {
     throw new Error('Cannot reliably test primality of numbers larger than 9,007,199,254,740,991 or smaller than -9,007,199,254,740,991');
   }
 };
+
+exports.populationStandardDeviation = (...params) => {
+  handleErrors(params);
+
+  return floatPrecise(Math.sqrt(populationVariance(...params)));
+};
+

lib/populationVariance.js

@@ -1,16 +1,6 @@
 const { average } = require('./average');
 const { floatPrecise } = require('./floatPrecise');
 
-exports.populationVariance = (...params) => {
-  handleErrors(params);
-
-  const mean = average(...params);
-  // const sum = params.reduce((acc, v) => acc + ((v - mean) ** 2), 0);
-  const sum = params.reduce((acc, v) => acc + Math.pow(v - mean, 2), 0);
-
-  return floatPrecise(sum / params.length);
-};
-
 const handleErrors = (params) => {
   if (params.length <= 1) throw new Error('Must provide two or more paramters');
   if (params.some(param => typeof param !== 'number')) {
@@ -22,3 +12,14 @@ const handleErrors = (params) => {
     throw new Error('Cannot reliably test primality of numbers larger than 9,007,199,254,740,991 or smaller than -9,007,199,254,740,991');
   }
 };
+
+exports.populationVariance = (...params) => {
+  handleErrors(params);
+
+  const mean = average(...params);
+  // const sum = params.reduce((acc, v) => acc + ((v - mean) ** 2), 0);
+  const sum = params.reduce((acc, v) => acc + Math.pow(v - mean, 2), 0);
+
+  return floatPrecise(sum / params.length);
+};
+

lib/sampleStandardDeviation.js

@@ -1,12 +1,6 @@
 const { sampleVariance } = require('./sampleVariance');
 const { floatPrecise } = require('./floatPrecise');
 
-exports.sampleStandardDeviation = (...params) => {
-  handleErrors(params);
-
-  return floatPrecise(Math.sqrt(sampleVariance(...params)));
-};
-
 const handleErrors = (params) => {
   if (params.length <= 1) throw new Error('Must provide two or more paramters');
   if (params.some(param => typeof param !== 'number')) {
@@ -18,3 +12,9 @@ const handleErrors = (params) => {
     throw new Error('Cannot reliably test primality of numbers larger than 9,007,199,254,740,991 or smaller than -9,007,199,254,740,991');
   }
 };
+
+exports.sampleStandardDeviation = (...params) => {
+  handleErrors(params);
+
+  return floatPrecise(Math.sqrt(sampleVariance(...params)));
+};

lib/sampleVariance.js

@@ -1,16 +1,6 @@
 const { average } = require('./average');
 const { floatPrecise } = require('./floatPrecise');
 
-exports.sampleVariance = (...params) => {
-  handleErrors(params);
-
-  const mean = average(...params);
-  // const sum = params.reduce((acc, v) => acc + ((v - mean) ** 2), 0);
-  const sum = params.reduce((acc, v) => acc + Math.pow(v - mean, 2), 0);
-
-  return floatPrecise(sum / (params.length - 1));
-};
-
 const handleErrors = (params) => {
   if (params.length <= 1) throw new Error('Must provide two or more paramters');
   if (params.some(param => typeof param !== 'number')) {
@@ -22,3 +12,14 @@ const handleErrors = (params) => {
     throw new Error('Cannot reliably test primality of numbers larger than 9,007,199,254,740,991 or smaller than -9,007,199,254,740,991');
   }
 };
+
+exports.sampleVariance = (...params) => {
+  handleErrors(params);
+
+  const mean = average(...params);
+  // const sum = params.reduce((acc, v) => acc + ((v - mean) ** 2), 0);
+  const sum = params.reduce((acc, v) => acc + Math.pow(v - mean, 2), 0);
+
+  return floatPrecise(sum / (params.length - 1));
+};
+

lib/sum.js

@@ -1,13 +1,5 @@
 const { floatPrecise } = require('./floatPrecise');
 
-exports.sum = (...params) => {
-  handleErrors(params);
-
-  const result = params.reduce((prev, cur) => prev + cur, 0);
-
-  return floatPrecise(result);
-};
-
 const handleErrors = (params) => {
   if (params.length === 0) throw new Error('Must provide one or more paramters');
   if (params.some(param => typeof param !== 'number')) {
@@ -19,3 +11,11 @@ const handleErrors = (params) => {
     throw new Error('Cannot reliably test primality of numbers larger than 9,007,199,254,740,991 or smaller than -9,007,199,254,740,991');
   }
 };
+
+exports.sum = (...params) => {
+  handleErrors(params);
+
+  const result = params.reduce((prev, cur) => prev + cur, 0);
+
+  return floatPrecise(result);
+};