Package weka.classifiers.functions.pace

Source Code of weka.classifiers.functions.pace.DiscreteFunction

/*
*    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.  */

/*
*    ChisqMixture.java
*    Copyright (C) 2002 University of Waikato, Hamilton, New Zealand
*
*/

package weka.classifiers.functions.pace;

import weka.core.RevisionHandler;
import weka.core.RevisionUtils;
import weka.core.matrix.DoubleVector;
import weka.core.matrix.FlexibleDecimalFormat;
import weka.core.matrix.IntVector;


/** Class for handling discrete functions. <p>
*
* A discrete function here is one that takes non-zero values over a finite
* set of points. <p>
*
* @author Yong Wang (yongwang@cs.waikato.ac.nz)
* @version $Revision: 1.4 $ */

public class  DiscreteFunction
  implements RevisionHandler {
   
  protected DoubleVector  points;
  protected DoubleVector  values;

  /** Constructs an empty discrete function */
  public DiscreteFunction()
  {
    this(null, null);
  }
   
  /** Constructs a discrete function with the point values provides and the
   *  function values are all 1/n.
   * @param p the point values
   */
  public DiscreteFunction( DoubleVector p )
  {
    this( p, null );
  }
   
  /** Constructs a discrete function with both the point values and
   *  function values provided.
   * @param p the point values
   * @param v the function values */
  public DiscreteFunction( DoubleVector p, DoubleVector v )
  {
    points = p;
    values = v;
    formalize();
  }
   
  private DiscreteFunction  formalize()
  {
    if( points == null ) points = new DoubleVector();
    if( values == null ) values = new DoubleVector();
 
    if( points.isEmpty() ) {
      if( ! values.isEmpty() )
  throw new IllegalArgumentException("sizes not match");
    }
    else {
      int n = points.size();
      if( values.isEmpty() ) {
  values = new DoubleVector( n, 1./n );
      }
      else {
  if( values.size() != n )
    throw new IllegalArgumentException("sizes not match");
      }
    }
    return this;
  }
   
  /**
   * Normalizes the function values with L1-norm.
   */
  public DiscreteFunction  normalize()
  {
    if ( ! values.isEmpty() ) {
      double s = values.sum();
      if( s != 0.0 && s != 1.0 ) values.timesEquals( 1. / s );
    }
    return this;
  }
 
  /**
   * Sorts the point values of the discrete function.
   */
  public void  sort()
  {
    IntVector index = points.sortWithIndex();
    values = values.subvector( index );
  }
 
  /**
   * Clones the discrete function
   */
  public Object  clone()
  {
    DiscreteFunction d = new DiscreteFunction();
    d.points = (DoubleVector) points.clone();
    d.values = (DoubleVector) values.clone();
    return d;
  }
 
  /**
   * Makes each individual point value unique
   */
  public DiscreteFunction  unique()
  {
    int count = 0;
   
    if( size() < 2 ) return this;
    for(int i = 1; i <= size() - 1; i++ ) {
      if( points.get( count ) != points.get( i ) ) {
  count++;
  points.set( count, points.get( i ) );
  values.set( count, values.get( i ) );
      }
      else {
  values.set( count, values.get(count) + values.get(i) );
      }
    }
    points = (DoubleVector) points.subvector(0, count);
    values = (DoubleVector) values.subvector(0, count);
    return this;
  }

  /**
   * Returns the size of the point set.
   */
  public int  size()
  {
    if( points == null ) return 0;
    return points.size();
  }
 
  /**
   * Gets a particular point value
   * @param i the index
   */
  public double  getPointValue( int i )
  {
    return points.get(i);
  }
 
  /**
   * Gets a particular function value
   * @param i the index
   */
  public double  getFunctionValue( int i )
  {
    return values.get(i);
  }
   
  /**
   * Sets a particular point value
   * @param i the index
   */
  public void  setPointValue( int i, double p )
  {
    points.set(i, p);
  }
   
  /**
   * Sets a particular function value
   * @param i the index
   */
  public void  setFunctionValue( int i, double v )
  {
    values.set(i, v);
  }
   
  /**
   * Gets all point values
   */
  protected DoubleVector  getPointValues()
  {
    return points;
  }
   
  /**
   * Gets all function values
   */
  protected DoubleVector  getFunctionValues()
  {
    return values;
  }
 
  /**
   * Returns true if it is empty.
   */
  public boolean  isEmpty()
  {
    if( size() == 0 ) return true;
    return false;
  }
 
  //    public void  addPoint( double x, double y ) {
  //    points.addPoint( x );
  //    values.addPoint( y );
  //    }
 
  /**
   * Returns the combined of two discrete functions
   * @param d the second discrete function
   * @return the combined discrte function
   */
  public DiscreteFunction  plus( DiscreteFunction d )
  {
    return ((DiscreteFunction) clone()).plusEquals( d );
  }
 
  /**
   * Returns the combined of two discrete functions. The first function is
   * replaced with the new one.
   * @param d the second discrete function
   * @return the combined discrte function */
  public DiscreteFunction  plusEquals( DiscreteFunction d )
  {
    points = points.cat( d.points );
    values = values.cat( d.values );
    return this;
  }
 
  /**
   * All function values are multiplied by a double
   * @param x the multiplier
   */
  public DiscreteFunction  timesEquals( double x )
  {
    values.timesEquals( x );
    return this;
  }

  /**
   * Converts the discrete function to string.
   */
  public String  toString()
  {
    StringBuffer text = new StringBuffer();
    FlexibleDecimalFormat nf1 = new FlexibleDecimalFormat( 5 );
    nf1.grouping( true );
    FlexibleDecimalFormat nf2 = new FlexibleDecimalFormat( 5 );
    nf2.grouping( true );
    for(int i = 0; i < size(); i++) {
      nf1.update( points.get(i) );
      nf2.update( values.get(i) );
    }

    text.append("\t" + nf1.formatString("Points") +
    "\t" + nf2.formatString("Values") + "\n\n");
    for(int i = 0; i <= size() - 1; i++) {
      text.append( "\t" + nf1.format( points.get(i) ) + "\t" +
       nf2.format( values.get(i) ) + "\n" );
    }
 
    return text.toString();
  }
 
  /**
   * Returns the revision string.
   *
   * @return    the revision
   */
  public String getRevision() {
    return RevisionUtils.extract("$Revision: 1.4 $");
  }

  public static void main( String args[] )
  {
 
    double points[] = {2,1,2,3,3};
    double values[] = {3,2,4,1,3};
    DiscreteFunction d = new DiscreteFunction( new DoubleVector( points ),
                 new DoubleVector( values ));
    System.out.println( d );
    d.normalize();
    System.out.println( "d (after normalize) = \n" + d );
    points[1] = 10;
    System.out.println( "d (after setting [1]) = \n" + d);
    d.sort();
    System.out.println( "d (after sorting) = \n" + d);
    d.unique();
    System.out.println( "d (after unique) = \n" + d );
  }
}
TOP

Related Classes of weka.classifiers.functions.pace.DiscreteFunction

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.