模糊推理(T-S系统)——补充

接上篇博客：点击打开链接

//农业生产的经济指标，等级划分标准：

/*********************************************/
//等级 高 中 低       */
//亩产 2000以上 1500~2000 1500以下 */
//费用 7以上 4~7 4以下    */
//用工 50以上   25~50 25以下   */
//收入 120以上   90~120 90以下   */
//肥力 3~5 1~3      */
/*********************************************/
//如果隶属度函数为f(x)，则：
//高的隶属度函数为f(x)的1/2次方
//中的隶属度函数为min(f(x), 1-f(x))
//低的隶属度函数为(1-f(x))的1/2次方


//推理规则
//if亩产低and费用高and用工高and收入低and肥力低then评价差
//if亩产中and费用低and用工低and收入中and肥力高then评价中
//if亩产高and费用低and用工低and收入高and肥力高then评价高
//if亩产中and费用中and用工中and收入中and肥力高then评价中
//if亩产高and费用高and用工高and收入低and肥力低then评价差
//评价等级高、中、低分别用3, 2, 1表示


#include "stdio.h"
#include "stdlib.h"
#include "math.h"


#define INF 999
#define DEF 0.0000001
#define dimNum 5    //经济指标数
#define N 5   //规则条数
#define min(a, b) (a<b?a:b)
#define max(a, b) (a>b?a:b)


double fun1(double x);  //亩产隶属度函数
double fun2(double x);  //费用隶属度函数
double fun3(double x);  //用工隶属度函数
double fun4(double x);  //收入隶属度函数
double fun5(double x);  //肥力隶属度函数
void rule1();    //第1条规则
void rule2();    //第2条规则
void rule3();    //第3条规则
void rule4();    //第4条规则
void rule5();    //第5条规则


double MIN_W[N]={0};   //取小法加权值
double MUL_W[N]={0};   //乘积法加权值
double evaluate[N];  //评价结果
double yieldPerMu ;   //亩产
double cost;     //每百斤产量费用
double useWork;   //每亩用工时
double netIncome;  //每亩纯收入
double soil;     //土壤肥力等级


void main()
{
int i, j;


printf("亩产:");
scanf("%lf", &yieldPerMu);
printf("每百斤产量费用:");
scanf("%lf", &cost);
printf("每亩用工时:");
scanf("%lf", &useWork);
printf("每亩纯收入:");
scanf("%lf", &netIncome);
printf("土壤肥力等级:");
scanf("%lf", &soil);


rule1();
rule2();
rule3();
rule4();
rule5();


double MIN_EVA=0;//取小法最终评价
double MUL_EVA=0;//乘积法最终评价
double min_sum1, min_sum2, mul_sum1, mul_sum2;  

min_sum1 = min_sum2 = mul_sum1 = mul_sum2 = 0; 
for(i=0; i<N; i++)
{
min_sum1 += MIN_W[i]*evaluate[i];
min_sum2 += MIN_W[i];
mul_sum1 += MUL_W[i]*evaluate[i];
mul_sum2 += MUL_W[i];
}

MIN_EVA = min_sum1/(min_sum2+DEF);
MUL_EVA = mul_sum1/(mul_sum2+DEF);


printf("取小法最终评价等级为：%0.3lf  \n乘积法最终评价等级为：%0.3lf\n", MIN_EVA, MUL_EVA);


}




//第1条规则
void rule1()
{
int i;
double minTemp;
double mulTemp;
double wTemp[dimNum];


for(i=0; i<dimNum; i++)
wTemp[i] = INF;

wTemp[0] = sqrtf(1-fun1(yieldPerMu));
wTemp[1] = sqrtf(fun2(cost));
wTemp[2] = sqrtf(fun3(useWork));
wTemp[3] = sqrtf(1-fun4(netIncome));
wTemp[4] = sqrtf(1-fun5(soil));
evaluate[0] = 1;

//将隶属度过低的归为0
for(i=0; i<dimNum; i++)
if(wTemp[i]<DEF)
wTemp[i] = 0;


//取小法
minTemp = INF;
for(i=0; i<dimNum; i++)
if(wTemp[i]!=INF)
minTemp = min(minTemp, wTemp[i]);
MIN_W[0] = minTemp;

//乘积法
mulTemp = 1;
for(i=0; i<dimNum; i++)
if(wTemp[i]!=INF)
mulTemp = mulTemp*wTemp[i];
MUL_W[0] = mulTemp;


}




//第2条规则
void rule2()
{
int i;
double minTemp;
double mulTemp;
double wTemp[dimNum];

for(i=0; i<dimNum; i++)
wTemp[i] = INF;

wTemp[0] = min(1-fun1(yieldPerMu), fun1(yieldPerMu));
wTemp[1] = sqrtf(1-fun2(cost));
wTemp[2] = sqrtf(1-fun3(useWork));
wTemp[3] = sqrtf(fun4(netIncome));
wTemp[4] = sqrtf(fun5(soil));
evaluate[1] = 2;

//将隶属度过低的归为0
for(i=0; i<dimNum; i++)
if(wTemp[i]<DEF)
wTemp[i] = 0;


//取小法
minTemp = INF;
for(i=0; i<dimNum; i++)
if(wTemp[i]!=INF)
minTemp = min(minTemp, wTemp[i]);
MIN_W[1] = minTemp;

//乘积法
mulTemp = 1;
for(i=0; i<dimNum; i++)
if(wTemp[i]!=INF)
mulTemp = mulTemp*wTemp[i];
MUL_W[1] = mulTemp;


}




//第3条规则
void rule3()
{
int i;
double minTemp;
double mulTemp;
double wTemp[dimNum];

for(i=0; i<dimNum; i++)
wTemp[i] = INF;

wTemp[0] = sqrtf(fun1(yieldPerMu));
wTemp[1] = sqrtf(1-fun2(cost));
wTemp[2] = sqrtf(1-fun3(useWork));
wTemp[3] = sqrtf(fun4(netIncome));
wTemp[4] = sqrtf(fun5(soil));
evaluate[2] = 3;


//将隶属度过低的归为0
for(i=0; i<dimNum; i++)
if(wTemp[i]<DEF)
wTemp[i] = 0;


//取小法
minTemp = INF;
for(i=0; i<dimNum; i++)
if(wTemp[i]!=INF)
minTemp = min(minTemp, wTemp[i]);
MIN_W[2] = minTemp;

//乘积法
mulTemp = 1;
for(i=0; i<dimNum; i++)
if(wTemp[i]!=INF)
mulTemp = mulTemp*wTemp[i];
MUL_W[2] = mulTemp;


}




//第4条规则
void rule4()
{
int i;
double minTemp;
double mulTemp;
double wTemp[dimNum];

for(i=0; i<dimNum; i++)
wTemp[i] = INF;

wTemp[0] = min(fun1(yieldPerMu), 1-fun1(yieldPerMu));
wTemp[1] = min(fun2(cost), 1-fun2(cost));
wTemp[2] = min(fun3(useWork), 1-fun3(useWork));
wTemp[3] = min(fun4(netIncome), 1-fun4(netIncome));
wTemp[4] = sqrtf(fun5(soil));
evaluate[3] = 2;

//将隶属度过低的归为0
for(i=0; i<dimNum; i++)
if(wTemp[i]<DEF)
wTemp[i] = 0;


//取小法
minTemp = INF;
for(i=0; i<dimNum; i++)
if(wTemp[i]!=INF)
minTemp = min(minTemp, wTemp[i]);
MIN_W[3] = minTemp;

//乘积法
mulTemp = 1;
for(i=0; i<dimNum; i++)
if(wTemp[i]!=INF)
mulTemp = mulTemp*wTemp[i];
MUL_W[3] = mulTemp;


}




//第5条规则
void rule5()
{
int i;
double minTemp;
double mulTemp;
double wTemp[dimNum];

for(i=0; i<dimNum; i++)
wTemp[i] = INF;

wTemp[0] = sqrtf(fun1(yieldPerMu));
wTemp[1] = sqrtf(fun2(cost));
wTemp[2] = sqrtf(fun3(useWork));
wTemp[3] = sqrtf(1-fun4(netIncome));
wTemp[4] = sqrtf(1-fun5(soil));
evaluate[4] = 1;

//将隶属度过低的归为0
for(i=0; i<dimNum; i++)
if(wTemp[i]<DEF)
wTemp[i] = 0;


//取小法
minTemp = INF;
for(i=0; i<dimNum; i++)
if(wTemp[i]!=INF)
minTemp = min(minTemp, wTemp[i]);
MIN_W[4] = minTemp;

//乘积法
mulTemp = 1;
for(i=0; i<dimNum; i++)
if(wTemp[i]!=INF)
mulTemp = mulTemp*wTemp[i];
MUL_W[4] = mulTemp;

}




//亩产隶属度函数
double fun1(double x)
{


if(x<=1500)
return 0;


if(x>1500 && x<=2000)
return ((x-1500)/500)*((x-1500)/500);


if(x>2000)
return 1;
}




//费用隶属度函数
double fun2(double x)
{
if(x<=4)
return 0;


if(x>4 && x<=7)
return ((x-4)/3)*((x-4)/3);


if(x>7)
return 1;
}


//用工隶属度函数
double fun3(double x)
{
if(x<=25)
return 0;

if(x>25 && x<=50)
return ((x-25)/25)*((x-25)/25);

if(x>50)
return 1;


}


//收入隶属度函数
double fun4(double x)
{
if(x<=90)
return 0;

if(x>90 && x<=120)
return ((x-90)/30)*((x-90)/30);

if(x>120)
return 1;
}


//肥力隶属度函数
double fun5(double x)
{
if(x<=0)
return 0;


if(x>0 && x<=5)
return (x/5)*(x/5);


if(x>5)
return 1;
}