public Factor getFactorFor(params AssignmentProposition[] evidence) { Set <RandomVariable> fofVars = new Set <RandomVariable>( table.getFor()); foreach (AssignmentProposition ap in evidence) { fofVars.Remove(ap.getTermVariable()); } ProbabilityTable fof = new ProbabilityTable(new List <RandomVariable>(fofVars)); // Otherwise need to iterate through the table for the // non evidence variables. Object[] termValues = new Object[fofVars.Count]; //ProbabilityTable.Iterator di = new ProbabilityTable.Iterator() { // public void iterate(Map<RandomVariable, Object> possibleWorld, // double probability) { // if (0 == termValues.length) { // fof.getValues()[0] += probability; // } else { // int i = 0; // for (RandomVariable rv : fof.getFor()) { // termValues[i] = possibleWorld.get(rv); // i++; // } // fof.getValues()[fof.getIndex(termValues)] += probability; // } // } //}; //table.iterateOverTable(di, evidence); // TODO: another screwed up iterator return(fof); }
public CategoricalDistribution getConditioningCase( params AssignmentProposition[] parentValues) { if (parentValues.Length != parents.Count) { throw new ArgumentException( "The number of parent value arguments [" + parentValues.Length + "] is not equal to the number of parents [" + parents.Count + "] for this CPT."); } ProbabilityTable cc = new ProbabilityTable(getOn()); //ProbabilityTable.Iterator pti = new ProbabilityTable.Iterator() { // private int idx = 0; // public void iterate(Map<RandomVariable, Object> possibleAssignment, // double probability) { // cc.getValues()[idx] = probability; // idx++; // } //}; //table.iterateOverTable(pti, parentValues); // TODO: this is screwed up return(cc); }
public ProbabilityTableIterator(IProposition conjProp, ProbabilityTable ud, object[] values, ISet <IRandomVariable> vars) { this.conjProp = conjProp; this.ud = ud; this.values = values; this.vars = vars; }
internal CharacterProbabilisticSuggestionCollection(string text, int selection) : this() { Debug.Assert(text != null); Debug.Assert(0 <= selection); Debug.Assert(selection <= text.Length); var wordLength = text.ReverseWordLength(selection); if (0 < wordLength && wordLength < ProbabilityTable.MAX_WORD_LEN) { for (var ch = 'a'; ch <= 'z'; ch++) { var probability = ProbabilityTable.GetProbability(wordLength, char.ToLower(text[selection - 1]), ch); suggestions[ch - 'a'] = new CharacterSuggestion(ch, probability); } } else { for (var ch = 'a'; ch <= 'z'; ch++) { var probability = ProbabilityTable.GetProbability(0, ProbabilityTable.WordBeginChar, ch); suggestions[ch - 'a'] = new CharacterSuggestion(ch, probability); } } }
public ICategoricalDistribution jointDistribution(params IProposition[] propositions) { ProbabilityTable d = null; IProposition conjProp = ProbUtil.constructConjunction(propositions); ISet <IRandomVariable> vars = CollectionFactory.CreateSet <IRandomVariable>(conjProp.getUnboundScope()); if (vars.Size() > 0) { IRandomVariable[] distVars = vars.ToArray(); ProbabilityTable ud = new ProbabilityTable(distVars); object[] values = new object[vars.Size()]; ProbabilityTable.ProbabilityTableIterator di = new ProbabilityTableIterator(conjProp, ud, values, vars); distribution.iterateOverTable(di); d = ud; } else { // No Unbound Variables, therefore just return // the singular probability related to the proposition. d = new ProbabilityTable(); d.setValue(0, prior(propositions)); } return(d); }
public void test_pointwiseProduct() { IRandomVariable xRV = new RandVar("X", new BooleanDomain()); IRandomVariable yRV = new RandVar("Y", new BooleanDomain()); IRandomVariable zRV = new RandVar("Z", new BooleanDomain()); ProbabilityTable xyD = new ProbabilityTable(new double[] { // X = true, Y = true 1.0, // X = true, Y = false 2.0, // X = false, Y = true 3.0, // X = false, Y = false 4.0 }, xRV, yRV); ProbabilityTable zD = new ProbabilityTable(new double[] { 3.0, 7.0 }, zRV); // Not commutative assertArrayEquals(new double[] { 3.0, 7.0, 6.0, 14.0, 9.0, 21.0, 12.0, 28.0 }, xyD.pointwiseProduct(zD).getValues(), DELTA_THRESHOLD); assertArrayEquals(new double[] { 3.0, 6.0, 9.0, 12.0, 7.0, 14.0, 21.0, 28.0 }, zD.pointwiseProduct(xyD).getValues(), DELTA_THRESHOLD); }
public CategoricalDistributionIteratorJointDistribution(IProposition conjProp, ISet <IRandomVariable> vars, ProbabilityTable ud, object[] values) { this.conjProp = conjProp; this.vars = vars; this.ud = ud; this.values = values; }
protected void testForwardStep_UmbrellaWorld(IForwardStepInference uw) { // AIMA3e pg. 572 // Day 0, no observations only the security guards prior beliefs // P(R<sub>0</sub>) = <0.5, 0.5> ICategoricalDistribution prior = new ProbabilityTable(new double[] { 0.5, 0.5 }, ExampleRV.RAIN_t_RV); // Day 1, the umbrella appears, so U<sub>1</sub> = true. // ≈ <0.818, 0.182> ICollection <AssignmentProposition> e1 = CollectionFactory.CreateQueue <AssignmentProposition>(); e1.Add(new AssignmentProposition(ExampleRV.UMBREALLA_t_RV, true)); ICategoricalDistribution f1 = uw.forward(prior, e1); assertArrayEquals(new double[] { 0.818, 0.182 }, f1.getValues(), DELTA_THRESHOLD); // Day 2, the umbrella appears, so U<sub>2</sub> = true. // ≈ <0.883, 0.117> ICollection <AssignmentProposition> e2 = CollectionFactory.CreateQueue <AssignmentProposition>(); e2.Add(new AssignmentProposition(ExampleRV.UMBREALLA_t_RV, true)); ICategoricalDistribution f2 = uw.forward(f1, e2); assertArrayEquals(new double[] { 0.883, 0.117 }, f2.getValues(), DELTA_THRESHOLD); }
public virtual ICategoricalDistribution jointDistribution(params IProposition[] propositions) { ProbabilityTable d = null; IProposition conjProp = ProbUtil.constructConjunction(propositions); ISet <IRandomVariable> vars = CollectionFactory.CreateSet <IRandomVariable>(conjProp.getUnboundScope()); if (vars.Size() > 0) { IRandomVariable[] distVars = new IRandomVariable[vars.Size()]; int i = 0; foreach (IRandomVariable rv in vars) { distVars[i] = rv; ++i; } ProbabilityTable ud = new ProbabilityTable(distVars); object[] values = new object[vars.Size()]; CategoricalDistributionIterator di = new CategoricalDistributionIteratorJointDistribution(conjProp, vars, ud, values); IRandomVariable[] X = conjProp.getScope().ToArray(); bayesInference.Ask(X, new AssignmentProposition[0], bayesNet).iterateOver(di); d = ud; } else { // No Unbound Variables, therefore just return // the singular probability related to the proposition. d = new ProbabilityTable(); d.setValue(0, prior(propositions)); } return(d); }
public ProbabilityTableIteratorImpl(IBayesianNetwork bn, ProbabilityTable q, ObservedEvidence e, IRandomVariable[] x, EnumerationAsk enumerationAsk) { this.bn = bn; this.q = q; this.e = e; this.x = x; this.enumerationAsk = enumerationAsk; }
public void test_iterateOverTable_fixedValues() { RandVar aRV = new RandVar("A", new BooleanDomain()); RandVar bRV = new RandVar("B", new BooleanDomain()); RandVar cRV = new RandVar("C", new BooleanDomain()); ProbabilityTable ptABC = new ProbabilityTable(new double[] { // A = true, B = true, C = true 1.0, // A = true, B = true, C = false 10.0, // A = true, B = false, C = true 100.0, // A = true, B = false, C = false 1000.0, // A = false, B = true, C = true 10000.0, // A = false, B = true, C = false 100000.0, // A = false, B = false, C = true 1000000.0, // A = false, B = false, C = false 10000000.0 }, aRV, bRV, cRV); ICollection <double> answer = CollectionFactory.CreateQueue <double>(); ProbabilityTable.ProbabilityTableIterator pti = new iter(answer); answer.Clear(); ptABC.iterateOverTable(pti, new AssignmentProposition(aRV, true)); Assert.AreEqual(1111.0, sumOf(answer), DELTA_THRESHOLD); answer.Clear(); ptABC.iterateOverTable(pti, new AssignmentProposition(aRV, false)); Assert.AreEqual(11110000.0, sumOf(answer), DELTA_THRESHOLD); answer.Clear(); ptABC.iterateOverTable(pti, new aima.net.probability.proposition.AssignmentProposition(bRV, true)); Assert.AreEqual(110011.0, sumOf(answer), DELTA_THRESHOLD); answer.Clear(); ptABC.iterateOverTable(pti, new AssignmentProposition(bRV, false)); Assert.AreEqual(11001100.0, sumOf(answer), DELTA_THRESHOLD); answer.Clear(); ptABC.iterateOverTable(pti, new AssignmentProposition(cRV, true)); Assert.AreEqual(1010101.0, sumOf(answer), DELTA_THRESHOLD); answer.Clear(); ptABC.iterateOverTable(pti, new AssignmentProposition(cRV, false)); Assert.AreEqual(10101010.0, sumOf(answer), DELTA_THRESHOLD); answer.Clear(); ptABC.iterateOverTable(pti, new AssignmentProposition(bRV, true), new AssignmentProposition(cRV, true)); Assert.AreEqual(10001.0, sumOf(answer), DELTA_THRESHOLD); }
private ICategoricalDistribution initBackwardMessage() { ProbabilityTable b = new ProbabilityTable(tToTm1StateVarMap.GetKeys()); for (int i = 0; i < b.size(); ++i) { b.setValue(i, 1.0); } return(b); }
protected void testBackwardStep_UmbrellaWorld(IBackwardStepInference uw) { // AIMA3e pg. 575 ICategoricalDistribution b_kp2t = new ProbabilityTable(new double[] { 1.0, 1.0 }, ExampleRV.RAIN_t_RV); ICollection <AssignmentProposition> e2 = CollectionFactory.CreateQueue <AssignmentProposition>(); e2.Add(new AssignmentProposition(ExampleRV.UMBREALLA_t_RV, true)); ICategoricalDistribution b1 = uw.backward(b_kp2t, e2); assertArrayEquals(new double[] { 0.69, 0.41 }, b1.getValues(), DELTA_THRESHOLD); }
static void forwardBackWardDemo() { System.Console.WriteLine("DEMO: Forward-BackWard"); System.Console.WriteLine("======================"); System.Console.WriteLine("Umbrella World"); System.Console.WriteLine("--------------"); ForwardBackward uw = new ForwardBackward( GenericTemporalModelFactory.getUmbrellaWorldTransitionModel(), GenericTemporalModelFactory.getUmbrellaWorld_Xt_to_Xtm1_Map(), GenericTemporalModelFactory.getUmbrellaWorldSensorModel()); ICategoricalDistribution prior = new ProbabilityTable(new double[] { 0.5, 0.5 }, ExampleRV.RAIN_t_RV); // Day 1 ICollection <ICollection <AssignmentProposition> > evidence = CollectionFactory.CreateQueue <ICollection <AssignmentProposition> >(); ICollection <AssignmentProposition> e1 = CollectionFactory.CreateQueue <AssignmentProposition>(); e1.Add(new AssignmentProposition(ExampleRV.UMBREALLA_t_RV, true)); evidence.Add(e1); ICollection <ICategoricalDistribution> smoothed = uw.forwardBackward(evidence, prior); System.Console.WriteLine("Day 1 (Umbrealla_t=true) smoothed:\nday 1 = " + smoothed.Get(0)); // Day 2 ICollection <AssignmentProposition> e2 = CollectionFactory.CreateQueue <AssignmentProposition>(); e2.Add(new AssignmentProposition(ExampleRV.UMBREALLA_t_RV, true)); evidence.Add(e2); smoothed = uw.forwardBackward(evidence, prior); System.Console.WriteLine("Day 2 (Umbrealla_t=true) smoothed:\nday 1 = " + smoothed.Get(0) + "\nday 2 = " + smoothed.Get(1)); // Day 3 ICollection <AssignmentProposition> e3 = CollectionFactory.CreateQueue <AssignmentProposition>(); e3.Add(new AssignmentProposition(ExampleRV.UMBREALLA_t_RV, false)); evidence.Add(e3); smoothed = uw.forwardBackward(evidence, prior); System.Console.WriteLine("Day 3 (Umbrealla_t=false) smoothed:\nday 1 = " + smoothed.Get(0) + "\nday 2 = " + smoothed.Get(1) + "\nday 3 = " + smoothed.Get(2)); System.Console.WriteLine("======================"); }
public void CoverCharacterPrediction() { var validChar = ProbabilityTable.GetProbability(1, 'a', 'b'); Assert.AreNotEqual(0, validChar); var invalidChar = ProbabilityTable.GetProbability(0, '+', '¬'); Assert.AreEqual(0, invalidChar); var tooLongWord = ProbabilityTable.GetProbability(128, 'a', 'b'); Assert.AreEqual(0, tooLongWord); }
// function ENUMERATION-ASK(X, e, bn) returns a distribution over X /** * The ENUMERATION-ASK algorithm in Figure 14.9 evaluates expression trees * (Figure 14.8) using depth-first recursion. * * @param X * the query variables. * @param observedEvidence * observed values for variables E. * @param bn * a Bayes net with variables {X} ∪ E ∪ Y /* Y = hidden * variables // * @return a distribution over the query variables. */ public ICategoricalDistribution enumerationAsk(IRandomVariable[] X, AssignmentProposition[] observedEvidence, IBayesianNetwork bn) { // Q(X) <- a distribution over X, initially empty ProbabilityTable Q = new ProbabilityTable(X); ObservedEvidence e = new ObservedEvidence(X, observedEvidence, bn); // for each value x<sub>i</sub> of X do ProbabilityTable.ProbabilityTableIterator di = new ProbabilityTableIteratorImpl(bn, Q, e, X, this); Q.iterateOverTable(di); // return NORMALIZE(Q(X)) return(Q.normalize()); }
public FullJointDistributionModel(double[] values, params IRandomVariable[] vars) { if (null == vars) { throw new IllegalArgumentException("Random Variables describing the model's representation of the World need to be specified."); } distribution = new ProbabilityTable(values, vars); representation = CollectionFactory.CreateSet <IRandomVariable>(); for (int i = 0; i < vars.Length; ++i) { representation.Add(vars[i]); } representation = CollectionFactory.CreateReadOnlySet <IRandomVariable>(representation); }
public FullJointDistributionModel(double[] values, params RandomVariable[] vars) { if (null == vars) { throw new ArgumentException( "Random Variables describing the model's representation of the World need to be specified."); } distribution = new ProbabilityTable(values, vars); representation = new Set <RandomVariable>(); for (int i = 0; i < vars.Length; i++) { representation.add(vars[i]); } //representation = Collections.unmodifiableSet(representation); }
public virtual ICategoricalDistribution GetConditioningCase(params AssignmentProposition[] parentValues) { if (parentValues.Length != parents.Size()) { throw new IllegalArgumentException( "The number of parent value arguments [" + parentValues.Length + "] is not equal to the number of parents [" + parents.Size() + "] for this CPT."); } ProbabilityTable cc = new ProbabilityTable(GetOn()); ProbabilityTable.ProbabilityTableIterator pti = new GetConditionCaseIterator(cc); table.iterateOverTable(pti, parentValues); return(cc); }
public CategoricalDistribution jointDistribution( params IProposition[] propositions) { ProbabilityTable d = null; IProposition conjProp = ProbUtil .constructConjunction(propositions); LinkedHashSet <RandomVariable> vars = new LinkedHashSet <RandomVariable>( conjProp.getUnboundScope()); if (vars.Count > 0) { RandomVariable[] distVars = new RandomVariable[vars.Count]; vars.CopyTo(distVars); ProbabilityTable ud = new ProbabilityTable(distVars); Object[] values = new Object[vars.Count]; //ProbabilityTable.Iterator di = new ProbabilityTable.Iterator() { // public void iterate(Map<RandomVariable, Object> possibleWorld, // double probability) { // if (conjProp.holds(possibleWorld)) { // int i = 0; // for (RandomVariable rv : vars) { // values[i] = possibleWorld.get(rv); // i++; // } // int dIdx = ud.getIndex(values); // ud.setValue(dIdx, ud.getValues()[dIdx] + probability); // } // } //}; //distribution.iterateOverTable(di); // TODO: d = ud; } else { // No Unbound Variables, therefore just return // the singular probability related to the proposition. d = new ProbabilityTable(); d.setValue(0, prior(propositions)); } return(d); }
/// <summary> /// Gets the random value within a specified range, except max value; /// </summary> /// <param name="table">The table.</param> /// <param name="min">The minimum.</param> /// <param name="max">The maximum.</param> /// <param name="isReversed">if set to <c>true</c> [isReversed].</param> /// <returns></returns> public static int GetRandomValue(this ProbabilityTable <int> table, int min, int max, bool isReversed) { var potentialValues = Enumerable.Range(min, max - min).ToList(); var batchSize = (int)Math.Ceiling(potentialValues.Count / _batchCount); var potentialValuesTable = potentialValues.GroupBy(v => v / batchSize + 1) .SelectMany(g => g.Select(v => new { Value = v, Probability = table.GetProbability(GetBatchNumber((int)g.Key, isReversed)) })).ToList(); var randomTable = potentialValuesTable .SelectMany(v => Enumerable.Range(1, (int)Math.Ceiling(v.Probability * _probabilityMultiplier)) .Select(i => v.Value)) .ToList(); var random = LinearUniformRandom.GetInstance.Next(randomTable.Count); return(randomTable[random]); }
public virtual IFactor GetFactorFor(params AssignmentProposition[] evidence) { ISet <IRandomVariable> fofVars = CollectionFactory.CreateSet <IRandomVariable>(table.getFor()); foreach (AssignmentProposition ap in evidence) { fofVars.Remove(ap.getTermVariable()); } ProbabilityTable fof = new ProbabilityTable(fofVars); // Otherwise need to iterate through the table for the // non evidence variables. object[] termValues = new object[fofVars.Size()]; ProbabilityTable.ProbabilityTableIterator di = new getFactorForIterator(termValues, fof); table.iterateOverTable(di, evidence); return(fof); }
protected void testForwardBackward_UmbrellaWorld(IForwardBackwardInference uw) { // AIMA3e pg. 572 // Day 0, no observations only the security guards prior beliefs // P(R<sub>0</sub>) = <0.5, 0.5> ICategoricalDistribution prior = new ProbabilityTable(new double[] { 0.5, 0.5 }, ExampleRV.RAIN_t_RV); // Day 1 ICollection <ICollection <AssignmentProposition> > evidence = CollectionFactory.CreateQueue <ICollection <AssignmentProposition> >(); ICollection <AssignmentProposition> e1 = CollectionFactory.CreateQueue <AssignmentProposition>(); e1.Add(new AssignmentProposition(ExampleRV.UMBREALLA_t_RV, true)); evidence.Add(e1); ICollection <ICategoricalDistribution> smoothed = uw.forwardBackward(evidence, prior); Assert.AreEqual(1, smoothed.Size()); assertArrayEquals(new double[] { 0.818, 0.182 }, smoothed.Get(0).getValues(), DELTA_THRESHOLD); // Day 2 ICollection <AssignmentProposition> e2 = CollectionFactory.CreateQueue <AssignmentProposition>(); e2.Add(new AssignmentProposition(ExampleRV.UMBREALLA_t_RV, true)); evidence.Add(e2); smoothed = uw.forwardBackward(evidence, prior); Assert.AreEqual(2, smoothed.Size()); assertArrayEquals(new double[] { 0.883, 0.117 }, smoothed.Get(0).getValues(), DELTA_THRESHOLD); assertArrayEquals(new double[] { 0.883, 0.117 }, smoothed.Get(1).getValues(), DELTA_THRESHOLD); // Day 3 ICollection <AssignmentProposition> e3 = CollectionFactory.CreateQueue <AssignmentProposition>(); e3.Add(new AssignmentProposition(ExampleRV.UMBREALLA_t_RV, false)); evidence.Add(e3); smoothed = uw.forwardBackward(evidence, prior); Assert.AreEqual(3, smoothed.Size()); assertArrayEquals(new double[] { 0.861, 0.138 }, smoothed.Get(0).getValues(), DELTA_THRESHOLD); assertArrayEquals(new double[] { 0.799, 0.201 }, smoothed.Get(1).getValues(), DELTA_THRESHOLD); assertArrayEquals(new double[] { 0.190, 0.810 }, smoothed.Get(2).getValues(), DELTA_THRESHOLD); }
public CPT(IRandomVariable on, double[] values, params IRandomVariable[] conditionedOn) { this.on = on; if (null == conditionedOn) { conditionedOn = new IRandomVariable[0]; } IRandomVariable[] tableVars = new IRandomVariable[conditionedOn.Length + 1]; for (int i = 0; i < conditionedOn.Length; ++i) { tableVars[i] = conditionedOn[i]; parents.Add(conditionedOn[i]); } tableVars[conditionedOn.Length] = on; table = new ProbabilityTable(values, tableVars); onDomain.AddAll(((IFiniteDomain)on.getDomain()).GetPossibleValues()); checkEachRowTotalsOne(); }
public ICategoricalDistribution forward(ICategoricalDistribution f1_t, ICollection <AssignmentProposition> e_tp1) { ICategoricalDistribution s1 = new ProbabilityTable(f1_t.getFor()); // Set up required working variables IProposition[] props = new IProposition[s1.getFor().Size()]; int i = 0; foreach (IRandomVariable rv in s1.getFor()) { props[i] = new RandVar(rv.getName(), rv.getDomain()); ++i; } IProposition Xtp1 = ProbUtil.constructConjunction(props); AssignmentProposition[] xt = new AssignmentProposition[tToTm1StateVarMap.Size()]; IMap <IRandomVariable, AssignmentProposition> xtVarAssignMap = CollectionFactory.CreateInsertionOrderedMap <IRandomVariable, AssignmentProposition>(); i = 0; foreach (IRandomVariable rv in tToTm1StateVarMap.GetKeys()) { xt[i] = new AssignmentProposition(tToTm1StateVarMap.Get(rv), "<Dummy Value>"); xtVarAssignMap.Put(rv, xt[i]); ++i; } // Step 1: Calculate the 1 time step prediction // ∑<sub>x<sub>t</sub></sub> CategoricalDistributionIterator if1_t = new CategoricalDistributionIteratorImpl(transitionModel, xtVarAssignMap, s1, Xtp1, xt); f1_t.iterateOver(if1_t); // Step 2: multiply by the probability of the evidence // and normalize // <b>P</b>(e<sub>t+1</sub> | X<sub>t+1</sub>) ICategoricalDistribution s2 = sensorModel.posteriorDistribution(ProbUtil .constructConjunction(e_tp1.ToArray()), Xtp1); return(s2.multiplyBy(s1).normalize()); }
public CategoricalDistribution enumerationAsk(RandomVariable[] X, AssignmentProposition[] observedEvidence, BayesianNetwork bn) { // Q(X) <- a distribution over X, initially empty ProbabilityTable Q = new ProbabilityTable(X); ObservedEvidence e = new ObservedEvidence(X, observedEvidence, bn); // for each value x<sub>i</sub> of X do // ProbabilityTable.Iterator di = new ProbabilityTable.Iterator() // { // int cnt = 0; // /** // * <pre> // * Q(x<sub>i</sub>) <- ENUMERATE-ALL(bn.VARS, e<sub>x<sub>i</sub></sub>) // * where e<sub>x<sub>i</sub></sub> is e extended with X = x<sub>i</sub> // * </pre> // */ // public void iterate(Map<RandomVariable, // Object > possibleWorld, // double probability) { // for (int i = 0; i < X.length; i++) { // e.setExtendedValue(X[i], // possibleWorld.get(X[i])); // } // Q.setValue(cnt, // enumerateAll(bn.getVariablesInTopologicalOrder(), e)); // cnt++; //} //} // ; // Q.iterateOverTable(di); // // return NORMALIZE(Q(X)) // return Q.normalize(); // TODO: need to clean this up, fail for now return(null); }
public ICategoricalDistribution backward(ICategoricalDistribution b_kp2t, ICollection <AssignmentProposition> e_kp1) { ICategoricalDistribution b_kp1t = new ProbabilityTable(b_kp2t.getFor()); // Set up required working variables IProposition[] props = new IProposition[b_kp1t.getFor().Size()]; int i = 0; foreach (IRandomVariable rv in b_kp1t.getFor()) { IRandomVariable prv = tToTm1StateVarMap.Get(rv); props[i] = new RandVar(prv.getName(), prv.getDomain()); ++i; } IProposition Xk = ProbUtil.constructConjunction(props); AssignmentProposition[] ax_kp1 = new AssignmentProposition[tToTm1StateVarMap.Size()]; IMap <IRandomVariable, AssignmentProposition> x_kp1VarAssignMap = CollectionFactory.CreateInsertionOrderedMap <IRandomVariable, AssignmentProposition>(); i = 0; foreach (IRandomVariable rv in b_kp1t.getFor()) { ax_kp1[i] = new AssignmentProposition(rv, "<Dummy Value>"); x_kp1VarAssignMap.Put(rv, ax_kp1[i]); ++i; } IProposition x_kp1 = ProbUtil.constructConjunction(ax_kp1); props = e_kp1.ToArray(); IProposition pe_kp1 = ProbUtil.constructConjunction(props); // ∑<sub>x<sub>k+1</sub></sub> CategoricalDistributionIterator ib_kp2t = new CategoricalDistributionIteratorImpl2(x_kp1VarAssignMap, sensorModel, transitionModel, b_kp1t, pe_kp1, Xk, x_kp1); b_kp2t.iterateOver(ib_kp2t); return(b_kp1t); }
public override void OnInspectorGUI() { ProbabilityTable wpt = (ProbabilityTable)target; EditorGUILayout.BeginVertical(); EditorGUILayout.LabelField("Items"); float tmpProb = 0; for (int i = 0; i < wpt.Size; i++) { tmpProb = wpt.probabilities[i]; EditorGUILayout.BeginHorizontal(); wpt.items[i] = EditorGUILayout.ObjectField(wpt.items[i], typeof(Object), true, GUILayout.Width(200)); tmpProb = EditorGUILayout.Slider(tmpProb, 0, 1); //EditorGUILayout.FloatField(tmpProb,GUILayout.Width(100)); if (GUI.changed) { wpt.SetProbability(i, tmpProb); } if (GUILayout.Button("Remove")) { wpt.RemoveEntry(i); } EditorGUILayout.EndHorizontal(); } if (GUILayout.Button("Add Entry")) { wpt.AddItem(null); } if (GUILayout.Button("Reset Probabilities")) { wpt.ResetProbabilities(); } EditorGUILayout.EndVertical(); EditorGUIUtility.LookLikeControls(); }
public void test_pointwiseProductPOS() { IRandomVariable xRV = new RandVar("X", new BooleanDomain()); IRandomVariable yRV = new RandVar("Y", new BooleanDomain()); IRandomVariable zRV = new RandVar("Z", new BooleanDomain()); ProbabilityTable xyD = new ProbabilityTable(new double[] { // X = true, Y = true 1.0, // X = true, Y = false 2.0, // X = false, Y = true 3.0, // X = false, Y = false 4.0 }, xRV, yRV); ProbabilityTable zD = new ProbabilityTable(new double[] { 3.0, 7.0 }, zRV); // Make commutative by specifying an order for the product assertArrayEquals(xyD.pointwiseProduct(zD).getValues(), zD .pointwiseProductPOS(xyD, xRV, yRV, zRV).getValues(), DELTA_THRESHOLD); }
public Demographic(DemographicProcessesConfiguration configuration, ProbabilityTable <int> birthProbability, ProbabilityTable <int> deathProbability) { _configuration = configuration; _birthProbability = birthProbability; _deathProbability = deathProbability; }