} else if (m_unpruned) {	throw new Exception("Doesn't make sense to change confidence for unpruned "			    +"tree!");      } else {	m_CF = (new Float(confidenceString)).floatValue();	if ((m_CF <= 0) || (m_CF >= 1)) {	  throw new Exception("Confidence has to be greater than zero and smaller " +			      "than one!");	}      }    } else {      m_CF = 0.25f;    }    String numFoldsString = Utils.getOption('N', options);    if (numFoldsString.length() != 0) {      if (!m_reducedErrorPruning) {	throw new Exception("Setting the number of folds" +			    " doesn't make sense if" +			    " reduced error pruning is not selected.");      } else {	m_numFolds = Integer.parseInt(numFoldsString);      }    } else {      m_numFolds = 3;    }    String seedString = Utils.getOption('Q', options);    if (seedString.length() != 0) {      m_Seed = Integer.parseInt(seedString);    } else {      m_Seed = 1;    }  }  /**   * Gets the current settings of the Classifier.   *   * @return an array of strings suitable for passing to setOptions   */  public String [] getOptions() {    String [] options = new String [14];    int current = 0;    if (m_noCleanup) {      options[current++] = "-L";    }    if (m_unpruned) {      options[current++] = "-U";    } else {      if (!m_subtreeRaising) {	options[current++] = "-S";      }      if (m_reducedErrorPruning) {	options[current++] = "-R";	options[current++] = "-N"; options[current++] = "" + m_numFolds;	options[current++] = "-Q"; options[current++] = "" + m_Seed;      } else {	options[current++] = "-C"; options[current++] = "" + m_CF;      }    }    if (m_binarySplits) {      options[current++] = "-B";    }    options[current++] = "-M"; options[current++] = "" + m_minNumObj;    if (m_useLaplace) {      options[current++] = "-A";    }    while (current < options.length) {      options[current++] = "";    }    return options;  }  /**   * Returns the tip text for this property   * @return tip text for this property suitable for   * displaying in the explorer/experimenter gui   */  public String seedTipText() {    return "The seed used for randomizing the data " +      "when reduced-error pruning is used.";  }  /**   * Get the value of Seed.   *   * @return Value of Seed.   */  public int getSeed() {        return m_Seed;  }    /**   * Set the value of Seed.   *   * @param newSeed Value to assign to Seed.   */  public void setSeed(int newSeed) {        m_Seed = newSeed;  }  /**   * Returns the tip text for this property   * @return tip text for this property suitable for   * displaying in the explorer/experimenter gui   */  public String useLaplaceTipText() {    return "Whether counts at leaves are smoothed based on Laplace.";  }  /**   * Get the value of useLaplace.   *   * @return Value of useLaplace.   */  public boolean getUseLaplace() {        return m_useLaplace;  }    /**   * Set the value of useLaplace.   *   * @param newuseLaplace Value to assign to useLaplace.   */  public void setUseLaplace(boolean newuseLaplace) {        m_useLaplace = newuseLaplace;  }    /**   * Returns a description of the classifier.   *    * @return a description of the classifier   */  public String toString() {    if (m_root == null) {      return "No classifier built";    }    if (m_unpruned)      return "J48 unpruned tree\n------------------\n" + m_root.toString();    else      return "J48 pruned tree\n------------------\n" + m_root.toString();  }  /**   * Returns a superconcise version of the model   *    * @return a summary of the model   */  public String toSummaryString() {    return "Number of leaves: " + m_root.numLeaves() + "\n"         + "Size of the tree: " + m_root.numNodes() + "\n";  }  /**   * Returns the size of the tree   * @return the size of the tree   */  public double measureTreeSize() {    return m_root.numNodes();  }  /**   * Returns the number of leaves   * @return the number of leaves   */  public double measureNumLeaves() {    return m_root.numLeaves();  }  /**   * Returns the number of rules (same as number of leaves)   * @return the number of rules   */  public double measureNumRules() {    return m_root.numLeaves();  }    /**   * Returns an enumeration of the additional measure names   * @return an enumeration of the measure names   */  public Enumeration enumerateMeasures() {    Vector newVector = new Vector(3);    newVector.addElement("measureTreeSize");    newVector.addElement("measureNumLeaves");    newVector.addElement("measureNumRules");    return newVector.elements();  }  /**   * Returns the value of the named measure   * @param additionalMeasureName the name of the measure to query for its value   * @return the value of the named measure   * @throws IllegalArgumentException if the named measure is not supported   */  public double getMeasure(String additionalMeasureName) {    if (additionalMeasureName.compareToIgnoreCase("measureNumRules") == 0) {      return measureNumRules();    } else if (additionalMeasureName.compareToIgnoreCase("measureTreeSize") == 0) {      return measureTreeSize();    } else if (additionalMeasureName.compareToIgnoreCase("measureNumLeaves") == 0) {      return measureNumLeaves();    } else {      throw new IllegalArgumentException(additionalMeasureName 			  + " not supported (j48)");    }  }    /**   * Returns the tip text for this property   * @return tip text for this property suitable for   * displaying in the explorer/experimenter gui   */  public String unprunedTipText() {    return "Whether pruning is performed.";  }  /**   * Get the value of unpruned.   *   * @return Value of unpruned.   */  public boolean getUnpruned() {        return m_unpruned;  }    /**   * Set the value of unpruned. Turns reduced-error pruning   * off if set.   * @param v  Value to assign to unpruned.   */  public void setUnpruned(boolean v) {    if (v) {      m_reducedErrorPruning = false;    }    m_unpruned = v;  }  /**   * Returns the tip text for this property   * @return tip text for this property suitable for   * displaying in the explorer/experimenter gui   */  public String confidenceFactorTipText() {    return "The confidence factor used for pruning (smaller values incur "      + "more pruning).";  }    /**   * Get the value of CF.   *   * @return Value of CF.   */  public float getConfidenceFactor() {        return m_CF;  }    /**   * Set the value of CF.   *   * @param v  Value to assign to CF.   */  public void setConfidenceFactor(float v) {        m_CF = v;  }     /**   * Returns the tip text for this property   * @return tip text for this property suitable for   * displaying in the explorer/experimenter gui   */  public String minNumObjTipText() {    return "The minimum number of instances per leaf.";  }  /**   * Get the value of minNumObj.   *   * @return Value of minNumObj.   */  public int getMinNumObj() {        return m_minNumObj;  }    /**   * Set the value of minNumObj.   *   * @param v  Value to assign to minNumObj.   */  public void setMinNumObj(int v) {        m_minNumObj = v;  }  /**   * Returns the tip text for this property   * @return tip text for this property suitable for   * displaying in the explorer/experimenter gui   */  public String reducedErrorPruningTipText() {    return "Whether reduced-error pruning is used instead of C.4.5 pruning.";  }   /**   * Get the value of reducedErrorPruning.    *   * @return Value of reducedErrorPruning.   */  public boolean getReducedErrorPruning() {        return m_reducedErrorPruning;  }    /**   * Set the value of reducedErrorPruning. Turns   * unpruned trees off if set.   *   * @param v  Value to assign to reducedErrorPruning.   */  public void setReducedErrorPruning(boolean v) {        if (v) {      m_unpruned = false;    }    m_reducedErrorPruning = v;  }    /**   * Returns the tip text for this property   * @return tip text for this property suitable for   * displaying in the explorer/experimenter gui   */  public String numFoldsTipText() {    return "Determines the amount of data used for reduced-error pruning. "      + " One fold is used for pruning, the rest for growing the tree.";  }  /**   * Get the value of numFolds.   *   * @return Value of numFolds.   */  public int getNumFolds() {        return m_numFolds;  }    /**   * Set the value of numFolds.   *   * @param v  Value to assign to numFolds.   */  public void setNumFolds(int v) {        m_numFolds = v;  }   /**   * Returns the tip text for this property   * @return tip text for this property suitable for   * displaying in the explorer/experimenter gui   */  public String binarySplitsTipText() {    return "Whether to use binary splits on nominal attributes when "      + "building the trees.";  }    /**   * Get the value of binarySplits.   *   * @return Value of binarySplits.   */  public boolean getBinarySplits() {        return m_binarySplits;  }    /**   * Set the value of binarySplits.   *   * @param v  Value to assign to binarySplits.   */  public void setBinarySplits(boolean v) {        m_binarySplits = v;  }    /**   * Returns the tip text for this property   * @return tip text for this property suitable for   * displaying in the explorer/experimenter gui   */  public String subtreeRaisingTipText() {    return "Whether to consider the subtree raising operation when pruning.";  }   /**   * Get the value of subtreeRaising.   *   * @return Value of subtreeRaising.   */  public boolean getSubtreeRaising() {        return m_subtreeRaising;  }    /**   * Set the value of subtreeRaising.   *   * @param v  Value to assign to subtreeRaising.   */  public void setSubtreeRaising(boolean v) {        m_subtreeRaising = v;  }  /**   * Returns the tip text for this property   * @return tip text for this property suitable for   * displaying in the explorer/experimenter gui   */  public String saveInstanceDataTipText() {    return "Whether to save the training data for visualization.";  }  /**   * Check whether instance data is to be saved.   *   * @return true if instance data is saved   */  public boolean getSaveInstanceData() {        return m_noCleanup;  }    /**   * Set whether instance data is to be saved.   * @param v true if instance data is to be saved   */  public void setSaveInstanceData(boolean v) {        m_noCleanup = v;  }    /**   * Returns the revision string.   *    * @return		the revision   */  public String getRevision() {    return RevisionUtils.extract("$Revision: 1.9 $");  }   /**   * Main method for testing this class   *   * @param argv the commandline options   */  public static void main(String [] argv){    runClassifier(new J48(), argv);  }}