Programme 4 : Calcul de la distance de freinage (version 2)

Contenu du fichier

/**
\file calcul_distance_de_freinage_bis.cpp
 
 \brief Ce programme calcule la distance de freinage d'une voiture
 
 \author Benoit Fraikin
 \date 7 septembre 2007 (dernière version)
 \date 7 septembre 2007 (création)
 \version 1.0 : 7 septembre 2007
 
 \b Entrees:
 \li (cin) Vitesse \c vitesse_initiale initiale (float )
 \li (cin) Acceleration \c acceleration_initiale initiale (float )
 \li (cin) Vitesse \c vitesse_a_atteindre a atteindre (float )
 
 \b Sorties:
 \li (cout) Distance \c distance_freinage de freinage en metres (float )
 \li (cout) Distange \c distance_reaction de reaction en metres (float )
 \li (cout) Distance \c distance_ralentissement_en_metre de ralentissement en metre (float )
 \li (cout) La composante \c composante_en_milles_de_la_distance_ralentissement en mille entier de la distance de ralentissement en systeme imperial (int )
 \li (cout) La composante \c composante_en_verges_de_la_distance_ralentissement en verge entière de la distance de ralentissement en systeme imperial (int )
 \li (cout) La composante \c composante_en_pieds_de_la_distance_ralentissement en pied entier de la distance de ralentissement en systeme imperial (int )
 \li (cout) La composante \c composante_en_pouces_de_la_distance_ralentissement en pouce entier de la distance de ralentissement en systeme imperial (int )
 
 Ce programme calcule a partir de la vitesse initiale d'un vehicule
 et de l'acceleration initiale a laquelle il est soumis, la distance
 necessaire pour atteindre une vitesse choisie par l'utilisateur.
 La distance de reaction correspond au temps mis avant d'applique l'acceleration.
 La distance de freinage est la distance necessaire a partir du moment ou
 l'acceleration rentre en jeu. La distance de ralentissement est la somme des
 deux. \n
 On estime ici que le temps de reaction est constant et correspond a une seconde. \n
 Quatre distances sont affichees : la distance de reaction, celle de freinage 
 et celles de ralentissement en metre et en systeme imperial 
 (mille, verge, pied, pouce).
 La distance de ralentissement en systeme imperial est representee par 
 quatre valeurs, chacune entiere. On perd donc avec la mesure en systeme
 imperial la precision en dessous du pouces. On peut cependant estimer que
 ceci est legitime puisque de toute facon, les erreurs de mesures et les
 approximations ne permettent pas d'etre plus precis.
  
 */

#include <cmath>
#include <iostream>

using namespace std;

/**
\brief Ce programme calcule la distance de freinage d'une voiture
 */
int main ()
{
    // Declaration des constantes
    const int TEMPS_REACTION = 1 ; // temps de reaction en seconde
    const int NBRE_PIEDS_DANS_MILLE = 5280 ; // nombre de pieds dans un mille
    const int NBRE_PIEDS_DANS_VERGE = 3 ; // nombre de pieds dans une verge
    const int NBRE_POUCES_DANS_PIED = 12 ; // nombre de pouces dans un pied
    const int NBRE_POUCES_DANS_VERGE = NBRE_POUCES_DANS_PIED * NBRE_PIEDS_DANS_VERGE ; // nombre de pouces dans une verge
    const int NBRE_POUCES_DANS_MILLE = NBRE_POUCES_DANS_PIED * NBRE_PIEDS_DANS_MILLE ; // nombre de pouces dans un mille
    const float NBRE_METRES_DANS_VERGE = 0.914 ; // nombre de metres dans une verge
    const float NBRE_POUCES_DANS_METRE = NBRE_POUCES_DANS_VERGE / NBRE_METRES_DANS_VERGE ; // nombre de pouces dans un metre

    // Declaration des variables
    // Entrees
    float vitesse_initiale, acceleration_initiale, vitesse_a_atteindre ;
    
    // Sorties
    float distance_reaction ;
    float distance_freinage ;
    float distance_ralentissement_en_metres ;
    int composante_en_milles_de_la_distance_ralentissement;
    int composante_en_verges_de_la_distance_ralentissement;
    int composante_en_pieds_de_la_distance_ralentissement;
    int composante_en_pouces_de_la_distance_ralentissement;
    
    // variables pour des calculs intermediaires
    float difference_de_vitesse ;
    int distance_totale_en_pouces;
    int reste_en_pouces; // servira pour reste_milles, reste_verges et reste_pieds
    // note : reste_en_pouces est dans notre programme la seule vraie variable de notre programme
    
    
    // 1 Lire les entrées
    // 1.1    lire la vitesse initiale 
    cout << "Quel est la vitesse initiale ?" << endl;
    cin >> vitesse_initiale ;
    
    // 1.2    lire l'accéleration de freinage 
    cout << "Quel est l'acceleration de freinage initiale ?" << endl;
    cin >> acceleration_initiale ;
    
    // 1.3    lire la vitesse à atteindre 
    cout << "Quel est la vitesse a atteindre ?" << endl;
    cin >> vitesse_a_atteindre ;
    
    // 2    Calculer la distance de ralentissement en metres
    // 2.1    calculer la distance de réaction 
    distance_reaction = vitesse_initiale * TEMPS_REACTION ;
    
    // 2.2    calculer la distance de freinage 
    difference_de_vitesse = vitesse_initiale - vitesse_a_atteindre ;
    distance_freinage = ( pow(difference_de_vitesse, 2) - 2 * vitesse_initiale * difference_de_vitesse )
                        / (2 * acceleration_initiale) ;

    // 2.3    calculer la distance de ralentissement 
    distance_ralentissement_en_metres = distance_reaction + distance_freinage ;
    
    // 3   Calculer la distance de ralentissement en mesure impériale
    // 3.1    calculer la distance totale en pouces
    distance_totale_en_pouces = (int) floor(distance_ralentissement_en_metres * NBRE_POUCES_DANS_METRE) ;
    
    // 3.2    calculer la distance en milles entiers 
    composante_en_milles_de_la_distance_ralentissement = distance_totale_en_pouces / NBRE_POUCES_DANS_MILLE ;

    // 3.3    calculer le reste en pouces
    reste_en_pouces = distance_totale_en_pouces % NBRE_POUCES_DANS_MILLE ;
    
    // 3.4    calculer la distance en verges entières
    composante_en_verges_de_la_distance_ralentissement = reste_en_pouces / NBRE_POUCES_DANS_VERGE ;
    
    // 3.5    calculer le reste en pouces
    reste_en_pouces = reste_en_pouces % NBRE_POUCES_DANS_VERGE ;
    
    // 3.6    calculer la distance en pieds entiers
    composante_en_pieds_de_la_distance_ralentissement = reste_en_pouces / NBRE_POUCES_DANS_PIED ;
    
    // 3.7    calculer le reste en pouces
    reste_en_pouces = reste_en_pouces % NBRE_POUCES_DANS_PIED ;
    
    // 3.8    calculer la distance en pouces entiers
    composante_en_pouces_de_la_distance_ralentissement = reste_en_pouces ;
    
    // 4   Afficher les résultats
    // 4.1    afficher la distance de réaction
    cout << "Dr = " << distance_reaction << endl;
    
    // 4.2    afficher la distance de freinage
    cout << "Df = " << distance_freinage << endl;
    
    // 4.3    afficher la distance totale de ralentissement en metres
    cout << "D = " << distance_ralentissement_en_metres << endl;
    
    // 4.4    afficher la distance totale de ralentissement dans le système impérial
    cout << "Distance en mesure imperiale : " << endl;
    
    // 4.4.1     afficher la distance totale de ralentissement en milles entiers
    cout << composante_en_milles_de_la_distance_ralentissement << " milles," << endl ;
    
    // 4.4.2     afficher la distance totale de ralentissement en verges entières
    cout << composante_en_verges_de_la_distance_ralentissement << " verges," << endl ;
    
    // 4.4.3     afficher la distance totale de ralentissement en pieds entiers
    cout << composante_en_pieds_de_la_distance_ralentissement << " pieds," << endl ;
    
    // 4.4.4     afficher la distance totale de ralentissement en pouces entiers
    cout << composante_en_pouces_de_la_distance_ralentissement << " pouces." << endl ;
        
    // Fin du programme
    return 0;
}