findwithcapabilities.java

矩阵的QR分解算法

/*
 *    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 2 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, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*
 * FindWithCapabilities.java
 * Copyright (C) 2006 University of Waikato, Hamilton, New Zealand
 */

package weka.core;

import weka.core.Capabilities.Capability;
import weka.gui.GenericPropertiesCreator;

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.Vector;

/**
 * Locates all classes with certain capabilities. One should keep in mind, 
 * that works only with the default capabilities of a scheme and doesn't
 * take dependencies into account. E.g., a meta-classifier that could have
 * a base classifier handling numeric classes, but by default uses one with
 * a nominal class, will never show up in a search for schemes that handle
 * numeric classes.<p/>
 * 
 <!-- options-start -->
 * Valid options are: <p/>
 * 
 * <pre> All class and attribute options can be prefixed with 'not',
 * e.g., '-not-numeric-class'. This makes sure that the returned
 * schemes 'cannot' handle numeric classes.
 * </pre>
 * 
 * <pre> -num-instances &lt;num&gt;
 *  The minimum number of instances (default 1).</pre>
 * 
 * <pre> -unary-class
 *  Must handle unray classes.</pre>
 * 
 * <pre> -binary-class
 *  Must handle binary classes.</pre>
 * 
 * <pre> -nominal-class
 *  Must handle nominal classes.</pre>
 * 
 * <pre> -numeric-class
 *  Must handle numeric classes.</pre>
 * 
 * <pre> -string-class
 *  Must handle string classes.</pre>
 * 
 * <pre> -date-class
 *  Must handle date classes.</pre>
 * 
 * <pre> -relational-class
 *  Must handle relational classes.</pre>
 * 
 * <pre> -no-class
 *  Doesn't need a class.</pre>
 * 
 * <pre> -unary-atts
 *  Must handle unary attributes.</pre>
 * 
 * <pre> -binary-atts
 *  Must handle binary attributes.</pre>
 * 
 * <pre> -nominal-atts
 *  Must handle nominal attributes.</pre>
 * 
 * <pre> -numeric-atts
 *  Must handle numeric attributes.</pre>
 * 
 * <pre> -string-atts
 *  Must handle string attributes.</pre>
 * 
 * <pre> -date-atts
 *  Must handle date attributes.</pre>
 * 
 * <pre> -relational-atts
 *  Must handle relational attributes.</pre>
 * 
 * <pre> -only-multiinstance
 *  Must handle multi-instance data.</pre>
 * 
 * <pre> -W &lt;classname&gt;
 *  The Capabilities handler to base the handling on.
 *  The other parameters can be used to override the ones
 *  determined from the handler. Additional parameters for
 *  handler can be passed on after the '--'.
 *  Either '-W' or '-t' can be used.</pre>
 * 
 * <pre> -t &lt;file&gt;
 *  The dataset to base the capabilities on.
 *  The other parameters can be used to override the ones
 *  determined from the handler.
 *  Either '-t' or '-W' can be used.</pre>
 * 
 * <pre> -c &lt;num&gt;
 *  The index of the class attribute, -1 for none.
 *  'first' and 'last' are also valid.
 *  Only in conjunction with option '-t'.</pre>
 * 
 * <pre> -superclass
 *  Superclass to look for in the packages.
 * </pre>
 * 
 * <pre> -packages
 *  Comma-separated list of packages to search in.</pre>
 * 
 * <pre> -generic
 *  Retrieves the package list from the GenericPropertiesCreator
 *  for the given superclass. (overrides -packages &lt;list&gt;).</pre>
 * 
 * <pre> -misses
 *  Also prints the classname that didn't match the criteria.</pre>
 * 
 <!-- options-end -->
 * 
 * @author  fracpete (fracpete at waikato dot ac dot nz)
 * @version $Revision: 1.3 $
 * @see Capabilities
 * @see Capabilities.Capability
 * @see GenericPropertiesCreator
 */
public class FindWithCapabilities 
implements OptionHandler, CapabilitiesHandler {

  /** the capabilities to look for */
  protected Capabilities m_Capabilities = new Capabilities(this);

  /** the capabilities to look for to "not have" */
  protected Capabilities m_NotCapabilities = new Capabilities(this);

  /** the packages to search in */
  protected Vector m_Packages = new Vector();

  /** a capabilities handler to retrieve the capabilities from */
  protected CapabilitiesHandler m_Handler = null;

  /** a file the capabilities can be based on */
  protected String m_Filename = "";

  /** the class index, in case the capabilities are based on a file */
  protected SingleIndex m_ClassIndex = new SingleIndex();

  /** the superclass from the GenericPropertiesCreator to retrieve the packages from */
  protected String m_Superclass = "";

  /** whether to use the GenericPropertiesCreator with the superclass */
  protected boolean m_GenericPropertiesCreator = false;

  /** the classes that matched */
  protected Vector m_Matches = new Vector();

  /** the class that didn't match */
  protected Vector m_Misses = new Vector();

  /**
   * Returns an enumeration describing the available options.
   *
   * @return an enumeration of all the available options.
   */
  public Enumeration listOptions() {
    Vector result = new Vector();

    result.addElement(new Option(
	"", "", 0, 
	"All class and attribute options can be prefixed with 'not',\n"
	+ "e.g., '-not-numeric-class'. This makes sure that the returned\n"
	+ "schemes 'cannot' handle numeric classes."));

    result.addElement(new Option(
	"\tThe minimum number of instances (default 1).",
	"num-instances", 1, "-num-instances <num>"));

    result.addElement(new Option(
	"\tMust handle unray classes.",
	"unary-class", 0, "-unary-class"));

    result.addElement(new Option(
	"\tMust handle binary classes.",
	"binary-class", 0, "-binary-class"));

    result.addElement(new Option(
	"\tMust handle nominal classes.",
	"nominal-class", 0, "-nominal-class"));

    result.addElement(new Option(
	"\tMust handle numeric classes.",
	"numeric-class", 0, "-numeric-class"));

    result.addElement(new Option(
	"\tMust handle string classes.",
	"string-class", 0, "-string-class"));

    result.addElement(new Option(
	"\tMust handle date classes.",
	"date-class", 0, "-date-class"));

    result.addElement(new Option(
	"\tMust handle relational classes.",
	"relational-class", 0, "-relational-class"));

    result.addElement(new Option(
	"\tDoesn't need a class.",
	"no-class", 0, "-no-class"));

    result.addElement(new Option(
	"\tMust handle unary attributes.",
	"unary-atts", 0, "-unary-atts"));

    result.addElement(new Option(
	"\tMust handle binary attributes.",
	"binary-atts", 0, "-binary-atts"));

    result.addElement(new Option(
	"\tMust handle nominal attributes.",
	"nominal-atts", 0, "-nominal-atts"));

    result.addElement(new Option(
	"\tMust handle numeric attributes.",
	"numeric-atts", 0, "-numeric-atts"));

    result.addElement(new Option(
	"\tMust handle string attributes.",
	"string-atts", 0, "-string-atts"));

    result.addElement(new Option(
	"\tMust handle date attributes.",
	"date-atts", 0, "-date-atts"));

    result.addElement(new Option(
	"\tMust handle relational attributes.",
	"relational-atts", 0, "-relational-atts"));

    result.addElement(new Option(
	"\tMust handle multi-instance data.",
	"only-multiinstance", 0, "-only-multiinstance"));

    result.addElement(new Option(
	"\tThe Capabilities handler to base the handling on.\n"
	+ "\tThe other parameters can be used to override the ones\n"
	+ "\tdetermined from the handler. Additional parameters for\n"
	+ "\thandler can be passed on after the '--'.\n"
	+ "\tEither '-W' or '-t' can be used.",
	"W", 1, "-W <classname>"));

    result.addElement(new Option(
	"\tThe dataset to base the capabilities on.\n"
	+ "\tThe other parameters can be used to override the ones\n"
	+ "\tdetermined from the handler.\n"
	+ "\tEither '-t' or '-W' can be used.",
	"t", 1, "-t <file>"));

    result.addElement(new Option(
	"\tThe index of the class attribute, -1 for none.\n"
	+ "\t'first' and 'last' are also valid.\n"
	+ "\tOnly in conjunction with option '-t'.",
	"c", 1, "-c <num>"));

    result.addElement(new Option(
	"\tSuperclass to look for in the packages.\n",
	"superclass", 1, "-superclass"));

    result.addElement(new Option(
	"\tComma-separated list of packages to search in.",
	"packages", 1, "-packages"));

    result.addElement(new Option(
	"\tRetrieves the package list from the GenericPropertiesCreator\n"
	+ "\tfor the given superclass. (overrides -packages <list>).",
	"generic", 1, "-generic"));

    result.addElement(new Option(
	"\tAlso prints the classname that didn't match the criteria.",
	"misses", 0, "-misses"));

    return result.elements();
  }

  /**
   * Parses a given list of options. 
   *
   * @param options the list of options as an array of strings
   * @throws Exception if an option is not supported
   */
  public void setOptions(String[] options) throws Exception {
    String      		tmpStr;
    Class			cls;
    CapabilitiesHandler		handler;
    boolean			initialized;
    StringTokenizer		tok;
    GenericPropertiesCreator	creator;
    Properties			props;

    m_Capabilities = new Capabilities(this);
    initialized    = false;

    tmpStr = Utils.getOption('W', options);
    if (tmpStr.length() != 0) {
      cls = Class.forName(tmpStr);
      if (ClassDiscovery.hasInterface(CapabilitiesHandler.class, cls)) {
	initialized = true;
	handler = (CapabilitiesHandler) cls.newInstance();
	if (handler instanceof OptionHandler)
	  ((OptionHandler) handler).setOptions(Utils.partitionOptions(options));
	setHandler(handler);
      }
      else {
	throw new IllegalArgumentException("Class '" + tmpStr + "' is not a CapabilitiesHandler!");
      }
    }
    else {
      tmpStr = Utils.getOption('c', options);
      if (tmpStr.length() != 0)
	setClassIndex(tmpStr);
      else
	setClassIndex("last");

      tmpStr = Utils.getOption('t', options);
      setFilename(tmpStr);
    }

    tmpStr = Utils.getOption("num-instances", options);
    if (tmpStr.length() != 0)
      m_Capabilities.setMinimumNumberInstances(Integer.parseInt(tmpStr));
    else if (!initialized)
      m_Capabilities.setMinimumNumberInstances(1);

    // allowed
    if (Utils.getFlag("no-class", options))
      enable(Capability.NO_CLASS);
    // not allowed
    if (Utils.getFlag("not-no-class", options))
      enableNot(Capability.NO_CLASS);

    if (!m_Capabilities.handles(Capability.NO_CLASS)) {
      // allowed
      if (Utils.getFlag("nominal-class", options)) {
	enable(Capability.NOMINAL_CLASS);
	disable(Capability.BINARY_CLASS);
      }
      if (Utils.getFlag("binary-class", options)) {
	enable(Capability.BINARY_CLASS);
	disable(Capability.UNARY_CLASS);
      }
      if (Utils.getFlag("unary-class", options))
	enable(Capability.UNARY_CLASS);
      if (Utils.getFlag("numeric-class", options))
	enable(Capability.NUMERIC_CLASS);
      if (Utils.getFlag("string-class", options))
	enable(Capability.STRING_CLASS);
      if (Utils.getFlag("date-class", options))
	enable(Capability.DATE_CLASS);
      if (Utils.getFlag("relational-class", options))
	enable(Capability.RELATIONAL_CLASS);
    }
    // not allowed
    if (Utils.getFlag("not-nominal-class", options)) {
      enableNot(Capability.NOMINAL_CLASS);
      disableNot(Capability.BINARY_CLASS);
    }
    if (Utils.getFlag("not-binary-class", options)) {
      enableNot(Capability.BINARY_CLASS);
      disableNot(Capability.UNARY_CLASS);
    }
    if (Utils.getFlag("not-unary-class", options))
      enableNot(Capability.UNARY_CLASS);
    if (Utils.getFlag("not-numeric-class", options))
      enableNot(Capability.NUMERIC_CLASS);
    if (Utils.getFlag("not-string-class", options))
      enableNot(Capability.STRING_CLASS);
    if (Utils.getFlag("not-date-class", options))
      enableNot(Capability.DATE_CLASS);
    if (Utils.getFlag("not-relational-class", options))
      enableNot(Capability.RELATIONAL_CLASS);

    // allowed
    if (Utils.getFlag("nominal-atts", options)) {
      enable(Capability.NOMINAL_ATTRIBUTES);
      disable(Capability.BINARY_ATTRIBUTES);
    }
    if (Utils.getFlag("binary-atts", options)) {
      enable(Capability.BINARY_ATTRIBUTES);
      disable(Capability.UNARY_ATTRIBUTES);
    }
    if (Utils.getFlag("unary-atts", options))
      enable(Capability.UNARY_ATTRIBUTES);
    if (Utils.getFlag("numeric-atts", options))
      enable(Capability.NUMERIC_ATTRIBUTES);
    if (Utils.getFlag("string-atts", options))
      enable(Capability.STRING_ATTRIBUTES);
    if (Utils.getFlag("date-atts", options))
      enable(Capability.DATE_ATTRIBUTES);
    if (Utils.getFlag("relational-atts", options))
      enable(Capability.RELATIONAL_ATTRIBUTES);
    // not allowed
    if (Utils.getFlag("not-nominal-atts", options)) {
      enableNot(Capability.NOMINAL_ATTRIBUTES);
      disableNot(Capability.BINARY_ATTRIBUTES);
    }
    if (Utils.getFlag("not-binary-atts", options)) {
      enableNot(Capability.BINARY_ATTRIBUTES);
      disableNot(Capability.UNARY_ATTRIBUTES);
    }
    if (Utils.getFlag("not-unary-atts", options))
      enableNot(Capability.UNARY_ATTRIBUTES);
    if (Utils.getFlag("not-numeric-atts", options))
      enableNot(Capability.NUMERIC_ATTRIBUTES);
    if (Utils.getFlag("not-string-atts", options))
      enableNot(Capability.STRING_ATTRIBUTES);
    if (Utils.getFlag("not-date-atts", options))
      enableNot(Capability.DATE_ATTRIBUTES);
    if (Utils.getFlag("not-relational-atts", options))
      enableNot(Capability.RELATIONAL_ATTRIBUTES);

    if (Utils.getFlag("only-multiinstance", options))
      enable(Capability.ONLY_MULTIINSTANCE);

    tmpStr = Utils.getOption("superclass", options);
    if (tmpStr.length() != 0)
      m_Superclass = tmpStr;
    else
      throw new IllegalArgumentException("A superclass has to be specified!");

    tmpStr = Utils.getOption("packages", options);
    if (tmpStr.length() != 0) {
      tok        = new StringTokenizer(tmpStr, ",");
      m_Packages = new Vector();
      while (tok.hasMoreTokens())
	m_Packages.add(tok.nextToken());
    }

    if (Utils.getFlag("generic", options)) {
      creator    = new GenericPropertiesCreator();
      creator.execute(false);
      props	 = creator.getInputProperties();
      tok        = new StringTokenizer(props.getProperty(m_Superclass), ",");
      m_Packages = new Vector();
      while (tok.hasMoreTokens())
	m_Packages.add(tok.nextToken());
    }
  }

  /**
   * Gets the current settings of this object.
   * 
   * @return an array of strings suitable for passing to setOptions
   */
  public String[] getOptions() {
    Vector 	result;