mathexpression.java

代码是一个分类器的实现,其中使用了部分weka的源代码。可以将项目导入eclipse运行

	        newIndices[ind] = j;
	        ind++;
	      }
	  }
        }
      }	
      double[] tempVals = new double[ind];
      int[] tempInd = new int[ind];
      System.arraycopy(newVals, 0, tempVals, 0, ind);
      System.arraycopy(newIndices, 0, tempInd, 0, ind);
      inst = new SparseInstance(instance.weight(), tempVals, tempInd,
                                instance.numAttributes());
    } else {
      double[] vals = instance.toDoubleArray();
      for (int j = 0; j < getInputFormat().numAttributes(); j++) {
        if (m_SelectCols.isInRange(j)) {
	  if (instance.attribute(j).isNumeric() &&
	      (!Instance.isMissingValue(vals[j])) &&
	      (getInputFormat().classIndex() != j)) {
              symbols.put("A", new Double(vals[j]));  
              symbols.put("MAX", new Double(m_attStats[j].numericStats.max));
              symbols.put("MIN", new Double(m_attStats[j].numericStats.min));
              symbols.put("MEAN", new Double(m_attStats[j].numericStats.mean));
              symbols.put("SD", new Double(m_attStats[j].numericStats.stdDev));
              symbols.put("COUNT", new Double(m_attStats[j].numericStats.count));
              symbols.put("SUM", new Double(m_attStats[j].numericStats.sum));
              symbols.put("SUMSQUARED", new Double(m_attStats[j].numericStats.sumSq));
              vals[j] = m_expTree.eval(symbols);
              if (Double.isNaN(vals[j]) || Double.isInfinite(vals[j])) {
                  System.err.println("WARNING:Error in Evaluation the Expression: missing value set");
                  vals[j] = Instance.missingValue();
              }
	  }
        }
      }
      inst = new Instance(instance.weight(), vals);
    }
    inst.setDataset(instance.dataset());
    push(inst);
  }

  /**
   * Parses a given list of options. <p/>
   * 
   <!-- options-start -->
   * Valid options are: <p/>
   * 
   * <pre> -unset-class-temporarily
   *  Unsets the class index temporarily before the filter is
   *  applied to the data.
   *  (default: no)</pre>
   * 
   * <pre> -E &lt;expression&gt;
   *  Specify the expression to apply. Eg. pow(A,6)/(MEAN+MAX)
   *  Supported operators are +, -, *, /, pow, log,
   *  abs, cos, exp, sqrt, tan, sin, ceil, floor, rint, (, ), 
   *  MEAN, MAX, MIN, SD, COUNT, SUM, SUMSQUARED, ifelse</pre>
   * 
   * <pre> -R &lt;index1,index2-index4,...&gt;
   *  Specify list of columns to ignore. First and last are valid
   *  indexes. (default none)</pre>
   * 
   * <pre> -V
   *  Invert matching sense (i.e. only modify specified columns)</pre>
   * 
   <!-- options-end -->
   *
   * @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 {
    super.setOptions(options);

    String expString = Utils.getOption('E', options);
    if (expString.length() != 0) {
      setExpression(expString);
    } else {
      setExpression(m_defaultExpression);
    }
    
    String ignoreList = Utils.getOption('R', options);
    if (ignoreList.length() != 0) {
      setIgnoreRange(ignoreList);
    }

    setInvertSelection(Utils.getFlag('V', options));
  }
  
  /**
   * Gets the current settings of the filter.
   *
   * @return an array of strings suitable for passing to setOptions
   */
  public String [] getOptions() {
    Vector        result;
    String[]      options;
    int           i;

    result = new Vector();

    options = super.getOptions();
    for (i = 0; i < options.length; i++)
      result.add(options[i]);

    result.add("-E");
    result.add(getExpression());
    
    if (getInvertSelection())
      result.add("-V");

    if (!getIgnoreRange().equals("")) {
      result.add("-R");
      result.add(getIgnoreRange());
    }

    return (String[]) result.toArray(new String[result.size()]);
  }
  
  /**
   * Returns an enumeration describing the available options.
   *
   * @return an enumeration of all the available options.
   */
  public Enumeration listOptions() {
    Vector result = new Vector();
    Enumeration enm = super.listOptions();
    while (enm.hasMoreElements())
      result.add(enm.nextElement());
      
    result.addElement(new Option(
	"\tSpecify the expression to apply. Eg. pow(A,6)/(MEAN+MAX)"
	+"\n\tSupported operators are +, -, *, /, pow, log,"
	+"\n\tabs, cos, exp, sqrt, tan, sin, ceil, floor, rint, (, ), "
	+"\n\tMEAN, MAX, MIN, SD, COUNT, SUM, SUMSQUARED, ifelse",
	"E",1,"-E <expression>"));
    
    result.addElement(new Option(
	"\tSpecify list of columns to ignore. First and last are valid\n"
	+"\tindexes. (default none)",
	"R", 1, "-R <index1,index2-index4,...>"));
    
    result.addElement(new Option(
	"\tInvert matching sense (i.e. only modify specified columns)",
	"V", 0, "-V"));
    
    return result.elements();
  }
  
  /**
   * Returns the tip text for this property
   *
   * @return tip text for this property suitable for
   * displaying in the explorer/experimenter gui
   */
  public String expressionTipText() {
    return "Specify the expression to apply. The 'A' letter"
             + "refers to the attribute value. MIN,MAX,MEAN,SD"
             + "refer respectively to minimum, maximum, mean and"
             + "standard deviation of the attribute."
	     +"\n\tSupported operators are +, -, *, /, pow, log,"
             +"abs, cos, exp, sqrt, tan, sin, ceil, floor, rint, (, ),"
             +"A,MEAN, MAX, MIN, SD, COUNT, SUM, SUMSQUARED, ifelse"
             +"\n\tEg. pow(A,6)/(MEAN+MAX)*ifelse(A<0,0,sqrt(A))+ifelse(![A>9 && A<15])";
  }
  
  /**
   * Set the expression to apply
   * @param expr a mathematical expression to apply
   */
  public void setExpression(String expr) {
    m_expression = expr;
  }

  /**
   * Get the expression
   * @return the expression
   */
  public String getExpression() {
    return m_expression;
  }
  
    /**
   * 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 unselect."
      + " If set to true, only the specified attributes will be modified;"
      + " If set to false, specified attributes will not be modified.";
  }

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

    return !m_SelectCols.getInvert();
  }

  /**
   * Set whether selected columns should be select or unselect. If true the 
   * selected columns are modified. If false the selected columns are not
   * modified.
   *
   * @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 ignoreRangeTipText() {

    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 getIgnoreRange() {

    return m_SelectCols.getRanges();
  }

  /**
   * Set which attributes are to be ignored
   *
   * @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 setIgnoreRange(String rangeList) {

    m_SelectCols.setRanges(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) {
    runFilter(new MathExpression(), argv);
  }
}