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

Functional requirements of Student Attendance Monitoring System with non-functional

Leave a Comment / Uncategorized / By Projects Inventory

Functional Requirements User Authentication and Authorization Secure Login: Provide secure registration, login, and account management for students, teachers, and administrators. Role-Based Access: Implement role-based access controls to manage permissions for different system features (e.g., student access, teacher functions, admin capabilities). Attendance Tracking Real-Time Tracking: Record and track student attendance in real-time using methods such as …

Functional requirements of Student Attendance Monitoring System with non-functional Read More »

Simulation of Epidemic Spread Gaming Project in C++

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

#include <iostream>
#include <iomanip>

// Class representing the Epidemic Model
class EpidemicModel {
public:
    EpidemicModel(double initialSusceptible, double initialInfected, double initialRecovered,
                  double infectionRate, double recoveryRate, double timeStep)
        : susceptible(initialSusceptible), infected(initialInfected), recovered(initialRecovered),
          infectionRate(infectionRate), recoveryRate(recoveryRate), timeStep(timeStep) {}

    void simulate(double totalTime) {
        std::cout << std::fixed << std::setprecision(2);
        std::cout << "Time\tSusceptible\tInfected\tRecovered\n";

        for (double t = 0; t <= totalTime; t += timeStep) {
            // Output current state
            std::cout << t << "\t" << susceptible << "\t" << infected << "\t" << recovered << "\n";

            // Calculate changes
            double newInfections = infectionRate * susceptible * infected;
            double newRecoveries = recoveryRate * infected;

            // Update states
            susceptible -= newInfections * timeStep;
            infected += (newInfections - newRecoveries) * timeStep;
            recovered += newRecoveries * timeStep;

            // Ensure values remain within bounds
            if (susceptible < 0) susceptible = 0;
            if (infected < 0) infected = 0;
            if (recovered < 0) recovered = 0;
        }
    }

private:
    double susceptible;
    double infected;
    double recovered;
    double infectionRate;
    double recoveryRate;
    double timeStep;
};

int main() {
    double initialSusceptible, initialInfected, initialRecovered;
    double infectionRate, recoveryRate;
    double timeStep, totalTime;

    std::cout << "Enter initial number of susceptible individuals: ";
    std::cin >> initialSusceptible;

    std::cout << "Enter initial number of infected individuals: ";
    std::cin >> initialInfected;

    std::cout << "Enter initial number of recovered individuals: ";
    std::cin >> initialRecovered;

    std::cout << "Enter infection rate (per susceptible and infected): ";
    std::cin >> infectionRate;

    std::cout << "Enter recovery rate (per infected): ";
    std::cin >> recoveryRate;

    std::cout << "Enter time step (in days): ";
    std::cin >> timeStep;

    std::cout << "Enter total simulation time (in days): ";
    std::cin >> totalTime;

    EpidemicModel model(initialSusceptible, initialInfected, initialRecovered,
                        infectionRate, recoveryRate, timeStep);

    model.simulate(totalTime);

    return 0;
}

#include <iostream>

#include <iomanip>

// Class representing the Epidemic Model

class EpidemicModel {

public:

EpidemicModel(double initialSusceptible, double initialInfected, double initialRecovered,

double infectionRate, double recoveryRate, double timeStep)

: susceptible(initialSusceptible), infected(initialInfected), recovered(initialRecovered),

infectionRate(infectionRate), recoveryRate(recoveryRate), timeStep(timeStep) {}

void simulate(double totalTime) {

std::cout << std::fixed << std::setprecision(2);

std::cout << "Time\tSusceptible\tInfected\tRecovered\n";

for (double t = 0; t <= totalTime; t += timeStep) {

// Output current state

std::cout << t << "\t" << susceptible << "\t" << infected << "\t" << recovered << "\n";

// Calculate changes

double newInfections = infectionRate * susceptible * infected;

double newRecoveries = recoveryRate * infected;

// Update states

susceptible -= newInfections * timeStep;

infected += (newInfections - newRecoveries) * timeStep;

recovered += newRecoveries * timeStep;

// Ensure values remain within bounds

if (susceptible < 0) susceptible = 0;

if (infected < 0) infected = 0;

if (recovered < 0) recovered = 0;

}

private:

double susceptible;

double infected;

double recovered;

double infectionRate;

double recoveryRate;

double timeStep;

};

int main() {

double initialSusceptible, initialInfected, initialRecovered;

double infectionRate, recoveryRate;

double timeStep, totalTime;

std::cout << "Enter initial number of susceptible individuals: ";

std::cin >> initialSusceptible;

std::cout << "Enter initial number of infected individuals: ";

std::cin >> initialInfected;

std::cout << "Enter initial number of recovered individuals: ";

std::cin >> initialRecovered;

std::cout << "Enter infection rate (per susceptible and infected): ";

std::cin >> infectionRate;

std::cout << "Enter recovery rate (per infected): ";

std::cin >> recoveryRate;

std::cout << "Enter time step (in days): ";

std::cin >> timeStep;

std::cout << "Enter total simulation time (in days): ";

std::cin >> totalTime;

EpidemicModel model(initialSusceptible, initialInfected, initialRecovered,

infectionRate, recoveryRate, timeStep);

model.simulate(totalTime);

return 0;

}

Explanation Class EpidemicModel: Purpose: Simulates the spread of an epidemic over time. Attributes: susceptible: Number of susceptible individuals. infected: Number of infected individuals. recovered: Number of recovered individuals. infectionRate: Rate at which susceptible individuals get infected by contact with infected individuals. recoveryRate: Rate at which infected individuals recover. timeStep: Time interval for each simulation …

Simulation of Epidemic Spread Gaming Project in C++ Read More »

Functional requirements of Stock Portfolio Management System with non-functional

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

Functional Requirements User Authentication and Authorization Secure Login: Provide secure registration, login, and account management for users. Role-Based Access: Implement role-based access controls for different levels of user access (e.g., basic user, portfolio manager, admin). Portfolio Management Portfolio Tracking: Allow users to track and manage multiple portfolios, including current holdings, asset allocation, and performance. Transaction …

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

Simulation of Employee Performance Gaming Project in C++

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

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

class Employee {
public:
    Employee(const std::string& name, const std::vector<double>& performanceScores)
        : name(name), performanceScores(performanceScores) {}

    std::string getName() const { return name; }
    double getAverageScore() const {
        double sum = 0;
        for (double score : performanceScores) {
            sum += score;
        }
        return performanceScores.empty() ? 0 : sum / performanceScores.size();
    }

private:
    std::string name;
    std::vector<double> performanceScores;
};

int main() {
    int numEmployees;
    std::cout << "Enter the number of employees: ";
    std::cin >> numEmployees;

    std::vector<Employee> employees;

    for (int i = 0; i < numEmployees; ++i) {
        std::string name;
        int numCriteria;
        std::cout << "Enter name for employee " << i + 1 << ": ";
        std::cin.ignore();  // To ignore any newline character left in the buffer
        std::getline(std::cin, name);

        std::cout << "Enter the number of performance criteria for " << name << ": ";
        std::cin >> numCriteria;

        std::vector<double> performanceScores(numCriteria);
        for (int j = 0; j < numCriteria; ++j) {
            std::cout << "Enter score for criterion " << j + 1 << ": ";
            std::cin >> performanceScores[j];
        }

        employees.emplace_back(name, performanceScores);
    }

    std::cout << std::fixed << std::setprecision(2);
    std::cout << "\nEmployee Performance Report:\n";
    std::cout << "Name\tAverage Score\n";

    for (const auto& employee : employees) {
        std::cout << employee.getName() << "\t" << employee.getAverageScore() << "\n";
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <iomanip>

class Employee {

public:

Employee(const std::string& name, const std::vector<double>& performanceScores)

: name(name), performanceScores(performanceScores) {}

std::string getName() const { return name; }

double getAverageScore() const {

double sum = 0;

for (double score : performanceScores) {

sum += score;

}

return performanceScores.empty() ? 0 : sum / performanceScores.size();

}

private:

std::string name;

std::vector<double> performanceScores;

};

int main() {

int numEmployees;

std::cout << "Enter the number of employees: ";

std::cin >> numEmployees;

std::vector<Employee> employees;

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

std::string name;

int numCriteria;

std::cout << "Enter name for employee " << i + 1 << ": ";

std::cin.ignore(); // To ignore any newline character left in the buffer

std::getline(std::cin, name);

std::cout << "Enter the number of performance criteria for " << name << ": ";

std::cin >> numCriteria;

std::vector<double> performanceScores(numCriteria);

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

std::cout << "Enter score for criterion " << j + 1 << ": ";

std::cin >> performanceScores[j];

}

employees.emplace_back(name, performanceScores);

}

std::cout << std::fixed << std::setprecision(2);

std::cout << "\nEmployee Performance Report:\n";

std::cout << "Name\tAverage Score\n";

for (const auto& employee : employees) {

std::cout << employee.getName() << "\t" << employee.getAverageScore() << "\n";

}

return 0;

}

Explanation Class Employee: Purpose: Represents an employee and their performance evaluation. Attributes: name: Name of the employee. performanceScores: Vector storing performance scores for various criteria. Methods: getName(): Returns the employee’s name. getAverageScore(): Calculates and returns the average performance score based on the criteria scores. Main Function: Setup: Initializes a list of employees. Input: Prompts …

Simulation of Employee Performance Gaming Project in C++ Read More »

Functional requirements of Stock Market Analysis System with non-functional

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

Functional Requirements Data Acquisition and Integration Real-Time Data Feed: Integrate with financial data providers to acquire real-time stock prices, trading volumes, and other market data. Historical Data: Access historical stock market data for analysis, including historical prices, trading volumes, and financial statements. Data Storage and Management Database Management: Store and manage large volumes of stock …

Functional requirements of Stock Market Analysis System with non-functional Read More »

Simulation of Elevator System Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

class Elevator {
public:
    Elevator(int numFloors) : currentFloor(0), numFloors(numFloors) {}

    void request(int floor) {
        if (floor < 0 || floor >= numFloors) {
            std::cerr << "Invalid floor request.\n";
            return;
        }
        if (floor != currentFloor) {
            requests.push(floor);
        }
    }

    void operate() {
        while (!requests.empty()) {
            int targetFloor = requests.front();
            requests.pop();

            moveToFloor(targetFloor);
        }
    }

private:
    int currentFloor;
    int numFloors;
    std::queue<int> requests;

    void moveToFloor(int targetFloor) {
        std::cout << "Moving from floor " << currentFloor << " to floor " << targetFloor << "\n";
        currentFloor = targetFloor;
    }
};

int main() {
    int numFloors = 5; // Number of floors in the building
    Elevator elevator(numFloors);

    int numRequests;
    std::cout << "Enter the number of floor requests: ";
    std::cin >> numRequests;

    for (int i = 0; i < numRequests; ++i) {
        int floor;
        std::cout << "Enter floor request " << i + 1 << ": ";
        std::cin >> floor;
        elevator.request(floor);
    }

    std::cout << "Starting elevator operation...\n";
    elevator.operate();

    return 0;
}

#include <iostream>

#include <vector>

#include <queue>

#include <algorithm>

class Elevator {

public:

Elevator(int numFloors) : currentFloor(0), numFloors(numFloors) {}

void request(int floor) {

if (floor < 0 || floor >= numFloors) {

std::cerr << "Invalid floor request.\n";

return;

}

if (floor != currentFloor) {

requests.push(floor);

}

void operate() {

while (!requests.empty()) {

int targetFloor = requests.front();

requests.pop();

moveToFloor(targetFloor);

}

private:

int currentFloor;

int numFloors;

std::queue<int> requests;

void moveToFloor(int targetFloor) {

std::cout << "Moving from floor " << currentFloor << " to floor " << targetFloor << "\n";

currentFloor = targetFloor;

}

};

int main() {

int numFloors = 5; // Number of floors in the building

Elevator elevator(numFloors);

int numRequests;

std::cout << "Enter the number of floor requests: ";

std::cin >> numRequests;

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

int floor;

std::cout << "Enter floor request " << i + 1 << ": ";

std::cin >> floor;

elevator.request(floor);

}

std::cout << "Starting elevator operation...\n";

elevator.operate();

return 0;

}

Explanation Class Elevator: Purpose: Simulates an elevator system handling floor requests. Attributes: currentFloor: The current floor of the elevator. numFloors: Total number of floors in the building. requests: Queue of requested floors. Methods: request(int floor): Adds a floor request to the queue if the floor is valid and different from the current floor. operate(): …

Simulation of Elevator System Gaming Project in C++ Read More »

Functional requirements of Staff Attendance Management System with non-functional

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

Functional Requirements User Authentication and Authorization Secure registration, login, and account management for staff, managers, and administrators. Role-based access controls to manage permissions for different system features (e.g., employee access, manager reports, admin settings). Attendance Tracking Record and track employee attendance using methods such as manual entry, biometric systems, or RFID. Support for tracking different …

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

Simulation of Edge Computing Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <random>
#include <iomanip>

// Class representing a task
class Task {
public:
    Task(int id, int dataSize) : id(id), dataSize(dataSize), isCompleted(false) {}

    int getId() const { return id; }
    int getDataSize() const { return dataSize; }
    bool isTaskCompleted() const { return isCompleted; }
    void markAsCompleted() { isCompleted = true; }

private:
    int id;
    int dataSize;
    bool isCompleted;
};

// Class representing an edge device
class EdgeDevice {
public:
    EdgeDevice(int id) : id(id), taskQueue() {}

    int getId() const { return id; }

    void addTask(const Task& task) {
        taskQueue.push(task);
    }

    void processTasks() {
        while (!taskQueue.empty()) {
            Task task = taskQueue.front();
            taskQueue.pop();
            std::cout << "Edge Device " << id << " processing Task " << task.getId() << "\n";
            // Simulate task processing with a delay
            // Here we just mark the task as completed
            task.markAsCompleted();
        }
    }

private:
    int id;
    std::queue<Task> taskQueue;
};

// Class representing the central server
class CentralServer {
public:
    void addTask(const Task& task) {
        tasks.push_back(task);
    }

    void distributeTasks(std::vector<EdgeDevice>& edgeDevices) {
        std::cout << "Distributing tasks to edge devices...\n";
        std::default_random_engine generator;
        std::uniform_int_distribution<int> distribution(0, edgeDevices.size() - 1);

        for (auto& task : tasks) {
            int deviceIndex = distribution(generator);
            edgeDevices[deviceIndex].addTask(task);
            std::cout << "Task " << task.getId() << " assigned to Edge Device " << edgeDevices[deviceIndex].getId() << "\n";
        }
    }

private:
    std::vector<Task> tasks;
};

int main() {
    int numTasks = 5;
    int numDevices = 3;

    // Create tasks
    std::vector<Task> tasks;
    for (int i = 0; i < numTasks; ++i) {
        tasks.emplace_back(i, rand() % 100 + 1);  // Random data size between 1 and 100
    }

    // Create edge devices
    std::vector<EdgeDevice> edgeDevices;
    for (int i = 0; i < numDevices; ++i) {
        edgeDevices.emplace_back(i);
    }

    // Create central server and add tasks
    CentralServer server;
    for (const auto& task : tasks) {
        server.addTask(task);
    }

    // Distribute tasks to edge devices
    server.distributeTasks(edgeDevices);

    // Process tasks on edge devices
    std::cout << "Processing tasks on edge devices...\n";
    for (auto& device : edgeDevices) {
        device.processTasks();
    }

    return 0;
}

100

101

102

103

104

105

106

#include <iostream>

#include <vector>

#include <string>

#include <queue>

#include <random>

#include <iomanip>

// Class representing a task

class Task {

public:

Task(int id, int dataSize) : id(id), dataSize(dataSize), isCompleted(false) {}

int getId() const { return id; }

int getDataSize() const { return dataSize; }

bool isTaskCompleted() const { return isCompleted; }

void markAsCompleted() { isCompleted = true; }

private:

int id;

int dataSize;

bool isCompleted;

};

// Class representing an edge device

class EdgeDevice {

public:

EdgeDevice(int id) : id(id), taskQueue() {}

int getId() const { return id; }

void addTask(const Task& task) {

taskQueue.push(task);

}

void processTasks() {

while (!taskQueue.empty()) {

Task task = taskQueue.front();

taskQueue.pop();

std::cout << "Edge Device " << id << " processing Task " << task.getId() << "\n";

// Simulate task processing with a delay

// Here we just mark the task as completed

task.markAsCompleted();

}

private:

int id;

std::queue<Task> taskQueue;

};

// Class representing the central server

class CentralServer {

public:

void addTask(const Task& task) {

tasks.push_back(task);

}

void distributeTasks(std::vector<EdgeDevice>& edgeDevices) {

std::cout << "Distributing tasks to edge devices...\n";

std::default_random_engine generator;

std::uniform_int_distribution<int> distribution(0, edgeDevices.size() - 1);

for (auto& task : tasks) {

int deviceIndex = distribution(generator);

edgeDevices[deviceIndex].addTask(task);

std::cout << "Task " << task.getId() << " assigned to Edge Device " << edgeDevices[deviceIndex].getId() << "\n";

}

private:

std::vector<Task> tasks;

};

int main() {

int numTasks = 5;

int numDevices = 3;

// Create tasks

std::vector<Task> tasks;

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

tasks.emplace_back(i, rand() % 100 + 1); // Random data size between 1 and 100

}

// Create edge devices

std::vector<EdgeDevice> edgeDevices;

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

edgeDevices.emplace_back(i);

}

// Create central server and add tasks

CentralServer server;

for (const auto& task : tasks) {

server.addTask(task);

}

// Distribute tasks to edge devices

server.distributeTasks(edgeDevices);

// Process tasks on edge devices

std::cout << "Processing tasks on edge devices...\n";

for (auto& device : edgeDevices) {

device.processTasks();

}

return 0;

}

Explanation Class Task: Purpose: Represents a task with an ID and a data size. Attributes: id: Identifier for the task. dataSize: Size of the task’s data. isCompleted: Status of whether the task has been completed. Methods: getId(), getDataSize(): Accessors for task attributes. isTaskCompleted(): Checks if the task is completed. markAsCompleted(): Marks the task as …

Simulation of Edge Computing Gaming Project in C++ Read More »

Functional requirements of Sports Club Management System with non-functional

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

Functional Requirements User Authentication and Authorization Secure registration, login, and account management for members, staff, and administrators. Role-based access controls to manage permissions for different system features (e.g., member access, staff management, admin functions). Member Management Maintain a database of members with profiles, contact information, membership types, and status. Allow members to update their profiles, …

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

Functional requirements of Speech Recognition System with non-functional

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

Functional Requirements Speech-to-Text Conversion Accurately convert spoken words into text. Support for multiple languages and dialects. Handle various accents and speech patterns. Voice Command Recognition Recognize and execute predefined voice commands or control instructions. Provide customizable command sets for different applications or use cases. Speaker Identification and Verification Identify and verify speakers based on their …

Functional requirements of Speech Recognition System with non-functional Read More »