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

Simulation of Natural Language Processing Gaming Project in C++

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

#include <iostream>
#include <string>
#include <map>
#include <sstream>
#include <algorithm>

class SimpleNLP {
private:
    std::map<std::string, int> wordFrequency; // To store word frequency

public:
    // Function to process a text input and count word frequencies
    void processText(const std::string& text) {
        std::string word;
        std::istringstream stream(text);
        
        while (stream >> word) {
            // Remove punctuation from the word
            word.erase(std::remove_if(word.begin(), word.end(), ::ispunct), word.end());
            // Convert to lowercase
            std::transform(word.begin(), word.end(), word.begin(), ::tolower);
            // Update word frequency
            ++wordFrequency[word];
        }
    }

    // Function to display the word frequencies
    void displayWordFrequencies() const {
        std::cout << "Word Frequencies:\n";
        for (const auto& pair : wordFrequency) {
            std::cout << pair.first << ": " << pair.second << "\n";
        }
    }
};

int main() {
    std::string text;

    // Input text from the user
    std::cout << "Enter the text for NLP processing (end input with an empty line):\n";
    std::getline(std::cin, text);
    
    // Create a SimpleNLP object
    SimpleNLP nlp;

    // Process the input text
    nlp.processText(text);

    // Display the word frequencies
    nlp.displayWordFrequencies();

    return 0;
}

#include <iostream>

#include <string>

#include <map>

#include <sstream>

#include <algorithm>

class SimpleNLP {

private:

std::map<std::string, int> wordFrequency; // To store word frequency

public:

// Function to process a text input and count word frequencies

void processText(const std::string& text) {

std::string word;

std::istringstream stream(text);

while (stream >> word) {

// Remove punctuation from the word

word.erase(std::remove_if(word.begin(), word.end(), ::ispunct), word.end());

// Convert to lowercase

std::transform(word.begin(), word.end(), word.begin(), ::tolower);

// Update word frequency

++wordFrequency[word];

}

// Function to display the word frequencies

void displayWordFrequencies() const {

std::cout << "Word Frequencies:\n";

for (const auto& pair : wordFrequency) {

std::cout << pair.first << ": " << pair.second << "\n";

}

};

int main() {

std::string text;

// Input text from the user

std::cout << "Enter the text for NLP processing (end input with an empty line):\n";

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

// Create a SimpleNLP object

SimpleNLP nlp;

// Process the input text

nlp.processText(text);

// Display the word frequencies

nlp.displayWordFrequencies();

return 0;

}

Explanation Class Definition (SimpleNLP): Private Members: wordFrequency: A std::map to store the frequency of each word in the text. processText Method: Takes a string of text as input and processes it to count the frequency of each word. Uses std::istringstream to tokenize the input text. Removes punctuation from each word and converts it to …

Simulation of Natural Language Processing Gaming Project in C++ Read More »

Simulation of Newton’s Cradle Gaming Project in C++

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

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

class NewtonsCradleSimulator {
private:
    double gravity;         // Acceleration due to gravity
    double damping;         // Damping factor to simulate energy loss
    double mass;            // Mass of each ball
    double length;          // Length of the string
    double angle;           // Initial angle from vertical
    double angularVelocity; // Initial angular velocity

    struct Ball {
        double angle;
        double angularVelocity;
    };

    std::vector<Ball> balls;

public:
    // Constructor
    NewtonsCradleSimulator(double gravity, double damping, double mass, double length, double angle, double angularVelocity, int numBalls)
        : gravity(gravity), damping(damping), mass(mass), length(length), angle(angle), angularVelocity(angularVelocity) {
        balls.resize(numBalls, {angle, angularVelocity});
    }

    // Function to simulate the motion of the cradle
    void simulate(double totalTime, double timeStep) {
        int steps = static_cast<int>(totalTime / timeStep);

        std::cout << "Time\tBall Angles\n";
        std::cout << "---------------------\n";

        for (int step = 0; step <= steps; ++step) {
            double time = step * timeStep;
            updateMotion(timeStep);
            printState(time);
        }
    }

private:
    // Function to update the motion of the balls
    void updateMotion(double timeStep) {
        for (auto& ball : balls) {
            double angularAcceleration = -gravity / length * std::sin(ball.angle) - damping * ball.angularVelocity;
            ball.angularVelocity += angularAcceleration * timeStep;
            ball.angle += ball.angularVelocity * timeStep;
        }
    }

    // Function to print the current state of the simulation
    void printState(double time) const {
        std::cout << std::fixed << std::setprecision(2) << time << "\t";
        for (const auto& ball : balls) {
            std::cout << ball.angle << " ";
        }
        std::cout << "\n";
    }
};

int main() {
    double gravity, damping, mass, length, angle, angularVelocity, totalTime, timeStep;
    int numBalls;

    // Input parameters from the user
    std::cout << "Enter the acceleration due to gravity (m/s^2): ";
    std::cin >> gravity;
    std::cout << "Enter the damping factor: ";
    std::cin >> damping;
    std::cout << "Enter the mass of each ball (kg): ";
    std::cin >> mass;
    std::cout << "Enter the length of the string (m): ";
    std::cin >> length;
    std::cout << "Enter the initial angle from vertical (radians): ";
    std::cin >> angle;
    std::cout << "Enter the initial angular velocity (rad/s): ";
    std::cin >> angularVelocity;
    std::cout << "Enter the number of balls: ";
    std::cin >> numBalls;
    std::cout << "Enter the total time for the simulation (s): ";
    std::cin >> totalTime;
    std::cout << "Enter the time step for the simulation (s): ";
    std::cin >> timeStep;

    // Create a NewtonsCradleSimulator object
    NewtonsCradleSimulator simulator(gravity, damping, mass, length, angle, angularVelocity, numBalls);

    // Run the simulation
    simulator.simulate(totalTime, timeStep);

    return 0;
}

#include <iostream>

#include <cmath>

#include <vector>

#include <iomanip>

class NewtonsCradleSimulator {

private:

double gravity; // Acceleration due to gravity

double damping; // Damping factor to simulate energy loss

double mass; // Mass of each ball

double length; // Length of the string

double angle; // Initial angle from vertical

double angularVelocity; // Initial angular velocity

struct Ball {

double angle;

double angularVelocity;

};

std::vector<Ball> balls;

public:

// Constructor

NewtonsCradleSimulator(double gravity, double damping, double mass, double length, double angle, double angularVelocity, int numBalls)

: gravity(gravity), damping(damping), mass(mass), length(length), angle(angle), angularVelocity(angularVelocity) {

balls.resize(numBalls, {angle, angularVelocity});

}

// Function to simulate the motion of the cradle

void simulate(double totalTime, double timeStep) {

int steps = static_cast<int>(totalTime / timeStep);

std::cout << "Time\tBall Angles\n";

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

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

double time = step * timeStep;

updateMotion(timeStep);

printState(time);

}

private:

// Function to update the motion of the balls

void updateMotion(double timeStep) {

for (auto& ball : balls) {

double angularAcceleration = -gravity / length * std::sin(ball.angle) - damping * ball.angularVelocity;

ball.angularVelocity += angularAcceleration * timeStep;

ball.angle += ball.angularVelocity * timeStep;

}

// Function to print the current state of the simulation

void printState(double time) const {

std::cout << std::fixed << std::setprecision(2) << time << "\t";

for (const auto& ball : balls) {

std::cout << ball.angle << " ";

}

std::cout << "\n";

}

};

int main() {

double gravity, damping, mass, length, angle, angularVelocity, totalTime, timeStep;

int numBalls;

// Input parameters from the user

std::cout << "Enter the acceleration due to gravity (m/s^2): ";

std::cin >> gravity;

std::cout << "Enter the damping factor: ";

std::cin >> damping;

std::cout << "Enter the mass of each ball (kg): ";

std::cin >> mass;

std::cout << "Enter the length of the string (m): ";

std::cin >> length;

std::cout << "Enter the initial angle from vertical (radians): ";

std::cin >> angle;

std::cout << "Enter the initial angular velocity (rad/s): ";

std::cin >> angularVelocity;

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

std::cin >> numBalls;

std::cout << "Enter the total time for the simulation (s): ";

std::cin >> totalTime;

std::cout << "Enter the time step for the simulation (s): ";

std::cin >> timeStep;

// Create a NewtonsCradleSimulator object

NewtonsCradleSimulator simulator(gravity, damping, mass, length, angle, angularVelocity, numBalls);

// Run the simulation

simulator.simulate(totalTime, timeStep);

return 0;

}

Explanation Class Definition (NewtonsCradleSimulator): Private Members: gravity: Acceleration due to gravity. damping: Damping factor to simulate energy loss due to friction. mass: Mass of each ball (not used in calculations but could be for future improvements). length: Length of the string of each ball. angle: Initial angle of the balls from the vertical. angularVelocity: …

Simulation of Newton’s Cradle Gaming Project in C++ Read More »

Simulation of Network Topology Gaming Project in C++

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

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

class NetworkTopologySimulator {
private:
    int numNodes;                 // Number of nodes in the network
    std::vector<std::vector<int>> adjacencyMatrix; // Adjacency matrix representing network connections

public:
    // Constructor
    NetworkTopologySimulator(int numNodes)
        : numNodes(numNodes), adjacencyMatrix(numNodes, std::vector<int>(numNodes, 0)) {}

    // Add connection between nodes
    void addConnection(int node1, int node2) {
        if (node1 < numNodes && node2 < numNodes) {
            adjacencyMatrix[node1][node2] = 1;
            adjacencyMatrix[node2][node1] = 1; // Assuming undirected graph
        }
    }

    // Perform BFS from a starting node and print the result
    void performBFS(int startNode) const {
        if (startNode >= numNodes) {
            std::cerr << "Invalid starting node.\n";
            return;
        }

        std::vector<bool> visited(numNodes, false);
        std::queue<int> q;

        visited[startNode] = true;
        q.push(startNode);

        std::cout << "BFS traversal starting from node " << startNode << ": ";

        while (!q.empty()) {
            int node = q.front();
            q.pop();
            std::cout << node << " ";

            for (int i = 0; i < numNodes; ++i) {
                if (adjacencyMatrix[node][i] == 1 && !visited[i]) {
                    visited[i] = true;
                    q.push(i);
                }
            }
        }
        std::cout << "\n";
    }
};

int main() {
    int numNodes, numConnections, node1, node2, startNode;

    // Input number of nodes and connections
    std::cout << "Enter the number of nodes in the network: ";
    std::cin >> numNodes;
    NetworkTopologySimulator simulator(numNodes);

    std::cout << "Enter the number of connections: ";
    std::cin >> numConnections;

    // Input connections
    for (int i = 0; i < numConnections; ++i) {
        std::cout << "Enter connection " << i + 1 << " (node1 node2): ";
        std::cin >> node1 >> node2;
        simulator.addConnection(node1, node2);
    }

    // Input starting node for BFS
    std::cout << "Enter the starting node for BFS: ";
    std::cin >> startNode;

    // Perform BFS
    simulator.performBFS(startNode);

    return 0;
}

#include <iostream>

#include <vector>

#include <queue>

class NetworkTopologySimulator {

private:

int numNodes; // Number of nodes in the network

std::vector<std::vector<int>> adjacencyMatrix; // Adjacency matrix representing network connections

public:

// Constructor

NetworkTopologySimulator(int numNodes)

: numNodes(numNodes), adjacencyMatrix(numNodes, std::vector<int>(numNodes, 0)) {}

// Add connection between nodes

void addConnection(int node1, int node2) {

if (node1 < numNodes && node2 < numNodes) {

adjacencyMatrix[node1][node2] = 1;

adjacencyMatrix[node2][node1] = 1; // Assuming undirected graph

}

// Perform BFS from a starting node and print the result

void performBFS(int startNode) const {

if (startNode >= numNodes) {

std::cerr << "Invalid starting node.\n";

return;

}

std::vector<bool> visited(numNodes, false);

std::queue<int> q;

visited[startNode] = true;

q.push(startNode);

std::cout << "BFS traversal starting from node " << startNode << ": ";

while (!q.empty()) {

int node = q.front();

q.pop();

std::cout << node << " ";

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

if (adjacencyMatrix[node][i] == 1 && !visited[i]) {

visited[i] = true;

q.push(i);

}

std::cout << "\n";

}

};

int main() {

int numNodes, numConnections, node1, node2, startNode;

// Input number of nodes and connections

std::cout << "Enter the number of nodes in the network: ";

std::cin >> numNodes;

NetworkTopologySimulator simulator(numNodes);

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

std::cin >> numConnections;

// Input connections

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

std::cout << "Enter connection " << i + 1 << " (node1 node2): ";

std::cin >> node1 >> node2;

simulator.addConnection(node1, node2);

}

// Input starting node for BFS

std::cout << "Enter the starting node for BFS: ";

std::cin >> startNode;

// Perform BFS

simulator.performBFS(startNode);

return 0;

}

Explanation Class Definition (NetworkTopologySimulator): Private Members: numNodes: Number of nodes in the network. adjacencyMatrix: 2D vector representing connections between nodes, where a value of 1 indicates a connection. Constructor: Initializes the adjacency matrix for the network with the specified number of nodes. addConnection Method: Adds a connection between two nodes in the network by …

Simulation of Network Topology Gaming Project in C++ Read More »

Simulation of Newton’s Law of Cooling Gaming Project in C++

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

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

class NewtonsLawOfCoolingSimulator {
private:
    double initialTemperature; // Initial temperature of the object
    double ambientTemperature; // Ambient temperature
    double coolingConstant;    // Cooling constant (k)
    double timeStep;           // Time step for the simulation

public:
    // Constructor
    NewtonsLawOfCoolingSimulator(double initialTemperature, double ambientTemperature, double coolingConstant, double timeStep)
        : initialTemperature(initialTemperature), ambientTemperature(ambientTemperature), coolingConstant(coolingConstant), timeStep(timeStep) {}

    // Function to simulate cooling over time
    void simulate(double totalTime) const {
        int steps = static_cast<int>(totalTime / timeStep);
        double currentTemperature = initialTemperature;

        std::cout << "Time\tTemperature\n";
        std::cout << "-----------------------\n";

        for (int i = 0; i <= steps; ++i) {
            double time = i * timeStep;
            currentTemperature = ambientTemperature + (initialTemperature - ambientTemperature) * exp(-coolingConstant * time);
            std::cout << std::fixed << std::setprecision(2) << time << "\t" << currentTemperature << "\n";
        }
    }
};

int main() {
    double initialTemperature, ambientTemperature, coolingConstant, timeStep, totalTime;

    // Input parameters from the user
    std::cout << "Enter the initial temperature of the object: ";
    std::cin >> initialTemperature;
    std::cout << "Enter the ambient temperature: ";
    std::cin >> ambientTemperature;
    std::cout << "Enter the cooling constant (k): ";
    std::cin >> coolingConstant;
    std::cout << "Enter the time step for the simulation: ";
    std::cin >> timeStep;
    std::cout << "Enter the total time for the simulation: ";
    std::cin >> totalTime;

    // Create a NewtonsLawOfCoolingSimulator object
    NewtonsLawOfCoolingSimulator simulator(initialTemperature, ambientTemperature, coolingConstant, timeStep);

    // Run the simulation
    simulator.simulate(totalTime);

    return 0;
}

#include <iostream>

#include <cmath>

#include <iomanip>

class NewtonsLawOfCoolingSimulator {

private:

double initialTemperature; // Initial temperature of the object

double ambientTemperature; // Ambient temperature

double coolingConstant; // Cooling constant (k)

double timeStep; // Time step for the simulation

public:

// Constructor

NewtonsLawOfCoolingSimulator(double initialTemperature, double ambientTemperature, double coolingConstant, double timeStep)

: initialTemperature(initialTemperature), ambientTemperature(ambientTemperature), coolingConstant(coolingConstant), timeStep(timeStep) {}

// Function to simulate cooling over time

void simulate(double totalTime) const {

int steps = static_cast<int>(totalTime / timeStep);

double currentTemperature = initialTemperature;

std::cout << "Time\tTemperature\n";

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

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

double time = i * timeStep;

currentTemperature = ambientTemperature + (initialTemperature - ambientTemperature) * exp(-coolingConstant * time);

std::cout << std::fixed << std::setprecision(2) << time << "\t" << currentTemperature << "\n";

}

};

int main() {

double initialTemperature, ambientTemperature, coolingConstant, timeStep, totalTime;

// Input parameters from the user

std::cout << "Enter the initial temperature of the object: ";

std::cin >> initialTemperature;

std::cout << "Enter the ambient temperature: ";

std::cin >> ambientTemperature;

std::cout << "Enter the cooling constant (k): ";

std::cin >> coolingConstant;

std::cout << "Enter the time step for the simulation: ";

std::cin >> timeStep;

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

std::cin >> totalTime;

// Create a NewtonsLawOfCoolingSimulator object

NewtonsLawOfCoolingSimulator simulator(initialTemperature, ambientTemperature, coolingConstant, timeStep);

// Run the simulation

simulator.simulate(totalTime);

return 0;

}

Explanation Class Definition (NewtonsLawOfCoolingSimulator): Private Members: initialTemperature: Initial temperature of the object. ambientTemperature: Temperature of the surrounding environment. coolingConstant: Cooling constant (k), which determines the rate of cooling. timeStep: Interval of time between calculations in the simulation. Constructor: Initializes the simulation parameters with the provided values. simulate Method: Computes and prints the temperature of …

Simulation of Newton’s Law of Cooling Gaming Project in C++ Read More »

Simulation of Nuclear Decay Gaming Project in C++

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

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

class NuclearDecaySimulator {
private:
    double initialAmount; // Initial quantity of the radioactive substance
    double decayConstant; // Decay constant (lambda)
    double timeStep;      // Time step for the simulation

public:
    // Constructor
    NuclearDecaySimulator(double initialAmount, double decayConstant, double timeStep)
        : initialAmount(initialAmount), decayConstant(decayConstant), timeStep(timeStep) {}

    // Function to simulate decay over time
    void simulate(double totalTime) const {
        int steps = static_cast<int>(totalTime / timeStep);
        double currentAmount = initialAmount;

        std::cout << "Time\tAmount Remaining\n";
        std::cout << "--------------------------\n";

        for (int i = 0; i <= steps; ++i) {
            double time = i * timeStep;
            currentAmount = initialAmount * exp(-decayConstant * time);
            std::cout << std::fixed << std::setprecision(2) << time << "\t" << currentAmount << "\n";
        }
    }
};

int main() {
    double initialAmount, decayConstant, timeStep, totalTime;

    // Input parameters from the user
    std::cout << "Enter the initial amount of the substance: ";
    std::cin >> initialAmount;
    std::cout << "Enter the decay constant (lambda): ";
    std::cin >> decayConstant;
    std::cout << "Enter the time step for the simulation: ";
    std::cin >> timeStep;
    std::cout << "Enter the total time for the simulation: ";
    std::cin >> totalTime;

    // Create a NuclearDecaySimulator object
    NuclearDecaySimulator simulator(initialAmount, decayConstant, timeStep);

    // Run the simulation
    simulator.simulate(totalTime);

    return 0;
}

#include <iostream>

#include <cmath>

#include <iomanip>

class NuclearDecaySimulator {

private:

double initialAmount; // Initial quantity of the radioactive substance

double decayConstant; // Decay constant (lambda)

double timeStep; // Time step for the simulation

public:

// Constructor

NuclearDecaySimulator(double initialAmount, double decayConstant, double timeStep)

: initialAmount(initialAmount), decayConstant(decayConstant), timeStep(timeStep) {}

// Function to simulate decay over time

void simulate(double totalTime) const {

int steps = static_cast<int>(totalTime / timeStep);

double currentAmount = initialAmount;

std::cout << "Time\tAmount Remaining\n";

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

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

double time = i * timeStep;

currentAmount = initialAmount * exp(-decayConstant * time);

std::cout << std::fixed << std::setprecision(2) << time << "\t" << currentAmount << "\n";

}

};

int main() {

double initialAmount, decayConstant, timeStep, totalTime;

// Input parameters from the user

std::cout << "Enter the initial amount of the substance: ";

std::cin >> initialAmount;

std::cout << "Enter the decay constant (lambda): ";

std::cin >> decayConstant;

std::cout << "Enter the time step for the simulation: ";

std::cin >> timeStep;

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

std::cin >> totalTime;

// Create a NuclearDecaySimulator object

NuclearDecaySimulator simulator(initialAmount, decayConstant, timeStep);

// Run the simulation

simulator.simulate(totalTime);

return 0;

}

Explanation Class Definition (NuclearDecaySimulator): Private Members: initialAmount: Initial quantity of the radioactive substance. decayConstant: Decay constant (λ), which describes the rate of decay. timeStep: Interval of time between calculations in the simulation. Constructor: Initializes the simulation parameters with provided values. simulate Method: Calculates and prints the amount of the substance remaining over time. Computes …

Simulation of Nuclear Decay Gaming Project in C++ Read More »

Simulation of Nuclear Decay Gaming Project in C++

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

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

class NuclearDecaySimulator {
private:
    double initialAmount; // Initial amount of the substance
    double decayConstant; // Decay constant (lambda)
    double timeStep;      // Time step for the simulation

public:
    // Constructor
    NuclearDecaySimulator(double initialAmount, double decayConstant, double timeStep)
        : initialAmount(initialAmount), decayConstant(decayConstant), timeStep(timeStep) {}

    // Function to simulate decay over time
    void simulate(double totalTime) const {
        int steps = static_cast<int>(totalTime / timeStep);
        double currentAmount = initialAmount;

        std::cout << "Time\tAmount Remaining\n";
        std::cout << "--------------------------\n";

        for (int i = 0; i <= steps; ++i) {
            double time = i * timeStep;
            currentAmount = initialAmount * exp(-decayConstant * time);
            std::cout << std::fixed << std::setprecision(2) << time << "\t" << currentAmount << "\n";
        }
    }
};

int main() {
    double initialAmount, decayConstant, timeStep, totalTime;

    // Input parameters
    std::cout << "Enter the initial amount of the substance: ";
    std::cin >> initialAmount;
    std::cout << "Enter the decay constant (lambda): ";
    std::cin >> decayConstant;
    std::cout << "Enter the time step for the simulation: ";
    std::cin >> timeStep;
    std::cout << "Enter the total time for the simulation: ";
    std::cin >> totalTime;

    // Create a simulator object
    NuclearDecaySimulator simulator(initialAmount, decayConstant, timeStep);

    // Run the simulation
    simulator.simulate(totalTime);

    return 0;
}

#include <iostream>

#include <cmath>

#include <iomanip>

class NuclearDecaySimulator {

private:

double initialAmount; // Initial amount of the substance

double decayConstant; // Decay constant (lambda)

double timeStep; // Time step for the simulation

public:

// Constructor

NuclearDecaySimulator(double initialAmount, double decayConstant, double timeStep)

: initialAmount(initialAmount), decayConstant(decayConstant), timeStep(timeStep) {}

// Function to simulate decay over time

void simulate(double totalTime) const {

int steps = static_cast<int>(totalTime / timeStep);

double currentAmount = initialAmount;

std::cout << "Time\tAmount Remaining\n";

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

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

double time = i * timeStep;

currentAmount = initialAmount * exp(-decayConstant * time);

std::cout << std::fixed << std::setprecision(2) << time << "\t" << currentAmount << "\n";

}

};

int main() {

double initialAmount, decayConstant, timeStep, totalTime;

// Input parameters

std::cout << "Enter the initial amount of the substance: ";

std::cin >> initialAmount;

std::cout << "Enter the decay constant (lambda): ";

std::cin >> decayConstant;

std::cout << "Enter the time step for the simulation: ";

std::cin >> timeStep;

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

std::cin >> totalTime;

// Create a simulator object

NuclearDecaySimulator simulator(initialAmount, decayConstant, timeStep);

// Run the simulation

simulator.simulate(totalTime);

return 0;

}

Explanation Class Definition: NuclearDecaySimulator class holds the parameters for the simulation: initialAmount (the initial quantity of the substance), decayConstant (the decay rate), and timeStep (the granularity of time steps in the simulation). Constructor: Initializes the parameters of the simulation. simulate Method: Computes and displays the amount of substance remaining over time. Uses the formula …

Simulation of Nuclear Decay Gaming Project in C++ Read More »

Simulation of Operating System Concepts Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <iomanip> // For std::fixed and std::setprecision

struct Process {
    int id;      // Process ID
    int arrival; // Arrival time (in milliseconds)
    int burst;   // Burst time (in milliseconds)
    int start;   // Start time (in milliseconds)
    int finish;  // Finish time (in milliseconds)
};

// Function to simulate FCFS scheduling
void fcfsScheduling(std::vector<Process>& processes) {
    int currentTime = 0;

    std::cout << "Process ID\tArrival Time\tBurst Time\tStart Time\tFinish Time" << std::endl;

    for (auto& process : processes) {
        // Update start time and finish time
        process.start = std::max(currentTime, process.arrival);
        process.finish = process.start + process.burst;
        currentTime = process.finish;

        // Output process details
        std::cout << process.id << "\t\t"
                  << process.arrival << "\t\t"
                  << process.burst << "\t\t"
                  << process.start << "\t\t"
                  << process.finish << std::endl;
    }
}

int main() {
    int numProcesses;

    // Input number of processes
    std::cout << "Enter the number of processes: ";
    std::cin >> numProcesses;
    
    std::vector<Process> processes(numProcesses);

    for (int i = 0; i < numProcesses; ++i) {
        Process p;
        p.id = i + 1; // Assign process ID starting from 1
        std::cout << "Enter arrival time for process " << p.id << " (milliseconds): ";
        std::cin >> p.arrival;
        std::cout << "Enter burst time for process " << p.id << " (milliseconds): ";
        std::cin >> p.burst;
        processes[i] = p;
    }

    // Call the scheduling function
    fcfsScheduling(processes);

    return 0;
}

#include <iostream>

#include <vector>

#include <iomanip> // For std::fixed and std::setprecision

struct Process {

int id; // Process ID

int arrival; // Arrival time (in milliseconds)

int burst; // Burst time (in milliseconds)

int start; // Start time (in milliseconds)

int finish; // Finish time (in milliseconds)

};

// Function to simulate FCFS scheduling

void fcfsScheduling(std::vector<Process>& processes) {

int currentTime = 0;

std::cout << "Process ID\tArrival Time\tBurst Time\tStart Time\tFinish Time" << std::endl;

for (auto& process : processes) {

// Update start time and finish time

process.start = std::max(currentTime, process.arrival);

process.finish = process.start + process.burst;

currentTime = process.finish;

// Output process details

std::cout << process.id << "\t\t"

<< process.arrival << "\t\t"

<< process.burst << "\t\t"

<< process.start << "\t\t"

<< process.finish << std::endl;

}

int main() {

int numProcesses;

// Input number of processes

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

std::cin >> numProcesses;

std::vector<Process> processes(numProcesses);

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

Process p;

p.id = i + 1; // Assign process ID starting from 1

std::cout << "Enter arrival time for process " << p.id << " (milliseconds): ";

std::cin >> p.arrival;

std::cout << "Enter burst time for process " << p.id << " (milliseconds): ";

std::cin >> p.burst;

processes[i] = p;

}

// Call the scheduling function

fcfsScheduling(processes);

return 0;

}

Explanation: Headers and Structure: Includes iostream for input and output operations and iomanip for formatting. Defines the Process structure with id, arrival time, burst time, start time, and finish time. fcfsScheduling Function: Takes a vector of Process structures as input. Uses currentTime to keep track of the time as processes are scheduled. Iterates through …

Simulation of Operating System Concepts Gaming Project in C++ Read More »

Functional requirements of College Alumni Portal 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 alumni, administrators, and other users. Role-Based Access: Implement role-based access controls to manage permissions based on user roles (e.g., alumni, admin, event organizer). Profile Management Profile Creation: Allow alumni to create and manage their profiles, including personal information, educational …

Functional requirements of College Alumni Portal with non-functional Read More »

Simulation of Particle Motion Gaming Project in C++

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

#include <iostream>
#include <iomanip> // For std::fixed and std::setprecision

// Structure to represent a particle
struct Particle {
    double x;       // Position in x (meters)
    double y;       // Position in y (meters)
    double vx;      // Velocity in x direction (meters/second)
    double vy;      // Velocity in y direction (meters/second)
    double ax;      // Acceleration in x direction (meters/second^2)
    double ay;      // Acceleration in y direction (meters/second^2)
};

// Function to update the particle's position and velocity using Euler's method
void updateParticle(Particle& particle, double dt) {
    particle.vx += particle.ax * dt;
    particle.vy += particle.ay * dt;
    particle.x += particle.vx * dt;
    particle.y += particle.vy * dt;
}

int main() {
    Particle particle;
    double dt; // Time step for simulation
    int steps; // Number of simulation steps

    // Input initial conditions
    std::cout << "Enter the initial x position of the particle (meters): ";
    std::cin >> particle.x;
    std::cout << "Enter the initial y position of the particle (meters): ";
    std::cin >> particle.y;
    std::cout << "Enter the initial velocity in x direction (meters/second): ";
    std::cin >> particle.vx;
    std::cout << "Enter the initial velocity in y direction (meters/second): ";
    std::cin >> particle.vy;
    std::cout << "Enter the acceleration in x direction (meters/second^2): ";
    std::cin >> particle.ax;
    std::cout << "Enter the acceleration in y direction (meters/second^2): ";
    std::cin >> particle.ay;

    std::cout << "Enter the time step for the simulation (seconds): ";
    std::cin >> dt;
    std::cout << "Enter the number of simulation steps: ";
    std::cin >> steps;

    // Simulation loop
    std::cout << "Step\tX Position\tY Position" << std::endl;
    for (int step = 0; step <= steps; ++step) {
        std::cout << step << "\t"
                  << std::fixed << std::setprecision(2) << particle.x << "\t"
                  << std::fixed << std::setprecision(2) << particle.y << std::endl;
        updateParticle(particle, dt);
    }

    return 0;
}

#include <iostream>

#include <iomanip> // For std::fixed and std::setprecision

// Structure to represent a particle

struct Particle {

double x; // Position in x (meters)

double y; // Position in y (meters)

double vx; // Velocity in x direction (meters/second)

double vy; // Velocity in y direction (meters/second)

double ax; // Acceleration in x direction (meters/second^2)

double ay; // Acceleration in y direction (meters/second^2)

};

// Function to update the particle's position and velocity using Euler's method

void updateParticle(Particle& particle, double dt) {

particle.vx += particle.ax * dt;

particle.vy += particle.ay * dt;

particle.x += particle.vx * dt;

particle.y += particle.vy * dt;

}

int main() {

Particle particle;

double dt; // Time step for simulation

int steps; // Number of simulation steps

// Input initial conditions

std::cout << "Enter the initial x position of the particle (meters): ";

std::cin >> particle.x;

std::cout << "Enter the initial y position of the particle (meters): ";

std::cin >> particle.y;

std::cout << "Enter the initial velocity in x direction (meters/second): ";

std::cin >> particle.vx;

std::cout << "Enter the initial velocity in y direction (meters/second): ";

std::cin >> particle.vy;

std::cout << "Enter the acceleration in x direction (meters/second^2): ";

std::cin >> particle.ax;

std::cout << "Enter the acceleration in y direction (meters/second^2): ";

std::cin >> particle.ay;

std::cout << "Enter the time step for the simulation (seconds): ";

std::cin >> dt;

std::cout << "Enter the number of simulation steps: ";

std::cin >> steps;

// Simulation loop

std::cout << "Step\tX Position\tY Position" << std::endl;

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

std::cout << step << "\t"

<< std::fixed << std::setprecision(2) << particle.x << "\t"

<< std::fixed << std::setprecision(2) << particle.y << std::endl;

updateParticle(particle, dt);

}

return 0;

}

Explanation: Headers and Structure: Includes iostream for input and output operations and iomanip for formatting. Defines the Particle structure with x, y for position, vx, vy for velocity, and ax, ay for acceleration. updateParticle Function: Updates the particle’s velocity based on its acceleration (ax, ay) and time step (dt). Updates the particle’s position based …

Simulation of Particle Motion Gaming Project in C++ Read More »

Functional requirements of Travel Booking 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, including travelers, agents, and administrators. Role-Based Access: Implement role-based access controls to manage permissions based on user roles (e.g., traveler, travel agent, admin). Search and Booking Flight Search: Allow users to search for flights based on criteria such …

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