Bonsoir,

Sous réserve de validation des experts,  langage Python est bien adapté pour calculer ce genre de résultats.

Bonjour
Sur mon vieil ordinateur mon petit programme en Basic ne me donne que 14 décimales (toutes exactes ?).
Pour la somme des 100 000 000 premières racines carrées il met 134 secondes et me donne 666666671666.458784566114608.
Je pense que Python ferait mieux. SVP

Personne pour faire ces quelques lignes de code ? Car je ne connais pas (encore) Python.

Bonjour,
Ce que donne Maple avec 30 chiffres significatifs :


PDF - 88 Ko

Merci lake, je vais pouvoir comparer.

Je ne trouve pas la même chose que lake pour les derniers chiffres

import decimal
from multiprocessing.dummy import Pool as ThreadPool

precision = 100
decimal.getcontext().prec = precision

def sum_of_sqrt(u):
    decimal.getcontext().prec = precision
    return sum(decimal.Decimal(k).sqrt() for k in range(*u))


if __name__ == "__main__":
    n = 100_000
    nb_procs = 32
    
    segment_size = n // nb_procs
    jobs = map(lambda k: (k,min(n+1,k+segment_size)), range(1,n+1,segment_size))
    
    
    pool = ThreadPool(nb_procs)
    r = pool.map(sum_of_sqrt, jobs)
    
    pool.close()
    pool.join()
    
    #print(r)
    print(sum(r))

Bonjour Ulmière,
J'avais pris la précaution d'écrire :

Si tu fais le même calcul sur Maple avec un nombre de décimales plus élevé comme 100 ou 200, tu trouves plus de chiffres en commun avec les miens ?

Par exemple, si je demande une précision de 300 chiffres (272 apès la virgule), je trouve

21082008.973917740557444841993793776689559770029192679907126829058520
907189362394675376032463212439720486514999790107305918535871407408377
123975883566772378876405609244289884801891966912275184850811348092082
470371461687194471862054978705791172531657479322010392197196765548335
7313312159930363711682695


résultat qui prolonge le précédent.

Pour une précision de 30, je trouve 21082008.9739177405574448419937

Bonjour
Merci pour votre collaboration. Si je vous comprends, difficile de faire confiance en totalité à ces logiciels.  On peut compter sur 17 décimales exactes. C'est peu si on compare au nombre de décimales affichées. Si on fait un simple calcul avec Excel on est différent dès la 10e décimale. Mais, ce qui est étonnant, c'est qu'on a 6 au lieu de 5 donc un résultat supérieur.

Bonjour à tous,
>>Ulmière :
Avec 300 chiffres significatifs, il y a"divergence" pour les 3 dernières décimales.
Du coup j'ai demandé aussi 310 chiffres siginficatifs.
Je ne tire aucune conclusion de tout ça ...


PDF - 144 Ko

La conclusion que j'en tire, c'est que si tu demandes à Maple d'être plus précis il se rapproche quand même beaucoup de ce que dit mon script Python

L'autre conclusion, c'est que si tu veux être certain d'avoir n chiffres corrects, demandes-en n+50 en utilisant l'un ou l'autre

Bonjour Ulmière,
Je ne suis pas d'accord avec tes "certitudes".
Dans ton cas (avec python) comme le mien (avec maple), nous sommes tout à fait incapables de déterminer quelle est la dernière décimale "correcte".
Personnellement je crois qu'il n'y a aucune raison de penser que la première décimale est correcte !

Bonsoir
Mais alors comment font les scientifiques et les mathématiciens pour donner des valeurs de constantes avec des millions de décimales ? Je sais qu'ils disposent de gros ordinateurs mais quand même ...

Bonsoir derny,
Je suis un "minus" mathématique.
Il est certain que les (vrais) mathématiciens en question ont des certitudes à juste titre.
Comment font-ils ? Je ne sais pas

Bonjour lake
Pour les premières décimales, c'est bon. Mais jusqu'où ? Il y a pas mal de temps j'avais commencé un petit blog mathématique mais n'avais pas continué parce qu'il était limité et manque de temps aussi. J'avais élaboré quelques formules approchées (voir le lien ci-dessous). Depuis j'ai même amélioré certaines formules mais tout cela reste anecdotique.


_{Sylvieg edit >    * lien facilité *}

Nous utilisons deux approches complémentaires

* reformuler pour l'écrire par exemple comme fonction sommatoire d'un produit de convolution, et pouvoir utiliser les méthodes de sommation classique (hyperbole de Dirichlet, etc)

* utiliser comme dans mon code Python des librairies de calcul avec précision arbitraire. C'est comme pour les bigint mais avec des floats

Dans le cas de sqrt, on peut calculer beaucoup de décimales très efficacement grâce à l'algorithme de Newton-Raphson qui double à chaque itération le nombre de décimales correctes. Donc si tu veux n décimales correctes, tu n'as besoin de que d'un nombre d'itérations de l'ordre de log2(n). Il faut idéalement prendre un n plus grand que ce que tu vises pour le résultat final, parce que la somme de deux flottants à n décimales correctes n'a pas forcément n décimales correctes.
Difficile de dire si Maple comprend par lui-même cela où s'il fait tout avec n décimales correctes puis somme tout ça (ce qui peut expliquer les différences entre lake et moi). Les toutes dernières décimales s'expliquent aussi sans doute par une représentation différente des données en mémoire, ce qui change un peu les bits de poids faible.


En tout cas ce qu'il faut retenir, c'est que si tu veux n décimales correctes il te faut
* un bonne méthode (mathématique) de sommation, pour avoir un résultat en temps raisonnable et si possible pas trop d'arrondis à gérer
* une bonne librairie bigfloat dans ton langage favori pour faire tout ce beau calcul, à qui tu demanderas de faire un peu mieux que ce que tu attends histoire d'être bien sûr d'avoir tes n décimales correctes.

Essaie par exemple d'estimer pi par une méthode de Monte-Carlo (même accélérée par des suites pseudo-aléatoires à discrépance faible (Halton, etc))
Essaie de faire la même chose en utilisant une série de Fourier (celle de  la valeur absolue par exemple) et compare le nombre d'itérations qu'il te faut avec les deux méthodes de calcul pour obtenir un même nombre donné de décimales correctes

Merci à vous deux

Curieux :
Quand n (pair) ==> ∞  la sommation des   racines ==> 2/3   + 5  .
Pour n impair il faut multiplier ce résultat par V10

Cet équivalent m'a l'air douteux. En faisant apparaitre une somme de Riemann,



Si remplaces n par }, tu devrais trouver quelque chose d'équivalent à

Il faut bien-sûr lire et , mais surtout,

Bonjour
Si on laisse tomber les décimales (qui semblent aussi tendre vers une limite mais laquelle ?) on a :
S10000=666716
S1000000=666667166
S100000000=666666671666
S10000000000=666666666716666
...
La règle est simple à établir au visu des résultats.

Bonjour à tous,
Un "Nous" bien sibyllin :

Et les décimales semblent tendre vers 2(1-1/V10)/3

Ma "formule" du 8 à 23h20 établie précipitamment n'est pas bonne.  A élaborer au vue des résultats  (à 17h07) ce que Ulmiere a rectifié.