miningarraystream.java

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

    // -----------------------------------------------------------------------
    //  Methods of cursor positioning
    // -----------------------------------------------------------------------
    /**
     * Set cursor before first row.
     *
     * @exception MiningException could not reset cursor
     */
    public void reset() throws MiningException
    {
        cursorPosition = -1;
    }

    /**
     * Advance cursor by one position.
     *
     * @return true, if further rows exist, else false
     * @exception MiningException could not advance cursor
     */
    public boolean next() throws MiningException
    {
        cursorPosition++;
        if (cursorPosition < miningArrayLength)
          return true;

        return false;
    }

    /**
     * Move cursor to given position.
     *
     * @param position new position of the cursor
     * @return true if cursor could be positioned, false if not
     * @exception MiningException could not move cursor
     */
    public boolean move(int position) throws MiningException
    {
        if (position < miningArrayLength)
        {
            cursorPosition = position;
            return true;
        }

        return false;
    }

    // -----------------------------------------------------------------------
    //  Methods of reading from the stream
    // -----------------------------------------------------------------------
    /**
     * Read current mining vector.
     *
     * @return mining vector to read
     * @exception MiningException could not read vector
     */
    public MiningVector read() throws MiningException
    {
        MiningVector vector = null;
        double[] values     = new double[ metaData.getAttributesNumber() ];

        // Use array of objects:
        if (useObjectArray) {
          for( int i = 0; i < values.length; i++ )
          {
            Object obj         = miningObjectArray[cursorPosition][i];
            MiningAttribute ma = metaData.getMiningAttribute( i );
            if (ma instanceof CategoricalAttribute)
            {
              CategoricalAttribute cAtt = (CategoricalAttribute) ma;
              Category cat = new Category( obj );
              values[i]    = cAtt.getKey( cat );
              // If unboundedCategories, add object as category to meta data:
              if ( Category.isMissingValue( values[i] ) 
                      && cAtt.isUnboundedCategories())
              {
                  //<<tyleung 30/3/2005 to avoid putting NaN as a category
                  boolean isMissingValue = false;
                  if(ValueValidator.isDouble(cat.getValue().toString())){
                      double val = Double.parseDouble(cat.getValue().toString());
                      
                      if(Double.isNaN(val)){
                          isMissingValue = true;
                      }
                  }
                  if(!isMissingValue){
	                  Category categ = new Category( obj );
	                  values[i] = cAtt.addCategory( categ );
                  }
                  //tyleung 30/3/2005>>
              }
            }
            else
            {
            	//<<10/09/2005, Frank J. Xu
                //Handle missing values for date type of cell.
                if((obj.toString()).length() > 0){
                	values[i] = Double.parseDouble( obj.toString() );
                }            	                
                //10/09/2005, Frank J. Xu>>
            }
          };
        }
        // Use array of doubles:
        else {
          values = miningArray[cursorPosition];
        };

        vector = new MiningVector( values );
        vector.setMetaData( metaData );

        return vector;
    }

    /**
     * Reads value at given coordinates.
     *
     * @param     rowNumber         the row number
     * @param     attributeIndex    the index of MiningAttribute to read value
     *
     * @return    value of MiningAttribute with index <code>attributeIndex</code> at
     *            <code>rowNumber</code> row
     * @exception MiningException if an error occurs
     */
    public double readAttributeValue(int rowNumber, int attributeIndex) throws MiningException
    {
      // Use mining array:
      if (! useObjectArray)
        return miningArray[rowNumber][attributeIndex];

      // Use mining objects array:
      double value       = 0.0;
      Object obj         = miningObjectArray[rowNumber][attributeIndex];
      MiningAttribute ma = metaData.getMiningAttribute( attributeIndex );
      if (ma instanceof CategoricalAttribute)
      {
        CategoricalAttribute cAtt = (CategoricalAttribute) ma;
        Category cat = new Category( obj );
        value = cAtt.getKey( cat );
        // If specified, add object as category to meta data:
        if ( Category.isMissingValue( value ) && cAtt.isUnboundedCategories() )
        {
           Category categ = new Category( obj );
           value = cAtt.addCategory( categ );
        }
      }
      else
      {
        value = Double.parseDouble( obj.toString() );
      };

      return value;
    }

    // -----------------------------------------------------------------------
    // Test
    // -----------------------------------------------------------------------
    /**
     * Test.
     *
     * @param args arguments (ignored)
     */
    public static void main(String[] args) {

      try {
        // FIRST CONSTRUCTOR TYPE:
        System.out.println("Mining array without metadata given:");

        // Mining array for xor problem:
        double[][] mArr = new double[4][3];
        mArr[0][0] = 0;
        mArr[0][1] = 0;
        mArr[0][2] = 0.0;
        mArr[1][0] = 0;
        mArr[1][1] = 1;
        mArr[1][2] = 1.0;
        mArr[2][0] = 1;
        mArr[2][1] = 0;
        mArr[2][2] = 1.0;
        mArr[3][0] = 1;
        mArr[3][1] = 1;
        mArr[3][2] = 0.0;

        // Create mining array stream for numeric attributes:
        MiningArrayStream mas = new MiningArrayStream( mArr );

        // Show data from mining array stream:
        MiningDataSpecification metaData = mas.getMetaData();
        System.out.println("metaData: " + metaData.toString());
        System.out.println("vectorsNumber = " + mas.getVectorsNumber());;
        while (mas.next()) {
          MiningVector vec = mas.read();
          System.out.println("vec: " + vec.toString() );
        };
        double value = mas.readAttributeValue(3, 1);
        System.out.println("value(3,1) = " + value);
        System.out.println();

        // SECOND CONSTRUCTOR TYPE:
        System.out.println("Mining array with metadata given:");

        // Define attributes for current array:
        NumericAttribute numAtt1    = new NumericAttribute("numAtt1");
        NumericAttribute numAtt2    = new NumericAttribute("numAtt2");
        CategoricalAttribute catAtt = new CategoricalAttribute("catAtt");
        Category cat1 = new Category("zero");
        Category cat2 = new Category("one");
        catAtt.addCategory(cat1);
        catAtt.addCategory(cat2);

        // Define new meta data:
        metaData = new MiningDataSpecification();
        metaData.addMiningAttribute(numAtt1);
        metaData.addMiningAttribute(numAtt2);
        metaData.addMiningAttribute(catAtt);

        // Create new mining array stream with new meta data:
        mas = new MiningArrayStream( mArr, metaData );

        // Show data from mining array stream:
        metaData = mas.getMetaData();
        System.out.println("metaData: " + metaData.toString());
        while (mas.next()) {
          MiningVector vec = mas.read();
          System.out.println("vec: " + vec.toString() );
        };
        System.out.println();

        // THIRD CONSTRUCTOR TYPE:
        System.out.println("Mining object array with metadata given:");

        // Array of objects:
        Object[][] mObArr = new Object[4][3];
        mObArr[0][0] = new Double(0);
        mObArr[0][1] = new Double(0);
        mObArr[0][2] = new String("zero");
        mObArr[1][0] = new Double(1);
        mObArr[1][1] = new Double(0);
        mObArr[1][2] = new String("one");
        mObArr[2][0] = new Double(0);
        mObArr[2][1] = new Double(1);
        mObArr[2][2] = new String("one");
        mObArr[3][0] = new Double(1);
        mObArr[3][1] = new Double(1);
        mObArr[3][2] = new String("zero");

        // Create new mining object array stream with given meta data:
        mas = new MiningArrayStream( mObArr, metaData );

        // Show data from mining array stream:
        metaData = mas.getMetaData();
        System.out.println("metaData: " + metaData.toString());
        while (mas.next()) {
          MiningVector vec = mas.read();
          System.out.println("vec: " + vec.toString() );
        };
        System.out.println();

        // THIRD CONSTRUCTOR TYPE WITH UNBOUNDED CATEGORIES:
        System.out.println("Mining object array with metadata of unbounded categories:");

        // Set unboundedCategories for categorical attribute:
        catAtt.setUnboundedCategories(true);

        // Modify array of objects by adding an object not defined in meta data:
        mObArr[2][2] = new String("edinica (po russkii)");

        // Create new mining object array stream with given meta data:
        mas = new MiningArrayStream( mObArr, metaData );

        // Show data from mining array stream:
        metaData = mas.getMetaData();
        System.out.println("metaData: " + metaData.toString());
        while (mas.next()) {
          MiningVector vec = mas.read();
          System.out.println("vec: " + vec.toString() );
        };
        System.out.println();

        // FOURTH CONSTRUCTOR TYPE:
        System.out.println("Mining array from input stream:");

        // Create new mining array stream from previous one:
        mas.reset();
        MiningArrayStream mas2 = new MiningArrayStream( mas );

        // Show data from mining array stream 2:
        metaData = mas2.getMetaData();
        System.out.println("metaData2: " + metaData.toString());
        while (mas2.next()) {
          MiningVector vec = mas2.read();
          System.out.println("vec2: " + vec.toString() );
        };
    }
    catch (Exception ex) {
      ex.printStackTrace();
    };
  }


}