suvatCalculator.cpp

#include <iostream>
#include <limits>
#include <string>
#include <array>
#include <cmath>

void readInput(const std::string& prompt, double& variable, bool& isKnown) {
    std::cout << prompt;
    std::string input;
    std::getline(std::cin, input);
    if (input.empty()) {
        isKnown = false;
    }
    else {
        try {
            variable = std::stod(input);
            isKnown = true;
        }
        catch (const std::invalid_argument&) {
            std::cout << "Invalid input detected. The variable will be considered unknown.\n";
            isKnown = false;
        }
    }
}

int main() {
    std::array<bool, 5> isKnown = { false, false, false, false, false };
    double s = 0, u = 0, v = 0, a = 0, t = 0;

    readInput("Please enter the value for displacement (s): ", s, isKnown[0]);
    readInput("Please enter the initial velocity (u): ", u, isKnown[1]);
    readInput("Please enter the final velocity (v): ", v, isKnown[2]);
    readInput("Please enter the acceleration (a): ", a, isKnown[3]);
    readInput("Please enter the time taken (t): ", t, isKnown[4]);

    std::cout << "\n";

    int knownCount = 0;
    for (bool known : isKnown) {
        if (known) ++knownCount;
    }

    if (knownCount < 3) {
        std::cout << "Insufficient data. At least three variables must be known to calculate the others.\n";
    }
    else {
        bool changed;
        do {
            changed = false;
            // Equation: v = u + a * t
            if (isKnown[1] && isKnown[3] && isKnown[4] && !isKnown[2]) {
                v = u + a * t;
                isKnown[2] = true;
                changed = true;
                std::cout << "Calculated final velocity (v) using v = u + a * t: " << v << "\n";
            }
            if (isKnown[2] && isKnown[3] && isKnown[4] && !isKnown[1]) {
                u = v - a * t;
                isKnown[1] = true;
                changed = true;
                std::cout << "Calculated initial velocity (u) using u = v - a * t: " << u << "\n";
            }
            if (isKnown[1] && isKnown[2] && isKnown[4] && !isKnown[3]) {
                a = (v - u) / t;
                isKnown[3] = true;
                changed = true;
                std::cout << "Calculated acceleration (a) using a = (v - u) / t: " << a << "\n";
            }
            if (isKnown[1] && isKnown[2] && isKnown[3] && !isKnown[4]) {
                if (a != 0) {
                    t = (v - u) / a;
                    isKnown[4] = true;
                    changed = true;
                    std::cout << "Calculated time (t) using t = (v - u) / a: " << t << "\n";
                }
                else {
                    std::cout << "Cannot calculate time (t) because acceleration (a) is zero.\n";
                }
            }
            // Equation: s = ((u + v) / 2) * t
            if (isKnown[1] && isKnown[2] && isKnown[4] && !isKnown[0]) {
                s = ((u + v) / 2) * t;
                isKnown[0] = true;
                changed = true;
                std::cout << "Calculated displacement (s) using s = ((u + v) / 2) * t: " << s << "\n";
            }
            if (isKnown[0] && isKnown[1] && isKnown[2] && !isKnown[4]) {
                if (u + v != 0) {
                    t = (2 * s) / (u + v);
                    isKnown[4] = true;
                    changed = true;
                    std::cout << "Calculated time (t) using t = (2 * s) / (u + v): " << t << "\n";
                }
                else {
                    std::cout << "Cannot calculate time (t) because (u + v) is zero.\n";
                }
            }
            // Equation: s = u * t + 0.5 * a * t^2
            if (isKnown[1] && isKnown[3] && isKnown[4] && !isKnown[0]) {
                s = u * t + 0.5 * a * t * t;
                isKnown[0] = true;
                changed = true;
                std::cout << "Calculated displacement (s) using s = u * t + 0.5 * a * t^2: " << s << "\n";
            }
            if (isKnown[0] && isKnown[1] && isKnown[3] && !isKnown[4]) {
                // Solve quadratic equation for t
                double discriminant = u * u + 2 * a * s;
                if (discriminant >= 0 && a != 0) {
                    double sqrtDiscriminant = std::sqrt(discriminant);
                    t = (-u + sqrtDiscriminant) / a;
                    isKnown[4] = true;
                    changed = true;
                    std::cout << "Calculated time (t) using quadratic formula: " << t << "\n";
                }
                else {
                    std::cout << "Cannot calculate time (t) due to invalid discriminant or zero acceleration.\n";
                }
            }
            // Equation: v^2 = u^2 + 2 * a * s
            if (isKnown[1] && isKnown[3] && isKnown[0] && !isKnown[2]) {
                double value = u * u + 2 * a * s;
                if (value >= 0) {
                    v = std::sqrt(value);
                    isKnown[2] = true;
                    changed = true;
                    std::cout << "Calculated final velocity (v) using v^2 = u^2 + 2 * a * s: " << v << "\n";
                }
                else {
                    std::cout << "Cannot calculate final velocity (v) due to negative value under square root.\n";
                }
            }
            if (isKnown[2] && isKnown[3] && isKnown[0] && !isKnown[1]) {
                double value = v * v - 2 * a * s;
                if (value >= 0) {
                    u = std::sqrt(value);
                    isKnown[1] = true;
                    changed = true;
                    std::cout << "Calculated initial velocity (u) using u^2 = v^2 - 2 * a * s: " << u << "\n";
                }
                else {
                    std::cout << "Cannot calculate initial velocity (u) due to negative value under square root.\n";
                }
            }
            // Equation: s = v * t - 0.5 * a * t^2
            if (isKnown[2] && isKnown[4] && isKnown[3] && !isKnown[0]) {
                s = v * t - 0.5 * a * t * t;
                isKnown[0] = true;
                changed = true;
                std::cout << "Calculated displacement (s) using s = v * t - 0.5 * a * t^2: " << s << "\n";
            }
            // Equation: s = ((v + u) / 2) * t
            if (isKnown[1] && isKnown[2] && isKnown[4] && !isKnown[0]) {
                s = ((u + v) / 2) * t;
                isKnown[0] = true;
                changed = true;
                std::cout << "Calculated displacement (s) using s = ((u + v) / 2) * t: " << s << "\n";
            }
        } while (changed);

        std::cout << "\nFinal results:\n";
        if (isKnown[0]) std::cout << "Displacement (s): " << s << "\n";
        if (isKnown[1]) std::cout << "Initial velocity (u): " << u << "\n";
        if (isKnown[2]) std::cout << "Final velocity (v): " << v << "\n";
        if (isKnown[3]) std::cout << "Acceleration (a): " << a << "\n";
        if (isKnown[4]) std::cout << "Time taken (t): " << t << "\n";
    }

    return 0;
}