public void testDecrement() { MixedRadixNumber mrn = new MixedRadixNumber(5, new int[] { 3, 2 }); int i = 0; while (mrn.decrement()) { i++; } Assert.AreEqual(i, mrn.getMaxAllowedValue()); }
public void testCurrentNumberalValue() { MixedRadixNumber mrn; // mrn = new MixedRadixNumber(0, new int[] { 3, 3, 2, 2 }); Assert.AreEqual(0, mrn.getCurrentNumeralValue(0)); Assert.AreEqual(0, mrn.getCurrentNumeralValue(1)); Assert.AreEqual(0, mrn.getCurrentNumeralValue(2)); Assert.AreEqual(0, mrn.getCurrentNumeralValue(3)); // mrn = new MixedRadixNumber(35, new int[] { 3, 3, 2, 2 }); Assert.AreEqual(2, mrn.getCurrentNumeralValue(0)); Assert.AreEqual(2, mrn.getCurrentNumeralValue(1)); Assert.AreEqual(1, mrn.getCurrentNumeralValue(2)); Assert.AreEqual(1, mrn.getCurrentNumeralValue(3)); // mrn = new MixedRadixNumber(25, new int[] { 3, 3, 2, 2 }); Assert.AreEqual(1, mrn.getCurrentNumeralValue(0)); Assert.AreEqual(2, mrn.getCurrentNumeralValue(1)); Assert.AreEqual(0, mrn.getCurrentNumeralValue(2)); Assert.AreEqual(1, mrn.getCurrentNumeralValue(3)); // mrn = new MixedRadixNumber(17, new int[] { 3, 3, 2, 2 }); Assert.AreEqual(2, mrn.getCurrentNumeralValue(0)); Assert.AreEqual(2, mrn.getCurrentNumeralValue(1)); Assert.AreEqual(1, mrn.getCurrentNumeralValue(2)); Assert.AreEqual(0, mrn.getCurrentNumeralValue(3)); // mrn = new MixedRadixNumber(8, new int[] { 3, 3, 2, 2 }); Assert.AreEqual(2, mrn.getCurrentNumeralValue(0)); Assert.AreEqual(2, mrn.getCurrentNumeralValue(1)); Assert.AreEqual(0, mrn.getCurrentNumeralValue(2)); Assert.AreEqual(0, mrn.getCurrentNumeralValue(3)); // mrn = new MixedRadixNumber(359, new int[] { 3, 4, 5, 6 }); Assert.AreEqual(2, mrn.getCurrentNumeralValue(0)); Assert.AreEqual(3, mrn.getCurrentNumeralValue(1)); Assert.AreEqual(4, mrn.getCurrentNumeralValue(2)); Assert.AreEqual(5, mrn.getCurrentNumeralValue(3)); // mrn = new MixedRadixNumber(359, new int[] { 6, 5, 4, 3 }); Assert.AreEqual(5, mrn.getCurrentNumeralValue(0)); Assert.AreEqual(4, mrn.getCurrentNumeralValue(1)); Assert.AreEqual(3, mrn.getCurrentNumeralValue(2)); Assert.AreEqual(2, mrn.getCurrentNumeralValue(3)); }
public ProbabilityTable(double[] vals, params RandomVariable[] vars) { if (null == vals) { throw new ArgumentException("Values must be specified"); } if (vals.Length != ProbUtil.expectedSizeOfProbabilityTable(vars)) { throw new ArgumentException("ProbabilityTable of Length " + values.Length + " is not the correct size, should be " + ProbUtil.expectedSizeOfProbabilityTable(vars) + " in order to represent all possible combinations."); } if (null != vars) { foreach (RandomVariable rv in vars) { // Track index information relevant to each variable. randomVarInfo.Add(rv, new RVInfo(rv)); } } values = new double[vals.Length]; Array.Copy(vals, 0, values, 0, vals.Length); radices = createRadixs(randomVarInfo); if (radices.Length > 0) { queryMRN = new MixedRadixNumber(0, radices); } }
public ProbabilityTable divideBy(ProbabilityTable divisor) { if (!randomVarInfo.keySet().containsAll(divisor.randomVarInfo.keySet())) { throw new IllegalArgumentException( "Divisor must be a subset of the dividend."); } ProbabilityTable quotient = new ProbabilityTable(new List<RandomVariable>(randomVarInfo.Keys)); if (1 == divisor.getValues().Length) { double d = divisor.getValues()[0]; for (int i = 0; i < quotient.getValues().Length; i++) { if (0 == d) { quotient.getValues()[i] = 0; } else { quotient.getValues()[i] = getValues()[i]/d; } } } else { Set<RandomVariable> dividendDivisorDiff = SetOps .difference(new List<RVInfo>(randomVarInfo.keySet()), new List<RVInfo>(randomVarInfo.keySet())); Map<RandomVariable, RVInfo> tdiff = null; MixedRadixNumber tdMRN = null; if (dividendDivisorDiff.size() > 0) { tdiff = new LinkedHashMap<RandomVariable, RVInfo>(); foreach (RandomVariable rv in dividendDivisorDiff) { tdiff.put(rv, new RVInfo(rv)); } tdMRN = new MixedRadixNumber(0, createRadixs(tdiff)); } Map<RandomVariable, RVInfo> diff = tdiff; MixedRadixNumber dMRN = tdMRN; int[] qRVs = new int[quotient.radices.Length]; MixedRadixNumber qMRN = new MixedRadixNumber(0, quotient.radices); //ProbabilityTable.Iterator divisorIterator = new ProbabilityTable.Iterator() { // public void iterate(Map<RandomVariable, Object> possibleWorld, // double probability) { // foreach (RandomVariable rv in possibleWorld.keySet()) { // RVInfo rvInfo = quotient.randomVarInfo.get(rv); // qRVs[rvInfo.getRadixIdx()] = rvInfo // .getIdxForDomain(possibleWorld.get(rv)); // } // if (null != diff) { // // Start from 0 off the diff // dMRN.setCurrentValueFor(new int[diff.size()]); // do { // for (RandomVariable rv : diff.keySet()) { // RVInfo drvInfo = diff.get(rv); // RVInfo qrvInfo = quotient.randomVarInfo.get(rv); // qRVs[qrvInfo.getRadixIdx()] = dMRN // .getCurrentNumeralValue(drvInfo // .getRadixIdx()); // } // updateQuotient(probability); // } while (dMRN.increment()); // } else { // updateQuotient(probability); // } // } // // // //private void updateQuotient(double probability) { // int offset = (int) qMRN.getCurrentValueFor(qRVs); // if (0 == probability) { // quotient.getValues()[offset] = 0; // } else { // quotient.getValues()[offset] += getValues()[offset] // / probability; // } //} ////// }; // divisor.iterateOverTable(divisorIterator); // TODO } return quotient; }
/** * Iterate over all possible values assignments for the Random Variables * comprising this ProbabilityTable that are not in the fixed set of values. * This allows you to iterate over a subset of possible combinations. * * @param pti * the ProbabilityTable Iterator to iterate * @param fixedValues * Fixed values for a subset of the Random Variables comprising * this Probability Table. */ public void iterateOverTable(Factor.Iterator pti, params AssignmentProposition[] fixedValues) { Map<RandomVariable, Object> possibleWorld = new LinkedHashMap<RandomVariable, Object>(); MixedRadixNumber tableMRN = new MixedRadixNumber(0, radices); int[] tableRadixValues = new int[radices.Length]; // Assert that the Random Variables for the fixed values // are part of this probability table and assign // all the fixed values to the possible world. foreach (AssignmentProposition ap in fixedValues) { if (!randomVarInfo.ContainsKey(ap.getTermVariable())) { throw new ArgumentException("Assignment proposition [" + ap + "] does not belong to this probability table."); } possibleWorld.Add(ap.getTermVariable(), ap.getValue()); RVInfo fixedRVI = randomVarInfo.get(ap.getTermVariable()); tableRadixValues[fixedRVI.getRadixIdx()] = fixedRVI .getIdxForDomain(ap.getValue()); } // If have assignments for all the random variables // in this probability table if (fixedValues.Length == randomVarInfo.Count) { // Then only 1 iteration call is required. pti.iterate(possibleWorld, getValue(fixedValues)); } else { // Else iterate over the non-fixed values List<RandomVariable> freeVariables = SetOps.difference( new List<RandomVariable>(randomVarInfo.Keys), new List<RandomVariable>(possibleWorld.Keys)); Map<RandomVariable, RVInfo> freeVarInfo = new LinkedHashMap<RandomVariable, RVInfo>(); // Remove the fixed Variables foreach (RandomVariable fv in freeVariables) { freeVarInfo.put(fv, new RVInfo(fv)); } int[] freeRadixValues = createRadixs(freeVarInfo); MixedRadixNumber freeMRN = new MixedRadixNumber(0, freeRadixValues); Object fval = null; // Iterate through all combinations of the free variables do { // Put the current assignments for the free variables // into the possible world and update // the current index in the table MRN foreach (RVInfo freeRVI in freeVarInfo.values()) { fval = freeRVI.getDomainValueAt(freeMRN .getCurrentNumeralValue(freeRVI.getRadixIdx())); possibleWorld.put(freeRVI.getVariable(), fval); tableRadixValues[randomVarInfo.get(freeRVI.getVariable()) .getRadixIdx()] = freeRVI.getIdxForDomain(fval); } pti.iterate(possibleWorld, values[(int) tableMRN .getCurrentValueFor(tableRadixValues)]); } while (freeMRN.increment()); } }
// END-Factor // /** * Iterate over all the possible value assignments for the Random Variables * comprising this ProbabilityTable. * * @param pti * the ProbabilityTable Iterator to iterate. */ public void iterateOverTable(Factor.Iterator pti) { Map<RandomVariable, Object> possibleWorld = new LinkedHashMap<RandomVariable, Object>(); MixedRadixNumber mrn = new MixedRadixNumber(0, radices); do { foreach (RVInfo rvInfo in randomVarInfo.Values) { possibleWorld.put(rvInfo.getVariable(), rvInfo .getDomainValueAt(mrn.getCurrentNumeralValue(rvInfo . getRadixIdx ()))); } pti.iterate(possibleWorld, values[mrn.intValue()]); } while (mrn.increment()); }