getvalue.java

根据模糊故障数的资料

package arithmetic.troubleTree;

import java.util.*;
import java.io.*;

public class GetValue {

	private int matterNum;
	private int systemNum;

	private double[][] XX;
	private double[][] XXP;
	private double[][] YYP;
	private double[] YP;
	
	private TSBlurTroubleAnalyze tsb = new TSBlurTroubleAnalyze();

	public void getMatterNum(int a) {
		this.matterNum = a;
	}

	public void getSystemNum(int a) {
		this.systemNum = a;
	}

	public void conformity() {
		int x = matterNum;
		int y = systemNum;
	}

	/**
	 * @deprecated 外界只要输入以下给定的3个参数，就可以得出该事件集合＝》组合事件的各个故障程度的概率
	 * @param XD
	 * 			其形式：序号\事件集 X1     ,    X2 ··············Xn
	 * 					0	 x1的故障程度,  x2的故障程度       xn的故障程度 
	 * 					1	 x1的故障程度,  x2的故障程度       xn的故障程度	
	 * 					··     ·····         ····              ····
	 * 					n－1 x1的故障程度,  x2的故障程度       xn的故障程度
	 * 			动态数组：该矩阵把事件集XD的故障程度，用ArrayList来存储表示。
	 * @param XP
	 * 			其形式：序号\事件集 X1      ,     X2 ··············Xn
	 * 					0	 x1的故障程度概率, x2的故障程度概率  xn的故障程度概率 
	 * 					1	 x1的故障程度概率, x2的故障程度概率  xn的故障程度概率	
	 * 					··       ······         ·····          ·····
	 * 					n－1 x1的故障程度概率,  x2的故障程度概率 xn的故障程度概率
	 * 			动态数组：该矩阵把事件集XP的故障程度的概率，用ArrayList来存储表示。
	 * @param YD 从外界得到以上事件集组合＝》组合事件y的所有故障程度在专家经验下发生的概率，
	 * 			是一个一位数组,其值是组合事件y的故障程度。
	 * @return
	 * 			一维数组：得到组合事件y的各个故障程度在以上事件集下发生的概率。
	 */
	//public double[] autoCompute(ArrayList XD,ArrayList XP,double[] YD){
	public double[] autoCompute(ArrayList XD,ArrayList XP,double[][] YD){
		getTroubleDegree(XD);
		getTroubleProbility(XP);
		
		//YYP = getYYD(YD);
		setYTroubleProbilityY(YD);
		
		setTroubleDegreeTSB();
		setTroubleDProbilityTSB();
		GetTroubleProbilityY();
		
		getYTroubleProbilityY();
		for(int i = 0; i < YP.length; i++){
			System.out.println("value is :" + YP[i]);
		}
		return YP;
	}
	
/*--------------------------------------------------------------------*/
	/**
	 * @deprecated 给类TSB赋值，输入YY矩阵
	 */
	//public void setYTroubleProbilityY(double[][] yy){
		//tsb.setYY(yy);
	//}
	public void setYTroubleProbilityY(double[][] yy){
		tsb.setYY(yy);
	}
	
	/**
	 * @deprecated 获得一维矩阵YP，组合事件YP的概率
	 *
	 */
	public void getYTroubleProbilityY(){
	    YP = tsb.YP;
	    //System.out.println("tsb.YP length is :" + tsb.YP.length);
	}
	
	/**
	 * @deprecated 根据获得的一维矩阵YD，通过调用其它类来完成二维矩阵YYP，
	 * @param YD
	 * 			一维矩阵YD。
	 * @return
	 */
	//public double[][] getYYD(double[] YD){
		//GetCompoundMatterY getCompoundMatterY = new GetCompoundMatterY();
		//return getCompoundMatterY.produceYYP(YD);
	//}
/*--------------------------------------------------------------------*/	
	/**
	 * 3
	 * @deprecated 调用
	 * @param x
	 */
	public void GetTroubleProbilityY() {
		tsb.computeAllY();
		System.out.println("successfu4");
		YP = tsb.YP;
		for(int n = 0; n < YP.length; n++)
			System.out.println();
	}

	/**
	 * 1
	 * @deprecated 调用SetRuleMatix矩阵，产生TroubleDegree RuleMatix
	 * @return 已经生成故障程度规则矩阵XX，并返回
	 */
	public double[][] getTroubleDegree(ArrayList x) {
		SetRuleMatixs ruleMatixs = new SetRuleMatixs(x);
		this.XX = ruleMatixs.getRuleMatixs();
		System.out.println("successful1");
		return ruleMatixs.getRuleMatixs();
	}

	/**
	 * 1
	 * @deprecated 调用SetRuleMatix矩阵，产生TroubleProbility RuleMatix
	 * @return 已经生成概率规则矩阵XXP，并返回
	 */
	public double[][] getTroubleProbility(ArrayList xp) {
		SetRuleMatixs ruleMatixs = new SetRuleMatixs(xp);
		this.XXP = ruleMatixs.getRuleMatixs();
		System.out.println("successful2");
		return ruleMatixs.getRuleMatixs();
	}
	
	/**
	 * 2
	 * @deprecated 调用SetRuleMatix矩阵，产生TroubleDegree RuleMatix
	 * @param x
	 */
	public void setTroubleDegreeTSB() {
		tsb.setXX(XX);
	}
	
	/**
	 * 2
	 * @deprecated 调用SetRuleMatix矩阵，产生TroubleDegree RuleMatix
	 * @param x
	 */
	public void setTroubleDProbilityTSB() {
		System.out.println("successful3");
		tsb.setXXP(XXP);
	}

}