lift.cpp File Reference

#include <algorithm>
#include <cassert>
#include <chrono>
#include <iomanip>
#include <iostream>
#include <random>
#include <vector>

Include dependency graph for lift.cpp:

Go to the source code of this file.

Classes
class	Lift
class	Queue

Macros
#define	numLifts   numQueues
#define	numQueues   2

Enumerations
enum	{   liftCapacity = 20 , maxRound = 12 , minRound = 5 , minRoundDifference = 4 ,   minNumPeople = 0 , maxNumPeople = liftCapacity * maxRound , minDefaultNumPeople = liftCapacity * minRound , normDistSDBound = 2 ,   coutWidth = 8 }
enum	{   lift1MeanWaitingTime = 10 , lift1StdDevWaitingTime = 2 , lift2MeanWaitingTime = 12 , lift2StdDevWaitingTime = 4 ,   isLift1FasterThanLift2 = true }

Functions
auto	main () -> int
auto	simulateTwoQueues (std::vector< Queue * > queues) -> decltype(Queue::id)

Macro Definition Documentation

numLifts

#define numLifts   numQueues

Definition at line 27 of file lift.cpp.

Referenced by Queue::Queue().

numQueues

#define numQueues   2

Definition at line 26 of file lift.cpp.

Referenced by Queue::Queue(), and main().

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
liftCapacity
maxRound
minRound
minRoundDifference
minNumPeople
maxNumPeople
minDefaultNumPeople
normDistSDBound
coutWidth

Definition at line 14 of file lift.cpp.

     {
    liftCapacity = 20,
    maxRound = 12,
    minRound = 5,
    minRoundDifference = 4,
    minNumPeople = 0,
    maxNumPeople = liftCapacity * maxRound,
    minDefaultNumPeople = liftCapacity * minRound,
    normDistSDBound = 2,
    coutWidth = 8
};

anonymous enum

anonymous enum

Enumerator
lift1MeanWaitingTime
lift1StdDevWaitingTime
lift2MeanWaitingTime
lift2StdDevWaitingTime
isLift1FasterThanLift2

Definition at line 29 of file lift.cpp.

     {
    lift1MeanWaitingTime = 10,
    lift1StdDevWaitingTime = 2,
    lift2MeanWaitingTime = 12,
    lift2StdDevWaitingTime = 4,
    isLift1FasterThanLift2 = true
};

Function Documentation

main()

auto main

(

void

)

-> int

Definition at line 130 of file lift.cpp.

                   {
    // Result vector
    std::vector<std::string> const headers = {"Queue1", "Queue2", "Lift1", "Lift2", "Fastest"};
    struct results {
        public:
            unsigned int queueLength;
            unsigned int queue2Length;
            unsigned int lift1WaitingTime;
            unsigned int lift2WaitingTime;
            unsigned int fastestQueueId;
    } __attribute__((aligned(32)));
    std::vector<results> rows;
    // Simulate which queue is the fastest under every possible scenario
    // which is achieved by generating random queue length and lift waiting time
    static_assert(isLift1FasterThanLift2 != 0u, "Lift 1 must be faster than Lift 2");
    for (unsigned int queueLength = minDefaultNumPeople; queueLength <= maxNumPeople;
         queueLength += liftCapacity) {
        for (unsigned int queue2Length = minDefaultNumPeople;
             queue2Length <= queueLength - minRoundDifference; queue2Length += liftCapacity) {
            std::vector<Queue *> queues;
 
            // todo: add more queues
            queues.push_back(new Queue(numQueues - 1, queueLength,
                new Lift(0, lift1MeanWaitingTime, lift1StdDevWaitingTime)));
            queues.push_back(new Queue(numQueues, queue2Length,
                new Lift(1, lift2MeanWaitingTime, lift2StdDevWaitingTime)));
 
            auto fastestQueueId = simulateTwoQueues(queues);
 
            // Add the result only if the fastest queue is different from the previous
            // simulation Otherwise, remove the last simulation and add the new one
            if (!rows.empty() && rows.back().fastestQueueId == fastestQueueId &&
                rows.back().queueLength == queueLength) {
                rows.pop_back();
            }
            results const result = {queueLength, queue2Length, (*queues.begin())->waitingTime,
                (*++queues.begin())->waitingTime, fastestQueueId};
            rows.push_back(result);
 
            // Free the memory
            for (Queue * queue : queues) {
                delete queue->lift;
                delete queue;
            }
        }
    }
 
    // Print the results
    for (const std::string & header : headers) {
        std::cout << std::setw(coutWidth) << header;
    }
    std::cout << '\n';
    for (const results & row : rows) {
        std::cout << std::setw(coutWidth) << row.queueLength;
        std::cout << std::setw(coutWidth) << row.queue2Length;
        std::cout << std::setw(coutWidth) << row.lift1WaitingTime;
        std::cout << std::setw(coutWidth) << row.lift2WaitingTime;
        std::cout << std::setw(coutWidth) << row.fastestQueueId;
        std::cout << '\n';
    }
    return 0;
}

References coutWidth, isLift1FasterThanLift2, lift1MeanWaitingTime, lift1StdDevWaitingTime, lift2MeanWaitingTime, lift2StdDevWaitingTime, liftCapacity, maxNumPeople, minDefaultNumPeople, minRoundDifference, numQueues, and simulateTwoQueues().

Here is the call graph for this function:

simulateTwoQueues()

auto simulateTwoQueues

(

std::vector< Queue * >

queues

)

-> decltype(Queue::id)

Definition at line 113 of file lift.cpp.

                                                                       {
    // Simulate the total time taken for the lift to serve all the queues
    for (Queue * queue : queues) {
        while (queue->numPeople > minNumPeople) {
            queue->waitingTime = queue->lift->getAvailableTime(queue->waitingTime);
            if (queue->numPeople > queue->lift->capacity) {
                queue->numPeople -= queue->lift->capacity;
            }
            else {
                queue->numPeople = minNumPeople;
            }
        }
    }
    // Return the fastest queue id
    return (*std::min_element(queues.begin(), queues.end()))->id;
}

References Queue::id, and minNumPeople.

Referenced by main().

Here is the caller graph for this function: