variablenumber.java

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

		double oldMax = ((UnivariateStatistics) varUniStatsTransf.get(varUniStatsTransf.size() - 2)).getMaxValue();

		for (int i = 0; i < numOss; i++)
			obsValue[i].setIndex(nVar, obsValue[i].getIndex(nVar) * (oldMax - oldMin) + oldMin);
		listOfTransfs.remove(listOfTransfs.size() - 1);
		// Removes associated statistics
		varUniStatsTransf.remove(varUniStatsTransf.size() - 1);
		statsUniCurrentIndexTransf -= 1;
	}

	/**
	 * Undo the following transformation (value - mean) / (standard deviation)
	 */
	private void undoStandardTransformation() {
		double oldDevStd = ((UnivariateStatistics) varUniStatsTransf.get(varUniStatsTransf.size() - 2)).getDevStd();
		double oldMean = ((UnivariateStatistics) varUniStatsTransf.get(varUniStatsTransf.size() - 2)).getMean();

		for (int i = 0; i < numOss; i++)
			obsValue[i].setIndex(nVar, (obsValue[i].getIndex(nVar) * oldDevStd)	+ oldMean);
		listOfTransfs.remove(listOfTransfs.size() - 1);
		// Removes associated statistics
		varUniStatsTransf.remove(varUniStatsTransf.size() - 1);
		statsUniCurrentIndexTransf -= 1;
	}

	/**
	 * Check if logarithmic transformation is applyable to variable
	 * @return If logarithm is applyable
	 */
	private boolean isLogTrasformable() {
		return ((obsValue[0].getIndex(nVar) > 0));
	}
	/**
	 * Returns names of transformations
	 * @return Array of transformation's names
	 */
	public static String[] getTrasfName() {
		String[] ret = { "Logarithmic", "MinMax", "StandardDev" };
		return ret;
	}
	/**
	 * 
	 * @return
	 */
	public String getTrasfStr() {
		String[] trasfName = { "Log", "Mm", "SD" };
		String ret = "";
		int j = 0;
		int i;

		for (i = 0; i < listOfTransfs.size(); i++) {
			if (((Integer) listOfTransfs.get(i)).intValue() != SAMPLING){
				ret += trasfName[((Integer) listOfTransfs.get(i)).intValue()] + "(";
				j++;	//D
			}
		}
		ret += "X";
		for(i= 0; i < j; i++) ret += ")";
		/*if (i == 0)
			ret = "X";
		else
			ret += "X)";
        */
		return ret;
	}

	/** ******** METHODS FOR PLOT ********** */
	// Indica la variabile compagna nel plot del grafico
	private int val;
	// Valore di start e end intervallo di visualizzazione variabile
	private int PosS;
	private int PosE;
	// Valori min e max della variabile gemella nel grafico
	private double minV;
	private double maxV;

	public double getDimInt() {
		return ((UnivariateStatistics) varUniStatsTransf.get(statsUniCurrentIndexTransf))
				.getRangeValue() / 1000;
	}

	public int getNumeroOssPerInt() {
		return PosE - PosS;
	}

	public int getStartInt(int j) {
		return intervalGraph[(j - 1)*10];
	}

	public int getEndInt(int j) {
		return intervalGraph[j*10];
	}

	/**
	 * Restituisce il valore relativo all'indice pos dell'array degli intervalli
	 * @param Index
	 *            Indice dell'array degli intervalli
	 * @return Restituzione del valore realtivo ad uno limite dell'intervallo
	 */
	public double getIntValue(int Index) {

		return (obsValue[numOss - 1].getIndex(nVar) - obsValue[0].getIndex(nVar)) * 0.01 * Index + obsValue[0].getIndex(nVar);
	}

	/**
	 * Restituisce il valore relativo all'indice pos dell'array degli intervalli
	 * @param Index
	 *            Indice dell'array degli intervalli
	 * @return Restituzione del valore realtivo ad uno limite dell'intervallo
	 */
	public double getIntValueG(int Index) {
		return (obsValue[numOss - 1].getIndex(nVar) - obsValue[0].getIndex(nVar)) * 0.001 * Index + obsValue[0].getIndex(nVar);

	}

	/**
	 * Impostazione per la ricerca dei punti all'interno di un intervallo per il plot
	 * @param min
	 *            Limite inferiore dell'intervallo come indice dell'array degli intervalli
	 * @param max
	 *            Limite superiore dell'intervallo come indice dell'array degli intervalli
	 * @param minv
	 *            Limite inferiore come valore della variabile compagna dello scatter plot
	 * @param maxv
	 *            Limite superiore come valore della variabile compagna dello scatter plot
	 * @param n
	 *            Posizone della variabile compagna nello scatter plot nelle osservazioni
	 */
	public void setRangeIntervallo(int min, int max, double minv, double maxv, int n) {
		// Settaggio delle informazioni per restituizione osservazioni da plottare
		minV = minv;
		maxV = maxv;
		val = n;
		PosS = intervalGraph[min];
		PosE = intervalGraph[max];
	}

	/**
	 * Restituisce il prossimo indice se esiste dell'osservazione da plottare che corrisponde alle restrizioni 
	 * impostate con setRangeQuantili
	 * 
	 * @return indice che soddisfa le condizioni
	 */
	public int getNextInt() throws Exception {
		while (obsValue[PosS].getIndex(val) < minV	|| obsValue[PosS].getIndex(val) > maxV) {
			PosS++;
			if (PosS > PosE)
				throw new Exception();
		}
		if (PosS > PosE)
			throw new Exception();
		return PosS++;

	}

	/**
	 * Restituisce il range tra posizioni di intervalli
	 * @param min
	 *            posizone minima dell'intervallo
	 * @param max
	 *            posizone massima dell'intervallo
	 * @return range tra i due intervalli
	 */
	public double getIntRange(int min, int max) {
		return (obsValue[numOss - 1].getIndex(nVar) - obsValue[0].getIndex(nVar)) * 0.01 * (max - min);
	}

	/**
	 * Restituisce il range tra posizioni di intervalli
	 * @param min
	 *            posizone minima dell'intervallo
	 * @param max
	 *            posizone massima dell'intervallo
	 * @return range tra i due intervalli
	 */
	public double getIntRangeG(int min, int max) {
		return (obsValue[numOss - 1].getIndex(nVar) - obsValue[0].getIndex(nVar)) * 0.001 * (max - min);
	}

	/**
	 * NON UTILIZZATO ERRATO 
	 * Restituisce l'array degli intervalli
	 * @return vettore contenente le posizioni delle variabili che delimitano gli intervalli
	 */
	/*public int[] getInterval() {
		return interval;
	}*/

	public int getIndex(double value) {
		int i = 0;
		for (i = 0; i < intervalGraph.length; i++) {
			if (value <= obsValue[intervalGraph[i]].getIndex(nVar))
				return i;
		}
		return i - 1;
	}

	public int getIndexMin(double value) {
		int i = 0;
		for (i = 0; i < intervalGraph.length; i++) {
			if (value <= obsValue[intervalGraph[i]].getIndex(nVar))
				return i;
		}
		return i - 1;
	}

	public int getIndexMax(double value) {
		int i = 0;
		for (i = 0; i < intervalGraph.length; i++) {
			if (value < obsValue[intervalGraph[i]].getIndex(nVar))
				return i;
		}
		return i - 1;
	}

	public int[] getInterval1000() {
		return intervalGraph;
	}

	/**
	 * Applies filter to variable
	 * 
	 * @param filter
	 * @return
	 */
	public int applySampling(FilterOnVariable filter) {
		int j=1;
		
		sampled = true;
		listOfTransfs.add(new Integer(SAMPLING));
		ArrayList temp = new ArrayList(); //Observation
		for (int i = 0; i < obsValue.length; i++) {
			if (filter.isMatching(obsValue[i], i)) {
				temp.add(obsValue[i]);
				obsValue[i].setID(j++);
			} else {
				obsValue[i].setValid(false);		
			}
		}
		obsValue = new Observation[temp.size()];
		temp.toArray(obsValue);
		
		temp.clear();
		temp = null;
		
		numOss = obsValue.length;
		varUniStatsTransf.add(new UnivariateStatistics(obsValue, nVar));
		statsUniCurrentIndexTransf += 1;
		calculateIntervals();
		return numOss;
	}

	/**
	 * Sync variable respect with another variable sampling
	 * 
	 * @param size
	 */
	public void updateOnSampling(int size) {
		listOfTransfs.add(new Integer(SAMPLING));
		int i = 0;
		Observation[] temp = new Observation[size];
		// obsValue = new Observation[size];
		for (int j = 0; j < obsValue.length; j++) {
			if (obsValue[j].isValid())
				temp[i++] = obsValue[j];
		}
		obsValue = temp;
		temp = null;
		
		numOss = obsValue.length;
		varUniStatsTransf.add(new UnivariateStatistics(obsValue, nVar));
		statsUniCurrentIndexTransf += 1;
		calculateIntervals();
	}

	public void undoSampling() {
		resetSampling();
		resetValidity();
	}

	private void resetValidity() {
		for (int i = 0; i < originalValue.length; i++){
			originalValue[i].setValid(true);
			originalValue[i].setID(i);
		}
	}

	public void resetSampling() {
		sampled = false;
		while (listOfTransfs.size() > 0 && ((Integer) listOfTransfs.get(listOfTransfs.size() - 1)).intValue() != SAMPLING) {
			undoLastTrasf();
		}
		obsValue = originalValue;
		numOss = obsValue.length;
		listOfTransfs.remove(listOfTransfs.size() - 1);
		varUniStatsTransf.remove(statsUniCurrentIndexTransf);
		statsUniCurrentIndexTransf -= 1;
		// Removes all others SAMPLING in array
		int p = listOfTransfs.size() - 1;
		for (int i = p; i >= 0; i--) {
			if (((Integer) listOfTransfs.get(i)).intValue() == SAMPLING) {
				listOfTransfs.remove(i);
				varUniStatsTransf.remove(i+1);
				statsUniCurrentIndexTransf -= 1;
			}
		}
		calculateIntervals();
	}
	
	public boolean isSampled(){
		return sampled;
	}
	
	public Observation[] getCurObs(){
		return obsValue;
	}
	
	public int getObsID(int Index){
		if (Index < 0 || Index > obsValue.length) {
			throw new ArrayIndexOutOfBoundsException();
		} else
			return obsValue[Index].getID();
	}
	
	//Update 28/10/2006: + aggiunta funzione per recupero numero trasformazioni esistenti per la variabile
	//					 + spostamento reset della validity a ID in matrixOsservazioni
	//					 + aggiunte funzioni separate per operazione trasformazione variabili per clustering
	//					 ? controllare con Fuma se le statistiche sono necessarie dopo la trasf altrimenti non si ricalcolano
	public int getNumOfTransf(){
		return listOfTransfs.size();
	}
	
	/* These two functions are used only to transform and antitransform variable 
	 * for the clutering operation.As you can see aonly STDEV and MINMAX tranformations
	 * are allowed and no control on variable's type are performed.
	 */
	public void doClusteringTrasformation(int index){
		switch (index) {
		case STDEV:
			setStandardTransformation();
			break;
		case MINMAX:
			setMaxMinTransformation();
			break;
		default:
		}
	}
	public void undoClueringTrasformation(){
		switch (((Integer) listOfTransfs.get(listOfTransfs.size() - 1)).intValue()) {
		case STDEV:
			undoStandardTransformation();
			break;
		case MINMAX:
			undoMaxMinTransformation();
			break;
		}
	}
}