globe1.cpp

某个实验事编写粗糙集智能信息处理的程序

 	Set*  pPosSet=new Set[ClassDNum];/////////////positive Set 
	Set TemSet,TemSet1;
	int* pElement=new int[1];
    for(i=0;i<ClassDNum;i++){//得到每个决策类的正域pPosSet[i]
		for(j=0;j<RecNum;j++){
			if(Set::SetLessSet(pTClasswL[j],pEClassofDecis[i])){
                pElement[0]=j;
				TemSet1.SetParameter (pElement,1);
			    TemSet=pPosSet[i]+TemSet1;
				pPosSet[i]=TemSet;
			}
		}
	}
	int CardofPosRegion=0;
	for(i=0;i<ClassDNum;i++){
		CardofPosRegion+=pPosSet[i].GetCard ();//得到正域元素数目
	}
	delete[] pEClassofDecis;
	delete[] pTem;
	delete[] pPosSet;
	delete[] pTClasswL;
	return CardofPosRegion;
}
////////////////////////////Find Core Condition Attribute////////////////////////////////////////////////////////////////
void global1::FindCoreConAttr(Set& Core_ConAttr,int& Core_num,int* pCMiss,Set& Fre,
			float** pIS,char ***ISTable,int* pDec,int Rec_Num,Set& Con_Attr_Set)
{//找到条件属性的核属性  Core_num记录区分因子D的中属性个数，如果为核属性则为1
	int i,j,k,Tem,Core_Card;
	bool add=false,add1;
	int* pCore;
	int* pFre;
	int Con_Attr_Num=Con_Attr_Set.GetCard ();//条件属性个
	pCore=new int[Con_Attr_Num];
	/////////////////////////////////////////////////////////////////denny修改
	Core_num=0;
	int ***pTem;//记录扩展差异矩阵中每一个单元格子中区别属性
	int **Num; //记录扩展差异矩阵中每一个单元格子中属性的数目	
	pTem=new int **[Rec_Num];
	for(i=0;i<Rec_Num;i++)
	{
		pTem[i]=new int* [Rec_Num];
		for(j=0;j<Rec_Num;j++)	
			pTem[i][j]=new int[Con_Attr_Num];
	}
    Num=new int*[Rec_Num];
	for(i=0;i<Rec_Num;i++)
	{
		Num[i]=new int [Rec_Num];
		for(j=0;j<Rec_Num;j++)
			Num[i][j]=0;
	}
    /////////////////////////////////////////////////////////////////
	pFre=new int[Con_Attr_Num];
	for(i=0;i<Con_Attr_Num;i++){
		pFre[i]=1;
	}
	Core_Card=0;//统计核属性个数
	for(i=0;i<Rec_Num;i++){
		for(j=i+1;j<Rec_Num;j++){
               if(ToleRelation(pIS,ISTable,Con_Attr_Set,i,j)){
			     continue;	//i,j实例满足限制容差关系,继续			  
			   }
			   else{
		    	Tem=0;
				add1=false;
			   	for(k=0;k<Con_Attr_Num;k++){
//			   		if((pIS[i][Con_Attr_Set.GetElement (k)]!=-1)&&(pIS[j][Con_Attr_Set.GetElement (k)]!=-1)
					if(strcmp(ISTable[i][Con_Attr_Set.GetElement (k)],"-")!=0 
						&& strcmp(ISTable[j][Con_Attr_Set.GetElement (k)],"-")!=0)
					{
						add1=true;
						if(pIS[j][Con_Attr_Set.GetElement (k)]!=pIS[i][Con_Attr_Set.GetElement (k)]){
						//如果i,j实例对应属性值都不为遗失并且不相等						
			   			pTem[i][j][Tem]=Con_Attr_Set.GetElement (k);
			   			Tem++;
						} 
					}
				}
				if(add1==false) //denny增加的处理步骤
				{
					for(k=0;k<Con_Attr_Num;k++){
						pTem[i][j][Tem]=Con_Attr_Set.GetElement (k);
						Tem++;
					}
				}
				Num[i][j]=Tem;//记录格子的属性个数
				if(Core_num==0 && Num[i][j]>0)
					Core_num=Num[i][j];
			   }//end else
		}//end for(j)
	} //end for(i)
	if(Core_num>0){
    	for(i=0;i<Rec_Num;i++)//得到包含属性个数最小的区分因子的个数
	    	for(j=i+1;j<Rec_Num;j++)
				if(Core_num>Num[i][j] && Num[i][j]>0)
					Core_num=Num[i][j];
				}
       if(Core_num>1)//此时，先统计这样的区分因子的出现频率，再选取出现频率最大且遗失属性值最小的一个区分因子
	   {
		   int DNum=0;//统计区分因子
		   Set tempSet;//临时集合
		   int Rec=Rec_Num*Rec_Num;
		   Set *D=new Set[Rec];
		   	for(i=0;i<Rec_Num;i++)
			{
        		for(j=i+1;j<Rec_Num;j++)
				{
					if(Core_num==Num[i][j])
					{
						add=true;
						tempSet.SetParameter(pTem[i][j],Core_num);
						for(k=0;k<DNum;k++)
						{
							if(Set::SetEqualSet(tempSet,D[k]))
							{//看是否有重复
							add=false;
							pFre[k]++;
							break;
							} //end if
						}//end for(k) 
					   if(add)
					   {//不重复,加入
					   	D[DNum].SetParameter(pTem[i][j],Core_num);
					 	DNum++;//区分因子个数数目加一
					   } 
					}//end if(Core_num==Num[i][j])
					}//edn for(j)
				} //end for(i)
            if(DNum>1)//最小区分因子不止一个，选取出现频率最大的那个区分因子
			{
				int MaxFre=pFre[0];
				int label=0;
				int MaxFreNum=0;
				for(i=1;i<DNum;i++)   //统计出现频率，找到最大值
				{
					if(MaxFre<pFre[i])
					{
						MaxFre=pFre[i];
						label=i;  //标记第一个最大频率
					}
				}
				for(i=0;i<DNum;i++)
					if(MaxFre==pFre[i])
						MaxFreNum++;//得到出现频率最大的区分因子个数
				if(MaxFreNum==1)
				{
					Core_ConAttr=D[label];
				}
				else //z找出遗失属性值最少的那个区分因子
				{
					int MissAttrNum=0;
					int MissAttrNum1=0;
					int Attlabel;//属性位置标记
					for(i=0;i<Core_num;i++)
					{
						Attlabel=D[label].GetElement(i);
						MissAttrNum=MissAttrNum+pCMiss[Attlabel];
					}
					for(i=label+1;i<DNum;i++)
						if(MaxFre==pFre[i])
						{
							MissAttrNum1=0;
							for(j=0;j<Core_num;j++)
								MissAttrNum1+=pCMiss[D[i].GetElement(j)];
							if(MissAttrNum1<MissAttrNum)
								label=i;
						}
					Core_ConAttr=D[label]; //找到遗失属性最小的属性集合
				} //end else
			}			//end if(Core_num>1)
			else if(DNum==1)
				Core_ConAttr=D[0]; //只有一个这样的最小区分因子
	   }//end if(Core_num>1)
	   else if(Core_num==1)//Core_num＝1时唯一属性区分两个实例,为核属性
	   {
	      for(i=0;i<Rec_Num;i++)
		  {
	     	for(j=i+1;j<Rec_Num;j++)
			{
				if(Num[i][j]==1)
				{
					add=true;
					for(k=0;k<Core_Card;k++)
					{
						if(pTem[i][j][0]==pCore[k])
						{//看是否有重复
							add=false;
							pFre[k]++;
							break;
						}
					}
					if(add)
					{//不重复,加入
						pCore[Core_Card]=pTem[i][j][0];
						Core_Card++;//核属性数目加一
					}
				}//end if					
			}//end for(j)
		  }//end for(i)
	   
		  if(Core_Card==0)
		  {
			  Core_ConAttr.SetParameter(NULL,0);//to be revised
			  Fre.SetParameter (NULL,0);
		  }else
		  {
			  Core_ConAttr.SetParameter (pCore,Core_Card);
			  Fre.SetParameter (pFre,Core_Card);
		  }
	   }  //end else
	 for(i=0;i<Rec_Num;i++)	
	 {
		 delete[] Num[i];
		 for(j=0;j<Rec_Num;j++)	
			delete [] pTem[i][j];
		 delete[] pTem[i];
	 }
	delete[]pTem;
	delete[]pCore;
	delete[]pFre;

}
////////////////Algorithm1/////////////////////////////////////////////////////////////////////////////
////////////////computer Missed Value   Number///////////////////////////////////////////////////////////
int global1::MissValueNum(Set& Q,int* pCMiss)
{//统计信息表总的遗失属性数
	int k;
	int Miss=0;
    for(k=0;k<Q.GetCard ();k++){
		Miss=Miss+pCMiss[Q.GetElement (k)];
	}
	return Miss;
}
////////////Select Condition Attribute Set/////////////////////////////////////////////////////////
bool global1::SelConAttrSet(float Criterion,Set&  Rset,float** pIS,char ***ISTable,int RecNum,Set& ConAttrSet,int* pDecis)
{//确定条件属性集,按照一定的精度(正域所占全集的比例)确定条件属性
	int i,j,k;
	float Rate;
	int ConAttrNum;
	int* pCMiss;
	Set P;
	P=ConAttrSet;
	Rset.SetParameter (NULL,0);
    ConAttrNum=ConAttrSet.GetCard ();
	//////////////////////////////////////////////////
    pCMiss=new int[ConAttrNum];
   	int Miss;
	for(i=0;i<ConAttrNum;i++){///missed value number of condition attribute//统计每个条件属性的遗失属性数目
		Miss=0;
		for(j=0;j<RecNum;j++){
//			if(pIS[j][ConAttrSet.GetElement (i)]==-1)
			if(strcmp(ISTable[j][ConAttrSet.GetElement (i)],"-")==0)
			{
				Miss++;
			}
		}
		pCMiss[ConAttrSet.GetElement (i)]=Miss;
	}
	bool add;
    int* pCCard=new int[ConAttrSet.GetCard()];////Card of all attributes
	for(i=0;i<ConAttrSet.GetCard();i++){//统计每个属性不同属性值的个数
		pCCard[i]=0;
		for(j=0;j<RecNum;j++){
			add=true;
			for(k=0;k<j;k++){
				if(pIS[k][i]==pIS[j][i]){
					add=false;
					break;
				}
			}
			if(add){
				pCCard[i]++;
			}
		}
	}
	//////////////////////////////////////////
    Set Q,Fre,Tem,TemD,Max_Fre;

	int* pTemElement;
	Q.SetParameter (NULL,0);
	int TemCard;
	int Core_num=0;
	FindCoreConAttr(Q,Core_num,pCMiss,Fre,pIS, ISTable,pDecis,RecNum,ConAttrSet);//找到核属性
	
	Set Del_Fre;
	int* pFre=new int[1];
	pFre[0]=0;
	Del_Fre.SetParameter (pFre,1);//初始化Del_Fre
	delete[] pFre;
	int Max_F;
	int Position;
	int MinMiss;
	int MinCard;
	int* pTemq=new int[1];
	//////////////////////////////////// ////////denny修改
	if(Core_num>1)   //当区分属性个数大于一时,R=D,if kr>Criterion,返回
	{
    	Rset=Q;
		if(Rset.GetCard ()==ConAttrSet.GetCard ()){
    		return true;//等于全体条件属性集,返回
		}
    	Rate=float(CardofPosRegion(pIS, ISTable,pDecis,RecNum,Rset))/RecNum;
    	if(Rate>=Criterion)//满足预期近似分类精度,返回
	    	return true;
	}
	/////////////////////////////////////////////////
	else if(Core_num==1) 
	{
	while(Q.GetCard ()!=0){//核属性不为空 步骤7
    	Max_F=0;
    	for(i=0;i<Fre.GetCard ();i++){
    		if(Fre.GetElement (i)>Max_F){//找出频率最大的
    			Max_F=Fre.GetElement (i);
			}
		}
    	TemCard=0;
    	pTemElement=new int[Q.GetCard ()];
    	for(i=0;i<Q.GetCard ();i++){
    		if(Fre.GetElement (i)==Max_F){//当找到频率最大的属性时,拷贝属性
    			pTemElement[TemCard]=Q.GetElement (i);
    			TemCard++;
			}
		}
	   Max_Fre.SetParameter (pTemElement,TemCard);///得到最大频率属性集合,可能不止一个max frequency set
       delete[] pTemElement;
    	if(Max_Fre.GetCard ()==1){//唯一
    		pTemq[0]=Max_Fre.GetElement (0);//选出属性
		}else{//多个,选出最小遗失属性值,最少不同属性个数的属性
			MinMiss=pCMiss[Max_Fre.GetElement (0)];
	    	for(i=0;i<Max_Fre.GetCard ();i++){
	    		if(pCMiss[Max_Fre.GetElement (i)]<MinMiss){
	    			MinMiss=pCMiss[Max_Fre.GetElement (i)];
				}
			}
            for(i=0;i<Max_Fre.GetCard ();i++){
		    	if(pCMiss[Max_Fre.GetElement (i)]==MinMiss){
		         	pTemq[0]=Max_Fre.GetElement (i);
			    	MinCard=pCCard[Max_Fre.GetElement (i)];
		        	break;
				}
			}
            for(i=0;i<Max_Fre.GetCard ();i++){
		    	if(pCMiss[Max_Fre.GetElement (i)]==MinMiss){//不止一个属性具有最小遗失
					if(pCCard[Max_Fre.GetElement (i)]<MinCard){
						pTemq[0]=Max_Fre.GetElement (i);
			        	MinCard=pCCard[Max_Fre.GetElement (i)];
					}
				}
			}
		}
        TemD.SetParameter(pTemq,1);//找到了这个核属性,确定位置
		for(i=0;i<Q.GetCard ();i++){
			if(TemD.GetElement (0)==Q.GetElement (i)){
				Position=i;
				break;
			}
		}
		Fre.Replace (Position,0);//频率设为0
		Tem=Fre-Del_Fre;
		Fre=Tem;//得到剩下的频率集合
	    Tem=Q-TemD;//得到剩下的属性集合
        Q=Tem;
	    Tem=Rset+TemD;//约简后的属性集
    	Rset=Tem;
		if(Rset.GetCard ()==ConAttrSet.GetCard ()){
    		return true;//等于全体条件属性集,返回
		}
    	Rate=float(CardofPosRegion(pIS, ISTable,pDecis,RecNum,Rset))/RecNum;
    	if(Rate>=Criterion){//满足预期近似分类精度,返回
	    	return true;
		}
	}//while
	}
	//不存在核属性时
	delete[] pTemq;

	Tem=P-Rset;
	P=Tem;//step8
	
/*	TemCard=0;
	Set  Del_Set;
	pTemElement=new int[P.GetCard ()];
	for(i=0;i<P.GetCard ();i++){
		if(pCCard[P.GetElement (i)]==1){
	    	pTemElement[TemCard]=P.GetElement (i);
		    TemCard++;
		}
	}	
	Del_Set.SetParameter (pTemElement,TemCard);
	delete[] pTemElement;
	Tem=P-Del_Set;
	P=Tem;*/
	Set  EqCardPos;
	int* pCardPos;
    int MaxPos;
	int* pSelP=new int[1];
	do{//step9
		MaxPos=0;
		pCardPos=new int[P.GetCard()];
		pTemElement=new int[1];
		for(i=0;i<P.GetCard();i++){
			pTemElement[0]=P.GetElement(i);
			Tem.SetParameter(pTemElement,1);
			TemD=Tem+Rset;
			pCardPos[i]=CardofPosRegion(pIS, ISTable,pDecis,RecNum,TemD);
			if(pCardPos[i]>MaxPos){//CardofPosRegion(pIS,pDecis,RecNum,TemD)
				MaxPos=pCardPos[i];//CardofPosRegion(pIS,pDecis,RecNum,TemD);
			}
		}
		delete[] pTemElement;
        pTemElement=new int[P.GetCard()];
		TemCard=0;
		for(i=0;i<P.GetCard ();i++){
			if(pCardPos[i]==MaxPos){
				pTemElement[TemCard]=P.GetElement (i);
				TemCard++;//统计具有最大近似分类精度的属性个数
			}
		}
		EqCardPos.SetParameter (pTemElement,TemCard);
		delete[]  pCardPos;
		delete[] pTemElement;
        if(EqCardPos.GetCard ()==1){
			pSelP[0]=EqCardPos.GetElement (0);
		}
		else{	//不止一个,选出具有最小((遗失属性值个数*属性不同值)的属性
			MinMiss=pCMiss[EqCardPos.GetElement (0)];//modify
/////////////////////////////////////////////////////////////////////////////////////////////////修改
			int MissCard=pCMiss[EqCardPos.GetElement (0)]*pCCard[EqCardPos.GetElement (0)];
			pSelP[0]=EqCardPos.GetElement (0);
            for(i=0;i<EqCardPos.GetCard ();i++){
				if(MissCard>pCMiss[EqCardPos.GetElement (i)]*pCCard[EqCardPos.GetElement (i)]){
					MissCard=pCMiss[EqCardPos.GetElement (i)]*pCCard[EqCardPos.GetElement (i)];
					pSelP[0]=EqCardPos.GetElement (i);
				}
			}
/*	    	for(i=0;i<EqCardPos.GetCard ();i++){//  find a attribut with min missed value
				if(pCMiss[EqCardPos.GetElement (i)]<MinMiss){
			    	MinMiss=pCMiss[EqCardPos.GetElement (i)];
				}
			}
	    	for(i=0;i<EqCardPos.GetCard ();i++){
		    	if(pCMiss[EqCardPos.GetElement (i)]==MinMiss){
		    		pSelP[0]=EqCardPos.GetElement (i);
					MinCard=pCCard[EqCardPos.GetElement (i)];
					break;
				}
			}
           	for(i=0;i<EqCardPos.GetCard();i++){
				if(pCMiss[EqCardPos.GetElement (i)]==MinMiss){
	        		if(pCCard[EqCardPos.GetElement (i)]<MinCard){
                        pSelP[0]=EqCardPos.GetElement (i);
	        			MinCard=pCCard[EqCardPos.GetElement (i)];
					}
				}
			}
*///////////////////////////////////////////////////////////////////////////////////////////////////修改
		}
		Tem.SetParameter (pSelP,1);
		TemD=Rset+Tem;
		Rset=TemD;
		TemD=P-Tem;
		P=TemD;
        if(P.GetCard ()==0){
	  	     break;
		}
		Rate=float(CardofPosRegion(pIS, ISTable,pDecis,RecNum,Rset))/RecNum;
	}while(Rate<Criterion);
	delete[] pSelP;
	delete[] pCCard;    
    delete[] pCMiss;
	return true;
}
/////////////////////Decision Matrix///////////////////////////////////////////////////////////////////////
//void global1::DecisMatrix(Set** pDMatrix,char** pIS,int RecNum,Set& ConAttrSet,int* pDecis)
void global1::DecisMatrix(Set* pDMatrix,int n,float** pIS,char*** ISTable,int RecNum,int ConAttrNum,int* pDecis)
{//构建规则n的广义差异矩阵行
	int j,k,m;
	int* pTem=new int[ConAttrNum];//ConAttrSet.GetCard ()
	int  Tem;
	m=0;
	int Same;
/*	for(j=0;j<RecNum;j++){ 
			if(pDecis[j]!=pDecis[n]){//决策不等
		   		Tem=0;
				Same=0;
		    	for(k=0;k<ConAttrNum;k++){
					if(strcmp(ISTable[n][k],"-")!=0 && strcmp(ISTable[j][k],"-")!=0)
					{//只要有一个不为遗失值
						Same++;
					}
				}
				if(Same==0){//j和n之间不存在这样的关系
                   for(k=0;k<ConAttrNum;k++){
					   pTem[Tem]=k;
					   Tem++;
				   }
				}else{
					for(k=0;k<ConAttrNum;k++){
//    	    		  if((pIS[n][k]!=-1)&&(pIS[j][k]!=-1)&&(pIS[j][k]!=pIS[n][k])){//ConAttrSet.GetElement (k)
						if(strcmp(ISTable[n][k],"-")!=0 && strcmp(ISTable[j][k],"-")!=0 && pIS[j][k]!=pIS[n][k]){
    		    			pTem[Tem]=k;//统计差异属性
  			    			Tem++;