/// <summary>Computations that depend on the observed value of vy</summary>
private void Changed_vy()
{
if (this.Changed_vy_isDone)
{
return;
}
Gaussian vyMean_F = default(Gaussian);
this.vyMean_marginal_F = Gaussian.Uniform();
Gaussian vyMean_use_B = default(Gaussian);
// Message to 'vyMean' from GaussianFromMeanAndVariance factor
vyMean_F = GaussianFromMeanAndVarianceOp.SampleAverageConditional(0.0, 10.0);
Gamma vySigma_F = default(Gamma);
// Message to 'vySigma' from Sample factor
vySigma_F = GammaFromShapeAndScaleOp.SampleAverageConditional(1.0, 1.0);
Gamma vySigma_use_B = default(Gamma);
// Message to 'vySigma_use' from Gaussian factor
vySigma_use_B = GaussianOp.PrecisionAverageConditional(Gaussian.PointMass(this.Vy), vyMean_F, vySigma_F);
// Message to 'vyMean_use' from Gaussian factor
vyMean_use_B = GaussianOp.MeanAverageConditional(this.Vy, vyMean_F, vySigma_F, vySigma_use_B);
// Message to 'vyMean_marginal' from Variable factor
this.vyMean_marginal_F = VariableOp.MarginalAverageConditional <Gaussian>(vyMean_use_B, vyMean_F, this.vyMean_marginal_F);
this.vySigma_marginal_F = Gamma.Uniform();
// Message to 'vySigma_marginal' from Variable factor
this.vySigma_marginal_F = VariableOp.MarginalAverageConditional <Gamma>(vySigma_use_B, vySigma_F, this.vySigma_marginal_F);
this.vy_marginal_F = Gaussian.Uniform();
// Message to 'vy_marginal' from DerivedVariable factor
this.vy_marginal_F = DerivedVariableOp.MarginalAverageConditional <Gaussian, double>(this.Vy, this.vy_marginal_F);
this.Changed_vy_isDone = true;
}
/// <summary>Computations that do not depend on observed values</summary>
public void Constant()
{
if (this.Constant_iterationsDone == 1)
{
return;
}
// The constant 'vBernoulli0'
Bernoulli vBernoulli0 = Bernoulli.FromLogOdds(0);
this.vbool0_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli0);
// Message from use of 'vbool0'
Bernoulli vbool0_use_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli0);
// Message to 'vbool0_marginal' from Variable factor
this.vbool0_marginal_F = VariableOp.MarginalAverageConditional <Bernoulli>(vbool0_use_B, vBernoulli0, this.vbool0_marginal_F);
this.vbool1_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli0);
// Message from use of 'vbool1'
Bernoulli vbool1_use_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli0);
// Message to 'vbool1_marginal' from Variable factor
this.vbool1_marginal_F = VariableOp.MarginalAverageConditional <Bernoulli>(vbool1_use_B, vBernoulli0, this.vbool1_marginal_F);
Bernoulli vbool2_F = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
this.vbool2_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message from use of 'vbool2'
Bernoulli vbool2_use_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'vbool2' from And factor
vbool2_F = BooleanAndOp.AndAverageConditional(vBernoulli0, vBernoulli0);
// Message to 'vbool2_marginal' from DerivedVariable factor
this.vbool2_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(vbool2_use_B, vbool2_F, this.vbool2_marginal_F);
this.Constant_iterationsDone = 1;
}
/// <summary>Computations that depend on the observed value of x1</summary>
private void Changed_x1()
{
if (this.Changed_x1_isDone)
{
return;
}
Gaussian x2_F = default(Gaussian);
this.x2_marginal_F = Gaussian.Uniform();
Gaussian x2_use_B = Gaussian.Uniform();
// Message to 'x2' from GaussianFromMeanAndVariance factor
x2_F = GaussianFromMeanAndVarianceOp.SampleAverageConditional(0.0, 100.0);
// Message to 'x2_marginal' from Variable factor
this.x2_marginal_F = VariableOp.MarginalAverageConditional <Gaussian>(x2_use_B, x2_F, this.x2_marginal_F);
Gaussian vdouble26_F = default(Gaussian);
this.vdouble26_marginal_F = Gaussian.Uniform();
Gaussian vdouble26_use_B = Gaussian.Uniform();
Gaussian[] vdouble26_uses_F;
Gaussian[] vdouble26_uses_B;
// Create array for 'vdouble26_uses' Forwards messages.
vdouble26_uses_F = new Gaussian[2];
// Create array for 'vdouble26_uses' Backwards messages.
vdouble26_uses_B = new Gaussian[2];
vdouble26_uses_B[1] = Gaussian.Uniform();
vdouble26_uses_B[0] = Gaussian.Uniform();
vdouble26_uses_F[1] = Gaussian.Uniform();
vdouble26_uses_F[0] = Gaussian.Uniform();
// Message to 'vdouble26' from Difference factor
vdouble26_F = DoublePlusOp.AAverageConditional(x2_F, this.X1);
// Message to 'vdouble26' from Copy factor
vdouble26_F = Distribution.SetPoint <Gaussian, double>(vdouble26_F, Factor.Copy <double>(0.0));
// FactorManager.Any(vdouble26_F, vdouble26_F) is now updated in all contexts
// Message to 'vdouble26_uses' from Replicate factor
vdouble26_uses_F[0] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(vdouble26_uses_B, vdouble26_F, 0, vdouble26_uses_F[0]);
// Message to 'vdouble26_uses' from Replicate factor
vdouble26_uses_F[1] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(vdouble26_uses_B, vdouble26_F, 1, vdouble26_uses_F[1]);
// Message to 'vdouble26_uses' from Replicate factor
vdouble26_uses_F[0] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(vdouble26_uses_B, vdouble26_F, 0, vdouble26_uses_F[0]);
// FactorManager.Any(vdouble26_uses_F[0], vdouble26_uses_F[0]) is now updated in all contexts
// Message to 'vdouble26_marginal' from DerivedVariable factor
this.vdouble26_marginal_F = DerivedVariableOp.MarginalAverageConditional <Gaussian>(vdouble26_use_B, vdouble26_uses_F[0], this.vdouble26_marginal_F);
// Message to 'vdouble26_uses' from Replicate factor
vdouble26_uses_F[1] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(vdouble26_uses_B, vdouble26_F, 1, vdouble26_uses_F[1]);
// FactorManager.Any(vdouble26_uses_F[1], vdouble26_uses_F[1]) is now updated in all contexts
// Message to 'vdouble26_marginal' from DerivedVariable factor
this.vdouble26_marginal_F = DerivedVariableOp.MarginalAverageConditional <Gaussian>(vdouble26_use_B, vdouble26_uses_F[1], this.vdouble26_marginal_F);
this.x1_marginal_F = Gaussian.Uniform();
// Message to 'x1_marginal' from DerivedVariable factor
this.x1_marginal_F = DerivedVariableOp.MarginalAverageConditional <Gaussian, double>(this.X1, this.x1_marginal_F);
// FactorManager.Any(vdouble26_marginal_F, vdouble26_marginal_F) is now updated in all contexts
this.Changed_x1_isDone = true;
}
/// <summary>Computations that depend on the observed value of FeatureIndexes and FeatureValues and InstanceCount and InstanceFeatureCounts and WeightConstraints and WeightPriors</summary>
private void Changed_FeatureIndexes_FeatureValues_InstanceCount_InstanceFeatureCounts_WeightConstraints_WeightPri6()
{
if (this.Changed_FeatureIndexes_FeatureValues_InstanceCount_InstanceFeatureCounts_WeightConstraints_WeightPri6_isDone)
{
return;
}
for (int InstanceRange = 0; InstanceRange < this.InstanceCount; InstanceRange++)
{
for (int InstanceFeatureRanges = 0; InstanceFeatureRanges < this.InstanceFeatureCounts[InstanceRange]; InstanceFeatureRanges++)
{
this.FeatureScores_F[InstanceRange][InstanceFeatureRanges] = GaussianProductOpBase.ProductAverageConditional(this.FeatureValues[InstanceRange][InstanceFeatureRanges], this.Weights_FeatureIndexes_F[InstanceRange][InstanceFeatureRanges]);
}
this.Score_F[InstanceRange] = FastSumOp.SumAverageConditional(this.FeatureScores_F[InstanceRange]);
this.NoisyScore_F[InstanceRange] = GaussianFromMeanAndVarianceOp.SampleAverageConditional(this.Score_F[InstanceRange], 1.0);
this.Labels_F[InstanceRange] = IsPositiveOp.IsPositiveAverageConditional(this.NoisyScore_F[InstanceRange]);
this.Labels_marginal_F[InstanceRange] = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(this.Labels_use_B_reduced, this.Labels_F[InstanceRange], this.Labels_marginal_F[InstanceRange]);
}
this.Changed_FeatureIndexes_FeatureValues_InstanceCount_InstanceFeatureCounts_WeightConstraints_WeightPri6_isDone = true;
}
/// <summary>Computations that depend on the observed value of y and biasPrior and xValueCount and xValues and wPrior and xIndices</summary>
public void Changed_y_biasPrior_xValueCount_xValues_wPrior_xIndices()
{
if (this.Changed_y_biasPrior_xValueCount_xValues_wPrior_xIndices_iterationsDone == 1)
{
return;
}
this.vdouble13_use_B = IsPositiveOp.XAverageConditional(this.Y, this.vdouble13_F);
this.vdouble11_B = GaussianFromMeanAndVarianceOp.MeanAverageConditional(this.vdouble13_use_B, 1);
this.bias_use_B = DoublePlusOp.BAverageConditional(this.vdouble11_B, this.score_F);
this.bias_marginal_F = VariableOp.MarginalAverageConditional <Gaussian>(this.bias_use_B, this.BiasPrior, this.bias_marginal_F);
this.score_B = DoublePlusOp.AAverageConditional(this.vdouble11_B, this.BiasPrior);
this.product_B = FastSumOp.ArrayAverageConditional <DistributionStructArray <Gaussian, double> >(this.score_B, this.score_F, this.product_F, this.product_B);
for (int userFeature = 0; userFeature < this.XValueCount; userFeature++)
{
this.wSparse_use_B[userFeature] = GaussianProductOp.BAverageConditional(this.product_B[userFeature], this.XValues[userFeature]);
}
this.wSparse_marginal_F = DerivedVariableOp.MarginalAverageConditional <DistributionStructArray <Gaussian, double> >(this.wSparse_use_B, this.wSparse_F,
this.wSparse_marginal_F);
this.Changed_y_biasPrior_xValueCount_xValues_wPrior_xIndices_iterationsDone = 1;
}
/// <summary>Computations that depend on the observed value of firstCoin</summary>
private void Changed_firstCoin()
{
if (this.Changed_firstCoin_isDone)
{
return;
}
this.firstCoin_marginal = Bernoulli.Uniform();
this.firstCoin_marginal = Distribution.SetPoint <Bernoulli, bool>(this.firstCoin_marginal, this.FirstCoin);
Bernoulli vBernoulli0 = Bernoulli.Uniform();
Bernoulli bothHeads_F = default(Bernoulli);
this.bothHeads_marginal_F = Bernoulli.Uniform();
Bernoulli bothHeads_use_B = Bernoulli.Uniform();
// Message to 'bothHeads' from And factor
bothHeads_F = BooleanAndOp.AndAverageConditional(this.FirstCoin, vBernoulli0);
// Message to 'bothHeads_marginal' from DerivedVariable factor
this.bothHeads_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(bothHeads_use_B, bothHeads_F, this.bothHeads_marginal_F);
this.Changed_firstCoin_isDone = true;
}
/// <summary>Computations that do not depend on observed values</summary>
private void Constant()
{
if (this.Constant_isDone)
{
return;
}
Bernoulli vBernoulli0 = Bernoulli.Uniform();
this.firstCoin_marginal_F = Bernoulli.Uniform();
this.secondCoin_marginal_F = Bernoulli.Uniform();
Bernoulli bothHeads_F = default(Bernoulli);
this.bothHeads_marginal_F = Bernoulli.Uniform();
Bernoulli bothHeads_use_B = Bernoulli.Uniform();
// Message to 'bothHeads' from And factor
bothHeads_F = BooleanAndOp.AndAverageConditional(vBernoulli0, vBernoulli0);
// Message to 'bothHeads_marginal' from DerivedVariable factor
this.bothHeads_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(bothHeads_use_B, bothHeads_F, this.bothHeads_marginal_F);
this.Constant_isDone = true;
}
/// <summary>Computations that do not depend on observed values</summary>
private void Constant()
{
if (this.Constant_isDone)
{
return;
}
Bernoulli vBernoulli0 = Bernoulli.Uniform();
this.vbool0_marginal_F = Bernoulli.Uniform();
this.vbool1_marginal_F = Bernoulli.Uniform();
Bernoulli vbool2_F = default(Bernoulli);
this.vbool2_marginal_F = Bernoulli.Uniform();
Bernoulli vbool2_use_B = Bernoulli.Uniform();
// Message to 'vbool2' from And factor
vbool2_F = BooleanAndOp.AndAverageConditional(vBernoulli0, vBernoulli0);
// Message to 'vbool2_marginal' from DerivedVariable factor
this.vbool2_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(vbool2_use_B, vbool2_F, this.vbool2_marginal_F);
this.Constant_isDone = true;
}
/// <summary>Computations that depend on the observed value of InstanceCount and FeatureCount and FeatureValues and numberOfIterationsDecreased and WeightPriors and WeightConstraints</summary>
private void Changed_InstanceCount_FeatureCount_FeatureValues_numberOfIterationsDecreased_WeightPriors_WeightCons10()
{
if (this.Changed_InstanceCount_FeatureCount_FeatureValues_numberOfIterationsDecreased_WeightPriors_WeightCons10_iterationsDone == 1)
{
return;
}
for (int InstanceRange = 0; InstanceRange < this.instanceCount; InstanceRange++)
{
for (int FeatureRange = 0; FeatureRange < this.featureCount; FeatureRange++)
{
// Message to 'FeatureScores' from Product factor
this.FeatureScores_F[InstanceRange][FeatureRange] = GaussianProductOp.ProductAverageConditional(this.featureValues[InstanceRange][FeatureRange], this.Weights_depth1_rep_F[FeatureRange][InstanceRange]);
}
// Message to 'Score' from Sum factor
this.Score_F[InstanceRange] = FastSumOp.SumAverageConditional(this.FeatureScores_F[InstanceRange]);
// Message to 'NoisyScore' from GaussianFromMeanAndVariance factor
this.NoisyScore_F[InstanceRange] = GaussianFromMeanAndVarianceOp.SampleAverageConditional(this.Score_F[InstanceRange], 1.0);
// Message to 'Labels' from IsPositive factor
this.Labels_F[InstanceRange] = IsPositiveOp.IsPositiveAverageConditional(this.NoisyScore_F[InstanceRange]);
// Message to 'Labels_marginal' from DerivedVariable factor
this.Labels_marginal_F[InstanceRange] = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(this.Labels_use_B[InstanceRange], this.Labels_F[InstanceRange], this.Labels_marginal_F[InstanceRange]);
}
this.Changed_InstanceCount_FeatureCount_FeatureValues_numberOfIterationsDecreased_WeightPriors_WeightCons10_iterationsDone = 1;
}
/// <summary>Computations that depend on the observed value of vVector__343</summary>
private void Changed_vVector__343()
{
if (this.Changed_vVector__343_iterationsDone == 1)
{
return;
}
this.vVector__343_marginal = new PointMass <Vector[]>(this.VVector__343);
// The constant 'vVectorGaussian343'
VectorGaussian vVectorGaussian343 = VectorGaussian.FromNatural(DenseVector.FromArray(new double[3] {
1547829870.0, 525077980.0, 200270.0
}), new PositiveDefiniteMatrix(new double[3, 3] {
{ 4254590363351.0, 1127383488860.0, 433199230.0 }, { 1127383488860.0, 482723521821.0, 146764360.0 }, { 433199230.0, 146764360.0, 56221.0 }
}));
this.vVector1029_marginal_F = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian343);
// Buffer for ReplicateOp_Divide.Marginal<VectorGaussian>
VectorGaussian vVector1029_rep_B_toDef = default(VectorGaussian);
// Message to 'vVector1029_rep' from Replicate factor
vVector1029_rep_B_toDef = ReplicateOp_Divide.ToDefInit <VectorGaussian>(vVectorGaussian343);
// Message to 'vVector1029_marginal' from Variable factor
this.vVector1029_marginal_F = VariableOp.MarginalAverageConditional <VectorGaussian>(vVector1029_rep_B_toDef, vVectorGaussian343, this.vVector1029_marginal_F);
DistributionStructArray <Gaussian, double> vdouble__1029_F = default(DistributionStructArray <Gaussian, double>);
// Create array for 'vdouble__1029' Forwards messages.
vdouble__1029_F = new DistributionStructArray <Gaussian, double>(1);
for (int index343 = 0; index343 < 1; index343++)
{
vdouble__1029_F[index343] = Gaussian.Uniform();
}
DistributionStructArray <Gaussian, double> vdouble__1030_F = default(DistributionStructArray <Gaussian, double>);
// Create array for 'vdouble__1030' Forwards messages.
vdouble__1030_F = new DistributionStructArray <Gaussian, double>(1);
for (int index343 = 0; index343 < 1; index343++)
{
vdouble__1030_F[index343] = Gaussian.Uniform();
}
DistributionRefArray <VectorGaussian, Vector> vVector1029_rep_F = default(DistributionRefArray <VectorGaussian, Vector>);
DistributionRefArray <VectorGaussian, Vector> vVector1029_rep_B = default(DistributionRefArray <VectorGaussian, Vector>);
// Create array for 'vVector1029_rep' Forwards messages.
vVector1029_rep_F = new DistributionRefArray <VectorGaussian, Vector>(1);
// Create array for 'vVector1029_rep' Backwards messages.
vVector1029_rep_B = new DistributionRefArray <VectorGaussian, Vector>(1);
for (int index343 = 0; index343 < 1; index343++)
{
vVector1029_rep_B[index343] = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian343);
vVector1029_rep_F[index343] = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian343);
}
// Buffer for ReplicateOp_Divide.UsesAverageConditional<VectorGaussian>
VectorGaussian vVector1029_rep_F_marginal = default(VectorGaussian);
// Message to 'vVector1029_rep' from Replicate factor
vVector1029_rep_F_marginal = ReplicateOp_Divide.MarginalInit <VectorGaussian>(vVectorGaussian343);
// Message to 'vVector1029_rep' from Replicate factor
vVector1029_rep_F_marginal = ReplicateOp_Divide.Marginal <VectorGaussian>(vVector1029_rep_B_toDef, vVectorGaussian343, vVector1029_rep_F_marginal);
// Buffer for InnerProductOp.InnerProductAverageConditional
// Create array for replicates of 'vVector1029_rep_F_index343__AMean'
Vector[] vVector1029_rep_F_index343__AMean = new Vector[1];
for (int index343 = 0; index343 < 1; index343++)
{
// Message to 'vdouble__1030' from InnerProduct factor
vVector1029_rep_F_index343__AMean[index343] = InnerProductOp.AMeanInit(vVector1029_rep_F[index343]);
}
// Buffer for InnerProductOp.AMean
// Create array for replicates of 'vVector1029_rep_F_index343__AVariance'
PositiveDefiniteMatrix[] vVector1029_rep_F_index343__AVariance = new PositiveDefiniteMatrix[1];
for (int index343 = 0; index343 < 1; index343++)
{
// Message to 'vdouble__1030' from InnerProduct factor
vVector1029_rep_F_index343__AVariance[index343] = InnerProductOp.AVarianceInit(vVector1029_rep_F[index343]);
// Message to 'vVector1029_rep' from Replicate factor
vVector1029_rep_F[index343] = ReplicateOp_Divide.UsesAverageConditional <VectorGaussian>(vVector1029_rep_B[index343], vVector1029_rep_F_marginal, index343, vVector1029_rep_F[index343]);
}
// Create array for 'vdouble__1030_marginal' Forwards messages.
this.vdouble__1030_marginal_F = new DistributionStructArray <Gaussian, double>(1);
for (int index343 = 0; index343 < 1; index343++)
{
this.vdouble__1030_marginal_F[index343] = Gaussian.Uniform();
}
// Message from use of 'vdouble__1030'
DistributionStructArray <Gaussian, double> vdouble__1030_use_B = default(DistributionStructArray <Gaussian, double>);
// Create array for 'vdouble__1030_use' Backwards messages.
vdouble__1030_use_B = new DistributionStructArray <Gaussian, double>(1);
for (int index343 = 0; index343 < 1; index343++)
{
vdouble__1030_use_B[index343] = Gaussian.Uniform();
// Message to 'vdouble__1030' from InnerProduct factor
vVector1029_rep_F_index343__AVariance[index343] = InnerProductOp.AVariance(vVector1029_rep_F[index343], vVector1029_rep_F_index343__AVariance[index343]);
// Message to 'vdouble__1030' from InnerProduct factor
vVector1029_rep_F_index343__AMean[index343] = InnerProductOp.AMean(vVector1029_rep_F[index343], vVector1029_rep_F_index343__AVariance[index343], vVector1029_rep_F_index343__AMean[index343]);
// Message to 'vdouble__1030' from InnerProduct factor
vdouble__1030_F[index343] = InnerProductOp.InnerProductAverageConditional(vVector1029_rep_F_index343__AMean[index343], vVector1029_rep_F_index343__AVariance[index343], this.VVector__343[index343]);
// Message to 'vdouble__1030_marginal' from DerivedVariable factor
this.vdouble__1030_marginal_F[index343] = DerivedVariableOp.MarginalAverageConditional <Gaussian>(vdouble__1030_use_B[index343], vdouble__1030_F[index343], this.vdouble__1030_marginal_F[index343]);
}
// Create array for 'vdouble__1029_marginal' Forwards messages.
this.vdouble__1029_marginal_F = new DistributionStructArray <Gaussian, double>(1);
for (int index343 = 0; index343 < 1; index343++)
{
this.vdouble__1029_marginal_F[index343] = Gaussian.Uniform();
}
// Message from use of 'vdouble__1029'
DistributionStructArray <Gaussian, double> vdouble__1029_use_B = default(DistributionStructArray <Gaussian, double>);
// Create array for 'vdouble__1029_use' Backwards messages.
vdouble__1029_use_B = new DistributionStructArray <Gaussian, double>(1);
for (int index343 = 0; index343 < 1; index343++)
{
vdouble__1029_use_B[index343] = Gaussian.Uniform();
// Message to 'vdouble__1029' from GaussianFromMeanAndVariance factor
vdouble__1029_F[index343] = GaussianFromMeanAndVarianceOp.SampleAverageConditional(vdouble__1030_F[index343], 0.1);
// Message to 'vdouble__1029_marginal' from Variable factor
this.vdouble__1029_marginal_F[index343] = VariableOp.MarginalAverageConditional <Gaussian>(vdouble__1029_use_B[index343], vdouble__1029_F[index343], this.vdouble__1029_marginal_F[index343]);
}
this.Changed_vVector__343_iterationsDone = 1;
}
/// <summary>Computations that depend on the observed value of vVector__134 and vdouble__402</summary>
private void Changed_vVector__134_vdouble__402()
{
if (this.Changed_vVector__134_vdouble__402_iterationsDone == 1)
{
return;
}
this.vVector__134_marginal = new PointMass <Vector[]>(this.VVector__134);
this.vdouble__402_marginal = new DistributionStructArray <Gaussian, double>(5622, delegate(int index134) {
return(Gaussian.Uniform());
});
this.vdouble__402_marginal = Distribution.SetPoint <DistributionStructArray <Gaussian, double>, double[]>(this.vdouble__402_marginal, this.Vdouble__402);
// The constant 'vVectorGaussian134'
VectorGaussian vVectorGaussian134 = VectorGaussian.FromNatural(DenseVector.FromArray(new double[3] {
0.0, 0.0, 0.0
}), new PositiveDefiniteMatrix(new double[3, 3] {
{ 1.0, 0.0, 0.0 }, { 0.0, 1.0, 0.0 }, { 0.0, 0.0, 1.0 }
}));
this.vVector403_marginal_F = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian134);
// Message from use of 'vdouble__403'
DistributionStructArray <Gaussian, double> vdouble__403_use_B = default(DistributionStructArray <Gaussian, double>);
// Create array for 'vdouble__403_use' Backwards messages.
vdouble__403_use_B = new DistributionStructArray <Gaussian, double>(5622);
for (int index134 = 0; index134 < 5622; index134++)
{
vdouble__403_use_B[index134] = Gaussian.Uniform();
// Message to 'vdouble__403_use' from GaussianFromMeanAndVariance factor
vdouble__403_use_B[index134] = GaussianFromMeanAndVarianceOp.MeanAverageConditional(this.Vdouble__402[index134], 0.1);
}
DistributionRefArray <VectorGaussian, Vector> vVector403_rep_B = default(DistributionRefArray <VectorGaussian, Vector>);
// Create array for 'vVector403_rep' Backwards messages.
vVector403_rep_B = new DistributionRefArray <VectorGaussian, Vector>(5622);
for (int index134 = 0; index134 < 5622; index134++)
{
vVector403_rep_B[index134] = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian134);
// Message to 'vVector403_rep' from InnerProduct factor
vVector403_rep_B[index134] = InnerProductOp.AAverageConditional(vdouble__403_use_B[index134], this.VVector__134[index134], vVector403_rep_B[index134]);
}
// Buffer for ReplicateOp_Divide.Marginal<VectorGaussian>
VectorGaussian vVector403_rep_B_toDef = default(VectorGaussian);
// Message to 'vVector403_rep' from Replicate factor
vVector403_rep_B_toDef = ReplicateOp_Divide.ToDefInit <VectorGaussian>(vVectorGaussian134);
// Message to 'vVector403_rep' from Replicate factor
vVector403_rep_B_toDef = ReplicateOp_Divide.ToDef <VectorGaussian>(vVector403_rep_B, vVector403_rep_B_toDef);
// Message to 'vVector403_marginal' from Variable factor
this.vVector403_marginal_F = VariableOp.MarginalAverageConditional <VectorGaussian>(vVector403_rep_B_toDef, vVectorGaussian134, this.vVector403_marginal_F);
DistributionStructArray <Gaussian, double> vdouble__403_F = default(DistributionStructArray <Gaussian, double>);
// Create array for 'vdouble__403' Forwards messages.
vdouble__403_F = new DistributionStructArray <Gaussian, double>(5622);
for (int index134 = 0; index134 < 5622; index134++)
{
vdouble__403_F[index134] = Gaussian.Uniform();
}
DistributionRefArray <VectorGaussian, Vector> vVector403_rep_F = default(DistributionRefArray <VectorGaussian, Vector>);
// Create array for 'vVector403_rep' Forwards messages.
vVector403_rep_F = new DistributionRefArray <VectorGaussian, Vector>(5622);
for (int index134 = 0; index134 < 5622; index134++)
{
vVector403_rep_F[index134] = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian134);
}
// Buffer for ReplicateOp_Divide.UsesAverageConditional<VectorGaussian>
VectorGaussian vVector403_rep_F_marginal = default(VectorGaussian);
// Message to 'vVector403_rep' from Replicate factor
vVector403_rep_F_marginal = ReplicateOp_Divide.MarginalInit <VectorGaussian>(vVectorGaussian134);
// Message to 'vVector403_rep' from Replicate factor
vVector403_rep_F_marginal = ReplicateOp_Divide.Marginal <VectorGaussian>(vVector403_rep_B_toDef, vVectorGaussian134, vVector403_rep_F_marginal);
// Buffer for InnerProductOp.InnerProductAverageConditional
// Create array for replicates of 'vVector403_rep_F_index134__AMean'
Vector[] vVector403_rep_F_index134__AMean = new Vector[5622];
for (int index134 = 0; index134 < 5622; index134++)
{
// Message to 'vdouble__403' from InnerProduct factor
vVector403_rep_F_index134__AMean[index134] = InnerProductOp.AMeanInit(vVector403_rep_F[index134]);
}
// Buffer for InnerProductOp.AMean
// Create array for replicates of 'vVector403_rep_F_index134__AVariance'
PositiveDefiniteMatrix[] vVector403_rep_F_index134__AVariance = new PositiveDefiniteMatrix[5622];
for (int index134 = 0; index134 < 5622; index134++)
{
// Message to 'vdouble__403' from InnerProduct factor
vVector403_rep_F_index134__AVariance[index134] = InnerProductOp.AVarianceInit(vVector403_rep_F[index134]);
// Message to 'vVector403_rep' from Replicate factor
vVector403_rep_F[index134] = ReplicateOp_Divide.UsesAverageConditional <VectorGaussian>(vVector403_rep_B[index134], vVector403_rep_F_marginal, index134, vVector403_rep_F[index134]);
}
// Create array for 'vdouble__403_marginal' Forwards messages.
this.vdouble__403_marginal_F = new DistributionStructArray <Gaussian, double>(5622);
for (int index134 = 0; index134 < 5622; index134++)
{
this.vdouble__403_marginal_F[index134] = Gaussian.Uniform();
// Message to 'vdouble__403' from InnerProduct factor
vVector403_rep_F_index134__AVariance[index134] = InnerProductOp.AVariance(vVector403_rep_F[index134], vVector403_rep_F_index134__AVariance[index134]);
// Message to 'vdouble__403' from InnerProduct factor
vVector403_rep_F_index134__AMean[index134] = InnerProductOp.AMean(vVector403_rep_F[index134], vVector403_rep_F_index134__AVariance[index134], vVector403_rep_F_index134__AMean[index134]);
// Message to 'vdouble__403' from InnerProduct factor
vdouble__403_F[index134] = InnerProductOp.InnerProductAverageConditional(vVector403_rep_F_index134__AMean[index134], vVector403_rep_F_index134__AVariance[index134], this.VVector__134[index134]);
// Message to 'vdouble__403_marginal' from DerivedVariable factor
this.vdouble__403_marginal_F[index134] = DerivedVariableOp.MarginalAverageConditional <Gaussian>(vdouble__403_use_B[index134], vdouble__403_F[index134], this.vdouble__403_marginal_F[index134]);
}
this.Changed_vVector__134_vdouble__402_iterationsDone = 1;
}
/// <summary>Computations that depend on the observed value of Cloudy and WetGrass</summary>
public void Changed_Cloudy_WetGrass()
{
if (this.Changed_Cloudy_WetGrass_iterationsDone == 1)
{
return;
}
// The constant 'vBernoulli18'
Bernoulli vBernoulli18 = Bernoulli.FromLogOdds(0);
this.Cloudy_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli18);
this.Cloudy_marginal = Distribution.SetPoint <Bernoulli, bool>(this.Cloudy_marginal, this.cloudy);
// The constant 'vBernoulli23'
Bernoulli vBernoulli23 = Bernoulli.FromLogOdds(4.5951198501345889);
this.WetGrass_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli23);
this.WetGrass_marginal = Distribution.SetPoint <Bernoulli, bool>(this.WetGrass_marginal, this.wetGrass);
// The constant 'vBernoulli21'
Bernoulli vBernoulli21 = Bernoulli.FromLogOdds(1.3862943611198908);
Bernoulli Rain_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli21);
this.Rain_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli21);
// Message to use of 'Rain'
Bernoulli Rain_use_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli21);
// Message from use of 'Rain'
Bernoulli Rain_use_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli21);
if (this.cloudy)
{
// Message to 'Rain' from Copy factor
Rain_F = Factor.Copy <Bernoulli>(vBernoulli21);
}
// The constant 'vBernoulli22'
Bernoulli vBernoulli22 = Bernoulli.FromLogOdds(0.28185115214098749);
if (!this.cloudy)
{
// Message to 'Rain' from Copy factor
Rain_F = Factor.Copy <Bernoulli>(vBernoulli22);
}
// Rain_F is now updated in all contexts
if (this.cloudy)
{
// Message to 'Rain_use' from DerivedVariable factor
Rain_use_F = Factor.Copy <Bernoulli>(Rain_F);
}
Bernoulli Rain_cond_Sprinkler_0_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_0_selector_cases_0' from Random factor
Rain_cond_Sprinkler_0_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli23));
DistributionStructArray <Bernoulli, bool> Rain_cond_Sprinkler_0_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Rain_cond_Sprinkler_0_selector_cases' Backwards messages.
Rain_cond_Sprinkler_0_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2);
for (int _ind0 = 0; _ind0 < 2; _ind0++)
{
Rain_cond_Sprinkler_0_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor
Rain_cond_Sprinkler_0_selector_cases_B[0] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_0_selector_cases_0_B);
// The constant 'vBernoulli24'
Bernoulli vBernoulli24 = Bernoulli.FromLogOdds(2.1972245773362196);
Bernoulli Rain_cond_Sprinkler_0_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_0_selector_cases_1' from Random factor
Rain_cond_Sprinkler_0_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli24));
// Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor
Rain_cond_Sprinkler_0_selector_cases_B[1] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_0_selector_cases_1_B);
if (!this.cloudy)
{
// Message to 'Rain_use' from DerivedVariable factor
Rain_use_F = Factor.Copy <Bernoulli>(vBernoulli22);
}
// Rain_use_F is now updated in all contexts
Bernoulli[] Sprinkler_selector_cases_0_uses_B = default(Bernoulli[]);
// Create array for 'Sprinkler_selector_cases_0_uses' Backwards messages.
Sprinkler_selector_cases_0_uses_B = new Bernoulli[5];
for (int _ind = 0; _ind < 5; _ind++)
{
Sprinkler_selector_cases_0_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Sprinkler_selector_cases_0_uses' from Cases factor
Sprinkler_selector_cases_0_uses_B[4] = Bernoulli.FromLogOdds(CasesOp.LogEvidenceRatio(Rain_cond_Sprinkler_0_selector_cases_B, Rain_use_F));
Bernoulli Sprinkler_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Sprinkler_selector_cases_0' from Replicate factor
Sprinkler_selector_cases_0_B = ReplicateOp.DefAverageConditional <Bernoulli>(Sprinkler_selector_cases_0_uses_B, Sprinkler_selector_cases_0_B);
DistributionStructArray <Bernoulli, bool> Sprinkler_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Sprinkler_selector_cases' Backwards messages.
Sprinkler_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2);
for (int _ind0 = 0; _ind0 < 2; _ind0++)
{
Sprinkler_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Sprinkler_selector_cases' from Copy factor
Sprinkler_selector_cases_B[0] = Factor.Copy <Bernoulli>(Sprinkler_selector_cases_0_B);
Bernoulli Rain_cond_Sprinkler_1_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_1_selector_cases_0' from Random factor
Rain_cond_Sprinkler_1_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli24));
DistributionStructArray <Bernoulli, bool> Rain_cond_Sprinkler_1_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Rain_cond_Sprinkler_1_selector_cases' Backwards messages.
Rain_cond_Sprinkler_1_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2);
for (int _ind0 = 0; _ind0 < 2; _ind0++)
{
Rain_cond_Sprinkler_1_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor
Rain_cond_Sprinkler_1_selector_cases_B[0] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_1_selector_cases_0_B);
// The constant 'vBernoulli26'
Bernoulli vBernoulli26 = Bernoulli.FromLogOdds(-2.4423470353692043);
Bernoulli Rain_cond_Sprinkler_1_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_1_selector_cases_1' from Random factor
Rain_cond_Sprinkler_1_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli26));
// Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor
Rain_cond_Sprinkler_1_selector_cases_B[1] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_1_selector_cases_1_B);
Bernoulli[] Sprinkler_selector_cases_1_uses_B = default(Bernoulli[]);
// Create array for 'Sprinkler_selector_cases_1_uses' Backwards messages.
Sprinkler_selector_cases_1_uses_B = new Bernoulli[5];
for (int _ind = 0; _ind < 5; _ind++)
{
Sprinkler_selector_cases_1_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Sprinkler_selector_cases_1_uses' from Cases factor
Sprinkler_selector_cases_1_uses_B[4] = Bernoulli.FromLogOdds(CasesOp.LogEvidenceRatio(Rain_cond_Sprinkler_1_selector_cases_B, Rain_use_F));
Bernoulli Sprinkler_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Sprinkler_selector_cases_1' from Replicate factor
Sprinkler_selector_cases_1_B = ReplicateOp.DefAverageConditional <Bernoulli>(Sprinkler_selector_cases_1_uses_B, Sprinkler_selector_cases_1_B);
// Message to 'Sprinkler_selector_cases' from Copy factor
Sprinkler_selector_cases_B[1] = Factor.Copy <Bernoulli>(Sprinkler_selector_cases_1_B);
Bernoulli[] Sprinkler_selector_uses_B = default(Bernoulli[]);
// Create array for 'Sprinkler_selector_uses' Backwards messages.
Sprinkler_selector_uses_B = new Bernoulli[2];
// The constant 'vBernoulli19'
Bernoulli vBernoulli19 = Bernoulli.FromLogOdds(-2.1972245773362191);
for (int _ind = 0; _ind < 2; _ind++)
{
Sprinkler_selector_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli19);
}
// Message to 'Sprinkler_selector_uses' from Cases factor
Sprinkler_selector_uses_B[0] = CasesOp.BAverageConditional(Sprinkler_selector_cases_B);
Bernoulli Sprinkler_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli19);
if (this.cloudy)
{
// Message to 'Sprinkler' from Copy factor
Sprinkler_F = Factor.Copy <Bernoulli>(vBernoulli19);
}
if (!this.cloudy)
{
// Message to 'Sprinkler' from Copy factor
Sprinkler_F = Factor.Copy <Bernoulli>(vBernoulli18);
}
// Sprinkler_F is now updated in all contexts
// Message to use of 'Sprinkler'
Bernoulli Sprinkler_use_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli19);
if (this.cloudy)
{
// Message to 'Sprinkler_use' from DerivedVariable factor
Sprinkler_use_F = Factor.Copy <Bernoulli>(Sprinkler_F);
}
if (!this.cloudy)
{
// Message to 'Sprinkler_use' from DerivedVariable factor
Sprinkler_use_F = Factor.Copy <Bernoulli>(vBernoulli18);
}
// Sprinkler_use_F is now updated in all contexts
// Buffer for Replicate2BufferOp.UsesAverageConditional<Bernoulli>
Bernoulli Sprinkler_selector_uses_B_marginal = default(Bernoulli);
// Message to 'Sprinkler_selector_uses' from Replicate factor
Sprinkler_selector_uses_B_marginal = Replicate2BufferOp.MarginalInit <Bernoulli>(Sprinkler_use_F);
// Message to 'Sprinkler_selector_uses' from Replicate factor
Sprinkler_selector_uses_B_marginal = Replicate2BufferOp.Marginal <Bernoulli>(Sprinkler_selector_uses_B, Sprinkler_use_F, Sprinkler_selector_uses_B_marginal);
Bernoulli[] Sprinkler_selector_uses_F = default(Bernoulli[]);
// Create array for 'Sprinkler_selector_uses' Forwards messages.
Sprinkler_selector_uses_F = new Bernoulli[2];
for (int _ind = 0; _ind < 2; _ind++)
{
Sprinkler_selector_uses_F[_ind] = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli19);
}
// Message to 'Sprinkler_selector_uses' from Replicate factor
Sprinkler_selector_uses_F[1] = Replicate2BufferOp.UsesAverageConditional <Bernoulli>(Sprinkler_selector_uses_B, Sprinkler_use_F, Sprinkler_selector_uses_B_marginal, 1, Sprinkler_selector_uses_F[1]);
Bernoulli Rain_cond_Sprinkler_0_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli21);
// Message to 'Rain_cond_Sprinkler_0_selector' from Cases factor
Rain_cond_Sprinkler_0_selector_B = CasesOp.BAverageConditional(Rain_cond_Sprinkler_0_selector_cases_B);
DistributionStructArray <Bernoulli, bool> Rain_cond_Sprinkler_B = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Rain_cond_Sprinkler' Backwards messages.
Rain_cond_Sprinkler_B = new DistributionStructArray <Bernoulli, bool>(2);
for (int _gateind = 0; _gateind < 2; _gateind++)
{
Rain_cond_Sprinkler_B[_gateind] = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli21);
}
// Message to 'Rain_cond_Sprinkler' from Copy factor
Rain_cond_Sprinkler_B[0] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_0_selector_B);
Bernoulli Rain_cond_Sprinkler_1_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli21);
// Message to 'Rain_cond_Sprinkler_1_selector' from Cases factor
Rain_cond_Sprinkler_1_selector_B = CasesOp.BAverageConditional(Rain_cond_Sprinkler_1_selector_cases_B);
// Message to 'Rain_cond_Sprinkler' from Copy factor
Rain_cond_Sprinkler_B[1] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_1_selector_B);
// Message to 'Rain_use' from EnterPartial factor
Rain_use_B = GateEnterPartialOp <bool> .ValueAverageConditional <Bernoulli>(Rain_cond_Sprinkler_B, Sprinkler_selector_uses_F[1], Rain_use_F, new int[2] {
0, 1
}, Rain_use_B);
if (this.cloudy)
{
// Message to 'Rain_marginal' from DerivedVariable factor
this.Rain_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Rain_use_B, Rain_F, this.Rain_marginal_F);
}
if (!this.cloudy)
{
// Message to 'Rain_marginal' from DerivedVariable factor
this.Rain_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Rain_use_B, vBernoulli22, this.Rain_marginal_F);
}
// Rain_marginal_F is now updated in all contexts
this.Sprinkler_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli19);
Bernoulli Sprinkler_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli19);
// Message to 'Sprinkler_selector' from Replicate factor
Sprinkler_selector_B = ReplicateOp.DefAverageConditional <Bernoulli>(Sprinkler_selector_uses_B, Sprinkler_selector_B);
if (this.cloudy)
{
// Message to 'Sprinkler_marginal' from DerivedVariable factor
this.Sprinkler_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Sprinkler_selector_B, Sprinkler_F, this.Sprinkler_marginal_F);
}
if (!this.cloudy)
{
// Message to 'Sprinkler_marginal' from DerivedVariable factor
this.Sprinkler_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Sprinkler_selector_B, vBernoulli18, this.Sprinkler_marginal_F);
}
// Sprinkler_marginal_F is now updated in all contexts
this.Changed_Cloudy_WetGrass_iterationsDone = 1;
}
/// <summary>Computations that depend on the observed value of numberOfIterationsDecreased and WetGrass</summary>
/// <param name="numberOfIterations">The number of times to iterate each loop</param>
public void Changed_numberOfIterationsDecreased_WetGrass(int numberOfIterations)
{
if (this.Changed_numberOfIterationsDecreased_WetGrass_iterationsDone == numberOfIterations)
{
return;
}
// The constant 'vBernoulli32'
Bernoulli vBernoulli32 = Bernoulli.FromLogOdds(4.5951198501345889);
this.WetGrass_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli32);
this.WetGrass_marginal = Distribution.SetPoint <Bernoulli, bool>(this.WetGrass_marginal, this.wetGrass);
Bernoulli Rain_F = ArrayHelper.MakeUniform <Bernoulli>(this.vBernoulli30);
// The constant 'vBernoulli27'
Bernoulli vBernoulli27 = Bernoulli.FromLogOdds(0);
this.Cloudy_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli27);
DistributionStructArray <Bernoulli, bool> Rain_cond_Cloudy_F = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Rain_cond_Cloudy' Forwards messages.
Rain_cond_Cloudy_F = new DistributionStructArray <Bernoulli, bool>(2);
for (int _gateind = 0; _gateind < 2; _gateind++)
{
Rain_cond_Cloudy_F[_gateind] = ArrayHelper.MakeUniform <Bernoulli>(this.vBernoulli30);
}
// Message to 'Rain_cond_Cloudy' from Copy factor
Rain_cond_Cloudy_F[0] = Factor.Copy <Bernoulli>(this.vBernoulli30);
// The constant 'vBernoulli31'
Bernoulli vBernoulli31 = Bernoulli.FromLogOdds(-1.3862943611198906);
// Message to 'Rain_cond_Cloudy' from Copy factor
Rain_cond_Cloudy_F[1] = Factor.Copy <Bernoulli>(vBernoulli31);
DistributionStructArray <Bernoulli, bool> Cloudy_selector_cases_F = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Cloudy_selector_cases' Forwards messages.
Cloudy_selector_cases_F = new DistributionStructArray <Bernoulli, bool>(2);
for (int _iv0 = 0; _iv0 < 2; _iv0++)
{
Cloudy_selector_cases_F[_iv0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Cloudy_selector_cases' from Cases factor
Cloudy_selector_cases_F = CasesOp.CasesAverageConditional <DistributionStructArray <Bernoulli, bool> >(vBernoulli27, Cloudy_selector_cases_F);
// The constant 'vBernoulli28'
Bernoulli vBernoulli28 = Bernoulli.FromLogOdds(-2.1972245773362191);
DistributionStructArray <Bernoulli, bool> Sprinkler_cond_Cloudy_F = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Sprinkler_cond_Cloudy' Forwards messages.
Sprinkler_cond_Cloudy_F = new DistributionStructArray <Bernoulli, bool>(2);
for (int _gateind = 0; _gateind < 2; _gateind++)
{
Sprinkler_cond_Cloudy_F[_gateind] = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli28);
}
// Message to 'Sprinkler_cond_Cloudy' from Copy factor
Sprinkler_cond_Cloudy_F[0] = Factor.Copy <Bernoulli>(vBernoulli28);
// Message to 'Sprinkler_cond_Cloudy' from Copy factor
Sprinkler_cond_Cloudy_F[1] = Factor.Copy <Bernoulli>(vBernoulli27);
Bernoulli Rain_cond_Sprinkler_0_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_0_selector_cases_0' from Random factor
Rain_cond_Sprinkler_0_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli32));
DistributionStructArray <Bernoulli, bool> Rain_cond_Sprinkler_0_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Rain_cond_Sprinkler_0_selector_cases' Backwards messages.
Rain_cond_Sprinkler_0_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2);
for (int _ind0 = 0; _ind0 < 2; _ind0++)
{
Rain_cond_Sprinkler_0_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor
Rain_cond_Sprinkler_0_selector_cases_B[0] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_0_selector_cases_0_B);
// The constant 'vBernoulli33'
Bernoulli vBernoulli33 = Bernoulli.FromLogOdds(2.1972245773362196);
Bernoulli Rain_cond_Sprinkler_0_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_0_selector_cases_1' from Random factor
Rain_cond_Sprinkler_0_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli33));
// Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor
Rain_cond_Sprinkler_0_selector_cases_B[1] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_0_selector_cases_1_B);
Bernoulli[] Sprinkler_selector_cases_0_uses_B = default(Bernoulli[]);
// Create array for 'Sprinkler_selector_cases_0_uses' Backwards messages.
Sprinkler_selector_cases_0_uses_B = new Bernoulli[5];
for (int _ind = 0; _ind < 5; _ind++)
{
Sprinkler_selector_cases_0_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
Bernoulli Sprinkler_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
DistributionStructArray <Bernoulli, bool> Sprinkler_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Sprinkler_selector_cases' Backwards messages.
Sprinkler_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2);
for (int _ind0 = 0; _ind0 < 2; _ind0++)
{
Sprinkler_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
Bernoulli Rain_cond_Sprinkler_1_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_1_selector_cases_0' from Random factor
Rain_cond_Sprinkler_1_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli33));
DistributionStructArray <Bernoulli, bool> Rain_cond_Sprinkler_1_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Rain_cond_Sprinkler_1_selector_cases' Backwards messages.
Rain_cond_Sprinkler_1_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2);
for (int _ind0 = 0; _ind0 < 2; _ind0++)
{
Rain_cond_Sprinkler_1_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor
Rain_cond_Sprinkler_1_selector_cases_B[0] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_1_selector_cases_0_B);
// The constant 'vBernoulli35'
Bernoulli vBernoulli35 = Bernoulli.FromLogOdds(Double.NegativeInfinity);
Bernoulli Rain_cond_Sprinkler_1_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_1_selector_cases_1' from Random factor
Rain_cond_Sprinkler_1_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli35));
// Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor
Rain_cond_Sprinkler_1_selector_cases_B[1] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_1_selector_cases_1_B);
Bernoulli[] Sprinkler_selector_cases_1_uses_B = default(Bernoulli[]);
// Create array for 'Sprinkler_selector_cases_1_uses' Backwards messages.
Sprinkler_selector_cases_1_uses_B = new Bernoulli[5];
for (int _ind = 0; _ind < 5; _ind++)
{
Sprinkler_selector_cases_1_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
Bernoulli Sprinkler_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
Bernoulli[] Sprinkler_selector_uses_B = default(Bernoulli[]);
// Create array for 'Sprinkler_selector_uses' Backwards messages.
Sprinkler_selector_uses_B = new Bernoulli[2];
for (int _ind = 0; _ind < 2; _ind++)
{
Sprinkler_selector_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli28);
}
Bernoulli Sprinkler_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli28);
// Buffer for Replicate2BufferOp.UsesAverageConditional<DistributionStructArray<Bernoulli,bool>>
DistributionStructArray <Bernoulli, bool> Cloudy_selector_cases_uses_B_marginal = default(DistributionStructArray <Bernoulli, bool>);
// Message to 'Cloudy_selector_cases_uses' from Replicate factor
Cloudy_selector_cases_uses_B_marginal = Replicate2BufferOp.MarginalInit <DistributionStructArray <Bernoulli, bool> >(Cloudy_selector_cases_F);
DistributionStructArray <Bernoulli, bool>[] Cloudy_selector_cases_uses_F = default(DistributionStructArray <Bernoulli, bool>[]);
// Create array for 'Cloudy_selector_cases_uses' Forwards messages.
Cloudy_selector_cases_uses_F = new DistributionStructArray <Bernoulli, bool> [4];
for (int _ind = 0; _ind < 4; _ind++)
{
// Create array for 'Cloudy_selector_cases_uses' Forwards messages.
Cloudy_selector_cases_uses_F[_ind] = new DistributionStructArray <Bernoulli, bool>(2);
for (int _iv0 = 0; _iv0 < 2; _iv0++)
{
Cloudy_selector_cases_uses_F[_ind][_iv0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
}
Bernoulli Sprinkler_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli28);
// Buffer for Replicate2BufferOp.UsesAverageConditional<Bernoulli>
Bernoulli Sprinkler_selector_uses_B_marginal = default(Bernoulli);
// Message to 'Sprinkler_selector_uses' from Replicate factor
Sprinkler_selector_uses_B_marginal = Replicate2BufferOp.MarginalInit <Bernoulli>(Sprinkler_F);
Bernoulli[] Sprinkler_selector_uses_F = default(Bernoulli[]);
// Create array for 'Sprinkler_selector_uses' Forwards messages.
Sprinkler_selector_uses_F = new Bernoulli[2];
for (int _ind = 0; _ind < 2; _ind++)
{
Sprinkler_selector_uses_F[_ind] = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli28);
}
Bernoulli Rain_cond_Sprinkler_0_selector_B = ArrayHelper.MakeUniform <Bernoulli>(this.vBernoulli30);
// Message to 'Rain_cond_Sprinkler_0_selector' from Cases factor
Rain_cond_Sprinkler_0_selector_B = CasesOp.BAverageConditional(Rain_cond_Sprinkler_0_selector_cases_B);
DistributionStructArray <Bernoulli, bool> Rain_cond_Sprinkler_B = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Rain_cond_Sprinkler' Backwards messages.
Rain_cond_Sprinkler_B = new DistributionStructArray <Bernoulli, bool>(2);
for (int _gateind = 0; _gateind < 2; _gateind++)
{
Rain_cond_Sprinkler_B[_gateind] = ArrayHelper.MakeUniform <Bernoulli>(this.vBernoulli30);
}
// Message to 'Rain_cond_Sprinkler' from Copy factor
Rain_cond_Sprinkler_B[0] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_0_selector_B);
Bernoulli Rain_cond_Sprinkler_1_selector_B = ArrayHelper.MakeUniform <Bernoulli>(this.vBernoulli30);
// Message to 'Rain_cond_Sprinkler_1_selector' from Cases factor
Rain_cond_Sprinkler_1_selector_B = CasesOp.BAverageConditional(Rain_cond_Sprinkler_1_selector_cases_B);
// Message to 'Rain_cond_Sprinkler' from Copy factor
Rain_cond_Sprinkler_B[1] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_1_selector_B);
for (int iteration = this.Changed_numberOfIterationsDecreased_WetGrass_iterationsDone; iteration < numberOfIterations; iteration++)
{
// Message to 'Cloudy_selector_cases_uses' from Replicate factor
Cloudy_selector_cases_uses_B_marginal = Replicate2BufferOp.Marginal <DistributionStructArray <Bernoulli, bool> >(this.Cloudy_selector_cases_uses_B, Cloudy_selector_cases_F, Cloudy_selector_cases_uses_B_marginal);
// Message to 'Cloudy_selector_cases_uses' from Replicate factor
Cloudy_selector_cases_uses_F[1] = Replicate2BufferOp.UsesAverageConditional <DistributionStructArray <Bernoulli, bool> >(this.Cloudy_selector_cases_uses_B, Cloudy_selector_cases_F, Cloudy_selector_cases_uses_B_marginal, 1, Cloudy_selector_cases_uses_F[1]);
// Message to 'Rain' from Exit factor
Rain_F = GateExitOp <bool> .ExitAverageConditional <Bernoulli>(this.Rain_use_B, Cloudy_selector_cases_uses_F[1], Rain_cond_Cloudy_F, Rain_F);
// Message to 'Sprinkler_selector_cases_1_uses' from Cases factor
Sprinkler_selector_cases_1_uses_B[4] = Bernoulli.FromLogOdds(CasesOp.LogEvidenceRatio(Rain_cond_Sprinkler_1_selector_cases_B, Rain_F));
// Message to 'Sprinkler_selector_cases_1' from Replicate factor
Sprinkler_selector_cases_1_B = ReplicateOp.DefAverageConditional <Bernoulli>(Sprinkler_selector_cases_1_uses_B, Sprinkler_selector_cases_1_B);
// Message to 'Sprinkler_selector_cases' from Copy factor
Sprinkler_selector_cases_B[1] = Factor.Copy <Bernoulli>(Sprinkler_selector_cases_1_B);
// Message to 'Sprinkler_selector_cases_0_uses' from Cases factor
Sprinkler_selector_cases_0_uses_B[4] = Bernoulli.FromLogOdds(CasesOp.LogEvidenceRatio(Rain_cond_Sprinkler_0_selector_cases_B, Rain_F));
// Message to 'Sprinkler_selector_cases_0' from Replicate factor
Sprinkler_selector_cases_0_B = ReplicateOp.DefAverageConditional <Bernoulli>(Sprinkler_selector_cases_0_uses_B, Sprinkler_selector_cases_0_B);
// Message to 'Sprinkler_selector_cases' from Copy factor
Sprinkler_selector_cases_B[0] = Factor.Copy <Bernoulli>(Sprinkler_selector_cases_0_B);
// Message to 'Sprinkler_selector_uses' from Cases factor
Sprinkler_selector_uses_B[0] = CasesOp.BAverageConditional(Sprinkler_selector_cases_B);
// Message to 'Sprinkler_selector' from Replicate factor
Sprinkler_selector_B = ReplicateOp.DefAverageConditional <Bernoulli>(Sprinkler_selector_uses_B, Sprinkler_selector_B);
// Message to 'Cloudy_selector_cases_uses' from Exit factor
this.Cloudy_selector_cases_uses_B[3] = GateExitOp <bool> .CasesAverageConditional <Bernoulli, DistributionStructArray <Bernoulli, bool> >(Sprinkler_selector_B, Sprinkler_cond_Cloudy_F, this.Cloudy_selector_cases_uses_B[3]);
// Message to 'Cloudy_selector_cases_uses' from Replicate factor
Cloudy_selector_cases_uses_B_marginal = Replicate2BufferOp.Marginal <DistributionStructArray <Bernoulli, bool> >(this.Cloudy_selector_cases_uses_B, Cloudy_selector_cases_F, Cloudy_selector_cases_uses_B_marginal);
// Message to 'Cloudy_selector_cases_uses' from Replicate factor
Cloudy_selector_cases_uses_F[3] = Replicate2BufferOp.UsesAverageConditional <DistributionStructArray <Bernoulli, bool> >(this.Cloudy_selector_cases_uses_B, Cloudy_selector_cases_F, Cloudy_selector_cases_uses_B_marginal, 3, Cloudy_selector_cases_uses_F[3]);
// Message to 'Sprinkler' from Exit factor
Sprinkler_F = GateExitOp <bool> .ExitAverageConditional <Bernoulli>(Sprinkler_selector_B, Cloudy_selector_cases_uses_F[3], Sprinkler_cond_Cloudy_F, Sprinkler_F);
// Message to 'Sprinkler_selector_uses' from Replicate factor
Sprinkler_selector_uses_B_marginal = Replicate2BufferOp.Marginal <Bernoulli>(Sprinkler_selector_uses_B, Sprinkler_F, Sprinkler_selector_uses_B_marginal);
// Message to 'Sprinkler_selector_uses' from Replicate factor
Sprinkler_selector_uses_F[1] = Replicate2BufferOp.UsesAverageConditional <Bernoulli>(Sprinkler_selector_uses_B, Sprinkler_F, Sprinkler_selector_uses_B_marginal, 1, Sprinkler_selector_uses_F[1]);
// Message to 'Rain_use' from EnterPartial factor
this.Rain_use_B = GateEnterPartialOp <bool> .ValueAverageConditional <Bernoulli>(Rain_cond_Sprinkler_B, Sprinkler_selector_uses_F[1], Rain_F, new int[2] {
0, 1
}, this.Rain_use_B);
// Message to 'Cloudy_selector_cases_uses' from Exit factor
this.Cloudy_selector_cases_uses_B[1] = GateExitOp <bool> .CasesAverageConditional <Bernoulli, DistributionStructArray <Bernoulli, bool> >(this.Rain_use_B, Rain_cond_Cloudy_F, this.Cloudy_selector_cases_uses_B[1]);
this.OnProgressChanged(new ProgressChangedEventArgs(iteration));
}
DistributionStructArray <Bernoulli, bool> Cloudy_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Cloudy_selector_cases' Backwards messages.
Cloudy_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2);
for (int _iv0 = 0; _iv0 < 2; _iv0++)
{
Cloudy_selector_cases_B[_iv0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Cloudy_selector_cases' from Replicate factor
Cloudy_selector_cases_B = ReplicateOp.DefAverageConditional <DistributionStructArray <Bernoulli, bool> >(this.Cloudy_selector_cases_uses_B, Cloudy_selector_cases_B);
Bernoulli Cloudy_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli27);
// Message to 'Cloudy_selector' from Cases factor
Cloudy_selector_B = CasesOp.BAverageConditional(Cloudy_selector_cases_B);
// Message to 'Cloudy_marginal' from Variable factor
this.Cloudy_marginal_F = VariableOp.MarginalAverageConditional <Bernoulli>(Cloudy_selector_B, vBernoulli27, this.Cloudy_marginal_F);
this.Rain_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(this.vBernoulli30);
// Message to 'Rain_marginal' from DerivedVariable factor
this.Rain_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(this.Rain_use_B, Rain_F, this.Rain_marginal_F);
this.Sprinkler_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli28);
// Message to 'Sprinkler_marginal' from DerivedVariable factor
this.Sprinkler_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Sprinkler_selector_B, Sprinkler_F, this.Sprinkler_marginal_F);
this.Changed_numberOfIterationsDecreased_WetGrass_iterationsDone = numberOfIterations;
}
/// <summary>Computations that depend on the observed value of Cloudy and WetGrass and Sprinkler</summary>
public void Changed_Cloudy_WetGrass_Sprinkler()
{
if (this.Changed_Cloudy_WetGrass_Sprinkler_iterationsDone == 1)
{
return;
}
// The constant 'vBernoulli0'
Bernoulli vBernoulli0 = Bernoulli.FromLogOdds(0);
this.Cloudy_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli0);
this.Cloudy_marginal = Distribution.SetPoint <Bernoulli, bool>(this.Cloudy_marginal, this.cloudy);
// The constant 'vBernoulli5'
Bernoulli vBernoulli5 = Bernoulli.FromLogOdds(4.5951198501345889);
this.WetGrass_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli5);
this.WetGrass_marginal = Distribution.SetPoint <Bernoulli, bool>(this.WetGrass_marginal, this.wetGrass);
// The constant 'vBernoulli1'
Bernoulli vBernoulli1 = Bernoulli.FromLogOdds(-2.1972245773362191);
this.Sprinkler_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli1);
this.Sprinkler_marginal = Distribution.SetPoint <Bernoulli, bool>(this.Sprinkler_marginal, this.sprinkler);
// The constant 'vBernoulli3'
Bernoulli vBernoulli3 = Bernoulli.FromLogOdds(1.3862943611198908);
Bernoulli Rain_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3);
this.Rain_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3);
// Message from use of 'Rain'
Bernoulli Rain_use_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3);
if (this.cloudy)
{
// Message to 'Rain' from Copy factor
Rain_F = Factor.Copy <Bernoulli>(vBernoulli3);
}
// The constant 'vBernoulli4'
Bernoulli vBernoulli4 = Bernoulli.FromLogOdds(-1.3862943611198906);
if (!this.cloudy)
{
// Message to 'Rain' from Copy factor
Rain_F = Factor.Copy <Bernoulli>(vBernoulli4);
}
// Rain_F is now updated in all contexts
if (this.sprinkler)
{
this.Rain_cond_Sprinkler_0_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_0_selector_cases_0' from Random factor
this.Rain_cond_Sprinkler_0_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli5));
// Create array for 'Rain_cond_Sprinkler_0_selector_cases' Backwards messages.
this.Rain_cond_Sprinkler_0_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2);
for (int _ind0 = 0; _ind0 < 2; _ind0++)
{
this.Rain_cond_Sprinkler_0_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor
this.Rain_cond_Sprinkler_0_selector_cases_B[0] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_0_selector_cases_0_B);
}
// The constant 'vBernoulli6'
Bernoulli vBernoulli6 = Bernoulli.FromLogOdds(2.1972245773362196);
if (this.sprinkler)
{
this.Rain_cond_Sprinkler_0_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_0_selector_cases_1' from Random factor
this.Rain_cond_Sprinkler_0_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli6));
// Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor
this.Rain_cond_Sprinkler_0_selector_cases_B[1] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_0_selector_cases_1_B);
this.Rain_cond_Sprinkler_0_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3);
// Message to 'Rain_cond_Sprinkler_0_selector' from Cases factor
this.Rain_cond_Sprinkler_0_selector_B = CasesOp.BAverageConditional(this.Rain_cond_Sprinkler_0_selector_cases_B);
// Message to 'Rain_use' from Copy factor
Rain_use_B = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_0_selector_B);
}
if (!this.sprinkler)
{
this.Rain_cond_Sprinkler_1_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_1_selector_cases_0' from Random factor
this.Rain_cond_Sprinkler_1_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli6));
// Create array for 'Rain_cond_Sprinkler_1_selector_cases' Backwards messages.
this.Rain_cond_Sprinkler_1_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2);
for (int _ind0 = 0; _ind0 < 2; _ind0++)
{
this.Rain_cond_Sprinkler_1_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor
this.Rain_cond_Sprinkler_1_selector_cases_B[0] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_1_selector_cases_0_B);
}
// The constant 'vBernoulli8'
Bernoulli vBernoulli8 = Bernoulli.FromLogOdds(Double.NegativeInfinity);
if (!this.sprinkler)
{
this.Rain_cond_Sprinkler_1_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_1_selector_cases_1' from Random factor
this.Rain_cond_Sprinkler_1_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli8));
// Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor
this.Rain_cond_Sprinkler_1_selector_cases_B[1] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_1_selector_cases_1_B);
this.Rain_cond_Sprinkler_1_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3);
// Message to 'Rain_cond_Sprinkler_1_selector' from Cases factor
this.Rain_cond_Sprinkler_1_selector_B = CasesOp.BAverageConditional(this.Rain_cond_Sprinkler_1_selector_cases_B);
// Message to 'Rain_use' from Copy factor
Rain_use_B = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_1_selector_B);
}
// Rain_use_B is now updated in all contexts
if (this.cloudy)
{
// Message to 'Rain_marginal' from DerivedVariable factor
this.Rain_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Rain_use_B, Rain_F, this.Rain_marginal_F);
}
if (!this.cloudy)
{
// Message to 'Rain_marginal' from DerivedVariable factor
this.Rain_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Rain_use_B, vBernoulli4, this.Rain_marginal_F);
}
// Rain_marginal_F is now updated in all contexts
this.Changed_Cloudy_WetGrass_Sprinkler_iterationsDone = 1;
}
/// <summary>Computations that depend on the observed value of Sprinkler and WetGrass</summary>
public void Changed_Sprinkler_WetGrass()
{
if (this.Changed_Sprinkler_WetGrass_iterationsDone == 1)
{
return;
}
// The constant 'vBernoulli1'
Bernoulli vBernoulli1 = Bernoulli.FromLogOdds(-2.1972245773362191);
this.Sprinkler_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli1);
this.Sprinkler_marginal = Distribution.SetPoint <Bernoulli, bool>(this.Sprinkler_marginal, this.sprinkler);
// The constant 'vBernoulli5'
Bernoulli vBernoulli5 = Bernoulli.FromLogOdds(4.5951198501345889);
this.WetGrass_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli5);
this.WetGrass_marginal = Distribution.SetPoint <Bernoulli, bool>(this.WetGrass_marginal, this.wetGrass);
// The constant 'vBernoulli3'
Bernoulli vBernoulli3 = Bernoulli.FromLogOdds(1.3862943611198908);
Bernoulli Rain_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3);
// The constant 'vBernoulli0'
Bernoulli vBernoulli0 = Bernoulli.FromLogOdds(0);
this.Cloudy_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli0);
Bernoulli[] Cloudy_selector_cases_0_uses_B = default(Bernoulli[]);
// Create array for 'Cloudy_selector_cases_0_uses' Backwards messages.
Cloudy_selector_cases_0_uses_B = new Bernoulli[7];
for (int _ind = 0; _ind < 7; _ind++)
{
Cloudy_selector_cases_0_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Cloudy_selector_cases_0_uses' from Random factor
Cloudy_selector_cases_0_uses_B[6] = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.sprinkler, vBernoulli1));
Bernoulli Cloudy_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Cloudy_selector_cases_0' from Replicate factor
Cloudy_selector_cases_0_B = ReplicateOp.DefAverageConditional <Bernoulli>(Cloudy_selector_cases_0_uses_B, Cloudy_selector_cases_0_B);
DistributionStructArray <Bernoulli, bool>[] Cloudy_selector_cases_uses_B = default(DistributionStructArray <Bernoulli, bool>[]);
// Create array for 'Cloudy_selector_cases_uses' Backwards messages.
Cloudy_selector_cases_uses_B = new DistributionStructArray <Bernoulli, bool> [3];
for (int _ind = 0; _ind < 3; _ind++)
{
// Create array for 'Cloudy_selector_cases_uses' Backwards messages.
Cloudy_selector_cases_uses_B[_ind] = new DistributionStructArray <Bernoulli, bool>(2);
for (int _iv0 = 0; _iv0 < 2; _iv0++)
{
Cloudy_selector_cases_uses_B[_ind][_iv0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
}
// Message to 'Cloudy_selector_cases_uses' from Copy factor
Cloudy_selector_cases_uses_B[0][0] = Factor.Copy <Bernoulli>(Cloudy_selector_cases_0_B);
DistributionStructArray <Bernoulli, bool> Rain_cond_Cloudy_F = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Rain_cond_Cloudy' Forwards messages.
Rain_cond_Cloudy_F = new DistributionStructArray <Bernoulli, bool>(2);
for (int _gateind = 0; _gateind < 2; _gateind++)
{
Rain_cond_Cloudy_F[_gateind] = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3);
}
// Message to 'Rain_cond_Cloudy' from Copy factor
Rain_cond_Cloudy_F[0] = Factor.Copy <Bernoulli>(vBernoulli3);
// The constant 'vBernoulli4'
Bernoulli vBernoulli4 = Bernoulli.FromLogOdds(-1.3862943611198906);
// Message to 'Rain_cond_Cloudy' from Copy factor
Rain_cond_Cloudy_F[1] = Factor.Copy <Bernoulli>(vBernoulli4);
if (this.sprinkler)
{
this.Rain_cond_Sprinkler_0_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_0_selector_cases_0' from Random factor
this.Rain_cond_Sprinkler_0_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli5));
// Create array for 'Rain_cond_Sprinkler_0_selector_cases' Backwards messages.
this.Rain_cond_Sprinkler_0_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2);
for (int _ind0 = 0; _ind0 < 2; _ind0++)
{
this.Rain_cond_Sprinkler_0_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor
this.Rain_cond_Sprinkler_0_selector_cases_B[0] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_0_selector_cases_0_B);
}
// The constant 'vBernoulli6'
Bernoulli vBernoulli6 = Bernoulli.FromLogOdds(2.1972245773362196);
if (this.sprinkler)
{
this.Rain_cond_Sprinkler_0_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_0_selector_cases_1' from Random factor
this.Rain_cond_Sprinkler_0_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli6));
// Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor
this.Rain_cond_Sprinkler_0_selector_cases_B[1] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_0_selector_cases_1_B);
this.Rain_cond_Sprinkler_0_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3);
// Message to 'Rain_cond_Sprinkler_0_selector' from Cases factor
this.Rain_cond_Sprinkler_0_selector_B = CasesOp.BAverageConditional(this.Rain_cond_Sprinkler_0_selector_cases_B);
}
// Message from use of 'Rain'
Bernoulli Rain_use_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3);
if (this.sprinkler)
{
// Message to 'Rain_use' from Copy factor
Rain_use_B = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_0_selector_B);
}
if (!this.sprinkler)
{
this.Rain_cond_Sprinkler_1_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_1_selector_cases_0' from Random factor
this.Rain_cond_Sprinkler_1_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli6));
// Create array for 'Rain_cond_Sprinkler_1_selector_cases' Backwards messages.
this.Rain_cond_Sprinkler_1_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2);
for (int _ind0 = 0; _ind0 < 2; _ind0++)
{
this.Rain_cond_Sprinkler_1_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor
this.Rain_cond_Sprinkler_1_selector_cases_B[0] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_1_selector_cases_0_B);
}
// The constant 'vBernoulli8'
Bernoulli vBernoulli8 = Bernoulli.FromLogOdds(Double.NegativeInfinity);
if (!this.sprinkler)
{
this.Rain_cond_Sprinkler_1_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Rain_cond_Sprinkler_1_selector_cases_1' from Random factor
this.Rain_cond_Sprinkler_1_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli8));
// Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor
this.Rain_cond_Sprinkler_1_selector_cases_B[1] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_1_selector_cases_1_B);
this.Rain_cond_Sprinkler_1_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3);
// Message to 'Rain_cond_Sprinkler_1_selector' from Cases factor
this.Rain_cond_Sprinkler_1_selector_B = CasesOp.BAverageConditional(this.Rain_cond_Sprinkler_1_selector_cases_B);
// Message to 'Rain_use' from Copy factor
Rain_use_B = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_1_selector_B);
}
// Rain_use_B is now updated in all contexts
// Message to 'Cloudy_selector_cases_uses' from Exit factor
Cloudy_selector_cases_uses_B[1] = GateExitOp <bool> .CasesAverageConditional <Bernoulli, DistributionStructArray <Bernoulli, bool> >(Rain_use_B, Rain_cond_Cloudy_F, Cloudy_selector_cases_uses_B[1]);
Bernoulli[] Cloudy_selector_cases_1_uses_B = default(Bernoulli[]);
// Create array for 'Cloudy_selector_cases_1_uses' Backwards messages.
Cloudy_selector_cases_1_uses_B = new Bernoulli[7];
for (int _ind = 0; _ind < 7; _ind++)
{
Cloudy_selector_cases_1_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Cloudy_selector_cases_1_uses' from Random factor
Cloudy_selector_cases_1_uses_B[6] = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.sprinkler, vBernoulli0));
Bernoulli Cloudy_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
// Message to 'Cloudy_selector_cases_1' from Replicate factor
Cloudy_selector_cases_1_B = ReplicateOp.DefAverageConditional <Bernoulli>(Cloudy_selector_cases_1_uses_B, Cloudy_selector_cases_1_B);
// Message to 'Cloudy_selector_cases_uses' from Copy factor
Cloudy_selector_cases_uses_B[2][1] = Factor.Copy <Bernoulli>(Cloudy_selector_cases_1_B);
DistributionStructArray <Bernoulli, bool> Cloudy_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Cloudy_selector_cases' Backwards messages.
Cloudy_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2);
for (int _iv0 = 0; _iv0 < 2; _iv0++)
{
Cloudy_selector_cases_B[_iv0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
// Message to 'Cloudy_selector_cases' from Replicate factor
Cloudy_selector_cases_B = ReplicateOp.DefAverageConditional <DistributionStructArray <Bernoulli, bool> >(Cloudy_selector_cases_uses_B, Cloudy_selector_cases_B);
Bernoulli Cloudy_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli0);
// Message to 'Cloudy_selector' from Cases factor
Cloudy_selector_B = CasesOp.BAverageConditional(Cloudy_selector_cases_B);
// Message to 'Cloudy_marginal' from Variable factor
this.Cloudy_marginal_F = VariableOp.MarginalAverageConditional <Bernoulli>(Cloudy_selector_B, vBernoulli0, this.Cloudy_marginal_F);
DistributionStructArray <Bernoulli, bool> Cloudy_selector_cases_F = default(DistributionStructArray <Bernoulli, bool>);
// Create array for 'Cloudy_selector_cases' Forwards messages.
Cloudy_selector_cases_F = new DistributionStructArray <Bernoulli, bool>(2);
for (int _iv0 = 0; _iv0 < 2; _iv0++)
{
Cloudy_selector_cases_F[_iv0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
DistributionStructArray <Bernoulli, bool>[] Cloudy_selector_cases_uses_F = default(DistributionStructArray <Bernoulli, bool>[]);
// Create array for 'Cloudy_selector_cases_uses' Forwards messages.
Cloudy_selector_cases_uses_F = new DistributionStructArray <Bernoulli, bool> [3];
for (int _ind = 0; _ind < 3; _ind++)
{
// Create array for 'Cloudy_selector_cases_uses' Forwards messages.
Cloudy_selector_cases_uses_F[_ind] = new DistributionStructArray <Bernoulli, bool>(2);
for (int _iv0 = 0; _iv0 < 2; _iv0++)
{
Cloudy_selector_cases_uses_F[_ind][_iv0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli());
}
}
// Message to 'Cloudy_selector_cases' from Cases factor
Cloudy_selector_cases_F = CasesOp.CasesAverageConditional <DistributionStructArray <Bernoulli, bool> >(vBernoulli0, Cloudy_selector_cases_F);
// Buffer for Replicate2BufferOp.UsesAverageConditional<DistributionStructArray<Bernoulli,bool>>
DistributionStructArray <Bernoulli, bool> Cloudy_selector_cases_uses_B_marginal = default(DistributionStructArray <Bernoulli, bool>);
// Message to 'Cloudy_selector_cases_uses' from Replicate factor
Cloudy_selector_cases_uses_B_marginal = Replicate2BufferOp.MarginalInit <DistributionStructArray <Bernoulli, bool> >(Cloudy_selector_cases_F);
// Message to 'Cloudy_selector_cases_uses' from Replicate factor
Cloudy_selector_cases_uses_B_marginal = Replicate2BufferOp.Marginal <DistributionStructArray <Bernoulli, bool> >(Cloudy_selector_cases_uses_B, Cloudy_selector_cases_F, Cloudy_selector_cases_uses_B_marginal);
// Message to 'Cloudy_selector_cases_uses' from Replicate factor
Cloudy_selector_cases_uses_F[1] = Replicate2BufferOp.UsesAverageConditional <DistributionStructArray <Bernoulli, bool> >(Cloudy_selector_cases_uses_B, Cloudy_selector_cases_F, Cloudy_selector_cases_uses_B_marginal, 1, Cloudy_selector_cases_uses_F[1]);
this.Rain_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3);
// Message to 'Rain' from Exit factor
Rain_F = GateExitOp <bool> .ExitAverageConditional <Bernoulli>(Rain_use_B, Cloudy_selector_cases_uses_F[1], Rain_cond_Cloudy_F, Rain_F);
// Message to 'Rain_marginal' from DerivedVariable factor
this.Rain_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Rain_use_B, Rain_F, this.Rain_marginal_F);
this.Changed_Sprinkler_WetGrass_iterationsDone = 1;
}
/// <summary>Computations that do not depend on observed values</summary>
private void Constant()
{
if (this.Constant_isDone)
{
return;
}
Gaussian t1_F = default(Gaussian);
this.t1_marginal_F = Gaussian.Uniform();
Gaussian t1_use_B = Gaussian.Uniform();
// Message to 't1' from GaussianFromMeanAndVariance factor
t1_F = GaussianFromMeanAndVarianceOp.SampleAverageConditional(1.0, 1.0);
Gaussian[] t1_uses_F;
Gaussian[] t1_uses_B;
// Create array for 't1_uses' Forwards messages.
t1_uses_F = new Gaussian[2];
// Create array for 't1_uses' Backwards messages.
t1_uses_B = new Gaussian[2];
t1_uses_B[1] = Gaussian.Uniform();
t1_uses_B[0] = Gaussian.Uniform();
t1_uses_F[1] = Gaussian.Uniform();
t1_uses_F[0] = Gaussian.Uniform();
// Message to 't1_marginal' from Variable factor
this.t1_marginal_F = VariableOp.MarginalAverageConditional <Gaussian>(t1_use_B, t1_F, this.t1_marginal_F);
// Message to 't1_uses' from Replicate factor
t1_uses_F[0] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(t1_uses_B, t1_F, 0, t1_uses_F[0]);
// Message to 't1_uses' from Replicate factor
t1_uses_F[1] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(t1_uses_B, t1_F, 1, t1_uses_F[1]);
Gaussian t2_F = default(Gaussian);
this.t2_marginal_F = Gaussian.Uniform();
Gaussian t2_use_B = Gaussian.Uniform();
// Message to 't2' from GaussianFromMeanAndVariance factor
t2_F = GaussianFromMeanAndVarianceOp.SampleAverageConditional(10.0, 1.0);
Gaussian[] t2_uses_F;
Gaussian[] t2_uses_B;
// Create array for 't2_uses' Forwards messages.
t2_uses_F = new Gaussian[2];
// Create array for 't2_uses' Backwards messages.
t2_uses_B = new Gaussian[2];
t2_uses_B[1] = Gaussian.Uniform();
t2_uses_B[0] = Gaussian.Uniform();
t2_uses_F[1] = Gaussian.Uniform();
t2_uses_F[0] = Gaussian.Uniform();
// Message to 't2_marginal' from Variable factor
this.t2_marginal_F = VariableOp.MarginalAverageConditional <Gaussian>(t2_use_B, t2_F, this.t2_marginal_F);
// Message to 't2_uses' from Replicate factor
t2_uses_F[0] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(t2_uses_B, t2_F, 0, t2_uses_F[0]);
// Message to 't2_uses' from Replicate factor
t2_uses_F[1] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(t2_uses_B, t2_F, 1, t2_uses_F[1]);
Gaussian vdouble6_F = default(Gaussian);
this.vdouble6_marginal_F = Gaussian.Uniform();
Gaussian vdouble6_use_B = Gaussian.Uniform();
// Message to 'vdouble6' from Plus factor
vdouble6_F = DoublePlusOp.SumAverageConditional(t1_uses_F[0], t2_uses_F[0]);
// Message to 'vdouble6_marginal' from DerivedVariable factor
this.vdouble6_marginal_F = DerivedVariableOp.MarginalAverageConditional <Gaussian>(vdouble6_use_B, vdouble6_F, this.vdouble6_marginal_F);
Gaussian t4_F = default(Gaussian);
this.t4_marginal_F = Gaussian.Uniform();
Gaussian t4_use_B = Gaussian.Uniform();
// Message to 't4' from GaussianFromMeanAndVariance factor
t4_F = GaussianFromMeanAndVarianceOp.SampleAverageConditional(2.0, 1.0);
Gaussian[] t4_uses_F;
Gaussian[] t4_uses_B;
// Create array for 't4_uses' Forwards messages.
t4_uses_F = new Gaussian[2];
// Create array for 't4_uses' Backwards messages.
t4_uses_B = new Gaussian[2];
t4_uses_B[1] = Gaussian.Uniform();
t4_uses_B[0] = Gaussian.Uniform();
t4_uses_F[1] = Gaussian.Uniform();
t4_uses_F[0] = Gaussian.Uniform();
// Message to 't4_marginal' from Variable factor
this.t4_marginal_F = VariableOp.MarginalAverageConditional <Gaussian>(t4_use_B, t4_F, this.t4_marginal_F);
// Message to 't4_uses' from Replicate factor
t4_uses_F[0] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(t4_uses_B, t4_F, 0, t4_uses_F[0]);
// Message to 't4_uses' from Replicate factor
t4_uses_F[1] = ReplicateOp_NoDivide.UsesAverageConditional <Gaussian>(t4_uses_B, t4_F, 1, t4_uses_F[1]);
Gaussian vdouble10_F = default(Gaussian);
this.vdouble10_marginal_F = Gaussian.Uniform();
Gaussian vdouble10_use_B = Gaussian.Uniform();
// Message to 'vdouble10' from Plus factor
vdouble10_F = DoublePlusOp.SumAverageConditional(t1_uses_F[1], t2_uses_F[1]);
// Message to 'vdouble10_marginal' from DerivedVariable factor
this.vdouble10_marginal_F = DerivedVariableOp.MarginalAverageConditional <Gaussian>(vdouble10_use_B, vdouble10_F, this.vdouble10_marginal_F);
Gaussian t5_F = default(Gaussian);
this.t5_marginal_F = Gaussian.Uniform();
Gaussian t5_use_B = Gaussian.Uniform();
// Message to 't5' from Product factor
t5_F = GaussianProductOp.ProductAverageConditional(t5_use_B, vdouble10_F, t4_uses_F[0]);
// Message to 't5_marginal' from DerivedVariable factor
this.t5_marginal_F = DerivedVariableOp.MarginalAverageConditional <Gaussian>(t5_use_B, t5_F, this.t5_marginal_F);
Gaussian t7_F = default(Gaussian);
this.t7_marginal_F = Gaussian.Uniform();
Gaussian t7_use_B = Gaussian.Uniform();
// Message to 't7' from Product factor
t7_F = GaussianProductOp.ProductAverageConditional(t7_use_B, vdouble6_F, t4_uses_F[1]);
// Message to 't7_marginal' from DerivedVariable factor
this.t7_marginal_F = DerivedVariableOp.MarginalAverageConditional <Gaussian>(t7_use_B, t7_F, this.t7_marginal_F);
this.Constant_isDone = true;
}
