How to use simple-statistics - 10 common examples

it('statistics methods on fields of array', () => {
    const data = [];
    for (let i = 1; i <= 10; i++) {
      // 1~10
      data.push({
        a: [i, i + 10, [-i, i * i, [-i * i, 1 / i]]],
      });
    }
    const dv = new DataSet.View().source(data);
    const values = flattenDeep(dv.getColumn('a'));
    expect(dv.max('a')).to.equal(max(values));
    expect(dv.min('a')).to.equal(min(values));
    expect(dv.mean('a')).to.equal(mean(values));
    expect(dv.average('a')).to.equal(mean(values));
    expect(dv.median('a')).to.equal(median(values));
    expect(dv.mode('a')).to.equal(mode(values));
    expect(dv.quantile('a', 0.5)).to.equal(quantile(values, 0.5));
    expect(dv.quantiles('a', [0, 0.1, 0.5])).to.eql(map([0, 0.1, 0.5], (p) => quantile(values, p)));
    expect(dv.quantilesByFraction('a', 4)).to.eql(map([0, 0.25, 0.5, 0.75, 1], (p) => quantile(values, p)));
    expect(dv.standardDeviation('a')).to.equal(standardDeviation(values));
    expect(dv.sum('a')).to.equal(sum(values));
    expect(dv.variance('a')).to.equal(variance(values));
    expect(dv.range('a')).to.eql([min(values), max(values)]);
  });
});

function calculateLinearFit(datapoints){

  var data = [];

  for(var j=0;j< datapoints.length;j++){

    if(datapoints[j][0] !== null) {
      data.push([j, datapoints[j][0]]);
    }
  }

  var line = ss.linear_regression()
      .data(data)
      .line()

  var gradient = ss.linear_regression()
      .data(data)
      .m()
  //winston.info('stijgings percentage: ' + (line(data.length-1)-line(0))/ line(0)) / data.length * 100;
  //winston.info('gradient: ' + gradient * 100);
  //winston.info('line(0): ' + line(0));
  //winston.info('line(data.length-1): ' + line(data.length-1));

  /* if no valid number is calculated, return null*/

  var result = !isNaN(Math.round(((((line(data.length-1)-line(0))/ line(0)) / data.length) * 100 * 100)* 100) / 100) ? Math.round(((((line(data.length-1)-line(0))/ line(0)) / data.length) * 100 * 100)* 100) / 100 : null;

  return result;

it('statistics methods on fields of array', () => {
    const data = [];
    for (let i = 1; i <= 10; i++) {
      // 1~10
      data.push({
        a: [i, i + 10, [-i, i * i, [-i * i, 1 / i]]],
      });
    }
    const dv = new DataSet.View().source(data);
    const values = flattenDeep(dv.getColumn('a'));
    expect(dv.max('a')).to.equal(max(values));
    expect(dv.min('a')).to.equal(min(values));
    expect(dv.mean('a')).to.equal(mean(values));
    expect(dv.average('a')).to.equal(mean(values));
    expect(dv.median('a')).to.equal(median(values));
    expect(dv.mode('a')).to.equal(mode(values));
    expect(dv.quantile('a', 0.5)).to.equal(quantile(values, 0.5));
    expect(dv.quantiles('a', [0, 0.1, 0.5])).to.eql(map([0, 0.1, 0.5], (p) => quantile(values, p)));
    expect(dv.quantilesByFraction('a', 4)).to.eql(map([0, 0.25, 0.5, 0.75, 1], (p) => quantile(values, p)));
    expect(dv.standardDeviation('a')).to.equal(standardDeviation(values));
    expect(dv.sum('a')).to.equal(sum(values));
    expect(dv.variance('a')).to.equal(variance(values));
    expect(dv.range('a')).to.eql([min(values), max(values)]);
  });
});

source._backend.getTile(0,0,0, function(err, vtile, headers) {
            if (err) throw err;
            var tile = vtile;
            var layerInfo = profiler.layerInfo(tile);

            // Tile has a 'coastline' layer
            var coastline = _(layerInfo).where({ name: 'coastline' })[0];
            t.ok(coastline);

            // Tile contains 4177 features
            t.equal(coastline.coordCount.length, 1437);
            t.equal(coastline.features, 1437);

            // Longest/shortest features
            t.equal(ss.max(coastline.coordCount), 380);
            t.equal(ss.min(coastline.coordCount), 2);

            // Most/least duplication
            t.equal(ss.max(coastline.duplicateCoordCount), 0);
            t.equal(ss.min(coastline.duplicateCoordCount), 0);

            // Max/Min distance between consecutive coords
            var diff = Math.abs(ss.max(coastline.coordDistance) - 570446.5598775251);
            t.ok(diff < 0.1);
            t.equal(ss.min(coastline.coordDistance), 1181.6043940629547);

            // Expected jsonsize
            t.equal(coastline.jsonsize, 520120);

            t.end();
        });
    });

}, function (err, result) {
    process.stdout.write(' DONE!\n\n');
    if (err) {
      console.log(err);
      process.exit(1);
    }

    console.log('Response Times:');
    console.log('Min: ' + Math.floor(ss.min(result)) + 'ms');
    console.log('Max: ' + Math.floor(ss.max(result)) + 'ms');
    console.log('95th: ' + Math.floor(ss.quantile(result, 0.95)) + 'ms');
    console.log('Std Dev: ' + Math.floor(ss.standardDeviation(result)) + 'ms');

    console.log('\nRedis Cache:');
    redisStats(api);

    console.log('\nUser Cache:');
    userStats(api);

    process.exit(0); // TODO shutdown cleanly

    api.client._client.shutdown();
  });
}

}, function (err, result) {
    process.stdout.write(' DONE!\n\n');
    if (err) {
      console.log(err);
      process.exit(1);
    }

    console.log('Response Times:');
    console.log('Min: ' + Math.floor(ss.min(result)) + 'ms');
    console.log('Max: ' + Math.floor(ss.max(result)) + 'ms');
    console.log('95th: ' + Math.floor(ss.quantile(result, 0.95)) + 'ms');
    console.log('Std Dev: ' + Math.floor(ss.standardDeviation(result)) + 'ms');

    console.log('\nRedis Cache:');
    redisStats(api);

    console.log('\nUser Cache:');
    userStats(api);

    process.exit(0); // TODO shutdown cleanly

    api.client._client.shutdown();
  });
}

[100, 500, 1000, 2000, 3000, 5000, 10000].forEach(function(nRounds){
	let nSimulations = 20
	let results = []
	for(let i = 0; i < nSimulations; i++){
		// console.log(`do simulation ${i} with ${nRounds} rounds`)
		var result = PokerHand.MonteCarlo.simulateOddsIfAllIn(nRounds, holeCards, communityCards, nbOtherPlayers)
		results.push(result)
	}
	
	// compute stats on the results
	let mean = SimpleStats.mean(results)
	let stddev = SimpleStats.standardDeviation(results)
	let max = SimpleStats.max(results)
	let min = SimpleStats.min(results)
	console.log(`nRounds ${nRounds.toString().padStart(5)} : mean ${mean.toFixed(6)} (${Math.round(mean*100).toString().padStart(2)}%) - stddev ${stddev.toFixed(6)} - delta min/max [${(min-mean).toFixed(6)}, ${(max-mean).toFixed(6)}]`)	
})

forIn(groups, (group) => {
    const totalSum = sum(group.map((row: any) => row[field]));
    if (totalSum === 0) {
      console.warn(`Invalid data: total sum of field ${field} is 0!`);
    }
    const innerGroups = partition(group, [dimension]);
    forIn(innerGroups, (innerGroup) => {
      const innerSum = sum(innerGroup.map((row: any) => row[field]));
      // const resultRow = pick(innerGroup[0], union(groupBy, [ dimension ]));
      const resultRow = innerGroup[0];
      // FIXME in case dimension and field is the same
      const dimensionValue = resultRow[dimension];
      resultRow[field] = innerSum;
      resultRow[dimension] = dimensionValue;
      if (totalSum === 0) {
        resultRow[as!] = 0;
      } else {
        resultRow[as!] = innerSum / totalSum;

function safeQuantile(values: number[], q: number | number[]): any {
  // Handle cases when `values` is empty gracefully
  if (values.length > 0) {
    return quantile(values, q as any)
  } else if (typeof q === 'number') {
    return 0
  } else {
    return q.map(() => 0)
  }
}

data.weeks.push(year.weeks[w]);
                }

                for (var wd = 0; wd < 7; wd++) {
                    data.weekDays[wd] = data.weekDays[wd].concat(year.weekDays[wd]);
                }

                data.days = data.days.concat(year.days);
            }

            // districtData.data = data;

            // calculate means
            districtData.meanYears = ss.mean(data.years);
            districtData.meanMonth = ss.mean(data.month);

            for (var l = 0; l < 12; l++) {
                if (data.yearMonth[l].length === 0) {
                    districtData.meanYearMonth[l] = 0;
                }
                else if (data.yearMonth[l].length === 1) {
                    districtData.meanYearMonth[l] = data.yearMonth[l][0];
                }
                else {
                    districtData.meanYearMonth[l] = ss.mean(data.yearMonth[l]);
                }

                if (output.districts.length === 0) {
                    output.meanYearMonth[l] = districtData.meanYearMonth[l];
                }
                else {