Problème de précision en C++ [Résolu]

Signaler
Messages postés
65
Date d'inscription
samedi 14 mars 2020
Statut
Membre
Dernière intervention
8 avril 2021
-
Messages postés
15781
Date d'inscription
mardi 11 mars 2003
Statut
Contributeur
Dernière intervention
9 avril 2021
-
Bonjour,

Je suis en train de créer un programme qui calcul toute les possibilité de ratio et il affiche les 4 résultats les plus proche d'un ratio qui est logé dans la variable recherché. Par contre, mon problème est que la précision du chiffre dans la variable recherché n'est pas bonne du tout car si je fais le même calcule sur une calculatrice, la réponse n'est pas la même, vous pouvez même l'essayer. Ce que je voudrais c'est que le résultat de la variable nommé "recherché" soit le même que le résultat de la calculatrice.

Voici mon code :

    #include <iostream>
    #include <vector>
    #include <algorithm>
    #include <math.h>
    #include <iomanip>
    #include <windows.h>
    #define pi 3.14159265358979323846264338328
    using namespace std;

    int myArr[] = { 113, 111, 109, 107, 103, 103, 101, 100, 99, 98, 97, 95, 93, 93, 92, 91, 90, 89, 89, 87, 85, 83, 81, 80, 79, 77, 76, 75, 74, 73, 72, 71, 71, 70, 69, 67, 66, 65, 63, 62, 61, 60, 60, 59, 58, 57, 56, 55, 55, 53, 52, 51, 50, 50, 49, 48, 48, 47, 46, 46, 45, 45, 44, 43, 43, 42, 41, 40, 39, 37, 36, 36, 36, 36, 35, 34, 33, 32, 31, 30, 30, 29, 29, 26, 26, 25, 24, 24, 23, 22, 20, 20 };
    vector <float> value{};
    float ele;
    float ele1;
    float ele2;
    float ele3;
    float getClosest() {    
        for (float ele : myArr) {
            for (float ele1 : myArr) {
                for (float ele2 : myArr) {
                    for (float ele3 : myArr) {
                        value.push_back((ele / ele1) * (ele2 / ele3));
                    }
                }
            }
        }
        return 0;
    }
// Fin fonction pour calculer les ratios des gear

// Début fonction pour connaitre la valeur la plus proche
    float getClosest2(float search) {
        float closest;
        closest = 0;
        float item;
        for (float item : value) {
            if (closest == 0 || fabs(search - closest) > fabs(item - search)) {
                closest = item;
            }
        }
        return closest;
    }
// Fin fonction pour connaitre la valeur la plus proche

    // Début de l'équation pour la valeur recherche du MOD 
            float recherche = 9.0*(sin(45*(pi/180)) / 5.8);
    // Fin de l'équation pour la valeur recherche du MOD 
   
    // Début de la recherche de la première valeur la plus proche
            getClosest();
            float valPlusProche = getClosest2(recherche);
            float tab[4][1];
            for (float ele : myArr) {
                for (float ele1 : myArr) {
                    for (float ele2 : myArr) {
                        for (float ele3 : myArr) {
                            float calc = (ele/ele1)*(ele2/ele3);
                            if (calc == valPlusProche) {
                                tab[0][0] = ele;
                                tab[1][0] = ele1;
                                tab[2][0] = ele2;
                                tab[3][0] = ele3;
                                tab[4][0] = (tab[0][0]/tab[1][0])*(tab[2][0]/tab[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            float table = tab[4][0];
    // Fin de la recherche de la première valeur la plus proche

    // Début de l'éffacement de la première valeur la plus proche dans le tableau value
            float value_to_remove = valPlusProche;
            value.erase(std::remove(value.begin(), value.end(), value_to_remove), value.end()); 
    // Fin de l'éffacement de la première valeur la plus proche dans le tableau value

    // Début de la recherche de la deuxième valeur la plus proche
            float valPlusProche1 = getClosest2(recherche);
            float tab1[4][1];
            for (float ele : myArr){
                for (float ele1 : myArr) {
                    for (float ele2 : myArr) {
                        for (float ele3 : myArr) {
                            float calc = (ele / ele1) * (ele2 / ele3);
                            if (calc == valPlusProche1) {
                                tab1[0][0] = ele;
                                tab1[1][0] = ele1;
                                tab1[2][0] = ele2;
                                tab1[3][0] = ele3;
                                tab1[4][0] = (tab1[0][0]/tab1[1][0])*(tab1[2][0]/tab1[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            float table1 = tab1[4][0];
    // Fin de la recherche de la deuxième valeur la plus proche

    // Début de l'éffacement de la deuxième valeur la plus proche dans le tableau value
            float value_to_remove1 = valPlusProche1;
            value.erase(std::remove(value.begin(), value.end(), value_to_remove1), value.end()); 
    // Fin de l'éffacement de la deuxième valeur la plus proche dans le tableau value

    // Début de la recherche de la troisième valeur la plus proche
            float valPlusProche2 = getClosest2(recherche);
            float tab2[4][1];
            for (float ele : myArr){
                for (float ele1 : myArr) {
                    for (float ele2 : myArr) {
                        for (float ele3 : myArr) {
                            float calc = (ele / ele1) * (ele2 / ele3);
                            if (calc == valPlusProche2) {
                                tab2[0][0] = ele;
                                tab2[1][0] = ele1;
                                tab2[2][0] = ele2;
                                tab2[3][0] = ele3;
                                tab2[4][0] = (tab2[0][0]/tab2[1][0])*(tab2[2][0]/tab2[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            float table2 = tab2[4][0];
    // Fin de la recherche de la troisième valeur la plus proche

    // Début de l'éffacement de la troisième valeur la plus proche dans le tableau value
            float value_to_remove2 = valPlusProche2;
            value.erase(std::remove(value.begin(), value.end(), value_to_remove2), value.end()); 
    // Fin de l'éffacement de la troisième valeur la plus proche dans le tableau value

    // Début de la recherche de la quatrième valeur la plus proche
            float valPlusProche3 = getClosest2(recherche);
            float tab3[4][1];
            for (float ele : myArr){
                for (float ele1 : myArr) {
                    for (float ele2 : myArr) {
                        for (float ele3 : myArr) {
                            float calc = (ele / ele1) * (ele2 / ele3);
                            if (calc == valPlusProche3) {
                                tab3[0][0] = ele;
                                tab3[1][0] = ele1;
                                tab3[2][0] = ele2;
                                tab3[3][0] = ele3;
                                tab3[4][0] = (tab3[0][0]/tab3[1][0])*(tab3[2][0]/tab3[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            float table3 = tab3[4][0];
    // Fin de la recherche de la quatrième valeur la plus proche

    // Début affichage des informations
           
            printf("Ratio recherch%c : %.7f\n", 130, recherche);
            printf("R%csultat ratio #1 : %.7f \n", 130, table);
            cout << "Engrenages " << tab[0][0] << ", " << tab[1][0] << ", " << tab[2][0] << " et " << tab[3][0] << endl;
            
            cout << "=============================================================" << endl;
            
            printf("Ratio recherch%c : %.7f \n", 130, recherche);
            printf("R%csultat ratio #2 : %.7f \n", 130, table1);
            cout << "Engrenages " << tab1[0][0] << ", " << tab1[1][0] << ", " << tab1[2][0] << " et " << tab1[3][0] << endl;
    
            cout << "=============================================================" << endl;
          
            printf("Ratio recherch%c : %.7f \n", 130, recherche);
            printf("R%csultat ratio #3 : %.7f \n", 130, table2);
            cout << "Engrenages " << tab2[0][0] << ", " << tab2[1][0] << ", " << tab2[2][0] << " et " << tab2[3][0] << endl;
           
            cout << "=============================================================" << endl;
           
            printf("Ratio recherch%c : %.7f \n", 130, recherche);
            printf("R%csultat ratio #4 : %.7f \n", 130, table3);
            cout << "Engrenages " << tab3[0][0] << ", " << tab3[1][0] << ", " << tab3[2][0] << " et " << tab3[3][0] << endl;
          ;
            cout << "=============================================================\n" << endl;
    // Fin affichage des informations
        }



Merci d'avance

6 réponses

Messages postés
15039
Date d'inscription
lundi 9 juin 2008
Statut
Contributeur
Dernière intervention
10 avril 2021
827
bonjour,
as-tu fait une recherche "c++ precision float"?
Messages postés
15781
Date d'inscription
mardi 11 mars 2003
Statut
Contributeur
Dernière intervention
9 avril 2021
685
Bonjour
https://forums.commentcamarche.net/forum/affich-35846831-erreur-de-calcul#3

Voir ma réponse, puis celles de Dalfab et Reivax
Messages postés
540
Date d'inscription
dimanche 7 février 2016
Statut
Membre
Dernière intervention
8 avril 2021
69
Bonjour,

Le type
float
est réservé aux cas où on n'a besoin de très peu de précision et où il faut à tout prix économiser la mémoire. Depuis 1985, le type préconisé pour les calculs flottants est le type
double
, il est plus rapide (sur la plupart des processeurs) et nettement plus précis.

Je te propose donc de remplacer
float
par
double
dans ton code. Tu n'obtiendras pas la même chose que ta calculatrice, mais ça sera peut-être mieux qu"elle. Le
float
lui n'y arrivera jamais.
Messages postés
15781
Date d'inscription
mardi 11 mars 2003
Statut
Contributeur
Dernière intervention
9 avril 2021
685
Salut, je ne me rappelais pas que la préconisation était si ancienne.
Ce qui est quand même surprenant, c'est le nombre de cours ou d'outils actuels qui utilisent encore des float....
Messages postés
540
Date d'inscription
dimanche 7 février 2016
Statut
Membre
Dernière intervention
8 avril 2021
69 >
Messages postés
15781
Date d'inscription
mardi 11 mars 2003
Statut
Contributeur
Dernière intervention
9 avril 2021

Le problème est qu'il n'y pas eu de préconisation. Mais à un moment, les notations ont évolués la fonction fabs() retournait un float, et la syntaxe à évolué en :
float fabsf( float arg );
double fabs( double arg );
long double fabsl( long double arg );
Ça a été officialisé avec le C99, mais les compilateurs de l'époque avaient une option pour savoir si fabs() et autres retournaient un float ou un double.

De même pour indiquer un littéral flottant on ajoute un suffixe f, alors que le double n'en a pas besoin.
Donc le float serait alors devenu la cas particulier et le double le cas normal.
Le plus caractéristique est comment est mis un float sur la pile, il est désormais converti en double (si on donne un float à une fonction attendant un float on se prend une double conversion intermédiaire!) C'est pourquoi dans un printf() le paramètre désignant un float ou un double est désormais le même "%f".
Les processeurs de l'époque étaient même plus rapide pour les double car c'était celui qui était hardcodé. C'est moins le cas aujourd'hui avec les unités de calcul parallèles.

Ils ont gardé par contre le fait que dans un scanf, ça n'est pas le float l'exception, c'est le double qui utilise "%lf".

Alors pourquoi beaucoup de cours continuent d'utiliser les float? Je ne sais pas vraiment, mais on trouve encore des cours qui indiquent qu'on doit déclarer ses variables au début des fonctions (cf le code ci-dessus!) alors!!

PS: en fait je travaille dans l'embarqué et donc je n'utilise quasiment jamais les flottants, et si je dois je me restreint au float, car les processeurs que j'utilise n'ont pas de coprocesseurs ni d'unité flottante.
Messages postés
15781
Date d'inscription
mardi 11 mars 2003
Statut
Contributeur
Dernière intervention
9 avril 2021
685 >
Messages postés
540
Date d'inscription
dimanche 7 février 2016
Statut
Membre
Dernière intervention
8 avril 2021

Le plus caractéristique est comment est mis un float sur la pile, il est désormais converti en double

Oui c'est le cas en C# aussi.
Messages postés
65
Date d'inscription
samedi 14 mars 2020
Statut
Membre
Dernière intervention
8 avril 2021

Bonjour,

Mais si j'ai absolument besoins que le chiffre qui va être afficher soit égal à la calculatrice, comment faire?
Messages postés
15781
Date d'inscription
mardi 11 mars 2003
Statut
Contributeur
Dernière intervention
9 avril 2021
685
Tu as essayé avec des doubles?
Messages postés
65
Date d'inscription
samedi 14 mars 2020
Statut
Membre
Dernière intervention
8 avril 2021

Bonjour,

Merci Whismeril, ça marche, mais maintenant, j'ai rajouté n autre bout de code et ce bout de code dois trouver l'inverse de la variable choix. Mais même si je met des doubles, ça ne change rien, la réponse afficher ne correspond pas au résultat de ma calculatrice.

Voici mon code:

 #include <iostream>
    #include <vector>
    #include <algorithm>
    #include <math.h>
    #include <iomanip>
    #include <windows.h>
    #define pi 3.14159265358979323846264338328
    using namespace std;

    int myArr[] = { 113, 111, 109, 107, 103, 103, 101, 100, 99, 98, 97, 95, 93, 93, 92, 91, 90, 89, 89, 87, 85, 83, 81, 80, 79, 77, 76, 75, 74, 73, 72, 71, 71, 70, 69, 67, 66, 65, 63, 62, 61, 60, 60, 59, 58, 57, 56, 55, 55, 53, 52, 51, 50, 50, 49, 48, 48, 47, 46, 46, 45, 45, 44, 43, 43, 42, 41, 40, 39, 37, 36, 36, 36, 36, 35, 34, 33, 32, 31, 30, 30, 29, 29, 26, 26, 25, 24, 24, 23, 22, 20, 20 };
    vector <float> value{};
    float ele;
    float ele1;
    float ele2;
    float ele3;
    float getClosest() {    
        for (float ele : myArr) {
            for (float ele1 : myArr) {
                for (float ele2 : myArr) {
                    for (float ele3 : myArr) {
                        value.push_back((ele / ele1) * (ele2 / ele3));
                    }
                }
            }
        }
        return 0;
    }
// Fin fonction pour calculer les ratios des gear

// Début fonction pour connaitre la valeur la plus proche
    float getClosest2(float search) {
        float closest;
        closest = 0;
        float item;
        for (float item : value) {
            if (closest == 0 || fabs(search - closest) > fabs(item - search)) {
                closest = item;
            }
        }
        return closest;
    }
// Fin fonction pour connaitre la valeur la plus proche
int main() {
    // Début de l'équation pour la valeur recherche du MOD 
            double recherche = 9.0*(sin(45*(pi/180)) / 5.8);
    // Fin de l'équation pour la valeur recherche du MOD 
   
    // Début de la recherche de la première valeur la plus proche
            getClosest();
            double valPlusProche = getClosest2(recherche);
            double tab[4][1];
            for (float ele : myArr) {
                for (float ele1 : myArr) {
                    for (float ele2 : myArr) {
                        for (float ele3 : myArr) {
                            float calc = (ele/ele1)*(ele2/ele3);
                            if (calc == valPlusProche) {
                                tab[0][0] = ele;
                                tab[1][0] = ele1;
                                tab[2][0] = ele2;
                                tab[3][0] = ele3;
                                tab[4][0] = (tab[0][0]/tab[1][0])*(tab[2][0]/tab[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            double table = tab[4][0];
    // Fin de la recherche de la première valeur la plus proche

    // Début de l'éffacement de la première valeur la plus proche dans le tableau value
            double value_to_remove = valPlusProche;
            value.erase(std::remove(value.begin(), value.end(), value_to_remove), value.end()); 
    // Fin de l'éffacement de la première valeur la plus proche dans le tableau value

    // Début de la recherche de la deuxième valeur la plus proche
            double valPlusProche1 = getClosest2(recherche);
            double tab1[4][1];
            for (float ele : myArr){
                for (float ele1 : myArr) {
                    for (float ele2 : myArr) {
                        for (float ele3 : myArr) {
                            float calc = (ele / ele1) * (ele2 / ele3);
                            if (calc == valPlusProche1) {
                                tab1[0][0] = ele;
                                tab1[1][0] = ele1;
                                tab1[2][0] = ele2;
                                tab1[3][0] = ele3;
                                tab1[4][0] = (tab1[0][0]/tab1[1][0])*(tab1[2][0]/tab1[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            double table1 = tab1[4][0];
    // Fin de la recherche de la deuxième valeur la plus proche

    // Début de l'éffacement de la deuxième valeur la plus proche dans le tableau value
            double value_to_remove1 = valPlusProche1;
            value.erase(std::remove(value.begin(), value.end(), value_to_remove1), value.end()); 
    // Fin de l'éffacement de la deuxième valeur la plus proche dans le tableau value

    // Début de la recherche de la troisième valeur la plus proche
            double valPlusProche2 = getClosest2(recherche);
            double tab2[4][1];
            for (float ele : myArr){
                for (float ele1 : myArr) {
                    for (float ele2 : myArr) {
                        for (float ele3 : myArr) {
                            float calc = (ele / ele1) * (ele2 / ele3);
                            if (calc == valPlusProche2) {
                                tab2[0][0] = ele;
                                tab2[1][0] = ele1;
                                tab2[2][0] = ele2;
                                tab2[3][0] = ele3;
                                tab2[4][0] = (tab2[0][0]/tab2[1][0])*(tab2[2][0]/tab2[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            double table2 = tab2[4][0];
    // Fin de la recherche de la troisième valeur la plus proche

    // Début de l'éffacement de la troisième valeur la plus proche dans le tableau value
            double value_to_remove2 = valPlusProche2;
            value.erase(std::remove(value.begin(), value.end(), value_to_remove2), value.end()); 
    // Fin de l'éffacement de la troisième valeur la plus proche dans le tableau value

    // Début de la recherche de la quatrième valeur la plus proche
            double valPlusProche3 = getClosest2(recherche);
            float tab3[4][1];
            for (float ele : myArr){
                for (float ele1 : myArr) {
                    for (float ele2 : myArr) {
                        for (float ele3 : myArr) {
                            float calc = (ele / ele1) * (ele2 / ele3);
                            if (calc == valPlusProche3) {
                                tab3[0][0] = ele;
                                tab3[1][0] = ele1;
                                tab3[2][0] = ele2;
                                tab3[3][0] = ele3;
                                tab3[4][0] = (tab3[0][0]/tab3[1][0])*(tab3[2][0]/tab3[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            double table3 = tab3[4][0];
    // Fin de la recherche de la quatrième valeur la plus proche

    // Début affichage des informations
           
            printf("Ratio recherch%c : %.9f\n", 130, recherche);
            printf("R%csultat ratio #1 : %.9f \n", 130, table);
            cout << "Engrenages " << tab[0][0] << ", " << tab[1][0] << ", " << tab[2][0] << " et " << tab[3][0] << endl;
            double sinangle = (table * 5.8)/9;
            double transformsin = (asin(sinangle))*180/pi;
            printf("Donnera un angle de %.9f\n", transformsin);
            cout << "=============================================================" << endl;
            
            printf("Ratio recherch%c : %.9f \n", 130, recherche);
            printf("R%csultat ratio #2 : %.9f \n", 130, table1);
            cout << "Engrenages " << tab1[0][0] << ", " << tab1[1][0] << ", " << tab1[2][0] << " et " << tab1[3][0] << endl;
            double sinangle1 = (table1 * 5.8)/9;
            double transformsin1 = (asin(sinangle1))*180/pi;
            printf("Donnera un angle de %.9f\n", transformsin1);

            cout << "=============================================================" << endl;
          
            printf("Ratio recherch%c : %.9f \n", 130, recherche);
            printf("R%csultat ratio #3 : %.9f \n", 130, table2);
            cout << "Engrenages " << tab2[0][0] << ", " << tab2[1][0] << ", " << tab2[2][0] << " et " << tab2[3][0] << endl;
            double sinangle2 = (table2 * 5.8)/9;
            double transformsin2 = (asin(sinangle))*180/pi;
            printf("Donnera un angle de %.9f\n", transformsin2);

            cout << "=============================================================" << endl;
           
            printf("Ratio recherch%c : %.9f \n", 130, recherche);
            printf("R%csultat ratio #4 : %.9f \n", 130, table3);
            cout << "Engrenages " << tab3[0][0] << ", " << tab3[1][0] << ", " << tab3[2][0] << " et " << tab3[3][0] << endl;
            double sinangle3 = (table3 * 5.8)/9;
            double transformsin3 = (asin(sinangle))*180/pi;
            printf("Donnera un angle de %.9f\n", transformsin3);

            cout << "=============================================================\n" << endl;
    // Fin affichage des informations
        }
        
Messages postés
15039
Date d'inscription
lundi 9 juin 2008
Statut
Contributeur
Dernière intervention
10 avril 2021
827 >
Messages postés
65
Date d'inscription
samedi 14 mars 2020
Statut
Membre
Dernière intervention
8 avril 2021

peux-tu partager les valeurs affichées par l'un et l'autre?

pourquoi as-tu absolument besoin que le nombre qui va être affiché soit égal à la calculatrice? de quelle calculatrice s'agit-il?
Messages postés
65
Date d'inscription
samedi 14 mars 2020
Statut
Membre
Dernière intervention
8 avril 2021
>
Messages postés
15039
Date d'inscription
lundi 9 juin 2008
Statut
Contributeur
Dernière intervention
10 avril 2021

J'ai besoin que le nombre soit égal à la calculatrice parce que l'opération peux s'effectuer à la main mais je crée un programme pour automatiser cette tâche et peux importe la calculatrice qu'on utilise. Mon programme, pour le premier résultat, il affiche 44.999997467 et ce pour l'inverse du sinus, et sur la calculatrice il affiche 44,999997469, mais j'ai absolument besoins qu'ils soient égal.

Merci
Messages postés
15781
Date d'inscription
mardi 11 mars 2003
Statut
Contributeur
Dernière intervention
9 avril 2021
685
Tu dis que ça marche mais que ça marche pas et ton code est toujours plein de float....
Messages postés
65
Date d'inscription
samedi 14 mars 2020
Statut
Membre
Dernière intervention
8 avril 2021

Donc si je comprend il faut que j'enlève tout mes float, même ceux dans les fonctions?
Messages postés
15039
Date d'inscription
lundi 9 juin 2008
Statut
Contributeur
Dernière intervention
10 avril 2021
827 >
Messages postés
65
Date d'inscription
samedi 14 mars 2020
Statut
Membre
Dernière intervention
8 avril 2021

non, il ne faut pas, sauf si tu veux des résultats plus précis.
Messages postés
65
Date d'inscription
samedi 14 mars 2020
Statut
Membre
Dernière intervention
8 avril 2021
>
Messages postés
15039
Date d'inscription
lundi 9 juin 2008
Statut
Contributeur
Dernière intervention
10 avril 2021

D'accord mais même si je les enlèves tous et que je les remplaces par des double, le résultat va encore être différent.
Messages postés
15039
Date d'inscription
lundi 9 juin 2008
Statut
Contributeur
Dernière intervention
10 avril 2021
827 >
Messages postés
65
Date d'inscription
samedi 14 mars 2020
Statut
Membre
Dernière intervention
8 avril 2021

peux-tu montrer le nouveau résultat?
Messages postés
65
Date d'inscription
samedi 14 mars 2020
Statut
Membre
Dernière intervention
8 avril 2021
>
Messages postés
15039
Date d'inscription
lundi 9 juin 2008
Statut
Contributeur
Dernière intervention
10 avril 2021

Si je retire tout les float, voici mon code :

       #include <iostream>
    #include <list>
    #include <algorithm>
    #include <math.h>
    #include <iomanip>
    #include <windows.h>
    #define pi 3.14159265358979323846264338328
    using namespace std;

    double myArr[] = { 113, 111, 109, 107, 103, 103, 101, 100, 99, 98, 97, 95, 93, 93, 92, 91, 90, 89, 89, 87, 85, 83, 81, 80, 79, 77, 76, 75, 74, 73, 72, 71, 71, 70, 69, 67, 66, 65, 63, 62, 61, 60, 60, 59, 58, 57, 56, 55, 55, 53, 52, 51, 50, 50, 49, 48, 48, 47, 46, 46, 45, 45, 44, 43, 43, 42, 41, 40, 39, 37, 36, 36, 36, 36, 35, 34, 33, 32, 31, 30, 30, 29, 29, 26, 26, 25, 24, 24, 23, 22, 20, 20 };
    list <double> value{};
    double ele;
    double ele1;
    double ele2;
    double ele3;
    double getClosest() {    
        for (double ele : myArr) {
            for (double ele1 : myArr) {
                for (double ele2 : myArr) {
                    for (double ele3 : myArr) {
                        value.push_back((ele / ele1) * (ele2 / ele3));
                    }
                }
            }
        }
        return 0;
    }
// Fin fonction pour calculer les ratios des gear

// Début fonction pour connaitre la valeur la plus proche
    double getClosest2(double search) {
        double closest;
        closest = 0;
        double item;
        for (double item : value) {
            if (closest == 0 || abs(search - closest) > abs(item - search)) {
                closest = item;
            }
        }
        return closest;
    }
// Fin fonction pour connaitre la valeur la plus proche
int main() {
   
    // Début de l'équation pour la valeur recherche du MOD 
            double recherche = 9*(sin(45*(pi/180)) / 5.8);
    // Fin de l'équation pour la valeur recherche du MOD 
   
    // Début de la recherche de la première valeur la plus proche
            getClosest();
            double valPlusProche = getClosest2(recherche);
            double tab[4][1];
            for (double ele : myArr) {
                for (double ele1 : myArr) {
                    for (double ele2 : myArr) {
                        for (double ele3 : myArr) {
                            double calc = (ele/ele1)*(ele2/ele3);
                            if (calc == valPlusProche) {
                                tab[0][0] = ele;
                                tab[1][0] = ele1;
                                tab[2][0] = ele2;
                                tab[3][0] = ele3;
                                tab[4][0] = (tab[0][0]/tab[1][0])*(tab[2][0]/tab[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            double table = tab[4][0];
    // Fin de la recherche de la première valeur la plus proche

    // Début de l'éffacement de la première valeur la plus proche dans le tableau value
            double value_to_remove = valPlusProche;
            value.erase(std::remove(value.begin(), value.end(), value_to_remove), value.end()); 
    // Fin de l'éffacement de la première valeur la plus proche dans le tableau value

    // Début de la recherche de la deuxième valeur la plus proche
            double valPlusProche1 = getClosest2(recherche);
            double tab1[4][1];
            for (double ele : myArr){
                for (double ele1 : myArr) {
                    for (double ele2 : myArr) {
                        for (double ele3 : myArr) {
                            double calc = (ele / ele1) * (ele2 / ele3);
                            if (calc == valPlusProche1) {
                                tab1[0][0] = ele;
                                tab1[1][0] = ele1;
                                tab1[2][0] = ele2;
                                tab1[3][0] = ele3;
                                tab1[4][0] = (tab1[0][0]/tab1[1][0])*(tab1[2][0]/tab1[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            double table1 = tab1[4][0];
    // Fin de la recherche de la deuxième valeur la plus proche

    // Début de l'éffacement de la deuxième valeur la plus proche dans le tableau value
            double value_to_remove1 = valPlusProche1;
            value.erase(std::remove(value.begin(), value.end(), value_to_remove1), value.end()); 
    // Fin de l'éffacement de la deuxième valeur la plus proche dans le tableau value

    // Début de la recherche de la troisième valeur la plus proche
            double valPlusProche2 = getClosest2(recherche);
            double tab2[4][1];
            for (double ele : myArr){
                for (double ele1 : myArr) {
                    for (double ele2 : myArr) {
                        for (double ele3 : myArr) {
                            double calc = (ele / ele1) * (ele2 / ele3);
                            if (calc == valPlusProche2) {
                                tab2[0][0] = ele;
                                tab2[1][0] = ele1;
                                tab2[2][0] = ele2;
                                tab2[3][0] = ele3;
                                tab2[4][0] = (tab2[0][0]/tab2[1][0])*(tab2[2][0]/tab2[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            double table2 = tab2[4][0];
    // Fin de la recherche de la troisième valeur la plus proche

    // Début de l'éffacement de la troisième valeur la plus proche dans le tableau value
            double value_to_remove2 = valPlusProche2;
            value.erase(std::remove(value.begin(), value.end(), value_to_remove2), value.end()); 
    // Fin de l'éffacement de la troisième valeur la plus proche dans le tableau value

    // Début de la recherche de la quatrième valeur la plus proche
            double valPlusProche3 = getClosest2(recherche);
            double tab3[4][1];
            for (double ele : myArr){
                for (double ele1 : myArr) {
                    for (double ele2 : myArr) {
                        for (double ele3 : myArr) {
                            double calc = (ele / ele1) * (ele2 / ele3);
                            if (calc == valPlusProche3) {
                                tab3[0][0] = ele;
                                tab3[1][0] = ele1;
                                tab3[2][0] = ele2;
                                tab3[3][0] = ele3;
                                tab3[4][0] = (tab3[0][0]/tab3[1][0])*(tab3[2][0]/tab3[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            double table3 = tab3[4][0];
    // Fin de la recherche de la quatrième valeur la plus proche

    // Début affichage des informations
           
            printf("Ratio recherch%c : %.7f\n", 130, recherche);
            printf("R%csultat ratio #1 : %.7f \n", 130, table);
            cout << "Engrenages " << tab[0][0] << ", " << tab[1][0] << ", " << tab[2][0] << " et " << tab[3][0] << endl;
            double sinangle = (table * 5.8)/9;
            double transformsin = (asin(sinangle))*180/pi;
         
           
            printf("Donnera un angle de %.9f\n", transformsin);
            cout << "=============================================================" << endl;
            
            printf("Ratio recherch%c : %.7f \n", 130, recherche);
            printf("R%csultat ratio #2 : %.7f \n", 130, table1);
            cout << "Engrenages " << tab1[0][0] << ", " << tab1[1][0] << ", " << tab1[2][0] << " et " << tab1[3][0] << endl;
            double sinangle1 = (table1 * 5.8)/9;
            double transformsin1 = (asin(sinangle1))*180/pi;
            printf("Donnera un angle de %.9f\n", transformsin1);
            cout << "=============================================================" << endl;
          
            printf("Ratio recherch%c : %.7f \n", 130, recherche);
            printf("R%csultat ratio #3 : %.7f \n", 130, table2);
            cout << "Engrenages " << tab2[0][0] << ", " << tab2[1][0] << ", " << tab2[2][0] << " et " << tab2[3][0] << endl;
            double sinangle2 = (table2 * 5.8)/9;
            double transformsin2 = (asin(sinangle))*180/pi;
            printf("Donnera un angle de %.9f\n", transformsin2);

            cout << "=============================================================" << endl;
           
            printf("Ratio recherch%c : %.7f \n", 130, recherche);
            printf("R%csultat ratio #4 : %.7f \n", 130, table3);
            cout << "Engrenages " << tab3[0][0] << ", " << tab3[1][0] << ", " << tab3[2][0] << " et " << tab3[3][0] << endl;
            double sinangle3 = (table3 * 5.8)/9;
            double transformsin3 = (asin(sinangle))*180/pi;
            printf("Donnera un angle de %.9f\n", transformsin3);

            cout << "=============================================================\n" << endl;
    // Fin affichage des informations
        }
        
        

Et le résultat du premier ratio est de l'arc du sinus est 44.999997467 sur le programme et sur la calculatrice c'est 44,99999684278048340310258988422.
Messages postés
15781
Date d'inscription
mardi 11 mars 2003
Statut
Contributeur
Dernière intervention
9 avril 2021
685
Alors je site

message du 9 mai à 21h30
Mon programme, pour le premier résultat, il affiche 44.999997467 et ce pour l'inverse du sinus, et sur la calculatrice il affiche 44,999997469


message du 10 mais à 17h41
Et le résultat du premier ratio est de l'arc du sinus est 44.999997467 sur le programme et sur la calculatrice c'est 44,99999684278048340310258988422.


Donc la calculatrice a changé ou tu t'es trompé quelque part? Parce qu'il y a une valeur commune, mais c'est pas celle que tu attribues à la caculette.

Il faut aussi penser que printf arrondit ce qu'il affiche.
Là par exemple, tu as écrit que tu voulais 7 décimales.
            printf("Ratio recherch%c : %.7f\n", 130, recherche);

Il y a peut-être un problème comme cela.


Enfin, tu dis vouloir absolument la même chose que la calculatrice, il faut quand envisager 2 choses:
  • la calculatrice c'est de l'électronique, elle aussi utilise des flottants et y'a un moment où rien ne garantie que sa précision soit meilleure que ton algorithme.
  • tu calcules un arcsin, avec une valeur proche de 45, je vais supposer que c'est en degré (valeur aberrante pour des radians et les grades sont très peu utilisés). Donc là tu bataille pour 1e-6 degrés. Ce qui est ridiculement petit, c'est environ 1.7e-8 radians. Pour rappel, 1e-3 radian correspond à un arc de cercle de 1 m pour un rayon de 1000 m. => 1,7e-8 radians correspond à peu prés à 17 microns. Evidement, si tu veux faire des calculs astronomiques, ça ne suffit pas, mais pour ce type de calculs, il y a des bibliothèques mathématiques dédiées. Dans la vie de tous les jours ça suffit plus que largement.