skowron.cpp

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

			delete m_pRules;
			m_pRules = m_pr1;
		}
	}
	else//冲突时 m_Confict[n-1]!=0
	{
		int k=n-1;
		int iCoreAtt=-1;
    	for(k=0;k<iAttNum;k++)
			if(m_pCut[k]==1)
			{
				iCoreAtt=k;//得到核属性
				break;
			}		
	    Object* m_TempObject1;
		int rule_val;//规则的值
		for(i = 0;i < iClassNum;i++)
		{//构造并拷贝规则 i行产生的规则
	//		if(temp[i][0] == 1)
	//		{//本来就冲突
				while(m_pr1 != NULL)//m_pr1初始化为规则表
				{
					int jj,j1,j; 
					m_TempObject = pSheet;
					while(m_TempObject != NULL)
					{						
						if(m_TempObject->m_iSerial == n)
						{//为规则拷贝到新分配的空间m_pd2
							m_TempObject1=m_TempObject;//得到此时对应的行
							m_pd2 = new Defaultrules;
							m_pd2->serial = ++serial;//serial初始化为0 规则序号
							serial1=m_pd2->serial;
							m_pd2->rule = new int[iAttNum+1];
							for(int j = 0;j < iAttNum;j++)
							{
								if(m_pr1->rule[j] == 1)//规则中该j属性不可省
									m_pd2->rule[j] = m_TempObject->m_pRec[j];
								else
									m_pd2->rule[j] = -1;
							}
							m_pd2->rule[iAttNum] = m_TempObject->m_pRec[iAttNum];//决策
                            rule_val=m_pd2->rule[iAttNum];
							compute_totalnum_coveragenum(m_pr1,n,m_pd2);
			//				m_pd2->totalnum = total_num;//总样本数
			//				m_pd2->coveragenum = temp[i][1];//覆盖样本数
							m_pd2->reliability = (float)m_pd2->coveragenum/m_pd2->totalnum;//信任度
							j1=1;
							if(m_pd2->reliability <fAlpha)
							     j1=0;
							m_pd2->p = NULL;
							m_pd4 = m_pDefaultrules;//指向规则指针头
							if(j1==0)// 支持度不够
								jj=1;//不构造规则
							else
								jj=0;
							int i1;
							while(m_pd4 != NULL && jj==0)
							{ 
						       for(i1=0;i1<iAttNum+1;i1++)
							   {//比较规则的属性值和决策值 找到第一个不同的属性
							      if(m_pd2->rule[i1] != m_pd4->rule[i1])
								      break;
							   } 
						       if(i1 == iAttNum+1)//没有不一样的属性
							   {
								   jj = 1;
								   serial1=m_pd4->serial ;//得到规则的序号
								   break;
							   }
					           m_pd4 = m_pd4->p;//下一条规则
							}
							if(jj == 1)
							{//m_pd2重复,删除
						      delete[] m_pd2->rule;
						      delete m_pd2;
					          serial--;
							} 
					        else
							{//指向下一条规则 修改m_pd1,m_pd2,m_pd3
							  if(m_pd1 == NULL)
							  	m_pd1 = m_pd2;
							  else
								m_pd3->p = m_pd2;
						      m_pd3 = m_pd2;
						      m_pd2 = m_pd2->p;
							}
						    break; 
						}//end if(m_TempObject->m_iSerial-1==i)
						m_TempObject = m_TempObject->p;
					}//end while(m_TempObject!=NULL)
					
					Object* m_TempObject2;
					m_TempObject = pSheet;
					if(cut != 0  && j1==1)//说明此时存在m_pd2  cut为0 表示为初次产生规则而没有封锁事实
					{//构造封锁事实
				//	 for(int i1=0;i1<iAttNum;i1++)
						bool exit;
						int k,tail=0;
						int *exit_core_val=new int [10000];	
						exit_core_val[tail++]=m_TempObject1->m_pRec[iCoreAtt];
						for(int l=0;l<iMatrixLine;l++)
							if(m_Conflict[l]==1 && l!=n-1)
							{
								exit=true;
								m_TempObject2=pSheet;
								k=l;
								while(k)
								{//找到k行对应的对象
									m_TempObject2=m_TempObject2->p;
									k--;
								}
								for(k=0;k<tail;k++)
									if(m_TempObject2->m_pRec[iCoreAtt]==exit_core_val[k])
										exit=false;
								if(exit	&& m_TempObject2->m_pRec[iAttNum]!=m_TempObject1->m_pRec[iAttNum])
                                   //核属性值不等任何满足规则样列,且决策不等,构造封锁事实
								{
									m_pb2 = new Blockrules;
									m_pb2->rule = new int[iAttNum];
									for(j = 0;j < iAttNum;j++)
										m_pb2->rule[j] = -1;
									m_pb2->serial = serial1;
									m_pb2->p = NULL;
									m_pb2->rule[iCoreAtt] = m_TempObject2->m_pRec[iCoreAtt];
									Blockrules *m_pb4=m_pb1;
									j=0;
									int j1;
									while(m_pb4!=NULL)
									{
										j=0;
										if(m_pb4->serial==m_pb2->serial)
											for(j1=0;j1<iAttNum;j1++)
												if(m_pb4->rule[j1]!=m_pb2->rule[j1])
													break;
										if(j1==iAttNum)
										{
											j=1;
											break;
										}
										m_pb4=m_pb4->p;
									}
									if(j==0)//规则还不重复
									{//看是否 默认规则集中有重复的封锁事实
										m_pb4=m_pBlockrules;
										while(m_pb4!=NULL)
										{
										  j=0;
										  if(m_pb4->serial==m_pb2->serial)
											for(j1=0;j1<iAttNum;j1++)
												if(m_pb4->rule[j1]!=m_pb2->rule[j1])
													break;
										   if(j1==iAttNum)
										   { 
											 j=1;
											 break;
										   } 
									      m_pb4=m_pb4->p;
										} //end while
									}
									if(j==1)
									{//m_pb2重复,删除
										delete[] m_pb2->rule;
										delete m_pb2;
									}
									else
									{
										if(m_pb1 == NULL)
										   m_pb1 = m_pb2;
									    else
										   m_pb3->p = m_pb2;
										block++;
								     	m_pb3 = m_pb2;
									    m_pb2 = m_pb2->p;
									}
								}//end if
								else 
									if(m_TempObject2->m_pRec[iAttNum]==m_TempObject1->m_pRec[iAttNum])
                                        exit_core_val[tail++]=m_TempObject2->m_pRec[iCoreAtt];
							}//end  if(m_Confict[i]==1 && l!=n-1)
						delete []exit_core_val;
					}//end if(cut!=0)	
					m_pr1 = m_pr1->p;//下一条规则
				}//end while(m_pr1!=NULL)
//			}//end if(temp[i][0]==1)
		}//end for(i)
	
		while(m_pRules != NULL)
		{//析构
			m_pr1 = m_pRules->p;
			delete[] m_pRules->rule;
			delete m_pRules;
			m_pRules = m_pr1;
		}
//		for(i = 0;i < iClassNum;i++)
//			delete[] temp[i];		
//		delete[] temp;
//		delete[] temp1;
	}//end else
	return;
}//end rulejudge()


void CSkowron::Projection(CSkowron::Cell** m_Matrix,int* m_pConflict,int cut,int* tempcut)
{//得到规则集;cut为0表示原是表产生规则;cut为1表示为原始表的子集来产生子集
	Cell* m_pRecord = NULL;
	//m_pPoint = NULL;
	int** temp_cut=NULL;
	int* temp_cut1=NULL;
	
	Conflictline* m_Conflictline = NULL;
	Conflictline* m_Conflictline1 = NULL;
	Conflictline* m_Conflictline2 = NULL;
	/*	struct Conflictline
	   { 
		int* m_Conflict;
		Conflictline* p;
	   };	*/
	int* m_Conflict = NULL;
	int* m_TempConflict = NULL;
	Cell** m_TempMatrix = NULL;
	int* cuttemp = NULL;

	Cutline* m_Cutline = NULL;
	Cutline* m_TempCutline = new Cutline;
	Cutline* m_TempCutline1=new Cutline;
	Cuttree* m_TempCuttree = NULL;
	Cuttree* m_TempCuttree1 = NULL;
		
	int i,j,k;
	int n = 0;
	int* m_pCut = NULL;
	m_Conflict = NULL;	
	m_pCut = new int[iAttNum];
	for(i = 0;i < iAttNum;i++)
		m_pCut[i] = 0;
	if(cut == 0)
	{
		//m_Conflict = new int[class_num];
		//for(i=0;i<class_num;i++)
		//	m_Conflict[i] = m_Sheet.m_pConflict[i];
		for(i = 0;i < iMatrixLine;i++)
		{//可辨别矩阵i行
			m_pRecord = new Cell[iMatrixLine];
			for(j = 0;j < iMatrixLine;j++)
			{
				m_pRecord[j].nattribute = m_Matrix[i][j].nattribute ;//将可辨识矩阵的第i行拷贝到m_pRecord[j]
			    m_pRecord[j].serial  = m_Matrix[i][j].serial ;
				m_pRecord[j].m_p  = new int [iAttNum];
				for(int k=0;k<iAttNum;k++)
					m_pRecord[j].m_p [k] = m_Matrix[i][j].m_p[k] ;
			}
			n=0;
			callnum = 0;
			rulenum = iAttNum + 1;
			m_pRules = NULL;			
			for(j = 0;j < iMatrixLine;j++)
			{
				if(m_pRecord[j].nattribute != 0)
				{//找到第一个不同的属性列
					n = m_pRecord[j].serial;//实际为m_pRecord所在的矩阵行号:从1开始..
					break;
				}
			}
			if(n>0)//说明该行有差异属性,就产生规则
				DefaultRule(m_pRecord,NULL,0);//产生默认规则
			else continue;			
			m_Conflictline1 = new Conflictline;//为冲突样例分配空间
			m_Conflictline1->m_Conflict = new int[iClassNum];
			m_Conflictline1->p = NULL;
			for(j = 0;j < iClassNum;j++)//初始化
				m_Conflictline1->m_Conflict[j] = 0;
			
			int n1;
			if(m_pConflict[n-1] != -1 && (n>0))//增加n>0
			{//n-1样例冲突
				m_Conflictline1->m_Conflict[n-1] = 1;
				n1=n-1;
				while(m_pConflict[n1]!=n-1)
				{//将冲突样例都设置为1
					n1 = m_pConflict[n1];
					m_Conflictline1->m_Conflict[n1] = 1;
				}
			}
			RulesJudge(n,0,m_pCut,m_Conflictline1->m_Conflict);

			delete[] m_Conflictline1->m_Conflict;
			delete m_Conflictline1;

			if(m_pDefaultrules == NULL)
			{
				m_pDefaultrules = m_pd1;//m_pd1指向规则指针头
				m_pTempDefault = m_pd3;
			}
			else
			{
				if(m_pd1 != NULL)
				{
				//	m_pTempDefault->p = m_pd1;
					Defaultrules* m_pd5=m_pDefaultrules;
					while(m_pd5->p!=NULL)
						m_pd5=m_pd5->p;
					m_pd5->p = m_pd1;//加入规则表
					m_pTempDefault = m_pd3;//m_pd3指向m_pd2前面一个指针,当前封锁块
				}
			}

			if(m_pBlockrules == NULL)
			{//封锁规则块
				m_pBlockrules = m_pb1;//块头
				m_pTempBlock = m_pb3;//当前封锁块
			}
			else
			{
				if(m_pb1 != NULL)
				{
					m_pTempBlock->p = m_pb1;
					m_pTempBlock = m_pb3;
				}
			}	
		}//end for(i = 0;i < iMatrixLine;i++)
		delete[] m_pCut;
		Projection(m_Matrix,m_pConflict,1,NULL);
		return;
	}
	else//if(cut!=0)
	{
		int min = iAttNum;
		for(i = 0;i < iMatrixLine;i++)
		{//取到属性个数最少的置为min
			for(j = 0;j < iMatrixLine;j++)
			{
				if(m_Matrix[i][j].nattribute != 0 && m_Matrix[i][j].nattribute<min)
					min = m_Matrix[i][j].nattribute;
			}
		}
		if(min!=1)
			return;
		int* coreAtt=new int[iAttNum];
	//	compute_coreAtt(tempcut,coreAtt);
		//tempcut是已有的核属性集合,计算剩下属性中的核属性集合存放在coreAtt中
		for(i = 0;i < iMatrixLine;i++)
		{
			for(j = i;j < iMatrixLine;j++)
			{//在上半▲中搜寻单个属性
				if(m_Matrix[i][j].nattribute == 1)
				{
					bool IsCore=Judge_core(i,j,m_Matrix,tempcut);
					if(IsCore)
					{
					if(m_Cutline == NULL)
					{
						m_TempCutline = new Cutline;
						m_TempCutline->x = i;//单个属性坐标x,y
						m_TempCutline->y = j;
						m_TempCutline->p = NULL;
						m_Cutline = m_TempCutline;
						//m_TempCutline1 = m_TempCutline;
						m_TempCutline = m_TempCutline->p;//指向下一个Cutline
					}
					else//m_Cutline!=NULL
					{//说明有两个或更多的m_Matrix[i][j].nattribute=min,此时看和上一个(i,j)对应
     //的属性是否相等.相同就不增加,退出;否则开辟新的单元,将此时的(i,j)加入m_Cutline
						m_TempCutline = m_Cutline;
						while(m_TempCutline != NULL)
						{
							for(int k = 0;k < iAttNum;k++)
							{
								if(m_Matrix[m_TempCutline->x][m_TempCutline->y].m_p[k] != m_Matrix[i][j].m_p[k])
									break;
								//m_TempCutline1 = m_TempCutline1->p;
							}
							if(k == iAttNum)//相等
								break;
							m_TempCutline1 = m_TempCutline;
							m_TempCutline = m_TempCutline->p;
						}
						if(m_TempCutline == NULL)
						{//不为已知单个属性,加入m_TempCutline
							m_TempCutline = new Cutline;
							m_TempCutline->x = i;
							m_TempCutline->y = j;
							m_TempCutline->p = NULL;
							m_TempCutline1->p = m_TempCutline;
							m_TempCutline = m_TempCutline->p;
						}
					}//end else
					}//end if(IsCore)
				}//end if(m_Matrix[i][j]
			}//end for(j)
		}//end for(i)
		if(m_Cutline==NULL)
			return;
		m_TempCutline = m_Cutline;//核属性集合
		while(m_TempCutline != NULL)
		{
			cuttemp = new int[iAttNum];
			for(i = 0;i < iAttNum;i++)//存储m_TempCutline中的一个核属性
				cuttemp[i] = m_Matrix[m_TempCutline->x][m_TempCutline->y].m_p[i];
			if(tempcut != NULL)//带入上一级的核属性
			{
				for(i = 0;i < iAttNum;i++)
				{
					if(tempcut[i] == 1)
						cuttemp[i] = 1;
				}//end for
			}//end if

			m_TempCuttree = m_Cuttree;//初始为NULL
			n = 0;
    		while(m_TempCuttree != NULL)
			{
				for(i = 0;i < iAttNum;i++)
				{
					if(m_TempCuttree->cut[i] != cuttemp[i])
						break;
				}
				if(i == iAttNum)
					n = 1;
				m_TempCuttree1= m_TempCuttree;
				m_TempCuttree = m_TempCuttree->p;
			}

			if(n == 0 )// else delete[] cuttemp
			{//m_tempCuttree中没有m_Cutline中的属性
				m_TempCuttree = new Cuttree;//分配空间
				m_TempCuttree->cut = new int[iAttNum];
				m_TempCuttree->p = NULL;
				for(i = 0;i < iAttNum;i++)
					m_TempCuttree->cut[i] = cuttemp[i];
				
				if(m_Cuttree == NULL)
					m_Cuttree = m_TempCuttree;//构建m_Cuttree
				else
					m_TempCuttree1->p = m_TempCuttree;//指向下一条记录

				m_TempConflict = new int[iClassNum];
				for(i = 0;i < iClassNum;i++)
					m_TempConflict[i] = m_pConflict[i];
			
				//delete[] m_pConflict;
				int x;
				int y;
				m_TempMatrix = new Cell*[iMatrixLine];
				for(i = 0;i < iMatrixLine;i++)
					m_TempMatrix[i] = new Cell[iMatrixLine];
				for(i = 0;i < iMatrixLine;i++)
				{//构建m_Matrix的拷贝 m_TempMatrix
					for(j = 0;j < iMatrixLine;j++)
					{
						m_TempMatrix[i][j].nattribute = m_Matrix[i][j].nattribute;
						m_TempMatrix[i][j].serial = m_Matrix[i][j].serial;
						m_TempMatrix[i][j].m_p = new int[iAttNum];
						for(int k = 0;k < iAttNum;k++)
							m_TempMatrix[i][j].m_p[k] = m_Matrix[i][j].m_p[k];
					}//end for(j)
				}//end for(j)
							
				x = m_TempCutline->x;//矩阵坐标,指向核属性
				y = m_TempCutline->y;				
				
		    	temp_cut = new int*[iMatrixLine];//改过
				temp_cut1 = new int[iMatrixLine];
				for(i = 0;i < iMatrixLine;i++)
					temp_cut[i] = new int[2];
				for(i = 0;i < iMatrixLine;i++)
					temp_cut1[i] = 0;
				
				for(i = 0;i < iMatrixLine;i++)
				{
					for(j = 0;j < 2;j++)
						temp_cut[i][j] = -1;
				}
				

				for(i = 0;i < iAttNum;i++)
					m_pCut[i] = m_TempMatrix[x][y].m_p[i];//核属性				
				if(temp_cut!=NULL)
				{
					temp_cut[0][0] = x;
				    temp_cut[0][1] = y;
				}
				if(temp_cut1!=NULL)
				{