MIKE PLATA

//import java.util.*;

public class LastLaugh{

  public static void main(String[] args){

      //instantiate and initialize objects
	  GeneralUtility generalTool = new GeneralUtility();
	  FileUtility fileTool = new FileUtility();
	  InputUtility ioTool = new InputUtility();
	  LoadGame gameTool = new LoadGame();
	  CoreObjects gameStructure = new CoreObjects();
	  GameDriver gameDriver = new GameDriver();
	  
	  
	  //invoke loadObjects method to instantiate all needed objects
	  gameTool.createAndPopulateAllObjects(gameStructure);
	  
	  
	  //initiate do-while loop
     do {
    	 
    	 //invoke runTitleScreen method
    	 gameDriver.runTitleScreen(gameStructure, fileTool, ioTool);
    	 
    	 //initiate switch statement
    	 switch(gameStructure.getSelector().getTitleSelection()) {
    	 
	    	//enter case 1 
    	 	case 1:	gameDriver.runIntroSequence(gameStructure, fileTool, ioTool);
	    	 		break;//break out of switch
	    	 			
	    	//enter case 2 
    	 	case 2:	generalTool.runUpdateGameObjects(gameStructure);
	    			break;//break out of switch
	    			
    	 	//enter default case
    	 	default:	ioTool.tauntPlayer();
    	 }//end switch
    		
    	 
    	 if(gameStructure.getSelector().getTitleSelection() != 3)
    		 gameDriver.runMainGame(gameStructure, ioTool);
    	 
     }while(gameStructure.getSelector().getTitleSelection() != 3);

  }//end main

}//end class

// src/data/labs/pool-boy/full-code.cs
using System;
using System.Collections.Generic;

public class Pool
{
    static int poolCount = 0;
    Location location;
    Temperature temperature;
    int idNumber;

    public Pool(int x_Coordinate, int y_Coordinate, int degree, string scale)
    {
        location = new Location(x_Coordinate, y_Coordinate);
        temperature = new Temperature(degree, scale);
        this.idNumber = ++poolCount;
    }

    public Location Location { get => location; set => location = value; }
    public Temperature Temperature { get => temperature; set => temperature = value; }
    public int IdNumber { get => idNumber; }
}

public class MaintenanceCrew
{
    List<Pool> servicedPools;
    Location nextPoolLocation;

    public MaintenanceCrew()
    {
        servicedPools = new List<Pool>();
        nextPoolLocation = new Location();
    }

    public void MoveToNextPool(Pool[] pools)
    {
        // Max distance calculated from furthest origin bounds (14, 10)
        const double MAX_DISTANCE = 17.205;
        double distance, distanceToNextPool = MAX_DISTANCE;

        // Nearest Neighbor: Find the first pool to service from the origin
        if (servicedPools.Count == 0)
        {
            Location origin = new Location();
            for (int pool = 0; pool < pools.Length; pool++)
            {
                distance = FindDistance(origin, pools[pool].Location);
                if (distance < distanceToNextPool)
                {
                    distanceToNextPool = distance;
                    nextPoolLocation = pools[pool].Location;
                }
            }
        }
        // Nearest Neighbor: Find the closest unserviced pool from current location
        else
        {
            Location currentPoolLocation = servicedPools[(servicedPools.Count - 1)].Location;
            for (int pool = 0; pool < pools.Length; pool++)
            {
                if (!servicedPools.Contains(pools[pool]))
                {
                    distance = FindDistance(currentPoolLocation, pools[pool].Location);
                    if (distance < distanceToNextPool)
                    {
                        distanceToNextPool = distance;
                        nextPoolLocation = pools[pool].Location;
                    }
                }
            }
        }
    }

    private double FindDistance(Location currentPoolLocation, Location nextPoolLocation)
    {
        // Euclidean distance calculation
        double x2_x1 = nextPoolLocation.X_Coordinate - currentPoolLocation.X_Coordinate;
        double y2_y1 = nextPoolLocation.Y_Coordinate - currentPoolLocation.Y_Coordinate;
        
        return Math.Sqrt(Math.Pow(x2_x1, 2) + Math.Pow(y2_y1, 2));
    }

    public void UpdateServicedPoolsList(Pool[] pools)
    {
        foreach (Pool communityPool in pools)
        {
            if(communityPool.Location == nextPoolLocation)
            {
                servicedPools.Add(communityPool);
            }
        }
    }

    public void SetNewTemperature(ref Pool[] pools)
    {
        Random randomTemp = new Random();
        foreach (Pool communityPool in pools)
        {
            if (communityPool.Location == nextPoolLocation)
            {
                communityPool.Temperature.Degree = randomTemp.Next(98, 105);
            }
        }
    }

    public void ReturnToMaintenanceRoom()
    {
        const int ORIGIN = 0;
        nextPoolLocation.X_Coordinate = ORIGIN;
        nextPoolLocation.Y_Coordinate = ORIGIN;
    }
}

/*/////////////////////////////////////////////////////////////////////////////
Class:      ECE 3310 - Data Structures and Algorithms
Professor:  Professor Meng Lai Yin

Author:     M1-K3 (Mike Plata)
Program:    PA1 - Numerical Analysis- United States Population Mean
Purpose:    To demonstrate the function of an ADT array

Function:   This program instantiates an object of type UnitesStatesPopulation,
            which is an ADT array. Next it creates 50 objects of type
            StatePopulation and stores these objects in the ADT array. Then,
            reading from two separate files, writes to the data members of each
            StatePopulation, filling it with a state's name, population in the
            given year, and the year 2020. Finally the Mean of the United States
            Population is calculated recursively. All data is displayed to the
            user.

NOTES:      1. 9/21/2022 - Professor Yin modified the assignment by the following:
                a) data members encapsulated by the struct holding the data
                    'state name', 'state population', and 'year' no longer needs
                    the data member 'year', as we are only working with one year,
                    2020.
                b) the ADT array, may encapsulate a static array instead of a
                    pointer based dynamic array
            2. 9/25/2022 - A suggestion from a classmate was to use type 'long'
                for population and mean to express the values without scientific
                notation. Works well this way. I believe it was the right call.
*//////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <fstream>
#include <iomanip>
#include <string>
#include "UsaPopulations.h"
using namespace std;

///////////////////////////////////////////////////////////////////////////////
//========================== Function Prototypes ============================//
///////////////////////////////////////////////////////////////////////////////

void writeStateNamesToStates(ifstream& fileObjectIn, 
    UsaPopulations& populations);
void writeStatePopulationsToStates(ifstream& fileObjectIn, 
    UsaPopulations& populations);
void writeTable(UsaPopulations populations);
long calculatePopulationMean(UsaPopulations populations, int n);

///////////////////////////////////////////////////////////////////////////////
//============================= Global Constants ============================//
///////////////////////////////////////////////////////////////////////////////

const string NAMES_FILE = "StateNames.txt",
    POPULATIONS_FILE = "StatePopulations.txt";

///////////////////////////////////////////////////////////////////////////////
//========================= Main Entryway Of Program ========================//
///////////////////////////////////////////////////////////////////////////////
int main()
{    
    //instantiation of objects
    UsaPopulations usPopulation2020 = UsaPopulations();
    ifstream stateNames(NAMES_FILE), 
        statePopulations(POPULATIONS_FILE);

    //declare and initialize string constants
    const string POPULATION_MESSAGE = "Have you ever wondered what the mean, aka "
        "average, population across the United States was in 2020?\n\n"
        "Well, neither have I. Despite that, this program has calculated "
        "it for you.\n\n"
        "You're Welcome!\n",
        FILE_ERROR = "Could not open the file - '",
        POPULATION_LABEL = "\nThe U.S. population MEAN for 2020 is: ",
        END_MESSAGE = "\nThe program has ended. You may now close the window";

    //declare and initialize variables
    long populationMean_2020 = 0;

    //if file is open write data to array or exit with error
    if(stateNames.is_open())
        writeStateNamesToStates(stateNames, usPopulation2020);
    else
    {
        cerr << FILE_ERROR << NAMES_FILE << "'\n";

        return EXIT_FAILURE;
    }
    
    //if file is open write data to array or exit with error
    if(statePopulations.is_open())
        writeStatePopulationsToStates(statePopulations, usPopulation2020);
    else
    {
        cerr << FILE_ERROR << POPULATIONS_FILE << "'\n";

        return EXIT_FAILURE;
    }
    
    //calculate mean of US population in 2020
    populationMean_2020 = calculatePopulationMean(usPopulation2020,
        usPopulation2020.getSize());

    //displays message to user and waits for them to continue
    cout << POPULATION_MESSAGE;
    system("pause");

    //displays data: State Names, State Populations, and Population Mean
    writeTable(usPopulation2020);
    cout << POPULATION_LABEL << populationMean_2020 << END_MESSAGE + "\n\n";
    
    //fin
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//========================== Supplemental Methods ===========================//
///////////////////////////////////////////////////////////////////////////////

void writeStateNamesToStates(ifstream& fileObjectIn, 
    UsaPopulations& populations)
{
    string name = "";
    int dataSize = populations.getSize();

    for (int index = 0; index < dataSize; index++)
    {
        //write state name from file
        getline(fileObjectIn, name);

        populations.setStateName(index, name);
    }

    fileObjectIn.close();
}

void writeStatePopulationsToStates(ifstream& fileObjectIn, 
    UsaPopulations& populations)
{
    string population = "";
    int dataSize = populations.getSize();

    for (int index = 0; index < dataSize; index++)
    {
        //write state population from file
        getline(fileObjectIn, population);

        populations.setStatePopulation(index, stol(population));
    }

    fileObjectIn.close();
}

long calculatePopulationMean(UsaPopulations populations, int n)
{
    if (n == 1)
        return populations.getState(n - 1).statePopulation;
    else
        return ((calculatePopulationMean(populations, n - 1) * (n - 1) +
            populations.getState(n - 1).statePopulation) / n);
}

void writeTable(UsaPopulations populations)
{
    const int COLUMN_WIDTH_1 = 20, COLUMN_WIDTH_2 = 10, WIDTH_MOD = 5;
    const string COLUMN_1 = "STATE", COLUMN_2 = "POPULATION",
        OUTER_BORDER = string((COLUMN_WIDTH_1 + COLUMN_WIDTH_2 + WIDTH_MOD), '='),
        INNER_BORDER = string((COLUMN_WIDTH_1 + COLUMN_WIDTH_2 + WIDTH_MOD), '-');

    int dataSize = populations.getSize();
    
    cout << endl << OUTER_BORDER << endl 
        << setw(COLUMN_WIDTH_1) << left << COLUMN_1 + "\t" 
        << setw(COLUMN_WIDTH_2) << left << COLUMN_2 + "\n" 
        << OUTER_BORDER << endl;

    for (int index = 0; index < dataSize; index++)
    {
        cout << setw(COLUMN_WIDTH_1) << left 
            << populations.getState(index).stateName << "\t"
            << setw(COLUMN_WIDTH_2) << left 
            << populations.getState(index).statePopulation << "\n"
            << INNER_BORDER << endl;
    }

    cout << OUTER_BORDER << endl;
}

`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company: 
// Engineer: 
// 
// Create Date: 12/07/2023 06:08:42 PM
// Design Name: 
// Module Name: Combination_Control
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//////////////////////////////////////////////////////////////////////////////////


module Combination_Control(
		input[5:0] game_clock,
		input game_start_flag,
		input system_clock,
		input system_reset,

		output[11:0] current_lock_combination
	);

	reg[11:0] new_lock_combination_reg;	
	wire[11:0] random_lock_combination;
	wire[3:0] to_random_combo_control;
	
	Randomization_Control Randomizer(
	   .clock(system_clock),
	   .reset_internal_reg(system_reset),
        
       .randomization_factors(to_random_combo_control)
	);

	Combination_Generator RandomCombo(
		.randomization_factors(to_random_combo_control),
		.clock(system_clock),
		.reset_internal_reg(system_reset),

		.lock_combination(random_lock_combination)
	);
	
	always @(posedge system_clock)
	   begin
	       if(system_reset)
	           new_lock_combination_reg = 12'b0;
	       else if(game_start_flag == 1'b1 & (game_clock == 6'b000000))
	           begin
	               new_lock_combination_reg <= random_lock_combination;
	           end
	   end
	
//	always @(game_start_flag)
//	   begin
//	       new_lock_combination_reg <= random_lock_combination;
//	   end

//	always @(game_clock)
//		begin
//			if(game_clock == 6'b000000)
//				new_lock_combination_reg <= random_lock_combination;
//		end

	assign current_lock_combination = new_lock_combination_reg;
endmodule

`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company: 
// Engineer: 
// 
// Create Date: 12/07/2023 06:06:41 PM
// Design Name: 
// Module Name: Combination_Generator
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//////////////////////////////////////////////////////////////////////////////////


module Combination_Generator(
		input[3:0] randomization_factors,
		input clock,
		input reset_internal_reg,

		output[11:0] lock_combination
	);

	wire[11:0] lock_combo_bus;
	wire rng_always_enabled;
	assign rng_always_enabled = 1'b1;

	RNG_0_TO_F RandomDigit1(
		.clock(clock),
		.enable(rng_always_enabled),
		.reset(reset_internal_reg),
		.count_direction(randomization_factors[0]),
		.shift_or_rotate(randomization_factors[1]),
		.number_of_shifts_or_rotations(randomization_factors[3:2]),

		.random_number_out(lock_combo_bus[3:0])
	);

	RNG_0_TO_F RandomDigit2(
		.clock(clock),
		.enable(rng_always_enabled),
		.reset(reset_internal_reg),
		.count_direction(randomization_factors[3]),
		.shift_or_rotate(randomization_factors[0]),
		.number_of_shifts_or_rotations(randomization_factors[2:1]),

		.random_number_out(lock_combo_bus[7:4])
	);

	RNG_0_TO_F RandomDigit3(
		.clock(clock),
		.enable(rng_always_enabled),
		.reset(reset_internal_reg),
		.count_direction(randomization_factors[2]),
		.shift_or_rotate(randomization_factors[3]),
		.number_of_shifts_or_rotations(randomization_factors[1:0]),

		.random_number_out(lock_combo_bus[11:8])
	);

	assign lock_combination = lock_combo_bus;
endmodule

/*
    Class:      ECE 4310 - Op Sys for Embedded Apps
    Professor:  Liviu Oniciuc
    Assignment: Seminar Two - Process Scheduler
    Due Date:   3/5/2024
    Group:      A6
    Members:    Mike Plata & Jessica Ramirez
*/

///////////////////////////////////////////////////////////////////////////////
//LIBRARY INCLUSIONS
///////////////////////////////////////////////////////////////////////////////
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <time.h>

///////////////////////////////////////////////////////////////////////////////
//TYPE-DEF
///////////////////////////////////////////////////////////////////////////////
typedef struct Process Process;
struct Process
{
    Process* next;

    int id;
    char category[30];
    char state[10];
    int priority_level;
    int completion_time_ms;
    int processed_through_current_queue;
    int wait_counter;    
    
};

typedef struct Queue
{
    Process* head;
    Process* tail;

    int priority_level;
    int time_quantum_ms;
    int processes_in_queue;
}Queue;

///////////////////////////////////////////////////////////////////////////////
//PRE-PROCESSOR DIRECTIVES
///////////////////////////////////////////////////////////////////////////////
Process* createNewProcess();
void initializeProcessPriority(Process* process);
void initializeProcessCompletionTime(Process* process);
void sortProcess(Queue* hi, Queue* mid, Queue* low, Process* process);
void printProcessInfo(Process* process);
Queue* createNewQueue();
int enQueue(Queue* queue, Process* process);
Process* deQueue(Queue* queue);
void returnToFrontOfQueue(Queue* queue, Process* process);
Process* removeFromQueue(Queue* queue, Process* process_to_remove);
bool queueIsNotEmpty(Queue* queue);
void printQueueInfo(Queue* queue);
void multiLevelFeedbackScheduler(Queue* hi, Queue* mid, Queue* low);
void feedbackQueue(Queue* active_queue, Queue* lower_queue, Process* active_process);
void firstComeFirstServeQueue(Queue* active_queue, Process* active_process);
void runActiveProcess(Queue* queue, Process* process);
void updateWaitCountersMultipleQueues(Queue* q1, Queue* q2, Queue* q3, Process* last_process);
void updateWaitCounters(Queue* queue, Process* last_run_process);
void upgradeStarvingProcesses(Queue* hi, Queue* mid, Queue* low);
void upgradeProcessPriority(Queue* lower_priority_queue, Queue* higher_priority_queue);
void displayQueues(Queue* hi, Queue* mid, Queue* low);
bool newProcessArrival();
void newProcessAlert(char priority[]);
void priorityQueueUpgradeAlert();
void priorityQueueDowngradeAlert();

///////////////////////////////////////////////////////////////////////////////
//GLOBAL VARIABLES
///////////////////////////////////////////////////////////////////////////////
int global_nextProcess_id = 0;
int global_time_modifier = 0;

///////////////////////////////////////////////////////////////////////////////
//MAIN FUNCTION
///////////////////////////////////////////////////////////////////////////////
int main()
{   
    srand((unsigned int)(time(NULL) + global_time_modifier)); //seed rand function
    global_time_modifier++;
    int random_processes = rand() % 6 + 5; //random number from 5-10
    
    //define 3 queues of differing priority and unique time quantums
    Queue* high_priority_queue = createNewQueue(0,4);
    Queue* mid_priority_queue = createNewQueue(1,16);
    Queue* low_priority_queue = createNewQueue(2,32);

    //define 5 to 10 random process, sorted into differing priority queues 
    for(int make_new_process = 0; make_new_process < random_processes; make_new_process++)
        sortProcess(high_priority_queue, mid_priority_queue, low_priority_queue, createNewProcess());

    printf("\033[31m%d Processes Initially Made\n\n\033[0m", random_processes); 

    //continually run the Multi-Level Feedback Scheduler for testing
    /* do
    {
        displayQueues(high_priority_queue, mid_priority_queue, low_priority_queue);
        multiLevelFeedbackScheduler(high_priority_queue, mid_priority_queue, low_priority_queue);
        
    } while (true); */

    for(int run_scheduler = 0; run_scheduler < (random_processes * 2); run_scheduler++)
    {
        displayQueues(high_priority_queue, mid_priority_queue, low_priority_queue);
        multiLevelFeedbackScheduler(high_priority_queue, mid_priority_queue, low_priority_queue);
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//HELPER FUNCTIONS - PROCESSES
///////////////////////////////////////////////////////////////////////////////
Process* createNewProcess()
{
    Process* new_process = (Process*) malloc(sizeof(Process));

    if(new_process == NULL) 
        return NULL;

    new_process->next = NULL;
    new_process->id = global_nextProcess_id;
    strcpy(new_process->state,"READY");
    new_process->processed_through_current_queue = 0;
    new_process->wait_counter = 0; 
    initializeProcessPriority(new_process);
    initializeProcessCompletionTime(new_process);
      
    global_nextProcess_id++;
    return new_process;
}

void initializeProcessPriority(Process* process)
{
    srand((unsigned int)(time(NULL) + global_time_modifier)); //seed rand function
    global_time_modifier++;

    switch(process->priority_level = rand() % 3)
    {
        case 0:
            strcpy(process->category,"System Process");
            break;

        case 1:
            strcpy(process->category,"Interactive Process");
            break;

        case 2:
            strcpy(process->category,"Batch Process");
            break;

        default:
            strcpy(process->category,"Categorization ERROR");
            break;
    }
}

void initializeProcessCompletionTime(Process* process)
{
    srand((unsigned int)(time(NULL) + global_time_modifier)); //seed rand function
    global_time_modifier++;
    
    switch(rand() % 4) //random number from 0-3
    {
        case 0:
            process->completion_time_ms = 4;
            break;

        case 1:
            process->completion_time_ms = 16;
            break;

        case 2:
            process->completion_time_ms = 32;
            break;

        case 3:
            process->completion_time_ms = 64;
            break;
            
        default:
            process->completion_time_ms = 0;
            break;
    }
}

void sortProcess(Queue* hi, Queue* mid, Queue* low, Process* process)
{
    switch(process->priority_level)
    {
        case 0:
            enQueue(hi, process);
            newProcessAlert("HIGH");
            break;

        case 1:
            enQueue(mid, process);
            newProcessAlert("MID");
            break;

        case 2:
            enQueue(low, process);
            newProcessAlert("LOW");
            break;

        default:
            printf("\n:::: ERROR SORTING PROCESS ::::\n");
            break;
    }
}

void printProcessInfo(Process* process)
{
    printf("\033[33m+--------------------------------------+\n");
    printf("| Process ID:           %8d       |\n", process->id);
    printf("| Category:             %8s |\n", process->category);
    printf("| State:                %8s       |\n", process->state);
    printf("| Priority Level:       %8d       |\n", process->priority_level);
    printf("| Completion Time (ms): %8d       |\n", process->completion_time_ms);
    printf("| Wait Counter:         %8d       |\n", process->wait_counter);
    printf("+--------------------------------------+\033[0m\n");
}

///////////////////////////////////////////////////////////////////////////////
//HELPER FUNCTIONS - QUEUES
///////////////////////////////////////////////////////////////////////////////
Queue* createNewQueue(int priority_level, int time_quantum)
{
    Queue* new_queue = (Queue*) malloc(sizeof(Queue));

    if(new_queue == NULL)
        return NULL;

    new_queue->head = NULL;
    new_queue->tail = NULL;
    new_queue->priority_level = priority_level;
    new_queue->time_quantum_ms = time_quantum;
    new_queue->processes_in_queue = 0;

    return new_queue;
}

int enQueue(Queue* queue, Process* process)
{
    if(queue == NULL)
        return -1;

    if(queue->head == NULL)
    {
        queue->head = process;
        queue->tail = process;
        queue->processes_in_queue++;
        return 0;
    }

    queue->tail->next = process;
    queue->tail = process;
    queue->processes_in_queue++;
    return 0;
}

Process* deQueue(Queue* queue)
{
    if(queue == NULL || queue->head == NULL)
        return NULL;

    Process* dequeued_process = queue->head;
    
    if(queue->head == queue->tail)
    {
        queue->head = NULL;
        queue->tail = NULL;
        dequeued_process->next = NULL;
        queue->processes_in_queue--;
        return dequeued_process;
    }

    queue->head = queue->head->next;
    dequeued_process->next = NULL;
    queue->processes_in_queue--;
    return dequeued_process;
}

void returnToFrontOfQueue(Queue* queue, Process* process)
{
    if(!queueIsNotEmpty(queue))
        enQueue(queue, process);
    else
    {
        process->next = queue->head;
        queue->head = process;
    }

    queue->processes_in_queue++;
}

Process* removeFromQueue(Queue* queue, Process* process_to_remove)
{
    Process* original_head = queue->head;
    Process* process_to_check;
    Process* removed_process;

    //checks if the queue's head is the process to be removed
    //if yes, removes and returns it, if not, puts it in the back of the queue
    if(process_to_remove == queue->head)
    {
        removed_process = deQueue(queue);
        removed_process->next = NULL;
        return removed_process;
    }
    else
        enQueue(queue,deQueue(queue));
    
    //if original head was not process to be removed, cycles through queue to find
    //the process to be removed, and puts queue back in original order
    do
    {
        process_to_check = deQueue(queue);
        
        if(process_to_check == process_to_remove)
            removed_process = process_to_check;
        else
            enQueue(queue, process_to_check);

    } while (queue->head != original_head);
    
    removed_process->next = NULL;
    return removed_process;
}

bool queueIsNotEmpty(Queue* queue)
{
    if(queue->head != NULL) 
        return true;
    else 
        return false;
}

void printQueueInfo(Queue* queue)
{   
    printf("\033[32m╔════════════════════════════════════╗\n");
    printf("║  Queue Priority Level:  %8d   ║\n", queue->priority_level);
    printf("║  Time Quantum (ms):     %8d   ║\n", queue->time_quantum_ms);
    printf("║  Processes in Queue:    %8d   ║\n", queue->processes_in_queue);
    printf("║  Head Process ID:       %8d   ║\n", (queue->head != NULL) ? queue->head->id : -1);

    if(queue->processes_in_queue > 2)
    {
        Process* current_process = queue->head->next;
        
        do
        {
            printf("║  Next Process ID:       %8d   ║\n", current_process->id);
            current_process = current_process->next;

        } while (current_process != queue->tail);
        
    }

    printf("║  Tail Process ID:       %8d   ║\n", (queue->tail != NULL) ? queue->tail->id : -1);
    printf("╚════════════════════════════════════╝\033[0m\n");
}

///////////////////////////////////////////////////////////////////////////////
//HELPER FUNCTIONS - SCHEDULER
///////////////////////////////////////////////////////////////////////////////
void multiLevelFeedbackScheduler(Queue* hi, Queue* mid, Queue* low)
{
    /* srand((unsigned int)(time(NULL) + global_time_modifier)); //seed rand function
    global_time_modifier++; */

    Process* active_process = NULL;
    
    //check queues for processes and process queues in order from hi to low priority
    if(queueIsNotEmpty(hi))
        feedbackQueue(hi, mid, active_process);
    else if(queueIsNotEmpty(mid))
        feedbackQueue(mid, low, active_process);
    else if(queueIsNotEmpty(low))
        firstComeFirstServeQueue(low, active_process);
    
    updateWaitCountersMultipleQueues(hi, mid, low, active_process);

    upgradeStarvingProcesses(hi, mid, low);

    //if random number from 0-3 is a 1, create new process and place in queue
    if(newProcessArrival())
    {
        sortProcess(hi, mid, low, createNewProcess());
        //printf("\n\nNEW PROCESS ADDED TO A QUEUE\n\n");
    }
}

void feedbackQueue(Queue* active_queue, Queue* lower_queue, Process* active_process)
{
    active_process = deQueue(active_queue);
    runActiveProcess(active_queue, active_process);
    active_process->processed_through_current_queue++;

    if(active_process->completion_time_ms > 0 && active_process->processed_through_current_queue < 3)
        enQueue(active_queue, active_process);
    else if(active_process->completion_time_ms > 0)
    {
        active_process->processed_through_current_queue = 0;
        enQueue(lower_queue, active_process);
        priorityQueueDowngradeAlert();
    }
       
    else
        free(active_process);
}

void firstComeFirstServeQueue(Queue* active_queue, Process* active_process)
{
    //take the process at the front of the queue and run it 
    active_process = deQueue(active_queue);
    runActiveProcess(active_queue, active_process);

    if(active_process->completion_time_ms > 0)
        returnToFrontOfQueue(active_queue, active_process);
    else
        free(active_process);
}

void runActiveProcess(Queue* queue, Process* process)
{
    //update process' state to active
    strcpy(process->state,"ACTIVE");
    printProcessInfo(process);
    
    //update process' time to completion
    process->completion_time_ms -= queue->time_quantum_ms;
    if(process->completion_time_ms < 0)
        process->completion_time_ms = 0;

    //reset process' time waiting to be the active process
    process->wait_counter = 0;
    
    //update process' state to either ready or complete
    if(process->completion_time_ms == 0)
        strcpy(process->state,"COMPLETE");
    else
        strcpy(process->state,"READY");
    
    printProcessInfo(process);
}

void updateWaitCountersMultipleQueues(Queue* q1, Queue* q2, Queue* q3, Process* last_process)
{
    if(queueIsNotEmpty(q1))
        updateWaitCounters(q1, last_process);

    if(queueIsNotEmpty(q2))
        updateWaitCounters(q2, last_process);

    if(queueIsNotEmpty(q3))
        updateWaitCounters(q3, last_process);
}

void updateWaitCounters(Queue* queue, Process* last_run_process)
{
    Process* original_head = queue->head;
    Process* process_to_update;

    do
    {
        process_to_update = deQueue(queue);

        if(process_to_update != last_run_process)
            process_to_update->wait_counter++;

        enQueue(queue, process_to_update);

    } while (queue->head != original_head);
    
}

void upgradeStarvingProcesses(Queue* hi, Queue* mid, Queue* low)
{
    //if any starving proccess found, upgrade them to the highest priority queue.
    if(queueIsNotEmpty(mid))
        upgradeProcessPriority(mid, hi);

    //if any starving proccess found, upgrade them to the highest priority queue.
    if(queueIsNotEmpty(low))
        upgradeProcessPriority(low, hi);
}

void upgradeProcessPriority(Queue* lower_priority_queue, Queue* higher_priority_queue)
{
    Process* current_process = lower_priority_queue->head;
    Process* removed_process;

    const int LONG_WAIT_TIME = 4;

    do
    {
        if(current_process->wait_counter == LONG_WAIT_TIME)
        {
            removed_process = current_process;
            current_process = current_process->next;

            removed_process = removeFromQueue(lower_priority_queue, removed_process);
            enQueue(higher_priority_queue, removed_process);

            priorityQueueUpgradeAlert();
        }
        else
            current_process = current_process->next;
            
    } while (current_process != NULL);
}

///////////////////////////////////////////////////////////////////////////////
//HELPER FUNCTIONS - MISC
///////////////////////////////////////////////////////////////////////////////
void displayQueues(Queue* hi, Queue* mid, Queue* low)
{
    printQueueInfo(hi);
    printQueueInfo(mid);
    printQueueInfo(low);
}

bool newProcessArrival()
{
    srand((unsigned int)(time(NULL) + global_time_modifier)); //seed rand function
    global_time_modifier++;

    if(rand() % 4 == 1)
        return true;
    else 
        return false;
}

void newProcessAlert(char priority[])
{
    printf("+*****************************************+\n");
    printf("| NEW PROCESS ADDED TO %s PRIORITY QUEUE |\n", priority);
    printf("+*****************************************+\n");
}

void priorityQueueUpgradeAlert()
{
    printf("\033[34m+<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>+\n");
    printf("| PROCESS UPGRADED TO HIGH PRIORITY QUEUE  |\n");
    printf("+<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>+\033[0m\n");
}

void priorityQueueDowngradeAlert()
{
    printf("\033[35m+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+\n");
    printf("|  PROCESS DOWNGRADED TO LOWER PRIORITY QUEUE |\n");
    printf("+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+\033[0m\n");
}

import cv2
import numpy as np
import time
import os
from matplotlib import pyplot as plt
import psutil


start_time = time.time()
process = psutil.Process(os.getpid())
start_cpu_times = process.cpu_times()
cpu_freq = psutil.cpu_freq().current  # in MHz



# Get current script directory and image path
script_path = os.path.abspath(__file__)
new_directory = os.path.dirname(script_path)
image_file_path = os.path.join(new_directory, 'highresstockimage.png')

# Read and convert image
color_image = cv2.imread(image_file_path)
gray_image = cv2.cvtColor(color_image, cv2.COLOR_BGR2GRAY)

# Create convolution matrices
edge_detection_matrix = np.array([
    [-0.7263, -0.9183, -0.9078, -0.9109, -0.9078, -0.9183, -0.7263],
    [-0.7263, -0.5612, -0.5847, -0.5814, -0.5847, -0.5612, -0.7263],
    [ 0.5447,  0.6292,  0.6539,  0.6543,  0.6539,  0.6292,  0.5447],
    [ 1.8157,  1.7005,  1.6771,  1.6758,  1.6771,  1.7005,  1.8157],
    [ 0.5447,  0.6292,  0.6539,  0.6543,  0.6539,  0.6292,  0.5447],
    [-0.7263, -0.5612, -0.5847, -0.5814, -0.5847, -0.5612, -0.7263],
    [-0.7263, -0.9183, -0.9078, -0.9109, -0.9078, -0.9183, -0.7263]
])

gaussian_blur_matrix = np.array([
    [0.00000067, 0.00002292, 0.00019117, 0.00038771, 0.00019117, 0.00002292, 0.00000067],
    [0.00002292, 0.00078633, 0.00655965, 0.01330373, 0.00655965, 0.00078633, 0.00002292],
    [0.00019117, 0.00655965, 0.05472157, 0.11098164, 0.05472157, 0.00655965, 0.00019117],
    [0.00038771, 0.01330373, 0.11098164, 0.22508352, 0.11098164, 0.01330373, 0.00038771],
    [0.00019117, 0.00655965, 0.05472157, 0.11098164, 0.05472157, 0.00655965, 0.00019117],
    [0.00002292, 0.00078633, 0.00655965, 0.01330373, 0.00655965, 0.00078633, 0.00002292],
    [0.00000067, 0.00002292, 0.00019117, 0.00038771, 0.00019117, 0.00002292, 0.00000067]
])

sharpening_matrix = np.array([
    [ 0,    0,   -0.2,  0,    0],
    [ 0,  -0.2,  -0.5, -0.2,  0],
    [-0.2, -0.5,  5,   -0.5, -0.2],
    [ 0,  -0.2,  -0.5, -0.2,  0],
    [ 0,    0,   -0.2,  0,    0]
])

# Apply convolutions
blurred_image = cv2.filter2D(gray_image, -1, gaussian_blur_matrix)
edged_image = cv2.filter2D(gray_image, -1, edge_detection_matrix)
sharpened_image = cv2.filter2D(gray_image, -1, sharpening_matrix)

# Display images using matplotlib
plt.figure("Original Image")
plt.imshow(gray_image, cmap='gray')
plt.axis('off')

plt.figure("Blurred Image")
plt.imshow(blurred_image, cmap='gray')
plt.axis('off')

plt.figure("Edged Image")
plt.imshow(edged_image, cmap='gray')
plt.axis('off')

plt.figure("Sharpened Image")
plt.imshow(sharpened_image, cmap='gray')
plt.axis('off')

elapsed_time = time.time() - start_time

# End measurements
elapsed_time = time.time() - start_time
end_cpu_times = process.cpu_times()
user_time = end_cpu_times.user - start_cpu_times.user
system_time = end_cpu_times.system - start_cpu_times.system
total_cpu_time = user_time + system_time

# Estimate total cycles and CPI
cpu_freq_hz = cpu_freq * 1e6  # Convert MHz to Hz
estimated_cycles = total_cpu_time * cpu_freq_hz
# NOTE: Instruction count is not measurable directly from Python.
# Assume an estimate (e.g. 1e9) or use `perf` externally for actual instruction count.
estimated_instructions = 1e9
estimated_cpi = estimated_cycles / estimated_instructions


print(f'\n--- Benchmark Results ---')
print(f'Elapsed time: {elapsed_time:.4f} seconds')
print(f'Estimated CPU frequency: {cpu_freq:.2f} MHz')
print(f'Estimated CPU cycles: {estimated_cycles:.0f}')
print(f'Estimated CPI (based on 1e9 instructions): {estimated_cpi:.4f}')
print(f'Memory used: {process.memory_info().rss / (1024 ** 2):.2f} MB')


plt.show()