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

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 »

Functional requirements of Smart Home Security System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements User Authentication and Authorization Secure registration, login, and account management for homeowners, family members, and authorized users. Role-based access controls to manage permissions for system features. Real-Time Surveillance Provide live video feeds from indoor and outdoor security cameras. Allow users to view camera feeds remotely via a web or mobile application. Intrusion Detection …

Functional requirements of Smart Home Security System with non-functional 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 »

Functional requirements of Smart Health Monitoring System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements User Authentication and Authorization Secure registration, login, and account management for patients, healthcare providers, and administrators. Role-based access control to ensure appropriate permissions for viewing and managing health data. Real-Time Health Data Monitoring Monitor vital signs such as heart rate, blood pressure, temperature, and glucose levels using wearable devices or sensors. Provide real-time …

Functional requirements of Smart Health Monitoring System with non-functional Read More »

Functional requirements of Smart Garbage Monitoring System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements User Authentication and Authorization Allow users (e.g., waste management staff, administrators) to register, log in, and manage their accounts securely. Provide role-based access controls to ensure appropriate permissions. Real-Time Garbage Monitoring Monitor the fill level of garbage bins in real-time using sensors (e.g., ultrasonic, weight sensors). Provide data on bin status, including fullness, …

Functional requirements of Smart Garbage Monitoring System with non-functional Read More »

Functional requirements of Smart Farming System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements User Authentication and Authorization Allow farmers, agronomists, and administrators to register, log in, and manage their accounts securely. Different access levels based on user roles (e.g., farmer, consultant, admin). Farm Monitoring and Management Provide real-time monitoring of farm conditions such as soil moisture, temperature, humidity, and light levels. Support for monitoring various farm …

Functional requirements of Smart Farming System with non-functional Read More »

Functional requirements of Smart Energy Management System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements User Authentication and Authorization Allow users to register, log in, and manage their accounts with secure authentication. Different access levels for users (e.g., home users, facility managers, administrators). Energy Consumption Monitoring Provide real-time monitoring of energy consumption across various devices and systems. Display detailed energy usage statistics and historical data. Energy Usage Analytics …

Functional requirements of Smart Energy Management System with non-functional 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 »

Functional requirements of Smart Classroom System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements User Authentication and Authorization Allow students, teachers, and administrators to register, log in, and manage their accounts. Different access levels based on user roles (e.g., teacher, student, admin). Classroom Management Create, manage, and schedule classes, including virtual and physical classrooms. Support for different types of sessions (e.g., lectures, group discussions). Content Delivery Provide …

Functional requirements of Smart Classroom System with non-functional Read More »

Functional requirements of Smart Car Parking System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements User Authentication and Authorization Allow users to register, log in, and manage their accounts. Different access levels for users (e.g., regular users, administrators). Parking Space Management Display real-time availability of parking spaces. Provide information on parking space locations and types (e.g., standard, reserved, electric vehicle charging). Booking and Reservation Allow users to book …

Functional requirements of Smart Car Parking System with non-functional Read More »