Have something to say? Contribute New Article Reply to this Article
Queueing Simulation
Working on a simulation which closely resembles waiting in a line at a bank. Program runs the simulation based on the user's inputs of # of servers, simulation time, average time between arrival, and transaction time. Here's what I have so far:
/*~~~prog3.cpp~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| |
| |
| Author: Megan MacDonald |
| Date Completed: April 3, 2009 |
| Class: CSC 2110, section 002 |
| Tennessee Technological University |
| |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include <iostream>
#include <string>
using namespace std;
#include "Control.h"
#include "server.h"
#include "Queue_of_Jobs.h"
#define Max_Server 10
#define Min_Server 0
#define Max_simTime 10000
#define Min_simTime 0
#define Max_transTime 100
#define Min_transTime 0
#define Max_arrivalTime 100
#define Min_arrivalTime 0
int main()
{
int servers, simTime, transTime, arrivalTime;
//get parameters
cout<<"Number of Servers? ";
cin>>servers;
cout << endl;
while (servers > Max_Server || servers < Min_Server)
{
cout << "The number of servers you entered is outside of scope. " << endl
<< "Please enter a number between 0 & 10: ";
cin >> servers;
cout << endl;
}
cout<<"Simulation Time? ";
cin>>simTime;
cout << endl;
while (simTime > Max_simTime || simTime < Min_simTime)
{
cout << "The simulation time you entered is outside of scope. " << endl
<< "Please enter a number between 0 & 10000: ";
cin >> simTime;
cout << endl;
}
cout<<"Transition Time? ";
cin>>transTime;
cout << endl;
while (transTime > Max_transTime || transTime < Min_transTime)
{
cout << "The transaction time you entered is outside of scope. " << endl
<< "Please enter a number between 0 & 100: ";
cin >> transTime;
cout << endl;
}
cout<<"Arrival Time? ";
cin>>arrivalTime;
cout << endl;
while (arrivalTime > Max_arrivalTime || arrivalTime < Min_arrivalTime)
{
cout << "The arrival time you entered is outside of scope. " << endl
<<"Please enter a number between 0 & 100: ";
cin >> arrivalTime;
cout << endl;
}
cout<<servers<<endl;
cout<<simTime<<endl;
cout<<transTime<<endl;
cout<<arrivalTime<<endl;
Control c;
Server s;
Queue_of_Jobs q;
Job temp;
int clock;
int t; //used for random number
int tempTime; //used for time of customer in front
int waitTime; //used to calculate the job's wait time
s.insert(servers);
s.display();
cout << endl << endl;
for (clock=0; clock<simTime; clock++)
{
t=rand()%5;
if(q.checkForNewJob(t))
{
temp.inTime = clock;
q.enqueue(temp);
cout << "Customer enqueued" << endl;
}
else
cout << "Customer did not arrive" << endl;
if (q.checkLine())
cout << "There is a customer waiting in line" << endl;
int tempFront=q.front();
if (q.dequeue())
{
waitTime = clock - tempFront;
cout << "Wait Time of Customer is: " << waitTime << endl;
cout << "~~~~~A Customer was DeQueued~~~" << endl;
}
c.totalWait(waitTime);
//check servers
//update servers
cout << "*************************************" << endl;
}
}/*~~~server.h~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| |
| |
| Author: Megan MacDonald |
| Date Completed: April 3, 2009 |
| Class: CSC 2110, section 002 |
| Tennessee Technological University |
| |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include <iostream>
#include <string>
using namespace std;
typedef int ServerType;
class Server
{
private:
int mySize;
class Node
{
public:
int data;
Node * next;
Node(int ident){
data = ident;
next = NULL;
}
};
typedef Node * NodePointer;
NodePointer first;
public:
Server();
bool isAvailable();
void engage();
void disEngage();
void insert(int numServers);
void display();
};/*~~~server.cpp~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| |
| |
| Author: Megan MacDonald |
| Date Completed: April 3, 2009 |
| Class: CSC 2110, section 002 |
| Tennessee Technological University |
| |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include <iostream>
using namespace std;
#include "server.h"
Server::Server()
{
first = NULL;
mySize = 0;
}
bool Server::isAvailable()
{
}
void Server::engage()
{
}
void Server::disEngage()
{
}
void Server::insert(int numServers)
{
cout << "MySize: " << mySize << endl;
int index;
int i;
for (index=0; index<numServers; index++)
{
NodePointer nPtr = new Node(index);
if (index == 0)
{
nPtr->next = first;
first = nPtr;
}
else
{
NodePointer predPtr = first;
for (i=0; i==mySize; i++)
{
predPtr = predPtr->next;
}
nPtr->next = predPtr->next;
predPtr->next = nPtr;
}
mySize++;
}
cout << "MySize: " << mySize << endl;
}
void Server::display()
{
NodePointer ptr;
ptr = first;
while (ptr != NULL)
{
cout << ptr->data;
ptr = ptr->next;
}
}/*~~~Queue_of_Jobs.h~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| |
| |
| Author: Megan MacDonald |
| Date Completed: April 3, 2009 |
| Class: CSC 2110, section 002 |
| Tennessee Technological University |
| |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include <iostream>
#include <string>
using namespace std;
typedef struct Job ElementType;
#define capacity 100
struct Job
{
int inTime;
};
class Queue_of_Jobs
{
private:
ElementType myArray[capacity];
int mySize;
int frontOfQueue;
int back;
int count;
public:
Queue_of_Jobs();
bool enqueue(ElementType newJob);
bool dequeue();
int front();
int size();
bool checkForNewJob(int number);
bool checkLine();
};/*~~~job.cpp~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| |
| |
| Author: Megan MacDonald |
| Date Completed: April 3, 2009 |
| Class: CSC 2110, section 002 |
| Tennessee Technological University |
| |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include <iostream>
#include <ctime>
#include <cstdlib>
#include "Queue_of_Jobs.h"
Queue_of_Jobs::Queue_of_Jobs()
{
mySize = 0;
frontOfQueue = 0;
back = 0;
count = 0;
}
bool Queue_of_Jobs::enqueue(ElementType newJob)
{
if (mySize == capacity)
{
cout << "Queue if full." << endl;
return false;
}
else
{
myArray[back] = newJob;
back = (back + 1)%capacity;
count++;
mySize++;
return true;
}
}
bool Queue_of_Jobs::dequeue()
{
if (front() == 0) //Queue is empty
{
cout << "Queue was empty - could not remove a customer." << endl;
return false;
}
else
{
ElementType j = myArray[frontOfQueue];
if (frontOfQueue == capacity)
{
frontOfQueue = 0;
}
frontOfQueue = frontOfQueue + 1;
count--;
mySize--;
cout << "Front of queue: " << frontOfQueue << endl;
return true;
}
}
int Queue_of_Jobs::front()
{
if (checkLine())
{
ElementType j = myArray[frontOfQueue];
return (j.inTime);
}
else
{
//Queue is empty
return 0;
}
}
int Queue_of_Jobs::size()
{
mySize = (back - frontOfQueue)%capacity;
return mySize;
}
bool Queue_of_Jobs::checkForNewJob(int number)
{
if (number%2)
return true;
else
return false;
}
bool Queue_of_Jobs::checkLine()
{
if (count >= 1)
return true;
else
return false;
}/*~~~Control.h~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| |
| |
| Author: Megan MacDonald |
| Date Completed: April 3, 2009 |
| Class: CSC 2110, section 002 |
| Tennessee Technological University |
| |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include <iostream>
class Control
{
private:
int averageWaitTime;
int totalWaitTime;
public:
Control();
int totalWait(int waittime);
int averageWait(int numJobs);
void display();
};/*~~~Control.h~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| |
| |
| Author: Megan MacDonald |
| Date Completed: April 3, 2009 |
| Class: CSC 2110, section 002 |
| Tennessee Technological University |
| |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include <iostream>
using namespace std;
#include "Control.h"
Control::Control()
{
totalWaitTime = 0;
averageWaitTime = 0;
}
int Control::totalWait(int waittime)
{
totalWaitTime = totalWaitTime + waittime;
}
int Control::averageWait(int numJobs)
{
averageWaitTime = totalWaitTime / numJobs;
}
void Control::display()
{
cout << "Total Wait Time: " << totalWaitTime << endl;
cout << "Average Wait Time was: " << averageWaitTime << endl;
}I'm not sure what you are looking for but the structure looks good. I didn't analyze it but it *looks* well written, which I have to say is quite refreshing to see.
ArkM: Thanks for the tip on inserting the code -- didn't realize there was a difference.
Also, this is a presentation, rather a work in progress: I felt like sharing:icon_cool:
And thanks Adam
Just one thing; shouldn't the last file's header docs be control.cpp? not control.h
You have two control.h's
Ok here's the finished program :)
/*~~~prog3.cpp~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| "Waiting ...waiting... Next!" |
| Program 3: A Queuing Simulation |
| |
| This program creates a simulation similar to that of a bank line. |
| The program starts by receiving the user's input data for the |
| number of server, the simulation time, the transaction time, |
| and the average arrival time. Then the program checks to make |
| sure the data is within the scope. |
| Once data is within scope, program commences. The servers are |
| inserted and the transaction_time is initialized. |
| Then the main loop of the simulation commences: the clock is used |
| as an incrementor and when clock reaces simulation time, |
| simulation ends. |
| First, the simulation checks for a new customer. If there is one, |
| the job is enqueued with the current clock as its input value. |
| The number of jobs enqueued is incremented. |
| Next, the program checks the line for any jobs as a test. |
| Then, the program runs through the servers. First, if a server is |
| available and there is someone in line, a job gets dequeued. |
| Then the wait time for that job is computed and added to the |
| total wait time and that server is engaged. |
| Another for loop checks the servers for if they are not available. |
| If they aren't available, their transaction time is |
| incremented. |
| Then, the servers are check to see if they have reached the |
| transaction_time, and if they have they are disEngaged. |
| Outside of the clock/simulation loop, the number of jobs left in |
| the queue are calculated, along with how long those in the |
| queue have waited thus far. |
| Finally, the number of jobs left, their wait time, the total wait |
| time, and the average wait time per job is displayed. |
| |
| Author: Megan MacDonald |
| Date Completed: April 3, 2009 |
| Class: CSC 2110, section 002 |
| Tennessee Technological University |
| |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include <iostream>
#include <string>
using namespace std;
#include "Control.h"
#include "server.h"
#include "Queue_of_Jobs.h"
#define Max_Server 10 //sets the define statements...
#define Min_Server 0
#define Max_simTime 10000
#define Min_simTime 0
#define Max_transTime 100
#define Min_transTime 0
#define Max_arrivalTime 100
#define Min_arrivalTime 0
int main()
{
Control c; //creating objects...
Server s;
Queue_of_Jobs q;
Job temp;
int clock; //used for running simulation
int i; //used in for loop
int t; //used for random number
int tempTime; //used for time of customer in front
int waitTime; //used to calculate the job's wait time
int servers, simTime, transTime, arrivalTime; //declares input variables
int numberOfJobsEnqueued = 0;
int numberOfJobsDequeued = 0;
cout<<"Number of Servers? ";
cin>>servers; //sets the servers to the user's input
cout << endl;
while (servers > Max_Server || servers < Min_Server) //checks to make sure value is w/in scope
{
cout << "The number of servers you entered is outside of scope. " << endl
<< "Please enter a number between 0 & 10: ";
cin >> servers;
cout << endl;
}
cout<<"Simulation Time? ";
cin>>simTime; //sets the simulation time to the user's input
cout << endl;
while (simTime > Max_simTime || simTime < Min_simTime) //checks to make sure value is w/in scope
{
cout << "The simulation time you entered is outside of scope. " << endl
<< "Please enter a number between 0 & 10000: ";
cin >> simTime;
cout << endl;
}
cout<<"Transaction Time? ";
cin>>transTime; //sets the transaction time to the user's input
cout << endl;
while (transTime > Max_transTime || transTime < Min_transTime) //checks to make sure value is w/in scope
{
cout << "The transaction time you entered is outside of scope. " << endl
<< "Please enter a number between 0 & 100: ";
cin >> transTime;
cout << endl;
}
cout<<"Arrival Time? ";
cin>>arrivalTime; //sets the average arrival time to the user's input
cout << endl;
while (arrivalTime > Max_arrivalTime || arrivalTime < Min_arrivalTime) //checks to make sure value is w/in scope
{
cout << "The arrival time you entered is outside of scope. " << endl
<<"Please enter a number between 0 & 100: ";
cin >> arrivalTime;
cout << endl;
}
s.setTransaction(transTime); //setting the transaction_time...
s.insert(servers); //creating the servers...
cout << "Display: " << endl;
s.display(); //displays the server list...
cout << endl << endl;
/*Time simulation using the user's input for simulation
length and incrementing the clock until it reaches
the simulation time.*/
for (clock=0; clock<simTime; clock++)
{
t=rand()%arrivalTime; //random number generator bbased on average arival time
if(q.checkForNewJob(t)) //checks for a job based on the random number
{
temp.inTime = clock; //sets the in time to the clock
q.enqueue(temp); //enqueue the clock's time
numberOfJobsEnqueued++;
cout << "Customer Arrived" << endl;
}
else
cout << "Customer did not arrive" << endl;
if (q.checkLine()) //checks to see if there is anyone waiting
cout << "There is a customer waiting in line" << endl;
int tempFront=q.front(); //temporary storage for the value at front of the queue
for (i=0; i<servers; i++) //for loop runs from 0 to number of servers
{
if (s.isAvailable(i) && q.checkLine()) //if a server is available and...
{
if (q.dequeue()) //and if dequeue is successful..
{
waitTime = clock - tempFront; //wait time for job is current time minus the in time for job
cout << "~~~~~A Customer was DeQueued~~~" << endl;
cout << "Wait Time of Customer is: " << waitTime << endl;
s.engage(i);
}
cout << "A server was successfully engaged" << endl;
c.totalWait(waitTime); //and total wait time is updated.
}//end if isAvailable
}//end server for loop
for (i=0; i<servers; i++) //for loop runs from 0 to number of servers
{
if (!s.isAvailable(i))
{
s.incrementTrans(i); //the server's transaction time is decremented
}
}//end server for loop
s.checkForTransaction(); //checks if a server needs to be dequeued
cout << "clock: " << clock << endl;
cout << "*************************************" << endl;
} //end clock for loop
int numberJobsLeft;
int newClock = simTime - 1;
int totalWaitinLine=0;
while (q.checkLine())
{
int tempFront = q.front(); //temporary placeholder for front of queue
waitTime = newClock - tempFront; //wait time for job is current time minus the in time for job
q.dequeue(); //dequeue the front
numberJobsLeft++; //add one to jobs left
totalWaitinLine = totalWaitinLine + waitTime; //update total wait time of jobs left
}
//display
cout << "Jobs left in queue: " << numberJobsLeft << endl;
cout << "Total Wait time of those left in queue: " << totalWaitinLine << endl;
int jobsWaitedOn = numberOfJobsEnqueued;
c.averageWait(jobsWaitedOn);
c.display();
}/*~~~Queue_of_Jobs.cpp~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| Queue_of_Jobs handles the operations of the queue of jobs. |
| Functions: |
| Queue_of_Jobs(): default constructor |
| bool enqueue(ElementType newJob): adds a job to the queue |
| bool dequeue(): removes a job from the front of the queue |
| int front(): returns the front value of the queue |
| int size(): returns how many are in the queue |
| bool checkForNewJob(int number): checks to add a job |
| bool checkLine(): checks the queue for if there is a job |
| |
| Author: Megan MacDonald |
| Date Completed: April 3, 2009 |
| Class: CSC 2110, section 002 |
| Tennessee Technological University |
| |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include <iostream>
#include <ctime>
#include <cstdlib>
#include "Queue_of_Jobs.h"
Queue_of_Jobs::Queue_of_Jobs()
{
mySize = 0;
frontOfQueue = 0;
back = 0;
count = 0;
}
bool Queue_of_Jobs::enqueue(ElementType newJob)
{
if (mySize == capacity)
{
cout << "Queue is full." << endl << "Your simulation FAILS!" << endl
<< "Try using smaller numbers..." << endl;
exit(-1);
return false;
}
else
{
myArray[back] = newJob;
back = (back + 1)%capacity;
count++;
mySize++;
return true;
}
}
bool Queue_of_Jobs::dequeue()
{
if (!checkLine()) //Queue is empty
{
return false;
}
else
{
ElementType j = myArray[frontOfQueue];
if (frontOfQueue == capacity)
{
frontOfQueue = 0;
}
frontOfQueue = frontOfQueue + 1;
count--;
mySize--;
return true;
}
}
int Queue_of_Jobs::front()
{
if (checkLine())
{
ElementType j = myArray[frontOfQueue];
return (j.inTime);
}
else
{
//Queue is empty
return 0;
}
}
int Queue_of_Jobs::size()
{
mySize = (back - frontOfQueue)%capacity;
return mySize;
}
bool Queue_of_Jobs::checkForNewJob(int number)
{
if (number%2)
return true;
else
return false;
}
bool Queue_of_Jobs::checkLine()
{
if (count >= 1)
return true;
else
return false;
}/*~~~Queue_of_Jobs.h~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| Queue_of_Jobs handles the operations of the queue of jobs. |
| Functions: |
| Queue_of_Jobs(): default constructor |
| bool enqueue(ElementType newJob): adds a job to the queue |
| bool dequeue(): removes a job from the front of the queue |
| int front(): returns the front value of the queue |
| int size): returns how many are in the queue |
| bool checkForNewJob(int number): checks to add a job |
| bool checkLine(): checks the queue for if there is a job |
| |
| Author: Megan MacDonald |
| Date Completed: April 3, 2009 |
| Class: CSC 2110, section 002 |
| Tennessee Technological University |
| |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include <iostream>
#include <string>
using namespace std;
typedef struct Job ElementType;
#define capacity 100
struct Job
{
int inTime;
};
class Queue_of_Jobs
{
private:
ElementType myArray[capacity];
int mySize;
int frontOfQueue;
int back;
int count;
public:
Queue_of_Jobs();
bool enqueue(ElementType newJob);
bool dequeue();
int front();
int size();
bool checkForNewJob(int number);
bool checkLine();
};/*~~~server.cpp~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| The server handles the "serving" side of the simulation. |
| The server acts as a bank teller might: engaging with |
| customers, having a transaction time for while they |
| work with a customer and so on. |
| Functions: |
| Server(): default constructor |
| bool isAvailable(int index): checks server for engaged |
| void engage(int index): sets the server to not available |
| void disEngage(int index): sets the server to available |
| void insert(int numServers): inserts server to list |
| void display(): displays the list of servers |
| void setTransaction(int transTime): uses the user input |
| to set the transaction_time |
| bool incrementTrans(int index): increments the server's |
| serving time by one until it reaches transaction_time |
| bool checkForTransaction(): checks server for for need to |
| disEngage. |
| |
| Author: Megan MacDonald |
| Date Completed: April 3, 2009 |
| Class: CSC 2110, section 002 |
| Tennessee Technological University |
| |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include <iostream>
using namespace std;
#include "server.h"
Server::Server()
{
first = NULL;
mySize = 0;
}
void Server::setTransaction(int transTime)
{
transaction_time = transTime;
}
bool Server::incrementTrans(int index)
{
NodePointer ptr = first;
int i;
for (i=0; i<index; i++)
{
ptr = ptr->next;
}
if (!isAvailable(index))
{
if (ptr->data.time == transaction_time)
return false;
else
{
int a;
a = ptr->data.time;
a++;
ptr->data.time = a;
return true;
}
}
else
return false;
}
bool Server::checkForTransaction()
{
NodePointer ptr = first;
int i;
int count = 0;
for (i=0; i<mySize; i++)
{
if (!isAvailable(i) && (ptr->data.time == transaction_time))
{
disEngage(i);
cout << "Server was disEngaged!" << endl;
count++;
}
else
ptr = ptr->next;
}
if (count == 0)
return false;
else
return true;
}
bool Server::isAvailable(int index)
{
NodePointer ptr = first;
int i;
for (i=0; i<index; i++)
{
ptr = ptr->next;
}
if (ptr->data.avail == 0)
{
return true;
}
else if (ptr->data.avail == 1)
{
return false;
}
}
void Server::engage(int index)
{
NodePointer ptr = first;
int i;
for (i=0; i<index; i++)
{
ptr = ptr->next;
}
ptr->data.avail = 1;
ptr->data.time = 0;
}
void Server::disEngage(int index)
{
NodePointer ptr = first;
int i;
for (i=0; i<index; i++)
{
ptr = ptr->next;
}
if (ptr->data.avail == 0)
cout << "server already disEngaged" << endl;
else if (ptr->data.avail == 1)
{
ptr->data.avail = 0;
ptr->data.time = 0;
}
}
void Server::insert(int numServers)
{
ServerType serv;
int a = 0;
int index;
int i;
for (index=0; index<numServers; index++)
{
serv.identity = index;
serv.avail = a;
serv.time = a;
NodePointer nPtr = new Node(serv);
nPtr->next = first;
first = nPtr;
mySize++;
}
}
void Server::display()
{
NodePointer ptr;
ptr = first;
while (ptr != NULL)
{
cout << ptr->data.identity
<< " : " << ptr->data.avail
<< " : " << ptr->data.time << endl;
ptr = ptr->next;
}
}/*~~~server.h~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| The server handles the "serving" side of the simulation. |
| The server acts as a bank teller might: engaging with |
| customers, having a transaction time for while they |
| work with a customer and so on. |
| Functions: |
| Server(): default constructor |
| bool isAvailable(int index): checks server for engaged |
| void engage(int index): sets the server to not available |
| void disEngage(int index): sets the server to available |
| void insert(int numServers): inserts server to list |
| void display(): displays the list of servers |
| void setTransaction(int transTime): uses the user input |
| to set the transaction_time |
| bool incrementTrans(int index): increments the server's |
| serving time by one until it reaches transaction_time |
| bool checkForTransaction(): checks server for for need to |
| disEngage. |
| |
| Author: Megan MacDonald |
| Date Completed: April 3, 2009 |
| Class: CSC 2110, section 002 |
| Tennessee Technological University |
| |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include <iostream>
#include <string>
using namespace std;
typedef struct aServer ServerType;
struct aServer
{
int avail;
int time;
int identity;
};
class Server
{
private:
int mySize;
int transaction_time;
class Node
{
public:
ServerType data;
Node * next;
Node(ServerType ident){
data = ident;
next = NULL;
}
};
typedef Node * NodePointer;
NodePointer first;
NodePointer predPtr;
public:
Server();
bool isAvailable(int index);
void engage(int index);
void disEngage(int index);
void insert(int numServers);
void display();
void setTransaction(int transTime);
bool incrementTrans(int index);
bool checkForTransaction();
};/*~~~Control.cpp~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| Control handles the overall waitTime of customers and the |
| average wait time for customers. |
| Functions: |
| Control(): default constructor |
| int totalWait(int waittime): keeps a running total for |
| the time a job waits |
| int averageWait(int numJobs): calculates the average wait |
| void display(): displays the total and average wait times |
| |
| Author: Megan MacDonald |
| Date Completed: April 3, 2009 |
| Class: CSC 2110, section 002 |
| Tennessee Technological University |
| |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include <iostream>
using namespace std;
#include "Control.h"
Control::Control()
{
totalWaitTime = 0;
averageWaitTime = 0;
}
int Control::totalWait(int waittime)
{
totalWaitTime = totalWaitTime + waittime;
}
int Control::averageWait(int numJobs)
{
averageWaitTime = totalWaitTime / numJobs;
}
void Control::display()
{
cout << "Total Wait Time: " << totalWaitTime << endl;
cout << "Average Wait Time was: " << averageWaitTime << endl;
}/*~~~Control.h~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| Control handles the overall waitTime of customers and the |
| average wait time for customers. |
| Functions: |
| Control(): default constructor |
| int totalWait(int waittime): keeps a running total for |
| the time a job waits |
| int averageWait(int numJobs): calculates the average wait |
| void display(): displays the total and average wait times |
| |
| Author: Megan MacDonald |
| Date Completed: April 3, 2009 |
| Class: CSC 2110, section 002 |
| Tennessee Technological University |
| |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include <iostream>
class Control
{
private:
int averageWaitTime;
int totalWaitTime;
public:
Control(); //default constructor
//calculates the total wait time during simulation
int totalWait(int waittime);
//calculates the average wait time using totalWaitTime and number of jobs
int averageWait(int numJobs);
//displays the total wait time and the average wait time
void display();
};This article has been dead for over three months
You
© 2012 DaniWeb® LLC
