Projects Inventory – Page 104 – Projects Inventory Management Systems and Source Codes PHP, C#, C, Android and many others

Functional requirements of Restaurant Ordering System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements for a Restaurant Ordering System User Authentication and Authorization: Customer: Ability to create accounts, log in, and manage personal profiles. Restaurant Staff: Secure login and role-based access for different functions (e.g., waitstaff, kitchen staff, managers). Admin: Full access for system configuration and management. Menu Management: Admin/Restaurant Staff: Add, update, and delete menu items, …

Functional requirements of Restaurant Ordering System with non-functional Read More »

Simulation of Traffic Signal Control Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <chrono>
#include <thread>

// Constants for traffic light durations
const int GREEN_DURATION = 10; // Duration of green light in seconds
const int YELLOW_DURATION = 3;  // Duration of yellow light in seconds
const int RED_DURATION = 7;     // Duration of red light in seconds

// Function to simulate traffic signal control
void simulateTrafficSignal() {
    while (true) {
        std::cout << "Green light\n";
        std::this_thread::sleep_for(std::chrono::seconds(GREEN_DURATION));

        std::cout << "Yellow light\n";
        std::this_thread::sleep_for(std::chrono::seconds(YELLOW_DURATION));

        std::cout << "Red light\n";
        std::this_thread::sleep_for(std::chrono::seconds(RED_DURATION));
    }
}

int main() {
    std::cout << "Traffic Signal Control Simulation\n";
    simulateTrafficSignal();
    return 0;
}

#include <iostream>

#include <chrono>

#include <thread>

// Constants for traffic light durations

const int GREEN_DURATION = 10; // Duration of green light in seconds

const int YELLOW_DURATION = 3; // Duration of yellow light in seconds

const int RED_DURATION = 7; // Duration of red light in seconds

// Function to simulate traffic signal control

void simulateTrafficSignal() {

while (true) {

std::cout << "Green light\n";

std::this_thread::sleep_for(std::chrono::seconds(GREEN_DURATION));

std::cout << "Yellow light\n";

std::this_thread::sleep_for(std::chrono::seconds(YELLOW_DURATION));

std::cout << "Red light\n";

std::this_thread::sleep_for(std::chrono::seconds(RED_DURATION));

}

int main() {

std::cout << "Traffic Signal Control Simulation\n";

simulateTrafficSignal();

return 0;

}

Explanation Constants: GREEN_DURATION: The duration of the green light phase in seconds. YELLOW_DURATION: The duration of the yellow light phase in seconds. RED_DURATION: The duration of the red light phase in seconds. simulateTrafficSignal Function: Continuously simulates the traffic signal cycles. Green Light: Prints “Green light” and waits for GREEN_DURATION seconds. Yellow Light: Prints “Yellow …

Simulation of Traffic Signal Control Gaming Project in C++ Read More »

Functional requirements of Repair Service Management System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements for a Repair Service Management System User Authentication and Authorization: Users (customers, repair technicians, service managers, and administrators) should be able to create accounts, log in, and manage their profiles. Role-based access control to manage permissions and access levels for different user types. Service Request Management: Allow customers to create and submit service …

Functional requirements of Repair Service Management System with non-functional Read More »

Simulation of Virtual Memory Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_map>

// Constants
const int PAGE_SIZE = 4; // Number of pages in memory
const int NUM_PAGES = 10; // Total number of pages in the virtual memory

// Class to simulate a virtual memory system
class VirtualMemory {
public:
    VirtualMemory(int pageSize) : pageSize(pageSize) {}

    // Access a page
    void accessPage(int pageNumber) {
        if (pageTable.find(pageNumber) == pageTable.end()) {
            // Page fault: page not in memory
            if (memory.size() >= pageSize) {
                // Memory is full, need to evict a page
                int evictPage = pageQueue.front();
                pageQueue.pop();
                pageTable.erase(evictPage);
                std::cout << "Page " << evictPage << " evicted from memory.\n";
            }
            // Load the page into memory
            memory.push_back(pageNumber);
            pageTable[pageNumber] = memory.size() - 1;
            pageQueue.push(pageNumber);
            std::cout << "Page " << pageNumber << " loaded into memory.\n";
        } else {
            // Page hit: page is already in memory
            std::cout << "Page " << pageNumber << " is already in memory.\n";
        }
    }

    // Print current memory state
    void printMemory() const {
        std::cout << "Current memory state: ";
        for (int page : memory) {
            std::cout << page << " ";
        }
        std::cout << std::endl;
    }

private:
    int pageSize;
    std::vector<int> memory;
    std::unordered_map<int, int> pageTable; // Maps page number to its position in memory
    std::queue<int> pageQueue; // Keeps track of page replacement order
};

int main() {
    VirtualMemory vm(PAGE_SIZE);

    // Simulate accessing pages
    std::vector<int> pageRequests = {1, 2, 3, 4, 1, 5, 6, 2, 7, 8, 9, 10, 5, 3};

    for (int pageNumber : pageRequests) {
        vm.accessPage(pageNumber);
        vm.printMemory();
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <queue>

#include <unordered_map>

// Constants

const int PAGE_SIZE = 4; // Number of pages in memory

const int NUM_PAGES = 10; // Total number of pages in the virtual memory

// Class to simulate a virtual memory system

class VirtualMemory {

public:

VirtualMemory(int pageSize) : pageSize(pageSize) {}

// Access a page

void accessPage(int pageNumber) {

if (pageTable.find(pageNumber) == pageTable.end()) {

// Page fault: page not in memory

if (memory.size() >= pageSize) {

// Memory is full, need to evict a page

int evictPage = pageQueue.front();

pageQueue.pop();

pageTable.erase(evictPage);

std::cout << "Page " << evictPage << " evicted from memory.\n";

}

// Load the page into memory

memory.push_back(pageNumber);

pageTable[pageNumber] = memory.size() - 1;

pageQueue.push(pageNumber);

std::cout << "Page " << pageNumber << " loaded into memory.\n";

} else {

// Page hit: page is already in memory

std::cout << "Page " << pageNumber << " is already in memory.\n";

}

// Print current memory state

void printMemory() const {

std::cout << "Current memory state: ";

for (int page : memory) {

std::cout << page << " ";

}

std::cout << std::endl;

}

private:

int pageSize;

std::vector<int> memory;

std::unordered_map<int, int> pageTable; // Maps page number to its position in memory

std::queue<int> pageQueue; // Keeps track of page replacement order

};

int main() {

VirtualMemory vm(PAGE_SIZE);

// Simulate accessing pages

std::vector<int> pageRequests = {1, 2, 3, 4, 1, 5, 6, 2, 7, 8, 9, 10, 5, 3};

for (int pageNumber : pageRequests) {

vm.accessPage(pageNumber);

vm.printMemory();

}

return 0;

}

Explanation Constants: PAGE_SIZE: The maximum number of pages that can be held in memory at a time. NUM_PAGES: Total number of unique pages in virtual memory. VirtualMemory Class: Attributes: pageSize: Maximum capacity of pages in memory. memory: Vector to store pages currently in memory. pageTable: Maps page numbers to their positions in memory for …

Simulation of Virtual Memory Gaming Project in C++ Read More »

Functional requirements of Rental Car Management System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements for a Rental Car Management System User Authentication and Authorization: Users (customers, rental agents, and administrators) should be able to create accounts, log in, and manage their profiles. Role-based access control to manage permissions for different user types. Vehicle Management: Ability to add, edit, and manage vehicle listings, including details like make, model, …

Functional requirements of Rental Car Management System with non-functional Read More »

Simulation of Virtual Reality (VR) Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <conio.h> // For _kbhit() and _getch()

// Constants for movement speed
const float MOVE_SPEED = 0.5f;

// Function to print the current position of the object
void printPosition(float x, float y, float z) {
    std::cout << "Object Position - X: " << x << ", Y: " << y << ", Z: " << z << std::endl;
}

// Function to handle user input and move the object
void handleInput(float& x, float& y, float& z) {
    if (_kbhit()) {
        char ch = _getch(); // Get the user input

        switch (ch) {
            case 'w': // Move forward
                z -= MOVE_SPEED;
                break;
            case 's': // Move backward
                z += MOVE_SPEED;
                break;
            case 'a': // Move left
                x -= MOVE_SPEED;
                break;
            case 'd': // Move right
                x += MOVE_SPEED;
                break;
            case 'q': // Move up
                y += MOVE_SPEED;
                break;
            case 'e': // Move down
                y -= MOVE_SPEED;
                break;
            case 'x': // Exit the simulation
                std::exit(0);
                break;
        }
    }
}

int main() {
    // Initial position of the virtual object
    float x = 0.0f;
    float y = 0.0f;
    float z = 0.0f;

    std::cout << "Virtual Reality Simulation\n";
    std::cout << "Controls:\n";
    std::cout << "W: Move Forward\n";
    std::cout << "S: Move Backward\n";
    std::cout << "A: Move Left\n";
    std::cout << "D: Move Right\n";
    std::cout << "Q: Move Up\n";
    std::cout << "E: Move Down\n";
    std::cout << "X: Exit Simulation\n";

    while (true) {
        printPosition(x, y, z);
        handleInput(x, y, z);
    }

    return 0;
}

#include <iostream>

#include <conio.h> // For _kbhit() and _getch()

// Constants for movement speed

const float MOVE_SPEED = 0.5f;

// Function to print the current position of the object

void printPosition(float x, float y, float z) {

std::cout << "Object Position - X: " << x << ", Y: " << y << ", Z: " << z << std::endl;

}

// Function to handle user input and move the object

void handleInput(float& x, float& y, float& z) {

if (_kbhit()) {

char ch = _getch(); // Get the user input

switch (ch) {

case 'w': // Move forward

z -= MOVE_SPEED;

break;

case 's': // Move backward

z += MOVE_SPEED;

break;

case 'a': // Move left

x -= MOVE_SPEED;

break;

case 'd': // Move right

x += MOVE_SPEED;

break;

case 'q': // Move up

y += MOVE_SPEED;

break;

case 'e': // Move down

y -= MOVE_SPEED;

break;

case 'x': // Exit the simulation

std::exit(0);

break;

}

int main() {

// Initial position of the virtual object

float x = 0.0f;

float y = 0.0f;

float z = 0.0f;

std::cout << "Virtual Reality Simulation\n";

std::cout << "Controls:\n";

std::cout << "W: Move Forward\n";

std::cout << "S: Move Backward\n";

std::cout << "A: Move Left\n";

std::cout << "D: Move Right\n";

std::cout << "Q: Move Up\n";

std::cout << "E: Move Down\n";

std::cout << "X: Exit Simulation\n";

while (true) {

printPosition(x, y, z);

handleInput(x, y, z);

}

return 0;

}

Explanation Constants: MOVE_SPEED: Defines how much the object moves per key press. printPosition Function: Outputs the current position of the virtual object in 3D space. handleInput Function: Handles user input to move the object. Uses _kbhit() and _getch() from <conio.h> to check for and get keyboard input. Moves the object based on the pressed …

Simulation of Virtual Reality (VR) Gaming Project in C++ Read More »

Functional requirements of Rent Management System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements for a Rent Management System User Authentication and Authorization: Users (landlords, tenants, and administrators) should be able to create accounts, log in, and manage their profiles. Role-based access control to manage permissions and access levels for different user types. Property Management: Landlords should be able to add, edit, and manage property listings, including …

Functional requirements of Rent Management System with non-functional Read More »

Functional requirements of Remote Health Monitoring System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements for a Remote Health Monitoring System User Authentication and Authorization: Users (patients, healthcare providers, and administrators) should be able to create accounts, log in, and manage their profiles. Role-based access control to manage permissions for different user types. Health Data Collection: Ability to collect health data from various sources such as wearable devices …

Functional requirements of Remote Health Monitoring System with non-functional Read More »

Simulation of Water Ripple Effect Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>

// Constants
const int GRID_SIZE = 20; // Size of the grid (GRID_SIZE x GRID_SIZE)
const double DAMPING_FACTOR = 0.98; // Damping factor for ripple effect
const double RIPPLE_STRENGTH = 10.0; // Initial strength of the ripple
const int RIPPLE_RADIUS = 5; // Radius of the ripple effect
const int NUM_STEPS = 30; // Number of simulation steps

// Function to initialize the grid
void initializeGrid(std::vector<std::vector<double>>& grid) {
    for (int i = 0; i < GRID_SIZE; ++i) {
        for (int j = 0; j < GRID_SIZE; ++j) {
            grid[i][j] = 0.0;
        }
    }
}

// Function to create a ripple effect
void createRipple(std::vector<std::vector<double>>& grid, int centerX, int centerY, double strength) {
    for (int i = 0; i < GRID_SIZE; ++i) {
        for (int j = 0; j < GRID_SIZE; ++j) {
            double distance = std::sqrt((i - centerX) * (i - centerX) + (j - centerY) * (j - centerY));
            if (distance < RIPPLE_RADIUS) {
                grid[i][j] += strength * (1.0 - distance / RIPPLE_RADIUS);
            }
        }
    }
}

// Function to update the grid
void updateGrid(std::vector<std::vector<double>>& grid) {
    std::vector<std::vector<double>> newGrid = grid;
    for (int i = 1; i < GRID_SIZE - 1; ++i) {
        for (int j = 1; j < GRID_SIZE - 1; ++j) {
            newGrid[i][j] = (grid[i - 1][j] + grid[i + 1][j] + grid[i][j - 1] + grid[i][j + 1]) / 4.0;
            newGrid[i][j] *= DAMPING_FACTOR;
        }
    }
    grid = newGrid;
}

// Function to print the grid
void printGrid(const std::vector<std::vector<double>>& grid) {
    for (const auto& row : grid) {
        for (double value : row) {
            std::cout << std::setw(6) << std::fixed << std::setprecision(2) << value << " ";
        }
        std::cout << "\n";
    }
    std::cout << "\n";
}

int main() {
    // Create a grid for the simulation
    std::vector<std::vector<double>> grid(GRID_SIZE, std::vector<double>(GRID_SIZE, 0.0));
    
    // Initialize the grid
    initializeGrid(grid);
    
    // Create an initial ripple effect
    createRipple(grid, GRID_SIZE / 2, GRID_SIZE / 2, RIPPLE_STRENGTH);

    std::cout << "Initial Ripple Effect:\n";
    printGrid(grid);

    // Simulate the ripple effect over time
    for (int step = 0; step < NUM_STEPS; ++step) {
        updateGrid(grid);
        std::cout << "Step " << step + 1 << ":\n";
        printGrid(grid);
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <cmath>

#include <iomanip>

// Constants

const int GRID_SIZE = 20; // Size of the grid (GRID_SIZE x GRID_SIZE)

const double DAMPING_FACTOR = 0.98; // Damping factor for ripple effect

const double RIPPLE_STRENGTH = 10.0; // Initial strength of the ripple

const int RIPPLE_RADIUS = 5; // Radius of the ripple effect

const int NUM_STEPS = 30; // Number of simulation steps

// Function to initialize the grid

void initializeGrid(std::vector<std::vector<double>>& grid) {

for (int i = 0; i < GRID_SIZE; ++i) {

for (int j = 0; j < GRID_SIZE; ++j) {

grid[i][j] = 0.0;

}

// Function to create a ripple effect

void createRipple(std::vector<std::vector<double>>& grid, int centerX, int centerY, double strength) {

for (int i = 0; i < GRID_SIZE; ++i) {

for (int j = 0; j < GRID_SIZE; ++j) {

double distance = std::sqrt((i - centerX) * (i - centerX) + (j - centerY) * (j - centerY));

if (distance < RIPPLE_RADIUS) {

grid[i][j] += strength * (1.0 - distance / RIPPLE_RADIUS);

}

// Function to update the grid

void updateGrid(std::vector<std::vector<double>>& grid) {

std::vector<std::vector<double>> newGrid = grid;

for (int i = 1; i < GRID_SIZE - 1; ++i) {

for (int j = 1; j < GRID_SIZE - 1; ++j) {

newGrid[i][j] = (grid[i - 1][j] + grid[i + 1][j] + grid[i][j - 1] + grid[i][j + 1]) / 4.0;

newGrid[i][j] *= DAMPING_FACTOR;

}

grid = newGrid;

}

// Function to print the grid

void printGrid(const std::vector<std::vector<double>>& grid) {

for (const auto& row : grid) {

for (double value : row) {

std::cout << std::setw(6) << std::fixed << std::setprecision(2) << value << " ";

}

std::cout << "\n";

}

std::cout << "\n";

}

int main() {

// Create a grid for the simulation

std::vector<std::vector<double>> grid(GRID_SIZE, std::vector<double>(GRID_SIZE, 0.0));

// Initialize the grid

initializeGrid(grid);

// Create an initial ripple effect

createRipple(grid, GRID_SIZE / 2, GRID_SIZE / 2, RIPPLE_STRENGTH);

std::cout << "Initial Ripple Effect:\n";

printGrid(grid);

// Simulate the ripple effect over time

for (int step = 0; step < NUM_STEPS; ++step) {

updateGrid(grid);

std::cout << "Step " << step + 1 << ":\n";

printGrid(grid);

}

return 0;

}

Explanation Constants: GRID_SIZE: Size of the grid representing the water surface. DAMPING_FACTOR: Factor by which the ripple strength decreases each step. RIPPLE_STRENGTH: Initial strength of the ripple. RIPPLE_RADIUS: Radius of the ripple effect. NUM_STEPS: Number of simulation steps to run. initializeGrid Function: Initializes the grid with all zero values, representing a flat water surface. …

Simulation of Water Ripple Effect Gaming Project in C++ Read More »

Functional requirements of Remote Controlled Home Appliances System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements for a Remote Controlled Home Appliances System User Authentication and Authorization: Users should be able to create accounts, log in, and manage their profiles. Role-based access control for different types of users (e.g., homeowners, administrators). Appliance Management: Users should be able to add, configure, and manage home appliances (e.g., lights, thermostat, security cameras). …

Functional requirements of Remote Controlled Home Appliances System with non-functional Read More »