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

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 »

Simulation of Doppler Effect Gaming Project in C++

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

#include <iostream>
#include <cmath>

class DopplerEffect {
public:
    DopplerEffect(double sourceFrequency, double speedOfSound)
        : sourceFrequency(sourceFrequency), speedOfSound(speedOfSound) {}

    // Calculates the observed frequency when the source and observer are moving
    double calculateObservedFrequency(double observerSpeed, double sourceSpeed) const {
        // Doppler effect formula:
        // f' = f * (v + vo) / (v + vs)
        // Where:
        // f' is the observed frequency
        // f is the source frequency
        // v is the speed of sound
        // vo is the speed of the observer (positive if moving towards the source)
        // vs is the speed of the source (positive if moving away from the observer)

        double observedFrequency = sourceFrequency * (speedOfSound + observerSpeed) / (speedOfSound + sourceSpeed);
        return observedFrequency;
    }

private:
    double sourceFrequency; // Frequency of the source in Hz
    double speedOfSound;    // Speed of sound in the medium (e.g., air) in m/s
};

int main() {
    double sourceFrequency = 440.0; // Frequency of the source (e.g., a sound wave) in Hz
    double speedOfSound = 343.0;    // Speed of sound in air at 20°C in m/s

    DopplerEffect doppler(sourceFrequency, speedOfSound);

    // User input for observer's and source's speeds
    double observerSpeed, sourceSpeed;
    std::cout << "Enter the speed of the observer (m/s, positive if moving towards the source): ";
    std::cin >> observerSpeed;
    std::cout << "Enter the speed of the source (m/s, positive if moving away from the observer): ";
    std::cin >> sourceSpeed;

    double observedFrequency = doppler.calculateObservedFrequency(observerSpeed, sourceSpeed);
    std::cout << "Observed Frequency: " << observedFrequency << " Hz" << std::endl;

    return 0;
}

#include <iostream>

#include <cmath>

class DopplerEffect {

public:

DopplerEffect(double sourceFrequency, double speedOfSound)

: sourceFrequency(sourceFrequency), speedOfSound(speedOfSound) {}

// Calculates the observed frequency when the source and observer are moving

double calculateObservedFrequency(double observerSpeed, double sourceSpeed) const {

// Doppler effect formula:

// f' = f * (v + vo) / (v + vs)

// Where:

// f' is the observed frequency

// f is the source frequency

// v is the speed of sound

// vo is the speed of the observer (positive if moving towards the source)

// vs is the speed of the source (positive if moving away from the observer)

double observedFrequency = sourceFrequency * (speedOfSound + observerSpeed) / (speedOfSound + sourceSpeed);

return observedFrequency;

}

private:

double sourceFrequency; // Frequency of the source in Hz

double speedOfSound; // Speed of sound in the medium (e.g., air) in m/s

};

int main() {

double sourceFrequency = 440.0; // Frequency of the source (e.g., a sound wave) in Hz

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

DopplerEffect doppler(sourceFrequency, speedOfSound);

// User input for observer's and source's speeds

double observerSpeed, sourceSpeed;

std::cout << "Enter the speed of the observer (m/s, positive if moving towards the source): ";

std::cin >> observerSpeed;

std::cout << "Enter the speed of the source (m/s, positive if moving away from the observer): ";

std::cin >> sourceSpeed;

double observedFrequency = doppler.calculateObservedFrequency(observerSpeed, sourceSpeed);

std::cout << "Observed Frequency: " << observedFrequency << " Hz" << std::endl;

return 0;

}

Explanation Header Files: <iostream>: For input and output operations. <cmath>: Included for completeness, though not used in this specific example. DopplerEffect Class: Constructor: Initializes the sourceFrequency and speedOfSound. The source frequency is the frequency of the wave emitted by the source, and the speed of sound is the propagation speed of the wave through …

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

Simulation of Data Warehousing Gaming Project in C++

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

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

class DataWarehouse {
public:
    // Adds data to the warehouse
    void addData(const std::string& key, const std::string& value) {
        data[key] = value;
    }

    // Retrieves data from the warehouse
    std::string getData(const std::string& key) const {
        auto it = data.find(key);
        if (it != data.end()) {
            return it->second;
        } else {
            return "Data not found";
        }
    }

    // Displays all data in the warehouse
    void displayAllData() const {
        for (const auto& entry : data) {
            std::cout << "Key: " << entry.first << ", Value: " << entry.second << std::endl;
        }
    }

private:
    std::unordered_map<std::string, std::string> data;
};

int main() {
    DataWarehouse warehouse;

    // Add some data to the warehouse
    warehouse.addData("User1", "Alice");
    warehouse.addData("User2", "Bob");
    warehouse.addData("User3", "Charlie");

    // Retrieve and display specific data
    std::cout << "Retrieving User2: " << warehouse.getData("User2") << std::endl;

    // Display all data
    std::cout << "Displaying all data:" << std::endl;
    warehouse.displayAllData();

    return 0;
}

#include <iostream>

#include <vector>

#include <unordered_map>

#include <string>

class DataWarehouse {

public:

// Adds data to the warehouse

void addData(const std::string& key, const std::string& value) {

data[key] = value;

}

// Retrieves data from the warehouse

std::string getData(const std::string& key) const {

auto it = data.find(key);

if (it != data.end()) {

return it->second;

} else {

return "Data not found";

}

// Displays all data in the warehouse

void displayAllData() const {

for (const auto& entry : data) {

std::cout << "Key: " << entry.first << ", Value: " << entry.second << std::endl;

}

private:

std::unordered_map<std::string, std::string> data;

};

int main() {

DataWarehouse warehouse;

// Add some data to the warehouse

warehouse.addData("User1", "Alice");

warehouse.addData("User2", "Bob");

warehouse.addData("User3", "Charlie");

// Retrieve and display specific data

std::cout << "Retrieving User2: " << warehouse.getData("User2") << std::endl;

// Display all data

std::cout << "Displaying all data:" << std::endl;

warehouse.displayAllData();

return 0;

}

Explanation Header Files: <iostream>: For input and output operations. <vector>: Although not used in this example, it’s included for potential extensions. <unordered_map>: To store key-value pairs efficiently. <string>: For handling string operations. DataWarehouse Class: addData(): Adds a key-value pair to the data warehouse. The key is a unique identifier, and the value is the …

Simulation of Data Warehousing Gaming Project in C++ Read More »

Simulation of Data Mining Techniques Gaming Project in C++

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

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

struct Point {
    double x, y;
    int clusterId; // Cluster assignment

    Point(double x = 0, double y = 0) : x(x), y(y), clusterId(-1) {}
};

class KMeans {
public:
    KMeans(int k, int maxIterations) : k(k), maxIterations(maxIterations) {
        std::srand(std::time(0));
    }

    void fit(std::vector<Point>& points) {
        // Initialize centroids randomly
        initializeCentroids(points);

        for (int iteration = 0; iteration < maxIterations; ++iteration) {
            bool changed = false;

            // Assign points to the nearest centroid
            for (auto& point : points) {
                int newClusterId = findClosestCentroid(point);
                if (point.clusterId != newClusterId) {
                    point.clusterId = newClusterId;
                    changed = true;
                }
            }

            // Recalculate centroids
            recalculateCentroids(points);

            if (!changed) break; // Stop if no change in cluster assignments
        }
    }

    void printResults(const std::vector<Point>& points) const {
        for (int i = 0; i < k; ++i) {
            std::cout << "Cluster " << i + 1 << " (Centroid: "
                      << centroids[i].x << ", " << centroids[i].y << "):\n";
            for (const auto& point : points) {
                if (point.clusterId == i) {
                    std::cout << "  (" << point.x << ", " << point.y << ")\n";
                }
            }
        }
    }

private:
    int k;
    int maxIterations;
    std::vector<Point> centroids;

    void initializeCentroids(const std::vector<Point>& points) {
        centroids.clear();
        std::vector<int> indices(points.size());
        for (int i = 0; i < points.size(); ++i) indices[i] = i;
        std::random_shuffle(indices.begin(), indices.end());
        for (int i = 0; i < k; ++i) {
            centroids.push_back(points[indices[i]]);
        }
    }

    int findClosestCentroid(const Point& point) const {
        int closestId = 0;
        double minDistance = std::numeric_limits<double>::max();
        for (int i = 0; i < k; ++i) {
            double distance = euclideanDistance(point, centroids[i]);
            if (distance < minDistance) {
                minDistance = distance;
                closestId = i;
            }
        }
        return closestId;
    }

    void recalculateCentroids(const std::vector<Point>& points) {
        std::vector<Point> newCentroids(k, Point());
        std::vector<int> counts(k, 0);

        for (const auto& point : points) {
            int id = point.clusterId;
            newCentroids[id].x += point.x;
            newCentroids[id].y += point.y;
            counts[id]++;
        }

        for (int i = 0; i < k; ++i) {
            if (counts[i] > 0) {
                newCentroids[i].x /= counts[i];
                newCentroids[i].y /= counts[i];
            }
            centroids[i] = newCentroids[i];
        }
    }

    double euclideanDistance(const Point& a, const Point& b) const {
        return std::sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
    }
};

int main() {
    std::vector<Point> points = {
        {1.0, 2.0}, {1.5, 1.8}, {5.0, 8.0}, {8.0, 8.0},
        {1.0, 0.6}, {9.0, 11.0}, {8.0, 2.0}, {10.0, 2.0},
        {9.0, 3.0}
    };

    int k = 3; // Number of clusters
    int maxIterations = 100;

    KMeans kmeans(k, maxIterations);
    kmeans.fit(points);
    kmeans.printResults(points);

    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

#include <iostream>

#include <vector>

#include <cmath>

#include <limits>

#include <cstdlib>

#include <ctime>

struct Point {

double x, y;

int clusterId; // Cluster assignment

Point(double x = 0, double y = 0) : x(x), y(y), clusterId(-1) {}

};

class KMeans {

public:

KMeans(int k, int maxIterations) : k(k), maxIterations(maxIterations) {

std::srand(std::time(0));

}

void fit(std::vector<Point>& points) {

// Initialize centroids randomly

initializeCentroids(points);

for (int iteration = 0; iteration < maxIterations; ++iteration) {

bool changed = false;

// Assign points to the nearest centroid

for (auto& point : points) {

int newClusterId = findClosestCentroid(point);

if (point.clusterId != newClusterId) {

point.clusterId = newClusterId;

changed = true;

}

// Recalculate centroids

recalculateCentroids(points);

if (!changed) break; // Stop if no change in cluster assignments

}

void printResults(const std::vector<Point>& points) const {

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

std::cout << "Cluster " << i + 1 << " (Centroid: "

<< centroids[i].x << ", " << centroids[i].y << "):\n";

for (const auto& point : points) {

if (point.clusterId == i) {

std::cout << " (" << point.x << ", " << point.y << ")\n";

}

private:

int k;

int maxIterations;

std::vector<Point> centroids;

void initializeCentroids(const std::vector<Point>& points) {

centroids.clear();

std::vector<int> indices(points.size());

for (int i = 0; i < points.size(); ++i) indices[i] = i;

std::random_shuffle(indices.begin(), indices.end());

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

centroids.push_back(points[indices[i]]);

}

int findClosestCentroid(const Point& point) const {

int closestId = 0;

double minDistance = std::numeric_limits<double>::max();

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

double distance = euclideanDistance(point, centroids[i]);

if (distance < minDistance) {

minDistance = distance;

closestId = i;

}

return closestId;

}

void recalculateCentroids(const std::vector<Point>& points) {

std::vector<Point> newCentroids(k, Point());

std::vector<int> counts(k, 0);

for (const auto& point : points) {

int id = point.clusterId;

newCentroids[id].x += point.x;

newCentroids[id].y += point.y;

counts[id]++;

}

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

if (counts[i] > 0) {

newCentroids[i].x /= counts[i];

newCentroids[i].y /= counts[i];

}

centroids[i] = newCentroids[i];

}

double euclideanDistance(const Point& a, const Point& b) const {

return std::sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));

}

};

int main() {

std::vector<Point> points = {

{1.0, 2.0}, {1.5, 1.8}, {5.0, 8.0}, {8.0, 8.0},

{1.0, 0.6}, {9.0, 11.0}, {8.0, 2.0}, {10.0, 2.0},

{9.0, 3.0}

};

int k = 3; // Number of clusters

int maxIterations = 100;

KMeans kmeans(k, maxIterations);

kmeans.fit(points);

kmeans.printResults(points);

return 0;

}

Explanation Header Files: <iostream>: For input and output operations. <vector>: For storing and manipulating collections of Point objects. <cmath>: For mathematical functions like std::sqrt(). <limits>: To use std::numeric_limits for initializing the minimum distance. <cstdlib>: For random number generation. <ctime>: For seeding the random number generator. Point Struct: Represents a data point with x and …

Simulation of Data Mining Techniques Gaming Project in C++ Read More »

Simulation of Data Link Layer Protocols Gaming Project in C++

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

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

class Frame {
public:
    Frame(const std::string& data) : data(data) {
        checksum = calculateChecksum(data);
    }

    std::string getData() const { return data; }
    int getChecksum() const { return checksum; }

    bool isCorrupted() const {
        return calculateChecksum(data) != checksum;
    }

private:
    std::string data;
    int checksum;

    int calculateChecksum(const std::string& data) const {
        int sum = 0;
        for (char c : data) {
            sum += static_cast<int>(c);
        }
        return sum % 256; // Simple checksum (mod 256)
    }
};

class DataLinkLayer {
public:
    void sendFrame(const Frame& frame) {
        std::cout << "Sending frame with data: " << frame.getData() << std::endl;
        receivedFrame = frame;
    }

    void receiveFrame() {
        if (receivedFrame.isCorrupted()) {
            std::cout << "Error: Frame is corrupted." << std::endl;
        } else {
            std::cout << "Frame received successfully with data: " << receivedFrame.getData() << std::endl;
        }
    }

private:
    Frame receivedFrame{"default"};
};

int main() {
    std::srand(std::time(0));

    DataLinkLayer linkLayer;

    // Simulate sending a frame
    std::string data = "Hello, Data Link Layer!";
    Frame frame(data);
    linkLayer.sendFrame(frame);

    // Simulate potential corruption
    if (std::rand() % 2) {
        // Simulate corruption by altering data
        std::string corruptedData = data;
        corruptedData[0] = (corruptedData[0] == 'H') ? 'X' : 'H'; // Simple corruption example
        Frame corruptedFrame(corruptedData);
        linkLayer.sendFrame(corruptedFrame);
    }

    // Receive and check the frame
    linkLayer.receiveFrame();

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

#include <cstdlib>

#include <ctime>

class Frame {

public:

Frame(const std::string& data) : data(data) {

checksum = calculateChecksum(data);

}

std::string getData() const { return data; }

int getChecksum() const { return checksum; }

bool isCorrupted() const {

return calculateChecksum(data) != checksum;

}

private:

std::string data;

int checksum;

int calculateChecksum(const std::string& data) const {

int sum = 0;

for (char c : data) {

sum += static_cast<int>(c);

}

return sum % 256; // Simple checksum (mod 256)

}

};

class DataLinkLayer {

public:

void sendFrame(const Frame& frame) {

std::cout << "Sending frame with data: " << frame.getData() << std::endl;

receivedFrame = frame;

}

void receiveFrame() {

if (receivedFrame.isCorrupted()) {

std::cout << "Error: Frame is corrupted." << std::endl;

} else {

std::cout << "Frame received successfully with data: " << receivedFrame.getData() << std::endl;

}

private:

Frame receivedFrame{"default"};

};

int main() {

std::srand(std::time(0));

DataLinkLayer linkLayer;

// Simulate sending a frame

std::string data = "Hello, Data Link Layer!";

Frame frame(data);

linkLayer.sendFrame(frame);

// Simulate potential corruption

if (std::rand() % 2) {

// Simulate corruption by altering data

std::string corruptedData = data;

corruptedData[0] = (corruptedData[0] == 'H') ? 'X' : 'H'; // Simple corruption example

Frame corruptedFrame(corruptedData);

linkLayer.sendFrame(corruptedFrame);

}

// Receive and check the frame

linkLayer.receiveFrame();

return 0;

}

Explanation Header Files: <iostream>: For input and output operations. <vector>: Used here just for completeness in case of extension. <string>: To handle string operations. <cstdlib>: For functions like std::rand(). <ctime>: For seeding the random number generator. Frame Class: Constructor: Initializes a frame with data and calculates its checksum. getData(): Returns the data of the …

Simulation of Data Link Layer Protocols Gaming Project in C++ Read More »

Simulation of Data Analytics Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <numeric>
#include <algorithm>

class DataAnalytics {
public:
    DataAnalytics(int size) : dataSize(size) {
        // Initialize random number generator
        std::srand(std::time(0));
    }

    void generateData() {
        data.clear();
        for (int i = 0; i < dataSize; ++i) {
            data.push_back(std::rand() % 100 + 1); // Random data between 1 and 100
        }
    }

    void displayData() const {
        std::cout << "Generated Data: ";
        for (int value : data) {
            std::cout << value << " ";
        }
        std::cout << std::endl;
    }

    double calculateMean() const {
        double sum = std::accumulate(data.begin(), data.end(), 0.0);
        return sum / dataSize;
    }

    double calculateMedian() {
        std::vector<int> sortedData = data;
        std::sort(sortedData.begin(), sortedData.end());
        if (dataSize % 2 == 0) {
            return (sortedData[dataSize / 2 - 1] + sortedData[dataSize / 2]) / 2.0;
        } else {
            return sortedData[dataSize / 2];
        }
    }

    int calculateMode() {
        std::unordered_map<int, int> frequency;
        for (int value : data) {
            frequency[value]++;
        }

        int mode = data[0];
        int maxCount = 0;
        for (const auto& pair : frequency) {
            if (pair.second > maxCount) {
                maxCount = pair.second;
                mode = pair.first;
            }
        }
        return mode;
    }

private:
    int dataSize;
    std::vector<int> data;
};

int main() {
    const int dataSize = 10;
    DataAnalytics analytics(dataSize);

    analytics.generateData();
    analytics.displayData();

    std::cout << "Mean: " << analytics.calculateMean() << std::endl;
    std::cout << "Median: " << analytics.calculateMedian() << std::endl;
    std::cout << "Mode: " << analytics.calculateMode() << std::endl;

    return 0;
}

#include <iostream>

#include <vector>

#include <cstdlib>

#include <ctime>

#include <numeric>

#include <algorithm>

class DataAnalytics {

public:

DataAnalytics(int size) : dataSize(size) {

// Initialize random number generator

std::srand(std::time(0));

}

void generateData() {

data.clear();

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

data.push_back(std::rand() % 100 + 1); // Random data between 1 and 100

}

void displayData() const {

std::cout << "Generated Data: ";

for (int value : data) {

std::cout << value << " ";

}

std::cout << std::endl;

}

double calculateMean() const {

double sum = std::accumulate(data.begin(), data.end(), 0.0);

return sum / dataSize;

}

double calculateMedian() {

std::vector<int> sortedData = data;

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

if (dataSize % 2 == 0) {

return (sortedData[dataSize / 2 - 1] + sortedData[dataSize / 2]) / 2.0;

} else {

return sortedData[dataSize / 2];

}

int calculateMode() {

std::unordered_map<int, int> frequency;

for (int value : data) {

frequency[value]++;

}

int mode = data[0];

int maxCount = 0;

for (const auto& pair : frequency) {

if (pair.second > maxCount) {

maxCount = pair.second;

mode = pair.first;

}

return mode;

}

private:

int dataSize;

std::vector<int> data;

};

int main() {

const int dataSize = 10;

DataAnalytics analytics(dataSize);

analytics.generateData();

analytics.displayData();

std::cout << "Mean: " << analytics.calculateMean() << std::endl;

std::cout << "Median: " << analytics.calculateMedian() << std::endl;

std::cout << "Mode: " << analytics.calculateMode() << std::endl;

return 0;

}

Explanation Header Files: <iostream>: For input and output operations. <vector>: To use the std::vector container for storing data. <cstdlib>: For functions like std::rand() and std::srand(). <ctime>: For the std::time() function to seed the random number generator. <numeric>: For std::accumulate() used in calculating the mean. <algorithm>: For std::sort() used in sorting the data. DataAnalytics Class: …

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