public void AssertEqualTo(MyClass that)
{
Assert.Equal(0, this.bernoulli.MaxDiff(that.bernoulli));
Assert.Equal(0, this.beta.MaxDiff(that.beta));
Assert.Equal(0, this.binomial.MaxDiff(that.binomial));
Assert.Equal(0, this.conjugateDirichlet.MaxDiff(that.conjugateDirichlet));
Assert.Equal(0, this.dirichlet.MaxDiff(that.dirichlet));
Assert.Equal(0, this.discrete.MaxDiff(that.discrete));
Assert.Equal(0, this.gamma.MaxDiff(that.gamma));
Assert.Equal(0, this.gammaPower.MaxDiff(that.gammaPower));
Assert.Equal(0, this.gaussian.MaxDiff(that.gaussian));
Assert.Equal(0, this.nonconjugateGaussian.MaxDiff(that.nonconjugateGaussian));
Assert.Equal(0, this.pointMass.MaxDiff(that.pointMass));
Assert.Equal(0, this.sparseBernoulliList.MaxDiff(that.sparseBernoulliList));
Assert.Equal(0, this.sparseBetaList.MaxDiff(that.sparseBetaList));
Assert.Equal(0, this.sparseGammaList.MaxDiff(that.sparseGammaList));
Assert.Equal(0, this.truncatedGamma.MaxDiff(that.truncatedGamma));
Assert.Equal(0, this.truncatedGaussian.MaxDiff(that.truncatedGaussian));
Assert.Equal(0, this.wrappedGaussian.MaxDiff(that.wrappedGaussian));
Assert.Equal(0, this.sparseGaussianList.MaxDiff(that.sparseGaussianList));
Assert.Equal(0, this.unnormalizedDiscrete.MaxDiff(that.unnormalizedDiscrete));
Assert.Equal(0, this.vectorGaussian.MaxDiff(that.vectorGaussian));
Assert.Equal(0, this.wishart.MaxDiff(that.wishart));
Assert.Equal(0, this.pareto.MaxDiff(that.pareto));
Assert.Equal(0, this.poisson.MaxDiff(that.poisson));
Assert.Equal(0, ga.MaxDiff(that.ga));
Assert.Equal(0, vga.MaxDiff(that.vga));
Assert.Equal(0, ga2D.MaxDiff(that.ga2D));
Assert.Equal(0, vga2D.MaxDiff(that.vga2D));
Assert.Equal(0, gaJ.MaxDiff(that.gaJ));
Assert.Equal(0, vgaJ.MaxDiff(that.vgaJ));
Assert.Equal(0, this.sparseGp.MaxDiff(that.sparseGp));
Assert.True(this.quantileEstimator.ValueEquals(that.quantileEstimator));
}
public void BugsPumpModified()
{
//model
//{
// for (i in 1 : N) {
// theta[i] ~ dgamma(alpha, beta)
// lambda[i] <- theta[i] * t[i]
// x[i] ~ dpois(lambda[i])
// }
// beta ~ dgamma(0.1, 1.0)
//}
// Data:
// list(t = c(94.3, 15.7, 62.9, 126, 5.24, 31.4, 1.05, 1.05, 2.1, 10.5),
// x = c(5, 1, 5, 14, 3, 19, 1, 1, 4, 22), N = 10, alpha=0.7)
Rand.Restart(12347);
int N = 10;
double[] tData = new double[] { 94.3, 15.7, 62.9, 126, 5.24, 31.4, 1.05, 1.05, 2.1, 10.5 };
int[] xData = new int[] { 5, 1, 5, 14, 3, 19, 1, 1, 4, 22 };
// Exponential distribution is a special case of Gamma distribution (Shape =1)
//var alpha = Variable.GammaFromShapeAndRate(1.0, 1.0);
var beta = Variable.GammaFromShapeAndRate(0.1, 1.0);
var alpha = 0.7;
Range i = new Range(N);
var theta = Variable.Array <double>(i);
var lambda = Variable.Array <double>(i);
var t = Variable.Array <double>(i);
var x = Variable.Array <int>(i);
theta[i] = Variable.GammaFromShapeAndRate(alpha, beta).ForEach(i);
lambda[i] = theta[i] * t[i];
x[i] = Variable.Poisson(lambda[i]);
x.ObservedValue = xData;
t.ObservedValue = tData;
var engine = new InferenceEngine(new GibbsSampling());
engine.NumberOfIterations = 100000;
engine.ShowProgress = false;
engine.ShowTimings = true;
// Expected values (from WinBugs)
double[] expectedThetaPostMean = { 0.06003, 0.1017, 0.08966, 0.1158, 0.5998, 0.6082, 0.8838, 0.8935, 1.565, 1.987 };
double[] expectedThetaPostSD = { 0.02509, 0.07878, 0.03766, 0.03019, 0.3166, 0.1401, 0.7187, 0.7132, 0.7583, 0.4219 };
IDistribution <double[]> thetaExpected =
Distribution <double> .Array(Util.ArrayInit(N, k => Gamma.FromMeanAndVariance(expectedThetaPostMean[k], expectedThetaPostSD[k] * expectedThetaPostSD[k])));
var thetaPost = engine.Infer(theta);
Console.WriteLine(StringUtil.JoinColumns("theta = ", thetaPost, " should be ", thetaExpected));
Assert.True(thetaExpected.MaxDiff(thetaPost) < 1.3);
}
public void ConstrainEqualCaseArrayTest()
{
Range i = new Range(4).Named("i");
VariableArray <double> x = Variable.Array <double>(i).Named("x");
VariableArray <int> c = Variable.Array <int>(i).Named("c");
using (Variable.ForEach(i))
{
c[i] = Variable.Discrete(new double[] { 0.5, 0.5 });
using (Variable.Case(c[i], 0))
{
x[i] = Variable.GaussianFromMeanAndVariance(1, 1);
}
using (Variable.Case(c[i], 1))
{
x[i] = Variable.GaussianFromMeanAndVariance(2, 1);
}
}
VariableArray <double> data = Variable.Observed(new double[] { 0.9, 1.1, 1.9, 2.1 }, i).Named("data");
Variable.ConstrainEqual(x[i], data[i]);
InferenceEngine engine = new InferenceEngine(new VariationalMessagePassing());
Discrete[] cExpectedArray = new Discrete[]
{
new Discrete(0.6457, 0.3543),
new Discrete(0.5987, 0.4013), new Discrete(0.4013, 0.5987),
new Discrete(0.3543, 0.6457)
};
IDistribution <int[]> cExpected = Distribution <int> .Array(cExpectedArray);
object cActual = engine.Infer(c);
Console.WriteLine(StringUtil.JoinColumns("c = ", cActual, " should be ", cExpected));
Assert.True(cExpected.MaxDiff(cActual) < 1e-4);
}