CALCUL D'INCERTITUDE

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

template<typename numbr3s> void nb(numbr3s &num , const bool &entier)
{
    std::string saisie;
    std::string verif;

    size_t found;
    bool good = true;
    bool trouble = false;
    numbr3s num1;

    do
    {
        if(good == false)
        {
            std::cout << std::endl << "-> Saisie incorrecte, ressaisissez: ";
        }

        std::cin>>saisie;

        if(entier != true)
        {
            found = saisie.find_first_of(",");
            while(found != std::string::npos)
            {
                saisie[found] = '.';// les virgules françaises seront automatiquement transformées en point.
                found = saisie.find_first_of("," , found+1);
            }
        }

        std::istringstream iss(saisie);// conversion du type string en type double.
        iss >> num1;

        if(iss.fail())
        {
            good = false;
            trouble = true;
        }
        else
        {
            std::ostringstream oss;
            oss << num1;

            verif = oss.str();

            if(verif.size() < saisie.size())
            {
                good = false;
                trouble = true;
            }
            else{good = true;}
        }

        if(good == true && trouble == true)
        {
            std::cout << "-> OK!" << std::endl << std::endl;
        }

    }while(good == false);

    num = num1;
}

int main()
{
    std::cout<<">-------------------- CALCUL D'INCERTITUDE --------------------<"<<std::endl<<std::endl;
    double val , total1;
    int taille , quitter = 0 , Z;

    do//pour le "quitter" de fin
    {
        if(quitter == 0)// ce cas ne se présentera qu'une seule fois.
        {
            std::cout << "  |------------------------------------------------------------|" << std::endl;
            std::cout << "  |    delta(1)/(1) = [delta(2)/(2)] + [delta(3)/(3)] + ...    |" << std::endl;
            std::cout << "  |------------------------------------------------------------|" << std::endl << std::endl;
        }

        std::cout << "Entrer la valeur (1) dont on cherche l'incertitude:  ";
        nb(val , 0);
        val = std::abs(val);

        do
        {
            std::cout << "Indiquer le nombre de valeurs permettant de calculer la valeur (1): ";
            nb(taille , 1);
            if(taille < 1){std::cout << std::endl << "--> ATTENTION! Il doit subsister au moins une valeur. Ressaisissez." << std::endl << std::endl;}
        }while(taille < 1);

        std::vector<double> VAL(taille,0);// définition du "tableau" de stockage des valeurs.
        std::vector<double> INC(taille,0);// même chose que ci-dessus mais pour les incertitudes.

        std::cout << std::endl << "Entrer ces valeurs: " << std::endl;

        Z = 0;

        do
        {
            std::cout << std::endl << "<----->";
            std::cout << std::endl << "Valeur (" << Z+2 << ") = ";
            nb(VAL[Z] , 0);
            std::cout << "Incertitude sur la valeur (" << Z+2 << ") = ";
            nb(INC[Z] , 0);
            Z++;
            std::cout << "<----->" << std::endl;
        }while(Z < taille);

        total1 = 0;
        Z = 0;

        do
        {
            total1 = total1 + std::abs(INC[Z]/VAL[Z]);
            Z++;
        }while(Z < taille);

        std::cout << std::endl << "L'incertitude sur la valeur (1) est: " << total1 * val;
        std::cout << std::endl << std::endl << ">--------------------------------------------------------------<" << std::endl;
        std::cout << std::endl << "--> Faire un autre calcul d'incertitude? (1=oui/0=non): ";
        nb(quitter , 1);
        std::cout << std::endl << ">--------------------------------------------------------------<" << std::endl << std::endl;
    }while(quitter > 0);
    return 0;
}