Mercurial > hg > index.fcgi > www > www-1

annotate gtc/simple-statistics.js @ 132:99e4022eae52

find changesets by author, revision, files, or words in the commit message
pics3: add Dockerfile and requirements.pip
author paulo
date Thu, 20 Jan 2022 01:28:46 -0800
parents
children
rev   line source
paulo@89 1 (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.ss = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
paulo@89 2 /* @flow */
paulo@89 3 'use strict';
paulo@89 4
paulo@89 5 // # simple-statistics
paulo@89 6 //
paulo@89 7 // A simple, literate statistics system.
paulo@89 8
paulo@89 9 var ss = module.exports = {};
paulo@89 10
paulo@89 11 // Linear Regression
paulo@89 12 ss.linearRegression = require(21);
paulo@89 13 ss.linearRegressionLine = require(22);
paulo@89 14 ss.standardDeviation = require(54);
paulo@89 15 ss.rSquared = require(43);
paulo@89 16 ss.mode = require(32);
paulo@89 17 ss.modeSorted = require(33);
paulo@89 18 ss.min = require(29);
paulo@89 19 ss.max = require(23);
paulo@89 20 ss.minSorted = require(30);
paulo@89 21 ss.maxSorted = require(24);
paulo@89 22 ss.sum = require(56);
paulo@89 23 ss.sumSimple = require(58);
paulo@89 24 ss.product = require(39);
paulo@89 25 ss.quantile = require(40);
paulo@89 26 ss.quantileSorted = require(41);
paulo@89 27 ss.iqr = ss.interquartileRange = require(19);
paulo@89 28 ss.medianAbsoluteDeviation = ss.mad = require(27);
paulo@89 29 ss.chunk = require(8);
paulo@89 30 ss.shuffle = require(51);
paulo@89 31 ss.shuffleInPlace = require(52);
paulo@89 32 ss.sample = require(45);
paulo@89 33 ss.ckmeans = require(9);
paulo@89 34 ss.uniqueCountSorted = require(61);
paulo@89 35 ss.sumNthPowerDeviations = require(57);
paulo@89 36 ss.equalIntervalBreaks = require(14);
paulo@89 37
paulo@89 38 // sample statistics
paulo@89 39 ss.sampleCovariance = require(47);
paulo@89 40 ss.sampleCorrelation = require(46);
paulo@89 41 ss.sampleVariance = require(50);
paulo@89 42 ss.sampleStandardDeviation = require(49);
paulo@89 43 ss.sampleSkewness = require(48);
paulo@89 44
paulo@89 45 // combinatorics
paulo@89 46 ss.permutationsHeap = require(36);
paulo@89 47 ss.combinations = require(10);
paulo@89 48 ss.combinationsReplacement = require(11);
paulo@89 49
paulo@89 50 // measures of centrality
paulo@89 51 ss.geometricMean = require(17);
paulo@89 52 ss.harmonicMean = require(18);
paulo@89 53 ss.mean = ss.average = require(25);
paulo@89 54 ss.median = require(26);
paulo@89 55 ss.medianSorted = require(28);
paulo@89 56
paulo@89 57 ss.rootMeanSquare = ss.rms = require(44);
paulo@89 58 ss.variance = require(62);
paulo@89 59 ss.tTest = require(59);
paulo@89 60 ss.tTestTwoSample = require(60);
paulo@89 61 // ss.jenks = require('./src/jenks');
paulo@89 62
paulo@89 63 // Classifiers
paulo@89 64 ss.bayesian = require(2);
paulo@89 65 ss.perceptron = require(35);
paulo@89 66
paulo@89 67 // Distribution-related methods
paulo@89 68 ss.epsilon = require(13); // We make ε available to the test suite.
paulo@89 69 ss.factorial = require(16);
paulo@89 70 ss.bernoulliDistribution = require(3);
paulo@89 71 ss.binomialDistribution = require(4);
paulo@89 72 ss.poissonDistribution = require(37);
paulo@89 73 ss.chiSquaredGoodnessOfFit = require(7);
paulo@89 74
paulo@89 75 // Normal distribution
paulo@89 76 ss.zScore = require(63);
paulo@89 77 ss.cumulativeStdNormalProbability = require(12);
paulo@89 78 ss.standardNormalTable = require(55);
paulo@89 79 ss.errorFunction = ss.erf = require(15);
paulo@89 80 ss.inverseErrorFunction = require(20);
paulo@89 81 ss.probit = require(38);
paulo@89 82 ss.mixin = require(31);
paulo@89 83
paulo@89 84 // Root-finding methods
paulo@89 85 ss.bisect = require(5);
paulo@89 86
paulo@89 87 },{"10":10,"11":11,"12":12,"13":13,"14":14,"15":15,"16":16,"17":17,"18":18,"19":19,"2":2,"20":20,"21":21,"22":22,"23":23,"24":24,"25":25,"26":26,"27":27,"28":28,"29":29,"3":3,"30":30,"31":31,"32":32,"33":33,"35":35,"36":36,"37":37,"38":38,"39":39,"4":4,"40":40,"41":41,"43":43,"44":44,"45":45,"46":46,"47":47,"48":48,"49":49,"5":5,"50":50,"51":51,"52":52,"54":54,"55":55,"56":56,"57":57,"58":58,"59":59,"60":60,"61":61,"62":62,"63":63,"7":7,"8":8,"9":9}],2:[function(require,module,exports){
paulo@89 88 'use strict';
paulo@89 89 /* @flow */
paulo@89 90
paulo@89 91 /**
paulo@89 92 * [Bayesian Classifier](http://en.wikipedia.org/wiki/Naive_Bayes_classifier)
paulo@89 93 *
paulo@89 94 * This is a naïve bayesian classifier that takes
paulo@89 95 * singly-nested objects.
paulo@89 96 *
paulo@89 97 * @class
paulo@89 98 * @example
paulo@89 99 * var bayes = new BayesianClassifier();
paulo@89 100 * bayes.train({
paulo@89 101 * species: 'Cat'
paulo@89 102 * }, 'animal');
paulo@89 103 * var result = bayes.score({
paulo@89 104 * species: 'Cat'
paulo@89 105 * })
paulo@89 106 * // result
paulo@89 107 * // {
paulo@89 108 * // animal: 1
paulo@89 109 * // }
paulo@89 110 */
paulo@89 111 function BayesianClassifier() {
paulo@89 112 // The number of items that are currently
paulo@89 113 // classified in the model
paulo@89 114 this.totalCount = 0;
paulo@89 115 // Every item classified in the model
paulo@89 116 this.data = {};
paulo@89 117 }
paulo@89 118
paulo@89 119 /**
paulo@89 120 * Train the classifier with a new item, which has a single
paulo@89 121 * dimension of Javascript literal keys and values.
paulo@89 122 *
paulo@89 123 * @param {Object} item an object with singly-deep properties
paulo@89 124 * @param {string} category the category this item belongs to
paulo@89 125 * @return {undefined} adds the item to the classifier
paulo@89 126 */
paulo@89 127 BayesianClassifier.prototype.train = function(item, category) {
paulo@89 128 // If the data object doesn't have any values
paulo@89 129 // for this category, create a new object for it.
paulo@89 130 if (!this.data[category]) {
paulo@89 131 this.data[category] = {};
paulo@89 132 }
paulo@89 133
paulo@89 134 // Iterate through each key in the item.
paulo@89 135 for (var k in item) {
paulo@89 136 var v = item[k];
paulo@89 137 // Initialize the nested object `data[category][k][item[k]]`
paulo@89 138 // with an object of keys that equal 0.
paulo@89 139 if (this.data[category][k] === undefined) {
paulo@89 140 this.data[category][k] = {};
paulo@89 141 }
paulo@89 142 if (this.data[category][k][v] === undefined) {
paulo@89 143 this.data[category][k][v] = 0;
paulo@89 144 }
paulo@89 145
paulo@89 146 // And increment the key for this key/value combination.
paulo@89 147 this.data[category][k][v]++;
paulo@89 148 }
paulo@89 149
paulo@89 150 // Increment the number of items classified
paulo@89 151 this.totalCount++;
paulo@89 152 };
paulo@89 153
paulo@89 154 /**
paulo@89 155 * Generate a score of how well this item matches all
paulo@89 156 * possible categories based on its attributes
paulo@89 157 *
paulo@89 158 * @param {Object} item an item in the same format as with train
paulo@89 159 * @returns {Object} of probabilities that this item belongs to a
paulo@89 160 * given category.
paulo@89 161 */
paulo@89 162 BayesianClassifier.prototype.score = function(item) {
paulo@89 163 // Initialize an empty array of odds per category.
paulo@89 164 var odds = {}, category;
paulo@89 165 // Iterate through each key in the item,
paulo@89 166 // then iterate through each category that has been used
paulo@89 167 // in previous calls to `.train()`
paulo@89 168 for (var k in item) {
paulo@89 169 var v = item[k];
paulo@89 170 for (category in this.data) {
paulo@89 171 // Create an empty object for storing key - value combinations
paulo@89 172 // for this category.
paulo@89 173 odds[category] = {};
paulo@89 174
paulo@89 175 // If this item doesn't even have a property, it counts for nothing,
paulo@89 176 // but if it does have the property that we're looking for from
paulo@89 177 // the item to categorize, it counts based on how popular it is
paulo@89 178 // versus the whole population.
paulo@89 179 if (this.data[category][k]) {
paulo@89 180 odds[category][k + '_' + v] = (this.data[category][k][v] || 0) / this.totalCount;
paulo@89 181 } else {
paulo@89 182 odds[category][k + '_' + v] = 0;
paulo@89 183 }
paulo@89 184 }
paulo@89 185 }
paulo@89 186
paulo@89 187 // Set up a new object that will contain sums of these odds by category
paulo@89 188 var oddsSums = {};
paulo@89 189
paulo@89 190 for (category in odds) {
paulo@89 191 // Tally all of the odds for each category-combination pair -
paulo@89 192 // the non-existence of a category does not add anything to the
paulo@89 193 // score.
paulo@89 194 oddsSums[category] = 0;
paulo@89 195 for (var combination in odds[category]) {
paulo@89 196 oddsSums[category] += odds[category][combination];
paulo@89 197 }
paulo@89 198 }
paulo@89 199
paulo@89 200 return oddsSums;
paulo@89 201 };
paulo@89 202
paulo@89 203 module.exports = BayesianClassifier;
paulo@89 204
paulo@89 205 },{}],3:[function(require,module,exports){
paulo@89 206 'use strict';
paulo@89 207 /* @flow */
paulo@89 208
paulo@89 209 var binomialDistribution = require(4);
paulo@89 210
paulo@89 211 /**
paulo@89 212 * The [Bernoulli distribution](http://en.wikipedia.org/wiki/Bernoulli_distribution)
paulo@89 213 * is the probability discrete
paulo@89 214 * distribution of a random variable which takes value 1 with success
paulo@89 215 * probability `p` and value 0 with failure
paulo@89 216 * probability `q` = 1 - `p`. It can be used, for example, to represent the
paulo@89 217 * toss of a coin, where "1" is defined to mean "heads" and "0" is defined
paulo@89 218 * to mean "tails" (or vice versa). It is
paulo@89 219 * a special case of a Binomial Distribution
paulo@89 220 * where `n` = 1.
paulo@89 221 *
paulo@89 222 * @param {number} p input value, between 0 and 1 inclusive
paulo@89 223 * @returns {number} value of bernoulli distribution at this point
paulo@89 224 * @example
paulo@89 225 * bernoulliDistribution(0.5); // => { '0': 0.5, '1': 0.5 }
paulo@89 226 */
paulo@89 227 function bernoulliDistribution(p/*: number */) {
paulo@89 228 // Check that `p` is a valid probability (0 ≤ p ≤ 1)
paulo@89 229 if (p < 0 || p > 1 ) { return NaN; }
paulo@89 230
paulo@89 231 return binomialDistribution(1, p);
paulo@89 232 }
paulo@89 233
paulo@89 234 module.exports = bernoulliDistribution;
paulo@89 235
paulo@89 236 },{"4":4}],4:[function(require,module,exports){
paulo@89 237 'use strict';
paulo@89 238 /* @flow */
paulo@89 239
paulo@89 240 var epsilon = require(13);
paulo@89 241 var factorial = require(16);
paulo@89 242
paulo@89 243 /**
paulo@89 244 * The [Binomial Distribution](http://en.wikipedia.org/wiki/Binomial_distribution) is the discrete probability
paulo@89 245 * distribution of the number of successes in a sequence of n independent yes/no experiments, each of which yields
paulo@89 246 * success with probability `probability`. Such a success/failure experiment is also called a Bernoulli experiment or
paulo@89 247 * Bernoulli trial; when trials = 1, the Binomial Distribution is a Bernoulli Distribution.
paulo@89 248 *
paulo@89 249 * @param {number} trials number of trials to simulate
paulo@89 250 * @param {number} probability
paulo@89 251 * @returns {Object} output
paulo@89 252 */
paulo@89 253 function binomialDistribution(
paulo@89 254 trials/*: number */,
paulo@89 255 probability/*: number */)/*: ?Object */ {
paulo@89 256 // Check that `p` is a valid probability (0 ≤ p ≤ 1),
paulo@89 257 // that `n` is an integer, strictly positive.
paulo@89 258 if (probability < 0 || probability > 1 ||
paulo@89 259 trials <= 0 || trials % 1 !== 0) {
paulo@89 260 return undefined;
paulo@89 261 }
paulo@89 262
paulo@89 263 // We initialize `x`, the random variable, and `accumulator`, an accumulator
paulo@89 264 // for the cumulative distribution function to 0. `distribution_functions`
paulo@89 265 // is the object we'll return with the `probability_of_x` and the
paulo@89 266 // `cumulativeProbability_of_x`, as well as the calculated mean &
paulo@89 267 // variance. We iterate until the `cumulativeProbability_of_x` is
paulo@89 268 // within `epsilon` of 1.0.
paulo@89 269 var x = 0,
paulo@89 270 cumulativeProbability = 0,
paulo@89 271 cells = {};
paulo@89 272
paulo@89 273 // This algorithm iterates through each potential outcome,
paulo@89 274 // until the `cumulativeProbability` is very close to 1, at
paulo@89 275 // which point we've defined the vast majority of outcomes
paulo@89 276 do {
paulo@89 277 // a [probability mass function](https://en.wikipedia.org/wiki/Probability_mass_function)
paulo@89 278 cells[x] = factorial(trials) /
paulo@89 279 (factorial(x) * factorial(trials - x)) *
paulo@89 280 (Math.pow(probability, x) * Math.pow(1 - probability, trials - x));
paulo@89 281 cumulativeProbability += cells[x];
paulo@89 282 x++;
paulo@89 283 // when the cumulativeProbability is nearly 1, we've calculated
paulo@89 284 // the useful range of this distribution
paulo@89 285 } while (cumulativeProbability < 1 - epsilon);
paulo@89 286
paulo@89 287 return cells;
paulo@89 288 }
paulo@89 289
paulo@89 290 module.exports = binomialDistribution;
paulo@89 291
paulo@89 292 },{"13":13,"16":16}],5:[function(require,module,exports){
paulo@89 293 'use strict';
paulo@89 294 /* @flow */
paulo@89 295
paulo@89 296 var sign = require(53);
paulo@89 297 /**
paulo@89 298 * [Bisection method](https://en.wikipedia.org/wiki/Bisection_method) is a root-finding
paulo@89 299 * method that repeatedly bisects an interval to find the root.
paulo@89 300 *
paulo@89 301 * This function returns a numerical approximation to the exact value.
paulo@89 302 *
paulo@89 303 * @param {Function} func input function
paulo@89 304 * @param {Number} start - start of interval
paulo@89 305 * @param {Number} end - end of interval
paulo@89 306 * @param {Number} maxIterations - the maximum number of iterations
paulo@89 307 * @param {Number} errorTolerance - the error tolerance
paulo@89 308 * @returns {Number} estimated root value
paulo@89 309 * @throws {TypeError} Argument func must be a function
paulo@89 310 *
paulo@89 311 * @example
paulo@89 312 * bisect(Math.cos,0,4,100,0.003); // => 1.572265625
paulo@89 313 */
paulo@89 314 function bisect(
paulo@89 315 func/*: (x: any) => number */,
paulo@89 316 start/*: number */,
paulo@89 317 end/*: number */,
paulo@89 318 maxIterations/*: number */,
paulo@89 319 errorTolerance/*: number */)/*:number*/ {
paulo@89 320
paulo@89 321 if (typeof func !== 'function') throw new TypeError('func must be a function');
paulo@89 322
paulo@89 323 for (var i = 0; i < maxIterations; i++) {
paulo@89 324 var output = (start + end) / 2;
paulo@89 325
paulo@89 326 if (func(output) === 0 || Math.abs((end - start) / 2) < errorTolerance) {
paulo@89 327 return output;
paulo@89 328 }
paulo@89 329
paulo@89 330 if (sign(func(output)) === sign(func(start))) {
paulo@89 331 start = output;
paulo@89 332 } else {
paulo@89 333 end = output;
paulo@89 334 }
paulo@89 335 }
paulo@89 336
paulo@89 337 throw new Error('maximum number of iterations exceeded');
paulo@89 338 }
paulo@89 339
paulo@89 340 module.exports = bisect;
paulo@89 341
paulo@89 342 },{"53":53}],6:[function(require,module,exports){
paulo@89 343 'use strict';
paulo@89 344 /* @flow */
paulo@89 345
paulo@89 346 /**
paulo@89 347 * **Percentage Points of the χ2 (Chi-Squared) Distribution**
paulo@89 348 *
paulo@89 349 * The [χ2 (Chi-Squared) Distribution](http://en.wikipedia.org/wiki/Chi-squared_distribution) is used in the common
paulo@89 350 * chi-squared tests for goodness of fit of an observed distribution to a theoretical one, the independence of two
paulo@89 351 * criteria of classification of qualitative data, and in confidence interval estimation for a population standard
paulo@89 352 * deviation of a normal distribution from a sample standard deviation.
paulo@89 353 *
paulo@89 354 * Values from Appendix 1, Table III of William W. Hines & Douglas C. Montgomery, "Probability and Statistics in
paulo@89 355 * Engineering and Management Science", Wiley (1980).
paulo@89 356 */
paulo@89 357 var chiSquaredDistributionTable = { '1':
paulo@89 358 { '0.995': 0,
paulo@89 359 '0.99': 0,
paulo@89 360 '0.975': 0,
paulo@89 361 '0.95': 0,
paulo@89 362 '0.9': 0.02,
paulo@89 363 '0.5': 0.45,
paulo@89 364 '0.1': 2.71,
paulo@89 365 '0.05': 3.84,
paulo@89 366 '0.025': 5.02,
paulo@89 367 '0.01': 6.63,
paulo@89 368 '0.005': 7.88 },
paulo@89 369 '2':
paulo@89 370 { '0.995': 0.01,
paulo@89 371 '0.99': 0.02,
paulo@89 372 '0.975': 0.05,
paulo@89 373 '0.95': 0.1,
paulo@89 374 '0.9': 0.21,
paulo@89 375 '0.5': 1.39,
paulo@89 376 '0.1': 4.61,
paulo@89 377 '0.05': 5.99,
paulo@89 378 '0.025': 7.38,
paulo@89 379 '0.01': 9.21,
paulo@89 380 '0.005': 10.6 },
paulo@89 381 '3':
paulo@89 382 { '0.995': 0.07,
paulo@89 383 '0.99': 0.11,
paulo@89 384 '0.975': 0.22,
paulo@89 385 '0.95': 0.35,
paulo@89 386 '0.9': 0.58,
paulo@89 387 '0.5': 2.37,
paulo@89 388 '0.1': 6.25,
paulo@89 389 '0.05': 7.81,
paulo@89 390 '0.025': 9.35,
paulo@89 391 '0.01': 11.34,
paulo@89 392 '0.005': 12.84 },
paulo@89 393 '4':
paulo@89 394 { '0.995': 0.21,
paulo@89 395 '0.99': 0.3,
paulo@89 396 '0.975': 0.48,
paulo@89 397 '0.95': 0.71,
paulo@89 398 '0.9': 1.06,
paulo@89 399 '0.5': 3.36,
paulo@89 400 '0.1': 7.78,
paulo@89 401 '0.05': 9.49,
paulo@89 402 '0.025': 11.14,
paulo@89 403 '0.01': 13.28,
paulo@89 404 '0.005': 14.86 },
paulo@89 405 '5':
paulo@89 406 { '0.995': 0.41,
paulo@89 407 '0.99': 0.55,
paulo@89 408 '0.975': 0.83,
paulo@89 409 '0.95': 1.15,
paulo@89 410 '0.9': 1.61,
paulo@89 411 '0.5': 4.35,
paulo@89 412 '0.1': 9.24,
paulo@89 413 '0.05': 11.07,
paulo@89 414 '0.025': 12.83,
paulo@89 415 '0.01': 15.09,
paulo@89 416 '0.005': 16.75 },
paulo@89 417 '6':
paulo@89 418 { '0.995': 0.68,
paulo@89 419 '0.99': 0.87,
paulo@89 420 '0.975': 1.24,
paulo@89 421 '0.95': 1.64,
paulo@89 422 '0.9': 2.2,
paulo@89 423 '0.5': 5.35,
paulo@89 424 '0.1': 10.65,
paulo@89 425 '0.05': 12.59,
paulo@89 426 '0.025': 14.45,
paulo@89 427 '0.01': 16.81,
paulo@89 428 '0.005': 18.55 },
paulo@89 429 '7':
paulo@89 430 { '0.995': 0.99,
paulo@89 431 '0.99': 1.25,
paulo@89 432 '0.975': 1.69,
paulo@89 433 '0.95': 2.17,
paulo@89 434 '0.9': 2.83,
paulo@89 435 '0.5': 6.35,
paulo@89 436 '0.1': 12.02,
paulo@89 437 '0.05': 14.07,
paulo@89 438 '0.025': 16.01,
paulo@89 439 '0.01': 18.48,
paulo@89 440 '0.005': 20.28 },
paulo@89 441 '8':
paulo@89 442 { '0.995': 1.34,
paulo@89 443 '0.99': 1.65,
paulo@89 444 '0.975': 2.18,
paulo@89 445 '0.95': 2.73,
paulo@89 446 '0.9': 3.49,
paulo@89 447 '0.5': 7.34,
paulo@89 448 '0.1': 13.36,
paulo@89 449 '0.05': 15.51,
paulo@89 450 '0.025': 17.53,
paulo@89 451 '0.01': 20.09,
paulo@89 452 '0.005': 21.96 },
paulo@89 453 '9':
paulo@89 454 { '0.995': 1.73,
paulo@89 455 '0.99': 2.09,
paulo@89 456 '0.975': 2.7,
paulo@89 457 '0.95': 3.33,
paulo@89 458 '0.9': 4.17,
paulo@89 459 '0.5': 8.34,
paulo@89 460 '0.1': 14.68,
paulo@89 461 '0.05': 16.92,
paulo@89 462 '0.025': 19.02,
paulo@89 463 '0.01': 21.67,
paulo@89 464 '0.005': 23.59 },
paulo@89 465 '10':
paulo@89 466 { '0.995': 2.16,
paulo@89 467 '0.99': 2.56,
paulo@89 468 '0.975': 3.25,
paulo@89 469 '0.95': 3.94,
paulo@89 470 '0.9': 4.87,
paulo@89 471 '0.5': 9.34,
paulo@89 472 '0.1': 15.99,
paulo@89 473 '0.05': 18.31,
paulo@89 474 '0.025': 20.48,
paulo@89 475 '0.01': 23.21,
paulo@89 476 '0.005': 25.19 },
paulo@89 477 '11':
paulo@89 478 { '0.995': 2.6,
paulo@89 479 '0.99': 3.05,
paulo@89 480 '0.975': 3.82,
paulo@89 481 '0.95': 4.57,
paulo@89 482 '0.9': 5.58,
paulo@89 483 '0.5': 10.34,
paulo@89 484 '0.1': 17.28,
paulo@89 485 '0.05': 19.68,
paulo@89 486 '0.025': 21.92,
paulo@89 487 '0.01': 24.72,
paulo@89 488 '0.005': 26.76 },
paulo@89 489 '12':
paulo@89 490 { '0.995': 3.07,
paulo@89 491 '0.99': 3.57,
paulo@89 492 '0.975': 4.4,
paulo@89 493 '0.95': 5.23,
paulo@89 494 '0.9': 6.3,
paulo@89 495 '0.5': 11.34,
paulo@89 496 '0.1': 18.55,
paulo@89 497 '0.05': 21.03,
paulo@89 498 '0.025': 23.34,
paulo@89 499 '0.01': 26.22,
paulo@89 500 '0.005': 28.3 },
paulo@89 501 '13':
paulo@89 502 { '0.995': 3.57,
paulo@89 503 '0.99': 4.11,
paulo@89 504 '0.975': 5.01,
paulo@89 505 '0.95': 5.89,
paulo@89 506 '0.9': 7.04,
paulo@89 507 '0.5': 12.34,
paulo@89 508 '0.1': 19.81,
paulo@89 509 '0.05': 22.36,
paulo@89 510 '0.025': 24.74,
paulo@89 511 '0.01': 27.69,
paulo@89 512 '0.005': 29.82 },
paulo@89 513 '14':
paulo@89 514 { '0.995': 4.07,
paulo@89 515 '0.99': 4.66,
paulo@89 516 '0.975': 5.63,
paulo@89 517 '0.95': 6.57,
paulo@89 518 '0.9': 7.79,
paulo@89 519 '0.5': 13.34,
paulo@89 520 '0.1': 21.06,
paulo@89 521 '0.05': 23.68,
paulo@89 522 '0.025': 26.12,
paulo@89 523 '0.01': 29.14,
paulo@89 524 '0.005': 31.32 },
paulo@89 525 '15':
paulo@89 526 { '0.995': 4.6,
paulo@89 527 '0.99': 5.23,
paulo@89 528 '0.975': 6.27,
paulo@89 529 '0.95': 7.26,
paulo@89 530 '0.9': 8.55,
paulo@89 531 '0.5': 14.34,
paulo@89 532 '0.1': 22.31,
paulo@89 533 '0.05': 25,
paulo@89 534 '0.025': 27.49,
paulo@89 535 '0.01': 30.58,
paulo@89 536 '0.005': 32.8 },
paulo@89 537 '16':
paulo@89 538 { '0.995': 5.14,
paulo@89 539 '0.99': 5.81,
paulo@89 540 '0.975': 6.91,
paulo@89 541 '0.95': 7.96,
paulo@89 542 '0.9': 9.31,
paulo@89 543 '0.5': 15.34,
paulo@89 544 '0.1': 23.54,
paulo@89 545 '0.05': 26.3,
paulo@89 546 '0.025': 28.85,
paulo@89 547 '0.01': 32,
paulo@89 548 '0.005': 34.27 },
paulo@89 549 '17':
paulo@89 550 { '0.995': 5.7,
paulo@89 551 '0.99': 6.41,
paulo@89 552 '0.975': 7.56,
paulo@89 553 '0.95': 8.67,
paulo@89 554 '0.9': 10.09,
paulo@89 555 '0.5': 16.34,
paulo@89 556 '0.1': 24.77,
paulo@89 557 '0.05': 27.59,
paulo@89 558 '0.025': 30.19,
paulo@89 559 '0.01': 33.41,
paulo@89 560 '0.005': 35.72 },
paulo@89 561 '18':
paulo@89 562 { '0.995': 6.26,
paulo@89 563 '0.99': 7.01,
paulo@89 564 '0.975': 8.23,
paulo@89 565 '0.95': 9.39,
paulo@89 566 '0.9': 10.87,
paulo@89 567 '0.5': 17.34,
paulo@89 568 '0.1': 25.99,
paulo@89 569 '0.05': 28.87,
paulo@89 570 '0.025': 31.53,
paulo@89 571 '0.01': 34.81,
paulo@89 572 '0.005': 37.16 },
paulo@89 573 '19':
paulo@89 574 { '0.995': 6.84,
paulo@89 575 '0.99': 7.63,
paulo@89 576 '0.975': 8.91,
paulo@89 577 '0.95': 10.12,
paulo@89 578 '0.9': 11.65,
paulo@89 579 '0.5': 18.34,
paulo@89 580 '0.1': 27.2,
paulo@89 581 '0.05': 30.14,
paulo@89 582 '0.025': 32.85,
paulo@89 583 '0.01': 36.19,
paulo@89 584 '0.005': 38.58 },
paulo@89 585 '20':
paulo@89 586 { '0.995': 7.43,
paulo@89 587 '0.99': 8.26,
paulo@89 588 '0.975': 9.59,
paulo@89 589 '0.95': 10.85,
paulo@89 590 '0.9': 12.44,
paulo@89 591 '0.5': 19.34,
paulo@89 592 '0.1': 28.41,
paulo@89 593 '0.05': 31.41,
paulo@89 594 '0.025': 34.17,
paulo@89 595 '0.01': 37.57,
paulo@89 596 '0.005': 40 },
paulo@89 597 '21':
paulo@89 598 { '0.995': 8.03,
paulo@89 599 '0.99': 8.9,
paulo@89 600 '0.975': 10.28,
paulo@89 601 '0.95': 11.59,
paulo@89 602 '0.9': 13.24,
paulo@89 603 '0.5': 20.34,
paulo@89 604 '0.1': 29.62,
paulo@89 605 '0.05': 32.67,
paulo@89 606 '0.025': 35.48,
paulo@89 607 '0.01': 38.93,
paulo@89 608 '0.005': 41.4 },
paulo@89 609 '22':
paulo@89 610 { '0.995': 8.64,
paulo@89 611 '0.99': 9.54,
paulo@89 612 '0.975': 10.98,
paulo@89 613 '0.95': 12.34,
paulo@89 614 '0.9': 14.04,
paulo@89 615 '0.5': 21.34,
paulo@89 616 '0.1': 30.81,
paulo@89 617 '0.05': 33.92,
paulo@89 618 '0.025': 36.78,
paulo@89 619 '0.01': 40.29,
paulo@89 620 '0.005': 42.8 },
paulo@89 621 '23':
paulo@89 622 { '0.995': 9.26,
paulo@89 623 '0.99': 10.2,
paulo@89 624 '0.975': 11.69,
paulo@89 625 '0.95': 13.09,
paulo@89 626 '0.9': 14.85,
paulo@89 627 '0.5': 22.34,
paulo@89 628 '0.1': 32.01,
paulo@89 629 '0.05': 35.17,
paulo@89 630 '0.025': 38.08,
paulo@89 631 '0.01': 41.64,
paulo@89 632 '0.005': 44.18 },
paulo@89 633 '24':
paulo@89 634 { '0.995': 9.89,
paulo@89 635 '0.99': 10.86,
paulo@89 636 '0.975': 12.4,
paulo@89 637 '0.95': 13.85,
paulo@89 638 '0.9': 15.66,
paulo@89 639 '0.5': 23.34,
paulo@89 640 '0.1': 33.2,
paulo@89 641 '0.05': 36.42,
paulo@89 642 '0.025': 39.36,
paulo@89 643 '0.01': 42.98,
paulo@89 644 '0.005': 45.56 },
paulo@89 645 '25':
paulo@89 646 { '0.995': 10.52,
paulo@89 647 '0.99': 11.52,
paulo@89 648 '0.975': 13.12,
paulo@89 649 '0.95': 14.61,
paulo@89 650 '0.9': 16.47,
paulo@89 651 '0.5': 24.34,
paulo@89 652 '0.1': 34.28,
paulo@89 653 '0.05': 37.65,
paulo@89 654 '0.025': 40.65,
paulo@89 655 '0.01': 44.31,
paulo@89 656 '0.005': 46.93 },
paulo@89 657 '26':
paulo@89 658 { '0.995': 11.16,
paulo@89 659 '0.99': 12.2,
paulo@89 660 '0.975': 13.84,
paulo@89 661 '0.95': 15.38,
paulo@89 662 '0.9': 17.29,
paulo@89 663 '0.5': 25.34,
paulo@89 664 '0.1': 35.56,
paulo@89 665 '0.05': 38.89,
paulo@89 666 '0.025': 41.92,
paulo@89 667 '0.01': 45.64,
paulo@89 668 '0.005': 48.29 },
paulo@89 669 '27':
paulo@89 670 { '0.995': 11.81,
paulo@89 671 '0.99': 12.88,
paulo@89 672 '0.975': 14.57,
paulo@89 673 '0.95': 16.15,
paulo@89 674 '0.9': 18.11,
paulo@89 675 '0.5': 26.34,
paulo@89 676 '0.1': 36.74,
paulo@89 677 '0.05': 40.11,
paulo@89 678 '0.025': 43.19,
paulo@89 679 '0.01': 46.96,
paulo@89 680 '0.005': 49.65 },
paulo@89 681 '28':
paulo@89 682 { '0.995': 12.46,
paulo@89 683 '0.99': 13.57,
paulo@89 684 '0.975': 15.31,
paulo@89 685 '0.95': 16.93,
paulo@89 686 '0.9': 18.94,
paulo@89 687 '0.5': 27.34,
paulo@89 688 '0.1': 37.92,
paulo@89 689 '0.05': 41.34,
paulo@89 690 '0.025': 44.46,
paulo@89 691 '0.01': 48.28,
paulo@89 692 '0.005': 50.99 },
paulo@89 693 '29':
paulo@89 694 { '0.995': 13.12,
paulo@89 695 '0.99': 14.26,
paulo@89 696 '0.975': 16.05,
paulo@89 697 '0.95': 17.71,
paulo@89 698 '0.9': 19.77,
paulo@89 699 '0.5': 28.34,
paulo@89 700 '0.1': 39.09,
paulo@89 701 '0.05': 42.56,
paulo@89 702 '0.025': 45.72,
paulo@89 703 '0.01': 49.59,
paulo@89 704 '0.005': 52.34 },
paulo@89 705 '30':
paulo@89 706 { '0.995': 13.79,
paulo@89 707 '0.99': 14.95,
paulo@89 708 '0.975': 16.79,
paulo@89 709 '0.95': 18.49,
paulo@89 710 '0.9': 20.6,
paulo@89 711 '0.5': 29.34,
paulo@89 712 '0.1': 40.26,
paulo@89 713 '0.05': 43.77,
paulo@89 714 '0.025': 46.98,
paulo@89 715 '0.01': 50.89,
paulo@89 716 '0.005': 53.67 },
paulo@89 717 '40':
paulo@89 718 { '0.995': 20.71,
paulo@89 719 '0.99': 22.16,
paulo@89 720 '0.975': 24.43,
paulo@89 721 '0.95': 26.51,
paulo@89 722 '0.9': 29.05,
paulo@89 723 '0.5': 39.34,
paulo@89 724 '0.1': 51.81,
paulo@89 725 '0.05': 55.76,
paulo@89 726 '0.025': 59.34,
paulo@89 727 '0.01': 63.69,
paulo@89 728 '0.005': 66.77 },
paulo@89 729 '50':
paulo@89 730 { '0.995': 27.99,
paulo@89 731 '0.99': 29.71,
paulo@89 732 '0.975': 32.36,
paulo@89 733 '0.95': 34.76,
paulo@89 734 '0.9': 37.69,
paulo@89 735 '0.5': 49.33,
paulo@89 736 '0.1': 63.17,
paulo@89 737 '0.05': 67.5,
paulo@89 738 '0.025': 71.42,
paulo@89 739 '0.01': 76.15,
paulo@89 740 '0.005': 79.49 },
paulo@89 741 '60':
paulo@89 742 { '0.995': 35.53,
paulo@89 743 '0.99': 37.48,
paulo@89 744 '0.975': 40.48,
paulo@89 745 '0.95': 43.19,
paulo@89 746 '0.9': 46.46,
paulo@89 747 '0.5': 59.33,
paulo@89 748 '0.1': 74.4,
paulo@89 749 '0.05': 79.08,
paulo@89 750 '0.025': 83.3,
paulo@89 751 '0.01': 88.38,
paulo@89 752 '0.005': 91.95 },
paulo@89 753 '70':
paulo@89 754 { '0.995': 43.28,
paulo@89 755 '0.99': 45.44,
paulo@89 756 '0.975': 48.76,
paulo@89 757 '0.95': 51.74,
paulo@89 758 '0.9': 55.33,
paulo@89 759 '0.5': 69.33,
paulo@89 760 '0.1': 85.53,
paulo@89 761 '0.05': 90.53,
paulo@89 762 '0.025': 95.02,
paulo@89 763 '0.01': 100.42,
paulo@89 764 '0.005': 104.22 },
paulo@89 765 '80':
paulo@89 766 { '0.995': 51.17,
paulo@89 767 '0.99': 53.54,
paulo@89 768 '0.975': 57.15,
paulo@89 769 '0.95': 60.39,
paulo@89 770 '0.9': 64.28,
paulo@89 771 '0.5': 79.33,
paulo@89 772 '0.1': 96.58,
paulo@89 773 '0.05': 101.88,
paulo@89 774 '0.025': 106.63,
paulo@89 775 '0.01': 112.33,
paulo@89 776 '0.005': 116.32 },
paulo@89 777 '90':
paulo@89 778 { '0.995': 59.2,
paulo@89 779 '0.99': 61.75,
paulo@89 780 '0.975': 65.65,
paulo@89 781 '0.95': 69.13,
paulo@89 782 '0.9': 73.29,
paulo@89 783 '0.5': 89.33,
paulo@89 784 '0.1': 107.57,
paulo@89 785 '0.05': 113.14,
paulo@89 786 '0.025': 118.14,
paulo@89 787 '0.01': 124.12,
paulo@89 788 '0.005': 128.3 },
paulo@89 789 '100':
paulo@89 790 { '0.995': 67.33,
paulo@89 791 '0.99': 70.06,
paulo@89 792 '0.975': 74.22,
paulo@89 793 '0.95': 77.93,
paulo@89 794 '0.9': 82.36,
paulo@89 795 '0.5': 99.33,
paulo@89 796 '0.1': 118.5,
paulo@89 797 '0.05': 124.34,
paulo@89 798 '0.025': 129.56,
paulo@89 799 '0.01': 135.81,
paulo@89 800 '0.005': 140.17 } };
paulo@89 801
paulo@89 802 module.exports = chiSquaredDistributionTable;
paulo@89 803
paulo@89 804 },{}],7:[function(require,module,exports){
paulo@89 805 'use strict';
paulo@89 806 /* @flow */
paulo@89 807
paulo@89 808 var mean = require(25);
paulo@89 809 var chiSquaredDistributionTable = require(6);
paulo@89 810
paulo@89 811 /**
paulo@89 812 * The [χ2 (Chi-Squared) Goodness-of-Fit Test](http://en.wikipedia.org/wiki/Goodness_of_fit#Pearson.27s_chi-squared_test)
paulo@89 813 * uses a measure of goodness of fit which is the sum of differences between observed and expected outcome frequencies
paulo@89 814 * (that is, counts of observations), each squared and divided by the number of observations expected given the
paulo@89 815 * hypothesized distribution. The resulting χ2 statistic, `chiSquared`, can be compared to the chi-squared distribution
paulo@89 816 * to determine the goodness of fit. In order to determine the degrees of freedom of the chi-squared distribution, one
paulo@89 817 * takes the total number of observed frequencies and subtracts the number of estimated parameters. The test statistic
paulo@89 818 * follows, approximately, a chi-square distribution with (k − c) degrees of freedom where `k` is the number of non-empty
paulo@89 819 * cells and `c` is the number of estimated parameters for the distribution.
paulo@89 820 *
paulo@89 821 * @param {Array<number>} data
paulo@89 822 * @param {Function} distributionType a function that returns a point in a distribution:
paulo@89 823 * for instance, binomial, bernoulli, or poisson
paulo@89 824 * @param {number} significance
paulo@89 825 * @returns {number} chi squared goodness of fit
paulo@89 826 * @example
paulo@89 827 * // Data from Poisson goodness-of-fit example 10-19 in William W. Hines & Douglas C. Montgomery,
paulo@89 828 * // "Probability and Statistics in Engineering and Management Science", Wiley (1980).
paulo@89 829 * var data1019 = [
paulo@89 830 * 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
paulo@89 831 * 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
paulo@89 832 * 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
paulo@89 833 * 2, 2, 2, 2, 2, 2, 2, 2, 2,
paulo@89 834 * 3, 3, 3, 3
paulo@89 835 * ];
paulo@89 836 * ss.chiSquaredGoodnessOfFit(data1019, ss.poissonDistribution, 0.05)); //= false
paulo@89 837 */
paulo@89 838 function chiSquaredGoodnessOfFit(
paulo@89 839 data/*: Array<number> */,
paulo@89 840 distributionType/*: Function */,
paulo@89 841 significance/*: number */)/*: boolean */ {
paulo@89 842 // Estimate from the sample data, a weighted mean.
paulo@89 843 var inputMean = mean(data),
paulo@89 844 // Calculated value of the χ2 statistic.
paulo@89 845 chiSquared = 0,
paulo@89 846 // Degrees of freedom, calculated as (number of class intervals -
paulo@89 847 // number of hypothesized distribution parameters estimated - 1)
paulo@89 848 degreesOfFreedom,
paulo@89 849 // Number of hypothesized distribution parameters estimated, expected to be supplied in the distribution test.
paulo@89 850 // Lose one degree of freedom for estimating `lambda` from the sample data.
paulo@89 851 c = 1,
paulo@89 852 // The hypothesized distribution.
paulo@89 853 // Generate the hypothesized distribution.
paulo@89 854 hypothesizedDistribution = distributionType(inputMean),
paulo@89 855 observedFrequencies = [],
paulo@89 856 expectedFrequencies = [],
paulo@89 857 k;
paulo@89 858
paulo@89 859 // Create an array holding a histogram from the sample data, of
paulo@89 860 // the form `{ value: numberOfOcurrences }`
paulo@89 861 for (var i = 0; i < data.length; i++) {
paulo@89 862 if (observedFrequencies[data[i]] === undefined) {
paulo@89 863 observedFrequencies[data[i]] = 0;
paulo@89 864 }
paulo@89 865 observedFrequencies[data[i]]++;
paulo@89 866 }
paulo@89 867
paulo@89 868 // The histogram we created might be sparse - there might be gaps
paulo@89 869 // between values. So we iterate through the histogram, making
paulo@89 870 // sure that instead of undefined, gaps have 0 values.
paulo@89 871 for (i = 0; i < observedFrequencies.length; i++) {
paulo@89 872 if (observedFrequencies[i] === undefined) {
paulo@89 873 observedFrequencies[i] = 0;
paulo@89 874 }
paulo@89 875 }
paulo@89 876
paulo@89 877 // Create an array holding a histogram of expected data given the
paulo@89 878 // sample size and hypothesized distribution.
paulo@89 879 for (k in hypothesizedDistribution) {
paulo@89 880 if (k in observedFrequencies) {
paulo@89 881 expectedFrequencies[+k] = hypothesizedDistribution[k] * data.length;
paulo@89 882 }
paulo@89 883 }
paulo@89 884
paulo@89 885 // Working backward through the expected frequencies, collapse classes
paulo@89 886 // if less than three observations are expected for a class.
paulo@89 887 // This transformation is applied to the observed frequencies as well.
paulo@89 888 for (k = expectedFrequencies.length - 1; k >= 0; k--) {
paulo@89 889 if (expectedFrequencies[k] < 3) {
paulo@89 890 expectedFrequencies[k - 1] += expectedFrequencies[k];
paulo@89 891 expectedFrequencies.pop();
paulo@89 892
paulo@89 893 observedFrequencies[k - 1] += observedFrequencies[k];
paulo@89 894 observedFrequencies.pop();
paulo@89 895 }
paulo@89 896 }
paulo@89 897
paulo@89 898 // Iterate through the squared differences between observed & expected
paulo@89 899 // frequencies, accumulating the `chiSquared` statistic.
paulo@89 900 for (k = 0; k < observedFrequencies.length; k++) {
paulo@89 901 chiSquared += Math.pow(
paulo@89 902 observedFrequencies[k] - expectedFrequencies[k], 2) /
paulo@89 903 expectedFrequencies[k];
paulo@89 904 }
paulo@89 905
paulo@89 906 // Calculate degrees of freedom for this test and look it up in the
paulo@89 907 // `chiSquaredDistributionTable` in order to
paulo@89 908 // accept or reject the goodness-of-fit of the hypothesized distribution.
paulo@89 909 degreesOfFreedom = observedFrequencies.length - c - 1;
paulo@89 910 return chiSquaredDistributionTable[degreesOfFreedom][significance] < chiSquared;
paulo@89 911 }
paulo@89 912
paulo@89 913 module.exports = chiSquaredGoodnessOfFit;
paulo@89 914
paulo@89 915 },{"25":25,"6":6}],8:[function(require,module,exports){
paulo@89 916 'use strict';
paulo@89 917 /* @flow */
paulo@89 918
paulo@89 919 /**
paulo@89 920 * Split an array into chunks of a specified size. This function
paulo@89 921 * has the same behavior as [PHP's array_chunk](http://php.net/manual/en/function.array-chunk.php)
paulo@89 922 * function, and thus will insert smaller-sized chunks at the end if
paulo@89 923 * the input size is not divisible by the chunk size.
paulo@89 924 *
paulo@89 925 * `sample` is expected to be an array, and `chunkSize` a number.
paulo@89 926 * The `sample` array can contain any kind of data.
paulo@89 927 *
paulo@89 928 * @param {Array} sample any array of values
paulo@89 929 * @param {number} chunkSize size of each output array
paulo@89 930 * @returns {Array<Array>} a chunked array
paulo@89 931 * @example
paulo@89 932 * chunk([1, 2, 3, 4, 5, 6], 2);
paulo@89 933 * // => [[1, 2], [3, 4], [5, 6]]
paulo@89 934 */
paulo@89 935 function chunk(sample/*:Array<any>*/, chunkSize/*:number*/)/*:?Array<Array<any>>*/ {
paulo@89 936
paulo@89 937 // a list of result chunks, as arrays in an array
paulo@89 938 var output = [];
paulo@89 939
paulo@89 940 // `chunkSize` must be zero or higher - otherwise the loop below,
paulo@89 941 // in which we call `start += chunkSize`, will loop infinitely.
paulo@89 942 // So, we'll detect and throw in that case to indicate
paulo@89 943 // invalid input.
paulo@89 944 if (chunkSize <= 0) {
paulo@89 945 throw new Error('chunk size must be a positive integer');
paulo@89 946 }
paulo@89 947
paulo@89 948 // `start` is the index at which `.slice` will start selecting
paulo@89 949 // new array elements
paulo@89 950 for (var start = 0; start < sample.length; start += chunkSize) {
paulo@89 951
paulo@89 952 // for each chunk, slice that part of the array and add it
paulo@89 953 // to the output. The `.slice` function does not change
paulo@89 954 // the original array.
paulo@89 955 output.push(sample.slice(start, start + chunkSize));
paulo@89 956 }
paulo@89 957 return output;
paulo@89 958 }
paulo@89 959
paulo@89 960 module.exports = chunk;
paulo@89 961
paulo@89 962 },{}],9:[function(require,module,exports){
paulo@89 963 'use strict';
paulo@89 964 /* @flow */
paulo@89 965
paulo@89 966 var uniqueCountSorted = require(61),
paulo@89 967 numericSort = require(34);
paulo@89 968
paulo@89 969 /**
paulo@89 970 * Create a new column x row matrix.
paulo@89 971 *
paulo@89 972 * @private
paulo@89 973 * @param {number} columns
paulo@89 974 * @param {number} rows
paulo@89 975 * @return {Array<Array<number>>} matrix
paulo@89 976 * @example
paulo@89 977 * makeMatrix(10, 10);
paulo@89 978 */
paulo@89 979 function makeMatrix(columns, rows) {
paulo@89 980 var matrix = [];
paulo@89 981 for (var i = 0; i < columns; i++) {
paulo@89 982 var column = [];
paulo@89 983 for (var j = 0; j < rows; j++) {
paulo@89 984 column.push(0);
paulo@89 985 }
paulo@89 986 matrix.push(column);
paulo@89 987 }
paulo@89 988 return matrix;
paulo@89 989 }
paulo@89 990
paulo@89 991 /**
paulo@89 992 * Generates incrementally computed values based on the sums and sums of
paulo@89 993 * squares for the data array
paulo@89 994 *
paulo@89 995 * @private
paulo@89 996 * @param {number} j
paulo@89 997 * @param {number} i
paulo@89 998 * @param {Array<number>} sums
paulo@89 999 * @param {Array<number>} sumsOfSquares
paulo@89 1000 * @return {number}
paulo@89 1001 * @example
paulo@89 1002 * ssq(0, 1, [-1, 0, 2], [1, 1, 5]);
paulo@89 1003 */
paulo@89 1004 function ssq(j, i, sums, sumsOfSquares) {
paulo@89 1005 var sji; // s(j, i)
paulo@89 1006 if (j > 0) {
paulo@89 1007 var muji = (sums[i] - sums[j - 1]) / (i - j + 1); // mu(j, i)
paulo@89 1008 sji = sumsOfSquares[i] - sumsOfSquares[j - 1] - (i - j + 1) * muji * muji;
paulo@89 1009 } else {
paulo@89 1010 sji = sumsOfSquares[i] - sums[i] * sums[i] / (i + 1);
paulo@89 1011 }
paulo@89 1012 if (sji < 0) {
paulo@89 1013 return 0;
paulo@89 1014 }
paulo@89 1015 return sji;
paulo@89 1016 }
paulo@89 1017
paulo@89 1018 /**
paulo@89 1019 * Function that recursively divides and conquers computations
paulo@89 1020 * for cluster j
paulo@89 1021 *
paulo@89 1022 * @private
paulo@89 1023 * @param {number} iMin Minimum index in cluster to be computed
paulo@89 1024 * @param {number} iMax Maximum index in cluster to be computed
paulo@89 1025 * @param {number} cluster Index of the cluster currently being computed
paulo@89 1026 * @param {Array<Array<number>>} matrix
paulo@89 1027 * @param {Array<Array<number>>} backtrackMatrix
paulo@89 1028 * @param {Array<number>} sums
paulo@89 1029 * @param {Array<number>} sumsOfSquares
paulo@89 1030 */
paulo@89 1031 function fillMatrixColumn(iMin, iMax, cluster, matrix, backtrackMatrix, sums, sumsOfSquares) {
paulo@89 1032 if (iMin > iMax) {
paulo@89 1033 return;
paulo@89 1034 }
paulo@89 1035
paulo@89 1036 // Start at midpoint between iMin and iMax
paulo@89 1037 var i = Math.floor((iMin + iMax) / 2);
paulo@89 1038
paulo@89 1039 matrix[cluster][i] = matrix[cluster - 1][i - 1];
paulo@89 1040 backtrackMatrix[cluster][i] = i;
paulo@89 1041
paulo@89 1042 var jlow = cluster; // the lower end for j
paulo@89 1043
paulo@89 1044 if (iMin > cluster) {
paulo@89 1045 jlow = Math.max(jlow, backtrackMatrix[cluster][iMin - 1] || 0);
paulo@89 1046 }
paulo@89 1047 jlow = Math.max(jlow, backtrackMatrix[cluster - 1][i] || 0);
paulo@89 1048
paulo@89 1049 var jhigh = i - 1; // the upper end for j
paulo@89 1050 if (iMax < matrix.length - 1) {
paulo@89 1051 jhigh = Math.min(jhigh, backtrackMatrix[cluster][iMax + 1] || 0);
paulo@89 1052 }
paulo@89 1053
paulo@89 1054 var sji;
paulo@89 1055 var sjlowi;
paulo@89 1056 var ssqjlow;
paulo@89 1057 var ssqj;
paulo@89 1058 for (var j = jhigh; j >= jlow; --j) {
paulo@89 1059 sji = ssq(j, i, sums, sumsOfSquares);
paulo@89 1060
paulo@89 1061 if (sji + matrix[cluster - 1][jlow - 1] >= matrix[cluster][i]) {
paulo@89 1062 break;
paulo@89 1063 }
paulo@89 1064
paulo@89 1065 // Examine the lower bound of the cluster border
paulo@89 1066 sjlowi = ssq(jlow, i, sums, sumsOfSquares);
paulo@89 1067
paulo@89 1068 ssqjlow = sjlowi + matrix[cluster - 1][jlow - 1];
paulo@89 1069
paulo@89 1070 if (ssqjlow < matrix[cluster][i]) {
paulo@89 1071 // Shrink the lower bound
paulo@89 1072 matrix[cluster][i] = ssqjlow;
paulo@89 1073 backtrackMatrix[cluster][i] = jlow;
paulo@89 1074 }
paulo@89 1075 jlow++;
paulo@89 1076
paulo@89 1077 ssqj = sji + matrix[cluster - 1][j - 1];
paulo@89 1078 if (ssqj < matrix[cluster][i]) {
paulo@89 1079 matrix[cluster][i] = ssqj;
paulo@89 1080 backtrackMatrix[cluster][i] = j;
paulo@89 1081 }
paulo@89 1082 }
paulo@89 1083
paulo@89 1084 fillMatrixColumn(iMin, i - 1, cluster, matrix, backtrackMatrix, sums, sumsOfSquares);
paulo@89 1085 fillMatrixColumn(i + 1, iMax, cluster, matrix, backtrackMatrix, sums, sumsOfSquares);
paulo@89 1086 }
paulo@89 1087
paulo@89 1088 /**
paulo@89 1089 * Initializes the main matrices used in Ckmeans and kicks
paulo@89 1090 * off the divide and conquer cluster computation strategy
paulo@89 1091 *
paulo@89 1092 * @private
paulo@89 1093 * @param {Array<number>} data sorted array of values
paulo@89 1094 * @param {Array<Array<number>>} matrix
paulo@89 1095 * @param {Array<Array<number>>} backtrackMatrix
paulo@89 1096 */
paulo@89 1097 function fillMatrices(data, matrix, backtrackMatrix) {
paulo@89 1098 var nValues = matrix[0].length;
paulo@89 1099
paulo@89 1100 // Shift values by the median to improve numeric stability
paulo@89 1101 var shift = data[Math.floor(nValues / 2)];
paulo@89 1102
paulo@89 1103 // Cumulative sum and cumulative sum of squares for all values in data array
paulo@89 1104 var sums = [];
paulo@89 1105 var sumsOfSquares = [];
paulo@89 1106
paulo@89 1107 // Initialize first column in matrix & backtrackMatrix
paulo@89 1108 for (var i = 0, shiftedValue; i < nValues; ++i) {
paulo@89 1109 shiftedValue = data[i] - shift;
paulo@89 1110 if (i === 0) {
paulo@89 1111 sums.push(shiftedValue);
paulo@89 1112 sumsOfSquares.push(shiftedValue * shiftedValue);
paulo@89 1113 } else {
paulo@89 1114 sums.push(sums[i - 1] + shiftedValue);
paulo@89 1115 sumsOfSquares.push(sumsOfSquares[i - 1] + shiftedValue * shiftedValue);
paulo@89 1116 }
paulo@89 1117
paulo@89 1118 // Initialize for cluster = 0
paulo@89 1119 matrix[0][i] = ssq(0, i, sums, sumsOfSquares);
paulo@89 1120 backtrackMatrix[0][i] = 0;
paulo@89 1121 }
paulo@89 1122
paulo@89 1123 // Initialize the rest of the columns
paulo@89 1124 var iMin;
paulo@89 1125 for (var cluster = 1; cluster < matrix.length; ++cluster) {
paulo@89 1126 if (cluster < matrix.length - 1) {
paulo@89 1127 iMin = cluster;
paulo@89 1128 } else {
paulo@89 1129 // No need to compute matrix[K-1][0] ... matrix[K-1][N-2]
paulo@89 1130 iMin = nValues - 1;
paulo@89 1131 }
paulo@89 1132
paulo@89 1133 fillMatrixColumn(iMin, nValues - 1, cluster, matrix, backtrackMatrix, sums, sumsOfSquares);
paulo@89 1134 }
paulo@89 1135 }
paulo@89 1136
paulo@89 1137 /**
paulo@89 1138 * Ckmeans clustering is an improvement on heuristic-based clustering
paulo@89 1139 * approaches like Jenks. The algorithm was developed in
paulo@89 1140 * [Haizhou Wang and Mingzhou Song](http://journal.r-project.org/archive/2011-2/RJournal_2011-2_Wang+Song.pdf)
paulo@89 1141 * as a [dynamic programming](https://en.wikipedia.org/wiki/Dynamic_programming) approach
paulo@89 1142 * to the problem of clustering numeric data into groups with the least
paulo@89 1143 * within-group sum-of-squared-deviations.
paulo@89 1144 *
paulo@89 1145 * Minimizing the difference within groups - what Wang & Song refer to as
paulo@89 1146 * `withinss`, or within sum-of-squares, means that groups are optimally
paulo@89 1147 * homogenous within and the data is split into representative groups.
paulo@89 1148 * This is very useful for visualization, where you may want to represent
paulo@89 1149 * a continuous variable in discrete color or style groups. This function
paulo@89 1150 * can provide groups that emphasize differences between data.
paulo@89 1151 *
paulo@89 1152 * Being a dynamic approach, this algorithm is based on two matrices that
paulo@89 1153 * store incrementally-computed values for squared deviations and backtracking
paulo@89 1154 * indexes.
paulo@89 1155 *
paulo@89 1156 * This implementation is based on Ckmeans 3.4.6, which introduced a new divide
paulo@89 1157 * and conquer approach that improved runtime from O(kn^2) to O(kn log(n)).
paulo@89 1158 *
paulo@89 1159 * Unlike the [original implementation](https://cran.r-project.org/web/packages/Ckmeans.1d.dp/index.html),
paulo@89 1160 * this implementation does not include any code to automatically determine
paulo@89 1161 * the optimal number of clusters: this information needs to be explicitly
paulo@89 1162 * provided.
paulo@89 1163 *
paulo@89 1164 * ### References
paulo@89 1165 * _Ckmeans.1d.dp: Optimal k-means Clustering in One Dimension by Dynamic
paulo@89 1166 * Programming_ Haizhou Wang and Mingzhou Song ISSN 2073-4859
paulo@89 1167 *
paulo@89 1168 * from The R Journal Vol. 3/2, December 2011
paulo@89 1169 * @param {Array<number>} data input data, as an array of number values
paulo@89 1170 * @param {number} nClusters number of desired classes. This cannot be
paulo@89 1171 * greater than the number of values in the data array.
paulo@89 1172 * @returns {Array<Array<number>>} clustered input
paulo@89 1173 * @example
paulo@89 1174 * ckmeans([-1, 2, -1, 2, 4, 5, 6, -1, 2, -1], 3);
paulo@89 1175 * // The input, clustered into groups of similar numbers.
paulo@89 1176 * //= [[-1, -1, -1, -1], [2, 2, 2], [4, 5, 6]]);
paulo@89 1177 */
paulo@89 1178 function ckmeans(data/*: Array<number> */, nClusters/*: number */)/*: Array<Array<number>> */ {
paulo@89 1179
paulo@89 1180 if (nClusters > data.length) {
paulo@89 1181 throw new Error('Cannot generate more classes than there are data values');
paulo@89 1182 }
paulo@89 1183
paulo@89 1184 var sorted = numericSort(data),
paulo@89 1185 // we'll use this as the maximum number of clusters
paulo@89 1186 uniqueCount = uniqueCountSorted(sorted);
paulo@89 1187
paulo@89 1188 // if all of the input values are identical, there's one cluster
paulo@89 1189 // with all of the input in it.
paulo@89 1190 if (uniqueCount === 1) {
paulo@89 1191 return [sorted];
paulo@89 1192 }
paulo@89 1193
paulo@89 1194 // named 'S' originally
paulo@89 1195 var matrix = makeMatrix(nClusters, sorted.length),
paulo@89 1196 // named 'J' originally
paulo@89 1197 backtrackMatrix = makeMatrix(nClusters, sorted.length);
paulo@89 1198
paulo@89 1199 // This is a dynamic programming way to solve the problem of minimizing
paulo@89 1200 // within-cluster sum of squares. It's similar to linear regression
paulo@89 1201 // in this way, and this calculation incrementally computes the
paulo@89 1202 // sum of squares that are later read.
paulo@89 1203 fillMatrices(sorted, matrix, backtrackMatrix);
paulo@89 1204
paulo@89 1205 // The real work of Ckmeans clustering happens in the matrix generation:
paulo@89 1206 // the generated matrices encode all possible clustering combinations, and
paulo@89 1207 // once they're generated we can solve for the best clustering groups
paulo@89 1208 // very quickly.
paulo@89 1209 var clusters = [],
paulo@89 1210 clusterRight = backtrackMatrix[0].length - 1;
paulo@89 1211
paulo@89 1212 // Backtrack the clusters from the dynamic programming matrix. This
paulo@89 1213 // starts at the bottom-right corner of the matrix (if the top-left is 0, 0),
paulo@89 1214 // and moves the cluster target with the loop.
paulo@89 1215 for (var cluster = backtrackMatrix.length - 1; cluster >= 0; cluster--) {
paulo@89 1216
paulo@89 1217 var clusterLeft = backtrackMatrix[cluster][clusterRight];
paulo@89 1218
paulo@89 1219 // fill the cluster from the sorted input by taking a slice of the
paulo@89 1220 // array. the backtrack matrix makes this easy - it stores the
paulo@89 1221 // indexes where the cluster should start and end.
paulo@89 1222 clusters[cluster] = sorted.slice(clusterLeft, clusterRight + 1);
paulo@89 1223
paulo@89 1224 if (cluster > 0) {
paulo@89 1225 clusterRight = clusterLeft - 1;
paulo@89 1226 }
paulo@89 1227 }
paulo@89 1228
paulo@89 1229 return clusters;
paulo@89 1230 }
paulo@89 1231
paulo@89 1232 module.exports = ckmeans;
paulo@89 1233
paulo@89 1234 },{"34":34,"61":61}],10:[function(require,module,exports){
paulo@89 1235 /* @flow */
paulo@89 1236 'use strict';
paulo@89 1237 /**
paulo@89 1238 * Implementation of Combinations
paulo@89 1239 * Combinations are unique subsets of a collection - in this case, k elements from a collection at a time.
paulo@89 1240 * https://en.wikipedia.org/wiki/Combination
paulo@89 1241 * @param {Array} elements any type of data
paulo@89 1242 * @param {int} k the number of objects in each group (without replacement)
paulo@89 1243 * @returns {Array<Array>} array of permutations
paulo@89 1244 * @example
paulo@89 1245 * combinations([1, 2, 3], 2); // => [[1,2], [1,3], [2,3]]
paulo@89 1246 */
paulo@89 1247
paulo@89 1248 function combinations(elements /*: Array<any> */, k/*: number */) {
paulo@89 1249 var i;
paulo@89 1250 var subI;
paulo@89 1251 var combinationList = [];
paulo@89 1252 var subsetCombinations;
paulo@89 1253 var next;
paulo@89 1254
paulo@89 1255 for (i = 0; i < elements.length; i++) {
paulo@89 1256 if (k === 1) {
paulo@89 1257 combinationList.push([elements[i]])
paulo@89 1258 } else {
paulo@89 1259 subsetCombinations = combinations(elements.slice( i + 1, elements.length ), k - 1);
paulo@89 1260 for (subI = 0; subI < subsetCombinations.length; subI++) {
paulo@89 1261 next = subsetCombinations[subI];
paulo@89 1262 next.unshift(elements[i]);
paulo@89 1263 combinationList.push(next);
paulo@89 1264 }
paulo@89 1265 }
paulo@89 1266 }
paulo@89 1267 return combinationList;
paulo@89 1268 }
paulo@89 1269
paulo@89 1270 module.exports = combinations;
paulo@89 1271
paulo@89 1272 },{}],11:[function(require,module,exports){
paulo@89 1273 /* @flow */
paulo@89 1274 'use strict';
paulo@89 1275
paulo@89 1276 /**
paulo@89 1277 * Implementation of [Combinations](https://en.wikipedia.org/wiki/Combination) with replacement
paulo@89 1278 * Combinations are unique subsets of a collection - in this case, k elements from a collection at a time.
paulo@89 1279 * 'With replacement' means that a given element can be chosen multiple times.
paulo@89 1280 * Unlike permutation, order doesn't matter for combinations.
paulo@89 1281 *
paulo@89 1282 * @param {Array} elements any type of data
paulo@89 1283 * @param {int} k the number of objects in each group (without replacement)
paulo@89 1284 * @returns {Array<Array>} array of permutations
paulo@89 1285 * @example
paulo@89 1286 * combinationsReplacement([1, 2], 2); // => [[1, 1], [1, 2], [2, 2]]
paulo@89 1287 */
paulo@89 1288 function combinationsReplacement(
paulo@89 1289 elements /*: Array<any> */,
paulo@89 1290 k /*: number */) {
paulo@89 1291
paulo@89 1292 var combinationList = [];
paulo@89 1293
paulo@89 1294 for (var i = 0; i < elements.length; i++) {
paulo@89 1295 if (k === 1) {
paulo@89 1296 // If we're requested to find only one element, we don't need
paulo@89 1297 // to recurse: just push `elements[i]` onto the list of combinations.
paulo@89 1298 combinationList.push([elements[i]])
paulo@89 1299 } else {
paulo@89 1300 // Otherwise, recursively find combinations, given `k - 1`. Note that
paulo@89 1301 // we request `k - 1`, so if you were looking for k=3 combinations, we're
paulo@89 1302 // requesting k=2. This -1 gets reversed in the for loop right after this
paulo@89 1303 // code, since we concatenate `elements[i]` onto the selected combinations,
paulo@89 1304 // bringing `k` back up to your requested level.
paulo@89 1305 // This recursion may go many levels deep, since it only stops once
paulo@89 1306 // k=1.
paulo@89 1307 var subsetCombinations = combinationsReplacement(
paulo@89 1308 elements.slice(i, elements.length),
paulo@89 1309 k - 1);
paulo@89 1310
paulo@89 1311 for (var j = 0; j < subsetCombinations.length; j++) {
paulo@89 1312 combinationList.push([elements[i]]
paulo@89 1313 .concat(subsetCombinations[j]));
paulo@89 1314 }
paulo@89 1315 }
paulo@89 1316 }
paulo@89 1317
paulo@89 1318 return combinationList;
paulo@89 1319 }
paulo@89 1320
paulo@89 1321 module.exports = combinationsReplacement;
paulo@89 1322
paulo@89 1323 },{}],12:[function(require,module,exports){
paulo@89 1324 'use strict';
paulo@89 1325 /* @flow */
paulo@89 1326
paulo@89 1327 var standardNormalTable = require(55);
paulo@89 1328
paulo@89 1329 /**
paulo@89 1330 * **[Cumulative Standard Normal Probability](http://en.wikipedia.org/wiki/Standard_normal_table)**
paulo@89 1331 *
paulo@89 1332 * Since probability tables cannot be
paulo@89 1333 * printed for every normal distribution, as there are an infinite variety
paulo@89 1334 * of normal distributions, it is common practice to convert a normal to a
paulo@89 1335 * standard normal and then use the standard normal table to find probabilities.
paulo@89 1336 *
paulo@89 1337 * You can use `.5 + .5 * errorFunction(x / Math.sqrt(2))` to calculate the probability
paulo@89 1338 * instead of looking it up in a table.
paulo@89 1339 *
paulo@89 1340 * @param {number} z
paulo@89 1341 * @returns {number} cumulative standard normal probability
paulo@89 1342 */
paulo@89 1343 function cumulativeStdNormalProbability(z /*:number */)/*:number */ {
paulo@89 1344
paulo@89 1345 // Calculate the position of this value.
paulo@89 1346 var absZ = Math.abs(z),
paulo@89 1347 // Each row begins with a different
paulo@89 1348 // significant digit: 0.5, 0.6, 0.7, and so on. Each value in the table
paulo@89 1349 // corresponds to a range of 0.01 in the input values, so the value is
paulo@89 1350 // multiplied by 100.
paulo@89 1351 index = Math.min(Math.round(absZ * 100), standardNormalTable.length - 1);
paulo@89 1352
paulo@89 1353 // The index we calculate must be in the table as a positive value,
paulo@89 1354 // but we still pay attention to whether the input is positive
paulo@89 1355 // or negative, and flip the output value as a last step.
paulo@89 1356 if (z >= 0) {
paulo@89 1357 return standardNormalTable[index];
paulo@89 1358 } else {
paulo@89 1359 // due to floating-point arithmetic, values in the table with
paulo@89 1360 // 4 significant figures can nevertheless end up as repeating
paulo@89 1361 // fractions when they're computed here.
paulo@89 1362 return +(1 - standardNormalTable[index]).toFixed(4);
paulo@89 1363 }
paulo@89 1364 }
paulo@89 1365
paulo@89 1366 module.exports = cumulativeStdNormalProbability;
paulo@89 1367
paulo@89 1368 },{"55":55}],13:[function(require,module,exports){
paulo@89 1369 'use strict';
paulo@89 1370 /* @flow */
paulo@89 1371
paulo@89 1372 /**
paulo@89 1373 * We use `ε`, epsilon, as a stopping criterion when we want to iterate
paulo@89 1374 * until we're "close enough". Epsilon is a very small number: for
paulo@89 1375 * simple statistics, that number is **0.0001**
paulo@89 1376 *
paulo@89 1377 * This is used in calculations like the binomialDistribution, in which
paulo@89 1378 * the process of finding a value is [iterative](https://en.wikipedia.org/wiki/Iterative_method):
paulo@89 1379 * it progresses until it is close enough.
paulo@89 1380 *
paulo@89 1381 * Below is an example of using epsilon in [gradient descent](https://en.wikipedia.org/wiki/Gradient_descent),
paulo@89 1382 * where we're trying to find a local minimum of a function's derivative,
paulo@89 1383 * given by the `fDerivative` method.
paulo@89 1384 *
paulo@89 1385 * @example
paulo@89 1386 * // From calculation, we expect that the local minimum occurs at x=9/4
paulo@89 1387 * var x_old = 0;
paulo@89 1388 * // The algorithm starts at x=6
paulo@89 1389 * var x_new = 6;
paulo@89 1390 * var stepSize = 0.01;
paulo@89 1391 *
paulo@89 1392 * function fDerivative(x) {
paulo@89 1393 * return 4 * Math.pow(x, 3) - 9 * Math.pow(x, 2);
paulo@89 1394 * }
paulo@89 1395 *
paulo@89 1396 * // The loop runs until the difference between the previous
paulo@89 1397 * // value and the current value is smaller than epsilon - a rough
paulo@89 1398 * // meaure of 'close enough'
paulo@89 1399 * while (Math.abs(x_new - x_old) > ss.epsilon) {
paulo@89 1400 * x_old = x_new;
paulo@89 1401 * x_new = x_old - stepSize * fDerivative(x_old);
paulo@89 1402 * }
paulo@89 1403 *
paulo@89 1404 * console.log('Local minimum occurs at', x_new);
paulo@89 1405 */
paulo@89 1406 var epsilon = 0.0001;
paulo@89 1407
paulo@89 1408 module.exports = epsilon;
paulo@89 1409
paulo@89 1410 },{}],14:[function(require,module,exports){
paulo@89 1411 'use strict';
paulo@89 1412 /* @flow */
paulo@89 1413
paulo@89 1414 var max = require(23),
paulo@89 1415 min = require(29);
paulo@89 1416
paulo@89 1417 /**
paulo@89 1418 * Given an array of data, this will find the extent of the
paulo@89 1419 * data and return an array of breaks that can be used
paulo@89 1420 * to categorize the data into a number of classes. The
paulo@89 1421 * returned array will always be 1 longer than the number of
paulo@89 1422 * classes because it includes the minimum value.
paulo@89 1423 *
paulo@89 1424 * @param {Array<number>} data input data, as an array of number values
paulo@89 1425 * @param {number} nClasses number of desired classes
paulo@89 1426 * @returns {Array<number>} array of class break positions
paulo@89 1427 * @example
paulo@89 1428 * equalIntervalBreaks([1, 2, 3, 4, 5, 6], 4); //= [1, 2.25, 3.5, 4.75, 6]
paulo@89 1429 */
paulo@89 1430 function equalIntervalBreaks(data/*: Array<number> */, nClasses/*:number*/)/*: Array<number> */ {
paulo@89 1431
paulo@89 1432 if (data.length <= 1) {
paulo@89 1433 return data;
paulo@89 1434 }
paulo@89 1435
paulo@89 1436 var theMin = min(data),
paulo@89 1437 theMax = max(data);
paulo@89 1438
paulo@89 1439 // the first break will always be the minimum value
paulo@89 1440 // in the dataset
paulo@89 1441 var breaks = [theMin];
paulo@89 1442
paulo@89 1443 // The size of each break is the full range of the data
paulo@89 1444 // divided by the number of classes requested
paulo@89 1445 var breakSize = (theMax - theMin) / nClasses;
paulo@89 1446
paulo@89 1447 // In the case of nClasses = 1, this loop won't run
paulo@89 1448 // and the returned breaks will be [min, max]
paulo@89 1449 for (var i = 1; i < nClasses; i++) {
paulo@89 1450 breaks.push(breaks[0] + breakSize * i);
paulo@89 1451 }
paulo@89 1452
paulo@89 1453 // the last break will always be the
paulo@89 1454 // maximum.
paulo@89 1455 breaks.push(theMax);
paulo@89 1456
paulo@89 1457 return breaks;
paulo@89 1458 }
paulo@89 1459
paulo@89 1460 module.exports = equalIntervalBreaks;
paulo@89 1461
paulo@89 1462 },{"23":23,"29":29}],15:[function(require,module,exports){
paulo@89 1463 'use strict';
paulo@89 1464 /* @flow */
paulo@89 1465
paulo@89 1466 /**
paulo@89 1467 * **[Gaussian error function](http://en.wikipedia.org/wiki/Error_function)**
paulo@89 1468 *
paulo@89 1469 * The `errorFunction(x/(sd * Math.sqrt(2)))` is the probability that a value in a
paulo@89 1470 * normal distribution with standard deviation sd is within x of the mean.
paulo@89 1471 *
paulo@89 1472 * This function returns a numerical approximation to the exact value.
paulo@89 1473 *
paulo@89 1474 * @param {number} x input
paulo@89 1475 * @return {number} error estimation
paulo@89 1476 * @example
paulo@89 1477 * errorFunction(1).toFixed(2); // => '0.84'
paulo@89 1478 */
paulo@89 1479 function errorFunction(x/*: number */)/*: number */ {
paulo@89 1480 var t = 1 / (1 + 0.5 * Math.abs(x));
paulo@89 1481 var tau = t * Math.exp(-Math.pow(x, 2) -
paulo@89 1482 1.26551223 +
paulo@89 1483 1.00002368 * t +
paulo@89 1484 0.37409196 * Math.pow(t, 2) +
paulo@89 1485 0.09678418 * Math.pow(t, 3) -
paulo@89 1486 0.18628806 * Math.pow(t, 4) +
paulo@89 1487 0.27886807 * Math.pow(t, 5) -
paulo@89 1488 1.13520398 * Math.pow(t, 6) +
paulo@89 1489 1.48851587 * Math.pow(t, 7) -
paulo@89 1490 0.82215223 * Math.pow(t, 8) +
paulo@89 1491 0.17087277 * Math.pow(t, 9));
paulo@89 1492 if (x >= 0) {
paulo@89 1493 return 1 - tau;
paulo@89 1494 } else {
paulo@89 1495 return tau - 1;
paulo@89 1496 }
paulo@89 1497 }
paulo@89 1498
paulo@89 1499 module.exports = errorFunction;
paulo@89 1500
paulo@89 1501 },{}],16:[function(require,module,exports){
paulo@89 1502 'use strict';
paulo@89 1503 /* @flow */
paulo@89 1504
paulo@89 1505 /**
paulo@89 1506 * A [Factorial](https://en.wikipedia.org/wiki/Factorial), usually written n!, is the product of all positive
paulo@89 1507 * integers less than or equal to n. Often factorial is implemented
paulo@89 1508 * recursively, but this iterative approach is significantly faster
paulo@89 1509 * and simpler.
paulo@89 1510 *
paulo@89 1511 * @param {number} n input
paulo@89 1512 * @returns {number} factorial: n!
paulo@89 1513 * @example
paulo@89 1514 * factorial(5); // => 120
paulo@89 1515 */
paulo@89 1516 function factorial(n /*: number */)/*: number */ {
paulo@89 1517
paulo@89 1518 // factorial is mathematically undefined for negative numbers
paulo@89 1519 if (n < 0) { return NaN; }
paulo@89 1520
paulo@89 1521 // typically you'll expand the factorial function going down, like
paulo@89 1522 // 5! = 5 * 4 * 3 * 2 * 1. This is going in the opposite direction,
paulo@89 1523 // counting from 2 up to the number in question, and since anything
paulo@89 1524 // multiplied by 1 is itself, the loop only needs to start at 2.
paulo@89 1525 var accumulator = 1;
paulo@89 1526 for (var i = 2; i <= n; i++) {
paulo@89 1527 // for each number up to and including the number `n`, multiply
paulo@89 1528 // the accumulator my that number.
paulo@89 1529 accumulator *= i;
paulo@89 1530 }
paulo@89 1531 return accumulator;
paulo@89 1532 }
paulo@89 1533
paulo@89 1534 module.exports = factorial;
paulo@89 1535
paulo@89 1536 },{}],17:[function(require,module,exports){
paulo@89 1537 'use strict';
paulo@89 1538 /* @flow */
paulo@89 1539
paulo@89 1540 /**
paulo@89 1541 * The [Geometric Mean](https://en.wikipedia.org/wiki/Geometric_mean) is
paulo@89 1542 * a mean function that is more useful for numbers in different
paulo@89 1543 * ranges.
paulo@89 1544 *
paulo@89 1545 * This is the nth root of the input numbers multiplied by each other.
paulo@89 1546 *
paulo@89 1547 * The geometric mean is often useful for
paulo@89 1548 * **[proportional growth](https://en.wikipedia.org/wiki/Geometric_mean#Proportional_growth)**: given
paulo@89 1549 * growth rates for multiple years, like _80%, 16.66% and 42.85%_, a simple
paulo@89 1550 * mean will incorrectly estimate an average growth rate, whereas a geometric
paulo@89 1551 * mean will correctly estimate a growth rate that, over those years,
paulo@89 1552 * will yield the same end value.
paulo@89 1553 *
paulo@89 1554 * This runs on `O(n)`, linear time in respect to the array
paulo@89 1555 *
paulo@89 1556 * @param {Array<number>} x input array
paulo@89 1557 * @returns {number} geometric mean
paulo@89 1558 * @example
paulo@89 1559 * var growthRates = [1.80, 1.166666, 1.428571];
paulo@89 1560 * var averageGrowth = geometricMean(growthRates);
paulo@89 1561 * var averageGrowthRates = [averageGrowth, averageGrowth, averageGrowth];
paulo@89 1562 * var startingValue = 10;
paulo@89 1563 * var startingValueMean = 10;
paulo@89 1564 * growthRates.forEach(function(rate) {
paulo@89 1565 * startingValue *= rate;
paulo@89 1566 * });
paulo@89 1567 * averageGrowthRates.forEach(function(rate) {
paulo@89 1568 * startingValueMean *= rate;
paulo@89 1569 * });
paulo@89 1570 * startingValueMean === startingValue;
paulo@89 1571 */
paulo@89 1572 function geometricMean(x /*: Array<number> */) {
paulo@89 1573 // The mean of no numbers is null
paulo@89 1574 if (x.length === 0) { return undefined; }
paulo@89 1575
paulo@89 1576 // the starting value.
paulo@89 1577 var value = 1;
paulo@89 1578
paulo@89 1579 for (var i = 0; i < x.length; i++) {
paulo@89 1580 // the geometric mean is only valid for positive numbers
paulo@89 1581 if (x[i] <= 0) { return undefined; }
paulo@89 1582
paulo@89 1583 // repeatedly multiply the value by each number
paulo@89 1584 value *= x[i];
paulo@89 1585 }
paulo@89 1586
paulo@89 1587 return Math.pow(value, 1 / x.length);
paulo@89 1588 }
paulo@89 1589
paulo@89 1590 module.exports = geometricMean;
paulo@89 1591
paulo@89 1592 },{}],18:[function(require,module,exports){
paulo@89 1593 'use strict';
paulo@89 1594 /* @flow */
paulo@89 1595
paulo@89 1596 /**
paulo@89 1597 * The [Harmonic Mean](https://en.wikipedia.org/wiki/Harmonic_mean) is
paulo@89 1598 * a mean function typically used to find the average of rates.
paulo@89 1599 * This mean is calculated by taking the reciprocal of the arithmetic mean
paulo@89 1600 * of the reciprocals of the input numbers.
paulo@89 1601 *
paulo@89 1602 * This is a [measure of central tendency](https://en.wikipedia.org/wiki/Central_tendency):
paulo@89 1603 * a method of finding a typical or central value of a set of numbers.
paulo@89 1604 *
paulo@89 1605 * This runs on `O(n)`, linear time in respect to the array.
paulo@89 1606 *
paulo@89 1607 * @param {Array<number>} x input
paulo@89 1608 * @returns {number} harmonic mean
paulo@89 1609 * @example
paulo@89 1610 * harmonicMean([2, 3]).toFixed(2) // => '2.40'
paulo@89 1611 */
paulo@89 1612 function harmonicMean(x /*: Array<number> */) {
paulo@89 1613 // The mean of no numbers is null
paulo@89 1614 if (x.length === 0) { return undefined; }
paulo@89 1615
paulo@89 1616 var reciprocalSum = 0;
paulo@89 1617
paulo@89 1618 for (var i = 0; i < x.length; i++) {
paulo@89 1619 // the harmonic mean is only valid for positive numbers
paulo@89 1620 if (x[i] <= 0) { return undefined; }
paulo@89 1621
paulo@89 1622 reciprocalSum += 1 / x[i];
paulo@89 1623 }
paulo@89 1624
paulo@89 1625 // divide n by the the reciprocal sum
paulo@89 1626 return x.length / reciprocalSum;
paulo@89 1627 }
paulo@89 1628
paulo@89 1629 module.exports = harmonicMean;
paulo@89 1630
paulo@89 1631 },{}],19:[function(require,module,exports){
paulo@89 1632 'use strict';
paulo@89 1633 /* @flow */
paulo@89 1634
paulo@89 1635 var quantile = require(40);
paulo@89 1636
paulo@89 1637 /**
paulo@89 1638 * The [Interquartile range](http://en.wikipedia.org/wiki/Interquartile_range) is
paulo@89 1639 * a measure of statistical dispersion, or how scattered, spread, or
paulo@89 1640 * concentrated a distribution is. It's computed as the difference between
paulo@89 1641 * the third quartile and first quartile.
paulo@89 1642 *
paulo@89 1643 * @param {Array<number>} sample
paulo@89 1644 * @returns {number} interquartile range: the span between lower and upper quartile,
paulo@89 1645 * 0.25 and 0.75
paulo@89 1646 * @example
paulo@89 1647 * interquartileRange([0, 1, 2, 3]); // => 2
paulo@89 1648 */
paulo@89 1649 function interquartileRange(sample/*: Array<number> */) {
paulo@89 1650 // Interquartile range is the span between the upper quartile,
paulo@89 1651 // at `0.75`, and lower quartile, `0.25`
paulo@89 1652 var q1 = quantile(sample, 0.75),
paulo@89 1653 q2 = quantile(sample, 0.25);
paulo@89 1654
paulo@89 1655 if (typeof q1 === 'number' && typeof q2 === 'number') {
paulo@89 1656 return q1 - q2;
paulo@89 1657 }
paulo@89 1658 }
paulo@89 1659
paulo@89 1660 module.exports = interquartileRange;
paulo@89 1661
paulo@89 1662 },{"40":40}],20:[function(require,module,exports){
paulo@89 1663 'use strict';
paulo@89 1664 /* @flow */
paulo@89 1665
paulo@89 1666 /**
paulo@89 1667 * The Inverse [Gaussian error function](http://en.wikipedia.org/wiki/Error_function)
paulo@89 1668 * returns a numerical approximation to the value that would have caused
paulo@89 1669 * `errorFunction()` to return x.
paulo@89 1670 *
paulo@89 1671 * @param {number} x value of error function
paulo@89 1672 * @returns {number} estimated inverted value
paulo@89 1673 */
paulo@89 1674 function inverseErrorFunction(x/*: number */)/*: number */ {
paulo@89 1675 var a = (8 * (Math.PI - 3)) / (3 * Math.PI * (4 - Math.PI));
paulo@89 1676
paulo@89 1677 var inv = Math.sqrt(Math.sqrt(
paulo@89 1678 Math.pow(2 / (Math.PI * a) + Math.log(1 - x * x) / 2, 2) -
paulo@89 1679 Math.log(1 - x * x) / a) -
paulo@89 1680 (2 / (Math.PI * a) + Math.log(1 - x * x) / 2));
paulo@89 1681
paulo@89 1682 if (x >= 0) {
paulo@89 1683 return inv;
paulo@89 1684 } else {
paulo@89 1685 return -inv;
paulo@89 1686 }
paulo@89 1687 }
paulo@89 1688
paulo@89 1689 module.exports = inverseErrorFunction;
paulo@89 1690
paulo@89 1691 },{}],21:[function(require,module,exports){
paulo@89 1692 'use strict';
paulo@89 1693 /* @flow */
paulo@89 1694
paulo@89 1695 /**
paulo@89 1696 * [Simple linear regression](http://en.wikipedia.org/wiki/Simple_linear_regression)
paulo@89 1697 * is a simple way to find a fitted line
paulo@89 1698 * between a set of coordinates. This algorithm finds the slope and y-intercept of a regression line
paulo@89 1699 * using the least sum of squares.
paulo@89 1700 *
paulo@89 1701 * @param {Array<Array<number>>} data an array of two-element of arrays,
paulo@89 1702 * like `[[0, 1], [2, 3]]`
paulo@89 1703 * @returns {Object} object containing slope and intersect of regression line
paulo@89 1704 * @example
paulo@89 1705 * linearRegression([[0, 0], [1, 1]]); // => { m: 1, b: 0 }
paulo@89 1706 */
paulo@89 1707 function linearRegression(data/*: Array<Array<number>> */)/*: { m: number, b: number } */ {
paulo@89 1708
paulo@89 1709 var m, b;
paulo@89 1710
paulo@89 1711 // Store data length in a local variable to reduce
paulo@89 1712 // repeated object property lookups
paulo@89 1713 var dataLength = data.length;
paulo@89 1714
paulo@89 1715 //if there's only one point, arbitrarily choose a slope of 0
paulo@89 1716 //and a y-intercept of whatever the y of the initial point is
paulo@89 1717 if (dataLength === 1) {
paulo@89 1718 m = 0;
paulo@89 1719 b = data[0][1];
paulo@89 1720 } else {
paulo@89 1721 // Initialize our sums and scope the `m` and `b`
paulo@89 1722 // variables that define the line.
paulo@89 1723 var sumX = 0, sumY = 0,
paulo@89 1724 sumXX = 0, sumXY = 0;
paulo@89 1725
paulo@89 1726 // Use local variables to grab point values
paulo@89 1727 // with minimal object property lookups
paulo@89 1728 var point, x, y;
paulo@89 1729
paulo@89 1730 // Gather the sum of all x values, the sum of all
paulo@89 1731 // y values, and the sum of x^2 and (x*y) for each
paulo@89 1732 // value.
paulo@89 1733 //
paulo@89 1734 // In math notation, these would be SS_x, SS_y, SS_xx, and SS_xy
paulo@89 1735 for (var i = 0; i < dataLength; i++) {
paulo@89 1736 point = data[i];
paulo@89 1737 x = point[0];
paulo@89 1738 y = point[1];
paulo@89 1739
paulo@89 1740 sumX += x;
paulo@89 1741 sumY += y;
paulo@89 1742
paulo@89 1743 sumXX += x * x;
paulo@89 1744 sumXY += x * y;
paulo@89 1745 }
paulo@89 1746
paulo@89 1747 // `m` is the slope of the regression line
paulo@89 1748 m = ((dataLength * sumXY) - (sumX * sumY)) /
paulo@89 1749 ((dataLength * sumXX) - (sumX * sumX));
paulo@89 1750
paulo@89 1751 // `b` is the y-intercept of the line.
paulo@89 1752 b = (sumY / dataLength) - ((m * sumX) / dataLength);
paulo@89 1753 }
paulo@89 1754
paulo@89 1755 // Return both values as an object.
paulo@89 1756 return {
paulo@89 1757 m: m,
paulo@89 1758 b: b
paulo@89 1759 };
paulo@89 1760 }
paulo@89 1761
paulo@89 1762
paulo@89 1763 module.exports = linearRegression;
paulo@89 1764
paulo@89 1765 },{}],22:[function(require,module,exports){
paulo@89 1766 'use strict';
paulo@89 1767 /* @flow */
paulo@89 1768
paulo@89 1769 /**
paulo@89 1770 * Given the output of `linearRegression`: an object
paulo@89 1771 * with `m` and `b` values indicating slope and intercept,
paulo@89 1772 * respectively, generate a line function that translates
paulo@89 1773 * x values into y values.
paulo@89 1774 *
paulo@89 1775 * @param {Object} mb object with `m` and `b` members, representing
paulo@89 1776 * slope and intersect of desired line
paulo@89 1777 * @returns {Function} method that computes y-value at any given
paulo@89 1778 * x-value on the line.
paulo@89 1779 * @example
paulo@89 1780 * var l = linearRegressionLine(linearRegression([[0, 0], [1, 1]]));
paulo@89 1781 * l(0) // = 0
paulo@89 1782 * l(2) // = 2
paulo@89 1783 * linearRegressionLine({ b: 0, m: 1 })(1); // => 1
paulo@89 1784 * linearRegressionLine({ b: 1, m: 1 })(1); // => 2
paulo@89 1785 */
paulo@89 1786 function linearRegressionLine(mb/*: { b: number, m: number }*/)/*: Function */ {
paulo@89 1787 // Return a function that computes a `y` value for each
paulo@89 1788 // x value it is given, based on the values of `b` and `a`
paulo@89 1789 // that we just computed.
paulo@89 1790 return function(x) {
paulo@89 1791 return mb.b + (mb.m * x);
paulo@89 1792 };
paulo@89 1793 }
paulo@89 1794
paulo@89 1795 module.exports = linearRegressionLine;
paulo@89 1796
paulo@89 1797 },{}],23:[function(require,module,exports){
paulo@89 1798 'use strict';
paulo@89 1799 /* @flow */
paulo@89 1800
paulo@89 1801 /**
paulo@89 1802 * This computes the maximum number in an array.
paulo@89 1803 *
paulo@89 1804 * This runs on `O(n)`, linear time in respect to the array
paulo@89 1805 *
paulo@89 1806 * @param {Array<number>} x input
paulo@89 1807 * @returns {number} maximum value
paulo@89 1808 * @example
paulo@89 1809 * max([1, 2, 3, 4]);
paulo@89 1810 * // => 4
paulo@89 1811 */
paulo@89 1812 function max(x /*: Array<number> */) /*:number*/ {
paulo@89 1813 var value;
paulo@89 1814 for (var i = 0; i < x.length; i++) {
paulo@89 1815 // On the first iteration of this loop, max is
paulo@89 1816 // NaN and is thus made the maximum element in the array
paulo@89 1817 if (value === undefined || x[i] > value) {
paulo@89 1818 value = x[i];
paulo@89 1819 }
paulo@89 1820 }
paulo@89 1821 if (value === undefined) {
paulo@89 1822 return NaN;
paulo@89 1823 }
paulo@89 1824 return value;
paulo@89 1825 }
paulo@89 1826
paulo@89 1827 module.exports = max;
paulo@89 1828
paulo@89 1829 },{}],24:[function(require,module,exports){
paulo@89 1830 'use strict';
paulo@89 1831 /* @flow */
paulo@89 1832
paulo@89 1833 /**
paulo@89 1834 * The maximum is the highest number in the array. With a sorted array,
paulo@89 1835 * the last element in the array is always the largest, so this calculation
paulo@89 1836 * can be done in one step, or constant time.
paulo@89 1837 *
paulo@89 1838 * @param {Array<number>} x input
paulo@89 1839 * @returns {number} maximum value
paulo@89 1840 * @example
paulo@89 1841 * maxSorted([-100, -10, 1, 2, 5]); // => 5
paulo@89 1842 */
paulo@89 1843 function maxSorted(x /*: Array<number> */)/*:number*/ {
paulo@89 1844 return x[x.length - 1];
paulo@89 1845 }
paulo@89 1846
paulo@89 1847 module.exports = maxSorted;
paulo@89 1848
paulo@89 1849 },{}],25:[function(require,module,exports){
paulo@89 1850 'use strict';
paulo@89 1851 /* @flow */
paulo@89 1852
paulo@89 1853 var sum = require(56);
paulo@89 1854
paulo@89 1855 /**
paulo@89 1856 * The mean, _also known as average_,
paulo@89 1857 * is the sum of all values over the number of values.
paulo@89 1858 * This is a [measure of central tendency](https://en.wikipedia.org/wiki/Central_tendency):
paulo@89 1859 * a method of finding a typical or central value of a set of numbers.
paulo@89 1860 *
paulo@89 1861 * This runs on `O(n)`, linear time in respect to the array
paulo@89 1862 *
paulo@89 1863 * @param {Array<number>} x input values
paulo@89 1864 * @returns {number} mean
paulo@89 1865 * @example
paulo@89 1866 * mean([0, 10]); // => 5
paulo@89 1867 */
paulo@89 1868 function mean(x /*: Array<number> */)/*:number*/ {
paulo@89 1869 // The mean of no numbers is null
paulo@89 1870 if (x.length === 0) { return NaN; }
paulo@89 1871
paulo@89 1872 return sum(x) / x.length;
paulo@89 1873 }
paulo@89 1874
paulo@89 1875 module.exports = mean;
paulo@89 1876
paulo@89 1877 },{"56":56}],26:[function(require,module,exports){
paulo@89 1878 'use strict';
paulo@89 1879 /* @flow */
paulo@89 1880
paulo@89 1881 var quantile = require(40);
paulo@89 1882
paulo@89 1883 /**
paulo@89 1884 * The [median](http://en.wikipedia.org/wiki/Median) is
paulo@89 1885 * the middle number of a list. This is often a good indicator of 'the middle'
paulo@89 1886 * when there are outliers that skew the `mean()` value.
paulo@89 1887 * This is a [measure of central tendency](https://en.wikipedia.org/wiki/Central_tendency):
paulo@89 1888 * a method of finding a typical or central value of a set of numbers.
paulo@89 1889 *
paulo@89 1890 * The median isn't necessarily one of the elements in the list: the value
paulo@89 1891 * can be the average of two elements if the list has an even length
paulo@89 1892 * and the two central values are different.
paulo@89 1893 *
paulo@89 1894 * @param {Array<number>} x input
paulo@89 1895 * @returns {number} median value
paulo@89 1896 * @example
paulo@89 1897 * median([10, 2, 5, 100, 2, 1]); // => 3.5
paulo@89 1898 */
paulo@89 1899 function median(x /*: Array<number> */)/*:number*/ {
paulo@89 1900 return +quantile(x, 0.5);
paulo@89 1901 }
paulo@89 1902
paulo@89 1903 module.exports = median;
paulo@89 1904
paulo@89 1905 },{"40":40}],27:[function(require,module,exports){
paulo@89 1906 'use strict';
paulo@89 1907 /* @flow */
paulo@89 1908
paulo@89 1909 var median = require(26);
paulo@89 1910
paulo@89 1911 /**
paulo@89 1912 * The [Median Absolute Deviation](http://en.wikipedia.org/wiki/Median_absolute_deviation) is
paulo@89 1913 * a robust measure of statistical
paulo@89 1914 * dispersion. It is more resilient to outliers than the standard deviation.
paulo@89 1915 *
paulo@89 1916 * @param {Array<number>} x input array
paulo@89 1917 * @returns {number} median absolute deviation
paulo@89 1918 * @example
paulo@89 1919 * medianAbsoluteDeviation([1, 1, 2, 2, 4, 6, 9]); // => 1
paulo@89 1920 */
paulo@89 1921 function medianAbsoluteDeviation(x /*: Array<number> */) {
paulo@89 1922 // The mad of nothing is null
paulo@89 1923 var medianValue = median(x),
paulo@89 1924 medianAbsoluteDeviations = [];
paulo@89 1925
paulo@89 1926 // Make a list of absolute deviations from the median
paulo@89 1927 for (var i = 0; i < x.length; i++) {
paulo@89 1928 medianAbsoluteDeviations.push(Math.abs(x[i] - medianValue));
paulo@89 1929 }
paulo@89 1930
paulo@89 1931 // Find the median value of that list
paulo@89 1932 return median(medianAbsoluteDeviations);
paulo@89 1933 }
paulo@89 1934
paulo@89 1935 module.exports = medianAbsoluteDeviation;
paulo@89 1936
paulo@89 1937 },{"26":26}],28:[function(require,module,exports){
paulo@89 1938 'use strict';
paulo@89 1939 /* @flow */
paulo@89 1940
paulo@89 1941 var quantileSorted = require(41);
paulo@89 1942
paulo@89 1943 /**
paulo@89 1944 * The [median](http://en.wikipedia.org/wiki/Median) is
paulo@89 1945 * the middle number of a list. This is often a good indicator of 'the middle'
paulo@89 1946 * when there are outliers that skew the `mean()` value.
paulo@89 1947 * This is a [measure of central tendency](https://en.wikipedia.org/wiki/Central_tendency):
paulo@89 1948 * a method of finding a typical or central value of a set of numbers.
paulo@89 1949 *
paulo@89 1950 * The median isn't necessarily one of the elements in the list: the value
paulo@89 1951 * can be the average of two elements if the list has an even length
paulo@89 1952 * and the two central values are different.
paulo@89 1953 *
paulo@89 1954 * @param {Array<number>} sorted input
paulo@89 1955 * @returns {number} median value
paulo@89 1956 * @example
paulo@89 1957 * medianSorted([10, 2, 5, 100, 2, 1]); // => 52.5
paulo@89 1958 */
paulo@89 1959 function medianSorted(sorted /*: Array<number> */)/*:number*/ {
paulo@89 1960 return quantileSorted(sorted, 0.5);
paulo@89 1961 }
paulo@89 1962
paulo@89 1963 module.exports = medianSorted;
paulo@89 1964
paulo@89 1965 },{"41":41}],29:[function(require,module,exports){
paulo@89 1966 'use strict';
paulo@89 1967 /* @flow */
paulo@89 1968
paulo@89 1969 /**
paulo@89 1970 * The min is the lowest number in the array. This runs on `O(n)`, linear time in respect to the array
paulo@89 1971 *
paulo@89 1972 * @param {Array<number>} x input
paulo@89 1973 * @returns {number} minimum value
paulo@89 1974 * @example
paulo@89 1975 * min([1, 5, -10, 100, 2]); // => -10
paulo@89 1976 */
paulo@89 1977 function min(x /*: Array<number> */)/*:number*/ {
paulo@89 1978 var value;
paulo@89 1979 for (var i = 0; i < x.length; i++) {
paulo@89 1980 // On the first iteration of this loop, min is
paulo@89 1981 // NaN and is thus made the minimum element in the array
paulo@89 1982 if (value === undefined || x[i] < value) {
paulo@89 1983 value = x[i];
paulo@89 1984 }
paulo@89 1985 }
paulo@89 1986 if (value === undefined) {
paulo@89 1987 return NaN;
paulo@89 1988 }
paulo@89 1989 return value;
paulo@89 1990 }
paulo@89 1991
paulo@89 1992 module.exports = min;
paulo@89 1993
paulo@89 1994 },{}],30:[function(require,module,exports){
paulo@89 1995 'use strict';
paulo@89 1996 /* @flow */
paulo@89 1997
paulo@89 1998 /**
paulo@89 1999 * The minimum is the lowest number in the array. With a sorted array,
paulo@89 2000 * the first element in the array is always the smallest, so this calculation
paulo@89 2001 * can be done in one step, or constant time.
paulo@89 2002 *
paulo@89 2003 * @param {Array<number>} x input
paulo@89 2004 * @returns {number} minimum value
paulo@89 2005 * @example
paulo@89 2006 * minSorted([-100, -10, 1, 2, 5]); // => -100
paulo@89 2007 */
paulo@89 2008 function minSorted(x /*: Array<number> */)/*:number*/ {
paulo@89 2009 return x[0];
paulo@89 2010 }
paulo@89 2011
paulo@89 2012 module.exports = minSorted;
paulo@89 2013
paulo@89 2014 },{}],31:[function(require,module,exports){
paulo@89 2015 'use strict';
paulo@89 2016 /* @flow */
paulo@89 2017
paulo@89 2018 /**
paulo@89 2019 * **Mixin** simple_statistics to a single Array instance if provided
paulo@89 2020 * or the Array native object if not. This is an optional
paulo@89 2021 * feature that lets you treat simple_statistics as a native feature
paulo@89 2022 * of Javascript.
paulo@89 2023 *
paulo@89 2024 * @param {Object} ss simple statistics
paulo@89 2025 * @param {Array} [array=] a single array instance which will be augmented
paulo@89 2026 * with the extra methods. If omitted, mixin will apply to all arrays
paulo@89 2027 * by changing the global `Array.prototype`.
paulo@89 2028 * @returns {*} the extended Array, or Array.prototype if no object
paulo@89 2029 * is given.
paulo@89 2030 *
paulo@89 2031 * @example
paulo@89 2032 * var myNumbers = [1, 2, 3];
paulo@89 2033 * mixin(ss, myNumbers);
paulo@89 2034 * console.log(myNumbers.sum()); // 6
paulo@89 2035 */
paulo@89 2036 function mixin(ss /*: Object */, array /*: ?Array<any> */)/*: any */ {
paulo@89 2037 var support = !!(Object.defineProperty && Object.defineProperties);
paulo@89 2038 // Coverage testing will never test this error.
paulo@89 2039 /* istanbul ignore next */
paulo@89 2040 if (!support) {
paulo@89 2041 throw new Error('without defineProperty, simple-statistics cannot be mixed in');
paulo@89 2042 }
paulo@89 2043
paulo@89 2044 // only methods which work on basic arrays in a single step
paulo@89 2045 // are supported
paulo@89 2046 var arrayMethods = ['median', 'standardDeviation', 'sum', 'product',
paulo@89 2047 'sampleSkewness',
paulo@89 2048 'mean', 'min', 'max', 'quantile', 'geometricMean',
paulo@89 2049 'harmonicMean', 'root_mean_square'];
paulo@89 2050
paulo@89 2051 // create a closure with a method name so that a reference
paulo@89 2052 // like `arrayMethods[i]` doesn't follow the loop increment
paulo@89 2053 function wrap(method) {
paulo@89 2054 return function() {
paulo@89 2055 // cast any arguments into an array, since they're
paulo@89 2056 // natively objects
paulo@89 2057 var args = Array.prototype.slice.apply(arguments);
paulo@89 2058 // make the first argument the array itself
paulo@89 2059 args.unshift(this);
paulo@89 2060 // return the result of the ss method
paulo@89 2061 return ss[method].apply(ss, args);
paulo@89 2062 };
paulo@89 2063 }
paulo@89 2064
paulo@89 2065 // select object to extend
paulo@89 2066 var extending;
paulo@89 2067 if (array) {
paulo@89 2068 // create a shallow copy of the array so that our internal
paulo@89 2069 // operations do not change it by reference
paulo@89 2070 extending = array.slice();
paulo@89 2071 } else {
paulo@89 2072 extending = Array.prototype;
paulo@89 2073 }
paulo@89 2074
paulo@89 2075 // for each array function, define a function that gets
paulo@89 2076 // the array as the first argument.
paulo@89 2077 // We use [defineProperty](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/defineProperty)
paulo@89 2078 // because it allows these properties to be non-enumerable:
paulo@89 2079 // `for (var in x)` loops will not run into problems with this
paulo@89 2080 // implementation.
paulo@89 2081 for (var i = 0; i < arrayMethods.length; i++) {
paulo@89 2082 Object.defineProperty(extending, arrayMethods[i], {
paulo@89 2083 value: wrap(arrayMethods[i]),
paulo@89 2084 configurable: true,
paulo@89 2085 enumerable: false,
paulo@89 2086 writable: true
paulo@89 2087 });
paulo@89 2088 }
paulo@89 2089
paulo@89 2090 return extending;
paulo@89 2091 }
paulo@89 2092
paulo@89 2093 module.exports = mixin;
paulo@89 2094
paulo@89 2095 },{}],32:[function(require,module,exports){
paulo@89 2096 'use strict';
paulo@89 2097 /* @flow */
paulo@89 2098
paulo@89 2099 var numericSort = require(34),
paulo@89 2100 modeSorted = require(33);
paulo@89 2101
paulo@89 2102 /**
paulo@89 2103 * The [mode](http://bit.ly/W5K4Yt) is the number that appears in a list the highest number of times.
paulo@89 2104 * There can be multiple modes in a list: in the event of a tie, this
paulo@89 2105 * algorithm will return the most recently seen mode.
paulo@89 2106 *
paulo@89 2107 * This is a [measure of central tendency](https://en.wikipedia.org/wiki/Central_tendency):
paulo@89 2108 * a method of finding a typical or central value of a set of numbers.
paulo@89 2109 *
paulo@89 2110 * This runs on `O(nlog(n))` because it needs to sort the array internally
paulo@89 2111 * before running an `O(n)` search to find the mode.
paulo@89 2112 *
paulo@89 2113 * @param {Array<number>} x input
paulo@89 2114 * @returns {number} mode
paulo@89 2115 * @example
paulo@89 2116 * mode([0, 0, 1]); // => 0
paulo@89 2117 */
paulo@89 2118 function mode(x /*: Array<number> */)/*:number*/ {
paulo@89 2119 // Sorting the array lets us iterate through it below and be sure
paulo@89 2120 // that every time we see a new number it's new and we'll never
paulo@89 2121 // see the same number twice
paulo@89 2122 return modeSorted(numericSort(x));
paulo@89 2123 }
paulo@89 2124
paulo@89 2125 module.exports = mode;
paulo@89 2126
paulo@89 2127 },{"33":33,"34":34}],33:[function(require,module,exports){
paulo@89 2128 'use strict';
paulo@89 2129 /* @flow */
paulo@89 2130
paulo@89 2131 /**
paulo@89 2132 * The [mode](http://bit.ly/W5K4Yt) is the number that appears in a list the highest number of times.
paulo@89 2133 * There can be multiple modes in a list: in the event of a tie, this
paulo@89 2134 * algorithm will return the most recently seen mode.
paulo@89 2135 *
paulo@89 2136 * This is a [measure of central tendency](https://en.wikipedia.org/wiki/Central_tendency):
paulo@89 2137 * a method of finding a typical or central value of a set of numbers.
paulo@89 2138 *
paulo@89 2139 * This runs in `O(n)` because the input is sorted.
paulo@89 2140 *
paulo@89 2141 * @param {Array<number>} sorted input
paulo@89 2142 * @returns {number} mode
paulo@89 2143 * @example
paulo@89 2144 * modeSorted([0, 0, 1]); // => 0
paulo@89 2145 */
paulo@89 2146 function modeSorted(sorted /*: Array<number> */)/*:number*/ {
paulo@89 2147
paulo@89 2148 // Handle edge cases:
paulo@89 2149 // The mode of an empty list is NaN
paulo@89 2150 if (sorted.length === 0) { return NaN; }
paulo@89 2151 else if (sorted.length === 1) { return sorted[0]; }
paulo@89 2152
paulo@89 2153 // This assumes it is dealing with an array of size > 1, since size
paulo@89 2154 // 0 and 1 are handled immediately. Hence it starts at index 1 in the
paulo@89 2155 // array.
paulo@89 2156 var last = sorted[0],
paulo@89 2157 // store the mode as we find new modes
paulo@89 2158 value = NaN,
paulo@89 2159 // store how many times we've seen the mode
paulo@89 2160 maxSeen = 0,
paulo@89 2161 // how many times the current candidate for the mode
paulo@89 2162 // has been seen
paulo@89 2163 seenThis = 1;
paulo@89 2164
paulo@89 2165 // end at sorted.length + 1 to fix the case in which the mode is
paulo@89 2166 // the highest number that occurs in the sequence. the last iteration
paulo@89 2167 // compares sorted[i], which is undefined, to the highest number
paulo@89 2168 // in the series
paulo@89 2169 for (var i = 1; i < sorted.length + 1; i++) {
paulo@89 2170 // we're seeing a new number pass by
paulo@89 2171 if (sorted[i] !== last) {
paulo@89 2172 // the last number is the new mode since we saw it more
paulo@89 2173 // often than the old one
paulo@89 2174 if (seenThis > maxSeen) {
paulo@89 2175 maxSeen = seenThis;
paulo@89 2176 value = last;
paulo@89 2177 }
paulo@89 2178 seenThis = 1;
paulo@89 2179 last = sorted[i];
paulo@89 2180 // if this isn't a new number, it's one more occurrence of
paulo@89 2181 // the potential mode
paulo@89 2182 } else { seenThis++; }
paulo@89 2183 }
paulo@89 2184 return value;
paulo@89 2185 }
paulo@89 2186
paulo@89 2187 module.exports = modeSorted;
paulo@89 2188
paulo@89 2189 },{}],34:[function(require,module,exports){
paulo@89 2190 'use strict';
paulo@89 2191 /* @flow */
paulo@89 2192
paulo@89 2193 /**
paulo@89 2194 * Sort an array of numbers by their numeric value, ensuring that the
paulo@89 2195 * array is not changed in place.
paulo@89 2196 *
paulo@89 2197 * This is necessary because the default behavior of .sort
paulo@89 2198 * in JavaScript is to sort arrays as string values
paulo@89 2199 *
paulo@89 2200 * [1, 10, 12, 102, 20].sort()
paulo@89 2201 * // output
paulo@89 2202 * [1, 10, 102, 12, 20]
paulo@89 2203 *
paulo@89 2204 * @param {Array<number>} array input array
paulo@89 2205 * @return {Array<number>} sorted array
paulo@89 2206 * @private
paulo@89 2207 * @example
paulo@89 2208 * numericSort([3, 2, 1]) // => [1, 2, 3]
paulo@89 2209 */
paulo@89 2210 function numericSort(array /*: Array<number> */) /*: Array<number> */ {
paulo@89 2211 return array
paulo@89 2212 // ensure the array is not changed in-place
paulo@89 2213 .slice()
paulo@89 2214 // comparator function that treats input as numeric
paulo@89 2215 .sort(function(a, b) {
paulo@89 2216 return a - b;
paulo@89 2217 });
paulo@89 2218 }
paulo@89 2219
paulo@89 2220 module.exports = numericSort;
paulo@89 2221
paulo@89 2222 },{}],35:[function(require,module,exports){
paulo@89 2223 'use strict';
paulo@89 2224 /* @flow */
paulo@89 2225
paulo@89 2226 /**
paulo@89 2227 * This is a single-layer [Perceptron Classifier](http://en.wikipedia.org/wiki/Perceptron) that takes
paulo@89 2228 * arrays of numbers and predicts whether they should be classified
paulo@89 2229 * as either 0 or 1 (negative or positive examples).
paulo@89 2230 * @class
paulo@89 2231 * @example
paulo@89 2232 * // Create the model
paulo@89 2233 * var p = new PerceptronModel();
paulo@89 2234 * // Train the model with input with a diagonal boundary.
paulo@89 2235 * for (var i = 0; i < 5; i++) {
paulo@89 2236 * p.train([1, 1], 1);
paulo@89 2237 * p.train([0, 1], 0);
paulo@89 2238 * p.train([1, 0], 0);
paulo@89 2239 * p.train([0, 0], 0);
paulo@89 2240 * }
paulo@89 2241 * p.predict([0, 0]); // 0
paulo@89 2242 * p.predict([0, 1]); // 0
paulo@89 2243 * p.predict([1, 0]); // 0
paulo@89 2244 * p.predict([1, 1]); // 1
paulo@89 2245 */
paulo@89 2246 function PerceptronModel() {
paulo@89 2247 // The weights, or coefficients of the model;
paulo@89 2248 // weights are only populated when training with data.
paulo@89 2249 this.weights = [];
paulo@89 2250 // The bias term, or intercept; it is also a weight but
paulo@89 2251 // it's stored separately for convenience as it is always
paulo@89 2252 // multiplied by one.
paulo@89 2253 this.bias = 0;
paulo@89 2254 }
paulo@89 2255
paulo@89 2256 /**
paulo@89 2257 * **Predict**: Use an array of features with the weight array and bias
paulo@89 2258 * to predict whether an example is labeled 0 or 1.
paulo@89 2259 *
paulo@89 2260 * @param {Array<number>} features an array of features as numbers
paulo@89 2261 * @returns {number} 1 if the score is over 0, otherwise 0
paulo@89 2262 */
paulo@89 2263 PerceptronModel.prototype.predict = function(features) {
paulo@89 2264
paulo@89 2265 // Only predict if previously trained
paulo@89 2266 // on the same size feature array(s).
paulo@89 2267 if (features.length !== this.weights.length) { return null; }
paulo@89 2268
paulo@89 2269 // Calculate the sum of features times weights,
paulo@89 2270 // with the bias added (implicitly times one).
paulo@89 2271 var score = 0;
paulo@89 2272 for (var i = 0; i < this.weights.length; i++) {
paulo@89 2273 score += this.weights[i] * features[i];
paulo@89 2274 }
paulo@89 2275 score += this.bias;
paulo@89 2276
paulo@89 2277 // Classify as 1 if the score is over 0, otherwise 0.
paulo@89 2278 if (score > 0) {
paulo@89 2279 return 1;
paulo@89 2280 } else {
paulo@89 2281 return 0;
paulo@89 2282 }
paulo@89 2283 };
paulo@89 2284
paulo@89 2285 /**
paulo@89 2286 * **Train** the classifier with a new example, which is
paulo@89 2287 * a numeric array of features and a 0 or 1 label.
paulo@89 2288 *
paulo@89 2289 * @param {Array<number>} features an array of features as numbers
paulo@89 2290 * @param {number} label either 0 or 1
paulo@89 2291 * @returns {PerceptronModel} this
paulo@89 2292 */
paulo@89 2293 PerceptronModel.prototype.train = function(features, label) {
paulo@89 2294 // Require that only labels of 0 or 1 are considered.
paulo@89 2295 if (label !== 0 && label !== 1) { return null; }
paulo@89 2296 // The length of the feature array determines
paulo@89 2297 // the length of the weight array.
paulo@89 2298 // The perceptron will continue learning as long as
paulo@89 2299 // it keeps seeing feature arrays of the same length.
paulo@89 2300 // When it sees a new data shape, it initializes.
paulo@89 2301 if (features.length !== this.weights.length) {
paulo@89 2302 this.weights = features;
paulo@89 2303 this.bias = 1;
paulo@89 2304 }
paulo@89 2305 // Make a prediction based on current weights.
paulo@89 2306 var prediction = this.predict(features);
paulo@89 2307 // Update the weights if the prediction is wrong.
paulo@89 2308 if (prediction !== label) {
paulo@89 2309 var gradient = label - prediction;
paulo@89 2310 for (var i = 0; i < this.weights.length; i++) {
paulo@89 2311 this.weights[i] += gradient * features[i];
paulo@89 2312 }
paulo@89 2313 this.bias += gradient;
paulo@89 2314 }
paulo@89 2315 return this;
paulo@89 2316 };
paulo@89 2317
paulo@89 2318 module.exports = PerceptronModel;
paulo@89 2319
paulo@89 2320 },{}],36:[function(require,module,exports){
paulo@89 2321 /* @flow */
paulo@89 2322
paulo@89 2323 'use strict';
paulo@89 2324
paulo@89 2325 /**
paulo@89 2326 * Implementation of [Heap's Algorithm](https://en.wikipedia.org/wiki/Heap%27s_algorithm)
paulo@89 2327 * for generating permutations.
paulo@89 2328 *
paulo@89 2329 * @param {Array} elements any type of data
paulo@89 2330 * @returns {Array<Array>} array of permutations
paulo@89 2331 */
paulo@89 2332 function permutationsHeap/*:: <T> */(elements /*: Array<T> */)/*: Array<Array<T>> */ {
paulo@89 2333 var indexes = new Array(elements.length);
paulo@89 2334 var permutations = [elements.slice()];
paulo@89 2335
paulo@89 2336 for (var i = 0; i < elements.length; i++) {
paulo@89 2337 indexes[i] = 0;
paulo@89 2338 }
paulo@89 2339
paulo@89 2340 for (i = 0; i < elements.length;) {
paulo@89 2341 if (indexes[i] < i) {
paulo@89 2342
paulo@89 2343 // At odd indexes, swap from indexes[i] instead
paulo@89 2344 // of from the beginning of the array
paulo@89 2345 var swapFrom = 0;
paulo@89 2346 if (i % 2 !== 0) {
paulo@89 2347 swapFrom = indexes[i];
paulo@89 2348 }
paulo@89 2349
paulo@89 2350 // swap between swapFrom and i, using
paulo@89 2351 // a temporary variable as storage.
paulo@89 2352 var temp = elements[swapFrom];
paulo@89 2353 elements[swapFrom] = elements[i];
paulo@89 2354 elements[i] = temp;
paulo@89 2355
paulo@89 2356 permutations.push(elements.slice());
paulo@89 2357 indexes[i]++;
paulo@89 2358 i = 0;
paulo@89 2359
paulo@89 2360 } else {
paulo@89 2361 indexes[i] = 0;
paulo@89 2362 i++;
paulo@89 2363 }
paulo@89 2364 }
paulo@89 2365
paulo@89 2366 return permutations;
paulo@89 2367 }
paulo@89 2368
paulo@89 2369 module.exports = permutationsHeap;
paulo@89 2370
paulo@89 2371 },{}],37:[function(require,module,exports){
paulo@89 2372 'use strict';
paulo@89 2373 /* @flow */
paulo@89 2374
paulo@89 2375 var epsilon = require(13);
paulo@89 2376 var factorial = require(16);
paulo@89 2377
paulo@89 2378 /**
paulo@89 2379 * The [Poisson Distribution](http://en.wikipedia.org/wiki/Poisson_distribution)
paulo@89 2380 * is a discrete probability distribution that expresses the probability
paulo@89 2381 * of a given number of events occurring in a fixed interval of time
paulo@89 2382 * and/or space if these events occur with a known average rate and
paulo@89 2383 * independently of the time since the last event.
paulo@89 2384 *
paulo@89 2385 * The Poisson Distribution is characterized by the strictly positive
paulo@89 2386 * mean arrival or occurrence rate, `λ`.
paulo@89 2387 *
paulo@89 2388 * @param {number} lambda location poisson distribution
paulo@89 2389 * @returns {number} value of poisson distribution at that point
paulo@89 2390 */
paulo@89 2391 function poissonDistribution(lambda/*: number */) {
paulo@89 2392 // Check that lambda is strictly positive
paulo@89 2393 if (lambda <= 0) { return undefined; }
paulo@89 2394
paulo@89 2395 // our current place in the distribution
paulo@89 2396 var x = 0,
paulo@89 2397 // and we keep track of the current cumulative probability, in
paulo@89 2398 // order to know when to stop calculating chances.
paulo@89 2399 cumulativeProbability = 0,
paulo@89 2400 // the calculated cells to be returned
paulo@89 2401 cells = {};
paulo@89 2402
paulo@89 2403 // This algorithm iterates through each potential outcome,
paulo@89 2404 // until the `cumulativeProbability` is very close to 1, at
paulo@89 2405 // which point we've defined the vast majority of outcomes
paulo@89 2406 do {
paulo@89 2407 // a [probability mass function](https://en.wikipedia.org/wiki/Probability_mass_function)
paulo@89 2408 cells[x] = (Math.pow(Math.E, -lambda) * Math.pow(lambda, x)) / factorial(x);
paulo@89 2409 cumulativeProbability += cells[x];
paulo@89 2410 x++;
paulo@89 2411 // when the cumulativeProbability is nearly 1, we've calculated
paulo@89 2412 // the useful range of this distribution
paulo@89 2413 } while (cumulativeProbability < 1 - epsilon);
paulo@89 2414
paulo@89 2415 return cells;
paulo@89 2416 }
paulo@89 2417
paulo@89 2418 module.exports = poissonDistribution;
paulo@89 2419
paulo@89 2420 },{"13":13,"16":16}],38:[function(require,module,exports){
paulo@89 2421 'use strict';
paulo@89 2422 /* @flow */
paulo@89 2423
paulo@89 2424 var epsilon = require(13);
paulo@89 2425 var inverseErrorFunction = require(20);
paulo@89 2426
paulo@89 2427 /**
paulo@89 2428 * The [Probit](http://en.wikipedia.org/wiki/Probit)
paulo@89 2429 * is the inverse of cumulativeStdNormalProbability(),
paulo@89 2430 * and is also known as the normal quantile function.
paulo@89 2431 *
paulo@89 2432 * It returns the number of standard deviations from the mean
paulo@89 2433 * where the p'th quantile of values can be found in a normal distribution.
paulo@89 2434 * So, for example, probit(0.5 + 0.6827/2) ≈ 1 because 68.27% of values are
paulo@89 2435 * normally found within 1 standard deviation above or below the mean.
paulo@89 2436 *
paulo@89 2437 * @param {number} p
paulo@89 2438 * @returns {number} probit
paulo@89 2439 */
paulo@89 2440 function probit(p /*: number */)/*: number */ {
paulo@89 2441 if (p === 0) {
paulo@89 2442 p = epsilon;
paulo@89 2443 } else if (p >= 1) {
paulo@89 2444 p = 1 - epsilon;
paulo@89 2445 }
paulo@89 2446 return Math.sqrt(2) * inverseErrorFunction(2 * p - 1);
paulo@89 2447 }
paulo@89 2448
paulo@89 2449 module.exports = probit;
paulo@89 2450
paulo@89 2451 },{"13":13,"20":20}],39:[function(require,module,exports){
paulo@89 2452 'use strict';
paulo@89 2453 /* @flow */
paulo@89 2454
paulo@89 2455 /**
paulo@89 2456 * The [product](https://en.wikipedia.org/wiki/Product_(mathematics)) of an array
paulo@89 2457 * is the result of multiplying all numbers together, starting using one as the multiplicative identity.
paulo@89 2458 *
paulo@89 2459 * This runs on `O(n)`, linear time in respect to the array
paulo@89 2460 *
paulo@89 2461 * @param {Array<number>} x input
paulo@89 2462 * @return {number} product of all input numbers
paulo@89 2463 * @example
paulo@89 2464 * product([1, 2, 3, 4]); // => 24
paulo@89 2465 */
paulo@89 2466 function product(x/*: Array<number> */)/*: number */ {
paulo@89 2467 var value = 1;
paulo@89 2468 for (var i = 0; i < x.length; i++) {
paulo@89 2469 value *= x[i];
paulo@89 2470 }
paulo@89 2471 return value;
paulo@89 2472 }
paulo@89 2473
paulo@89 2474 module.exports = product;
paulo@89 2475
paulo@89 2476 },{}],40:[function(require,module,exports){
paulo@89 2477 'use strict';
paulo@89 2478 /* @flow */
paulo@89 2479
paulo@89 2480 var quantileSorted = require(41);
paulo@89 2481 var quickselect = require(42);
paulo@89 2482
paulo@89 2483 /**
paulo@89 2484 * The [quantile](https://en.wikipedia.org/wiki/Quantile):
paulo@89 2485 * this is a population quantile, since we assume to know the entire
paulo@89 2486 * dataset in this library. This is an implementation of the
paulo@89 2487 * [Quantiles of a Population](http://en.wikipedia.org/wiki/Quantile#Quantiles_of_a_population)
paulo@89 2488 * algorithm from wikipedia.
paulo@89 2489 *
paulo@89 2490 * Sample is a one-dimensional array of numbers,
paulo@89 2491 * and p is either a decimal number from 0 to 1 or an array of decimal
paulo@89 2492 * numbers from 0 to 1.
paulo@89 2493 * In terms of a k/q quantile, p = k/q - it's just dealing with fractions or dealing
paulo@89 2494 * with decimal values.
paulo@89 2495 * When p is an array, the result of the function is also an array containing the appropriate
paulo@89 2496 * quantiles in input order
paulo@89 2497 *
paulo@89 2498 * @param {Array<number>} sample a sample from the population
paulo@89 2499 * @param {number} p the desired quantile, as a number between 0 and 1
paulo@89 2500 * @returns {number} quantile
paulo@89 2501 * @example
paulo@89 2502 * quantile([3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20], 0.5); // => 9
paulo@89 2503 */
paulo@89 2504 function quantile(sample /*: Array<number> */, p /*: Array<number> | number */) {
paulo@89 2505 var copy = sample.slice();
paulo@89 2506
paulo@89 2507 if (Array.isArray(p)) {
paulo@89 2508 // rearrange elements so that each element corresponding to a requested
paulo@89 2509 // quantile is on a place it would be if the array was fully sorted
paulo@89 2510 multiQuantileSelect(copy, p);
paulo@89 2511 // Initialize the result array
paulo@89 2512 var results = [];
paulo@89 2513 // For each requested quantile
paulo@89 2514 for (var i = 0; i < p.length; i++) {
paulo@89 2515 results[i] = quantileSorted(copy, p[i]);
paulo@89 2516 }
paulo@89 2517 return results;
paulo@89 2518 } else {
paulo@89 2519 var idx = quantileIndex(copy.length, p);
paulo@89 2520 quantileSelect(copy, idx, 0, copy.length - 1);
paulo@89 2521 return quantileSorted(copy, p);
paulo@89 2522 }
paulo@89 2523 }
paulo@89 2524
paulo@89 2525 function quantileSelect(arr, k, left, right) {
paulo@89 2526 if (k % 1 === 0) {
paulo@89 2527 quickselect(arr, k, left, right);
paulo@89 2528 } else {
paulo@89 2529 k = Math.floor(k);
paulo@89 2530 quickselect(arr, k, left, right);
paulo@89 2531 quickselect(arr, k + 1, k + 1, right);
paulo@89 2532 }
paulo@89 2533 }
paulo@89 2534
paulo@89 2535 function multiQuantileSelect(arr, p) {
paulo@89 2536 var indices = [0];
paulo@89 2537 for (var i = 0; i < p.length; i++) {
paulo@89 2538 indices.push(quantileIndex(arr.length, p[i]));
paulo@89 2539 }
paulo@89 2540 indices.push(arr.length - 1);
paulo@89 2541 indices.sort(compare);
paulo@89 2542
paulo@89 2543 var stack = [0, indices.length - 1];
paulo@89 2544
paulo@89 2545 while (stack.length) {
paulo@89 2546 var r = Math.ceil(stack.pop());
paulo@89 2547 var l = Math.floor(stack.pop());
paulo@89 2548 if (r - l <= 1) continue;
paulo@89 2549
paulo@89 2550 var m = Math.floor((l + r) / 2);
paulo@89 2551 quantileSelect(arr, indices[m], indices[l], indices[r]);
paulo@89 2552
paulo@89 2553 stack.push(l, m, m, r);
paulo@89 2554 }
paulo@89 2555 }
paulo@89 2556
paulo@89 2557 function compare(a, b) {
paulo@89 2558 return a - b;
paulo@89 2559 }
paulo@89 2560
paulo@89 2561 function quantileIndex(len /*: number */, p /*: number */)/*:number*/ {
paulo@89 2562 var idx = len * p;
paulo@89 2563 if (p === 1) {
paulo@89 2564 // If p is 1, directly return the last index
paulo@89 2565 return len - 1;
paulo@89 2566 } else if (p === 0) {
paulo@89 2567 // If p is 0, directly return the first index
paulo@89 2568 return 0;
paulo@89 2569 } else if (idx % 1 !== 0) {
paulo@89 2570 // If index is not integer, return the next index in array
paulo@89 2571 return Math.ceil(idx) - 1;
paulo@89 2572 } else if (len % 2 === 0) {
paulo@89 2573 // If the list has even-length, we'll return the middle of two indices
paulo@89 2574 // around quantile to indicate that we need an average value of the two
paulo@89 2575 return idx - 0.5;
paulo@89 2576 } else {
paulo@89 2577 // Finally, in the simple case of an integer index
paulo@89 2578 // with an odd-length list, return the index
paulo@89 2579 return idx;
paulo@89 2580 }
paulo@89 2581 }
paulo@89 2582
paulo@89 2583 module.exports = quantile;
paulo@89 2584
paulo@89 2585 },{"41":41,"42":42}],41:[function(require,module,exports){
paulo@89 2586 'use strict';
paulo@89 2587 /* @flow */
paulo@89 2588
paulo@89 2589 /**
paulo@89 2590 * This is the internal implementation of quantiles: when you know
paulo@89 2591 * that the order is sorted, you don't need to re-sort it, and the computations
paulo@89 2592 * are faster.
paulo@89 2593 *
paulo@89 2594 * @param {Array<number>} sample input data
paulo@89 2595 * @param {number} p desired quantile: a number between 0 to 1, inclusive
paulo@89 2596 * @returns {number} quantile value
paulo@89 2597 * @example
paulo@89 2598 * quantileSorted([3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20], 0.5); // => 9
paulo@89 2599 */
paulo@89 2600 function quantileSorted(sample /*: Array<number> */, p /*: number */)/*:number*/ {
paulo@89 2601 var idx = sample.length * p;
paulo@89 2602 if (p < 0 || p > 1) {
paulo@89 2603 return NaN;
paulo@89 2604 } else if (p === 1) {
paulo@89 2605 // If p is 1, directly return the last element
paulo@89 2606 return sample[sample.length - 1];
paulo@89 2607 } else if (p === 0) {
paulo@89 2608 // If p is 0, directly return the first element
paulo@89 2609 return sample[0];
paulo@89 2610 } else if (idx % 1 !== 0) {
paulo@89 2611 // If p is not integer, return the next element in array
paulo@89 2612 return sample[Math.ceil(idx) - 1];
paulo@89 2613 } else if (sample.length % 2 === 0) {
paulo@89 2614 // If the list has even-length, we'll take the average of this number
paulo@89 2615 // and the next value, if there is one
paulo@89 2616 return (sample[idx - 1] + sample[idx]) / 2;
paulo@89 2617 } else {
paulo@89 2618 // Finally, in the simple case of an integer value
paulo@89 2619 // with an odd-length list, return the sample value at the index.
paulo@89 2620 return sample[idx];
paulo@89 2621 }
paulo@89 2622 }
paulo@89 2623
paulo@89 2624 module.exports = quantileSorted;
paulo@89 2625
paulo@89 2626 },{}],42:[function(require,module,exports){
paulo@89 2627 'use strict';
paulo@89 2628 /* @flow */
paulo@89 2629
paulo@89 2630 module.exports = quickselect;
paulo@89 2631
paulo@89 2632 /**
paulo@89 2633 * Rearrange items in `arr` so that all items in `[left, k]` range are the smallest.
paulo@89 2634 * The `k`-th element will have the `(k - left + 1)`-th smallest value in `[left, right]`.
paulo@89 2635 *
paulo@89 2636 * Implements Floyd-Rivest selection algorithm https://en.wikipedia.org/wiki/Floyd-Rivest_algorithm
paulo@89 2637 *
paulo@89 2638 * @private
paulo@89 2639 * @param {Array<number>} arr input array
paulo@89 2640 * @param {number} k pivot index
paulo@89 2641 * @param {number} left left index
paulo@89 2642 * @param {number} right right index
paulo@89 2643 * @returns {undefined}
paulo@89 2644 * @example
paulo@89 2645 * var arr = [65, 28, 59, 33, 21, 56, 22, 95, 50, 12, 90, 53, 28, 77, 39];
paulo@89 2646 * quickselect(arr, 8);
paulo@89 2647 * // = [39, 28, 28, 33, 21, 12, 22, 50, 53, 56, 59, 65, 90, 77, 95]
paulo@89 2648 */
paulo@89 2649 function quickselect(arr /*: Array<number> */, k /*: number */, left /*: number */, right /*: number */) {
paulo@89 2650 left = left || 0;
paulo@89 2651 right = right || (arr.length - 1);
paulo@89 2652
paulo@89 2653 while (right > left) {
paulo@89 2654 // 600 and 0.5 are arbitrary constants chosen in the original paper to minimize execution time
paulo@89 2655 if (right - left > 600) {
paulo@89 2656 var n = right - left + 1;
paulo@89 2657 var m = k - left + 1;
paulo@89 2658 var z = Math.log(n);
paulo@89 2659 var s = 0.5 * Math.exp(2 * z / 3);
paulo@89 2660 var sd = 0.5 * Math.sqrt(z * s * (n - s) / n);
paulo@89 2661 if (m - n / 2 < 0) sd *= -1;
paulo@89 2662 var newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
paulo@89 2663 var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
paulo@89 2664 quickselect(arr, k, newLeft, newRight);
paulo@89 2665 }
paulo@89 2666
paulo@89 2667 var t = arr[k];
paulo@89 2668 var i = left;
paulo@89 2669 var j = right;
paulo@89 2670
paulo@89 2671 swap(arr, left, k);
paulo@89 2672 if (arr[right] > t) swap(arr, left, right);
paulo@89 2673
paulo@89 2674 while (i < j) {
paulo@89 2675 swap(arr, i, j);
paulo@89 2676 i++;
paulo@89 2677 j--;
paulo@89 2678 while (arr[i] < t) i++;
paulo@89 2679 while (arr[j] > t) j--;
paulo@89 2680 }
paulo@89 2681
paulo@89 2682 if (arr[left] === t) swap(arr, left, j);
paulo@89 2683 else {
paulo@89 2684 j++;
paulo@89 2685 swap(arr, j, right);
paulo@89 2686 }
paulo@89 2687
paulo@89 2688 if (j <= k) left = j + 1;
paulo@89 2689 if (k <= j) right = j - 1;
paulo@89 2690 }
paulo@89 2691 }
paulo@89 2692
paulo@89 2693 function swap(arr, i, j) {
paulo@89 2694 var tmp = arr[i];
paulo@89 2695 arr[i] = arr[j];
paulo@89 2696 arr[j] = tmp;
paulo@89 2697 }
paulo@89 2698
paulo@89 2699 },{}],43:[function(require,module,exports){
paulo@89 2700 'use strict';
paulo@89 2701 /* @flow */
paulo@89 2702
paulo@89 2703 /**
paulo@89 2704 * The [R Squared](http://en.wikipedia.org/wiki/Coefficient_of_determination)
paulo@89 2705 * value of data compared with a function `f`
paulo@89 2706 * is the sum of the squared differences between the prediction
paulo@89 2707 * and the actual value.
paulo@89 2708 *
paulo@89 2709 * @param {Array<Array<number>>} data input data: this should be doubly-nested
paulo@89 2710 * @param {Function} func function called on `[i][0]` values within the dataset
paulo@89 2711 * @returns {number} r-squared value
paulo@89 2712 * @example
paulo@89 2713 * var samples = [[0, 0], [1, 1]];
paulo@89 2714 * var regressionLine = linearRegressionLine(linearRegression(samples));
paulo@89 2715 * rSquared(samples, regressionLine); // = 1 this line is a perfect fit
paulo@89 2716 */
paulo@89 2717 function rSquared(data /*: Array<Array<number>> */, func /*: Function */) /*: number */ {
paulo@89 2718 if (data.length < 2) { return 1; }
paulo@89 2719
paulo@89 2720 // Compute the average y value for the actual
paulo@89 2721 // data set in order to compute the
paulo@89 2722 // _total sum of squares_
paulo@89 2723 var sum = 0, average;
paulo@89 2724 for (var i = 0; i < data.length; i++) {
paulo@89 2725 sum += data[i][1];
paulo@89 2726 }
paulo@89 2727 average = sum / data.length;
paulo@89 2728
paulo@89 2729 // Compute the total sum of squares - the
paulo@89 2730 // squared difference between each point
paulo@89 2731 // and the average of all points.
paulo@89 2732 var sumOfSquares = 0;
paulo@89 2733 for (var j = 0; j < data.length; j++) {
paulo@89 2734 sumOfSquares += Math.pow(average - data[j][1], 2);
paulo@89 2735 }
paulo@89 2736
paulo@89 2737 // Finally estimate the error: the squared
paulo@89 2738 // difference between the estimate and the actual data
paulo@89 2739 // value at each point.
paulo@89 2740 var err = 0;
paulo@89 2741 for (var k = 0; k < data.length; k++) {
paulo@89 2742 err += Math.pow(data[k][1] - func(data[k][0]), 2);
paulo@89 2743 }
paulo@89 2744
paulo@89 2745 // As the error grows larger, its ratio to the
paulo@89 2746 // sum of squares increases and the r squared
paulo@89 2747 // value grows lower.
paulo@89 2748 return 1 - err / sumOfSquares;
paulo@89 2749 }
paulo@89 2750
paulo@89 2751 module.exports = rSquared;
paulo@89 2752
paulo@89 2753 },{}],44:[function(require,module,exports){
paulo@89 2754 'use strict';
paulo@89 2755 /* @flow */
paulo@89 2756
paulo@89 2757 /**
paulo@89 2758 * The Root Mean Square (RMS) is
paulo@89 2759 * a mean function used as a measure of the magnitude of a set
paulo@89 2760 * of numbers, regardless of their sign.
paulo@89 2761 * This is the square root of the mean of the squares of the
paulo@89 2762 * input numbers.
paulo@89 2763 * This runs on `O(n)`, linear time in respect to the array
paulo@89 2764 *
paulo@89 2765 * @param {Array<number>} x input
paulo@89 2766 * @returns {number} root mean square
paulo@89 2767 * @example
paulo@89 2768 * rootMeanSquare([-1, 1, -1, 1]); // => 1
paulo@89 2769 */
paulo@89 2770 function rootMeanSquare(x /*: Array<number> */)/*:number*/ {
paulo@89 2771 if (x.length === 0) { return NaN; }
paulo@89 2772
paulo@89 2773 var sumOfSquares = 0;
paulo@89 2774 for (var i = 0; i < x.length; i++) {
paulo@89 2775 sumOfSquares += Math.pow(x[i], 2);
paulo@89 2776 }
paulo@89 2777
paulo@89 2778 return Math.sqrt(sumOfSquares / x.length);
paulo@89 2779 }
paulo@89 2780
paulo@89 2781 module.exports = rootMeanSquare;
paulo@89 2782
paulo@89 2783 },{}],45:[function(require,module,exports){
paulo@89 2784 'use strict';
paulo@89 2785 /* @flow */
paulo@89 2786
paulo@89 2787 var shuffle = require(51);
paulo@89 2788
paulo@89 2789 /**
paulo@89 2790 * Create a [simple random sample](http://en.wikipedia.org/wiki/Simple_random_sample)
paulo@89 2791 * from a given array of `n` elements.
paulo@89 2792 *
paulo@89 2793 * The sampled values will be in any order, not necessarily the order
paulo@89 2794 * they appear in the input.
paulo@89 2795 *
paulo@89 2796 * @param {Array} array input array. can contain any type
paulo@89 2797 * @param {number} n count of how many elements to take
paulo@89 2798 * @param {Function} [randomSource=Math.random] an optional source of entropy
paulo@89 2799 * instead of Math.random
paulo@89 2800 * @return {Array} subset of n elements in original array
paulo@89 2801 * @example
paulo@89 2802 * var values = [1, 2, 4, 5, 6, 7, 8, 9];
paulo@89 2803 * sample(values, 3); // returns 3 random values, like [2, 5, 8];
paulo@89 2804 */
paulo@89 2805 function sample/*:: <T> */(
paulo@89 2806 array /*: Array<T> */,
paulo@89 2807 n /*: number */,
paulo@89 2808 randomSource /*: Function */) /*: Array<T> */ {
paulo@89 2809 // shuffle the original array using a fisher-yates shuffle
paulo@89 2810 var shuffled = shuffle(array, randomSource);
paulo@89 2811
paulo@89 2812 // and then return a subset of it - the first `n` elements.
paulo@89 2813 return shuffled.slice(0, n);
paulo@89 2814 }
paulo@89 2815
paulo@89 2816 module.exports = sample;
paulo@89 2817
paulo@89 2818 },{"51":51}],46:[function(require,module,exports){
paulo@89 2819 'use strict';
paulo@89 2820 /* @flow */
paulo@89 2821
paulo@89 2822 var sampleCovariance = require(47);
paulo@89 2823 var sampleStandardDeviation = require(49);
paulo@89 2824
paulo@89 2825 /**
paulo@89 2826 * The [correlation](http://en.wikipedia.org/wiki/Correlation_and_dependence) is
paulo@89 2827 * a measure of how correlated two datasets are, between -1 and 1
paulo@89 2828 *
paulo@89 2829 * @param {Array<number>} x first input
paulo@89 2830 * @param {Array<number>} y second input
paulo@89 2831 * @returns {number} sample correlation
paulo@89 2832 * @example
paulo@89 2833 * sampleCorrelation([1, 2, 3, 4, 5, 6], [2, 2, 3, 4, 5, 60]).toFixed(2);
paulo@89 2834 * // => '0.69'
paulo@89 2835 */
paulo@89 2836 function sampleCorrelation(x/*: Array<number> */, y/*: Array<number> */)/*:number*/ {
paulo@89 2837 var cov = sampleCovariance(x, y),
paulo@89 2838 xstd = sampleStandardDeviation(x),
paulo@89 2839 ystd = sampleStandardDeviation(y);
paulo@89 2840
paulo@89 2841 return cov / xstd / ystd;
paulo@89 2842 }
paulo@89 2843
paulo@89 2844 module.exports = sampleCorrelation;
paulo@89 2845
paulo@89 2846 },{"47":47,"49":49}],47:[function(require,module,exports){
paulo@89 2847 'use strict';
paulo@89 2848 /* @flow */
paulo@89 2849
paulo@89 2850 var mean = require(25);
paulo@89 2851
paulo@89 2852 /**
paulo@89 2853 * [Sample covariance](https://en.wikipedia.org/wiki/Sample_mean_and_sampleCovariance) of two datasets:
paulo@89 2854 * how much do the two datasets move together?
paulo@89 2855 * x and y are two datasets, represented as arrays of numbers.
paulo@89 2856 *
paulo@89 2857 * @param {Array<number>} x first input
paulo@89 2858 * @param {Array<number>} y second input
paulo@89 2859 * @returns {number} sample covariance
paulo@89 2860 * @example
paulo@89 2861 * sampleCovariance([1, 2, 3, 4, 5, 6], [6, 5, 4, 3, 2, 1]); // => -3.5
paulo@89 2862 */
paulo@89 2863 function sampleCovariance(x /*:Array<number>*/, y /*:Array<number>*/)/*:number*/ {
paulo@89 2864
paulo@89 2865 // The two datasets must have the same length which must be more than 1
paulo@89 2866 if (x.length <= 1 || x.length !== y.length) {
paulo@89 2867 return NaN;
paulo@89 2868 }
paulo@89 2869
paulo@89 2870 // determine the mean of each dataset so that we can judge each
paulo@89 2871 // value of the dataset fairly as the difference from the mean. this
paulo@89 2872 // way, if one dataset is [1, 2, 3] and [2, 3, 4], their covariance
paulo@89 2873 // does not suffer because of the difference in absolute values
paulo@89 2874 var xmean = mean(x),
paulo@89 2875 ymean = mean(y),
paulo@89 2876 sum = 0;
paulo@89 2877
paulo@89 2878 // for each pair of values, the covariance increases when their
paulo@89 2879 // difference from the mean is associated - if both are well above
paulo@89 2880 // or if both are well below
paulo@89 2881 // the mean, the covariance increases significantly.
paulo@89 2882 for (var i = 0; i < x.length; i++) {
paulo@89 2883 sum += (x[i] - xmean) * (y[i] - ymean);
paulo@89 2884 }
paulo@89 2885
paulo@89 2886 // this is Bessels' Correction: an adjustment made to sample statistics
paulo@89 2887 // that allows for the reduced degree of freedom entailed in calculating
paulo@89 2888 // values from samples rather than complete populations.
paulo@89 2889 var besselsCorrection = x.length - 1;
paulo@89 2890
paulo@89 2891 // the covariance is weighted by the length of the datasets.
paulo@89 2892 return sum / besselsCorrection;
paulo@89 2893 }
paulo@89 2894
paulo@89 2895 module.exports = sampleCovariance;
paulo@89 2896
paulo@89 2897 },{"25":25}],48:[function(require,module,exports){
paulo@89 2898 'use strict';
paulo@89 2899 /* @flow */
paulo@89 2900
paulo@89 2901 var sumNthPowerDeviations = require(57);
paulo@89 2902 var sampleStandardDeviation = require(49);
paulo@89 2903
paulo@89 2904 /**
paulo@89 2905 * [Skewness](http://en.wikipedia.org/wiki/Skewness) is
paulo@89 2906 * a measure of the extent to which a probability distribution of a
paulo@89 2907 * real-valued random variable "leans" to one side of the mean.
paulo@89 2908 * The skewness value can be positive or negative, or even undefined.
paulo@89 2909 *
paulo@89 2910 * Implementation is based on the adjusted Fisher-Pearson standardized
paulo@89 2911 * moment coefficient, which is the version found in Excel and several
paulo@89 2912 * statistical packages including Minitab, SAS and SPSS.
paulo@89 2913 *
paulo@89 2914 * @param {Array<number>} x input
paulo@89 2915 * @returns {number} sample skewness
paulo@89 2916 * @example
paulo@89 2917 * sampleSkewness([2, 4, 6, 3, 1]); // => 0.590128656384365
paulo@89 2918 */
paulo@89 2919 function sampleSkewness(x /*: Array<number> */)/*:number*/ {
paulo@89 2920 // The skewness of less than three arguments is null
paulo@89 2921 var theSampleStandardDeviation = sampleStandardDeviation(x);
paulo@89 2922
paulo@89 2923 if (isNaN(theSampleStandardDeviation) || x.length < 3) {
paulo@89 2924 return NaN;
paulo@89 2925 }
paulo@89 2926
paulo@89 2927 var n = x.length,
paulo@89 2928 cubedS = Math.pow(theSampleStandardDeviation, 3),
paulo@89 2929 sumCubedDeviations = sumNthPowerDeviations(x, 3);
paulo@89 2930
paulo@89 2931 return n * sumCubedDeviations / ((n - 1) * (n - 2) * cubedS);
paulo@89 2932 }
paulo@89 2933
paulo@89 2934 module.exports = sampleSkewness;
paulo@89 2935
paulo@89 2936 },{"49":49,"57":57}],49:[function(require,module,exports){
paulo@89 2937 'use strict';
paulo@89 2938 /* @flow */
paulo@89 2939
paulo@89 2940 var sampleVariance = require(50);
paulo@89 2941
paulo@89 2942 /**
paulo@89 2943 * The [standard deviation](http://en.wikipedia.org/wiki/Standard_deviation)
paulo@89 2944 * is the square root of the variance.
paulo@89 2945 *
paulo@89 2946 * @param {Array<number>} x input array
paulo@89 2947 * @returns {number} sample standard deviation
paulo@89 2948 * @example
paulo@89 2949 * sampleStandardDeviation([2, 4, 4, 4, 5, 5, 7, 9]).toFixed(2);
paulo@89 2950 * // => '2.14'
paulo@89 2951 */
paulo@89 2952 function sampleStandardDeviation(x/*:Array<number>*/)/*:number*/ {
paulo@89 2953 // The standard deviation of no numbers is null
paulo@89 2954 var sampleVarianceX = sampleVariance(x);
paulo@89 2955 if (isNaN(sampleVarianceX)) { return NaN; }
paulo@89 2956 return Math.sqrt(sampleVarianceX);
paulo@89 2957 }
paulo@89 2958
paulo@89 2959 module.exports = sampleStandardDeviation;
paulo@89 2960
paulo@89 2961 },{"50":50}],50:[function(require,module,exports){
paulo@89 2962 'use strict';
paulo@89 2963 /* @flow */
paulo@89 2964
paulo@89 2965 var sumNthPowerDeviations = require(57);
paulo@89 2966
paulo@89 2967 /*
paulo@89 2968 * The [sample variance](https://en.wikipedia.org/wiki/Variance#Sample_variance)
paulo@89 2969 * is the sum of squared deviations from the mean. The sample variance
paulo@89 2970 * is distinguished from the variance by the usage of [Bessel's Correction](https://en.wikipedia.org/wiki/Bessel's_correction):
paulo@89 2971 * instead of dividing the sum of squared deviations by the length of the input,
paulo@89 2972 * it is divided by the length minus one. This corrects the bias in estimating
paulo@89 2973 * a value from a set that you don't know if full.
paulo@89 2974 *
paulo@89 2975 * References:
paulo@89 2976 * * [Wolfram MathWorld on Sample Variance](http://mathworld.wolfram.com/SampleVariance.html)
paulo@89 2977 *
paulo@89 2978 * @param {Array<number>} x input array
paulo@89 2979 * @return {number} sample variance
paulo@89 2980 * @example
paulo@89 2981 * sampleVariance([1, 2, 3, 4, 5]); // => 2.5
paulo@89 2982 */
paulo@89 2983 function sampleVariance(x /*: Array<number> */)/*:number*/ {
paulo@89 2984 // The variance of no numbers is null
paulo@89 2985 if (x.length <= 1) { return NaN; }
paulo@89 2986
paulo@89 2987 var sumSquaredDeviationsValue = sumNthPowerDeviations(x, 2);
paulo@89 2988
paulo@89 2989 // this is Bessels' Correction: an adjustment made to sample statistics
paulo@89 2990 // that allows for the reduced degree of freedom entailed in calculating
paulo@89 2991 // values from samples rather than complete populations.
paulo@89 2992 var besselsCorrection = x.length - 1;
paulo@89 2993
paulo@89 2994 // Find the mean value of that list
paulo@89 2995 return sumSquaredDeviationsValue / besselsCorrection;
paulo@89 2996 }
paulo@89 2997
paulo@89 2998 module.exports = sampleVariance;
paulo@89 2999
paulo@89 3000 },{"57":57}],51:[function(require,module,exports){
paulo@89 3001 'use strict';
paulo@89 3002 /* @flow */
paulo@89 3003
paulo@89 3004 var shuffleInPlace = require(52);
paulo@89 3005
paulo@89 3006 /*
paulo@89 3007 * A [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle)
paulo@89 3008 * is a fast way to create a random permutation of a finite set. This is
paulo@89 3009 * a function around `shuffle_in_place` that adds the guarantee that
paulo@89 3010 * it will not modify its input.
paulo@89 3011 *
paulo@89 3012 * @param {Array} sample an array of any kind of element
paulo@89 3013 * @param {Function} [randomSource=Math.random] an optional entropy source
paulo@89 3014 * @return {Array} shuffled version of input
paulo@89 3015 * @example
paulo@89 3016 * var shuffled = shuffle([1, 2, 3, 4]);
paulo@89 3017 * shuffled; // = [2, 3, 1, 4] or any other random permutation
paulo@89 3018 */
paulo@89 3019 function shuffle/*::<T>*/(sample/*:Array<T>*/, randomSource/*:Function*/) {
paulo@89 3020 // slice the original array so that it is not modified
paulo@89 3021 sample = sample.slice();
paulo@89 3022
paulo@89 3023 // and then shuffle that shallow-copied array, in place
paulo@89 3024 return shuffleInPlace(sample.slice(), randomSource);
paulo@89 3025 }
paulo@89 3026
paulo@89 3027 module.exports = shuffle;
paulo@89 3028
paulo@89 3029 },{"52":52}],52:[function(require,module,exports){
paulo@89 3030 'use strict';
paulo@89 3031 /* @flow */
paulo@89 3032
paulo@89 3033 /*
paulo@89 3034 * A [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle)
paulo@89 3035 * in-place - which means that it **will change the order of the original
paulo@89 3036 * array by reference**.
paulo@89 3037 *
paulo@89 3038 * This is an algorithm that generates a random [permutation](https://en.wikipedia.org/wiki/Permutation)
paulo@89 3039 * of a set.
paulo@89 3040 *
paulo@89 3041 * @param {Array} sample input array
paulo@89 3042 * @param {Function} [randomSource=Math.random] an optional source of entropy
paulo@89 3043 * @returns {Array} sample
paulo@89 3044 * @example
paulo@89 3045 * var sample = [1, 2, 3, 4];
paulo@89 3046 * shuffleInPlace(sample);
paulo@89 3047 * // sample is shuffled to a value like [2, 1, 4, 3]
paulo@89 3048 */
paulo@89 3049 function shuffleInPlace(sample/*:Array<any>*/, randomSource/*:Function*/)/*:Array<any>*/ {
paulo@89 3050
paulo@89 3051
paulo@89 3052 // a custom random number source can be provided if you want to use
paulo@89 3053 // a fixed seed or another random number generator, like
paulo@89 3054 // [random-js](https://www.npmjs.org/package/random-js)
paulo@89 3055 randomSource = randomSource || Math.random;
paulo@89 3056
paulo@89 3057 // store the current length of the sample to determine
paulo@89 3058 // when no elements remain to shuffle.
paulo@89 3059 var length = sample.length;
paulo@89 3060
paulo@89 3061 // temporary is used to hold an item when it is being
paulo@89 3062 // swapped between indices.
paulo@89 3063 var temporary;
paulo@89 3064
paulo@89 3065 // The index to swap at each stage.
paulo@89 3066 var index;
paulo@89 3067
paulo@89 3068 // While there are still items to shuffle
paulo@89 3069 while (length > 0) {
paulo@89 3070 // chose a random index within the subset of the array
paulo@89 3071 // that is not yet shuffled
paulo@89 3072 index = Math.floor(randomSource() * length--);
paulo@89 3073
paulo@89 3074 // store the value that we'll move temporarily
paulo@89 3075 temporary = sample[length];
paulo@89 3076
paulo@89 3077 // swap the value at `sample[length]` with `sample[index]`
paulo@89 3078 sample[length] = sample[index];
paulo@89 3079 sample[index] = temporary;
paulo@89 3080 }
paulo@89 3081
paulo@89 3082 return sample;
paulo@89 3083 }
paulo@89 3084
paulo@89 3085 module.exports = shuffleInPlace;
paulo@89 3086
paulo@89 3087 },{}],53:[function(require,module,exports){
paulo@89 3088 'use strict';
paulo@89 3089 /* @flow */
paulo@89 3090
paulo@89 3091 /**
paulo@89 3092 * [Sign](https://en.wikipedia.org/wiki/Sign_function) is a function
paulo@89 3093 * that extracts the sign of a real number
paulo@89 3094 *
paulo@89 3095 * @param {Number} x input value
paulo@89 3096 * @returns {Number} sign value either 1, 0 or -1
paulo@89 3097 * @throws {TypeError} if the input argument x is not a number
paulo@89 3098 * @private
paulo@89 3099 *
paulo@89 3100 * @example
paulo@89 3101 * sign(2); // => 1
paulo@89 3102 */
paulo@89 3103 function sign(x/*: number */)/*: number */ {
paulo@89 3104 if (typeof x === 'number') {
paulo@89 3105 if (x < 0) {
paulo@89 3106 return -1;
paulo@89 3107 } else if (x === 0) {
paulo@89 3108 return 0
paulo@89 3109 } else {
paulo@89 3110 return 1;
paulo@89 3111 }
paulo@89 3112 } else {
paulo@89 3113 throw new TypeError('not a number');
paulo@89 3114 }
paulo@89 3115 }
paulo@89 3116
paulo@89 3117 module.exports = sign;
paulo@89 3118
paulo@89 3119 },{}],54:[function(require,module,exports){
paulo@89 3120 'use strict';
paulo@89 3121 /* @flow */
paulo@89 3122
paulo@89 3123 var variance = require(62);
paulo@89 3124
paulo@89 3125 /**
paulo@89 3126 * The [standard deviation](http://en.wikipedia.org/wiki/Standard_deviation)
paulo@89 3127 * is the square root of the variance. It's useful for measuring the amount
paulo@89 3128 * of variation or dispersion in a set of values.
paulo@89 3129 *
paulo@89 3130 * Standard deviation is only appropriate for full-population knowledge: for
paulo@89 3131 * samples of a population, {@link sampleStandardDeviation} is
paulo@89 3132 * more appropriate.
paulo@89 3133 *
paulo@89 3134 * @param {Array<number>} x input
paulo@89 3135 * @returns {number} standard deviation
paulo@89 3136 * @example
paulo@89 3137 * variance([2, 4, 4, 4, 5, 5, 7, 9]); // => 4
paulo@89 3138 * standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]); // => 2
paulo@89 3139 */
paulo@89 3140 function standardDeviation(x /*: Array<number> */)/*:number*/ {
paulo@89 3141 // The standard deviation of no numbers is null
paulo@89 3142 var v = variance(x);
paulo@89 3143 if (isNaN(v)) { return 0; }
paulo@89 3144 return Math.sqrt(v);
paulo@89 3145 }
paulo@89 3146
paulo@89 3147 module.exports = standardDeviation;
paulo@89 3148
paulo@89 3149 },{"62":62}],55:[function(require,module,exports){
paulo@89 3150 'use strict';
paulo@89 3151 /* @flow */
paulo@89 3152
paulo@89 3153 var SQRT_2PI = Math.sqrt(2 * Math.PI);
paulo@89 3154
paulo@89 3155 function cumulativeDistribution(z) {
paulo@89 3156 var sum = z,
paulo@89 3157 tmp = z;
paulo@89 3158
paulo@89 3159 // 15 iterations are enough for 4-digit precision
paulo@89 3160 for (var i = 1; i < 15; i++) {
paulo@89 3161 tmp *= z * z / (2 * i + 1);
paulo@89 3162 sum += tmp;
paulo@89 3163 }
paulo@89 3164 return Math.round((0.5 + (sum / SQRT_2PI) * Math.exp(-z * z / 2)) * 1e4) / 1e4;
paulo@89 3165 }
paulo@89 3166
paulo@89 3167 /**
paulo@89 3168 * A standard normal table, also called the unit normal table or Z table,
paulo@89 3169 * is a mathematical table for the values of Φ (phi), which are the values of
paulo@89 3170 * the cumulative distribution function of the normal distribution.
paulo@89 3171 * It is used to find the probability that a statistic is observed below,
paulo@89 3172 * above, or between values on the standard normal distribution, and by
paulo@89 3173 * extension, any normal distribution.
paulo@89 3174 *
paulo@89 3175 * The probabilities are calculated using the
paulo@89 3176 * [Cumulative distribution function](https://en.wikipedia.org/wiki/Normal_distribution#Cumulative_distribution_function).
paulo@89 3177 * The table used is the cumulative, and not cumulative from 0 to mean
paulo@89 3178 * (even though the latter has 5 digits precision, instead of 4).
paulo@89 3179 */
paulo@89 3180 var standardNormalTable/*: Array<number> */ = [];
paulo@89 3181
paulo@89 3182 for (var z = 0; z <= 3.09; z += 0.01) {
paulo@89 3183 standardNormalTable.push(cumulativeDistribution(z));
paulo@89 3184 }
paulo@89 3185
paulo@89 3186 module.exports = standardNormalTable;
paulo@89 3187
paulo@89 3188 },{}],56:[function(require,module,exports){
paulo@89 3189 'use strict';
paulo@89 3190 /* @flow */
paulo@89 3191
paulo@89 3192 /**
paulo@89 3193 * Our default sum is the [Kahan summation algorithm](https://en.wikipedia.org/wiki/Kahan_summation_algorithm) is
paulo@89 3194 * a method for computing the sum of a list of numbers while correcting
paulo@89 3195 * for floating-point errors. Traditionally, sums are calculated as many
paulo@89 3196 * successive additions, each one with its own floating-point roundoff. These
paulo@89 3197 * losses in precision add up as the number of numbers increases. This alternative
paulo@89 3198 * algorithm is more accurate than the simple way of calculating sums by simple
paulo@89 3199 * addition.
paulo@89 3200 *
paulo@89 3201 * This runs on `O(n)`, linear time in respect to the array
paulo@89 3202 *
paulo@89 3203 * @param {Array<number>} x input
paulo@89 3204 * @return {number} sum of all input numbers
paulo@89 3205 * @example
paulo@89 3206 * sum([1, 2, 3]); // => 6
paulo@89 3207 */
paulo@89 3208 function sum(x/*: Array<number> */)/*: number */ {
paulo@89 3209
paulo@89 3210 // like the traditional sum algorithm, we keep a running
paulo@89 3211 // count of the current sum.
paulo@89 3212 var sum = 0;
paulo@89 3213
paulo@89 3214 // but we also keep three extra variables as bookkeeping:
paulo@89 3215 // most importantly, an error correction value. This will be a very
paulo@89 3216 // small number that is the opposite of the floating point precision loss.
paulo@89 3217 var errorCompensation = 0;
paulo@89 3218
paulo@89 3219 // this will be each number in the list corrected with the compensation value.
paulo@89 3220 var correctedCurrentValue;
paulo@89 3221
paulo@89 3222 // and this will be the next sum
paulo@89 3223 var nextSum;
paulo@89 3224
paulo@89 3225 for (var i = 0; i < x.length; i++) {
paulo@89 3226 // first correct the value that we're going to add to the sum
paulo@89 3227 correctedCurrentValue = x[i] - errorCompensation;
paulo@89 3228
paulo@89 3229 // compute the next sum. sum is likely a much larger number
paulo@89 3230 // than correctedCurrentValue, so we'll lose precision here,
paulo@89 3231 // and measure how much precision is lost in the next step
paulo@89 3232 nextSum = sum + correctedCurrentValue;
paulo@89 3233
paulo@89 3234 // we intentionally didn't assign sum immediately, but stored
paulo@89 3235 // it for now so we can figure out this: is (sum + nextValue) - nextValue
paulo@89 3236 // not equal to 0? ideally it would be, but in practice it won't:
paulo@89 3237 // it will be some very small number. that's what we record
paulo@89 3238 // as errorCompensation.
paulo@89 3239 errorCompensation = nextSum - sum - correctedCurrentValue;
paulo@89 3240
paulo@89 3241 // now that we've computed how much we'll correct for in the next
paulo@89 3242 // loop, start treating the nextSum as the current sum.
paulo@89 3243 sum = nextSum;
paulo@89 3244 }
paulo@89 3245
paulo@89 3246 return sum;
paulo@89 3247 }
paulo@89 3248
paulo@89 3249 module.exports = sum;
paulo@89 3250
paulo@89 3251 },{}],57:[function(require,module,exports){
paulo@89 3252 'use strict';
paulo@89 3253 /* @flow */
paulo@89 3254
paulo@89 3255 var mean = require(25);
paulo@89 3256
paulo@89 3257 /**
paulo@89 3258 * The sum of deviations to the Nth power.
paulo@89 3259 * When n=2 it's the sum of squared deviations.
paulo@89 3260 * When n=3 it's the sum of cubed deviations.
paulo@89 3261 *
paulo@89 3262 * @param {Array<number>} x
paulo@89 3263 * @param {number} n power
paulo@89 3264 * @returns {number} sum of nth power deviations
paulo@89 3265 * @example
paulo@89 3266 * var input = [1, 2, 3];
paulo@89 3267 * // since the variance of a set is the mean squared
paulo@89 3268 * // deviations, we can calculate that with sumNthPowerDeviations:
paulo@89 3269 * var variance = sumNthPowerDeviations(input) / input.length;
paulo@89 3270 */
paulo@89 3271 function sumNthPowerDeviations(x/*: Array<number> */, n/*: number */)/*:number*/ {
paulo@89 3272 var meanValue = mean(x),
paulo@89 3273 sum = 0;
paulo@89 3274
paulo@89 3275 for (var i = 0; i < x.length; i++) {
paulo@89 3276 sum += Math.pow(x[i] - meanValue, n);
paulo@89 3277 }
paulo@89 3278
paulo@89 3279 return sum;
paulo@89 3280 }
paulo@89 3281
paulo@89 3282 module.exports = sumNthPowerDeviations;
paulo@89 3283
paulo@89 3284 },{"25":25}],58:[function(require,module,exports){
paulo@89 3285 'use strict';
paulo@89 3286 /* @flow */
paulo@89 3287
paulo@89 3288 /**
paulo@89 3289 * The simple [sum](https://en.wikipedia.org/wiki/Summation) of an array
paulo@89 3290 * is the result of adding all numbers together, starting from zero.
paulo@89 3291 *
paulo@89 3292 * This runs on `O(n)`, linear time in respect to the array
paulo@89 3293 *
paulo@89 3294 * @param {Array<number>} x input
paulo@89 3295 * @return {number} sum of all input numbers
paulo@89 3296 * @example
paulo@89 3297 * sumSimple([1, 2, 3]); // => 6
paulo@89 3298 */
paulo@89 3299 function sumSimple(x/*: Array<number> */)/*: number */ {
paulo@89 3300 var value = 0;
paulo@89 3301 for (var i = 0; i < x.length; i++) {
paulo@89 3302 value += x[i];
paulo@89 3303 }
paulo@89 3304 return value;
paulo@89 3305 }
paulo@89 3306
paulo@89 3307 module.exports = sumSimple;
paulo@89 3308
paulo@89 3309 },{}],59:[function(require,module,exports){
paulo@89 3310 'use strict';
paulo@89 3311 /* @flow */
paulo@89 3312
paulo@89 3313 var standardDeviation = require(54);
paulo@89 3314 var mean = require(25);
paulo@89 3315
paulo@89 3316 /**
paulo@89 3317 * This is to compute [a one-sample t-test](https://en.wikipedia.org/wiki/Student%27s_t-test#One-sample_t-test), comparing the mean
paulo@89 3318 * of a sample to a known value, x.
paulo@89 3319 *
paulo@89 3320 * in this case, we're trying to determine whether the
paulo@89 3321 * population mean is equal to the value that we know, which is `x`
paulo@89 3322 * here. usually the results here are used to look up a
paulo@89 3323 * [p-value](http://en.wikipedia.org/wiki/P-value), which, for
paulo@89 3324 * a certain level of significance, will let you determine that the
paulo@89 3325 * null hypothesis can or cannot be rejected.
paulo@89 3326 *
paulo@89 3327 * @param {Array<number>} sample an array of numbers as input
paulo@89 3328 * @param {number} x expected value of the population mean
paulo@89 3329 * @returns {number} value
paulo@89 3330 * @example
paulo@89 3331 * tTest([1, 2, 3, 4, 5, 6], 3.385).toFixed(2); // => '0.16'
paulo@89 3332 */
paulo@89 3333 function tTest(sample/*: Array<number> */, x/*: number */)/*:number*/ {
paulo@89 3334 // The mean of the sample
paulo@89 3335 var sampleMean = mean(sample);
paulo@89 3336
paulo@89 3337 // The standard deviation of the sample
paulo@89 3338 var sd = standardDeviation(sample);
paulo@89 3339
paulo@89 3340 // Square root the length of the sample
paulo@89 3341 var rootN = Math.sqrt(sample.length);
paulo@89 3342
paulo@89 3343 // returning the t value
paulo@89 3344 return (sampleMean - x) / (sd / rootN);
paulo@89 3345 }
paulo@89 3346
paulo@89 3347 module.exports = tTest;
paulo@89 3348
paulo@89 3349 },{"25":25,"54":54}],60:[function(require,module,exports){
paulo@89 3350 'use strict';
paulo@89 3351 /* @flow */
paulo@89 3352
paulo@89 3353 var mean = require(25);
paulo@89 3354 var sampleVariance = require(50);
paulo@89 3355
paulo@89 3356 /**
paulo@89 3357 * This is to compute [two sample t-test](http://en.wikipedia.org/wiki/Student's_t-test).
paulo@89 3358 * Tests whether "mean(X)-mean(Y) = difference", (
paulo@89 3359 * in the most common case, we often have `difference == 0` to test if two samples
paulo@89 3360 * are likely to be taken from populations with the same mean value) with
paulo@89 3361 * no prior knowledge on standard deviations of both samples
paulo@89 3362 * other than the fact that they have the same standard deviation.
paulo@89 3363 *
paulo@89 3364 * Usually the results here are used to look up a
paulo@89 3365 * [p-value](http://en.wikipedia.org/wiki/P-value), which, for
paulo@89 3366 * a certain level of significance, will let you determine that the
paulo@89 3367 * null hypothesis can or cannot be rejected.
paulo@89 3368 *
paulo@89 3369 * `diff` can be omitted if it equals 0.
paulo@89 3370 *
paulo@89 3371 * [This is used to confirm or deny](http://www.monarchlab.org/Lab/Research/Stats/2SampleT.aspx)
paulo@89 3372 * a null hypothesis that the two populations that have been sampled into
paulo@89 3373 * `sampleX` and `sampleY` are equal to each other.
paulo@89 3374 *
paulo@89 3375 * @param {Array<number>} sampleX a sample as an array of numbers
paulo@89 3376 * @param {Array<number>} sampleY a sample as an array of numbers
paulo@89 3377 * @param {number} [difference=0]
paulo@89 3378 * @returns {number} test result
paulo@89 3379 * @example
paulo@89 3380 * ss.tTestTwoSample([1, 2, 3, 4], [3, 4, 5, 6], 0); //= -2.1908902300206643
paulo@89 3381 */
paulo@89 3382 function tTestTwoSample(
paulo@89 3383 sampleX/*: Array<number> */,
paulo@89 3384 sampleY/*: Array<number> */,
paulo@89 3385 difference/*: number */) {
paulo@89 3386 var n = sampleX.length,
paulo@89 3387 m = sampleY.length;
paulo@89 3388
paulo@89 3389 // If either sample doesn't actually have any values, we can't
paulo@89 3390 // compute this at all, so we return `null`.
paulo@89 3391 if (!n || !m) { return null; }
paulo@89 3392
paulo@89 3393 // default difference (mu) is zero
paulo@89 3394 if (!difference) {
paulo@89 3395 difference = 0;
paulo@89 3396 }
paulo@89 3397
paulo@89 3398 var meanX = mean(sampleX),
paulo@89 3399 meanY = mean(sampleY),
paulo@89 3400 sampleVarianceX = sampleVariance(sampleX),
paulo@89 3401 sampleVarianceY = sampleVariance(sampleY);
paulo@89 3402
paulo@89 3403 if (typeof meanX === 'number' &&
paulo@89 3404 typeof meanY === 'number' &&
paulo@89 3405 typeof sampleVarianceX === 'number' &&
paulo@89 3406 typeof sampleVarianceY === 'number') {
paulo@89 3407 var weightedVariance = ((n - 1) * sampleVarianceX +
paulo@89 3408 (m - 1) * sampleVarianceY) / (n + m - 2);
paulo@89 3409
paulo@89 3410 return (meanX - meanY - difference) /
paulo@89 3411 Math.sqrt(weightedVariance * (1 / n + 1 / m));
paulo@89 3412 }
paulo@89 3413 }
paulo@89 3414
paulo@89 3415 module.exports = tTestTwoSample;
paulo@89 3416
paulo@89 3417 },{"25":25,"50":50}],61:[function(require,module,exports){
paulo@89 3418 'use strict';
paulo@89 3419 /* @flow */
paulo@89 3420
paulo@89 3421 /**
paulo@89 3422 * For a sorted input, counting the number of unique values
paulo@89 3423 * is possible in constant time and constant memory. This is
paulo@89 3424 * a simple implementation of the algorithm.
paulo@89 3425 *
paulo@89 3426 * Values are compared with `===`, so objects and non-primitive objects
paulo@89 3427 * are not handled in any special way.
paulo@89 3428 *
paulo@89 3429 * @param {Array} input an array of primitive values.
paulo@89 3430 * @returns {number} count of unique values
paulo@89 3431 * @example
paulo@89 3432 * uniqueCountSorted([1, 2, 3]); // => 3
paulo@89 3433 * uniqueCountSorted([1, 1, 1]); // => 1
paulo@89 3434 */
paulo@89 3435 function uniqueCountSorted(input/*: Array<any>*/)/*: number */ {
paulo@89 3436 var uniqueValueCount = 0,
paulo@89 3437 lastSeenValue;
paulo@89 3438 for (var i = 0; i < input.length; i++) {
paulo@89 3439 if (i === 0 || input[i] !== lastSeenValue) {
paulo@89 3440 lastSeenValue = input[i];
paulo@89 3441 uniqueValueCount++;
paulo@89 3442 }
paulo@89 3443 }
paulo@89 3444 return uniqueValueCount;
paulo@89 3445 }
paulo@89 3446
paulo@89 3447 module.exports = uniqueCountSorted;
paulo@89 3448
paulo@89 3449 },{}],62:[function(require,module,exports){
paulo@89 3450 'use strict';
paulo@89 3451 /* @flow */
paulo@89 3452
paulo@89 3453 var sumNthPowerDeviations = require(57);
paulo@89 3454
paulo@89 3455 /**
paulo@89 3456 * The [variance](http://en.wikipedia.org/wiki/Variance)
paulo@89 3457 * is the sum of squared deviations from the mean.
paulo@89 3458 *
paulo@89 3459 * This is an implementation of variance, not sample variance:
paulo@89 3460 * see the `sampleVariance` method if you want a sample measure.
paulo@89 3461 *
paulo@89 3462 * @param {Array<number>} x a population
paulo@89 3463 * @returns {number} variance: a value greater than or equal to zero.
paulo@89 3464 * zero indicates that all values are identical.
paulo@89 3465 * @example
paulo@89 3466 * variance([1, 2, 3, 4, 5, 6]); // => 2.9166666666666665
paulo@89 3467 */
paulo@89 3468 function variance(x/*: Array<number> */)/*:number*/ {
paulo@89 3469 // The variance of no numbers is null
paulo@89 3470 if (x.length === 0) { return NaN; }
paulo@89 3471
paulo@89 3472 // Find the mean of squared deviations between the
paulo@89 3473 // mean value and each value.
paulo@89 3474 return sumNthPowerDeviations(x, 2) / x.length;
paulo@89 3475 }
paulo@89 3476
paulo@89 3477 module.exports = variance;
paulo@89 3478
paulo@89 3479 },{"57":57}],63:[function(require,module,exports){
paulo@89 3480 'use strict';
paulo@89 3481 /* @flow */
paulo@89 3482
paulo@89 3483 /**
paulo@89 3484 * The [Z-Score, or Standard Score](http://en.wikipedia.org/wiki/Standard_score).
paulo@89 3485 *
paulo@89 3486 * The standard score is the number of standard deviations an observation
paulo@89 3487 * or datum is above or below the mean. Thus, a positive standard score
paulo@89 3488 * represents a datum above the mean, while a negative standard score
paulo@89 3489 * represents a datum below the mean. It is a dimensionless quantity
paulo@89 3490 * obtained by subtracting the population mean from an individual raw
paulo@89 3491 * score and then dividing the difference by the population standard
paulo@89 3492 * deviation.
paulo@89 3493 *
paulo@89 3494 * The z-score is only defined if one knows the population parameters;
paulo@89 3495 * if one only has a sample set, then the analogous computation with
paulo@89 3496 * sample mean and sample standard deviation yields the
paulo@89 3497 * Student's t-statistic.
paulo@89 3498 *
paulo@89 3499 * @param {number} x
paulo@89 3500 * @param {number} mean
paulo@89 3501 * @param {number} standardDeviation
paulo@89 3502 * @return {number} z score
paulo@89 3503 * @example
paulo@89 3504 * zScore(78, 80, 5); // => -0.4
paulo@89 3505 */
paulo@89 3506 function zScore(x/*:number*/, mean/*:number*/, standardDeviation/*:number*/)/*:number*/ {
paulo@89 3507 return (x - mean) / standardDeviation;
paulo@89 3508 }
paulo@89 3509
paulo@89 3510 module.exports = zScore;
paulo@89 3511
paulo@89 3512 },{}]},{},[1])(1)
paulo@89 3513 });
paulo@89 3514 //# sourceMappingURL=simple-statistics.js.map