Release 1.5.0

dist/jstat.js

@@ -546,6 +546,19 @@ jStat.max = function max(arr) {
 };
 
 
+// unique values of an array
+jStat.unique = function unique(arr) {
+  var hash = {}, _arr = [];
+  for(var i = 0; i < arr.length; i++) {
+    if (!hash[arr[i]]) {
+      hash[arr[i]] = true;
+      _arr.push(arr[i]);
+    }
+  }
+  return _arr;
+};
+
+
 // mean value of an array
 jStat.mean = function mean(arr) {
   return jStat.sum(arr) / arr.length;
@@ -598,6 +611,25 @@ jStat.diff = function diff(arr) {
 };
 
 
+// ranks of an array
+jStat.rank = function (arr) {
+  var arrlen = arr.length;
+  var sorted = arr.slice().sort(ascNum);
+  var ranks = new Array(arrlen);
+  for (var i = 0; i < arrlen; i++) {
+    var first = sorted.indexOf(arr[i]);
+    var last = sorted.lastIndexOf(arr[i]);
+    if (first === last) {
+      var val = first;
+    } else {
+      var val = (first + last) / 2;
+    }
+    ranks[i] = val + 1;
+  }
+  return ranks;
+};
+
+
 // mode of an array
 // if there are multiple modes of an array, return all of them
 // is this the appropriate way of handling it?
@@ -644,6 +676,16 @@ jStat.variance = function variance(arr, flag) {
   return jStat.sumsqerr(arr) / (arr.length - (flag ? 1 : 0));
 };
 
+// deviation of an array
+jStat.deviation = function (arr) {
+  var mean = jStat.mean(arr);
+  var arrlen = arr.length;
+  var dev = new Array(arrlen);
+  for (var i = 0; i < arrlen; i++) {
+    dev[i] = arr[i] - mean;
+  }
+  return dev;
+};
 
 // standard deviation of an array
 // flag = true indicates sample instead of population
@@ -798,37 +840,21 @@ jStat.corrcoeff = function corrcoeff(arr1, arr2) {
 };
 
   // (spearman's) rank correlation coefficient, sp
-jStat.spearmancoeff = function spearmancoeff(arr1, arr2) {
-  sortfunction = function(a,b) { return a[1]-b[1]};
-  var npoints = arr1.length;
-  if (arr1.length != arr2.length)
-    return 0.0;
-  if (npoints == 0)
-    return 0.0;
-  var arr1cp = new Array(npoints);
-  var arr2cp = new Array(npoints);
-  var arr1rank = new Array(npoints);
-  var arr2rank = new Array(npoints);
-  var arr1cps;
-  var arr2cps;
-  var dsqr = 0;
-  var i;
-  for (i = 0; i < npoints; i++){
-    arr1cp[i] = [i,arr1[i]];
-    arr2cp[i] = [i,arr2[i]];
-  }
-  var arr1cps = arr1cp.sort(sortfunction);
-  var arr2cps = arr2cp.sort(sortfunction);
-  for (i = 0; i < npoints; i++){
-    arr1rank[arr1cps[i][0]] = i;
-    arr2rank[arr2cps[i][0]] = i;
-  }
-  dsqr = 0;
-  for (i = 0; i < npoints; i++){
-    dsqr  += (arr1rank[i] - arr2rank[i])*(arr1rank[i] - arr2rank[i]);
-  }
-  return 1 - dsqr*6.0/(npoints*(npoints*npoints-1))
-};
+jStat.spearmancoeff =  function (arr1, arr2) {
+  arr1 = jStat.rank(arr1);
+  arr2 = jStat.rank(arr2);
+  var arr1dev = jStat.deviation(arr1);
+  var arr2dev = jStat.deviation(arr2);
+  return jStat.sum(arr1dev.map(function (x, i) {
+    return x * arr2dev[i];
+  })) /
+  Math.sqrt(jStat.sum(arr1dev.map(function (x) {
+    return Math.pow(x, 2);
+    })) * jStat.sum(arr2dev.map(function (x) {
+      return Math.pow(x, 2);
+  }))
+  );
+}
 
 
 // statistical standardized moments (general form of skew/kurt)
@@ -932,9 +958,9 @@ var jProto = jStat.prototype;
       return jStat[passfunc](this[0], fullbool);
     };
   })(funcs[i]);
-})(('sum sumsqrd sumsqerr sumrow product min max mean meansqerr geomean ' +
-    'median diff mode range variance stdev meandev meddev coeffvar quartiles ' +
-    'histogram skewness kurtosis').split(' '));
+})(('sum sumsqrd sumsqerr sumrow product min max unique mean meansqerr ' +
+    'geomean median diff rank mode range variance deviation stdev meandev ' +
+    'meddev coeffvar quartiles histogram skewness kurtosis').split(' '));
 
 
 // Extend jProto with functions that take arguments. Operations on matrices are
@@ -2522,13 +2548,17 @@ jStat.extend(jStat.triangular, {
 var push = Array.prototype.push;
 var isArray = jStat.utils.isArray;
 
+function isUsable(arg) {
+  return isArray(arg) || arg instanceof jStat;
+}
+
 jStat.extend({
 
   // add a vector/matrix to a vector/matrix or scalar
   add: function add(arr, arg) {
     // check if arg is a vector or scalar
-    if (isArray(arg)) {
-      if (!isArray(arg[0])) arg = [ arg ];
+    if (isUsable(arg)) {
+      if (!isUsable(arg[0])) arg = [ arg ];
       return jStat.map(arr, function(value, row, col) {
         return value + arg[row][col];
       });
@@ -2539,8 +2569,8 @@ jStat.extend({
   // subtract a vector or scalar from the vector
   subtract: function subtract(arr, arg) {
     // check if arg is a vector or scalar
-    if (isArray(arg)) {
-      if (!isArray(arg[0])) arg = [ arg ];
+    if (isUsable(arg)) {
+      if (!isUsable(arg[0])) arg = [ arg ];
       return jStat.map(arr, function(value, row, col) {
         return value - arg[row][col] || 0;
       });
@@ -2550,8 +2580,8 @@ jStat.extend({
 
   // matrix division
   divide: function divide(arr, arg) {
-    if (isArray(arg)) {
-      if (!isArray(arg[0])) arg = [ arg ];
+    if (isUsable(arg)) {
+      if (!isUsable(arg[0])) arg = [ arg ];
       return jStat.multiply(arr, jStat.inv(arg));
     }
     return jStat.map(arr, function(value) { return value / arg; });
@@ -2562,9 +2592,9 @@ jStat.extend({
     var row, col, nrescols, sum,
     nrow = arr.length,
     ncol = arr[0].length,
-    res = jStat.zeros(nrow, nrescols = (isArray(arg)) ? arg[0].length : ncol),
+    res = jStat.zeros(nrow, nrescols = (isUsable(arg)) ? arg[0].length : ncol),
     rescols = 0;
-    if (isArray(arg)) {
+    if (isUsable(arg)) {
       for (; rescols < nrescols; rescols++) {
         for (row = 0; row < nrow; row++) {
           sum = 0;
@@ -2580,8 +2610,8 @@ jStat.extend({
 
   // Returns the dot product of two matricies
   dot: function dot(arr, arg) {
-    if (!isArray(arr[0])) arr = [ arr ];
-    if (!isArray(arg[0])) arg = [ arg ];
+    if (!isUsable(arr[0])) arr = [ arr ];
+    if (!isUsable(arg[0])) arg = [ arg ];
     // convert column to row vector
     var left = (arr[0].length === 1 && arr.length !== 1) ? jStat.transpose(arr) : arr,
     right = (arg[0].length === 1 && arg.length !== 1) ? jStat.transpose(arg) : arg,
@@ -2628,7 +2658,7 @@ jStat.extend({
     // check the p-value of the norm, and set for most common case
     if (isNaN(p)) p = 2;
     // check if multi-dimensional array, and make vector correction
-    if (isArray(arr[0])) arr = arr[0];
+    if (isUsable(arr[0])) arr = arr[0];
     // vector norm
     for (; i < arr.length; i++) {
       nnorm += Math.pow(Math.abs(arr[i]), p);