Zufall


Processing 2.0

Auch in Processing gibt es Möglichkeiten Zufallszahlen zu erzeugen. Die einfachste Möglichkeit bietet hier die Funktion random(). Manchmal will man aber Zufallszahlen haben, die jeweils nur leicht voneinander abweichen, sowie in der Natur. Für diese Aufgabe gibt es die noise() – Funktion, die immer Zahlen zwischen 0 und 1 ausgibt. Durch den folgenden Parameter kann man nur die Größe der Abweichung von Zahl zu Zahl beeinflusst werden.

random(hoch, tief)

Beispiel: starte Applet
Von diesem Programm werden an zufälligen Positionen Ellipsen gezeichnet. Auch die Strichstärke ist variabel. Dadurch entstehen große und kleine Formen.

void setup()
{
size(300,300);
stroke(0,40);
}

void draw()
{
int x=int(random(300));
int y=int(random(300));
int z=int(random(10));
strokeWeight(z);
ellipse(x, y, 1,1);
}

randomSeed(Wert)

Mit randomSeed() und einem Integer als Wert kann man, wenn man will (und der Integer-Wert immer der gleiche ist) immer die gleiche Zufallszahlenreihe erzeugen.

Aufgabe: Schreibe ein Programm, das in etwa folgenden Output erzeugt.

noise(x,y,z)

Die noise– Funktion kann mit einem, zwei oder drei- Parametern aufrufen, je nachdem, ob man 1-,2- oder 3-dimensional arbeiten will. Erzeugt werden immer Zahlenwerte zwischen o und 1, die jeweils nur geringe Unterschiede zu den Zahlen davor aufweisen. Will man natürliche Vorgänge simulieren, ist diese Funtktion sehr sinnvoll.

Die Werte von x, y und z müssen, um unterschiedliche Zunoise– Funktionfallszahlen zu generieren bei jedem Durchlauf erhöht werden. Größe der Schritte definiert dann die Variabilität der Zahlenreihe. Für die meisten Anwendungen eignen sich Schritte von 0.005 bis o.1.

Beispiel: starte Applet

float v = 0.0;
float inc = 0.01;
float next= 0.01;

void setup()
{
size(300,300);
noStroke();
fill(50);
}

void draw()
{
translate(width/2, height/2);
float b = noise(v) * 5.0;
float n = next/1.0;
rect (next*cos(n)+b,next*sin(n)+b, 1, 1);
v=v+inc;
next = next+0.01;
}

Beispiel: starte Applet

float v = 0.0;
float inc = 0.01;
float next= 0.8;

void setup()
{
 background(255);
 smooth();
 size(300,300);
 noStroke();
 frameRate(120);
 colorMode(HSB);
}

void draw()
{
 translate(width/2, height/2);
 float b = noise(v) * 10.0;
 float n = next;
 fill(frameCount%180,255,255,50);
 ellipse (next*cos(n)+b,next*sin(n)+b, 5*b, 5*b);
 v=v+inc;
 next = next+0.1;
}

Gauss’sche Verteilung

Denken wir an die Größenverteilung bei Menschen. Ein durchschnittlicher männlicher Österreicher ist 1,78 m groß. Betrachten wir nun eine Menge von Menschen, dann ist klar, dass sehr wenige über 2 m groß, oder kleiner als 1,65  sind. Die meisten sind etwa so groß, wie der Durchschnitt. Das heißt: Je größer die Abweichung vom Mittel, desto weniger Menschen dieser Größe wird es geben. Eine entsprechende Kurve sieht dann so aus:

In Processing kann man solche Zahlenverteilungen mit der Random – Klasse erzeugen. Die Klasse kann folgendermaßen verwendet werden: Objekt erstellen:

Random gauss;

Dann Objekt initialisieren:
gauss = new Random();

Nun kann man mit der folgenden Codezeile die Zahlen erzeugen:

float num = (float) generator.nextGaussian();

 

Advertisements

2 Kommentare

  1. Pingback: Processing – Über dieses Weblog « processing – tutorial

  2. Pingback: Rotations II « processing – tutorial

Kommentar verfassen

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

WordPress.com-Logo

Du kommentierst mit Deinem WordPress.com-Konto. Abmelden / Ändern )

Twitter-Bild

Du kommentierst mit Deinem Twitter-Konto. Abmelden / Ändern )

Facebook-Foto

Du kommentierst mit Deinem Facebook-Konto. Abmelden / Ändern )

Google+ Foto

Du kommentierst mit Deinem Google+-Konto. Abmelden / Ändern )

Verbinde mit %s

%d Bloggern gefällt das: