C++ Projects – Page 8 – Projects Inventory

Simulation of Welding Process Gaming Project in C++

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

#include <iostream>
#include <vector>

// Constants
const double INITIAL_TEMPERATURE = 20.0; // Initial temperature in degrees Celsius
const double WELDING_TEMPERATURE = 1500.0; // Temperature during welding in degrees Celsius
const double COOLING_RATE = 0.05; // Cooling rate per second
const double WELDING_DURATION = 5.0; // Duration of welding in seconds
const double TIME_STEP = 0.1; // Time step for the simulation in seconds

// Function to simulate the welding process
std::vector<double> simulateWelding(double weldingTemperature, double weldingDuration, double coolingRate, double timeStep) {
    std::vector<double> temperatures;
    double currentTemperature = INITIAL_TEMPERATURE;
    double timeElapsed = 0.0;

    // Heating phase
    while (timeElapsed < weldingDuration) {
        currentTemperature = weldingTemperature;
        temperatures.push_back(currentTemperature);
        timeElapsed += timeStep;
    }

    // Cooling phase
    while (currentTemperature > INITIAL_TEMPERATURE) {
        currentTemperature -= coolingRate * timeStep;
        if (currentTemperature < INITIAL_TEMPERATURE) {
            currentTemperature = INITIAL_TEMPERATURE;
        }
        temperatures.push_back(currentTemperature);
    }

    return temperatures;
}

int main() {
    std::vector<double> temperatures = simulateWelding(WELDING_TEMPERATURE, WELDING_DURATION, COOLING_RATE, TIME_STEP);

    std::cout << "Time (s)  Temperature (°C)\n";
    double timeElapsed = 0.0;

    for (double temp : temperatures) {
        std::cout << timeElapsed << "        " << temp << "\n";
        timeElapsed += TIME_STEP;
    }

    return 0;
}

#include <iostream>

#include <vector>

// Constants

const double INITIAL_TEMPERATURE = 20.0; // Initial temperature in degrees Celsius

const double WELDING_TEMPERATURE = 1500.0; // Temperature during welding in degrees Celsius

const double COOLING_RATE = 0.05; // Cooling rate per second

const double WELDING_DURATION = 5.0; // Duration of welding in seconds

const double TIME_STEP = 0.1; // Time step for the simulation in seconds

// Function to simulate the welding process

std::vector<double> simulateWelding(double weldingTemperature, double weldingDuration, double coolingRate, double timeStep) {

std::vector<double> temperatures;

double currentTemperature = INITIAL_TEMPERATURE;

double timeElapsed = 0.0;

// Heating phase

while (timeElapsed < weldingDuration) {

currentTemperature = weldingTemperature;

temperatures.push_back(currentTemperature);

timeElapsed += timeStep;

}

// Cooling phase

while (currentTemperature > INITIAL_TEMPERATURE) {

currentTemperature -= coolingRate * timeStep;

if (currentTemperature < INITIAL_TEMPERATURE) {

currentTemperature = INITIAL_TEMPERATURE;

}

temperatures.push_back(currentTemperature);

}

return temperatures;

}

int main() {

std::vector<double> temperatures = simulateWelding(WELDING_TEMPERATURE, WELDING_DURATION, COOLING_RATE, TIME_STEP);

std::cout << "Time (s) Temperature (°C)\n";

double timeElapsed = 0.0;

for (double temp : temperatures) {

std::cout << timeElapsed << " " << temp << "\n";

timeElapsed += TIME_STEP;

}

return 0;

}

Explanation Constants: INITIAL_TEMPERATURE: The initial temperature before welding starts. WELDING_TEMPERATURE: The temperature reached during the welding process. COOLING_RATE: The rate at which the temperature decreases per second after welding stops. WELDING_DURATION: The duration of the welding process. TIME_STEP: The time increment for each step of the simulation. simulateWelding Function: Simulates the welding process, including …

Simulation of Welding Process Gaming Project in C++ Read More »

Simulation of Wireless Communication Gaming Project in C++

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

#include <iostream>
#include <random>

// Function to generate a random noise value
double generateNoise(double mean, double stddev) {
    static std::default_random_engine generator;
    std::normal_distribution<double> distribution(mean, stddev);
    return distribution(generator);
}

// Function to simulate signal transmission and reception
double simulateCommunication(double signalStrength, double noiseMean, double noiseStddev) {
    // Generate noise
    double noise = generateNoise(noiseMean, noiseStddev);
    
    // Simulate received signal (signal + noise)
    double receivedSignal = signalStrength + noise;
    
    return receivedSignal;
}

int main() {
    double signalStrength = 100.0;   // Signal strength in dB
    double noiseMean = 0.0;          // Mean of the noise distribution
    double noiseStddev = 10.0;       // Standard deviation of the noise distribution
    
    int numSimulations = 10;         // Number of simulations to run
    
    std::cout << "Simulating wireless communication:\n";
    
    for (int i = 0; i < numSimulations; ++i) {
        double receivedSignal = simulateCommunication(signalStrength, noiseMean, noiseStddev);
        std::cout << "Simulation " << (i + 1) << ": Received Signal = " << receivedSignal << " dB\n";
    }

    return 0;
}

#include <iostream>

#include <random>

// Function to generate a random noise value

double generateNoise(double mean, double stddev) {

static std::default_random_engine generator;

std::normal_distribution<double> distribution(mean, stddev);

return distribution(generator);

}

// Function to simulate signal transmission and reception

double simulateCommunication(double signalStrength, double noiseMean, double noiseStddev) {

// Generate noise

double noise = generateNoise(noiseMean, noiseStddev);

// Simulate received signal (signal + noise)

double receivedSignal = signalStrength + noise;

return receivedSignal;

}

int main() {

double signalStrength = 100.0; // Signal strength in dB

double noiseMean = 0.0; // Mean of the noise distribution

double noiseStddev = 10.0; // Standard deviation of the noise distribution

int numSimulations = 10; // Number of simulations to run

std::cout << "Simulating wireless communication:\n";

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

double receivedSignal = simulateCommunication(signalStrength, noiseMean, noiseStddev);

std::cout << "Simulation " << (i + 1) << ": Received Signal = " << receivedSignal << " dB\n";

}

return 0;

}

Explanation generateNoise Function: Generates a random noise value using a normal distribution. The std::normal_distribution class from the C++ Standard Library is used to generate noise values with a specified mean and standard deviation. simulateCommunication Function: Simulates the wireless communication by adding noise to the transmitted signal. The received signal is calculated by adding the …

Simulation of Wireless Communication Gaming Project in C++ Read More »

Simulation of Ecosystem Dynamics Gaming Project in C++

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

#include <iostream>

// Structure to represent the state of the ecosystem
struct EcosystemState {
    double prey_population;     // Population of prey
    double predator_population; // Population of predators
};

// Function to update the ecosystem state based on the Lotka-Volterra equations
void updateEcosystemState(EcosystemState& state, double alpha, double beta, double delta, double gamma, double dt) {
    // Compute the changes in population
    double dPrey = (alpha * state.prey_population - beta * state.prey_population * state.predator_population) * dt;
    double dPredator = (delta * state.prey_population * state.predator_population - gamma * state.predator_population) * dt;
    
    // Update populations
    state.prey_population += dPrey;
    state.predator_population += dPredator;
}

int main() {
    // Initial conditions
    EcosystemState ecosystem = {40.0, 9.0};  // Initial populations: 40 prey, 9 predators

    // Parameters for the Lotka-Volterra model
    double alpha = 0.1;  // Prey birth rate
    double beta = 0.02;  // Predation rate
    double delta = 0.01; // Predator reproduction rate
    double gamma = 0.1;  // Predator death rate

    double dt = 0.1;  // Time step (in arbitrary time units)
    int steps = 100;  // Number of simulation steps

    // Simulate the ecosystem dynamics
    for (int i = 0; i < steps; ++i) {
        updateEcosystemState(ecosystem, alpha, beta, delta, gamma, dt);

        // Print the current state of the ecosystem
        std::cout << "Time: " << i * dt << ", "
                  << "Prey Population: " << ecosystem.prey_population << ", "
                  << "Predator Population: " << ecosystem.predator_population << "\n";
    }

    return 0;
}

#include <iostream>

// Structure to represent the state of the ecosystem

struct EcosystemState {

double prey_population; // Population of prey

double predator_population; // Population of predators

};

// Function to update the ecosystem state based on the Lotka-Volterra equations

void updateEcosystemState(EcosystemState& state, double alpha, double beta, double delta, double gamma, double dt) {

// Compute the changes in population

double dPrey = (alpha * state.prey_population - beta * state.prey_population * state.predator_population) * dt;

double dPredator = (delta * state.prey_population * state.predator_population - gamma * state.predator_population) * dt;

// Update populations

state.prey_population += dPrey;

state.predator_population += dPredator;

}

int main() {

// Initial conditions

EcosystemState ecosystem = {40.0, 9.0}; // Initial populations: 40 prey, 9 predators

// Parameters for the Lotka-Volterra model

double alpha = 0.1; // Prey birth rate

double beta = 0.02; // Predation rate

double delta = 0.01; // Predator reproduction rate

double gamma = 0.1; // Predator death rate

double dt = 0.1; // Time step (in arbitrary time units)

int steps = 100; // Number of simulation steps

// Simulate the ecosystem dynamics

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

updateEcosystemState(ecosystem, alpha, beta, delta, gamma, dt);

// Print the current state of the ecosystem

std::cout << "Time: " << i * dt << ", "

<< "Prey Population: " << ecosystem.prey_population << ", "

<< "Predator Population: " << ecosystem.predator_population << "\n";

}

return 0;

}

Explanation EcosystemState Structure: This structure holds the state of the ecosystem, including the populations of prey and predators. Main Function: The ecosystem is initialized with 40 prey and 9 predators. The program simulates the ecosystem for 100 steps, with each step representing an arbitrary time unit. The state of the ecosystem is printed after …

Simulation of Ecosystem Dynamics Gaming Project in C++ Read More »

Simulation of Drone Flight Gaming Project in C++

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

#include <iostream>
#include <cmath>

// Structure to represent the drone's state
struct DroneState {
    double x;  // Position in the x-axis
    double y;  // Position in the y-axis
    double vx; // Velocity in the x-axis
    double vy; // Velocity in the y-axis
    double ax; // Acceleration in the x-axis
    double ay; // Acceleration in the y-axis
};

// Function to update the drone's state based on acceleration and time step
void updateDroneState(DroneState& state, double dt) {
    // Update velocity based on acceleration
    state.vx += state.ax * dt;
    state.vy += state.ay * dt;
    
    // Update position based on velocity
    state.x += state.vx * dt;
    state.y += state.vy * dt;
}

int main() {
    // Initial conditions
    DroneState drone = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

    double dt = 0.1;  // Time step (seconds)
    int steps = 100;  // Number of simulation steps

    // Simulate the drone flight
    for (int i = 0; i < steps; ++i) {
        // Example acceleration input: hovering with slight forward acceleration
        if (i < 20) {
            drone.ax = 0.0;
            drone.ay = 0.1;  // Small upward acceleration
        } else if (i < 50) {
            drone.ax = 0.1;  // Forward acceleration
            drone.ay = 0.0;
        } else {
            drone.ax = 0.0;
            drone.ay = 0.0;  // No acceleration (coasting)
        }

        // Update drone state
        updateDroneState(drone, dt);

        // Print the current state of the drone
        std::cout << "Time: " << i * dt << " s, "
                  << "Position: (" << drone.x << ", " << drone.y << "), "
                  << "Velocity: (" << drone.vx << ", " << drone.vy << ")\n";
    }

    return 0;
}

#include <iostream>

#include <cmath>

// Structure to represent the drone's state

struct DroneState {

double x; // Position in the x-axis

double y; // Position in the y-axis

double vx; // Velocity in the x-axis

double vy; // Velocity in the y-axis

double ax; // Acceleration in the x-axis

double ay; // Acceleration in the y-axis

};

// Function to update the drone's state based on acceleration and time step

void updateDroneState(DroneState& state, double dt) {

// Update velocity based on acceleration

state.vx += state.ax * dt;

state.vy += state.ay * dt;

// Update position based on velocity

state.x += state.vx * dt;

state.y += state.vy * dt;

}

int main() {

// Initial conditions

DroneState drone = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

double dt = 0.1; // Time step (seconds)

int steps = 100; // Number of simulation steps

// Simulate the drone flight

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

// Example acceleration input: hovering with slight forward acceleration

if (i < 20) {

drone.ax = 0.0;

drone.ay = 0.1; // Small upward acceleration

} else if (i < 50) {

drone.ax = 0.1; // Forward acceleration

drone.ay = 0.0;

} else {

drone.ax = 0.0;

drone.ay = 0.0; // No acceleration (coasting)

}

// Update drone state

updateDroneState(drone, dt);

// Print the current state of the drone

std::cout << "Time: " << i * dt << " s, "

<< "Position: (" << drone.x << ", " << drone.y << "), "

<< "Velocity: (" << drone.vx << ", " << drone.vy << ")\n";

}

return 0;

}

Explanation DroneState Structure: This structure holds the state of the drone, including its position (x, y), velocity (vx, vy), and acceleration (ax, ay) in a 2D space. updateDroneState Function: This function updates the drone’s velocity and position based on the current acceleration and the time step (dt). The velocity is updated using the equation …

Simulation of Drone Flight Gaming Project in C++ Read More »

Simulation of Double Pendulum Gaming Project in C++

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

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

// Constants
const double PI = 3.141592653589793;
const double G = 9.81;  // Acceleration due to gravity (m/s^2)
const double DT = 0.01; // Time step for the simulation (s)

// Structure to hold the state of the pendulum
struct PendulumState {
    double theta1; // Angle of the first pendulum (radians)
    double theta2; // Angle of the second pendulum (radians)
    double omega1; // Angular velocity of the first pendulum (rad/s)
    double omega2; // Angular velocity of the second pendulum (rad/s)
};

// Function to compute the derivatives for the double pendulum
PendulumState computeDerivatives(const PendulumState& state, double m1, double m2, double l1, double l2) {
    PendulumState derivatives;

    double delta = state.theta2 - state.theta1;
    double den1 = (m1 + m2) * l1 - m2 * l1 * std::cos(delta) * std::cos(delta);
    double den2 = (l2 / l1) * den1;

    derivatives.omega1 = ((m2 * l1 * state.omega1 * state.omega1 * std::sin(delta) * std::cos(delta) +
                           m2 * G * std::sin(state.theta2) * std::cos(delta) +
                           m2 * l2 * state.omega2 * state.omega2 * std::sin(delta) -
                           (m1 + m2) * G * std::sin(state.theta1)) / den1);

    derivatives.omega2 = ((-m2 * l2 * state.omega2 * state.omega2 * std::sin(delta) * std::cos(delta) +
                           (m1 + m2) * G * std::sin(state.theta1) * std::cos(delta) -
                           (m1 + m2) * l1 * state.omega1 * state.omega1 * std::sin(delta) -
                           (m1 + m2) * G * std::sin(state.theta2)) / den2);

    derivatives.theta1 = state.omega1;
    derivatives.theta2 = state.omega2;

    return derivatives;
}

// Function to update the state using Euler's method
void updateState(PendulumState& state, const PendulumState& derivatives) {
    state.theta1 += derivatives.theta1 * DT;
    state.theta2 += derivatives.theta2 * DT;
    state.omega1 += derivatives.omega1 * DT;
    state.omega2 += derivatives.omega2 * DT;
}

int main() {
    // Initial conditions
    PendulumState state;
    state.theta1 = PI / 2;  // 90 degrees
    state.theta2 = PI / 4;  // 45 degrees
    state.omega1 = 0.0;
    state.omega2 = 0.0;

    double m1 = 1.0;  // Mass of the first pendulum (kg)
    double m2 = 1.0;  // Mass of the second pendulum (kg)
    double l1 = 1.0;  // Length of the first pendulum (m)
    double l2 = 1.0;  // Length of the second pendulum (m)

    for (int i = 0; i < 1000; ++i) {
        PendulumState derivatives = computeDerivatives(state, m1, m2, l1, l2);
        updateState(state, derivatives);

        std::cout << "Time: " << i * DT << " s, "
                  << "Theta1: " << state.theta1 << " rad, "
                  << "Theta2: " << state.theta2 << " rad\n";
    }

    return 0;
}

#include <iostream>

#include <cmath>

#include <vector>

// Constants

const double PI = 3.141592653589793;

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

const double DT = 0.01; // Time step for the simulation (s)

// Structure to hold the state of the pendulum

struct PendulumState {

double theta1; // Angle of the first pendulum (radians)

double theta2; // Angle of the second pendulum (radians)

double omega1; // Angular velocity of the first pendulum (rad/s)

double omega2; // Angular velocity of the second pendulum (rad/s)

};

// Function to compute the derivatives for the double pendulum

PendulumState computeDerivatives(const PendulumState& state, double m1, double m2, double l1, double l2) {

PendulumState derivatives;

double delta = state.theta2 - state.theta1;

double den1 = (m1 + m2) * l1 - m2 * l1 * std::cos(delta) * std::cos(delta);

double den2 = (l2 / l1) * den1;

derivatives.omega1 = ((m2 * l1 * state.omega1 * state.omega1 * std::sin(delta) * std::cos(delta) +

m2 * G * std::sin(state.theta2) * std::cos(delta) +

m2 * l2 * state.omega2 * state.omega2 * std::sin(delta) -

(m1 + m2) * G * std::sin(state.theta1)) / den1);

derivatives.omega2 = ((-m2 * l2 * state.omega2 * state.omega2 * std::sin(delta) * std::cos(delta) +

(m1 + m2) * G * std::sin(state.theta1) * std::cos(delta) -

(m1 + m2) * l1 * state.omega1 * state.omega1 * std::sin(delta) -

(m1 + m2) * G * std::sin(state.theta2)) / den2);

derivatives.theta1 = state.omega1;

derivatives.theta2 = state.omega2;

return derivatives;

}

// Function to update the state using Euler's method

void updateState(PendulumState& state, const PendulumState& derivatives) {

state.theta1 += derivatives.theta1 * DT;

state.theta2 += derivatives.theta2 * DT;

state.omega1 += derivatives.omega1 * DT;

state.omega2 += derivatives.omega2 * DT;

}

int main() {

// Initial conditions

PendulumState state;

state.theta1 = PI / 2; // 90 degrees

state.theta2 = PI / 4; // 45 degrees

state.omega1 = 0.0;

state.omega2 = 0.0;

double m1 = 1.0; // Mass of the first pendulum (kg)

double m2 = 1.0; // Mass of the second pendulum (kg)

double l1 = 1.0; // Length of the first pendulum (m)

double l2 = 1.0; // Length of the second pendulum (m)

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

PendulumState derivatives = computeDerivatives(state, m1, m2, l1, l2);

updateState(state, derivatives);

std::cout << "Time: " << i * DT << " s, "

<< "Theta1: " << state.theta1 << " rad, "

<< "Theta2: " << state.theta2 << " rad\n";

}

return 0;

}

Explanation Constants: PI, G, and DT are constants representing the value of π, the gravitational constant, and the time step for the simulation, respectively. PendulumState Structure: This structure holds the state of the double pendulum, including the angles (theta1, theta2) and angular velocities (omega1, omega2) of the two pendulums. computeDerivatives Function: This function calculates …

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

Simulation of Doppler Effect Gaming Project in C++

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

#include <iostream>
#include <cmath>

const double SPEED_OF_SOUND = 343.0;  // Speed of sound in air at 20°C in m/s

// Function to calculate the observed frequency using the Doppler effect formula
double calculateDopplerEffect(double sourceFrequency, double sourceSpeed, double observerSpeed, bool movingTowards) {
    if (movingTowards) {
        return sourceFrequency * ((SPEED_OF_SOUND + observerSpeed) / (SPEED_OF_SOUND - sourceSpeed));
    } else {
        return sourceFrequency * ((SPEED_OF_SOUND - observerSpeed) / (SPEED_OF_SOUND + sourceSpeed));
    }
}

int main() {
    double sourceFrequency, sourceSpeed, observerSpeed;
    char direction;

    std::cout << "Enter the frequency of the source (Hz): ";
    std::cin >> sourceFrequency;
    
    std::cout << "Enter the speed of the source (m/s): ";
    std::cin >> sourceSpeed;

    std::cout << "Enter the speed of the observer (m/s): ";
    std::cin >> observerSpeed;

    std::cout << "Is the observer moving towards the source? (y/n): ";
    std::cin >> direction;
    
    bool movingTowards = (direction == 'y' || direction == 'Y');

    double observedFrequency = calculateDopplerEffect(sourceFrequency, sourceSpeed, observerSpeed, movingTowards);

    std::cout << "The observed frequency is: " <<

#include <iostream>

#include <cmath>

const double SPEED_OF_SOUND = 343.0; // Speed of sound in air at 20°C in m/s

// Function to calculate the observed frequency using the Doppler effect formula

double calculateDopplerEffect(double sourceFrequency, double sourceSpeed, double observerSpeed, bool movingTowards) {

if (movingTowards) {

return sourceFrequency * ((SPEED_OF_SOUND + observerSpeed) / (SPEED_OF_SOUND - sourceSpeed));

} else {

return sourceFrequency * ((SPEED_OF_SOUND - observerSpeed) / (SPEED_OF_SOUND + sourceSpeed));

}

int main() {

double sourceFrequency, sourceSpeed, observerSpeed;

char direction;

std::cout << "Enter the frequency of the source (Hz): ";

std::cin >> sourceFrequency;

std::cout << "Enter the speed of the source (m/s): ";

std::cin >> sourceSpeed;

std::cout << "Enter the speed of the observer (m/s): ";

std::cin >> observerSpeed;

std::cout << "Is the observer moving towards the source? (y/n): ";

std::cin >> direction;

bool movingTowards = (direction == 'y' || direction == 'Y');

double observedFrequency = calculateDopplerEffect(sourceFrequency, sourceSpeed, observerSpeed, movingTowards);

std::cout << "The observed frequency is: " <<

Explanation Constants: SPEED_OF_SOUND: The speed of sound in air at 20°C, set to 343 m/s. This is the reference speed used in the Doppler effect calculations. calculateDopplerEffect Function: This function calculates the observed frequency based on whether the source and observer are moving towards or away from each other. Main Function: The program prompts …

Simulation of Doppler Effect Gaming Project in C++ Read More »

Simulation of Disk Scheduling Algorithms Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

class DiskScheduler {
public:
    // FCFS Algorithm
    int FCFS(const std::vector<int>& requests, int head) {
        int seek_operations = 0;
        int current_position = head;

        for (int request : requests) {
            seek_operations += std::abs(current_position - request);
            current_position = request;
        }

        return seek_operations;
    }

    // SSTF Algorithm
    int SSTF(std::vector<int> requests, int head) {
        int seek_operations = 0;
        int current_position = head;

        while (!requests.empty()) {
            auto closest = std::min_element(requests.begin(), requests.end(),
                [&current_position](int a, int b) {
                    return std::abs(a - current_position) < std::abs(b - current_position);
                });

            seek_operations += std::abs(current_position - *closest);
            current_position = *closest;
            requests.erase(closest);
        }

        return seek_operations;
    }

    // SCAN (Elevator) Algorithm
    int SCAN(std::vector<int> requests, int head, int disk_size) {
        int seek_operations = 0;
        int current_position = head;

        std::sort(requests.begin(), requests.end());
        
        // Split requests into those less than and greater than the current head position
        std::vector<int> left, right;
        for (int request : requests) {
            if (request < current_position)
                left.push_back(request);
            else
                right.push_back(request);
        }

        // Scan to the right (towards the end of the disk)
        for (int request : right) {
            seek_operations += std::abs(current_position - request);
            current_position = request;
        }

        // Then scan to the left (towards the beginning of the disk)
        if (!left.empty()) {
            seek_operations += std::abs(current_position - disk_size);
            current_position = disk_size;

            for (auto it = left.rbegin(); it != left.rend(); ++it) {
                seek_operations += std::abs(current_position - *it);
                current_position = *it;
            }
        }

        return seek_operations;
    }
};

int main() {
    DiskScheduler scheduler;
    int head, disk_size, num_requests;

    std::cout << "Enter initial head position: ";
    std::cin >> head;

    std::cout << "Enter disk size: ";
    std::cin >> disk_size;

    std::cout << "Enter number of requests: ";
    std::cin >> num_requests;

    std::vector<int> requests(num_requests);
    std::cout << "Enter the requests: ";
    for (int i = 0; i < num_requests; ++i) {
        std::cin >> requests[i];
    }

    int fcfs_seek = scheduler.FCFS(requests, head);
    int sstf_seek = scheduler.SSTF(requests, head);
    int scan_seek = scheduler.SCAN(requests, head, disk_size);

    std::cout << "Total seek operations (FCFS): " << fcfs_seek << "\n";
    std::cout << "Total seek operations (SSTF): " << sstf_seek << "\n";
    std::cout << "Total seek operations (SCAN): " << scan_seek << "\n";

    return 0;
}

100

101

102

103

104

105

#include <iostream>

#include <vector>

#include <algorithm>

#include <cmath>

class DiskScheduler {

public:

// FCFS Algorithm

int FCFS(const std::vector<int>& requests, int head) {

int seek_operations = 0;

int current_position = head;

for (int request : requests) {

seek_operations += std::abs(current_position - request);

current_position = request;

}

return seek_operations;

}

// SSTF Algorithm

int SSTF(std::vector<int> requests, int head) {

int seek_operations = 0;

int current_position = head;

while (!requests.empty()) {

auto closest = std::min_element(requests.begin(), requests.end(),

[&current_position](int a, int b) {

return std::abs(a - current_position) < std::abs(b - current_position);

});

seek_operations += std::abs(current_position - *closest);

current_position = *closest;

requests.erase(closest);

}

return seek_operations;

}

// SCAN (Elevator) Algorithm

int SCAN(std::vector<int> requests, int head, int disk_size) {

int seek_operations = 0;

int current_position = head;

std::sort(requests.begin(), requests.end());

// Split requests into those less than and greater than the current head position

std::vector<int> left, right;

for (int request : requests) {

if (request < current_position)

left.push_back(request);

else

right.push_back(request);

}

// Scan to the right (towards the end of the disk)

for (int request : right) {

seek_operations += std::abs(current_position - request);

current_position = request;

}

// Then scan to the left (towards the beginning of the disk)

if (!left.empty()) {

seek_operations += std::abs(current_position - disk_size);

current_position = disk_size;

for (auto it = left.rbegin(); it != left.rend(); ++it) {

seek_operations += std::abs(current_position - *it);

current_position = *it;

}

return seek_operations;

}

};

int main() {

DiskScheduler scheduler;

int head, disk_size, num_requests;

std::cout << "Enter initial head position: ";

std::cin >> head;

std::cout << "Enter disk size: ";

std::cin >> disk_size;

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

std::cin >> num_requests;

std::vector<int> requests(num_requests);

std::cout << "Enter the requests: ";

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

std::cin >> requests[i];

}

int fcfs_seek = scheduler.FCFS(requests, head);

int sstf_seek = scheduler.SSTF(requests, head);

int scan_seek = scheduler.SCAN(requests, head, disk_size);

std::cout << "Total seek operations (FCFS): " << fcfs_seek << "\n";

std::cout << "Total seek operations (SSTF): " << sstf_seek << "\n";

std::cout << "Total seek operations (SCAN): " << scan_seek << "\n";

return 0;

}

Explanation DiskScheduler Class: This class contains implementations for the FCFS, SSTF, and SCAN (Elevator) disk scheduling algorithms. Each algorithm is implemented as a member function returning the total number of seek operations required. FCFS Algorithm: The FCFS function implements the First-Come, First-Served algorithm. It processes each request in the order received and calculates the …

Simulation of Disk Scheduling Algorithms Gaming Project in C++ Read More »

Simulation of Diffraction Patterns Gaming Project in C++

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

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

// Constants
const double PI = 3.141592653589793;
const double WAVELENGTH = 500e-9;  // Wavelength of light in meters (e.g., 500 nm)
const double SLIT_WIDTH = 1e-6;    // Width of the slit in meters (e.g., 1 micron)
const double SCREEN_DISTANCE = 1.0; // Distance from slit to screen in meters

// Function to calculate the intensity at a point on the screen
double calculateIntensity(double y) {
    double beta = (PI * SLIT_WIDTH * y) / (WAVELENGTH * SCREEN_DISTANCE);
    if (beta == 0) {
        return 1.0;  // Maximum intensity at the center
    } else {
        return pow(sin(beta) / beta, 2);
    }
}

// Function to simulate and display the diffraction pattern
void simulateDiffractionPattern(int points, double screenSize) {
    std::vector<double> intensity(points);

    double step = screenSize / points;
    double maxIntensity = 0.0;

    for (int i = 0; i < points; ++i) {
        double y = -screenSize / 2 + i * step;
        intensity[i] = calculateIntensity(y);
        if (intensity[i] > maxIntensity) {
            maxIntensity = intensity[i];
        }
    }

    // Display the diffraction pattern
    std::cout << "Simulated Diffraction Pattern:\n";
    for (int i = 0; i < points; ++i) {
        int barLength = static_cast<int>((intensity[i] / maxIntensity) * 50);
        std::cout << std::setw(3) << i << " | ";
        for (int j = 0; j < barLength; ++j) {
            std::cout << "*";
        }
        std::cout << "\n";
    }
}

int main() {
    int points;
    double screenSize;

    std::cout << "Enter the number of points to simulate: ";
    std::cin >> points;
    std::cout << "Enter the screen size in meters: ";
    std::cin >> screenSize;

    simulateDiffractionPattern(points, screenSize);

    return 0;
}

#include <iostream>

#include <cmath>

#include <vector>

#include <iomanip>

// Constants

const double PI = 3.141592653589793;

const double WAVELENGTH = 500e-9; // Wavelength of light in meters (e.g., 500 nm)

const double SLIT_WIDTH = 1e-6; // Width of the slit in meters (e.g., 1 micron)

const double SCREEN_DISTANCE = 1.0; // Distance from slit to screen in meters

// Function to calculate the intensity at a point on the screen

double calculateIntensity(double y) {

double beta = (PI * SLIT_WIDTH * y) / (WAVELENGTH * SCREEN_DISTANCE);

if (beta == 0) {

return 1.0; // Maximum intensity at the center

} else {

return pow(sin(beta) / beta, 2);

}

// Function to simulate and display the diffraction pattern

void simulateDiffractionPattern(int points, double screenSize) {

std::vector<double> intensity(points);

double step = screenSize / points;

double maxIntensity = 0.0;

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

double y = -screenSize / 2 + i * step;

intensity[i] = calculateIntensity(y);

if (intensity[i] > maxIntensity) {

maxIntensity = intensity[i];

}

// Display the diffraction pattern

std::cout << "Simulated Diffraction Pattern:\n";

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

int barLength = static_cast<int>((intensity[i] / maxIntensity) * 50);

std::cout << std::setw(3) << i << " | ";

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

std::cout << "*";

}

std::cout << "\n";

}

int main() {

int points;

double screenSize;

std::cout << "Enter the number of points to simulate: ";

std::cin >> points;

std::cout << "Enter the screen size in meters: ";

std::cin >> screenSize;

simulateDiffractionPattern(points, screenSize);

return 0;

}

Explanation Constants: The program defines constants like the wavelength of light (WAVELENGTH), slit width (SLIT_WIDTH), and the distance from the slit to the screen (SCREEN_DISTANCE). These values are set in meters, representing typical values for visible light and slit experiments. calculateIntensity Function: This function returns the relative intensity, which is normalized by the maximum …

Simulation of Diffraction Patterns Gaming Project in C++ Read More »

Simulation of Deep Learning Models Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <cmath>
#include <cstdlib>
#include <ctime>

class NeuralNetwork {
private:
    std::vector<std::vector<double>> weights1;  // Weights between input and hidden layer
    std::vector<std::vector<double>> weights2;  // Weights between hidden and output layer
    std::vector<double> hiddenLayer;            // Neurons in the hidden layer
    std::vector<double> outputLayer;            // Neurons in the output layer
    double learningRate;

    // Activation function (sigmoid)
    double sigmoid(double x) {
        return 1.0 / (1.0 + exp(-x));
    }

    // Derivative of the sigmoid function
    double sigmoidDerivative(double x) {
        return x * (1.0 - x);
    }

public:
    NeuralNetwork(int inputSize, int hiddenSize, int outputSize, double lr) : learningRate(lr) {
        srand(static_cast<unsigned>(time(0)));
        
        // Initialize weights with random values
        weights1.resize(inputSize, std::vector<double>(hiddenSize));
        for (auto &row : weights1) {
            for (auto &weight : row) {
                weight = ((double)rand() / RAND_MAX);
            }
        }

        weights2.resize(hiddenSize, std::vector<double>(outputSize));
        for (auto &row : weights2) {
            for (auto &weight : row) {
                weight = ((double)rand() / RAND_MAX);
            }
        }

        hiddenLayer.resize(hiddenSize);
        outputLayer.resize(outputSize);
    }

    // Feedforward process
    std::vector<double> feedForward(const std::vector<double> &input) {
        for (size_t i = 0; i < hiddenLayer.size(); ++i) {
            double sum = 0.0;
            for (size_t j = 0; j < input.size(); ++j) {
                sum += input[j] * weights1[j][i];
            }
            hiddenLayer[i] = sigmoid(sum);
        }

        for (size_t i = 0; i < outputLayer.size(); ++i) {
            double sum = 0.0;
            for (size_t j = 0; j < hiddenLayer.size(); ++j) {
                sum += hiddenLayer[j] * weights2[j][i];
            }
            outputLayer[i] = sigmoid(sum);
        }

        return outputLayer;
    }

    // Backpropagation process
    void backpropagate(const std::vector<double> &input, const std::vector<double> &target) {
        std::vector<double> outputError(outputLayer.size());
        std::vector<double> hiddenError(hiddenLayer.size());

        // Calculate error at output layer
        for (size_t i = 0; i < outputLayer.size(); ++i) {
            outputError[i] = (target[i] - outputLayer[i]) * sigmoidDerivative(outputLayer[i]);
        }

        // Calculate error at hidden layer
        for (size_t i = 0; i < hiddenLayer.size(); ++i) {
            double sum = 0.0;
            for (size_t j = 0; j < outputError.size(); ++j) {
                sum += outputError[j] * weights2[i][j];
            }
            hiddenError[i] = sum * sigmoidDerivative(hiddenLayer[i]);
        }

        // Update weights between hidden and output layer
        for (size_t i = 0; i < hiddenLayer.size(); ++i) {
            for (size_t j = 0; j < outputLayer.size(); ++j) {
                weights2[i][j] += learningRate * outputError[j] * hiddenLayer[i];
            }
        }

        // Update weights between input and hidden layer
        for (size_t i = 0; i < input.size(); ++i) {
            for (size_t j = 0; j < hiddenLayer.size(); ++j) {
                weights1[i][j] += learningRate * hiddenError[j] * input[i];
            }
        }
    }

    // Train the neural network
    void train(const std::vector<std::vector<double>> &trainingInputs, const std::vector<std::vector<double>> &trainingOutputs, int epochs) {
        for (int i = 0; i < epochs; ++i) {
            for (size_t j = 0; j < trainingInputs.size(); ++j) {
                feedForward(trainingInputs[j]);
                backpropagate(trainingInputs[j], trainingOutputs[j]);
            }
        }
    }

    // Test the neural network
    void test(const std::vector<double> &input) {
        std::vector<double> output = feedForward(input);
        std::cout << "Output: ";
        for (const auto &o : output) {
            std::cout << o << " ";
        }
        std::cout << "\n";
    }
};

int main() {
    // Simple dataset for XOR problem
    std::vector<std::vector<double>> inputs = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
    std::vector<std::vector<double>> outputs = {{0}, {1}, {1}, {0}};

    NeuralNetwork nn(2, 2, 1, 0.5);

    // Train the network
    nn.train(inputs, outputs, 10000);

    // Test the network
    std::cout << "Testing the trained network on XOR problem:\n";
    for (const auto &input : inputs) {
        std::cout << "Input: " << input[0] << " " << input[1] << " => ";
        nn.test(input);
    }

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

#include <iostream>

#include <vector>

#include <cmath>

#include <cstdlib>

#include <ctime>

class NeuralNetwork {

private:

std::vector<std::vector<double>> weights1; // Weights between input and hidden layer

std::vector<std::vector<double>> weights2; // Weights between hidden and output layer

std::vector<double> hiddenLayer; // Neurons in the hidden layer

std::vector<double> outputLayer; // Neurons in the output layer

double learningRate;

// Activation function (sigmoid)

double sigmoid(double x) {

return 1.0 / (1.0 + exp(-x));

}

// Derivative of the sigmoid function

double sigmoidDerivative(double x) {

return x * (1.0 - x);

}

public:

NeuralNetwork(int inputSize, int hiddenSize, int outputSize, double lr) : learningRate(lr) {

srand(static_cast<unsigned>(time(0)));

// Initialize weights with random values

weights1.resize(inputSize, std::vector<double>(hiddenSize));

for (auto &row : weights1) {

for (auto &weight : row) {

weight = ((double)rand() / RAND_MAX);

}

weights2.resize(hiddenSize, std::vector<double>(outputSize));

for (auto &row : weights2) {

for (auto &weight : row) {

weight = ((double)rand() / RAND_MAX);

}

hiddenLayer.resize(hiddenSize);

outputLayer.resize(outputSize);

}

// Feedforward process

std::vector<double> feedForward(const std::vector<double> &input) {

for (size_t i = 0; i < hiddenLayer.size(); ++i) {

double sum = 0.0;

for (size_t j = 0; j < input.size(); ++j) {

sum += input[j] * weights1[j][i];

}

hiddenLayer[i] = sigmoid(sum);

}

for (size_t i = 0; i < outputLayer.size(); ++i) {

double sum = 0.0;

for (size_t j = 0; j < hiddenLayer.size(); ++j) {

sum += hiddenLayer[j] * weights2[j][i];

}

outputLayer[i] = sigmoid(sum);

}

return outputLayer;

}

// Backpropagation process

void backpropagate(const std::vector<double> &input, const std::vector<double> &target) {

std::vector<double> outputError(outputLayer.size());

std::vector<double> hiddenError(hiddenLayer.size());

// Calculate error at output layer

for (size_t i = 0; i < outputLayer.size(); ++i) {

outputError[i] = (target[i] - outputLayer[i]) * sigmoidDerivative(outputLayer[i]);

}

// Calculate error at hidden layer

for (size_t i = 0; i < hiddenLayer.size(); ++i) {

double sum = 0.0;

for (size_t j = 0; j < outputError.size(); ++j) {

sum += outputError[j] * weights2[i][j];

}

hiddenError[i] = sum * sigmoidDerivative(hiddenLayer[i]);

}

// Update weights between hidden and output layer

for (size_t i = 0; i < hiddenLayer.size(); ++i) {

for (size_t j = 0; j < outputLayer.size(); ++j) {

weights2[i][j] += learningRate * outputError[j] * hiddenLayer[i];

}

// Update weights between input and hidden layer

for (size_t i = 0; i < input.size(); ++i) {

for (size_t j = 0; j < hiddenLayer.size(); ++j) {

weights1[i][j] += learningRate * hiddenError[j] * input[i];

}

// Train the neural network

void train(const std::vector<std::vector<double>> &trainingInputs, const std::vector<std::vector<double>> &trainingOutputs, int epochs) {

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

for (size_t j = 0; j < trainingInputs.size(); ++j) {

feedForward(trainingInputs[j]);

backpropagate(trainingInputs[j], trainingOutputs[j]);

}

// Test the neural network

void test(const std::vector<double> &input) {

std::vector<double> output = feedForward(input);

std::cout << "Output: ";

for (const auto &o : output) {

std::cout << o << " ";

}

std::cout << "\n";

}

};

int main() {

// Simple dataset for XOR problem

std::vector<std::vector<double>> inputs = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};

std::vector<std::vector<double>> outputs = {{0}, {1}, {1}, {0}};

NeuralNetwork nn(2, 2, 1, 0.5);

// Train the network

nn.train(inputs, outputs, 10000);

// Test the network

std::cout << "Testing the trained network on XOR problem:\n";

for (const auto &input : inputs) {

std::cout << "Input: " << input[0] << " " << input[1] << " => ";

nn.test(input);

}

return 0;

}

Explanation NeuralNetwork Class: The NeuralNetwork class implements a simple feedforward neural network with one hidden layer. The class contains the following data members: weights1: Weights connecting the input layer to the hidden layer. weights2: Weights connecting the hidden layer to the output layer. hiddenLayer: The neurons in the hidden layer. outputLayer: The neurons in …

Simulation of Deep Learning Models Gaming Project in C++ Read More »

Simulation of Database Management System Gaming Project in C++

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

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

class Record {
public:
    int id;
    std::string name;
    int age;

    Record(int i, const std::string &n, int a) : id(i), name(n), age(a) {}
};

class Database {
private:
    std::vector<Record> records;

public:
    void addRecord(int id, const std::string &name, int age) {
        records.emplace_back(id, name, age);
        std::cout << "Record added successfully!\n";
    }

    void displayRecords() const {
        if (records.empty()) {
            std::cout << "No records to display.\n";
            return;
        }
        std::cout << "ID\tName\t\tAge\n";
        std::cout << "--------------------------------\n";
        for (const auto &record : records) {
            std::cout << record.id << "\t" << record.name << "\t\t" << record.age << "\n";
        }
    }

    void searchRecord(int id) const {
        for (const auto &record : records) {
            if (record.id == id) {
                std::cout << "Record Found:\n";
                std::cout << "ID: " << record.id << ", Name: " << record.name << ", Age: " << record.age << "\n";
                return;
            }
        }
        std::cout << "Record not found.\n";
    }

    void deleteRecord(int id) {
        for (auto it = records.begin(); it != records.end(); ++it) {
            if (it->id == id) {
                records.erase(it);
                std::cout << "Record deleted successfully!\n";
                return;
            }
        }
        std::cout << "Record not found.\n";
    }
};

int main() {
    Database db;
    int choice, id, age;
    std::string name;

    do {
        std::cout << "\n--- Database Management System ---\n";
        std::cout << "1. Add Record\n";
        std::cout << "2. Display Records\n";
        std::cout << "3. Search Record\n";
        std::cout << "4. Delete Record\n";
        std::cout << "5. Exit\n";
        std::cout << "Enter your choice: ";
        std::cin >> choice;

        switch (choice) {
            case 1:
                std::cout << "Enter ID: ";
                std::cin >> id;
                std::cin.ignore(); // to ignore newline after ID input
                std::cout << "Enter Name: ";
                std::getline(std::cin, name);
                std::cout << "Enter Age: ";
                std::cin >> age;
                db.addRecord(id, name, age);
                break;
            case 2:
                db.displayRecords();
                break;
            case 3:
                std::cout << "Enter ID to search: ";
                std::cin >> id;
                db.searchRecord(id);
                break;
            case 4:
                std::cout << "Enter ID to delete: ";
                std::cin >> id;
                db.deleteRecord(id);
                break;
            case 5:
                std::cout << "Exiting...\n";
                break;
            default:
                std::cout << "Invalid choice! Please try again.\n";
        }
    } while (choice != 5);

    return 0;
}

100

101

102

103

104

105

106

107

#include <iostream>

#include <vector>

#include <string>

class Record {

public:

int id;

std::string name;

int age;

Record(int i, const std::string &n, int a) : id(i), name(n), age(a) {}

};

class Database {

private:

std::vector<Record> records;

public:

void addRecord(int id, const std::string &name, int age) {

records.emplace_back(id, name, age);

std::cout << "Record added successfully!\n";

}

void displayRecords() const {

if (records.empty()) {

std::cout << "No records to display.\n";

return;

}

std::cout << "ID\tName\t\tAge\n";

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

for (const auto &record : records) {

std::cout << record.id << "\t" << record.name << "\t\t" << record.age << "\n";

}

void searchRecord(int id) const {

for (const auto &record : records) {

if (record.id == id) {

std::cout << "Record Found:\n";

std::cout << "ID: " << record.id << ", Name: " << record.name << ", Age: " << record.age << "\n";

return;

}

std::cout << "Record not found.\n";

}

void deleteRecord(int id) {

for (auto it = records.begin(); it != records.end(); ++it) {

if (it->id == id) {

records.erase(it);

std::cout << "Record deleted successfully!\n";

return;

}

std::cout << "Record not found.\n";

}

};

int main() {

Database db;

int choice, id, age;

std::string name;

do {

std::cout << "\n--- Database Management System ---\n";

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

std::cout << "2. Display Records\n";

std::cout << "3. Search Record\n";

std::cout << "4. Delete Record\n";

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

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

std::cin >> choice;

switch (choice) {

case 1:

std::cout << "Enter ID: ";

std::cin >> id;

std::cin.ignore(); // to ignore newline after ID input

std::cout << "Enter Name: ";

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

std::cout << "Enter Age: ";

std::cin >> age;

db.addRecord(id, name, age);

break;

case 2:

db.displayRecords();

break;

case 3:

std::cout << "Enter ID to search: ";

std::cin >> id;

db.searchRecord(id);

break;

case 4:

std::cout << "Enter ID to delete: ";

std::cin >> id;

db.deleteRecord(id);

break;

case 5:

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

break;

default:

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

}

} while (choice != 5);

return 0;

}

Explanation Record Class: The Record class represents a single record in the database. It contains three data members: id, name, and age. Database Class: The Database class contains a std::vector of Record objects, representing the collection of records in the database. The class has the following member functions: addRecord(int id, const std::string &name, int …

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