People arrive at a self-service cafeteria at the rate of one every 30±20 seconds

Question

People arrive at a self-service cafeteria at the rate of one every 30±20 seconds. Forty percent go to the sandwich counter, where one worker makes a sandwich in 60±30 seconds. The rest goes to the main counter, where one server spoons the prepared meal onto the plate in 45±30seconds. All customers must pay a single cashier, which takes 25±10 seconds for all customers, eating takes 20±10 minutes. After eating 10%of the people go back for desert spending an additional 10±2 minutes altogether in the cafeteria. Simulate until 100 people have left the cafeteria. How many people are left in the cafeteria, and what are they doing, and at the time the simulation stops.

Explanation / Answer

#include<iostream>
#include <cmath>
#include "lcgrand.h"
using namespace std;
const int Queu_Limit=100;
const int BUSY=1;
const int IDLE=0;

int
choice,
Num_Completed_Customers,
Number_of_Events,   
Number_in_Queue,
Server_Status;

double
End_Time,
Type_Next_Event,
Mean_interArrival_Time,
Mean_service_Time,
Clock,
Time_Arrival[Queu_Limit + 1],
Service_Time[Queu_Limit + 1],
Next_Arrival_Time,
Next_Completion_Time,
Next_Service_Time,
Total_Flow_Time,
Progres_Arrival_Time,
Progres_Completion_Time,
Waiting_Time;
void initialize();
void Timing();
void Arrival();
void Completition();
float expon(float mean);
void Search_Min(double[],double[]);

int main()
{

initialize();   

cout<<" * Single-server queueing system with fixed run * ";

cout<<" _________________________________________________"<<endl;
  
cout<<" 1.First In First Out"<<endl;

cout<<" 2.Minimum Processing Time"<<endl<<endl;

do
{
cout<<" Enter your Policy: ";

cin>>choice;

}while(choice>2||choice<1);

cout<<" Mean Inter arrival Time: "<<Mean_interArrival_Time;

cout<<" Mean Service Time: "<<Mean_service_Time<<endl;

cout<<"The End of Simulation Time: "<<End_Time<<endl<<endl;
  

while(true)
{

Timing();

if(Clock>End_Time)
break;

switch (int(Type_Next_Event))
{

case 1:
Arrival();
break;

case 2:
Completition();
break;
}
}
  
  

cout<<" Total Flow Time: "<<Total_Flow_Time;

cout<<" Total Waiting Time in Queue: "<<Waiting_Time;

cout<<" Average Waiting Time in Queue: "<<Waiting_Time / Num_Completed_Customers;

cout<<" Average Flow Time: "<<Total_Flow_Time / Num_Completed_Customers;

cout<<" Number of Completed Customers: "<<Num_Completed_Customers;

cout<<" Average Number of Customers In System / Unit Time: "<<Num_Completed_Customers / Clock<<endl<<endl;
  
return 0;
}

void initialize()
{

Number_of_Events = 2;

Mean_interArrival_Time=1.0;

Mean_service_Time=0.5;

End_Time=100.0;

Clock = 0.0;

Server_Status = IDLE;

Number_in_Queue = 0;

Num_Completed_Customers = 0;

Total_Flow_Time = 0.0;

Waiting_Time = 0.0;

Next_Arrival_Time = Clock + expon(Mean_interArrival_Time);//Arriving

Next_Service_Time = expon(Mean_service_Time);

Next_Completion_Time = 1.0e+10;
Progres_Arrival_Time=0.0;

Progres_Completion_Time = 0.0;
}

void Timing()
{
Type_Next_Event = 0;

if(Next_Arrival_Time < Next_Completion_Time)
{

Type_Next_Event = 1;

Clock=Next_Arrival_Time;

}

else
{
Type_Next_Event = 2;

Clock = Next_Completion_Time;

}

if (Type_Next_Event == 0)
{
cout<<" Event List Empty at Time: "<<Clock;
  
exit(1);
}   

}

void Arrival()
{
if (Server_Status == BUSY)
{
++Number_in_Queue;

if (Number_in_Queue > Queu_Limit)
{
cout<<" Overflow of the array time_arrival at";

cout<<"time: "<<Clock;

exit(2);
}

Time_Arrival[Number_in_Queue] = Clock;

Service_Time[Number_in_Queue] = Next_Service_Time;

}

else
{
Server_Status = BUSY;

Next_Completion_Time = Clock + Next_Service_Time;

Progres_Arrival_Time = Next_Arrival_Time;

Progres_Completion_Time = Next_Completion_Time;

}

Next_Arrival_Time = Clock + expon(Mean_interArrival_Time);

Next_Service_Time = expon(Mean_service_Time);


}

void Completition()
{

double Delay;

++Num_Completed_Customers;

Total_Flow_Time+= ( Progres_Completion_Time - Progres_Arrival_Time );


if (Number_in_Queue == 0)
{
Server_Status= IDLE;

Next_Completion_Time = 1.0e+10;
}

else
{

if(choice==2)
Search_Min(Time_Arrival,Service_Time);

Delay= Clock - Time_Arrival[1];

Waiting_Time+= Delay;

Next_Completion_Time = Clock + Service_Time[1];

Progres_Arrival_Time = Time_Arrival[1];

Progres_Completion_Time = Next_Completion_Time;

--Number_in_Queue;

for (int i=1;i<=Number_in_Queue;i++)
{
Time_Arrival[i] = Time_Arrival[i + 1];

Service_Time[i] = Service_Time[i + 1];
}

}
}

void Search_Min(double A_time[],double S_time[])
{
int Min=1;

double temp;

for(int i=1;i<Number_in_Queue;i++)
if(S_time[Min]>S_time[i+1])
Min=i+1;

temp=S_time[1];
S_time[1]=S_time[Min];
S_time[Min]=temp;

temp=A_time[1];
A_time[1]=A_time[Min];
A_time[Min]=temp;

}

float expon(float mean)
{
return (-mean * log(lcgrand(1)));
}

lcgrand.h:
cpp code
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
float lcgrand(int stream);

#define MODLUS 2147483647
#define MULT1 24112
#define MULT2 26143

static long zrng[] =
{ 1,
1973272912, 281629770, 20006270,1280689831,2096730329,1933576050,
913566091, 246780520,1363774876, 604901985,1511192140,1259851944,
824064364, 150493284, 242708531, 75253171,1964472944,1202299975,
233217322,1911216000, 726370533, 403498145, 993232223,1103205531,
762430696,1922803170,1385516923, 76271663, 413682397, 726466604,
336157058,1432650381,1120463904, 595778810, 877722890,1046574445,
68911991,2088367019, 748545416, 622401386,2122378830, 640690903,
1774806513,2132545692,2079249579, 78130110, 852776735,1187867272,
1351423507,1645973084,1997049139, 922510944,2045512870, 898585771,
243649545,1004818771, 773686062, 403188473, 372279877,1901633463,
498067494,2087759558, 493157915, 597104727,1530940798,1814496276,
536444882,1663153658, 855503735, 67784357,1432404475, 619691088,
119025595, 880802310, 176192644,1116780070, 277854671,1366580350,
1142483975,2026948561,1053920743, 786262391,1792203830,1494667770,
1923011392,1433700034,1244184613,1147297105, 539712780,1545929719,
190641742,1645390429, 264907697, 620389253,1502074852, 927711160,
364849192,2049576050, 638580085, 547070247 };

float lcgrand(int stream)
{
long zi, lowprd, hi31;

zi = zrng[stream];
lowprd = (zi & 65535) * MULT1;
hi31 = (zi >> 16) * MULT1 + (lowprd >> 16);
zi = ((lowprd & 65535) - MODLUS) +
((hi31 & 32767) << 16) + (hi31 >> 15);
if (zi < 0) zi += MODLUS;
lowprd = (zi & 65535) * MULT2;
hi31 = (zi >> 16) * MULT2 + (lowprd >> 16);
zi = ((lowprd & 65535) - MODLUS) +
((hi31 & 32767) << 16) + (hi31 >> 15);
if (zi < 0) zi += MODLUS;
zrng[stream] = zi;
return (zi >> 7 | 1) / 16777216.0;
}

Related Questions

Navigate

• Browse (All)
• Browse P
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.