Pi

[invite3d7be5ae]

Bonjour,
je vous propose un programme qui calcul pi. Je l'ai fait en Turbo Pascal.
Sa particularité est qu'il n'utilise aucun nombre réel!

Attention : ne pas prendre le maximum (enlevez environ 10)!
-----

[invite3d7be5ae]

Normalement, il est en pièce jointe.
Je le remet ici.

[invite97a92052]

Extensions de fichiers valides: bmp gif jpeg jpg pdf png

Essaye d'héberger ton programme sur un serveur...

[invite3d7be5ae]

Comment on fait???????

Zut, je croyais qu'on pouvait mettre des fichiers .zip.

[A voir en vidéo sur Futura]

[invite0f5c0a62]

ben en même temps le pascal c'est du texte tu peux aussi faire un ou deux copier coller sur tes posts

ça doit pas être très gros ton programme, sinon explique nous l'algorithme que tu utilise

[invite3d7be5ae]

D'accord mais vous ne pourrez pas l'éxécuter.

program pi22;

uses crt;

const maxtab1=7810;

var retenue :longint;
pi_tableau :array[1..maxtab1] of longint;
pi_decimales:array[1..trunc(maxtab1/3.32)] of byte;
nbdeci,nbcol,i,k:1..maxtab1;
reponse :char;


procedure initia;
var i:1..maxtab1;
begin
clrscr;
writeln('Je vais vous calculer le nombre pi.');
write('Donne-moi le nombre de décimales (compris entre 0 et ',trunc(maxtab1 / 3.32),') : ');
readln(nbdeci);
nbcol:=trunc(nbdeci*3.32)+1;
for i:=1 to nbcol do pi_tableau[i]:=2;
retenue:=0;
end;


begin
repeat;
initia;
writeln;
write('Voici les décimales de pi que j''ai calculé : ');
for k:=1 to nbdeci do
for i:=nbcol downto 1 do
begin
pi_tableau[i]:=(pi_tableau[i]*10)+retenue;
if i=1 then begin
retenue:=0; (** enregistrement de la d‚cimale **)
pi_decimales[k]:=pi_tableau[1] div 10;
pi_tableau[1]:=pi_tableau[1] mod 10;
if pi_decimales[k]>9 then
begin
pi_decimales[k-1]:=pi_decimales[k-1]+(pi_decimales[k] div 10);
pi_decimales[k]:=pi_decimales[k] mod 10;
pi_tableau[1]:=pi_tableau[1] mod 10;
if k>1 then write(pi_decimales[k-1]);
if k=2 then write (',');
end (********* jusqu'ici ************)
else begin
if k>1 then write(pi_decimales[k-1]);
if k=2 then write (',');
end;
end
else begin
retenue:=pi_tableau[i] div(2*i-1); (** calcul de la retenue **)
retenue:=retenue*(i-1);
pi_tableau[i]:=pi_tableau[i] mod(2*i-1); (** calcul du reste **)
end;
end;
writeln;
writeln('Veux-tu recommencer? (o ou n)');
reponse:=readkey;
write(reponse);
until reponse='n';
end.



Et voilà, cherchez maintenant un compilateur sur Google.
Ne cherchez pas avec Delphi.

Le mien marche uniquement en mode Ms-Dos.

[invite3d7be5ae]

Maintenant sans les décalages qui ont disparu dans le copier-coller, ce n'est plus très lisible.

Bonne lecture!!

[invite3d7be5ae]

Voilà un exemple :
Voici les décimales de pi que j'ai calculé : 3,1415926535897932384626433832 795028841971693993751058209749 445923078164062862089986280348 2534211706798214808651328
230664709384460955058223172535 940812848111745028410270193852 11055596446229489549
30381964

1 seconde sur un 700Mhz.

1000:6 secondes

2000:20 secondes

P.S. : Voilà les décimales que je connais par coeur :
3,1415926535897932384626433832 795028841971693993751059209749 4459230781640628620

Il y a en a 78.

[fragman]

Un expert pyschiatre japonais de 59 ans a pulvérisé samedi le record mondial de mémorisation du nombre "pi" en alignant par coeur 83.431 décimales.

Il a fallu 13 heures à Akira Haraguchi pour accomplir l'exploit, parfaitement inutile, dans un hall public de Kisarazu (banlieue sud de Tokyo).

Le précédent record, selon le livre Guinness des record, était de 42.195 décimales.

Cet exploit est une spécialité nippone puisque le record appartenait depuis 1995 à un ancien étudiant japonais.

M. Haraguchi était déjà parvenu à réciter à la suite 54.000 décimales de pi en septembre dernier, mais le record n'avait pas été homologué car il avait dépassé le temps imparti par les organisateurs.

Cette fois, il n'y avait pas de limite de temps.

[invite9565d975]

Sa particularité est qu'il n'utilise aucun nombre réel!

Ah bon, il n'utilise que des nombres complexes ?

Plus sérieusement, il y a aussi la formule BBP dont on peut tirer un algo intéressant puisqu'elle permet de déterminer le nième digit de pi sans avoir à calculer les précédents !

[invite4793db90]

Plus sérieusement, il y a aussi la formule BBP dont on peut tirer un algo intéressant puisqu'elle permet de déterminer le nième digit de pi sans avoir à calculer les précédents !

En hexadécimale cependant.

Cordialement.

[invite3d7be5ae]

Je voulais dire : il n'utilise que des nombres entiers qui sont différent des nombres réels en programmation.
Car les nombres réels (en programmation) n'ont que 20 décimales que l'on peut avoir dont 3 fausses.

[invitedebe236f]

programme traduit en vb
j espere que je fait pas d erreur

Option Explicit
Const maxtab1 = 50000
Dim retenue As Long
Dim pi_tableau(maxtab1) As Long
Dim pi_decimales(Int(maxtab1 / 3.32)) As Integer

Dim st As String
Dim Nbdeci, nbcol As Integer


Sub initia()

Dim i As Integer

Nbdeci = 2000
nbcol = Int(Nbdeci * 3.32) + 1
For i = 1 To nbcol
pi_tableau(i) = 2
Next i
retenue = 0
End Sub


Sub b()
Dim k As Integer
Dim i As Long
st = ""
initia

For k = 1 To Nbdeci
For i = nbcol To 1 Step -1
pi_tableau(i) = (pi_tableau(i) * 10) + retenue
If i = 1 Then
retenue = 0
pi_decimales(k) = Int(pi_tableau(1) / 10)
pi_tableau(1) = pi_tableau(1) Mod 10
If pi_decimales(k) > 9 Then
pi_decimales(k - 1) = pi_decimales(k - 1) + Int(pi_decimales(k) / 10)
pi_decimales(k) = pi_decimales(k) Mod 10
pi_tableau(1) = pi_tableau(1) Mod 10
If k > 1 Then st = st & pi_decimales(k - 1)
If k = 2 Then st = st & ","
Else
If k > 1 Then st = st & pi_decimales(k - 1)
If k = 2 Then st = st & ","
End If
Else
retenue = Int(pi_tableau(i) / (2 * i - 1))
retenue = retenue * (i - 1)
pi_tableau(i) = pi_tableau(i) Mod (2 * i - 1)
End If
Next i
Next k
MsgBox "pi=" & st
End Sub

[invitead065b7f]

Bonjour,

n'y aurait-il pas une âme charitable pour donner tout simplement l'algorithme, ou alors traduire le programme dans un vrai langage (en OCaml quoi ). Sur quelle formule est basée ton algo ? J'avoue que j'ai la flemme de tout éplucher, surtout que je ne connais ni Pascal ni VB...


Quand j'étais jeune, j'avais créé un programme pour ma calculatrice à partir de la formule du développement série d'arctangente. C'était pas très efficace, mais je pense que c'étais en partie dûe à la machine.

Amicalement,
Moma

[invite4793db90]

Quand j'étais jeune, j'avais créé un programme pour ma calculatrice à partir de la formule du développement série d'arctangente. C'était pas très efficace, mais je pense que c'étais en partie dûe à la machine.

Euh non, c'est dû à la formule qui converge très très lentement.

Sinon, j'avoue aussi que si quelqu'un se dévoue pour éclaircir un peu les codes précédents, je suis preneur.

Cordialement.

[invitedebe236f]

je crois qu il utile ca si j ai bien comprit

Une des méthodes pour écrire le nombre Pi en décimal consiste à convertir en base 10 le nombre 2,222222222222... exprimé au départ dans la base d'Euler à pas variable. L'avantage de cette technique pour calculer Pi est que le temps de calcul sera constant pour sortir toutes les décimales, de la première à la dernière

[invitec314d025]

Une des méthodes pour écrire le nombre Pi en décimal consiste à convertir en base 10 le nombre 2,222222222222... exprimé au départ dans la base d'Euler à pas variable.

C'est quoi la base d'Euler à pas variable ?

[invite4793db90]

C'est quoi la base d'Euler à pas variable ?

Salut,

j'ai trouvé ceci (milieu de page).

Cordialement.

[invitec314d025]

Merci beaucoup.

[invite3d7be5ae]

Si vous voulez, il existe un programme du même type pour e (mais plus rapide) :

program e22;

uses crt,crt2;

const maxtab1=10843;
col_deci=0.506;

var retenue :longint;
e_tableau :array[1..maxtab1] of longint;
e_decimales:array[1..trunc(maxtab1/col_deci)]of byte;
nbdeci,nbcol,i,k:longint;
reponse :char;


procedure initia;
var i:1..maxtab1;
begin
clrscr;
writeln('Je vais vous calculer le nombre e.');
write('Donne-moi le nombre de décimales (compris entre 0 et ',trunc(maxtab1/col_deci),') : ');
readln(nbdeci);
nbdeci:=nbdeci+2;
if nbdeci<25 then nbcol:=trunc(1.4*nbdeci)+1
else if nbdeci<95 then nbcol:=nbdeci
else if nbdeci<500 then nbcol:=trunc(nbdeci*0.7)
else nbcol:=trunc(nbdeci*col_deci);
for i:=1 to nbcol do e_tableau[i]:=1;
retenue:=0;
end;


begin
repeat;
initia;
writeln;
write('Voici les décimales de e que j''ai calculé : ');
for k:=1 to nbdeci do
for i:=nbcol downto 1 do
begin
e_tableau[i]:=(e_tableau[i]*10)+retenue;
if i=1 then begin
retenue:=0; (** enregistrement de la d‚cimale **)
e_decimales[k]:=e_tableau[1] div 10;
e_tableau[1]:=e_tableau[1] mod 10;
if k>1 then write(e_decimales[k-1]);
if k=2 then write (',');
end
else begin
retenue:=e_tableau[i] div(i-1); (** calcul de la retenue **)
e_tableau[i]:=e_tableau[i] mod(i-1); (** calcul du reste **)
end;
end;
writeln;
writeln('Veux-tu recommencer? (o ou n)');
readk(reponse,['o','n']);
until reponse='n';
end.