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 Inferencer.lookupMarginal(Variable v)
          Returns the computed marginal of a given variable.
 Factor BruteForceInferencer.lookupMarginal(Variable var)
           
abstract  Factor AbstractInferencer.lookupMarginal(Variable variable)
           
 Factor AbstractBeliefPropagation.lookupMarginal(Variable var)
           
 Factor SamplingInferencer.lookupMarginal(VarSet varSet)
           
 Factor JunctionTreeInferencer.lookupMarginal(VarSet varSet)
           
 Factor Inferencer.lookupMarginal(VarSet varSet)
          Returns the computed marginal of a given clique in a graph.
 Factor BruteForceInferencer.lookupMarginal(VarSet c)
           
 Factor AbstractInferencer.lookupMarginal(VarSet c)
           
 Factor AbstractBeliefPropagation.lookupMarginal(VarSet c)
           
 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 UniNormalFactor.duplicate()
           
 Factor UniformFactor.duplicate()
           
 Factor TableFactor.duplicate()
           
 Factor SkeletonFactor.duplicate()
           
 Factor PottsTableFactor.duplicate()
           
 Factor NormalFactor.duplicate()
           
 Factor LogTableFactor.duplicate()
           
 Factor FactorGraph.duplicate()
          Returns a copy of this model.
 Factor Factor.duplicate()
           
 Factor CPT.duplicate()
           
 Factor ConstantFactor.duplicate()
           
 Factor BoltzmannUnaryFactor.duplicate()
           
 Factor BoltzmannPairFactor.duplicate()
           
 Factor BinaryUnaryFactor.duplicate()
           
 Factor BetaFactor.duplicate()
           
 Factor Assignment.duplicate()
           
abstract  Factor AbstractTableFactor.duplicate()
           
 Factor FactorGraph.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 CPT.extractMax(java.util.Collection vars)
           
 Factor AbstractTableFactor.extractMax(java.util.Collection vars)
           
 Factor AbstractFactor.extractMax(java.util.Collection vars)
           
 Factor FactorGraph.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 CPT.extractMax(Variable var)
           
 Factor AbstractTableFactor.extractMax(Variable var)
           
 Factor AbstractFactor.extractMax(Variable var)
           
 Factor FactorGraph.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 CPT.extractMax(Variable[] vars)
           
 Factor AbstractTableFactor.extractMax(Variable[] vars)
           
 Factor AbstractFactor.extractMax(Variable[] vars)
           
protected  Factor UniNormalFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor UniformFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor SkeletonFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor PottsTableFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor NormalFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor ConstantFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor BinaryUnaryFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor BetaFactor.extractMaxInternal(VarSet varSet)
           
protected  Factor Assignment.extractMaxInternal(VarSet varSet)
           
protected abstract  Factor AbstractFactor.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 FactorGraph.marginalize(java.util.Collection vars)
           
 Factor Factor.marginalize(java.util.Collection vars)
          Returns the marginal of this distribution over the given variables.
 Factor CPT.marginalize(java.util.Collection vars)
           
 Factor AbstractTableFactor.marginalize(java.util.Collection vars)
           
 Factor AbstractFactor.marginalize(java.util.Collection vars)
           
 Factor FactorGraph.marginalize(Variable var)
           
 Factor Factor.marginalize(Variable var)
          Returns the marginal of this distribution over one variable.
 Factor CPT.marginalize(Variable var)
           
 Factor AbstractTableFactor.marginalize(Variable var)
           
 Factor AbstractFactor.marginalize(Variable var)
           
 Factor FactorGraph.marginalize(Variable[] vars)
           
 Factor Factor.marginalize(Variable[] vars)
          Returns the marginal of this distribution over the given variables.
 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)
           
protected  Factor TableFactor.marginalizeInternal(AbstractTableFactor result)
           
protected  Factor LogTableFactor.marginalizeInternal(AbstractTableFactor result)
           
protected abstract  Factor AbstractTableFactor.marginalizeInternal(AbstractTableFactor result)
           
protected  Factor UniNormalFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor UniformFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor SkeletonFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor PottsTableFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor NormalFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor ConstantFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor BinaryUnaryFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor BetaFactor.marginalizeInternal(VarSet varsToKeep)
           
protected  Factor Assignment.marginalizeInternal(VarSet varsToKeep)
           
protected abstract  Factor AbstractFactor.marginalizeInternal(VarSet varsToKeep)
           
 Factor FactorGraph.marginalizeOut(Variable var)
           
 Factor Factor.marginalizeOut(Variable var)
          Returns the marginal distribution attained by summing out the given variable.
 Factor CPT.marginalizeOut(Variable var)
           
 Factor AbstractTableFactor.marginalizeOut(Variable var)
           
 Factor AbstractFactor.marginalizeOut(Variable var)
           
 Factor FactorGraph.marginalizeOut(VarSet varset)
           
 Factor Factor.marginalizeOut(VarSet varset)
          Returns the marginal distribution attained by summing out the given set of variables.
 Factor CPT.marginalizeOut(VarSet varset)
           
 Factor AbstractTableFactor.marginalizeOut(VarSet badVars)
           
 Factor AbstractFactor.marginalizeOut(VarSet varset)
           
static Factor Factors.mix(AbstractTableFactor f1, AbstractTableFactor f2, double alpha)
          Returns a new Factor F = alpha * f1 + (1 - alpha) * f2.
 Factor FactorGraph.multiply(Factor dist)
           
 Factor Factor.multiply(Factor dist)
          Returns the elementwise product of this factor with another.
 Factor CPT.multiply(Factor dist)
           
 Factor ConstantFactor.multiply(Factor other)
           
 Factor BoltzmannUnaryFactor.multiply(Factor other)
           
 Factor BoltzmannPairFactor.multiply(Factor other)
           
 Factor AbstractTableFactor.multiply(Factor dist)
          Returns the elementwise product of this potential and another one.
 Factor AbstractFactor.multiply(Factor dist)
           
static Factor Factors.multiplyAll(java.util.Collection factors)
           
 Factor UniNormalFactor.normalize()
           
 Factor UniformFactor.normalize()
           
 Factor TableFactor.normalize()
          Multiplies every entry in the potential by a constant such that all the entries sum to 1.
 Factor SkeletonFactor.normalize()
           
 Factor PottsTableFactor.normalize()
           
 Factor NormalFactor.normalize()
           
 Factor LogTableFactor.normalize()
           
 Factor FactorGraph.normalize()
           
 Factor Factor.normalize()
          Multiplies this potential by a constant such that it sums to 1.
 Factor CPT.normalize()
           
 Factor ConstantFactor.normalize()
           
 Factor BinaryUnaryFactor.normalize()
           
 Factor BetaFactor.normalize()
           
 Factor Assignment.normalize()
           
abstract  Factor AbstractTableFactor.normalize()
           
protected  Factor TableFactor.slice_general(Variable[] vars, Assignment observed)
           
protected  Factor LogTableFactor.slice_general(Variable[] vars, Assignment observed)
           
protected abstract  Factor AbstractTableFactor.slice_general(Variable[] vars, 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  Factor LogTableFactor.slice_onevar(Variable var, Assignment observed)
           
protected abstract  Factor AbstractTableFactor.slice_onevar(Variable var, Assignment observed)
           
protected  Factor TableFactor.slice_twovar(Variable v1, Variable v2, Assignment observed)
           
protected  Factor LogTableFactor.slice_twovar(Variable v1, Variable v2, Assignment observed)
           
protected abstract  Factor AbstractTableFactor.slice_twovar(Variable v1, Variable v2, Assignment observed)
           
 Factor UniNormalFactor.slice(Assignment assn)
           
 Factor UniformFactor.slice(Assignment assn)
           
 Factor SkeletonFactor.slice(Assignment assn)
           
 Factor PottsTableFactor.slice(Assignment assn)
           
 Factor NormalFactor.slice(Assignment assn)
           
 Factor FactorGraph.slice(Assignment assn)
           
 Factor Factor.slice(Assignment assn)
           
 Factor CPT.slice(Assignment assn)
           
 Factor ConstantFactor.slice(Assignment assn)
           
 Factor BinaryUnaryFactor.slice(Assignment assn)
           
 Factor BetaFactor.slice(Assignment assn)
           
 Factor Assignment.slice(Assignment assn)
           
 Factor AbstractTableFactor.slice(Assignment assn)
          Creates a new potential that is equal to this one, restricted to a given assignment.
 Factor FactorGraph.slice(Assignment assn, java.util.Map toSlicedMap)
           
 

Methods in cc.mallet.grmm.types with parameters of type Factor
 void UndirectedModel.addFactor(Factor factor)
           
 void FactorGraph.addFactor(Factor factor)
          Adds a factor to the model.
protected  void FactorGraph.afterFactorAdd(Factor factor)
          Performs operations on a factor after it has been added to the model, such as caching.
protected  void DirectedModel.afterFactorAdd(Factor factor)
           
 boolean FactorGraph.almostEquals(Factor p)
           
 boolean Factor.almostEquals(Factor p)
          Returns whether this is almost equal to another potential.
 boolean CPT.almostEquals(Factor p)
           
 boolean AbstractTableFactor.almostEquals(Factor p)
           
 boolean AbstractFactor.almostEquals(Factor p)
           
 boolean UniNormalFactor.almostEquals(Factor p, double epsilon)
           
 boolean UniformFactor.almostEquals(Factor p, double epsilon)
           
 boolean SkeletonFactor.almostEquals(Factor p, double epsilon)
           
 boolean PottsTableFactor.almostEquals(Factor p, double epsilon)
           
 boolean NormalFactor.almostEquals(Factor p, double epsilon)
           
 boolean FactorGraph.almostEquals(Factor p, double epsilon)
           
 boolean Factor.almostEquals(Factor p, double epsilon)
           
 boolean CPT.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 Assignment.almostEquals(Factor p, double epsilon)
           
 boolean AbstractTableFactor.almostEquals(Factor p, double epsilon)
           
static Factor Factors.average(Factor ptl1, Factor ptl2, double weight)
           
protected  void FactorGraph.beforeFactorAdd(Factor factor)
          Performs checking of a factor before it is added to the model.
protected  void DirectedModel.beforeFactorAdd(Factor factor)
           
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 UniNormalFactor.divideBy(Factor f)
           
 void UniformFactor.divideBy(Factor other)
           
 void NormalFactor.divideBy(Factor f)
           
 void FactorGraph.divideBy(Factor pot)
           
 void Factor.divideBy(Factor pot)
          Computes this /= pot
 void CPT.divideBy(Factor pot)
           
 void BetaFactor.divideBy(Factor f)
           
 void AbstractTableFactor.divideBy(Factor pot)
          Does the conceptual equivalent of this /= pot.
 void AbstractFactor.divideBy(Factor pot)
           
 int FactorGraph.getIndex(Factor factor)
           
 Factor FactorGraph.multiply(Factor dist)
           
 Factor Factor.multiply(Factor dist)
          Returns the elementwise product of this factor with another.
 Factor CPT.multiply(Factor dist)
           
 Factor ConstantFactor.multiply(Factor other)
           
 Factor BoltzmannUnaryFactor.multiply(Factor other)
           
 Factor BoltzmannPairFactor.multiply(Factor other)
           
 Factor AbstractTableFactor.multiply(Factor dist)
          Returns the elementwise product of this potential and another one.
 Factor AbstractFactor.multiply(Factor dist)
           
static DiscreteFactor TableFactor.multiplyAll(Factor[] phis)
           
 void UniNormalFactor.multiplyBy(Factor f)
           
 void UniformFactor.multiplyBy(Factor other)
           
 void NormalFactor.multiplyBy(Factor f)
           
 void FactorGraph.multiplyBy(Factor pot)
           
 void Factor.multiplyBy(Factor pot)
          Does this *= pot.
 void CPT.multiplyBy(Factor pot)
           
 void ConstantFactor.multiplyBy(Factor other)
           
 void BetaFactor.multiplyBy(Factor f)
           
 void AbstractTableFactor.multiplyBy(Factor pot)
          Does the conceptual equivalent of this *= pot.
 void AbstractFactor.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 PottsTableFactor.sumGradLog(Factor q, Variable param, Assignment theta)
           
 double ParameterizedFactor.sumGradLog(Factor q, Variable param, Assignment assn)
          Computes the expected derivative of the log factor value.
 double BinaryUnaryFactor.sumGradLog(Factor q, Variable param, Assignment paramAssn)
           
 

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.