problème de calcul sur 20 à 50 chiffres de ma formule sur les nombres premiers

[JPL]

Et nous balancer du code correctement formaté et lisible, ça n'était pas dans les tutos non plus ?

Ici, on a l'équivalent informatique de : https://forums.futura-sciences.com/m...-premiers.html

C'est à dire "je veux faire un truc mais toute forme de rigueur et de méthode est à proscrire".

Je viens de corriger sa balise. C’est formaté maintenant.
-----

[saniadaff]

Maintenant j’apprécie cette façon d'intervenir car c'est du concret; s'il n y a rien dans le message sauf de l'humour ou de l'humeur je ne réponds pas c'est ce qui c'est passé dans la section maths et je vois bien que c'est pour cette raison vous voulez vous mettre dans mon dos;

Ici vous êtes explicite et ça peu nous apporter quelles que chose; donc même si votre aide est accompagnée par des réprimandes ou injure je la prends!!
Maintenant ce que vous signalez ce trouve à quel niveau, je toute suite le corriger:

package Premier4;

import java.util.*;
import java.lang.Math;
import java.math.BigInteger;
import java.math.BigDecimal;

public class Premier4 {

	public static void main(String[] args) {
		Premier4 P1 = new Premier4();
		Scanner keby = new Scanner(System.in);

		System.out.println("Veuillez saisir le rang inferieur n1 et superieur n2 :");
		 BigInteger s=keby.nextBigInteger();
		 BigInteger m=keby.nextBigInteger();
		 
		 for (BigInteger x = s ; x.compareTo(m) == -1 || x.compareTo(m) == 0;x = x.add(new BigInteger("1")) ) {	

		System.out.printf("P%d \n"+ P1.Formule2(x));

		}
		 
		 keby.close();

		}
		public int Div1 (BigInteger n) {	
			
		      int step;
		       int i;
		      
			    if ( n.compareTo(BigInteger.valueOf(5))==-1 ) {
			    	if((n.compareTo(BigInteger.valueOf (2)) == 0) || (n.compareTo(BigInteger.valueOf (3)) == 0))  {			    	    
			    	
			    		 return 1;
			    	 }
			    	 
			    	 else {
			    		 
			    	
			    		 return 2;
			            
			            }
			    	 
			          } 
			            else  if((n.mod(new BigInteger("6")).equals(BigInteger.ZERO))||(n.mod(new BigInteger("6")).equals( BigInteger.valueOf(2)))||(n.mod(new BigInteger("6")).equals( BigInteger.valueOf(4)))) 
			            {
			                   
			            	return 2;
			            
			            }  
			            
			            else if (n.mod(new BigInteger("6")).equals( BigInteger.valueOf(3))) {
			                        
			            	return 3;
			                  
			            }
			                         else {
			        i=5;
			        step=2;
			        BigInteger bi; 
			     
			        while ( i*i <= n ) {
			            
			    	 if (n.mod(new BigInteger("i")).equals( BigInteger.valueOf(0))) {
			    		 
			    		 return i;
			    	 }
			    	else {
			           
			    		i=i+ step;
			    	 
			            if ( step==2) {
			                step= 4;
			         }
			        else {
			               
			            	step=2;
			            }
			    	 }
			     }
			        return 1;
			        
			                         }
			    }




		public BigInteger Formule2 (BigInteger n){

		BigInteger p;	
		loop1:	
		for (BigInteger j = n ; j.compareTo(n.multiply(new BigInteger("2"))) == -1 || j.compareTo(n.multiply(new BigInteger("2"))) == 0;j = j.add(new BigInteger("1")) ) {	

		n=j;	
		int i=0;
		int r=0;
					
		BigInteger deux = new BigInteger("2");
				
		BigInteger control = (deux.multiply(n)).add(new BigInteger("1")); 
		
		BigInteger Q = Div1(2 * n + 1);
		BigInteger b = Q;
		long sortie = 0;
		ArrayList<BigInteger> K= new ArrayList<BigInteger> ();
		K.add((deux.multiply(n)).add(new BigInteger("1")));

		while ((Q!=1) && (sortie == 0)) {
		b = Q ;
		control = (deux.multiply(n)).add(new BigInteger("Q")); 
		Q = Div1(2 * n + Q);
		r=K.size();
		while (i<r) {

		if (control== K.get(i) ) {

		sortie = sortie + 1;

		}

		i=i+1;
		}

		K.add((deux.multiply(n)).add(new BigInteger("Q")));
		

		}


		if ((Q==1) && (sortie == 0) ){	
			
			p = (deux.multiply(n)).add(new BigInteger("b")); 
		    break loop1;



		}

		    }

		return p;

		}

}

Merci de cette intervention positive!!!

[JPL]

Merci d’utiliser la balise Code, pas Quote !

[vgondr98]

n est un BigInteger et i est un int.
Tu ne peux pas comparer un int est un BigInteger. Il faut transformer ton int en BigInterger avant
https://stackoverflow.com/questions/...and-biginteger

int i = 3;
BigInteger n = new BigInteger("100");
		
while (BigInteger.valueOf(i).multiply(BigInteger.valueOf(i)).compareTo(n) <= 0)// while ( i*i <= n ) {{
	System.out.println(i);
	i++;
}

Cela donne :
3
4
5
6
7
8
9
10

[saniadaff]

Merci!
ça reste un tout petit peu

cette ligne:
Q = Div1(2 * n + Q);
++++++++++++++++++++
Ici encore
while (Q.compareTo(new BigInteger("1")) < 0) && (sortie == 0)) {
+++++++++++++++++++++++++++++++++++++++++++++++++
Et ici
if ((Q==1) && (sortie == 0) ){

Quand je mets ça, cela ne fonctionne pas:
BigInteger Q = Div1(deux.multiply(n)).add(new BigInteger("1"));

[vgondr98]

Il faut que tu retire le / dans ta première balise code.

[vgondr98]

Sinon, je vois pas le rapport entre
Q = Div1(2 * n + Q);
et
BigInteger Q = Div1(deux.multiply(n)).add(new BigInteger("1")); qui correspond à Q = Div1(2 * n + 1);

[saniadaff]

Oui je ne peu plus modifier; les 5 minutes sont epuisées

[vgondr98]

Reposte ton message.

[saniadaff]

et pourtant la ligne ne passe pas

[vgondr98]

cette ligne:
Q = Div1(2 * n + Q);
++++++++++++++++++++
Ici encore
while (Q.compareTo(new BigInteger("1")) < 0) && (sortie == 0)) {
++++++++++++++++++++++++++++++ +++++++++++++++++++
Et ici
if ((Q==1) && (sortie == 0) ){

Il faut écrire CODE en majuscule.

[saniadaff]

Merci!
ça reste un tout petit peu

cette ligne:
Q = Div1(2 * n + Q);
++++++++++++++++++++
Ici encore
while (Q.compareTo(new BigInteger("1")) < 0) && (sortie == 0)) {
++++++++++++++++++++++++++++++ +++++++++++++++++++
Et ici
if ((Q==1) && (sortie == 0) ){

Quand je mets ça, cela ne fonctionne pas: il y a une erreur sur cette ligne
BigInteger Q = Div1(deux.multiply(n)).add(new BigInteger("1"));

[vgondr98]

Tu as bien changé

public int Div1 (BigInteger n) {

par

public BigInteger Div1 (BigInteger n) {

?

[saniadaff]

Il y a une seule erreur de compilation
ça dit que b n'est pas utilisé dans la fonction Formule2;

la boucle for plante l’exécution et quand je l'ai enlevé aussi tous le p=0;

Voici le code:

package Premier4;

import java.util.*;
import java.math.BigInteger;

public class Premier4 {

	public static void main(String[] args) {
		Premier4 P1 = new Premier4();
		Scanner keby = new Scanner(System.in);

		System.out.println("Veuillez saisir le rang inferieur n1 et superieur n2 :");
		 BigInteger s=keby.nextBigInteger();
		 BigInteger m=keby.nextBigInteger();
		 
		 for (BigInteger x = s ; x.compareTo(m) == -1 || x.compareTo(m) == 0;x = x.add(new BigInteger("1")) ) {	

		System.out.printf("\n"+ P1.Formule2(x));

		}
		 
		 keby.close();

		}
		public BigInteger Div1 (BigInteger n) {	
			
		      int step;
		        
		      
			    if ( n.compareTo(BigInteger.valueOf(5))==-1 ) {
			    	if((n.compareTo(BigInteger.valueOf (2)) == 0) || (n.compareTo(BigInteger.valueOf (3)) == 0))  {			    	    
			    	
			    		 return BigInteger.valueOf (1) ;
			    	 }
			    	 
			    	 else {
			    		 
			    	
			    		 return BigInteger.valueOf (2);
			            
			            }
			    	 
			          } 
			            else  if((n.mod(new BigInteger("6")).equals(BigInteger.ZERO))||(n.mod(new BigInteger("6")).equals( BigInteger.valueOf(2)))||(n.mod(new BigInteger("6")).equals( BigInteger.valueOf(4)))) 
			            {
			                   
			            	return BigInteger.valueOf (2);
			            
			            }  
			            
			            else if (n.mod(new BigInteger("6")).equals( BigInteger.valueOf(3))) {
			                        
			            	return BigInteger.valueOf (3);
			                  
			            }
			                         else {
			           
			        step=2;
			        int  i= 5;
			     
			        while (BigInteger.valueOf(i).multiply(BigInteger.valueOf(i)).compareTo(n) <= 0)  {
			            
			    	 if (n.mod(new BigInteger("i")).equals( BigInteger.valueOf(0))) {
			    		 
			    		 return BigInteger.valueOf (i);
			    	 }
			    	else {
			           
			    		i=i+ step;
			    	 
			            if ( step==2) {
			                step= 4;
			         }
			        else {
			               
			            	step=2;
			            }
			    	 }
			     }
			        return BigInteger.valueOf (1);
			        
			                         }
			    }




		public BigInteger Formule2 (BigInteger n){

		//BigInteger p=new BigInteger("0");	
		/*loop1:	
		for (BigInteger j = n ; j.compareTo(n.multiply(new BigInteger("2"))) == -1 || j.compareTo(n.multiply(new BigInteger("2"))) == 0;j = j.add(new BigInteger("1")) ) {	

		n=j;	*/
			
		int i=0;
		int r=0;
		
		BigInteger deux = new BigInteger("2");				
		BigInteger control = (deux.multiply(n)).add(new BigInteger("1")); 
		BigInteger Q = Div1(deux.multiply(n)).add(new BigInteger("1"));		
		BigInteger b = Q;
		long sortie = 0;
		
		ArrayList<BigInteger> K= new ArrayList<BigInteger> ();
		K.add((deux.multiply(n)).add(new BigInteger("1")));

		while ((Q.compareTo(new BigInteger("1")) <0) && (sortie == 0)) {
		b = Q ;
		control = (deux.multiply(n)).add(new BigInteger("Q")); 
		Q = Div1(deux.multiply(n)).add(new BigInteger("Q"));		
		r=K.size();
		while (BigInteger.valueOf(i).compareTo(BigInteger.valueOf(r)) < 0)  {		

		if (control== K.get(i) ) {

		sortie = sortie + 1;

		}

		i=i+1;
		}

		K.add((deux.multiply(n)).add(new BigInteger("Q")));
		

		}

		if ((Q.compareTo(new BigInteger("1")) ==0) && (sortie == 0)) {
					
			return  (deux.multiply(n)).add(new BigInteger("b")); 
		   // break loop1;



		}

		  //  }

		return BigInteger.valueOf (0); 

		}

}

C'est ce code qui est transformé en BigInteger:

package Premier3;

import java.util.*;



public class Premier3 {
	

public static void main(String[] args) {
Premier3 P1 = new Premier3();
Scanner keby = new Scanner(System.in);

System.out.println("Veuillez saisir le rang inferieur n1 et superieur n2 :");
long s=keby.nextLong();
long m=keby.nextLong();
for (long x = s ; x <= m; x++) {

System.out.printf("P%d  : %d \n",+x, +P1.Formule2(x));

}
keby.close();
}
public int Div1 (Long n) {	
	
      int step;
       int i;

	    if ( n < 5 ) {
	    	 if ((n==2) || ( n==3)) {	    		 
	    	
	    		 return 1;
	    	 }
	    	 
	    	 else {
	    		 
	    	
	    		 return 2;
	            
	            }
	    	 
	          }
	            else if (( n%6==0) || (n%6==2) || (n%6==4 )) {
	                   
	            	return 2;
	            
	            }  
	            
	            else if (n%6==3) {
	                        
	            	return 3 ;
	                  
	            }
	                         else {
	        i=5;
	        step=2;
	     while ( i*i <= n ) {
	            
	    	 if (n%i==0) {
	    		 
	    		 return i;
	    	 }
	    	else {
	           
	    		i=i+ step;
	    	 
	            if ( step==2) {
	                step= 4;
	         }
	        else {
	               
	            	step=2;
	            }
	    	 }
	     }
	        return 1;
	        
	                         }
	    }




public Long Formule2 (Long n){

long p=0;	
loop1:	
for(long j=n;j<=2*n;j++) {
n=j;	
int i=0;
int r=0;
long control = 2 * n + 1 ;
long Q = Div1(2 * n + 1);
long b = Q;
int sortie = 0;
ArrayList<Long> K= new ArrayList<Long> ();
K.add(control);



while ((Q!=1) && (sortie == 0)) {

b = Q ;
control=2 * n + Q;
Q = Div1(2 * n + Q);
r=K.size();
while (i<r) {

if (control== K.get(i) ) {

sortie = sortie + 1;

}

i=i+1;
}


K.add(2 * n + Q);

}


if ((Q==1) && (sortie == 0) ){	

p=2 * n + b;  break loop1;



}

    }

return p;

}

}

[vgondr98]

Ce n'est pas une erreur de compilation mais un warning qui te dit que ta variable b n'est pas utilisée. En gros elle sert à rien.

[vgondr98]

return (deux.multiply(n)).add(new BigInteger("b"));

Sinon la tu passes la lettre b en paramètre au lieu de ta variable b.

Comme cela : return (deux.multiply(n)).add(b);

Cela va faire disparaitre ton warning.

[saniadaff]

Ah oui ça disparu!

J'ai fait le test partie par partie et je vois que les boucles ne sont pas accédées ce qui veut dire que les tests dans for et while et le if ne sont pas exécutés;

System.out.printf("\n n : "+ n);
System.out.printf("\n Q avant while : "+ Q);
System.out.printf("\n b avant while : "+ b);
++++++++++++++++++++++++++++++ ++++++++++++++++
System.out.printf("\n Q dans while : "+ Q);
System.out.printf("\n b dans while : "+ b);
++++++++++++++++++++++++++++++ ++++++++++++++++++
System.out.printf("\n n : "+ n);
System.out.printf("\n Q sortie while : "+ Q);
System.out.printf("\n b sortie while : "+ b);
System.out.printf("\n b p=2*n+1 : "+ (deux.multiply(n)).add(b));
++++++++++++++++++++++++++++++ ++++++++++++++++++++++
System.out.printf("\n n : "+ n);
System.out.printf("\n Q sortie while : "+ Q);
System.out.printf("\n b sortie while : "+ b);
voici l'exécution:

Veuillez saisir le rang inferieur n1 et superieur n2 :
1
5

 n   :  1
 Q avant while  :  2
 b avant while  :  2
 n   :  1
 Q sortie while  :  2
 b sortie while  :  2
0
 n   :  2
 Q avant while  :  3
 b avant while  :  3
 n   :  2
 Q sortie while  :  3
 b sortie while  :  3
0
 n   :  3
 Q avant while  :  3
 b avant while  :  3
 n   :  3
 Q sortie while  :  3
 b sortie while  :  3
0
 n   :  4
 Q avant while  :  3
 b avant while  :  3
 n   :  4
 Q sortie while  :  3
 b sortie while  :  3
0
 n   :  5
 Q avant while  :  3
 b avant while  :  3
 n   :  5
 Q sortie while  :  3
 b sortie while  :  3
0

[saniadaff]

Merci!

package Premier4;

import java.util.*;
import java.math.BigInteger;

public class Premier4 {

	public static void main(String[] args) {
		Premier4 P1 = new Premier4();
		Scanner keby = new Scanner(System.in);

		System.out.println("Veuillez saisir le rang inferieur n1 et superieur n2 :");
		 BigInteger s=keby.nextBigInteger();
		 BigInteger m=keby.nextBigInteger();
		 
		 for (BigInteger x = s ; x.compareTo(m) == -1 || x.compareTo(m) == 0;x = x.add(new BigInteger("1")) ) {	

		System.out.printf("\n"+ P1.Formule2(x));

		}
		 
		 keby.close();

		}
		public BigInteger Div1 (BigInteger n) {	
			
			//BigInteger d=sqrt(n);
	
			 
		      int step;
		   
		      
			    if ( n.compareTo(BigInteger.valueOf(5))<0 ) {
			    	
			    	
			    	if((n.compareTo(BigInteger.valueOf (2)) == 0) || (n.compareTo(BigInteger.valueOf (3)) == 0))  {			    	    
			    	
			    		 return BigInteger.valueOf (1) ;
			    	 }
			    	 
			    	 else {
			    		 
			    	
			    		 return BigInteger.valueOf (2);
			            
			            }
			    	 
			          } 
			            else  if((n.mod(new BigInteger("6")).equals(BigInteger.ZERO))||(n.mod(new BigInteger("6")).equals( BigInteger.valueOf(2)))||(n.mod(new BigInteger("6")).equals( BigInteger.valueOf(4)))) 
			            {
			                   
			            	return BigInteger.valueOf (2);
			            
			            }  
			            
			            else if (n.mod(new BigInteger("6")).equals( BigInteger.valueOf(3))) {
			                        
			            	return BigInteger.valueOf (3);
			                  
			            }
			                         else {
			           
			        step=2;
			        int  i= 5;
			     
			        while (BigInteger.valueOf(i).multiply(BigInteger.valueOf(i)).compareTo(n) <= 0)  {
			            
			    	 if (n.mod(BigInteger.valueOf(i)).equals( BigInteger.valueOf(0))) {
			    		 
			    		 return BigInteger.valueOf (i);
			    	 }
			    	else {
			           
			    		i=i+ step;
			    	 
			            if ( step==2) {
			                step= 4;
			         }
			        else {
			               
			            	step=2;
			            }
			    	 }
			     }
			        return BigInteger.valueOf (1);
			        
			                         }
			    }




		public BigInteger Formule2 (BigInteger n){

		BigInteger p=new BigInteger("0");
		
		loop1:	
		
		for (BigInteger j = n ; j.compareTo(n.multiply(new BigInteger("2"))) < 0 /*|| j.compareTo(n.multiply(new BigInteger("2"))) == 0*/;j = j.add(new BigInteger("1")) ) {	

		n=j;	
			
		int i=0;
		int r=0;
		
		BigInteger deux = new BigInteger("2");				
		BigInteger control = (deux.multiply(n)).add(new BigInteger("1")); 
		BigInteger Q = Div1((deux.multiply(n)).add(new BigInteger("1")));		
		BigInteger b = Q;
		long sortie = 0;
		
		ArrayList<BigInteger> K= new ArrayList<BigInteger> ();
		K.add((deux.multiply(n)).add(new BigInteger("1")));
		
		
		while ((Q.compareTo(new BigInteger("1")) <0) && (sortie == 0)) {
		b = Q ;
		control = (deux.multiply(n)).add(new BigInteger("Q")); 
		Q = Div1((deux.multiply(n)).add(new BigInteger("Q")));		
		r=K.size();
		while (BigInteger.valueOf(i).compareTo(BigInteger.valueOf(r)) < 0)  {		

		if (control== K.get(i) ) {

		sortie = sortie + 1;

		}

		i=i+1;
		}

		K.add((deux.multiply(n)).add(new BigInteger("Q")));
	
		}

		if ((Q.compareTo(new BigInteger("1")) ==0) && (sortie == 0)) {
			
	
					
		  p=(deux.multiply(n)).add(b);
		  break loop1 ;
        


		}
		
		
		   }

		return p; 

		}
		
		/* 
		 BigInteger sqrt(BigInteger n) {
			  BigInteger a = BigInteger.ONE;
			  BigInteger b = new BigInteger(n.shiftRight(5).add(new BigInteger("8")).toString());
			  while(b.compareTo(a) >= 0) {
			    BigInteger mid = new BigInteger(a.add(b).shiftRight(1).toString());
			    if(mid.multiply(mid).compareTo(n) > 0) b = mid.subtract(BigInteger.ONE);
			    else a = mid.add(BigInteger.ONE);
			  }
			  return a.subtract(BigInteger.ONE);
			}
			
			*/

}

[saniadaff]

Merci Mr vgondr98 et tous ceux qui ont aidez!!

mais je vais revenir car je suis entrain de modifier la fonction Div1 pour le test modulo 30 car c'est lent pour des grandes valeurs;

OK les autres permettez moi de revenir un peu dans la politique dont certains ont essayé de me plonger à chaque fois que occasion se présentait et depuis dans la rubrique Maths sur le sujet Découverte sur les nombres premiers car ils ont tentés le tout pour nous faire revenir déçu;

Avant tout, je suis bien avertis que la validation d'une oeuvre scientifique relève de beaucoup de jugement d'où mes démarches pour faire connaitre ma découverte à un maximum de lecteurs car je ne suis pas le seul sur ce coup;

D'ailleurs je dis ça en passant, le mathématicien britannique Sir Michael Atiyah cherche désespérément à faire valider sa démonstration sur cette conjecture de Riemann sans succès.

pm42

La troisième formule est acceptée par tous ceux qui se sont exercés là dessus; donc c'est un véritable succès pour moi et ton gg0 n'aura rien sous la main sauf des injures pour s'oppose, tout en oubliant que son avis ne compte pas pour une validation scientifique, sauf à titre d'un pro en Maths s'il est à la hauteur aussi de faire une suggestion à l'auteur;

Ah oui moi je suis bien à la hauteur car j'ai quelle que chose sous la main qui est discutable; un conseil si tu n'a pas le courage pour des recherches ne méprise pas ceux qui ont le cran pour des recherche pointu et courageux.

Tu n'as sans doute pas remarqué les commentaires de gg0 sur l'autre fil (qui lui est mathématiciens).
Quand à ce fil, tu n'as sans doute pas remarqué non plus que c'est moi qui t'ai donné la solution à ton problème.

Donc, c'est simple : tu t'es attaqué à un problème largement au dessus de ton niveau : les nombres premiers et sans même connaitre la base de la base, c'est à dire les articles de Wikipedia.
Tu codes sans respecter les règles élémentaires ce qui te complique la vie et celle de ceux qui veulent t'aider.
Et tu ignores toute remarque qui ne t'arrange pas.

C'est hyper-classique et à la fin, tu ne vas arriver à rien.
Si tu veux progresser, tu peux changer d'attitude et écouter les gens plus expérimentés que toi ou bien t'accrocher à l'illusion que tu vas trouver des trucs sur un sujet hyper-pointu où des générations de mathématiciens tous plus géniaux les uns que les autres ont bossé.
Et clairement, tu n'es pas dans cette catégorie (comme tout le monde ici d'ailleurs).

les commentaires de gg0 était vide de sens car il n y avait que de humeur au lieu faire une analyse de pro; donc en tant que politicien je vais le répondre comme si c'est un autre message différent du contexte qu'il la bien donner;

Il n a même pas fait une analyse de pro car il y a trois formules;

Dans la première formule c'est dit qu'il y a un mélange d'un nombre restreint des nombres composés qui aussi est très important que tous ceux que mes processionnaires ont déjà trouvées;

il dit que la formule des nombres premiers existe alors qu'en réalité il n'est même pas capable de nous mettre un lien vers un site expliquant cella; ou nous faire un dessein de cette formule;

C'est ça un mathématicien!!!!

ceux qui ont essayé de l'aidez sur ce coup n'ont rien trouvé de mieux; car cette formule qui trouve tous les nombres premiers appart de démarches purement algorithmiques comme Ératosthène et etc.. n'existe pas;

Si ça doit exister ça serra une première; càd mes trois formules.

La première formule trouve tous les nombres premier y compris certain nombres composés;

la deuxième formule trouve tous les nombres premiers sans aucun mélange des nombres composés que ton gg0 n'a pas mis dans sont commentaire, parce que tout simplement il est envahi par la jalousie de quelle que chose dont il ne pourra plus rien car c'est ma chance et c'est une affaire de Dieu quand on parle de découverte;

la troisième formule, la il n'a rien dit hein!!!

C'est fait express ou il y avait déjà un préjugé? car il avait même signaler aux lecteurs, chose qu'il n'est pas obligé de le faire, que c'est la reprise d'un sujet fermé sur un autre forum;

il étais donc aller faire un tour de l'autre coté avant mon post ic;i ; càd la discussion qui est fermée sur https://www.developpez.net/forums/d2...bres-premiers/

Mais il n'a pas rapporté les commentaires justiciers de ce côte aussi:

en prenant par exemple sur la remarque de certains pro de ce forum dont il fait allusion

par exemple:

1-Mr laurent_ott

Bonjour,
J'ai pris la peine de coder l'algorithme proposé (avec un pseudo code ça aurait été plus simple), voir ci-dessous. C'est en BASIC donc tout le monde devrait comprendre.

La bonne nouvelle c'est que ça marche (en tout cas sur les tests que j'ai fait), la moins bonne c'est que ça reste long.
Je pense que cela vient de la fonction Nbdiv qui recherche au moins un diviseur. Donc quand le nombre est premier ça prend du temps. Et plus il est grand plus c'est long. D'où une amélioration possible en utilisant le test de Miller-Rabin puisque la fonction Nbdiv ne sert qu'a vérifier si le nombre est premier ou pas.

Une question : Lorsque je lance le traitement avec main(10999), main(11000) et main(11001) j'obtiens 22003, qui est bien premier mais est le 2465ème premier (plus ou moins un tout dépend si l'on prend 1 comme premier), d'où ma remarque : le nombre passé en argument n'a aucun rapport avec le rang du nombre premier dans la liste des nombres premier. Est-ce que j'ai loupé une étape ?

Il faut reconnaitre que l'algorithme donne un nombre premier quand on lui passe un argument, alors qu'un crible doit mémoriser les premiers un à un et nécessite donc une mémoire dimensionnée en conséquence. Mais est-ce vraiment plus rapide que de tester un nombre puis le suivant jusqu'à trouver un premier ? Faudrait tester sur des nombres plus grands.

Mr tbc92

Je crois que tu as répondu à la question : on construit un nombre an+b, on sait que ce nombre n'est pas pair par construction. Et on teste s'il est premier, en cherchant ses diviseurs, et en particulier, en cherchant son plus petit diviseur.
Et on recommence plusieurs fois. Quitte (peut-être) à tester plusieurs fois le même nombre.

Dans les outils classiques, on a un nombre p, et on teste s'il est premier. On veut juste savoir s'il est premier, on n'a pas besoin de connaître son plus petit diviseur.

Dans les 2 cas, on passe donc par un test pour chercher si un nombre donné est premier. Et c'est ce test là qui est couteux, et qui n'est pas du tout évoqué ici.

Dans les outils classiques, pour tester si un nombre est premier on ne va pas vérifier s'il est divisible par 9 ou par 15 ou par 21. Ici, ce point n'est pas évoqué.

La deuxième formule est plus complique d'où mon insistance à ce que les gens puis s'intéressés pour sa compréhension et pour des éventuelles criques;

Mais ce que je n'accepterais pas, ce sont des niaiseries, des réprimandes car nul ne peut m'effrayer en terme de connaissance sur le net;

Mr Mateo Nebra, le fondateur du site zero, un de ses disciples m'a fait comprendre que tout le monde apprends dans le tas sur le net et la plupart des pro sont des autodidactes;

ce qui veux dire que forcement chacun a une limite a partir du moment ou on apprend sans programme fixe;

Merci les internautes !!

Il le faudrait car je devrais être plus courtois de l'autre coté pour que mon objectif soit atteint celui de permettre les lecteurs ç la compréhension mais le sujet est fermé;

[Paraboloide_Hyperbolique]

Sachez que je n'apprécie pas du tout votre vilipendage de gg0 que je tiens pour une personne très serviable et bien plus compétente en mathématiques que vous ne l'êtes.

De plus, rappel du point 6 de charte:

Toutes idées ou raisonnements (aussi géniaux soient-ils) doivent reposer sur des connaissances scientifiques ou techniques valides et non sur de vagues suppositions personnelles, basées sur d’intimes convictions. L’un des objectifs de Futura-Sciences étant la vulgarisation scientifique de bon niveau, ce n’est pas le lieu pour des questionnements ou remises en cause de théories admises dont seuls des spécialistes ont les compétences pour débattre, ni pour l’exposé de théories strictement personnelles. Une telle démarche aurait sa place uniquement dans un séminaire ou un congrès scientifique.

[saniadaff]

Mr Paraboloide_Hyperbolique toutes mes excuses si vous êtes dommage collatérale car j'ai assez de respect pour vous et pour tous ceux qui m'aide sur un forum;

C'est pm42 qui m'a poussé au bout, vous pouvez le voir par ses messages dans ce fil; il a toujours essayé de montrer à ceux qui sont dans ce fil que j'ai un autre sujet dans la rubrique maths; chose qui n'est pas normale;
sinon Mr gg0 m'a attaqué virilement de l'autre coté je ne l'ai pas répondu vu son age qui est affiché;

Je suis d'accord avec ce que vous évoquez à savoir:

L’un des objectifs de Futura-Sciences étant la vulgarisation scientifique de bon niveau, ce n’est pas le lieu pour des questionnements ou remises en cause de théories admises dont seuls des spécialistes ont les compétences pour débattre, ni pour l’exposé de théories strictement personnelles. Une telle démarche aurait sa place uniquement dans un séminaire ou un congrès scientifique.

Mais ce n'est pas ce qui s'est passé de l'autre coté; prenez la penne et aller faire un tour sur le sujetécouverte sur les nombres premiers;

J'ai été fermé sans mon consentement et les motifs évoqué ne tiendrais pas car à l'intérieur de ce message il y a bel et bien les Maths dedans et j'ai pas reçu un message autorisant de poster la totalité de mon article et pourtant je l'ai demandé car la page autorise une longueur de message qui dépasse chez moi.

Le sujet concerne une découverte et ne remet en cause d'aucune théorie mathématique mais plutôt ça viens ajouter un plus sur la science;

C'est un sujet où chacun est libre de critiquer, suggérer et de commenter pourvue que je puis me rendre compte de la véracité de ce qui trouvé;

Mais pas pour réprimander, injurier ou discriminer l'auteur;

Je n'ai commis aucun crime pour cette découverte ce qui fait que pour sortir sous silence je suis revenus à la charge pour montrer que j'ai un cursus qui peu faire de moi un chercheur contrairement à ce que pm42 veux nous faire croire qu'on est incapable de faire une découverte dans un thème dont euler n'a pas pu;

Regardez ma théorie et étudier avant de s'affirmer sans tenir compte des fautes d'orthographes ou des erreur de frappes surtout que vous vous êtes rendu compte que c'est erreur de frappe;
je ne suis ni diable ni Dieu je peux être médiocre et avoir la chance pour une invention;

Surtout toutes mes excuses;

[JPL]

Cette discussion continue dans les règlements de compte. Elle va donc être fermée pour deux raisons :

1. Attaques personnelles répétées.
2. Théorie personnelle. Lire : Vous avez démontré un résultat mathématique.