variablenumber.java

一个用于排队系统仿真的开源软件,有非常形象的图象仿真过程!

/**    
 * Copyright (C) 2006, Laboratorio di Valutazione delle Prestazioni - Politecnico di Milano

 * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package jmt.engine.jwat;

import java.util.ArrayList;

import jmt.engine.jwat.filters.FilterOnVariable;
import jmt.engine.jwat.workloadAnalysis.exceptions.TrasformException;
import jmt.gui.jwat.JWATConstants;
import jmt.gui.jwat.input.VariableMapping;

/**
 * Description: This class represents a single variable which contains numerical
 * values. It provides statistics information and variable transofrmations
 * 
 * @author Brambilla Davide Matr 667986, Fumagalli Claudio 667971 Class created
 *         1-ago-2006 8.08.30 Darksch
 * 
 */
public class VariableNumber implements JWATConstants {
	/* Transformation codes */
	public static final short LOGARITHMIC = 0;
	public static final short MINMAX = 1;
	public static final short STDEV = 2;
	public static final short SAMPLING = 3;
	public static final short NONE = 4;

	/* List of observations sorted according to this variable */
	protected Observation[] obsValue;
	/* Original observations value keep as backup for undo sampling transformations */
	protected Observation[] originalValue;
	/* Variable name */
	protected String name;
	/* Index of this variable in the observation */
	protected int nVar;
	/* Type of variable */
	private short varType;
	/* Univariate statistics object */
	private ArrayList varUniStatsTransf = new ArrayList(); // UnivariateStatistics
	/* Current statistics info */
	private short statsUniCurrentIndexTransf = 0;
	/* List of transformations applied to variable */
	private ArrayList listOfTransfs = new ArrayList(); //Integer
	/* Dimensions of intervals and intervals */
	private final int intervalSize = 100;
	private final int intervalGraphSize = 1000;
	private int[] interval = new int[intervalSize + 1];
	private int[] intervalGraph = new int[intervalGraphSize + 1];
	/* Number of observations */
	private int numOss = 0;
	/* Indeicates if it is sampled */
	private boolean sampled = false;

	/**
	 * Constructor, creates new numerical variable.
	 * @param valObs
	 *            list of observations already sorted by this variable
	 * @param vName
	 *            variable's name
	 * @param pos
	 *            variable's positione in observation
	 * @param varMapping
	 *            mapping object (null)
	 */
	public VariableNumber(Observation[] valObs, String vName, int pos,
			short type, VariableMapping varMapping) {
		name = vName;
		nVar = pos;
		numOss = valObs.length;
		varType = type;
		originalValue = new Observation[valObs.length];
		// Saving observations
		for (int i = 0; i < numOss; i++) {
			originalValue[i] = valObs[i];
		}
		obsValue = originalValue;
		// Initializes remaining parameters
		varUniStatsTransf.add(new UnivariateStatistics(obsValue, nVar));
		calculateIntervals();
	}

	/**
	 * Returns Index-th value of the variable
	 * @param Index
	 *            index of variable's value desired
	 * @return value of Index-th value
	 * @throws ArrayIndexOutOfBoundsException
	 *             throws if Index is < 0 or > numbero of observations
	 */
	public double getValue(int Index) throws ArrayIndexOutOfBoundsException {
		if (Index < 0 || Index > obsValue.length) {
			throw new ArrayIndexOutOfBoundsException();
		} else
			return obsValue[Index].getIndex(nVar);
	}

	/**
	 * Returns the index-th value of the var-th variable of the observaion
	 * @param Index
	 *            index of variable's value desired
	 * @param var
	 *            variable index
	 * @return index-th value of the var-th variable
	 * @throws ArrayIndexOutOfBoundsException
	 *             throws if Index is < 0 or > numbero of observations or var <
	 *             0 or > number of variables ( elements of observation )
	 */
	public double getValue(int Index, int var)
			throws ArrayIndexOutOfBoundsException {
		if (Index < 0 || Index > obsValue.length) {
			throw new ArrayIndexOutOfBoundsException();
		} else
			return obsValue[Index].getIndex(var);
	}

	/**
	 * Returns object holding current univariate variable statistics
	 * @return <code>univariateStatistics</code>
	 */
	public UnivariateStatistics getUniStats() {
		return (UnivariateStatistics) varUniStatsTransf.get(statsUniCurrentIndexTransf);
	}

	/**
	 * Returns element corresponding to the ind quantile
	 * @param ind
	 *            quantile
	 * @return element corresponding to the ind quantile
	 */
	public double getQuantile(int ind) {
		double quant = 0;
		int[] quantili = ((UnivariateStatistics) varUniStatsTransf.get(statsUniCurrentIndexTransf)).getQuantili();

		if (this.Size() % 2 == 0)
			quant = (obsValue[quantili[ind - 1]].getIndex(nVar) + obsValue[quantili[ind - 1] - 1].getIndex(nVar)) / 2;
		else
			quant = obsValue[quantili[ind - 1]].getIndex(nVar);
		return quant;
	}

	/**
	 * Returns number of observations
	 * @return number of observations
	 */
	public int Size() {
		return obsValue.length;
	}

	/**
	 * Returns variable's index
	 * @return variable's index
	 */
	public int getIndex() {
		return nVar;
	}

	/**
	 * Return variable's name
	 * @return variable's name
	 */
	public String getName() {
		return name;
	}

	/**
	 * Returns variable's type
	 * @return variable's type
	 */
	public short getType() {
		return varType;
	}

	// This method calculates index of intervals used to plot graphs
	private void calculateIntervals() {
		interval[0] = 0;
		intervalGraph[0] = 0;

		int posInt = 1;
		int posIntG = 1;

		double range = ((UnivariateStatistics) varUniStatsTransf.get(statsUniCurrentIndexTransf)).getRangeValue();
		double min = ((UnivariateStatistics) varUniStatsTransf.get(statsUniCurrentIndexTransf)).getMinValue();

		int nIns = 0;
		int nInsG = 0;

		for (int i = 0; i < numOss; i++) {
			// Graph interval ( 1000 intervals )
			if (obsValue[i].getIndex(nVar) <= range * (0.001 * posIntG) + min || obsValue[i].getIndex(nVar) > range + min) {
				nInsG++;
			} else {
				if (nInsG == 0) {
					intervalGraph[posIntG] = intervalGraph[posIntG - 1];
				} else {
					intervalGraph[posIntG] = i - 1;
				}
				posIntG++;
				nInsG = 0;
				i--;
			}
			if(posIntG == 1001){
				break;
			}
			// Graph interval ( 100 intervals )
/*			if (obsValue[i].getIndex(nVar) <= range * (0.01 * posInt) + min	|| obsValue[i].getIndex(nVar) > range + min) {
				nIns++;
			} else {
				if (nIns == 0) {
					interval[posInt] = interval[posInt - 1];
				} else {
					interval[posInt] = i - 1;
				}
				posInt++;
				nIns = 0;
			}*/
		}
		intervalGraph[1000] = obsValue.length - 1;
		//interval[100] = obsValue.length - 1;
	}

	/** ******* TRANSFORMATIONS SECTION ********* */

	/**
	 * Perform one of the transformations
	 * @param index
	 *            transformation to apply
	 * @throws TrasformException
	 *             throws if it isn't possible to apply transformation
	 */
	public void doTransformation(int index) throws TrasformException {
		// Checks if this is a numeric variable otherwise no transformation
		if (varType == NUMERIC) {
			switch (index) {
			case LOGARITHMIC:
				setLogTransformation();
				break;
			case STDEV:
				setStandardTransformation();
				break;
			case MINMAX:
				setMaxMinTransformation();
				break;
			}
		} else {
			throw new TrasformException("This in not a NUMERIC variable");
		}
		calculateIntervals();
	}

	/**
	 * Performs logarithmic transformation 10 based
	 * @throws TrasformException
	 *             if exists al least one value <= 0
	 */
	private void setLogTransformation() throws TrasformException {
		if (isLogTrasformable()) {
			for (int i = 0; i < numOss; i++)
				obsValue[i].setIndex(nVar, Math.log(obsValue[i].getIndex(nVar))	/ Math.log(10));
			addTrasf(LOGARITHMIC);
		} else {
			throw new TrasformException("Logarithmic transformation not allowed");
		}
	}

	/**
	 * Performs min/max transformation (value - minimum) / (maximum - minimum)
	 */
	private void setMaxMinTransformation() {
		for (int i = 0; i < numOss; i++)
			obsValue[i].setIndex(nVar,(obsValue[i].getIndex(nVar) - 
						((UnivariateStatistics) varUniStatsTransf.get(statsUniCurrentIndexTransf)).getMinValue()) / (
								((UnivariateStatistics) varUniStatsTransf.get(statsUniCurrentIndexTransf)).getRangeValue()));
		addTrasf(MINMAX);
	}

	/**
	 * Performs the following transformation (value - mean) / (standard deviation)
	 */
	private void setStandardTransformation() {
		for (int i = 0; i < numOss; i++)
			obsValue[i].setIndex(nVar,(obsValue[i].getIndex(nVar) - 
					((UnivariateStatistics) varUniStatsTransf.get(statsUniCurrentIndexTransf)).getMean()) / 
						((UnivariateStatistics) varUniStatsTransf.get(statsUniCurrentIndexTransf)).getDevStd());	
		addTrasf(STDEV);
	}

	/**
	 * Adds transformations info to variable
	 * @param transf
	 *            transformation applied
	 */
	private void addTrasf(short transf) {
		listOfTransfs.add(new Integer(transf));
		// Stores new statistics after transformation applied
		varUniStatsTransf.add(new UnivariateStatistics(obsValue, nVar));
		statsUniCurrentIndexTransf += 1;
	}

	/**
	 * Undo last transformation applied to variable if exists
	 */
	public boolean undoLastTrasf() {
		if (listOfTransfs.size() > 0) {
			switch (((Integer) listOfTransfs.get(listOfTransfs.size() - 1)).intValue()) {
			case LOGARITHMIC:
				undoLogTrasformation();
				calculateIntervals();
				break;
			case STDEV:
				undoStandardTransformation();
				calculateIntervals();
				break;
			case MINMAX:
				undoMaxMinTransformation();
				calculateIntervals();
				break;
			case SAMPLING:
				undoSampling();
				undoLastTrasf();
				calculateIntervals();
				return true;
			}
		}
		return false;
	}

	/**
	 * Undo a logarithmic transformation
	 */
	private void undoLogTrasformation() {
		// Removes last Log transformation
		for (int i = 0; i < numOss; i++)
			obsValue[i].setIndex(nVar, Math.pow(10, obsValue[i].getIndex(nVar)));
		listOfTransfs.remove(listOfTransfs.size() - 1);
		// Removes associated statistics
		varUniStatsTransf.remove(varUniStatsTransf.size() - 1);
		statsUniCurrentIndexTransf -= 1;
	}

	/**
	 * Undo min/max transformation (value - minimum) / (maximum - minimum)
	 */
	private void undoMaxMinTransformation() {
		double oldMin = ((UnivariateStatistics) varUniStatsTransf.get(varUniStatsTransf.size() - 2)).getMinValue();