Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## 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` | `AbstractBeliefPropagation.lookupMarginal(Variable var)`
`abstract Factor` | `AbstractInferencer.lookupMarginal(Variable variable)`
`Factor` | `JunctionTree.lookupMarginal(Variable var)`
`Factor` | `VariableElimination.lookupMarginal(Variable var)`
`Factor` | `Inferencer.lookupMarginal(Variable v)` Returns the computed marginal of a given variable.
`Factor` | `JunctionTreeInferencer.lookupMarginal(Variable var)`
`Factor` | `SamplingInferencer.lookupMarginal(Variable var)`
`Factor` | `BruteForceInferencer.lookupMarginal(Variable var)`
`Factor` | `AbstractBeliefPropagation.lookupMarginal(VarSet c)`
`Factor` | `AbstractInferencer.lookupMarginal(VarSet c)`
`Factor` | `Inferencer.lookupMarginal(VarSet varSet)` Returns the computed marginal of a given clique in a graph.
`Factor` | `JunctionTreeInferencer.lookupMarginal(VarSet varSet)`
`Factor` | `SamplingInferencer.lookupMarginal(VarSet varSet)`
`Factor` | `BruteForceInferencer.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` | `SkeletonFactor.duplicate()`
`Factor` | `CPT.duplicate()`
`Factor` | `UniNormalFactor.duplicate()`
`Factor` | `Factor.duplicate()`
`Factor` | `NormalFactor.duplicate()`
`Factor` | `BoltzmannUnaryFactor.duplicate()`
`abstract Factor` | `AbstractTableFactor.duplicate()`
`Factor` | `LogTableFactor.duplicate()`
`Factor` | `ConstantFactor.duplicate()`
`Factor` | `FactorGraph.duplicate()` Returns a copy of this model.
`Factor` | `UniformFactor.duplicate()`
`Factor` | `BinaryUnaryFactor.duplicate()`
`Factor` | `PottsTableFactor.duplicate()`
`Factor` | `TableFactor.duplicate()`
`Factor` | `Assignment.duplicate()`
`Factor` | `BoltzmannPairFactor.duplicate()`
`Factor` | `BetaFactor.duplicate()`
`Factor` | `CPT.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` | `AbstractTableFactor.extractMax(java.util.Collection vars)`
`Factor` | `FactorGraph.extractMax(java.util.Collection vars)`
`Factor` | `AbstractFactor.extractMax(java.util.Collection vars)`
`Factor` | `CPT.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` | `AbstractTableFactor.extractMax(Variable var)`
`Factor` | `FactorGraph.extractMax(Variable var)`
`Factor` | `AbstractFactor.extractMax(Variable var)`
`Factor` | `CPT.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` | `AbstractTableFactor.extractMax(Variable[] vars)`
`Factor` | `FactorGraph.extractMax(Variable[] vars)`
`Factor` | `AbstractFactor.extractMax(Variable[] vars)`
`protected Factor` | `SkeletonFactor.extractMaxInternal(VarSet varSet)`
`protected Factor` | `UniNormalFactor.extractMaxInternal(VarSet varSet)`
`protected Factor` | `NormalFactor.extractMaxInternal(VarSet varSet)`
`protected Factor` | `BoltzmannUnaryFactor.extractMaxInternal(VarSet varSet)`
`protected Factor` | `ConstantFactor.extractMaxInternal(VarSet varSet)`
`protected Factor` | `UniformFactor.extractMaxInternal(VarSet varSet)`
`protected Factor` | `BinaryUnaryFactor.extractMaxInternal(VarSet varSet)`
`protected Factor` | `PottsTableFactor.extractMaxInternal(VarSet varSet)`
`protected Factor` | `Assignment.extractMaxInternal(VarSet varSet)`
`protected Factor` | `BoltzmannPairFactor.extractMaxInternal(VarSet varSet)`
`protected Factor` | `BetaFactor.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` | `CPT.marginalize(java.util.Collection vars)`
`Factor` | `Factor.marginalize(java.util.Collection vars)` Returns the marginal of this distribution over the given variables.
`Factor` | `AbstractTableFactor.marginalize(java.util.Collection vars)`
`Factor` | `FactorGraph.marginalize(java.util.Collection vars)`
`Factor` | `AbstractFactor.marginalize(java.util.Collection vars)`
`Factor` | `CPT.marginalize(Variable var)`
`Factor` | `Factor.marginalize(Variable var)` Returns the marginal of this distribution over one variable.
`Factor` | `AbstractTableFactor.marginalize(Variable var)`
`Factor` | `FactorGraph.marginalize(Variable var)`
`Factor` | `AbstractFactor.marginalize(Variable var)`
`Factor` | `CPT.marginalize(Variable[] vars)`
`Factor` | `Factor.marginalize(Variable[] vars)` Returns the marginal of this distribution over the given variables.
`Factor` | `AbstractTableFactor.marginalize(Variable[] vars)` Returns the marginal of this distribution over the given variables.
`Factor` | `FactorGraph.marginalize(Variable[] vars)`
`Factor` | `AbstractFactor.marginalize(Variable[] vars)`
`protected abstract Factor` | `AbstractTableFactor.marginalizeInternal(AbstractTableFactor result)`
`protected Factor` | `LogTableFactor.marginalizeInternal(AbstractTableFactor result)`
`protected Factor` | `TableFactor.marginalizeInternal(AbstractTableFactor result)`
`protected Factor` | `SkeletonFactor.marginalizeInternal(VarSet varsToKeep)`
`protected Factor` | `UniNormalFactor.marginalizeInternal(VarSet varsToKeep)`
`protected Factor` | `NormalFactor.marginalizeInternal(VarSet varsToKeep)`
`protected Factor` | `BoltzmannUnaryFactor.marginalizeInternal(VarSet varsToKeep)`
`protected Factor` | `ConstantFactor.marginalizeInternal(VarSet varsToKeep)`
`protected Factor` | `UniformFactor.marginalizeInternal(VarSet varsToKeep)`
`protected Factor` | `BinaryUnaryFactor.marginalizeInternal(VarSet varsToKeep)`
`protected Factor` | `PottsTableFactor.marginalizeInternal(VarSet varsToKeep)`
`protected Factor` | `Assignment.marginalizeInternal(VarSet varsToKeep)`
`protected Factor` | `BoltzmannPairFactor.marginalizeInternal(VarSet varsToKeep)`
`protected Factor` | `BetaFactor.marginalizeInternal(VarSet varsToKeep)`
`protected abstract Factor` | `AbstractFactor.marginalizeInternal(VarSet varsToKeep)`
`Factor` | `CPT.marginalizeOut(Variable var)`
`Factor` | `Factor.marginalizeOut(Variable var)` Returns the marginal distribution attained by summing out the given variable.
`Factor` | `AbstractTableFactor.marginalizeOut(Variable var)`
`Factor` | `FactorGraph.marginalizeOut(Variable var)`
`Factor` | `AbstractFactor.marginalizeOut(Variable var)`
`Factor` | `CPT.marginalizeOut(VarSet varset)`
`Factor` | `Factor.marginalizeOut(VarSet varset)` Returns the marginal distribution attained by summing out the given set of variables.
`Factor` | `AbstractTableFactor.marginalizeOut(VarSet badVars)`
`Factor` | `FactorGraph.marginalizeOut(VarSet varset)`
`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` | `CPT.multiply(Factor dist)`
`Factor` | `Factor.multiply(Factor dist)` Returns the elementwise product of this factor with another.
`Factor` | `AbstractTableFactor.multiply(Factor dist)` Returns the elementwise product of this potential and another one.
`Factor` | `ConstantFactor.multiply(Factor other)`
`Factor` | `FactorGraph.multiply(Factor dist)`
`Factor` | `AbstractFactor.multiply(Factor dist)`
`static Factor` | `Factors.multiplyAll(java.util.Collection factors)`
`Factor` | `SkeletonFactor.normalize()`
`Factor` | `CPT.normalize()`
`Factor` | `UniNormalFactor.normalize()`
`Factor` | `Factor.normalize()` Multiplies this potential by a constant such that it sums to 1.
`Factor` | `NormalFactor.normalize()`
`Factor` | `BoltzmannUnaryFactor.normalize()`
`abstract Factor` | `AbstractTableFactor.normalize()`
`Factor` | `LogTableFactor.normalize()`
`Factor` | `ConstantFactor.normalize()`
`Factor` | `FactorGraph.normalize()`
`Factor` | `UniformFactor.normalize()`
`Factor` | `BinaryUnaryFactor.normalize()`
`Factor` | `PottsTableFactor.normalize()`
`Factor` | `TableFactor.normalize()` Multiplies every entry in the potential by a constant such that all the entries sum to 1.
`Factor` | `Assignment.normalize()`
`Factor` | `BoltzmannPairFactor.normalize()`
`Factor` | `BetaFactor.normalize()`
`protected abstract Factor` | `AbstractTableFactor.slice_general(Variable[] vars, Assignment observed)`
`protected Factor` | `LogTableFactor.slice_general(Variable[] vars, Assignment observed)`
`protected Factor` | `TableFactor.slice_general(Variable[] vars, Assignment observed)`
`protected abstract Factor` | `AbstractTableFactor.slice_onevar(Variable var, 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_twovar(Variable v1, Variable v2, Assignment observed)`
`protected Factor` | `LogTableFactor.slice_twovar(Variable v1, Variable v2, Assignment observed)`
`protected Factor` | `TableFactor.slice_twovar(Variable v1, Variable v2, Assignment observed)`
`Factor` | `SkeletonFactor.slice(Assignment assn)`
`Factor` | `CPT.slice(Assignment assn)`
`Factor` | `UniNormalFactor.slice(Assignment assn)`
`Factor` | `Factor.slice(Assignment assn)`
`Factor` | `NormalFactor.slice(Assignment assn)`
`Factor` | `BoltzmannUnaryFactor.slice(Assignment assn)`
`Factor` | `AbstractTableFactor.slice(Assignment assn)` Creates a new potential that is equal to this one, restricted to a given assignment.
`Factor` | `ConstantFactor.slice(Assignment assn)`
`Factor` | `FactorGraph.slice(Assignment assn)`
`Factor` | `UniformFactor.slice(Assignment assn)`
`Factor` | `BinaryUnaryFactor.slice(Assignment assn)`
`Factor` | `PottsTableFactor.slice(Assignment assn)`
`Factor` | `Assignment.slice(Assignment assn)`
`Factor` | `BoltzmannPairFactor.slice(Assignment assn)`
`Factor` | `BetaFactor.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` | `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` | `CPT.almostEquals(Factor p)`
`boolean` | `Factor.almostEquals(Factor p)` Returns whether this is almost equal to another potential.
`boolean` | `AbstractTableFactor.almostEquals(Factor p)`
`boolean` | `FactorGraph.almostEquals(Factor p)`
`boolean` | `AbstractFactor.almostEquals(Factor p)`
`boolean` | `SkeletonFactor.almostEquals(Factor p, double epsilon)`
`boolean` | `CPT.almostEquals(Factor p, double epsilon)`
`boolean` | `UniNormalFactor.almostEquals(Factor p, double epsilon)`
`boolean` | `Factor.almostEquals(Factor p, double epsilon)`
`boolean` | `NormalFactor.almostEquals(Factor p, double epsilon)`
`boolean` | `BoltzmannUnaryFactor.almostEquals(Factor p, double epsilon)`
`boolean` | `AbstractTableFactor.almostEquals(Factor p, double epsilon)`
`boolean` | `ConstantFactor.almostEquals(Factor p, double epsilon)`
`boolean` | `FactorGraph.almostEquals(Factor p, double epsilon)`
`boolean` | `UniformFactor.almostEquals(Factor p, double epsilon)`
`boolean` | `BinaryUnaryFactor.almostEquals(Factor p, double epsilon)`
`boolean` | `PottsTableFactor.almostEquals(Factor p, double epsilon)`
`boolean` | `Assignment.almostEquals(Factor p, double epsilon)`
`boolean` | `BoltzmannPairFactor.almostEquals(Factor p, double epsilon)`
`boolean` | `BetaFactor.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` | `CPT.divideBy(Factor pot)`
`void` | `UniNormalFactor.divideBy(Factor f)`
`void` | `Factor.divideBy(Factor pot)` Computes this /= pot
`void` | `NormalFactor.divideBy(Factor f)`
`void` | `AbstractTableFactor.divideBy(Factor pot)` Does the conceptual equivalent of this /= pot.
`void` | `FactorGraph.divideBy(Factor pot)`
`void` | `UniformFactor.divideBy(Factor other)`
`void` | `BetaFactor.divideBy(Factor f)`
`void` | `AbstractFactor.divideBy(Factor pot)`
`int` | `FactorGraph.getIndex(Factor factor)`
`Factor` | `CPT.multiply(Factor dist)`
`Factor` | `Factor.multiply(Factor dist)` Returns the elementwise product of this factor with another.
`Factor` | `AbstractTableFactor.multiply(Factor dist)` Returns the elementwise product of this potential and another one.
`Factor` | `ConstantFactor.multiply(Factor other)`
`Factor` | `FactorGraph.multiply(Factor dist)`
`Factor` | `AbstractFactor.multiply(Factor dist)`
`static DiscreteFactor` | `TableFactor.multiplyAll(Factor[] phis)`
`void` | `CPT.multiplyBy(Factor pot)`
`void` | `UniNormalFactor.multiplyBy(Factor f)`
`void` | `Factor.multiplyBy(Factor pot)` Does this *= pot.
`void` | `NormalFactor.multiplyBy(Factor f)`
`void` | `AbstractTableFactor.multiplyBy(Factor pot)` Does the conceptual equivalent of this *= pot.
`void` | `ConstantFactor.multiplyBy(Factor other)`
`void` | `FactorGraph.multiplyBy(Factor pot)`
`void` | `UniformFactor.multiplyBy(Factor other)`
`void` | `BetaFactor.multiplyBy(Factor f)`
`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` | `ParameterizedFactor.sumGradLog(Factor q, Variable param, Assignment assn)` Computes the expected derivative of the log factor value.
`double` | `BoltzmannUnaryFactor.sumGradLog(Factor q, Variable param, Assignment paramAssn)`
`double` | `BinaryUnaryFactor.sumGradLog(Factor q, Variable param, Assignment paramAssn)`
`double` | `PottsTableFactor.sumGradLog(Factor q, Variable param, Assignment theta)`
`double` | `BoltzmannPairFactor.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.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES