exports.T.TEST = function(data_x, data_y) {
data_x = utils.parseNumberArray(utils.flatten(data_x));
data_y = utils.parseNumberArray(utils.flatten(data_y));
if (utils.anyIsError(data_x, data_y)) {
return error.value;
}
var mean_x = jStat.mean(data_x);
var mean_y = jStat.mean(data_y);
var s_x = 0;
var s_y = 0;
var i;
for (i = 0; i < data_x.length; i++) {
s_x += Math.pow(data_x[i] - mean_x, 2);
}
for (i = 0; i < data_y.length; i++) {
s_y += Math.pow(data_y[i] - mean_y, 2);
}
s_x = s_x / (data_x.length-1);
s_y = s_y / (data_y.length-1);
var t = Math.abs(mean_x - mean_y) / Math.sqrt(s_x/data_x.length + s_y/data_y.length);
return exports.T.DIST['2T'](t, data_x.length+data_y.length-2);
};
exports.AVEDEV = function() {
var range = utils.parseNumberArray(utils.flatten(arguments));
if (range instanceof Error) {
return range;
}
return jStat.sum(jStat(range).subtract(jStat.mean(range)).abs()[0]) / range.length;
};
Object.keys(allCounts).forEach (function (param) {
var oldSucc = counts.succ[param] || 0
var oldFail = counts.fail[param] || 0
var newSucc = oldSucc + (deltaCounts.succ[param] || 0)
var newFail = oldFail + (deltaCounts.fail[param] || 0)
d += jStat.betaln(newSucc+1,newFail+1) - jStat.betaln(oldSucc+1,oldFail+1)
})
it('sums multiple beta distributions for multiple throughput sources', function () {
simParams.throughputRisks = [];
var sim = new ProjectSimulator(simParams);
sim.validateAndCleanParameters();
var validatedParameters = sim.validatedSimParams;
var throughputSamples = [];
_.times(validatedParameters.maxIterations, function () {
throughputSamples.push(sim.throughputGenerator.generate());
});
expect(throughputSamples.length).to.equal(validatedParameters.maxIterations);
expect(jStat.min(throughputSamples)).to.be.lt(30);
expect(jStat.max(throughputSamples)).to.be.gt(74);
});
exports.SKEW = function() {
var range = utils.parseNumberArray(utils.flatten(arguments));
if (range instanceof Error) {
return range;
}
var mean = jStat.mean(range);
var n = range.length;
var sigma = 0;
for (var i = 0; i < n; i++) {
sigma += Math.pow(range[i] - mean, 3);
}
return n * sigma / ((n - 1) * (n - 2) * Math.pow(jStat.stdev(range, true), 3));
};
exports.KURT = function() {
var range = utils.parseNumberArray(utils.flatten(arguments));
if (range instanceof Error) {
return range;
}
var mean = jStat.mean(range);
var n = range.length;
var sigma = 0;
for (var i = 0; i < n; i++) {
sigma += Math.pow(range[i] - mean, 4);
}
sigma = sigma / Math.pow(jStat.stdev(range, true), 4);
return ((n * (n + 1)) / ((n - 1) * (n - 2) * (n - 3))) * sigma - 3 * (n - 1) * (n - 1) / ((n - 2) * (n - 3));
};
exports.COVARIANCE.P = function(array1, array2) {
array1 = utils.parseNumberArray(utils.flatten(array1));
array2 = utils.parseNumberArray(utils.flatten(array2));
if (utils.anyIsError(array1, array2)) {
return error.value;
}
var mean1 = jStat.mean(array1);
var mean2 = jStat.mean(array2);
var result = 0;
var n = array1.length;
for (var i = 0; i < n; i++) {
result += (array1[i] - mean1) * (array2[i] - mean2);
}
return result / n;
};
exports.GEOMEAN = function() {
var args = utils.parseNumberArray(utils.flatten(arguments));
if (args instanceof Error) {
return args;
}
return jStat.geomean(args);
};
exports.GAMMALN = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return jStat.gammaln(number);
};
it('adjusts throughput based on multiple throughput risks', function () {
simParams.throughputSources = [{
'description': 'tiny team',
'min': '0',
'mostLikely': '10',
'max': '20'
}];
simParams.throughputRisks = [
{
'description': 'attrition/turnover',
'prob': '0.5',
'impact': '10'
}, {
'description': 'attrition/turnover',
'prob': '0.25',
'impact': '-10'
}
];
var sim = new ProjectSimulator(simParams);
sim.validateAndCleanParameters();
var validatedParameters = sim.validatedSimParams;
var samples = _.times(validatedParameters.maxIterations, function () {
return sim.throughputGenerator.generate();
});
expect(jStat.mean(samples)).to.be.within(12, 13);
});
ScopeChangeGenerator.prototype.generate = function () {
var samples = _.map(
this.scopeChanges,
distributions.betaSampleFromHumanInputs
);
return Math.round(jStat.sum(samples));
};
it('should set bins for a large range', function() {
var h = new Histogram([0, 177]);
h.setupBins();
var expected = [0, 18, 35, 53, 71, 89, 106, 124, 142, 159, 177];
expect(jStat.range(expected)).to.equal(177);
expect(expected.length).to.equal(11);
expect(h.getBins()).to.deep.equal(expected);
});
exports.SLOPE = function(data_y, data_x) {
data_y = utils.parseNumberArray(utils.flatten(data_y));
data_x = utils.parseNumberArray(utils.flatten(data_x));
if (utils.anyIsError(data_y, data_x)) {
return error.value;
}
var xmean = jStat.mean(data_x);
var ymean = jStat.mean(data_y);
var n = data_x.length;
var num = 0;
var den = 0;
for (var i = 0; i < n; i++) {
num += (data_x[i] - xmean) * (data_y[i] - ymean);
den += Math.pow(data_x[i] - xmean, 2);
}
return num / den;
};
exports.COVARIANCE.S = function(array1, array2) {
array1 = utils.parseNumberArray(utils.flatten(array1));
array2 = utils.parseNumberArray(utils.flatten(array2));
if (utils.anyIsError(array1, array2)) {
return error.value;
}
return jStat.covariance(array1, array2);
};
exports.ERFC = function(x) {
// Return error if x is not a number
if (isNaN(x)) {
return error.value;
}
return jStat.erfc(x);
};
exports.CORREL = function(array1, array2) {
array1 = utils.parseNumberArray(utils.flatten(array1));
array2 = utils.parseNumberArray(utils.flatten(array2));
if (utils.anyIsError(array1, array2)) {
return error.value;
}
return jStat.corrcoeff(array1, array2);
};
it('should set bins for a range equal to two less than max bins', function() {
var h = new Histogram([6, 5, 5, 5, 7, 7, -2]);
h.setupBins();
var expected = [-2, -1, 0, 1, 2, 3, 4, 5, 6, 7];
expect(jStat.range(expected)).to.equal(9);
expect(expected.length).to.equal(10);
expect(h.getBins()).to.deep.equal(expected);
});
it('should set bins for a range equal to max bins', function() {
var h = new Histogram([-1, 10]);
h.setupBins();
var expected = [-1, 0, 1, 2, 3, 5, 6, 7, 8, 9, 10];
expect(jStat.range(expected)).to.equal(11);
expect(expected.length).to.equal(11);
expect(h.getBins()).to.deep.equal(expected);
});
it('should set bins for a range three more than max bins', function() {
var h = new Histogram([0, 14]);
h.setupBins();
var expected = [0, 1, 3, 4, 6, 7, 8, 10, 11, 13, 14];
expect(jStat.range(expected)).to.equal(14);
expect(expected.length).to.equal(11);
expect(h.getBins()).to.deep.equal(expected);
});
exports.CONFIDENCE.T = function(alpha, sd, n) {
alpha = utils.parseNumber(alpha);
sd = utils.parseNumber(sd);
n = utils.parseNumber(n);
if (utils.anyIsError(alpha, sd, n)) {
return error.value;
}
return jStat.tci(1, alpha, sd, n)[1] - 1;
};
exports.TRIMMEAN = function(range, percent) {
range = utils.parseNumberArray(utils.flatten(range));
percent = utils.parseNumber(percent);
if (utils.anyIsError(range, percent)) {
return error.value;
}
var trim = mathTrig.FLOOR(range.length * percent, 2) / 2;
return jStat.mean(utils.initial(utils.rest(range.sort(function(a, b) {
return a - b;
}), trim), trim));
};
exports.FORECAST = function(x, data_y, data_x) {
x = utils.parseNumber(x);
data_y = utils.parseNumberArray(utils.flatten(data_y));
data_x = utils.parseNumberArray(utils.flatten(data_x));
if (utils.anyIsError(x, data_y, data_x)) {
return error.value;
}
var xmean = jStat.mean(data_x);
var ymean = jStat.mean(data_y);
var n = data_x.length;
var num = 0;
var den = 0;
for (var i = 0; i < n; i++) {
num += (data_x[i] - xmean) * (data_y[i] - ymean);
den += Math.pow(data_x[i] - xmean, 2);
}
var b = num / den;
var a = ymean - b * xmean;
return a + b * x;
};
exports.DEVSQ = function() {
var range = utils.parseNumberArray(utils.flatten(arguments));
if (range instanceof Error) {
return range;
}
var mean = jStat.mean(range);
var result = 0;
for (var i = 0; i < range.length; i++) {
result += Math.pow((range[i] - mean), 2);
}
return result;
};
exports.ERF = function(lower_bound, upper_bound) {
// Set number2 to zero if undefined
upper_bound = (upper_bound === undefined) ? 0 : upper_bound;
lower_bound = utils.parseNumber(lower_bound);
upper_bound = utils.parseNumber(upper_bound);
if (utils.anyIsError(lower_bound, upper_bound)) {
return error.value;
}
return jStat.erf(lower_bound);
};
it('generates beta distributed throughput samples for a single throughput source', function () {
simParams.throughputSources = [{
'description': 'A team',
'min': '20',
'mostLikely': '45',
'max': '60'
}];
simParams.throughputRisks = [];
var sim = new ProjectSimulator(simParams);
sim.validateAndCleanParameters();
var validatedParameters = sim.validatedSimParams;
var validatedThroughputSource = validatedParameters.throughputSources[0];
var tolerance = 3;
var throughputSamples = [];
_.times(validatedParameters.maxIterations, function () {
throughputSamples.push(sim.throughputGenerator.generate());
});
expect(throughputSamples.length).to.equal(validatedParameters.maxIterations);
expect(jStat.min(throughputSamples)).to.be.lt(validatedThroughputSource.min + tolerance);
expect(jStat.max(throughputSamples)).to.be.gt(validatedThroughputSource.max - tolerance);
expect(jStat.mean(throughputSamples) - validatedThroughputSource.mostLikely).to.be.lt(0.1);
});
exports.COLUMNS = function(matrix) {
if (arguments.length !== 1) {
return error.na;
}
if (!(matrix instanceof Array)) {
return error.value;
}
if (matrix.length === 0) {
return 0;
}
return jStat.cols(matrix);
};
exports.GAMMALN.PRECISE = function(x) {
if (arguments.length !== 1) {
return error.na;
}
if (x <= 0) {
return error.num;
}
if (typeof x !== 'number') {
return error.value;
}
return jStat.gammaln(x);
};
exports.GAMMA = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
if (number === 0) {
return error.num;
}
if (parseInt(number, 10) === number && number < 0) {
return error.num;
}
return jStat.gammafn(number);
};
exports.SKEW.P = function() {
var range = utils.parseNumberArray(utils.flatten(arguments));
if (range instanceof Error) {
return range;
}
var mean = jStat.mean(range);
var n = range.length;
var m2 = 0;
var m3 = 0;
for (var i = 0; i < n; i++) {
m3 += Math.pow(range[i] - mean, 3);
m2 += Math.pow(range[i] - mean, 2);
}
m3 = m3 / n;
m2 = m2 / n;
return m3 / Math.pow(m2, 3 / 2);
};
exports.COLUMN = function(matrix, index) {
if (arguments.length !== 2) {
return error.na;
}
if (index < 0) {
return error.num;
}
if (!(matrix instanceof Array) || (typeof index !== 'number')) {
return error.value;
}
if (matrix.length === 0) {
return undefined;
}
return jStat.col(matrix, index);
};