Schlagwort-Archive: Variablen

Variablen und Datentypen


Processing 2.0

Alle Daten im Computer werden irgendwann einmal in eine Folge 0er und 1er übersetzt. In Software sind Daten meist Buchstaben und Zahlen, aber auch Bilder, Musik und Video. In Processing kann man viele dieser verschiedenen Daten verarbeiten, aber nicht alle auf die gleiche Weise.

Datentypen

Sie legen fest, wie Daten in die Sprache des Computers (eine Reihe aus 0 und 1) übersetzt werden. Es gibt sog. primitive Datentypen, die in den meisten Programmiersprachen schon festgelegt sind. Darüber hinaus, kann man aber auch seine eigenen Datentypen erstellen.

Primitive Datentypen sind:

  • int – 32 bit – Ganzzahlen von ca. -2 Mrd. bis ca. +2Mrd.
  • float – 32 bit – Gleitkommazahl mit 8 Stellen Genauigkeit
  • boolean – 1 bit – true oder false
  • byte – 8 bit – -128 bis+127
  • char – 16 bit  – 0 bis 65535 für einzelne Zeichen
  • color – 32 bit – 1.6777.216 Farben

Im Gegensatz zu den primitiven gibt es auch nicht primitive Datentypen (z.b. String), die bei Bedarf auch selbst definiert werden können. Beim Typ String kann man schon an der Schreibweise (groß) erkennen, dass er sich von den primitiven Datentypen unterscheidet. Und zwar dadurch, dass er, wie auch in Java üblich ein Objekt ist, dessen Eigenschaften durch eine Klasse definiert werden (zur genaueren Erklärung suche nach Objekte und Klassen). Schauen wir uns nun den Unterschied zwischen char und String genauer an. Während eine Variable vom Typ char ein Zeichen enthalten kann, ist kann ein String eine beliebige Anzahl an Zeichen (eine Zeichenkette) beinhalten. Ein weiterer Unterschied besteht in der Zuweisung der Werte.

char zeichen = ‚a‘; // deklariert die Variable zeichen und weist ihr den Wert a zu
char zeichen = „a“; // Error! ist nicht zulässig

String kette = „hallo welt!“; //Erzeugt ein Objekt vom Typ String mit dem Namen kette und weist diesem Objekt den Wert „hallo welt“ zu.

Variablen

Variablen sind Platzhalter im Speicher und können mit entsprechenden Werten beschrieben werden. Bevor ein Wert in einer Variablen gespeichert werden kann, muss diese „deklariert“ werden. Dabei wird ein entsprechender Datentyp für die Variable definiert. Bsp:

  • int x; // deklariert die Variable x
  • x=12; //weist der Variablen x den Wert 12 zu
  • float z; //deklariert die Variable z
  • z=3,14 //weist der Variablen z den Wert 3,14 zu
  • boolean wahr;//deklariert die Variable wahr
  • wahr=true;//weist der Variablen wahr den Wert true zu

Man kann das Ganze etwas abkürzen und Deklaration und Wertzuweisung in einem Schritt durchführen.

  • int x=12;
  • float z=3,14;

Eine Variable darf nur einmal deklariert werden, kann dann aber nacheinander verschiedenste Werte enthalten.

Variablenname dürfen frei gewählt werden, allerdings keine reservierten Ausdrücke sein (int, null, true, false usw.).

Processing hat einige vordefinierte Variablen, nämlich in  size(): width and height. Wenn diese nicht anders definiert werden, haben sie den Wert 100. Deshalb ist das Anwendungsfenster in einem Programm ohne size(x,y) – Anweisung 100*100 px groß.

 println(width + ", " + height);
//gibt 100, 100 im Terminalfenster aus

Wenn man ein Programm für verschiedene Auflösungen schreiben will, ist es gut die Variablen width und height zu verwenden, da man dann allein mit der size() – Funktion die ganze Anwendung skalieren kann.

Beispiel:

size(300,300);
rect(width/10,height/10,width/2,height/2);
rect(width/4,height/4,width/2,height/2);
ellipse(width/2,height/2,width/4, height/4);

Aufgabe: Schreibe ein Programm, das einige Variablen von den Typen char und String erzeugt und gibt diese mit der Funktion println im Konsolenfenster aus.

Mathematische Operationen


Processing 2.0

Da alles was in einer Anwendung gezeigt wird auf Nummern basiert, ist es unerlässlich, dass wir uns zumindest kurz ausschließlich mit diesen beschäftigen.

Beispiel: starte Applet

size(250,250);
int grau=50;
fill(grau);
rect(20,20,100,100);
grau=grau+50;
fill(grau);
rect(40,40,100,100);
grau=grau+50;
fill(grau);
rect(60,60,100,100);
grau=grau+50;
fill(grau);
rect(80,80,100,100);
grau=grau+50;
fill(grau);
rect(100,100,100,100);

Hier wird mit Hilfe einer Variable der Grau-Wert der Quadrate definiert.

Beispiel: starte Applet

size(300,300);
int x=2; //x ist jetzt 2
line(x,0, x,height);
x=x*2;//x ist jetzt 4
line(x,0, x,height);
x=x*2;//x ist jetzt 8
line(x,0, x,height);
x=x*2;//x ist jetzt 16
line(x,0, x,height);
x=x*2;//x ist jetzt 32
line(x,0, x,height);
x=x*2;//x ist jetzt 64
line(x,0, x,height);
x=x*2;//x ist jetzt 128
line(x,0, x,height);
x=x*2;//x ist jetzt 256
line(x,0, x,height);

Hier werden Parameter der Funktion line() durch die Variable x kontrolliert.

Übung: Verändere das Programm Variablen so, dass es horizontale statt  vertikale Linien zeichnet und lass die Linien immer um 2 Pixel dicker werden.

Modulo

In einem Programm kann man also ganz leicht alle Grundrechnungsarten anwenden. Oft ist es aber auch nötig den Rest einer Berechnung mit Ganzzahlen zu ermitteln. Dafür gibt es einen eigenen Operator. Dieser wird Modulo genannt und mit einem % geschrieben.

10 % 3 = 1
6 % 2 = 0
29 % 9 = 2

Natürlich können solche Berechnungen nur mit Zahlen des Datentyps int durchgefürht werden.

Datentypen können nicht beliebig kombiniert werden. Ein Ausdruck in der Form int x=4.0/3 liefert eine Fehlermeldung. float x=4.0/3 würde hingegen 1,3333334 ergeben. Die gleichen Ergebnisse kommen auch zustande, wenn die Zahlen durch Variablen mit den gleichen Werten ersetzt werden. Man muss also eigentlich immer genau wissen, welche Werte eine Variable annehmen kann.

Punktrechnung vor Strichrechnung

… gilt auch in Processing. Zudem kann man, wie auch in der Mathematik, Klammern setzen.

In der Kürze liegt die Würze

x++ steht für x=x+1;
y– für y=y-1;
x+=5 für x=x+5;
y-=5 für y=y-5;

usw.

Mathematische Funktionen

ceil();

Berechnet die nächste Ganzzahl aus einer Gleitkommazahl und rundet dabei immer auf.

floor();

Berechnet die nächste Ganzzahl aus einer Gleitkommazahl und rundet dabei immer ab.

round();

Berechnet eine Ganzzahl aus einer Gleitkommazahl. Dabei wird gerundet.

min(); und max();

Geben von beliebig vielen Zahlen als Parameter jeweils die größte oder die kleinste zurück.

Werte Normalisieren und Mappen

norm(Wert, niedrig, hoch);

Beim Normalisieren geht es darum Wertbereiche ineinander Umzuwandeln, bsp. einen Farbwinkel(0-360°) in einen Bereich zwischen 0 und 1. Die entsprechende Anweisung  würde dann lauten: norm(Winkelx, 0, 360);

Der Vorteil des Zahlenbereichs zwischen 0 und 1 besteht darin, dass man die Zahlen beliebig multiplizieren und dividieren kann, ohne je den Bereich zu verlassen.

lerp(niedrig, hoch, norm.Wert);

Die lerp()-Funktion ist die Umkehrfunktion von norm(). Man gibt einen Bereich an und dann einen bereits normalisierten Wert (zwischen 0 und 1). Die Funktion gibt dann den, dem Bereich entsprechenden Wert zurück.

map(Wert, niedrig1, hoch1, niedrig2, hoch2);

Mit der Funtion map() kann man zwei beliebige Zahlenbereiche direkt ineinander umwandeln.