it("gives the correct regression equation, R^2, and function for a sample input with no correlation", ()=>{
const data:[number,number][] = [
[0.10198768, 0.10165061],
[0.10150876, 0.47896164],
[0.30063469, 0.43840858],
[0.24547808, 0.63594344],
[0.05588675, 0.93228701],
[0.95760052, 0.53645723],
[0.02858332, 0.79155903],
[0.49389574, 0.54855519],
[0.77610317, 0.9879552],
[0.00350206, 0.73565457]
];
const computations = getRegressionComputations(data);
// target values computed via python: scipy.stats.linregress
const m = 0.079113612612723011;
const b = 0.59449349756220937;
const r2 = 0.010257434869772463;
// test regression equation to make sure its approximately the same as what python gives
const match = computations.string.match(/y = ([\d.]+)x \+ ([\d.]+)/);
assert.isNotNull(match, "equation has correct form");
const M = parseFloat(match![1]);
const B = parseFloat(match![2]);
assert.approximately(M, m, 0.05);
assert.approximately(B, b, 0.05);
// make sure `predict` gives the same result as the equation
for (let i=0; i<100; i+=1) {
assert.approximately(computations.predict(i)[1], M*i + B, 0.0000005, `value for ${i}`);
}
// test R^2
assert.approximately(computations.r2, r2, 0.05, "R^2");
});
export function assertCoords(coords: coord) {
assert.isArray(coords);
assert.lengthOf(coords, 2);
assert.approximately(coords[0], 13, 1);
assert.approximately(coords[1], 51, 3);
}
dvb.findAddress(lng, lat).then((address) => {
assert.isDefined(address);
assert.strictEqual(address!.name, "Nöthnitzer Straße 46");
assert.strictEqual(address!.city, "Dresden");
assert.strictEqual(address!.type, dvb.POI_TYPE.Coords);
assert.approximately(address!.coords[0], lng, 0.001);
assert.approximately(address!.coords[1], lat, 0.001);
}));
it("gives the correct result on sample data", ()=>{
// source: https://www.wessa.net/rwasp_spearman.wasp
assert.approximately(
computeCorrelationPValue(-0.423285542595266, 23),
0.0441623330731344,
0.0000000005
);
});
it("gives the correct regression equation, R^2, and function for a sample input with strong correlation", ()=>{
const data:[number,number][] = [
[0,0.33517481],
[1,3.00712561],
[2,6.73118302],
[3,9.25128682],
[4,12.0432596],
[5,15.9087018],
[6,18.71122156],
[7,21.69213527],
[8,24.57708193],
[9,27.98002031],
[10,30.67017471],
[11,33.55231386],
[12,36.20724938],
[13,39.21414698],
[14,42.74163248],
[15,45.95986539],
[16,48.28399276],
[17,51.52361803],
[18,54.62495359]
];
const computations = getRegressionComputations(data);
// target values computed via python: scipy.stats.linregress
const m = 3.0120636256561446;
const b = 0.41853989070105158;
const r2 = 0.99970735279778178;
// test regression equation to make sure its approximately the same as what python gives
const match = computations.string.match(/y = ([\d.]+)x \+ ([\d.]+)/);
assert.isNotNull(match, "equation has correct form");
const M = parseFloat(match![1]);
const B = parseFloat(match![2]);
assert.approximately(M, m, 0.05);
assert.approximately(B, b, 0.05);
// make sure `predict` gives the same result as the equation
for (let i=0; i<100; i+=1) {
assert.approximately(computations.predict(i)[1], M*i + B, 0.0000005, `value for ${i}`);
}
// test R^2
assert.approximately(computations.r2, r2, 0.05, "R^2");
});
it("adds two numeric stats together", () => {
const aData = [1.1, 3.3, 2.2];
const bData = [2.0, 3.0, 5.5, 1.2];
let countA = 0;
let countB = 0;
let countAB = 0;
let sumA = 0;
let sumB = 0;
let sumAB = 0;
const a = emptyStats();
const b = emptyStats();
const ab = emptyStats();
aData.forEach(v => {
countA++;
sumA += v;
record(a, countA, v);
});
bData.forEach(v => {
countB++;
sumB += v;
record(b, countB, v);
});
bData.concat(aData).forEach(v => {
countAB++;
sumAB += v;
record(ab, countAB, v);
});
assert.approximately(a.mean, 2.2, 0.0000001);
assert.approximately(a.mean, sumA / countA, 0.0000001);
assert.approximately(b.mean, sumB / countB, 0.0000001);
assert.approximately(ab.mean, sumAB / countAB, 0.0000001);
const combined = addNumericStats(a, b, countA, countB);
assert.approximately(combined.mean, ab.mean, 0.0000001);
assert.approximately(combined.squared_diffs, ab.squared_diffs, 0.0000001);
const reversed = addNumericStats(b, a, countB, countA);
assert.deepEqual(reversed, combined);
});
it("combines statement statistics", () => {
const a = randomStats();
const b = randomStats();
const c = randomStats();
const ab = combineStatementStats([a, b]);
const ac = combineStatementStats([a, c]);
const bc = combineStatementStats([b, c]);
// tslint:disable:variable-name
const ab_c = combineStatementStats([ab, c]);
const ac_b = combineStatementStats([ac, b]);
const bc_a = combineStatementStats([bc, a]);
// tslint:enable:variable-name
assert.equal(ab_c.count.toString(), ac_b.count.toString());
assert.equal(ab_c.count.toString(), bc_a.count.toString());
assert.equal(ab_c.first_attempt_count.toString(), ac_b.first_attempt_count.toString());
assert.equal(ab_c.first_attempt_count.toString(), bc_a.first_attempt_count.toString());
assert.equal(ab_c.max_retries.toString(), ac_b.max_retries.toString());
assert.equal(ab_c.max_retries.toString(), bc_a.max_retries.toString());
assert.approximately(ab_c.num_rows.mean, ac_b.num_rows.mean, 0.0000001);
assert.approximately(ab_c.num_rows.mean, bc_a.num_rows.mean, 0.0000001);
assert.approximately(ab_c.num_rows.squared_diffs, ac_b.num_rows.squared_diffs, 0.0000001);
assert.approximately(ab_c.num_rows.squared_diffs, bc_a.num_rows.squared_diffs, 0.0000001);
assert.approximately(ab_c.parse_lat.mean, ac_b.parse_lat.mean, 0.0000001);
assert.approximately(ab_c.parse_lat.mean, bc_a.parse_lat.mean, 0.0000001);
assert.approximately(ab_c.parse_lat.squared_diffs, ac_b.parse_lat.squared_diffs, 0.0000001);
assert.approximately(ab_c.parse_lat.squared_diffs, bc_a.parse_lat.squared_diffs, 0.0000001);
assert.approximately(ab_c.plan_lat.mean, ac_b.plan_lat.mean, 0.0000001);
assert.approximately(ab_c.plan_lat.mean, bc_a.plan_lat.mean, 0.0000001);
assert.approximately(ab_c.plan_lat.squared_diffs, ac_b.plan_lat.squared_diffs, 0.0000001);
assert.approximately(ab_c.plan_lat.squared_diffs, bc_a.plan_lat.squared_diffs, 0.0000001);
assert.approximately(ab_c.run_lat.mean, ac_b.run_lat.mean, 0.0000001);
assert.approximately(ab_c.run_lat.mean, bc_a.run_lat.mean, 0.0000001);
assert.approximately(ab_c.run_lat.squared_diffs, ac_b.run_lat.squared_diffs, 0.0000001);
assert.approximately(ab_c.run_lat.squared_diffs, bc_a.run_lat.squared_diffs, 0.0000001);
assert.approximately(ab_c.service_lat.mean, ac_b.service_lat.mean, 0.0000001);
assert.approximately(ab_c.service_lat.mean, bc_a.service_lat.mean, 0.0000001);
assert.approximately(ab_c.service_lat.squared_diffs, ac_b.service_lat.squared_diffs, 0.0000001);
assert.approximately(ab_c.service_lat.squared_diffs, bc_a.service_lat.squared_diffs, 0.0000001);
assert.approximately(ab_c.overhead_lat.mean, ac_b.overhead_lat.mean, 0.0000001);
assert.approximately(ab_c.overhead_lat.mean, bc_a.overhead_lat.mean, 0.0000001);
assert.approximately(ab_c.overhead_lat.squared_diffs, ac_b.overhead_lat.squared_diffs, 0.0000001);
assert.approximately(ab_c.overhead_lat.squared_diffs, bc_a.overhead_lat.squared_diffs, 0.0000001);
});
it("WmOrGK4toWGS84 GK4", () => {
const point = utils.WmOrGK4toWGS84(`${gk4[0]}`, `${gk4[1]}`);
assert.isArray(point);
assert.approximately(point![0], wgs84[0], 0.0001);
assert.approximately(point![1], wgs84[1], 0.0001);
});
it("WGS84toWm", () => {
const point = utils.WGS84toWm(wgs84[0], wgs84[1]);
assert.approximately(point[0], wm[0], 3);
assert.approximately(point[1], wm[1], 3);
});
it("WGS84toGK4", () => {
const point = utils.WGS84toGK4(wgs84[0], wgs84[1]);
assert.approximately(point[0], gk4[0], 3);
assert.approximately(point[1], gk4[1], 3);
});