import cc.mallet.grmm.util.Flops; //导入依赖的package包/类
protected void divideByInternal (DiscreteFactor ptl)
{
  int[] projection = largeIdxToSmall (ptl);
  int numLocs = probs.numLocations ();
  for (int singleLoc = 0; singleLoc < numLocs; singleLoc++) {
    int smallIdx = projection[singleLoc];
    double prev = this.probs.valueAtLocation (singleLoc);
    double newVal = ptl.logValue (smallIdx);
    double product = prev - newVal;
    /* by convention, let -Inf + Inf (corresponds to 0/0) be -Inf */
    if (Double.isInfinite (newVal)) {
      product = Double.NEGATIVE_INFINITY;
    }
    this.probs.setValueAtLocation (singleLoc, product);
  }
  Flops.increment (numLocs);  // handle the pluses
}
 

import cc.mallet.grmm.util.Flops; //导入依赖的package包/类
protected Factor marginalizeInternal (AbstractTableFactor result)
  {

    result.setAll (Double.NEGATIVE_INFINITY);
    int[] projection = largeIdxToSmall (result);

    /* Add each element of the single array of the large potential
to the correct element in the small potential. */
    int numLocs = probs.numLocations ();
    for (int largeLoc = 0; largeLoc < numLocs; largeLoc++) {

      /* Convert a single-index from this distribution to
 one for the smaller distribution */
      int smallIdx = projection[largeLoc];

      /* Whew! Now, add it in. */
      double oldValue = this.probs.valueAtLocation (largeLoc);
      double currentValue = result.probs.singleValue (smallIdx);
      result.probs.setValueAtLocation (smallIdx,
              Maths.sumLogProb (oldValue, currentValue));

    }
    Flops.sumLogProb (numLocs);

    return result;
  }
 

import cc.mallet.grmm.util.Flops; //导入依赖的package包/类
protected Factor marginalizeInternal (AbstractTableFactor result)
  {

    result.setAll (0.0);

    int[] projection = largeIdxToSmall (result);

    /* Add each element of the single array of the large potential
to the correct element in the small potential. */
    int numLocs = probs.numLocations ();
    for (int largeLoc = 0; largeLoc < numLocs; largeLoc++) {

      /* Convert a single-index from this distribution to
 one for the smaller distribution */
      int smallIdx = projection[largeLoc];

      /* Whew! Now, add it in. */
      double oldValue = this.probs.valueAtLocation (largeLoc);
      result.probs.incrementSingleValue (smallIdx, oldValue);
    }

    Flops.increment (numLocs);

    return result;
  }
 

import cc.mallet.grmm.util.Flops; //导入依赖的package包/类
protected void divideByInternal (DiscreteFactor ptl)
{
  int[] projection = largeIdxToSmall (ptl);
  int numLocs = probs.numLocations ();
  for (int singleLoc = 0; singleLoc < numLocs; singleLoc++) {
    int smallIdx = projection[singleLoc];
    double prev = this.probs.valueAtLocation (singleLoc);
    double newVal = ptl.value (smallIdx);
    double product = prev / newVal;
    /* by convention, let dividing by zero just return 0 */
    if (Maths.almostEquals (newVal, 0)) {
      product = 0;
    }
    this.probs.setValueAtLocation (singleLoc, product);
  }
  Flops.increment (numLocs);
}
 

import cc.mallet.grmm.util.Flops; //导入依赖的package包/类
private double logspaceOneNorm ()
{
  double sum = Double.NEGATIVE_INFINITY; // That's 0 in log space
  for (int i = 0; i < probs.numLocations (); i++) {
    sum = Maths.sumLogProb (sum, probs.valueAtLocation (i));
  }
  Flops.sumLogProb (probs.numLocations ());
  return sum;
}
 

import cc.mallet.grmm.util.Flops; //导入依赖的package包/类
/**
 * Does the conceptual equivalent of this *= pot.
 * Assumes that pot's variables are a subset of
 * this potential's.
 */
protected void multiplyByInternal (DiscreteFactor ptl)
{
  int[] projection = largeIdxToSmall (ptl);
  int numLocs = probs.numLocations ();
  for (int singleLoc = 0; singleLoc < numLocs; singleLoc++) {
    int smallIdx = projection[singleLoc];
    double prev = this.probs.valueAtLocation (singleLoc);
    double newVal = ptl.logValue (smallIdx);
    double product = prev + newVal;
    this.probs.setValueAtLocation (singleLoc, product);
  }
  Flops.increment (numLocs);  // handle the pluses
}
 

import cc.mallet.grmm.util.Flops; //导入依赖的package包/类
/**
 * Does the conceptual equivalent of this += pot.
 * Assumes that pot's variables are a subset of
 * this potential's.
 */
protected void plusEqualsInternal (DiscreteFactor ptl)
{
  int[] projection = largeIdxToSmall (ptl);
  int numLocs = probs.numLocations ();
  for (int singleLoc = 0; singleLoc < numLocs; singleLoc++) {
    int smallIdx = projection[singleLoc];
    double prev = this.probs.valueAtLocation (singleLoc);
    double newVal = ptl.logValue (smallIdx);
    double product = Maths.sumLogProb (prev, newVal);
    this.probs.setValueAtLocation (singleLoc, product);
  }
  Flops.sumLogProb (numLocs);
}
 

import cc.mallet.grmm.util.Flops; //导入依赖的package包/类
public void setValues (double[] vals)
{
  Flops.log (vals.length);
  for (int i = 0; i < vals.length; i++) {
    setRawValue (i, Math.log (vals[i]));
  }
}
 

import cc.mallet.grmm.util.Flops; //导入依赖的package包/类
private void timesEqualsLog (double logV)
{
  Flops.increment (probs.numLocations ());
  Matrix other = (Matrix) probs.cloneMatrix ();
  other.setAll (logV);
  probs.plusEquals (other);
}
 

import cc.mallet.grmm.util.Flops; //导入依赖的package包/类
public static LogTableFactor makeFromMatrix (Variable[] vars, SparseMatrixn values)
{
  SparseMatrixn logValues = (SparseMatrixn) values.cloneMatrix ();
  for (int i = 0; i < logValues.numLocations (); i++) {
    logValues.setValueAtLocation (i, Math.log (logValues.valueAtLocation (i)));
  }
  Flops.log (logValues.numLocations ());
  return new LogTableFactor (vars, logValues);
}
 

import cc.mallet.grmm.util.Flops; //导入依赖的package包/类
public Matrix getValueMatrix ()
{
  Matrix logProbs = (Matrix) probs.cloneMatrix ();
  for (int loc = 0; loc < probs.numLocations (); loc++) {
    logProbs.setValueAtLocation (loc, Math.exp (logProbs.valueAtLocation (loc)));
  }
  Flops.exp (probs.numLocations ());
  return logProbs;
}
 

import cc.mallet.grmm.util.Flops; //导入依赖的package包/类
/**
 * Multiplies every entry in the potential by a constant
 * such that all the entries sum to 1.
 */
public Factor normalize ()
{
  Flops.increment (2 * probs.numLocations ());
  probs.oneNormalize ();
  return this;
}