Jippendbc

Computer Programs for Optimization of Cam Profile Based on B - Spline

CAMGA
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<conio.h>
#defme PRECISION 9
#define popsize 40
#define nvar 40
#define nfunc 2
#define nconstr 4
#define gpopsize 80
#define divsn 520
#define weight (mass*9.80665)
#define pi 3.14159265

float pcross, pmut, nm, nc;

int generations,n=3 9,k=6;
float mass,preload,ks,kf,cs;
int speed=3000, constant=2;
double beta=130.0,campois-0.3, follpois=0.3;
double camyoung=2.0e5, follyoung=2.0e5;
float eccen=0.0, bcircrad=18.0,pcircrad=25.0,rr=7.0,conlen=15.0,width=15.0;
float kl=30.0,k2=26.25,lift=8.0,clearance=5.0,b=15.0,prd=10.0,mu=0.25;
float random seed, u[46];

typed ef struct
{
int rank,flag;
float var[nvar],crowd_dst,error,fitness[nfunc];
float disp[divsn+l ],vel[divsn+l ],accel[divsn+l ],jerk[divsn+l ],ping[divsn+l ];
float
cdisp[divsn+l],cvel[divsn+l],caccel[divsn+l],radcurv[divsn+l],load[divsn+l],comps
tress[divsn+l ],preang[divsn+l ],nload[divsn+l ];
} individual;

typedef struct
{
individual ind[popsize], *ind_ptr;
int maxrank, rankno[popsize], rankarfpopsize][popsize];
} population;

population oldpop,*old_pop_ptr,matepop,*mate_pop_ptr,newpop,*new_pop_ptr;

#include "random.h"
#include "initial.h"
#include "camforce.h"
#include "follchar.h"
#include "camchar.h"

163
 Appendixc

#include "curarea.h"
#include "mutation.h'
#include "cross.h"
#include "function.h"
#include "bspline.h"
#include "rank.h"
#include "select.h"
#include "weight.h"
#include "elitist.h"
//#include "output.h"

void main()
{
FILE *fpl,*fp2,*fp3,*fp4,*fp5,*fp6,*fp7,*fp8,*fp9,*fpl0,*fpl I,*fpl2,*fpl3,
*fpl4;
int i,j,s,m,t,gen=50;
printf("enter the values of \nseed b/n 0 to 1 \npc\npm\nnc\nnm\nno
ofgenerations\n");
scanf("%f%f%f%f%f%d",&random_seed,&pcross,&pmut,&nc,&nm,&genera
tions);
printf("enter the values of mass in Kgs\n ks in N/mm\n kf in N/mm\n cs in N-
S/mm\n preload in N\n ');
scanf("%P/of%f%f%f',&mass,&ks,&kf,&cs,&preload);
warmuprandom(randomseed);
for(i=0;i<popsize;i++)
{
for(j=0;j <popsize;j++)
{
oldpop.rankar[i][j]=0;
}
oldpop.rankno[i]=0;
oldpop.ind[i].error=0;
oldpop.ind[i] .crowd_dst=0;
}
//clrscr();
fp 14=fopen( "paretofront"w");
fclose(fpl4);
fp 1 =fopen(" outp ut"," w");
initialize();
old_pop_ptr=&(oldpop);
oldfunc(old_pop_ptr);
old_pop_ptr=&(oldpop);
ranking(old_pop_ptr);
m=oldpop.maxrank;
for(i=0;i<m;i++)
crowding(i+l);
printf("\n \t\t initialgeneration ");
fprintf(fpl,"\n \t\t initialgeneration ");
for(i=0;i<popsize;i++)
{
164
 jAppendhi

printf("\n");
fprintf(fpl,"\n");
if(oldpop.ind[i].error!=0.0)
{
fprintf(fpl ,"%d\t infeasible",i+1);
printf("%d\t infeasible", i+1);
}
else
{
fprintf(fp 1 ,"%d\t feasible",i+1);
printf("%d\t feasible",i+1);
}
for(j=0;j<nfimc;j++)
{
fprintf(fp 1, "\t%f',oldpop. ind[i]. fitness[j ]);
printf("\t%f',oldpop.ind[i].fitness[j]);
}
fprintf(fpl ,"\t %f',oldpop.ind[i].etTor);
printf("\t %f',oldpop.ind[i] .error);
}
fclose(fpl);
for(s=0;s<generations;s++)
{
fp 1 =fopen( "output"," a");
printf("\n");
old_pop_ptr=&(oldpop);
mate pop ptr=&(matepop);
selection(old_pop_ptr, mate_popjptr);
xover(new_pop_ptr,matejpop_ptr);
mutation(new_pop_ptr);
new_pop_ptr=&(newpop);
newfunc(new_pop_ptr);
old_pop_ptr=&(oldpop);
new_pop_ptr=&(newpop);
elitism();
for(i=0;i<popsize;i++)
{
for(j=0;j<nvar;j++)
oldpop.ind[i].var[j]=matepop.ind[i].var[j];
}
old_pop_ptr=&(oldpop);
oldfunc(old_pop__ptr);
old_pop_ptr=&(oldpop);
ranking(old_pop_ptr);
m=oldpop.maxrank;
for(i=0;i<m;i++)
crowding(i+l);
printf("\n");
fprintf(fpl,"\n");
printf("\n \t\t generation no=%d",s+l);

165
 Appendix.

fprintf(fpl,"\n\n \t\t generation no=%d",s+l);

for(i=0;i<popsize;i++)
{
printf("\n");
fprintf(fpl,"\n");
if(oldpop.ind[i].error!=0.0)
{
fprintf(fp 1 ,"%d\t infeasible",i+1);
printf("%d\t infeasible",i+1);
}
else
{
fprintf(fpl,"%d\t feasible",i+1);
printf("%d\t feasible",i+1);
}
for(j=0;j <nfunc;j++)
{
fprintf(fpl,"\t%f',oldpop.ind[i].fitness[j]);
printf("\t%f',oldpop.ind[i].fitness[j]);
}
printf("\t %f',oldpop.ind[i] .error);
fprintf(fpl,"\t %f',oldpop.ind[i].error);
}
fclose(fpl);
if(s+l==gen)
{
fp 14=fopen( "paretoffont", "a");
m=oldpop.rankno[0];
fprintf(fp 14,"Vn\n \t\t generation no=%d",s+l);
for(i=0;i<m;i++)
{
fprintf(fpl4,"V);
t=oldpop.rankar[0] [i];
for(j=0;j <nfunc;j ++)
{
fprintf(fpl,"\t%f',oldpop.ind[i].fitness[j]);
}
}
fclose(fpl4);
gen=gen+50;
}
//getch();
}
fpl=fopen("output","a");
for(i=0;i<popsize;i++)
{
tprintf(fpl,"\n\n %d ",i+l);
for(j=0 ;j <nvar;j++)
lprintf(^» 1, "\t%f' ,oldpop. ind [ i]. var[j ]);

166
 j-ippetidbi

printf("\n");
fprintf(fpl,"\n\n");
old_pop_ptr=&(oldpop);
pesudewei ght(o 1 d_pop_p tr);
printf("\t\t Weight vector");
fprintf(fpl,"\t\t weight vector");
m=oldpop.rankno[0];
for(i=0;i<m;i++)
{
t=oldpop.rankar[0] [i];
printf("\n%d",t+l);
fprintf(fpl,"\n%d",t+l);
for(j=0 ;j <nfunc;j++)
{
fprintf(fpl,"\t%f',pesuweight[i][j]);
printf( "\t%f\t" ,pesuweight[i] [j ]);
}
}
fclose(fpl);

fp2=fopen("disp","w");
for(i=0;i<popsize;i++)
{
fprintf(fp2,"\n\n %d ”,i+l);
for(j=0;j<=divsn;j++)
fprintf(fp2,"\t%f',oldpop.ind[i].disp[j]);
}
fclose(Q)2);

fp3=fopen("velocity","w");
for(i=0;i<popsize;i++)
{
fprintf(Q)3,"\n\n %d ",i+l);
for(j=0;j <=di vsn;j ++)
fprintf(fp3, "\t%f' ,oldpop. ind[i]. vel [j ]);
}
fclose(fp3);

fp4=fopen("accel","w");
for(i=0;i<popsize;i++)
{
fprintf(fp4,"\n\n %d ",i+l);
for(j=0;j<=divsn;j++)
fprintf(fp4,"\t%f',oldpop.ind[i].accel[j]);
}
fclose(tp4);

fp5=fopen("jerk","w");
for(i=0;i<popsize;i++)
{

167
 fprintfTfp5,"\n\n %d ",i+l);
for(j=0 ;j <=di vsn;j++)
fprintf(fp5,"\t%f',oldpop.ind[i].jerk[j]);
}
fclose(fp5);

fp6=fopen("pmg'7'w");
for(i=0;i<popsize;i++)
{
fprintf(fp6,"\n\n %d ",i+l);
for(j=0 ;j <=divsn;j++)
fprintf(fp6,"\t%f',oldpop.ind[i].ping[j]);
}
fclose(fp6);

Q)7=fopen(" camdi sp "," w");

for(i=0;i<popsize;i++)
{
fprintf(fp7,"\n\n %d ”,i+l);
for(j=0;j<=divsn;j++)
fprintf(fp7,"\t%f',oldpop.ind[i].cdisp[j]);
}
fclose(fp7);

Q)8=fopen("camvel","w");
for(i=0;i<popsize;i++)
{
fprintf(fp8,"\n\n %d ",i+l);
for(j=0;j <=di vsn;j++)
fyrint f( fp 8," \t %f', oldpop. ind [ i ]. cvel [j ]);
}
fclose(fp8);

fp9=fopen("camaccel","w");
for(i=0;i<popsize;i++)
{
fprintf(fp9,"\n\n %d ",i+l);
for(j=0;j<=divsn;j++)
fprintf(fp9,"\t%f',oldpop.ind[i].caccel[j]);
}
fclose(fp9);

fplO=fopen("load","w");
for(i-0;i<popsize;i++)
{
fprintf(fplO,"\n\n %d ",i+l);
for(j=0 ;j <=d i vsn;j++)
fprintf(fplO,"\t%f',oldpop.ind[i].load[j]);
}
fclose(fplO);

168
 Jippendvt

fpl l=fopen("radcurv","w");
for(i=0;i<popsize;i++)
{
fprintf(fpl l,"\n\n %d ",i+l);
for(j=0;j <=divsn;j++)
fprintf(fpl l,"\t%f',oldpop.ind[i].radcurv[j]);
}
fclose(fpll);

fpl2=fopen("compstress",''w");
for(i=0;i<popsize;i++)
{
fprintf(fpl2,"\n\n %d ",i+l);
for(j=0;j<=divsn;j++)
fprintf(fpl2,"\t%f',oldpop.ind[i].compstress[j]);
}
fclose(fpl2);
fpl 3=fopen("preang","w");
for(i=0; i<popsize;i++)
{
fprintf(fpl3,"\n\n %d ”,i+l);
for(j -0;j <=divsn;j++)
fprintf(fpl3,"\t%f',oldpop.ind[i].preang[j]);
}
fclose(fpl3);
getch();

169
 Appendix

Random
#include <math.h>

/* variables are declared static so that they cannot conflict with names of */

static double oldrand[55]; /* Array of 55

random numbers */
static intjrand; /*
current random number */
static double mdx2; /* used with random
normal deviate */
static int mdcalcflag; /* used with random
normal deviate */
void warmup_random( float randomseed);
void advance_random()
/* Create next batch of 55 random numbers */
{
int jl;
double newrandom;

for(jl = 0; jl <24; j 1 ++)

{
new random = oldrand[jl] - oldrand[jl+31];
iffnew random < 0.0) new random = new random + 1.0;
oldrand[j 1 ] = newrandom;
}
for(j 1 = 24; j 1 < 55; j 1 ++)
{
new random = oldrand [jl] - oldrand [j 1 -24];
if(new_random < 0.0) newrandom = newrandom + 1.0;
oldrand[j 1 ] = newrandom;
}
}

int flip(float prob)

/* Flip a biased coin - true if heads */
{
float randompercf);

if(randomperc() <= prob)

retum(l);
else
retum(0);
}
void initrandomnormaldeviate()
/* initialization routine for randomnormaldeviate */
{
mdcalcflag = 1;
}

170
 Jippemfui

double noise(double mu ,double sigma)

/* normal noise with specified mean & std dev: mu & sigma */
{
double randomnormaldeviate();

retum((randomnormaldeviate()*sigma) + mu);
}

//randomize(float randomseed)
/*Get seed number for random and start it up */
/*{
intjl;

for(jl=0; jl<=54; jl++) oldrandjjl] = 0.0;

jrand=0;

if(numfiles : 0)
{
do
{
fprintf(outfp," Enter random number seed, 0.0 to 1.0 -> ");
fscanf(infp,"%f', &randomseed);
}
while((randomseed < 0.0) || (randomseed > 1.0));
}
else
{
fscanf(infp,"%f', &randomseed);
}

warmuprandom(randomseed);
} */

double randomnormaldeviate()
/* random normal deviate after ACM algorithm 267 / Box-Muller Method */
{
float randomperc();
double t, mdx 1;

if(mdcalcflag)
{
mdxl = sqrt(- 2.0*log((double) randomperc()));
t = 6.2831853072 * (double) randomperc();
mdx2 = sin(t);
mdcalcflag = 0;
retum(mdxl * cos(t));
}
else
{

171
 flppendvt

mdcalcflag = 1;
retum(mdx2);
}
}

float randomperc()
/* Fetch a single random number between 0.0 and 1.0 - Subtractive Method */
/* See Knuth, D. (1969), v. 2 for details */
/* name changed from random() to avoid library conflicts on some machines*/
{
jrand++;
if(jrand >= 55)
{
jrand = 1;
advance_random();
}
retum((float) oldrandjjrand]);

int md(int low,int high)

/* Pick a random integer between low and high */
{
int i;
float randomperc();

if(low >= high)

i = low;
else
{
i = (randomperc() * (high - low + 1)) + low;
if(i > high) i = high;
}
retum(i);

float mdreal(float lo ,float hi)

/* real random number between specified limits */
{
retum((randomperc() * (hi - lo)) + lo);
}

void warmup_random( float random_seed)

/* Get random off and running */
{
int jl, ii;
double new random, prev random;

172
 Appendix

oldrand[54] = randomseed;
newrandom = 0.000000001;
prevrandom = randomseed;
for(jl = 1 ; jl <= 54; jl++)
{
ii = (21*jl)%54;
oldrand[ii] = new_random;
newrandom = prevrandom-newrandom;
if(new_random<0.0) new random = new random + 1.0;
prevrandom = oldrand[ii];
}

advance_random();
advance_random();
advance_random();

jrand = 0;

173
 Appendix

Initial

/* This is the program to initialize the data */

void initialize();

void initialize!)
{
int i,j;
float x,a,b;
for(j=0;j<popsize;j++)
{
for(i=0;i<=n;i++)
{
if(i<5)
oldpop.indyj.varfij^O.O;
else
{
if(i<16)
{
a=oldpop.ind[j] .var[i-1 ];
do
{
b=mdreal(0.0,l .0);
}
while(a>b||(b-a)>0.25);
oldpop.ind[j].var[i]-b;
}
else
{
if(i<24)
oldpop.ind[j ]. var[i]= 1.0;
else
{
if(i<35)
{
a=oldpop. ind[j ]. var[i-1 ];
do
{
b=mdreal(0.0,1.0);
}
while(a<b||(a-b)>0.25);
oldpop.ind[j].var[i]=b;
}
else
oldpop.ind[j].var[i]=0.0;
}
}
}
}

174
 Jippendvt

}
x=(1.0/(n+2-k));
for(i=0;i<=n+k;i++)
{
if(i<k)
u[i]=0.0;
else
{
if(i<=n)
u[i]=u[i-l]+x;
else
u[i]=l;
}
}

175
 Jlppendvt

CAMFORCE

/* This is the program to calculate the cam force */

#include<math.h>
float pressureangle(float a, float b);
float radiouscurvature(float dis, float ve, float acce);
float compressivestress(float camcur, float nload);
float contactforce(float a, float b, float c);
float normalforce(float fy, float exload);

float pressureangle(flcat a, float b)

{
float x,y,z,w,preang,s;
s=b*( 180/pi);
y=s-eccen;
z=sqrt(pow(pcircrad,2)-pow(eccen,2));
w=a+z;
x=y/w;
preang=atan(x);
retum(preang);
}

float radiouscurvature(float dis, float ve, float acce)

{
float x,y,z,a,b,c,d,e,f,g,s,t;
s=ve*( 180.0/pi);
t=acce*pow((l 80.0/pi),2);
x=pcircrad;
y=pow((x+dis),2);
z=pow(s,2);
a=pow((y+z),1.5);
b=s;
c=2*s;
d=(b*c)+y;
e=(x+dis)*t;
f=d-e;
g=a/f;
retum(g);
}

float compressivestress{float camcur, float n load)

{
float x,y,z,a,b,c,d,e,f,g;
if(n_Joad<=0.0)
g=0.0;

176
 JippendLp

else
{
x=1.0/rr;
y=l ,0/fabs(camcur);
z=n_load*(x+y);
a=l ,0-pow(campois,2);
b=l .0-pow(follpois,2);
c=a/camyoung;
d=b/fo 11 young;
e=conlen*(c+d);
f=z/e;
g=sqrt(f)*0.57;
}
retum(g);
}

float contactforce(float a, float b, float c)

{
float d,e,x,fc;
d=(36*((pow(speed,2)/pow(constant,2))));
e=(6*speed)/constant;
x-d/1000;
fc=(x!|£mass*c)+(e*cs*b)+(ks*a)+preload+weight;
retum(fc);
}

float normalforce(float fy, float exload)

{
float dis,z,zteta,p,q,r,s;

//dis:=pop3_ptr->ind_ptr->disp[j ];

//z=lift+clearance+rr;
//zteta=z-dis;
//p=2*mu*prd;
//q=mu*sin(fy)*((2*zteta)+b-p);
r=cos(fy);//-q;
s=exload/r;
retum(s);
}

177
 Jlppetldb^

FOLLCHAR

/* This is the program to calculate follower motion characteristics */

#include<math.h>
float displacement(float v,int i,population *pop3_ptr);
float velocity(float v,int i,population *pop3_ptr);
float accelaration(float v,int i,population *pop3_ptr);
float jerkr(float v,int i,population *pop3_ptr);
float pong(float v,int i,population *pop3_ptr);
float blen(int a,float b,int c);
float blender(int a,int b,float c,int d);

float displacement(float v,int i,population *pop3_ptr)

{
intj;
float pu,p,y;
pop3_ptr->ind_ptr=&(pop3_ptr->ind[i]);
pu=0;
for(j=0 ;j <=n;j++)
{
p=pop3_ptr->ind_ptr->var[j ];
pu=pu+p*blen(j,v,k);
}
y=pu*lift;
retum(y);
}

float velocity(float v,int i,population *pop3_ptr)

{
int j,m;
float vder,p,vel;
pop3_ptr->ind_ptr=&(pop3__ptr->ind[i]);
vder=0.0;
for(j=0 ;j <=n;j++)
{
p=pop3_ptr->ind_ptr->var[j ];
m=l;
vder=vder+(p*blender(m,j,v,k));
}
vel=vder*(lift/beta);
retum(vel);
}

float accelaration(float v,int i,population *pop3_ptr)

{
int j,m;

178
 JZppenduc

float ader,a,p;
pop3_ptr->ind_ptr=&(pop3_ptr->ind[i]);
ader=0.0;
for(j=0;j<-n;j++)
{
p=pop3_ptr->ind_ptr->var[j];
m=2;
ader=ader+p*blender(m,j ,v,k);
}
a=ader*(lift/pow(beta,2));
retum(a);
}

float jerkr(float v,int i,population *pop3_ptr)

{
int j,m;
float jderjrrk,p;
pop3_ptr->ind_ptr=&(pop3_ptr->ind[i]);
jder=0.0;
for(j=0;j<=n;j++)
{
p=pop3_ptr->ind_ptr->var[j ];
m=3;
j der=j der+p *bl ender(m,j, v,k);
}
jrrk=j der* (lift/pow(beta, 3));
retum(jrrk);
}

float pongffloat v,int i,population *pop3_ptr)

{
int j,m;
float jpder,jep,p;
pop3_ptr->ind_ptr=&(pop3_ptr->ind[i]);
jpder=0.0;
for(j=0 ;j <=n ;j++)
{
p=pop3_ptr->ind_ptr->var[j];
m=4;
jpder=jpder+p*blender(m,j,v,k);
}
j ep=(jpder* (li ft/po w(beta,4)));
retum(jep);
}

179
 Jlppendhc

CAMCHAR

/* This is the program to calculate cam profile characteristics */

#include<math.h>

float camdisplacement(float x, float y, float z);

float camvelocity(float x, float y, float z);
float camaccelarationffloat x, float y, float z);

float camdisplacement(float x, float y, float z)

{
float a,b,c,d,e,cdisp;
a=(preload/kf);
b=(mass/(kfc 1000));
c=((pow( speed,2)/pow(constant,2))*36);
d=((cs*6*speed)/(kf* constant));
e=((kf+ks)/kf);
cdisp=(a+(b*z*c)+(d*y)+(e*x));
retum(cdisp);
}

float camvelocity(float x, float y, float z)

{
float a,b,c,d,ve;
a=(mass/(kf! 1000));
b=((pow( speed,2)/pow(constant,2))*36);
c=((cs* 6 * speed)/(kf* constant));
d=((kf+ks)/kf);
ve=((a!|!b*z)+(c*y)+(d*x));
retum(ve);
}
float camaccelaration(float x, float y, float z)
{
float a,b,c,d,acce;
a=(mass/(kf: 1000));
b=((pow(speed,2)/pow(constant,2)) *36);
c=((cs * 6 * speed)/(kf* constant));
d=((kf+ks)/kf);
acce=((a*b*z)+(c*y)+(d*x));
retum(acce);
}

180
 jlppending

CURAREA

/* This is the program to calculate the area below the curve */

float area(float y[],int s);

float totalaccelaration(float a[], int s);

float area(float y[],int s)

{
int j;
float ar,w,x,a;
a=divsn;
x=1.0/a;
w=0.0;
for(j=1 ;j<divsn;j++)
w=w+y[j];
ar=(x/2)*(y[0]+y[divsn]+(2*w));
retum(ar);
}

float totalaccelaration(float a[], int s)

{
int j;
float x,c;
float b[divsn+l],sta,w;
c=divsn;
x= 1.0/c;
for(j=0;j<=divsn;j++)
{
b[j>pow(a[j],2);
}
w=0.0;
for(j=l;j<divsn;j++)
w=w+b[j];
sta=(x/2):(!(b[0]+b[divsn]+(2*w));
retum(sta);
}

181
 Jippetidbi

CROSS

/* This is the program to perform crossover */

void xover(population *new_pop_ptr,population *mate_pop_ptr);

float
l[nvar]= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
float
h[nvar]={0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0};

void xover(population *new_pop_ptr,population *mate_pop_ptr)

{
int i,j;
float al ,b 1 ,cl ,ul,beta,betaq,expp,t,alpha,pari ,par2,childl ,child2,a,b;
float randomperc();
for(i=0;i<popsize;i=i+2)
{
if(flip(pcross)==T)
{
for(j=0 ;j <nvar ;j++)
{
pari = mate_pop_ptr->ind[i].var[j];
par2 = mate_pop_ptr->ind[i+l].var[j];
if(flip(0.5)==l)
{
if(fabs(parl - par2)>0.000001)
{
if(parl > par2)
{
t=parl;
parl=par2;
par2=t;
}
al=parl-l[j];
bl=h[j]-par2;

cl=par2-parl;
if(al<bl)
beta=l+(2*al)/cl;
else
beta=l+(2*bl)/cl;
expp=l+nc;
beta=l/beta;
alpha=2 -po w(beta, expp);
if(alpha<=0.0)
{
printf("error");
exit(-l);
}

182
 Appendix

u 1 =randomperc();
if(ul<=1.0&&ul>=0.0)
ul=ul;
else
ul=0.4;
expp=l/(nc+l);
if(ul<=(l/alpha))
{
betaq=pow((alpha*ul ),expp);
}
else
{
if(alpha<0.0)
{
printf("error");
exit(-l);
}
betaq=pow(( 1 /(2-(alpha*ul ))),expp);
}
}
else
{
betaq=1.0;
}
child 1 =0.5*((par 1 +par2)-betaq*fabs(par2-parl));
child2=0.5 * ((par 1 +par2)+betaq* fabs(par2 -pari));
if(childl<l[i])
childl=l[j];
if(childl>h[j])
child l=h[j];
if(child2<l[j])
child2=l[j];
if(child2>h[j])
child2=h[j];
}
else
{
child l=parl;
child2-par2;
}
newpop.ind[i].var[j]=childl;
newpop.ind[i+1 ]. var[j]=child2;
}

mate_pop_ptr=&(matepop);
new_pop_ptr=&(newpop);
mate_pop_ptr->ind_ptr=&(mate_pop_ptr->ind[i]);
new_pop_ptr->ind_ptr=&(new_pop_ptr->ind[i]);

183
 Appendix.

for(j=0 ;j <nvar ;j++)

{
a=mate_popjptr->ind_ptr->var[j];
new_pop_ptr->ind_ptr->var [j ]=a;
}
mate_pop_ptr->ind_ptr=&(mate_pop_ptr->ind[i+1 ]);
new__pop_ptr->ind_ptr=&(new_pop_ptr->ind[i+l]);
for(j=0;j<nvar:j++)
{
b=mate_pop_ptr->ind_ptr->var[j ];
new_pop_ptr->ind_ptr->var[j]=b;
}
}

184
 Jlppendvc

FUNCTION

/* This is the program to calculate the objective functions and constraints */

void oldfunc(population *pop_ptr);

void newfunc(population *pop_ptr);

void oldfunc(population *pop_ptr)

{
float *fit_ptr, f[nfiinc],al[divsn+l],b;
float cstr[nconstr][divsn+l], cc,v,a,c,x,y,z,yl[divsn+l];
float disp,vel,accel jerk,ping;
float cdisp,cvel,caccel;
float radcurv,preang,load,nload,compstress;
float *err_ptr, error 1;
int i,j,s;
for(i=0;i<popsize;i++)
{
P°P_Ptr->ind_ptr=&(pop_ptr->ind[i]);
old_pop_ptr=&(oldpop);
for(j=0,v=0.0;j<=divsn;j++,v=v+( 1.0/divsn))
{
disp=displacement(v,i,old_pop_ptr);
yl[j]=disp;
pop_ptr->ind_ptr->di sp[j]—disp;
vel=velocity(v,i,old__pop__ptr);
PoP_ptr->ind_ptr-> vel [j ]=vel;
accel=accelaration(v,i,old_pop_ptr);
al [j]=accel*pow((l 80.0/pi),2);
pop_ptr->ind_ptr->accel [j]=accel;
j erk=j erkr(v,i,old_pop_ptr);
p0p_ptr->ind_ptr->j erk[j ]=j erk;
ping=pong(v,i,old_pop_ptr);
p0p_ptr->ind_ptr->ping[j ]=ping;

cdisp=camdisplacement(disp,vel,accel);
p0p_ptr->ind_ptr->cdisp[j]=cdisp;
cvel=camvelocity( vel,accel,jerk);
pop_ptr->ind_ptr->cvel [j]=cvel;
caccel=camaccelaration( accel,jerk,ping);
pop_ptr->ind_ptr->caccel[j]=caccel;

preang=pressureangle(cdisp,cvel);
pop_ptr->ind_ptr->preang[j]=preang*( 180.0/pi);

radcurv=radiouscurvature(cdisp,cvel,caccel);
pop_ptr->ind_ptr->radcurv[j]=radcurv;

185
load=contactforce(disp,vel,accel);
p°p_ptr->indjptr->load[j]=load;

nload=normalforce(preang,load);
p°p_ptr->ind_ptr->nload[j]=nload;

compstress=compressivestress(radcurv,nload);
p°p_ptr->ind_ptr->comp stress [j ]=compstres s;

a=(load-1)/fabs(load);
if(a<0.0)
cstr[0][j]=(1.0/a);
else
cstr[0][j]=a;
b=compstress;
if(b=0.0)
cstr[l][j]=0.0;
else
cstr[l][j]=(1480.0/b)-l;
x=cdisp;
y=preang;
z=tan(y);
c=kl/(k2-x);
if(z==0.0)
cstr[2][j]=0.0;
else
cstr[2][j]=fabs(c/z)-l;
if(radcurv>0.0)
cstr[3 ] [j]=(fabs(radcurv)/( 1.5 *rr))-1;
else
{
if(radcurv==0.0)
cstr[3][j]=-1.0;
else
cstr [3 ] [j ]=(5.0-( 1.0/fabs(radcurv)))/5 0.0;
}
}

fit_ptr=&(pop_ptr->indjptr->fitness[0]);
err_ptr=&(pop_ptr->ind_ptr->error);
a=area(yl,(divsn+l));
ft0]=(8-a);
b=totalaccelaration(a 1 ,divsn+1);
f[l]=b;

for(s=0;s<nfune;s++)
{
*fit_ptr++=f[s];
}
error 1=0.0;

186
 Jippeiufai

for(s=0; s<nconstr; s++)

{
for(j=0;j<=divsn;j++)
{
cc=cstr[s][j];
if(cc<0.0)
errorl=errorl-cc;
}
}
/*
for(j=0;j<=nvar;j++)
{
if(j<=(nvar/2))
{
a=pop_ptr->ind_ptr->var[j+1 ];
b=pop_ptr->ind_ptr->var[j];
c=a-b;
if(c<0.0)
errorl =errorl -c;
}
else
{
a=pop_ptr->ind_ptr->var[j-1 ];
b=pop_ptr->ind_ptr->var[j];
c=a-b;
if(c<0.0)
errorl =errorl-c;
}
}
*/
*err_ptr=errorl;
}
return;
}

void newfunc(population *pop_ptr)

{
float *fit_ptr, f[nfunc],al[divsn+l];
float x,y,z, cstr[nconstr][divsn+l],cc,v,a,b,c,yl[divsn+l];
float disp,vel,accel,jerk,ping;
float cdisp,cvel,caccel;
float radcurv,preang,load,nload,compstress;
float *err_ptr,errorl;
int i,j,s;

for(i=0;i<popsize;i++)
{
pop_ptr->ind_ptr=&(pop_ptr->ind [i ]);
new_pop_ptr=&(newpop);
for(j=0,v=0.0;j<=divsn;j++,v=v+( 1.0/divsn))

187
 JLppendbc

{
disp=displacement(v,i,new_pop_ptr);
yl[j]=disp;
p°p_ptr->ind_ptr->di sp [j ]=di sp;
vel=velocity(v,i,new_pop_ptr);
popj>tr->indj>tr->vel (j ] ==vel;
accel=accelaration(v,i,new_pop_ptr);
al [j]=accel*pow((l 80.0/pi), 2);
P°P__ptr->ind_ptr->accel [j ]=accel;
j erk=j erkr(v, i ,new_pop_ptr);
pop_ptr->ind_ptr->j erk[j ]=jerk;
ping=pong(v,i,new_pop_ptr);
P°P_ptr_>ind_ptr->ping[j ]=ping;

cdisp-camdisplacement(disp,vel,accel);
p°p_ptr->ind_ptr->cdisp[j]=cdisp;
cvel=camvelocity(vel,acceljerk);
P°P_Ptr->ind_ptr->cvel[j ]=cvel;
caccel=camaccelaration(accel,jerk,ping);
pop_ptr->ind_ptr->caccel [j ]=caccel;

preang=pressureangle(cdisp,cvel);
pop_ptr->ind_ptr->preang[j ] =preang;

radcurv=radiouscurvature(cdisp,cvel,caccel);
p°p_ptr->ind_ptr->radcurv[j]=radcurv;

load=contactforce(disp,vel,accel);
PoP_ptr->ind_ptr-> lo ad [j ]=lo ad;

nload=normalforce(preang,load);
pop_ptr->ind_ptr->nlo ad[j]=nload;

compstress=compressivestress(radcurv,nload);
pop_ptr->ind_ptr->compstress[j]=compstress;

a=(load-1 )/fabs(load);
if(a<0.0)
cstr[0][j]=(1.0/a);
else
cstr[0][j]=a;
b=compstress;
if(b==0.0)
cstr[l][j]=0.0;
else
estr[ 1 ] [j]=( 1480.0/b)-1;
x=cdisp;
y=preang;
z=tan(y);
c=kl/(k2-x);

188
 Jlppendvt

if(z=0.0)
cstr[2][j]=0.0;
else
cstr[2][j]=fabs(c/z)-1;
if(radcurv>0.0)
cstr[3][j]=(fabs(radcurv)/(l .5*rr))-l;
else
{
if(radcurv==0.0)
cstr[3][j]=-1.0;
else
cstr[3 ] [j ]=(5.0-( 1.0/fabs(radcurv)))/50.0;
}
}
fit_ptr=&(pop_ptr->ind_ptr->fitness[0]);
err_ptr=&(pop_ptr->ind_ptr->error);

a=area(yl ,(divsn+l));
f[0]=(8-a);

b=totalaccelaration(al ,divsn);
fll]=b;

for(s=0;s<nfimc;s++)
{
*fit_ptr++=f[s];
}

error 1=0.0;
for(s=0;s<nconstr;s++)
{
for(j=0;j<=divsn;j++)
{
cc=cstr[s][j];
if(cc<0.0)
errorl=errorl-cc;
}
}
/*
for(j=0;j<=nvar;j++)
{
if(j<=(nvar/2))
{
a=pop_ptr->ind_ptr->var[j+1 ];
b=pop_ptr->indjptr->var [j];
c=a-b;
if(c<0.0)
errorl=errorl-c;
}
else

189
 JLppendvt

a=pop_ptr->ind_ptr->var[j-1 ];
b=pop_ptr->ind_ptr->var[j];
c-a-b;
if(c<0.0)
errorl =errorl-c;
}
}
*/
*err_ptr=errorl;
}
return;
}

190
 Appendix

RANK

/* This the program to assign ranks and crowding distance to individuals */

float fparal[popsize][2];

void sort(int ml);

void crowding(int mk);
int indcmp3(float *ptrl, float *ptr2);
void ranking(population *pop_ptr);

void sort(int ml)

{
float temp, temp 1;
int i,s;
for(s=0;s<m 1 -1 ;s++)
{
for(i=s+l ;i<ml ;i++)
{
if(fparal[s] [ 1 ]>fparal[i] [ 1 ])
{
temp-fparal[s][ 1 ];
temp 1 =fparal [s] [0];
fparal[s][l]=fparal[i][l];
fparal[s] [0]=fparal[i] [0];
f|)aral[i][l]=temp;
fparal[i][0]=templ;
}
}
}
return;
}

void crowding(int mk)

{
float length[popsize][2], max, min, diff;
int i,j,ml,a;
m 1 =oldpop.rankno[mk-1 ];
for(j=0;j<nfunc;j++)
{
for(i=0;i<ml;i++)
{
fparal[i][0]=0;
fj)aral[i][l]=0;
}
for(i=0;i<ml;i++)
{
a=oldpop.rankar[mk-1 ] [i];

191
 Appendix

fparal[i][0]=a;
fparal[i][l]=oldpop.ind[a].fitness[j];
}
sort(ml);
max=fparal [m 1 -1 ] [ 1 ];
min=fparal[0][l];
diff=max-min;
for(i=0;i<ml;i++)
{
if(i==0| |i==(m 1 -1))
!
length[i][0]=fparal[i][0];
length[i] [ 1 ]=100*max;
}
else
{
lengthfi] [0]=fparal [i ] [0];
if(diff!=0)
length[i] [ 1 ]=fabs(fparal [i+1 ] [ 1 ] -fparal[i-1 ] [ 1 ])/diff;
else
length[i][l]=1.0;
}
}
for(i=0;i<ml;i++)
{
a=length[i][0];
oldpop.ind[a] .crowd_dst+=length[i] [ 1 ];
}
}
return;
}

int indcmp3(float *ptrl, float *ptr2)

{
float fitl[nfunc], fit2[nfunc];
int i,value,m,nl;
for(i=0; i<nfunc; i++)
{
fitl[i]=*ptrl++;
fit2[i]=*ptr2++;
}
m=0;
nl=0;
while(m<nfunc&«&fitl [m]<=fit2[m])
{
if(fitl [m]==fit2[m])
nl++;
m++;
}

192
 jlppendvt

if(m==nfunc)
{
if(nl==nfunc)
value=3;
else
value= 1;
}
else
{
m=0;
nl=0;
while(m<nfunc&&fit 1 [m]>=fit2[m])
{
if(fitl [m]==fit2[m])
nl++;
m++;
}
if(m==nfunc)
{
if(nl !=nfunc)
value=2;
else
value=3;
}
else
value=3;
}
retum( value);
}

void ranking(population *pop_ptr)

{
int i,j,s,mk,val,maxrank,q;
float *ptrl, *ptr2;
float *err_ptrl, *err_ptr2;
mk=0;
maxrank=0;
q=0;
for(j=0;j<popsize;j++)
{
pop_ptr->md[j].rank=0;
}
for(s=0;s<popsize;s++,q=0)
{
for(j=0;j<popsize;j++)
{
if(pop_ptr->ind[j ] .rank==0)
break;
}
if(j==popsize)

193
 Jippendbi

break;
mk=mk+l;
for(i=0;i<popsize;i++)
{
P°P_ptr->ind__ptr=&(pop_ptr->ind[i]);
if(pop_ptr->ind_ptr->rank==0)
{
ptrl=&(pop_ptr->ind_ptr->fitness[Oj);
err_ptr 1 =&(pop_ptr->ind_ptr->error);
for(j=0;j<popsize;j++)
{
if(i!=j)
{
i f(pop_ptr->ind [j ] .rank==01 |pop_ptr->ind [j ]. rank==mk)
{
p°p_ptr->ind_ptr=&(pop_ptr->ind[j]);
ptr2:=&(pop_ptr->ind_ptr->fitness[0]);
err_ptr2=&(pop_ptr->ind_ptr->error);
if(*err_ptrl <=0.0&&*err_ptr2>0.0)
continue;
else
{
if(*err_ptrl >0.0&&*errjptr2<=0.0)
break;
else
{
if(*err_ptrl > *err_ptr2)
break;
else
{
if(*errjptrl < *err_ptr2)
continue;
else
{
val=indcmp3(ptrl ,ptr2);
if(val-=2)
break;
if(val==l)
continue;
if(val==3)
continue;
}
}
}
}
}
}
}
if(j==popsize)
{

194
 J-lppetidhi

p°p_ptr->ind[i] ,rank=mk;
pop_ptr->rankar[mk-1 ] [q]=i;
q++;
}
}
}
pop_ptr->rankno[mk-1 ]=q;
}
p°p_ptr->maxrank=nik;
return;
}

195
 Appendix.

SELECT

/* This is the program to different individual get selected */

void selection(population *popl_ptr, population *pop2_ptr);

void selection(population *popl_ptr, population *pop2_ptr)

{
int *fit_ptrl, *fit_ptr2, i,s,rl,r2;
float *fl_ptr, *f2_ptr, *select_ptr,*sl_ptr, *s2_ptr;
for(s=0;s<popsize;s++)
{
pop2_ptr->ind_ptr=&(pop2_ptr->ind [ s]);
select_ptr=&(pop2_ptr->ind_ptr->var [0]);
r 1 =md(0,(popsize-1));
pop 1 _ptr->ind_ptr=&(pop 1 _ptr->ind[r 1 ]);
s 1 _ptr=&(pop l_ptr->ind_ptr->var[0]);
fit_ptr 1 =&(pop 1 _ptr->indjptr->rank);
f1 _ptr=&(pop 1 _ptr->ind_ptr->crowd_dst);
r2=md(0, (popsize-1));
pop 1 _ptr->ind_ptr=&(pop 1 _ptr->ind[r2]);
s2_ptr=&(pop 1 _ptr->ind_ptr->var[0]);
fit_ptr2=&(pop 1 _ptr->ind_ptr->rank);
f2_ptr=&(pop 1 _ptr->ind_ptr->crowddst);
if(*fit_ptr 1 >*fit_ptr2)
{
for(i=0;i<nvar;i++)
* select_ptr++=:|! s2_ptr++;
j

else
{
if(*fit_ptrl <*fit_ptr2)
{
for(i=0;i<nvar;i++)
* select_ptr++=*s 1 _ptr++;
}
else
{
if(*fl_ptr<*f2_ptr)
{
for(i=0;i<nvar;i++)
* select__ptr++=* s2_ptr++;
}
else
{
for(i=0;i<nvar;i++)
*select__ptr++r=*s 1 _ptr++;
}
}

196
 Jippendbc

}
}
return;
}

197
 J4pperufix_

WEIGHT
/* This is the program to calculate weight vector */

float pesuweight[popsize][nfunc];
float function[nfunc][2];
void weightsort(int s, population *pop_ptr);
void pesudeweight(population *pop_ptr);

void pesudeweight(population *pop_ptr)

{
int i,j,r,m,t;

float a,b,c,d,e,f,din;
for(i=0;i<nfunc;i++)
{

weightsort(i, pop_ptr);
}
m=pop_ptr->rankno [ 0];
for(i=0;i<nfunc;i++)
{
for(j=0;j<m;j++)
{
t=pop_ptr->rankar[0] [j];
if(pop_ptr->ind[t].fitness[i]!=function[i][0])
{
a=function[i] [0]-popptr->ind[t] ,fitness[i];
b=function[i] [0]-function[i] [ 1 ];
c=a/b;
din=0;
for(r=0;r<nfune;r++)
{
d=funetion[r][0]-pop_ptr->ind[t].fitness[r];
e=function[r] [0]-function[r] [ 1 ];
if(d!=0)
f=d/e;
else
f=0.0;
din=din+f;
}
pesuweight[j][i]=c/din;
}
else
pesuweight[j][i]=0.0;
}
}
}

void weightsortfint s, population *pop_ptr)

198
 jippendvt

float fitness[popsize], temp;

int i,r,m,t;
m~P°P_ptr->rankn°[0];
for(i=0;i<m;i++)
{
t=p°p_ptr->rankar[0] [i];
fitness[i]=pop_ptr->ind[t].fitness[s];
}
for(i=0;i<m-l ;i++)
{
for(r=i+l ;r<m;r++)
{
if(fitness[i]<fitness[r])
{
temp=fitness[i];
fitness[i]=fitness[r];
fitness[r]=temp;
}
}
}
function[s][0]=fitness[0];
function[s] [ 1 ]=fitness[m-1 ];
}

199
 jZppeiu&t

ELITIST

/* This is the program to apply elitisms */

typedef struct
{
int gmaxrank,grankar[gpopsize] [gpopsize],grankno[gpopsize];
individual indg[gpopsize], *indg ptr;
} globalpopulation;
globalpopulation globalpop, *global_pop_ptr;

float gparal[gpopsize][2];
void granking(globalpopulation *global_pop_ptr);
void gcrowdsort (int mk, int t);
void gcrowd(int rank);
void gsort(int ml);
void elitism();
void crowdsort (int mk, int t);

void gcrowdsort (int mk, int t)

{
int i,s,a;
float temp, tempi,gfparal[gpopsize][2];
for(i=0;i<t;i++)
{
a=globalpop.grankar[mk] [i];
gfparal[i][0]=a;
gfparal[i][l]=globalpop.indg[a].crowd_dst;
}
for(s=0;s<t-1 ;s++)
{
for(i=s+l;i<t;i++)
{
if(gfparal[s][ 1 ]<gfparal[i] [ 1 ])
{
temp=gfparal [s] [ 1 ];
temp 1 =gfparal [ s] [0];
gfparalfs] [ 1 ]=gfp aral [ i ] [ 1 ];
gfj}aral[s][0]=gfparal[i][0];
gtparal [i] [ 1 ]=temp;
gfparal [i] [0]=temp 1;
}
}
}
for(i=0;i<t;i++)
{
globalpop.grankar[mk][i]=gfparal[i][0];
}
return;

200
 Appendix.

void granking(globalpopulation *global_pop_ptr)

{
int i,j,s,mk,val,gmaxrank,q;

float *err_ptrl, *err_ptr2,*ptrl, *ptr2;

mk=0;
gmaxrank=0;
q=0;
for(j=0;j<gpopsize;j++)
{
global_pop_ptr->indg[j ] .rank=0;
}
for(s=0;s<gpopsize;s++,q=0)
{
for(j=0 ;j <gpopsize;j++)
{
if(global_pop_ptr->indg[j ] .rank==0)
break;
}
if(j==gpopsize)
break;
mk=mk+1;
for(i=0;i<gpopsize;i++)
{
global pop ptr->indg ptr=&(global pop ptr->indg|~il);
if(global_pop_ptr->indg_ptr->rank==0)
{
ptrl=&(global_pop_ptr->indg_ptr->fitness[0]);
err ptrl=&(global pop ptr->indg ptr->error);
for(j=0;j<gpopsize;j++)
{
if(i!=j)
{
if(global_pop_ptr->indg[j].rank==0||global_pop_ptr->indg[j].rank==mk)
{
global pop ptr->indg ptr=&(global pop ptr->indg[jl);
ptr2=&(global_pop_ptr->indg__ptr->fitness[ 0]);
err_ptr2=&(global_pop_ptr->indg_ptr->error);
iff *err_ptr 1 <=0.0&&* err_ptr2>0.0)
continue;
else
{
if(*err_ptrl >0.0&&*err_ptr2<=0.0)
break;
else
{
if(*err_ptrl > *err_ptr2)

201
 Jippendbi

break;
else
{
if(*err_ptrl < *err_ptr2)
continue;
else
{
val=indcmp3(ptrl ,ptr2);
if(val=2)
break;
if(val== 1)
continue;
if(val==3)
continue;
}
}
}
}
}
}
}
if(j==gpopsiz:e)
{
global_pop_ptr->indg[i] ,rank=mk;
global_pop_ptr->grankar[mk-1 ] [q]=i;

}
}
global_pop_ptr->grankno[mk-1 ]=q;
}
global_pop_ptr->gmaxrank=mk;
return;
}

void gcrowd(int rank)

{
float glength[gpopsize][2], max, min, diff;
int i,j,ml,a;
m 1 =globalpop.grankno[rank-1 ];
for(j=0;j<nfunc;j++)
{
for(i=0;i<ml ;i++)
{
gparal[i][0]=0;
gparal [i] [ 1 ]=0;
}
for(i=0;i<ml;i++)
{
a=globalpop.grankar[rank-1 ] [i];

202
 Jippendb^

gparal[i][0]=a;
gparal[i][l]=globalpop.indg[a].fitness[j];
}
gsort(ml);
max=gparal [m 1 -1 ] [ 1 ];
min=gparal[0][l];
diff=max-min;
for(i=0;i<ml ;i++)
{
if(i~011 i==(m 1 -1))
{
glength[i] [0]—gparal[i] [0];
glength[i] [ 1 ]=100*max;
}
else
{
glength[i][0]=gparal[i][0];
glength[i][ 1 ]=fabs(gparal[i+1 ][ 1 ]-gparal[i-1 ] [ 1 ])/diff;
}
}
for(i=0;i<ml ;i++)
{
a=glength[i][0];
globalpop.indg[a] .crowd_dst+=glength[i] [ 1 ];
}
}
return;
}

void gsort(int m 1)
{
float temp, temp 1;
int i,s;
for(s=0;s<ml-l ;s++)
{
for(i=s+l ;i<ml ;i++)
{
if(gparal[s] [ 1 ]>gparal[i] [ 1 ])
{
temp=gp ar al [ s] [ 1 ];
templ=gparal[s][0];
gparal[s] [ 1 ]=gparal[i] [ 1 ];
gparaljs] [0]=gparal[i] [0];
gparal[i][ 1 ]=temp;
gparal[i][0]=templ;
}
}
}
return;
}

203
void elitism()
{
int i,j,r,m,t,a,extra,sel,sum,diff;
diff=gpopsize-popsize;
for(i=0;i<gpopsize;i++)
{
for(j=0;j<gpopsize;j++)
globalpop.grankar[i][j]=0;
globalpop.grankno[i]=0;
globalpop.indg[i] .error=0;
globalpop.indg[;] .crowd_dst=0;
globalpop.indg[i] .rank=0;
globalpop.indg[i].flag=0;
}
for(i=0;i<popsize;i++)
{
for(r=0;r<nvar;r++)
globalpop.indg[i].var[r=newpop.ind[i].var[r];
for(j=0 ;j <nfunc ;j++)
globalpop.indg[i].fitness[j]=newpop.ind[i].fitness[j];
globalpop.indg[i].error=newpop.ind[i].error;
}
for(i=0;i<popsize;i++)
oldpop.ind[i].flag=0;
m=oldpop.maxrank;
sum=0;
for(j=0;j<m;j++)
{
t=oldpop.rankno[j ];
sum=sum+t;
if(sum<=diff)
{
for(i=0;i<t;i++)
{
a=oldpop.rankar[j] [i];
oldpop.ind[a].flag=l;
}
}
else
{
extra=sum-diff;
sel=t-extra;
crowdsort(j,t);
for(i=0;i<sel;i++)
{
a=oldpop.rankar[j][i];
oldpop.ind[a].flag=l;
}

204
 Appendix,

break;
}
}
for(r=0,i=popsize;r<popsize;r++)
{
if(oldpop.ind[r].flag==l)
{
globalpop.indg[i].error=oldpop.ind[r].error;
for(j=0 ;j <nvar;j++)
globalpop. indg[i]. var[j ]=oldpop. ind [r]. var[j ];
for(j=0 ;j <nfunc ;j++)
globalpop. indg[i].fitness[j]=oldpop.ind[r].fitness[j];
i=i+1;
}
}

globalpop.gmaxrank=0;
global_pop_ptr=&(globalpop);
granking(global_pop_ptr);
m=globalpop. gmaxrank;
for(i=0;i<m;i++)
{
gcrowd(i+l);
}
sum=0;
for(j=0;j<m;j++)
{
t=globalpop.grankno[j];
sum=sum+t;
if(sum<=popsize)
{
for(i=:0;i<t;i++)
{
a=globalpop.grankar[j] [i];
globalpop.indg[a].flag=l;
}
}
else
{
extra=sum-popsize;
sel=t-extra;
gcrowdsort(j,t);
for(i=0;i<sel;i++)
{
a=globalpop.grankar[j] [i];
globalpop.indg[ a].flag=l;
}
break;
}
}

205
for(r=0,i=0;r<gpopsize;r++)
{
if(globalpop.indg[r].flag==l)
{
for(j=0;j<nvar;j++)
matepop.ind[i].var[j]=globalpop.indg[r].var[j];
i=i+1;
}
}
return;
}

void crowdsort (int mk, int t)

{
int i,r,a;
float temp, templ,paral[popsize][2];
for(i=0;i<t;i++)
{
a=oldpop.rankar[mk] [i];
paral[i][0]=a;
paral[i] [ 1 ]=oldpop.ind[a] .crowddst;
}
for(r=0;r<t-1 ;r++)
{
for(i=r+l ;i<t;i++)
{
if(paral[r] [ 1 ]<paral[i] [ 1 ])
{
temp=paral[r][l];
temp 1 =paral [r] [0];
paral[r] [ 1 ]=paral[i] [ 1 ];
paral [r] [0]=paral[i] [0];
paral[i][l]=temp;
paral[i][0]=templ;
}
}
}
for(i=0;i<t;i++)
{
oldpop.rankar[mk] [i]=paral[i] [0];
}
return;
}

206