C++ Projects – Page 5 – Projects Inventory

Simulation of Quality Control in Manufacturing Gaming Project in C++

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

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

// Function to simulate quality control check
int qualityControlCheck(int batchSize, double defectRate) {
    int defectiveCount = 0;

    // Simulate the quality check for each item
    for (int i = 0; i < batchSize; ++i) {
        // Randomly determine if an item is defective
        if (static_cast<double>(std::rand()) / RAND_MAX < defectRate) {
            ++defectiveCount;
        }
    }

    return defectiveCount;
}

int main() {
    // Seed the random number generator
    std::srand(static_cast<unsigned>(std::time(nullptr)));

    int batchSize;
    double defectRate;

    std::cout << "Enter the batch size: ";
    std::cin >> batchSize;

    std::cout << "Enter the defect rate (as a percentage, e.g., 0.05 for 5%): ";
    std::cin >> defectRate;

    // Ensure defectRate is between 0 and 1
    if (defectRate < 0 || defectRate > 1) {
        std::cerr << "Error: Defect rate must be between 0 and 1." << std::endl;
        return 1;
    }

    int defectiveCount = qualityControlCheck(batchSize, defectRate);

    std::cout << "Batch Size: " << batchSize << std::endl;
    std::cout << "Defect Rate: " << defectRate * 100 << "%" << std::endl;
    std::cout << "Number of Defective Items: " << defectiveCount << std::endl;
    std::cout << "Percentage of Defective Items: "
              << static_cast<double>(defectiveCount) / batchSize * 100 << "%" << std::endl;

    return 0;
}

#include <iostream>

#include <vector>

#include <cstdlib>

#include <ctime>

// Function to simulate quality control check

int qualityControlCheck(int batchSize, double defectRate) {

int defectiveCount = 0;

// Simulate the quality check for each item

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

// Randomly determine if an item is defective

if (static_cast<double>(std::rand()) / RAND_MAX < defectRate) {

++defectiveCount;

}

return defectiveCount;

}

int main() {

// Seed the random number generator

std::srand(static_cast<unsigned>(std::time(nullptr)));

int batchSize;

double defectRate;

std::cout << "Enter the batch size: ";

std::cin >> batchSize;

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

std::cin >> defectRate;

// Ensure defectRate is between 0 and 1

if (defectRate < 0 || defectRate > 1) {

std::cerr << "Error: Defect rate must be between 0 and 1." << std::endl;

return 1;

}

int defectiveCount = qualityControlCheck(batchSize, defectRate);

std::cout << "Batch Size: " << batchSize << std::endl;

std::cout << "Defect Rate: " << defectRate * 100 << "%" << std::endl;

std::cout << "Number of Defective Items: " << defectiveCount << std::endl;

std::cout << "Percentage of Defective Items: "

<< static_cast<double>(defectiveCount) / batchSize * 100 << "%" << std::endl;

return 0;

}

Explanation Function qualityControlCheck(int batchSize, double defectRate): Purpose: Simulates the quality control check for a batch of items. Parameters: batchSize: The number of items in the batch. defectRate: The probability of an item being defective. Implementation: Iterates through each item in the batch. Uses a random number to determine if an item is defective based …

Simulation of Quality Control in Manufacturing Gaming Project in C++ Read More »

Simulation of Quantum Computing Gaming Project in C++

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

#include <iostream>
#include <complex>
#include <iomanip>
#include <cstdlib>
#include <ctime>

const double PI = 3.141592653589793;

// A complex number type for quantum amplitudes
using Complex = std::complex<double>;

// Class to represent a Qubit
class Qubit {
public:
    Qubit(double theta) {
        // Initialize the qubit state with angles theta and phi
        alpha = std::cos(theta / 2);
        beta = std::sin(theta / 2) * std::exp(Complex(0, 2 * PI * std::rand() / RAND_MAX));
    }

    // Print the state of the qubit
    void printState() const {
        std::cout << "Qubit State: ";
        std::cout << std::fixed << std::setprecision(2)
                  << "|" << alpha << "|0> + " << beta << "|1>" << std::endl;
    }

    // Measure the qubit state
    int measure() const {
        // Compute probabilities
        double prob0 = std::norm(alpha);
        double prob1 = std::norm(beta);

        // Print probabilities
        std::cout << "Probability of |0>: " << prob0 << std::endl;
        std::cout << "Probability of |1>: " << prob1 << std::endl;

        // Randomly choose the measurement outcome based on probabilities
        double rand_val = static_cast<double>(std::rand()) / RAND_MAX;
        return rand_val < prob0 ? 0 : 1;
    }

private:
    Complex alpha; // Amplitude for |0>
    Complex beta;  // Amplitude for |1>
};

int main() {
    // Seed the random number generator
    std::srand(static_cast<unsigned>(std::time(nullptr)));

    double theta;
    std::cout << "Enter the angle theta (in radians) for the qubit state: ";
    std::cin >> theta;

    Qubit qubit(theta);
    qubit.printState();

    int measurement = qubit.measure();
    std::cout << "Measurement result: |" << measurement << ">" << std::endl;

    return 0;
}

#include <iostream>

#include <complex>

#include <iomanip>

#include <cstdlib>

#include <ctime>

const double PI = 3.141592653589793;

// A complex number type for quantum amplitudes

using Complex = std::complex<double>;

// Class to represent a Qubit

class Qubit {

public:

Qubit(double theta) {

// Initialize the qubit state with angles theta and phi

alpha = std::cos(theta / 2);

beta = std::sin(theta / 2) * std::exp(Complex(0, 2 * PI * std::rand() / RAND_MAX));

}

// Print the state of the qubit

void printState() const {

std::cout << "Qubit State: ";

std::cout << std::fixed << std::setprecision(2)

<< "|" << alpha << "|0> + " << beta << "|1>" << std::endl;

}

// Measure the qubit state

int measure() const {

// Compute probabilities

double prob0 = std::norm(alpha);

double prob1 = std::norm(beta);

// Print probabilities

std::cout << "Probability of |0>: " << prob0 << std::endl;

std::cout << "Probability of |1>: " << prob1 << std::endl;

// Randomly choose the measurement outcome based on probabilities

double rand_val = static_cast<double>(std::rand()) / RAND_MAX;

return rand_val < prob0 ? 0 : 1;

}

private:

Complex alpha; // Amplitude for |0>

Complex beta; // Amplitude for |1>

};

int main() {

// Seed the random number generator

std::srand(static_cast<unsigned>(std::time(nullptr)));

double theta;

std::cout << "Enter the angle theta (in radians) for the qubit state: ";

std::cin >> theta;

Qubit qubit(theta);

qubit.printState();

int measurement = qubit.measure();

std::cout << "Measurement result: |" << measurement << ">" << std::endl;

return 0;

}

Explanation Constants: PI: Mathematical constant π used for generating random angles. Type Alias: Complex: Alias for std::complex<double> to represent complex numbers for quantum amplitudes. Class Qubit: Purpose: Represents a quantum bit (qubit) and provides functionality to initialize, print its state, and measure it. Constructor Qubit(double theta): Initializes the qubit state with a given angle …

Simulation of Quantum Computing Gaming Project in C++ Read More »

Simulation of Quantum Tunneling Gaming Project in C++

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

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

// Constants
const double PI = 3.141592653589793;
const double HBAR = 1.0545718e-34; // Planck's constant over 2π (Js)
const double MASS = 9.10938356e-31; // Electron mass (kg)

// Function to compute the wave function at a given position
double waveFunction(double x, double potential, double energy, double width) {
    double k = sqrt(2 * MASS * energy) / HBAR;
    double kappa = sqrt(2 * MASS * (potential - energy)) / HBAR;

    if (x < 0 || x > width) {
        return 0.0;
    } else if (x <= width / 2) {
        return sin(k * x);
    } else {
        return exp(-kappa * (x - width / 2));
    }
}

// Function to simulate and print the quantum tunneling effect
void simulateQuantumTunneling(double potential, double energy, double width, int numPoints) {
    std::vector<double> positions(numPoints);
    std::vector<double> waveFunctions(numPoints);

    // Set up positions and compute wave functions
    double step = width / (numPoints - 1);
    for (int i = 0; i < numPoints; ++i) {
        positions[i] = i * step;
        waveFunctions[i] = waveFunction(positions[i], potential, energy, width);
    }

    // Print results
    std::cout << "Position\tWave Function\n";
    for (int i = 0; i < numPoints; ++i) {
        std::cout << std::fixed << std::setprecision(5) << positions[i] << "\t"
                  << std::fixed << std::setprecision(5) << waveFunctions[i] << "\n";
    }
}

int main() {
    double potential = 1.0e-18; // Potential barrier in Joules
    double energy = 1.5e-19; // Particle energy in Joules
    double width = 1e-10; // Width of the barrier in meters
    int numPoints = 100; // Number of points to simulate

    std::cout << "Quantum Tunneling Simulation\n";
    simulateQuantumTunneling(potential, energy, width, numPoints);

    return 0;
}

#include <iostream>

#include <vector>

#include <cmath>

#include <iomanip>

// Constants

const double PI = 3.141592653589793;

const double HBAR = 1.0545718e-34; // Planck's constant over 2π (Js)

const double MASS = 9.10938356e-31; // Electron mass (kg)

// Function to compute the wave function at a given position

double waveFunction(double x, double potential, double energy, double width) {

double k = sqrt(2 * MASS * energy) / HBAR;

double kappa = sqrt(2 * MASS * (potential - energy)) / HBAR;

if (x < 0 || x > width) {

return 0.0;

} else if (x <= width / 2) {

return sin(k * x);

} else {

return exp(-kappa * (x - width / 2));

}

// Function to simulate and print the quantum tunneling effect

void simulateQuantumTunneling(double potential, double energy, double width, int numPoints) {

std::vector<double> positions(numPoints);

std::vector<double> waveFunctions(numPoints);

// Set up positions and compute wave functions

double step = width / (numPoints - 1);

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

positions[i] = i * step;

waveFunctions[i] = waveFunction(positions[i], potential, energy, width);

}

// Print results

std::cout << "Position\tWave Function\n";

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

std::cout << std::fixed << std::setprecision(5) << positions[i] << "\t"

<< std::fixed << std::setprecision(5) << waveFunctions[i] << "\n";

}

int main() {

double potential = 1.0e-18; // Potential barrier in Joules

double energy = 1.5e-19; // Particle energy in Joules

double width = 1e-10; // Width of the barrier in meters

int numPoints = 100; // Number of points to simulate

std::cout << "Quantum Tunneling Simulation\n";

simulateQuantumTunneling(potential, energy, width, numPoints);

return 0;

}

Explanation Constants: PI: Mathematical constant π. HBAR: Reduced Planck’s constant (h/2π), crucial for quantum mechanics calculations. MASS: Mass of an electron (in kilograms), used for wave function calculations. Function waveFunction(double x, double potential, double energy, double width): Purpose: Computes the wave function of a particle given a potential barrier and energy. Parameters: x: Position …

Simulation of Quantum Tunneling Gaming Project in C++ Read More »

Simulation of RAID Levels Gaming Project in C++

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

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

enum RaidLevel { RAID0, RAID1, NUM_RAID_LEVELS };

class RAID {
public:
    virtual void writeData(const std::string& data) = 0;
    virtual std::string readData() const = 0;
    virtual ~RAID() = default;
};

class RAID0 : public RAID {
public:
    RAID0(int numDisks) : numDisks(numDisks) {
        disks.resize(numDisks);
    }

    void writeData(const std::string& data) override {
        for (int i = 0; i < numDisks; ++i) {
            disks[i] = data.substr(i * (data.size() / numDisks), data.size() / numDisks);
        }
    }

    std::string readData() const override {
        std::string result;
        for (const auto& disk : disks) {
            result += disk;
        }
        return result;
    }

private:
    int numDisks;
    std::vector<std::string> disks;
};

class RAID1 : public RAID {
public:
    RAID1(int numDisks) : numDisks(numDisks) {
        disks.resize(numDisks);
    }

    void writeData(const std::string& data) override {
        // Write to the first disk and mirror it to others
        disks[0] = data;
        for (int i = 1; i < numDisks; ++i) {
            disks[i] = disks[0];
        }
    }

    std::string readData() const override {
        // Data from the first disk (mirrored)
        return disks[0];
    }

private:
    int numDisks;
    std::vector<std::string> disks;
};

void simulateRaid(RaidLevel level, const std::string& data) {
    std::unique_ptr<RAID> raid;
    if (level == RAID0) {
        raid = std::make_unique<RAID0>(2); // Example with 2 disks
    } else if (level == RAID1) {
        raid = std::make_unique<RAID1>(2); // Example with 2 disks
    }

    if (raid) {
        raid->writeData(data);
        std::cout << "Read data from RAID level " << level << ": " << raid->readData() << "\n";
    }
}

int main() {
    std::string data = "This is sample data for RAID simulation.";

    std::cout << "Simulating RAID 0:\n";
    simulateRaid(RAID0, data);

    std::cout << "Simulating RAID 1:\n";
    simulateRaid(RAID1, data);

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

enum RaidLevel { RAID0, RAID1, NUM_RAID_LEVELS };

class RAID {

public:

virtual void writeData(const std::string& data) = 0;

virtual std::string readData() const = 0;

virtual ~RAID() = default;

};

class RAID0 : public RAID {

public:

RAID0(int numDisks) : numDisks(numDisks) {

disks.resize(numDisks);

}

void writeData(const std::string& data) override {

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

disks[i] = data.substr(i * (data.size() / numDisks), data.size() / numDisks);

}

std::string readData() const override {

std::string result;

for (const auto& disk : disks) {

result += disk;

}

return result;

}

private:

int numDisks;

std::vector<std::string> disks;

};

class RAID1 : public RAID {

public:

RAID1(int numDisks) : numDisks(numDisks) {

disks.resize(numDisks);

}

void writeData(const std::string& data) override {

// Write to the first disk and mirror it to others

disks[0] = data;

for (int i = 1; i < numDisks; ++i) {

disks[i] = disks[0];

}

std::string readData() const override {

// Data from the first disk (mirrored)

return disks[0];

}

private:

int numDisks;

std::vector<std::string> disks;

};

void simulateRaid(RaidLevel level, const std::string& data) {

std::unique_ptr<RAID> raid;

if (level == RAID0) {

raid = std::make_unique<RAID0>(2); // Example with 2 disks

} else if (level == RAID1) {

raid = std::make_unique<RAID1>(2); // Example with 2 disks

}

if (raid) {

raid->writeData(data);

std::cout << "Read data from RAID level " << level << ": " << raid->readData() << "\n";

}

int main() {

std::string data = "This is sample data for RAID simulation.";

std::cout << "Simulating RAID 0:\n";

simulateRaid(RAID0, data);

std::cout << "Simulating RAID 1:\n";

simulateRaid(RAID1, data);

return 0;

}

Explanation Enums: RaidLevel: Enum representing different RAID levels (RAID 0, RAID 1). Class RAID: Purpose: Abstract base class for RAID implementations. Methods: writeData(const std::string& data): Pure virtual method for writing data. readData() const: Pure virtual method for reading data. Destructor: Virtual destructor to ensure proper cleanup of derived classes. Class RAID0: Purpose: Implements RAID …

Simulation of RAID Levels Gaming Project in C++ Read More »

Simulation of Random Walks Gaming Project in C++

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

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

// Directions for movement: right, left, up, down
enum Direction { RIGHT, LEFT, UP, DOWN, NUM_DIRECTIONS };

struct Position {
    int x, y;
};

// Function to get a random direction
Direction getRandomDirection() {
    return static_cast<Direction>(std::rand() % NUM_DIRECTIONS);
}

// Function to update the position based on direction
void move(Position& pos, Direction dir) {
    switch (dir) {
        case RIGHT: pos.x += 1; break;
        case LEFT: pos.x -= 1; break;
        case UP: pos.y -= 1; break;
        case DOWN: pos.y += 1; break;
    }
}

int main() {
    const int GRID_SIZE = 10; // Size of the grid
    const int NUM_STEPS = 50; // Number of steps to simulate

    // Initialize the random number generator
    std::srand(static_cast<unsigned>(std::time(nullptr)));

    Position agentPos = {GRID_SIZE / 2, GRID_SIZE / 2}; // Start position at the center

    std::vector<std::vector<char>> grid(GRID_SIZE, std::vector<char>(GRID_SIZE, '.'));

    for (int step = 0; step < NUM_STEPS; ++step) {
        // Mark the current position
        if (agentPos.x >= 0 && agentPos.x < GRID_SIZE && agentPos.y >= 0 && agentPos.y < GRID_SIZE) {
            grid[agentPos.y][agentPos.x] = '*';
        }

        // Get a random direction and move the agent
        Direction dir = getRandomDirection();
        move(agentPos, dir);

        // Keep the agent within the grid boundaries
        if (agentPos.x < 0) agentPos.x = 0;
        if (agentPos.x >= GRID_SIZE) agentPos.x = GRID_SIZE - 1;
        if (agentPos.y < 0) agentPos.y = 0;
        if (agentPos.y >= GRID_SIZE) agentPos.y = GRID_SIZE - 1;
    }

    // Display the grid
    std::cout << "Random Walk Simulation:\n";
    for (int y = 0; y < GRID_SIZE; ++y) {
        for (int x = 0; x < GRID_SIZE; ++x) {
            std::cout << grid[y][x] << ' ';
        }
        std::cout << '\n';
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <cstdlib>

#include <ctime>

// Directions for movement: right, left, up, down

enum Direction { RIGHT, LEFT, UP, DOWN, NUM_DIRECTIONS };

struct Position {

int x, y;

};

// Function to get a random direction

Direction getRandomDirection() {

return static_cast<Direction>(std::rand() % NUM_DIRECTIONS);

}

// Function to update the position based on direction

void move(Position& pos, Direction dir) {

switch (dir) {

case RIGHT: pos.x += 1; break;

case LEFT: pos.x -= 1; break;

case UP: pos.y -= 1; break;

case DOWN: pos.y += 1; break;

}

int main() {

const int GRID_SIZE = 10; // Size of the grid

const int NUM_STEPS = 50; // Number of steps to simulate

// Initialize the random number generator

std::srand(static_cast<unsigned>(std::time(nullptr)));

Position agentPos = {GRID_SIZE / 2, GRID_SIZE / 2}; // Start position at the center

std::vector<std::vector<char>> grid(GRID_SIZE, std::vector<char>(GRID_SIZE, '.'));

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

// Mark the current position

if (agentPos.x >= 0 && agentPos.x < GRID_SIZE && agentPos.y >= 0 && agentPos.y < GRID_SIZE) {

grid[agentPos.y][agentPos.x] = '*';

}

// Get a random direction and move the agent

Direction dir = getRandomDirection();

move(agentPos, dir);

// Keep the agent within the grid boundaries

if (agentPos.x < 0) agentPos.x = 0;

if (agentPos.x >= GRID_SIZE) agentPos.x = GRID_SIZE - 1;

if (agentPos.y < 0) agentPos.y = 0;

if (agentPos.y >= GRID_SIZE) agentPos.y = GRID_SIZE - 1;

}

// Display the grid

std::cout << "Random Walk Simulation:\n";

for (int y = 0; y < GRID_SIZE; ++y) {

for (int x = 0; x < GRID_SIZE; ++x) {

std::cout << grid[y][x] << ' ';

}

std::cout << '\n';

}

return 0;

}

Explanation Constants: GRID_SIZE: Size of the grid (10×10). NUM_STEPS: Number of steps to simulate in the random walk. Enums and Structs: Direction: Enum representing possible movement directions (right, left, up, down). Position: Struct to represent the agent’s position in the grid. Function getRandomDirection(): Purpose: Returns a random direction for movement. Implementation: Uses std::rand() to …

Simulation of Random Walks Gaming Project in C++ Read More »

Simulation of Recommendation Systems Gaming Project in C++

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

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

const int NUM_USERS = 5;
const int NUM_ITEMS = 4;

// Function to compute the similarity between two users using cosine similarity
double computeSimilarity(const std::vector<double>& user1, const std::vector<double>& user2) {
    double dotProduct = 0.0;
    double norm1 = 0.0;
    double norm2 = 0.0;

    for (int i = 0; i < NUM_ITEMS; ++i) {
        dotProduct += user1[i] * user2[i];
        norm1 += user1[i] * user1[i];
        norm2 += user2[i] * user2[i];
    }

    norm1 = std::sqrt(norm1);
    norm2 = std::sqrt(norm2);

    if (norm1 == 0.0 || norm2 == 0.0) {
        return 0.0;
    }

    return dotProduct / (norm1 * norm2);
}

// Function to recommend items for a user based on similarities with other users
void recommendItems(const std::vector<std::vector<double>>& ratings, int targetUser) {
    std::vector<double> userRatings = ratings[targetUser];
    std::vector<double> itemScores(NUM_ITEMS, 0.0);
    std::vector<double> totalSimilarities(NUM_ITEMS, 0.0);

    for (int i = 0; i < NUM_USERS; ++i) {
        if (i == targetUser) continue;

        double similarity = computeSimilarity(ratings[targetUser], ratings[i]);

        for (int j = 0; j < NUM_ITEMS; ++j) {
            if (ratings[i][j] > 0) {
                itemScores[j] += similarity * ratings[i][j];
                totalSimilarities[j] += similarity;
            }
        }
    }

    std::cout << "Recommendations for User " << targetUser + 1 << ":\n";
    for (int i = 0; i < NUM_ITEMS; ++i) {
        if (userRatings[i] == 0) { // Only recommend items not yet rated by the user
            double predictedRating = (totalSimilarities[i] > 0) ? itemScores[i] / totalSimilarities[i] : 0.0;
            std::cout << "Item " << i + 1 << ": " << std::fixed << std::setprecision(2) << predictedRating << "\n";
        }
    }
}

int main() {
    // Example ratings matrix (users x items)
    std::vector<std::vector<double>> ratings = {
        {4, 0, 0, 2},
        {0, 5, 0, 0},
        {3, 0, 0, 0},
        {0, 0, 4, 0},
        {5, 0, 0, 0}
    };

    int targetUser;
    std::cout << "Enter the user number (1-" << NUM_USERS << ") for recommendations: ";
    std::cin >> targetUser;

    if (targetUser < 1 || targetUser > NUM_USERS) {
        std::cerr << "Invalid user number.\n";
        return 1;
    }

    recommendItems(ratings, targetUser - 1);

    return 0;
}

#include <iostream>

#include <vector>

#include <cmath>

#include <iomanip>

const int NUM_USERS = 5;

const int NUM_ITEMS = 4;

// Function to compute the similarity between two users using cosine similarity

double computeSimilarity(const std::vector<double>& user1, const std::vector<double>& user2) {

double dotProduct = 0.0;

double norm1 = 0.0;

double norm2 = 0.0;

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

dotProduct += user1[i] * user2[i];

norm1 += user1[i] * user1[i];

norm2 += user2[i] * user2[i];

}

norm1 = std::sqrt(norm1);

norm2 = std::sqrt(norm2);

if (norm1 == 0.0 || norm2 == 0.0) {

return 0.0;

}

return dotProduct / (norm1 * norm2);

}

// Function to recommend items for a user based on similarities with other users

void recommendItems(const std::vector<std::vector<double>>& ratings, int targetUser) {

std::vector<double> userRatings = ratings[targetUser];

std::vector<double> itemScores(NUM_ITEMS, 0.0);

std::vector<double> totalSimilarities(NUM_ITEMS, 0.0);

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

if (i == targetUser) continue;

double similarity = computeSimilarity(ratings[targetUser], ratings[i]);

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

if (ratings[i][j] > 0) {

itemScores[j] += similarity * ratings[i][j];

totalSimilarities[j] += similarity;

}

std::cout << "Recommendations for User " << targetUser + 1 << ":\n";

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

if (userRatings[i] == 0) { // Only recommend items not yet rated by the user

double predictedRating = (totalSimilarities[i] > 0) ? itemScores[i] / totalSimilarities[i] : 0.0;

std::cout << "Item " << i + 1 << ": " << std::fixed << std::setprecision(2) << predictedRating << "\n";

}

int main() {

// Example ratings matrix (users x items)

std::vector<std::vector<double>> ratings = {

{4, 0, 0, 2},

{0, 5, 0, 0},

{3, 0, 0, 0},

{0, 0, 4, 0},

{5, 0, 0, 0}

};

int targetUser;

std::cout << "Enter the user number (1-" << NUM_USERS << ") for recommendations: ";

std::cin >> targetUser;

if (targetUser < 1 || targetUser > NUM_USERS) {

std::cerr << "Invalid user number.\n";

return 1;

}

recommendItems(ratings, targetUser - 1);

return 0;

}

Explanation Constants: NUM_USERS: Number of users in the system. NUM_ITEMS: Number of items available for rating. Function computeSimilarity(const std::vector<double>& user1, const std::vector<double>& user2): Purpose: Computes the cosine similarity between two users based on their item ratings. Parameters: user1, user2: Vectors of ratings for two different users. Implementation: Computes the dot product and norms of …

Simulation of Recommendation Systems Gaming Project in C++ Read More »

Simulation of Reinforcement Learning Gaming Project in C++

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

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

const int GRID_SIZE = 5;
const double ALPHA = 0.1;  // Learning rate
const double GAMMA = 0.9;  // Discount factor
const double EPSILON = 0.1; // Exploration rate
const int NUM_EPISODES = 1000;

enum Actions { UP, DOWN, LEFT, RIGHT, NUM_ACTIONS };

struct State {
    int x, y;
};

class QLearningAgent {
public:
    QLearningAgent() {
        // Initialize Q-table with zeros
        qTable.resize(GRID_SIZE * GRID_SIZE, std::vector<double>(NUM_ACTIONS, 0.0));
        std::srand(static_cast<unsigned>(std::time(nullptr)));
    }

    // Choose action based on epsilon-greedy policy
    int chooseAction(const State& state) {
        if (static_cast<double>(std::rand()) / RAND_MAX < EPSILON) {
            // Explore: choose a random action
            return std::rand() % NUM_ACTIONS;
        } else {
            // Exploit: choose the best action based on Q-table
            int stateIndex = getStateIndex(state);
            double maxQ = qTable[stateIndex][0];
            int bestAction = 0;
            for (int a = 1; a < NUM_ACTIONS; ++a) {
                if (qTable[stateIndex][a] > maxQ) {
                    maxQ = qTable[stateIndex][a];
                    bestAction = a;
                }
            }
            return bestAction;
        }
    }

    // Update Q-table based on the agent's experience
    void updateQTable(const State& state, int action, double reward, const State& nextState) {
        int stateIndex = getStateIndex(state);
        int nextStateIndex = getStateIndex(nextState);
        double maxNextQ = *std::max_element(qTable[nextStateIndex].begin(), qTable[nextStateIndex].end());
        qTable[stateIndex][action] += ALPHA * (reward + GAMMA * maxNextQ - qTable[stateIndex][action]);
    }

private:
    // Convert state to a unique index
    int getStateIndex(const State& state) const {
        return state.y * GRID_SIZE + state.x;
    }

    std::vector<std::vector<double>> qTable;
};

void printGrid(const State& agentPos, const State& goalPos) {
    for (int y = 0; y < GRID_SIZE; ++y) {
        for (int x = 0; x < GRID_SIZE; ++x) {
            if (x == agentPos.x && y == agentPos.y) {
                std::cout << "A ";
            } else if (x == goalPos.x && y == goalPos.y) {
                std::cout << "G ";
            } else {
                std::cout << ". ";
            }
        }
        std::cout << "\n";
    }
}

int main() {
    QLearningAgent agent;
    State goalPos = {GRID_SIZE - 1, GRID_SIZE - 1};
    double reward = 10.0;
    double stepReward = -1.0;

    for (int episode = 0; episode < NUM_EPISODES; ++episode) {
        State agentPos = {0, 0}; // Start position

        while (agentPos.x != goalPos.x || agentPos.y != goalPos.y) {
            int action = agent.chooseAction(agentPos);

            // Move the agent based on the action
            State nextPos = agentPos;
            switch (action) {
                case UP:    if (nextPos.y > 0) --nextPos.y; break;
                case DOWN:  if (nextPos.y < GRID_SIZE - 1) ++nextPos.y; break;
                case LEFT:  if (nextPos.x > 0) --nextPos.x; break;
                case RIGHT: if (nextPos.x < GRID_SIZE - 1) ++nextPos.x; break;
            }

            double rewardValue = (nextPos.x == goalPos.x && nextPos.y == goalPos.y) ? reward : stepReward;
            agent.updateQTable(agentPos, action, rewardValue, nextPos);

            agentPos = nextPos;
        }
    }

    std::cout << "Trained Q-table:\n";
    for (int y = 0; y < GRID_SIZE; ++y) {
        for (int x = 0; x < GRID_SIZE; ++x) {
            std::cout << std::fixed << std::setprecision(2) << agent.qTable[y * GRID_SIZE + x][UP] << " ";
        }
        std::cout << "\n";
    }

    std::cout << "Final grid:\n";
    printGrid({GRID_SIZE - 1, GRID_SIZE - 1}, goalPos);

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

#include <iostream>

#include <vector>

#include <cstdlib>

#include <ctime>

#include <iomanip>

const int GRID_SIZE = 5;

const double ALPHA = 0.1; // Learning rate

const double GAMMA = 0.9; // Discount factor

const double EPSILON = 0.1; // Exploration rate

const int NUM_EPISODES = 1000;

enum Actions { UP, DOWN, LEFT, RIGHT, NUM_ACTIONS };

struct State {

int x, y;

};

class QLearningAgent {

public:

QLearningAgent() {

// Initialize Q-table with zeros

qTable.resize(GRID_SIZE * GRID_SIZE, std::vector<double>(NUM_ACTIONS, 0.0));

std::srand(static_cast<unsigned>(std::time(nullptr)));

}

// Choose action based on epsilon-greedy policy

int chooseAction(const State& state) {

if (static_cast<double>(std::rand()) / RAND_MAX < EPSILON) {

// Explore: choose a random action

return std::rand() % NUM_ACTIONS;

} else {

// Exploit: choose the best action based on Q-table

int stateIndex = getStateIndex(state);

double maxQ = qTable[stateIndex][0];

int bestAction = 0;

for (int a = 1; a < NUM_ACTIONS; ++a) {

if (qTable[stateIndex][a] > maxQ) {

maxQ = qTable[stateIndex][a];

bestAction = a;

}

return bestAction;

}

// Update Q-table based on the agent's experience

void updateQTable(const State& state, int action, double reward, const State& nextState) {

int stateIndex = getStateIndex(state);

int nextStateIndex = getStateIndex(nextState);

double maxNextQ = *std::max_element(qTable[nextStateIndex].begin(), qTable[nextStateIndex].end());

qTable[stateIndex][action] += ALPHA * (reward + GAMMA * maxNextQ - qTable[stateIndex][action]);

}

private:

// Convert state to a unique index

int getStateIndex(const State& state) const {

return state.y * GRID_SIZE + state.x;

}

std::vector<std::vector<double>> qTable;

};

void printGrid(const State& agentPos, const State& goalPos) {

for (int y = 0; y < GRID_SIZE; ++y) {

for (int x = 0; x < GRID_SIZE; ++x) {

if (x == agentPos.x && y == agentPos.y) {

std::cout << "A ";

} else if (x == goalPos.x && y == goalPos.y) {

std::cout << "G ";

} else {

std::cout << ". ";

}

std::cout << "\n";

}

int main() {

QLearningAgent agent;

State goalPos = {GRID_SIZE - 1, GRID_SIZE - 1};

double reward = 10.0;

double stepReward = -1.0;

for (int episode = 0; episode < NUM_EPISODES; ++episode) {

State agentPos = {0, 0}; // Start position

while (agentPos.x != goalPos.x || agentPos.y != goalPos.y) {

int action = agent.chooseAction(agentPos);

// Move the agent based on the action

State nextPos = agentPos;

switch (action) {

case UP: if (nextPos.y > 0) --nextPos.y; break;

case DOWN: if (nextPos.y < GRID_SIZE - 1) ++nextPos.y; break;

case LEFT: if (nextPos.x > 0) --nextPos.x; break;

case RIGHT: if (nextPos.x < GRID_SIZE - 1) ++nextPos.x; break;

}

double rewardValue = (nextPos.x == goalPos.x && nextPos.y == goalPos.y) ? reward : stepReward;

agent.updateQTable(agentPos, action, rewardValue, nextPos);

agentPos = nextPos;

}

std::cout << "Trained Q-table:\n";

for (int y = 0; y < GRID_SIZE; ++y) {

for (int x = 0; x < GRID_SIZE; ++x) {

std::cout << std::fixed << std::setprecision(2) << agent.qTable[y * GRID_SIZE + x][UP] << " ";

}

std::cout << "\n";

}

std::cout << "Final grid:\n";

printGrid({GRID_SIZE - 1, GRID_SIZE - 1}, goalPos);

return 0;

}

Explanation Constants: GRID_SIZE: Size of the grid (5×5). ALPHA: Learning rate, which controls how much new information overrides old information. GAMMA: Discount factor, which models the importance of future rewards. EPSILON: Exploration rate for the epsilon-greedy policy. NUM_EPISODES: Number of training episodes for the Q-learning algorithm. Class QLearningAgent: Attributes: qTable: A 2D vector representing …

Simulation of Reinforcement Learning Gaming Project in C++ Read More »

Simulation of Risk Management Gaming Project in C++

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

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

// Function to calculate Value at Risk (VaR)
double calculateVaR(double meanReturn, double volatility, double confidenceLevel, double investmentAmount) {
    // Z-score for the given confidence level
    double zScore = 0.0;
    if (confidenceLevel == 0.95) {
        zScore = 1.645; // Approximate Z-score for 95% confidence level
    } else if (confidenceLevel == 0.99) {
        zScore = 2.33; // Approximate Z-score for 99% confidence level
    } else {
        std::cerr << "Confidence level must be 0.95 or 0.99.\n";
        return -1.0;
    }

    // Calculate Value at Risk (VaR)
    double VaR = investmentAmount * (meanReturn - zScore * volatility);
    return VaR;
}

int main() {
    double meanReturn, volatility, confidenceLevel, investmentAmount;

    std::cout << "Enter the expected mean return (as a decimal, e.g., 0.08 for 8%): ";
    std::cin >> meanReturn;
    std::cout << "Enter the annual volatility (standard deviation) of the investment: ";
    std::cin >> volatility;
    std::cout << "Enter the confidence level (0.95 or 0.99): ";
    std::cin >> confidenceLevel;
    std::cout << "Enter the investment amount: ";
    std::cin >> investmentAmount;

    double VaR = calculateVaR(meanReturn, volatility, confidenceLevel, investmentAmount);

    if (VaR != -1.0) {
        std::cout << std::fixed << std::setprecision(2);
        std::cout << "Value at Risk (VaR) for the investment: $" << VaR << "\n";
        std::cout << "This represents the potential loss at the " << (confidenceLevel * 100) << "% confidence level.\n";
    }

    return 0;
}

#include <iostream>

#include <iomanip>

#include <cmath>

// Function to calculate Value at Risk (VaR)

double calculateVaR(double meanReturn, double volatility, double confidenceLevel, double investmentAmount) {

// Z-score for the given confidence level

double zScore = 0.0;

if (confidenceLevel == 0.95) {

zScore = 1.645; // Approximate Z-score for 95% confidence level

} else if (confidenceLevel == 0.99) {

zScore = 2.33; // Approximate Z-score for 99% confidence level

} else {

std::cerr << "Confidence level must be 0.95 or 0.99.\n";

return -1.0;

}

// Calculate Value at Risk (VaR)

double VaR = investmentAmount * (meanReturn - zScore * volatility);

return VaR;

}

int main() {

double meanReturn, volatility, confidenceLevel, investmentAmount;

std::cout << "Enter the expected mean return (as a decimal, e.g., 0.08 for 8%): ";

std::cin >> meanReturn;

std::cout << "Enter the annual volatility (standard deviation) of the investment: ";

std::cin >> volatility;

std::cout << "Enter the confidence level (0.95 or 0.99): ";

std::cin >> confidenceLevel;

std::cout << "Enter the investment amount: ";

std::cin >> investmentAmount;

double VaR = calculateVaR(meanReturn, volatility, confidenceLevel, investmentAmount);

if (VaR != -1.0) {

std::cout << std::fixed << std::setprecision(2);

std::cout << "Value at Risk (VaR) for the investment: $" << VaR << "\n";

std::cout << "This represents the potential loss at the " << (confidenceLevel * 100) << "% confidence level.\n";

}

return 0;

}

Explanation Function calculateVaR(double meanReturn, double volatility, double confidenceLevel, double investmentAmount): Purpose: Computes the Value at Risk (VaR) for an investment, which estimates the potential loss at a given confidence level. Parameters: meanReturn: Expected mean return of the investment (as a decimal). volatility: Annual volatility (standard deviation) of the investment. confidenceLevel: Confidence level for the …

Simulation of Risk Management Gaming Project in C++ Read More »

Simulation of RLC Circuit Gaming Project in C++

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

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

const double PI = 3.141592653589793;

// Function to calculate impedance of RLC circuit
double calculateImpedance(double R, double L, double C, double f) {
    double omega = 2 * PI * f; // Angular frequency
    double XL = omega * L;     // Inductive reactance
    double XC = 1 / (omega * C); // Capacitive reactance
    return std::sqrt(R * R + (XL - XC) * (XL - XC)); // Impedance
}

// Function to calculate voltage across R, L, and C
void calculateVoltages(double R, double L, double C, double f, double Vsource, double& VR, double& VL, double& VC) {
    double omega = 2 * PI * f; // Angular frequency
    double XL = omega * L;     // Inductive reactance
    double XC = 1 / (omega * C); // Capacitive reactance
    double Z = calculateImpedance(R, L, C, f); // Impedance

    // Voltage across R
    VR = (R / Z) * Vsource;
    // Voltage across L
    VL = ((XL) / Z) * Vsource;
    // Voltage across C
    VC = ((XC) / Z) * Vsource;
}

int main() {
    // Circuit parameters
    double R, L, C, f, Vsource;
    
    // User input
    std::cout << "Enter the resistance (R) in ohms: ";
    std::cin >> R;
    std::cout << "Enter the inductance (L) in henries: ";
    std::cin >> L;
    std::cout << "Enter the capacitance (C) in farads: ";
    std::cin >> C;
    std::cout << "Enter the frequency (f) in hertz: ";
    std::cin >> f;
    std::cout << "Enter the source voltage (V) in volts: ";
    std::cin >> Vsource;

    double VR, VL, VC;
    calculateVoltages(R, L, C, f, Vsource, VR, VL, VC);

    std::cout << std::fixed << std::setprecision(2);
    std::cout << "Impedance of the RLC circuit: " << calculateImpedance(R, L, C, f) << " ohms\n";
    std::cout << "Voltage across the resistor (VR): " << VR << " volts\n";
    std::cout << "Voltage across the inductor (VL): " << VL << " volts\n";
    std::cout << "Voltage across the capacitor (VC): " << VC << " volts\n";

    return 0;
}

#include <iostream>

#include <cmath>

#include <iomanip>

const double PI = 3.141592653589793;

// Function to calculate impedance of RLC circuit

double calculateImpedance(double R, double L, double C, double f) {

double omega = 2 * PI * f; // Angular frequency

double XL = omega * L; // Inductive reactance

double XC = 1 / (omega * C); // Capacitive reactance

return std::sqrt(R * R + (XL - XC) * (XL - XC)); // Impedance

}

// Function to calculate voltage across R, L, and C

void calculateVoltages(double R, double L, double C, double f, double Vsource, double& VR, double& VL, double& VC) {

double omega = 2 * PI * f; // Angular frequency

double XL = omega * L; // Inductive reactance

double XC = 1 / (omega * C); // Capacitive reactance

double Z = calculateImpedance(R, L, C, f); // Impedance

// Voltage across R

VR = (R / Z) * Vsource;

// Voltage across L

VL = ((XL) / Z) * Vsource;

// Voltage across C

VC = ((XC) / Z) * Vsource;

}

int main() {

// Circuit parameters

double R, L, C, f, Vsource;

// User input

std::cout << "Enter the resistance (R) in ohms: ";

std::cin >> R;

std::cout << "Enter the inductance (L) in henries: ";

std::cin >> L;

std::cout << "Enter the capacitance (C) in farads: ";

std::cin >> C;

std::cout << "Enter the frequency (f) in hertz: ";

std::cin >> f;

std::cout << "Enter the source voltage (V) in volts: ";

std::cin >> Vsource;

double VR, VL, VC;

calculateVoltages(R, L, C, f, Vsource, VR, VL, VC);

std::cout << std::fixed << std::setprecision(2);

std::cout << "Impedance of the RLC circuit: " << calculateImpedance(R, L, C, f) << " ohms\n";

std::cout << "Voltage across the resistor (VR): " << VR << " volts\n";

std::cout << "Voltage across the inductor (VL): " << VL << " volts\n";

std::cout << "Voltage across the capacitor (VC): " << VC << " volts\n";

return 0;

}

Explanation Constants: PI: Mathematical constant π. Function calculateImpedance(double R, double L, double C, double f): Purpose: Computes the total impedance of the series RLC circuit. Parameters: R: Resistance in ohms. L: Inductance in henries. C: Capacitance in farads. f: Frequency in hertz. Implementation: Angular Frequency: omega = 2 * PI * f. Inductive Reactance: …

Simulation of RLC Circuit Gaming Project in C++ Read More »

Simulation of Robot Arm Movement Gaming Project in C++

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

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

const double PI = 3.141592653589793;
const double DEG_TO_RAD = PI / 180.0;

// Function to calculate the position of the end-effector
void calculateEndEffectorPosition(double angle1, double angle2, double length1, double length2, double& x, double& y) {
    // Convert angles from degrees to radians
    double rad1 = angle1 * DEG_TO_RAD;
    double rad2 = angle2 * DEG_TO_RAD;
    
    // Calculate the position of the end-effector
    x = length1 * std::cos(rad1) + length2 * std::cos(rad1 + rad2);
    y = length1 * std::sin(rad1) + length2 * std::sin(rad1 + rad2);
}

int main() {
    // Arm segment lengths
    double length1 = 10.0; // Length of the first segment
    double length2 = 10.0; // Length of the second segment

    // Angles in degrees
    double angle1, angle2;

    std::cout << "Enter the angles for the robot arm (in degrees):\n";
    std::cout << "Angle 1: ";
    std::cin >> angle1;
    std::cout << "Angle 2: ";
    std::cin >> angle2;

    double x, y;
    calculateEndEffectorPosition(angle1, angle2, length1, length2, x, y);

    std::cout << std::fixed << std::setprecision(2);
    std::cout << "End-Effector Position: (" << x << ", " << y << ")\n";

    return 0;
}

#include <iostream>

#include <cmath>

#include <iomanip>

const double PI = 3.141592653589793;

const double DEG_TO_RAD = PI / 180.0;

// Function to calculate the position of the end-effector

void calculateEndEffectorPosition(double angle1, double angle2, double length1, double length2, double& x, double& y) {

// Convert angles from degrees to radians

double rad1 = angle1 * DEG_TO_RAD;

double rad2 = angle2 * DEG_TO_RAD;

// Calculate the position of the end-effector

x = length1 * std::cos(rad1) + length2 * std::cos(rad1 + rad2);

y = length1 * std::sin(rad1) + length2 * std::sin(rad1 + rad2);

}

int main() {

// Arm segment lengths

double length1 = 10.0; // Length of the first segment

double length2 = 10.0; // Length of the second segment

// Angles in degrees

double angle1, angle2;

std::cout << "Enter the angles for the robot arm (in degrees):\n";

std::cout << "Angle 1: ";

std::cin >> angle1;

std::cout << "Angle 2: ";

std::cin >> angle2;

double x, y;

calculateEndEffectorPosition(angle1, angle2, length1, length2, x, y);

std::cout << std::fixed << std::setprecision(2);

std::cout << "End-Effector Position: (" << x << ", " << y << ")\n";

return 0;

}

Explanation Constants: PI: Mathematical constant π. DEG_TO_RAD: Conversion factor from degrees to radians. Function calculateEndEffectorPosition(double angle1, double angle2, double length1, double length2, double& x, double& y): Purpose: Calculates the position of the end-effector (tip) of the robot arm based on joint angles and segment lengths. Parameters: angle1, angle2: Angles of the two joints in …

Simulation of Robot Arm Movement Gaming Project in C++ Read More »