/// <summary>
/// Evidence message for EP
/// </summary>
/// <param name="isPositive">Incoming message from 'isPositive'.</param>
/// <param name="x">Incoming message from 'x'.</param>
/// <returns>Logarithm of the factor's average value across the given argument distributions</returns>
/// <remarks><para>
/// The formula for the result is <c>log(sum_(isPositive,x) p(isPositive,x) factor(isPositive,x))</c>.
/// </para></remarks>
public static double LogAverageFactor(Bernoulli isPositive, Gaussian x)
{
Bernoulli to_isPositive = IsPositiveAverageConditional(x);
return(isPositive.GetLogAverageOf(to_isPositive));
#if false
// Z = p(b=T) p(x > 0) + p(b=F) p(x <= 0)
// = p(b=F) + (p(b=T) - p(b=F)) p(x > 0)
if (x.IsPointMass)
{
return(Factor.IsPositive(x.Point) ? isPositive.GetLogProbTrue() : isPositive.GetLogProbFalse());
}
else if (x.IsUniform())
{
return(Bernoulli.LogProbEqual(isPositive.LogOdds, 0.0));
}
else
{
// m/sqrt(v) = (m/v)/sqrt(1/v)
double z = x.MeanTimesPrecision / Math.Sqrt(x.Precision);
if (isPositive.IsPointMass)
{
return(isPositive.Point ? MMath.NormalCdfLn(z) : MMath.NormalCdfLn(-z));
}
else
{
return(MMath.LogSumExp(isPositive.GetLogProbTrue() + MMath.NormalCdfLn(z), isPositive.GetLogProbFalse() + MMath.NormalCdfLn(-z)));
}
}
#endif
}
/// <summary>
/// Evidence message for EP
/// </summary>
/// <param name="isPositive">Incoming message from 'isPositive'.</param>
/// <param name="x">Incoming message from 'x'.</param>
/// <returns>Logarithm of the factor's average value across the given argument distributions</returns>
/// <remarks><para>
/// The formula for the result is <c>log(sum_(isPositive,x) p(isPositive,x) factor(isPositive,x))</c>.
/// </para></remarks>
public static double LogAverageFactor(Bernoulli isPositive, Gaussian x)
{
if (isPositive.IsPointMass && x.Precision == 0) {
double tau = x.MeanTimesPrecision;
if (isPositive.Point && tau < 0) {
// int I(x>0) exp(tau*x) dx = -1/tau
return -Math.Log(-tau);
}
if (!isPositive.Point && tau > 0) {
// int I(x<0) exp(tau*x) dx = 1/tau
return -Math.Log(tau);
}
}
Bernoulli to_isPositive = IsPositiveAverageConditional(x);
return isPositive.GetLogAverageOf(to_isPositive);
}
/// <summary>Evidence message for EP.</summary>
/// <param name="isPositive">Incoming message from <c>isPositive</c>.</param>
/// <param name="x">Incoming message from <c>x</c>.</param>
/// <returns>Logarithm of the factor's average value across the given argument distributions.</returns>
/// <remarks>
/// <para>The formula for the result is <c>log(sum_(isPositive,x) p(isPositive,x) factor(isPositive,x))</c>.</para>
/// </remarks>
public static double LogAverageFactor(Bernoulli isPositive, Gaussian x)
{
if (isPositive.IsPointMass && x.Precision == 0)
{
double tau = x.MeanTimesPrecision;
if (isPositive.Point && tau < 0)
{
// int I(x>0) exp(tau*x) dx = -1/tau
return(-Math.Log(-tau));
}
if (!isPositive.Point && tau > 0)
{
// int I(x<0) exp(tau*x) dx = 1/tau
return(-Math.Log(tau));
}
}
Bernoulli to_isPositive = IsPositiveAverageConditional(x);
return(isPositive.GetLogAverageOf(to_isPositive));
}
/// <summary>
/// Evidence message for EP
/// </summary>
/// <param name="isPositive">Incoming message from 'isPositive'.</param>
/// <param name="x">Incoming message from 'x'.</param>
/// <returns>Logarithm of the factor's average value across the given argument distributions</returns>
/// <remarks><para>
/// The formula for the result is <c>log(sum_(isPositive,x) p(isPositive,x) factor(isPositive,x))</c>.
/// </para></remarks>
public static double LogAverageFactor(Bernoulli isPositive, Gaussian x)
{
Bernoulli to_isPositive = IsPositiveAverageConditional(x);
return isPositive.GetLogAverageOf(to_isPositive);
#if false
// Z = p(b=T) p(x > 0) + p(b=F) p(x <= 0)
// = p(b=F) + (p(b=T) - p(b=F)) p(x > 0)
if (x.IsPointMass) {
return Factor.IsPositive(x.Point) ? isPositive.GetLogProbTrue() : isPositive.GetLogProbFalse();
} else if(x.IsUniform()) {
return Bernoulli.LogProbEqual(isPositive.LogOdds,0.0);
} else {
// m/sqrt(v) = (m/v)/sqrt(1/v)
double z = x.MeanTimesPrecision / Math.Sqrt(x.Precision);
if (isPositive.IsPointMass) {
return isPositive.Point ? MMath.NormalCdfLn(z) : MMath.NormalCdfLn(-z);
} else {
return MMath.LogSumExp(isPositive.GetLogProbTrue() + MMath.NormalCdfLn(z), isPositive.GetLogProbFalse() + MMath.NormalCdfLn(-z));
}
}
#endif
}
/// <summary>
/// Evidence message for EP
/// </summary>
/// <param name="sample">Incoming message from 'sample'.</param>
/// <param name="to_sample">Outgoing message to 'sample'.</param>
/// <returns>Logarithm of the factor's average value across the given argument distributions</returns>
/// <remarks><para>
/// The formula for the result is <c>log(sum_(sample) p(sample) factor(sample,probTrue))</c>.
/// </para></remarks>
public static double LogAverageFactor(Bernoulli sample, [Fresh] Bernoulli to_sample)
{
return sample.GetLogAverageOf(to_sample);
}
/// <summary>
/// Evidence message for EP.
/// </summary>
/// <param name="and">Incoming message from 'and'.</param>
/// <param name="a">Incoming message from 'a'.</param>
/// <param name="b">Constant value for 'b'.</param>
/// <returns>Logarithm of the factor's average value across the given argument distributions.</returns>
/// <remarks><para>
/// The formula for the result is <c>log(sum_(and,a) p(and,a) factor(and,a,b))</c>.
/// </para></remarks>
public static double LogAverageFactor(Bernoulli and, Bernoulli a, bool b)
{
Bernoulli to_and = AndAverageConditional(a, b);
return(to_and.GetLogAverageOf(and));
}
/// <summary>Evidence message for EP.</summary>
/// <param name="or">Incoming message from <c>or</c>.</param>
/// <param name="to_or">Outgoing message to <c>or</c>.</param>
/// <returns>Logarithm of the factor's average value across the given argument distributions.</returns>
/// <remarks>
/// <para>The formula for the result is <c>log(sum_(or) p(or) factor(or,a,b))</c>.</para>
/// </remarks>
public static double LogAverageFactor(Bernoulli or, [Fresh] Bernoulli to_or)
{
return(to_or.GetLogAverageOf(or));
}
/// <summary>
/// Evidence message for EP
/// </summary>
/// <param name="isGreaterThan">Incoming message from 'isGreaterThan'.</param>
/// <param name="a">Incoming message from 'a'.</param>
/// <param name="to_isGreaterThan">Outgoing message to 'isGreaterThan'.</param>
/// <returns>Logarithm of the factor's average value across the given argument distributions</returns>
/// <remarks><para>
/// The formula for the result is <c>log(sum_(isGreaterThan,a) p(isGreaterThan,a) factor(isGreaterThan,a,b))</c>.
/// </para></remarks>
public static double LogAverageFactor(Bernoulli isGreaterThan, Discrete a, [Fresh] Bernoulli to_isGreaterThan)
{
return(to_isGreaterThan.GetLogAverageOf(isGreaterThan));
}
/// <summary>
/// Evidence message for EP
/// </summary>
/// <param name="allTrue">Incoming message from 'allTrue'. Must be a proper distribution. If uniform, the result will be uniform.</param>
/// <param name="to_allTrue">Outgoing message to 'allTrue'.</param>
/// <returns>Logarithm of the factor's average value across the given argument distributions</returns>
/// <remarks><para>
/// The formula for the result is <c>log(sum_(allTrue) p(allTrue) factor(allTrue,array))</c>.
/// </para></remarks>
/// <exception cref="ImproperMessageException"><paramref name="allTrue"/> is not a proper distribution</exception>
public static double LogAverageFactor([SkipIfUniform] Bernoulli allTrue, [Fresh] Bernoulli to_allTrue)
{
return(to_allTrue.GetLogAverageOf(allTrue));
}
/// <summary>
/// Evidence message for EP
/// </summary>
/// <param name="not">Incoming message from 'not'.</param>
/// <param name="b">Incoming message from 'b'.</param>
/// <param name="to_not">Outgoing message to 'not'.</param>
/// <returns>Logarithm of the factor's average value across the given argument distributions</returns>
/// <remarks><para>
/// The formula for the result is <c>log(sum_(not,b) p(not,b) factor(not,b))</c>.
/// </para></remarks>
public static double LogAverageFactor(Bernoulli not, Bernoulli b, [Fresh] Bernoulli to_not)
{
return(to_not.GetLogAverageOf(not));
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="DiscreteAreEqualOp"]/message_doc[@name="LogAverageFactor(Bernoulli, Bernoulli)"]/*'/>
public static double LogAverageFactor(Bernoulli areEqual, [Fresh] Bernoulli to_areEqual)
{
return(to_areEqual.GetLogAverageOf(areEqual));
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="BooleanAreEqualOp"]/message_doc[@name="LogAverageFactor(bool, Bernoulli, bool, Bernoulli)"]/*'/>
public static double LogAverageFactor(bool areEqual, Bernoulli A, bool B, [Fresh] Bernoulli to_A)
{
//Bernoulli toA = AAverageConditional(areEqual, B);
return(A.GetLogAverageOf(to_A));
}
/// <summary>
/// Evidence message for EP
/// </summary>
/// <param name="areEqual">Constant value for 'areEqual'.</param>
/// <param name="A">Incoming message from 'a'.</param>
/// <param name="B">Constant value for 'b'.</param>
/// <param name="to_A">Outgoing message to 'a'.</param>
/// <returns>Logarithm of the factor's average value across the given argument distributions</returns>
/// <remarks><para>
/// The formula for the result is <c>log(sum_(a) p(a) factor(areEqual,a,b))</c>.
/// </para></remarks>
public static double LogAverageFactor(bool areEqual, Bernoulli A, bool B, [Fresh] Bernoulli to_A)
{
//Bernoulli toA = AAverageConditional(areEqual, B);
return A.GetLogAverageOf(to_A);
}
/// <summary>Evidence message for EP.</summary>
/// <param name="sample">Incoming message from <c>sample</c>.</param>
/// <param name="to_sample">Outgoing message to <c>sample</c>.</param>
/// <returns>Logarithm of the factor's average value across the given argument distributions.</returns>
/// <remarks>
/// <para>The formula for the result is <c>log(sum_(sample) p(sample) factor(sample,probTrue))</c>.</para>
/// </remarks>
public static double LogAverageFactor(Bernoulli sample, [Fresh] Bernoulli to_sample)
{
return(sample.GetLogAverageOf(to_sample));
}
public static double LogEvidenceRatio(
Bernoulli label, Bernoulli to_label, Vector point, GaussianGamma shapeParamsX, GaussianGamma shapeParamsY)
{
return LogAverageFactor(label, point, shapeParamsX, shapeParamsY) - label.GetLogAverageOf(to_label);
}
public static double LogEvidenceRatio(
Bernoulli label, Bernoulli to_label, Vector point, Gaussian shapeX, Gaussian shapeY, PositiveDefiniteMatrix shapeOrientation)
{
return LogAverageFactor(label, point, shapeX, shapeY, shapeOrientation) - label.GetLogAverageOf(to_label);
}