Discussion :

[Togno]

Bonjour à tous,

Je suis débutant en python et essaye de me réaliser un petit script pour effectuer un calcul. Pour gagner en précision j'ai utiliser le module Decimal afin d'avoir plus que les 14 chiffres significatifs de base des float.

Cependant j'ai un soucis avec abs() qui me détruit la précision de mon Decimal. J'ai essayé copy_abs et __abs__() présents dans la documentation mais mon interpréteur ne le reconnait pas.

Auriez-vous une solution à me propose ?

[wiztricks]

Salut,

Cependant j'ai un soucis avec abs() qui me détruit la précision de mon Decimal. J'ai essayé copy_abs et __abs__() présents dans la documentation mais mon interpréteur ne le reconnait pas.

Sous ma version de Python (3.4), la fonction builtins abs et la méthode .copy_abs() retournent un decimal et préservent la précision.
Vous utilisez quelle version?
Poster le code que vous avez essayé pourrait aussi aider à comprendre votre soucis.

- W

[Togno]

Bonjour,

Merci de votre réponse rapide.


Je cherche a trouver une présentation rationnelle sous la forme P/Q de ln(pi) qui soit la plus précise possible. J'ai facilement été jusqu'a une solution "parfaite" avec la précision que permettent les float. Maintenant je cherche a aller plus loin tout en limitant au max les calculs et donc le temps d'execution. Mais ma variable renvoyant mon erreur perd ses chiffres significatifs petit a petit.

Je ne comprend pas pourquoi. J'ai fait des essais et effectivement ce n'est pas abs() le coupable.



Voici mon code :

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
from math import *
from decimal import *
 
 
 
getcontext().prec=14
i=Decimal(14)
y=14
jesus=Decimal(log(pi))*Decimal(1)
P=Decimal(5)
 
n=Decimal(0.01)
precision=Decimal(100)
 
while P<10000000000000000001:
    jesus=Decimal(log(pi))*Decimal(1)
    Q=P//(Decimal(log(pi))*Decimal(1)+10**(-i-1))
    while Q<=P:
        if (P/Q)<(Decimal(log(pi))*Decimal(1)+10**(-i+1)):
            Q=P
        elif abs(precision)>abs((P/Q)-jesus):
            precision = (P/Q)-jesus
            a=P
            b=Q
            print("a=", a, "b=", b, "precision=", precision)
 
        Q+=1
 
    if P==Decimal(10000000000000000000)*n:
        print (100*n, "%")
        n+=1
    if precision<Decimal(10)**(-y-1):
        y+=1
        i+=Decimal(1)
        getcontext().prec=y
 
    P+=1

Je re-précise que je suis novice (au cas où il y ai des absurdités).

Merci beaucoup.

[picodev]

Bonjour,
pour ce genre de chose j'aurai tendance à utiliser une bibliothèque comme sympy qui propose un calcul symbolique. Les meilleures approximations sont celles obtenues par fractions continues. Un exemple pourrait être :

Code :

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

1
2
3
4
5
6
7
8
9
10
#! /usr/bin/env python3
# -*- coding: utf8 -*-
#
 
from sympy import log,pi
from sympy.ntheory.continued_fraction import continued_fraction_convergents, continued_fraction_iterator
 
it=continued_fraction_convergents(continued_fraction_iterator(log(pi)))
for i in range(15):
  print(i, next(it))

Je commence à découvrir cette bibliothèque, mais ça pourrait être une piste à suivre.

[Togno]

Bonjour picodev,

Je viens de passer un moment a trouver comment installer votre module (j'ai eu beaucoup de mal a trouvé un tuto compréhensible pour mon niveau de connaissance).

Pourriez-vous m'expliquer ce qu'est sensé faire votre morceau de code ?

[picodev]

Alors comme les meilleures approximations rationnelles d'un irrationnel sont les réduites des fraction continues autant essayer s'approximer ln 𝜋 en les utilisant.
Le module sympy permet de faire du calcul symbolique. continued_fraction_iterator(x) donne la suite des coef de la fraction continue de x, continued_fraction_convergents prend la liste des coef pour construire la réduite qui sera une approximation de x.