模糊聚类算法的C语言实现六Word下载.docx

模糊聚类算法的C语言实现六Word下载.docx

《模糊聚类算法的C语言实现六Word下载.docx》由会员分享，可在线阅读，更多相关《模糊聚类算法的C语言实现六Word下载.docx（19页珍藏版）》请在冰豆网上搜索。

第i类包含的素数（i=1,2,…,num）

//Mark[j]：

第j个样本相应的组号（j=1,2,…,n）

//Classify[i][j]：

第i类包含的第j素的下标

intn,m,ossible;

doublex[N][M],cArr[N][N],zero[M];

//x:

每个对象由一组特征数据表征,cArr:

存储模糊相似（等价）矩阵

doublecoycArr[N][N];

//zero:

辅助量每个指标均为零coycArr:

传递闭包法中的中转矩阵

intcBoolArr[N][N];

//取阈值limitLine的截关系存储至cBoolArr

doublecenter[N][M],overallcenter[M];

//center:

聚类中心overallcenter:

总体样本的中心向量

doubleA0[N][M],A1[N][M],v[N][M];

//A0:

c-模糊划分矩阵A1:

迭代所得c-模糊划分矩阵v:

聚类中心矩阵

DATAgrou[L],otGrou,reviseGrou;

//grou[L]:

对于每一个阈值limitLine有一个分类otGrou:

最优分类

//reviseGrou:

ISODATA修正后得到的分类

voidinut（）//输入样本数据

inti,j;

scanf（&

quot;

%d%d&

&

am;

n,&

m）;

//n:

样本个数m:

每个样本的特征

for（i=1;

i&

=n;

i++）

for（j=1;

j&

=m;

j++）

%lf&

x[i][j]）;

//具体数据输入

return;

}

voidinitial（）//设置辅助量zero方便直接利用距离公式求得cArr初始值

intk;

for（k=1;

k&

k++）

zero[k]=0;

doubledistance2（doublea[],doubleb[]）//求向量a,b之间的距离

doubledis;

dis=0;

dis+=（a[k]-b[k]）*（a[k]-b[k]）;

returndis;

voidcreat_conformArr（）//建立模糊相似矩阵

inti,j,k;

intnegative=0;

//指示所得矩阵是否含有负值

doubledis_to_origin[N],tem;

dis_to_origin[i]=sqrt（distance2（x[i],zero））;

i++）//夹角余弦法确定x[i]与x[j]的相似程度cArr[i][j]

tem=0;

tem+=x[i][k]*x[j][k];

cArr[i][j]=tem/（dis_to_origin[i]*dis_to_origin[j]）;

if（cArr[i][j]&

0）

negative=1;

break;

if（negative）//若cArr中出现负值则将矩阵全体重新调整为非负

cArr[i][j]++;

cArr[i][j]/=2;

voidenclosure_algorithm（）//传递闭包法求模糊等价矩阵

intunchanged=0;

//判断是否求得传递闭包

doublemergeVal;

while（unchanged==0）

unchanged=1;

i++）//矩阵之间的自乘算

法

mergeVal=0;

if（cArr[i][k]&

=cArr[k][j]&

&

cArr[i][k]&

mergeVal）

mergeVal=cArr[i][k];

elseif（cArr[i][k]&

cArr[k][j]&

mergeVal=cArr[k][j];

if（mergeVal&

cArr[i][j]）

coycArr[i][j]=mergeVal;

unchanged=0;

else

coycArr[i][j]=cArr[i][j];

cArr[i][j]=coycArr[i][j];

voidaroximate_closure（）//简化模糊等价矩阵

cArr[i][j]=floor（cArr[i][j]*10+0.5）/10;

//每个四舍五入到小数点第一位

inttwo_ower（int）//求2的整数次幂

inti,add;

add=1;

=;

add*=2;

returnadd;

voidcluster（）//基于传递闭包的聚类过程

doublelimitLine,limitSte,minLimit;

intgrouNum;

intcmArr[N],grouIndentify[N],grouDelegate[N];

intflag,count;

inttem;

grouNum=1;

limitLine=1;

//聚类阈值起始值

limitSte=0.1;

//聚类阈值步长

minLimit=0.1;

//聚类阈值下限

k=0;

while（limitLine&

=minLimit）

k++;

limitLine||fabs（cArr[i][j]-limitLine）&

1e-5）

cBoolArr[i][j]=1;

//凡是cArr[i][j]&

=limitLine的位置在0-1矩阵中均置1

cBoolArr[i][j]=0;

//而cArr[i][j]&

limitLine的位置置为0

tem+=cBoolArr[i][j]*two_ower（i-1）;

cmArr[j]=tem;

//cmArr:

将各列的值用唯一的二进制数表示方便比较

}

grouIndentify[1]=1;

//当前该轮聚类分析中各素所在的组号

grouDelegate[1]=1;

//当前该轮聚类分析中各组的代表素

//当前该轮聚类分析中的分类数即最大组号

for（i=2;

i++）//算法的主要部分

flag=0;

//当前素是否属于已分出的组

for（count=1;

count&

=grouNum;

count++）//如果当前的素属于已分出的组则并出其所在的组

if（cmArr[grouDelegate[count]]==cmArr[i]）

grouIndentify[i]=count;

flag=1;

if（flag==0）//如果当前的素不属于任何一份出的组则将其置入新组并选该作为新组的代表

grouNum++;

grouDelegate[grouNum]=i;

grouIndentify[i]=grouNum;

grou[k].line=limitLine;

//对于每个聚类阈值确定其分组情况并存入相应grou[k]

grou[k].num=grouNum;

grou[k].mark[j]=grouIndentify[j];

grou[k].contain[i]=0;

if（grouIndentify[j]==i）

grou[k].classify[i][++grou[k].contain[i]]=j;

if（grouNum==1）

limitLine-=limitSte;

ossible=k;

voidredigest_grou（）//将相同的分组并入一个情况使grou[1]~grou[ossible]为互不相同的分组

intflag;

;

j=i+1;

if（j&

ossible）

while（grou[i].num==grou[j].num）

j++;

if（flag）

for（k=j;

=ossible;

grou[k-j+i+1]=grou[k];

ossible=ossible-j+i+1;

if（i==ossible-1）

doubleF_stat（DATAtemGrou）//计算聚类temGrou的F-统计量方法

doubleabove,below;

=temGrou.num;

{//第i类的聚类中心向量

center[i][k]=0;

=temGrou.contain[i];

center[i][k]+=x[temGrou.classify[i][j]][k];

center[i][j]/=temGrou.contain[i];

k++）//总体样本的中心向量

overallcenter[k]=0;

overallcenter[k]+=x[j][k];

overallcenter[k]/=n;

if（temGrou.num==1||temGrou.num==n）

return0;

//求F值

above=0;

//above:

分子表征类与类之间的距离

above+=temGrou.contain[i]*distance2（center[i],overallcenter）;

above/=temGrou.num-1;

below=0;

//below:

分母表征类内样本间距离

below+=distance2（x[temGrou.classify[i][j]],center[i]）;

below/=n-temGrou.num;

returnabove/below;

voidotlimitLine_select（）//确定最佳阈值

inti,ot;

doublemax;

grou[i].F=F_stat（grou[i]）;

max=0;

ot=1;

if（grou[i].F&

max）//F值越大说明分类越合理

max=grou[i].F;

ot=i;

otGrou=grou[ot];

doublematrix_model（doublea[][N],doubleb[][N],ints,intt）//求矩阵范数|a-b|s行t列

=s;

=t;

dis+=（a[i][j]-b[i][j]）*（a[i][j]-b[i][j]）;

returnsqrt（dis）;

voidISOdata（DATAtemGrou）//将temGrou作为初始值进行ISODATA迭代

intc;

inti,j,k,rn=n;

intexcet[N],judge[N];

doubletem;

intis_nonemty[N];

intcount;

c=temGrou.num;

i++）

excet[i]=0;

j=0;

if（temGrou.contain[i]==1）//对于仅有一个样本的类聚类前应该排除待聚类后再加上该类

excet[temGrou.classify[i][1]]=1;

c--;

rn--;

continue;

k++）

if（temGrou.mark[k]==i）

A0[j][k]=1;

A0[j][k]=0;

=c;

i++）//根据初始分类取初始c-模糊划分矩阵A0

if（excet[j]==0）

A0[i][k]=A0[i][j];

if（i==1）

judge[k]=j;

count=0;

while

（1）

count++;

=rn;

A1[i][j]=A0[i][j]*A0[i][j];

i++）//计算当前迭代步的聚类中心矩阵

tem+=A1[i][j];

v[i][k]=0;

v[i][k]+=A1[i][j]*x[j][k];

v[i][k]/=tem;

i++）//修正A0得到新的A1

tem+=1/distance2（x[j],v[k]）;

tem*=distance2（x[j],v[i]）;

A1[i][j]=1/tem;

if（matrix_model（A0,A1,c,rn）&

=1e-5）//判断是否达到迭代出口

A0[i][j]=A1[i][j];

if（count&

1000）

rintf（&

OverFlow\n&

）;

ste=%d\n&

count）;

j++）//将模糊划分清晰化

tem=A0[1][j];

k=1;

for（i=2;

if（A0[i][j]&

tem）

tem=A0[i][j];

k=i;

reviseGrou.mark[judge[j]]=k;

//按最大隶属度原则将x[judge[j]]归入组号为k的类

{

is_nonemty[i]=0;

//记录已分出类的样本数目

if（reviseGrou.mark[judge[j]]==i）

is_nonemty[i]++;

//由于ISODATA给出的最终划分是退化的情形因此空集也可能成为子类

）//重新调整组号使共有c组编号从1至c且每组非空

if（is_none

mty[i]==0）

if（reviseGrou.mark[judge[k]]&

i）

reviseGrou.mark[judge[k]]--;

for（j=i;

is_nonemty[j]=is_nonemty[j+1];

i++;

k=c;

//这时对应每一个组号的类都是非空的

if（excet[i]==1）//将迭代前排除的类加上

reviseGrou.mark[i]=++k;

reviseGrou.num=k;

//修正后得到的最终分类类数

//reviseGrou.mark标记在最终分类中每个样本所在的组

=reviseGrou.num;

reviseGrou.contain[i]=0;

if（reviseGrou.mark[j]==i）

reviseGrou.classify[i][++reviseGrou.contain[i]]=j;

voidoutut（）

intj,k;

%d\n&

reviseGrou.num）;

x%d&

j）;

\n&

%d&

reviseGrou.mark[j]）;

%d:

%d\n&

j,reviseGrou.contain[j]）;

=reviseGrou.contain[j];

reviseGrou.classify[j][k]）;

intmain（）

freoen（&

in.txt&

r&

stdin）;

out.txt&

w&

stdout）;

inut（）;

//读入数据

initial（）;

//初始化

creat_conformArr（）;

//建立模糊相似矩阵

enclosure_algorithm（）;

//求其传递闭包

aroximate_closure（）;

//将得到的模糊等价矩阵的素四舍五入到一位小数

cluster（）;

//对阈值为00.1~0.91的情形做聚类

redigest_grou（）;

//简化分组使其不出现重复的分类方案