Java Utils.grOrEq方法代码示例

import weka.core.Utils; //导入方法依赖的package包/类
/**
 * Checks if at least two bags contain a minimum number of instances.
 */
public final boolean check(double minNoObj) {

  int counter = 0;
  int i;

  for (i = 0; i < m_perBag.length; i++) {
    if (Utils.grOrEq(m_perBag[i], minNoObj)) {
      counter++;
    }
  }
  if (counter > 1) {
    return true;
  } else {
    return false;
  }
}
 

import weka.core.Utils; //导入方法依赖的package包/类
/**
 * Returns index of bag containing maximum number of instances.
 */
public final int maxBag() {

  double max;
  int maxIndex;
  int i;

  max = 0;
  maxIndex = -1;
  for (i = 0; i < m_perBag.length; i++) {
    if (Utils.grOrEq(m_perBag[i], max)) {
      max = m_perBag[i];
      maxIndex = i;
    }
  }
  return maxIndex;
}
 

import weka.core.Utils; //导入方法依赖的package包/类
/**
 * Determine whether the scheme performs worse than ZeroR during testing
 * 
 * @param classifier the pre-trained classifier
 * @param evaluation the classifier evaluation object
 * @param train the training data
 * @param test the test data
 * @return index 0 is true if the scheme performs better than ZeroR
 * @throws Exception if there was a problem during the scheme's testing
 */
protected boolean[] testWRTZeroR(Classifier classifier,
  Evaluation evaluation, Instances train, Instances test) throws Exception {

  boolean[] result = new boolean[2];

  evaluation.evaluateModel(classifier, test);
  try {

    // Tested OK, compare with ZeroR
    Classifier zeroR = new weka.classifiers.rules.ZeroR();
    zeroR.buildClassifier(train);
    Evaluation zeroREval = new Evaluation(train);
    zeroREval.evaluateModel(zeroR, test);
    result[0] = Utils.grOrEq(zeroREval.errorRate(), evaluation.errorRate());
  } catch (Exception ex) {
    throw new Error("Problem determining ZeroR performance: "
      + ex.getMessage());
  }

  return result;
}
 

import weka.core.Utils; //导入方法依赖的package包/类
/**
 * Choose last index (ie. choose rule).
 */
public final int chooseLastIndex() {

  int minIndex = 0;
  double estimated, min = Double.MAX_VALUE;

  if (!m_isLeaf) {
    for (int i = 0; i < m_sons.length; i++) {
      if (son(i) != null) {
        if (Utils.grOrEq(localModel().distribution().perBag(i), m_minNumObj)) {
          estimated = son(i).getSizeOfBranch();
          if (Utils.sm(estimated, min)) {
            min = estimated;
            minIndex = i;
          }
        }
      }
    }
  }

  return minIndex;
}
 

import weka.core.Utils; //导入方法依赖的package包/类
/**
 * Creates split on enumerated attribute.
 * 
 * @exception Exception if something goes wrong
 */
private void handleEnumeratedAttribute(Instances trainInstances)
  throws Exception {

  Distribution newDistribution, secondDistribution;
  int numAttValues;
  double currIG, currGR;
  Instance instance;
  int i;

  numAttValues = trainInstances.attribute(m_attIndex).numValues();
  newDistribution = new Distribution(numAttValues,
    trainInstances.numClasses());

  // Only Instances with known values are relevant.
  Enumeration<Instance> enu = trainInstances.enumerateInstances();
  while (enu.hasMoreElements()) {
    instance = enu.nextElement();
    if (!instance.isMissing(m_attIndex)) {
      newDistribution.add((int) instance.value(m_attIndex), instance);
    }
  }
  m_distribution = newDistribution;

  // For all values
  for (i = 0; i < numAttValues; i++) {

    if (Utils.grOrEq(newDistribution.perBag(i), m_minNoObj)) {
      secondDistribution = new Distribution(newDistribution, i);

      // Check if minimum number of Instances in the two
      // subsets.
      if (secondDistribution.check(m_minNoObj)) {
        m_numSubsets = 2;
        currIG = m_infoGainCrit.splitCritValue(secondDistribution,
          m_sumOfWeights);
        currGR = m_gainRatioCrit.splitCritValue(secondDistribution,
          m_sumOfWeights, currIG);
        if ((i == 0) || Utils.gr(currGR, m_gainRatio)) {
          m_gainRatio = currGR;
          m_infoGain = currIG;
          m_splitPoint = i;
          m_distribution = secondDistribution;
        }
      }
    }
  }
}