Summe (1/Primzahl [i]^2)> = 1?

Question

Während ich versuchte, einen Algorithmus zu entwickeln, stolperte ich über diese Frage. Es ist keine Hausaufgabe.

Sei P_i = ein Array der ersten i Primzahlen. Jetzt muss ich die kleinste i so dass

Sum<n=0..i> 1/(P_i[n]*P_i[n]) >= 1. 

(wenn eine solche i vorhanden ist).

Eine Näherung für die i 'th prime ist i*log(i). Also habe ich das in Java versucht:

public static viod main(String args[]) { 
    double sum = 0.0; 
    long i = 2; 

    while(sum<1.0) { 
     sum += 1.0/(i*Math.log(i)*i*Math.log(i)); 
     i++; 
    } 

    System.out.println(i+": "+sum); 
} 

Allerdings wird das oben genannte nicht beendet, weil es auf 0,7 konvergiert. Allerdings 1/100000000^2 Runden auf 0.0 in Java, deshalb funktioniert es nicht. Aus dem gleichen Grund funktioniert es nicht, auch wenn Sie die 6. Zeile mit

sum += 1.0/(i*i) 

ersetzen, während das sollte 1 erreichen, wenn mich nicht alles täuscht, weil die Summe schneller incease sollte als 1/2^i und die letztere konvergiert zu 1 . Mit anderen Worten zeigt dies, dass Java-Rundung bewirkt, dass die Summe 1 nicht erreicht. Ich denke, dass das Minimum i meines Problems existieren sollte.

Answer 1

Auf der Mathematik Seite dieser Frage nicht die Java-Seite:

Wenn ich das Problem zu verstehen, ist es keine Lösung (kein Wert von i).

Für jede endliche Menge P_i der Primzahlen {p_1, p_2, ... p_i} sei N_i die Menge aller ganzen Zahlen bis p_i, {1,2,3, ..., p_i}. Die Summe 1/p^2 (für alle p_n in P_i) ist kleiner als die Summe aller 1/x^2 für x in N_i.

Die Summe von 1/x^2 tends to ~1.65 aber seit dem 1. nie in der Menge der Primzahlen sein, wird die Summe begrenzt durch ~ 0,65

Answer 2

Ich denke, Sie könnten die Präzision verlieren, die Sie benötigen, wenn Sie Standard Math.log multipliziert mit float i verwenden. Ich denke, das kann mit einem geeigneten RoundingMode gehandhabt werden. Bitte beachten Sie setRoundingMode

Answer 3

Sie können nicht doppelt dafür verwenden, weil es nicht einheitlich ist. Sie sollten Fraktionen verwenden. Ich fand diese Klasse https://github.com/kiprobinson/BigFraction

Dann habe ich versucht zu finden, was geschieht:

public static void main(String args[]) { 
     BigFraction fraction = BigFraction.valueOf(1, 4); 
     int n = 10000000, status = 1, num = 3; 
     double limit = 0.4; 

     for (int count = 2; count <= n;) { 
      for (int j = 2; j <= Math.sqrt(num); j++) { 
       if (num % j == 0) { 
        status = 0; 
        break; 
       } 
      } 
      if (status != 0) { 
       fraction = fraction.add(BigFraction.valueOf(1,BigInteger.valueOf(num).multiply(BigInteger.valueOf(num)))); 

       if (fraction.doubleValue() >= limit){ 
        System.out.println("reached " + limit + " with " + count + " firsts prime numbers"); 
        limit += 0.01; 
       } 

       count++; 
      } 
      status = 1; 
      num++; 
     } 
    } 

Dieser diesen Ausgang ist mit:

reached 0.4 with 3 firsts prime numbers 
reached 0.41000000000000003 with 4 firsts prime numbers 
reached 0.42000000000000004 with 5 firsts prime numbers 
reached 0.43000000000000005 with 6 firsts prime numbers 
reached 0.44000000000000006 with 8 firsts prime numbers 
reached 0.45000000000000007 with 22 firsts prime numbers 

Und nichts mehr in einer Minute. Ich debugge es und fand heraus, dass es extrem langsam und langsamer wächst, ich denke nicht, es kann 1 sogar in der Unendlichkeit erreichen :) (aber ich weiß nicht, wie ich es beweisen soll).