Discussion :

[gigimino]

Salut à tous

Je n'arrive pas à trouver l'algo qui calcule cette expression :

1+1/3+1/5+............+1/n

avec la boucle for 'Turbo Pascal'.

Quelqu'un peut-il m'aider ??? Merci.

[droggo]

Lao,

L'algorithme est littéralement inclus dans la formule.

Comment fais-tu à la main ?

Et voilà ...

[gigimino]

Oui je sais, merci, mais j'ai un problème : le compteur i de la boucle for augmente par pas de 1 mais là, avec les nombres impairs 1 et 3 jusqu'à n, c'est ça mon problème.

Et merci.

[JeitEmgie]

FYI

http://www.jimloy.com/algebra/series.htm

[droggo]

Soa,

Oui je sais, merci, mais j'ai un problème : le compteur i de la boucle for augmente par pas de 1 mais là, avec les nombres impairs 1 et 3 jusqu'à n, c'est ça mon problème.

Et merci.

Un compteur de boucle est un compteur, absolument rien ne t'oblige à t'en servir directement pour les calculs, tu peux t'en servir pour mettre à jour une variable intermédiaire.

Même pour un débutant, j'ai de la peine à croire qu'on reste bloqué par ça, une petite réflexion aurait dû t'indiquer une marche à suivre.

[l_autodidacte]

On est tous passé par cette étape je suppose !
Le lien donné plus haut pour les séries mathématiques ne résout pas le problème ni les remarques un peu décourageantes.

Je dirais plutôt qu'indiquer une, parmi d'autres, méthode de test est plus appropriée que d'être un peu sec dans la réponse ou les remarques.

1 - Déclare un compteur entier et une limite (n entier) supérieure
2 - Déclare un réel(Sum par exemple) qui reçoit le résultat du calcul.
3 - A l'intérieur d'une boucle For ....Do , ajoute la condition si Compteur impair faire le calcul( cela se fait aisément avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

IF ODD(Compteur) Then

4 - Affecte le résultat à la variable réelle déclarée plus haut et initialisée à 0(zéro):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Sum:=Sum +1/Compteur;

[JeitEmgie]

Le lien donné plus haut pour les séries mathématiques ne résout pas le problème [/code]

"S=1+1/3+1/5+1/7+1/9+1/11... (with odd denominators)? Well, every term is greater than the corresponding term in the 1/prime series, and so it also diverges"

Ce qui signifie qu'il existe un N à partir duquel le résultat mathématique ne sera plus représentable par les types flottants natifs (float, double, long double) d'un ordinateur.
Ce qui signifie aussi qu'il existe un M à partir duquel 1/M sera <<<< S et que vu la façon dont les flottants sont stockés dans un ordinateur ordinaire, S + 1/M = S autrement dit la somme ne sera plus modifiée, et donc le résultat obtenu sur ordinateur dépendra uniquement du type de flottant choisi et n'aura donc rien à voir avec le résultat mathématique : +∞.
Ce qui signifie aussi que la question du TP pose un problème plus important que de savoir faire une boucle avec un incrément de 2, et que ne pas y répondre risque de valoir une note médiocre (tout comme l'idée de faire un test de parité à chaque étape).

[droggo]

Fia,

"S=1+1/3+1/5+1/7+1/9+1/11... (with odd denominators)? Well, every term is greater than the corresponding term in the 1/prime series, and so it also diverges"

Ce qui signifie qu'il existe un N à partir duquel le résultat mathématique ne sera plus représentable par les types flottants natifs (float, double, long double) d'un ordinateur.
Ce qui signifie aussi qu'il existe un M à partir duquel 1/M sera <<<< S et que vu la façon dont les flottants sont stockés dans un ordinateur ordinaire, S + 1/M = S autrement dit la somme ne sera plus modifiée, et donc le résultat obtenu sur ordinateur dépendra uniquement du type de flottant choisi et n'aura donc rien à voir avec le résultat mathématique : +∞.
Ce qui signifie aussi que la question du TP pose un problème plus important que de savoir faire une boucle avec un incrément de 2, et que ne pas y répondre risque de valoir une note médiocre (tout comme l'idée de faire un test de parité à chaque étape).

Bien sûr, mais il s'agit d'un exercie pour débutant, et on ne lui demande pas de calculer le résultat avec une résolution infinie.

1 - Déclare un compteur entier et une limite (n entier) supérieure
2 - Déclare un réel(Sum par exemple) qui reçoit le résultat du calcul.
3 - A l'intérieur d'une boucle For ....Do , ajoute la condition si Compteur impair faire le calcul

Ce n'est pas une méthode très propre (seulement un tour sur deux vraiment utile), et ce n'est donc pas à conseiller à un débutant.

[l_autodidacte]

Ce n'est pas une méthode très propre (seulement un tour sur deux vraiment utile), et ce n'est donc pas à conseiller à un débutant.

Je n'ai pas bien saisie ta remarque.

Bien sûr il y a pas mal d'autres alternatives, j'en ai choisi la plus simple et selon le choix du demandeur(boucle For ....Do).

Une boucle While ....Do ou Repeat ....Until sera mieux adaptée dans ce cas et sans faire de test d'imparité(en faisant un incrément de 2) pour ne pas introduire une variable intermédiaire dans le calcul.

[droggo]

Hia,

Je n'ai pas bien saisie ta remarque.

Bien sûr il y a pas mal d'autres alternatives, j'en ai choisi la plus simple et selon le choix du demandeur(boucle For ....Do).

Une boucle While ....Do ou Repeat ....Until sera mieux adaptée dans ce cas et sans faire de test d'imparité(en faisant un incrément de 2) pour ne pas introduire une variable intermédiaire dans le calcul.

Et si le terme servant effectivement au calcul avait un pas de 10, 100, 1000, tu ferais une boucle dont 9, 99, 999 tours seraient inutiles ?

J'espère que non.

Alors pourquoi le faire avec un pas = 2 ?

Et si on impose une boucle for, donc un pas 1 en Pascal, on utilise une variable intermédiaire, dont la valeur dépendra du compteur de boucle.

Accessoirement, en tant qu'enseignant, je n'attribuerais pas la meilleure note à cette solution et à sa justification.

[JeitEmgie]

La série diverge mais croissant très lentement, la question est la suivante lorsqu'on travaille avec différentes combinaisons d'entiers et de flottants :

qu'est-ce qui va bloquer le premier ?

l'entier qui va atteindre le maximum de sa représentation (soit 2^bitsize_of_integer - 1 pour des entiers non signés)
ou
le flottant auquel l'ajout du 1/N de produira plus d'effet car la différence de taille d'exposant entre S et 1/N sera telle que 1/N ne sera plus significatif et donc que S+1/N vaudra toujours S…

[l_autodidacte]

Je ne pense pas que le demandeur ayant posé la question a pour but de faire un tel calcul

mais il a demandé un algo lui permettant le calcul de l'expression pour un nombre fini

d'itérations( n fini).

Dans ce cadre j'en ai proposé un(qui ne semble pas convenir à certains) dont voici l'approche avec n=99999999 et i LongInt(sous P4 3.0GHz):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
Som:=0;
For i:=1 to n do 
     Begin  
        If Odd(i) Then   som:=som+ 1/i;
   { Ce code marche très bien mais très lent ; durée d'exécution : 3mn 4s 41cs}
    End;

Une autre possibilité est ce

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 som:=0;
  For i:=1 to n Do
    Begin 
        Som:=Som+1/i -((i+1) Mod 2)/i ;
        { Ce code est environ 4 fois plus rapide que le précédent 48s 11cs}
    End;

enfin, une 3ème possibilité est ce

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 Som:=0;
   For i:=0 to n div 2 -1 Do
      Begin
          Som:=Som + 1/(2*i+1);
       {Temps d'exécution 50s 38cs.On devrait s'attendre à ce qu'il soit 
       encore plus court puisque l'intervalle est divisé par 2 !!!! mais....}
      End;

et il y a sûrement d'autres possibilités...

[JeitEmgie]

Je ne pense pas que le demandeur ayant posé la question a pour but de faire un tel calcul

mais il a demandé un algo lui permettant le calcul de l'expression pour un nombre fini

d'itérations( n fini).

Dans ce cadre j'en ai proposé un(qui ne semble pas convenir à certains) dont voici l'approche avec n=99999999…

Sauf que pour S stocké sous forme de flottant simple précision, le N max est de 2537607 ce qui est < à 99999999. Au-delà, le 1/N ne change plus la valeur de la série S qui plafonnera à 8.0 .

Pour des flottants double précision, on épuisera un entier non signé de 32 bits et S vaudra 11.725536311458622407144503085874.

[droggo]

Jai,

Sauf que pour S stocké sous forme de flottant simple précision, le N max est de 2537607 ce qui est < à 99999999. Au-delà, le 1/N ne change plus la valeur de la série S qui plafonnera à 8.0 .

Pour des flottants double précision, on épuisera un entier non signé de 32 bits et S vaudra 11.725536311458622407144503085874.

On a compris !

Mais le problème ne se pose pas pour le cas traité : il s'agit d'un exercice pour un débutant, et à ce stade, il n'a pas à se préoccuper de ça (ça viendra, mais il a le temps).

[wiwaxia]

Bonjour,

Pour évaluer l'erreur résultant du cumul des arrondis, il suffit de recalculer la somme en sens inverse, en commençant par le dernier terme.
La sommation rétrograde donne d'ailleurs le meilleur résultat, parce qu'elle commence par les termes les plus petits.

Le programme test suivant donne la somme des inverses des entiers impairs
<= n, jusqu'à 2.10^9 +1; l'écart observé entre les deux résultats atteint alors 1,31.10^-13, ce qui laisse encore 14 chiffres corrects et le dernier garanti à 1 ou 2 unités près: pas de quoi trop s'inquiéter, donc.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
 PROGRAM xxx;
 
 USES Crt;
 CONST Nmax = 2000000001; u = 11; v = 20; w = v - 3;
 TYPE Entier = LONGINT;
      Reel   = EXTENDED;
 
 VAR i, k, Imax, n: Entier;
     r, s, t, Somme, Somme1: Reel;
 
 PROCEDURE A;                            { Pause / Arrˆt du programme }
   VAR Touche: CHAR;
   BEGIN
     WHILE Keypressed DO Touche:= ReadKey; REPEAT UNTIL KeyPressed;
     WHILE Keypressed DO Touche:= ReadKey; IF Touche=#27 THEN Halt
   END;
 
{****************************************************************************
*                                                                           *
*   Programme principal                                                     *
*                                                                           *
****************************************************************************}
 
 BEGIN
   TextBackGround(0); TextColor(15); ClrScr;
   REPEAT
     GotoXY(u,10); ClrEol;
		 Write('n = '); Read(n)
   UNTIL (n<=Nmax);
   s:= 0; Imax:= n DIV 2;
   FOR i:= 0 TO Imax DO BEGIN
                          k:= 2 * i; Inc(k);
                          r:= 1 / k; t:= r + s;	s:= t
	                    END;
   Somme:= s; GotoXY(v, u+2); Write(Imax:u, k:u, '     ', Somme:v:w);
 
   s:= 0;
   FOR i:= Imax DOWNTO 0 DO BEGIN
                              k:= 2 * i; Inc(k);
                              r:= 1 / k; t:= r + s;	s:= t
	                          END;
   Somme1:= s;         GotoXY(v, u+4);
	 Write(Imax:u, k:u, '     ', Somme1:v:w);
   r:= Somme - Somme1; GotoXY(v+u, u+6);
	 Write('Ecart          ',  r:v:w);
   A
 END.

[JeitEmgie]

Mais le problème ne se pose pas pour le cas traité : il s'agit d'un exercice pour un débutant, et à ce stade, il n'a pas à se préoccuper de ça (ça viendra, mais il a le temps).

et ce n'est pas le but d'une formation qu'un étudiant fasse faire ses TPs par d'autres…
surtout quand la question posée concerne le b.a.ba de la syntaxe d'un langage…
si l'étudiant ne sait pas lire une syntaxe BNF, on peut le guider, mais lui donner la solution toute cuite : non.
(et a fortiori si la solution proposée frise le ridicule…)

[droggo]

Hoa,

et ce n'est pas le but d'une formation qu'un étudiant fasse faire ses TPs par d'autres…
surtout quand la question posée concerne le b.a.ba de la syntaxe d'un langage…
si l'étudiant ne sait pas lire une syntaxe BNF, on peut le guider, mais lui donner la solution toute cuite : non.
(et a fortiori si la solution proposée frise le ridicule…)

Si tu suis un tant soit peu les messages des membres réguliers, tu dois savoir que je ne cesse de le répéter.

[olfakrid]

je propose ce programme pour débutant sans notion avancées pour calculer s1 =1+1/2+1/3+....1/n ;;;s2=1+1/3+1/5+...........1/n;;;s3=1/2+1/4+1/6+.....1/n-1 avec n positif et impair pour les 3 sommes :
solution ci jointe

[droggo]

Hoe,

Nous refiler un fichier Word pour donner le listing d'un programme, je crois que c'est une première !

Et je me demande pourquoi une telle démarche, alors qu'un simple fichier texte fait parfaitement l'affaire, étant la forme d'origine de n'importe quel environnement de développement Pascal.

Bref, pour un premier message, je trouve l'approche assez limite.

ps : je n'ai pas téléchargé le fichier, car je ne pourrais pas le lire (eh oui, j'utilise une vieille version d'Office, je n'ai pas les moyens de systématiquement acheter la dernière en date).

[batyann811]

Tu aurais du ouvrir car c'est encore plus drôle.

Le fichier Word contient un document d'une seule page qui contient une image qui est une capture d'un écran TP7 affichant le programme.

Déjà une capture d'écran pour un simple texte c'est lourd mais aller, en plus, coller ça dans un document Word tout en déterrant un sujet vieux de plus d'un an...