gspn.java

来自「Petri网分析工具PIPE is open-source」· Java 代码 · 共 1,440 行 · 第 1/4 页

		for (int i = 1; i<= row; i++) {
			for(int j = 0; j < row; j ++) {
				enh.set(i, j, inv.get(i-1,j));
			}
		}
		
		for (int i = 1; i <= row; i++) {
			enh.set(i, row, 0);
		}
		
		enh.print(8,5);
		*/
		
		//This generates the steady state distribution of the embedded Markov process.
	/*	double[] embeddedMarkovSteadyStateDistrib = reduction(enh);
		for (int i = 0; i < embeddedMarkovSteadyStateDistrib.length; i++) {
			System.out.println("Result " + i + " = " + embeddedMarkovSteadyStateDistrib[i]);
		}
		
		Matrix meanVisits = calcMeanNumVisits(embeddedMarkovSteadyStateDistrib);
		
		meanVisits.print(8,5);
		
		double[] sojournTime = calcSojournTime(pnmldata, tangible);
		
		int sLength = sojournTime.length;
		System.out.println("Sojourn times");
		for (int i = 0; i< sLength; i++) {
			System.out.print ("Sojourn time " + i + " " + sojournTime[i] + " ");
		}
		
		System.out.println();
		
		double xHat = xHat(sojournTime, embeddedMarkovSteadyStateDistrib);
		System.out.println(xHat +" xHat");

		double[] meanCycleTimes = calcMeanCycleTimes(embeddedMarkovSteadyStateDistrib, xHat);
		
		int meanCycleLength = meanCycleTimes.length;
		for (int i = 0; i < meanCycleLength; i++) {
			System.out.println(meanCycleTimes[i] + " meanCycleTimes["+ i +"]");
		}
		
		double[] steadyStateDistribution = getSteadyStateDistribution(meanCycleTimes, sojournTime);
		for (int i = 0; i<meanCycleLength; i++) {
			System.out.println(steadyStateDistribution[i] + " steady state distribution["+ i + "]");
		}
		
		double[][] rates = rateMatrix(pnmldata, tangible, vanishing);
		
		Matrix eTwiddle = new Matrix(rates);
		System.out.println("E twiddle");
		eTwiddle.print(5,8);
		
		Matrix eTwiddleIMinusCInverse = eTwiddle.times(iMinusCInverse);
		eTwiddleIMinusCInverse.print(5,8);
		Matrix steadyStateDistrib = new Matrix(1,meanCycleLength);
		for (int i=0; i< meanCycleLength; i++) {
			steadyStateDistrib.set(0,i,steadyStateDistribution[i]);
		}
		Matrix vanishingSteadyState = steadyStateDistrib.times(eTwiddleIMinusCInverse);
		vanishingSteadyState.print(5,8);
		*/
		
		/*
		double tp1 = getVanishingStateThroughput(pnmldata, vanishing, 0, vanishingSteadyState );
		System.out.println("Transition 1 throughput: " + tp1);
		double tp2 = getVanishingStateThroughput(pnmldata, vanishing, 1, vanishingSteadyState );
		System.out.println("Transition 2 throughput: " + tp2);
		double tp3 = getVanishingStateThroughput(pnmldata, vanishing, 2, vanishingSteadyState );
		
		System.out.println("Transition 3 throughput: " + tp3);
		
		double tp4 = getTransitionThroughputSPN(pnmldata, tangible, steadyStateDistribution, 4);
		System.out.println("Transition 4 throughput: " + tp4);
		*/
		//double[] throughput = getTransitionThroughput(pnmldata, vanishing, tangible, vanishingSteadyState, steadyStateDistribution);
		//for (int i = 0; i<transCount; i++){
		//	System.out.print( throughput[i] + " ");
		//}
		//next - calculate throughput for tangible states as per SPN methodology
		//calculate throughput for vanishing states .
		
		
		
	//}
	
//######################################################################################################################	
	
	/**
	 * 
	 * @param Matrix c where C is the matrix of transition probabilities from vanishing to vanishing states
	 * @param Matrix d where D is the matrix of transition probabilities from vanishing to tangible states
	 * @param Matrix e where E is the matrix of transition probabilities from tangible to vanishing states
	 * @param Matrix f where F is the matrix of transition probabilities from tangible to tangible states
	 * @return double[] - the steady state distributions for Markov chain embedded in tangible states
	 * This function produces a solution for the following equations:
	 * P' = F + E*((I-C)^-1)*D 
	 * &pi; bar * P' = &pi; bar
	 * &Sigma; (&pi; bar (i)) &forall; i == 1
	 * where &pi; bar is the vector of the embedded Markov chain steady state distribution.
	 * See Falko Bause - Stochastic Petri Nets - An Introduction to the Theory p181.
	 * 
	 */
	private double[] getEmbeddedMarkovChainSteadyStateDistribution(Matrix c, Matrix d, Matrix e, Matrix f){
		//Part one - generate P'  (= F + E*((I-C)^-1)*D)
		
		int cSize = c.getRowDimension();
		Matrix iMinusC  = new Matrix(cSize, cSize); //initialise as an identity matrix
		for (int i = 0; i<cSize; i++){
			for (int j = 0; j < cSize; j++) {
				if (i==j) iMinusC.set(i,j,1.0);
				else iMinusC.set(i,j,0);
			}
		}
		iMinusC.minusEquals(c);
		Matrix iMinusCInverse = iMinusC.inverse();
		Matrix iMinusCInverseD = new Matrix(iMinusCInverse.getRowDimension(),d.getColumnDimension());
		iMinusCInverseD = iMinusCInverse.times(d); 
		Matrix eIMinusCInverseD = new Matrix(e.getRowDimension(),iMinusCInverseD.getColumnDimension());
		eIMinusCInverseD = e.times(iMinusCInverseD);	
		f.plusEquals(eIMinusCInverseD);
		
		//Part two - rearrange P' and pi_bar to prepare them for Gaussian reduction
		Matrix piBarM = new Matrix(1,f.getColumnDimension());
		for (int i = 0; i <f.getColumnDimension(); i++){
			piBarM.set(0,i,1);	
		}
		
		Matrix inverseF = f.transpose();
		for (int j = 0; j <inverseF.getRowDimension(); j ++) {
			inverseF.set(j, j, (inverseF.get(j,j)) - 1);
		}
		int row = inverseF.getColumnDimension();
		
		Matrix solutionMatrix = new Matrix(row+1, row+1);
		
		for (int i = 0; i <= row; i++){
			solutionMatrix.set(0, i, 1);
		}
		for (int i = 1; i<= row; i++) {
			for(int j = 0; j < row; j ++) {
				solutionMatrix.set(i, j, inverseF.get(i-1,j));
			}
		}
		
		for (int i = 1; i <= row; i++) {
			solutionMatrix.set(i, row, 0);
		}
		double[] embeddedMarkovSteadyStateDistrib = reduction(solutionMatrix);
		return embeddedMarkovSteadyStateDistrib;
	
	}
	
//######################################################################################################################	
	
	/**
	 * See if the supplied net has any timed transitions.
	 * @param DataLayer
	 * @return boolean
	 * @author Matthew
	 *
	 */
	private boolean hasTimedTransitions(DataLayer pnmldata){
		Transition[] transitions = pnmldata.getTransitions();
		int transCount = transitions.length;
		boolean hasTimed = false;
		int length = transitions.length;
		
		 for (int i = 0; i< length; i++) {
		 if (transitions[i].getTimed()==true)
		 hasTimed = true;
		 }
		 
		if (hasTimed == true)
			return true;
		else 
			return false;
		
	}
	
//######################################################################################################################	
	
	/**
	 * See if the supplied net has any timed transitions.
	 * @param DataLayer
	 * @return boolean
	 * @author Matthew
	 *
	 */
	private boolean hasImmediateTransitions(DataLayer pnmldata){
		Transition[] transitions = pnmldata.getTransitions();
		int transCount = transitions.length;
		boolean hasImmediate = false;
		int length = transitions.length;
		
		for (int i = 0; i< length; i++) {
			if (transitions[i].getTimed()==false)
				hasImmediate = true;
		}
		
		if (hasImmediate == true)
			return true;
		else 
			return false;
		
	}
	
//######################################################################################################################
	/**This function performs a Gaussian reduction on a given Matrix, returning an array of values representing the solution.
	 * @param Matrix - the matrix of coefficients to be solved
	 * @return double[] - the array of solutions
	 * 
	 */
	private double[] reduction(Matrix input) {
		int row = input.getRowDimension();
		int col = input.getColumnDimension();
		double[] result = new double[col-1];
		//initialise results to 0 - have n-1 unknowns in n equations, so result can be 1 less than size of input matrix.
		for (int i = 0; i<col-1; i++){
			result[i] = 0;
		}
		//***********************************************************
		//First stage - reduce matrix of coefficients by substitution
		//***********************************************************
		boolean reducedThisRow = false;
		
		//Start - first row should have 1 as each coefficient.  Test if second row has 0 as coeffiecient - if so, move on and swap.
		for (int i = 0; i < row - 1; i++){
			for (int j = i + 1; j <row; j++){
				if ((input.get(j, i)== 0.0)&& reducedThisRow == false ){ //if the element is 0 and we haven't already  
					int k = j;											//reduced a row, search down the list till we find one, then swap it into the current position
					while ((input.get(k,i)== 0.0)&& k < row - 1 ) {
						k++;
						}
					if (k < row) {
						swapRows(input, j, k);
					} else {
						throw new ArithmeticException("Not enough parameters to calculate result");
					}
				} else if (input.get(j,i)!=0.0){					//reduce the row coeffecients by arithmetic substitution.
				double factor = ((input.get(i, i))/(input.get(j, i)));
				//System.out.println(factor + " Factor");
				//System.out.println(input.get(i,i) +" input.get(i,i)");
				//System.out.println(input.get(j,i) +" input.get(i,j)");
				multiplyRow(input,j,factor);
				subtractRow(input,i,j);
				//input.print(8,5);				//if the coefficient is 0 and we've already performed a reduction in this pass
				reducedThisRow = true;			//take no action and move onto the next
				}								
			
			}
			reducedThisRow = false;					
		}
	//************************************
	//next stage - backwards substitution.
	//************************************
		for (int i= row - 2; i>= 0; i--) {
			double backSub = 0;
			for (int j = i+1; j<row-1; j++) {	
					backSub = backSub + (result[j]*input.get(i,j));
				}
			result[i] = (input.get(i,row - 1) - backSub)/input.get(i,i);
			}
		return result;
	}
	
//######################################################################################################################	
	//Helper function for reduction function
	private void swapRows (Matrix input, int row1, int row2) {
		int col = input.getColumnDimension();
		double temp;
		for (int i = 0; i < col; i++) {
			temp = input.get(row1,i);
			input.set(row1,i,input.get(row2,i));
			input.set(row2,i,temp);
		}
	}
	
//######################################################################################################################	
	//Helper function for reduction function
	private void multiplyRow(Matrix input, int row, double factor) {
		int col = input.getColumnDimension();
		for (int i = 0; i <col ; i++){
			double newVal = (input.get(row,i))*factor;
			input.set(row, i,newVal);
		}
	}
	
//######################################################################################################################	
	//subtract the values of row1 from the values of row2 
	private void subtractRow(Matrix input, int row1, int row2) {
		int col = input.getColumnDimension();
		for (int i = 0; i <col; i++) {
			double r1 = input.get(row1,i);
			double r2 = input.get(row2,i);
			//System.out.println(r1 +" r1 " + r2 + " r2 " + i + " i ");
			input.set(row2,i,(r2 - r1));
		}
	}
	
//######################################################################################################################
	
	private double[][] probabilityMatrix(DataLayer pnmldata, StateList list1, StateList list2) {
		int list1Length = list1.size();
		int list2Length = list2.size();
		double[][] result = new double[list1Length][list2Length];
		
		for(int i = 0; i <list1Length; i++){
			for(int j = 0; j <list2Length; j++){	
				result[i][j] = probMarkingAToMarkingB(pnmldata, list1.get(i), list2.get(j));
				//System.out.println(result[i][j]+ "  probability " + i + " " + j);
			}
		}

		return result;
		
	}

//######################################################################################################################
	
	private void printMatrix(double[][] input) {
		int rows = input.length;
		int cols = input[0].length;
		System.out.println("Printing a matrix of "+ rows +" rows and " + cols +" columns.");
		for (int i = 0; i<rows; i++) {
			for (int j = 0; j < cols; j++) {
				System.out.print(input[i][j] + " ");
			}
			System.out.println("");
		}
	}
	
//######################################################################################################################
	
	private void printMatrix(int[][] input) {
		int rows = input.length;
		int cols = input[0].length;
		System.out.println("Printing a matrix of "+ rows +" rows and " + cols +" columns.");
		for (int i = 0; i<rows; i++) {
			for (int j = 0; j < cols; j++) {
				System.out.print(input[i][j] + " ");
			}
			System.out.println("");
		}
	}	

//######################################################################################################################
	
	private void printMarking (int[] marking) {
	int rows = marking.length;
	System.out.print("Marking as follows: ");
	for (int i = 0; i < rows; i++) {
	System.out.print(marking[i] + " ");
	}
	System.out.println();
	}


}