Add round-robin CPU scheduling algorithm

cpu_scheduling_algorithms/round_robin_scheduling.cpp

@@ -0,0 +1,242 @@
+/**
+ * @file
+ * @brief Implementation of [Round Robin CPU
+ * scheduling](https://en.wikipedia.org/wiki/Round-robin_scheduling) algorithm
+ * @details
+ * Round-robin is a preemptive CPU scheduling algorithm where each
+ * ready task runs turn by turn only in a cyclic queue for a limited
+ * time slice. This algorithm also offers starvation free execution
+ * of processes.
+ * @author [Daemon19](https://github.com/Daemon19)
+ */
+
+#include <algorithm>  /// For std::sort
+#include <cassert>    /// For testing the round-robin algorithm
+#include <iomanip>    /// For formatting process results output
+#include <iostream>   /// For outputting process execution results
+#include <queue>      /// Container for process execution turn
+#include <set>        /// Container for processes that have arrived
+#include <string>     /// For converting int type to string
+#include <utility>    /// For std::pair
+#include <vector>     /// Container for processes that will be executed
+
+/**
+ * @brief Represent a process to be executed.
+ */
+struct Process {
+    uint32_t id;            ///< Used to distinguish processes
+    uint32_t arrival_time;  ///< The time at which the process arrives
+    uint32_t burst_time;    ///< Time required to complete process execution
+};
+
+/**
+ * @brief Represent the result of a process execution.
+ */
+struct ProcessResult : public Process {
+    uint32_t completion_time;   ///< The time at which the process execution is
+                                ///< finished
+    uint32_t turn_around_time;  ///< The turn around time required for the
+                                ///< process to complete
+    uint32_t waiting_time;      ///< Process waiting time before execution
+
+    /**
+     * @brief Constructor that calculate member variables based on a
+     * process and completion time.
+     *
+     * \param process A process that have been executed
+     * \param completion_time The process execution finish time
+     */
+    ProcessResult(const Process& process, uint32_t completion_time)
+        : Process(process), completion_time(completion_time) {
+        turn_around_time = completion_time - arrival_time;
+        waiting_time = turn_around_time - burst_time;
+    }
+
+    /**
+     * @brief Compare each member variable.
+     *
+     * \param p ProcessResult to be compared with
+     * \return true if the processes IS equal
+     * \return false if the processes IS NOT equal
+     */
+    bool operator==(const ProcessResult& p) const {
+        return id == p.id && arrival_time == p.arrival_time &&
+               burst_time == p.burst_time &&
+               completion_time == p.completion_time &&
+               turn_around_time == p.turn_around_time &&
+               waiting_time == p.waiting_time;
+    }
+};
+
+/**
+ * Represent remaining burst time of a process.
+ */
+using BTLeft = uint32_t;
+
+/**
+ * @brief Execute processes based on Round-robin algorithm.
+ *
+ * \param processes Processes to be executed
+ * \param time_slice Time slice for processes execution
+ * \return Results of each process execution
+ */
+std::vector<ProcessResult> RRExecute(const std::vector<Process>& processes,
+                                     uint32_t time_slice);
+
+/**
+ * @brief Print a table containing process results data.
+ *
+ * \return ostream inputted ostream
+ */
+std::ostream& operator<<(std::ostream& ostream,
+                         const std::vector<ProcessResult>& results);
+
+/**
+ * @brief Comparator function for sorting processes.
+ *
+ * \param p1 Process to be compared
+ * \param p2 Process to be compared
+ * \return
+ */
+bool CompareAT(const Process& p1, const Process& p2) {
+    return p1.arrival_time < p2.arrival_time;
+}
+
+/**
+ * @brief Check processes that arrive after the given time_elapsed.
+ *
+ * If a process arrive after the give time_elapsed, then the process
+ * will be pushed into the schedule queue and inserted into the
+ * arrived_process set.
+ *
+ * \param processes Processes that will be checked for arrival
+ * \param arrived_process A set containing processes that has arrived
+ * \param schedule Queue containing pair of process and its remaining burst time
+ * \param time_elapsed Time that has elapsed after processes execution
+ */
+void CheckArriveProcess(const std::vector<Process>& processes,
+                        std::set<uint32_t>* arrived_process,
+                        std::queue<std::pair<Process, BTLeft>>* schedule,
+                        uint32_t time_elapsed);
+
+/**
+ * @brief Self-test implementations
+ * @returns void
+ */
+static void Test() {
+    std::vector<Process> processes{
+        {0, 70, 3}, {1, 9, 2}, {2, 3, 39}, {3, 5, 29}, {4, 30, 90}};
+    const uint32_t kTimeSlice{3};
+    std::vector<ProcessResult> results = RRExecute(processes, kTimeSlice);
+
+    std::vector<uint32_t> correct_completion_times({80, 14, 100, 82, 166});
+    std::vector<ProcessResult> correct_results;
+    // Generate correct process results based on correct completion times
+    for (size_t i = 0; i < processes.size(); i++) {
+        correct_results.emplace_back(processes[i], correct_completion_times[i]);
+    }
+
+    // Sort the results and correct results so they're exactly the same
+    std::sort(results.begin(), results.end(), CompareAT);
+    std::sort(correct_results.begin(), correct_results.end(), CompareAT);
+
+    std::cout << results;
+    assert(results == correct_results);
+    std::cout << "All test passed.\n";
+}
+
+/**
+ * @brief Entry point of the program.
+ *
+ * \return 0 on exit
+ */
+int main() {
+    Test();
+    return 0;
+}
+
+std::vector<ProcessResult> RRExecute(const std::vector<Process>& processes,
+                                     uint32_t time_slice) {
+    std::queue<std::pair<Process, BTLeft>> schedule;
+    std::set<uint32_t> arrived_processes;
+
+    std::vector<ProcessResult> results;
+    results.reserve(processes.size());
+
+    // The time of the first process execution will be the lowest process AT
+    uint32_t time_elapsed =
+        std::min_element(processes.begin(), processes.end(), CompareAT)
+            ->arrival_time;
+
+    CheckArriveProcess(processes, &arrived_processes, &schedule, time_elapsed);
+
+    while (!schedule.empty()) {
+        std::pair<Process, BTLeft> current = schedule.front();
+        schedule.pop();
+
+        // If process burst time < time slice, then the process will be
+        // executed for the burst time amount of time, not the time
+        // quantum/slice
+        uint32_t elapsed =
+            (current.second > time_slice) ? time_slice : current.second;
+        current.second -= elapsed;
+        time_elapsed += elapsed;
+
+        CheckArriveProcess(processes, &arrived_processes, &schedule,
+                           time_elapsed);
+
+        if (current.second > 0) {
+            schedule.push(current);
+            continue;
+        }
+        // Generate process result based on the completion time (time
+        // that has elapsed)
+        results.emplace_back(current.first, time_elapsed);
+    }
+
+    return results;
+}
+
+std::ostream& operator<<(std::ostream& ostream,
+                         const std::vector<ProcessResult>& results) {
+    auto PrintCell = [&](const std::string& str) {
+        ostream << std::setw(17) << std::left << str;
+    };
+
+    std::vector<ProcessResult> sorted = results;
+    std::sort(sorted.begin(), sorted.end(), CompareAT);
+
+    PrintCell("Process ID");
+    PrintCell("Arrival Time");
+    PrintCell("Burst Time");
+    PrintCell("Completion Time");
+    PrintCell("Turnaround Time");
+    PrintCell("Waiting Time");
+    ostream << std::endl;
+
+    for (auto& p : sorted) {
+        PrintCell(std::to_string(p.id));
+        PrintCell(std::to_string(p.arrival_time));
+        PrintCell(std::to_string(p.burst_time));
+        PrintCell(std::to_string(p.completion_time));
+        PrintCell(std::to_string(p.turn_around_time));
+        PrintCell(std::to_string(p.waiting_time));
+        ostream << "\n";
+    }
+
+    return ostream;
+}
+
+void CheckArriveProcess(const std::vector<Process>& processes,
+                        std::set<uint32_t>* arrived_process,
+                        std::queue<std::pair<Process, BTLeft>>* schedule,
+                        uint32_t time_elapsed) {
+    for (auto& p : processes) {
+        if (p.arrival_time > time_elapsed ||
+            arrived_process->find(p.id) != arrived_process->end()) {
+            continue;
+        }
+        schedule->emplace(p, p.burst_time);
+        arrived_process->insert(p.id);
+    }
+}

dynamic_programming/0_1_knapsack.cpp

@@ -39,8 +39,8 @@ namespace dynamic_programming {
 namespace knapsack {
 /**
  * @brief Picking up all those items whose combined weight is below
- * the given capacity and calculating the value of those picked items. Trying all
- * possible combinations will yield the maximum knapsack value.
+ * the given capacity and calculating the value of those picked items. Trying
+ * all possible combinations will yield the maximum knapsack value.
  * @tparam n size of the weight and value array
  * @param capacity capacity of the carrying bag
  * @param weight array representing the weight of items
@@ -62,9 +62,9 @@ int maxKnapsackValue(const int capacity, const std::array<int, n> &weight,
                 // will be zero
                 maxValue[i][j] = 0;
             } else if (weight[i - 1] <= j) {
-                // if the ith item's weight(in the actual array it will be at i-1)
-                // is less than or equal to the allowed weight i.e. j then we
-                // can pick that item for our knapsack. maxValue will be the
+                // if the ith item's weight(in the actual array it will be at
+                // i-1) is less than or equal to the allowed weight i.e. j then
+                // we can pick that item for our knapsack. maxValue will be the
                 // obtained either by picking the current item or by not picking
                 // current item
 
@@ -76,8 +76,9 @@ int maxKnapsackValue(const int capacity, const std::array<int, n> &weight,
 
                 maxValue[i][j] = std::max(profit1, profit2);
             } else {
-                // as the weight of the current item is greater than the allowed weight, so
-                // maxProfit will be profit obtained by excluding the current item.
+                // as the weight of the current item is greater than the allowed
+                // weight, so maxProfit will be profit obtained by excluding the
+                // current item.
                 maxValue[i][j] = maxValue[i - 1][j];
             }
         }

physics/ground_to_ground_projectile_motion.cpp

@@ -43,7 +43,9 @@ double degrees_to_radians(double radian, double PI = 3.14) {
  */
 template <typename T>
 T time_of_flight(T initial_velocity, T angle, double gravity = 9.81) {
-    double Viy = initial_velocity * (std::sin(degrees_to_radians(angle))); // calculate y component of the initial velocity
+    double Viy = initial_velocity *
+                 (std::sin(degrees_to_radians(
+                     angle)));  // calculate y component of the initial velocity
     return 2.0 * Viy / gravity;
 }
 
@@ -55,7 +57,9 @@ T time_of_flight(T initial_velocity, T angle, double gravity = 9.81) {
  */
 template <typename T>
 T horizontal_range(T initial_velocity, T angle, T time) {
-    double Vix = initial_velocity * (std::cos(degrees_to_radians(angle))); // calculate x component of the initial velocity
+    double Vix = initial_velocity *
+                 (std::cos(degrees_to_radians(
+                     angle)));  // calculate x component of the initial velocity
     return Vix * time;
 }
 
@@ -68,7 +72,9 @@ T horizontal_range(T initial_velocity, T angle, T time) {
  */
 template <typename T>
 T max_height(T initial_velocity, T angle, double gravity = 9.81) {
-    double Viy = initial_velocity * (std::sin(degrees_to_radians(angle))); // calculate y component of the initial velocity
+    double Viy = initial_velocity *
+                 (std::sin(degrees_to_radians(
+                     angle)));  // calculate y component of the initial velocity
     return (std::pow(Viy, 2) / (2.0 * gravity));
 }
 }  // namespace ground_to_ground_projectile_motion
@@ -86,7 +92,9 @@ static void test() {
     // 1st test
     double expected_time_of_flight = 0.655;  // expected time output
     double flight_time_output =
-        std::round(physics::ground_to_ground_projectile_motion::time_of_flight(initial_velocity, angle) * 1000.0) /
+        std::round(physics::ground_to_ground_projectile_motion::time_of_flight(
+                       initial_velocity, angle) *
+                   1000.0) /
         1000.0;  // round output to 3 decimal places
 
     std::cout << "Projectile Flight Time (double)" << std::endl;
@@ -98,11 +106,13 @@ static void test() {
     std::cout << "TEST PASSED" << std::endl << std::endl;
 
     // 2nd test
-    double expected_horizontal_range = 2.51; // expected range output
+    double expected_horizontal_range = 2.51;  // expected range output
     double horizontal_range_output =
-        std::round(physics::ground_to_ground_projectile_motion::horizontal_range(initial_velocity, angle,
-                                             flight_time_output) *
-                   100.0) /
+        std::round(
+            physics::ground_to_ground_projectile_motion::horizontal_range(
+                initial_velocity, angle,
+                flight_time_output) *
+            100.0) /
         100.0;  // round output to 2 decimal places
 
     std::cout << "Projectile Horizontal Range (double)" << std::endl;
@@ -115,9 +125,11 @@ static void test() {
     std::cout << "TEST PASSED" << std::endl << std::endl;
 
     // 3rd test
-    double expected_max_height = 0.526; // expected height output
+    double expected_max_height = 0.526;  // expected height output
     double max_height_output =
-        std::round(physics::ground_to_ground_projectile_motion::max_height(initial_velocity, angle) * 1000.0) /
+        std::round(physics::ground_to_ground_projectile_motion::max_height(
+                       initial_velocity, angle) *
+                   1000.0) /
         1000.0;  // round output to 3 decimal places
 
     std::cout << "Projectile Max Height (double)" << std::endl;

sorting/merge_sort.cpp

@@ -31,7 +31,7 @@
  * @param r - end index or right index of second half array
  */
 void merge(int *arr, int l, int m, int r) {
-    int i, j, k;
+    int i = 0, j = 0, k = 0;
     int n1 = m - l + 1;
     int n2 = r - m;
 
@@ -88,7 +88,7 @@ void show(int *arr, int size) {
 
 /** Main function */
 int main() {
-    int size;
+    int size = 0;
     std::cout << "Enter the number of elements : ";
     std::cin >> size;
     int *arr = new int[size];