141 lines
4.3 KiB
Plaintext
141 lines
4.3 KiB
Plaintext
/*
|
|
This is the most basic file in our invariants family of tests.
|
|
|
|
See document in https://github.com/quantified-uncertainty/squiggle/pull/238 for details
|
|
|
|
Note: digits parameter should be higher than -4.
|
|
*/
|
|
|
|
open Jest
|
|
open Expect
|
|
open TestHelpers
|
|
|
|
let {
|
|
algebraicAdd,
|
|
algebraicMultiply,
|
|
algebraicDivide,
|
|
algebraicSubtract,
|
|
algebraicLogarithm,
|
|
algebraicPower,
|
|
} = module(DistributionOperation.Constructors)
|
|
|
|
let algebraicAdd = algebraicAdd(~env)
|
|
let algebraicMultiply = algebraicMultiply(~env)
|
|
let algebraicDivide = algebraicDivide(~env)
|
|
let algebraicSubtract = algebraicSubtract(~env)
|
|
let algebraicLogarithm = algebraicLogarithm(~env)
|
|
let algebraicPower = algebraicPower(~env)
|
|
|
|
describe("Mean", () => {
|
|
let digits = -4
|
|
|
|
let mean = GenericDist_Types.Constructors.UsingDists.mean
|
|
|
|
let runMean: result<DistributionTypes.genericDist, DistributionTypes.error> => float = distR => {
|
|
distR
|
|
->E.R2.fmap(mean)
|
|
->E.R2.fmap(run)
|
|
->E.R2.fmap(toFloat)
|
|
->E.R.toExn
|
|
->E.O2.toExn("Shouldn't see this because we trust testcase input")
|
|
}
|
|
|
|
let impossiblePath: string => assertion = algebraicOp =>
|
|
`${algebraicOp} has`->expect->toEqual("failed")
|
|
|
|
let distributions = list{
|
|
normalMake(0.0, 1e0),
|
|
betaMake(2e0, 4e0),
|
|
exponentialMake(1.234e0),
|
|
uniformMake(7e0, 1e1),
|
|
// cauchyMake(1e0, 1e0),
|
|
lognormalMake(1e0, 1e0),
|
|
triangularMake(1e0, 1e1, 5e1),
|
|
Ok(floatMake(1e1)),
|
|
}
|
|
let combinations = E.L.combinations2(distributions)
|
|
let zipDistsDists = E.L.zip(distributions, distributions)
|
|
|
|
let testOperationMean = (
|
|
distOp: (DistributionTypes.genericDist, DistributionTypes.genericDist) => result<DistributionTypes.genericDist, DistributionTypes.error>,
|
|
description: string,
|
|
floatOp: (float, float) => float,
|
|
dist1': result<SymbolicDistTypes.symbolicDist, string>,
|
|
dist2': result<SymbolicDistTypes.symbolicDist, string>
|
|
) => {
|
|
let dist1 = dist1'->E.R2.fmap(x=>DistributionTypes.Symbolic(x))->E.R2.fmap2(s=>DistributionTypes.Other(s))
|
|
let dist2 = dist2'->E.R2.fmap(x=>DistributionTypes.Symbolic(x))->E.R2.fmap2(s=>DistributionTypes.Other(s))
|
|
let received =
|
|
E.R.liftJoin2(distOp, dist1, dist2)
|
|
->E.R2.fmap(mean)
|
|
->E.R2.fmap(run)
|
|
->E.R2.fmap(toFloat)
|
|
let expected = floatOp(runMean(dist1), runMean(dist2))
|
|
switch received {
|
|
| Error(err) => impossiblePath(description)
|
|
| Ok(x) =>
|
|
switch x {
|
|
| None => impossiblePath(description)
|
|
| Some(x) => x->expect->toBeSoCloseTo(expected, ~digits)
|
|
}
|
|
}
|
|
}
|
|
|
|
describe("addition", () => {
|
|
let testAdditionMean = testOperationMean(algebraicAdd, "algebraicAdd", \"+.")
|
|
|
|
testAll("homogeneous addition", zipDistsDists, dists => {
|
|
let (dist1, dist2) = dists
|
|
testAdditionMean(dist1, dist2)
|
|
})
|
|
|
|
testAll("heterogeneous addition (1)", combinations, dists => {
|
|
let (dist1, dist2) = dists
|
|
testAdditionMean(dist1, dist2)
|
|
})
|
|
|
|
testAll("heterogeneous addition (commuted of 1 (or; 2))", combinations, dists => {
|
|
let (dist1, dist2) = dists
|
|
testAdditionMean(dist2, dist1)
|
|
})
|
|
})
|
|
|
|
describe("subtraction", () => {
|
|
let testSubtractionMean = testOperationMean(algebraicSubtract, "algebraicSubtract", \"-.")
|
|
|
|
testAll("homogeneous subtraction", zipDistsDists, dists => {
|
|
let (dist1, dist2) = dists
|
|
testSubtractionMean(dist1, dist2)
|
|
})
|
|
|
|
testAll("heterogeneous subtraction (1)", combinations, dists => {
|
|
let (dist1, dist2) = dists
|
|
testSubtractionMean(dist1, dist2)
|
|
})
|
|
|
|
testAll("heterogeneous subtraction (commuted of 1 (or; 2))", combinations, dists => {
|
|
let (dist1, dist2) = dists
|
|
testSubtractionMean(dist2, dist1)
|
|
})
|
|
})
|
|
|
|
describe("multiplication", () => {
|
|
let testMultiplicationMean = testOperationMean(algebraicMultiply, "algebraicMultiply", \"*.")
|
|
|
|
testAll("homogeneous subtraction", zipDistsDists, dists => {
|
|
let (dist1, dist2) = dists
|
|
testMultiplicationMean(dist1, dist2)
|
|
})
|
|
|
|
testAll("heterogeneoous subtraction (1)", combinations, dists => {
|
|
let (dist1, dist2) = dists
|
|
testMultiplicationMean(dist1, dist2)
|
|
})
|
|
|
|
testAll("heterogeneoous subtraction (commuted of 1 (or; 2))", combinations, dists => {
|
|
let (dist1, dist2) = dists
|
|
testMultiplicationMean(dist2, dist1)
|
|
})
|
|
})
|
|
})
|