/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="WrappedGaussianProductOp"]/message_doc[@name="AAverageConditional(WrappedGaussian, double, WrappedGaussian)"]/*'/>
public static WrappedGaussian AAverageConditional([SkipIfUniform] WrappedGaussian Product, double B, WrappedGaussian result)
{
result.Period = Product.Period / B;
result.Gaussian = GaussianProductOp.AAverageConditional(Product.Gaussian, B);
result.Normalize();
return(result);
}
private void GaussianProductOp_APointMass(double aMean, Gaussian Product, Gaussian B)
{
bool isProper = Product.IsProper();
Gaussian A = Gaussian.PointMass(aMean);
Gaussian result = GaussianProductOp.AAverageConditional(Product, A, B);
Console.WriteLine("{0}: {1}", A, result);
Gaussian result2 = isProper ? GaussianProductOp_Slow.AAverageConditional(Product, A, B) : result;
Console.WriteLine("{0}: {1}", A, result2);
Assert.True(result.MaxDiff(result2) < 1e-6);
var Amsg = InnerProductOp_PointB.BAverageConditional(Product, DenseVector.FromArray(B.GetMean()), new PositiveDefiniteMatrix(new double[, ] {
{ B.GetVariance() }
}), VectorGaussian.PointMass(aMean), VectorGaussian.Uniform(1));
//Console.WriteLine("{0}: {1}", A, Amsg);
Assert.True(result.MaxDiff(Amsg.GetMarginal(0)) < 1e-6);
double prevDiff = double.PositiveInfinity;
for (int i = 3; i < 40; i++)
{
double v = System.Math.Pow(0.1, i);
A = Gaussian.FromMeanAndVariance(aMean, v);
result2 = isProper ? GaussianProductOp.AAverageConditional(Product, A, B) : result;
double diff = result.MaxDiff(result2);
Console.WriteLine("{0}: {1} diff={2}", A, result2, diff.ToString("g4"));
//Assert.True(diff <= prevDiff || diff < 1e-6);
result2 = isProper ? GaussianProductOp_Slow.AAverageConditional(Product, A, B) : result;
diff = result.MaxDiff(result2);
Console.WriteLine("{0}: {1} diff={2}", A, result2, diff.ToString("g4"));
Assert.True(diff <= prevDiff || diff < 1e-6);
prevDiff = diff;
}
}
public static Gaussian DAverageConditional([SkipIfUniform] GammaPower exp, [Proper] Gaussian d)
{
double scale = 1 / exp.Power;
Gaussian forward = GaussianProductOp.ProductAverageConditional(scale, d);
Gaussian message = DAverageConditional(Gamma.FromNatural(exp.Shape - exp.Power, exp.Rate), forward);
Gaussian backward = GaussianProductOp.BAverageConditional(message, scale);
return(backward);
}
/// <summary>Computations that depend on the observed value of numberOfIterationsDecreased and WeightPriors and FeatureIndexes and InstanceCount and InstanceFeatureCounts and FeatureValues and Labels and WeightConstraints</summary>
/// <param name="numberOfIterations">The number of times to iterate each loop</param>
private void Changed_numberOfIterationsDecreased_WeightPriors_FeatureIndexes_InstanceCount_InstanceFeatureCounts_7(int numberOfIterations)
{
if (this.Changed_numberOfIterationsDecreased_WeightPriors_FeatureIndexes_InstanceCount_InstanceFeatureCounts_7_iterationsDone == numberOfIterations)
{
return;
}
for (int iteration = this.Changed_numberOfIterationsDecreased_WeightPriors_FeatureIndexes_InstanceCount_InstanceFeatureCounts_7_iterationsDone; iteration < numberOfIterations; iteration++)
{
// Message to 'Weights_uses' from Replicate factor
this.Weights_uses_B_toDef = ReplicateOp_Divide.ToDef <DistributionStructArray <Gaussian, double> >(this.Weights_uses_B, this.Weights_uses_B_toDef);
// Message to 'Weights_uses' from Replicate factor
this.Weights_uses_F_marginal = ReplicateOp_Divide.Marginal <DistributionStructArray <Gaussian, double> >(this.Weights_uses_B_toDef, this.weightPriors, this.Weights_uses_F_marginal);
// Message to 'Weights_uses' from Replicate factor
this.Weights_uses_F[1] = ReplicateOp_Divide.UsesAverageConditional <DistributionStructArray <Gaussian, double> >(this.Weights_uses_B[1], this.Weights_uses_F_marginal, 1, this.Weights_uses_F[1]);
// Message to 'Weights_FeatureIndexes' from JaggedSubarray factor
this.Weights_uses_F_1__marginal = JaggedSubarrayOp <double> .Marginal <DistributionStructArray <Gaussian, double>, Gaussian, object, DistributionStructArray <Gaussian, double> >(this.Weights_uses_F[1], this.IndexedWeights_B, this.featureIndexes, this.Weights_uses_F_1__marginal);
for (int InstanceRange = 0; InstanceRange < this.instanceCount; InstanceRange++)
{
// Message to 'Weights_FeatureIndexes' from JaggedSubarray factor
this.Weights_FeatureIndexes_F[InstanceRange] = JaggedSubarrayOp <double> .ItemsAverageConditional <DistributionStructArray <Gaussian, double>, Gaussian, DistributionStructArray <Gaussian, double> >(this.IndexedWeights_B[InstanceRange], this.Weights_uses_F[1], this.Weights_uses_F_1__marginal, this.featureIndexes, InstanceRange, this.Weights_FeatureIndexes_F[InstanceRange]);
for (int InstanceFeatureRanges = 0; InstanceFeatureRanges < this.instanceFeatureCounts[InstanceRange]; InstanceFeatureRanges++)
{
// Message to 'FeatureScores' from Product factor
this.FeatureScores_F[InstanceRange][InstanceFeatureRanges] = GaussianProductOp.ProductAverageConditional(this.featureValues[InstanceRange][InstanceFeatureRanges], this.Weights_FeatureIndexes_F[InstanceRange][InstanceFeatureRanges]);
}
// 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 'NoisyScore_use' from IsPositive factor
this.NoisyScore_use_B[InstanceRange] = IsPositiveOp_Proper.XAverageConditional(Bernoulli.PointMass(this.labels[InstanceRange]), this.NoisyScore_F[InstanceRange]);
// Message to 'Score' from GaussianFromMeanAndVariance factor
this.Score_B[InstanceRange] = GaussianFromMeanAndVarianceOp.MeanAverageConditional(this.NoisyScore_use_B[InstanceRange], 1.0);
// Message to 'FeatureScores' from Sum factor
this.FeatureScores_B[InstanceRange] = FastSumOp.ArrayAverageConditional <DistributionStructArray <Gaussian, double> >(this.Score_B[InstanceRange], this.Score_F[InstanceRange], this.FeatureScores_F[InstanceRange], this.FeatureScores_B[InstanceRange]);
for (int InstanceFeatureRanges = 0; InstanceFeatureRanges < this.instanceFeatureCounts[InstanceRange]; InstanceFeatureRanges++)
{
// Message to 'IndexedWeights' from Product factor
this.IndexedWeights_B[InstanceRange][InstanceFeatureRanges] = GaussianProductOp.BAverageConditional(this.FeatureScores_B[InstanceRange][InstanceFeatureRanges], this.featureValues[InstanceRange][InstanceFeatureRanges]);
}
this.Weights_uses_F_1__marginal = JaggedSubarrayOp <double> .MarginalIncrement <DistributionStructArray <Gaussian, double>, Gaussian, DistributionStructArray <Gaussian, double> >(this.Weights_uses_F_1__marginal, this.Weights_FeatureIndexes_F[InstanceRange], this.IndexedWeights_B[InstanceRange], this.featureIndexes, InstanceRange);
}
// Message to 'Weights_uses' from JaggedSubarray factor
this.Weights_uses_B[1] = JaggedSubarrayOp <double> .ArrayAverageConditional <Gaussian, DistributionStructArray <Gaussian, double>, DistributionStructArray <Gaussian, double> >(this.IndexedWeights_B, this.featureIndexes, this.Weights_uses_B[1]);
this.OnProgressChanged(new ProgressChangedEventArgs(iteration));
}
// Message to 'Weights_uses' from Replicate factor
this.Weights_uses_B_toDef = ReplicateOp_Divide.ToDef <DistributionStructArray <Gaussian, double> >(this.Weights_uses_B, this.Weights_uses_B_toDef);
// Message to 'Weights_marginal' from Variable factor
this.Weights_marginal_F = VariableOp.MarginalAverageConditional <DistributionStructArray <Gaussian, double> >(this.Weights_uses_B_toDef, this.weightPriors, this.Weights_marginal_F);
this.Changed_numberOfIterationsDecreased_WeightPriors_FeatureIndexes_InstanceCount_InstanceFeatureCounts_7_iterationsDone = numberOfIterations;
}
/// <summary>Computations that depend on the observed value of xValueCount and xValues and wPrior and xIndices</summary>
public void Changed_xValueCount_xValues_wPrior_xIndices()
{
if (this.Changed_xValueCount_xValues_wPrior_xIndices_iterationsDone == 1)
{
return;
}
for (int userFeature = 0; userFeature < this.XValueCount; userFeature++)
{
this.product_F[userFeature] = GaussianProductOp.ProductAverageConditional(this.XValues[userFeature], this.wSparse_F[userFeature]);
}
this.score_F = FastSumOp.SumAverageConditional(this.product_F);
this.Changed_xValueCount_xValues_wPrior_xIndices_iterationsDone = 1;
this.Changed_biasPrior_xValueCount_xValues_wPrior_xIndices_iterationsDone = 0;
this.Changed_y_biasPrior_xValueCount_xValues_wPrior_xIndices_iterationsDone = 0;
}
/// <summary>
/// Computes the inner product of the feature weights and values.
/// </summary>
/// <param name="weights">The feature weights.</param>
/// <param name="nonZeroValues">The sparse feature values.</param>
/// <param name="nonZeroIndices">The sparse feature indices.</param>
/// <returns>The contribution of the features.</returns>
private static Gaussian ComputeFeatureContribution(IList <Gaussian> weights, IList <double> nonZeroValues, IList <int> nonZeroIndices)
{
Debug.Assert(nonZeroValues.Count == nonZeroIndices.Count, "The number of values must be equal to the number of indices.");
int count = nonZeroValues.Count;
var nonZeroWeights = new Gaussian[count];
SubarrayOp <double> .ItemsAverageConditional(weights, nonZeroIndices, nonZeroWeights);
var products = new List <Gaussian>(count);
for (int i = 0; i < count; ++i)
{
products.Add(GaussianProductOp.ProductAverageConditional(nonZeroWeights[i], nonZeroValues[i]));
}
return(FastSumOp.SumAverageConditional(products));
}
public void GaussianProductOp_ProductPointMassTest()
{
Gaussian A = new Gaussian(1, 2);
Gaussian B = new Gaussian(3, 4);
Gaussian pointMass = Gaussian.PointMass(4);
Gaussian to_pointMass = GaussianProductOp.ProductAverageConditional(pointMass, A, B);
double prevDiff = double.PositiveInfinity;
for (int i = 0; i < 100; i++)
{
Gaussian Product = Gaussian.FromMeanAndVariance(4, System.Math.Pow(10, -i));
Gaussian to_product = GaussianProductOp.ProductAverageConditional(Product, A, B);
double evidence = GaussianProductOp.LogEvidenceRatio(Product, A, B, to_product);
Console.WriteLine($"{Product} {to_product} {evidence}");
double diff = to_product.MaxDiff(to_pointMass);
Assert.True(diff <= prevDiff || diff < 1e-6);
prevDiff = diff;
}
}
/// <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 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;
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="RatioGaussianOp"]/message_doc[@name="LogAverageFactor(double, Gaussian, double)"]/*'/>
public static double LogAverageFactor(double ratio, Gaussian a, double b)
{
Gaussian to_ratio = GaussianProductOp.AAverageConditional(a, b);
return(to_ratio.GetLogProb(ratio));
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="RatioGaussianOp"]/message_doc[@name="AAverageConditional(Gaussian, double)"]/*'/>
public static Gaussian AAverageConditional([SkipIfUniform] Gaussian ratio, double b)
{
return(GaussianProductOp.ProductAverageConditional(ratio, b));
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="RatioGaussianVmpOp"]/message_doc[@name="AAverageLogarithm(double, double)"]/*'/>
public static Gaussian AAverageLogarithm(double ratio, double B)
{
return(GaussianProductOp.ProductAverageConditional(ratio, B));
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="RatioGaussianVmpOp"]/message_doc[@name="RatioAverageLogarithm(Gaussian, double)"]/*'/>
public static Gaussian RatioAverageLogarithm([SkipIfUniform] Gaussian A, double B)
{
return(GaussianProductOp.AAverageConditional(A, B));
}
/// <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;
}
public void ProductOpTest()
{
Assert.True(GaussianProductVmpOp.ProductAverageLogarithm(
2.0,
Gaussian.FromMeanAndVariance(3.0, 5.0)).MaxDiff(Gaussian.FromMeanAndVariance(2 * 3, 4 * 5)) < 1e-8);
Assert.True(GaussianProductOp.ProductAverageConditional(
2.0,
Gaussian.FromMeanAndVariance(3.0, 5.0)).MaxDiff(Gaussian.FromMeanAndVariance(2 * 3, 4 * 5)) < 1e-8);
Assert.True(GaussianProductOp.ProductAverageConditional(new Gaussian(0, 1),
Gaussian.PointMass(2.0),
Gaussian.FromMeanAndVariance(3.0, 5.0)).MaxDiff(Gaussian.FromMeanAndVariance(2 * 3, 4 * 5)) < 1e-8);
Assert.True(GaussianProductVmpOp.ProductAverageLogarithm(
0.0,
Gaussian.FromMeanAndVariance(3.0, 5.0)).MaxDiff(Gaussian.PointMass(0.0)) < 1e-8);
Assert.True(GaussianProductOp.ProductAverageConditional(
0.0,
Gaussian.FromMeanAndVariance(3.0, 5.0)).MaxDiff(Gaussian.PointMass(0.0)) < 1e-8);
Assert.True(GaussianProductOp.ProductAverageConditional(new Gaussian(0, 1),
Gaussian.PointMass(0.0),
Gaussian.FromMeanAndVariance(3.0, 5.0)).MaxDiff(Gaussian.PointMass(0.0)) < 1e-8);
Assert.True(GaussianProductVmpOp.ProductAverageLogarithm(
Gaussian.FromMeanAndVariance(2, 4),
Gaussian.FromMeanAndVariance(3, 5)).MaxDiff(Gaussian.FromMeanAndVariance(2 * 3, 4 * 5 + 3 * 3 * 4 + 2 * 2 * 5)) < 1e-8);
Assert.True(GaussianProductOp.ProductAverageConditional(Gaussian.Uniform(),
Gaussian.FromMeanAndVariance(2, 4),
Gaussian.FromMeanAndVariance(3, 5)).MaxDiff(Gaussian.FromMeanAndVariance(2 * 3, 4 * 5 + 3 * 3 * 4 + 2 * 2 * 5)) <
1e-8);
Assert.True(GaussianProductOp.ProductAverageConditional(Gaussian.FromMeanAndVariance(0, 1e16),
Gaussian.FromMeanAndVariance(2, 4),
Gaussian.FromMeanAndVariance(3, 5)).MaxDiff(Gaussian.FromMeanAndVariance(2 * 3, 4 * 5 + 3 * 3 * 4 + 2 * 2 * 5)) <
1e-4);
Assert.True(GaussianProductOp.AAverageConditional(6.0, 2.0)
.MaxDiff(Gaussian.PointMass(6.0 / 2.0)) < 1e-8);
Assert.True(GaussianProductOp.AAverageConditional(6.0, new Gaussian(1, 3), Gaussian.PointMass(2.0))
.MaxDiff(Gaussian.PointMass(6.0 / 2.0)) < 1e-8);
Assert.True(GaussianProductOp.AAverageConditional(0.0, 0.0).IsUniform());
Assert.True(GaussianProductOp.AAverageConditional(Gaussian.Uniform(), 2.0).IsUniform());
Assert.True(GaussianProductOp.AAverageConditional(Gaussian.Uniform(), new Gaussian(1, 3), Gaussian.PointMass(2.0)).IsUniform());
Assert.True(GaussianProductOp.AAverageConditional(Gaussian.Uniform(), new Gaussian(1, 3), new Gaussian(2, 4)).IsUniform());
Gaussian aPrior = Gaussian.FromMeanAndVariance(0.0, 1000.0);
Assert.True((GaussianProductOp.AAverageConditional(
Gaussian.FromMeanAndVariance(10.0, 1.0),
aPrior,
Gaussian.FromMeanAndVariance(5.0, 1.0)) * aPrior).MaxDiff(
Gaussian.FromMeanAndVariance(2.208041421368822, 0.424566765678152)) < 1e-4);
Gaussian g = new Gaussian(0, 1);
Assert.True(GaussianProductOp.AAverageConditional(g, 0.0).IsUniform());
Assert.True(GaussianProductOp.AAverageConditional(0.0, 0.0).IsUniform());
Assert.True(GaussianProductVmpOp.AAverageLogarithm(g, 0.0).IsUniform());
Assert.True(Gaussian.PointMass(3.0).MaxDiff(GaussianProductVmpOp.AAverageLogarithm(6.0, 2.0)) < 1e-10);
Assert.True(GaussianProductVmpOp.AAverageLogarithm(0.0, 0.0).IsUniform());
try
{
Assert.True(GaussianProductVmpOp.AAverageLogarithm(6.0, g).IsUniform());
Assert.True(false, "Did not throw NotSupportedException");
}
catch (NotSupportedException)
{
}
try
{
g = GaussianProductOp.AAverageConditional(12.0, 0.0);
Assert.True(false, "Did not throw AllZeroException");
}
catch (AllZeroException)
{
}
try
{
g = GaussianProductVmpOp.AAverageLogarithm(12.0, 0.0);
Assert.True(false, "Did not throw AllZeroException");
}
catch (AllZeroException)
{
}
}
