[linux-l] [OT] Gewichtete Wahrscheinlichkeit, Random

[Olaf Radicke]

Am Sonntag, 18. Februar 2007 14:12 schrieb Oliver Bandel:
> On Sat, Feb 17, 2007 at 07:50:18PM +0100, Olaf Radicke wrote:

Ich beantworte die fragen, die auch in anderen Mails auftauchen - denke 
ich - am besten, in dem ich mein Code kommentiere...

die Zielstellung Semigraphisch dargestellt:

X 100% des maximalen Niederschlag(MN). Warschinlichkeitsfaktor(WF):1
.X 95% MN. WF 2
...X 90% MN. WF 4
.......X 85% MN. WF 8
...............X 80% MN. WF 16
...............................X 75% MN. WF 32
...............................................................X 
70% MN.WF 32 usw...


> > Wie auch immer. Der Algorithmus sieht jetzt so aus:
> >
> >         int[] regengewichtung = new int[2097151];
Mit Hilfe eines Versuchs habe ich festgestellt, das wenn ich 
Näherungswerte im 5% Abstand haben möchte, ich ein Array dieser Länge 
brauche. Bei meinen ersten Versuch hatte ich ein int (Int32) verwendet. 
Der war aber zu klein für den wert. Wenn ein Int32 "überfüllt" wird, 
fängt er bei 0 wieder an. Also angenommen ich hätte ein int mit dem 
maximalen wehrt 100 und ich versuche 101 zu speichern, "kippt er bei 
100 um" und fängt wieder bei Null (0) an. Also haben wir nicht 101 
gespeichert sondern 1. Das ist mir passiert, weil der Maximale Wert von 
Int32 für C# in meinem Buch falsch angegeben war.

> >         int faktor = 1;
Wie oft ein Wert (Niederschlagsmenge) in den Array vorkommen soll.

> >         ulong gesamt = 0;

Der  Countdown-Zähler, mit wir nicht über das Array-Ende 
hinausschreiben, aber jedesmal ein anderen Speicherplatz benutzen.
 
> >         for(int i = 100; i>=0; i=i-5)
> >         {
i ist der Countdown-Zähler der Prozent-Werte der Niederschläge. Wir 
beginnen mit 100% der maximalden Niderschlagsmenge. -5 weil wir in 
5%-Schritten vorgehen.

> >             for(int i2 = 0; i2<faktor; i2++)
> >             {
Da die Niderschlagsmengen unterschiedlich oft im Array vorkommen sollen, 
haben wir die Variable "Faktor", der bestimmt, wie oft die Schleife mit 
einer bestimmten Niderschlagsmengen-Wert in das Array geschrieben wird. 
Erster Durchgang z.B. ist für 100% Niederschläge, der ein mal in das 
array geschrieben wird...

> >                 regengewichtung[gesamt] = i;
Der wert wird im Array gespeichert.

> >                 gesamt = gesamt+1;
Nächstes Array-Element....


> >             }
> >             faktor = faktor*2;
Nach Ende des Schleifendurchlauf, Faktor mal zwei erhöhen.

> >         }
> >         int niederschlag = regengewichtung[r.Next(0,2097151)];
So, hier fehlte eine Zeile Code, mit klar ist, was hier passiert:
Random r = new Random(); r ist also eine Instanz einer Random-Klasse.

> >         Console.WriteLine("### niederschlag: " + niederschlag);

Ergebnis ist, das die Wahrscheinlichkeit das es nicht regnet 50% sind, 
25% das es mit 5% der maximalen Menge regnet. 12,5% das es mit 10% der 
maximalen Menge regnet. U.s.w.

Ich glaube es gibt die Möglichkeit, diese Problem mit geometrischen 
Formen zu lösen.

http://de.wikipedia.org/wiki/Kurve_(Mathematik)

Ansonsten hab ich dann noch das gefunden...

http://de.wikipedia.org/wiki/Inversionsmethode


Für meine Zwecke reicht es.

> ImPrinzipspricht ja nix gegen das Array, aber wie flexibel
> handhabst Du eine Größenänderung?

Die ist zugegebener Maßen schlecht.

> Was passiert in C# eigentlich, wenn man über die Arraygrenzen hinaus
> zugreift?

Ich glaube der Zustand ist wie bei C und C++ undefiniert. Im besten 
Fall, wirft die Runtime eine Laufzeit-Ausname. Im schlechtesten Fall, 
kann alles passieren. Deswegen die Erwähnung von ArrayList und warum 
ich sie trotzdem nicht nehme.

Gruß
Olaf