#include <iostream>
using namespace std;

class Prime
{
    public:
    explicit Prime();
    ~Prime();
    inline long NextPrime();

    private:
    long m_PrimeNumber;
};

Prime::Prime()
:m_PrimeNumber(1)
{

}

Prime::~Prime()
{

}

long Prime::NextPrime()
{
    for (int i=2;i<m_PrimeNumber;i++)
    {
        if((m_PrimeNumber % i) != 0)
        {
            m_PrimeNumber++;
            i=2;
        }
    }
    return m_PrimeNumber++;
}

int main()
{
    Prime temp;
    while(1)
    {
        cout << temp.NextPrime() << "\n";
        system("pause");
    }

    return 0;
}

???

MfG
Stromberg

Resultat Endlosschleife ^^

if((m_PrimeNumber % i) != 0)

nicht so sein?
[ censored ]

^-- Oben steckt der Fehler Ich klau hier niemandem die Arbeit

mbu.

#include <iostream> 
using namespace std; 

class Prime 
{ 
    public: 
    explicit Prime(); 
    ~Prime(); 
    inline long NextPrime(); 

    private: 
    long m_PrimeNumber; 
}; 

Prime::Prime() 
:m_PrimeNumber(1) 
{ 

} 

Prime::~Prime() 
{ 

} 

long Prime::NextPrime() 
{ 
    for (int i=2;i<m_PrimeNumber;i++) 
    { 
        if((m_PrimeNumber % i) == 0) 
        { 
            m_PrimeNumber++; 
            i=2; 
        } 
    } 
    return m_PrimeNumber++; 
} 

int main() 
{ 
    Prime temp; 
    while(1) 
    { 
        cout << temp.NextPrime() << "\n"; 
        system("pause"); 
    } 

    return 0; 
}

Kann ich das Ding noch schneller machen?

MfG
Stromberg

2. EDIT: naja, egal.

3. kann man eine bestimmte Gruppe von Zahlen bereits im Vorhinein ausschließen (bis auf ein Zahl ;))

usw.

P.S.: Ich wäre ein bisschen anders an die Sache herangegangen, aber so gehts ja auch

Gruß
Don06

Auch solltest du evtl. eine Abbruchbedingung bzgl. des Datentyps 'long' einbauen (unsigned long wäre sogar besser).

Wenn du wirklich ein effizientes Primzahlsuchprogramm schreiben willst - besonders für große Zahlen - dann mußt du dich erst ein bißchen mit Primzahl-Mathematik auseinandersetzen.

Gruß
Don06

Bei einer Suche bis zu 20. Mio braucht er auf meinem Rechner nur 2,25s, aber ca. 2,4MB SPeicher mehr als die übliche Methode). Die übliche Methode braucht hingegen ca 50s und selbst die von mir eigenhändig optimierte bruacht noch ca. 26s.
Dazu mal ein kleiner Screenshot meiner Testreihe.

Da die Methode des Siebs des Eratosthenes noch nicht optimiert ist, lässt sich da bestimmt noch ein bisschen rausholen.

Gruß
Don06

#include <iostream>
using namespace std;

enum NUMBER {N_a=2,N_b=3,N_c=5,N_d=7};

class Prime
{
    public:
    explicit Prime();
    ~Prime();
    void SearchPrime(const unsigned long &value);
    inline const unsigned long * get_PrimeNumber() const {return m_PrimeNumber;}

    private:
    unsigned long *m_PrimeNumber;

};

Prime::Prime()
:m_PrimeNumber(NULL)
{

}

Prime::~Prime()
{
    delete m_PrimeNumber;
}

void Prime::SearchPrime(const unsigned long &value)
{
    unsigned long temp=value;
    NUMBER special_number;
    unsigned long *array=new unsigned long[value];

    for (int j=0;j<4;j++)
    {
        switch(j)
        {
            case 0:
            special_number=N_a;
            break;
            case 1:
            special_number=N_b;
            break;
            case 2:
            special_number=N_c;
            break;
            case 3:
            special_number=N_d;
            break;
        }

        for (unsigned long i=1;temp<2;i++)
        {
            array[i*special_number]=true;
            temp=temp-special_number;
        }

        temp=value;

    }

    unsigned long counter=0;;

    for(unsigned long i=1;i<value;i++)
    {
        if (array[i] != true)
        {
            counter++;
            //cout << array[i] << "\n";  <--TESTEN OBS GEHT
        }
    }

    m_PrimeNumber=new unsigned long[counter];

    for(unsigned long i=1;i<value;i++)
    {
        if (array[i] != true) m_PrimeNumber[i]=array[i];
    }

    delete array;
}

MfG
Stromberg

typedef unsigned long uint;

void printPrimes(uint max)
{
	std::vector<bool> isPrimeArray(max + 1, true);
	isPrimeArray[0] = false;
	isPrimeArray[1] = false;

	uint factor = 2;
	uint squareRoot = static_cast <uint> 
		(sqrt(static_cast <double> (max)) + 0.5);
	while (factor <= squareRoot)
	{
		uint not_a_prime = factor + factor;
		while (not_a_prime <= max)
		{
			isPrimeArray[not_a_prime] = false;
			not_a_prime += factor;
		}

		++factor;
		while (!isPrimeArray[factor])
			++factor;
	}

	for (uint i = 0; i <= max; ++i)
		if (isPrimeArray[i])
			printf("%lu\n", i);
}

Du solltest die Ausgabe, aber in eine Date umleiten, da sonst die meiste Zeit mit der Konsolenausgabe verschwendet würde.

Also zB so aus der Konsole aufrufen:

PrintPrimes > primes.txt

Gruß
Don06

#include <iostream>
using namespace std;

class Prime
{
    public:
    explicit Prime();
    ~Prime();
    void SearchPrime(const unsigned long &value);
    inline const unsigned long * get_PrimeNumber() const {return m_PrimeNumber;}
    inline unsigned long get_counter() const {return m_counter;}

    private:
    unsigned long *m_PrimeNumber;
    unsigned long m_counter;

};

Prime::Prime()
:m_PrimeNumber(NULL),m_counter(0)
{

}

Prime::~Prime()
{
    delete []m_PrimeNumber;
}

void Prime::SearchPrime(const unsigned long &value)
{
    unsigned long *array=new unsigned long[value];
    unsigned short special_number=0;

    for (short j=0;j<4;j++)
    {
        switch (j)
        {
            case 0:
            special_number=2;
            break;
            case 1:
            special_number=3;
            break;
            case 2:
            special_number=5;
            break;
            case 3:
            special_number=7;
            break;
        }

        for (unsigned long i=1;(special_number*i)<=value;i++)
        {
            array[special_number*i]=0;
        }
    }

    for (unsigned long i=1;i<value;i++)
    {
        if (array[i] != 0) m_counter++;
    }

    m_PrimeNumber=new unsigned long[m_counter];
    unsigned long x=0;

    for (unsigned long i=1;i<value;i++)
    {
        if (array[i] != 0)
        {
            m_PrimeNumber[x]=i;
            x++;
        }
    }

    delete []array;
}

int main()
{
    Prime test;
    test.SearchPrime(10000);
    const unsigned long *temp=test.get_PrimeNumber();
    for (unsigned long i=0;i<test.get_counter();i++)
    {
        cout << temp[i] << "\n";
    }

    return 0;
}

@Don06
Ich schau mir jetzt mal deinen Code an, ich glaub meiner is im Vergleich zu deinem ziemlich hässlich :(...aber gut wenigstens funktioniert mein Code. (bis "198" :D)

MfG
Stromberg

Für Primzahlen gilt:

Eine Zahl aus der Menge der natürlichen Zahlen (N) größer 1 ist genau dann eine Primzahl, wenn sie durch 1 und sich selbst ohne Rest teilbar ist.

Des weiteren gilt:

Jede Zahl aus der Menge N größer 1 lässt sich als Produkt von Primzahlen darstellen.

Daraus folgt, dass eine natürliche Zahl q größer 1, welche nicht durch eine Primzahl kleiner q ohne Rest teilbar ist, eine Primzahl ist.

Bsp:
2 ist nicht durch eine Primzahl teilbar -> Primzahl
3 ist nicht durch eine Primtahl teilbar -> eine Primzahl
4 ist durch 2 teilbar: 2 x 2 = 4 -> keine Primzahl
5 ist nicht durch eine Primzahl teilbar -> Primzahl
6 ist durch 2 und 3 teilbar: 2 x 3 = 6 -> keine Primzahl
7 ist nicht durch eine Primzahl teilbar -> Primzahl
8 ist durch 2 teilbar: 2 x 2 x 2 = 8 -> keine Primzahl
9 ist durch 3 teilbar: 3 x 3 = 9 -> keine Primzahl
10 ist durch 2 und 5 teilbar: 2 x 5 = 10 -> keine Primzahl
...
100 ist durch 2 und 5 teilbar: 2 x 2 x 5 x 5 = 100 -> keine Primzahl
...

Das Thema reizt mich nun auch und ich versuche das ganze mal zu implementieren.

Grüße...

Heiko

Hinweis: Der Algorithmus erhebt nicht den Anspruch besonders performant oder elegant zu sein

// primes.cpp
#include <ios>
#include <iostream>
#include <vector>

typedef unsigned long ULONG;

// ==================================================================
// *** Deklaration Klasse PrimeGenerator und Operatoren ***
class PrimeGenerator
{
    friend std::ostream& operator<<(std::ostream&, const PrimeGenerator&);

private:
    // *** Attribute ***
    std::vector<ULONG> primes;

public:
    // *** Konstruktor ***
    PrimeGenerator()
        : primes()
        { }

    /*** Destruktor, Kopierkonstruktor und Zuweisungsoperator werden
        vom Compiler generiert. ***/

    // *** spezielle Methoden ***
    void generate(ULONG max);
        // Generiert Primzahlen bis zur Obergrenze 'max'

};

std::ostream& operator<<(std::ostream& out, const PrimeGenerator& p);

// ==================================================================
// ==================================================================
using namespace std;

// *** main-Funktion ***
int main(int argc, char** args)
    {
        PrimeGenerator pg;
        pg.generate(10000UL);
        cout << pg << endl;
        return 0;
    }

// ==================================================================
// *** Definition der Klasse PrimeGenerator und Operatoren ***
void PrimeGenerator::generate(ULONG max)
    {
        ULONG n = 2UL;  // Die Iteration startet mit 2

        do {

            // Prüfen, ob n durch eine (vorhandene) Primzahl ohne
            //  Rest teilbar ist.
            bool devideable = false;
            vector<ULONG>::const_iterator iter = primes.begin();

            for(; iter != primes.end() && !devideable; iter++) {
                if(n % (*iter) == 0) devideable = true;
            }

            // Ist n nicht durch eine Primzahl teilbar (for-Schleife
            //  wurde vollständig durchlaufen), so handelt es sich bei
            //  n ebenfalls um eine Primzahl und wird in den 
            //  Primzahlen-vector aufgenommen.
            if(!devideable) primes.push_back(n);

        } while(n++ < max);
    }

ostream& operator<<(ostream& out, const PrimeGenerator& p)
    {
        vector<ULONG>::const_iterator iter = p.primes.begin();
        for(; iter != p.primes.end(); iter++) {
            out << *iter << " ";
        }        
        return out;
    }

Ich hoffe, das hilft Dir ein bisschen, um bei der Thematik durchzublicken.

Grüße aus dem (im Moment sonnigen) Sauerland

Heiko

MfG
Stromberg

@Heiko:
Die Methode mit dem Modulo hatten wir schon, das Problem ist, dass so eine Division viel Zeit kostet. Die Methode der Vielfachen ist selbst gegenüber einer stark optimierten Version ca. 10-20 mal schneller. Und dann kann man ja noch optimieren

Ich hab die verschiedenen Methoden mal ausgibig getestet:
PrimePrintResults.xls

Besonders bei der Suche nach großen Primzahlen, dauert die Modulo-Methode einfach zu lange. Allerdings hat sie den Vorteil, dass man sich nicht um Speicher kümmern muss. Die Sieb-Methode kann schon mal ziemlich viel davon in Anspruch nehmen.

Gruß
Don06

#include <iostream>
using namespace std;

class prime
{
    public:
    prime() {}
    ~prime() {}
    inline bool is_prime(unsigned long &number) const;
    void search_prime(unsigned long &list_end) const;

    private:
    bool array_null(const unsigned long *value,unsigned long &temp) const;

};

bool prime::array_null(const unsigned long *value, unsigned long &temp) const
{
    if (value==0)
    {
        return true;
        temp++;
        array_null(++value,temp);
    }
    else
    {
        return false;
    }
}

bool prime::is_prime(unsigned long &number) const
{
    for (unsigned long i=2;i<number;i++)
    {
        if ((number % i) == 0) return false;
    }
    return true;
}

void prime::search_prime(unsigned long &list_end) const
{
    unsigned long *array=new unsigned long[list_end];
    for (unsigned long i=2;i<=list_end;i++)
    {
        array_null(&array[2-1],i);
        if (is_prime(i))
        {
            for (unsigned long j=2;j*i<=list_end;j++)
            {
                array[j*i-1]=0; //0 = KEINE PRIMZAHL
                //cout << "!\n";
            }
        }
     }

     for (unsigned long i=1;i<=list_end;i++)
     {
         if (array[i-1] != 0) cout << i << endl;
     }
}

int main()
{
    prime test;
    unsigned long a=197;
    test.search_prime(a);

    return 0;
}

Verstehst du den jetzigen Code von mir besser? Also ich erstelle ein Feld, und wenn jetzt z.B. "4" keine Primzahl ist, dann schreib ich "array[3]=0;", oder bei 16 "array[15]=0" und so kann ich das dann gleich immer schnell überprüfen.
Nur das GRÖßTE PROBLEM ist, wenn ich in meine Funktion einen höheren Wert als 196 eintrage, dann steht nur noch "1" u. "2" dran!?! Warum....das verstehe ich überhaupt nicht, warum geht es mit allen Zahlen < 197 aber mit Zahlen > 197 nicht mehr? Da kann doch höchstens bei mir was mit nem Typ nicht stimmen? Aber eigentlich sind alles "unsigned long".....mh des check ich mal gar net, findet jemand den Fehler vll.?

PS: Das "cout" nimmt ja die ganze Schnelligkeit weg, aber das steht bis jetzt nur zu Testzwecken drin. Wenn es mal gehen sollte, dann schmeiß ich des "cout" raus, und schreib alle Primzahlen in ein Feld rein.

MfG
Stromberg

#include <iostream>
using namespace std;

class prime
{
    public:
    prime() {}
    ~prime() {}
    inline bool is_prime(unsigned long &number) const;
    void search_prime(unsigned long &list_end) const;

    private:

};

bool prime::is_prime(unsigned long &number) const
{
    for (unsigned long i=2;i<number;i++)
    {
        if ((number % i) == 0) return false;
    }
    return true;
}

void prime::search_prime(unsigned long &list_end) const
{
    unsigned long *array=new unsigned long[list_end];
    for (unsigned long i=2;i<=list_end;i++)
    {

        while(array[i-1]==0)
        {
            i++;
        }

        if (is_prime(i))
        {
            for (unsigned long j=2;j*i<=list_end;j++)
            {
                array[j*i-1]=0; //0 = KEINE PRIMZAHL
            }
        }
     }

     for (unsigned long i=1;i<=list_end;i++)
     {
         if (array[i-1] != 0) cout << i << endl;
     }
}

int main()
{
    prime test;
    unsigned long a=206;
    test.search_prime(a);

    return 0;
}

MfG
Stromberg

(Aber ich hab immer so nen Komplex gegen "while Schleifen", weil ich irgendwo mal gehört habe, das es in einem guten Code nur 1 while Schleife gibt, nämlich die Hauptschleife. Unsinn?)

Wie wäre es mit goto anstatt der while-Schleife?