gt:     int currLastID = lastID + 1;
context: /*
   *   This program is free software: you can redistribute it and/or modify
   *   it under the terms of the GNU General Public License as published by
   *   the Free Software Foundation, either version 3 of the License, or
   *   (at your option) any later version.
   *
   *   This program is distributed in the hope that it will be useful,
   *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *   GNU General Public License for more details.
   *
   *   You should have received a copy of the GNU General Public License
   *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  /*
   *    ClassifierTree.java
   *    Copyright (C) 1999-2012 University of Waikato, Hamilton, New Zealand
   *
   */
  
  package weka.classifiers.trees.j48;
  
  import java.io.Serializable;
  
  import weka.core.Capabilities;
  import weka.core.CapabilitiesHandler;
  import weka.core.Drawable;
  import weka.core.Instance;
  import weka.core.Instances;
  import weka.core.RevisionHandler;
  import weka.core.RevisionUtils;
  import weka.core.Utils;
  
  /**
   * Class for handling a tree structure used for
   * classification.
   *
   * @author Eibe Frank (eibe@cs.waikato.ac.nz)
   * @version $Revision: 8034 $
   */
  public class ClassifierTree 
    implements Drawable, Serializable, CapabilitiesHandler, RevisionHandler {
  
    /** for serialization */
    static final long serialVersionUID = -8722249377542734193L;
    
    /** The model selection method. */  
    protected ModelSelection m_toSelectModel;     
  
    /** Local model at node. */
    protected ClassifierSplitModel m_localModel;  
  
    /** References to sons. */
    protected ClassifierTree [] m_sons;           
  
    /** True if node is leaf. */
    protected boolean m_isLeaf;                   
  
    /** True if node is empty. */
    protected boolean m_isEmpty;                  
  
    /** The training instances. */
    protected Instances m_train;                  
  
    /** The pruning instances. */
    protected Distribution m_test;     
  
    /** The id for the node. */
    protected int m_id;
  
    /** 
     * For getting a unique ID when outputting the tree (hashcode isn't
     * guaranteed unique) 
     */
    private static long PRINTED_NODES = 0;
  
    /**
     * Gets the next unique node ID.
     *
     * @return the next unique node ID.
     */
    protected static long nextID() {
  
      return PRINTED_NODES ++;
    }
  
    /**
     * Resets the unique node ID counter (e.g.
     * between repeated separate print types)
     */
    protected static void resetID() {
  
      PRINTED_NODES = 0;
    }
  
    /**
     * Constructor. 
     */
    public ClassifierTree(ModelSelection toSelectLocModel) {
      
      m_toSelectModel = toSelectLocModel;
    }
  
    /**
     * Returns default capabilities of the classifier tree.
     *
     * @return      the capabilities of this classifier tree
     */
    public Capabilities getCapabilities() {
      Capabilities result = new Capabilities(this);
      result.enableAll();
      
      return result;
    }
  
    /**
     * Method for building a classifier tree.
     *
     * @param data the data to build the tree from
     * @throws Exception if something goes wrong
     */
    public void buildClassifier(Instances data) throws Exception {
  
      // can classifier tree handle the data?
      getCapabilities().testWithFail(data);
  
      // remove instances with missing class
      data = new Instances(data);
      data.deleteWithMissingClass();
      
      buildTree(data, false);
    }
  
    /**
     * Builds the tree structure.
     *
     * @param data the data for which the tree structure is to be
     * generated.
     * @param keepData is training data to be kept?
     * @throws Exception if something goes wrong
     */
    public void buildTree(Instances data, boolean keepData) throws Exception {
      
      Instances [] localInstances;
  
      if (keepData) {
        m_train = data;
      }
      m_test = null;
      m_isLeaf = false;
      m_isEmpty = false;
      m_sons = null;
      m_localModel = m_toSelectModel.selectModel(data);
      if (m_localModel.numSubsets() > 1) {
        localInstances = m_localModel.split(data);
        data = null;
        m_sons = new ClassifierTree [m_localModel.numSubsets()];
        for (int i = 0; i < m_sons.length; i++) {
  	m_sons[i] = getNewTree(localInstances[i]);
  	localInstances[i] = null;
        }
      }else{
        m_isLeaf = true;
        if (Utils.eq(data.sumOfWeights(), 0))
  	m_isEmpty = true;
        data = null;
      }
    }
  
    /**
     * Builds the tree structure with hold out set
     *
     * @param train the data for which the tree structure is to be
     * generated.
     * @param test the test data for potential pruning
     * @param keepData is training Data to be kept?
     * @throws Exception if something goes wrong
     */
    public void buildTree(Instances train, Instances test, boolean keepData)
         throws Exception {
      
      Instances [] localTrain, localTest;
      int i;
      
      if (keepData) {
        m_train = train;
      }
      m_isLeaf = false;
      m_isEmpty = false;
      m_sons = null;
      m_localModel = m_toSelectModel.selectModel(train, test);
      m_test = new Distribution(test, m_localModel);
      if (m_localModel.numSubsets() > 1) {
        localTrain = m_localModel.split(train);
        localTest = m_localModel.split(test);
        train = test = null;
        m_sons = new ClassifierTree [m_localModel.numSubsets()];
        for (i=0;i<m_sons.length;i++) {
  	m_sons[i] = getNewTree(localTrain[i], localTest[i]);
  	localTrain[i] = null;
  	localTest[i] = null;
        }
      }else{
        m_isLeaf = true;
        if (Utils.eq(train.sumOfWeights(), 0))
  	m_isEmpty = true;
        train = test = null;
      }
    }
  
    /** 
     * Classifies an instance.
     *
     * @param instance the instance to classify
     * @return the classification
     * @throws Exception if something goes wrong
     */
    public double classifyInstance(Instance instance) 
      throws Exception {
  
      double maxProb = -1;
      double currentProb;
      int maxIndex = 0;
      int j;
  
      for (j = 0; j < instance.numClasses(); j++) {
        currentProb = getProbs(j, instance, 1);
        if (Utils.gr(currentProb,maxProb)) {
  	maxIndex = j;
  	maxProb = currentProb;
        }
      }
  
      return (double)maxIndex;
    }
  
    /**
     * Cleanup in order to save memory.
     * 
     * @param justHeaderInfo
     */
    public final void cleanup(Instances justHeaderInfo) {
  
      m_train = justHeaderInfo;
      m_test = null;
      if (!m_isLeaf)
        for (int i = 0; i < m_sons.length; i++)
  	m_sons[i].cleanup(justHeaderInfo);
    }
  
    /** 
     * Returns class probabilities for a weighted instance.
     *
     * @param instance the instance to get the distribution for
     * @param useLaplace whether to use laplace or not
     * @return the distribution
     * @throws Exception if something goes wrong
     */
    public final double [] distributionForInstance(Instance instance,
  						 boolean useLaplace) 
         throws Exception {
  
      double [] doubles = new double[instance.numClasses()];
  
      for (int i = 0; i < doubles.length; i++) {
        if (!useLaplace) {
  	doubles[i] = getProbs(i, instance, 1);
        } else {
  	doubles[i] = getProbsLaplace(i, instance, 1);
        }
      }
  
      return doubles;
    }
  
    /**
     * Assigns a uniqe id to every node in the tree.
     * 
     * @param lastID the last ID that was assign
     * @return the new current ID
     */
    public int assignIDs(int lastID) {
  
  