Tour en Vélo

[Fermé]
Signaler
Messages postés
30
Date d'inscription
mardi 30 juin 2015
Statut
Membre
Dernière intervention
10 mai 2016
-
Messages postés
30
Date d'inscription
mardi 30 juin 2015
Statut
Membre
Dernière intervention
10 mai 2016
-
Bonjour, toute la communauté, j'espère que vous avez tous la pêche car j'aurai besoin de vos yeux aiguisés d'amateur de JAVA....

Je dois résoudre un petit exercice :

Il s'agit d'un parcours de vélo composé d'une montée suivi d'une descente.
Le début et la fin de code me sont imposés, je ne suis qu'un débutant alors quelqu'un pourrait me dire ce qui fait que ça ne fonctionne pas bien, merci.

Tous les avis seront les bienvenus, n'ayez pas peur des commentaires, je suis armé de ma volonté d'APPRENDRE !!

<code java>import java.util.Scanner;

class Cycliste {
    private static Scanner clavier = new Scanner(System.in);
    public static void main(String[] args) {

        double t = 0.0;    // temps, en min.
        double d = 0.0;    // distance, en km
        double v = 30.0;   // vitesse, en km/h
        double acc = 0.0;  // accélération, en km/h/min
        double p = 175.0;  // puissance, en W

        /******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
  int masseCycliste = 0; // Poids du cycliste

  do {
   System.out.print("masse du cycliste (entre 40 et 180 ) ? ");
   masseCycliste = clavier.nextInt();
  } while (masseCycliste <= 40 || masseCycliste >= 180);

  double vitesseVent = 0; // Vitesse du vent

  do {
   System.out.print("vent (entre -20 et +20 km/h) ? ");
   vitesseVent = clavier.nextDouble();
  } while (vitesseVent <= -20 || vitesseVent >= 20);

  double distanceParcours = d; // Distance du parcours

  do {
   System.out.print("distance du parcours (<= 200 km) ? ");
   distanceParcours = clavier.nextDouble();
  } while (distanceParcours <= 11 && distanceParcours >= 200);

  double distanceMontee = 0.0; // distance parcourue au sommet
  do {
   System.out.print("distance au sommet du col (<=" + (d - 10));
   System.out.print(" km) ? ");
   distanceMontee = clavier.nextDouble();
  } while (distanceMontee < 0 || (distanceParcours - distanceMontee) < 10);

  int penteMoyMontee = 0; // % moyen de la montée
  do {
   System.out.print("pente moyenne jusqu'au sommet (<= 20 %) ? ");
   penteMoyMontee = clavier.nextInt();
  } while (penteMoyMontee < 0 || penteMoyMontee > 20);

  int penteMoyDescente = 0;// % moyen de la descente
  do {
   System.out.print("pente moyenne après le sommet (<= 20 %) ? ");
   penteMoyDescente = clavier.nextInt();
  } while (penteMoyDescente <= 0 || penteMoyDescente > 20);

  final double pasDeTemps = 1.f / 60.f; // constante du pas de temps
  final int puissanceMinimum = 10;// constante puissance minimum
  
  while ( d < distanceMontee){   
   
  t+=5;
  v = v - vitesseVent;
  p = (p - (0.5 * pasDeTemps) + (777.6 * (p / (v * masseCycliste))));
  acc = -2118.96 * Math.sin(Math.atan(penteMoyMontee / 100)) - (5 * (v * Math.abs(v)));
  v = v + (acc * pasDeTemps);
  d = d + (v * (pasDeTemps / 60.f)); 
  //  while conditions ecritures
  double roundedTime = Math.round(t);
        if (Math.abs(roundedTime - t) < 1e-5 && (int)roundedTime % 5 == 0) {
            System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                              t, d, v, acc, p); 
        }
        if (d == distanceMontee) {
   System.out.format("## Bernard a atteint le sommet en %.0f min.\n", t);
        }
   if (p < 10 || v < 3) {
    System.out.println("## Bernard abandonne, il n'en peut plus");
          System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                            t, d, v, acc, p); 
       }
      }
        
        while ( d < distanceParcours & d > distanceMontee ){   
   
      t+=5;
      v = v - vitesseVent;
      p = 10;
      acc = -2118.96 * Math.sin(Math.atan(penteMoyMontee / 100)) - (5 * (v * Math.abs(v)));
      v = v + (acc * pasDeTemps);
      d = d + (v * (pasDeTemps / 60.f)); 
      //  while conditions ecritures
      double roundedTime = Math.round(t);
            if (Math.abs(roundedTime - t) < 1e-5 && (int)roundedTime % 5 == 0) {
                System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                                  t, d, v, acc, p); 
            }
            if (p < 10 || v < 3) {
    System.out.println("## Bernard abandonne, il n'en peut plus");
          System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                            t, d, v, acc, p); 
       }
         } 
      
        
        /*******************************************
         * Ne rien modifier apres cette ligne.
         *******************************************/

        System.out.println("## Bernard est arrivé");
        System.out.format("%.0f, %.2f, %.2f, %.4f, %.2f\n",
                          t, d, v, acc, p);
    }
}

</code>


"APPRENDRE est la seule façon de grandir ...."

2 réponses

Messages postés
1
Date d'inscription
samedi 10 octobre 2015
Statut
Membre
Dernière intervention
10 octobre 2015
1
Bonjour,
1. Il faut lire attentivement l'énoncé, car il y a des opérations manquantes, par exemple ligne 74 et 102, lorsque vous calculez l'accélération, il manque une division par la masse du cycliste
2. Pour les opérations avec des "double" ou des "float", il faut utiliser l'annotation suivante : 10.0 et non 10, par exemple ligne 74 et 102, il y a des division par 100, il faut les changer 100.0
Résumé :
Relisez bien l'énoncé, rajouter ce qui manque, changer les annotation, et réessayez.
Cordialement.
1
Merci

Quelques mots de remerciements seront grandement appréciés. Ajouter un commentaire

CCM 41713 internautes nous ont dit merci ce mois-ci

Messages postés
30
Date d'inscription
mardi 30 juin 2015
Statut
Membre
Dernière intervention
10 mai 2016

Je pense deja avoir mal formulées les variables !!
L'intitulé de l'exercice exact c'est :

"

calculer la vitesse V du vent par rapport au cycliste : c'est simplement la différence entre la vitesse du cycliste et celle du vent : V=v-vitesse du vent ;

calculer la fatigue du cycliste : si le cycliste est encore en montée et que sa puissance est supérieure à la puissance minimale (définie plus haut : 10 W), alors il perd 0.5 fois DT de puissance (il pédale moins fort à cause de la fatigue) ;

calculer l'accélération du cycliste ; elle vaut :

moins 2'118.96 fois le sinus de l'arctangente de la pente divisée par 100. (Pour ceux que la Physique intéresse, il s'agit là de l'accélération liée au poids : 2'118.96 étant 9.81×60×3.6 en raison des unités (kilomètres par heure par minute).) En Java, on écrit simplement :
« -2118.96 * Math.sin(Math.atan(pente/100)) » ;
Notez que ce terme ne change pas tant que la pente ne change pas ;

moins 5 fois V fois Math.abs(V) divisé par la masse du cycliste ; (Physique : c'est la force exercée par le vent sur le cycliste ; 5 provient de 0.3×60/3.6.)

si la puissance et la vitesse du cycliste sont toutes les deux plus grandes que zéro (i.e. s'il n'a pas posé le pied par terre), on ajoute sa poussée (il pédale) : 777.6 (60×3.6×3.6) fois sa puissance divisé par le produit de sa vitesse et de sa masse :
777.6×pv×m

si après tous ces calculs la valeur absolue de l'accélération (Math.abs(acc)) est plus petite que 10?5 (qui s'écrit « 1e-5 » en Java), alors on la mettra à 0 ;

sinon, calculer la nouvelle vitesse du cycliste en ajoutant à l'ancienne valeur le produit de l'accélération par le « pas de temps » :
v=v+acc×DT

puis mettre à jour la distance parcourue : lui ajouter le produit de la (nouvelle) vitesse et du « pas de temps » divisé par 60 : (Cette division par 60 vient des unités : la vitesse est en kilomètres par heure alors que le temps est en minutes.)
d=d+v×DT60
"
Messages postés
30
Date d'inscription
mardi 30 juin 2015
Statut
Membre
Dernière intervention
10 mai 2016

Voici dans mon fichier comment je code ces formules physiques :

<code>for ( t = 0; d<distanceMontee;t+=5){
    v = v - vitesseVent;
       p = (p - (0.5 * pasDeTemps) + ((777.6 * p) / (v * masseCycliste)));
       acc = -2118.96 * Math.sin(Math.atan(penteMoyMontee / 100)) - (5 * (vitesseVent * Math.abs(v)));
       if ((Math.abs(acc)) < 1e-5 ){
        acc = 0;
       }       
       v = v + (acc * pasDeTemps);       
       d = d + ((v * pasDeTemps )/ 60.f);// calcul des variables en fonction du pas de temps qui incrémente
</code>


SVP aidé moi, je vois pas les soucis et pourtant ils sont la !!

Merci d'avance !!
Messages postés
30
Date d'inscription
mardi 30 juin 2015
Statut
Membre
Dernière intervention
10 mai 2016

Voici le code en entier pour plus de lisibilité ( car j'ai tout repris) sans succès toute fois :

import java.util.Scanner;

class Cycliste {
    private static Scanner clavier = new Scanner(System.in);
    public static void main(String[] args) {

        double t = 0.0;    // temps, en min.
        double d = 0.0;    // distance, en km
        double v = 30.0;   // vitesse, en km/h
        double acc = 0.0;  // accélération, en km/h/min
        double p = 175.0;  // puissance, en W

        /******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
		int masseCycliste = 0; // Poids du cycliste

		do {
			System.out.print("masse du cycliste (entre 40 et 180 ) ? ");
			masseCycliste = clavier.nextInt();
		} while (masseCycliste <= 40 || masseCycliste >= 180);

		double vitesseVent = 0; // Vitesse du vent

		do {
			System.out.print("vent (entre -20 et +20 km/h) ? ");
			vitesseVent = clavier.nextDouble();
		} while (vitesseVent <= -20 || vitesseVent >= 20);

		double distanceParcours = d; // Distance du parcours

		do {
			System.out.print("distance du parcours (<= 200 km) ? ");
			distanceParcours = clavier.nextDouble();
		} while (distanceParcours <= 11 && distanceParcours >= 200);

		double distanceMontee = 0.0; // distance parcourue au sommet
		do {
			System.out.print("distance au sommet du col (<=" + (d - 10));
			System.out.print(" km) ? ");
			distanceMontee = clavier.nextDouble();
		} while (distanceMontee < 0 || (distanceParcours - distanceMontee) < 10);

		int penteMoyMontee = 0; // % moyen de la montée
		do {
			System.out.print("pente moyenne jusqu'au sommet (<= 20 %) ? ");
			penteMoyMontee = clavier.nextInt();
		} while (penteMoyMontee < 0 || penteMoyMontee >= 20);

		int penteMoyDescente = 0;// % moyen de la descente
		do {
			System.out.print("pente moyenne après le sommet (<= 20 %) ? ");
			penteMoyDescente = clavier.nextInt();
		} while (penteMoyDescente <= 0 || penteMoyDescente >= 20);

		final float pasDeTemps = 1.f / 60.f; // constante du pas de temps
		final int puissanceMinimum = 10;// constante puissance minimum
		
		
		if (d<distanceMontee){
			
			for ( t = 0; d<distanceMontee;t+=5){
				v = v - vitesseVent;
	    		p = (p - (0.5 * pasDeTemps) + ((777.6 * p) / (v * masseCycliste)));
	    		acc = -2118.96 * Math.sin(Math.atan(penteMoyMontee / 100)) - (5 * (vitesseVent * Math.abs(v)));
	    		if ((Math.abs(acc)) < 1e-5 ){
	    			acc = 0;
	    		}	    		
	    		v = v + (acc * pasDeTemps);	    		
	    		d = d + ((v * pasDeTemps )/ 60.f);// calcul des variables en fonction du pas de temps qui incrémente
	    		
				double roundedTime = Math.round(t);
				if (Math.abs(roundedTime - t) < 1e-5 && (int)roundedTime % 5 == 0) {
					System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                              t, d, v, acc, p);	
					
        }
				}
		}
		else {
			if ( d>distanceMontee && d < distanceParcours ){//sous-entendu après sommet donc descente
			double tpsMontée;
			tpsMontée = t;// comment trouver le tps de la montée qui est dans la boucle précédente ?
			for (t=tpsMontée;d<distanceParcours;t+=5){
				v = v - vitesseVent;
	    		p = 10;
	    		acc = -2118.96 * Math.sin(Math.atan(penteMoyMontee / 100)) - (5 * (v * Math.abs(v)));
	    		v = v + (acc * pasDeTemps);
	    		d = d + ((v * pasDeTemps )/ 60.f);	
			}
		}
			else {
				 if (p < 10 || v < 3) {
						System.out.println("## Bernard abandonne, il n'en peut plus");
				        System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
				                          t, d, v, acc, p);	
				 }
				if (d == distanceMontee ){
					System.out.format("## Bernard a atteint le sommet en %.0f min.\n", t);	
			}
			}
    		  
									
		}
    /*******************************************
     * Ne rien modifier apres cette ligne.
     *******************************************/

    System.out.println("## Bernard est arrivé");
    System.out.format("%.0f, %.2f, %.2f, %.4f, %.2f\n",
                      t, d, v, acc, p);
}
}
Messages postés
30
Date d'inscription
mardi 30 juin 2015
Statut
Membre
Dernière intervention
10 mai 2016

j'y suis presque sauf l'arrondi de l'accélération auquel il manque 0.01

Quelqu'un voit ce qu'il se passe ?

Merci de prendre un peu de votre temps

import java.util.Scanner;

class Cycliste {
    private static Scanner clavier = new Scanner(System.in);
    public static void main(String[] args) {

        double t = 0.0;    // temps, en min.
        double d = 0.0;    // distance, en km
        double v = 30.0;   // vitesse, en km/h
        double acc = 0.0;  // accélération, en km/h/min
        double p = 175.0;  // puissance, en W

        /******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
		
		double masseCycliste; // Poids du cycliste
        double vent;// vitesse du vent
        double dtot; // distance totale du parcours
        double lmonté;// longueuur de la montée
        double Pmontée;// pourcentage moyen montée
        double Pdescente; //pourcentage moyen descente
        
		do {
			System.out.print("masse du cycliste (entre 40 et 180 ) ? ");
			masseCycliste = clavier.nextInt();
		} while (masseCycliste <= 40 || masseCycliste >= 180);

		

		do {
			System.out.print("vent (entre -20 et +20 km/h) ? ");
			vent= clavier.nextDouble();
		} while (vent<= -20 || vent >= 20);

		

		do {
			System.out.print("distance du parcours (<= 200 km) ? ");
			dtot = clavier.nextDouble();
		} while (dtot <= 10 && dtot >= 200);


		do {
			System.out.print("distance au sommet du col (<=" + (d - 10));
			System.out.print(" km) ? ");
			lmonté = clavier.nextDouble();
		} while (dtot <= 0 || (dtot - lmonté) <= 10);


		do {
			System.out.print("pente moyenne jusqu'au sommet (<= 20 %) ? ");
			Pmontée = clavier.nextInt();
		} while (Pmontée <= 0 || Pmontée >= 20);

		
		do {
			System.out.print("pente moyenne après le sommet (<= 20 %) ? ");
			Pdescente = clavier.nextInt();
		} while (Pdescente <= 0 || Pdescente >= 20);

	      
	 
	 
	 
	        // ==== SIMULATION ====
	 
	 
	       double t1;
	       double d1;
	 
	       	float a = 1;
	        float b = 60;
	        double Dt = a/b; 
	        double P_Min = 10;
	      
	 
	 
	 
	 
	      // affichage des informations courantes :	
	       System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
	               t, d, v, acc, p);
	 
	         do {	        	 
	 
	     
	                if (lmonté > 0 && p> P_Min ) { p = p-0.5*Dt;}	   // calcul fatigue cycliste  	
	       	
	                	t1 =(t+Dt); // incrémentation du temps
	                	t = t1;       	         	
	       		
	                	d1 = (d+v*(Dt/60.f)); // mise à jour de la distance
	                	d=d1;        	
	       
	                	double V = v-vent;                             
	     
	                	acc = (-2118.96*Math.sin(Math.atan(Pmontée/100.f)))-((5*V*(Math.abs(V)/masseCycliste)));       // calcul vitesse accélaration :                        		
	                		if (p>0 && v>0){ 
	                			acc = acc+(777.6*(p/(v*masseCycliste)));
	                			}        		                		
	                		{
	                			if (Math.abs(acc)< 1e-5)  {
	                				acc= 0;
	                		}                		
	                	v = v+acc*Dt;
	                	}              	        			
	 
	                		if (v<=3) {System.out.println("## Bernard abandonne, il n'en peut plus");
	                		System.out.format("%.0f, %.2f, %.2f, %.4f, %.2f\n",
	                				t, d, v, acc, p); 
	                		return;}
	 
	                         double roundedTime = Math.round(t);	
	                         	if (Math.abs(roundedTime - t) < 1e-5 && (int)roundedTime % 5 == 0) {
	                        	 System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
	                              t, d, v, acc, p); } 
	 
	 
	         			}
	         				while(lmonté>=d1);		
	         				System.out.format("## Bernard a atteint le sommet en %.0f min.\n", t);
	 
		 
	         do {   //calcul en descente
	        	 p = P_Min;    	 
	 
	 	
	        	 t1 = (t+Dt);// incrémentation du temps
	        	 t = t1;	 
	  		
	        	 d1 = d+v*(Dt/60);  // mise à jour de la distance
	        	 d=d1;
	 
	  
	         double V = v-vent;  // calcul vitesse du vent      
	  
	       	acc = (-2118.96*Math.sin(Math.atan(-Pdescente/100.f)))-((5*V*(Math.abs(V)/masseCycliste)));// calcul accélération
	 
	 
	         		if (p>0 && v>0) {
	         			acc = acc+(777.6*(p/(v*masseCycliste)));
	         			}        		
	 
	         		{
	         			if (Math.abs(acc)<1e-5){
	         			acc= 0;
	         			}
	 
	         			v = v+acc*Dt;
	         		}	
	         double roundedTime = Math.round(t);	
	         if (Math.abs(roundedTime - t) < 1e-5 && (int)roundedTime % 5 == 0) {
	         			System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
	                               t, d, v, acc, p); }
	         }while((dtot)>=d1);
	         
				/*******************************************
		         * Ne rien modifier apres cette ligne.
		         *******************************************/

		        System.out.println("## Bernard est arrivé");
		        System.out.format("%.0f, %.2f, %.2f, %.4f, %.2f\n",
		                          t, d, v, acc, p);
		    }
		}
Messages postés
30
Date d'inscription
mardi 30 juin 2015
Statut
Membre
Dernière intervention
10 mai 2016
>
Messages postés
30
Date d'inscription
mardi 30 juin 2015
Statut
Membre
Dernière intervention
10 mai 2016

problème d'arrondi de la distance à 10-2 près pas accélération :
Messages postés
30
Date d'inscription
mardi 30 juin 2015
Statut
Membre
Dernière intervention
10 mai 2016

Cette méthode d'arrondi ne change rien toujours écart de 10e-2, à l'affichage :

import java.util.Scanner;

class Cycliste {
    private static Scanner clavier = new Scanner(System.in);
    public static void main(String[] args) {

        double t = 0.0;    // temps, en min.
        double d = 0.0;    // distance, en km
        double v = 30.0;   // vitesse, en km/h
        double acc = 0.0;  // accélération, en km/h/min
        double p = 175.0;  // puissance, en W

        /******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
		
		float masseCycliste; // Poids du cycliste
        double vent;// vitesse du vent
        double dtot; // distance totale du parcours
        double lmonté;// longueuur de la montée
        double pourcentageMontée;// pourcentage moyen montée
        double pourcentageDescente; //pourcentage moyen descente
        
		do {
			System.out.print("masse du cycliste (entre 40 et 180 ) ? ");
			masseCycliste = clavier.nextFloat();
		} while (masseCycliste <= 40 || masseCycliste >= 180);

		

		do {
			System.out.print("vent (entre -20 et +20 km/h) ? ");
			vent= clavier.nextDouble();
		} while (vent<= -20 || vent >= 20);

		

		do {
			System.out.print("distance du parcours (<= 200 km) ? ");
			dtot = clavier.nextDouble();
		} while (dtot <= 10 && dtot >= 200);


		do {
			System.out.print("distance au sommet du col (<=" + (d - 10));
			System.out.print(" km) ? ");
			lmonté = clavier.nextDouble();
		} while (dtot <= 0 || (dtot - lmonté) <= 10);


		do {
			System.out.print("pente moyenne jusqu'au sommet (<= 20 %) ? ");
			pourcentageMontée = clavier.nextDouble();
		} while (pourcentageMontée <= 0 || pourcentageMontée >= 20);

		
		do {
			System.out.print("pente moyenne après le sommet (<= 20 %) ? ");
			pourcentageDescente = clavier.nextDouble();
		} while (pourcentageDescente <= 0 || pourcentageDescente >= 20);

	      
	 
	 
	 
	        // ==== SIMULATION ====
	 
	 
	       double t1;
	       double d1;
	 
	       	float a = 1;
	        float b = 60;
	        float deltaT = a/b; 
	        double P_Min = 10;
	      
	 
	 
	 
	 
	      // affichage des informations courantes :	
	       System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
	               t, d, v, acc, p);
	 
	         do {	        	 
	 
	     
	                if (lmonté > 0 && p> P_Min ) { p = p-0.5*deltaT;}	   // calcul fatigue cycliste  	
	       	
	                	t1 =(t+deltaT); // incrémentation du temps
	                	t = t1;       	         	
	       		
	                	d1 = (d+v*(deltaT/60)); // mise à jour de la distance
	                	d=d1;        	
	                	/* Arrondir la valeur a 10^-2 */
	                	d1 *= 100;
	                	d1 = (int)(a+.5);
	                	d1 /= 100;
	                	double V = v-vent;   
	                	
	                	// calcul vitesse accélaration : 
	                	acc = (-2118.96*Math.sin(Math.atan(pourcentageMontée/100.f)))-((5*V*(Math.abs(V)/masseCycliste))); 
	                	                       		
	                		if (p>0 && v>0){ 
	                			acc = acc+(777.6*(p/(v*masseCycliste)));
	                			  		}        		                		
	                		{
	                			if (Math.abs(acc)< 1e-5)  {
	                				acc= 0;
	                		}                		
	                	v = v+acc*deltaT;
	                	}              	        			
	 
	                		if (v<=3) {System.out.println("## Bernard abandonne, il n'en peut plus");
	                		System.out.format("%.0f, %.2f, %.2f, %.4f, %.2f\n",
	                				t, d, v, acc, p); 
	                		return;}
	 
	                         double roundedTime = Math.round(t);	
	                         	if (Math.abs(roundedTime - t) < 1e-5 && (int)roundedTime % 5 == 0) {
	                        	 System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
	                              t, d, v, acc, p); } 
	 
	 
	         			}
	         				while(lmonté>=d1);		
	         				System.out.format("## Bernard a atteint le sommet en %.0f min.\n", t);
	 
		 
	         do {   //calcul en descente
	        	 p = P_Min;    	 
	 
	 	
	        	 t1 = (t+deltaT);// incrémentation du temps
	        	 t = t1;	 
	  		
	        	 d1 = d+v*(deltaT/60.f);  // mise à jour de la distance
	        	 d=d1;
	        	 /* Arrondir la valeur a 10^-2 */
             	d1 *= 100;
             	d1 = (int)(a+.5);
             	d1 /= 100;
	  
	         double vitesseFvent = v-vent;  // calcul vitesse du vent      
	  
	       	acc = (-2118.96*Math.sin(Math.atan(-pourcentageDescente/100.f)))-((5*vitesseFvent*(Math.abs(vitesseFvent)/masseCycliste)));// calcul accélération
	       	
	 
	         		if (p>0 && v>0) {
	         			acc = acc+(777.6*(p/(v*masseCycliste)));
	         			  }        		
	 
	         		{
	         			if (Math.abs(acc)<1e-5){
	         			acc= 0;
	         			}
	 
	         			v = v+acc*deltaT;
	         		}	
	         double roundedTime = Math.round(t);	
	         if (Math.abs(roundedTime - t) < 1e-5 && (int)roundedTime % 5 == 0) {
	         			System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
	                               t, d, v, acc, p); }
	         }while((dtot)>=d1);
	         
				/*******************************************
		         * Ne rien modifier apres cette ligne.
		         *******************************************/

		        System.out.println("## Bernard est arrivé");
		        System.out.format("%.0f, %.2f, %.2f, %.4f, %.2f\n",
		                          t, d, v, acc, p);
		    }
}