Mittelwert und Standardabweichung

[Hobbyprogrammierer]

Hallo an alle,

ich benötige Hilfe. Und zwar vorerst zur Mittelwertbildung. Ich habe Textdateien die immer folgend aufgebaut sind: xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx...
Die x'e stehen nur für Zahlen und zwar für ein bis dreistellige. Bei Einstelligen halt mit 3 Leerzeichen, bei Zweistelligen mit 2 und so weiter...
Ich lese die 4er Blöcke jetzt mit folgender Routine in ein Array ein:

Delphi-Quellcode:

var f: file;
    i: Byte;
    A: Array[1..4] of char;

begin
  memo1.Lines.Clear;
  opendialog1.Execute;
  assignfile(f, opendialog1.FileName);
  reset(F, 1);
    for i:= 1 to 5 do
      begin
        blockread(f, a[1], sizeof(a));
        memo1.Lines.add(a);
      end;
  closefile(f);
end;

Aus diesen 5 Werten brauche ich jetzt den Mittelwert. Leider funktioniert das mit mean(Array) nicht, da ich kein Array of Double habe. Und das habe ich nicht, weil irgendwie ständig die Leerzeichen gestört haben. Gibts da noch einen anderen Weg, als die komplette Gleichung in eine Funktion zu schreiben? (Beim Mittelwert gehts ja noch, aber bei der Standardabweichung wirds schon schwieriger)


:shock:



Danke

[edit=alcaeus]delphi-tags eingefuegt. In Zukunft bitte selbst machen. Mfg, alcaeus[/edit]

[Flare]

Es gibt da so eine Prozedur namens Val(string, variable, code) mit der man aus einen String eine Zahl machen kann...nur weiß ich nicht ob der mit den Leerzeichen zurechtkommt.
Wenn nicht, gibt es die Funktion Trim(string) die die Leerzeichen wegschneidet.


Flare

[Hobbyprogrammierer]

Die Version das ganze in Strings zu wandeln, die Leerzeichen wegzuschneiden und anschliessend wieder Integer daraus zu machen um zu rechnen hatte ich auch schon. Problem ist nur, dass ich von diesen 4er Blöcken im Schnitt zwischen 5 und 8 Mio. in einer Textdatei habe. Das dauert ewig. Aber danke trotzdem!

[Hawkeye219]

Hallo,

das Aufteilen der Zeilen könntest Du mit einer Stringliste durchführen:

Delphi-Quellcode:

List := TStringList.Create;
try
  List.Delimiter := ' ';
  List.DelimitedText := '  1   4   199  55';
    
  // hier die Liste verarbeiten
    
finally
  List.Free;
end;

Nach der Zuweisung zu DelimitedText stehen die einzelnen Werte als String(!) in der Liste und können über einen ganzzahligen Index ausgelesen werden.

Gruß Hawkeye

[markusj]

Vorschlag: Du lagerst die Blöcke nicht in Arrays of Char, sondern, komplett gesehen, in einem Array of String, was ja fast das gleiche ist ...
Aber, du analysierst beim einlesen gleich, ob das Zeichen ein ' ' ist, wenn ja, schreibst dus einfach nicht in den String ...

Pseudocode:

Delphi-Quellcode:

var strings : array of string;
i := 0;
setlength(strings,1,1);
repeat
 blockread(datei, buf, 1);
 if buf <> ' ' then
  begin
  setlength(strings,length(strings+1);
  setlength(strings[i],length(strings[i]+1);
  strings[i,c] := buf;
  inc(c);
  end else
  begin
  inc(i);
  c := 1;
  end;
 until eof(datei);

Dann hast du ein dynamisches Array mit allen String-Ketten, die du dann einfach per StrToInt umwandeln kannst.

mfG

Markus

EDIT: Danke roter Kasten, ich habs gesehen ... eine Anmerkung, mein Code verhindert das auftreten von Leerzeichen in den Strings von Anfang an, das erspart eine Performanceaufwändige, doppelte Berarbeitung der Strings.
Was evtl. Leistung frisst, ist das ständige setlength();, da evtl. jedes Mal Speicher alloziiert wird (schreibt man das so?). Man könnte im Voraus eine Länge von z.B.5 für einen Teilstring und 1000 für das Dynamsiche Array verlangen und bei überschreitung dieser Grenze dann einen weiteren Packen drauflegen.
Am Ende wird geprüft, welche Strings nicht enthalten und diese werden dann rausgeschnitten.

EDIT2: Noch was ... auch wenns auf den ersten Blick schwieriger scheint ... du färst mit TFileStreams und TMemoryStreams besser als mit Files ... such mal danach!

[Hobbyprogrammierer]

Ahaa?! :oops:

Das kenne ich noch nicht. Hab ich das jetzt auch richtig verstanden? Eine Stringlist und das Array komplett weglassen?

Ich werd mir da jetzt mal was zusammensuchen. Danke erstmal!

Uh, noch eine Antwort. Ihr seid super!

[Hobbyprogrammierer]

Ja die TFilestreams hab ich mir auch schon angesehen und erstmal nicht durchgesehen. Aber ich werd sie mir dann wohl doch nochmal zu Gemüte führen.

Danke an alle für die schnellen Lösungen! :P

[Mackhack]

Was ist denn das fuer ne File bei 8 Mio. von solchen Eintraegen?

[Hobbyprogrammierer]

Das sind Messdaten von gepulsten Lasern. Und da diese von Dauertests stammen, sind das streckenweise auch 60Mio Einzeldaten. Und bei der Menge gibt auch Excel auf mit Mittelwert und Standardabweichungsberechnungen.

[Hawkeye219]

Hier noch eine Versuch (nur grob getestet):

Delphi-Quellcode:

var Numbers: array of integer;

procedure Parser (const aText: string);

  var p     : PChar;
      Count : Integer;
      Value : Integer;
      
begin

  // Zeiger auf das erste Zeichen setzen
  p := PChar(aText);

  // Anzahl Werte im Feld initialisieren
  Count := 0;

  // alle Zeichen des Strings verarbeiten
  while (p^ <> #0) do

    // ist es eine Ziffer?
    if (p^ in ['0'..'9']) then
      begin

        // ja: Zahl komplett einlesen
        Value := 0;
        while (p^ in ['0'..'9']) do
          begin
            Value := 10 * Value + Ord(p^) - Ord('0');
            Inc (p);
          end;

        // Feld bei Bedarf vergrößern
        if (Count = Length(Numbers)) then
          SetLength (Numbers, Count + 1024);

        // Zahl ablegen und zählen
        Numbers[Count] := Value;
        Inc (Count);

      end
    else

      // andere Zeichen überlesen
      Inc (p);

  // unbenutzte Feldelemente abschneiden    
  SetLength (Numbers, Count);

end;

Der Parser scannt den übergebenen Text und trägt alle gefundenen (positiven, ganzzahligen!) Werte in das Feld Numbers ein. Du kannst ihm einzelne Zeilen oder den kompletten Inhalt der Datei (als String) übergeben.

Gruß Hawkeye

[negaH]

Hi

du solltest mehrere Dinge berücksichtigen bei dieser Datenmenge:

1.) mit Stream arbeiten, statt den alten Blockread() etcpp.
2.) mit Buffern arbeiten, dh. deine Daten werden in einen Bufferspeicher geladen und von da ausgewertet
3.) die Konvertierung der Strings live durchführen, quasi "on the fly"
4.) die Berechnung des Durchschnittes und der Standardabweichung mit einer speziellen Formel durchführen. Dabei wird die normale Formel der Standardabweichung so umgestellt das sie auf Grund des Binomials nun sequientiell berechnet werden kann. Man kann also sequientiell deine Zahlen einlesen und wiederum "on the fly" diese Werte berechnen.

Anbei mal ein Lösungsvorschlag:

Delphi-Quellcode:

procedure XYZ;
const
  BufferSize = 1024 * 4;
var
  Stream: TFileStream;
  Buffer: String;
  Value: Integer;            // aktuelle Zahl in der Datei
  ValueSign: Integer;        // Vorzeichen von Value
  ValueCount: Integer;       // Anzahl der gelesenen Zahlen aus der Datei
  ValueValid: Boolean;       // enthält Value eine gültige Zahl ?
  Avg: Double;               // kummulierte Summe aller Zahlen -> Avg / ValueCount == Durchschnitt
  Dev: Double;               // kummulierte Quadrate aller Zahlen -> Dev * ValueCount - Avg / (ValueCount * (ValueCount -1)) == Standardabweichung
  CurChar,EndChar: PChar;    // Anfang/Ende des Buffer
  Symbol: Char;              // aktuell auszuwertende Ziffer/Buchstabe
begin
// initialisierung
  CurChar := nil;
  EndChar := nil;
  Value := 0;
  ValueSign := +1;
  ValueValid := False;
  ValueCount := 0;
  Avg := 0;
  Dev := 0;
// Buffer allozieren, Stream öffnen
  SetLength(Buffer, BufferSize);
  Stream := TFileStream.Create('Filename', fmOpenRead or fmShareDenyNone);
  try
    repeat
    // solange noch Zeichen im Buffer diese in Zahlen umwandeln
      while CurChar < EndChar do
      begin
        Symbol := CurChar^;
        if Symbol in ['0'..'9'] then
        begin // String in Zahl umwandeln
          Value := Value * 10 + Ord(Symbol) - Ord('0');
          ValueValid := True;
        end else
          if ValueValid then
          begin // falls in Value eine gültige Zahl war diese in Avg/Dev kummulieren
            Value := Value * ValueSign;
            Avg := Avg + Value;
            Dev := Dev + Sqr(Value);
            Inc(ValueCount);
            // 1.)
            ValueValid := False;
            Value := 0;
            ValueSign := +1;
          end else
            if Symbol = '-' then 
              ValueSign := -1;
        Inc(CurChar);
      end;
    // Buffer aus Datei laden
      CurChar := PChar(Buffer);
      EndChar := CurChar + Stream.Read(Buffer[1], BufferSize);
    until EndChar = CurChar;
    if ValueValid then
    begin // letzte eventuell nicht per Leerzeichen abgeschlossene Zahl berücksichtigen
      Value := Value * ValueSign;
      Avg := Avg + Value;
      Dev := Dev + Sqr(Value);
      Inc(ValueCount);
    end;
  finally
    Stream.Free;
  end;
// Standardabweichung berechnen
  Dev := (Dev * ValueCount - Sqr(Avg)) / (Sqr(ValueCount) - ValueCount);
// Durchschnitt berechnen
  Avg := Avg / ValueCount;
// Auf Grund obiger Formeln kann die Standardabweichung und der Durchschnitt zu jedem
// Zeitpunkt in Source bei 1.) fortlaufend berechnet werden -> also sequientiell
end;

Gruß hagen

[Hobbyprogrammierer]

Hallo!

Bin wieder wach! :shock:

Freue mich wirklich über derart viel Resonanz! Ist aber für einen *Hobbyprogrammierer* ganz schön harter Stoff. Werd ich wohl die ganze nächste Woche dran zu knacken haben. Aber danke nochmal vielmals! :thumb:

[Hobbyprogrammierer]

Bin wieder da :-D

Ich gebe zu, ich habe negaH´s Code einfach nur blind abgetippt. Aber mit Online-Hilfe, zwei Büchern und mehreren Stunden Konzentration ist´s gar nich mal so schwer. :stupid: Wenn man erstmal durch ist. Zwei Fragen sind allerdings offen geblieben:

1. Was genau macht diese Zeile?

Value:= Value*10 + Ord(Symbol) - Ord('0');


2. An welcher Stelle kann ich einsteigen, wenn ich nur z.B. die Werte zwischen 200.000 und 300.000 berechnet haben will? Kann ich CurChar und EndChar gleich zu Beginn die Positionen zuweisen?

Danke!

[cruiser]

1.) Bei mehreren Ziffern hintereinander sorgt das für die Multiplikation:
1. Ziffer: 5 > Value = 0 > Value*10+5 = 5
2. Ziffer: 2 > Value = 5 > Value*10+2 = 52
... usw.

2.) Ich würd hier einsteigen und Value mit logischen and's mitprüfen:

Delphi-Quellcode:

        end else
          if ValueValid then
          begin // falls in Value eine gültige Zahl war diese in Avg/Dev kummulieren

{--- zu: ---}

        end else
          if ValueValid and (Value >= 200) and (Value <= 300) then
          begin // falls in Value eine gültige Zahl war diese in Avg/Dev kummulieren

[Hobbyprogrammierer]

Klingt absolut logisch. Schonwieder ärgerlich nicht selbst drauf gekommen zu sein. :wall:

Danke, werds gleich mal einbauen.

[negaH]

Zitat:

2. An welcher Stelle kann ich einsteigen, wenn ich nur z.B. die Werte zwischen 200.000 und 300.000 berechnet haben will?

Delphi-Quellcode:

  if ValueValid then 
  begin // falls in Value eine gültige Zahl war diese in Avg/Dev kummulieren 
    Inc(ValueCount); 
    Value := Value * ValueSign; 

// hier nur die 100000'te bis 200000'te Zahl in berechnung berücksichtigen
    if (ValueCount >= 100000) and (ValueCount < 200000) then
    begin
      Avg := Avg + Value; 
      Dev := Dev + Sqr(Value); 
    end else
      if (ValueCount = 200000) then
      begin // hier bei 200000 Zahl die realen werte ausrechnen
        Dev := (Dev * (200000-100000) - Sqr(Avg)) / (Sqr((200000-100000)) - (200000-100000)); 
        Avg := Avg / (200000-100000); 
      end;

    ValueValid := False; 
    Value := 0; 
    ValueSign := +1;    
  end else

Zitat:

Kann ich CurChar und EndChar gleich zu Beginn die Positionen zuweisen?

Nein das geht nicht, es sei denn alle Zahlen verbrauchen exakt die gleiche Anzahl an Ziffern. Also angenommen bei einer 3 stelligen Zahl wären 2 Leerzeichen davor = 5 zeichen, bei einer 1 stelligen Zahl also 4 Leerzeichen == 5 zeichen, ergo alle Zahlen belegen 5 Bytes in der Datei, dann geht das direkt zu poitionieren. Statt aber CurChar etc. zu verändern einfach mit Stream.Position := 5 * 100000 auf die 100000'te Zahl positionieren und dann valueCount nur bis 100000 hochzählen lassen.

Gruß Hagen

[cruiser]

:gruebel: hum... da hab ich das wohl falsch verstanden. Ich hab es so gelesen dass er Nur Werte zw. 200 und 300 prüfen wollt. Aber stimmt... bei Integer gibbet keine Nachkommastellen. :oops:

[negaH]

Zitat:

1. Was genau macht diese Zeile?

Value:= Value*10 + Ord(Symbol) - Ord('0');

Kurz: das Gleiche wie StrToInt(),
es wandelt einen ASCII Zeichstrom aus Dezimalziffern zwischen '0' bis '9' in eine Zahl um.

Zuerstmal multiplizieren wir Value mit 10, weil ja die Daten in deiner Datei Dezimalzalhen sind, Zahlen zu Basis 10. Somit macht die Multiplikation mit 10 quasi eine weitere Stelle in der Zahl frei.

Ord(Symbol) - Ord('0') wandelt nun ein ASCII Zeichen das zwischen '0' bis '9' liegt in die entsprechende Zahl um. Wir machen un dabei den Fakt zu nutze das im ACSII Zeichsatz die Zeichen für die Ziffren 0 bis 9 einfach sequientiell kodiert sind. Das ASCII Zeichen für '0' hat den Bytewert Ord('0'), qausi der Index in die ASCII Zeichentabelle.

Du hast ja nun den Source eingebaut, und wie schnell ist es jetzt ?

Gruß Hagen

[Hobbyprogrammierer]

*Flupp*

Ungefähr so schnell. :-D

Aber so ganz richtig bin ich noch nicht dahintergestiegen. Also zwischen bestimmten Positionen zu lesen. Aber ich sag mal lieber, wie das Ergebnis genau aussehen soll:

Also in der Datei stehen meinetwegen *128 *130 *129 *129 *128.... und zwar meinethalben 5Mio. dieser 4er Blöcke. Von diesen muss ich jetzt immer 20 nacheinander einlesen, Mittelwert und Standardabweichung berechnen, dann die nächsten 20 u.s.w.

Wenn ich alles richtig verstanden habe, müsste ich eigentlich nur auf ValueCount schauen und immer bei 20+ die Berechnung durchführen. Oder? :?

[negaH]

Korrekt.

Und wenn deine Zahlen immer aus 4 Zeichen bestehen dann hast du enormes Glück gehabt denn du kannst sehr schnell positionieren. Das kann unter Umständen dir dabei helfen deine 8 Millionen Zahlen quasi in parallel abzuarbeiten. Dazu teilst du die Datei in sagen wir mal 20 kleinere Dateien die eine Größe besitzen die ein Vielfaches von 4 * 20 ist. 4 weil deine Zahlen ja immer aus 4 zeichen bestehen und * 20 weil du ja immer 20 solcher Zahlen bewerten möchtest.

Du kannst also ohne großen Aufwand die Verarbeitung mit mehreren CPUs bzw. Rechnern beschleunigen. Denn 8 Millionen Zahlen sind nicht wenige Zahlen, und selbst die schnellste Umsetzung als program wird denoch einiges an Reechenzeit benötigen.

Du solltest jetzt einfach folgendes abändern:

Delphi-Quellcode:

procedure ProcessFile(const AFilename: String; AOffset,ACount: Integer); 
// AOffset = Index der Zahl mit der begonnen werden soll, jede Zahl besteht aus 4 Zeichen in der Datei
// ACount = Anzahl der Zahlen die berechnet werden sollen
const 
  BufferSize = 1024 * 4; 
var 
  Stream: TFileStream; 
  Buffer: String; 
  Value: Integer;            // aktuelle Zahl in der Datei 
  ValueSign: Integer;        // Vorzeichen von Value 
  ValueCount: Integer;       // Anzahl der gelesenen Zahlen aus der Datei 
  ValueValid: Boolean;       // enthält Value eine gültige Zahl ? 
  Avg: Double;               // kummulierte Summe aller Zahlen -> Avg / ValueCount == Durchschnitt 
  Dev: Double;               // kummulierte Quadrate aller Zahlen -> Dev * ValueCount - Avg / (ValueCount * (ValueCount -1)) == Standardabweichung 
  CurChar,EndChar: PChar;    // Anfang/Ende des Buffer 
  Symbol: Char;              // aktuell auszuwertende Ziffer/Buchstabe 

  procedure Calculate;
  begin
    Value := Value * ValueSign; 
    Avg := Avg + Value; 
    Dev := Dev + Sqr(Value); 
    Inc(ValueCount); 
    if ValueCount = 20 then  
    begin
// Standardabweichung/Durchschnitt berechnen 
      Dev := (Dev * 20 - Sqr(Avg)) / (20*19); 
      Avg := Avg / 20; 
// hier Werte Avg/Dev speichern oder so...
// alle kumulativen Werte auf 0 setzen  
      ValueCount := 0; 
      Avg := 0;
      Dev := 0;
    end; 
    ValueValid := False; 
    Value := 0; 
    ValueSign := +1; 
    Dec(ACount); 
  end;

begin 
// initialisierung 
  CurChar := nil; 
  EndChar := nil; 
  Value := 0; 
  ValueSign := +1; 
  ValueValid := False; 
  ValueCount := 0; 
  Avg := 0; 
  Dev := 0; 
// Buffer allozieren, Stream öffnen 
  SetLength(Buffer, BufferSize); 
  Stream := TFileStream.Create(AFilename, fmOpenRead or fmShareDenyNone); 
  try 
    Stream.Position := AOffset * 4;
    repeat 
    // solange noch Zeichen im Buffer diese in Zahlen umwandeln 
      while (CurChar < EndChar) and (ACount > 0) do 
      begin 
        Symbol := CurChar^; 
        if Symbol in ['0'..'9'] then 
        begin // String in Zahl umwandeln 
          Value := Value * 10 + Ord(Symbol) - Ord('0'); 
          ValueValid := True; 
        end else 
          if ValueValid then // falls in Value eine gültige Zahl war diese in Avg/Dev kummulieren 
            Calculate 
          else 
            if Symbol = '-' then 
              ValueSign := -1; 
        Inc(CurChar); 
      end; 
    // Buffer aus Datei laden 
      CurChar := PChar(Buffer); 
      EndChar := CurChar + Stream.Read(Buffer[1], BufferSize); 
    until (EndChar = CurChar) and (ACount <= 0); 
    if ValueValid then // letzte eventuell nicht per Leerzeichen abgeschlossene Zahl berücksichtigen 
      Calculate;
  finally 
    Stream.Free; 
  end; 
end;

Gruß Hagen

[edit]
Da fällt mir ein das du aber sehr aufpassen musst. Betrachte deine Datei nochmal genau mit einem HEX Editor ob wirklich nur Zahlen in 4 Zeichen Gruppen darin vorkommen. Im speziellen beziehe ich mich auf den Zeilenumbruch, Zeilenvorschub -> Carrige Return, Linefeed -> #13,#10 und eventuell Tabs -> #9. Solche Sonderzeichen sollten darin nicht enthalten sein !
[/edit]

[Hobbyprogrammierer]

Heidiho, und noch eine Nacht. Ich dank erstmal und werde mich dann mal ans lernen machen. Das Schöne ist zwar das Dein Code immer auf Anhieb funktioniert, aber ich werd bekloppt, wenn ich nicht verstehe was mein Rechner da grad macht.

Ah, roter Kasten. Der Vorteil ist, dass ich diese Datei selbst 'erzeuge'. Also per Export aus dem Energiemessprogramm auf Arbeit. Da kann ich die Trennzeichen selbst wählen zwischen TAB, Return, none, ',' und ';'.
Und ganz am Anfang bin am Besten mit none klar gekommen. Da ist dann auch wirklich nichts Anderes drin. Man muß auch mal Glück haben :-D

[negaH]

Ähm, wenn du die Dateien selbst erzeugst warum berechnest du dann nicht sofort den Durchschnitt und StdDev ?
Entweder du kannst dann auf deine Dateien ganz verzichten oder organisierst diese Zeilenweis a 20 Zahlen und am Anfang der Zeile steht der Duchschnitt und StdDev.

Gruß Hagen

[Hobbyprogrammierer]

Hallo :hi:

Das Erstellen der .txt Datei macht schon das Messprogramm der Laser. Da kann ich lediglich die Trennzeichen bestimmen.

@negaH
Vom Kopf her bilde ich mir ein, Deinen Code verstanden zu haben. Allerdings tu ich mich momentan noch ein wenig schwer das ganze in einen Button.Click einzubauen. Aber ich kämpfe.

Andere Frage: Woher habt Ihr Euer Wissen so? Richtig gelernt? Ich hab hier zwei Bücher (NittyGritty und eins von Markt und Technik), die mir aber immer weniger helfen können. Filestreams sind z.B. in 3 Seiten abgetan. Könnt Ihr Bücher empfehlen?

Danke

[Mackhack]

Doberenz & Kowalski Bücher sind meiner Meinung ganz gut!

[Hobbyprogrammierer]

Okay, geschafft... bin am Ende :shock:

Also die erste Variante von negaH hab ich ja noch verstanden. Hab das Ganze einem ButtonClick inkl. OpenDialog zugeteilt...Prima funktioniert. Aber der letzte Teil ist doch irgendwie zuviel. Was macht denn die Procedure ProcessFile??? Und wo gehört die hin?
Hoffentlich verzweifelt ihr nicht noch mit mir :oops:

[negaH]

Sie macht genau das was du dir wünscht.

Du rufst sie zb so auf

ProcessFile('MyFile.txt', 100000, 5000);

dann wird sie die Datei MyFile.txt öffnen und mit der 100000'en Zahl beginnen und die nächsten 5000 Zahlen berechnen. Nach jeweils 20 Zahlen wird der Durchschnitt/stdDev berechnet. Das Einzigste was du nun noch bauen musst ist die Auswertung dieser beiden Werte in Calculate;

Gruß Hagen

[Hobbyprogrammierer]

:oops: :oops: :oops: :oops: :oops:

Nachts um drei hatts dann klick gemacht.Peinlich. Is wohl das mit dem Wald und den vielen Bäumen.
Ganz dolle Danke nochmal! Super Forum!

Ich weiß nicht wie es bei anderen Leuten aussieht, aber da ich des öfteren mit der Bearbeitung von Dateien zu tun hab, ist der Code doch wirklich Gold wert. Mal ganz abgesehen vom Lerneffekt.

Also vielleicht etwas für die Code-Library?!


Grüße
Ronny



Ups, Lampe jetzt erst gefunden. Schonwieder ein Baum :-D

[negaH]

Nein, so gut finde ich den Code auch wieder nicht. Er hat dir weitergeholfen und deshalb überbewertest du seine Qualität ;) Es gibt solche Beispiele enmass in der DP und die wenigsten davon gehören in die Codelib.

Gruß hagen