/// <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); }