#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<ctype.h>
#include<math.h>
#include<time.h>
#include<limits.h>
#define MAX 3
#define ARRIVE 0
#define DEPART 1
struct plane
{
int id; /* Identification no. of the plane */
int tm;
};
struct queue
{
int count;
int front;
int rear;
struct plane p[MAX];
};
void initqueue(struct queue *);
void addqueue(struct queue *,struct plane);
struct plane delqueue(struct queue *);
int size(struct queue);
int empty(struct queue);
int full(struct queue);
void initqueue(struct queue *pq)
{
pq->count=0;
pq->front=0;
pq->rear=-1;
}
void addqueue(struct queue *pq,struct plane item)
{
if(pq->count >= MAX)
{
printf("\n QUEUE is full .\n");
return;
}
(pq->count)++;
pq->rear=(pq->rear+1)%MAX;
pq->p[pq->rear]=item;
}
struct plane delqueue(struct queue *pq)
{
struct plane pl;
if(pq->count <= 0)
{
printf("\n QUEUE is Empty.\n ");
pl.id=0;
pl.tm=0;
}
else
{
(pq->count)--;
pl=pq->p[pq->front];
pq->front=(pq->front+1)%MAX;
}
return pl;
}
int size(struct queue q)
{
return q.count;
}
int empty(struct queue q)
{
return (q.count <= 0);
}
int full(struct queue q)
{
return (q.count>=MAX);
}
struct airport
{
struct queue landing;
struct queue takeoff;
struct queue *pl;
struct queue *pt;
int idletime; // Numberv of units when runway is idle
int landwait; // Total waiting time for planes landed
int takeoffwait; // Total waiting time for take off;
int nland; // No. of planes landed
int nplanes; // No. of planes processed so far
int nrefuse; // No. of planes refused of airport
int ntakeoff; // No. of planes taken off
struct plane pln;
};
void initairport(struct airport *);
void start(int *,double *,double *);
void newplane(struct airport *,int ,int );
void refuse(struct airport *,int);
void land(struct airport * ,struct plane,int);
void fly(struct airport*,struct plane,int);
void idle(struct airport *,int);
void conclude(struct airport *,int);
int randomnumber(double);
void apaddqueue(struct airport *,char);
struct plane apdelqueue(struct airport *,char);
int apsize(struct airport,char);
int apfull(struct airport,char);
int apempty(struct airport,char);
void myrandomize();
void initairport(struct airport *ap)
{
initqueue(&(ap->landing));
initqueue(&(ap->takeoff));
ap->pl=&(ap->landing);
ap->pt=&(ap->takeoff);
ap->nplanes=ap->nland=ap->ntakeoff=ap->nrefuse=0;
ap->landwait=ap->takeoffwait=ap->idletime=0;
}
void start(int *endtime,double *expectarrive,double *expectdepart)
{
int flag=0;
char wish;
printf("\n Program that stimulates an airport with only one runway.\n");
/* Instruct User */
printf(" One plane can land or depart in each unit of time . \n");
printf(" Up to %d planes can be waiting to land or takeoff at any time .\n",MAX);
printf(" How many units of time will the stimulation run ?");
/* Input parameter */
scanf("%d",endtime);
myrandomize();
do
{
printf("\n Expected number of arrivals per unit time ? ");
/* Error checking */
scanf("%lf",expectarrive);
printf("\n Expected nu,ber of departures per unit time ? ");
scanf("%lf",expectdepart);
if(*expectarrive < 0.0 || *expectarrive < 0.0)
{
printf(" These numbers must be nonnegative .\n");
flag=0;
}
else
{
if(*expectarrive + *expectdepart > 1.0)
{
printf(" The airport will become saturated. Read new numbers ? ");
fflush(stdin);
scanf("%c",&wish);
if(tolower(wish)=='y')
flag=0;
else
flag=1;
}
else
flag=1;
}
}while(flag==0);
}
void newplane(struct airport *ap,int curtime,int action)
/* Newplane: make a new record for a plane , update nplanes */
{
(ap->nplanes)++;
ap->pln.id=ap->nplanes;
ap->pln.tm=curtime;
switch(action)
{
case ARRIVE:
printf("\n");
printf(" Plane %d ready to land . \n",ap->nplanes);
break;
case DEPART:
printf("\nPlane %d ready to take iff .\n",ap->nplanes);
break;
}
}
void refuse(struct airport *ap,int action)
/* refuses : processes the plane when queue is full */
{
switch(action)
{
case ARRIVE:
printf("\tplane %d directed to another airport .\n",ap->pln.id);
break;
case DEPART:
printf("\tplane %d told to try later .\n",ap->pln.id);
break;
}
(ap->nrefuse)++;
}
void land(struct airport *ap,struct plane pl,int curtime)
/* Land :processa plane p that is actually landing */
{
int wait;
wait=curtime-pl.tm;
printf("%d : Plane %d landed",curtime,pl.id);
printf(" in queue %d units \n",wait);
(ap->nland)++;
(ap->landwait)+=wait;
}
void fly(struct airport *ap,struct plane pl,int curtime)
/* Fly : process a plane p that i actually landing */
{
int wait;
wait=curtime-pl.tm;
printf("%d : Plane %d took off ",curtime,pl.id);
printf(" in queue %d units \n",wait);
(ap->ntakeoff)++;
(ap->takeoffwait)+=wait;
}
void idle(struct airport *ap,int curtime)
/* Idle : updates variables for idle runway */
{
printf("%d : Runway is idle \n",curtime);
ap->idletime++;
}
void conclude(struct airport *ap,int endtime)
/* Conclude : write out statistics and conclude simulation */
{
printf("\t Simulation has concluded after %d units . \n",endtime);
printf("\t Total number of planes processed : %d\n",ap->nplanes);
printf("\t Number if planes landed : %d\n",ap->nland);
printf("\t Number of planes taken off : %d\n",ap->ntakeoff);
printf("\t Number of planes refused use %d \n",ap->nrefuse);
printf("\t Number left ready to land : %d \n",apsize(*ap,'l'));
printf("\t Number left ready to take off : %d\n",apsize(*ap,'t'));
if(endtime > 0)
printf("\t Percentage of time runway idle : %lf \n",((double)ap->idletime/endtime)*100.0);
if(ap->nland > 0)
printf("\t Average wait time to land : %lf \n",((double)ap->landwait/ap->nland));
if(ap->ntakeoff > 0)
printf("\t Average wait time to takeoff : %lf \n",((double)ap->takeoffwait/ap->ntakeoff));
}
int randomnumber(double expectedvalue)
/* Randomnumber : generates a pseudorandom integer according to the Poisson Distribution */
{
int n=0; /* Counter of iterations*/
double em;
double x; /* Pseudorandom number */
em=exp(-expectedvalue);
x=rand()/(double)INT_MAX;
while(x > em)
{
n++;
x*=rand()/(double)INT_MAX;
}
return n;
}
void apaddqueue(struct airport *ap,char type)
{
switch(tolower(type))
{
case 'l' :
addqueue(ap->pl,ap->pln);
break;
case 't' :
addqueue(ap->pt,ap->pln);
break;
}
}
struct plane apdelqueue(struct airport *ap,char type)
{
struct plane pl;
switch(tolower(type))
{
case 'l':
pl=delqueue(ap->pl);
break;
case 't':
pl=delqueue(ap->pl);
break;
}
return pl;
}
int apsize(struct airport ap,char type)
{
switch(tolower(type))
{
case 'l':
return(size(*(ap.pl)));
case 't':
return(size(*(ap.pt)));
}
return 0;
}
int apfull(struct airport ap,char type)
{
switch(tolower(type))
{
case 'l': return(full(*(ap.pl)));
case 't': return(full(*(ap.pt)));
}
return 0;
}
int apempty(struct airport ap,char type)
{
switch(tolower(type))
{
case 'l': return(empty(*(ap.pl)));
case 't': return(empty(*(ap.pt)));
}
return 0;
}
void myrandomize()
/* Sets starting point for pseudorandom numbers */
{
srand((unsigned int) (time(NULL)%10000));
}
void main()
{
struct airport a;
int i;
int pri; /* Pseudorandom integer */
int curtime; /* Current time ; one unit = time for takeoff and landing */
int endtime; /* Total number of time units to run */
double expectarrive; /* Number of planes arriving in one unt */
double expectdepart; /* Number of planes newly ready to take off */
struct plane temp;
clrscr();
initairport(&a);
start(&endtime,&expectarrive,&expectdepart);
for(curtime=1;curtime<=endtime;curtime++)
{
pri=randomnumber(expectarrive);
for(i=1;i<=pri;i++) /* Add to landing queue */
{
newplane(&a,curtime,ARRIVE);
if(apfull(a,'l'))
refuse(&a,ARRIVE);
else
apaddqueue(&a,'l');
}
pri=randomnumber(expectdepart);
for(i=1;i<=pri;i++) /* Add to take off queue*/
{
newplane(&a,curtime,DEPART);
if(apfull(a,'t'))
refuse(&a,DEPART);
else
apaddqueue(&a,'t');
}
if(!(apempty(a,'l'))) /* Bring plane to land */
{
temp=apdelqueue(&a,'l');
land(&a,temp,curtime);
}
else
{
if(!(apempty(a,'t'))) /* Allow plane to takeoff */
{
temp=apdelqueue(&a,'t');
fly(&a,temp,curtime);
}
else
idle(&a,curtime); /* Runway Idle */
}
}
conclude(&a,endtime); /* Finish simulation */
getch();
}
No comments:
Post a Comment