Nachkommastellen

[Herman2007]

Hi,
und zwar geht es darum das ich ein Programm schreiben muss, dass Werte aus einer Liste rausliesst und diese dann addiert:

Jetzt sollen die Werte die die Nachkommastellen "11,33,55,77,99" haben in eine neue Liste packen.
Das Problem ist das ich nicht weiss wie ich es formulieren muss, das die Abfrage nur auf die Nachkommastellen achtet und die Vorkommerstellen nicht beachtet.

if(5.83 + 6.58 == 11  ){                
			 System.out.println(true);
		 }else{
			 System.out.println(false);
		 }

Muss ich denn Double wert vielleicht zuerst in einen char[] umwandeln und somit nur die letzten beiden Werte beachten?

Ein weiteres Problem ist wie ich nach dem "==" die anderen "33,55,77,99" noch mit dazu kriege ich dachte mit "|" würde es gehen aber das funktioniert nicht.


Ich hoffe ihr habt nen paar Hilfreiche Tipps für mich.

MFG

Hermann

 

[The_S]

double d = 2.11;
d = Math.round((d - (int)d) * 100);
System.out.println(d == 11);

 

[der JoJo]

und beim verknüpfen must du jedes mal d == mitschreiben:

if( d==11 || d==33 ||d==55 ...)
{
   //do some shit
}

 

[The_S]

@Jojo

deine Signatur zaubert mir immer wieder ein Schmunzeln auf die Lippen :toll:

 

[Marco13]

double d = 2.11;
d = Math.round((d - (int)d) * 100);
System.out.println(d == 11);

Das ist immernoch gefährlich - und hat nur indirekt mit der gestellten Frage zu tun.

Für solche Abfragen empfielt sich ein

private static boolean epsilonEquals(double x, double y)
{
   final double epsilon = 1e-7;
   return Math.abs(x - y) <= epsilon * Math.abs(x);
 }

so dass man dann

if(epsilonEquals(5.83+6.58, 11)) {         ... }

machen kann...

 

[fehlerfinder]

double d = 2.11;
d = Math.round((d - (int)d) * 100);
System.out.println(d == 11);

Muss das nicht eher

double d = 2.11;
long l = Math.round((d - (int)d) * 100);
System.out.println(l == 11);

heißen?

 

[The_S]

ob ich jetzt n double oder n long vergleich, ist letztendlich doch egal ???:L .

 

[Herman2007]

Hat geklappt vielen dank =)



Ich hätte dazu (zu der Aufgabe) noch eine frage und zwar soll ich ja wie oben schon gesagt alle Paare aus der Liste die eine dieser Nachkommastellen ergeben in eine Liste packen.
So jetzt soll ich die Werte zuerst kombinieren die am wenigsten Paarungsmöglich keiten mit anderen haben:
Also zuerst denn Paaren der nur eine Paarungsmöglichkeit hat mit dem Paaren der auch nur eine oder zwei,drei......

So das man am ende so viele Paarungsmöglichkeiten wie möglich hat. (Ich hoffe man vesteht ungefähr worauf ich hinaus will)

Hab mir gedacht das ich das vll in einem zweidimensionalen Array Speicher und immer einen hochzähle wenn eine Paarungsmöglichkeit besteh aber weiss noch nicht genau wie ich das hinkriegen soll.

Vielleicht habt ihr ja auch noch eine paar gute ideen wär super nett und sehr hilfreich.

Später sollen da um die 20.000 Werte durchrasseln (ich weiss die Laufzeit wird wahrscheinlich ein Problem aber darum kümmer ich mich später =) ).


Dankeschön schonmal im vorraus!

MFG

Herman

 

[Herman2007]

Keiner eine Idee?

 

[der JoJo]

ich verstehe deine ausage einfach nich, iwas von paaren die paare haben und sich mit paaren paaren,?

poste mal ein einfaches beispiel

 

[fehlerfinder]

ob ich jetzt n double oder n long vergleich, ist letztendlich doch egal ???:L .

Ok - ich hatte es nicht getestet... Aber da Math.round(Double) einen long-Wert zurück gibt, hatte ich mal auf einen Compilerfehler getippt... Kommt aber keiner ;-)

 

[Herman2007]

Dachte mir schon das sowas kommt nachdem ich denn Text nochmal gelesen hab =)

Also z.b:



"C" ist nur einmal Paarbar mit "x"
"A" ist nur 3 mal Paarbar mit "y,x,c"
"D" ist 5 mal mit Paarbar mit "x,y,c,v,b"
.....



So jetzt soll zuert "C" mit "X" gepaart werden, da es am wenigsten Paarungsmöglichkeiten hat.
Jetzt soll "A" mit "y" gepaart werden, da es am zweitwenigsten Paarungsmöglichkeiten gar.
Jetzt "D" mit ...........

Hätte man als erstes "D" mit "X" gepaart könnte man "C" nicht mehr paaren, da es nur eine Paarungsmöglichkeit hat die weggefallen wäre.


So das man am Ende so viele Paare wie möglich rauskriegt.

Mein erster Gedanke war wie gesagt ein 2 Dimensionales Array wo ich immer 1 dazuaddiere wenn eine Paarungsmöglichkeit besteht.
Aber ich weiss nicht genau wie ich das umsetzen soll.



Hoffe es ist jetzt verständlicher.

MFG

Herman

 

[der JoJo]

Hoffe es ist jetzt verständlicher.

???:L :### ???:L ... nein

tut mir leid aber da kann ich dir nicht helfen

 

[fehlerfinder]

"C" ist nur einmal Paarbar mit "x"
"A" ist nur 3 mal Paarbar mit "y,x,c"
"D" ist 5 mal mit Paarbar mit "x,y,c,v,b"
[...]
Hoffe es ist jetzt verständlicher.

Kann es sein, dass du hier im falschen Thread, wenn nicht sogar im falschen Forum bist? Soll heißen: hast du den Beitrag, auf den du hinaus willst, evtl. gaaaaanz woanders gepostet?

 

[der JoJo]

ne ne, der is hier schohn richtig, ich glaube auch langsam zu verstehen was er meint,

Paarbar sind zwei werte dann, wenn das ergebniss der Addtition dießer Werte auf .11 , .33, .55, ... ended, oder?

 

[The_S]

ne ne, der is hier schohn richtig, ich glaube auch langsam zu verstehen was er meint,

Das is jetzt nicht dein Ernst oder :shock: ?

 

[Herman2007]

Genau!!!

Puh endlich hat`s einer ansatzweise verstanden vielleicht bin ich schon zu sehr in der materie drin und kann es nicht so gut formulieren, dass es auch für ander gut rüberkommt =)

 

[der JoJo]

doch, so ergiebt das nähmlich langsam sinn,
Angenommen

A=3.13
B=5.42
C=2.86
D=1.35

dann währen das die gültigen paare:

AB (8.55)
AC (5.99)
DB (6.77)

oder hab ich da jetzt was falsch verstanden?

 

[Herman2007]

Ne hast es richtig verstanden!!
Das wären die gültigen Paare.

 

[fehlerfinder]

Puh endlich hat`s einer ansatzweise verstanden vielleicht bin ich schon zu sehr in der materie drin und kann es nicht so gut formulieren, dass es auch für ander gut rüberkommt =)

Jetzt habe ich den Beitrag nochmal zurückverfolgt und mit viel gutem Willen lässt sich das Gesuchte auch tatsächlich aus dem Geschriebenen ermitteln.

Formulieren (oder verständlich formulieren) ist das Eine. Das kann schonmal schief gehen, kein Problem.

ABER: korrektes Deutsch schreiben - ohne Fehler, ohne SMS-Abkürzungen (ich hasse "vllt") und dergleichen kann man wohl verlangen. Genau dann lässt sich - bei korrekter Verwendung von Groß- und Kleinschreibung z.B. bei den "Paaren" (bei Verben klein, bei Substantiven groß...) - auch einigermaßen zügig ablesen, was evtl. gemeint sein könnte. Aber so... sorry... Wenn du nichtmal so viel Zeit aufbringst, vernünftig zu schreiben, warum soll ich dann meine wertvolle Zeit aufwenden, dir kostenlos(!) zu helfen??? :noe:

Sorry, dass jetzt ausgerechnet du "dran glauben" musstest. Das gilt auch für viele andere hier. Aber es geht ja auch anders. In diesem Sinne wünsche ich dir viel Erfolg bei der Lösungssuche und verabschiede mich aus diesem Thread.

 

[Herman2007]

Kann man nix machen trotzdem danke für`s lesen.

MFG

Herman

 

[der JoJo]

ich fande deinen Ansatz mit dem 2 dimensianalem array nicht schlecht, aber ich würde kein int array machen, sondern einfach ein boolean array, mit folgendem aufbau:

mit den daten von meinem letzten post

--A-B-C-D
A-X-1-1-0
B-1-X-0-1
C-1-0-X-0
D-0-1-0-X

dann brauchst du am ende nurnoch die booleanwerte addieren und hast somit die paarungsmöglichkeiten gezählt

 

[Marco13]

Ähm. Wenn mich jetzt nicht alles täuscht, ist das ein (abgewandeltes?*) Matching-Problem ( http://de.wikipedia.org/wiki/Paarung_(Graphentheorie) ) und die Lösung dafür ist .. naja... nicht wirklich schwierig, aber auch nicht völlig trivial. Der Ansatz, den du jetzt verfolgen wolltest, wäre dann ein Greedy-Algorithmus: Immer den Wert verpaaren, der im Moment am günstigsten erscheint. (Die Lösung, die dabei rauskommt, ist nicht unbedingt optimal - aber doch "meistens ganz gut"...)

* "abgewandelt", weil (mir) nicht klar ist, ob und wann Elemente mehrfach verwendet werden dürfen. der JoJo hat ja als Lösung geschrieben
AB (8.55)
AC (5.99)
DB (6.77)
Aber das letzte würde (FALLS ich nicht richtig verstanden habe) ja schon nichtmehr gehen, weil B schon bei AB "verbraucht" wurde?!

 

[happy_robot]

Anbei mal meine Lösung ohne viel mathematische Fummelei:

	public static boolean check(double a, double b) {
		String strSum = Double.toString(a+b);
		int intRest = Integer.parseInt(strSum.substring(strSum.indexOf('.')+1,strSum.indexOf('.')+3));
		return intRest % 11 != 0 ? false : ((intRest / 11)+2) % 2 != 0;
	}

Voraussetzung ist das es sich auf 2 Nachkommastellen beschränkt. Rundungsfehler sind hiermit ausgeschlossen.

mfg

EDIT: Das Ding mit den Paarungen scheint eine einfache Permutation zu sein. Die lässt sich evtl auch durch einfache Vergleiche auf wenige läufe reduzieren.

 

[Marco13]

Bei check(0.1, 0.1) haut's ihn mit einer Exception raus.
Bei check(0.94 0.17) ergibt die Summe 1.1099999999999999, und er liefert ein falsches Ergebnis.
Und von Geschwindigkeit (die ja laut Threadersteller relevant war) braucht man bei Double.toString, substring und mehrfachem indexOf :autsch: ja garnicht zu reden...

import java.util.*;

class CompareSpeedTest
{
    public static void main(String args[])
    {
        double input[] = createInput(2000);
        testCheck(1000, input);
        testCheck2(1000, input);
    }


    public static double[] createInput(int n)
    {
        Random random = new Random(0);
        double input[] = new double[n];
        for (int i=0; i<n; i++)
        {
            input[i] = ((int)(random.nextFloat() * 100) / 100.0);
        }
        return input;
    }


    public static void testCheck2(int n, double input[])
    {
        long before = System.currentTimeMillis();
        int counter = 0;
        for (int i=0; i<n; i++)
        {
            for (int j=0; j<input.length-1; j++)
            {
                if (check2(input[j], input[j+1]))
                {
                    counter++;
                }
            }
        }
        long time = System.currentTimeMillis()-before;
        System.out.println("check2 "+counter+" "+time);
    }

    public static boolean check2(double x, double y)
    {
        int i = (int)(x * 100 + 0.5);
        int j = (int)(y * 100 + 0.5);
        int d = (i+j) % 100;
        boolean result = (d % 11 == 0) && (((d / 11) % 2) == 1);
        return result;
    }



    public static void testCheck(int n, double input[])
    {
        long before = System.currentTimeMillis();
        int counter = 0;
        for (int i=0; i<n; i++)
        {
            for (int j=0; j<input.length-1; j++)
            {
                if (check(input[j], input[j+1]))
                {
                    counter++;
                }
            }
        }
        long time = System.currentTimeMillis()-before;
        System.out.println("check  "+counter+" "+time);
    }


    public static boolean check(double a, double b)
    {
        String strSum = Double.toString(a+b);
        int intRest = Integer.parseInt(strSum.substring(strSum.indexOf('.')+1,Math.min(strSum.indexOf('.')+3, strSum.length())));
        boolean result = intRest % 11 != 0 ? false : ((intRest / 11)+2) % 2 != 0;
        return result;
    }
}

(check2 ist aber auch "ohne Gewähr" - nur schnell hingeschrieben)

 

[happy_robot]

Bei check(0.1, 0.1) haut's ihn mit einer Exception raus.

Sorry...auf die Schnelle habe ich diesen Fehler nicht bedacht. Hast es ja bereits geändert.

Bei check(0.94 0.17) ergibt die Summe 1.1099999999999999, und er liefert ein falsches Ergebnis.

Probier doch mal:

System.out.println(0.94+0.17);

:shock:

Und von Geschwindigkeit (die ja laut Threadersteller relevant war) braucht man bei Double.toString, substring und mehrfachem indexOf :autsch: ja garnicht zu reden...

substring und indexOf lassen sich ohne probleme in sehr maschinennahen code übersetzen.

public static boolean check2(double x, double y)
{
int i = (int)(x * 100 + 0.5);
int j = (int)(y * 100 + 0.5);
int d = (i+j) % 100;
boolean result = (d % 11 == 0) && (((d / 11) % 2) == 1);
return result;
}

Finde ich sehr abenteuerlich
Bist Du Dir sicher daß Du tatsächlich die ersten 2 Nachkommastellen betrachtest?
Durch die Addition verschiebst Du Sie in den Vorkommabereich und berücksichtigst die Stellen davor aber im Modulo mit.

Wenn Du nur mal 1,33 nehmen würdest:

(1,33*100) % 11 != 33 % 11

Das scheint doch falsch zu sein....

mfg

 

[der JoJo]

ich weis garnicht was ihr immernoch auf der check methode rummreitet, das Problem wurde schohn im 2 post geklärt

 

[happy_robot]

ich weis garnicht was ihr immernoch auf der check methode rummreitet, das Problem wurde schohn im 2 post geklärt

ähhh....nein

 

[der JoJo]

ich weis garnicht was ihr immernoch auf der check methode rummreitet, das Problem wurde schohn im 2 post geklärt

ähhh....nein

wieso?

Hat geklappt vielen dank =)



Ich hätte dazu (zu der Aufgabe) noch eine frage und zwar soll ich ja wie oben schon gesagt alle Paare aus der Liste die eine dieser Nachkommastellen ergeben in eine Liste packen.
So jetzt soll ich die Werte zuerst kombinieren die am wenigsten Paarungsmöglich keiten mit anderen haben:
Also zuerst denn Paaren der nur eine Paarungsmöglichkeit hat mit dem Paaren der auch nur eine oder zwei,drei......

So das man am ende so viele Paarungsmöglichkeiten wie möglich hat. (Ich hoffe man vesteht ungefähr worauf ich hinaus will)

Hab mir gedacht das ich das vll in einem zweidimensionalen Array Speicher und immer einen hochzähle wenn eine Paarungsmöglichkeit besteh aber weiss noch nicht genau wie ich das hinkriegen soll.

Vielleicht habt ihr ja auch noch eine paar gute ideen wär super nett und sehr hilfreich.

Später sollen da um die 20.000 Werte durchrasseln (ich weiss die Laufzeit wird wahrscheinlich ein Problem aber darum kümmer ich mich später =) ).


Dankeschön schonmal im vorraus!

MFG

Herman

 

[happy_robot]

der zweite post lautete:

double d = 2.11;
d = Math.round((d - (int)d) * 100);
System.out.println(d == 11);

bei der berechnung von

(d - (int)d)

kommt es bereits zu einem rechenfehler. dieser wir hier mit 100 multipliziert (nicht nur das Ergebnis....auch der Fehler ) und dann gerundet um diesen Fehler vermeintlich wieder zu korrigieren.

dieser rundungsfehler bereitet mir gerade aber auch etwas kopfzerbrechen.

 

[der JoJo]

was für ein Fehler? gieb mal beispiel

#edit
meinst du
Bei check(0.94 0.17) ergibt die Summe 1.1099999999999999, und er liefert ein falsches Ergebnis.

das kann man mit einem einfach +0.005 beheben!

double a = 0.94
double b = 0.17;
double d = a+b+0.005; //1,1149999999999999 damit stimmts wieder
int nachkomma = Math.round((d - (int)d) * 100);
System.out.println(nachkomma == 11);

 

[Guest]

ja, genau das bereitet mir kopfzerbrechen.

die addition behebt den fehler ja nicht wirklich. er ist ja durchaus noch im ursprung existent. es ist mir auch klar daß es ab einer gewissen stelle rundungsfehler gibt, aber dieser taucht hier bereits nach der 2ten stelle auf.

 

[Marco13]

Probier doch mal:

System.out.println(0.94+0.17);

:shock:

So :shock:-ing ist das nicht, sondern ganz normal. Und man sollte versuchen, die üblichen Runddungsfehler, die bei IEEE754 auftreten, zu berücksichtigen.

substring und indexOf lassen sich ohne probleme in sehr maschinennahen code übersetzen.

Simmt.

while(true){}
läßt sich übrigens auch in sehr maschinennahen code übersetzen :wink:

...
Finde ich sehr abenteuerlich
...
Wenn Du nur mal 1,33 nehmen würdest:

(1,33*100) % 11 != 33 % 11

Nun, wenn als Summe 1.33 rauskommen soll, dann hat man z.B. Summanden 0.87 und 0.46. Und die Rechnung ergibt damit zum Beispiel sowas wie
int i = (int)(x * 100 + 0.5); // = (int)(87.0000000001 + 0.5) = 87 (Rundungsfehler werden beseitigt)
int j = (int)(y * 100 + 0.5); // = (int)(45.9999999999 + 0.5) = 46 (Rundungsfehler werden beseitigt)
int d = (i+j) % 100; // = 133 % 100 = 33

Und damit wird das richtige ergebnis geliefert. Um behaupten zu können, dass es IMMER das Richtige Ergebnis liefert, müßte ich nochmal drüber nachdenken... bis dahin kann ich nur sagen, dass ich mit ziemlich sicher bin, dass es immer das richtiger Ergebnis liefert. Und das in einem 30stel der Zeit deiner Methode. Und ob man 10 Sekunden auf das Ergebnis wartet oder 5 Minuten ist schon ein Unterschied - maschinennahe Übersetzung hin oder her. Aber im Notfall kann man das ja darauf schieben, das "Java ja interpretiert ist, und deswegen so schrecklich viel langsamer als C++" :bae: :wink:

 

[Guest]

ok ok...nich das wir uns hier in die haare kriegen

der rundungsfehler erscheint mir eklatant! die behebung dessen mit +0.5 finde ich übrigens auch sehr grosszügig.
dennoch behaupte ich daß meine variante immer das richtige ergebnis liefert insofern der rundungsfehler zu beginn nicht auftritt. und dieser fehler resultiert nicht aus dem algorithmus selber.

 

[happy_robot]

na doll...jetzt ist meine letztes posting als gast reingeflutscht .....


nichtdestotrotz:

5min auf das ergebnis zu warten ist allemal besser als 30s zu warten und dann 3 stunden drübergucken zu müssen ob's auch stimmt.

klarer zeitvorteil für meine variante

 

[der JoJo]

die behebung mittels 0.005 ist eine unter c++ Programmieren durchaus verbreitete maßname die deffinitiv immer zu dem richtigen ergebniss fürt. ich habe jetzt nur gerade keinen bock das Mathematisch zu beweisen

 

[@x.l]

Es handelt sich dabei um dieses Phänomen:

Unit last place

 

[Marco13]

Ja, und wenn ein Dreieck keine Ecken hat, dann besteht der Mond aus grünem Käse.

Tatsache ist, dass der Rundungsfehler bei deiner Lösung auftritt und NICHT berücksichtigt wird, und sie deswegen falsche Ergebnisse liefert. Bei meiner Variante tritt er wohl auch auf, aber wird berücksichtigt, was zumindest dazu führt, dass diese Lösung MEHR richtige Ausgaben liefert. (Und mit Aussagen wie "es wird IMMER die Richtige Lösung ausgegeben" bin ich vielleicht einfach nur vorsichtiger als viele andere :wink: )

Das +0.5 verwendet man eigentlich zum kaufmännischen Runden:
float x = 1.49;
int xx = (int)(x+0.5); // Wird zu 1
float y = 1.51;
int yy = (int)(y+0.5); // Wird zu 2
Aber in diesem Fall sollte es nur die Rundungsfehler ausgleichen, die (bei diesen Zahlen) wohl betragsmäßig nicht größer als 0.5 werden...


BTW: Es geht nicht um "in die Haare kriegen". Die Lösung, die du beschrieben hast, hat einige signifikante Nachteile (was bei Zahlen wie 1.23E-5 passiert, will ich garnicht wissen) Auch wenn Java so praktische Funktionen wie Double.toString und Integer.parseInt anbietet, sollte man sich schon SEHR genau überlegen, ob man die wirklich für solche Kleinigkeiten benutzen will, die sich häufig durch ein bißchen Modulo und ein casten auf int erledigen lassen. Schau' dir mal die Klasse "FloatingDecimal" an, die z.B. bei Double.toString die Umwandlung erledigt: Die ist extrem(!) aufwändig und kompliziert - das ist wirklich nichts, was man in low-level-Funktionen verwenden sollte.

EDIT: Das +0.5 gleicht Rundungsfehler in diesem Fall aus, würde aber evtl. zu unerwarteten Ergebnissen führen, wenn die Eingabezahlen merh als 2 Nachkommastellen haben - allerdings wurde an keiner Stelle gesagt, was dann passieren soll - und irgendwo ist zwangsläufig eine Grenze für die Rechengenauigkeit...

 

[happy_robot]

die behebung mittels 0.005 ist eine unter c++ Programmieren durchaus verbreitete maßname die deffinitiv immer zu dem richtigen ergebniss fürt. ich habe jetzt nur gerade keinen bock das Mathematisch zu beweisen

die behebung interessiert mich ja auch nicht. mich interessiert wie er in diesem zahlenbereich zustande kommt.
ich bin einfach nur überrascht das das schon bei der 2ten nachkommastelle schiefgeht. die korrektur dessen mag ja auch geläufig sein, dennoch ist es schlichtweg falsch!

wenn ich eine million schrauben verkaufen will und die schraube 0.94 € und die mutter 0.17 € kostet will ich bitte auch den richtigen preis dafür erhalten. die differenz aus richtigem und falschem ergebnis is' mir da nicht egal.

 

[Marco13]

EDIT Doppelpost - das ist mir ja noch nie passiert

 

[happy_robot]

@ @x.l:

Danke. Das hilft mir schon mal weiter.


@Marco13:

a) durch das erweitern des wertebereichs geht deine (jede) lösung irgendwann den bach runter. das ist also kein argument. jeder algorithmus beschreibt die gültigkeit nur in einen gewissen abgeschlossenen wertebereich.
b) Double.toString und Integer.parseInt habe ich selber als Laufzeit-Koloss beschrieben. is' lahm, aber trotzdem "richtiger".
c) das heisst also auch das "kaufmännisches runden" ein konformes mittel wäre um falsche ergebnisse jeglicher art in klausuren in den stand einer gültigen lösung zu erheben?

mfg

 

[Marco13]

die korrektur dessen mag ja auch geläufig sein, dennoch ist es schlichtweg falsch!

Ja, so sind Computer nunmal. Es gibt keine Möglichkeit, mit einem double eine Zahl wie 0.1 darzustellen. Da gibt es nichts darn zu rütteln. In deinem Beispiel würde man entweder BigDecimal verwenden, oder eine spzeielle Bibliothek, die für Finanzberechnungen gemacht ist, oder man würde in cent rechnen. Da hat man nur ganze Zahlen, und kein Problem mit Rundungsfehlern. (Nur evtl. mit Überläufen... wenn es wirklich SEHR viele Schrauben sind :wink: )

 

[Marco13]

Irgendwie sind unsere Beiträge nicht gut synchronisiert :wink:
a) Hatte ich im EDIT meines letzen Posts schon eingeräumt
b) Darüber könnte man streiten. Aber das will ich nicht.
c) Nein. Hat auch keiner gesagt. Nichtmal angedeutet.

 

[happy_robot]

prima. dann war's das von meiner seite und wir haben uns alle wieder lieb.

wollte einfach nur wissen wo das prob hier ist. @x.l. hat mir ja schon mal genug info gegeben um nachzuforschen.