Revise the Average Waiting Time program to do the following: a) Also output the
ID: 3803889 • Letter: R
Question
Revise the Average Waiting Time program to do the following:
a) Also output the largest number of customers who were on a queue at the same time.
b) Choose the queue for a customer to enter based on shortest finish time, rather than shortest size. The user should have the ability to choose which approach to use for any simulation run.
//---------------------------------------------------------------------
// Simulation.java by Dale/Joyce/Weems Chapter 5
//
// Models a sequence of customers being serviced
// by a number of queues.
//---------------------------------------------------------------------
import support.*; // Customer, CustomerGenerator
import ch05.queues.*;
public class Simulation
{
final int MAXTIME = Integer.MAX_VALUE;
CustomerGenerator custGen; // a customer generator
float avgWaitTime = 0.0f; // average wait time for most recent simulation
public Simulation(int minIAT, int maxIAT, int minST, int maxST)
{
custGen = new CustomerGenerator(minIAT, maxIAT, minST, maxST);
}
public float getAvgWaitTime()
{
return avgWaitTime;
}
public void simulate(int numQueues, int numCustomers)
// Preconditions: numQueues > 0
// numCustomers > 0
// No time generated during simulation is > MAXTIME
//
// Simulates numCustomers customers entering and leaving the
// a queuing system with numQueues queues
{
// the queues
GlassQueue[] queues = new GlassQueue[numQueues];
Customer nextCust; // next customer from generator
Customer cust; // holds customer for temporary use
int totWaitTime = 0; // total wait time
int custInCount = 0; // count of customers started so far
int custOutCount = 0; // count of customers finished so far
int nextArrTime; // next arrival time
int nextDepTime; // next departure time
int nextQueue; // index of queue for next departure
int shortest; // index of shortest queue
int shortestSize; // size of shortest queue
Customer rearCust; // customer at rear of shortest queue
int finishTime; // calculated finish time for customer being enqueued
// instantiate the queues
for (int i = 0; i < numQueues; i++)
queues[i] = new GlassQueue();
// set customer generator and get first customer
custGen.reset();
nextCust = custGen.nextCustomer();
while (custOutCount < numCustomers) // while still more customers to handle
{
// get next arrival time
if (custInCount != numCustomers)
nextArrTime = nextCust.getArrivalTime();
else
nextArrTime = MAXTIME;
// get next departure time and set nextQueue
nextDepTime = MAXTIME;
nextQueue = -1;
for (int i = 0; i < numQueues; i++)
if (queues[i].size() != 0)
{
cust = queues[i].peekFront();
if (cust.getFinishTime() < nextDepTime)
{
nextDepTime = cust.getFinishTime();
nextQueue = i;
}
}
if (nextArrTime < nextDepTime)
// handle customer arriving
{
// determine shortest queue
shortest = 0;
shortestSize = queues[0].size();
for (int i = 1; i < numQueues; i++)
{
if (queues[i].size() < shortestSize)
{
shortest = i;
shortestSize = queues[i].size();
}
}
// determine the finish time
if (shortestSize == 0)
finishTime = nextCust.getArrivalTime() + nextCust.getServiceTime();
else
{
rearCust = queues[shortest].peekRear();
finishTime = rearCust.getFinishTime() + nextCust.getServiceTime();
}
// set finish time and enqueue customer
nextCust.setFinishTime(finishTime);
queues[shortest].enqueue(nextCust);
custInCount = custInCount + 1;
// if needed, get next customer to enqueue
if (custInCount < numCustomers)
nextCust = custGen.nextCustomer();
}
else
// handle customer leaving
{
cust = queues[nextQueue].dequeue();
totWaitTime = totWaitTime + cust.getWaitTime();
custOutCount = custOutCount + 1;
}
} // end while
avgWaitTime = totWaitTime/(float)numCustomers;
}
}
//----------------------------------------------------------------------
// SimGUI.java by Dale/Joyce/Weems Chapter 5
//
// Simulates customers waiting in queues. Customers always enter
// the shortest queue.
//
// Input consists of simulation instance information:
// Minimum and maximum customer inter-arrival time.
// Minimum and maximum customer service time.
// Number of queues and customers.
//
// Assumes a friendly user, i.e., inputs are valid.
//
// Output is the average waiting time for a customer.
// Uses a graphical user interface.
//----------------------------------------------------------------------
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
import java.io.*;
import support.*;
public class SimGUI
{
// input text fields
private static JTextField minIATText;
private static JTextField maxIATText;
private static JTextField minSTText;
private static JTextField maxSTText;
private static JTextField numQueuesText;
private static JTextField numCustText;
// status Label
private static JLabel resultLabel; // label for status/result info
// Define a button listener.
private static class ActionHandler implements ActionListener
{
public void actionPerformed(ActionEvent event)
// listener for the button events
{
if (event.getActionCommand().equals("Simulate"))
{ // Handles Evaluate event.
float result;
Simulation sim = new Simulation
(Integer.parseInt(minIATText.getText()),
Integer.parseInt(maxIATText.getText()),
Integer.parseInt(minSTText.getText()),
Integer.parseInt(maxSTText.getText()));
sim.simulate(Integer.parseInt(numQueuesText.getText()),
Integer.parseInt(numCustText.getText()));
result = sim.getAvgWaitTime();
resultLabel.setText(" Average Wait Time: " + result);
}
else
if (event.getActionCommand().equals("Clear"))
{ // Handles Clear event.
resultLabel.setText(" RESULT ");
minIATText.setText("");
maxIATText.setText("");
minSTText.setText("");
maxSTText.setText("");
numQueuesText.setText("");
numCustText.setText("");
}
}
}
public static void main(String args[]) throws IOException
{
// Declare/instantiate/initialize display frame.
JFrame displayFrame = new JFrame();
displayFrame.setTitle("Queue Simulation Program");
displayFrame.setSize(350,300);
displayFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// text boxes for input
minIATText = new JTextField("", 5);
maxIATText = new JTextField("", 5);
minSTText = new JTextField("", 5);
maxSTText = new JTextField("", 5);
numQueuesText = new JTextField("", 5);
numCustText = new JTextField("", 5);
// input/result labels
JLabel InArgLabel = new JLabel(" Input Arguments:", JLabel.LEFT);
JLabel minIATLabel = new JLabel(" Minimum Inter-Arrival Time", JLabel.CENTER);
JLabel maxIATLabel = new JLabel(" Maximum Inter-Arrival Time", JLabel.CENTER);
JLabel minSTLabel = new JLabel(" Minimum Service Time", JLabel.CENTER);
JLabel maxSTLabel = new JLabel(" Maximum Service Time", JLabel.CENTER);
JLabel numQueuesLabel = new JLabel(" Number of Queues", JLabel.CENTER);
JLabel numCustLabel = new JLabel(" Number of Customers", JLabel.CENTER);
resultLabel = new JLabel(" RESULT ", JLabel.CENTER);
// input/result panels
JPanel minIATPanel = new JPanel();
JPanel maxIATPanel = new JPanel();
JPanel minSTPanel = new JPanel();
JPanel maxSTPanel = new JPanel();
JPanel numQueuesPanel = new JPanel();
JPanel numCustPanel = new JPanel();
JPanel resultPanel = new JPanel();
// set input/result panel layouts
minIATPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
maxIATPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
minSTPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
maxSTPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
numQueuesPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
numCustPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
resultPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
// add items to input/result panels
minIATPanel.add(minIATLabel);
minIATPanel.add(minIATText);
maxIATPanel.add(maxIATLabel);
maxIATPanel.add(maxIATText);
minSTPanel.add(minSTLabel);
minSTPanel.add(minSTText);
maxSTPanel.add(maxSTLabel);
maxSTPanel.add(maxSTText);
numQueuesPanel.add(numQueuesLabel);
numQueuesPanel.add(numQueuesText);
numCustPanel.add(numCustLabel);
numCustPanel.add(numCustText);
resultPanel.add(resultLabel);
// Simulate and Clear buttons
JButton simulate = new JButton("Simulate");
JButton clear = new JButton("Clear");
// Button event listener
ActionHandler action = new ActionHandler();
// Register button listeners.
simulate.addActionListener(action);
clear.addActionListener(action);
// Instantiate content pane and information panels.
Container contentPane = displayFrame.getContentPane();
JPanel mainPanel = new JPanel();
JPanel buttonPanel = new JPanel();
// Initialize main panel.
mainPanel.setLayout(new GridLayout(7,1));
mainPanel.add(InArgLabel);
mainPanel.add(minIATPanel);
mainPanel.add(maxIATPanel);
mainPanel.add(minSTPanel);
mainPanel.add(maxSTPanel);
mainPanel.add(numQueuesPanel);
mainPanel.add(numCustPanel);
// Initialize button panel.
buttonPanel.setLayout(new GridLayout(1,2));
buttonPanel.add(simulate);
buttonPanel.add(clear);
// Set up and show the frame.
contentPane.add(mainPanel, "North");
contentPane.add(buttonPanel, "Center");
contentPane.add(resultPanel, "South");
displayFrame.pack();
displayFrame.setVisible(true);
}
}
//---------------------------------------------------------------------
// SimulationApp.java by Dale/Joyce/Weems Chapter 5
//
// Simulates customers waiting in queues. Customers always enter
// the shortest queue.
//
// Input consists of customer information:
// Minimum and maximum customer inter-arrival time.
// Minimum and maximum customer service time.
// Followed by a sequence of simulation instance information:
// Number of queues and customers.
//
// Output includes, for each simulation instance:
// The average waiting time for a customer.
//----------------------------------------------------------------------
import java.util.Scanner;
public class SimulationApp
{
public static void main(String[] args)
{
Scanner conIn = new Scanner(System.in);
int minIAT; // minimum inter-arrival time
int maxIAT; // maximum inter-arrival time
int minST; // minimum service time
int maxST; // maximum service time
int numQueues; // number of queues
int numCust; // number of customers
String skip; // skip end of line after reading an integer
String more = null; // used to stop or continue processing
// Get customer information
System.out.print("Enter minimum inter-arrival time: ");
minIAT = conIn.nextInt();
System.out.print("Enter maximum inter-arrival time: ");
maxIAT = conIn.nextInt();
System.out.print("Enter minimum service time: ");
minST = conIn.nextInt();
System.out.print("Enter maximum service time: ");
maxST = conIn.nextInt();
// create object to perform simulation
Simulation sim = new Simulation(minIAT, maxIAT, minST, maxST);
do
{
// Get next simulation instance to be processed.
System.out.print("Enter number of queues: ");
numQueues = conIn.nextInt();
System.out.print("Enter number of customers: ");
numCust = conIn.nextInt();
skip = conIn.nextLine(); // skip end of line
// run simulation and output average waiting time
sim.simulate(numQueues, numCust);
System.out.println("Average waiting time is " + sim.getAvgWaitTime());
// Determine if there is another simulation instance to process
System.out.println();
System.out.print("Evaluate another simulation instance? (Y=Yes): ");
more = conIn.nextLine();
System.out.println();
}
while (more.equalsIgnoreCase("y"));
System.out.println("Program completed.");
}
}
AWT model
public class GlassQueue<T> extends ArrayUnbndQueue<T>
public class ArrayUnbndQueue<T> implements UnboundedQueueInterface<T>
public interface UnboundedQueueInterface<T> extends QueueInterface<T>
{
void enqueue(T element);
//Adds element to the rear of this quee.
}
public interface QueueInterface<T>
{
T dequeue() throws QueueUnderflowException;
//Throws QueueUnderflowException if this queue is empty;
//otherwise, removes front element from this queue and returns it
boolean isEmpty();
//Returns true if this queue is empty; otherwise, return false
}
description of the AWT model
description of the assignment based on:
Identify which of the authors' classes used for their Average Waiting Time (AWT) model is responsible for each of the seven items identified in #42.
Use the AWT model to determine a reasonable number of queues needed to serve a thousand customers, under four different scenarios specified in #43.
Modify the AWT model to:
report out the largest number of customers enqueued at the same time
assign the next arriving customer to a specific queue based on shortest finish time
provide a user interface control to allow user to select shortest finish time or shortest queue for assignments
Explanation / Answer
a) Also output the largest number of customers who were on a queue at the same time.
Since customers resides in queues [] in this program, so find which queue has max length and the max length is the max cust a same time.
int larNumCust=queues [0];
for (int i = 1; i < num Queues; i++)
if(queue[i]. size()>larNumCust)
larNumCust= queue[i]. size ();
Thus, your answer: larNumCust
b) Choose the queue for a customer to enter based on shortest finish time, rather than shortest size. The user should have the ability to choose which approach to use for any simulation run.
For shortest time, shortest variable defined in the program, would be your steering.
// set finish time and enqueue customer
nextCust.setFinishTime(finishTime);
queues[shortest].enqueue(nextCust);
custInCount = custInCount + 1;
the queue with shortest finish time is the fastest finishing queue, hence the answer.
For choice you could ask input from customer.
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.