i know it's too much long but i really need some help to fix the program errors , am stuck within whole code lines and ma mind went confused .. it's airport simulation program
the airport has one runway .. one plane can land and one plane can fly but not both in same time.the plans are waiting kept in 2 queues for landing and taking off.
#include <iostream>
#include <time.h>
#include "random"
using namespace std;
enum Runway_activity { idle, land, flyingoff };
enum plane_status { null, arriving, departing };
struct queuetype{
int front, rear;
};
class Plane
{
private:
int f_num; int clock_start;
int state;
public:
Plane()
{
f_num = -1;
clock_start = -1;
state = null;
}
Plane(int flight, int time,int status)
{
f_num = flight;
clock_start = time;
state = status;
cout << " Plane number " << flight << " ready to ";
if (status == arriving)
cout << "land." << endl;
else
cout << "take off." << endl;
}
void refuse() const
{
cout << " Plane number " << f_num;
if (state == arriving)
cout << " directed to another airport" << endl;
else
cout << " told to try to takeoff again later" << endl;
}
void land(int time) const
{
int wait = time - clock_start;
cout << time << ": Plane number " << f_num << " landed after ";
cout<<wait<<" time unit"<<((wait==1) ? "" : "s");
cout << " in the takeoff queue." << endl;
}
void fly(int time) const
{
int wait = time - clock_start;
cout << time << ": Plane number " << f_num;
cout << " took off after ";
cout << wait << " time unit" << ((wait == 1) ? "" : "s");
cout << " in the takeoff queue." << endl;
}
int empty(queuetype q){
if (q.front == q.rear)
return 1;
else
return 0;
}
int started() const { return clock_start; }
};
class Runway
{
private:
int queue_limit;
int num_land_requests; // number of planes asking to land
int num_takeoff_requests; // number of planes asking totake off
int num_landings; // number of planes that have landed
int num_takeoffs; //number of planes that have taken off
int num_land_accepted; // number of planes queued to land
int num_takeoff_accepted; // number of planes queued to take off
int num_land_refused; // number of landing planes refused
int num_takeoff_refused; // number of departing planes refused
int land_wait; //total_time of planes_waiting to land
int takeoff_wait; //total_time of planes_waiting to take off
int idle_time; //total_time runway is idle
public:
Plane landing;
Plane takeoff;
Runway(int limit)
{
queue_limit = limit;
num_land_requests = num_takeoff_requests = 0;
num_landings = num_takeoffs = 0;
num_land_refused = num_takeoff_refused = 0;
num_land_accepted = num_takeoff_accepted = 0;
land_wait = takeoff_wait = idle_time = 0;
}
int can_land(const Plane ¤t)
{
int result;
if (landing.size()<queue_limit)
result = landing.enqueue(current);
else
result = false;
num_land_requests++;
if (result != true)
num_land_refused++;
else
num_land_accepted++;
return result;
}
int can_depart(const Plane ¤t)
{
int result;
if (takeoff.size() < queue_limit)
result = takeoff.enqueue(current);
else
result = false;
num_takeoff_requests++;
if (result != true)
num_takeoff_refused++;
else
num_takeoff_accepted++;
return result;
}
Runway_activity activity(int time, Plane &moving)
{
Runway_activity in_progress;
if (!landing.empty())
{
landing.dequeue(moving);
land_wait += time - moving.started();
num_landings++; in_progress = land;
landing.serve();
}
else if (!takeoff.empty())
{
takeoff.dequeue(moving);
takeoff_wait += time - moving.started();
num_takeoffs++; in_progress = flyingoff;
takeoff.serve();
}
else{
idle_time++;
in_progress = idle;
}
return in_progress;
}
void finish(int time) const;
};
void initialize(int&, int&, double&, double&);
void run_idle(int);
void main()
{
int end_time; //time to run simulation
int queue_limit; //size of Runway queues
int flight_number = 0;
double arrival_rate, departure_rate;
start(end_time, queue_limit, arrival_rate,departure_rate);
random variable;
Runway airport(queue_limit);
for (int current_time = 0; current_time<end_time; current_time++)
{
int number_arrivals = variable.poisson(arrival_rate);
for (int i = 0; i<number_arrivals; i++){
Plane current_plane(flight_number++, current_time, arriving);
if (airport.can_land(current_plane) != true)
current_plane.refuse();
}
int number_departures = variable.poisson(departure_rate);
for (int j = 0; j<number_departures; j++)
{
Plane current_plane(flight_number++,current_time,departing);
if (airport.can_depart(current_plane) != true)
current_plane.refuse();
}Plane moving_plane;
switch (airport.activity(current_time,moving_plane))
{
case land: moving_plane.land(current_time); break;
case flyingoff: moving_plane.fly(current_time); break;
case idle: run_idle(current_time);
}
}
airport.finish(end_time);
}
void start(int &end_time, int &queue_limit, double &arrival_rate, double &departure_rate)
{
cout << "This program simulates an airport with onlyone runway. ";
cout << "One plane can land or depart in each unit of time.\n";
cout << "number of planes can be waiting to land or take off at any time : " ;
cin >> queue_limit;
cout << "How many units of time will the simulation run?\n";
cin >> end_time;
bool acceptable;
do{
cout << "Expected number of arrivals per unit time :";
cin >> arrival_rate;
cout << "Expected number of departures per unit time :";
cin >> departure_rate;
if (arrival_rate < 0.0 || departure_rate<0.0)
cout << " These_rates must be positive. ";
else
acceptable = true;
if (acceptable && arrival_rate + departure_rate>1.0){
cout << "One plane can land or depart in each unit of time.\n";
cout << "what number of planes can be waiting to land or take off at any time? ";
cin >> queue_limit;
cout << "How many units of time will the simulation run?\n";
cin >> end_time;
do{
cout << "Expected number of arrivals per unit time ? ";
cin >> arrival_rate;
cout << "Expected number of departures per unit time?";
cin >> departure_rate;
if (arrival_rate < 0.0 || departure_rate<0.0)
cout << " These_rates must be positive. " << endl;
else
acceptable = true;
if (acceptable && arrival_rate + departure_rate>1.0)
cout << "Safety Warning: This airport will become full";
} while (!acceptable);
}
}
void Runway::finish(int time) const
{
cout << "\n\nSimulation has concluded after " << time;
cout << " time units.\n Total number of planes processed ";
cout << (num_land_requests + num_takeoff_requests) << endl;
cout << "Total number of planes asking to land ";
cout << num_land_requests << endl;
cout << "Total number of planes asking to take off ";
cout << num_takeoff_requests << endl;
cout << "Total number of planes accepted for landing ";
cout << num_land_accepted << endl;
cout << "Total number of planes accepted for takeoff ";
cout << num_takeoff_accepted << endl; cout << "Total number of planes refused for landing ";
cout << num_land_refused << endl;
cout << "Total number of planes refused for takeoff ";
cout << num_takeoff_refused << endl;
cout << "Total number of planes that landed ";
cout << num_landings << endl;
cout << "Total number of planes that took off ";
cout << num_takeoffs << endl;
cout << "Total number of planes left in landing queue ";
cout << landing.size() << endl;
cout << "Total number of planes left in takeoff queue ";
cout << takeoff.size() << endl;
cout << "Percentage of time runway idle " << (100.0*(float)idle_time) / ((float)time) << "%" << endl;
cout << "Average wait in landing queue "<< ((float)land_wait) / ((float)num_landings) << " time units " << endl;
cout << "Average wait in takeoff queue"<< ((float)takeoff_wait) / ((float)num_takeoffs)<< "time units" << endl;
cout << "Average observed rate of planes wanting to land";
cout << ((float)num_land_requests) / ((float)time)<< " per time unit " << endl;
cout << "Average observed rate of planes wanting to take off ";
cout << ((float)num_takeoff_requests) / ((float)time) << " per time unit " << endl;
}
