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

Functional requirements of Supply Chain Visibility 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 across various roles (e.g., supply chain managers, logistics coordinators, suppliers). Role-Based Access: Implement role-based access controls to manage permissions based on user roles and responsibilities. Real-Time Tracking and Monitoring Goods Tracking: Track the real-time location and status of …

Functional requirements of Supply Chain Visibility System with non-functional Read More »

Functional requirements of Student Performance Analysis 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 students, teachers, administrators, and parents. Role-Based Access: Implement role-based access controls to manage permissions based on user roles (e.g., student, teacher, admin). Performance Data Collection Grades and Assessments: Collect and manage data on student grades, test scores, and assessments …

Functional requirements of Student Performance Analysis System with non-functional Read More »

Simulation of Error Detection and Correction Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <bitset>

// Function to calculate parity bits
std::bitset<7> encodeHamming(const std::bitset<4>& data) {
    std::bitset<7> encoded;

    // Set data bits
    encoded[2] = data[0];
    encoded[4] = data[1];
    encoded[5] = data[2];
    encoded[6] = data[3];

    // Calculate parity bits
    encoded[0] = encoded[2] ^ encoded[4] ^ encoded[6]; // p1
    encoded[1] = encoded[2] ^ encoded[5] ^ encoded[6]; // p2
    encoded[3] = encoded[4] ^ encoded[5] ^ encoded[6]; // p3

    return encoded;
}

// Function to decode and correct errors
std::bitset<4> decodeHamming(const std::bitset<7>& encoded) {
    std::bitset<4> data;
    
    // Calculate parity bits
    bool p1 = encoded[0];
    bool p2 = encoded[1];
    bool p3 = encoded[3];
    
    bool d1 = encoded[2];
    bool d2 = encoded[4];
    bool d3 = encoded[5];
    bool d4 = encoded[6];
    
    // Compute syndromes
    bool s1 = p1 ^ (d1 ^ d2 ^ d4);
    bool s2 = p2 ^ (d1 ^ d3 ^ d4);
    bool s3 = p3 ^ (d2 ^ d3 ^ d4);
    
    // Calculate error position
    int errorPos = s1 | (s2 << 1) | (s3 << 2);
    
    // Correct error if present
    if (errorPos) {
        std::cout << "Error detected at position: " << errorPos << "\n";
        if (errorPos <= 7) {
            encoded.flip(errorPos - 1); // Correct the error
        }
    }

    // Extract data bits
    data[0] = encoded[2];
    data[1] = encoded[4];
    data[2] = encoded[5];
    data[3] = encoded[6];

    return data;
}

int main() {
    std::bitset<4> data;
    std::cout << "Enter 4-bit data (e.g., 1010): ";
    std::cin >> data;

    // Encode the data
    std::bitset<7> encoded = encodeHamming(data);
    std::cout << "Encoded data: " << encoded << "\n";

    // Simulate transmission (Introduce a single-bit error for demonstration)
    std::bitset<7> received = encoded;
    int errorBit;
    std::cout << "Introduce a single-bit error (position 1-7, or 0 for no error): ";
    std::cin >> errorBit;
    if (errorBit > 0 && errorBit <= 7) {
        received.flip(errorBit - 1);
        std::cout << "Received data with error: " << received << "\n";
    }

    // Decode and correct the received data
    std::bitset<4> decoded = decodeHamming(received);
    std::cout << "Decoded data: " << decoded << "\n";

    return 0;
}

#include <iostream>

#include <vector>

#include <bitset>

// Function to calculate parity bits

std::bitset<7> encodeHamming(const std::bitset<4>& data) {

std::bitset<7> encoded;

// Set data bits

encoded[2] = data[0];

encoded[4] = data[1];

encoded[5] = data[2];

encoded[6] = data[3];

// Calculate parity bits

encoded[0] = encoded[2] ^ encoded[4] ^ encoded[6]; // p1

encoded[1] = encoded[2] ^ encoded[5] ^ encoded[6]; // p2

encoded[3] = encoded[4] ^ encoded[5] ^ encoded[6]; // p3

return encoded;

}

// Function to decode and correct errors

std::bitset<4> decodeHamming(const std::bitset<7>& encoded) {

std::bitset<4> data;

// Calculate parity bits

bool p1 = encoded[0];

bool p2 = encoded[1];

bool p3 = encoded[3];

bool d1 = encoded[2];

bool d2 = encoded[4];

bool d3 = encoded[5];

bool d4 = encoded[6];

// Compute syndromes

bool s1 = p1 ^ (d1 ^ d2 ^ d4);

bool s2 = p2 ^ (d1 ^ d3 ^ d4);

bool s3 = p3 ^ (d2 ^ d3 ^ d4);

// Calculate error position

int errorPos = s1 | (s2 << 1) | (s3 << 2);

// Correct error if present

if (errorPos) {

std::cout << "Error detected at position: " << errorPos << "\n";

if (errorPos <= 7) {

encoded.flip(errorPos - 1); // Correct the error

}

// Extract data bits

data[0] = encoded[2];

data[1] = encoded[4];

data[2] = encoded[5];

data[3] = encoded[6];

return data;

}

int main() {

std::bitset<4> data;

std::cout << "Enter 4-bit data (e.g., 1010): ";

std::cin >> data;

// Encode the data

std::bitset<7> encoded = encodeHamming(data);

std::cout << "Encoded data: " << encoded << "\n";

// Simulate transmission (Introduce a single-bit error for demonstration)

std::bitset<7> received = encoded;

int errorBit;

std::cout << "Introduce a single-bit error (position 1-7, or 0 for no error): ";

std::cin >> errorBit;

if (errorBit > 0 && errorBit <= 7) {

received.flip(errorBit - 1);

std::cout << "Received data with error: " << received << "\n";

}

// Decode and correct the received data

std::bitset<4> decoded = decodeHamming(received);

std::cout << "Decoded data: " << decoded << "\n";

return 0;

}

Explanation Function encodeHamming: Purpose: Encodes 4-bit data using the Hamming(7,4) code. Process: Sets the data bits in their positions. Calculates the parity bits (p1, p2, p3) and sets them accordingly. Returns the encoded 7-bit data. Function decodeHamming: Purpose: Decodes the 7-bit Hamming code and detects/corrects errors. Process: Calculates parity bits from the received data. …

Simulation of Error Detection and Correction Gaming Project in C++ Read More »

Functional requirements of Student Information 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 students, teachers, administrators, and parents. Role-Based Access: Implement role-based access controls to manage permissions for different system features based on user roles (e.g., student, teacher, admin). Student Enrollment and Registration Enrollment Management: Manage student enrollment processes, including initial registration, …

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

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 »