diff options
Diffstat (limited to '')
| -rw-r--r-- | js/dojo-1.6/dojox/math/stats.js | 204 |
1 files changed, 204 insertions, 0 deletions
diff --git a/js/dojo-1.6/dojox/math/stats.js b/js/dojo-1.6/dojox/math/stats.js new file mode 100644 index 0000000..9fb61fa --- /dev/null +++ b/js/dojo-1.6/dojox/math/stats.js @@ -0,0 +1,204 @@ +/*
+ Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
+ Available via Academic Free License >= 2.1 OR the modified BSD license.
+ see: http://dojotoolkit.org/license for details
+*/
+
+
+if(!dojo._hasResource["dojox.math.stats"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.math.stats"] = true;
+dojo.provide("dojox.math.stats");
+
+
+dojo.getObject("math.stats", true, dojox);
+
+(function(){
+ var st = dojox.math.stats;
+ dojo.mixin(st, {
+ sd: function(/* Number[] */a){
+ // summary:
+ // Returns the standard deviation of the passed arguments.
+ return Math.sqrt(st.variance(a)); // Number
+ },
+
+ variance: function(/* Number[] */a){
+ // summary:
+ // Find the variance in the passed array of numbers.
+ var mean=0, squares=0;
+ dojo.forEach(a, function(item){
+ mean+=item;
+ squares+=Math.pow(item,2);
+ });
+ return (squares/a.length)-Math.pow(mean/a.length, 2); // Number
+ },
+
+ bestFit: function(/* Object[] || Number[] */a, /* String? */xProp, /* String? */yProp){
+ // summary:
+ // Calculate the slope and intercept in a linear fashion. An array
+ // of objects is expected; optionally you can pass in the property
+ // names for "x" and "y", else x/y is used as the default. If you
+ // pass an array of numbers, it will be mapped to a set of {x,y} objects
+ // where x = the array index.
+ xProp = xProp || "x", yProp = yProp || "y";
+ if(a[0] !== undefined && typeof(a[0]) == "number"){
+ // this is an array of numbers, so use the index as x.
+ a = dojo.map(a, function(item, idx){
+ return { x: idx, y: item };
+ });
+ }
+
+ var sx = 0, sy = 0, sxx = 0, syy = 0, sxy = 0, stt = 0, sts = 0, n = a.length, t;
+ for(var i=0; i<n; i++){
+ sx += a[i][xProp];
+ sy += a[i][yProp];
+ sxx += Math.pow(a[i][xProp], 2);
+ syy += Math.pow(a[i][yProp], 2);
+ sxy += a[i][xProp] * a[i][yProp];
+ }
+
+ // we use the following because it's more efficient and accurate for determining the slope.
+ for(i=0; i<n; i++){
+ t = a[i][xProp] - sx/n;
+ stt += t*t;
+ sts += t*a[i][yProp];
+ }
+ var slope = sts/(stt||1); // prevent divide by zero.
+
+ // get Pearson's R
+ var d = Math.sqrt((sxx - Math.pow(sx,2)/n) * (syy - Math.pow(sy,2)/n));
+ if(d === 0){
+ throw new Error("dojox.math.stats.bestFit: the denominator for Pearson's R is 0.");
+ }
+
+ var r = (sxy-(sx*sy/n)) / d;
+ var r2 = Math.pow(r, 2);
+ if(slope < 0){
+ r = -r;
+ }
+
+ // to use: y = slope*x + intercept;
+ return { // Object
+ slope: slope,
+ intercept: (sy - sx*slope)/(n||1),
+ r: r,
+ r2: r2
+ };
+ },
+
+ forecast: function(/* Object[] || Number[] */a, /* Number */x, /* String? */xProp, /* String? */yProp){
+ // summary:
+ // Using the bestFit algorithm above, find y for the given x.
+ var fit = st.bestFit(a, xProp, yProp);
+ return (fit.slope * x) + fit.intercept; // Number
+ },
+
+ mean: function(/* Number[] */a){
+ // summary:
+ // Returns the mean value in the passed array.
+ var t=0;
+ dojo.forEach(a, function(v){
+ t += v;
+ });
+ return t / Math.max(a.length, 1); // Number
+ },
+
+ min: function(/* Number[] */a){
+ // summary:
+ // Returns the min value in the passed array.
+ return Math.min.apply(null, a); // Number
+ },
+
+ max: function(/* Number[] */a){
+ // summary:
+ // Returns the max value in the passed array.
+ return Math.max.apply(null, a); // Number
+ },
+
+ median: function(/* Number[] */a){
+ // summary:
+ // Returns the value closest to the middle from a sorted version of the passed array.
+ var t = a.slice(0).sort(function(a, b){ return a - b; });
+ return (t[Math.floor(a.length/2)] + t[Math.ceil(a.length/2)])/2; // Number
+ },
+
+ mode: function(/* Number[] */a){
+ // summary:
+ // Returns the mode from the passed array (number that appears the most often).
+ // This is not the most efficient method, since it requires a double scan, but
+ // is ensures accuracy.
+ var o = {}, r = 0, m = Number.MIN_VALUE;
+ dojo.forEach(a, function(v){
+ (o[v]!==undefined)?o[v]++:o[v]=1;
+ });
+
+ // we did the lookup map because we need the number that appears the most.
+ for(var p in o){
+ if(m < o[p]){
+ m = o[p], r = p;
+ }
+ }
+ return r; // Number
+ },
+
+ sum: function(/* Number[] */a){
+ // summary:
+ // Return the sum of all the numbers in the passed array. Does
+ // not check to make sure values within a are NaN (should simply
+ // return NaN).
+ var sum = 0;
+ dojo.forEach(a, function(n){
+ sum += n;
+ });
+ return sum; // Number
+ },
+
+ approxLin: function(a, pos){
+ // summary:
+ // Returns a linearly approximated value from an array using
+ // a normalized float position value.
+ // a: Number[]:
+ // a sorted numeric array to be used for the approximation.
+ // pos: Number:
+ // a position number from 0 to 1. If outside of this range it
+ // will be clamped.
+ // returns: Number
+ var p = pos * (a.length - 1), t = Math.ceil(p), f = t - 1;
+ if(f < 0){ return a[0]; }
+ if(t >= a.length){ return a[a.length - 1]; }
+ return a[f] * (t - p) + a[t] * (p - f); // Number
+ },
+
+ summary: function(a, alreadySorted){
+ // summary:
+ // Returns a non-parametric collection of summary statistics:
+ // the classic five-number summary extended to the Bowley's
+ // seven-figure summary.
+ // a: Number[]:
+ // a numeric array to be appraised.
+ // alreadySorted: Boolean?:
+ // a Boolean flag to indicated that the array is already sorted.
+ // This is an optional flag purely to improve the performance.
+ // If skipped, the array will be assumed unsorted.
+ // returns: Object
+ if(!alreadySorted){
+ a = a.slice(0); // copy the array
+ a.sort(function(a, b){ return a - b; }); // sort it properly
+ }
+ var l = st.approxLin,
+ result = {
+ // the five-number summary
+ min: a[0], // minimum
+ p25: l(a, 0.25), // lower quartile
+ med: l(a, 0.5), // median
+ p75: l(a, 0.75), // upper quartile
+ max: a[a.length - 1], // maximum
+ // extended to the Bowley's seven-figure summary
+ p10: l(a, 0.1), // first decile
+ p90: l(a, 0.9) // last decile
+ };
+ return result; // Object
+ }
+ });
+})();
+
+}
|