Question
I want to create a simulation like what is described in the picture below in a main.cpp using the DoublyLinkedList.hpp and the Queue.hpp DON'T MODIFY
I want to create a simulation like what is described in the picture below in a main.cpp using the DoublyLinkedList.hpp and the Queue.hpp
DON'T MODIFY THE DoublyLinkedList.hpp and the Queue.hpp, just used them in the main.cpp. The DoublyLinkedList.hpp and the Queue.hpp are provided way below
main.cpp:
int main() {
return 0; }
Instructions:
Example Output: LOG 0 start 20 entered line 1 length 1 20 entered line 2 length 1 20 entered line 3 length 1 20 entered line 4 length 1 20 exited line 1 length 0 wait time 0 20 entered register 1 20 exited line 2 length 0 wait time 0 20 entered register 2 20 exited line 3 length 0 wait time 0 20 entered register 3 20 exited line 4 length 0 wait time 0 20 entered register 4 30 entered line 1 length 1 30 entered line 2 length 1 30 entered line 3 length 1 30 entered line 4 length 1 30 entered line 5 length 1 30 exited line 5 length 0 wait time 0 30 entered register 5 35 entered line 5 length 1 35 entered line 6 length 1 35 entered line 7 length 1 35 exited line 6 length 0 wait time 0 35 entered register 6 35 exited line 7 length 0 wait time 0 35 entered register 7 40 entered line 6 length 1 40 entered line 7 length 1 40 entered line 8 length 1 40 entered line 1 length 2 40 entered line 2 length 2 40 entered line 3 length 2 40 exited line 8 length 0 wait time 0 40 entered register 8 60 entered line 8 length 1 60 entered line 4 length 2 60 entered line 5 length 2 60 entered line 6 length 2 60 entered line 7 length 2 60 entered line 8 length 2 60 entered line 1 length 3 60 entered line 2 length 3 60 exited register 1 60 exited line 1 length 2 wait time 30 60 entered register 1 60 exited register 3 60 exited line 3 length 1 wait time 30 60 entered register 3 65 exited register 4 65 exited line 4 length 1 wait time 35 65 entered register 4 70 entered line 3 length 2 70 entered line 4 length 2 70 entered line 1 length 3 70 entered line 3 length 3 70 entered line 4 length 3 70 entered line 5 length 3 70 entered line 6 length 3 70 exited register 2 70 exited line 2 length 2 wait time 40 70 entered register 2 80 exited register 5 80 exited line 5 length 2 wait time 45 80 entered register 5 80 exited register 6 80 exited line 6 length 2 wait time 40 80 entered register 6 85 entered line 2 length 3 85 entered line 5 length 3 85 entered line 6 length 3 85 entered line 7 length 3 85 entered line 8 length 3 90 lost 90 lost 90 lost 90 lost 90 lost 90 lost 90 lost 90 lost 90 lost 95 exited register 7 95 exited line 7 length 2 wait time 55 95 entered register 7 100 exited register 1 100 exited line 1 length 2 wait time 60 100 entered register 1 100 exited register 3 100 exited line 3 length 2 wait time 60 100 entered register 3 105 exited register 8 105 exited line 8 length 2 wait time 45 105 entered register 8 110 entered line 1 length 3 110 entered line 3 length 3 110 entered line 7 length 3 110 entered line 8 length 3 110 exited register 4 110 exited line 4 length 2 wait time 50 110 entered register 4 120 entered line 4 length 3 120 lost 120 exited register 2 120 exited line 2 length 2 wait time 80 120 entered register 2 125 exited register 6 125 exited line 6 length 2 wait time 65 125 entered register 6 130 entered line 2 length 3 130 entered line 6 length 3 130 lost 130 lost 130 exited register 5 130 exited line 5 length 2 wait time 70 130 entered register 5 135 entered line 5 length 3 140 exited register 1 140 exited line 1 length 2 wait time 80 140 entered register 1 140 exited register 3 140 exited line 3 length 2 wait time 70 140 entered register 3 150 entered line 1 length 3 150 entered line 3 length 3 155 exited register 4 155 exited line 4 length 2 wait time 85 155 entered register 4 155 exited register 7 155 exited line 7 length 2 wait time 95 155 entered register 7 170 exited register 2 170 exited line 2 length 2 wait time 110 170 entered register 2 170 exited register 6 170 exited line 6 length 2 wait time 100 170 entered register 6 170 exited register 8 170 exited line 8 length 2 wait time 110 170 entered register 8 180 entered line 2 length 3 180 entered line 4 length 3 180 entered line 6 length 3 180 entered line 7 length 3 180 entered line 8 length 3 180 lost 180 exited register 1 180 exited line 1 length 2 wait time 110 180 entered register 1 180 exited register 3 180 exited line 3 length 2 wait time 110 180 entered register 3 180 exited register 5 180 exited line 5 length 2 wait time 110 180 entered register 5 200 exited register 4 200 exited line 4 length 2 wait time 130 200 entered register 4 215 exited register 6 215 exited line 6 length 2 wait time 130 215 entered register 6 215 exited register 7 215 exited line 7 length 2 wait time 130 215 entered register 7 220 exited register 1 220 exited line 1 length 1 wait time 110 220 entered register 1 220 exited register 2 220 exited line 2 length 2 wait time 135 220 entered register 2 220 exited register 3 220 exited line 3 length 1 wait time 110 220 entered register 3 230 exited register 5 230 exited line 5 length 1 wait time 145 230 entered register 5 235 exited register 8 235 exited line 8 length 2 wait time 150 235 entered register 8 240 end STATS Entered Line : 53 Exited Line : 40 Exited Register : 32 Avg Wait Time : 68.12 Left In Line : 13 Left In Register: 8 Lost : 13
----------------------------------------------------------------------------
// DoublyLinkedList.hpp #ifndef DOUBLYLINKEDLIST_HPP #define DOUBLYLINKEDLIST_HPP #include "EmptyException.hpp" #include "IteratorException.hpp" template
----------------------------------------------------------------------------
#ifndef QUEUE_HPP #define QUEUE_HPP
#include "DoublyLinkedList.hpp"
template
// enqueue() adds the given value to the back of the queue, after // all of the ones that are already stored within. void enqueue(const ValueType& value);
// dequeue() removes the front value from the queue, if there is // one. If the queue is empty, it throws an EmptyException instead. void dequeue();
// front() returns the front value in the queue, if there is one. // If the queue is empty, it throws an EmptyException instead. const ValueType& front() const;
// These members of DoublyLinkedList are being made into public // members of Queue. Given a Queue object, you'd now be able to // call the isEmpty(), size(), or constIterator() member functions, // as well as say something like "Queue
using DoublyLinkedList
using DoublyLinkedList
template
this->addToEnd(value); }
template
template
#endif
In business or scientific contexts, it's sometimes very costly to make changes to the way that you're doing things, yet sometimes the changes you consider might yield great benefits. Unfortunately, you don't always know if they'll yield those benefits without some experimentation. But if the experimentation is too costly, you might never be willing to pay the cost of finding out whether the changes you're considering are worthwhile or not. Computers have a role to play in situations like this. If you can write a simulation that models reality well enough that it can demonstrate how things would turn out in various scenarios, you might be able to more cheaply find the answer you're looking for should I make this change or not? - and, if it turns out to be a positive one, you can proceed. In this project, we'll write a simulation like this one. Suppose that a chain of big-box retail stores is considering a rearrangement of the way that customers go through the check-out process, in hopes of processing customers more efficiently, helping them spend less time waiting in line, and keeping their business from being lost to more efficient competitors. To aid in that analysis, you'll build a program that will simulate two different arrangements of lines and registers, generating a log of the movement of customers throughout the simulation and, at the end, overall statistics. Along the way, you'll implement a doubly-linked list with head and tail pointers, then use it as the basis for a queue, which you'll then use in your simulation. This will give you additional practice with the kind of thinking and techniques you need to implement data structures, while also building your experience with some new areas of C++ that you may not have used a lot previously, such as templates, public and private inheritance, and move semantics. In the app directory, you'll write the rest of your code, a program that performs the following simulation. The format of the input and output are described in detail and need to be followed carefully; spelling, capitalization, and spacing are all relevant and must be correct for full credit. Your simulator will read all of its input from std::cin and write all of its output to std::cout. While you may want to use the technique of redirection to use files for this purpose (see below), your simulator will always use std::cin and std::cout. What are we simulating? In our hypothetical big-box retail store, customers shop and choose the merchandise they want to buy. Each customer then proceeds to get into a line to wait to be checked out. When there is an available cashier, the customer goes to the register where that cashier is waiting. When the cashier is finished checking the customer out, the customer exits the register and is considered finished. What we're interested in doing is tracking these movements: when customers enter lines, exit lines and enter registers, and finally exit registers. We'll then report various statistics at the conclusion of the simulation, to summarize the overall outcome. Arrangements of lines and registers There are two different arrangements of lines and registers that our simulation will support 1. One or more registers, each with its own separate line. A customer in a particular line will only ever proceed to the corresponding register 2. One or more registers, with one shared line feeding customers to all of them. The input First of all, you may freely assume that the input given to your simulation will match the description below. It may obviously be different than what's shown here, but it will always follow all of the rules here. Your program is free to do anything you'd like - up to and including crashing - in the case that the input is invalid. The simulator's input begins with what we'll call the setup section, which specifies the parameters that control how the simulation will run. The setup section looks like this - the italiczed portions are included here for descriptive purposes, but are not included in the actual input 4 the length of the simulation. in minutes 3 the number of registers the maximum line length. beyond which customers be lost S for a single line. M for multiple lines (one for each register) register #1 takes 40 seconds to process a customer 50 register #2 takes 50 seconds to process a customer 30 register w3 takes 30 seconds to process customer There are a few notes to be aware of: 3 M 40 When we talk about the length of the simulation, we don't actually intend for the simulation to take that long to run. The goal is for the simulation to give a quick answer to the question of "What would a day in my store look like if we arranged things like this?" . We'll say that each register has a register number and that they are numbered consecutively starting from 1. Similarly, lines will have a line number and they're also numbered consecutively starting from 1. The simulation length is given in minutes, while the processing times for each register are given in seconds. After reading the setup section of the input your simulator will have what it needs to set things up and get started. From there, the rest of the input specifies customer arrivals. Each line in the customer arrival section of the input consists of two numbers: a positive number of customers and the time that these customers arrival. (Time in our simulation is always measured in terms of the number of seconds since the simulation started. You can assume that the time associated with each line describing an arriving of customers will be greater than the time associated with the previous one. The input will always end with a line consisting of the word END. That doesn't mean that the simulation should end immediately, it just means that there are no more customer arrivals. leaves the the simulation The movement of customers through the simulation So that we can all agree on the r output of the simulation, we'll need to agree on the precise details of how customers move through the simulation. In the interest of keeping things simple, we'll take some liberties with reality - customers won't always do the smartest thing, we'll ignore how long it takes for customers to physically move around, and so on. Also, all actions are considered to have happened at discrete times measured in an integer number of seconds since the start of the simulation; something might happen at time 10 or time 11, but never at time 10.5. In any given second of simulation time, customer arrivals are always considered before customers are moved into and out of registers. When n customers arrive at a particular time, we assume that they're separate - they each have a shopping basket and are interested in engaging in a separate transaction. Each of them has a decision to make and they make them one right after the other The customer chooses the shortest line and enters it. Note that this is based only on how many customers are in each line; the presence or absence of a customer at any registers is not considered. When there is a tie (1.e., two lines are equally the shortest), the customer will always choose the line with the smallest line number (eg. If lines 3 and 7 are equally the shortest, the customer will enter line 3). er will emel If all of the lines are the maximum length specified in the setup section the customer is not willing to wait, and instead lation immediately. That customer is considered to be lost. (This is a crude representation of a store being busy enough that it drives away customers.) Whenever a register is unoccupied, a customer immediately moves from the corresponding line and into the register. That customer will stay for the appropriate number of seconds (as determined by the processing time for that register, specified in the setup section). At that time, the customer will leave the register and will immediately be replaced by another. . For the sake of simplicity, we'll assume that customers will never move from one line to another once they've entered line, nor will a customer ever enter a register from any line other than the one that corresponds to it. The output The output of your simulator consists of two sections: The log, which indicates each time an interesting event occurs. The log begins with the word LOG alone on a line, followed by one line of output for each event. Each line of output describing an event consists of an integer simulation time (the number of seconds since the simulation started), a space, and then a description of the event. The following kinds of events are required to be logged: The simulation started The simulation ended A customer entered a line, in which case we want to know which line number and how long the line is now (including the new customer) A customer exited a line, in which case we want to know which line number and how many seconds the customer waited in that line une A customer entered a register, in which case we want to know which register number A customer exited a register, in which case we want to know which register number - there's no need to see how long they waited, as this is always the same for a given register A customer has been lost (.e. they left without waiting in line because all lines were maximum length) The 'stats' section. This section on a line, followed by these stor begins with a blank line (to separate it from the log visually), followed by the word STATS alone How many customers entered a line during the simulation Loudt uit How many customers exited a line during the simulation . How many customers exited a register during the simulation - we don't show many customers entered a register, because every customer who exits a line immediately enters a register uch The average wait time, in simulation seconds, for customers who exited a line. We only care about how long they waited in line, and we only measure this for customers who exited a line; customers still remaining in line at the end of the simulation are not included. Display this value to two digits after the decimal point. How many customers are still left in line at the end of the simulation (t.e., they've entered a line but not exited it yet) How many customers are still left at a register at the end of the simulation (t.e., they've entered a register but not exited it yet) How many customers were lost during the simulation Example input and output A complete example of the simulator's input and expected output (for that input) are provided in the examples directory within your project directory in files called sample.in (the input) and sample out the output). Your goal is to match this format precisely, spelling, capitalization, and spacing are all relevant, so take some time to study the example and make sure you recognize the little details within it. Limitations You must use your own Queue class template to implement the concept of a line of customers. Beyond that you are free to use any part of the C++ Standard Library you wish in your simulator, even though it's forbidden in your DoublyLinkedList and Queue implementations. For example, you may prefer to use std::vector to store the registers or the lines (though you can certainly use DoublyLinkedList if you prefer)Step by Step Solution
There are 3 Steps involved in it
Step: 1
Get Instant Access to Expert-Tailored Solutions
See step-by-step solutions with expert insights and AI powered tools for academic success
Step: 2
Step: 3
Ace Your Homework with AI
Get the answers you need in no time with our AI-driven, step-by-step assistance
Get Started