Java Flops.increment方法代码示例

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 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包/类
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包/类
/**
 * 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包/类
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包/类
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.value (smallIdx);
    this.probs.setValueAtLocation (singleLoc, prev * newVal);
  }
  Flops.increment (numLocs);
}
 

import cc.mallet.grmm.util.Flops; //导入方法依赖的package包/类
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.value (smallIdx);
    this.probs.setValueAtLocation (singleLoc, prev + newVal);
  }
  Flops.increment (numLocs);
}
 

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;
}
 

import cc.mallet.grmm.util.Flops; //导入方法依赖的package包/类
public void timesEquals (double v)
{
  Flops.increment (probs.numLocations ());
  probs.timesEquals (v);
}
 

import cc.mallet.grmm.util.Flops; //导入方法依赖的package包/类
public double sum ()
{
  Flops.increment (probs.numLocations ());
  return probs.oneNorm ();
}
 

import cc.mallet.grmm.util.Flops; //导入方法依赖的package包/类
protected void plusEqualsAtLocation (int loc, double v)
{
  Flops.increment (1);
  double oldVal = valueAtLocation (loc);
  setRawValue (loc, oldVal + v);
}
 

import cc.mallet.grmm.util.Flops; //导入方法依赖的package包/类
public void exponentiate (double power)
{
  Flops.increment (probs.numLocations ());
  probs.timesEquals (power);
}