valreductionthree.cpp

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

	}
	delete []best_att;
}

int * ValReductionThree::get_best_att(int ***style, int num)
{//得到最好的属性组合,是数目最少的属性组合
	int i;
	int min=0;
	int count=0;
    int * att=new int[num+1];
	min=style[0][0][0];
	for(i=0;i<num;i++)
		if(min>style[i][0][0])
			min=style[i][0][0];
	for(i=0;i<num;i++)
		if(style[i][0][0]==min)
			att[++count]=i;//统计同为最小属性组合的数目
	att[0]=count;
    return att;
}

int * ValReductionThree::get_match_most(int row)
{//得到info行row匹配最多的属性组合 失败:返回:NULL
	//在row行中找到属性组合对应的值,再在info中匹配记录.找到匹配最多的
	//规则返回
	int i,j,k,col;
	int * count=NULL;                    //统计匹配的次数
	int num=0;                           //统计匹配属性的个数
//	int att_num=result[0][0];          //得到需检验的属性个数
    int att_num;
	int * val=NULL;
	if((count=new int[reduct_att_num])==0)
		return NULL;
	for(i=0;i<reduct_att_num;i++)
	{
		att_num=result[i][0];
		if((val=new int[att_num])==0)
		    return NULL;
		count[i]=0;
		for(j=0;j<att_num;j++)
		{//得到行row中与i规则对应的属性值
			col=result[i][j+1];
			val[j]=info[row][col];//属性约简后的信息表info
		}
		for(j=0;j<rule_num;j++)
		{//得到信息表中和val匹配的记录条数,作为规则i的匹配数目.没有考虑决策
			if(j!=row&&info[j][con_num]==info[row][con_num])
			{//决策相等,j!=row
	     		for(k=0;k<att_num;k++)
				{
		    		col=result[i][k+1];
		    		if(info[j][col]==val[k])
						num++;
					else
						break;
				}
				if(num==att_num)
					count[i]++;
				num=0;
			}
		}
	}
    int term=get_max(count,reduct_att_num);//得到个数最多的属性组合所在位置
	for(i=0;i<reduct_att_num;i++)
		if((count[i]==count[term])&&(i!=term))
			if(result[i][0]<result[term][0])
				term=i;	
	delete []val;
	delete []count;
	return result[term];
}

int * ValReductionThree::del_superflous(int ** tab)
{//删除表tab中多余的规则  success:返回多余的规则指针;else return NULL
	int i,j,k;                               //循环变量
	int count=0;                             //统计多余的规则
	int * tuple=NULL;                        //记录多余的规则
	int same=0;                              //统计属性值相同的个数
	int mark=0;                              //统计被标识的属性个数
	int rec=0;                               //检查是否已经属于被删除记录
	bool flag;
	for(i=0;i<rule_num;i++)
	{
		flag=false;
		for(k=0;k<count;k++)
		  if(i==tuple[k+1])
		  {
			  flag=true;
			  break;
		  }
	    if(flag)
			continue;
        for(j=0;j<rule_num;j++)
		{
		  if(j!=i)
		  {
			flag=false;
	    	for(k=0;k<count;k++)
		       if(j==tuple[k+1])
			   { 
			     flag=true;
			     break;
			   } 
	        if(flag) 
		      continue;
			same=0;
			mark=0;
  			for(k=0;k<con_num+1;k++)//要么属性值相等,要么j处为'-'
    			if(tab[i][k]==tab[j][k])
	    			same++;
	    		else if(tab[j][k]==-1)//为'-'
		    		mark++;
				else 
 					break;
	    		if(same+mark==con_num+1&&same!=con_num+1)//说明i规则和j规则匹配
				{
		    		if(tuple==NULL)
		     	    	tuple=new int[rule_num];
         	    	tuple[++count]=i;
				}
			}
		}//end for(j
	}//end for(i
	if(tuple!=NULL)
	{
		tuple[0]=count;
	    return tuple;
	}
	else return NULL;
}

int ValReductionThree::get_max(int * att,const int num)
{//得到匹配个数最多的属性组合所在位置 
	int i;
	int max=0;
	for(i=0;i<num;i++)
		if(att[max]<att[i])
			max=i;
	return max;
}

int ValReductionThree::charin(const char * str1,const char * str2)
{ //判断str1中的字符是否完全属于str2 不包含:return FALSE;否则:return TRUE
	int i;                                    //循环变量
	int length;                               //字符串长度
	char c;                                   //从字符串中取出的字符
	length=strlen(str1);
	for(i=0;i<length;i++)
	{
        c=str1[i];
		if(strchr(str2,c)==NULL)//看c是否包含于str2中.包含返回指针;否则为NULL
			return FALSE;
	}
	return TRUE;
}


void ValReductionThree::selectsort(int ** att,int num)
{//用选择法排序按照属性数目从小到大排序
	int i,j;                                  //循环变量
	int min_item;
	for(i=0;i<num-1;i++)
	{
		min_item=i;
		for(j=i+1;j<num;j++)
			if(att[j][0]<att[min_item][0])
				min_item=j;//找出属性个数最小者
		if(min_item!=i)
		{//将j和i交换
			int * transfer=new int[att[i][0]+1];
			for(j=0;j<att[i][0]+1;j++)
				transfer[j]=att[i][j];
			delete att[i];
			att[i]=new int[att[min_item][0]+1];
			for(j=0;j<att[min_item][0]+1;j++)
				att[i][j]=att[min_item][j];
			delete att[min_item];
			att[min_item]=new int[transfer[0]+1];
			for(j=0;j<transfer[0]+1;j++)
				att[min_item][j]=transfer[j];
			delete []transfer;
		}
	}
}

void ValReductionThree::selectsort(char ** str,int num)
{//用选择法排序按照属性数目从小到大排序 
	int i,j;                                  //循环变量
	int min_item;
	for(i=0;i<num-1;i++)
	{
		min_item=i;
		for(j=i+1;j<num;j++)
			if(strlen(str[j])<strlen(str[min_item]))
				min_item=j;
		if(min_item!=i)
		{//i<---->min_item
			char * transfer=new char[strlen(str[i])+1];
			strcpy(transfer,str[i]);
			delete str[i];
			str[i]=new char[strlen(str[min_item])+1];
			strcpy(str[i],str[min_item]);
			delete str[min_item];
			str[min_item]=new char[strlen(transfer)+1];
			strcpy(str[min_item],transfer);
			delete []transfer;
		}
	}
}

void ValReductionThree::selectsort(int * att)
{//用选择法对约简后的属性数组重新排列
	int i,j;                                 //循环变量
	int min_item;                            //具有最小值的项
	int transfer;       
	for(i=0;i<att[0]-1;i++)
	{
		min_item=i;
		for(j=i+1;j<att[0];j++)
			if(att[j+1]<att[min_item+1])
				min_item=j;
		if(min_item!=i)
		{
			transfer=att[i+1];
			att[i+1]=att[min_item+1];
			att[min_item+1]=transfer;
		}
	}
}


bool ValReductionThree::Run(char *s,char *r)
{	//主程序
	if(RunOne(s)!=1) return false; //读文件
//    CVP_B a;
//	a.m_b=0;
//	if(a.DoModal()==IDOK)
//		b=a.m_b;
//	else return false;
//	AfxMessageBox("精度取0"

	clock_t  finish,start;   //时钟计时开始
	start = clock();

	b=0;
	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;

	finish = clock();  //时钟结束
	CString str;
	double duration;
	duration = (double)(finish - start) / CLOCKS_PER_SEC;
	str.Format (" 约简运行时间:%f 秒",duration);
	AfxMessageBox(str);  

	Save_File2(r);
	return true;
}

 void ValReductionThree::Save_File2(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: ";
	for(i=0;i<atbcount;i++)
		fout<<atb[i]<<' ';
	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;
	m=0;
	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++;
				else break;
			}
			if(same_num==AttCount-1)
			{
				number1++;
				if(rule[i][AttCount-1]==tab[j][AttCount-1])
					number++;
			}
		}
		same_rec[i]=number;
		same_att[i]=number1;
		if(float(same_rec[i])/same_att[i]<b)
			m++;
	}

	fout<<"Rules number:"<<rule_num-m<<'\n';//原规则数减去信任度小于b的规则数
	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';

	for(i = 0;i <rule_num;i++)
	{
		if(float(same_rec[i])/same_att[i] < b)//b在开始define
			continue;//如果信任度小于b，则不输出规则
		k=0;
		for(j = 0;j<AttCount1;j++)
		{
			if(delatt[j])
			{
				fout<<'-'<<' ';
				continue;
			}
			if(rule[i][k]==-1)
				fout<<'-'<<' ';
			else
				if(cuttab[j]!=NULL)
					{					
						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])/same_att[i]<<' ';
		fout<<same_rec[i]<<' ';
		fout<<same_att[i];
		fout<<'\n';
	}

//写入文件尾部	while(!fin)
fout.close();
}