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