www.pudn.com > id3ClaafierTreeCode.rar > ThresholdCategorizer.java

package id3; 
import java.lang.*; 
import java.io.*; 
import shared.*; 
 
/** Categorize an instance by comparing the value of a single attribute to a 
 * threshold value. All instances for which the attribute is less than or equal 
 * to the threshold value are put into one category and those for which the 
 * attribute is greater than the threshold value are put into a second category. 
 * The attribute must be Real. 
 * 
 * @author James Louis Java Implementation. 
 * @author Chia-Hsin Li 11/23/94 Add operator== 
 * @author Brian Frasca 4/12/94 Initial revision 
 */ 
public class ThresholdCategorizer extends NodeCategorizer { 
    private AttrInfo attrInfo; 
    /** 
     */ 
    private int attrNum; 
    private double thresholdVal; 
    /** "Less than or equal" to description. 
     */ 
    private String LTEDscr;  // "less than or equal to" description 
    /** "Greater than" description. 
     */ 
    private String  GTDscr;  // "greater than" description 
     
    static private String UNKNOWN_VAL_STRRC ="?"; 
     
    /** Construct a ThresholdCategorizer. 
     * @param sch The schema for information this categorizer categorizes. 
     * @param attributeNum The attribute number for this threshold. 
     * @param threshold The threshold value. 
     * @param dscr Description of this categorizer. 
     */ 
    public ThresholdCategorizer(Schema sch, 
    int attributeNum, 
    double threshold, 
    String dscr) { 
        super(2, dscr, sch); 
        attrInfo = sch.attr_info(attributeNum); 
        attrNum = attributeNum; 
         
        change_threshold(threshold); 
    } 
     
    /** Changes the threshold value. 
     * @param threshold The new threshold value. 
     */ 
    public void change_threshold(double threshold) { 
        thresholdVal = threshold; 
        // Added to match MLC mantissa length. -JL 
        String output = Double.toString(thresholdVal); 
        if(output.indexOf('.') != -1 && output.substring(output.indexOf('.'),output.length()).length() > 12) 
            output = output.substring(0,output.indexOf('.') + 12); 
        LTEDscr = "<= "+output; 
        GTDscr =  "> "+output; 
    } 
     
     
    /** Returns the id number for this class. 
     * @return The class id number. 
     * @deprecated Use java's instanceOf function. 
     */ 
    public int class_id(){ return CLASS_THRESHOLD_CATEGORIZER; } 
     
    /** Builds an array of 3 strings for the labels (?, <= x, and > x) of the edges 
     * depending from the node for which this is the categorizer. 
     * 
     * @return An array of the strings built. 
     */ 
    public String[] real_edge_strings() { 
        String LESS_THAN_OR_EQUAL = "<= "; 
        String GREATER_THAN = "> "; 
        String[] catNames = new String[3]; //(Globals.UNKNOWN_CATEGORY_VAL, 3); 
        // CatNames is an array of 3 MStrings: 
        //   unknown, left node (less than or equal to thresholdVal), or 
        //   right node (greater than thresholdVal). 
        catNames[Globals.UNKNOWN_CATEGORY_VAL] = Globals.UNKNOWN_VAL_STR; 
        catNames[Globals.UNKNOWN_CATEGORY_VAL+1] = LESS_THAN_OR_EQUAL 
        + thresholdVal; 
        catNames[Globals.UNKNOWN_CATEGORY_VAL+2] = GREATER_THAN 
        + thresholdVal; 
         
        return catNames; 
    } 
     
    /** Returns the edge label leading to the node that the given instance should use 
     * to continue scoring or categorization. 
     * 
     * @param inst The instance being scored. 
     * @return Returns the category found after traversing the categorizer. 
     */ 
    public AugCategory branch(Instance inst) { 
        //   DBG(inst.attr_info(attrNum).compatible_with(attrInfo, TRUE)); 
        if (attrInfo.is_unknown(inst.values[attrNum])) 
            return new AugCategory(Globals.UNKNOWN_CATEGORY_VAL, UNKNOWN_VAL_STRRC); 
        else if (attrInfo.get_real_val(inst.values[attrNum]) <= thresholdVal) 
            return new AugCategory(Globals.FIRST_CATEGORY_VAL, LTEDscr); 
        else 
            return new AugCategory(Globals.FIRST_CATEGORY_VAL+1, GTDscr); 
    } 
     
    /** Prints a readable representation of the Categorizer to the given stream. 
     * 
     * @param stream The BufferedWriter to be printed to. 
     * @param dp The display preferences. 
     */ 
    public void display_struct(BufferedWriter stream, 
    DisplayPref dp) { 
        //   if (stream.output_type() == XStream) 
        //      err << "ThresholdCategorizer::display_struct: Xstream is not a " 
        //          << "supported stream."  << fatal_error; 
         
        //   if (dp.preference_type() != DisplayPref::ASCIIDisplay) 
        //      err << "ThresholdCategorizer::display_struct: Only ASCIIDisplay is " 
        //          << "supported by ThresholdCategorizer."  << fatal_error; 
        try{ 
            stream.write("Threshold Categorizer "+description() 
            +" categorizing on attribute "+attrInfo.name()+'\n'); 
        }catch(IOException e){e.printStackTrace();} 
    } 
     
    /** Updates usedAttr to include the attributes used in this categorizer. 
     * 
     * @param usedAttr An array of used attributes. TRUE values indicate the attribute matched to that 
     * index number is used, FALSE indicates it is not. 
     */ 
    public void set_used_attr(boolean[] usedAttr) { 
        //   ASSERT (attrNum >= 0 && attrNum < usedAttr.size()); 
        usedAttr[attrNum] = true; 
    } 
}