C++ Projects – Page 3 – Projects Inventory

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 »

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 »

Simulation of Pendulum Motion Gaming Project in C++

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

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

const double g = 9.81; // Acceleration due to gravity (m/s^2)

// Structure to represent the pendulum
struct Pendulum {
    double length;  // Length of the pendulum (meters)
    double angle;   // Angle from vertical (radians)
    double angularVelocity; // Angular velocity (radians/second)
};

// Function to update the pendulum's angle and angular velocity using Euler's method
void updatePendulum(Pendulum& pendulum, double dt) {
    double angularAcceleration = - (g / pendulum.length) * std::sin(pendulum.angle);
    pendulum.angularVelocity += angularAcceleration * dt;
    pendulum.angle += pendulum.angularVelocity * dt;
}

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

    // Input initial conditions
    std::cout << "Enter the length of the pendulum (meters): ";
    std::cin >> pendulum.length;
    std::cout << "Enter the initial angle from vertical (radians): ";
    std::cin >> pendulum.angle;
    std::cout << "Enter the initial angular velocity (radians/second): ";
    std::cin >> pendulum.angularVelocity;

    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\tAngle (radians)" << std::endl;
    for (int step = 0; step <= steps; ++step) {
        std::cout << step << "\t" << std::fixed << std::setprecision(4) << pendulum.angle << std::endl;
        updatePendulum(pendulum, dt);
    }

    return 0;
}

#include <iostream>

#include <cmath>

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

const double g = 9.81; // Acceleration due to gravity (m/s^2)

// Structure to represent the pendulum

struct Pendulum {

double length; // Length of the pendulum (meters)

double angle; // Angle from vertical (radians)

double angularVelocity; // Angular velocity (radians/second)

};

// Function to update the pendulum's angle and angular velocity using Euler's method

void updatePendulum(Pendulum& pendulum, double dt) {

double angularAcceleration = - (g / pendulum.length) * std::sin(pendulum.angle);

pendulum.angularVelocity += angularAcceleration * dt;

pendulum.angle += pendulum.angularVelocity * dt;

}

int main() {

Pendulum pendulum;

double dt; // Time step for simulation

int steps; // Number of simulation steps

// Input initial conditions

std::cout << "Enter the length of the pendulum (meters): ";

std::cin >> pendulum.length;

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

std::cin >> pendulum.angle;

std::cout << "Enter the initial angular velocity (radians/second): ";

std::cin >> pendulum.angularVelocity;

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\tAngle (radians)" << std::endl;

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

std::cout << step << "\t" << std::fixed << std::setprecision(4) << pendulum.angle << std::endl;

updatePendulum(pendulum, dt);

}

return 0;

}

Explanation: Headers and Constants: Includes iostream for input and output operations, cmath for mathematical functions, and iomanip for formatting. Defines g as the acceleration due to gravity (9.81 m/s²). Pendulum Structure: Represents the pendulum with its length, angle from vertical, and angularVelocity. updatePendulum Function: Calculates the angular acceleration using the formula −(g/length)⋅sin⁡(angle)- (g / …

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

Simulation of Planetary Motion Gaming Project in C++

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

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

const double G = 6.67430e-11; // Gravitational constant

// Structure to represent a celestial body
struct Body {
    double mass;    // Mass of the body (in kg)
    double x;       // X position (in meters)
    double y;       // Y position (in meters)
    double vx;      // Velocity in X direction (in meters/second)
    double vy;      // Velocity in Y direction (in meters/second)
};

// Function to update positions and velocities using simple Euler integration
void updateBody(Body& body, double ax, double ay, double dt) {
    body.vx += ax * dt;
    body.vy += ay * dt;
    body.x += body.vx * dt;
    body.y += body.vy * dt;
}

// Function to compute the gravitational acceleration on a body due to another body
void computeGravitationalAcceleration(const Body& body1, const Body& body2, double& ax, double& ay) {
    double dx = body2.x - body1.x;
    double dy = body2.y - body1.y;
    double distance = std::sqrt(dx * dx + dy * dy);
    double force = G * body1.mass * body2.mass / (distance * distance);
    double ax_temp = force * dx / (body1.mass * distance);
    double ay_temp = force * dy / (body1.mass * distance);
    ax = ax_temp;
    ay = ay_temp;
}

int main() {
    Body planet1, planet2;
    double dt; // Time step for simulation
    int steps; // Number of simulation steps

    // Input initial conditions
    std::cout << "Enter the mass of the first planet (kg): ";
    std::cin >> planet1.mass;
    std::cout << "Enter the initial x position of the first planet (m): ";
    std::cin >> planet1.x;
    std::cout << "Enter the initial y position of the first planet (m): ";
    std::cin >> planet1.y;
    std::cout << "Enter the initial velocity in x direction of the first planet (m/s): ";
    std::cin >> planet1.vx;
    std::cout << "Enter the initial velocity in y direction of the first planet (m/s): ";
    std::cin >> planet1.vy;

    std::cout << "Enter the mass of the second planet (kg): ";
    std::cin >> planet2.mass;
    std::cout << "Enter the initial x position of the second planet (m): ";
    std::cin >> planet2.x;
    std::cout << "Enter the initial y position of the second planet (m): ";
    std::cin >> planet2.y;
    std::cout << "Enter the initial velocity in x direction of the second planet (m/s): ";
    std::cin >> planet2.vx;
    std::cout << "Enter the initial velocity in y direction of the second planet (m/s): ";
    std::cin >> planet2.vy;

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

    // Simulation loop
    std::cout << "Step\tX1\tY1\tX2\tY2" << std::endl;
    for (int step = 0; step <= steps; ++step) {
        double ax1 = 0, ay1 = 0, ax2 = 0, ay2 = 0;

        // Compute gravitational acceleration on both planets
        computeGravitationalAcceleration(planet1, planet2, ax1, ay1);
        computeGravitationalAcceleration(planet2, planet1, ax2, ay2);

        // Update positions and velocities of both planets
        updateBody(planet1, ax1, ay1, dt);
        updateBody(planet2, ax2, ay2, dt);

        // Output positions of both planets
        std::cout << step << "\t"
                  << std::fixed << std::setprecision(2) << planet1.x << "\t"
                  << std::fixed << std::setprecision(2) << planet1.y << "\t"
                  << std::fixed << std::setprecision(2) << planet2.x << "\t"
                  << std::fixed << std::setprecision(2) << planet2.y << std::endl;
    }

    return 0;
}

#include <iostream>

#include <cmath>

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

const double G = 6.67430e-11; // Gravitational constant

// Structure to represent a celestial body

struct Body {

double mass; // Mass of the body (in kg)

double x; // X position (in meters)

double y; // Y position (in meters)

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

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

};

// Function to update positions and velocities using simple Euler integration

void updateBody(Body& body, double ax, double ay, double dt) {

body.vx += ax * dt;

body.vy += ay * dt;

body.x += body.vx * dt;

body.y += body.vy * dt;

}

// Function to compute the gravitational acceleration on a body due to another body

void computeGravitationalAcceleration(const Body& body1, const Body& body2, double& ax, double& ay) {

double dx = body2.x - body1.x;

double dy = body2.y - body1.y;

double distance = std::sqrt(dx * dx + dy * dy);

double force = G * body1.mass * body2.mass / (distance * distance);

double ax_temp = force * dx / (body1.mass * distance);

double ay_temp = force * dy / (body1.mass * distance);

ax = ax_temp;

ay = ay_temp;

}

int main() {

Body planet1, planet2;

double dt; // Time step for simulation

int steps; // Number of simulation steps

// Input initial conditions

std::cout << "Enter the mass of the first planet (kg): ";

std::cin >> planet1.mass;

std::cout << "Enter the initial x position of the first planet (m): ";

std::cin >> planet1.x;

std::cout << "Enter the initial y position of the first planet (m): ";

std::cin >> planet1.y;

std::cout << "Enter the initial velocity in x direction of the first planet (m/s): ";

std::cin >> planet1.vx;

std::cout << "Enter the initial velocity in y direction of the first planet (m/s): ";

std::cin >> planet1.vy;

std::cout << "Enter the mass of the second planet (kg): ";

std::cin >> planet2.mass;

std::cout << "Enter the initial x position of the second planet (m): ";

std::cin >> planet2.x;

std::cout << "Enter the initial y position of the second planet (m): ";

std::cin >> planet2.y;

std::cout << "Enter the initial velocity in x direction of the second planet (m/s): ";

std::cin >> planet2.vx;

std::cout << "Enter the initial velocity in y direction of the second planet (m/s): ";

std::cin >> planet2.vy;

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

std::cin >> dt;

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

std::cin >> steps;

// Simulation loop

std::cout << "Step\tX1\tY1\tX2\tY2" << std::endl;

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

double ax1 = 0, ay1 = 0, ax2 = 0, ay2 = 0;

// Compute gravitational acceleration on both planets

computeGravitationalAcceleration(planet1, planet2, ax1, ay1);

computeGravitationalAcceleration(planet2, planet1, ax2, ay2);

// Update positions and velocities of both planets

updateBody(planet1, ax1, ay1, dt);

updateBody(planet2, ax2, ay2, dt);

// Output positions of both planets

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

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

<< std::fixed << std::setprecision(2) << planet1.y << "\t"

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

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

}

return 0;

}

Explanation: Headers and Constants: Includes iostream for input and output, cmath for mathematical functions, and iomanip for formatting. Defines the gravitational constant G. Body Structure: Represents a celestial body with mass, position (x, y), and velocity (vx, vy). updateBody Function: Updates the position and velocity of a body using simple Euler integration based …

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

Simulation of Population Growth Gaming Project in C++

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

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

// Function to simulate population growth
void simulatePopulationGrowth(double initialPopulation, double growthRate, int years) {
    double population = initialPopulation;

    std::cout << "Year\tPopulation" << std::endl;
    for (int year = 0; year <= years; ++year) {
        std::cout << year << "\t" << std::fixed << std::setprecision(2) << population << std::endl;
        population *= (1 + growthRate);
    }
}

int main() {
    double initialPopulation;
    double growthRate;
    int years;

    // Input initial population, growth rate, and number of years
    std::cout << "Enter the initial population: ";
    std::cin >> initialPopulation;
    std::cout << "Enter the growth rate (as a decimal, e.g., 0.05 for 5%): ";
    std::cin >> growthRate;
    std::cout << "Enter the number of years: ";
    std::cin >> years;

    // Call the simulation function
    simulatePopulationGrowth(initialPopulation, growthRate, years);

    return 0;
}

#include <iostream>

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

// Function to simulate population growth

void simulatePopulationGrowth(double initialPopulation, double growthRate, int years) {

double population = initialPopulation;

std::cout << "Year\tPopulation" << std::endl;

for (int year = 0; year <= years; ++year) {

std::cout << year << "\t" << std::fixed << std::setprecision(2) << population << std::endl;

population *= (1 + growthRate);

}

int main() {

double initialPopulation;

double growthRate;

int years;

// Input initial population, growth rate, and number of years

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

std::cin >> initialPopulation;

std::cout << "Enter the growth rate (as a decimal, e.g., 0.05 for 5%): ";

std::cin >> growthRate;

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

std::cin >> years;

// Call the simulation function

simulatePopulationGrowth(initialPopulation, growthRate, years);

return 0;

}

Explanation: Headers and Function Declaration: Includes iostream for input and output operations and iomanip for formatting the output. Declares the simulatePopulationGrowth function which handles the simulation of population growth. simulatePopulationGrowth Function: Takes three parameters: initialPopulation (starting population), growthRate (rate of population increase), and years (number of years to simulate). Initializes the population variable with …

Simulation of Population Growth Gaming Project in C++ Read More »