Java tutorial
/* * 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/>. */ /* * Remove.java * Copyright (C) 1999-2012 University of Waikato, Hamilton, New Zealand * */ package weka.filters.unsupervised.attribute; import java.util.ArrayList; import java.util.Enumeration; import java.util.Vector; import weka.core.*; import weka.core.Capabilities.Capability; import weka.filters.Filter; import weka.filters.StreamableFilter; import weka.filters.UnsupervisedFilter; /** * <!-- globalinfo-start --> An filter that removes a range of attributes from * the dataset. Will re-order the remaining attributes if invert matching sense * is turned on and the attribute column indices are not specified in ascending * order. * <p/> * <!-- globalinfo-end --> * * <!-- options-start --> Valid options are: * <p/> * * <pre> * -R <index1,index2-index4,...> * Specify list of columns to delete. First and last are valid * indexes. (default none) * </pre> * * <pre> * -V * Invert matching sense (i.e. only keep specified columns) * </pre> * * <!-- options-end --> * * @author Len Trigg (trigg@cs.waikato.ac.nz) * @version $Revision$ */ public class Remove extends Filter implements UnsupervisedFilter, StreamableFilter, OptionHandler, WeightedAttributesHandler, WeightedInstancesHandler { /** for serialization */ static final long serialVersionUID = 5011337331921522847L; /** Stores which columns to select as a funky range */ protected Range m_SelectCols = new Range(); /** * Stores the indexes of the selected attributes in order, once the dataset is * seen */ protected int[] m_SelectedAttributes; /** * Constructor so that we can initialize the Range variable properly. */ public Remove() { m_SelectCols.setInvert(true); } /** * Returns an enumeration describing the available options. * * @return an enumeration of all the available options. */ @Override public Enumeration<Option> listOptions() { Vector<Option> newVector = new Vector<Option>(2); newVector.addElement(new Option( "\tSpecify list of columns to delete. First and last are valid\n" + "\tindexes. (default none)", "R", 1, "-R <index1,index2-index4,...>")); newVector .addElement(new Option("\tInvert matching sense (i.e. only keep specified columns)", "V", 0, "-V")); return newVector.elements(); } /** * Parses a given list of options. * <p/> * * <!-- options-start --> Valid options are: * <p/> * * <pre> * -R <index1,index2-index4,...> * Specify list of columns to delete. First and last are valid * indexes. (default none) * </pre> * * <pre> * -V * Invert matching sense (i.e. only keep specified columns) * </pre> * * <!-- options-end --> * * @param options the list of options as an array of strings * @throws Exception if an option is not supported */ @Override public void setOptions(String[] options) throws Exception { String deleteList = Utils.getOption('R', options); if (deleteList.length() != 0) { setAttributeIndices(deleteList); } setInvertSelection(Utils.getFlag('V', options)); if (getInputFormat() != null) { setInputFormat(getInputFormat()); } Utils.checkForRemainingOptions(options); } /** * Gets the current settings of the filter. * * @return an array of strings suitable for passing to setOptions */ @Override public String[] getOptions() { Vector<String> options = new Vector<String>(); if (getInvertSelection()) { options.add("-V"); } if (!getAttributeIndices().equals("")) { options.add("-R"); options.add(getAttributeIndices()); } return options.toArray(new String[0]); } /** * Returns the Capabilities of this filter. * * @return the capabilities of this object * @see Capabilities */ @Override public Capabilities getCapabilities() { Capabilities result = super.getCapabilities(); result.disableAll(); // attributes result.enableAllAttributes(); result.enable(Capability.MISSING_VALUES); // class result.enableAllClasses(); result.enable(Capability.MISSING_CLASS_VALUES); result.enable(Capability.NO_CLASS); return result; } /** * Sets the format of the input instances. * * @param instanceInfo an Instances object containing the input instance * structure (any instances contained in the object are ignored - * only the structure is required). * @return true if the outputFormat may be collected immediately * @throws Exception if the format couldn't be set successfully */ @Override public boolean setInputFormat(Instances instanceInfo) throws Exception { super.setInputFormat(instanceInfo); m_SelectCols.setUpper(instanceInfo.numAttributes() - 1); // Create the output buffer ArrayList<Attribute> attributes = new ArrayList<Attribute>(); int outputClass = -1; m_SelectedAttributes = m_SelectCols.getSelection(); if (m_SelectedAttributes.length == instanceInfo.numAttributes()) { // Nothing is being removed setOutputFormat(instanceInfo); initInputLocators(getInputFormat(), m_SelectedAttributes); return true; } for (int current : m_SelectedAttributes) { if (instanceInfo.classIndex() == current) { outputClass = attributes.size(); } Attribute keep = (Attribute) instanceInfo.attribute(current).copy(); attributes.add(keep); } // initInputLocators(instanceInfo, m_SelectedAttributes); initInputLocators(getInputFormat(), m_SelectedAttributes); Instances outputFormat = new Instances(instanceInfo.relationName(), attributes, 0); outputFormat.setClassIndex(outputClass); setOutputFormat(outputFormat); return true; } /** * Input an instance for filtering. Ordinarily the instance is processed and * made available for output immediately. Some filters require all instances * be read before producing output. * * @param instance the input instance * @return true if the filtered instance may now be collected with output(). * @throws IllegalStateException if no input structure has been defined. */ @Override public boolean input(Instance instance) { if (getInputFormat() == null) { throw new IllegalStateException("No input instance format defined"); } if (m_NewBatch) { resetQueue(); m_NewBatch = false; } if (getOutputFormat().numAttributes() == 0) { return false; } Instance inst; if (m_SelectedAttributes.length == getInputFormat().numAttributes()) { // Nothing is being removed inst = (Instance) instance.copy(); inst.setDataset(null); } else { double[] vals = new double[getOutputFormat().numAttributes()]; for (int i = 0; i < m_SelectedAttributes.length; i++) { int current = m_SelectedAttributes[i]; vals[i] = instance.value(current); } if (instance instanceof SparseInstance) { inst = new SparseInstance(instance.weight(), vals); } else { inst = new DenseInstance(instance.weight(), vals); } } copyValues(inst, false, instance.dataset(), outputFormatPeek()); push(inst); // No need to copy return true; } /** * Returns a string describing this filter * * @return a description of the filter suitable for displaying in the * explorer/experimenter gui */ public String globalInfo() { return "A filter that removes a range of" + " attributes from the dataset. Will " + "re-order the remaining attributes " + "if invert matching sense is turned " + "on and the attribute column indices " + "are not specified in ascending order."; } /** * 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 "Determines whether action is to select or delete." + " If set to true, only the specified attributes will be kept;" + " If set to false, specified attributes will be deleted."; } /** * 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_SelectCols.getInvert(); } /** * Set whether selected columns should be removed or kept. If true the * selected columns are kept and unselected columns are deleted. If false * selected columns are deleted and unselected columns are kept. * * @param invert the new invert setting */ public void setInvertSelection(boolean invert) { m_SelectCols.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 attributeIndicesTipText() { return "Specify range of attributes to act on." + " This is a comma separated list of attribute indices, with" + " \"first\" and \"last\" valid values. Specify an inclusive" + " range with \"-\". E.g: \"first-3,5,6-10,last\"."; } /** * Get the current range selection. * * @return a string containing a comma separated list of ranges */ public String getAttributeIndices() { return m_SelectCols.getRanges(); } /** * Set which attributes are to be deleted (or kept if invert is true) * * @param rangeList a string representing the list of attributes. Since the * string will typically come from a user, attributes are indexed * from 1. <br> * eg: first-3,5,6-last */ public void setAttributeIndices(String rangeList) { m_SelectCols.setRanges(rangeList); } /** * Set which attributes are to be deleted (or kept if invert is true) * * @param attributes an array containing indexes of attributes to select. * Since the array will typically come from a program, attributes are * indexed from 0. */ public void setAttributeIndicesArray(int[] attributes) { setAttributeIndices(Range.indicesToRangeList(attributes)); } /** * Returns the revision string. * * @return the revision */ @Override public String getRevision() { return RevisionUtils.extract("$Revision$"); } /** * Main method for testing this class. * * @param argv should contain arguments to the filter: use -h for help */ public static void main(String[] argv) { runFilter(new Remove(), argv); } }