skowron.cpp

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

					temp_cut1[x] = 1;
					temp_cut1[y] = 1;
				}
				
				int m,iCoreAtt;
				for(k=0;k<iAttNum;k++)
					if(m_pCut[k]==1)
						iCoreAtt=k;//核属性所在属性列
				
			    if(tempcut!=NULL)
					for(i = 0;i < iMatrixLine;i++)
					{//消除m_TempMatrix对应tempcut中的对应属性,得到当前要分析的表
					 for(j = 0;j < iMatrixLine;j++)
					 { 
						if(m_TempMatrix[i][j].nattribute != 0)
						{
							for(int k = 0;k < iAttNum;k++)
							{
								if(tempcut[k] == 1)
								{//k属性存在
									if(m_TempMatrix[i][j].m_p[k] == 1)
									{//在属性集中去掉k属性,属性个数减一
										m_TempMatrix[i][j].m_p[k] = 0;
										m_TempMatrix[i][j].nattribute--;
									}
								}
							}
						}
					 }// end for(j)
					}//end for(i)

				//扫描决策表,统计包含核属性且不仅仅是核属性的行所在的行号,记录在数组att中
				int* att=new int[iMatrixLine+1];
				k=0;
				for(i=0;i<iMatrixLine+1;i++)
					att[i]=-1;
				for(i=0;i<iMatrixLine;i++)//行
					for(j=0;j<iMatrixLine;j++)//列
						if(m_TempMatrix[i][j].m_p[iCoreAtt]==1 && m_TempMatrix[i][j].nattribute==1 )
						{//为单核属性集合,则去掉核属性后规则会发生变化;否则都包含于原有规则集中,不考虑
							m=0;
							for(int i1=0;i1<iMatrixLine;i1++)//扫描该行,如果除了核属性以外还有
								//其他属性.则构建att;否则不构建
							 if(m_TempMatrix[i][i1].nattribute>1 || (m_TempMatrix[i][i1].nattribute==1
							     && m_TempMatrix[i][i1].m_p[iCoreAtt]==0))
							 {
								 m=1;
								 break;//end for(i1)
							 }
							if(m==1)
							{
								att[k]=i;
								k++;							
							} 
							break;//end for(j)
						}
				int ii=0;
				while(att[ii]!=-1)
				{
					k=att[ii];//包含核属性的行号	
					ii++;
					m_Conflictline1 = new Conflictline;//生成冲突表
					m_Conflictline1->m_Conflict = new int[iClassNum];
					m_Conflictline1->p = NULL;
					for(i = 0;i < iClassNum;i++)
						m_Conflictline1->m_Conflict[i] = 0;//无冲突
					m=0;
					for(j=0;j<iMatrixLine;j++)//扫描该行,看是否有仅仅由核属性组成的集合
						if(m_TempMatrix[k][j].nattribute==1 && m_TempMatrix[k][j].m_p[iCoreAtt]==1)
							m=1;
				    j=k;
					if(m_TempConflict[j] != -1 )//j行为冲突,置m_Confictline1
					{ //将原先冲突的现在也设为冲突  并排除原始表冲突样例影响
					   m_Conflictline1->m_Conflict[k] = 1;//设置为1
					   while(m_TempConflict[j] !=k)
					   { 
						  j = m_TempConflict[j];
						  m_Conflictline1->m_Conflict[j] = 1;					
					   } 
					}
					if(m==1)//说明改行包含核属性
					{
						m_Conflictline1->m_Conflict[k] = 1;//设置为1
						for(i = 0;i < iMatrixLine;i++)//列
						{ //行i,k只靠核属性来区分,则去掉核属性后,i,k行冲突
					       	if(m_TempMatrix[k][i].nattribute==1 && m_TempMatrix[k][i].m_p[iCoreAtt]==1)
							{//矩阵中k行i列仅仅为核属性,此时k,i行冲突
						     	if(m_TempConflict[i] != -1)
								{//冲突
							    	m_Conflictline1->m_Conflict[i] = 1;//设为冲突
									j=i;
							    	while(m_TempConflict[j] != i)
									{ 
								    	j = m_TempConflict[j];
								    	m_Conflictline1->m_Conflict[j] = 1;					
									} 
								}
						      	else
							     	m_Conflictline1->m_Conflict[i] = 1;
							}
						}
					}//end if(m==1)
					if(m_Conflictline == NULL)
					{
						m_Conflictline = m_Conflictline1;
						m_Conflictline2 = m_Conflictline1;
					}
					else
					{//移动指针
						m_Conflictline2->p = m_Conflictline1;
						m_Conflictline2 = m_Conflictline1;
						m_Conflictline1 = m_Conflictline1->p;
					}
				}//enf while

                
				for(i = 0;i < iMatrixLine;i++)
				{//消除m_TempMatrix对应m_pCut中的对应属性
					for(j = 0;j < iMatrixLine;j++)
					{
						if(m_TempMatrix[i][j].nattribute != 0)
						{
							for(int k = 0;k < iAttNum;k++)
							{
								if(m_pCut[k] == 1)
								{//k属性存在
									if(m_TempMatrix[i][j].m_p[k] == 1)
									{//在属性集中去掉k属性,属性个数减一
										m_TempMatrix[i][j].m_p[k] = 0;
										m_TempMatrix[i][j].nattribute--;
									}
								}
							}
						}
					}//end for(j)
				}//end for(i)
               
				m=-1;
				m_Conflict = new int[iClassNum];
				for(i = 0;i < iClassNum;i++)
					m_Conflict[i] = 0;//初始化
           
				m_Conflictline1 = m_Conflictline;
    			while(m_Conflictline1 != NULL)
				{//设置m_TempConflict
					for(i = 0;i < iClassNum;i++)
					{
						if(m_Conflict[i] == 0)
							m_Conflict[i] = m_Conflictline1->m_Conflict[i];
					}
					m_Conflictline1 = m_Conflictline1->p;
				}

				j = 0;
				for(i = 0;i < iClassNum;i++)
				{
					if(m_Conflict[i] == 1)
					{
						if(j == 0)
						{
							n=i;
							m=i;
							j=1;
						}
						else
						{
							m_TempConflict[m] = i;
							m = i;
						}
					}
				}
				if(m!=-1)
					m_TempConflict[m] = n;
								
				delete[] m_Conflict;
				
				n = 0;
				for(i = 0;i < iMatrixLine;i++)
				{//目的:判断矩阵是否为空.非空置n=1
					for(j = 0;j < iMatrixLine;j++)
					{
						if(m_TempMatrix[i][j].nattribute != 0)
						{
							n = 1;
							break;
						}
					}
				}

				if(n == 0)
				{//矩阵为空.析构所有,返回
					//delete[] m_Conflict;
					delete[] m_pCut;
					delete[] cuttemp;
					delete[] tempcut;
					delete[] m_TempConflict;
					delete[] m_pConflict;
					for(i = 0;i < iMatrixLine;i++)
					{
						for(j = 0;j < iMatrixLine;j++)
						{
							delete[] m_Matrix[i][j].m_p;
							delete[] m_TempMatrix[i][j].m_p;
						}
					}
					
					for(i = 0;i < iMatrixLine;i++)
					{
						delete[] m_Matrix[i];
						delete[] m_TempMatrix[i];
					}
					delete[] m_Matrix;
					delete[] m_TempMatrix;
                    m_Matrix=NULL;
					m_TempMatrix=NULL;
					
					while(m_Cutline != NULL)
					{
						m_TempCutline = m_Cutline->p;
						delete m_Cutline;
						m_Cutline = m_TempCutline;
					}

					for(i = 0;i < iMatrixLine/2;i++)
						delete[] temp_cut[i];
					delete[] temp_cut;
                    temp_cut=NULL;

					while(m_Conflictline != NULL)
					{
						m_Conflictline1 = m_Conflictline->p;
						if(m_Conflictline1!=NULL)
							delete[] m_Conflictline->m_Conflict;
						delete m_Conflictline;
						m_Conflictline = m_Conflictline1;
					}
					return;		//回退
				}//end if(n == 0)

				m_Conflictline1 = m_Conflictline;//此时矩阵不为空
				m=0;
				while(att[m]!=-1)
				{
					i=att[m];//行号
					m++;
					m_pRecord =new Cell[iMatrixLine];
			        for(j = 0;j < iMatrixLine;j++)
					{ 
				         m_pRecord[j].nattribute = m_TempMatrix[i][j].nattribute ;//将可辨识矩阵的第i行拷贝到m_pRecord[j]
			             m_pRecord[j].serial  = m_TempMatrix[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_TempMatrix[i][j].m_p[k] ;
					} 
					callnum = 0;
					rulenum = iAttNum+1;//设置rulenum
					m_pRules = NULL;
					n=0;
					for(j=0;j<iMatrixLine;j++)
					{
						if(m_pRecord[j].nattribute!=0)
						{
							n=m_pRecord[j].serial ;//行号
							break;
						}
					}
					DefaultRule(m_pRecord,NULL,0);	
           		    RulesJudge(n,1,m_pCut,m_Conflictline1->m_Conflict);
					m_Conflictline1 = m_Conflictline1->p;
				/*	if(m_pRecord!=NULL)
					{//析构m_pRecord
						for(j = 0;j < iMatrixLine;j++)
							delete[] m_pRecord[j].m_p ;
					    delete[] m_pRecord;	
						m_pRecord=NULL;
					}
				*/
					if(m_pDefaultrules == NULL)
					{//加上默认规则
						m_pDefaultrules = m_pd1;
						m_pTempDefault = m_pd3;
					}
					else
					{
						if(m_pd1 != NULL)
						{
							m_pTempDefault->p = m_pd1;
							m_pTempDefault = m_pd3;
						}
					}
					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 while(att[m]!=-1)
                //析构所有
				for(i = 0;i < iMatrixLine;i++)
					delete[] temp_cut[i];
				delete[] temp_cut;
                delete []att; 
				while(m_Conflictline != NULL)
				{
					m_Conflictline1 = m_Conflictline->p;//
					if(m_Conflictline1!=NULL)
						delete[] m_Conflictline->m_Conflict;//error
					delete m_Conflictline;
					m_Conflictline = m_Conflictline1;
				}		
//				Projection(m_TempMatrix,m_TempConflict,1,m_pCut);
				Projection(m_TempMatrix,m_TempConflict,1,cuttemp);
				//delete m_TempMatrix;
			}//end if(n == 0 )// else delete[] cuttemp
			else
				delete[] cuttemp;
			m_TempCutline = m_TempCutline->p;
        }//end while(m_TempCutline != NULL)
		delete[] m_pCut;
     }//end else if(cut!=0)
	delete[] m_pConflict;	
	for(i = 0;i < iMatrixLine;i++)
		for(j = 0;j < iMatrixLine;j++)
			delete[] m_Matrix[i][j].m_p;
	for(i = 0;i < iMatrixLine;i++)
		delete[] m_Matrix[i];
	delete[] m_Matrix;		
	delete[] tempcut;
	while(m_Cutline != NULL)
	{
		m_TempCutline = m_Cutline->p;
		delete m_Cutline;
		m_Cutline = m_TempCutline;
	}
	while(m_Cuttree != NULL)
	{
		m_TempCuttree = m_Cuttree->p;
		delete []m_Cuttree->cut;
		delete m_Cuttree;
		m_Cuttree = m_TempCuttree; 
	}
	return;
}//end Projection()函数结束

BOOL CSkowron::CreateMatrix()
{//创建可辨识矩阵
	int i = 0;
	int j = 0;
	int k;
	int bConflict = 0;
	int* temp=NULL;
	Object* m_p1=NULL;
	Object* m_p2=NULL;
	m_p1 = pSheet;
	m_p2 = m_p1;
	
	try
	{
		temp = new int[iClassNum];
	}
	catch(CMemoryException* e)
	{
		::MessageBeep(MB_ICONHAND);
       	AfxMessageBox("Out of the memory!",MB_OK|MB_ICONSTOP);
		e->Delete();
    	return FALSE;
	}
	
	for(i = 0;i < iClassNum;i++)
		temp[i] = 0;//初始化temp	
	iMatrixLine=iClassNum;//矩阵行数
	try
	{
		pMatrix = new Cell*[iMatrixLine];
	}
	catch(CMemoryException* e)
	{
		::MessageBeep(MB_ICONHAND);
       	AfxMessageBox("Out of the memory!",MB_OK|MB_ICONSTOP);
		e->Delete();
		delete[] temp;
    	return FALSE;
	}	
	for(i = 0;i < iMatrixLine;i++)
	{//为矩阵分配空间
		try
		{
			pMatrix[i] = new Cell[iMatrixLine];
		}
		catch(CMemoryException* e)
		{
			::MessageBeep(MB_ICONHAND);
	    	AfxMessageBox("Out of the memory!",MB_OK|MB_ICONSTOP);
			e->Delete();
			delete[] temp;
		 	return FALSE;
		}		
	}//end for

	for(i = 0;i < iMatrixLine;i++)
	{//初始化矩阵
		for(j = 0;j < iMatrixLine;j++)
		{
			pMatrix[i][j].nattribute = 0;//不同的属性个数
			pMatrix[i][j].serial = 0;//序号
			
			try
			{
				pMatrix[i][j].m_p = new int[iAttNum];
			}
			catch(CMemoryException* e)
			{
				::MessageBeep(MB_ICONHAND);
				AfxMessageBox("Out of the memory!",MB_OK|MB_ICONSTOP);
				e->Delete();
				delete[] temp;
				return FALSE;
			}			
			
			for(k = 0;k < iAttNum;k++)
				pMatrix[i][j].m_p[k] = 0;
		}//end for
	}//end for
	i=0;
	j=0;
	while(m_p1 != NULL)//m_p1 = pSheet
	{
		while(m_p2!=NULL)
		{
			if(m_p1->m_pRec[iAttNum] != m_p2->m_pRec[iAttNum])
			{//决策不同
		       for(k=0;k<iAttNum;k++)
			   { 
			      if(m_p1->m_pRec[k] != m_p2->m_pRec[k])
				  { 
				     pMatrix[i][j].m_p[k] = 1;
				     pMatrix[i][j].serial = m_p1->m_iSerial;
				     pMatrix[i][j].nattribute++;
				  }//end if 
			   }//end for
			}//end if
		//	else//决策相同
		//       pMatrix[i][j].serial = m_p1->m_iSerial;
	        j++;//下一个属性
	        m_p2 = m_p2->p;//下一个样例
	        if(j == iMatrixLine)//一行结束
    		   j=0;
		}
		i++;
		m_p1 = m_p1->p;
		m_p2 = pSheet;
	}
	return TRUE;
}

BOOL CSkowron::InitTable()
{//消除重复样例
	try
	{
		pSheet = new Object;
	}
	catch(CMemoryException* e)
	{
		::MessageBeep(MB_ICONHAND);
       	AfxMessageBox("Out of the memory!",MB_OK|MB_ICONSTOP);
		e->Delete();
    	return FALSE;
	}
	
	Object* pHead=NULL;
	Object* p1=NULL;
	Object* p2=NULL;
	pHead = pSheet;
	p1 = pHead;
	p2 = pHead;
	pSheet->count = 1;