Textausgabe in Memo sehr langsam

[user64629]

So ich habe jetzt mal versucht eine ListBox zu nehmen, allerdings zeigt die meine Einträge nicht korrekt an! Irgendwann gegen Ende fängt sie einfach wieder von vorne an, ohne jedoch meine letzten Einträge anzuzeigen!

Jetzt meine Frage, wie befülle ich eine StringList?

Und meine PC hat ein Q8200, zwar auch nicht der shcnellste aber 2,33 GHz. Kerne sind ja egal unterstützt Delphi ja eh nicht.

Außerdem kann man bei meinem Programm ja eingeben, bis wo der die Primzahlen berechnen soll und es wäre ja schön wenn das über 4 Milliarden geht :-)

Hier mal der gesamte Auszug der Prozedur (jetzt im verbesserten Zustand)

Delphi-Quellcode:

var Primzahlen: Array of UInt64;

procedure TPrimzahlberechnung.BerechnenClick(Sender: TObject);
var Bis, i, j: UInt64;
    Primzahl: Boolean;
    Zwischenspeicher: TStringList;
begin
 Primzahlberechnung.Enabled := False;
 Berechnung.Show;
 Application.ProcessMessages;

 SetLength(Primzahlen, 8);
 Primzahlen[0] := 2;
 Primzahlen[1] := 3;
 Primzahlen[2] := 5;
 Primzahlen[3] := 7;
 Primzahlen[4] := 11;
 Primzahlen[5] := 13;
 Primzahlen[6] := 17;
 Primzahlen[7] := 19;

 i := 20;
 Bis := StrToInt64(Bereich.Text);
 while i < Bis
  do begin
      Primzahl := True;
      j := 0;
      while (j < Length(Primzahlen) - 1) and (Primzahlen[j] <= sqrt(i)) 
                                         and (Primzahl = True)
       do begin
           if i Mod Primzahlen[j] = 0
              then Primzahl := False;
           j := j + 1;
          end;
      if Primzahl = True
         then begin
               SetLength(Primzahlen, Length(Primzahlen) + 1);
               Primzahlen[Length(Primzahlen) - 1] := i;
              end;
      i := i + 1;
     end;

 Berechnung.Close;
 Ausgabe.Show;

// Bei einer Millionen seh ich hier nach knapp einer Sekunde das andere Formular

 Ergebniss.Items.Clear;
 Anzahl.Text := IntToStr(Length(Primzahlen));
 Application.ProcessMessages;

// Hier beginnt die Ausgabe

 i := 0;
 Zwischenspeicher := TStringList.Create;
 while i < Length(Primzahlen)
  do begin
      Zwischenspeicher.Add(IntToStr(Primzahlen[i]));
      i := i + 1;
     end;
 SendMessage(Ergebniss.Handle, WM_SETTEXT, 0, Longint(Zwischenspeicher.Text));
 Zwischenspeicher.Free;

 Ausgabe.Close;

// Hier seh ich das es gefüllt ist, dauert jetzt nur deutlich weniger als eine Sekunde :-)

 Primzahlberechnung.Enabled := True;
 Ergebniss.SetFocus;
end;

Ich habe noch 2 Formulare die angezeigt werden, damit man weiß das gearbeitet wird...


Edit: Ach steht ja ein Post vorher mit der StringList... Allerdins hat die ListBox trotzdem das Problem, das nicht alles angezeigt wird, also wieder mit langsamen Memo arbeiten? :-D


Edit 2: Okay hab wieder ein Memo genommen. Selbst die Ausgabe aller 664579 Primzahlen bis 10 Millionen klappt in unter einer Sekunde :-) Jetzt könnte ich noch versuchen einen schnelleren Algorithmus für die Primzahlen zu suchen danke :-)

[himitsu]

Primzahlen bis über 4 miliarden gehen schon,
aber der Index (also die Anzahl der Werte in dem Array) ist eher begrenzt.

Int64 und Extended bieten schonmal mehr Platz und wenn nötig kann man auch noch auf spezielle Mathebibliotheken verwenden.
Da gibt es übrigens mehrere direkt hier im Forum zu finden.

[Aphton]

Probiers mal so:

Quellcode

Delphi-Quellcode:

{...}

var
  i: Integer;
  Primzahlen: Int64Arr;
  PrimzahlenStr: String;

{...}

Primzahlen := SieveOfErastothenes(1, 4000000);
for i := 0 to High(Primzahlen) do
  PrimzahlenStr := PrimzahlenStr + IntToStr(Primzahlen[i]) + #13#10;
Ergebniss.Lines.BeginUpdate;
Ergebniss.Lines.Text := PrimzahlenStr;
Ergebniss.Lines.EndUpdate;

[Gustav.R]

Bin mir jetzt nicht ganz sicher, wer es hier irgendwo schon geschrieben hatte (himitsu)?

Sinngemäß lieber TRichEdit statt TMemo verwenden, für schnelle Zeilen ab XP oder erst ab Vista?

GG

[blackfin]

Zitat:

Kerne sind ja egal unterstützt Delphi ja eh nicht.

Das stimmt so nicht. Wenn du deine Berechnung in mehrere parallele Threads aufspaltest, dann verwendet Delphi sehr wohl die anderen Kerne zur Berechnung :-)
Gut, hat nichts mit dem langsamen Memo zu tun, aber die Aussage, dass Delphi keine zusätzlichen CPU-Kerne verwenden kann, stimmt ja so nicht :-)