removewithvalues.java

一个数据挖掘软件ALPHAMINERR的整个过程的JAVA版源代码

     * @return true if the filtered instance may now be collected with output().
     * @exception IllegalStateException
     *                if no input format has been set.
     */
    public boolean input(Instance instance) {

        if (getInputFormat() == null) {
            throw new IllegalStateException("No input instance format defined");
        }
        if (m_NewBatch) {
            resetQueue();
            m_NewBatch = false;
        }
        if (instance.isMissing(m_AttIndex.getIndex())) {
            if (!getMatchMissingValues()) {
                push((Instance) instance.copy());
                return true;
            } else {
                return false;
            }
        }
        if (isNumeric()) {
            if (!m_Values.getInvert()) {
                if (instance.value(m_AttIndex.getIndex()) < m_Value) {
                    push((Instance) instance.copy());
                    return true;
                }
            } else {
                if (instance.value(m_AttIndex.getIndex()) >= m_Value) {
                    push((Instance) instance.copy());
                    return true;
                }
            }
        }
        if (isNominal()) {
            if (m_Values.isInRange((int) instance.value(m_AttIndex.getIndex()))) {
                Instance temp = (Instance) instance.copy();
                if (getModifyHeader()) {
                    temp.setValue(m_AttIndex.getIndex(),
                            m_NominalMapping[(int) instance.value(m_AttIndex
                                    .getIndex())]);
                }
                push(temp);
                return true;
            }
        }
        return false;
    }

    /**
     * Returns true if selection attribute is nominal.
     * 
     * @return true if selection attribute is nominal
     */
    public boolean isNominal() {

        if (getInputFormat() == null) {
            return false;
        } else {
            return getInputFormat().attribute(m_AttIndex.getIndex())
                    .isNominal();
        }
    }

    /**
     * Returns true if selection attribute is numeric.
     * 
     * @return true if selection attribute is numeric
     */
    public boolean isNumeric() {

        if (getInputFormat() == null) {
            return false;
        } else {
            return getInputFormat().attribute(m_AttIndex.getIndex())
                    .isNumeric();
        }
    }

    /**
     * Returns the tip text for this property
     * 
     * @return tip text for this property suitable for displaying in the
     *         explorer/experimenter gui
     */
    public String modifyHeaderTipText() {
        return "When selecting on nominal attributes, removes header references to "
                + "excluded values.";
    }

    /**
     * Gets whether the header will be modified when selecting on nominal
     * attributes.
     * 
     * @return true if so.
     */
    public boolean getModifyHeader() {

        return m_ModifyHeader;
    }

    /**
     * Sets whether the header will be modified when selecting on nominal
     * attributes.
     * 
     * @param newModifyHeader
     *            true if so.
     */
    public void setModifyHeader(boolean newModifyHeader) {

        m_ModifyHeader = newModifyHeader;
    }

    /**
     * Returns the tip text for this property
     * 
     * @return tip text for this property suitable for displaying in the
     *         explorer/experimenter gui
     */
    public String attributeIndexTipText() {
        return "Choose attribute to be used for selection (default last).";
    }

    /**
     * Get the index of the attribute used.
     * 
     * @return the index of the attribute
     */
    public String getAttributeIndex() {

        return m_AttIndex.getSingleIndex();
    }

    /**
     * Sets index of the attribute used.
     * 
     * @param index
     *            the index of the attribute
     */
    public void setAttributeIndex(String attIndex) {

        m_AttIndex.setSingleIndex(attIndex);
    }

    /**
     * Returns the tip text for this property
     * 
     * @return tip text for this property suitable for displaying in the
     *         explorer/experimenter gui
     */
    public String splitPointTipText() {
        return "Numeric value to be used for selection on numeric attribute. "
                + "Instances with values smaller than given value will be selected.";
    }

    /**
     * Get the split point used for numeric selection
     * 
     * @return the numeric split point
     */
    public double getSplitPoint() {

        return m_Value;
    }

    /**
     * Split point to be used for selection on numeric attribute.
     * 
     * @param value
     *            the split point
     */
    public void setSplitPoint(double value) {

        m_Value = value;
    }

    /**
     * Returns the tip text for this property
     * 
     * @return tip text for this property suitable for displaying in the
     *         explorer/experimenter gui
     */
    public String matchMissingValuesTipText() {
        return "Missing values count as a match. This setting is independent of "
                + "the invertSelection option.";
    }

    /**
     * Gets whether missing values are counted as a match.
     * 
     * @return true if missing values are counted as a match.
     */
    public boolean getMatchMissingValues() {

        return m_MatchMissingValues;
    }

    /**
     * Sets whether missing values are counted as a match.
     * 
     * @param newMatchMissingValues
     *            true if missing values are counted as a match.
     */
    public void setMatchMissingValues(boolean newMatchMissingValues) {

        m_MatchMissingValues = newMatchMissingValues;
    }

    /**
     * Returns the tip text for this property
     * 
     * @return tip text for this property suitable for displaying in the
     *         explorer/experimenter gui
     */
    public String invertSelectionTipText() {
        return "Invert matching sense.";
    }

    /**
     * Get whether the supplied columns are to be removed or kept
     * 
     * @return true if the supplied columns will be kept
     */
    public boolean getInvertSelection() {

        return !m_Values.getInvert();
    }

    /**
     * Set whether selected values should be removed or kept. If true the
     * selected values are kept and unselected values are deleted.
     * 
     * @param invert
     *            the new invert setting
     */
    public void setInvertSelection(boolean invert) {

        m_Values.setInvert(!invert);
    }

    /**
     * Returns the tip text for this property
     * 
     * @return tip text for this property suitable for displaying in the
     *         explorer/experimenter gui
     */
    public String nominalIndicesTipText() {
        return "Range of label indices to be used for selection on nominal attribute. "
                + "First and last are valid indexes.";
    }

    /**
     * Get the set of nominal value indices that will be used for selection
     *
     * @return rangeList a string representing the list of nominal indices.
     */
    public String getNominalIndices() {

        return m_Values.getRanges();
    }

    /**
     * Set which nominal labels are to be included in the selection.
     *
     * @param rangeList a string representing the list of nominal indices.
     * eg: first-3,5,6-last
     * @exception InvalidArgumentException if an invalid range list is supplied
     */
    public void setNominalIndices(String rangeList) {

        m_Values.setRanges(rangeList);
    }

    /**
     * Set which values of a nominal attribute are to be used for
     * selection.
     *
     * @param values an array containing indexes of values to be
     * used for selection
     * @exception InvalidArgumentException if an invalid set of ranges is supplied
     */
    public void setNominalIndicesArr(int[] values) {

        String rangeList = "";
        for (int i = 0; i < values.length; i++) {
            if (i == 0) {
                rangeList = "" + (values[i] + 1);
            } else {
                rangeList += "," + (values[i] + 1);
            }
        }
        setNominalIndices(rangeList);
    }

    /**
     * Main method for testing this class.
     *
     * @param argv should contain arguments to the filter: 
     * use -h for help
     */
    public static void main(String[] argv) {

        try {
            if (Utils.getFlag('b', argv)) {
                Filter.batchFilterFile(new RemoveWithValues(), argv);
            } else {
                Filter.filterFile(new RemoveWithValues(), argv);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println(ex.getMessage());
        }
    }
}