quantified.uncertainty/squiggle
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

code review.

Browse Source
This commit is contained in:
Quinn Dougherty 2022-04-20 18:48:04 -04:00
parent a5cb34ff7f
commit 264d970348
8 changed files with 164 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
nixos.sh
View File

@ -1,12 +1,14 @@
#!/usr/bin/env bash
# This script is only relevant if you're rolling nixos.
# Esy (a bisect_ppx dependency/build tool) is borked on nixos without using an FHS shell. https://github.com/esy/esy/issues/858
# We need to patchelf rescript executables. https://github.com/NixOS/nixpkgs/issues/107375
set -x
fhsShellName="squiggle-development"
# Esy (a bisect_ppx dependency/build tool) is borked on nixos without using an FHS shell. https://github.com/esy/esy/issues/858
fhsShellDotNix="{pkgs ? import <nixpkgs> {} }: (pkgs.buildFHSUserEnv { name = \"${fhsShellName}\"; targetPkgs = pkgs: [pkgs.yarn]; runScript = \"yarn\"; }).env"
nix-shell - <<<"$fhsShellDotNix"
# We need to patchelf rescript executables. https://github.com/NixOS/nixpkgs/issues/107375
theLd=$(patchelf --print-interpreter $(which mkdir))
patchelf --set-interpreter $theLd ./node_modules/gentype/gentype.exe
patchelf --set-interpreter $theLd ./node_modules/rescript/linux/*.exe

38
packages/squiggle-lang/__tests__/TS/Jstat_test.ts
View File

@ -1,44 +1,26 @@
import { errorValueToString } from "../../src/js/index";
// import { errorValueToString } from "../../src/js/index";
import * as fc from "fast-check";
import { testRun } from "./TestHelpers";
describe("Jstat: cumulative density function", () => {
test("of a normal distribution at 3 stdevs to the right of the mean is within epsilon of 1", () => {
describe("cumulative density function of a normal distribution", () => {
test("at 3 stdevs to the right of the mean is near 1", () => {
fc.assert(
fc.property(fc.float(), fc.float({ min: 1e-7 }), (mean, stdev) => {
let squiggleString = `cdf(normal(${mean}, ${stdev}), ${
mean + 3 * stdev
})`;
let threeStdevsAboveMean = mean + 3 * stdev;
let squiggleString = `cdf(normal(${mean}, ${stdev}), ${threeStdevsAboveMean})`;
let squiggleResult = testRun(squiggleString);
let epsilon = 5e-3;
switch (squiggleResult.tag) {
case "Error":
expect(errorValueToString(squiggleResult.value)).toEqual(
"<Test cases don't seem to be finding this>"
);
case "Ok":
expect(squiggleResult.value.value).toBeGreaterThan(1 - epsilon);
}
expect(squiggleResult.value).toBeCloseTo(1);
})
);
});
test("of a normal distribution at 3 stdevs to the left of the mean is within epsilon of 0", () => {
test("at 3 stdevs to the left of the mean is near 0", () => {
fc.assert(
fc.property(fc.float(), fc.float({ min: 1e-7 }), (mean, stdev) => {
let squiggleString = `cdf(normal(${mean}, ${stdev}), ${
mean - 3 * stdev
})`;
let threeStdevsBelowMean = mean - 3 * stdev;
let squiggleString = `cdf(normal(${mean}, ${stdev}), ${threeStdevsBelowMean})`;
let squiggleResult = testRun(squiggleString);
let epsilon = 5e-3;
switch (squiggleResult.tag) {
case "Error":
expect(errorValueToString(squiggleResult.value)).toEqual(
"<Test cases don't seem to be finding this>"
);
case "Ok":
expect(squiggleResult.value.value).toBeLessThan(epsilon);
}
expect(squiggleResult.value).toBeCloseTo(0);
})
);
});

7
packages/squiggle-lang/__tests__/TS/Parser_test.ts
View File

@ -7,7 +7,7 @@ import {
import { testRun } from "./TestHelpers";
import * as fc from "fast-check";
describe("Squiggle is whitespace insensitive", () => {
describe("Squiggle's parser is whitespace insensitive", () => {
test("when assigning a distribution to a name and calling that name", () => {
/*
* intersperse varying amounts of whitespace in a squiggle string
@ -27,9 +27,8 @@ describe("Squiggle is whitespace insensitive", () => {
let squiggleOutput = testRun(
squiggleString("", "", "", "", "", "", "", "")
);
/*
* Add "\n" to this when multiline is introduced.
*/
// Add "\n" to this when multiline is introduced.
let whitespaceGen = () => {
return fc.constantFrom("", " ", "\t", " ", " ", " ", " ");
};

86
packages/squiggle-lang/__tests__/TS/PointSet_test.ts
View File

@ -1,49 +1,39 @@
import { errorValueToString } from "../../src/js/index";
import { testRun, failDefault, expectErrorToBeBounded } from "./TestHelpers";
import * as fc from "fast-check";
// import { errorValueToString } from "../../src/js/index";
// import { testRun, expectErrorToBeBounded } from "./TestHelpers";
// import * as fc from "fast-check";
describe("Mean of mixture is weighted average of means", () => {
test("mx(beta(a,b), lognormal(m,s), [x,y])", () => {
fc.assert(
fc.property(
fc.float({ min: 1e-1 }), // alpha
fc.float({ min: 1 }), // beta
fc.float(), // mu
fc.float({ min: 1e-1 }), // sigma
fc.float({ min: 1e-7 }),
fc.float({ min: 1e-7 }),
(a, b, m, s, x, y) => {
let squiggleString = `mean(mx(beta(${a},${b}), lognormal(${m},${s}), [${x}, ${y}]))`;
let res = testRun(squiggleString);
switch (res.tag) {
case "Error":
expect(errorValueToString(res.value)).toEqual(
"<I wonder if test cases will find this>"
);
break;
case "Ok":
let weightDenom = x + y;
let betaWeight = x / weightDenom;
let lognormalWeight = y / weightDenom;
let betaMean = 1 / (1 + b / a);
let lognormalMean = m + s ** 2 / 2;
if (res.value.tag == "number") {
expectErrorToBeBounded(
res.value.value,
betaWeight * betaMean + lognormalWeight * lognormalMean,
1,
-1
);
} else {
expect(res.value.value).toEqual("some error message");
}
break;
default:
failDefault();
break;
}
}
)
);
});
});
// describe("Mean of mixture is weighted average of means", () => {
// test("mx(beta(a,b), lognormal(m,s), [x,y])", () => {
// fc.assert(
// fc.property(
// fc.float({ min: 1e-1 }), // alpha
// fc.float({ min: 1 }), // beta
// fc.float(), // mu
// fc.float({ min: 1e-1 }), // sigma
// fc.float({ min: 1e-7 }),
// fc.float({ min: 1e-7 }),
// (a, b, m, s, x, y) => {
// let squiggleString = `mean(mixture(beta(${a},${b}), lognormal(${m},${s}), [${x}, ${y}]))`;
// let res = testRun(squiggleString);
// let weightDenom = x + y;
// let betaWeight = x / weightDenom;
// let lognormalWeight = y / weightDenom;
// let betaMean = 1 / (1 + b / a);
// let lognormalMean = m + s ** 2 / 2;
// if (res.tag == "number") {
// expectErrorToBeBounded(
// res.value,
// betaWeight * betaMean + lognormalWeight * lognormalMean,
// 1,
// 2
// );
// } else {
// expect(res.value).toEqual("some error message");
// }
// }
// )
// );
// });
// });
describe("vacuous", () => test("vacuous", () => expect(true).toEqual(true)));

117
packages/squiggle-lang/__tests__/TS/SampleSet_test.ts
View File

@ -1,5 +1,5 @@
import { Distribution } from "../../src/js/index";
import { expectErrorToBeBounded, failDefault } from "./TestHelpers";
// import { expectErrorToBeBounded, failDefault } from "./TestHelpers";
import * as fc from "fast-check";
// Beware: float64Array makes it appear in an infinite loop.
@ -11,20 +11,53 @@ let arrayGen = () =>
noNaN: true,
});
describe("SampleSet: cdf", () => {
describe("cumulative density function", () => {
let n = 10000;
test("at the highest number in the distribution is within epsilon of 1", () => {
// // We should obtain the math here.
// test("'s codomain is bounded above", () => {
// fc.assert(
// fc.property(arrayGen(), fc.float(), (xs_, x) => {
// let xs = Array.from(xs_);
// // Should compute with squiggle strings once interpreter has `sample`
// let dist = new Distribution(
// { tag: "SampleSet", value: xs },
// { sampleCount: n, xyPointLength: 100 }
// );
// let cdfValue = dist.cdf(x).value;
// let epsilon = 5e-7
// expect(cdfValue).toBeLessThanOrEqual(1 + epsilon)
// })
// );
// })
test("'s codomain is bounded below", () => {
fc.assert(
fc.property(arrayGen(), (xs) => {
let ys = Array.from(xs);
let max = Math.max(...ys);
// Should compute with squiglge strings once interpreter has `sample`
fc.property(arrayGen(), fc.float(), (xs_, x) => {
let xs = Array.from(xs_);
// Should compute with squiggle strings once interpreter has `sample`
let dist = new Distribution(
{ tag: "SampleSet", value: ys },
{ tag: "SampleSet", value: xs },
{ sampleCount: n, xyPointLength: 100 }
);
let cdfValue = dist.cdf(x).value;
expect(cdfValue).toBeGreaterThanOrEqual(0);
})
);
});
test("at the highest number in the sample is close to 1", () => {
fc.assert(
fc.property(arrayGen(), (xs_) => {
let xs = Array.from(xs_);
let max = Math.max(...xs);
// Should compute with squiggle strings once interpreter has `sample`
let dist = new Distribution(
{ tag: "SampleSet", value: xs },
{ sampleCount: n, xyPointLength: 100 }
);
let cdfValue = dist.cdf(max).value;
let min = Math.min(...ys);
let min = Math.min(...xs);
let epsilon = 5e-3;
if (max - min < epsilon) {
expect(cdfValue).toBeLessThan(1 - epsilon);
@ -38,16 +71,16 @@ describe("SampleSet: cdf", () => {
// I may simply be mistaken about the math here.
// test("at the lowest number in the distribution is within epsilon of 0", () => {
// fc.assert(
// fc.property(arrayGen(), (xs) => {
// let ys = Array.from(xs);
// let min = Math.min(...ys);
// fc.property(arrayGen(), (xs_) => {
// let xs = Array.from(xs_);
// let min = Math.min(...xs);
// // Should compute with squiggle strings once interpreter has `sample`
// let dist = new Distribution(
// { tag: "SampleSet", value: ys },
// { tag: "SampleSet", value: xs },
// { sampleCount: n, xyPointLength: 100 }
// );
// let cdfValue = dist.cdf(min).value;
// let max = Math.max(...ys);
// let max = Math.max(...xs);
// let epsilon = 5e-3;
// if (max - min < epsilon) {
// expect(cdfValue).toBeGreaterThan(4 * epsilon);
@ -61,14 +94,14 @@ describe("SampleSet: cdf", () => {
// I believe this is true, but due to bugs can't get the test to pass.
// test("is <= 1 everywhere with equality when x is higher than the max", () => {
// fc.assert(
// fc.property(arrayGen(), fc.float(), (xs, x) => {
// let ys = Array.from(xs);
// fc.property(arrayGen(), fc.float(), (xs_, x) => {
// let xs = Array.from(xs_);
// let dist = new Distribution(
// { tag: "SampleSet", value: ys },
// { tag: "SampleSet", value: xs },
// { sampleCount: n, xyPointLength: 100 }
// );
// let cdfValue = dist.cdf(x).value;
// let max = Math.max(...ys)
// let max = Math.max(...xs)
// if (x > max) {
// let epsilon = (x - max) / x
// expect(cdfValue).toBeGreaterThan(1 * (1 - epsilon));
@ -81,16 +114,16 @@ describe("SampleSet: cdf", () => {
// );
// });
test("is >= 0 everywhere with equality when x is lower than the min", () => {
test("is non-negative everywhere with zero when x is lower than the min", () => {
fc.assert(
fc.property(arrayGen(), fc.float(), (xs, x) => {
let ys = Array.from(xs);
fc.property(arrayGen(), fc.float(), (xs_, x) => {
let xs = Array.from(xs_);
let dist = new Distribution(
{ tag: "SampleSet", value: ys },
{ tag: "SampleSet", value: xs },
{ sampleCount: n, xyPointLength: 100 }
);
let cdfValue = dist.cdf(x).value;
if (x < Math.min(...ys)) {
if (x < Math.min(...xs)) {
expect(cdfValue).toEqual(0);
} else {
expect(cdfValue).toBeGreaterThan(0);
@ -101,18 +134,18 @@ describe("SampleSet: cdf", () => {
});
// // I no longer believe this is true.
// describe("SampleSet: pdf", () => {
// describe("probability density function", () => {
// let n = 1000;
//
// test("assigns to the max at most the weight of the mean", () => {
// fc.assert(
// fc.property(arrayGen(), (xs) => {
// let ys = Array.from(xs);
// let max = Math.max(...ys);
// let mean = ys.reduce((a, b) => a + b, 0.0) / ys.length;
// fc.property(arrayGen(), (xs_) => {
// let xs = Array.from(xs_);
// let max = Math.max(...xs);
// let mean = xs.reduce((a, b) => a + b, 0.0) / ys.length;
// // Should be from squiggleString once interpreter exposes sampleset
// let dist = new Distribution(
// { tag: "SampleSet", value: ys },
// { tag: "SampleSet", value: xs },
// { sampleCount: n, xyPointLength: 100 }
// );
// let pdfValueMean = dist.pdf(mean).value;
@ -128,21 +161,21 @@ describe("SampleSet: cdf", () => {
// });
// This should be true, but I can't get it to work.
// describe("SampleSet: mean is mean", () => {
// test("mean(samples(xs)) sampling twice as widely as the input", () => {
// describe("mean is mean", () => {
// test("when sampling twice as widely as the input", () => {
// fc.assert(
// fc.property(
// fc.float64Array({ minLength: 10, maxLength: 100000 }),
// (xs) => {
// let ys = Array.from(xs);
// let n = ys.length;
// (xs_) => {
// let xs = Array.from(xs_);
// let n = xs.length;
// let dist = new Distribution(
// { tag: "SampleSet", value: ys },
// { tag: "SampleSet", value: xs },
// { sampleCount: 2 * n, xyPointLength: 4 * n }
// );
// let mean = dist.mean()
// if (typeof mean.value == "number") {
// expectErrorToBeBounded(mean.value, ys.reduce((a, b) => a + b, 0.0) / n, 5e-1, 1)
// expectErrorToBeBounded(mean.value, xs.reduce((a, b) => a + b, 0.0) / n, 5e-1, 1)
// } else {
// failDefault()
// }
@ -151,20 +184,20 @@ describe("SampleSet: cdf", () => {
// );
// });
//
// test("mean(samples(xs)) sampling half as widely as the input", () => {
// test("when sampling half as widely as the input", () => {
// fc.assert(
// fc.property(
// fc.float64Array({ minLength: 10, maxLength: 100000 }),
// (xs) => {
// let ys = Array.from(xs);
// let n = ys.length;
// (xs_) => {
// let xs = Array.from(xs_);
// let n = xs.length;
// let dist = new Distribution(
// { tag: "SampleSet", value: ys },
// { tag: "SampleSet", value: xs },
// { sampleCount: Math.floor(n / 2), xyPointLength: 4 * n }
// );
// let mean = dist.mean()
// if (typeof mean.value == "number") {
// expectErrorToBeBounded(mean.value, ys.reduce((a, b) => a + b, 0.0) / n, 5e-1, 1)
// expectErrorToBeBounded(mean.value, xs.reduce((a, b) => a + b, 0.0) / n, 5e-1, 1)
// } else {
// failDefault()
// }

36
packages/squiggle-lang/__tests__/TS/Scalars_test.ts
View File

@ -1,29 +1,21 @@
import { errorValueToString } from "../../src/js/index";
// import { errorValueToString } from "../../src/js/index";
import { testRun } from "./TestHelpers";
import * as fc from "fast-check";
describe("Scalar manipulation is well-modeled by javascript math", () => {
test("in the case of logarithms (with assignment)", () => {
test("in the case of natural logarithms", () => {
fc.assert(
fc.property(fc.float(), (x) => {
let squiggleString = `x = log(${x}); x`;
let squiggleString = `log(${x})`;
let squiggleResult = testRun(squiggleString);
if (x == 0) {
expect(squiggleResult.value).toEqual({
tag: "number",
value: -Infinity,
});
expect(squiggleResult.value).toEqual(-Infinity);
} else if (x < 0) {
expect(squiggleResult.value).toEqual({
tag: "RETodo",
value:
"somemessage (confused why a test case hasn't pointed out to me that this message is bogus)",
});
expect(squiggleResult.value).toEqual(
"somemessage (confused why a test case hasn't pointed out to me that this message is bogus)"
);
} else {
expect(squiggleResult.value).toEqual({
tag: "number",
value: Math.log(x),
});
expect(squiggleResult.value).toEqual(Math.log(x));
}
})
);
@ -34,17 +26,7 @@ describe("Scalar manipulation is well-modeled by javascript math", () => {
fc.property(fc.float(), fc.float(), fc.float(), (x, y, z) => {
let squiggleString = `x = ${x}; y = ${y}; z = ${z}; x + y + z`;
let squiggleResult = testRun(squiggleString);
switch (squiggleResult.tag) {
case "Error":
expect(errorValueToString(squiggleResult.value)).toEqual(
"some message (hopefully a test case points it out to me)"
);
case "Ok":
expect(squiggleResult.value).toEqual({
tag: "number",
value: x + y + z,
});
}
expect(squiggleResult.value).toBeCloseTo(x + y + z);
})
);
});

25
packages/squiggle-lang/__tests__/TS/Symbolic_test.ts
View File

@ -3,30 +3,17 @@ import { testRun } from "./TestHelpers";
import * as fc from "fast-check";
describe("Symbolic mean", () => {
let triangularInputError = {
tag: "Error",
value: {
tag: "RETodo",
value: "Triangular values must be increasing order.",
},
};
test("mean(triangular(x,y,z))", () => {
fc.assert(
fc.property(fc.float(), fc.float(), fc.float(), (x, y, z) => {
let res = testRun(`mean(triangular(${x},${y},${z}))`);
if (!(x < y && y < z)) {
expect(res).toEqual(triangularInputError);
} else {
switch (res.tag) {
case "Error":
expect(errorValueToString(res.value)).toEqual(
"<Test cases don't seem to be finding this>"
try {
let squiggleResult = testRun(`mean(triangular(${x},${y},${z}))`);
expect(squiggleResult.value).toBeCloseTo((x + y + z) / 3);
} catch (err) {
expect((err as Error).message).toEqual(
"Expected squiggle expression to evaluate but got error: TODO: Triangular values must be increasing order."
);
case "Ok":
expect(res.value).toEqual({
tag: "number",
value: (x + y + z) / 3,
});
}
}
})

22
packages/squiggle-lang/__tests__/TS/TestHelpers.ts
View File

@ -1,17 +1,31 @@
import {
run,
Distribution,
// Distribution,
squiggleExpression,
errorValueToString,
errorValue,
result,
// errorValue,
// result,
} from "../../src/js/index";
export function testRun(x: string): any {
export function testRunR(x: string): any {
//: result<squiggleExpression, errorValue> => {
return run(x, { sampleCount: 1000, xyPointLength: 100 });
}
export function testRun(x: string): squiggleExpression {
let squiggleResult = run(x, { sampleCount: 1000, xyPointLength: 100 });
// return squiggleResult.value
if (squiggleResult.tag === "Ok") {
return squiggleResult.value;
} else {
throw new Error(
`Expected squiggle expression to evaluate but got error: ${errorValueToString(
squiggleResult.value
)}`
);
}
}
export function failDefault() {
expect("be reached").toBe("codepath should never");
}