/// <summary>Gibbs message to <c>choice</c>.</summary> /// <param name="sample">Constant value for <c>sample</c>.</param> /// <param name="probTrue0">Constant value for <c>probTrue0</c>.</param> /// <param name="probTrue1">Constant value for <c>probTrue1</c>.</param> /// <returns>The outgoing Gibbs message to the <c>choice</c> argument.</returns> /// <remarks> /// <para>The outgoing message is the factor viewed as a function of <c>choice</c> conditioned on the given values.</para> /// </remarks> public static Bernoulli ChoiceConditional(bool sample, double probTrue0, double probTrue1) { Bernoulli result = new Bernoulli(); if (probTrue0 == 0 || probTrue1 == 0) { throw new ArgumentException("probTrue is zero"); } if (sample) { double sum = probTrue0 + probTrue1; if (sum == 0.0) { throw new AllZeroException(); } else { result.SetProbTrue(probTrue1 / sum); } } else { double sum = 2 - probTrue1 - probTrue0; if (sum == 0.0) { throw new AllZeroException(); } else { result.SetProbTrue((1 - probTrue1) / sum); } } return(result); }
/// <summary> /// Gibbs message to 'sample'. /// </summary> /// <param name="index">Constant value for 'index'.</param> /// <param name="ProbTrue">Constant value for 'probTrue'.</param> /// <returns>The outgoing Gibbs message to the 'sample' argument.</returns> /// <remarks><para> /// The outgoing message is the factor viewed as a function of 'sample' conditioned on the given values. /// </para></remarks> public static Bernoulli SampleConditional(int index, double[] ProbTrue) { Bernoulli result = new Bernoulli(); result.SetProbTrue(ProbTrue[index]); return(result); }
/// <summary>Gibbs message to <c>sample</c>.</summary> /// <param name="choice">Constant value for <c>choice</c>.</param> /// <param name="probTrue0">Constant value for <c>probTrue0</c>.</param> /// <param name="probTrue1">Constant value for <c>probTrue1</c>.</param> /// <returns>The outgoing Gibbs message to the <c>sample</c> argument.</returns> /// <remarks> /// <para>The outgoing message is the factor viewed as a function of <c>sample</c> conditioned on the given values.</para> /// </remarks> public static Bernoulli SampleConditional(bool choice, double probTrue0, double probTrue1) { Bernoulli result = new Bernoulli(); result.SetProbTrue(choice ? probTrue1 : probTrue0); return(result); }
/// <summary>EP message to <c>sample</c>.</summary> /// <param name="choice">Incoming message from <c>choice</c>.</param> /// <param name="probTrue0">Constant value for <c>probTrue0</c>.</param> /// <param name="probTrue1">Constant value for <c>probTrue1</c>.</param> /// <returns>The outgoing EP message to the <c>sample</c> argument.</returns> /// <remarks> /// <para>The outgoing message is a distribution matching the moments of <c>sample</c> as the random arguments are varied. The formula is <c>proj[p(sample) sum_(choice) p(choice) factor(sample,choice,probTrue0,probTrue1)]/p(sample)</c>.</para> /// </remarks> public static Bernoulli SampleAverageConditional(Bernoulli choice, double probTrue0, double probTrue1) { Bernoulli result = new Bernoulli(); if (choice.IsPointMass) { return(SampleConditional(choice.Point, probTrue0, probTrue1)); } #if FAST result.SetProbTrue(choice.GetProbFalse() * probTrue0 + choice.GetProbTrue() * probTrue1); #else // This method is more numerically stable but slower. // let oX = log(p(X)/(1-p(X)) // let oY = log(p(Y)/(1-p(Y)) // oX = log( (TT*sigma(oY) + TF*sigma(-oY))/(FT*sigma(oY) + FF*sigma(-oY)) ) // = log( (TT*exp(oY) + TF)/(FT*exp(oY) + FF) ) // = log( (exp(oY) + TF/TT)/(exp(oY) + FF/FT) ) + log(TT/FT) // ay = log(TF/TT) // by = log(FF/FT) // offset = log(TT/FT) if (probTrue0 == 0 || probTrue1 == 0) { throw new ArgumentException("probTrue is zero"); } double ay = Math.Log(probTrue0 / probTrue1); double by = Math.Log((1 - probTrue0) / (1 - probTrue1)); double offset = MMath.Logit(probTrue1); result.LogOdds = MMath.DiffLogSumExp(choice.LogOdds, ay, by) + offset; #endif return(result); }
/// <summary> /// EP message to 'sample'. /// </summary> /// <param name="index">Incoming message from 'index'.</param> /// <param name="ProbTrue">Constant value for 'probTrue'.</param> /// <returns>The outgoing EP message to the 'sample' argument.</returns> /// <remarks><para> /// The outgoing message is the integral of the factor times incoming messages, over all arguments except 'sample'. /// The formula is <c>int f(sample,x) q(x) dx</c> where <c>x = (index,probTrue)</c>. /// </para></remarks> public static Bernoulli SampleAverageConditional(Discrete index, double[] ProbTrue) { Bernoulli result = new Bernoulli(); // E[X] = sum_Y p(Y) ProbTrue[Y] double p = 0; for (int i = 0; i < index.Dimension; i++) { p += ProbTrue[i] * index[i]; } result.SetProbTrue(p); return(result); }
/// <summary> /// Gibbs message to 'choice'. /// </summary> /// <param name="sample">Constant value for 'sample'.</param> /// <param name="probTrue0">Constant value for 'probTrue0'.</param> /// <param name="probTrue1">Constant value for 'probTrue1'.</param> /// <returns>The outgoing Gibbs message to the 'choice' argument.</returns> /// <remarks><para> /// The outgoing message is the factor viewed as a function of 'choice' conditioned on the given values. /// </para></remarks> public static Bernoulli ChoiceConditional(bool sample, double probTrue0, double probTrue1) { Bernoulli result = new Bernoulli(); if (probTrue0 == 0 || probTrue1 == 0) throw new ArgumentException("probTrue is zero"); if (sample) { double sum = probTrue0 + probTrue1; if(sum == 0.0) throw new AllZeroException(); else result.SetProbTrue(probTrue1 / sum); } else { double sum = 2 - probTrue1 - probTrue0; if(sum == 0.0) throw new AllZeroException(); else result.SetProbTrue((1 - probTrue1) / sum); } return result; }
/// <summary>EP message to <c>choice</c>.</summary> /// <param name="sample">Incoming message from <c>sample</c>. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="probTrue0">Constant value for <c>probTrue0</c>.</param> /// <param name="probTrue1">Constant value for <c>probTrue1</c>.</param> /// <returns>The outgoing EP message to the <c>choice</c> argument.</returns> /// <remarks> /// <para>The outgoing message is a distribution matching the moments of <c>choice</c> as the random arguments are varied. The formula is <c>proj[p(choice) sum_(sample) p(sample) factor(sample,choice,probTrue0,probTrue1)]/p(choice)</c>.</para> /// </remarks> /// <exception cref="ImproperMessageException"> /// <paramref name="sample" /> is not a proper distribution.</exception> public static Bernoulli ChoiceAverageConditional([SkipIfUniform] Bernoulli sample, double probTrue0, double probTrue1) { Bernoulli result = new Bernoulli(); if (sample.IsPointMass) { return(ChoiceConditional(sample.Point, probTrue0, probTrue1)); } #if FAST double p1 = sample.GetProbFalse() * (1 - probTrue1) + sample.GetProbTrue() * probTrue1; double p0 = sample.GetProbFalse() * (1 - probTrue0) + sample.GetProbTrue() * probTrue0; double sum = p0 + p1; if (sum == 0.0) { throw new AllZeroException(); } else { result.SetProbTrue(p1 / sum); } #else // This method is more numerically stable but slower. // ax = log(FT/TT) // bx = log(FF/TF) // offset = log(TT/TF) if (probTrue0 == 0 || probTrue1 == 0) { throw new ArgumentException("probTrue is zero"); } double ax = -MMath.Logit(probTrue1); double bx = -MMath.Logit(probTrue0); double offset = Math.Log(probTrue1 / probTrue0); result.LogOdds = MMath.DiffLogSumExp(sample.LogOdds, ax, bx) + offset; #endif return(result); }
/// <summary> /// Gibbs message to 'sample'. /// </summary> /// <param name="choice">Constant value for 'choice'.</param> /// <param name="probTrue0">Constant value for 'probTrue0'.</param> /// <param name="probTrue1">Constant value for 'probTrue1'.</param> /// <returns>The outgoing Gibbs message to the 'sample' argument.</returns> /// <remarks><para> /// The outgoing message is the factor viewed as a function of 'sample' conditioned on the given values. /// </para></remarks> public static Bernoulli SampleConditional(bool choice, double probTrue0, double probTrue1) { Bernoulli result = new Bernoulli(); result.SetProbTrue(choice ? probTrue1 : probTrue0); return result; }
/// <summary> /// EP message to 'choice'. /// </summary> /// <param name="sample">Incoming message from 'sample'. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="probTrue0">Constant value for 'probTrue0'.</param> /// <param name="probTrue1">Constant value for 'probTrue1'.</param> /// <returns>The outgoing EP message to the 'choice' argument.</returns> /// <remarks><para> /// The outgoing message is the integral of the factor times incoming messages, over all arguments except 'choice'. /// The formula is <c>int f(choice,x) q(x) dx</c> where <c>x = (sample,probTrue0,probTrue1)</c>. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="sample"/> is not a proper distribution</exception> public static Bernoulli ChoiceAverageConditional([SkipIfUniform] Bernoulli sample, double probTrue0, double probTrue1) { Bernoulli result = new Bernoulli(); if(sample.IsPointMass) return ChoiceConditional(sample.Point,probTrue0,probTrue1); #if FAST double p1 = sample.GetProbFalse() * (1 - probTrue1) + sample.GetProbTrue() * probTrue1; double p0 = sample.GetProbFalse() * (1 - probTrue0) + sample.GetProbTrue() * probTrue0; double sum = p0+p1; if(sum == 0.0) throw new AllZeroException(); else result.SetProbTrue(p1 / sum); #else // This method is more numerically stable but slower. // ax = log(FT/TT) // bx = log(FF/TF) // offset = log(TT/TF) if (probTrue0 == 0 || probTrue1 == 0) throw new ArgumentException("probTrue is zero"); double ax = -MMath.Logit(probTrue1); double bx = -MMath.Logit(probTrue0); double offset = Math.Log(probTrue1 / probTrue0); result.LogOdds = MMath.DiffLogSumExp(sample.LogOdds, ax, bx) + offset; #endif return result; }
/// <summary> /// EP message to 'sample'. /// </summary> /// <param name="choice">Incoming message from 'choice'.</param> /// <param name="probTrue0">Constant value for 'probTrue0'.</param> /// <param name="probTrue1">Constant value for 'probTrue1'.</param> /// <returns>The outgoing EP message to the 'sample' argument.</returns> /// <remarks><para> /// The outgoing message is the integral of the factor times incoming messages, over all arguments except 'sample'. /// The formula is <c>int f(sample,x) q(x) dx</c> where <c>x = (choice,probTrue0,probTrue1)</c>. /// </para></remarks> public static Bernoulli SampleAverageConditional(Bernoulli choice, double probTrue0, double probTrue1) { Bernoulli result = new Bernoulli(); if(choice.IsPointMass) return SampleConditional(choice.Point,probTrue0,probTrue1); #if FAST result.SetProbTrue(choice.GetProbFalse() * probTrue0 + choice.GetProbTrue() * probTrue1); #else // This method is more numerically stable but slower. // let oX = log(p(X)/(1-p(X)) // let oY = log(p(Y)/(1-p(Y)) // oX = log( (TT*sigma(oY) + TF*sigma(-oY))/(FT*sigma(oY) + FF*sigma(-oY)) ) // = log( (TT*exp(oY) + TF)/(FT*exp(oY) + FF) ) // = log( (exp(oY) + TF/TT)/(exp(oY) + FF/FT) ) + log(TT/FT) // ay = log(TF/TT) // by = log(FF/FT) // offset = log(TT/FT) if (probTrue0 == 0 || probTrue1 == 0) throw new ArgumentException("probTrue is zero"); double ay = Math.Log(probTrue0 / probTrue1); double by = Math.Log((1 - probTrue0) / (1 - probTrue1)); double offset = MMath.Logit(probTrue1); result.LogOdds = MMath.DiffLogSumExp(choice.LogOdds, ay, by) + offset; #endif return result; }
/// <summary> /// Gibbs message to 'sample'. /// </summary> /// <param name="index">Constant value for 'index'.</param> /// <param name="ProbTrue">Constant value for 'probTrue'.</param> /// <returns>The outgoing Gibbs message to the 'sample' argument.</returns> /// <remarks><para> /// The outgoing message is the factor viewed as a function of 'sample' conditioned on the given values. /// </para></remarks> public static Bernoulli SampleConditional(int index, double[] ProbTrue) { Bernoulli result = new Bernoulli(); result.SetProbTrue(ProbTrue[index]); return result; }
/// <summary> /// EP message to 'sample'. /// </summary> /// <param name="index">Incoming message from 'index'.</param> /// <param name="ProbTrue">Constant value for 'probTrue'.</param> /// <returns>The outgoing EP message to the 'sample' argument.</returns> /// <remarks><para> /// The outgoing message is the integral of the factor times incoming messages, over all arguments except 'sample'. /// The formula is <c>int f(sample,x) q(x) dx</c> where <c>x = (index,probTrue)</c>. /// </para></remarks> public static Bernoulli SampleAverageConditional(Discrete index, double[] ProbTrue) { Bernoulli result = new Bernoulli(); // E[X] = sum_Y p(Y) ProbTrue[Y] double p = 0; for (int i = 0; i < index.Dimension; i++) { p += ProbTrue[i] * index[i]; } result.SetProbTrue(p); return result; }