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

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 »

Simulation of Predator-Prey Model Gaming Project in C++

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

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

class PredatorPreyModel {
public:
    PredatorPreyModel(double preyInitial, double predatorInitial,
                      double preyBirthRate, double predatorDeathRate,
                      double predationRate, double reproductionRate,
                      double timeStep)
        : prey(preyInitial), predator(predatorInitial),
          preyBirthRate(preyBirthRate), predatorDeathRate(predatorDeathRate),
          predationRate(predationRate), reproductionRate(reproductionRate),
          timeStep(timeStep) {}

    void simulate(double totalTime) {
        std::cout << std::fixed << std::setprecision(2);
        std::cout << "Time\tPrey\tPredators\n";

        for (double t = 0; t <= totalTime; t += timeStep) {
            // Output current state
            std::cout << t << "\t" << prey << "\t" << predator << "\n";
            
            // Update populations
            double preyChange = preyBirthRate * prey - predationRate * prey * predator;
            double predatorChange = reproductionRate * prey * predator - predatorDeathRate * predator;
            
            prey += preyChange * timeStep;
            predator += predatorChange * timeStep;
        }
    }

private:
    double prey;
    double predator;
    double preyBirthRate;
    double predatorDeathRate;
    double predationRate;
    double reproductionRate;
    double timeStep;
};

int main() {
    double preyInitial, predatorInitial;
    double preyBirthRate, predatorDeathRate;
    double predationRate, reproductionRate;
    double timeStep, totalTime;

    std::cout << "Enter initial prey population: ";
    std::cin >> preyInitial;

    std::cout << "Enter initial predator population: ";
    std::cin >> predatorInitial;

    std::cout << "Enter prey birth rate: ";
    std::cin >> preyBirthRate;

    std::cout << "Enter predator death rate: ";
    std::cin >> predatorDeathRate;

    std::cout << "Enter predation rate: ";
    std::cin >> predationRate;

    std::cout << "Enter reproduction rate: ";
    std::cin >> reproductionRate;

    std::cout << "Enter time step: ";
    std::cin >> timeStep;

    std::cout << "Enter total simulation time: ";
    std::cin >> totalTime;

    PredatorPreyModel model(preyInitial, predatorInitial, preyBirthRate,
                            predatorDeathRate, predationRate, reproductionRate, timeStep);

    model.simulate(totalTime);

    return 0;
}

#include <iostream>

#include <vector>

#include <iomanip>

class PredatorPreyModel {

public:

PredatorPreyModel(double preyInitial, double predatorInitial,

double preyBirthRate, double predatorDeathRate,

double predationRate, double reproductionRate,

double timeStep)

: prey(preyInitial), predator(predatorInitial),

preyBirthRate(preyBirthRate), predatorDeathRate(predatorDeathRate),

predationRate(predationRate), reproductionRate(reproductionRate),

timeStep(timeStep) {}

void simulate(double totalTime) {

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

std::cout << "Time\tPrey\tPredators\n";

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

// Output current state

std::cout << t << "\t" << prey << "\t" << predator << "\n";

// Update populations

double preyChange = preyBirthRate * prey - predationRate * prey * predator;

double predatorChange = reproductionRate * prey * predator - predatorDeathRate * predator;

prey += preyChange * timeStep;

predator += predatorChange * timeStep;

}

private:

double prey;

double predator;

double preyBirthRate;

double predatorDeathRate;

double predationRate;

double reproductionRate;

double timeStep;

};

int main() {

double preyInitial, predatorInitial;

double preyBirthRate, predatorDeathRate;

double predationRate, reproductionRate;

double timeStep, totalTime;

std::cout << "Enter initial prey population: ";

std::cin >> preyInitial;

std::cout << "Enter initial predator population: ";

std::cin >> predatorInitial;

std::cout << "Enter prey birth rate: ";

std::cin >> preyBirthRate;

std::cout << "Enter predator death rate: ";

std::cin >> predatorDeathRate;

std::cout << "Enter predation rate: ";

std::cin >> predationRate;

std::cout << "Enter reproduction rate: ";

std::cin >> reproductionRate;

std::cout << "Enter time step: ";

std::cin >> timeStep;

std::cout << "Enter total simulation time: ";

std::cin >> totalTime;

PredatorPreyModel model(preyInitial, predatorInitial, preyBirthRate,

predatorDeathRate, predationRate, reproductionRate, timeStep);

model.simulate(totalTime);

return 0;

}

Explanation Class PredatorPreyModel: Purpose: Simulates the dynamics of predator and prey populations using the Lotka-Volterra equations. Attributes: prey: Current population of prey. predator: Current population of predators. preyBirthRate: Birth rate of prey. predatorDeathRate: Death rate of predators. predationRate: Rate at which predators kill prey. reproductionRate: Rate at which predators reproduce based on prey. timeStep: …

Simulation of Predator-Prey Model Gaming Project in C++ Read More »

Functional requirements of Spa Appointment Booking 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 customers and spa staff. Role-based access controls to manage permissions for different system features (e.g., customer, therapist, admin). Appointment Scheduling Allow customers to book, reschedule, or cancel appointments online. Provide a calendar view of available time slots and service options. Support for …

Functional requirements of Spa Appointment Booking System with non-functional Read More »

Simulation of Predictive Analytics Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <numeric>
#include <cmath>

// Function to calculate the mean of a vector
double mean(const std::vector<double>& data) {
    return std::accumulate(data.begin(), data.end(), 0.0) / data.size();
}

// Function to calculate the slope (m) and intercept (b) of the linear regression line
void linearRegression(const std::vector<double>& x, const std::vector<double>& y, double& slope, double& intercept) {
    size_t n = x.size();
    double x_mean = mean(x);
    double y_mean = mean(y);

    double numerator = 0.0;
    double denominator = 0.0;

    for (size_t i = 0; i < n; ++i) {
        numerator += (x[i] - x_mean) * (y[i] - y_mean);
        denominator += (x[i] - x_mean) * (x[i] - x_mean);
    }

    slope = numerator / denominator;
    intercept = y_mean - slope * x_mean;
}

// Function to predict a value based on the linear regression model
double predict(double x, double slope, double intercept) {
    return slope * x + intercept;
}

int main() {
    // Example data: x values (e.g., months) and y values (e.g., sales)
    std::vector<double> x = {1, 2, 3, 4, 5};  // Example x values
    std::vector<double> y = {2, 3, 5, 7, 11}; // Example y values (corresponding to x values)

    double slope, intercept;
    linearRegression(x, y, slope, intercept);

    std::cout << "Linear Regression Model:\n";
    std::cout << "Slope (m): " << slope << std::endl;
    std::cout << "Intercept (b): " << intercept << std::endl;

    double x_predict;
    std::cout << "Enter a value for x to predict its corresponding y: ";
    std::cin >> x_predict;

    double y_predict = predict(x_predict, slope, intercept);
    std::cout << "Predicted y for x = " << x_predict << " is " << y_predict << std::endl;

    return 0;
}

#include <iostream>

#include <vector>

#include <numeric>

#include <cmath>

// Function to calculate the mean of a vector

double mean(const std::vector<double>& data) {

return std::accumulate(data.begin(), data.end(), 0.0) / data.size();

}

// Function to calculate the slope (m) and intercept (b) of the linear regression line

void linearRegression(const std::vector<double>& x, const std::vector<double>& y, double& slope, double& intercept) {

size_t n = x.size();

double x_mean = mean(x);

double y_mean = mean(y);

double numerator = 0.0;

double denominator = 0.0;

for (size_t i = 0; i < n; ++i) {

numerator += (x[i] - x_mean) * (y[i] - y_mean);

denominator += (x[i] - x_mean) * (x[i] - x_mean);

}

slope = numerator / denominator;

intercept = y_mean - slope * x_mean;

}

// Function to predict a value based on the linear regression model

double predict(double x, double slope, double intercept) {

return slope * x + intercept;

}

int main() {

// Example data: x values (e.g., months) and y values (e.g., sales)

std::vector<double> x = {1, 2, 3, 4, 5}; // Example x values

std::vector<double> y = {2, 3, 5, 7, 11}; // Example y values (corresponding to x values)

double slope, intercept;

linearRegression(x, y, slope, intercept);

std::cout << "Linear Regression Model:\n";

std::cout << "Slope (m): " << slope << std::endl;

std::cout << "Intercept (b): " << intercept << std::endl;

double x_predict;

std::cout << "Enter a value for x to predict its corresponding y: ";

std::cin >> x_predict;

double y_predict = predict(x_predict, slope, intercept);

std::cout << "Predicted y for x = " << x_predict << " is " << y_predict << std::endl;

return 0;

}

Explanation Function mean(const std::vector<double>& data): Purpose: Computes the mean of a dataset. Implementation: Uses std::accumulate to sum the data and divides by the number of elements. Function linearRegression(const std::vector<double>& x, const std::vector<double>& y, double& slope, double& intercept): Purpose: Calculates the slope and intercept of the linear regression line. Parameters: x: Vector of independent variable …

Simulation of Predictive Analytics Gaming Project in C++ Read More »

Functional requirements of Software License 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 users, including administrators, IT staff, and license managers. Role-based access controls to manage permissions for different system features and data. License Tracking and Management Track and manage software licenses, including license type, quantity, expiration dates, and renewal terms. Support for various license …

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

Simulation of Project in C++ Management Gaming Project in C++

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

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

class Task {
public:
    Task(const std::string& name, const std::string& assignedTo, int priority)
        : name(name), assignedTo(assignedTo), priority(priority), isComplete(false) {}

    void markComplete() {
        isComplete = true;
    }

    void print() const {
        std::cout << std::setw(20) << std::left << name
                  << std::setw(20) << std::left << assignedTo
                  << std::setw(10) << std::left << priority
                  << (isComplete ? "Complete" : "Incomplete") << std::endl;
    }

private:
    std::string name;
    std::string assignedTo;
    int priority;
    bool isComplete;
};

class Project {
public:
    void addTask(const std::string& name, const std::string& assignedTo, int priority) {
        tasks.emplace_back(name, assignedTo, priority);
    }

    void markTaskComplete(int index) {
        if (index >= 0 && index < tasks.size()) {
            tasks[index].markComplete();
        } else {
            std::cerr << "Error: Invalid task index." << std::endl;
        }
    }

    void printTasks() const {
        std::cout << std::setw(20) << std::left << "Task Name"
                  << std::setw(20) << std::left << "Assigned To"
                  << std::setw(10) << std::left << "Priority"
                  << "Status" << std::endl;
        for (const auto& task : tasks) {
            task.print();
        }
    }

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

int main() {
    Project project;

    int choice;
    do {
        std::cout << "\nProject Management Simulation\n";
        std::cout << "1. Add Task\n";
        std::cout << "2. Mark Task Complete\n";
        std::cout << "3. Print Tasks\n";
        std::cout << "4. Exit\n";
        std::cout << "Enter your choice: ";
        std::cin >> choice;
        std::cin.ignore();  // To ignore the newline character after integer input

        if (choice == 1) {
            std::string name, assignedTo;
            int priority;
            std::cout << "Enter task name: ";
            std::getline(std::cin, name);
            std::cout << "Enter assigned to: ";
            std::getline(std::cin, assignedTo);
            std::cout << "Enter priority (1-10): ";
            std::cin >> priority;
            std::cin.ignore();  // To ignore the newline character after integer input
            project.addTask(name, assignedTo, priority);
        } else if (choice == 2) {
            int index;
            std::cout << "Enter task index to mark as complete: ";
            std::cin >> index;
            project.markTaskComplete(index);
        } else if (choice == 3) {
            project.printTasks();
        } else if (choice == 4) {
            std::cout << "Exiting program.\n";
        } else {
            std::cerr << "Invalid choice. Please try again.\n";
        }
    } while (choice != 4);

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

#include <iomanip>

class Task {

public:

Task(const std::string& name, const std::string& assignedTo, int priority)

: name(name), assignedTo(assignedTo), priority(priority), isComplete(false) {}

void markComplete() {

isComplete = true;

}

void print() const {

std::cout << std::setw(20) << std::left << name

<< std::setw(20) << std::left << assignedTo

<< std::setw(10) << std::left << priority

<< (isComplete ? "Complete" : "Incomplete") << std::endl;

}

private:

std::string name;

std::string assignedTo;

int priority;

bool isComplete;

};

class Project {

public:

void addTask(const std::string& name, const std::string& assignedTo, int priority) {

tasks.emplace_back(name, assignedTo, priority);

}

void markTaskComplete(int index) {

if (index >= 0 && index < tasks.size()) {

tasks[index].markComplete();

} else {

std::cerr << "Error: Invalid task index." << std::endl;

}

void printTasks() const {

std::cout << std::setw(20) << std::left << "Task Name"

<< std::setw(20) << std::left << "Assigned To"

<< std::setw(10) << std::left << "Priority"

<< "Status" << std::endl;

for (const auto& task : tasks) {

task.print();

}

private:

std::vector<Task> tasks;

};

int main() {

Project project;

int choice;

do {

std::cout << "\nProject Management Simulation\n";

std::cout << "1. Add Task\n";

std::cout << "2. Mark Task Complete\n";

std::cout << "3. Print Tasks\n";

std::cout << "4. Exit\n";

std::cout << "Enter your choice: ";

std::cin >> choice;

std::cin.ignore(); // To ignore the newline character after integer input

if (choice == 1) {

std::string name, assignedTo;

int priority;

std::cout << "Enter task name: ";

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

std::cout << "Enter assigned to: ";

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

std::cout << "Enter priority (1-10): ";

std::cin >> priority;

std::cin.ignore(); // To ignore the newline character after integer input

project.addTask(name, assignedTo, priority);

} else if (choice == 2) {

int index;

std::cout << "Enter task index to mark as complete: ";

std::cin >> index;

project.markTaskComplete(index);

} else if (choice == 3) {

project.printTasks();

} else if (choice == 4) {

std::cout << "Exiting program.\n";

} else {

std::cerr << "Invalid choice. Please try again.\n";

}

} while (choice != 4);

return 0;

}

Explanation Class Task: Purpose: Represents a single task within a project. Attributes: name: Name of the task. assignedTo: Person responsible for the task. priority: Priority level of the task (e.g., 1-10). isComplete: Status indicating whether the task is complete. Methods: markComplete(): Marks the task as complete. print(): Prints task details in a formatted manner. …

Simulation of Project in C++ Management Gaming Project in C++ Read More »

Functional requirements of Social Media Monitoring 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 users, including social media managers, analysts, and administrators. Role-based access controls to manage permissions for different system features and data. Social Media Integration Integrate with multiple social media platforms (e.g., Twitter, Facebook, Instagram, LinkedIn) to monitor posts, comments, mentions, and messages. Support …

Functional requirements of Social Media Monitoring System with non-functional Read More »