int main()
{
int i;
for (i = 0; i < 256; i++)
chartest[i].c = i;
chartest[0].c = 0; /* chartest-done */
Fun1(foo1);
Fun2(foo2);
Fun3(foo3);
Fun4(foo4);
Fun5(foo5);
Fun6(foo6);
Fun7(foo7);
Fun8(foo8);
Fun9(foo9);
Fun10(foo10);
Fun11(foo11);
Fun12(foo12);
Fun13(foo13);
Fun14(foo14);
Fun15(foo15);
Fun16(foo16);
Fun17(foo17);
Fun18(foo18);
/* An (almost-)infinite loop that first clears all the variables and then
calls each function. This "hack" is to make testing random
functions easier - "advance funN" is guaranteed to have always
been preceded by a global variable clearing zed call.
We don't let this run forever in case gdb crashes while testing,
we don't want to be left eating all cpu on the user's system. */
for (i = 0; i < 1000000; ++i)
{
zed ();
L1 = fun1();
L2 = fun2();
L3 = fun3();
L4 = fun4();
L5 = fun5();
L6 = fun6();
L7 = fun7();
L8 = fun8();
L9 = fun9();
L10 = fun10();
L11 = fun11();
L12 = fun12();
L13 = fun13();
L14 = fun14();
L15 = fun15();
L16 = fun16();
L17 = fun17();
L18 = fun18();
}
return 0;
}
int main()
{
srand((unsigned)time(NULL));
/*
Generic & Procedural Vars
*/
int i, j, k, l, vfun, vtest, vgen;
double edge, Vmax, goal, gb;
/*
Vars for Radius
*/
float absRadius; // Absolute perceptive radius
float relRadius; // A iteration var for radius
/*
Vars for Real-time Recording
*/
int adjmat[N][N]; // Adjacent Matrix
int sucCounter;
int radRec; // A var to count the index of the radius
/*
Vars for Storage Section
*/
double AveOptGen[relRange]; // Average number of generations of success optimization
double AveOptRate[relRange]; // Ratio of success tests/ total tests
double AveEndFit[relRange]; // End fit
double AveSucFit[relRange];// SUCCESSFUL EndFit The average of the gbest fitness in the end of each SUCCESSFUL test (last generation)
double FIndex[relRange], recordInd[testnum];
/* End of Storage Section */
/*
Initialization of some variables
*/
for(i=0; i<relRange; i++)
{
AveOptGen[i]=0;
AveOptRate[i]=0;
AveSucFit[i]=0;
AveEndFit[i]=0;
FIndex[i]=99; // Just a dummy and impossible value
}
pso = fopen("../../vicfdrpso.txt", "a+"); // We cannot use 'w' on the server in the lab in lack of privileges.
vfun=2;
switch(vfun)
{
case 1:
edge = 100;
Vmax = edge;
goal = 0.01;
break;
case 2:
edge = 30;
Vmax = edge;
goal = 100;
break;
case 3:
edge = 5.12;
Vmax = edge;
goal = 100;
break;
case 4:
edge = 600;
Vmax = edge;
goal = 0.1;
break;
default:
edge = 100;
Vmax = edge;
goal = 0.01;
}
radRec=0;
for(relRadius=relStart; relRadius<relEnd; relRadius+=relStep) // Loop layer 1 (relRadius)
{
sucCounter = 0;
for(vtest = 0; vtest < testnum; vtest++)
{
int sum = 1;
for(i = 0; i < coornum; i++)
{
pbest[i] = INT_MAX;
gbest[i] = INT_MAX;
}
for(i = 0; i < dim + 1; i++) //Initialization
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
coor[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * edge - edge;
vel[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * Vmax - Vmax;
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
//printf("%f\t", coor[(dim+1)*j+i]);
}
else
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
//printf("\n%d:%f,", j, coor[(dim+1)*j+i]);
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
}
}
}
absRadius = relRadius * sqrt(dim * pow(2 * edge , 2));
for(j=0; j<N; j++)
for(k=0; k<N; k++) // Avoid Relapse
{
if( getDistance(j,k) <= absRadius && j!=k ) // k Can be perceived by j
{
adjmat[j][k]=1;
}
else
{
adjmat[j][k]=0;
}
}
// Updating each bird's gbest:
for(j=0; j<N; j++)
{
for(k=0; k<N; k++)
if( adjmat[j][k] != 0 ) // k Can be perceived by j
{
// Updating the gbest of j
//printf("%f\t",getDistance(j,k));
if( coor[(dim+1)*k+dim] < gbest[(dim+1)*j+dim] )
{
for(l=0; l<=dim; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*k+l];
}
}
//printf("gbest of %d:%f\nfitness of %d:%f\n",j,gbest[(dim+1)*j+dim],j,coor[(dim+1)*j+dim]);
}
gb = gbest[dim]; // Updating the global gbest
for(i = 1; i < N; i++)
if(gbest[(dim+1)*i+dim] < gb)
gb = gbest[(dim+1)*i+dim];
//End of initialization
for(vgen = 0; vgen < gennum; vgen++) //gennum´ú½ø»¯£»
{
float inert_w;
inert_w=(wmax-wmin)*(gennum-vgen-1)/(gennum+wmin);
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
int lneigh; // The neighbor for the particle to learn from
lneigh=findNeigh_fdr(j,i);
double r1 = (double)rand() / RAND_MAX * 1;
double r2 = (double)rand() / RAND_MAX * 1;
double r3 = (double)rand() / RAND_MAX * 1;
vel[(dim+1)*j+i] = inert_w * vel[(dim+1)*j+i] + c1 * r1 * (pbest[(dim+1)*j+i] - coor[(dim+1)*j+i])\
+ c2 * r2 * (gbest[(dim+1)*j+i] - coor[(dim+1)*j+i])+ c3 * r3 * (pbest[(dim+1)*lneigh+i] - coor[(dim+1)*j+i]);
//vel[(dim+1)*j+i] = getMin( getMax(vel[(dim+1)*j+i],(-Vmax) ),Vmax);
coor[(dim+1)*j+i] += vel[(dim+1)*j+i]; // Moving
//coor[(dim+1)*j+i] = getMin( getMax(coor[(dim+1)*j+i], (-edge) ) ,edge);
}
else
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
// When i = dim, updating pbest:
if(coor[(dim+1)*j+i] < pbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
pbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
// Comparing itself with gbest:
if(coor[(dim+1)*j+i] < gbest[(dim+1)*j+i])
{
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
}
} // End of else
} // for birds
} // for dims
absRadius = relRadius * sqrt(dim * pow(2 * edge , 2));
// Producing the initiating Adjacent Matrix
for( j=0; j<N ; j++ )
for( k=0; k<N; k++) // Avoid Relapse
{
if( getDistance(j,k) <= absRadius && j!=k ) // k Can be perceived by j
{
adjmat[j][k]=1;
}
else
{
adjmat[j][k]=0;
}
}
// Updating each bird's gbest:
for( j=0; j<N ; j++ )
{
for( k=0; k<N ; k++ )
if( adjmat[j][k] != 0 ) // k Can be perceived by j
// Updating the gbest of j
if( coor[(dim+1)*k+dim] < gbest[(dim+1)*j+dim] )
for(l=0; l<=dim; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*k+l];
//printf("gbest of %d:%f\nfitness of %d:%f\n",j,gbest[(dim+1)*j+dim],j,coor[(dim+1)*j+dim]);
}
// End of Updating each bird's gbest
gb = gbest[dim]; // Updating the global gbest
for(i = 1; i < N; i++)
if(gbest[(dim+1)*i+dim] < gb)
gb = gbest[(dim+1)*i+dim];
if(gb < goal && sum != 0)
{
sum = 0; // Change the flag
//ngoal++;
sucCounter += 1;
AveOptGen[radRec] += vgen;
printf("suc gb:%1.15f\n",gb);
}
if(vgen+1 == 1000)
recordInd[vtest]=gb;
if(vgen == gennum - 1)
{
printf("last gb:%1.15f\n",gb);
AveEndFit[radRec] += gb;
if(sum == 0) // Succeeded
AveSucFit[radRec] += gb;
}
} // End of for VGEN!
} // End of vtest
FIndex[radRec]=countFIndex(recordInd);
AveEndFit[radRec] = AveEndFit[radRec]/testnum;
if(sucCounter!=0) // If succeeded
{
AveSucFit[radRec] = AveSucFit[radRec]/sucCounter;
AveOptGen[radRec] = AveOptGen[radRec]/sucCounter;
}
else
{
AveSucFit[radRec] = -1; // A flag to show the failure
AveOptGen[radRec] = -1; // A flag to show the failure
}
AveOptRate[radRec]=(double) sucCounter / testnum * 100;
printf("%1.15f,%1.15f,%f,%f,%f\n",AveEndFit[radRec],AveSucFit[radRec],AveOptGen[radRec],AveOptRate[radRec],FIndex[radRec]);
fprintf(pso,"%1.15f,%1.15f,%f,%f,%f\n",AveEndFit[radRec],AveSucFit[radRec],AveOptGen[radRec],AveOptRate[radRec],FIndex[radRec]);
// AveSucFit is the Average Endfit for only successful runs
radRec++;
printf("\n\nRadius %d is tested\n\n",radRec);
} // End of Loop layer 1 (relRadius)
printf("\n\n Done! You got it, dude!");
fclose(pso);
return 0;
}
int main()
{
//printf("a");
srand((unsigned)time(NULL));
int i, j, l, vfun, vtest, vgen, vlneighs;
float x, edge, Vmax, goal, gb, res = 0,avggennew=0;
float vel[coornum], results[2*testnum], stdindex[N-1];
int sucCounter;
// vlneighs:The number of neighbors a paricle learns from (self-excluded)
float AveEndFit[4];
float AveAllFit[4];
//Storage
float Sto_SucEndFit[N-1]; // N-1 circumstances
float Sto_SucGens[N-1];
float Sto_SucRate[N-1];
for(i=0;i<N-1;i++){
Sto_SucEndFit[i]=-1;
Sto_SucGens[i]=-1;
Sto_SucRate[i]=-1;
}
pso = fopen("lipso2.3-all-f2.txt", "a+");
//fprintf(pso, "num\tw\tc1\tc2\tfuncnum\tavggen\tratio\tfinalresult\n");
x = 0.7298;
for(vlneighs =0; vlneighs< N-1; vlneighs++)
{
fprintf(pso, "lneighs:%d\n",vlneighs);
for(i = 0; i < 4; i++){
AveAllFit[i]=0;
AveEndFit[i]=0;
}
for(vfun = 2; vfun < 3; vfun++)
{
for(i = 0; i < testnum; i++)
{
results[2*i] = gennum;
results[2*i+1] = 0;
}
if(vfun == 1)
{
edge = 100;
Vmax = edge;
goal = 0.01;
}
if(vfun == 2)
{
edge = 30;
Vmax = edge;
goal = 100;
}
if(vfun == 3)
{
edge = 5.12;
Vmax = edge;
goal = 100;
}
if(vfun == 4)
{
edge = 600;
Vmax = edge;
goal = 0.1;
}
int ngoal = 0, avggen = 0;
sucCounter = 0;
for(vtest = 0; vtest < testnum; vtest++)
{
int sum = 1;
for(i = 0; i < coornum; i++)
{
pbest[i] = INT_MAX;
}
for(i = 0; i < dim + 1; i++) //粒子初始化；
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
coor[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * edge - edge;
vel[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * Vmax - Vmax;
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
//printf("%f\t", coor[(dim+1)*j+i]);
}
else
{
// i=dim
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
//printf("\n%d:%f,", j, coor[(dim+1)*j+i]);
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
}
}
}
/*
int gbp;
gb = pbest[dim];
for(i = 1; i < N; i++)
if(pbest[(dim+1)*i+dim] < gb)
{
gb = pbest[(dim+1)*i+dim];
gbp = i;
}
*/
for(vgen = 0; vgen < gennum; vgen++) //gennum代进化；
{
// Finding gbest
double tempgb=pbest[dim];
int gbindex=0;
for( i = 1; i < N; i++)
if(pbest[(dim+1)*i+dim]<tempgb ){
tempgb=pbest[(dim+1)*i+dim];
gbindex=i;
}
get_vel_update(vlneighs, gbindex);
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
//double r1=(double)rand() / RAND_MAX;
//double r2=(double)rand() / RAND_MAX;
//vel[(dim+1)*j+i] = x * ( vel[(dim+1)*j+i] + phi*( r1*( pbest[(dim+1)*gbp+i]-coor[(dim+1)*j+i]) + r2*(pbest[(dim+1)*j+i]-coor[(dim+1)*j+i]) )/2 );
//vel[(dim+1)*j+i] = x * ( vel[(dim+1)*j+i] + 2.05*r1*(pbest[(dim+1)*j+i]-coor[(dim+1)*j+i])+2.05*r2*(pbest[(dim+1)*gbp+i]-coor[(dim+1)*j+i]));
vel[(dim+1)*j+i] = x * (vel[(dim+1)*j+i]+update[(dim+1)*j+i]);
coor[(dim+1)*j+i] += vel[(dim+1)*j+i];
}
else
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
if(coor[(dim+1)*j+i] < pbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
pbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
}
}
}
gb = pbest[dim];
for(i = 1; i < N; i++)
if(pbest[(dim+1)*i+dim] < gb)
{
gb = pbest[(dim+1)*i+dim];
//gbp = i;
}
//printf("\ngb:%f\n",gb);
if(gb < goal && sum != 0)
{
results[2*vtest] = (double)vgen;
results[2*vtest+1] = gb;
sum = 0;
//ngoal++;
printf("\ngb:%f,%d\t",gb,vgen);
sucCounter+=1;
}
if(vgen == 1000)
{
stdindmemo[vtest]=gb;
printf("\nvtest:%d,1000gen's gb:%1.30f\n",vtest,gb);
}
if(vgen == gennum - 1)
{
printf("lastgb:%f\n",gb);
AveAllFit[vfun-1] += gb;
if(sum == 0) // Succeeded
AveEndFit[vfun-1] += gb;
else
results[2*vtest] = vgen;
}
} // End of for VGEN!
} // End of for VTEST !
//Calculating the Standard Index
double avememofit=0;
for(i=0; i<testnum; i++)
avememofit+=stdindmemo[i];
avememofit/=testnum;
double delta=0;
for(i=0; i<testnum; i++)
delta += pow((stdindmemo[i]-avememofit),2);
delta = sqrt(delta/testnum);
double tempmemeo, median;
for(i=0; i<testnum-1; i++)
for(j=i+1; j<testnum; j++)
if(stdindmemo[i]>stdindmemo[j])
{
tempmemeo = stdindmemo[i];
stdindmemo[i] = stdindmemo[j];
stdindmemo[j] = tempmemeo;
}
if(testnum%2 == 0)
{
median = (stdindmemo[testnum/2]+stdindmemo[testnum/2+1])/2;
printf("\nmedian:%f; %f,%f",median,stdindmemo[testnum/2],stdindmemo[testnum/2+1]);
}
else
median = stdindmemo[testnum/2+1];
stdindex[vlneighs] = (median - avememofit)/delta;
printf("\nstdindex[vlneighs]%f",stdindex[vlneighs]);
if(sucCounter!=0){
Sto_SucEndFit[vlneighs]=AveEndFit[vfun-1]/sucCounter;
// fprintf(pso,"\n\n\nLast succeeded average gb fitness:%1.30f\n",AveEndFit[vfun-1]/sucCounter);
}
else
printf("\n\n\nLast succeeded average gb fitness: U gotta be kidding, man!\n");
for(i = 0; i < testnum; i++)
{
if(results[2*i] != gennum - 1)
{
ngoal++;
avggen += results[2*i];
res += results[2*i+1];
}
}
printf("%d,%d", avggen/vtest, ngoal);
if(ngoal == 0) // Unsuccessful
avggennew = (double)gennum - 1;
else
avggennew = (double)avggen / ngoal;
fprintf(pso, "AveGen,%f,SucRate,%f,SucEndFit,%f,LastFit,%f,StdIndex,%f\n", avggennew, (double)sucCounter/testnum*100,Sto_SucEndFit[vlneighs],AveAllFit[vfun-1]/testnum,stdindex[vlneighs]);
printf("\nAveGen,%f,SucRate,%f,SucEndFit,%f,LastFit,%f,StdIndex,%f\n", avggennew, (double)sucCounter/testnum*100,Sto_SucEndFit[vlneighs],AveAllFit[vfun-1]/testnum,stdindex[vlneighs]);
Sto_SucGens[vlneighs]=avggennew;
Sto_SucRate[vlneighs]=(double)sucCounter / testnum * 100;
} // End of for VFUN!
} // End of for vlneighs!
fclose(pso);
pso = fopen("lipso2.3-all-f2-SucEndFit.txt", "a+");
for(i=0;i<N;i++)
fprintf(pso,"%d,%1.30f\n",i+1,Sto_SucEndFit[i]);
fclose(pso);
pso = fopen("lipso2.3-all-f2-SucGens.txt", "a+");
for(i=0;i<N;i++)
fprintf(pso,"%d,%f\n",i+1,Sto_SucGens[i]);
fclose(pso);
pso = fopen("lipso2.3-all-f2-SucRate.txt", "a+");
for(i=0;i<N;i++)
fprintf(pso,"%d,%f\n",i+1,Sto_SucRate[i]);
fclose(pso);
}
int main()
{
srand((unsigned)time(NULL));
/*
Generic & Procedural Vars
*/
int i, j, k, l, vfun, vtest, vgen;
double edge, Vmax, goal, gb;
double vel[coornum], pbest[coornum], gbest[coornum];
/*
Vars for Real-time Recording
*/
int sucCounter;
/*
Vars for Storage Section
*/
double AveOptGen; // Average number of generations of success optimization
double AveOptRate; // Ratio of success tests/ total tests
double AveEndFit; // End fit
double AveSucFit;// SUCCESSFUL EndFit The average of the gbest fitness in the end of each SUCCESSFUL test (last generation)
double FIndex, recordInd[testnum];
/* End of Storage Section */
/*
Initialization of some variables
*/
AveOptGen=0;
AveOptRate=0;
AveSucFit=0;
AveEndFit=0;
FIndex=99; // Just a dummy and impossible value
pso = fopen("../../cpso.txt", "a+"); // We cannot use 'w' on the server in the lab in lack of privileges.
vfun=2;
switch(vfun)
{
case 1:
edge = 100;
Vmax = edge;
goal = 0.01;
break;
case 2:
edge = 30;
Vmax = edge;
goal = 100;
break;
case 3:
edge = 5.12;
Vmax = edge;
goal = 100;
break;
case 4:
edge = 600;
Vmax = edge;
goal = 0.1;
break;
default:
edge = 100;
Vmax = edge;
goal = 0.01;
}
//int ngoal = 0, avggen = 0;
sucCounter = 0;
for(vtest = 0; vtest < testnum; vtest++)
{
int sum = 1;
for(i = 0; i < coornum; i++)
{
pbest[i] = INT_MAX;
gbest[i] = INT_MAX;
}
for(i = 0; i < dim + 1; i++) //Initialization
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
coor[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * edge - edge;
vel[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * Vmax - Vmax;
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
//printf("%f\t", coor[(dim+1)*j+i]);
}
else
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
//printf("\n%d:%f,", j, coor[(dim+1)*j+i]);
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
if(coor[(dim+1)*j+i] < gbest[(dim+1)*j+i])
{
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
//printf("gbest:%f\t", gbest[(dim+1)*j+i]);
}
for(k = 0; k < N; k++)
if( gbest[(dim+1)*j+i] < gbest[(dim+1)*k+i])
{
//printf("t[%d][%d],",j,k);
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*k+l] = gbest[(dim+1)*j+l];
}
}
}
}
for(vgen = 0; vgen < gennum; vgen++) //gennum´ú½ø»¯£»
{
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
double r1 = (double)rand() / RAND_MAX * 1;
double r2 = (double)rand() / RAND_MAX * 1;
vel[(dim+1)*j+i] = w * vel[(dim+1)*j+i] + c1 * r1 * (pbest[(dim+1)*j+i] - coor[(dim+1)*j+i])\
+ c2 * r2 * (gbest[(dim+1)*j+i] - coor[(dim+1)*j+i]);
/*
if(vel[(dim+1)*j+i] > Vmax)
vel[(dim+1)*j+i] = Vmax;
if(vel[(dim+1)*j+i] < -Vmax)
vel[(dim+1)*j+i] = -Vmax;
*/
coor[(dim+1)*j+i] += vel[(dim+1)*j+i]; // Moving
}
else
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
if(coor[(dim+1)*j+i] < pbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
pbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
if(coor[(dim+1)*j+i] < gbest[(dim+1)*j+i])
{
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
}
for(k = 0; k < N; k++)
if( gbest[(dim+1)*j+i] < gbest[(dim+1)*k+i])
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*k+l] = gbest[(dim+1)*j+l];
}
}
}
gb = gbest[dim];
for(i = 1; i < N; i++)
if(gbest[(dim+1)*i+dim] < gb)
gb = gbest[(dim+1)*i+dim];
if(gb < goal && sum != 0)
{
sum = 0; // Change the flag
//ngoal++;
sucCounter += 1;
AveOptGen += vgen;
printf("suc gb:%1.30f\n",gb);
}
if(vgen == 1000)
recordInd[vtest]=gb;
if(vgen == gennum - 1)
{
printf("last gb:%1.15f\n",gb);
AveEndFit += gb;
if(sum == 0) // Succeeded
AveSucFit += gb;
}
} // End of for VGEN!
} // End of vtest
FIndex=countFIndex(recordInd);
AveEndFit = AveEndFit/testnum;
if(sucCounter!=0) // If succeeded
{
AveSucFit = AveSucFit/sucCounter;
AveOptGen = AveOptGen/sucCounter;
}
else
{
AveSucFit = -1; // A flag to show the failure
AveOptGen = -1; // A flag to show the failure
}
AveOptRate=(double) sucCounter / testnum * 100;
printf("%1.30f,%1.30f,%f,%f,%f\n",AveEndFit,AveSucFit,AveOptGen,AveOptRate,FIndex);
fprintf(pso,"%1.30f,%1.30f,%f,%f,%f\n",AveEndFit,AveSucFit,AveOptGen,AveOptRate,FIndex);
// AveSucFit is the Average Endfit for only successful runs
fclose(pso);
return 0;
}
int main()
{
//printf("a");
srand((unsigned)time(NULL));
int i, j, l, vfun, vtest, vgen, vlneighs;
float x, edge, Vmax, goal, gb, res = 0,avggennew=0;
float vel[coornum], results[2*testnum],midians[4];
int sucCounter;
// vlneighs:The number of neighbors a paricle learns from (self-excluded)
float AveEndFit[4];
//Storage
float Sto_SucEndFit[4][N-1]; // N-1 circumstances for learning
float Sto_SucGens[4][N-1];
float Sto_SucRate[4][N-1];
float Sto_StdIndex[N-1];
for(j=0; j<4; j++)
for(i=0; i<N-1; i++)
{
Sto_SucEndFit[j][i]=-1;
Sto_SucGens[j][i]=-1;
Sto_SucRate[j][i]=-1;
Sto_StdIndex[i]=999;
}
pso = fopen("fipso1.1-all-f1-f4-stdlized.txt", "a+");
fprintf(pso, "num\tw\tc1\tc2\tfuncnum\tavggen\tratio\tfinalresult\n");
x = 0.7298;
for(vlneighs =18; vlneighs< 36; vlneighs++)
{
fprintf(pso, "lneighs:%d\n",vlneighs);
for(i = 0; i < 4; i++)
AveEndFit[i]=0;
for(vfun = 1; vfun < 5; vfun++)
{
for(i = 0; i < testnum; i++)
{
results[2*i] = gennum;
results[2*i+1] = 0;
}
if(vfun == 1)
{
edge = 100;
Vmax = edge;
goal = 0.01;
}
if(vfun == 2)
{
edge = 30;
Vmax = edge;
goal = 100;
}
if(vfun == 3)
{
edge = 5.12;
Vmax = edge;
goal = 100;
}
if(vfun == 4)
{
edge = 600;
Vmax = edge;
goal = 0.1;
}
int ngoal = 0, avggen = 0;
sucCounter = 0;
for(vtest = 0; vtest < testnum; vtest++)
{
int sum = 1;
for(i = 0; i < coornum; i++)
{
pbest[i] = INT_MAX;
}
for(i = 0; i < dim + 1; i++) //粒子初始化；
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
coor[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * edge - edge;
vel[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * Vmax - Vmax;
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
//printf("%f\t", coor[(dim+1)*j+i]);
}
else
{
// i=dim
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
//printf("\n%d:%f,", j, coor[(dim+1)*j+i]);
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
}
}
}
/*
int gbp;
gb = pbest[dim];
for(i = 1; i < N; i++)
if(pbest[(dim+1)*i+dim] < gb)
{
gb = pbest[(dim+1)*i+dim];
gbp = i;
}
*/
for(vgen = 0; vgen < gennum; vgen++) //gennum代进化；
{
/*
int k;
double phi = 4.1;
double PBNINDEX[2][N]; // Pbest & Index
for(k=0; k<N; k++)
{
PBNINDEX[0][k]=pbest[(dim+1)*k+dim]; // pbest
PBNINDEX[1][k]=k; // The index of particle
}
for(k=0; k<N; k++){
printf("<%f,%d> ",PBNINDEX[0][k],(int)PBNINDEX[1][k]);
}
printf("\n");*/
//QuickSort(PBNINDEX,0,N-1); // Done sorting the fitness while keeping the index
// The quicksort gives a small to large sequence! (And fitness is better when smaller
//for(k=0; k<N; k++)
//printf("%f,[%f],",PBNINDEX[0][k],PBNINDEX[1][k]);
/*for(k=0; k<N; k++){
printf("<%f,%d> ",PBNINDEX[0][k],(int)PBNINDEX[1][k]);
}*/
//printf("\n");
/*
for(j = 0; j < N; j++)
{
for(i = 0; i < dim; i++)
{
double r1=(double)rand() / RAND_MAX, r2=(double)rand() / RAND_MAX;
int kkk=(int)PBNINDEX[1][0];
update[(dim+1)*j+i] = phi*( r1*( pbest[(dim+1)*kkk+i]-coor[(dim+1)*j+i]) + r2*(pbest[(dim+1)*j+i]-coor[(dim+1)*j+i]) )/2;
}
}
*/
get_vel_update(vlneighs);
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
//double r1=(double)rand() / RAND_MAX;
//double r2=(double)rand() / RAND_MAX;
//vel[(dim+1)*j+i] = x * ( vel[(dim+1)*j+i] + phi*( r1*( pbest[(dim+1)*gbp+i]-coor[(dim+1)*j+i]) + r2*(pbest[(dim+1)*j+i]-coor[(dim+1)*j+i]) )/2 );
//vel[(dim+1)*j+i] = x * ( vel[(dim+1)*j+i] + 2.05*r1*(pbest[(dim+1)*j+i]-coor[(dim+1)*j+i])+2.05*r2*(pbest[(dim+1)*gbp+i]-coor[(dim+1)*j+i]));
vel[(dim+1)*j+i] = x * (vel[(dim+1)*j+i]+update[(dim+1)*j+i]);
coor[(dim+1)*j+i] += vel[(dim+1)*j+i];
}
else
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
if(coor[(dim+1)*j+i] < pbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
pbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
}
}
}
gb = pbest[dim];
for(i = 1; i < N; i++)
if(pbest[(dim+1)*i+dim] < gb)
{
gb = pbest[(dim+1)*i+dim];
//gbp = i;
}
//printf("\ngb:%f\n",gb);
if(gb < goal && sum != 0)
{
results[2*vtest] = (double)vgen;
results[2*vtest+1] = gb;
sum = 0;
//ngoal++;
printf("\ngb:%f,%d\t",gb,vgen);
sucCounter+=1;
}
if(vgen == gennum - 1)
{
printf("lastgb:%f\n",gb);
if(sum == 0) // Succeeded
AveEndFit[vfun-1] += gb;
else
results[2*vtest] = vgen;
}
if(vgen ==1000)
{
allfun[vtest] = gb;
printf("\n1000gb:%1.30f\n",gb);
}
} // End of for VGEN!
} // End of for VTEST !
double miu=0;
for(i=0; i<testnum; i++)
miu += allfun[i];
miu /= testnum;
double delta=0;
for(i=0; i<testnum; i++)
delta += pow((allfun[i]-miu),2);
delta = sqrt(delta/testnum);
double tempfun;
for(i=0; i<testnum-1; i++)
for(j=i+1; j<testnum; j++)
if(allfun[i]>allfun[j])
{
tempfun = allfun[i];
allfun[i] = allfun[j];
allfun[j] = tempfun;
}
if(testnum%2 == 0)
{
midians[vfun-1] = (allfun[testnum/2]+allfun[testnum/2+1])/2;
printf("\ndelta:%f,%f,%f",midians[vfun-1],allfun[testnum/2],allfun[testnum/2+1]);
}
else
midians[vfun-1] = allfun[testnum/2+1];
midians[vfun-1] = (midians[vfun-1] - miu)/delta;
printf("\nmidians:%f",midians[vfun-1]);
printf("\nmidians[%d] is %f",vfun-1,midians[vfun-1]);
if(sucCounter!=0)
{
Sto_SucEndFit[vfun-1][vlneighs-1]=AveEndFit[vfun-1]/sucCounter;
fprintf(pso,"\n\n\nLast succeeded average gb fitness:%1.30f\n",AveEndFit[vfun-1]/sucCounter);
}
else
fprintf(pso,"\n\n\nLast succeeded average gb fitness: U gotta be kidding, man!\n");
for(i = 0; i < testnum; i++)
{
if(results[2*i] != gennum - 1)
{
ngoal++;
avggen += results[2*i];
res += results[2*i+1];
}
}
printf("%d,%d", avggen/vtest, ngoal);
if(ngoal == 0) // Unsuccessful
avggennew = (double)gennum - 1;
else
avggennew = (double)avggen / ngoal;
fprintf(pso, "\nAveGen:%f\nSucRate%f%%", avggennew, (double)sucCounter / testnum * 100);
Sto_SucGens[vfun-1][vlneighs-1]=avggennew;
Sto_SucRate[vfun-1][vlneighs-1]=(double)sucCounter / testnum * 100;
} // End of for VFUN!
double midian=0;
for(i=0; i<4; i++)
midian += midians[i];
midian /=4;
printf("\nmidian is %f\n",midian);
Sto_StdIndex[vlneighs-1]=midian;
//fprintf(pso,"\nstandardized performance:%fasdf\n",midian);
} // End of for vlneighs!
fclose(pso);
pso = fopen("fipso1.1-all-f1-f4-SucEndFit&StdIndex-stdlized.txt", "a+");
fprintf(pso,"vlneighs,f1-SEndfit,f2-SEndfit,f3-SEndfit,f4-SEndfit,StdIndex\n");
for(i=0; i<N; i++)
fprintf(pso,"%d,%1.30f,%1.30f,%1.30f,%1.30f,%f\n",i+1,Sto_SucEndFit[0][i],Sto_SucEndFit[1][i],Sto_SucEndFit[2][i],Sto_SucEndFit[3][i],Sto_StdIndex[i]);
fclose(pso);
pso = fopen("fipso1.1-all-f1-f4-SucGens-stdlized.txt", "a+");
for(i=0; i<N; i++)
fprintf(pso,"%d,%f,%f,%f,%f\n",i+1,Sto_SucGens[0][i],Sto_SucGens[1][i],Sto_SucGens[2][i],Sto_SucGens[3][i]);
fclose(pso);
pso = fopen("fipso1.1-all-f1-f4-SucRate-stdlized.txt", "a+");
for(i=0; i<N; i++)
fprintf(pso,"%d,%f,%f,%f,%f\n",i+1,Sto_SucRate[0][i],Sto_SucRate[1][i],Sto_SucRate[2][i],Sto_SucRate[3][i]);
fclose(pso);
return 0;
}
int main()
{
//printf("a");
srand((unsigned)time(NULL));
int i, j, l, vfun, vtest, vgen, vlneighs;
float x, edge, Vmax, goal, gb, res = 0,avggennew=0;
float vel[coornum], results[2*testnum];
int sucCounter;
// vlneighs:The number of neighbors a paricle learns from (self-excluded)
float AveEndFit[4];
//Storage
float Sto_SucEndFit[N-1]; // N-1 circumstances
float Sto_SucGens[N-1];
float Sto_SucRate[N-1];
for(i=0;i<N-1;i++){
Sto_SucEndFit[i]=-1;
Sto_SucGens[i]=-1;
Sto_SucRate[i]=-1;
}
pso = fopen("lipso2.0-all-f2.txt", "a+");
fprintf(pso, "num\tw\tc1\tc2\tfuncnum\tavggen\tratio\tfinalresult\n");
x = 0.7298;
for(vlneighs =1; vlneighs< N; vlneighs++)
{
fprintf(pso, "lneighs:%d\n",vlneighs);
for(i = 0; i < 4; i++)
AveEndFit[i]=0;
for(vfun = 2; vfun < 3; vfun++)
{
for(i = 0; i < testnum; i++)
{
results[2*i] = gennum;
results[2*i+1] = 0;
}
if(vfun == 1)
{
edge = 100;
Vmax = edge;
goal = 0.01;
}
if(vfun == 2)
{
edge = 30;
Vmax = edge;
goal = 100;
}
if(vfun == 3)
{
edge = 5.12;
Vmax = edge;
goal = 100;
}
if(vfun == 4)
{
edge = 600;
Vmax = edge;
goal = 0.1;
}
int ngoal = 0, avggen = 0;
sucCounter = 0;
for(vtest = 0; vtest < testnum; vtest++)
{
int sum = 1;
for(i = 0; i < coornum; i++)
{
pbest[i] = INT_MAX;
}
for(i = 0; i < dim + 1; i++) //粒子初始化；
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
coor[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * edge - edge;
vel[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * Vmax - Vmax;
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
//printf("%f\t", coor[(dim+1)*j+i]);
}
else
{
// i=dim
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
//printf("\n%d:%f,", j, coor[(dim+1)*j+i]);
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
}
}
}
/*
int gbp;
gb = pbest[dim];
for(i = 1; i < N; i++)
if(pbest[(dim+1)*i+dim] < gb)
{
gb = pbest[(dim+1)*i+dim];
gbp = i;
}
*/
for(vgen = 0; vgen < gennum; vgen++) //gennum代进化；
{
for(i=0; i<N; i++)
randlneighs[i]=0; // initializing the indices of learnees
choose_rand_neighbors(vlneighs);
//for(i=0; i<N; i++)
//printf("%d",randlneighs[i]); // initializing the indices of learnees
get_vel_update(vlneighs);
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
//double r1=(double)rand() / RAND_MAX;
//double r2=(double)rand() / RAND_MAX;
//vel[(dim+1)*j+i] = x * ( vel[(dim+1)*j+i] + phi*( r1*( pbest[(dim+1)*gbp+i]-coor[(dim+1)*j+i]) + r2*(pbest[(dim+1)*j+i]-coor[(dim+1)*j+i]) )/2 );
//vel[(dim+1)*j+i] = x * ( vel[(dim+1)*j+i] + 2.05*r1*(pbest[(dim+1)*j+i]-coor[(dim+1)*j+i])+2.05*r2*(pbest[(dim+1)*gbp+i]-coor[(dim+1)*j+i]));
vel[(dim+1)*j+i] = x * (vel[(dim+1)*j+i]+update[(dim+1)*j+i]);
coor[(dim+1)*j+i] += vel[(dim+1)*j+i];
}
else
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
if(coor[(dim+1)*j+i] < pbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
pbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
}
}
}
gb = pbest[dim];
for(i = 1; i < N; i++)
if(pbest[(dim+1)*i+dim] < gb)
{
gb = pbest[(dim+1)*i+dim];
//gbp = i;
}
//printf("\ngb:%f\n",gb);
if(gb < goal && sum != 0)
{
results[2*vtest] = (double)vgen;
results[2*vtest+1] = gb;
sum = 0;
//ngoal++;
printf("\ngb:%f,%d\t",gb,vgen);
sucCounter+=1;
}
if(vgen == gennum - 1)
{
printf("lastgb:%f\n",gb);
if(sum == 0) // Succeeded
AveEndFit[vfun-1] += gb;
else
results[2*vtest] = vgen;
}
} // End of for VGEN!
} // End of for VTEST !
if(sucCounter!=0){
Sto_SucEndFit[vlneighs-1]=AveEndFit[vfun-1]/sucCounter;
fprintf(pso,"\n\n\nLast succeeded average gb fitness:%1.30f\n",AveEndFit[vfun-1]/sucCounter);
}
else
fprintf(pso,"\n\n\nLast succeeded average gb fitness: U gotta be kidding, man!\n");
for(i = 0; i < testnum; i++)
{
if(results[2*i] != gennum - 1)
{
ngoal++;
avggen += results[2*i];
res += results[2*i+1];
}
}
printf("%d,%d", avggen/vtest, ngoal);
if(ngoal == 0) // Unsuccessful
avggennew = (double)gennum - 1;
else
avggennew = (double)avggen / ngoal;
fprintf(pso, "\nAveGen:%f\nSucRate%f%%", avggennew, (double)sucCounter / testnum * 100);
Sto_SucGens[vlneighs-1]=avggennew;
Sto_SucRate[vlneighs-1]=(double)sucCounter / testnum * 100;
} // End of for VFUN!
} // End of for vlneighs!
fclose(pso);
pso = fopen("lipso2.0-all-f2-SucEndFit.txt", "a+");
for(i=0;i<N;i++)
fprintf(pso,"%d,%1.30f\n",i+1,Sto_SucEndFit[i]);
fclose(pso);
pso = fopen("lipso2.0-all-f2-SucGens.txt", "a+");
for(i=0;i<N;i++)
fprintf(pso,"%d,%f\n",i+1,Sto_SucGens[i]);
fclose(pso);
pso = fopen("lipso2.0-all-f2-SucRate.txt", "a+");
for(i=0;i<N;i++)
fprintf(pso,"%d,%f\n",i+1,Sto_SucRate[i]);
fclose(pso);
}
int main()
{
srand((unsigned)time(NULL));
int i, j, k, l, varw, varc1, varc2, vfun=4, vtest, vgen, temp; // iteration vars
float w, c1, c2, edge, Vmax, goal, gb, res = 0, avggennew=0; // gb is the global gbest
float vel[coornum], pbest[coornum], gbest[coornum], results[4*testnum]; // Each bird's got their own gbest
float absRadius; // Absolute perceptive radius
float relRadius; // A iteration var for radius
int radRec; // A var to count the index of the radius
int adjmat[N][N]; // Adjacent Matrix
char buffer[19]; // A buffer to write the file, 15 is the estimated char numbers
char storage[19*51];
/* Storage Section */
//The strategy is: we store the 'sum' into 'aves'.
//When the time comes they got loaded into the file, we'll have them become real 'average'
float AveOptGen[51];
float AveOptRate[51];
float AveDeg[51][gennum/aveDegInterval+1]; // [Every 10 gen]
//So the truth is, we're getting the average(a matrix) of average(a test)
float AveOptFit[51][gennum/aveDegInterval+1]; // The average of the gbest fitness in the end of each test (last generation)
/* End of Storage Section */
for(i=0;i<51;i++){
AveOptGen[i]=0;
AveOptRate[i]=0;
for(j=0;j<gennum/aveDegInterval;j++){
AveDeg[i][j]=0;
AveOptFit[i][j]=0;
}
}
for(i=0;i<19*14*5;i++){
storage[i]=' ';
}
radRec=0; // Set the radius index counting number
for(relRadius=0.1;relRadius<1.41;relRadius+=0.02){ // Loop layer 1 (relRadius)
w = 0.6;
for(varw = 0; varw < 1; varw++)
{
c1 = 1.7;
for(varc1 = 0; varc1 < 1; varc1++)
{
c2 = 1.7;
for(varc2 = 0; varc2 < 1 ; varc2++)
{
edge = 600;
Vmax = edge;
goal = 0.1;
absRadius = relRadius * sqrt(dim * pow(2 * edge , 2));
//printf("absRadius:%f\n",absRadius);
int ngoal = 0, avggen = 0; // Goal achieving flag & Average generations
for(i = 0; i < testnum; i++)
{
results[4*i] = gennum;
results[4*i+1] = 0;
results[4*i+2] = gennum;
results[4*i+3] = 0;
}
for(vtest = 0; vtest < testnum; vtest++) // Run the experiment
{
/*for(i = 0; i < N; i++)
for(j = 0; j < N; j++)
adjmat[i][j]=0;
// Finished initializing adjacent matrix
*/
int sum = 1;
for(i = 0; i < coornum; i++)
{
pbest[i] = INT_MAX;
gbest[i] = INT_MAX;
}
//Initialization:
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
coor[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * edge - edge;
vel[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * Vmax - Vmax;
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
gbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
}
else
{ // i=dim
Fun4(j);
// Initializing pbest
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
gbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
/*
if(coor[(dim+1)*j+i] < gbest[(dim+1)*j+i])
{
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
}
for(k = 0; k < N; k++)
if( gbest[(dim+1)*j+i] < gbest[(dim+1)*k+i])
{
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*k+l] = gbest[(dim+1)*j+l];
}
*/
} // End of the condition i = dim
} // for birds
} // for dims
// Producing the initiating Adjacent Matrix
for(j=0;j<N;j++)
for(k=0;k<N;k++) // Avoid Relapse
{
if( getDistance(j,k) <= absRadius && j!=k ) // k Can be perceived by j
{
adjmat[j][k]=1;
}
else{
adjmat[j][k]=0;
}
}
// End of producing the initiating Adjacent Matrix
for( j=0; j<N ; j++ )
for( k=0; k<N ; k++ )
if( adjmat[j][k] != 0) // k Can be perceived by j
temp+=1;
temp/=N;
AveDeg[radRec][0]+=temp; // Got it
// Updating each bird's gbest:
for(j=0;j<N;j++){
for(k=0;k<N;k++)
if( adjmat[j][k] != 0 ){// k Can be perceived by j
// Updating the gbest of j
//printf("%f\t",getDistance(j,k));
if( coor[(dim+1)*k+dim] < gbest[(dim+1)*j+dim] ){
for(l=0;l<=dim;l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*k+l];
}
}
//printf("gbest of %d:%f\nfitness of %d:%f\n",j,gbest[(dim+1)*j+dim],j,coor[(dim+1)*j+dim]);
}
gb = gbest[dim]; // Updating the global gbest
for(i = 1; i < N; i++)
if(gbest[(dim+1)*i+dim] < gb)
gb = gbest[(dim+1)*i+dim];
AveOptFit[radRec][0]+=gb;
// End of Updating each bird's gbest in initialization
for(vgen = 0; vgen < gennum; vgen++) // Evolution
{
float aveDegree=0; // Average Degree
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
float r1 = (double)rand() / RAND_MAX * 1;
float r2 = (double)rand() / RAND_MAX * 1;
vel[(dim+1)*j+i] = w * vel[(dim+1)*j+i] + c1 * r1 * (pbest[(dim+1)*j+i] - coor[(dim+1)*j+i])\
+ c2 * r2 * (gbest[(dim+1)*j+i] - coor[(dim+1)*j+i]);
coor[(dim+1)*j+i] += vel[(dim+1)*j+i];
}
else // i = dim
{
Fun4(j);
// When i = dim, updating pbest:
if(coor[(dim+1)*j+i] < pbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
pbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
// Comparing itself with gbest:
if(coor[(dim+1)*j+i] < gbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
} // End of else
} // for birds
} // for dims
// Producing the initiating Adjacent Matrix
for( j=0; j<N ; j++ )
for( k=0; k<N; k++) // Avoid Relapse
{
int dist=getDistance(j,k);
if( dist <= absRadius && j!=k ) // k Can be perceived by j
{
adjmat[j][k]=1;
}
else{
adjmat[j][k]=0;
}
}
// End of producing the initiating Adjacent Matrix
//Caculating Average Degree of the generation
if( (vgen+1) % aveDegInterval == 0 ){
for( j=0; j<N ;j++ )
for( k=0; k<N ;k++ )
if( adjmat[j][k] != 0) // k Can be perceived by j
aveDegree+=1;
aveDegree/=N; // Got it
AveDeg[radRec][(vgen+1) / aveDegInterval] += aveDegree; // Storing Average Degree of this particular generation
}
// Updating each bird's gbest:
for( j=0; j<N ;j++ ){
for( k=0; k<N ;k++ )
if( adjmat[j][k] != 0 ) // k Can be perceived by j
// Updating the gbest of j
if( coor[(dim+1)*k+dim] < gbest[(dim+1)*j+dim] )
for(l=0;l<=dim;l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*k+l];
//printf("gbest of %d:%f\nfitness of %d:%f\n",j,gbest[(dim+1)*j+dim],j,coor[(dim+1)*j+dim]);
}
// End of Updating each bird's gbest
gb = gbest[dim]; // Updating the global gbest
for(i = 1; i < N; i++)
if(gbest[(dim+1)*i+dim] < gb)
gb = gbest[(dim+1)*i+dim];
if( (vgen+1) % aveDegInterval == 0 ){
AveOptFit[radRec][(vgen+1) / aveDegInterval]+=gb;
}
if(gb < goal && sum != 0)
{
results[4*vtest] = (double)vgen+1;
results[4*vtest+1] = gb;
sum = 0;
//ngoal++;
//break;
}
if(vgen == gennum - 1)
{
results[4*vtest+2] = gennum;
results[4*vtest+3] = gb;
}
} // for vgens
printf("\nA test for Function%d is done. The next one's coming at ya.\n\n",vfun);
} // for vtest
for(i = 0; i < testnum; i++)
{
if(results[4*i] != gennum)
{
ngoal++;
avggen += results[4*i];
res += results[4*i+1];
}
}
printf("%d,%d", avggen, ngoal);
if(ngoal == 0)
avggennew = (double)gennum;
else
avggennew = (double)avggen / ngoal;
printf("AVGEN:%f\t",avggennew);
AveOptGen[radRec]=avggennew;
printf("AVRATE:%f",(double)ngoal / testnum * 100);
AveOptRate[radRec]=(double)ngoal / testnum * 100;
printf("Function%d is tested under this radius.\n", vfun);
c2 += 0.1;
}
c1 += 0.1;
}
w += 0.1;
}
//} // End of Loop layer 2 (population)
radRec++;
printf("\n\nRadius %d is tested\n\n",radRec);
} // End of Loop layer 1 (relRadius)
printf("\n\n Done! You got it, dude!");
for(i=0;i<51;i++)
for(j=0;j<=(gennum/aveDegInterval);j++){
AveDeg[i][j]=(double)AveDeg[i][j]/testnum;
AveOptFit[i][j]=(double)AveOptFit[i][j]/testnum;
}
// Get da data in da file!
for(i=0;i<51;i++){
sprintf(buffer,"Gen%d,AvDeg%d,",i,i);
strcat(storage,buffer);
}
pso = fopen("vicpsoFunc4-adjmat.txt", "w");
fprintf(pso, "RelRadius,AveOptGen,AveOptRate,AveDeg\n");
for(i=0;i<51;i++){
fprintf(pso, "%f,%f,%f\n",0.2+i*0.005,AveOptGen[i],AveOptRate[i]);
}
fclose(pso);
pso = fopen("vicpsoFunc4-adjmat-AveDeg.txt", "w");
fprintf(pso, "%s\n",storage );
for(j=0;j<=(gennum/aveDegInterval);j++){
int inIte;
for(inIte=0;inIte<51;inIte++){
fprintf(pso, "%d,%f,",j*10,AveDeg[inIte][j]);
}
fprintf(pso, "\n");
}
fclose(pso);
pso = fopen("vicpsoFunc4-OptFit.txt", "w");
fprintf(pso, "%s\n",storage );
for(j=0;j<=(gennum/aveDegInterval);j++){
int inIte;
for(inIte=0;inIte<51;inIte++){
fprintf(pso, "%d,%f,",j*10,AveOptFit[inIte][j]);
}
fprintf(pso, "\n");
}
fclose(pso);
return 0;
} // End of main
int main()
{
srand((unsigned)time(NULL));
/*
Generic & Procedural Vars
*/
int i, j, k, l, vfun, vtest, vgen; // iteration vars
float edge, Vmax, goal, gb; // gb is the global gbest
float vel[coornum], pbest[coornum], gbest[coornum]; // Each bird's got their own gbest
/*
Vars for Radius
*/
float absRadius; // Absolute perceptive radius
float relRadius; // A iteration var for radius
/*
Vars for Real-time Recording
*/
int adjmat[N][N]; // Adjacent Matrix
int radRec; // A var to count the index of the radius
float res = 0, avggennew=0, results[4*testnum];
/*
Vars for Storage
*/
float AveOptGen[relRange]; // FuncNumber*RadiusNumber: Every 19[radius] with a func
float AveOptRate[relRange]; // FuncNumber*RadiusNumber: Every 19[radius] with a func
//So the truth is, we're getting the average(a matrix) of average(a test)
//float AveOptFit[relRange][gennum/aveDegInterval+1]; // The average of the gbest fitness of the interval generations
float AveEndFit[relRange]; // End fit
float AveOptFit[relRange][gennum/aveDegInterval+1]; // The average of the gbest fitness of the interval generations
float AveSucFit[relRange];// SUCCESSFUL EndFit The average of the gbest fitness in the end of each SUCCESSFUL test (last generation)
float FIndex[relRange], recordInd[testnum];
/* End of Storage Section */
char buffer[19]; // A buffer to write the file, 15 is the estimated char numbers
char storage[19*relRange];
for(i=0; i<relRange; i++)
{
AveOptGen[i]=0;
AveOptRate[i]=0;
AveEndFit[i]=0;
AveSucFit[i]=0;
for(j=0; j<gennum/aveDegInterval; j++)
{
AveOptFit[i][j]=0;
}
}
for(i=0; i<19*relRange; i++)
{
storage[i]=' ';
}
/*
Some settings
*/
pso = fopen("../../vicpso-dynarad.txt", "w");
vfun=1;
if(vfun == 1)
{
edge = 100;
Vmax = edge;
goal = 0.01;
}
if(vfun == 2)
{
edge = 30;
Vmax = edge;
goal = 100;
}
if(vfun == 3)
{
edge = 5.12;
Vmax = edge;
goal = 100;
}
if(vfun == 4)
{
edge = 600;
Vmax = edge;
goal = 0.1;
}
radRec=0; // Set the radius index counting number
printf("changeInte:%d",changeInte);
for(relRadius=relStart; relRadius<relEnd; relRadius+=relStep) // Loop layer 1 (relRadius)
{
int ngoal = 0, avggen = 0; // Goal achieving flag & Average generations
for(i = 0; i < testnum; i++)
{
results[4*i] = gennum;
results[4*i+1] = 0;
results[4*i+2] = gennum;
results[4*i+3] = 0;
}
for(vtest = 0; vtest < testnum; vtest++) // Run the experiment
{
float neoDiag=0;
float dist=0;
int sum = 1;
for(i = 0; i < coornum; i++)
{
pbest[i] = INT_MAX;
gbest[i] = INT_MAX;
}
//Initialization:
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
coor[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * edge - edge;
vel[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * Vmax - Vmax;
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
gbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
}
else
{
// i=dim
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
// Initializing pbest
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
gbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
} // End of the condition i = dim
} // for birds
} // for dims
//neoDiag=0;
// Producing the initiating Adjacent Matrix
/*for(j=0; j<N; j++)
for(k=0; k<N; k++) // Avoid Relapse
{
dist=getDistance(j,k);
if(dist>neoDiag)
neoDiag = dist;
}
*/
absRadius = relRadius * sqrt(dim * pow(2 * edge , 2));
for(j=0; j<N; j++)
for(k=0; k<N; k++) // Avoid Relapse
{
if( getDistance(j,k) <= absRadius && j!=k ) // k Can be perceived by j
{
adjmat[j][k]=1;
}
else
{
adjmat[j][k]=0;
}
}
// End of producing the initiating Adjacent Matrix
/* Average Degree
for( j=0; j<N ; j++ )
for( k=0; k<N ; k++ )
if( adjmat[j][k] != 0) // k Can be perceived by j
temp+=1;
temp/=N;
AveDeg[radRec][0]+=temp; // Got it
*/
// Updating each bird's gbest:
for(j=0; j<N; j++)
{
for(k=0; k<N; k++)
if( adjmat[j][k] != 0 ) // k Can be perceived by j
{
// Updating the gbest of j
//printf("%f\t",getDistance(j,k));
if( coor[(dim+1)*k+dim] < gbest[(dim+1)*j+dim] )
{
for(l=0; l<=dim; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*k+l];
}
}
//printf("gbest of %d:%f\nfitness of %d:%f\n",j,gbest[(dim+1)*j+dim],j,coor[(dim+1)*j+dim]);
}
gb = gbest[dim]; // Updating the global gbest
for(i = 1; i < N; i++)
if(gbest[(dim+1)*i+dim] < gb)
gb = gbest[(dim+1)*i+dim];
AveOptFit[radRec][0]+=gb;
// End of Updating each bird's gbest in initialization
for(vgen = 0; vgen < gennum; vgen++) // Evolution starts
{
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
float r1 = (double)rand() / RAND_MAX * 1;
float r2 = (double)rand() / RAND_MAX * 1;
vel[(dim+1)*j+i] = w * vel[(dim+1)*j+i] + c1 * r1 * (pbest[(dim+1)*j+i] - coor[(dim+1)*j+i])\
+ c2 * r2 * (gbest[(dim+1)*j+i] - coor[(dim+1)*j+i]);
coor[(dim+1)*j+i] += vel[(dim+1)*j+i];
}
else // i = dim
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
// When i = dim, updating pbest:
if(coor[(dim+1)*j+i] < pbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
pbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
// Comparing itself with gbest:
if(coor[(dim+1)*j+i] < gbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
} // End of else
} // for birds
} // for dims
if( (vgen+1) % (changeInte) == 0 && vgen!=0)
{
//printf("%d,%f\n",vgen,neoDiag);
absRadius=relRadius*neoDiag;
}
neoDiag=0;// reset
// Producing the Adjacent Matrix
for( j=0; j<N ; j++ )
for( k=0; k<N; k++) // Avoid Relapse
{
dist=getDistance(j,k);
if( getDistance(j,k) <= absRadius && j!=k ) // k Can be perceived by j
{
adjmat[j][k]=1;
}
else
{
adjmat[j][k]=0;
}
if( (vgen+1) % changeInte == (changeInte-1) )
if(dist>neoDiag)
{
neoDiag=dist;
//printf("%d,%d,dist:%f\t",j,k,dist);
}
}
//if(neoDiag!=0)
//printf("%d,%f\n",vgen,neoDiag);
// End of producing the initiating Adjacent Matrix
/* //Caculating Average Degree of the generation
if( (vgen+1) % aveDegInterval == 0 )
{
for( j=0; j<N ; j++ )
for( k=0; k<N ; k++ )
if( adjmat[j][k] != 0) // k Can be perceived by j
aveDegree+=1;
aveDegree/=N; // Got it
AveDeg[radRec][(vgen+1) / aveDegInterval] += aveDegree; // Storing Average Degree of this particular generation
}
*/
// Updating each bird's gbest:
for( j=0; j<N ; j++ )
{
for( k=0; k<N ; k++ )
if( adjmat[j][k] != 0 ) // k Can be perceived by j
// Updating the gbest of j
if( coor[(dim+1)*k+dim] < gbest[(dim+1)*j+dim] )
for(l=0; l<=dim; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*k+l];
//printf("gbest of %d:%f\nfitness of %d:%f\n",j,gbest[(dim+1)*j+dim],j,coor[(dim+1)*j+dim]);
}
// End of Updating each bird's gbest
gb = gbest[dim]; // Updating the global gbest
for(i = 1; i < N; i++)
if(gbest[(dim+1)*i+dim] < gb)
gb = gbest[(dim+1)*i+dim];
if( (vgen+1) % aveDegInterval == 0 )
{
AveOptFit[radRec][(vgen+1) / aveDegInterval]+=gb;
}
if(gb < goal && sum != 0)
{
results[4*vtest] = (double)vgen+1;
results[4*vtest+1] = gb;
sum = 0;
printf("\ngb:%f,%d\t",gb,vgen);
//ngoal++;
//break;
}
if(vgen == 1000)
recordInd[vtest]=gb;
if(vgen == gennum - 1)
{
results[4*vtest+2] = gennum;
results[4*vtest+3] = gb;
printf("lastgb:%f\n",gb);
AveEndFit[radRec]+=gb;
}
} // for vgens
printf("\nTest%d for Function%d of relRadius%f is done. The next one's coming at ya.\n\n",vtest,vfun,relRadius);
} // for vtest
FIndex[radRec]=countFIndex(recordInd);
AveEndFit[radRec] = AveEndFit[radRec]/testnum;
for(i = 0; i < testnum; i++)
{
if(results[4*i] != gennum)
{
ngoal++; //Suc Counter
avggen += results[4*i];
res += results[4*i+1];
AveSucFit[radRec]+=results[4*i+3];
}
}
//printf("%d,%d", avggen, ngoal);
if(ngoal == 0)
{
AveSucFit[radRec] = -1;
avggennew = (double)gennum;
}
else
{
AveSucFit[radRec] /= ngoal;
avggennew = (double)avggen / ngoal;
}
//printf("AVGEN:%f\t",avggennew);
AveOptGen[radRec]=avggennew;
//printf("AVRATE:%f",(double)ngoal / testnum * 100);
AveOptRate[radRec]=(double)ngoal / testnum * 100;
//printf("Function%d is tested under this radius.\n", vfun);
printf("%1.30f,%1.30f,%f,%f,%f\n",AveEndFit[radRec],AveSucFit[radRec],AveOptGen[radRec],AveOptRate[radRec],FIndex[radRec]); // Record a radius in a row, literally
fprintf(pso,"%1.30f,%1.30f,%f,%f,%f\n",AveEndFit[radRec],AveSucFit[radRec],AveOptGen[radRec],AveOptRate[radRec],FIndex[radRec]); // Record a radius in a row, literally
radRec++;
printf("\n\nRadius %d is tested\n\n",radRec);
} // End of Loop layer 1 (relRadius)
printf("\n\n Done! You got it, dude!");
fclose(pso);
for(i=0; i<relRange; i++)
for(j=0; j<=(gennum/aveDegInterval); j++)
{
AveOptFit[i][j]=(double)AveOptFit[i][j]/(testnum);
}
// Get da data in da file!
sprintf(storage,"Gen,");
for(i=0; i<relRange; i++)
{
sprintf(buffer,"ItemRel%f,",0.24+i*0.02);
strcat(storage,buffer);
}
/*
pso = fopen("vicpsoFunc-v4.4-AveDeg.txt", "w");
fprintf(pso, "%s\n",storage );
for(j=0; j<=(gennum/aveDegInterval); j++)
{
int inIte;
fprintf(pso,"%d,",j*10);
for(inIte=0; inIte<relRange; inIte++)
{
fprintf(pso, "%f,",AveDeg[inIte][j]);
}
fprintf(pso, "\n");
}
fclose(pso)*/
pso = fopen("../../vicpso-OptFit-dynarad.txt", "w");
fprintf(pso, "%s\n",storage );
for(j=0; j<=(gennum/aveDegInterval); j++)
{
int inIte;
fprintf(pso,"%d,",j*10);
for(inIte=0; inIte<relRange; inIte++)
{
fprintf(pso, "%f,",AveOptFit[inIte][j]);
}
fprintf(pso, "\n");
}
fclose(pso);
return 0;
} // End of main
int main()
{
//printf("a");
srand((unsigned)time(NULL));
int i, j, k, l, vfun, vtest, vgen;
float w, c1, c2, edge, Vmax, goal, gb, res = 0,avggennew=0;
float vel[coornum], pbest[coornum], gbest[coornum], results[2*testnum],lbest[coornum];
pso = fopen("pso1-4.txt", "a+");
fprintf(pso, "num\tw\tc1\tc2\tfuncnum\tavggen\tratio\tfinalresult\n");
w = 0.7298;
c1 = 1.49;
c2 = 1.49;
BAnet_produce();
for(vfun = 1; vfun < 5; vfun++)
{
if(vfun == 1)
{
edge = 100;
Vmax = edge;
goal = 0.01;
}
if(vfun == 2)
{
edge = 30;
Vmax = edge;
goal = 100;
}
if(vfun == 3)
{
edge = 5.12;
Vmax = edge;
goal = 100;
}
if(vfun == 4)
{
edge = 600;
Vmax = edge;
goal = 0.1;
}
int ngoal = 0, avggen = 0;
for(i = 0; i < testnum; i++)
{
results[2*i] = gennum;
results[2*i+1] = 0;
}
for(vtest = 0; vtest < testnum; vtest++)
{
int sum = 1;
for(i = 0; i < coornum; i++)
{
pbest[i] = INT_MAX;
gbest[i] = INT_MAX;
}
for(i = 0; i < dim + 1; i++) //粒子初始化；
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
coor[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * edge - edge;
vel[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * Vmax - Vmax;
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
//printf("%f\t", coor[(dim+1)*j+i]);
}
else
{
// i=dim
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
//printf("\n%d:%f,", j, coor[(dim+1)*j+i]);
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
if(coor[(dim+1)*j+i] < gbest[(dim+1)*j+i])
{
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
//printf("gbest:%f\t", gbest[(dim+1)*j+i]);
}
for(k = 0; k < N; k++)
if( gbest[(dim+1)*j+i] < gbest[(dim+1)*k+i])
{
//printf("t[%d][%d],",j,k);
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*k+l] = gbest[(dim+1)*j+l];
}
}
}
}
/*for(i = 0; i < coornum; i++)
{
printf("\nabc:%f,%f,%f", coor[i], pbest[i], gbest[i]);
if(i % (dim + 1) == dim)
printf("\n");
}*/
for(vgen = 0; vgen < gennum; vgen++) //gennum代进化；
{
double PBNINDEX[2][N]; // Pbest & Index
for(k=0; k<N; k++)
{
PBNINDEX[0][k]=pbest[(dim+1)*k+dim]; // pbest
PBNINDEX[1][k]=k; // The index of particle
}
BubbleSort(PBNINDEX,N); // Done sorting the fitness while keeping the index
for(j = 0; j < N; j++)
{
//printf("pbest:%f , "[(dim+1)*j+i]);
int flag=1;
for(k=0; k<N; k++)
{
if(t[j][(int)PBNINDEX[1][k]]!=INT_MAX && (int)PBNINDEX[1][k]!=j && flag==1)
{
for(i=0; i<dim+1; i++)
{
lbest[(dim+1)*j+i] = pbest[(dim+1)*((int)PBNINDEX[1][k])+i];
}
flag=0;
}
}
}
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
float r1 = (double)rand() / RAND_MAX * 1;
float r2 = (double)rand() / RAND_MAX * 1;
vel[(dim+1)*j+i] = w * vel[(dim+1)*j+i] + c1 * r1 * (pbest[(dim+1)*j+i] - coor[(dim+1)*j+i])\
+ c2 * r2 * (lbest[(dim+1)*j+i] - coor[(dim+1)*j+i]);
/*if(vel[(dim+1)*j+i] > Vmax)
vel[(dim+1)*j+i] = Vmax;
if(vel[(dim+1)*j+i] < -Vmax)
vel[(dim+1)*j+i] = -Vmax;*/
coor[(dim+1)*j+i] += vel[(dim+1)*j+i];
/*if(coor[(dim+1)*j+i] > edge)
{
coor[(dim+1)*j+i] = edge;
vel[(dim+1)*j+i] = 0;
}
if(coor[(dim+1)*j+i] < -edge)
{
coor[(dim+1)*j+i] = -edge;
vel[(dim+1)*j+i] = 0;
}*/
}
else
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
if(coor[(dim+1)*j+i] < pbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
pbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
if(coor[(dim+1)*j+i] < gbest[(dim+1)*j+i])
{
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
}
for(k = 0; k < N; k++)
if( gbest[(dim+1)*j+i] < gbest[(dim+1)*k+i])
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*k+l] = gbest[(dim+1)*j+l];
}
}
}
gb = pbest[dim];
for(i = 1; i < N; i++)
if(pbest[(dim+1)*i+dim] < gb)
gb = pbest[(dim+1)*i+dim];
if(gb < goal && sum != 0)
{
results[2*vtest] = (double)vgen;
results[2*vtest+1] = gb;
sum = 0;
//ngoal++;
printf("gb:%f\n",gb);
break;
}
if(vgen == gennum - 1)
{
results[2*vtest] = gennum - 1;
results[2*vtest+1] = gb;
}
} // End of vgen
} // End of vtest
for(i = 0; i < testnum; i++)
{
if(results[2*i] != gennum - 1)
{
ngoal++;
avggen += results[2*i];
res += results[2*i+1];
}
}
if(ngoal == 0)
avggennew = (double)gennum - 1;
else
avggennew = (double)avggen / ngoal;
printf("\n平均代数为：%f\n达优率为：%f%%\n", avggennew, (double)ngoal / testnum * 100);
fprintf(pso, "\n平均代数为：%f\n达优率为：%f%%", avggennew, (double)ngoal / testnum * 100);
} // end of vfun
fclose(pso);
return 0;
}
int main()
{
//printf("a");
srand((unsigned)time(NULL));
int i, j, l, varc1, varc2, vfun, vtest, vgen;
float x, c1, c2, edge, Vmax, goal, gb, res = 0,avggennew=0;
float vel[coornum], pbest[coornum], pm[coornum], results[2*testnum];
float AveEndFit[4];
int sucCounter;
for(i = 0; i < 4; i++)
AveEndFit[i]=0;
//BA(4);
pso = fopen("pso1-4.txt", "a+");
fprintf(pso, "num\tw\tc1\tc2\tfuncnum\tavggen\tratio\tfinalresult\n");
/*for(i = 0; i < N; i++)
{
for(j = 0; j < N; j++)
printf("%d,", t[i][j]);
printf("\n");
}*/
x = 0.7298;
c1 = 2.05;
for(varc1 = 0; varc1 < 1; varc1++)
{
c2 = 2.05;
for(varc2 = 0; varc2 < 1 ; varc2++)
{
for(vfun = 1; vfun < 5; vfun++)
{
for(i = 0; i < testnum; i++)
{
results[2*i] = gennum;
results[2*i+1] = 0;
}
if(vfun == 1)
{
edge = 100;
Vmax = edge;
goal = 0.01;
}
if(vfun == 2)
{
edge = 30;
Vmax = edge;
goal = 100;
}
if(vfun == 3)
{
edge = 5.12;
Vmax = edge;
goal = 100;
}
if(vfun == 4)
{
edge = 600;
Vmax = edge;
goal = 0.1;
}
int ngoal = 0, avggen = 0;
sucCounter = 0;
for(vtest = 0; vtest < testnum; vtest++)
{
int sum = 1;
for(i = 0; i < coornum; i++)
{
pbest[i] = INT_MAX;
}
for(i = 0; i < dim + 1; i++) //粒子初始化；
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
coor[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * edge - edge;
vel[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * Vmax - Vmax;
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
//printf("%f\t", coor[(dim+1)*j+i]);
}
else
{
// i=dim
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
//printf("\n%d:%f,", j, coor[(dim+1)*j+i]);
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
}
}
}
/*for(i = 0; i < coornum; i++)
{
printf("\nabc:%f,%f", coor[i], pbest[i]);
if(i % (dim + 1) == dim)
printf("\n");
}*/
for(vgen = 0; vgen < gennum; vgen++) //gennum代进化；
{
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
/*
int pm_k;
float ran[N],numerator=0;
for(pm_k = 0; pm_k < N; pm_k++)
{
ran[pm_k]=(double)rand() / RAND_MAX * (c1+c2) / N;
//printf(" %f ",ran[pm_k]);
}
for(pm_k = 0; pm_k < N; pm_k++)
{
numerator += ran[pm_k]*pbest[(dim+1)*pm_k+i];
//printf(" %f ",numerator);
}
pm[(dim+1)*j+i] = numerator/N;
//printf(" %f ",pm[(dim+1)*j+i]);
*/
float r,acc=0;
int k;
for (k=0;k<N;k++){
r = (double)rand() / RAND_MAX * (c1+c2);
acc+=r*(pbest[(dim+1)*k+i]-coor[(dim+1)*j+i]);
}
acc/=N;
vel[(dim+1)*j+i] = x * ( vel[(dim+1)*j+i] + acc );
/*if(vel[(dim+1)*j+i] > Vmax)
vel[(dim+1)*j+i] = Vmax;
if(vel[(dim+1)*j+i] < -Vmax)
vel[(dim+1)*j+i] = -Vmax;*/
coor[(dim+1)*j+i] += vel[(dim+1)*j+i];
/*if(coor[(dim+1)*j+i] > edge)
{
coor[(dim+1)*j+i] = edge;
vel[(dim+1)*j+i] = 0;
}
if(coor[(dim+1)*j+i] < -edge)
{
coor[(dim+1)*j+i] = -edge;
vel[(dim+1)*j+i] = 0;
}*/
}
else
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
if(coor[(dim+1)*j+i] < pbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
pbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
}
}
}
gb = pbest[dim];
for(i = 1; i < N; i++)
if(pbest[(dim+1)*i+dim] < gb)
gb = pbest[(dim+1)*i+dim];
//printf(" %f ",gb);
if(gb < goal && sum != 0)
{
results[2*vtest] = (double)vgen;
results[2*vtest+1] = gb;
sum = 0;
//ngoal++;
printf("\ngb:%f,%d\t",gb,vgen);
sucCounter+=1;
}
if(vgen == gennum - 1)
{
printf("lastgb:%f\n",gb);
if(sum == 0) // Succeeded
AveEndFit[vfun-1] += gb;
else
results[2*vtest] = vgen;
}
} // End of for VGEN!
} // End of for VTEST !
if(sucCounter!=0)
fprintf(pso,"\n\n\nLast succeeded average gb fitness:%f\n",AveEndFit[vfun-1]/sucCounter);
else
fprintf(pso,"\n\n\nLast succeeded average gb fitness: U gotta be kidding, man!\n");
for(i = 0; i < testnum; i++)
{
if(results[2*i] != gennum - 1)
{
ngoal++;
avggen += results[2*i];
res += results[2*i+1];
}
}
printf("%d,%d", avggen/vtest, ngoal);
if(ngoal == 0)
avggennew = (double)gennum - 1;
else
avggennew = (double)avggen / ngoal;
fprintf(pso, "\n平均代数为：%f\n达优率为：%f%%", avggennew, (double)sucCounter / testnum * 100);
} // End of for VFUN!
c2 += 0.1;
}
c1 += 0.1;
}
fclose(pso);
}
int main()
{
srand((unsigned)time(NULL));
/*
Generic & Procedural Vars
*/
int i, j, k, l, vfun, vtest, vgen;
float edge, Vmax, goal, gb;
float vel[coornum], pbest[coornum], update[coornum];
/*
Vars for Radius
*/
float absRadius; // Absolute perceptive radius
float relRadius; // A iteration var for radius
/*
Vars for Real-time Recording
*/
int adjmat[N][N]; // Adjacent Matrix
float results[2*testnum],res = 0,avggennew=0; // Results[] can be used to record gb
int sucCounter, radRec;
/*
Vars for Storage Section
*/
float AveOptGen[relRange]; // FuncNumber*RadiusNumber: Every 19[radius] with a func
float AveOptRate[relRange]; // FuncNumber*RadiusNumber: Every 19[radius] with a func
//So the truth is, we're getting the average(a matrix) of average(a test)
//float AveOptFit[relRange][gennum/aveDegInterval+1]; // The average of the gbest fitness of the interval generations
float AveEndFit[relRange]; // End fit
float AveSucFit[relRange];// SUCCESSFUL EndFit The average of the gbest fitness in the end of each SUCCESSFUL test (last generation)
float FIndex[relRange], recordInd[testnum];
/* End of Storage Section */
for(i=0; i<relRange; i++)
{
AveOptGen[i]=0;
AveOptRate[i]=0;
AveSucFit[i]=0;
AveEndFit[i]=0;
FIndex[i]=99;
}
pso = fopen("../../vicfipso.txt", "a+");
radRec = 0; // Recording radius
for(relRadius = relStart; relRadius < relEnd; relRadius += relStep)
{
for(vfun = 3; vfun < 4; vfun++)
{
for(i = 0; i < testnum; i++)
{
results[2*i] = gennum;
results[2*i+1] = 0;
}
if(vfun == 1)
{
edge = 100;
Vmax = edge;
goal = 0.01;
}
if(vfun == 2)
{
edge = 30;
Vmax = edge;
goal = 100;
}
if(vfun == 3)
{
edge = 5.12;
Vmax = edge;
goal = 100;
}
if(vfun == 4)
{
edge = 600;
Vmax = edge;
goal = 0.1;
}
int ngoal = 0, avggen = 0;
sucCounter = 0;
for(vtest = 0; vtest < testnum; vtest++)
{
float neoDiag=0;
float dist=0;
int sum = 1;
for(i = 0; i < coornum; i++)
{
pbest[i] = INT_MAX;
}
for(i = 0; i < dim + 1; i++) //粒子初始化；
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
coor[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * edge - edge;
vel[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * Vmax - Vmax;
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
//printf("%f\t", coor[(dim+1)*j+i]);
}
else
{
// i=dim
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
//printf("\n%d:%f,", j, coor[(dim+1)*j+i]);
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
}
}
}
absRadius = relRadius * sqrt(dim * pow(2 * edge , 2));
for(j=0; j<N; j++)
for(k=0; k<N; k++) // Avoid Relapse
{
if( getDistance(j,k) <= absRadius && j!=k ) // k Can be perceived by j
{
adjmat[j][k]=1;
}
else
{
adjmat[j][k]=0;
}
}
//End of initialization
for(vgen = 0; vgen < gennum; vgen++) //gennum代进化；
{
get_vel_update(update, pbest, c1, c2, adjmat);
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
vel[(dim+1)*j+i] = x * ( vel[(dim+1)*j+i] + update[(dim+1)*j+i] );
/*if(vel[(dim+1)*j+i] > Vmax)
vel[(dim+1)*j+i] = Vmax;
if(vel[(dim+1)*j+i] < -Vmax)
vel[(dim+1)*j+i] = -Vmax;*/
coor[(dim+1)*j+i] += vel[(dim+1)*j+i];
/*if(coor[(dim+1)*j+i] > edge)
{
coor[(dim+1)*j+i] = edge;
vel[(dim+1)*j+i] = 0;
}
if(coor[(dim+1)*j+i] < -edge)
{
coor[(dim+1)*j+i] = -edge;
vel[(dim+1)*j+i] = 0;
}*/
}
else
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
if(coor[(dim+1)*j+i] < pbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
pbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
}
}
}
if( (vgen+1) % (changeInte) == 0 && vgen!=0)
{
//printf("%d,%f\n",vgen,neoDiag);
absRadius=relRadius*neoDiag;
}
neoDiag=0;// reset
for(j=0; j<N; j++)
for(k=0; k<N; k++) // Avoid Relapse
{
dist=getDistance(j,k);
if( getDistance(j,k) <= absRadius && j!=k ) // k Can be perceived by j
{
adjmat[j][k]=1;
}
else
{
adjmat[j][k]=0;
}
if( (vgen+1) % changeInte == (changeInte-1) )
if(dist>neoDiag)
{
neoDiag=dist;
//printf("%d,%d,dist:%f\t",j,k,dist);
}
}
gb = pbest[dim];
for(i = 1; i < N; i++)
if(pbest[(dim+1)*i+dim] < gb)
gb = pbest[(dim+1)*i+dim];
if(gb < goal && sum != 0)
{
results[2*vtest] = (double)vgen;
results[2*vtest+1] = gb;
sum = 0;
//ngoal++;
//printf("\ngb:%f,%d\t",gb,vgen);
sucCounter+=1;
}
if(vgen == 1000)
recordInd[vtest]=gb;
if(vgen == gennum - 1)
{
printf("lastgb:%1.30f\n",gb);
AveEndFit[radRec] += gb;
if(sum == 0) // Succeeded
AveSucFit[radRec] += gb;
else
results[2*vtest] = vgen;
}
} // End of for VGEN!
//printf("%1.30f",gb);
} // End of for VTEST !
FIndex[radRec]=countFIndex(recordInd);
AveEndFit[radRec] = AveEndFit[radRec]/testnum;
if(sucCounter!=0)
AveSucFit[radRec] = AveSucFit[radRec]/sucCounter;
for(i = 0; i < testnum; i++)
{
if(results[2*i] != gennum - 1)
{
ngoal++;
avggen += results[2*i];
res += results[2*i+1];
}
}
printf("%d,%d", avggen/vtest, ngoal);
if(ngoal == 0)
avggennew = (float)gennum - 1;
else
avggennew = (float)avggen / ngoal;
AveOptGen[radRec] = avggennew;
AveOptRate[radRec] = (float)sucCounter / testnum * 100;
//fprintf(pso, "\n平均达优代数为：%f\n达优率为：%f%%", avggennew, (double)sucCounter / testnum * 100);
} // End of for VFUN!
if(AveOptRate[radRec]==0){ //Failed in this radius
printf("%1.30f,-1,%f,%f,%f\n",AveEndFit[radRec],AveOptGen[radRec],AveOptRate[radRec],FIndex[radRec]); // Record a radius in a row, literally
fprintf(pso,"%1.30f,-1,%f,%f,%f\n",AveEndFit[radRec],AveOptGen[radRec],AveOptRate[radRec],FIndex[radRec]); // Record a radius in a row, literally
}
else {
printf("%1.30f,%1.30f,%f,%f,%f\n",AveEndFit[radRec],AveSucFit[radRec],AveOptGen[radRec],AveOptRate[radRec],FIndex[radRec]); // Record a radius in a row, literally
fprintf(pso,"%1.30f,%1.30f,%f,%f,%f\n",AveEndFit[radRec],AveSucFit[radRec],AveOptGen[radRec],AveOptRate[radRec],FIndex[radRec]); // Record a radius in a row, literally
}
radRec++;
} // End of relRadius
fclose(pso);
}
int main()
{
srand((unsigned)time(NULL));
/*
Generic & Procedural Vars
*/
int i, j, k, l, vfun, vtest, vgen;
double edge, Vmax, goal, gb;
/*
Vars for Real-time Recording
*/
int sucCounter;
/*
Vars for Storage Section
*/
double AveOptGen; // Average number of generations of success optimization
double AveOptRate; // Ratio of success tests/ total tests
double AveEndFit; // End fit
double AveSucFit;// SUCCESSFUL EndFit The average of the gbest fitness in the end of each SUCCESSFUL test (last generation)
double FIndex, recordInd[testnum];
/* End of Storage Section */
/*
Initialization of some variables
*/
AveOptGen=0;
AveOptRate=0;
AveSucFit=0;
AveEndFit=0;
FIndex=99; // Just a dummy and impossible value
pso = fopen("clpso.txt", "a+"); // We cannot use 'w' on the server in the lab in lack of privileges.
vfun=1;
switch(vfun)
{
case 1:
edge = 100;
goal = 0.01;
break;
case 2:
edge = 30;
goal = 100;
break;
case 3:
edge = 5.12;
goal = 100;
break;
case 4:
edge = 600;
goal = 0.1;
break;
default:
edge = 100;
goal = 0.01;
}
Vmax = edge;
//Vmax = edge/2;
//int ngoal = 0, avggen = 0;
sucCounter = 0;
for(vtest = 0; vtest < testnum; vtest++)
{
int sum = 1;
for(i = 0; i < coornum; i++)
{
pbest[i] = INT_MAX;
gbest[i] = INT_MAX;
}
for(i = 0; i < dim + 1; i++) //Initialization
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
coor[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * edge - edge;
vel[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * Vmax - Vmax;
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
//printf("%f\t", coor[(dim+1)*j+i]);
}
else
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
//printf("\n%d:%f,", j, coor[(dim+1)*j+i]);
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
if(coor[(dim+1)*j+i] < gbest[(dim+1)*j+i])
{
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
//printf("gbest:%f\t", gbest[(dim+1)*j+i]);
}
for(k = 0; k < N; k++)
if( gbest[(dim+1)*j+i] < gbest[(dim+1)*k+i])
{
//printf("t[%d][%d],",j,k);
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*k+l] = gbest[(dim+1)*j+l];
}
}
}
}
// refgap_flag: A flag for counting the refreshing gap
// ite_a: A iteration counting variable
// cl_rec: A 2-dim recording array for comprehensive learning
int refgap_flag = 0, ite_a, cl_rec[N];
for(vgen = 0; vgen < gennum; vgen++) //gennum´ú½ø»¯£»
{
if(refgap_flag == refgap )
refgap_flag = 0;
float inert_w;
inert_w = (wmax-wmin)*(gennum-vgen-1)/gennum +wmin;
for(i = 0; i < dim + 1; i++)
{
if(refgap_flag == 0 )
{
for(ite_a=0; ite_a<N; ite_a++)
{
float rand_p = (float) rand() / RAND_MAX * 1;
if(rand_p<=Prob_c)
{
// Tournament
int learnee1=ceil(rand() / RAND_MAX * N) - 1; // Get a integer number from 0 to N-1
int learnee2=ceil(rand() / RAND_MAX * N) - 1; // Get a integer number from 0 to N-1
if(pbest[(dim+1)*learnee1+dim]< pbest[(dim+1)*learnee2+dim])
cl_rec[ite_a] = learnee1;
else
cl_rec[ite_a] = learnee2;
// End of tournament
}
else
cl_rec[ite_a] = ite_a;
} // End of for(ite_a=0; ite_a<N; ite_a++; )
} // End of if(refgap_flag == 0 )
for(j = 0; j < N; j++)
{
if(i < dim)
{
double rand_1 = (double)rand() / RAND_MAX * 1;
//double r2 = (double)rand() / RAND_MAX * 1;
vel[(dim+1)*j+i] = inert_w * vel[(dim+1)*j+i] + para_c * rand_1 * (pbest[(dim+1)*cl_rec[j]+i] - coor[(dim+1)*j+i]);
//vel[(dim+1)*j+i] = getMin( getMax(vel[(dim+1)*j+i],(-Vmax) ),Vmax);
coor[(dim+1)*j+i] += vel[(dim+1)*j+i]; // Moving
}
else
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
if(coor[(dim+1)*j+i] < pbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
pbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
if(coor[(dim+1)*j+i] < gbest[(dim+1)*j+i])
{
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
}
for(k = 0; k < N; k++)
if( gbest[(dim+1)*j+i] < gbest[(dim+1)*k+i])
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*k+l] = gbest[(dim+1)*j+l];
} // End of if/else (i < dim)
} // End of for(j = 0; j < N; j++)
} // End of (i = 0; i < dim + 1; i++)
refgap_flag++;
gb = gbest[dim];
for(i = 1; i < N; i++)
if(gbest[(dim+1)*i+dim] < gb)
gb = gbest[(dim+1)*i+dim];
if(gb < goal && sum != 0)
{
sum = 0; // Change the flag
//ngoal++;
sucCounter += 1;
AveOptGen += vgen;
printf("suc gb:%1.30f\n",gb);
}
if(vgen == 1000)
recordInd[vtest]=gb;
if(vgen == gennum - 1)
{
printf("last gb:%1.30f\n",gb);
AveEndFit += gb;
if(sum == 0) // Succeeded
AveSucFit += gb;
}
} // End of for VGEN!
} // End of vtest
FIndex=countFIndex(recordInd);
AveEndFit = AveEndFit/testnum;
if(sucCounter!=0) // If succeeded
{
AveSucFit = AveSucFit/sucCounter;
AveOptGen = AveOptGen/sucCounter;
}
else
{
AveSucFit = -1; // A flag to show the failure
AveOptGen = -1; // A flag to show the failure
}
AveOptRate=(double) sucCounter / testnum * 100;
printf("%1.30f,%1.30f,%f,%f,%f\n",AveEndFit,AveSucFit,AveOptGen,AveOptRate,FIndex);
fprintf(pso,"%1.30f,%1.30f,%f,%f,%f\n",AveEndFit,AveSucFit,AveOptGen,AveOptRate,FIndex);
// AveSucFit is the Average Endfit for only successful runs
fclose(pso);
return 0;
}
int main()
{
srand((unsigned)time(NULL));
/*
Generic & Procedural Vars
*/
int i, j, k, l, vfun, vtest, vgen;
double edge, Vmax, goal, gb;
/*
Vars for Radius
*/
float absRadius; // Absolute perceptive radius
float relRadius; // A iteration var for radius
/*
Vars for Real-time Recording
*/
int adjmat[N][N]; // Adjacent Matrix
int sucCounter;
int radRec; // A var to count the index of the radius
/*
Vars for Storage Section
*/
double AveOptGen[relRange]; // Average number of generations of success optimization
double AveOptRate[relRange]; // Ratio of success tests/ total tests
double AveEndFit[relRange]; // End fit
double AveSucFit[relRange];// SUCCESSFUL EndFit The average of the lbest fitness in the end of each SUCCESSFUL test (last generation)
double FIndex[relRange], recordInd[testnum];
/* End of Storage Section */
/*
Initialization of some variables
*/
for(i=0; i<relRange; i++)
{
AveOptGen[i]=0;
AveOptRate[i]=0;
AveSucFit[i]=0;
AveEndFit[i]=0;
FIndex[i]=99; // Just a dummy and impossible value
}
pso = fopen("vicclpso.txt", "a+"); // We cannot use 'w' on the server in the lab in lack of privileges.
vfun=1;
switch(vfun)
{
case 1:
edge = 100;
goal = 0.01;
break;
case 2:
edge = 30;
goal = 100;
break;
case 3:
edge = 5.12;
goal = 100;
break;
case 4:
edge = 600;
goal = 0.1;
break;
default:
edge = 100;
goal = 0.01;
}
Vmax = edge;
//Vmax = edge/2;
radRec=0;
for(relRadius=relStart; relRadius<relEnd; relRadius+=relStep) // Loop layer 1 (relRadius)
{
//int ngoal = 0, avggen = 0;
sucCounter = 0;
for(vtest = 0; vtest < testnum; vtest++)
{
int sum = 1;
for(i = 0; i < coornum; i++)
{
pbest[i] = INT_MAX;
gbest[i] = INT_MAX;
}
for(i = 0; i < dim + 1; i++) //Initialization
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
coor[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * edge - edge;
vel[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * Vmax - Vmax;
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
//printf("%f\t", coor[(dim+1)*j+i]);
}
else
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
//printf("\n%d:%f,", j, coor[(dim+1)*j+i]);
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
}
}
} // End of for(i = 0; i < dim + 1; i++)
absRadius = relRadius * sqrt(dim * pow(2 * edge , 2));
for(j=0; j<N; j++)
for(k=0; k<N; k++) // Avoid Relapse
{
if( getDistance(j,k) <= absRadius && j!=k ) // k Can be perceived by j
{
adjmat[j][k]=1;
}
else
{
adjmat[j][k]=0;
}
}
// Updating each bird's gbest:
for(j=0; j<N; j++)
{
for(k=0; k<N; k++)
if( adjmat[j][k] != 0 ) // k Can be perceived by j
{
// Updating the gbest of j
//printf("%f\t",getDistance(j,k));
if( coor[(dim+1)*k+dim] < gbest[(dim+1)*j+dim] )
{
for(l=0; l<=dim; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*k+l];
}
}
//printf("gbest of %d:%f\nfitness of %d:%f\n",j,gbest[(dim+1)*j+dim],j,coor[(dim+1)*j+dim]);
}
gb = gbest[dim]; // Updating the global gbest
for(i = 1; i < N; i++)
if(gbest[(dim+1)*i+dim] < gb)
gb = gbest[(dim+1)*i+dim];
// End of Updating each bird's gbest in initialization
//End of initialization
// refgap_flag: A flag for counting the refreshing gap
// ite_a: A iteration counting variable
// cl_rec: A 2-dim recording array for comprehensive learning
int refgap_flag = 0, ite_a, cl_rec[N];
for(vgen = 0; vgen < gennum; vgen++) //gennum´ú½ø»¯£»
{
if(refgap_flag == refgap )
refgap_flag = 0;
float inert_w;
inert_w = (wmax-wmin)*(gennum-vgen-1)/gennum +wmin;
for(i = 0; i < dim + 1; i++)
{
if(refgap_flag == 0 )
{
for(ite_a=0; ite_a<N; ite_a++)
{
float rand_p = (float) rand() / RAND_MAX * 1;
if(rand_p<=Prob_c)
{
// Getting the learnee
// learnee 1
int lflag=0,learnee1,learnee2,ite_count;
ite_count = 0;
while( (lflag==0) && (ite_count<N) )
{
learnee1=floor(rand() / RAND_MAX * N); // Get a integer number from 0 to N-1
if(adjmat[learnee1][ite_a]!=0)
lflag = 1;
else
ite_count++;
}
if(ite_count==N)
learnee1 = ite_a;
// learnee 2
lflag=0;
ite_count = 0;
while( (lflag==0) && (ite_count<N) )
{
learnee2=floor(rand() / RAND_MAX * N); // Get a integer number from 0 to N-1
if(adjmat[learnee2][ite_a]!=0)
lflag = 1;
else
ite_count++;
}
if(ite_count==N)
learnee2 = ite_a;
// Tournament
//int learnee1=floor(rand() / RAND_MAX * N); // Get a integer number from 0 to N-1
//int learnee2=floor(rand() / RAND_MAX * N); // Get a integer number from 0 to N-1
if(pbest[(dim+1)*learnee1+dim]< pbest[(dim+1)*learnee2+dim])
cl_rec[ite_a] = learnee1;
else
cl_rec[ite_a] = learnee2;
// End of tournament
// End of Getting the learnee
}
else
cl_rec[ite_a] = ite_a;
//printf("clrec[%d]",cl_rec[ite_a]);
} // End of for(ite_a=0; ite_a<N; ite_a++; )
//printf("\n");
} // End of if(refgap_flag == refgap || refgap_flag == 0 )
for(j = 0; j < N; j++)
{
if(i < dim)
{
if(adjmat[cl_rec[j]][j]==0)
cl_rec[j]=j;
//printf("clrec[%d]",cl_rec[j]);
double rand_1 = (double)rand() / RAND_MAX * 1;
//double r2 = (double)rand() / RAND_MAX * 1;
vel[(dim+1)*j+i] = inert_w * vel[(dim+1)*j+i] + para_c * rand_1 * (pbest[(dim+1)*cl_rec[j]+i] - coor[(dim+1)*j+i]);
//vel[(dim+1)*j+i] = getMin( getMax(vel[(dim+1)*j+i],(-Vmax) ),Vmax);
coor[(dim+1)*j+i] += vel[(dim+1)*j+i]; // Moving
}
else
{
if(vfun == 1)
Fun1(j);
if(vfun == 2)
Fun2(j);
if(vfun == 3)
Fun3(j);
if(vfun == 4)
Fun4(j);
if(coor[(dim+1)*j+i] < pbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
pbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
} // End of if/else (i < dim)
} // End of for(j = 0; j < N; j++)
} // End of (i = 0; i < dim + 1; i++)
refgap_flag++;
// Producing the initiating Adjacent Matrix
for(j=0; j<N; j++)
for(k=0; k<N; k++) // Avoid Relapse
{
if( getDistance(j,k) <= absRadius && j!=k ) // k Can be perceived by j
{
adjmat[j][k]=1;
}
else
{
adjmat[j][k]=0;
}
}
// Updating each bird's gbest:
for( j=0; j<N ; j++ )
{
for( k=0; k<N ; k++ )
if( adjmat[j][k] != 0 ) // k Can be perceived by j
// Updating the gbest of j
if( coor[(dim+1)*k+dim] < gbest[(dim+1)*j+dim] )
for(l=0; l<=dim; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*k+l];
//printf("gbest of %d:%f\nfitness of %d:%f\n",j,gbest[(dim+1)*j+dim],j,coor[(dim+1)*j+dim]);
}
// End of Updating each bird's gbest
// Getting the global optimum
gb = gbest[dim];
for(i = 1; i < N; i++)
if(gbest[(dim+1)*i+dim] < gb)
gb = gbest[(dim+1)*i+dim];
// Evaluating
if(gb < goal && sum != 0)
{
sum = 0; // Change the flag
//ngoal++;
sucCounter += 1;
AveOptGen[radRec] += vgen;
printf("suc gb:%1.15f\n",gb);
}
if(vgen + 1 == 1000)
recordInd[vtest]=gb;
if(vgen == gennum - 1)
{
printf("last gb:%1.15f\n",gb);
AveEndFit[radRec] += gb;
if(sum == 0) // Succeeded
AveSucFit[radRec] += gb;
}
} // End of for VGEN!
} // End of vtest
FIndex[radRec]=countFIndex(recordInd);
AveEndFit[radRec] = AveEndFit[radRec]/testnum;
if(sucCounter!=0) // If succeeded
{
AveSucFit[radRec] = AveSucFit[radRec]/sucCounter;
AveOptGen[radRec] = AveOptGen[radRec]/sucCounter;
}
else
{
AveSucFit[radRec] = -1; // A flag to show the failure
AveOptGen[radRec] = -1; // A flag to show the failure
}
AveOptRate[radRec]=(double) sucCounter / testnum * 100;
printf("%1.30f,%1.30f,%f,%f,%f\n",AveEndFit[radRec],AveSucFit[radRec],AveOptGen[radRec],AveOptRate[radRec],FIndex[radRec]);
fprintf(pso,"%1.30f,%1.30f,%f,%f,%f\n",AveEndFit[radRec],AveSucFit[radRec],AveOptGen[radRec],AveOptRate[radRec],FIndex[radRec]);
// AveSucFit is the Average Endfit for only successful runs
radRec++;
printf("\n\nRadius %d is tested\n\n",radRec);
// AveSucFit is the Average Endfit for only successful runs
} // End of Loop layer 1 (relRadius)
printf("\n\n Done! You got it, dude!");
fclose(pso);
return 0;
}
