Uses of Interface
cc.mallet.grmm.types.Factor

Packages that use Factor
cc.mallet.grmm.inference   
cc.mallet.grmm.inference.gbp   
cc.mallet.grmm.learning   
cc.mallet.grmm.types   
cc.mallet.grmm.util   
 

Uses of Factor in cc.mallet.grmm.inference
 

Methods in cc.mallet.grmm.inference that return Factor
 Factor MessageArray.ToMsgsIterator.currentMessage()
           
 Factor MessageArray.get(Factor from, Variable to)
           
 Factor MessageArray.get(java.lang.Object from, java.lang.Object to)
           
 Factor MessageArray.get(Variable from, Factor to)
           
 Factor JunctionTree.getCPF(VarSet c)
           
 Factor JunctionTree.getSepsetPot(VarSet v1, VarSet v2)
           
 Factor BruteForceInferencer.joint(FactorGraph model)
           
 Factor BruteForceInferencer.joint(JunctionTree jt)
           
 Factor VariableElimination.lookupMarginal(Variable var)
           
 Factor SamplingInferencer.lookupMarginal(Variable var)
           
 Factor JunctionTreeInferencer.lookupMarginal(Variable var)
           
 Factor JunctionTree.lookupMarginal(Variable var)
           
 Factor BruteForceInferencer.lookupMarginal(Variable var)
           
abstract  Factor AbstractInferencer.lookupMarginal(Variable variable)
           
 Factor AbstractBeliefPropagation.lookupMarginal(Variable var)
           
 Factor Inferencer.lookupMarginal(Variable v)
          Returns the computed marginal of a given variable.
 Factor SamplingInferencer.lookupMarginal(VarSet varSet)
           
 Factor JunctionTreeInferencer.lookupMarginal(VarSet varSet)
           
 Factor BruteForceInferencer.lookupMarginal(VarSet c)
           
 Factor AbstractInferencer.lookupMarginal(VarSet c)
           
 Factor AbstractBeliefPropagation.lookupMarginal(VarSet c)
           
 Factor Inferencer.lookupMarginal(VarSet varSet)
          Returns the computed marginal of a given clique in a graph.
 Factor AbstractBeliefPropagation.MessageStrategy.msgProduct(Factor product, int idx, int excludeMsgFrom)
           
 Factor AbstractBeliefPropagation.AbstractMessageStrategy.msgProduct(Factor product, int idx, int excludeMsgFrom)
           
 Factor MessageArray.ToMsgsIterator.next()
           
 Factor RandomGraphs.FactorGenerator.nextFactor(VarSet vars)
           
 Factor RandomGraphs.UniformFactorGenerator.nextFactor(VarSet vars)
           
 Factor TRP.query(DirectedModel m, Variable var)
           
 Factor VariableElimination.unnormalizedMarginal(FactorGraph model, Variable query)
          The bulk of the variable-elimination algorithm.
 

Methods in cc.mallet.grmm.inference with parameters of type Factor
 Factor MessageArray.get(Factor from, Variable to)
           
 Factor MessageArray.get(Variable from, Factor to)
           
 int MessageArray.getIndex(Factor from)
           
 Factor AbstractBeliefPropagation.MessageStrategy.msgProduct(Factor product, int idx, int excludeMsgFrom)
           
 Factor AbstractBeliefPropagation.AbstractMessageStrategy.msgProduct(Factor product, int idx, int excludeMsgFrom)
           
 void MessageArray.put(Factor from, Variable to, Factor msg)
           
 void MessageArray.put(int fromIdx, int toIdx, Factor msg)
           
 void MessageArray.put(Variable from, Factor to, Factor msg)
           
protected  void AbstractBeliefPropagation.sendMessage(FactorGraph mdl, Factor from, Variable to)
           
 void AbstractBeliefPropagation.MessageStrategy.sendMessage(FactorGraph mdl, Factor from, Variable to)
           
 void AbstractBeliefPropagation.SumProductMessageStrategy.sendMessage(FactorGraph mdl, Factor from, Variable to)
           
 void AbstractBeliefPropagation.MaxProductMessageStrategy.sendMessage(FactorGraph mdl, Factor from, Variable to)
           
protected  void AbstractBeliefPropagation.sendMessage(FactorGraph mdl, Variable from, Factor to)
           
 void AbstractBeliefPropagation.MessageStrategy.sendMessage(FactorGraph mdl, Variable from, Factor to)
           
 void AbstractBeliefPropagation.SumProductMessageStrategy.sendMessage(FactorGraph mdl, Variable from, Factor to)
           
 void AbstractBeliefPropagation.MaxProductMessageStrategy.sendMessage(FactorGraph mdl, Variable from, Factor to)
           
 void JunctionTree.setCPF(VarSet c, Factor pot)
           
 

Uses of Factor in cc.mallet.grmm.inference.gbp
 

Methods in cc.mallet.grmm.inference.gbp that return Factor
 Factor ParentChildGBP.lookupMarginal(Variable variable)
           
 Factor ParentChildGBP.lookupMarginal(VarSet varSet)
           
 

Uses of Factor in cc.mallet.grmm.learning
 

Classes in cc.mallet.grmm.learning that implement Factor
static class ACRF.UnrolledGraph
           
 

Methods in cc.mallet.grmm.learning that return Factor
 Factor ACRF.UnrolledVarSet.getFactor()
           
 

Methods in cc.mallet.grmm.learning with parameters of type Factor
 ACRF.UnrolledVarSet ACRF.UnrolledGraph.getUnrolledVarSet(Factor f)
           
 

Uses of Factor in cc.mallet.grmm.types
 

Subinterfaces of Factor in cc.mallet.grmm.types
 interface DiscreteFactor
          $Id: DiscreteFactor.java,v 1.1 2007/10/22 21:37:44 mccallum Exp $
 interface ParameterizedFactor
          A factor that supports taking derivatives with respect to its continuous variables.
 

Classes in cc.mallet.grmm.types that implement Factor
 class AbstractFactor
          An Abstract class from which new Factor classes can be subclassed.
 class AbstractTableFactor
          Class for a multivariate multinomial distribution.
 class Assignment
          An assignment to a bunch of variables.
 class BetaFactor
          $Id: BetaFactor.java,v 1.1 2007/10/22 21:37:44 mccallum Exp $
 class BinaryUnaryFactor
          A factor over a continuous variable theta and binary variables var.
 class BoltzmannPairFactor
          A factor over a continuous variable theta and binary variables var.
 class BoltzmannUnaryFactor
          A factor over a continuous variable theta and binary variables var.
 class ConstantFactor
          $Id: ConstantFactor.java,v 1.1 2007/10/22 21:37:44 mccallum Exp $
 class CPT
          $Id: CPT.java,v 1.1 2007/10/22 21:37:44 mccallum Exp $
 class DirectedModel
          Class for directed graphical models.
 class FactorGraph
          Class for undirected graphical models.
 class LogTableFactor
          Created: Jan 4, 2006
 class NormalFactor
          Multivariate Gaussian factor.
 class PottsTableFactor
          A factor over a continuous variable alpha and discrete variables x such that phi(x|alpha) is Potts.
 class SkeletonFactor
          A subclass of Factor in which all operations throw an UnsupportedOperationException.
 class TableFactor
          Created: Jan 4, 2006
 class UndirectedGrid
          A grid-shaped undirected graphical model.
 class UndirectedModel
          Class for pairwise undirected graphical models, also known as pairwise Markov random fields.
 class UniformFactor
          $Id: UniformFactor.java,v 1.1 2007/10/22 21:37:44 mccallum Exp $
 class UniNormalFactor
          Univariate Gaussian factor.
 

Methods in cc.mallet.grmm.types that return Factor
static Factor Factors.asFactor(Inferencer inf)
          Adapter that allows an Inferencer to be treated as if it were a factor.
static Factor Factors.average(Factor ptl1, Factor ptl2, double weight)
           
 Factor UniformFactor.duplicate()
           
 Factor UniNormalFactor.duplicate()
           
 Factor SkeletonFactor.duplicate()
           
 Factor NormalFactor.duplicate()
           
 Factor ConstantFactor.duplicate()
           
 Factor BoltzmannUnaryFactor.duplicate()
           
 Factor BoltzmannPairFactor.duplicate()
           
 Factor BinaryUnaryFactor.duplicate()
           
 Factor BetaFactor.duplicate()
           
 Factor PottsTableFactor.duplicate()
           
 Factor LogTableFactor.duplicate()
           
 Factor CPT.duplicate()
           
 Factor TableFactor.duplicate()
           
abstract  Factor AbstractTableFactor.duplicate()
           
 Factor Assignment.duplicate()
           
 Factor Factor.duplicate()
           
 Factor FactorGraph.duplicate()
          Returns a copy of this model.
 Factor CPT.extractMax(java.util.Collection vars)
           
 Factor AbstractTableFactor.extractMax(java.util.Collection vars)
           
 Factor AbstractFactor.extractMax(java.util.Collection vars)
           
 Factor Factor.extractMax(java.util.Collection vars)
          Returns a potential phi over the given variables obtained by taking phi (x) = max_[all v that contain x] this.prob (x)
 Factor FactorGraph.extractMax(java.util.Collection vars)
           
 Factor CPT.extractMax(Variable var)
           
 Factor AbstractTableFactor.extractMax(Variable var)
           
 Factor AbstractFactor.extractMax(Variable var)
           
 Factor Factor.extractMax(Variable var)
          Returns a potential phi over the given variables obtained by taking phi (x) = max_[all v that contain x] this.prob (x)
 Factor FactorGraph.extractMax(Variable var)
           
 Factor CPT.extractMax(Variable[] vars)
           
 Factor AbstractTableFactor.extractMax(Variable[] vars)
           
 Factor AbstractFactor.extractMax(Variable[] vars)
           
 Factor Factor.extractMax(Variable[] vars)
          Returns a potential phi over the given variables obtained by taking phi (x) = max_[all v that contain x] this.prob (x)
 Factor FactorGraph.extractMax(Variable[] vars)
           
protected  Factor UniformFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor UniNormalFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor SkeletonFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor NormalFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor ConstantFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor BoltzmannUnaryFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor BoltzmannPairFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor BinaryUnaryFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor BetaFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor PottsTableFactor.extractMaxInternal(VarSet varSet)
           
protected abstract  Factor AbstractFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor Assignment.extractMaxInternal(VarSet varSet)
           
 Factor FactorGraph.factorOf(java.util.Collection c)
          Searches the graphical model for a factor over the given collection of variables.
 Factor FactorGraph.factorOf(Variable var)
          Returns the factor for a given node.
 Factor FactorGraph.factorOf(Variable var1, Variable var2)
          Returns the factor defined over a given pair of variables.
 Factor FactorGraph.factorOf(VarSet varSet)
          Returns the factor in this graph, if any, whose domain is a given clique.
 Factor FactorGraph.getFactor(int i)
           
 Factor AbstractFactor.log()
           
static Factor ConstantFactor.makeIdentityFactor()
           
static Factor AbstractTableFactor.makeIdentityFactor(AbstractTableFactor copy)
          STATIC FACTORY METHODS
 Factor CPT.marginalize(java.util.Collection vars)
           
 Factor AbstractTableFactor.marginalize(java.util.Collection vars)
           
 Factor AbstractFactor.marginalize(java.util.Collection vars)
           
 Factor Factor.marginalize(java.util.Collection vars)
          Returns the marginal of this distribution over the given variables.
 Factor FactorGraph.marginalize(java.util.Collection vars)
           
 Factor CPT.marginalize(Variable var)
           
 Factor AbstractTableFactor.marginalize(Variable var)
           
 Factor AbstractFactor.marginalize(Variable var)
           
 Factor Factor.marginalize(Variable var)
          Returns the marginal of this distribution over one variable.
 Factor FactorGraph.marginalize(Variable var)
           
 Factor CPT.marginalize(Variable[] vars)
           
 Factor AbstractTableFactor.marginalize(Variable[] vars)
          Returns the marginal of this distribution over the given variables.
 Factor AbstractFactor.marginalize(Variable[] vars)
           
 Factor Factor.marginalize(Variable[] vars)
          Returns the marginal of this distribution over the given variables.
 Factor FactorGraph.marginalize(Variable[] vars)
           
protected  Factor LogTableFactor.marginalizeInternal(AbstractTableFactor result)
           
protected  Factor TableFactor.marginalizeInternal(AbstractTableFactor result)
           
protected abstract  Factor AbstractTableFactor.marginalizeInternal(AbstractTableFactor result)
           
protected  Factor UniformFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor UniNormalFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor SkeletonFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor NormalFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor ConstantFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor BoltzmannUnaryFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor BoltzmannPairFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor BinaryUnaryFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor BetaFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor PottsTableFactor.marginalizeInternal(VarSet varsToKeep)
           
protected abstract  Factor AbstractFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor Assignment.marginalizeInternal(VarSet varsToKeep)
           
 Factor CPT.marginalizeOut(Variable var)
           
 Factor AbstractTableFactor.marginalizeOut(Variable var)
           
 Factor AbstractFactor.marginalizeOut(Variable var)
           
 Factor Factor.marginalizeOut(Variable var)
          Returns the marginal distribution attained by summing out the given variable.
 Factor FactorGraph.marginalizeOut(Variable var)
           
 Factor CPT.marginalizeOut(VarSet varset)
           
 Factor AbstractTableFactor.marginalizeOut(VarSet badVars)
           
 Factor AbstractFactor.marginalizeOut(VarSet varset)
           
 Factor Factor.marginalizeOut(VarSet varset)
          Returns the marginal distribution attained by summing out the given set of variables.
 Factor FactorGraph.marginalizeOut(VarSet varset)
           
static Factor Factors.mix(AbstractTableFactor f1, AbstractTableFactor f2, double alpha)
          Returns a new Factor F = alpha * f1 + (1 - alpha) * f2.
 Factor ConstantFactor.multiply(Factor other)
           
 Factor CPT.multiply(Factor dist)
           
 Factor AbstractTableFactor.multiply(Factor dist)
          Returns the elementwise product of this potential and another one.
 Factor AbstractFactor.multiply(Factor dist)
           
 Factor Factor.multiply(Factor dist)
          Returns the elementwise product of this factor with another.
 Factor FactorGraph.multiply(Factor dist)
           
static Factor Factors.multiplyAll(java.util.Collection factors)
           
 Factor UniformFactor.normalize()
           
 Factor UniNormalFactor.normalize()
           
 Factor SkeletonFactor.normalize()
           
 Factor NormalFactor.normalize()
           
 Factor ConstantFactor.normalize()
           
 Factor BoltzmannUnaryFactor.normalize()
           
 Factor BoltzmannPairFactor.normalize()
           
 Factor BinaryUnaryFactor.normalize()
           
 Factor BetaFactor.normalize()
           
 Factor PottsTableFactor.normalize()
           
 Factor LogTableFactor.normalize()
           
 Factor CPT.normalize()
           
 Factor TableFactor.normalize()
          Multiplies every entry in the potential by a constant such that all the entries sum to 1.
abstract  Factor AbstractTableFactor.normalize()
           
 Factor Assignment.normalize()
           
 Factor Factor.normalize()
          Multiplies this potential by a constant such that it sums to 1.
 Factor FactorGraph.normalize()
           
protected  Factor LogTableFactor.slice_general(Variable[] vars, Assignment observed)
           
protected  Factor TableFactor.slice_general(Variable[] vars, Assignment observed)
           
protected abstract  Factor AbstractTableFactor.slice_general(Variable[] vars, Assignment observed)
           
protected  Factor LogTableFactor.slice_onevar(Variable var, Assignment observed)
           
protected  Factor TableFactor.slice_onevar(Variable var, Assignment observed)
          Creates a new potential from another by restricting it to a given assignment.
protected abstract  Factor AbstractTableFactor.slice_onevar(Variable var, Assignment observed)
           
protected  Factor LogTableFactor.slice_twovar(Variable v1, Variable v2, Assignment observed)
           
protected  Factor TableFactor.slice_twovar(Variable v1, Variable v2, Assignment observed)
           
protected abstract  Factor AbstractTableFactor.slice_twovar(Variable v1, Variable v2, Assignment observed)
           
 Factor UniformFactor.slice(Assignment assn)
           
 Factor UniNormalFactor.slice(Assignment assn)
           
 Factor SkeletonFactor.slice(Assignment assn)
           
 Factor NormalFactor.slice(Assignment assn)
           
 Factor ConstantFactor.slice(Assignment assn)
           
 Factor BoltzmannUnaryFactor.slice(Assignment assn)
           
 Factor BoltzmannPairFactor.slice(Assignment assn)
           
 Factor BinaryUnaryFactor.slice(Assignment assn)
           
 Factor BetaFactor.slice(Assignment assn)
           
 Factor PottsTableFactor.slice(Assignment assn)
           
 Factor CPT.slice(Assignment assn)
           
 Factor AbstractTableFactor.slice(Assignment assn)
          Creates a new potential that is equal to this one, restricted to a given assignment.
 Factor Assignment.slice(Assignment assn)
           
 Factor Factor.slice(Assignment assn)
           
 Factor FactorGraph.slice(Assignment assn)
           
 Factor FactorGraph.slice(Assignment assn, java.util.Map toSlicedMap)
           
 

Methods in cc.mallet.grmm.types with parameters of type Factor
 void FactorGraph.addFactor(Factor factor)
          Adds a factor to the model.
 void UndirectedModel.addFactor(Factor factor)
           
protected  void DirectedModel.afterFactorAdd(Factor factor)
           
protected  void FactorGraph.afterFactorAdd(Factor factor)
          Performs operations on a factor after it has been added to the model, such as caching.
 boolean CPT.almostEquals(Factor p)
           
 boolean AbstractTableFactor.almostEquals(Factor p)
           
 boolean AbstractFactor.almostEquals(Factor p)
           
 boolean Factor.almostEquals(Factor p)
          Returns whether this is almost equal to another potential.
 boolean FactorGraph.almostEquals(Factor p)
           
 boolean UniformFactor.almostEquals(Factor p, double epsilon)
           
 boolean UniNormalFactor.almostEquals(Factor p, double epsilon)
           
 boolean SkeletonFactor.almostEquals(Factor p, double epsilon)
           
 boolean NormalFactor.almostEquals(Factor p, double epsilon)
           
 boolean ConstantFactor.almostEquals(Factor p, double epsilon)
           
 boolean BoltzmannUnaryFactor.almostEquals(Factor p, double epsilon)
           
 boolean BoltzmannPairFactor.almostEquals(Factor p, double epsilon)
           
 boolean BinaryUnaryFactor.almostEquals(Factor p, double epsilon)
           
 boolean BetaFactor.almostEquals(Factor p, double epsilon)
           
 boolean PottsTableFactor.almostEquals(Factor p, double epsilon)
           
 boolean CPT.almostEquals(Factor p, double epsilon)
           
 boolean AbstractTableFactor.almostEquals(Factor p, double epsilon)
           
 boolean Assignment.almostEquals(Factor p, double epsilon)
           
 boolean Factor.almostEquals(Factor p, double epsilon)
           
 boolean FactorGraph.almostEquals(Factor p, double epsilon)
           
static Factor Factors.average(Factor ptl1, Factor ptl2, double weight)
           
protected  void DirectedModel.beforeFactorAdd(Factor factor)
           
protected  void FactorGraph.beforeFactorAdd(Factor factor)
          Performs checking of a factor before it is added to the model.
static int[] Factors.computeSizes(Factor result)
           
static Variable[] Factors.computeVars(Factor result)
           
static Variable[] Factors.continuousVarsOf(Factor fg)
           
static double Factors.corr(Factor factor)
           
static Variable[] Factors.discreteVarsOf(Factor fg)
           
 void UniformFactor.divideBy(Factor other)
           
 void UniNormalFactor.divideBy(Factor f)
           
 void NormalFactor.divideBy(Factor f)
           
 void BetaFactor.divideBy(Factor f)
           
 void CPT.divideBy(Factor pot)
           
 void AbstractTableFactor.divideBy(Factor pot)
          Does the conceptual equivalent of this /= pot.
 void AbstractFactor.divideBy(Factor pot)
           
 void Factor.divideBy(Factor pot)
          Computes this /= pot
 void FactorGraph.divideBy(Factor pot)
           
 int FactorGraph.getIndex(Factor factor)
           
 Factor ConstantFactor.multiply(Factor other)
           
 Factor CPT.multiply(Factor dist)
           
 Factor AbstractTableFactor.multiply(Factor dist)
          Returns the elementwise product of this potential and another one.
 Factor AbstractFactor.multiply(Factor dist)
           
 Factor Factor.multiply(Factor dist)
          Returns the elementwise product of this factor with another.
 Factor FactorGraph.multiply(Factor dist)
           
static DiscreteFactor TableFactor.multiplyAll(Factor[] phis)
           
 void UniformFactor.multiplyBy(Factor other)
           
 void UniNormalFactor.multiplyBy(Factor f)
           
 void NormalFactor.multiplyBy(Factor f)
           
 void ConstantFactor.multiplyBy(Factor other)
           
 void BetaFactor.multiplyBy(Factor f)
           
 void CPT.multiplyBy(Factor pot)
           
 void AbstractTableFactor.multiplyBy(Factor pot)
          Does the conceptual equivalent of this *= pot.
 void AbstractFactor.multiplyBy(Factor pot)
           
 void Factor.multiplyBy(Factor pot)
          Does this *= pot.
 void FactorGraph.multiplyBy(Factor pot)
           
static double Factors.mutualInformation(Factor factor)
          Given a joint distribution over two variables, returns their mutual information.
static double Factors.oneDistance(Factor bel1, Factor bel2)
           
 void AbstractTableFactor.plusEquals(Factor f)
           
 double PottsTableFactor.secondDerivative(Factor q, Variable param, Assignment theta)
           
 double BoltzmannUnaryFactor.sumGradLog(Factor q, Variable param, Assignment paramAssn)
           
 double BoltzmannPairFactor.sumGradLog(Factor q, Variable param, Assignment paramAssn)
           
 double BinaryUnaryFactor.sumGradLog(Factor q, Variable param, Assignment paramAssn)
           
 double ParameterizedFactor.sumGradLog(Factor q, Variable param, Assignment assn)
          Computes the expected derivative of the log factor value.
 double PottsTableFactor.sumGradLog(Factor q, Variable param, Assignment theta)
           
 

Constructors in cc.mallet.grmm.types with parameters of type Factor
FactorGraph(Factor[] factors)
           
 

Uses of Factor in cc.mallet.grmm.util
 

Classes in cc.mallet.grmm.util that implement Factor
 class LabelsAssignment
          A special kind of assignment for Variables that can be arranged in a LabelsSequence.