#include<iostream.h>
#include<iomanip.h>
#include<fstream.h>
#include<stdlib.h>
struct Fzb
{
	int yyz; //语言之
	int ly; //论域
	float lsd; //隶属值
	struct Fzb *next;
};

class Fuzzy
{
private:
	int g[49][3];  //定义了规则库，用于函数间调用
	float R[169][13];  //定义了关系矩阵，用于函数间调用
	float H[13][13];   //定义了查询表矩阵，用于函数间的调用
public:
	struct Fzb * Creatfzb(); //建立赋值表函数
	void Printfzb(struct Fzb *head1); //输出赋值表
	void Inputgzk(); //导入规则库
	void jlgx(struct Fzb*E,struct Fzb*EC,struct Fzb*U);  //建立关系矩阵
	void jlcxb(struct Fzb*E,struct Fzb*EC,struct Fzb*U); //建立查询表
};
struct Fzb *Fuzzy::Creatfzb()
{
	float f[8][14]={
		{0,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6},
		{-3,1,0.5,0,0,0,0,0,0,0,0,0,0,0},	
		{-2,0,0.5,1,0.5,0,0,0,0,0,0,0,0,0},
		{-1,0,0,0,0.5,1,0.5,0,0,0,0,0,0,0},
		{0,0,0,0,0,0,0.5,1,0.5,0,0,0,0,0},
		{1,0,0,0,0,0,0,0,0.5,1,0.5,0,0,0},
		{2,0,0,0,0,0,0,0,0,0,0.5,1,0.5,0},
		{3,0,0,0,0,0,0,0,0,0,0,0,0.5,1}};  //默认输入赋值表
	int i,k,j;
	fstream in,out;
	struct Fzb *head,*p1,*p2;
	int n=0;
	head=NULL;
	p1=new(Fzb);
	for(k=1;k<8;k++)
		for(j=1;j<14;j++)
		{
			n++;
			p1->lsd=f[k][j];
			p1->yyz=(int)f[k][0];
			p1->ly=(int)f[0][j];
			if(1==n) head=p1;
			p2=p1;
			p1=new(Fzb);
			p2->next=p1;
		}
		p2->next=NULL;
        int	m=0;
		return (head);
}
void Fuzzy::Inputgzk()
{
	int G[49][3]={
		{-3,-3,-3},{-3,-2,-3},{-3,-1,-3},{-3,0,-3},
		{-3,1,-2},{-3,2,0},{-3,3,0},{-2,-3,-3},
		{-2,-2,-3},{-2,-1,-3},{-2,0,-3},{-2,1,-2},
		{-2,2,0},{-2,3,0},{-1,-3,-2},{-1,-2,-2},
		{-1,-1,-2},{-1,0,-2},{-1,1,0},{-1,2,1},
		{-1,3,1},{0,-3,-2},{0,-2,-2},{0,-1,-1},
		{0,0,0},{0,1,1},{0,2,2},{0,3,2},{1,-3,-1},
		{1,-2,-1},{1,-1,0},{1,0,2},{1,1,2},{1,2,2},
		{1,3,2},{2,-3,0},{2,-2,0},{2,-1,2},{2,0,3},
		{2,1,3},{2,2,3},{2,3,3},{3,-3,0},{3,-2,0},
		{3,-1,2},{3,0,3},{3,1,3},{3,2,3},{3,3,3}}; //默认输入规则库
	int i,j;
	int n=0;
	for(i=0;i<49;i++)
		for(j=0;j<3;j++)
		{
			n++;
			g[i][j]=G[i][j];
			cout<<setw(5)<<g[i][j];   //显示规则库
			if(3==n) {cout<<endl;n=0;}
		}
}
void Fuzzy::Printfzb(struct Fzb *head1)
{
	struct Fzb *p;
	p=head1;
	int n,i,j;
	float a[8][14];
	while(NULL!=p)
	{
		a[p->yyz+4][p->ly+7]=p->lsd;
		p=p->next;
	}
	p=head1;
	while (NULL!=p) 
	{
		a[0][p->ly+7]=p->ly;
		p=p->next;
	}
	p=head1;
	while (NULL!=p) 
	{
        a[p->yyz+4][0]=p->yyz;
		p=p->next;
	}
	a[0][0]=0;
	int k;
		for(i=0;i<8;i++)  //用于输出标准形式的赋值表
		{
		    n=0;
			for(j=0;j<14;j++)
			{
				n++;
				if(0==j&&0!=i)
				{
					switch((int)a[i][j]) {
					case -3:
						cout<<setw(5)<<"NB";
						break;
					case -2:
						cout<<setw(5)<<"NM";
						break;
					case -1:
						cout<<setw(5)<<"NS";
						break;
					case 0:
						cout<<setw(5)<<"Z";
						break;
					case 1:
						cout<<setw(5)<<"PS";
						break;
					case 2:
						cout<<setw(5)<<"PM";
						break;
					case 3:
						cout<<setw(5)<<"PB";
					}
				}
				else
					cout<<setw(5)<<a[i][j];
				if(14==n) cout<<endl;
			}
		}
	
}
void Fuzzy::jlgx(struct Fzb*E,struct Fzb*EC,struct Fzb*U)
{
	int i,j,k,m,n,l,z;
	struct Fzb*p1,*p2,*p3;
    p1=E; p2=EC; p3=U;
	float a[13],b[13],c[13];
	float R1[169],R2[169][13];  //前者用于存储转置后的一维向量，后者用于暂时存储每条规则生成的关系矩阵
	for(i=0;i<49;i++)
		{
	
			p1=E; p2=EC; p3=U;
			k=0;m=0;n=0;z=0;
			while(NULL!=p1)
			{				
				if(p1->yyz==g[i][0])
				a[k++]=p1->lsd;					
				p1=p1->next;
			}
					
			while(NULL!=p2)
			{
				if(p2->yyz==g[i][1])
				b[m++]=p2->lsd;
				p2=p2->next;
			}
			while(NULL!=p3)
			{
				if(p3->yyz==g[i][2])
				c[n++]=p3->lsd;
				p3=p3->next;
			}
			for(j=0;j<13;j++)
			   for(l=0;l<13;l++)
				{
                    if(a[j]>b[l]) 
				    R1[z++]=b[l];
				    else
					R1[z++]=a[j];
				}
			for(j=0;j<169;j++)
				for(l=0;l<13;l++)
				{
				    if(R1[j]>c[l])
				    R2[j][l]=c[l];
				    else
				    R2[j][l]=R1[j];
				}
			if(0==i)
			for(j=0;j<169;j++)  //以下于对所有规则对应的关系矩阵作加法
			    for(l=0;l<13;l++)
				{
			      R[j][l]=R2[j][l];
			  }
		   for(j=0;j<169;j++)
				 for(l=0;l<13;l++)
				 {
					 if(R2[j][l]>R[j][l])
				     R[j][l]=R2[j][l];
			   }
							


	}
	i=0;
	for(j=0;j<169;j++)
		for(l=0;l<13;l++)
		{
			i++;
		    cout<<setw(5)<<R[j][l];  //输出总的关系矩
			if(13==i)
			{cout<<endl;i=0;}		
		}
	
		return;
}
void Fuzzy::jlcxb(struct Fzb*E,struct Fzb*EC,struct Fzb*U)
{
	int e,ec,u;
	int i,j,k,n=0,l=0,x=0;
	float m=0;
	struct Fzb*p1,*p2,*p3;
    p1=E;p2=EC;p3=U;
	float a[13],b[13];
	float gg[169];
	float max=0,min;
	float t[13];  //用于存储每次生成的U的隶属函数，从而求得每组e,ec对应的u
	for(i=0;i<13;i++)	
		for(j=0;j<13;j++)
		{
			m=0;
			p1=E;p2=EC;p3=U;
			l=0;
			e=i-6;
			ec=j-6;
			while (NULL!=p1)
			{
				if(e<0)
				{ 
				  if(e==p1->ly&&m<p1->lsd)
				  {
						 n=p1->yyz;
						 m=p1->lsd;
				  }
				}
				else
				{
					if(e==p1->ly&&m<=p1->lsd)
					{
						n=p1->yyz;
						m=p1->lsd;
					}
				}

				 p1=p1->next;
			}
			p1=E;
               while (NULL!=p1) 
			   {
				   if(n==p1->yyz) a[l++]=p1->lsd;
				   p1=p1->next;
               }
			   m=0;
			   while (NULL!=p2)
			   {
				   if(ec<0)
				   { 
					   if(ec==p2->ly&&m<p2->lsd)
					   {
						   n=p2->yyz;
						   m=p2->lsd;
					   }
				   }
				   else
				   {
					   if(ec==p2->ly&&m<=p2->lsd)
					   {
						   n=p2->yyz;
						   m=p2->lsd;
					   }
				   }
				   p2=p2->next;
			   }
			   p2=EC;
			   l=0;
               while (NULL!=p2) 
			   {
				   if(n==p2->yyz) b[l++]=p2->lsd;
				   p2=p2->next;
               }
			   /*
			   cout<<e<<"  "<<ec<<endl;
			   			   for(x=0;x<13;x++)
			   			   {
			   				   cout<<a[x]<<"  ";
			   			   }
			   			   cout<<endl;
			   			   for(x=0;x<13;x++)
			   			   {
			   				   cout<<b[x]<<"  ";
			   			   }
			   
			   			   cout<<endl;*/
			   n=0;
			   for(x=0;x<13;x++)
                for(l=0;l<13;l++)
				{
					if(a[x]<b[l]) gg[n++]=a[x];
					else gg[n++]=b[l];
				}
				for(x=0;x<13;x++)   //进行推理合成规则计算
				{
					max=0;
					for(l=0;l<169;l++)
					{
                       if(gg[l]<R[l][x]) min=gg[l];
					   else min=R[l][x];
					   if(max<min) max=min;
					}
					t[x]=max;
				}
				p3=U;
                 float sum=0;
				 float s=0;
				 float u=0;
				for(x=0;x<13;x++)
				{
					if(0!=t[x])
					{
						s=x-6;
					    sum+=t[x]*s;
						u+=t[x];
					}
				}
					H[i][j]=sum/u;
		}
		for(i=0;i<13;i++)
		{
			for(j=0;j<13;j++)
			{
				if(H[i][j]<0)
				cout<<setw(4)<<(int)(H[i][j]-0.5);
				else
				cout<<setw(4)<<(int)(H[i][j]+0.5);

			}
			cout<<endl;
		}
}

void main()
{
	struct Fzb *E,*EC,*U;
	E=EC=U=NULL;
	Fuzzy p;
	int jg;
	int n=1;
	E=p.Creatfzb();  //默认建立E的赋值表
	EC=p.Creatfzb(); //默认建立EC的赋值表
	U=p.Creatfzb();  //默认建立U的赋值表
	int t=1;
while (1==1) {

	cout<<endl<<"想做什么："<<endl<<"1、输出E的赋值表"<<endl<<"2、输出EC的赋值表"<<endl<<"3、输出U的赋值表"<<endl<<"4、显示规则库"<<endl<<"5、求解关系函数"<<endl<<"6、输出查询表"<<endl<<"6、退出"<<endl;
	cout<<"---->  ";
	cin>>jg;
	switch(jg) {
	case 1:
	cout<<"*************************************************************"<<endl;
	cout<<"E的赋值表如下："<<endl;
	p.Printfzb(E);
		break;
	case 2:
	cout<<"*************************************************************"<<endl;
	cout<<"EC的赋值表如下："<<endl;
	p.Printfzb(EC);
		break;
	case 3:
	cout<<"*************************************************************"<<endl;
	cout<<"U的赋值表如下："<<endl;
	p.Printfzb(U);
		break;
	case 4:
        p.Inputgzk();
		n=0;
		break;
	case 5:
		if(n) 
		{
			cout<<"*************************************************************"<<endl;
			cout<<"             未调入规则库，请先运行步骤4"<<'\a'<<endl;
			cout<<"*************************************************************"<<endl;
		}
		else
		{
			p.jlgx(E,EC,U);
			t=0;
		}
		break;
	case 6:
        if(t)
		{
			cout<<"*************************************************************"<<endl;
			cout<<"             未创建关系矩阵，请先运行步骤5"<<'\a'<<endl;
			cout<<"*************************************************************"<<endl;
		}
		else
		{
			cout<<"*************************************************************"<<endl;
			cout<<"查询表如下："<<endl;
			p.jlcxb(E,EC,U);
		}
		break;
	default:
		return;
	}
}
}