valreductiontwo.cpp

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

			for(j=0;j<con_num+1;j++)
				if(tab[i][j]!=-2&&tab[i][j]!=-1)
				{//count统计具体值得个数 具体值对应当属性位置存放在att中
					//具体值存放在att_val中
					att[count]=j;//开始count=0
					att_val[count++]=tab[i][j];
				}
			if(count>1)    //条件属性中包含具体值 至少为一(决策)
			{
				conflict=find_conflict(att,att_val,count);
		//false表示可以否仅靠这些属性就可得出决策
				if(conflict==FALSE) //仅由为标记属性值可以判断决策.不冲突
				{//将"?"改为'*'
					for(j=0;j<con_num;j++)
						if(tab[i][j]==-2)
						{
							tab[i][j]=-1;
							flag=true;
						}
				}
				else
				{//冲突时,将'?'修改回原属性值
					for(j=0;j<con_num;j++)
						if(tab[i][j]==-2)
							tab[i][j]=info[i][j];
				}
			}
			else if(count==1) //条件属性值均标记为"*"或"?"
				for(j=0;j<con_num;j++)
					if(tab[i][j]==-2)//将'?'修改回原属性值
				    	tab[i][j]=info[i][j];
		}
		find=FALSE;
		count=0;
	}
	delete []att;
	delete []att_val;
}

int ValReductionTwo::find_conflict(int * att, int * val, const int num)
{//success:return false; wrong return true  
//检查除去一个属性后的信息表是否存在冲突
//根据数组att中保存的属性编号，检查记录val是否仅靠这些属性就可得出决策
//false表示可以，num中保存的是属性的个数
	int i,j;                                     //循环变量
	int count=0;                                 //相同属性值数目统计
	for(i=0;i<rule_num;i++)
	{
		for(j=0;j<num-1;j++)
			if(info[i][att[j]]==val[j])
			    count++;
			else
				break;
		if(count==(num-1))//条件属性都相同
			if(info[i][con_num]!=val[num-1])
				return TRUE;//决策不同时,返回true
		count=0;
	}
	return FALSE;
}

int ValReductionTwo::check_conflict(int ** tab)
{ //返回条件属性全被标为"*"的记录个数 失败:返回-1
	int i,j;          //循环变量
	int count;           //统计每条记录中未被标记的元素个数
	int flag=0;               //统计条件属性全被标为"*"的个数
	for(i=0;i<rule_num;i++)
	{
		count=0;
		for(j=0;j<con_num;j++)
			if(tab[i][j]==-1)//不为'*'
				count++;
		if(count==con_num)
			flag++;
	}
	return flag;
}

  /* 原先代码
	int i,j;          //循环变量
	int count;           //统计每条记录中未被标记的元素个数
	int flag=0;               //统计条件属性全被标为"*"的个数
	int * att=NULL;            //进行检查的属性
	int * att_val=NULL;     //进行检查的属性值
	int conflict;           //查询是否有冲突记录

	att=new int[con_num+1];
	if(att==NULL)
	{
		AfxMessageBox("错误!");
		return -1;
	}
	att_val=new int [con_num+1];
	if(att_val==NULL)
	{
		AfxMessageBox("错误!");
		return -1;
	}

	for(i=0;i<rule_num;i++)
	{
		count=0;
		for(j=0;j<con_num+1;j++)
			if(tab[i][j]!=-1)//不为'*'
			{
				att[count]=j;
				att_val[count++]=tab[i][j];
			}				
		if(count>1&&count<con_num+1)
		{//未被标记的属性如果大于1并且含有被标为"*"的属性
			conflict=find_conflict(att,att_val,count);
			if(conflict==TRUE)//冲突
				for(j=0;j<con_num;j++)
					tab[i][j]=info[i][j];
		}
		else if(count==1)    //如果条件属性全部被标为"*"
			flag++;
		conflict=FALSE;
	}
	delete []att;
	delete []att_val;
	return flag;
}*/

int * ValReductionTwo::del_superflous(int ** tab1)
{//删除多余的规则  返回多余的规则指针 数组的第一个元素表示重复记录的数目
//success:return 冗余规则指针;else return NULL;
//步骤4：如果两条记录仅有一个条件属性值不同，且其中一条记
//录该属性被标记为"*"，那么，对该记录如果可由未被标记的属性值判断出决策，
//则删除另外一条记录，否则，删除本记录。

//自己重写的.
    int i,j,k;                  //循环变量
	int count=0;                //统计多余的规则
	int * tuple=NULL;          //记录多余的规则
	int same=0;               //统计属性值相同的个数
	int same1;
	int mark=0;               //统计被标识'*'的属性个数
	int l,l1;                     //标示仅有一个条件属性不同的两个样例中有'*'的样例
	int rec=0;                //检查是否已经属于被删除记录
//	bool flag;                //判断是否有冗余规则
	if((tuple=new int[rule_num+1])==0)
		return NULL;
	for(i=0;i<rule_num;i++)
	{
		l=-1;
		for(k=0;k<count;k++)
			if(i==tuple[k+1])//看i是否已经被删除
			{//说明i已经被删除
				l=-2;
				break;
			}
		if(l==-2)
			continue;
		for(j=0;j<rule_num;j++)
		{
           // flag=false;//没有冗余规则
			if(j!=i)
			{
				l=-1;				
		    	same=0;
		    	mark=0;
		        for(k=0;k<count;k++)//看j样例有没有被删除
			      if(j==tuple[k+1])//看j是否已经被删除
				  {//说明j已经被删除
				     l=-2;
				     break;
				  }
		       if(l==-2)
			      continue;
    			for(k=0;k<con_num+1;k++)//对每个条件属性比较
	    			if(tab1[i][k]==tab1[j][k])
		    			same++;//统计属性值相同的数目
		    		else
						if((tab1[j][k]==-1)||(tab1[i][k]==-1))
						{//属性值不同时,至少有一个为'*'
						mark++;//初始为0
						if(mark>1)
							break;
						if(tab1[j][k]==-1)//j样例k属性为'*'
						{  l=j;  l1=i;}//l1表示要删除对样例,l表示有'*'的样例
						if(tab1[i][k]==-1)//i样例k属性为'*'
						{	l=i; l1=j;}
						}
					else 
	 					break;
	    		if((same==con_num)&&mark==1)
				{//两条记录决策相同,仅有一个条件属性值不同，且其中一条记
					//录该属性被标记为"*"
				//	flag=true;
					//判断是否可以由l样例判断决策
					for(int i1=0;i1<RecCount;i1++)//every record
					{
						same1=0;
						for(int i2=0;i2<con_num;i2++)//所有条件
						{
							if(tab1[l][i2]==-1)
							{
								same1++;
								continue;
							}
							if(tab1[l][i2]!=tab[i1][i2])
								break;//退出i2循环
							else same1++;
						}
						if(same1==con_num)//条件匹配
							if(tab1[l][con_num]!=tab[i1][con_num])
							{//决策不同 说明不能由标志为'*'的规则l判断,应删除l规则
							//	flag=false;
								l1=l;//应删除l规则
								break;//退出i1循环
							}							
					}
		//			if(flag)
					tuple[++count]=l1;//将l1规则删除.从1开始记录重复规则
					if(l1==i)
						break;//删除i记录时,进行i+1记录的循环
				}
			}//end if(j!=i)
		}//end for(j=0;j<rule_num;j++)
	}//end for(i=0;i<rule_num;i++)
	if(count!=0)
    {
		tuple[0]=count;
		return tuple;
	}
	else return NULL;
}
/*
int * ValReductionTwo::del_superflous(int ** tab)
{//源文件备份
    int i,j,k;                  //循环变量
	int count=0;                //统计多余的规则
	int * tuple=NULL;          //记录多余的规则
	int same=0;               //统计属性值相同的个数
	int mark=0;               //统计被标识的属性个数
	int rec=0;                //检查是否已经属于被删除记录
	for(i=0;i<rule_num;i++)
		for(j=0;j<rule_num-1;j++)
		{
			if(j!=i)
			{
    			for(k=0;k<con_num+1;k++)
	    			if(tab[i][k]==tab[j][k])
		    			same++;
		    		else if(tab[j][k]==-1)
			    		mark++;//初始为0
					else 
	 					break;
	    		if(same+mark==con_num+1&&same!=con_num+1)
				{
		    		if(tuple==NULL)
		     	    	if((tuple=new int[rule_num+1])==0)
							return NULL;
					for(k=0;k<count;k++)
						if(i!=tuple[k+1])
							rec++;
						else
							break;
					if(rec==count)//最后
		     	    	tuple[++count]=i;
				}
		    	same=0;
		    	mark=0;
				rec=0;
			}
		}
	if(tuple!=NULL)
		tuple[0]=count;
	return tuple;
}
*/

ValReductionTwo::ValReductionTwo()
{
  info=NULL;
  rec_num=0;
  con_num=0;
  pDelTable=NULL;
  same_rec=NULL;
}
ValReductionTwo::~ValReductionTwo()
{
	int i,j;
	delete[] pDelTable;
	if(rule!=NULL)
	{
		for(i=0;i<rule_num;i++)
		{
	//	if(rule[i]!=NULL)
			delete []rule[i];
		} 
	 	delete []rule;
	}
	if(datasign!=NULL)
	{
		for(j=0;j<AttCount;j++)
		{ 
		if(datasign[j]!=NULL) delete []datasign[j];
		if (cuttab[j]!=NULL) delete []cuttab[j];
		} 
	if(cuttab) delete []cuttab;
	delete []datatype;
	delete []datasign;
	}
	delete []delatt;
}


bool ValReductionTwo::Run(char *s,char *r)
{	
	if(RunOne(s)!=1) return false;//读入文件全部信息
	con_num=AttCount-1;//得到条件属性数目
	rec_num=RecCount;//记录数目
//	info=tab;
	int i,j;
	info=new int*[RecCount];//为info分配空间
	for(i=0;i<RecCount;i++)
		info[i]=new int[AttCount];
	for(j=0;j<AttCount;j++)
	{
		if(delatt[j])
			continue;
		for(i=0;i<RecCount;i++)//赋值
			info[i][j]=tab[i][j];
	}
	if(!(rule=generate_rule()))
		return false;
	//AttCount=AttCount1;
	Save_Files(r);
	return true; 
}


void ValReductionTwo::Save_Files(char *r)
{
	fout.open(r,ios::out|ios::trunc);
	int i,j,m,k;//循环变量
	//输出文件头
	fout<<"Style:rule"<<'\n';		//表示为规则文件
	fout<<"Stage:0"<<'\n';			//为规则文件这个值无用
	fout<<"Condition attributes number:"<<AttCount1-1<<'\n';//列数
    fout<<"The Number of Condition attributes deleted: "<<atbcount<<'\n';
	fout<<"The position of Condition attributes deleted: ";
//	fout<<atbcount<<'\n';
	for(i=0;i<atbcount;i++)
		fout<<atb[i]<<' ';
	fout<<'\n';
	fout<<"Rules number:"<<rule_num<<'\n';//行数
	fout<<"Blocks number:0\n";//块数
	for(j=0;j<AttCount1;j++)
		fout<<datasign[j]<<"  ";//属性名称
	fout<<'\n';
	for(j=0;j<AttCount1;j++)
	{
		switch (datatype[j])//输出数据类型
		{
		case 1:fout<<"Integer"<<' ';break;
		case 2:fout<<"Float"<<' ';break;
		case 3:fout<<"String"<<' ';break;
		}
	}
	fout<<'\n';
	int* same_rec=NULL;
	same_rec=new int[rule_num];
	int* same_att=NULL;
	same_att=new int[rule_num];
	int number1,number,same_num;
	for(i=0;i<rule_num;i++)//规则
	{
		number1=number=0;
		for(int j=0;j<RecCount;j++)//原始记录
		{
			same_num=0;
			for(int k=0;k<AttCount1-1;k++)//属性
			{
				if(delatt[k])
					same_num++;				
				else if(rule[i][k]==-1)
					same_num++;
				else if(rule[i][k]==tab[j][k])
					same_num++;
			}
			if(same_num==AttCount-1)
			{
				number1++;
				if(rule[i][AttCount-1]==tab[j][AttCount-1])
					number++;
			}
		}
		same_rec[i]=number;
		same_att[i]=number1;
	}
	for(i = 0;i <rule_num;i++)
	{
		k=0;
		for(j = 0;j<AttCount1;j++)
		{//j属性
			if(delatt[j])//delatt表示属性本身已经被约简
			{
				fout<<'-'<<' ';
				continue;
			}
			if(rule[i][k]==-1)//规则i中k属性为'*'
				fout<<'-'<<' ';
			else
				if(cuttab[j]!=NULL)//j断点表
					{
					   for(m=0;m<RecCount;m++)
							if(cuttab[j][m].x==rule[i][k])
							{
								fout<<cuttab[j][m].string<<' ';
								break;
							}
					}
				else
					fout<<rule[i][k]<<' ';
			k++;
		}
		fout<<float(same_rec[i])/float(same_att[i])<<' ';
		fout<<same_rec[i]<<' ';
		fout<<same_att[i]<<'\n';
	}
//	fout<<"attribute\n";
//	fout<<atbcount<<'\n';
	//for(i=0;i<atbcount;i++)
	//	fout<<atb[i]<<' ';
//写入文件尾部	while(!fin)
    fout.close();
	delete[] same_rec;
	delete[] same_att;
}