La constante de Fridman

Télécharger le projet
Commenter

Description


La constante de Fridman u = 2.920050977316... semble avoir un fonctionnement magique.
On retrouve théoriquement la suite de tous les nombres premiers avec la récurrence :
f(1) = u et f(n+1) = [f(n)]*(f(n)-[f(n)]+1) => p(n) = [f(n)] dans laquelle p(n) est
le n-ième nombre premier et [x] est la partie entière du nombre x, exemple [3.14] = 3.

Mais cette constante u est un nombre réel irrationnel ayant une infinité de chiffres
décimaux significatifs. Pour cette raison on est obligé d'en utiliser une approximation.
Ce qui permet d'obtenir seulement une suite limitée des premiers nombres premiers,
en nombre aussi grand qu'on le souhaite selon la précision de l'approximation.

Pour en montrer une utilisation très simple le programme présenté ici développé
en C++ avec GMP affiche les 25 premiers nombres premiers plus petits que 100.

Le fichier explications.txt indique pourquoi et comment on a ce fonctionnement
qui est un peu surprenant à priori.

Source : 

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "gmp.h"
#pragma comment(lib, "gmp.lib")  
            
// r = partie entière de x (r = [x])
void entier(mpq_t r, mpq_t x) {
    mpz_t n;
    mpz_init(n);
    mpz_set_q(n, x);
    mpq_set_z(r, n);
}
          
int main() {
    mpz_t d;
    mpz_init(d);
    mpz_t n;
    mpz_init(n);
    mpq_t r;
    mpq_init(r);
    mpq_t t;
    mpq_init(t);
    mpq_t u;
    mpq_init(u);
    mpq_t v;
    mpq_init(v);
    mpq_t x;
    mpq_init(x);
    mpz_set_ui(n, 1);
    mpq_set_z(t, n);         //  t = 1  
    mpz_set_str(n, "29200509773161347120925629171120194680027278993214267", 10);
    mpz_set_str(d, "10000000000000000000000000000000000000000000000000000", 10);
    mpq_set_num(u, n);
    mpq_set_den(u, d);
    entier(r, u);
    mpz_set(n, mpq_numref(r));	
    printf("p(1) : %d\n", mpz_get_si(n));
    int i = 1;
    while(i < 25) {
        i = i+1;
        entier(v, u);        //  v = [u]  
        mpq_sub(x, u, v);
        mpq_add(x, x, t);
        mpq_mul(x, x, v);    //  x = [u] * (u - [u] + 1)  
        entier(r, x);        //  r = [x]  
        mpz_set(n, mpq_numref(r));	
        printf("p(%d) : %d\n", i, mpz_get_si(n));
        mpq_set(u, x);
    }
    printf("\n");
    getchar();
    return 0;
}

Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (pgl10)