模糊综合评判里面的综合评判值怎么算

发布网友 发布时间：2022-04-26 23:58

我来回答

共1个回答

热心网友 时间：2022-06-20 17:42

模糊综合评价法

模糊综合评价法（fuzzy comprehensive evaluation method）

什么是模糊综合评价法

模糊综合评价法是一种基于模糊数学的综合评标方法。该综合评价法根据模糊数学的隶属度理论把定性评价转化为定量评价，即用模糊数学对受到多种因素制约的事物或对象做出一个总体的评价。它具有结果清晰,系统性强的特点,能较好地解决模糊的、难以量化的问题,适合各种非确定性问题的解决。

模糊综合评价法的术语及其定义

为了便于描述，依据模糊数学的基本概念，对模糊综合评价法中的有关术语定义如下：

1．评价因素（F）：系指对招标项目评议的具体内容（例如，价格、各种指标、参数、规范、性能、状况，等等）。

为便于权重分配和评议，可以按评价因素的属性将评价因素分成若干类（例如，商务、技术、价格、伴随服务，等），把每一类都视为单一评价因素，并称之为第一级评价因素（F1）。第一级评价因素可以设置下属的第二级评价因素（例如，第一级评价因素“商务”可以有下属的第二级评价因素：交货期、付款条件和付款方式，等）。第二级评价因素可以设置下属的第*评价因素（F3）。依此类推。

2．评价因素值（Fv）：系指评价因素的具体值。例如，某投标人的某技术参数为120，那么，该投标人的该评价因素值为120。

3．评价值（E）：系指评价因素的优劣程度。评价因素最优的评价值为1（采用百分制时为100分）；欠优的评价因素，依据欠优的程度，其评价值大于或等于零、小于或等于1（采用百分制时为100分），即0≤E≤1（采用百分制时0≤E≤100）。

4．平均评价值（Ep）：系指评标委员会成员对某评价因素评价的平均值。

平均评价值（Ep）＝全体评标委员会成员的评价值之和÷评委数

5．权重（W）：系指评价因素的地位和重要程度。

第一级评价因素的权重之和为1；每一个评价因素的下一级评价因素的权重之和为1 。

6．加权平均评价值（Epw）：系指加权后的平均评价值。

加权平均评价值（Epw）＝平均评价值（Ep）×权重（W）。

7．综合评价值（Ez）：系指同一级评价因素的加权平均评价值（Epw）之和。综合评价值也是对应的上一级评价因素的值。

模糊综合评价法的特点

模糊综合评价法的最显著特点是：

一、相互比较。以最优的评价因素值为基准，其评价值为1；其余欠优的评价因素依据欠优的程度得到响应的评价值。

二、可以依据各类评价因素的特征，确定评价值与评价因素值之间的函数关系（即：隶属度函数）。确定这种函数关系（隶属度函数）有很多种方法，例如，F统计方法，各种类型的F分布等。当然，也可以请有经验的评标专家进行评价，直接给出评价值。

模糊综合评价法的一个应用案例

财政部文件《财政部关于加强*采购货物和服务项目价格评审管理的通知》（财库[2007]2号）中规定：

“综合评分法中的价格分统一采用低价优先法计算，即满足招标文件要求且投标价格最低的投标报价为评标基准价，其价格分为满分。其他投标人的价格分统一按照下列公式计算：

投标报价得分=（评标基准价／投标报价）×价格权值×100”

我们可以看到，上述规定有如下特征：

1．相互比较。将投标价格最优的设置为评标基准价，其评价值为1（采用百分制时，为100分）；其它的投标报价均与该评标基准价比较，得出响应的评价值（分值）。

评价值（投标报价得分）＝评标基准价÷投标报价（如果采用百分制，×100）。注意，这里得出的是加权前的评价值（分值）。

2．评价值与评价因素值之间的关系是函数关系（在这里用的是反比例函数关系，如果有更科学更合理的函数关系，也可用其它函数关系）。

说明：在这里，价格是评价（标）因素；投标人的具体投标报价称为评价因素值；对投标人的投标报价计算得分称为评价值。

实际上，财政部的上述规定在有意无意中应用了模糊数学的基本概念，是模糊综合评价法的应用。世界银行咨询服务评标也应用该方法。

既然评价因素“价格”可以采用这种评价方法，其它的评价因素也可以采用这种评价方法。

---------------------

----------------------

模糊综合评判算法 C语言版本

2008-01-05 22:24

本算法评价集个数为5，评价因子个数为6，采用超标加权法计算权重，线性降半阶隶属函数

#include <stdio.h>

#define MatrixRows 5
#define MatrixCols 6
double CalculateAverage(int m,double  a[MatrixRows][MatrixCols])    //计算平均值,m表示第m列的平均值
{
double myResult;
int i;

myResult=0;
for(i=0;i<MatrixRows;i++)
{
myResult+=a[i][m];
}
myResult=myResult/MatrixRows;

// printf("%lf\n",myResult);

return myResult;
}

double EWeight(int m,double a[MatrixRows][MatrixCols],double  b[MatrixCols]) //计算权重数组E,m为第m列的权重值
{
double Aver[MatrixCols] ; //m个含水层同一评价因子的平均值
double EResult; //计算权重结果
double ETotal;      //归一划权重和
int i;
for(i=0;i<MatrixCols;i++)
{
Aver[i]=CalculateAverage(i,a);
}
ETotal=0;
for(i=0;i<MatrixCols;i++)
{
ETotal+=(b[i]/Aver[i]);
}

EResult=(b[m]/Aver[m])/ETotal;
return EResult;
}

double Sort(int m,int n,double a[MatrixRows][MatrixCols])
{
double b[MatrixRows][MatrixCols];      //排序后的结果,对数组的每一个列中的四个数字进行从小到大排列
int  i,j,k;              //不可以直接对a[MatrixRows][MatrixCols]进行排序,因为是数组是传地址计算
for(i=0;i<MatrixRows;i++)     //
for(j=0;j<MatrixCols;j++)
b[i][j]=a[i][j];

for(j=0;j<MatrixCols;j++)
{
for(i=0;i<MatrixRows-1;i++)
for(k=i;k<MatrixRows;k++)
{
if(b[i][j]>b[k][j])      //排序
{
double tmp;
tmp=b[i][j];
b[i][j]=b[k][j];
b[k][j]=tmp;
}
}
}
return b[m][n];
}

double Lishu(int m,int n,double a[MatrixRows][MatrixCols],double  b[MatrixCols])     //计算当前样本b[MatrixCols]对各个评价因子的隶属度
{
double c[MatrixRows][MatrixCols];                      //排序后的结果
double  LSDResult[MatrixCols][MatrixRows];              //隶属度计算结果,即评价集与评价因子的关系矩阵
int i,j,k;
for(i=0;i<MatrixRows;i++)
for(j=0;j<MatrixCols;j++)
{
c[i][j]=Sort(i,j,a);         //排序
}
for(j=0;j<MatrixCols;j++)
{
for(i=0;i<MatrixRows;i++)
{
for(k=0;k<MatrixRows;k++)
{
if(a[i][j]==c[k][j])
{
if(k==0)
{
if(b[j]<c[k][j])
LSDResult[j][i]=1;
if(b[j]>=c[k][j]&&b[j]<c[k+1][j])
LSDResult[j][i]=((c[k+1][j]-b[j])/(c[k+1][j]-c[k][j]));
if(b[j]>=c[k+1][j])
LSDResult[j][i]=0;
}
if(k==1||k==2||k==3)
{
if(b[j]<c[k-1][j])
LSDResult[j][i]=0;
if(b[j]>=c[k-1][j]&&b[j]<c[k][j])
LSDResult[j][i]=((b[j]-c[k-1][j])/(c[k][j]-c[k-1][j]));
if(b[j]>=c[k][j]&&b[j]<c[k+1][j])
LSDResult[j][i]=((c[k+1][j]-b[j])/(c[k+1][j]-c[k][j]));
if(b[j]>=c[k+1][j])
LSDResult[j][i]=0;
}
if(k==4)
{
if(b[j]<c[k-1][j])
LSDResult[j][i]=0;
if(b[j]>=c[k-1][j] &&  b[j]<c[k][j])
LSDResult[j][i]=((b[j]-c[k-1][j])/(c[k][j]-c[k-1][j]));
if(b[j]>=c[k][j])
LSDResult[j][i]=1;
}
}
}

}
}
return LSDResult[m][n];
}

double FuzzyEvalution(int x,int m,int n,double  a[MatrixRows][MatrixCols],double b[MatrixCols])
{
double E[MatrixCols];       //超标加权法计算权重
double R[MatrixCols][MatrixRows];    //评价集与评价因子关系矩阵
double FEResult[MatrixRows];//最终计算对各个评价集的隶属度
int i,j;
for(i=0;i<MatrixCols;i++)
for(j=0;j<MatrixRows;j++)
{
R[i][j]=Lishu(i,j,a,b); //函数参数a[MatrixRows][MatrixCols]，得到的计算结果为MatrixCols  X MatrixRows矩阵
}
for(i=0;i<MatrixCols;i++)
{
E[i]=EWeight(i,a,b);
}

for(i=0; i<MatrixRows;i++)
{
FEResult[i]=0;
for(j=0;j<MatrixCols;j++)
{
FEResult[i]+=E[j]*R[j][i];
}
}

return FEResult[x];
}

void main()
{
double a[MatrixRows][MatrixCols];       //保存评价集标注值
double b[MatrixCols];           //保存待测出水点水样的值
double  myResult[MatrixRows];           //保存计算结果
double myweight[MatrixCols];   //计算权重的结果
double mysort[MatrixRows][MatrixCols]; //排序结果
double myLiShuDu[MatrixCols][MatrixRows];//评判集和评判因子的关系矩阵
int i,j;
//////////////////////////////////////////////////////////////////////////
printf("请输入评判集标准值:\n");
for(i=0;i<MatrixRows;i++)
{
printf("请输入评判集 %d 的标准值:\n",i+1);
for(j=0;j<MatrixCols;j++)
{
scanf("%lf",&a[i][j]);
}
}

printf("评判集标准值输出：\n");
for(i=0;i<MatrixRows;i++)
{
for(j=0;j<MatrixCols;j++)
printf("%lf, ",a[i][j]);
printf("\n");
}

printf("请输入出水点水样的值:\n");
for(i=0;i<MatrixCols;i++)
{
scanf("%lf",&b[i]);
}
////////////////////////////////////////////////////////////////////////////
for(i=0;i<MatrixCols;i++)       //计算权重数组
{
myweight[i]=EWeight(i,a,b);
}
printf("输出一维数组权重值:\n");
for(j=0;j<MatrixCols;j++)          //输出权重一维数组
printf("%lf\n",myweight[j]);
/////////////////////////////////////////////////////////////////////////

for(i=0;i<MatrixRows;i++)        //计算a[MatrixRows][MatrixCols]每一列中的四个数字排序（为计算隶属函数，隶属度准备）
{
for(j=0;j<MatrixCols;j++)
{
mysort[i][j]=Sort(i,j,a);
}
}
printf("输出a[MatrixRows][MatrixCols]每一列中的四个数字排序后的结果:\n");
for(i=0;i<MatrixRows;i++)        //输出a[MatrixRows][MatrixCols]每一列中的四个数字排序后的结果
{
for(j=0;j<MatrixCols;j++)
{
printf("%lf,    ",mysort[i][j]);
}
printf("\n");
}
/////////////////////////////////////////////////////////////////////////
printf("评判集和评判因子的关系矩阵:\n");
for(i=0;i<MatrixCols;i++)
for(j=0;j<MatrixRows;j++)
{
myLiShuDu[i][j]=Lishu(i,j,a,b);
}
for(i=0;i<MatrixCols;i++)
{
for(j=0;j<MatrixRows;j++)
{
printf("%lf, ",myLiShuDu[i][j]);
}
printf("\n");
}
/////////////////////////////////////////////////////////////////////////
for(i=0;i<MatrixRows;i++)
{
myResult[i]=FuzzyEvalution(i,MatrixRows,MatrixCols,a,b); //模糊综合评判
}
printf("以下为运算结果:\n");
for(i=0;i<MatrixRows;i++)
{
printf("%lf, \n",myResult[i]);
}
}