/// <summary>EP message to <c>character</c>.</summary>
/// <param name="probabilities">Incoming message from <c>probabilities</c>. Must be a proper distribution. If any element is uniform, the result will be uniform.</param>
/// <returns>The outgoing EP message to the <c>character</c> argument.</returns>
/// <remarks>
/// <para>The outgoing message is a distribution matching the moments of <c>character</c> as the random arguments are varied. The formula is <c>proj[p(character) sum_(probabilities) p(probabilities) factor(character,probabilities)]/p(character)</c>.</para>
/// </remarks>
/// <exception cref="ImproperMessageException">
/// <paramref name="probabilities" /> is not a proper distribution.</exception>
public static DiscreteChar CharacterAverageConditional([SkipIfUniform] Dirichlet probabilities)
{
Discrete resultAsDiscrete = Discrete.Uniform(probabilities.Dimension, probabilities.Sparsity);
DiscreteFromDirichletOp.SampleAverageConditional(probabilities, resultAsDiscrete);
return(DiscreteChar.FromVector(resultAsDiscrete.GetProbs()));
}
/// <summary>
/// Creates a distribution over characters that correspond to nucleobases.
/// </summary>
/// <param name="a">The probability of adenine.</param>
/// <param name="c">The probability of cytosine.</param>
/// <param name="g">The probability of guanine.</param>
/// <param name="t">The probability of thymine.</param>
/// <returns>The created distribution.</returns>
private static DiscreteChar NucleobaseDist(double a, double c, double g, double t)
{
Vector probs = PiecewiseVector.Zero(char.MaxValue + 1);
probs['A'] = a;
probs['C'] = c;
probs['G'] = g;
probs['T'] = t;
return(DiscreteChar.FromVector(probs));
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="SingleOp"]/message_doc[@name="CharacterAverageConditional(StringDistribution)"]/*'/>
public static DiscreteChar CharacterAverageConditional(StringDistribution str)
{
Argument.CheckIfNotNull(str, "str");
if (str.IsPointMass)
{
return(CharacterAverageConditional(str.Point));
}
Vector resultLogProb = PiecewiseVector.Constant(char.MaxValue + 1, double.NegativeInfinity);
StringAutomaton probFunc = str.GetWorkspaceOrPoint();
StringAutomaton.EpsilonClosure startEpsilonClosure = new Automaton <string, char, DiscreteChar, StringManipulator, StringAutomaton> .EpsilonClosure(probFunc, probFunc.Start);
for (int stateIndex = 0; stateIndex < startEpsilonClosure.Size; ++stateIndex)
{
StringAutomaton.State state = startEpsilonClosure.GetStateByIndex(stateIndex);
Weight stateLogWeight = startEpsilonClosure.GetStateWeightByIndex(stateIndex);
foreach (var transition in state.Transitions)
{
if (!transition.IsEpsilon)
{
StringAutomaton.State destState = probFunc.States[transition.DestinationStateIndex];
StringAutomaton.EpsilonClosure destStateClosure = new Automaton <string, char, DiscreteChar, StringManipulator, StringAutomaton> .EpsilonClosure(probFunc, destState);
if (!destStateClosure.EndWeight.IsZero)
{
Weight weight = Weight.Product(stateLogWeight, transition.Weight, destStateClosure.EndWeight);
var logProbs = transition.ElementDistribution.Value.GetProbs();
logProbs.SetToFunction(logProbs, Math.Log);
resultLogProb = LogSumExp(resultLogProb, logProbs, weight);
}
}
}
}
if (resultLogProb.All(double.IsNegativeInfinity))
{
throw new AllZeroException("An input distribution assigns zero probability to all single character strings.");
}
Vector resultProb = PiecewiseVector.Zero(char.MaxValue + 1);
double logNormalizer = resultLogProb.LogSumExp();
resultProb.SetToFunction(resultLogProb, lp => Math.Exp(lp - logNormalizer));
return(DiscreteChar.FromVector(resultProb));
}
public void UniformOf()
{
var unif1 = StringDistribution.ZeroOrMore(DiscreteChar.Lower());
Assert.False(unif1.IsUniform());
Assert.False(unif1.IsProper());
StringInferenceTestUtilities.TestProbability(unif1, 1.0, "hello", "a", string.Empty);
StringInferenceTestUtilities.TestProbability(unif1, 0.0, "123", "!", "Abc");
// Test if non-uniform element distribution does not affect the outcome
Vector probs = DiscreteChar.Digit().GetProbs();
probs['1'] = 0;
probs['2'] = 0.3;
probs['3'] = 0.0001;
var unif2 = StringDistribution.ZeroOrMore(DiscreteChar.FromVector(probs));
StringInferenceTestUtilities.TestProbability(unif2, 1.0, "0", "234", string.Empty);
StringInferenceTestUtilities.TestProbability(unif2, 0.0, "1", "231", "!", "Abc");
}
public void Char()
{
var charDist1 = StringDistribution.Char('a');
StringInferenceTestUtilities.TestProbability(charDist1, 1.0, "a");
StringInferenceTestUtilities.TestProbability(charDist1, 0.0, "aa", string.Empty);
var charDist2 = StringDistribution.Char(DiscreteChar.InRange('a', 'c'));
StringInferenceTestUtilities.TestProbability(charDist2, 1.0 / 3.0, "a", "b", "c");
StringInferenceTestUtilities.TestProbability(charDist2, 0.0, "ab", string.Empty);
Vector charProbs3 = PiecewiseVector.Zero(char.MaxValue + 1);
charProbs3['a'] = 0.1;
charProbs3['b'] = 0.9;
var charDist3 = StringDistribution.SingleElement(DiscreteChar.FromVector(charProbs3));
StringInferenceTestUtilities.TestProbability(charDist3, 0.1, "a");
StringInferenceTestUtilities.TestProbability(charDist3, 0.9, "b");
StringInferenceTestUtilities.TestProbability(charDist3, 0.0, "c", "ab", string.Empty);
}
/// <summary>EP message to <c>character</c>.</summary>
/// <param name="str">Incoming message from <c>str</c>.</param>
/// <returns>The outgoing EP message to the <c>character</c> argument.</returns>
/// <remarks>
/// <para>The outgoing message is a distribution matching the moments of <c>character</c> as the random arguments are varied. The formula is <c>proj[p(character) sum_(str) p(str) factor(character,str)]/p(character)</c>.</para>
/// </remarks>
public static DiscreteChar CharacterAverageConditional(StringDistribution str)
{
Argument.CheckIfNotNull(str, "str");
Vector resultlogProb = PiecewiseVector.Constant(char.MaxValue + 1, double.NegativeInfinity);
StringAutomaton probFunc = str.GetProbabilityFunction();
StringAutomaton.EpsilonClosure startEpsilonClosure = probFunc.Start.GetEpsilonClosure();
for (int stateIndex = 0; stateIndex < startEpsilonClosure.Size; ++stateIndex)
{
StringAutomaton.State state = startEpsilonClosure.GetStateByIndex(stateIndex);
double stateLogWeight = startEpsilonClosure.GetStateLogWeightByIndex(stateIndex);
for (int transitionIndex = 0; transitionIndex < state.Transitions.Count; ++transitionIndex)
{
StringAutomaton.Transition transition = state.Transitions[transitionIndex];
if (!transition.IsEpsilon)
{
StringAutomaton.State destState = probFunc.States[transition.DestinationStateIndex];
StringAutomaton.EpsilonClosure destStateClosure = destState.GetEpsilonClosure();
if (!double.IsNegativeInfinity(destStateClosure.EndLogWeight))
{
double logWeight = stateLogWeight + transition.LogWeight + destStateClosure.EndLogWeight;
resultlogProb = LogSumExp(resultlogProb, transition.ElementDistribution.GetInternalDiscrete().GetLogProbs(), logWeight);
}
}
}
}
if (resultlogProb.All(double.IsNegativeInfinity))
{
throw new AllZeroException("An input distribution assigns zero probability to all single character strings.");
}
Vector resultProb = PiecewiseVector.Zero(char.MaxValue + 1);
resultProb.SetToFunction(resultlogProb, Math.Exp);
return(DiscreteChar.FromVector(resultProb));
}
public static char Char(Vector probabilities)
{
return(DiscreteChar.FromVector(probabilities).Sample());
}