skowron.cpp

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

	pSheet->m_iSerial = 1;//设置为第0条记录
	try
	{
		pSheet->m_pRec = new int[iAttNum+1];
	}
	catch(CMemoryException* e)
	{
		::MessageBeep(MB_ICONHAND);
       	AfxMessageBox("Out of the memory!",MB_OK|MB_ICONSTOP);
		e->Delete();
    	return FALSE;
	}
	
	for(int i = 0;i < iAttNum+1;i++)
		pSheet->m_pRec[i] = pIntTable[0][i];//将记录0的各个属性值放入pSheet中
	pSheet->p = NULL;
	iClassNum++;//统计分类数目,现为1

	for(i = 1;i < iRecordNum;i++)
	{//后面的记录和p2记录比较,从而建立消除了冗余的决策表
		do
		{
			if(pIntTable[i][iAttNum] != p2->m_pRec[iAttNum])
			{//决策不同
				p1 = p2;
				p2= p2->p;//p2指向下一条记录
			}
			else
			{//决策相同
				for(int j = 0;j < iAttNum;j++)
				{
					if(p2->m_pRec[j] != pIntTable[i][j])
					{//条件属性不等
						p1 = p2;
						p2 = p2->p;
						break;
					}
				}
				if(j == iAttNum)//p2和pIntTable[i][j]完全相同
					break;//强行结束,退出do...while
			}
		}while(p2 != NULL);
		if(p2 == NULL)
		{//分配空间
			try
			{
				p2 = new Object;
			}
			catch(CMemoryException* e)
			{
				::MessageBeep(MB_ICONHAND);
       			AfxMessageBox("Out of the memory!",MB_OK|MB_ICONSTOP);
				e->Delete();
    			return FALSE;
			}
			p2->m_iSerial = p1->m_iSerial+1;//序号加一
			p2->count = 1;//重复数目
			p2->p = NULL;
			try
			{//分配属性空间
				p2->m_pRec = new int[iAttNum+1];
			}
			catch(CMemoryException* e)
			{
				::MessageBeep(MB_ICONHAND);
       			AfxMessageBox("Out of the memory!",MB_OK|MB_ICONSTOP);
				e->Delete();
    			return FALSE;
			}
			for(int j = 0;j < iAttNum+1;j++)
				p2->m_pRec[j] = pIntTable[i][j];//用i记录来初始化p2
			p1->p = p2;
			iClassNum++;//分类加一
		}
		else//p2!=NULL
			p2->count++;//重复数目加一
		p2 = pHead;//从头开始
	}
	return TRUE;
}

BOOL CSkowron::FindConflict()
{//消除冲突样例. 得到一致样例表(对冲突样例只保留第一个)  必要吗?
	int n;
	try
	{
		piConflict = new int[iClassNum];
	}
	catch(CMemoryException* e)
	{
		::MessageBeep(MB_ICONHAND);
    	AfxMessageBox("Out of the memory!",MB_OK|MB_ICONSTOP);
		e->Delete();
    	return FALSE;
	}	
	for(int i = 0;i < iClassNum;i++)
		piConflict[i] = -1;
	Object* p1=NULL;
	Object* p2=NULL;
	p1 = pSheet;//信息表
	p2 = p1->p;
	iMatrixLine = iClassNum;//矩阵行数,设为分类数
	while(p1->p != NULL)
	{
		if(piConflict[p1->m_iSerial-1] == -1)
		{//m_iSerial从1开始,所以要减一  p1不冲突
			n = p1->m_iSerial;
			while(p2 != NULL)
			{
				if(p1->m_pRec[iAttNum] != p2->m_pRec[iAttNum]
					&&piConflict[p2->m_iSerial-1] == -1)
				{//决策不等并且p2所指记录不冲突
					for(i = 0;i < iAttNum;i++)
					{
						if(p1->m_pRec[i] == p2->m_pRec[i])
							continue;//比较各个属性值,找到第一个相异属性
						else
							break;
					}
					if(i == iAttNum)
					{//没有相异属性 冲突
						if(piConflict[n-1] == -1)
						{//p1对应记录未被设为冲突
							piConflict[n-1] = p2->m_iSerial-1;//p1,p2相互冲突
							piConflict[p2->m_iSerial-1] = n-1;
						}
						else//和p1冲突的一系列记录中最后一条记录冲突设为p1序号
						{//p1已经设为冲突   such as:1,2,4,6冲突,冲突记录为2,4,6,1 相当于绕了一圈 
							while(piConflict[n-1] != p1->m_iSerial-1)//直到找到冲突为p1的最后一条记录
								n = piConflict[n-1]+1;//找到和p1冲突的下一条记录序号
							piConflict[n-1] = p2->m_iSerial-1;//指向最后增加的一条冲突记录
							piConflict[p2->m_iSerial-1] = p1->m_iSerial-1;//指向p1记录
						}
						iMatrixLine--;//冲突,矩阵行数减一
					}//end if(i==iAttNum)
				}//end if(决策不同)
				p2 = p2->p;
			}//end while
		}//end if(不冲突)
		p1 = p1->p;
		p2 = p1->p;
	}//end while(p1->p!=NULL)
	return TRUE;
}


void CSkowron::SaveFile(LPCTSTR lpszPathName)
{
	int sum_count;
	float rule_precision;
	struct CutRecord* pHead = NULL;
	CString temp;

	FILE* fp;
	fp = fopen(lpszPathName,"w");
	fprintf(fp,"Style:%s\n","rule");
	fprintf(fp,"Stage:%d\n",0);
	fprintf(fp,"Condition attributes number:%d\n",iAttNum);
	if(iStage==3)
	{
		fprintf(fp,"The Number of Condition attributes deleted: %d\n",abtcount);
        fprintf(fp,"The position of Condition attributes deleted:");
        for(int i=0;i<abtcount;i++)
		   fprintf(fp," %d ",abt[i]);
		fprintf(fp,"\n");
	}
	if(iStage==2)
	{
		fprintf(fp,"The Number of Condition attributes deleted: %d\n",0);
        fprintf(fp,"The position of Condition attributes deleted:");
		fprintf(fp,"\n");
	}
	fprintf(fp,"Rules number:%d\n",serial);
	fprintf(fp,"Blocks number:%d\n",block);

	for( int i = 0;i < iAttNum+1;i++)
		fprintf(fp,"%s ",pAttName[i]);
	fprintf(fp,"\n");
	for(i = 0;i < iAttNum+1;i++)
		fprintf(fp,"%s ",pDataType[i]);
	fprintf(fp,"\n");
	
	sum_count = 0;
	rule_precision = 0.0;
	while(m_pDefaultrules != NULL)
	{
		for(int i = 0;i < iAttNum+1;i++)
		{
			if(m_pDefaultrules->rule[i] == -1)
			{
				fprintf(fp,"%c ",'-');
				continue;
			}//end if

			if(bCuts)
			{
				pHead = struCutRecord;
				while(pHead != NULL)
				{
					if(pHead->iColumn == i)
						break;
					pHead = pHead->p;
				}//end while
				if(pHead != NULL)
				{
					for(int j = 0;j < pHead->iCuts;j++)
					{
						if(m_pDefaultrules->rule[i] == j)
						{
							fprintf(fp,"%s ",pHead->cpCut[j]);
							break;
						}//end if
					}//end for
				}//end if
				else
					fprintf(fp,"%d ",m_pDefaultrules->rule[i]);

			}//end if
			else
				fprintf(fp,"%d ",m_pDefaultrules->rule[i]);
		}//end for
		rule_precision += m_pDefaultrules->coveragenum;
		sum_count += m_pDefaultrules->totalnum;
		fprintf(fp," %.2f ",m_pDefaultrules->reliability);
		fprintf(fp,"%d ",m_pDefaultrules->coveragenum);
		fprintf(fp,"%d\n",m_pDefaultrules->totalnum);
		m_pTempDefault = m_pDefaultrules->p;
		delete[] m_pDefaultrules->rule;
		delete m_pDefaultrules;
		m_pDefaultrules = m_pTempDefault;
	}

	rule_precision /= sum_count; 

	fprintf(fp,"[Blocks]\n");
	while(m_pBlockrules != NULL)
	{
		for(int i = 0;i < iAttNum;i++)
		{
			if(m_pBlockrules->rule[i] == -1)
			{
				fprintf(fp,"%c ",'-');
				continue;
			}//end if

			if(bCuts)
			{
				pHead = struCutRecord;
				while(pHead != NULL)
				{
					if(pHead->iColumn == i)
						break;
					pHead = pHead->p;
				}//end while
				if(pHead != NULL)
				{
					for(int j = 0;j < pHead->iCuts;j++)
					{
						if(m_pBlockrules->rule[i] == j)
						{
							fprintf(fp,"%s ",pHead->cpCut[j]);
							break;
						}//end if
					}//end for
				}//end if
				else
					fprintf(fp,"%d ",m_pBlockrules->rule[i]);

			}//end if
			else
				fprintf(fp,"%d ",m_pBlockrules->rule[i]);
		}//end for
		fprintf(fp,"~规则%d\n",m_pBlockrules->serial);
		m_pTempBlock = m_pBlockrules->p;
		delete[] m_pBlockrules->rule;
		delete m_pBlockrules;
		m_pBlockrules = m_pTempBlock;
	}
 
//	fprintf(fp,"%f",rule_precision);

	fclose(fp);
}


double CSkowron::CountCut()
{//失败:return -1; success:return 阀值
	bool* bOver;
	try
	{
		bOver=new bool[iRecordNum];
	}
	catch(std::bad_alloc e)
	{		
		AfxMessageBox("out of memory!");
		return -1;
	}
	double minValue=1;
	for(int i=0;i<iRecordNum;i++)
	{
		bOver[i]=false;
	}

	for(i=0;i<iRecordNum-1;i++)
	{
		std::map<int,int> infor;//记录决策和相应的分类数
		int totalNum=1;			//记录具有相同属性值的数据个数
		if(bOver[i]==true)
			continue;   
		//下面循环计算和记录i相同属性值的数据决策值及各自的个数
   	    infor[pIntTable[i][iAttNum]]=1; //初始化
		for(int j=i+1;j<iRecordNum;j++)
		{
			if(bOver[j]==true)
		    	continue;
			if(pIntTable[i][iAttNum]!=pIntTable[j][iAttNum] )
				infor[pIntTable[j][iAttNum]]=0; //初始化
			bool bSame=true;
			for(int k=0;k<iAttNum;k++)
			{
				if( pIntTable[i][k]!=pIntTable[j][k] )
				{
					bSame=false;
					break;
				}
			}
			if(bSame)  //所有条件属性相等
			{
				totalNum++;	//总数增1
				infor[ pIntTable[j][iAttNum]] += 1;
				bOver[j]=true;	//表示该数据已经考虑过
			}
		}
		//////////////////////////////////////////////////////////
		if (infor.size()>1) //有冲突存在
		{
			int ii;
			if(i==95)
				ii=1;
			//获取最大值 计算局部最小确定性
			int max=infor[ pIntTable[i][iAttNum]];
			for( std::map<int,int>::iterator it_t=infor.begin();it_t!=infor.end();it_t++)
				if( it_t->second > max) max=it_t->second;
			//calculate fAlpha
			double alpha= (double)max / totalNum;
			if(alpha < minValue ) 
				minValue=alpha;
		}
	}
	CString str;
	str.Format(" 阈值 %f ",minValue);
	AfxMessageBox(str);
	delete[] bOver;
	return minValue;
}

void CSkowron::compute_totalnum_coveragenum(Rules *m_pr, int n, Defaultrules *&m_pd)
{
   Object* m_TempObject=pSheet;
   bool T;
   int i,total,coverage;
   total=0;
   coverage=0;
   while(m_TempObject!=NULL)
   {
	   T=true;
	   for(i=0;i<iAttNum;i++)
	   {
		   if(m_pr->rule[i]==1)
		   {
			   if(m_pd->rule[i]!=m_TempObject->m_pRec[i])
				   T=false;
		   }
		   if(!T)
               break;
	   }
	   if(T)
	   {
		   total+=m_TempObject->count;
		   if(m_pd->rule[iAttNum]==m_TempObject->m_pRec[iAttNum])
			   coverage+=m_TempObject->count;
	   }
	   m_TempObject=m_TempObject->p;
   }
   m_pd->totalnum=total;
   m_pd->coveragenum =coverage;   


}

void CSkowron::compute_coreAtt(int *del, int *&core)
{
    int i,j;
	for(i=0;i<iAttNum;i++)
		if(del[i]==1)
			core[i]=0;
		else
			core[i]=1;
}

bool CSkowron::Judge_core(int i, int j, Cell **m_Matrix, int *del_core)
{
	int* att=new int[iAttNum];
	int x=i;
	int y=j;
	int core;
	for(i=0;i<iAttNum;i++)
		if(m_Matrix[x][y].m_p[i]==1)
			core=i;
	if(del_core!=NULL)
	{
		for(i=0;i<iAttNum;i++)
		{
			if(del_core[i]==1)
				att[i]=0;
			else att[i]=1;
		}
	}
	else
		for(i=0;i<iAttNum;i++)
		   att[i]=1;
//	att[core]=1;//可能的核属性
	int Xnumber,Ynumber;
	Xnumber=Ynumber=0;
	bool T;
	Object* tempObject=pSheet;
	Object* XObject=NULL;
	Object* YObject=NULL;
	while(tempObject!=NULL)
	{
		if(tempObject->m_iSerial==x+1)
			XObject=tempObject;//得到x样列
		else if(tempObject->m_iSerial==y+1)
			YObject=tempObject;//得到y样列
		if(XObject && YObject)
			break;
		tempObject=tempObject->p;
	}
	tempObject=pSheet;
	//对信息表中i,j行分别求等价类中相异值的数目
	while(tempObject!=NULL)
	{
		T=true;
		for(j=0;j<iAttNum ;j++)
		{			
			if(att[j]==0)//属性被删除了的
				continue;
			if(att[j]==1 && XObject->m_pRec[j]!=tempObject->m_pRec[j])//比较属性值
				T=false;
		}
		if(j==iAttNum && T)//x的等价类
			if(XObject->m_pRec[iAttNum]!=tempObject->m_pRec[iAttNum])
			{
				Xnumber=2;
				break;
			}
		tempObject=tempObject->p;
	}
	tempObject=pSheet;
	while(tempObject!=NULL)
	{
		T=true;
		for(j=0;j<iAttNum;j++)
		{			
			if(att[j]==0)
				continue;
			if(att[j]==1 && YObject->m_pRec[j]!=tempObject->m_pRec[j])
				T=false;
		}
		if(j==iAttNum && T)//y的等价类
			if(YObject->m_pRec[iAttNum]!=tempObject->m_pRec[iAttNum])
			{
				Ynumber=2;
				break;
			}
		tempObject=tempObject->p;
	}
	delete []att;
	if(Xnumber==2 && Ynumber==2)
		return false;
	return true;
}