valreductionthree.cpp

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

// ValReductTwo.cpp : implementation file
//

#include "stdafx.h"
//#include "RSet.h"
//#include "roughsetDoc.h"
#include"stdlib.h"
#include "ValReductionThree.h"
#include<stdio.h>
#include"string.h"
#include "..\VP_B.h"
#include <math.h>
#include <stdlib.h> 

#ifndef NULL
#define NULL 0
#endif
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
//#define b 0  //精度B，控制输出规则的信任度
/////////////////////////////////////////////////////////////////////////////
// ValReductionThree决策矩阵值约简

ValReductionThree::ValReductionThree()
{
  array=NULL;
  element=0;
  rule=NULL;
  datasign=NULL;
  cuttab=NULL;
  result=NULL;
}

ValReductionThree::~ValReductionThree()
{
  	int i,j;
    if(rule!=NULL)
	{
		for(i=0;i<rule_num;i++)
		{ 
		delete []rule[i];
		} 
	    delete []rule;
	}
	if(datasign!=NULL)
	{
	  for(j=0;j<AttCount;j++)
	  { 
		delete []datasign[j];
		if (cuttab[j]!=NULL) delete []cuttab[j];
	  } 
	delete []cuttab;
	delete []datasign;
	}
	delete []datatype;

}
/////////////////////////////////////////////////////////////////////////////
// ValReductionThree message handlers

int ** ValReductionThree::generate_rule()
{ //  对于一个属性约简结果信息表RED，令Xi+(i=1,2…m), Xj-(j=1,2…n)表示关系R*（RED）的等价类，
//Xi+ POS RED（Y），Xj- NEG RED（Y）,决策矩阵M=（Mij）mn,定义为
//Mij ={ (a,f(Xi+ ,a)：a∈RED, f(Xi+ ,a)≠f(Xj-,a)),
	int i,j,k;                //循环变量	
	int same=0;               //统计不属于重复记录的个数
	int rec=0;                //统计新的规则数
	int sum=0;
	int * overlaps=NULL;      //保存重复的记录
	int * att=NULL;    //约简后的属性
	int * tuple=NULL;     //保存多余的规则
	overlaps=find_overlap(info,rec_num); //查找重复记录
	//pDelTable = new int[con_num+1];
	//for(i = 0;i < con_num+1;i++)
	//	pDelTable[i] = 0;
	int number=0;
	if(overlaps!=NULL)
	{
		rule_num=rec_num-overlaps[0];//消除重复记录后的记录数
		int ** rule=new int * [rule_num];
		for(i=0;i<rule_num;i++)
			rule[i]=new int[con_num+1];
		for(i=0;i<rec_num;i++)
		{
			same=0;
			for(j=0;j<overlaps[0];j++)
				if(i!=overlaps[j+1])
					same++;
			if(same==overlaps[0])
			{
				for(j=0;j<con_num+1;j++)
					rule[rec][j]=info[i][j];
				rec++;
			}
		}
		for(i=0;i<rec_num;i++)
			delete []info[i];
		delete []info;
	    info=new int *[rule_num];
		for (i=0;i<rule_num;i++)
			info[i]=new int [con_num+1];
		for (i=0;i<rule_num;i++)
			for (j=0;j<con_num+1;j++)
				info[i][j]=rule[i][j];
		for(i=0;i<rule_num;i++)
			delete []rule[i];
		delete []rule;
		rec_num=rule_num;
		delete []overlaps;
	}
	else
		rule_num=rec_num;

	int **information=new int * [rule_num];
	for(i=0;i<rule_num;i++)
	{
		same=0;
		reduct_att_num=0;		//有几组值约简结果
		information[i]=new int[con_num+1];
        create_array(i);//设置决策矩阵
        reduct_table();//计算属性组合
		//假如i样例产生好几种不同的约简属性组合,选取匹配最多的.
		if(reduct_att_num>1)//多种属性组合,要得到最大一般化规则
    		att=get_match_most(i);//得到info行i匹配最多的属性组合 失败:返回:NULL
		else if(reduct_att_num==1)//改动
			att=result[0];//只有一种属性组合
		else att=NULL;
		if(att!=NULL)
         for(j=0;j<con_num;j++)
			{ //约简后的条件属性个数con_num 用规则对i样例每个属性约简
			  for(k=0;k<att[0];k++)
			  	if(j!=att[k+1])
					same++;
				else 
					break;
			  if(same!=att[0])//只保留规则对应的条件属性
	     		information[i][j]=info[i][j];
		      else
			    	information[i][j]=-1;//i样例j属性令为'-'
		 	  same=0;
			} 
		else
			for(j=0;j<con_num;j++)
				information[i][j]=-1;//i样例j属性令为'-'
	    information[i][con_num]=info[i][con_num];//决策
		if(result!=NULL)
		{//析够 为下次准备
	    	for(j=0;j<reduct_att_num;j++)
    	    	delete []result[j];
   	    	delete []result;
		}
		result=NULL; 
		if(reductset!=NULL)
        	delete reductset;
		reductset=NULL;
	}

	overlaps=find_overlap(information,rec_num);//查找重复记录
	if(overlaps!=NULL)
	{//通过information表出去重复记录来设置rule表
		rule_num=rec_num-overlaps[0];
		int *same_record;
		int number=0;
		int sum=0;
		same_record=new int [rec_num-overlaps[0]];
		int ** rule=new int * [rule_num];
		for(i=0;i<rule_num;i++)
			rule[i]=new int[con_num+1];
		rec=0;
		for(i=0;i<rec_num;i++)
		{
			for(j=0;j<overlaps[0];j++)
				if(i!=overlaps[j+1])
					same++;
			if(same==overlaps[0])
			{
				for(j=0;j<con_num+1;j++)
					rule[rec][j]=information[i][j];
				rec++;
			}
			same=0;
			
		}
		for(i=0;i<rec_num;i++)
			delete []information[i];
		delete []information;
		information=rule;
		rec_num=rule_num;
		delete []overlaps;
	}

/*	tuple=del_superflous(information);  //删除多余的规则
	if(tuple!=NULL)
	{//删除多于规则,重新设置rule
		same=0;
		rec=0;                        
		int sum=0;
		int ** rule=new int * [rule_num-tuple[0]];
 		for(i=0;i<rule_num-tuple[0];i++)
		rule[i]=new int[con_num+1];
		for(i=0;i<rule_num;i++)
		{
			for(j=0;j<tuple[0];j++)
				if(i!=tuple[j+1])
					same++;
			if(same==tuple[0])
			{
				for(j=0;j<con_num+1;j++)
					rule[rec][j]=information[i][j];
				rec++;
			}
			same=0;
		}
		for(i=0;i<rule_num;i++)
			delete []information[i];
		delete []information;
		information=rule;
		rule_num=rec;
		delete []tuple;
	}
	*/
	return information;
}

int * ValReductionThree::find_overlap(int * * tab, int number)
{//查找重复记录  success:return 重复样例指针;否则返回NULL
	int i,j,k,t;                 //循环变量
	int count=0;                     //统计属性值相同的个数
	int find=FALSE;           //查找是否已经被列为重复记录
	int * same_rec=NULL;             //保存重复的记录
	int same_num=0;                  //重复记录的个数
	for(i=0;i<number-1;i++)
	{
		for(j=i+1;j<number;j++)
		{
			for(k=0;k<con_num+1;k++)//条件,决策
				if(tab[i][k]==tab[j][k])
					count++;
				else
					break;
			if(count==(con_num+1))
			{
				if(same_rec==NULL)
                 	if((same_rec=new int[number])==0)
						return NULL;
				for(t=0;t<same_num;t++)
                    if(same_rec[t]==i)
					{
					    find=TRUE;
					    break;
					}
				if(find==FALSE)
			    	same_rec[++same_num]=j;
			}
			find=FALSE;
			count=0;
		}
	}
	if(same_rec!=NULL)
    	same_rec[0]=same_num;
	return same_rec;
}

void ValReductionThree::create_array(int row)
{//设置决策矩阵M row:样例所在的行
	int i,k,l,n;                                //循环变量
	int * att=NULL;                                  //条件属性组合
	int find=FALSE;
	int m=0,num=0;
    if((att=new int[con_num+1])==0)
	{
		AfxMessageBox("wrong!");
		return;
	}
	element=0; //决策矩阵中元素的个数
	for(i=0;i<rec_num;i++)//rec_num: 信息表记录数
	{
		if(i!=row) //如果不是同一行
		{
			find=FALSE;
			num=0;
			m=0;
      	 	if(info[row][con_num]!=info[i][con_num])//如果决策属性不同
			{
	    		for(k=0;k<con_num;k++)
		    		if(info[row][k]!=info[i][k])
					{//找不同的条件属性
			    		att[++m]=k;
					}
		        att[0]=m;//att中保存属性不同的属性编号
		        for(l=0;l<element;l++)
				{
					if(array[l][0]==att[0])
					{//决策矩阵 array
    		     	    for(n=1;n<=att[0];n++)
			     		    if(array[l][n]==att[n])
                                num++;
			            if(num==att[0])//如果在决策表中能找到该编号
						{
			                find=TRUE;
				     	   	break;
						}
					} 
			    	num=0;
				}
		    	if(find==FALSE && (att[0]>0) )//需要加入决策矩阵
				{
		    		int ** newarray=NULL;
					if((newarray=new int *[element+1])==0)
					{
						AfxMessageBox("wrong!");
						return;
					}
			    	for(l=0;l<element;l++)
					{//将原先决策矩阵拷贝入newarray
			     	    newarray[l]=new int[array[l][0]+1];
				     	for(n=0;n<array[l][0]+1;n++)
				    		newarray[l][n]=array[l][n];
					}
		        	if(element>0)
					{
						for(l=0;l<element;l++)
							delete []array[l];
						delete []array;
					}
			    	array=newarray;
		    	    array[element]=new int[att[0]+1];//新增一行
		         	for(l=0;l<att[0]+1;l++)//将att中属性拷贝到矩阵中
		    	       	array[element][l]=att[l];
		    	   	element++;
				}
//		    	find=FALSE;
	    //		num=0;
			}
		}
	}
	delete []att;
}

void ValReductionThree::reduct_table()
{//计算属性组合
	int i,j,k;                  //循环变量
	int redu_num=0;             //约简属性集的元素个数
    int att_num=0;              //除去核属性后其余的属性组合数
	int *** DNF=NULL;           //由整数表示的积之和
	int item_num=0;               //积之和表达式的项数
	int find=FALSE;
   
   	reductset=new int[con_num+1];//存储核属性,核属性的个数为redu_num
	reductset[0]=0;
	for(i=0;i<element;i++)
		if(array[i][0]==1)
		{//找到核属性
			reductset[++redu_num]=array[i][1];
			reductset[0]=redu_num;
		}
	if(redu_num>0)
	{
		for(i=0;i<element;i++)
			if(array[i][0]>1)
			{
				for(j=1;j<=array[i][0];j++)
				{//对决策矩阵的第i行每个元素,判断是否含有核属性
                    for(k=1;k<=redu_num;k++)
						if(array[i][j]==reductset[k])
						{
							find=TRUE;
							break;
						}
					if(find==TRUE)
						break;//退出
				}
				if(find==FALSE)
					att_num++;//统计决策矩阵中不含有核属性的行数