public void multiplyBy (Factor other) { if (other instanceof ConstantFactor) { val *= other.value (new Assignment ()); } else { throw new UnsupportedOperationException ("Can't multiply uniform factor by "+other); } }
public void multiplyBy (Factor other) { if (other instanceof ConstantFactor) { val *= other.value (new Assignment ()); } else { throw new UnsupportedOperationException ("Can't multiply uniform factor by "+other); } }
public void multiplyBy (Factor f) { if (f instanceof ConstantFactor) { double val = f.value (new Assignment()); // NormalFactor must be normalized right now... if (Maths.almostEquals (val, 1.0)) { return; // ok, it's an identity factor } } throw new UnsupportedOperationException ("Can't multiply NormalFactor by "+f); }
public void divideBy (Factor f) { if (f instanceof ConstantFactor) { double val = f.value (new Assignment()); // NormalFactor must be normalized right now... if (Maths.almostEquals (val, 1.0)) { return; // ok, it's an identity factor } } throw new UnsupportedOperationException ("Can't divide NormalFactor by "+f); }
public void multiplyBy (Factor f) { if (f instanceof ConstantFactor) { double val = f.value (new Assignment()); // NormalFactor must be normalized right now... if (Maths.almostEquals (val, 1.0)) { return; // ok, it's an identity factor } } throw new UnsupportedOperationException ("Can't multiply NormalFactor by "+f); }
public void divideBy (Factor f) { if (f instanceof ConstantFactor) { double val = f.value (new Assignment()); // NormalFactor must be normalized right now... if (Maths.almostEquals (val, 1.0)) { return; // ok, it's an identity factor } } throw new UnsupportedOperationException ("Can't divide NormalFactor by "+f); }
public void divideBy (Factor f) { if (f instanceof ConstantFactor) { double val = f.value (new Assignment()); // NormalFactor must be normalized right now... if (Maths.almostEquals (val, 1.0)) { return; // ok, it's an identity factor } } throw new UnsupportedOperationException ("Can't divide NormalFactor by "+f); }
public void divideBy (Factor f) { if (f instanceof ConstantFactor) { double val = f.value (new Assignment()); // NormalFactor must be normalized right now... if (Maths.almostEquals (val, 1.0)) { return; // ok, it's an identity factor } } throw new UnsupportedOperationException ("Can't divide BetaFactor by "+f); }
public void multiplyBy (Factor f) { if (f instanceof ConstantFactor) { double val = f.value (new Assignment()); // NormalFactor must be normalized right now... if (Maths.almostEquals (val, 1.0)) { return; // ok, it's an identity factor } } throw new UnsupportedOperationException ("Can't multiply NormalFactor by "+f); }
public void multiplyBy (Factor f) { if (f instanceof ConstantFactor) { double val = f.value (new Assignment()); // NormalFactor must be normalized right now... if (Maths.almostEquals (val, 1.0)) { return; // ok, it's an identity factor } } throw new UnsupportedOperationException ("Can't multiply NormalFactor by "+f); }
public static double localMagnetization (Inferencer inferencer, Variable var) { if (var.getNumOutcomes () != 2) throw new IllegalArgumentException (); Factor marg = inferencer.lookupMarginal (var); AssignmentIterator it = marg.assignmentIterator (); double v1 = marg.value (it); it.advance (); double v2 = marg.value (it); return v1 - v2; }
public double value (AssignmentIterator it) { Assignment assn = it.assignment(); Factor tbl = sliceForAlpha (assn); return tbl.value (assn); }
public double value (Assignment assn) { Factor factor = inf.lookupMarginal (assn.varSet ()); return factor.value (assn); }
public double value (AssignmentIterator it) { Assignment assn = it.assignment(); Factor tbl = sliceForAlpha (assn); return tbl.value (assn); }
public double value (AssignmentIterator it) { Assignment assn = it.assignment(); Factor tbl = sliceForAlpha (assn); return tbl.value (assn); }
public double value (Assignment assn) { Factor factor = inf.lookupMarginal (assn.varSet ()); return factor.value (assn); }
public void testValue () { Variable var = new Variable (Variable.CONTINUOUS); Factor f = new UniNormalFactor (var, -1.0, 2.0); Assignment assn1 = new Assignment (var, -1.0); assertEquals (0.2821, f.value (assn1), 1e-4); assertEquals (Math.log (0.2821), f.logValue (assn1), 1e-4); Assignment assn2 = new Assignment (var, 1.5); assertEquals (0.05913, f.value (assn2), 1e-4); assertEquals (Math.log (0.05913), f.logValue (assn2), 1e-4); }
public void testValue () { Variable var = new Variable (Variable.CONTINUOUS); Factor f = new BetaFactor (var, 1.0, 1.2); Assignment assn = new Assignment (var, 0.7); assertEquals (0.94321, f.value(assn), 1e-5); }
public void testScaleMarginalize () { Assignment assn = new Assignment (vars, new int[] { 1, 0 }); assn.addRow (vars, new int[] { 1, 0 }); assn.addRow (vars, new int[] { 1, 1 }); assn.normalize (); Factor mrg = assn.marginalize (vars[1]); Assignment assn2 = new Assignment (vars[1], 0); assertEquals (0.666666, mrg.value (assn2), 1e-5); }
public void testTableTimesFg () { FactorGraph fg = new FactorGraph (); fg.multiplyBy (tbl1); fg.multiplyBy (tbl2); Factor product = tbl3.multiply (fg); assertTrue (product instanceof AbstractTableFactor); assertEquals (4, product.varSet ().size ()); Assignment assn = new Assignment (product.varSet ().toVariableArray (), new int [4]); assertEquals (0.032, product.value (assn), 1e-5); }