tsblurtroubleanalyze.java

根据模糊故障数的资料

package arithmetic.troubleTree;

import java.util.*;

public class TSBlurTroubleAnalyze {

	public double i, rule; // define the line,represent rules

	public double j; // define the row,represent matter or parts

	// ！XX矩阵的下标从0开始到YY.length-1, 行和列都有序号标示
	private double[][] XX; // 表示事件的故障程度的矩阵,i表示故障程度，j表示事件

	private double[][] XXP;// 表示事件的各种概率的矩阵，i表示各种概率，j表示事件

	private double x; // For every rule, 事件X的故障程度的概率的乘积

	private double y; // 每一条规则下，（事件X的（故障程度）所发生的（概率）的乘积）×（Y的（故障程度）对应的概率）

	// ！YY矩阵的下标从0开始到YY.length-1, 行和列都有序号标示
	// private double[][] YY; // 表示组合事件的故障程度的矩阵,i表示故障程度，j表示组合事件
	// private double[][] YYP;// 表示组合事件的各种概率的矩阵，i表示各种概率，j表示组合事件
	private double[][] YY; // 矩阵，该矩阵不同于XX，此矩阵的第一个表示行表示y的所有故障

	// 程度。其矩阵值是在相应故障程度下的发生概率
	// !注：该矩阵有行号，有列号
	public double[] YP; // 产生的矩阵YY的故障程度概率

	/**
	 * @param args
	 */
	/*
	 * public static void main(String[] args) { // TODO Auto-generated method
	 * stub TSBlurTroubleAnalyze tsb = new TSBlurTroubleAnalyze(); tsb.getXX();
	 * tsb.getXXP(); double[] yp = new double[28]; for(int q = 1; q < 28; q++){
	 * yp[q] = 1; } yp[1] = 0; yp[2] = 0.3; yp[4] = 0.4; yp[5] = 0.5;
	 * tsb.computeYp(yp); System.out.println(); }
	 */

	/**
	 * @deprecated 推导出y的所有故障程度的概率，关键点 1、哪一个y被选中 2、被选中的y的所有故障程度如何合理表示
	 * @param
	 */
	public void computeAllY() {
		//int nn = this.YY[0].length;
		int nn = this.YY.length;
		System.out.println("nn is " + YY.length);
		//数组yy有行号和列号
		//double[][] yy =new double[nn][YY.length];
		YP = new double[nn];
		//for(int n = 1; n < YY.length; n++){
			//for(int m = 1; m < YY[n].length; m++){
				//yy[m][n] = YY[n][m];
			//}
		//}
		//注：下面循环出现的yy在test测试里测试时，要换成YY，来测试
		//for (int mm = 1; mm < yy.length; mm++) {
		for (int mm = 1; mm < YY.length; mm++) {
			//for(int n = 1; n < yy[mm].length; n++){
				//System.out.println(yy[mm][n]);
			//}
			YP[mm] = computeYp(YY[mm]);
			//System.out.println(YP[mm]);
		}
	}

	/**
	 * @deprecated 推导出上一层的组合事件的一个故障程度的概率
	 * @param double[]b
	 *            表示每一条规则下的组合事件y的一个故障程度的概率 该数组没有行号和列号
	 * 
	 */
	public double computeYp(double[] b) {

		int n = XX.length - 1, m = XX[n].length - 1;
		// int ny = YYP.length - 1,my;
		// 表示每一条规则下的各种事件的故障程度
		double[] x = new double[m];
		// 表示每一条规则下的各种事件的故障程度的概率
		double[] xp = new double[m];
		// 表示每一条规则下的组合事件y的故障程度的概率
		double[] yp = b;

		double getCompP0L = 0;
		double getCompPY = 0;

		double getpy = 0;

		// n表示每一条规则，
		for (n = 1; n < XX.length; n++) {
			// m表示每一个事件在该规则下的故障程度
			// 把XX的值付给x，可能的问题：若有XX[][]的值为999，则说明该事件x没有该种故障程度
			for (m = 1; m < XX[n].length; m++) {
				if (XX[n][m] != (double) 999) {
					x[m - 1] = XX[n][m];
					xp[m - 1] = XXP[n][m];
				} else {
					x[m - 1] = (double) 999;
					xp[m - 1] = (double) 999;
				}

			}
			//for (int i = 0; i < xp.length; i++) {
				//System.out.println("value :" + xp[i]);
			//}

			getCompP0L = compP0L(xp);
			// System.out.print("getCompP0L value is :" + getCompP0L +"!!" +
			// "\n");
			getpy = yp[n];
			getCompPY = getCompPY + compPY(getCompP0L, getpy);
			//System.out.print("getCompPY value is :" +
			 //compPY(getCompP0L,getpy) +"!!" + "\n");

		}
		//System.out.print("value is :" + getCompPY +"!!" + "\n");
		return getCompPY;
		// System.out.print("value is :" + getCompPY +"!!" + "\n");
	}

	/**
	 * compute p0l
	 * 
	 * @param a ,
	 *            数组n表示在每一条规则下，所有事件的概率
	 * @return x, 返回该规则下的事件概率的乘积
	 */
	private double compP0L(double[] a) {
		double p0l = 1;
		for (int n = 0; n < a.length; n++) {
			if (a[n] != (double) 999) {
				p0l = p0l * a[n];
			} else
				p0l = p0l * 1;
		}
		x = p0l;

		return x;
	}

	/**
	 * @param a,
	 *            参数a表示该规则下的事件的概率乘积
	 * @return y, 返回该规则下的A × y的故障程度所对应的概率
	 */
	private double compPY(double a, double py) {
		py = py * a;
		y = py;

		return y;
	}

	/*-------------------------------------------------------------------*/
	/**
	 * @deprecated 从外界得到YY矩阵
	 * @param YY
	 */
	public void setYY(double[][] YY) {
		this.YY = YY;
	}

	/**
	 * @deprecated 从外界获得XX矩阵
	 * @param xx
	 */
	public void setXX(double[][] xx) {
		System.out.println("successful12");
		this.XX = xx;
	}

	/**
	 * @deprecated 从外界获得XXP矩阵
	 * @param xxp
	 */
	public void setXXP(double[][] xxp) {
		System.out.println("successful11");
		this.XXP = xxp;
		/*for (int i = 0; i < 28; i++) {
			for (int j = 0; j < 4; j++) {
				System.out.println("XXP[" + i + "][" + j + "] = " + XXP[i][j]
						+ ",   ");
			}
		}*/
	}

}