TI-Coding mit der TI-Nspire™ Technologie

In der ersten Übung dieser Lektion wirst du den TI-Nspire™ CX Basic Programmeditor kennen lernen und damit dein erstes Programm schreiben, speichern und laufen lassen.

Lernziele:

• Öffnen des Programmeditors aus der Calculator App
• Codieren des ersten Programms
  Speichern und Starten eines Programms

Öffnen des Programmeditors

Erstelle ein Neues Dokument und füge eine Calculator Applikation hinzu.

Beginne ein neues Programm in der Calculator Applikation über:

    menu> Funktionen und Programme> Programmeditor> Neu…

Schreibe ins Feld Name: den Namen deines ersten Programms, hello, und schließe mit [enter].

Für die Felder Typ und Bibliothekszugriff lassen wir vorerst Programm und Keine unverändert. Dies werden wir in späteren Lektionen behandeln.

Dein Schirm sollte nun aussehen, wie rechts abgebildet. Im linken Fenster findet sich die Calculator App und im rechten der Programmeditor. Im Editor wirst du dein Programm verfassen und im Calculator wirst du es dann ausführen. So kann man bequem das Programm bereits während seiner Entwicklung testen.

Auf dem Handheld kannst du mit [ctrl] [tab] zwischen den Fenstern wechseln. Eine Applikation (ein Fenster) ist dann aktiv, wenn sie einen schwarzen Rand aufweist.

Dein Programmcode wird innerhalb des Prgm … EndPrgm Blocks im Editor stehen. Die Schreibmarke sollte innerhalb des punktierten Rechtecks blinken. Wähle nun menu> E/A> Disp.

Gib die Vorlage für die doppelten Anführungszeichen [ " " ] (mit [ctrl] und der [x]-Taste) ein und schreibe den Text hello, world! zwischen An- und Ausführungszeichen.

Bevor jedes geschriebene Programm durchgeführt werden kann, muss es im Speicher des Rechners abgespeichert werden. Wähle dazu menu> Syntax überprüfen & speichern> Syntax überprüfen & speichern (oder verwende die Tastenkombination [ctrl] [B] am Handheld).

Zur Durchführung des Programms wechsle zuerst zur Calculator App, gib in der Eingabezeile den Namen des Programms gefolgt von einer linken Klammer ein und schließe die Eingabe ab mit [enter]. Wenn alles bisher richtig war, dann sollte der Text ‘hello, world!’ als Ergebnis der Programmausführung erscheinen.

Speichere das Dokument unter dem Namen hello world.

Herzlichen Glückwunsch! Du hast dein erstes TI-Nspire™ CX Basic Programm verfasst!

In der zweiten Übung von Lektion 1 lernst du die Übergabe von Argumenten an ein Programm und die Ausgabe von Ergebnissen der Berechnung von Termen.

Lernziele:

• Argumente in einem Programm verwenden
• Ausdrücke in Disp-Anweisungen verwenden

Warum benötigt ein Programm Klammern?

Die Klammern nach dem Programmnamen sind immer erforderlich und dienen zur Eingabe von Argumenten. Wir kennen zwei Arten von Argumenten: „formale” Argumente, die immer Variable sind und „aktuelle” Argumente, die Werte, Variable oder Terme, die Ergebnisse erzeugen, sind.

Wir erstellen nun ein Programm zur Berechnung der Hypotenuse eines rechtwinkligen Dreiecks.

Beginne mit dem Einfügen einer Calculator App auf eine neue Seite und starte mit einem neuen Programm:

          menu> Funktionen und Programme> Programmeditor> Neu…

Gib dem Programm dem Namen hypotenuse und schließe mit  [ENTER]

 

Schreibe zwischen die Klammern nach dem Programmnamen die beiden formalen Argumente a,b und führe dann die Schreibmarke in das punktierte Rechteck.

Gib dem Programm dem Namen hypotenuse und schließe mit  [ENTER]

 

Schreibe zwischen die Klammern nach dem Programmnamen die beiden formalen Argumente a,b und führe dann die Schreibmarke in das punktierte Rechteck.

Programmausführung

Wechsle ins Calculator-Fenster und schreibe den Programmnamen gefolgt von einer linken Klammer. Gib dann die Werte für die beiden Katheten, durch ein Komma getrennt, zwischen die Klammern ein und schließe mit [ENTER]. Verwende vorerst Werte für a und b für die du das Ergebnis kennst, um das Programm auf Richtigkeit zu testen!

Du kannst auch Terme anstelle von Zahlen eingeben, wie zum Beispiel:

                                hypotenuse(2*7, 9-5)

Speichere das Dokument, um damit auch das Programm zu speichern.

In diesem dritten Teil der Lektion 1 wirst du den grundsätzlichen Unterschied zwischen einem Programm und einer Funktion kennen lernen.

Lernziele:

• Erstellung eines Programms und einer Funktion, die beide die gleiche Aufgabe erfüllen
• Die Unterschiede zwischen einem Programm und einer Funktion erklären

Was ist eine Funktion?

Im TI-Nspire™ CX hat eine Funktion den Zweck, einen Wert AUSZUGEBEN. In der rechten Abbildung sieht man das Programm hypotenuse und die Funktion hypot, die die gleiche Aufgabe erfüllen. Beachte sowohl den Gebrauch von Return in der Funktion als auch, dass das Ergebnis der Funktion im Calculator in einer Zeile mit dem Funktionsaufruf erscheint. Die Funktion repräsentiert einen Wert, der in anderen Operationen, auch zur graphischen Darstellung, verwendet werden kann.

Erzeugung einer Funktion

Wähle im Calculator

           menu> Funktionen und Programme> Programmeditor> Neu…

Schreibe den Namen hypot und ändere den Typ von Programm auf Funktion. Schließe die Eingabe mit [ENTER], um die Funktion zu definieren.

Füge die Argumente a,b zwischen den Klammern ein. Füge dann innerhalb der Funktion den Return-Befehl über menu> Übertragungen> Return ein und ergänze den Befehl mit der Quadratwurzel von a2+b2.

‘Überprüfe die Syntax und speichere’ die Funktion über menu> Syntax überprüfen & speichern> Syntax überprüfen & speichern (oder verwende [CTRL] B auf dem Handheld).

Teste die Funktion im Calculator an einem Beispiel, wie etwa mit hypot(3,4).

Funktionen sind ähnlich wie Programme, aber nicht dasselbe. Sie können viele Befehle enthalten und so wie andere Programme im Editor aussehen. Aber sie unterscheiden sich von Programmen, da sie einen Funktionswert ausgeben. Dieser Wert kann eine Zahl, eine Liste, eine Zeichenkette, eine Matrix oder ein anderer verfügbarer Datentyp sein. Während Programme nur beschränkt einsetzbar sind, sind Funktionen vielseitiger. Programme können nur im Calculator oder in einer Math Box in den Notes ausgeführt werden. Funktionen lassen sich überall dort einsetzen, wo auch implementierte Funktionen verwendet werden können.

Auf einem TI-Nspire™ CX CAS gibt eine Funktion einen algebraischen Ausdruck aus, wenn nicht definierte Variable als Argumente eingesetzt werden.

Zeichnen der hypot(x,b)-Funktion

Definierte Funktionen haben den Vorteil, dass sie wie jede andere bereits implementierte Funktion verfügbar sind. Nachdem die Funktion hypot(a,b) definiert wurde, füge eine Graphs Applikation hinzu, schreibe f1(x)=hypot(x,3) in die Graph-Eingabezeile und schließe mit [ENTER].

In dieser Anwendung zur Lektion 1 wirst du die Vielseitigkeit der Disp-Anweisung entdecken und dein eigenes Programm entwickeln. Die Übungen zu Lektion 1 sollten schon durchgearbeitet worden sein.

Lernziele:

• Disp-Anweisungen mit Zeichengruppen erweitern, um klare Informationen zu erzeugen
• Ein eigenes Programm für eine Formel schreiben

Die Disp-Anweisung kann mehr als ein Objekt auf einmal darstellen.

Studiere den rechten Screenshot mit dem modifizierten Programm zur Berechnung der Hypotenuse von vorhin. Die Programmausgabe wiederholt die Argumente a und b mit geeigneten Bezeichnungen und gibt auch die Hypotenuse mit einer passenden Bezeichnung aus.

Die Objekte unter Anführungszeichen bezeichnen wir als “Zeichengruppen”. Eine Zeichenkette (string) ist eine Gruppe von zusammenhängenden Zeichen.

Wenn du ein Programm schreibst, denke immer daran, die Syntax zu prüfen und das Programm zu speichern, indem du menu> Syntax überprüfen & speichern > Syntax überprüfen & speichern (oder verwende [CTRL] B) bevor du das Programm ausführst.

Trenne die darzustellenden Objekte mit einem Komma. Hier sollte ein Komma zwischen dem Text (unter Anführungszeichen), den Werten a, b und dem Term stehen.

Schreibe ein Programm mit einem oder mehreren Argumenten.Gib das Ergebnis der Rechnung, das sich aus den Argumenten ergibt aus.

        Die Berechnung kann eine beliebige Formel sein.

Hier findest du ein paar Vorschläge: Das Programm soll eine Ausgabe mit klaren Bezeichnungen erzeugen.

Fläche einer ebenen Figur Quadrat: Seite² Dreieck: ½*b*h Kreis: pi*r² Trapez: ½*(b1+b2)*h

Volumen eines Körpers: Würfel: Kante³ Quadr. Pyramide: 1/3*Basiskante²*Höhe Kugel: 4/3*pi*r³ Einfache Verzinsung: A=P+P*R*T Zinseszinsen: A=P*(1+r/n)n*t

In der ersten Übung von Lektion 2 wirst du Variable in einem Programm verwenden und deren Bedeutung für das ganze Dokument entdecken.

Lernziele:

• Eine Variable in einem Programm verwenden
• Die Auswirkung der Schaffung einer Variablen im Programm auf das restliche Dokument kennen lernen
• Die Möglichkeiten von Variablen in einem Programm entdecken

Speichern eines Werts in einer Variablen

Du wirst öfters in einem Programm einen Wert einer Variablen zuordnen müssen. In unserem Beispiel werden wir die Fläche eines Dreiecks aus seinen Seitenlängen mithilfe der Heronschen Flächenformel berechnen. Das tun wir in zwei Schritten:

Zuerst berechnen wir den halben Umfang: s=1/2(a+b+c)

Und dann weiters die Fläche:fl=√(s*(s-a)*(s-b)*(s-c))

Der Screenshot zeigt das Programm. Beachte, wie das := Symbol verwendet wird, um eine Variable mit dem Ergebnis einer Berechnung zu belegen. Das ist nicht bloß ein =-Zeichen.

:= bedeutet „ergibt sich aus“ oder einfacher „wird zu“. So bedeutet der Befehl

         s:=1/2*(a+b+c) „s wird zum halben Umfang des Dreiecks”.

Auf dem TI-Nspire™ findet sich das Symbol := über der „Vorlagen“-Taste [/t].[].

Auf einem Computer und dem Handheld kann man auch die beiden Zeichen := getrennt eingeben. Der Doppelpunkt ist auf dem Handheld über die ‘Interpunktion" º rechts vom G erreichbar und das =-Zeichen liegt genau unter der [CTRL]-Taste. Am Handheld ist es einfacher über [].

Verwendung des Speichern-Operators

Anstelle der Zuweisung := kannst du auch mit dem Speichern-Operator [STO →] arbeiten. Betrachte den Programmcode rechts. Beachte dabei die umgekehrte Reihenfolge der Befehle, da hier der Speichern-Operator ([CTRL] [VAR]) mit der Variablen auf die Berechnung folgt. In dieser Abfolge werden die Befehle ausgeführt (von links nach rechts).

Sowohl der := -Operator als auch der [STO →] -Operator können für jede Zuweisung verwendet werden. Es ist aber auf die richtige Reihenfolge der Befehle zu achten. Beide Operationen werden als Zuweisungen bezeichnet.

Jetzt wollen wir das vollständige Programm heron(a,b,c) eingeben, wie im rechten Screenshot gezeigt.

Nach Eingabe des Codes überprüfen und speichern wir wieder über menu> Syntax überprüfen und speichern> Syntax überprüfen & speichern (oder mit [CTRL]  B).

Teste das Programm mit den Werten 3, 4, 5 um das Ergebnis 6 zu erhalten.
(Warum ist das 6?)

Wähle nun im Calculator die [VAR]-Taste, da kannst du die aktuelle Variablenliste ablesen. Die Variablen heron, s und fl sind aufgelistet. heron ist der Programmname, s und fl wurden im Programm erzeugt. a, b und c wurden doch auch im Programm verwendet. Wo sind diese?

Die Antwort ist, dass a, b und c als Argumente nur innerhalb des Programms existieren und nicht als Variable erzeugt wurden. Eigentlich wollen wir aber weder s noch fl als Variable im Dokument belassen. Wie wir diesen Nebeneffekt vermeiden können, erfahren wir in der nächsten Übung.

Denke daran, das Dokument mit dem Programm zu speichern. Es wird in der nächsten Übung gebraucht.

In der zweiten Übung in Lektion 2 wirst du lernen, wie man in einem Programm Variable als lokale Variable festlegt.

Lernziele:

• Den Nutzen von lokalen Variablen erkennen
• Lokale Variable in Programmen einsetzen

Beginne indem du das Dokument öffnest, das das Programm heron enthält, das du in Übung 1 geschrieben hast (siehe Abbildung rechts).

Erinnere dich, dass dieses Programm die Variablen s und fl - unbeabsichtigt - so erzeugt hat, dass sie für das aktuelle Problem im ganzen Dokument Gültigkeit hat. Das ist so nicht erwünscht, und du wirst lernen, wie du das vermeiden kannst.

Füge unter dem Prgm-Schlüsselwort die Anweisung

                          Local s, fl ein, die über menu> Variable definieren zu finden ist.

Nachdem das geschehen ist, überprüfe und speichere das Programm wie bereits gewohnt über menu> Syntax überprüfen und speichern> Syntax überprüfen und speichern (oder mit [CTRL] B).

Die Variablen s und fl löscht du nun im Calculator mit DelVar s, fl.

(Variable löschen findet sich in menu> Aktionen >Variable löschen.)

Führe das Programm heron aus.

Drücke wieder die [VAR]-Taste und du wirst feststellen können, dass nur mehr das Programm heron in der Variablenliste aufscheint.

Was ist geschehen?

Wenn man eine Variable als ‘Local’ deklariert, sagt man dem TI-Nspire™ CX, dass diese Variable während der Ausführung des Programms erzeugt und nach seiner Beendigung wieder gelöscht wird. Damit gibt es sie im aktuellen Problem nicht. Das löst auch das Problem, wenn die Variable s oder fl im Problem erzeugt wird und dort im Speicher verbleibt. Wenn dann z.B. s im Programm als lokale Variable eingeführt wird, berührt das die ‘Problemvariable’ s nicht, da das Programm seine eigene (temporäre) Variable erzeugt.

Zusammenfassung

Die ‘Gültigkeit’ einer Variablen ist der Bereich, in dem sie existiert. Im TI-Nspire™ CX gelten die Variablen im jeweils aktuellen tns-Problem. Wenn man im Dokument ein neues Problem öffnet, erhält man wieder eine leere Variablenliste. So weiß Problem 2 nichts über die Variablen von Problem 1 und umgekehrt.

Wenn Programme im selben Problem die gleichen Variablen verwenden kann es unbeabsichtigt oder auch beabsichtigt zur Erzeugung oder zum Gebrauch der Variablen in diesem Problem kommen. Bisweilen ist es sinnvoll, Programmvariable und Problemvariable zu verbinden. Darauf ist beim Programmentwurf zu achten.

Variable als Local zu definieren vermeidet die Erzeugung und Beeinflussung von Problemvariablen.

Für Funktionen gelten andere Regeln im Umgang mit lokalen Variablen. Das werden wir in der nächsten Übung sehen. Bleib dran!

In der dritten Übung von Lektion 2 wirst du etwas über die Auswirkung einer Funktion auf globale Variable lernen.

Lernziele:

• Die Auswirkung von Funktionen und Programmen auf globale Variable vergleichen
• Programmcode von Programm zu Programm oder innerhalb eines Programms kopieren und einfügen

Wir beginnen diese Sitzung indem wir das Dokument mit dem Programm heron wie rechts gezeigt wird, öffnen.

Füge eine weitere Calculator App in das Dokument ein und erzeuge ein neues Programm.

Ändere den Typ auf Funktion. Benenne die Funktion heronf.

Schreibe die Argumente a, b, c zwischen die Klammern und kopiere die beiden Anweisungen vom Programm in die Funktion.

Zum Kopieren und Einfügen (Copy & Paste) auf dem Handheld:

• Halte die [SHIFT]-Taste gedrückt und führe den Cursor über den zu kopierenden Text.
• Mit [CTRL] C kopierst du den Text in die Zwischenablage.
• Wechsle zur Funktion und setze die Schreibmarke an die gewünschte Position.
• Füge mit [CTRL] V den Text wieder ein.

Überprüfe und speichere die Funktion mit menu> Syntax überprüfen und speichern> Syntax überprüfen & speichern (oder mit [CTRL] B).

Wechsle zum Calculator und führe das Programm aus.

Siehst du die Fehlermeldung?

Was ist hier falsch gelaufen?

Die Variablen s und fl wurden nicht als Local deklariert.
The variable s is a global variable since it is not declared Local. Das ist in einem Programm erlaubt, in einer Funktion aber nicht. Erinnere dich daran, das seine Funktion einen Wert ausgeben soll. Um globale Variable von unbeabsichtigten Veränderungen (‘Nebenwirkungen’) zu schützen, verhindert das Betriebssystem, dass Funktionen globale Variable ändern können.

Was ist zu tun? Füge die Anweisung Local s, fl an der Spitze der Funktion ein, wähle menu> Syntax überprüfen und speichern> Syntax überprüfen & speichern (oder [CTRL]  B) um die Funktion zu speichern. Dann versuche die Funktion nochmals. Voila!

In dieser Anwendung in Lektion 2 wirst du ein Programm mit einigen einfachen Zuweisungen und arithmetischen Operationen schreiben, um ein „Rätsel“ zu codieren. Du solltest Übung 2 aus dieser Lektion durchgearbeitet haben.

Lernziele:

• Ein Programm mit gegebenen Befehlen schreiben
• Zuweisungen verwenden
• Das Rätsel im Programm lösen

Das Programm rätsel

Schreibe ein Programm mit den beiden Argumenten a und b. Dann:

• Addiere a zu b und speichere das Ergebnis in b
• Subtrahiere a von b und speichere das Ergebnis in a
• Subtrahiere a von b und speichere das Ergebnis in b
• Gib a und b aus

Speichere und teste dein Programm. Was bewirkt es? Funktioniert das Programm mit jedem beliebigen Zahlenpaar?

Nach dem ersten Anschein sieht es aus, als ob der jeweils gleiche Wert (das Ergebnis der Subtraktionen) in a and b gespeichert werden. Aber, ist das wirklich so?

In der ersten Übung von Lektion 3 wirst du die Eingabe in ein laufendes Programm mit Request lernen. Dazu einiges über Zeichenketten (Strings), sowie die einfachste Form einer If-Abfrage (Bedingung).

Lernziele:

• Eingabe mit Request und RequestStr
• Stringvariable und deren Verkettung untersuchen
• If-Anweisungen mit Bedingung einsetzen

Übersicht über Eingabemöglichkeiten

Bis jetzt konnten wir einem Programm oder einer Funktion zu verarbeitende Daten nur als Argumente übergeben. Im TI-Nspire™ CX gibt es zwei ähnliche Anweisungen, die es erlauben, einem Programm während seiner Ausführung Werte einzugeben. Man kann sie als ‚Eingabe-Anweisungen‘ bezeichnen:

1. Request “Eingabeaufforderung”, Variable (für numerische Werte) und
2. RequestStr “Eingabeaufforderung”, Variable (für Zeichenketten)

Diese Anweisungen findet man im E/A-Menu des Programmeditors.

Arten der Eingabe von Variablen

• Eine numerische Variable kann eine reelle oder komplexe Zahl, eine Liste oder auch eine Matrix enthalten. Sie kann in algebraischen Ausdrücken und zu deren Berechnung verwendet werden.
• Eine Zeichenkettenvariable kann jede Art von Text bestehend aus Buchstaben, Ziffern und den meisten Interpunktionszeichen enthalten. Sie kann nicht in algebraischen Ausdrücken verwendet werden, obwohl Zahlen in einer Zeichenkette erlaubt sind.
• In der “Eingabeaufforderung” wird beschrieben, was man vom Benutzer als Eingabe erwartet.
• Die Variable kann ein beliebiger Buchstabe oder rein nicht reserviertes Wort sein. Reservierte Wörter erkennt man daran, dass sich der Zeichensatz beim Eingeben von kursiv auf normal ändert.

Verkettung von Zeichenketten

Zwei Zeichenketten (Variable oder Buchstabengruppen oder eine Kombination von beiden) kann mit dem &-Operator zu einem langen String verbunden werden. Das ‚&‘ findet sich am Handheld in der Sonderzeichenpalette -.

 

         Beispiel:

                      vname:=”Johann”

                      nname:=”Schmied”

                      vnname:=vname & ” “ & nname

         Damit enthält die Variable vnname die Zeichenkette “Johann Schmied”.

Das rechts dargestellte Programm hat keine Argumente, aber zwei (lokale) Variable name und alter. Es gibt keinen Unterschied zwischen numerischen und Stringvariablen.

Die zweite Request-Anweisung (für das Alter) verkettet den Namen aus der ersten Anweisung mit dem string “ ’s Alter”.

Beachte: Der Programmname kann_wählen enthält einen Unterstrich. Dieses Zeichen findet sich über die Interpunktionstaste rechts vom G.

Bedingungen

Eine Bedingung ist ein Ausdruck, der den Wert true (=wahr) oder false (=falsch) annehmen kann. Bedingungen nutzen die Relationszeichen, die über ( [CTRL] =) eingefügt werden können. Das Gleichheitszeichen fehlt hier, da es über eine eigene Taste angesprochen wird.

Bedingungen können auch die logischen Operatoren and, or, not und xor verwenden, die nur im Katalog zu finden sind. Außerdem stellt der TI-Nspire noch nand, nor, implies, if and only if, und die isPrime( )-Funktion zur Verfügung.

Beispiele für Bedingungen:

• x > 0 and y > 0 (ergibt true wenn x größer ist als 0 and y ebenfalls größer ist als 0 ist. Beachte die Leerstellen vor und nach dem ‘ and ‘.)
• stunden > 40
• zeit ≤ 0
• alter ≥ 18
• c2 = a2 + b2

isPrime(n)

Die einfachste (=‘primitive’)-If Anweisung

Die einfachste Form aller If-Anweisungen ist:

                          If Bedingung

                              Anweisung, wenn Bedingung erfüllt

Im Programm kann_wählen() ist ein Beispiel für diese Anweisung zu finden. Wenn der Wert für die Variable alter mindestens 18 ist, dann wird die darunter stehende Disp-Anweisung ausgeführt, anderenfalls wird sie übersprungen. Diese Form der If-Anweisung setzt man für einfache Operationen ein, die keine alternativen Aktionen erfordern.

Einrücken des Programmcodes

Beachte, dass die Disp-Anweisung eingerückt steht. Dieses Einrücken ist am TI-Nspire™ CX möglich und macht den Code besser lesbar. Der Computer berücksichtigt dies nicht, aber die Disp-Anweisung muss in der unmittelbar nächsten Zeile nach der If-Anweisung stehen.

Die Programmdurchführung

• Nach „Überprüfung der Syntax und Speichern” des Programms wechsle in die Calculator App und starte das Programm. Die Klammern nach dem Programmnamen müssen eingegeben werden, obwohl es hier keine Argumente gibt.
• Die erste RequestStr-Anweisung öffnet eine Dialogbox. Gib einen Namen ein und schließe mit [ENTER].
• Die zweite Request-Anweisung zeigt eine Eingabeaufforderung mit dem vorher eingegebenen Namen und verlangt dessen Alter (eine Zahl). Gib die Zahl mit [ENTER] ein.

• Die Programmausgabe erscheint im Calculator. Wenn das Alter der Person mindestens 18 Jahre ist, dann erscheint der Text ‘…., du darfst wählen!’, anderenfalls wird nichts angezeigt.

In der zweiten Lerneinheit von Lektion 3 wirst du die If…Then…EndIf-Anweisung kennenlernen.

Lernziele:

• Untersuchung der If…Then…EndIf-Struktur
• Erzeugung von zusammengesetzten Bedingungen mit Relationen und logischen Operatoren
• Ein Programm unter Verwendung des If…Then…EndIf-Konstrukts schreiben, das Punkte der Ebene ihren Quadranten zuweist

Wie du dem rechten Screenshot entnehmen kannst, stellt der TI-NspireTM CX vier verschiedene Vorlagen für If-Anweisungen bereit. Man verwendet diese für weitere Verarbeitung unter Bedingungen. Das nennt man auch ‚Programmverzweigungen‘, da der Computer ab hier verschiedene Wege durch den Code nehmen kann.

Es ist ratsam, diese Konstruktionen aus dem Menu zu beziehen, da alle wichtigen Teile in den Programmcode an den richtigen Stellen eingefügt werden. Man hat dann im Programm nur mehr die leeren Stellen zu füllen.

Das Bild rechts zeigt den Code unmittelbar nach Wahl von 2: If…Then…Endif aus dem Menu Steuerung. Im nächsten Schritt ist die Bedingung (zwischen If und Then) und die gewünschte Aktion (zwischen If und EndIf) einzusetzen.

Wir wollen ein Programm schreiben, das den Benützer Werte für die Variablen x und y eingeben lässt. Das Programm gibt aus, in welchem Quadrant der Punkt (x,y) liegt und beschreibt zusätzlich die Vorzeichen der Koordinaten in diesem Quadrant.

Der erste (unvollständige) Teil des Programms ist rechts gezeigt. Oberhalb der If-Anweisung wirst du zwei Request-Anweisungen benötigen (eine für x und eine für y). Dann kannst du die If…EndIf-Konstruktion kopieren, dreimal einfügen und für die restlichen drei Quadranten entsprechend editieren.

Vergiss nicht, das reservierte Wort ‘and’ vom übrigen Text mit einem Leerzeichen zu trennen.

Kopiere den Code, den du nochmals verwenden willst, füge ihn ein und passe ihn an die jeweilige Bedingung an. Teste dein Programm mit verschiedenen Werten für x und y. (Gibt es auch Koordinaten, die nicht das gewünschte Ergebnis bringen? Wie könntest du diese Fälle behandeln?)

Markieren, Kopieren und Einfügen auf dem TI-Nspire™ CX

Markiere den Text, indem du bei gedrückter [↑ SHIFT]-Taste den Cursor über den Text bewegst. Mit [CTRL] C (kopieren) und [CTRL] V (einfügen) kopierst und fügst du den Text an geeigneter Stelle wieder ein.

Denke immer daran, deine Datei auch zu speichern, so dass das Programm gespeichert ist. Das Listing für das komplette Programm findest du hier:
Define if_then()= Prgm Request "x =",x Request "y=",y If x>0 and y>0 Then       Disp "Erster Quadrant"       Disp "x ist positiv"       Disp "y ist positiv" EndIf If x<0 and y>0 Then       Disp "ZweiterQuadrant"       Disp "x ist negativ"       Disp "y ist positiv" EndIf	If x<0 and y<0 Then        Disp "Dritter Quadrant"        Disp "x ist negativ"        Disp "y ist negativ" EndIf If x>0 and y<0 Then        Disp "Vierter Quadrant"        Disp "x ist positiv"        Disp "y ist negativ" EndIf EndPrgm

Im dritten Teil von Lektion 3 wirst du den Gebrauch von Else und ElseIf lernen.

Lernziele:

• If…Then…Else Anweisungen entwickeln, so dass Aktionen gesetzt werden, wenn die Bedingung erfüllt und auch nicht erfüllt ist
• Anwendung von ElseIf, um unterschiedliche Bedingungen in einem Block zu behandeln

Oft ist es notwendig, eine Aktion zu verfolgen, wenn die Bedingung erfüllt ist (true) und eine andere, wenn die Bedingung nicht erfüllt (false) ist. Dann kommt Else an die Reihe.

Die Wahl der If…Then…Else…EndIf-Struktur aus dem Menu Steuerung fügt alle vier reservierten Wörter ins Programm und lässt Platz für die fehlenden Teile des Codes.

Das Programm:

Zum Abschluss eines Seminars auf der Uni muss man drei Prüfungen absolvieren. Um das Seminar positive abzuschließen, ist ein Durchschnitt von 65 Punkten zu erreichen. Schreibe ein Programm, das aus den drei Einzelergebnissen den Durchschnitt berechnet und dann entweder „Bestanden“ oder „Nicht Bestanden“ ausgibt.

• Überlege zuerst, wie du die Einzelergebnisse ins Programm bekommst: als Programmargumente oder über einen Request-Dialog?
• Wie wird der Durschnitt berechnet?
• Für die Ausgabe des Ergebnisses werden wird die Text-Anweisung aus dem E/A-Menu einführen.

Der Einfachheit halber verwenden wir hier die Eingabe als Argumente.

Die durchschnittliche Punktzahl ist die Summe der Einzelwerte dividiert durch 3:

                                        durchschn:=(t1+t2+t3)/3.

       Verwende einen Dezimalpunkt nach 3, um sicher zu stellen, dass das Ergebnis eine Dezimalzahl wird.

Ergänze dann die If…Then…Else…EndIf-Anweisung und verwende die Text-Anweisung um entweder “Bestanden” oder “Nicht bestanden” auszugeben. (Wie könntest du den Durchschnittswert ebenfalls im Text ausgeben lassen?)

In der Anwendung zur Lektion 3 wirst du von den Sternzeichen lernen und ein Programmschreiben, das dir dein Sternzeichen verrät. Die Übungen dieser Lektion sollten schon durchgearbeitet worden sein.

Lernziele:

• If… then… elseIf…then…elseIf… in einem Programm verwenden
• Mit Datumskonvertierungen arbeiten

Der Tierkreis (auch Zodiak, engl. Zodiac)

In Astronomie und Astrologie teilen die Tierkreiszeichen den Himmel in 12 gleiche Gebiete. Diese Gebiete werden nach den Sternbildern benannt, die sich ungefähr in diesen Regionen befinden. Die Babylonier entwickelten diese Einteilung zwischen 1000 und 500 v.Chr. und begannen ihr Kalenderjahr mit dem Frühlingsbeginn (Tag- und Nachtgleiche). Daher ist das erste Sternzeichen der Widder (Aries) für den Zeitraum 21. März bis zum 20. April.

Das Programm

Wir schreiben ein Programm, bei dem der Benutzer Tag und Monat seines Geburtstags eingeben soll. Das Programm zeigt, unter welchem Sternbild er geboren ist. Dazu setzen wir eine umfangreiche If…Then-Konstruktion ein.

Der Anwender wird Tag und Monats nach unserem Kalender eingeben. Das Programm berechnet zuerst, der wievielte Tag im Jahr dieser Tag ist (z.B. ist der 14. April ist der 104. Tag). Mit If-Abfragen bestimmen wir dann das entsprechende Tierkreiszeichen.

Dazu müssen zuerst die in der Tabelle stehenden Daten in Tagesnummern (im Jahr) umgerechnet werden. Mit dem TI-Nspire™ CX verwenden wir die dbd-Funktion:

             dbd(3112.14,210315) berechnet die Anzahl der Tage vom

             31. Dez. 2014 (12.3114) bis zum 21. März 2015 (03.2115).

So ist der 21. März der 80. Tag im Jahr (siehe Screenshot).
Vervollständige die Tabelle der Dauern unter Verwendung deines TI-Nspire™ CX.

Hier sind die zeitlichen Intervalle für alle Tierkreiszeichen (Sternbilder):

Sternbild	Zeitraum ;	Von Tag Nr.	bis Tag Nr;.
Widder(Aries): Stier(Taurus): Zwillinge(Gemini): Krebs(Cancer): Löwe(Leo): Jungfrau(Virgo): Waage(Libra): Skorpion(Scorpio): Schütze(Sagittarius): Steinbock(Capricorn): Wassermann(Aquarius): Fische(Pisces):	21. März – 20. April 21. April – 21. Mai 22. Mai – 21. Juni 22. Juni – 22. Juli 23. Juli – 22. August 23. August – 23. September 24. September – 23. Oktober 24. Oktober – 22. November 23. November – 21. Dezember 22. Dezember – 20. Jänner 21. Jänner – 19. Februar 20. Februar – 20. März	80 111	110

Für unser Programm müssen wir Tag und Monat in das Format konvertieren, das die dbd-Funktion verlangt: TTMM.JJ.

Du kannst das folgendermaßen tun:

                  dcode := Tag*100 + Monat + 0.0015

Dann ergibt sich die Nummer des Tages:

                 dnum := dbd(12.3114, dcode)

Rechts steht ein Testprogramm, das nur den Tagescode und die Tagesnummer ausgibt. Der Test zeigt, dass diese Ausdrücke richtig arbeiten.

 

Nun können wir den restlichen Teil des Programms schreiben.

Erzeuge eine lange If…then…elseIf…then…elseIf…-Anweisung, um das Sternbild richtig zuzuweisen. Jede ‘Entscheidung’ speichert das entsprechende Sternzeichen in der Variablen stbild. Beim Steinbock musst du aufpassen!

Teste dein Programm sorgfältig mit Hilfe der oben angegebenen Tabelle.

Beachte, dass du auch ‘>=’ eingeben kannst und die ‘Syntax überprüfen …’-Operation macht automatisch das Zeichen  daraus.

Wenn die dbd-Funktion ein unsinniges Datum als Argument erhält (wie z.B: Monat 13 oder Tag 32), erscheint eine Fehlermeldung und das Programm wird abgebrochen.

Um sicher zu sein, dass gültige Daten eingegeben werden, sollte über eine Schleife solange abgefragt werden, bis richtige Daten eingegeben werden. Von Schleifen werden wir in der nächsten Lektion lernen. Mach nur weiter!

In dieser Lektion wirst du das Konzept von Schleifen in Programmen kennen lernen. Wir beginnen mit der For-Schleife.

Lernziele:

• Das Konzept von Schleifen in Programmen beschreiben
• Programme und Funktionen mit einer For…EndFor-Schleife schreiben

Über Schleifen

Die TI-Basic Programmiersprache bietet die Möglichkeit eine Gruppe von Anweisungen wieder und wieder abzuarbeiten. Diese Wiederholung von Anweisungen nennt man Schleifen.

Die drei Schleifenkonstruktionen, die du jetzt lernen wirst erreicht man im Programmeditor über menu> Steuerung (siehe rechts: For…, While… und Loop…).
Die While... und Loop...-Schleifen werden in den nächsten Übungen in dieser Lekzion behandelt. Für mehr Information über zusätzliche Kontrollstrukturen informiere dich bitte im Reference Guide auf der TI-Codes Webseite.

For…EndFor

Die For-Schleife dient zur Abarbeitung einer arithmetischen Folge von Werten. Man nennt einen derartigen Vorgang ‚Iteration‘.

Der Bezug der For…EndFor-Anweisung vom Steuerungsmenu gibt dir die notwendigen Bausteine, um die Anweisung richtig zu vervollständigen:

           For , ,

           EndFor

Die Kommata nach dem Wort For zeigen an, dass noch (mindestens) drei Angaben fehlen:

           For i, 1, n, 1

1. i ist die Lauf- oder Schleifenvariable. Hier muss eine Variable stehen.
2. 1 ist der Anfangswert für i: Nach jedem Durchlauf der Schleife wird dieser Wert erhöht oder die Zahl der durchlaufenen Schleifen (ab dem Anfangswert) gezählt (hier ab 1).
3. n ist der Endwert: Nach jedem Durchlauf der Schleife wird der Wert der Laufvariablen mit n verglichen und so lange wiederholt, bis sie größer als n ist.
4. 1 ist die Schrittweite (Inkrement): Nach jedem Schleifendurchlauf wird i um diesen Wert erhöht (hier ist dieser Wert 1). 1 muss als Schrittweite nicht angegeben werden, jede andere Schrittweite schon.

Jede einzelne oder alle von den letzten drei Komponenten können Zahlen oder Variable sein.

Programmausführung

Das im Screenshot gezeigte Programm erzeugt das rechts abgebildete Ergebnis.

• Der Wert für n (Endwert) ist ein Programmargument.
• Die Laufvariable i ist eine lkcale Variable. Sie beeinflusst nicht das übrige Problem.
• Die Schleife beginnt mit i=1 und erzeugt und zeigt die Werte von i und i2.

• Nach der Disp-Anweisung übergibt EndFor die Kontrolle zurück an die For-Anweisung, die i um die Schrittweite erhöht.
• Solange dieser Wert ≤ n ist, wird die Schleife erneut mit dem nun um die Schrittweite erhöhten Wert für i durchlaufen.
• Das wird solange wiederholt, bis der Endwert erreicht oder übertroffen wird.

Wenn die Schleife abgearbeitet ist, dann ist der Wert von i größer als der Endwert n! Du glaubst das nicht? Dann füge ein weiteres Disp i nach der EndFor-Anweisung ein und überzeuge dich selbst.

In dieser Übung wirst du von der vielseitigsten Schleife lernen: While…EndWhile

Lernziele:

• Eine einfache While-Schleife schreiben
• Mit einer While-Schleife die Dateneingabe prüfen

Das mächtige While…

Die While…EndWhile-Schleife läuft so lange wie die <Bedingung>  wahr bleibt. Das sieht folgendermaßen aus:

               <Setzen des Anfangswerts der Bedingung >

               While <Bedingung>

                      <Schleifenkörper>

<schleifenkörper>               EndWhile</schleifenkörper>

• <schleifenkörper> Vor dem Start der Schleife müssen eine oder mehrere Variable so definiert werden, dass die While-Anweisung die Bedingung beim ersten Mal auswerten kann. Damit erhält die Variable den Wahrheitswert true oder false. Bei einer Anfangsbedingung = false, wird die Schleife einfach übersprungen, anderenfalls wird in die Schleife eingetreten. </schleifenkörper>
• <schleifenkörper>Die ist ein logischer Ausdruck wie z.B. x>0.</schleifenkörper>

• Der  <Schleifenkörper> <schleifenkörper>  ist eine Sammlung von Anweisungen, die weitere Schleifen und If-Konstrukte beinhalten kann. Er wird so lange durchgeführt, so lange die <Bedingung>   true (wahr) bleibt.</schleifenkörper>
• <schleifenkörper>Das reservierte Wort EndWhile zeigt das Ende des <Schleifenkörpers> <schleifenkörpers>  an. An dieser Stelle verzweigt das Programm zurück an den Beginn der Schleife und überprüft die <Bedingung>.    Ist diese nicht (mehr) erfüllt, dann wird die Schleife verlassen, sonst wird sie ein weiteres Mal durchlaufen. </schleifenkörpers></schleifenkörper>

k:=1 am Beginn des Programms setzt die Anfangsbedingung auf einen bekannten Wert. Ohne diese Initialisierung könnte die Variable k einen gespeicherten Wert annehmen und damit einen unbekannten Wert ins Programm bringen.
Innerhalb des <schleifenkörpers> <Schleifenkörpers>  muss eine Anweisung vorkommen, die sich auf die <Bedingung> bezieht, so dass die Schleife dann auch einmal beendet wird und das Programm mit den folgenden Anweisungen weitergeführt wird. Üblicherweise findet sich eine derartige Anweisung am Ende der Schleife. Hier wird durch k:=k+1 sichergestellt, dass k einmal größer wird als n. </schleifenkörpers>

Dieser While-Schleife entspricht die folgende For-Schleife:

           For k, 1, n

               Disp k

           EndFor

Überprüfen, ob eine Eingabe gültig ist mit While…EndWhile

Wir werden einen Programmteil entwerfen, der sicher stellen soll, dass ein allfälliger Anwender eine positive Zahl eingibt. Es soll dem Anwender anzeigen, wenn die Eingabe falsch ist und ihn zu einer neuerlichen Eingabe auffordern.
Die Ausgabe für diesen Teil ist rechts gezeigt. Einige falsche Eingaben (weil negativ) wurden gemacht, um die Auswirkung zu demonstrieren.
Versuche, diesen Teil zu entwerfen, ohne auf die nächste Seite zu schauen!

1. Wir beginnen mit einem neuen Programm namens gueltig.

2. Definiere eine lokale Variable n und verwende Request zur Eingabeaufforderung durch den Anwender. Beachte, dass der Anwender um eine positive Zahl gefragt wird.

3. Füge die While-Anweisung vom Steuerungsmenu ein. Sowohl While als auch EndWhile werden ins Programm eingefügt und die Schreibmarke erscheint hinter dem Wort While.

4. Lege die Anfangsbedingung fest mit n ≤ 0.

• Hole den ≤ Operator über [CTRL] =.

5. Vervollständige nun den Schleifenkörper, indem du eine Fehlermeldung mit der Text-Anweisung entwirfst. Mit einer weiteren Request-Anweisung fordere den Anwender zu einer neuerlichen – richtigen – Eingabe für n auf.

Das rechts gezeigte Programm gueltig ( ) erzeugt den oben abgebildeten Dialog.
Beachte die BEIDEN Request-Anweisungen.

• Die erste dient dazu, die Bedingung (n≤0) zu initialisieren. Wird hier eine positive Zahl eingegeben, dann wird die Schleife nicht ausgeführt.
• Wenn aber mit 0 oder einer negativen Zahl geantwortet wird, dann erzeugt die Schleife die Fehlermeldung und verlangt nach einer anderen Zahl.

Der Schleifenkörper wird so lange ausgeführt, wie eine negative Zahl eingegeben wird. Dann wird die Disp-Anweisung mit der „Belohnung“ ausgeführt.

In dieser Übungseinheit wirst du die „Allzweckschleife“ Loop…EndLoop kennen lernen.

Lernziele:

• Die Loop…EndLoop-Schleife einsetzen
• Die Exit-Anweisung zum Verlassen einer Schleife verwenden

Welche Schleife ist das, Loop…EndLoop?

Die Loop…EndLoop-Schleife gestattet eine flexiblere Anwendung des Schleifenkonzepts. Die Anweisungen im Schleifenkörper werden so lange ausgeführt, bis eine Exit-Anweisung innerhalb der Schleife zu ihrem Abbruch führt. Wenn kein Exit angetroffen wird, führt das zu einer “Endlosschleife”. Wenn du unbeabsichtigt in eine Endlosschleife geraten bist, kannst am Handheld mit gedrückter und gehaltener [ON / HOME] -Taste das Programm unterbrechen.

Eine Loop…EndLoop-Schleife wird zumindest einmal durchlaufen, da es für den Eintritt in sie keine Bedingung gibt. Exit zwingt das Programm, mit der Anweisung, die dem EndLoop folgt, fortzufahren.

Beispiel: Wie oft muss man einen Würfel werfen, bis man zweimal hintereinander die gleiche Augenzahl erhält?

Beachte, dass im rechtsstehenden Programm die Loop…EndLoop-Schleife mit einem Exit unter einer Bedingung verlassen wird. Wenn der Zufallsgenerator randInt(1,6) hintereinander zwei gleiche Werte erzeugt, wird die Schleife über Exit verlassen und die Disp-Anweisung am Programmende ausgeführt.

Exit findest du über menu> Übertragungen> Exit.

Das Programm lässt sich auch mit einer While-Schleife erzeugen.

Bemerkung zur Syntax: Beachte im Programmcode oben den Gebrauch des Doppelpunkts zur Trennung zweier
                    Anweisungen in einer Zeile. Das erzeugt einen kürzeren und kompakteren Code.

                    Die Anweisung Exit findet man über menu> Übertragungen> Exit.

Programm: Errate die Zahl!

Um den Gebrauch von Loop…EndLoop zu demonstrieren, wollen wir in Spiel für zwei Personen entwickeln. Eine ganze Zahl von 1 bis 10 soll erraten werden. Wenn ein Spieler die, vom Rechner erzeugte Zahl errät, wird das Spiel mit einer „Gewinnanzeige“ beendet. Ein möglicher Spielverlauf wird im rechten Screenshot gezeigt.

1. Beginne ein neues Programm und gib ihm den Namen raten.

2. Starte das Programm mit der Initialisierung des Spiels. Führe drei Variable ein: die Nummer des Spielers (splr), die vom Computer erzeugte Zufallszahl (ti_z) und die vom Spieler geratene Zahl (sp_z).

Der Computer erzeugt eine Zufallszahl zwischen 1 und 10. Wir starten mit dem Spieler 0. Das macht den Wechsel der Spielernummer einfacher, wie wir gleich sehen werden.

3. Dann bilden wir die Schleife und fordern den ersten Spieler auf, die Zahl zu erraten. Die vollständige Anweisung dazu lautet:

      Request "Spieler " & string(splr) & " rate:", sp_z

• das ‘&’ verkettet die Strings. Da die Eingabeaufforderung mit Request nur ein String sein kann, wird die Variable splr mit der string()-Funktion (aus dem Catalog) in eine Zeichenkette umgewandelt.

4. Als nächstes bilde die Exit-Bedingung. Sobald ein Spieler die Zahl erraten hat, wird die Schleife verlassen. Dazu reicht die einfachste If-Anweisung:

            If sp_z = ti_z

            Exit

Erinnere dich, dass ein If ohne Then die nächste Anweisung ausführen lässt, wenn die Bedingung erfüllt ist, anderenfalls wird sie übersprungen.

5. Für den Wechsel der gibt es eine kluge Anweisung:

        splr := 1 – splr

iese kurze Anweisung schaltet den Wert von splr zwischen 0 und 1 hin und zurück. D.h., wenn splr = 0, dann wird auf 1 geschaltet, und wenn splr = 1, dann wird wieder auf 0 gestellt.

6. Zum Schluss füge mit einer Anweisung nach der Schleife eine Bemerkung für den Gewinner hinzu, wie etwa:

        Text “Spieler ” & string(splr) & “ hat gewonnen!”

Tipp: Wenn dir ‘Spieler 0’ und ‘Spieler 1’ nicht gefällt, dann addiere einfach 1 zur Variablen splr in dieser und in der Request-Anweisung. Am Display erscheinen dann 1 und 2, obwohl der Rechner 0 und 1 für die Spielernummern verwendet.

7. Vergiss nicht, das Programm vor jedem Testlauf zu speichern, denn du könntest ja in eine Endlosschleife geraten! Wenn das Programm einmal läuft, musst du spielen, bis ein Gewinner erscheint. Es gibt keinen Ausweg aus der Request-Anweisung. (Es gibt einen Trick: Gib keine Zahl ein!)

Diese Anwendung verwendet Schleifen, um so viele Daten, wie notwendig, zu sammeln. Als Erweiterung werden die Daten auf Gültigkeit geprüft. Mit If-An-weisungen wird eine geeignete Meldung ausgegeben.

Lernziele:

• Zähler- und Sammelanweisungen verwenden
• Eine Programmschleife zur Eingabe einer unbestimmten Anzahl von Daten verwenden
• Mit einem ‘Schalter’ eine Schleife abbrechen

Geschachtelte Strukturen

• Verschachteln ist die Programmiertechnik, bei der eine Kontrollstruktur innerhalb einer anderen auftritt.
• Der Ausdruck kommt vom Verstauen einer Schachtel in einer anderen um Platz zu sparen.
• Ein Programmierer setzt Schleifen innerhalb von Schleifen, Ifs in Schleifen und Schleifen in Ifs, um nach Erfordernissen des Programms komplexere Aufgaben zu erfüllen.
• Es ist wichtig, eine komplette Struktur ganz innerhalb eines anderen Blocks zu setzen, um Fehler zu vermeiden.

• Das Programm rechts zeigt eine While Schleife und eine If Konstruktion innerhalb einer anderen While-Schleife.
• Beachte das mehrfache Auftreten von EndWhile. Der Computer “weiß”, zu welchem While jedes EndWhile gehört.
• Die Einrückungen sind eine optische Unterstützung und helfen, die Programmlogik zu verdeutlichen.

Zuerst wird eine Schleife eingerichtet, die so lange Eingaben erwartet bis 0 eingegeben wird. Dann wird überprüft ob a<0. In diesem Fall wird die Meldung „Gib eine positive Zahl ein:“ gezeigt und um eine andere Eingabe gefragt. Wenn a>0, wird die Quadratwurzel berechnet und in einer weiteren If-Abfrage werden die Disp-Anweisungen ausgeführt.

Zusammenfassung der drei Schleifen:

For( Variable, Start, End)		While <Bedingung>		Loop If <Bedungung> : Exit
EndFor		EndWhile		EndLoop

For wird verwendet für eine Zählung oder für die Verarbeitung einer arithmetischen Folge von Werten.
While verwendet man, wenn man die Schleife komplett überspringen können will.
Loop wählt man, wenn die Schleife zumindest einmal durchlaufen werden soll. Sie muss eine Exit-Anweisung enthalten, üblicherweise als Teil einer If-Abfrage.

.

Lektion 4 Anwendung: Programm “bankinfo”

Ein Bankkunde hat bei einer Bank mehrere Konten. Die Bank verlangt, dass der Durchschnitt der Guthaben auf allen Konten mindestens $1000 beträgt, anderenfalls wird eine Verwaltungsgebühr fällig.

Liegt der Durchschnitt zwischen $1000 und $1250 benachrichtigt die Bank den Kunden mit einer Information über die drohende Gebühr.

Wenn der Durchschnitt aber über $1250 liegt, dann bedankt sich die Bank für den guten Durchschnittswert.

Wir wollen ein Programm schreiben, das den Kunden über seine Kontostände informiert. Er gibt seine Kontostände ein und das Programm zählt die Einlagen, berechnet deren Gesamtwert, sowie deren Durchschnitt und gibt dann dem Kunden eine entsprechende Information. Diese können z.B. lauten: „Verwaltungsgebühr fällig!“.

„Verwaltungsgebühr könnte bald anfallen!” und schlicht “VIELEN DANK!”.

Wir können zwei Methoden zur Eingabe einer Unbekannten Anzahl von Werten einsetzen:

• Methode 1: Frage zuerst nach der Zahl der Konten und verende dann eine For-Schleife zur Eingabe
• Methode 2: Frage nach den Beträgen und gib einen “Schalter” wie z.B. -999 als Anzeige dafür an, dass die Eingabe beendet ist. Bei dieser Methode setzt man eine While-Schleife ein.

Bei beiden Methoden rechnen wir die Gesamtsumme aller Werte laufend mit.

In Methode 2 müssen wir auch die Anzahl der Beträge mitzählen, sonst können wir den Durchschnitt nicht als Quotient aus Gesamtsumme und Anzahl berechnen. Die folgenden Informationen können hilfreich sein.

Dein Programm sollte ausgeben: 1. Die Anzahl der eingegebenen Beträge, 2. den Durchschnitt aller Beträge und 3. eine Meldung, die sich auf diesen Durchschnitt bezieht.

           Liegt der Durchschnitt: unter $1000: „Verwaltungsgebühr fällig!“

                                                 zwischen $1000 und $1250: „Verwaltungsgebühr könnte bald anfallen!“

                     …                         über $1250: „VIELEN DANK!“

Zählen und Aufsummieren (Akkumulieren)

Eine Anweisung wie c:=c+1 nennt man „Zähler“, da die Variable c bei jeder Ausführung um 1 erhöht wird.

Eine Anweisung wie t:=t+n wird „Akkumulator“ genannt, weil die Werte von n laufend aufsummiert (akkumuliert) werden. n wird zu t addiert und die entstehende Summe wieder als t abgespeichert. Am Ende der Abarbeitung der Schleife enthält die Variable t die Summe aller n-Werte.

Hier folgt ein Beispiel, das einen Zähler, einen Akkumulator (gesamt) und einen Schalter (-999), um die Anzahl der eingegebenen Beträge zu zählen.

Prgm Local zaehler,betrag,gesamt gesamt:=0 zaehler:=1	Erklärung Initialisierung der Variablen
Request "Betrag?",betrag	Ersten Betrag einlesen
While betrag≠−999	So lange bis -999 eingegeben wird
zaehler:=zaehlerr+1	Zähler wird um 1 erhöht
gesamt:="Betrag?"+betrag	add the amount to the total
Request "Betrag?",betrag	Betrag wird zur Summe addiert
EndWhile Disp "Count=",counter Disp "Total=",total endPrgm	Um nächsten Betrag wird gefragt

Die While-Schleife zählt und akkumuliert so lange bis -999 als Betrag eingegeben wird. Dann wird die Schleife beendet und die Resultate werden angezeigt.

Erweiterung

Versichere dich im Rahmen der Eingaberoutine, dass ein sinnvoller Betrag (größer 0) eingegeben wird und sieh für den Fall einer falschen Eingabe eine entsprechende Meldung an den Kunden vor.

In dieser Einheit wirst du lernen, wie man Listen in Programmen einsetzen kann, um interessante Streudiagramme zu erzeugen.

Lernziele:

• Einsatz von Listen in Programmen
• Mit Listen im Programm Streudiagramme erzeugen

TI-Nspire™ Basic kennt keine direkten Anweisungen zur Erzeugung von Grafiken. Ein Programm kann Funktionen zum Plotten und für Streudiagramme produzieren, aber keine Punkte direkt plotten.

In dieser Lektion werden wir drei wichtige Ideen verfolgen:

1. mit Listen in einem Programm arbeiten,
2. auf einer Graphs-Seite ein Streudiagramm dieser Listen darstellen, und
3. ‘dynamische’ Programme verwenden, die ‘auf Abruf’ laufen.

Listen definieren

Listen werden zwischen geschlungenen Klammern { } geschrieben. Um eine leere Liste zu erzeugen verwende eine Zuweisung wie etwa mliste:={ } ([ {} ] = [ctrl] [ ) ]) mit keinem Listenelement zwischen den Klammern.

Die Elemente der Liste (die Werte zwischen den Klammern) werden über eckige Klammern angesprochen. So meint man mit mliste[3] das dritte Element von mliste.

Man kann Elemente zu einer Liste hinzufügen, indem man einen Wert gleich hinter ihren letzten Wert ablegt. Wenn z.B. eine Liste mliste die drei Elemente 12, 7 und 2 enthält, kann man ein weiteres Element als Viertes hinzufügen.

mliste[4]:=17 ergibt dann mliste = {12, 7, 3, 17}. dim(Listenname) ergibt die Anzahl der Elemente der Liste und wird oft so dazu verwendet, ein Element in eine Liste aufzunehmen: mliste[dim(mliste)+1):=<neues Element>.

Programmierung von Zufallspunkten

Wir werden nun ein Programm schreiben, das ein Muster von Zufallspunkten auf der Graphs-Seite erzeugt.

1. Beginne ein neues Programm im Editor (wir wollen es zufpkte nennen) mit dem Argument n.
   • n ist die Anzahl der zu erzeugenden Punkte.
   • Das Programm produziert (oder erneuert) zwei ‘globale’ Listen von Zufallszahlen, mit denen wir das Streudiagramm auf einer Graphs-Seite plotten werden.

Zufallszahlengeneratoren

Im TI-Nspire™ CX gibt es mehrere Zufallszahlfunktionen. Die beiden am häufigsten gebrauchten sind rand() und randInt( ).

• rand() erzeugt eine Zufallszahl zwischen 0 und 1.
• randInt(a,b) erzeugt eine ganze Zufallszahl aus dem Intervall [a,b]. randInt(1,6) erzeugt eine ganze Zufallszahl von 1 bis 6. Probiere das im Calculator.

Wir machen den ersten Versuch, Listen von Zufallszahlen zu erzeugen:
xs := randInt(-10, 10, n)
ys := randInt(-6, 6, n)

2. Das dritte Argument in den beiden Funktionen lässt die randInt-Funktion eine Liste von n Werten im gewählten Intervall erzeugen, anstelle von nur einer einzigen.

3. Speichere das Programm mit [ctrl] [B]. Führe nun das Programm im Calculator mit einem kleinen Wert für n aus und sieh dir die Listen xs und ys an. Deine Werte werden wahrscheinlich nicht mit den rechts abgebildeten übereinstimmen.

4. Füge eine Graphs-Seite im Problem ein und erzeuge ein Streudiagramm von (xs,ys) über menu> Graph Eingabe/Bearbeitung> Streudiagramm.
5. Gib xs für die x-Werte (bei x←) und ys eine Zeile tiefer für die y-Werte (bei y←) ein.
6. Schließe ab mit [enter].

Siehst du nun, warum wir diese Intervalle für die Zufallszahlen gewählt haben? (Überprüfe die Standardvorgaben für die Fenstereinstellungen!)

Nachdem wir das Programm erfolgreich getestet haben, wechsle wieder zum Calculator und führe das Programm mit einem größeren Argument n (aber nicht zu groß) aus. Sieh dir das Ergebnis im Graphs-Fenster an.

In dieser Übungseinheit wirst du lernen, wie man einzelne Listenelemente kontrolliert und wie man ein Programm aus einer Math Box in den Notes „dynamisieren“ kann.

Lernziele:

• Reelle Zufallszahlen (Dezimalzahlen) in einem gegebenen Intervall erzeugen
• Mit der „interaktiven“ Eigenschaft der Math Boxes in den Notes ein Programm „dynamisch“ machen

In der vorigen Übung…

… haben wir ein Programm geschrieben, das zwei Listen von Zufallszahlen erzeugt und diese in Form eines Streudiagramms auf einer Graphs-Seite dargestellt hat. Erinnere dich an die Ausgabe von zufpkte(n) wie rechts gezeigt.

Das Programm hat sich darauf beschränkt, nur ganzzahlige Werte für die x- und y-Koordinaten des Streudiagramms zu erzeugen. Daher lagen die Punkte auf den Gitterpunkten. Jetzt wollen wir das Programm auch auf nichtganzzahlige Werte erweitern, so dass die Punkte wesentlich dichter zu liegen kommen.

Anstelle von randInt(-10, 10) werden wir mit der rand( )-Funktion eine Dezimalzahl (zwischen 0 und 1) generieren und dies so skalieren, dass die Punkte wiederum innerhalb des Standardfensters liegen.

Sehen wir uns zuerst die Ausgaben von rand( ) und rand(k) im Calculator an. Ohne Argument erzeugt rand() eine Dezimalzahl zwischen 0 und 1. Mit dem Argument 3 wird hingegen eine Liste von drei derartigen Dezimalzahlen ausgegeben. Diese Liste kann als Teil eines Ausdrucks dazu verwendet werden, dass die Werte die Grenzen [0, 1] überschreiten. So ergibt dann 5*rand(3) eine Liste von reellen Zufallszahlen zwischen 0 und 5.

Das müssen wir wissen, um zufällige Dezimalzahlen zwischen -10 und +10 zu erzeugen. Das ist ein Intervall von 20 Einheiten. Wir beginnen mit -10 und addieren eine Zufallszahl zwischen 0 und 20 dazu, die wir mit 20*rand() generieren.

1. Wir ändern in unserem Programm zufpkte(n) die randInt-Funktionen in einen Ausdruck, der rand() enthält, und zwar folgendermaßen:
   xs := -10 + 20*rand(n)
   ys:= -6 + 12*rand(n)

Diese Terme erzeugen n Werte zwischen -10 und 10 für xs und n Werte zwischen -6 und 6 für ys.

2. Lass das Programm im Calculator laufen und sieh dir die Werte von xs und ys an.

3. Dann gehe zum Streudiagramm von (xs,ys).

4. Starte das Programm nochmals mit einem größeren Argument n.
   • Rechts ist ein Screenshot nach der Durchführung von zufpkte(50) mit den Dezimalzahlen, die mit rand() erzeugt worden sind.

Dynamische Programme

1. Um das Programm dynamisch zu gestalten, füge eine Notes-Seite ein.
2. Füge weiters eine Math Box in die Notes ein über menu> Einfügen> Math Box.
3. Schreibe den Programmnamen mit einer Variablen (wir verwenden k) und drücke [enter] (oder rufe das Programm über die [var]-Taste auf).
   • Jetzt erscheint eine Fehlermeldung, da das Argument eine undefinierte Variable ist. Das werden wir gleich ändern.

Der Parameter, den du hier nimmst, muss nicht der gleiche sein, wie der im Programmeditor verwendete. Der Wert wird dem Programmargument übergeben.

4. Installiere auf der Graphs-Seite (mit dem Streudiagramm) einen Schieberegler über menu> Aktionen> Schieberegler einfügen
5. Nimm jene Variablenbezeichnung, die du in der Math Box genommen hast. Bei uns war das k.
6. Setze den Anfangswert auf 1, Minimum und Maximum auf 1 bzw. 100 und die Schrittweite auf 1, wie im rechten Bild angezeigt.
7. Drücke [enter] um den Schieberegler zu platzieren.
8. Bewege ihn auf eine passende Stelle und drücke [enter] oder klicke nochmals um ihn zu verschieben.

Du siehst, dass alle Punkte verschwunden sind, bis auf einen. Das ist das Resultat des Programms, das auf den neuen Wert für k (in unserem Demoprogramm) aus der Math Box auf der Notes-Seite reagiert.

Wenn du jetzt nochmals in die Notes schaust, wirst du merken, dass die Fehlermeldung verschwunden ist. Und an ihrer Stelle das Wort Fertig steht. Jetzt, wo das Argument k definiert ist, läuft das Programm ordnungsgemäß.

9. Bewege nun den Schieberegler für k. Jedes Mal, wenn der Wert für k geändert wird, wird das Programm erneut ausgeführt, neue Listen und damit neue Punkte werden generiert und schließlich auch im Streudiagramm dargestellt.

In dieser Übungseinheit wirst du lernen, wie man dynamische Programme dazu verwenden kann, andere Typen von Graphen mit der Data & Statistics Applikation zu erzeugen.

Lernziele:

• Ein Programm schreiben, das dynamisch die Daten am Display anpasst
• Ein Programm erzeugen, das einen realistischen Vorgang (Wurf mit 2 Würfeln) simuliert und das Ergebnis in einem sinnvollen Graph präsentiert

Dynamische Programme können weit mehr als nur Streudiagramme erzeugen!

Hier werden wir eine Demonstration der Verteilung der Summen der Augenzahlen von zwei fairen Würfeln für eine große (veränderbare) Anzahl von Würfen entwickeln.

Wenn du ein Paar regulärer Würfel wirfst, liegt die Augensumme zwischen 2 (zwei Einser werden geworfen) bis 12 (zwei Sechser werden geworfen). Aber, ist die Summe 10 gleich wahrscheinlich, oder treten einige Summen häufiger auf als die anderen? Wir wollen ein TI-Nspire-Problem entwickeln, das dieses Experiment mit einem Programm simuliert.

1. Eröffne ein neues Problem.
2. Wähle doc> Einfügen> Programmeditor> Neu…

Das Programm besteht aus nur einer Anweisung und enthält kein Argument:

summe:=randInt(1, 6, k) + randInt(1, 6, k)

Damit werden zwei globale Variable festgelegt:

k ist die Anzahl der Würfe und summe ist eine Liste, die k Augensummen der zwei geworfenen Würfel enthält.

3. Speichere das das Programm mit [ctrl] [B].

4. Füge nun eine Notes-Seite ein.
5. Füge dort eine Math Box ein mit menu> Einfügen> Math Box.
6. Schreibe den Programmnamen in die Math Box (mit den Klammern) und [enter].

Sei nicht überrascht, wenn du eine Fehlermeldung erhältst, k hat noch keinen Wert.

7. Füge eine Data & Statistics-Seite ein.
8. Installiere einen Schieberegler (menu> Aktionen> Schieberegler einfügen) für die Variable k gemäß der rechten Abbildung.
   Diese Variable repräsentiert die Anzahl der durchgeführten Würfe.
9. Platziere den Schieberegler am oberen Rand der Seite.

Mit dem nunmehr definierten Wert für k wird das Programm von der Notes-Seite aus durchgeführt. Am oberen Bildschirmrand kannst du ,Beschriftung: summe‘ lesen. Ein Punkt beschreibt gerade die Augensumme eines Würfelpaars.

Verwende den Schieberegler jetzt noch nicht!

10. Klicke in den unteren Rand und wähle summe für die horizontale Achse.
    • Damit erhalten wir ein senkrechtes Punktdiagramm der Augensummenliste.

11. Ändere nun die Darstellung über menu> Plot-Typ> Histogramm.

12. Aktiviere jetzt den Schieberegler, um mehr Würfe zu simulieren.
    • Wenn k größere Werte annimmt, dann musst du die Fenstereinstellungen anpassen. Wähle dazu menu> Fenster/Zoom> Zoom-Daten.

Welche Summe tritt am häufigsten auf? Welche am seltensten? Warum?

In dieser Anwendung werden wir ein Projekt entwickeln, um das ‘Chaos-Spiel’ zu spielen, bei dem das Sierpinski-Dreieck, ein berühmtes Fraktal, entsteht.

Lernziele:

• Ein Programm schreiben, das ein interessantes Bild erzeugt (das Sierpinski-Dreieck)
• Alle erlaubten Aktionen über Schieberegler kontrollieren

 

Das Sierpinski-Dreieck, oder auch die „Sierpinski-Dichtung“ genannt, ist ein Fraktal, das mit einem gleichseitigen Dreieck beginnt, wobei schrittweise die ‘inneren Dreiecke’ entfernt werden wie oben abgebildet. Das kann unendlich oft fortgesetzt werden bis das Dreieck ‘unendlich ausgehöhlt’ ist und jeder Teil des Bilds ähnlich zum ganzen Bild wird (Prinzip der Selbstähnlichkeit).

In diesem Projekt werden wir diese Figur auf eine andere Weise herstellen, nämlich mit dem so genannten Chaos-Spiel. Dieses Spiel hat die folgenden Regeln:

1. Wähle drei Punkte in der Ebene als Ecken eines Dreiecks: (0,0), (2,0) und (1,1). Wir wissen, dass dies kein gleichseitiges Dreieck ist.
2. Starte mit der Wahl eines Zufallspunkts (vorzugsweise innerhalb des Dreiecks, das muss aber nicht sein) und betrachte diesen Punkt als deine ‘momentane’ Position.
3. Wähle zufällig einen der drei Eckpunkte des Dreiecks aus.
4. Bewege dich auf halbem Weg von deiner Position zur gewählten Ecke, d.h., zum Mittelpunkt der Strecke von dir zu diesem Eckpunkt.
5. Zeichne einen Punkt an diese Stelle.
6. Wiederhole die Prozedur ab Schritt 3.

Wir werden ein wachsendes Streudiagramm zur Visualisierung dieses Spiels herstellen. Dabei werden wir lernen, wie man ein Streudiagramm zurücksetzt (ein Reset macht) und wie man den Schieberegler am Zurückgehen hindern kann (indem man den Pfeil-Links oder Pfeil-Rechts-Teil des verkleinerten Schiebereglers ausschaltet).

1. Beginne mit einem neuen Dokument und füge eine Graphs-Seite ein.
2. Bewege den Koordinatenursprung in die linke untere Ecke der Seite und strecke die Achsen so, dass die x-Achse bequem von 0 bis 2 und die y-Achse von 0 bis etwas mehr als 1 reicht. (Denke an die Koordinaten der Dreiecksecken.)
3. Verziehe die Koordinatenebene um den Ursprung zu bewegen und ziehe an der x-Achse, um die Skalierung zu ändern. Das kann auch noch später angepasst werden.

Es ist immer gut, das Dokument regelmäßig zu speichern (mit /+S), weil ja immer wieder etwas schiefgehen kann.

4. Richte ein Streudiagramm für die Listen xs und ys ein
   (menu> Graph Eingabe/Bearbeitung> Streudiagramm).
   • Diese Variablen sind noch nicht definiert, daher ist auch nach einem [enter] kein Diagramm zu sehen.

5. Füge zwei Schieberegler ein (menu> Aktionen> Schieberegler einfügen):
   • n – Anfangswert 0, Minimum 0, Maximum 2000, Schrittweite 1, horizontal und minimiert.
   • reset – Anfangswert 0, Minimum 0, Maximum 1, Schrittweite 1, horizontal und minimiert.
6. Platziere diese Regler in die obere rechte Ecke des Schirms, so dass sie nicht das Dreieck teilweise überdecken.

In der Graphs-Seite sind wir fertig.

Das Programm

1. Füge eine weitere Seite für den Programmeditor ein
   (doc> Einfügen > Programmeditor > Neu …).
2. Nenne das Programm sierpinski.

3. Füge hier auch eine Local-Anweisung für den Fall ein, dass später im Programm Hilfsvariable benötigt werden.
   • Verwende die Variable xxx vorläufig als Platzhalter.
4. Beginne den Programmcode mit dem ‘reset’-Konzept:
   • Wenn der reset-Schieberegler verwendet wird, werden alle Daten in den Listen xs und ys gelöscht und die Variablen reset und n auf 0 gesetzt.
   • Wenn das Programm zum ersten Mal läuft, wird es initialisiert (wenn n = 0 und reset ≠ 1).

Die Zuweisung reset:=0 in diesem Programmteil mag seltsam anmuten, aber es bewirkt, dass der Wert von reset am Schirm immer als 0 erscheinen wird.

Beim Klick auf die reset-Schaltfläche nimmt reset den Wert 1 an und veranlasst einen Programmlauf. Dann wird reset sofort wieder auf 0 zurückgesetzt (gemeinsam mit anderen Werten in diesem Programmteil).

Wie verhindern wir n am Abnehmen?

Wir wünschen, dass der Wert von n (die Anzahl der zu zeichnenden Punkte) nur zu- aber nicht abnimmt. Zu diesem Zweck merken wir uns den jeweils letzten Wert von n und vergleichen ihn mit dem allfällig neuen Wert. Ist dieser neue Wert kleiner als der neue, dann wird dieser ignoriert und n wieder auf den letzten Wert gesetzt.

1. Mit der Variablen letztn wird der letzte Wert von n gehalten. Das geschieht ganz am Programmende:
   letztn := n
   EndPrgm

Im nächsten Programmteil wird geprüft, ob das aktuelle n kleiner ist als das vorige n (wenn der Linkspfeil am Schieberegler angeklickt wird)?

2. Füge nach dem Initialisierungsteil hinzu:
   If n < letztn Then
   n := letztn
   Else
3. Gib letztn auch einen Anfangswert in der ersten If-Konstruktion:
   letztn:=0

4. Jetzt werden die Listen für das Streudiagramm gefüllt:
   
   • Der erste Punkt ist etwas Besonderes, denn das kann ein beliebiger Punkt sein. Wenn also n=1, belegen wir xs[1] und ys[1] mit einer Zufallszahl:
     Else
     If n = 1 Then
     xs[1] := rand()
     ys[1] := rand()
     Else

Die rand()-Funktion erzeugt eine Zufallszahl zwischen 0 und 1. Damit ist dieser Punkt tatsächlich ein Zufallspunkt im Quadrat zwischen (0,0) und (1,1).

Jetzt sind wir bereit, den Kern des zu Beginn erklärten Algorithmus anzugehen. Wir holen ihn kurz ins Gedächtnis zurück:

3. Wähle zufällig einen der drei Eckpunkte des Dreiecks aus.
4. Bewege dich auf halbem Weg von deiner Position zur gewählten Ecke, d.h., zum Mittelpunkt der Strecke von dir zu diesem Eckpunkt.
5. Zeichne einen Punkt an diese Stelle.

Wiederhole den Prozess ab Schritt 3.

5. Mit v := randint(1,3) wählen wir eine ganzzahlige Zufallszahl, die helfen wird, zwischen den drei Eckpunkten zu unterscheiden.
6. Konstruiere eine Reihe von If-Anweisungen auf der Grundlage von v um den nächsten Mittelpunkt zu berechnen.
   • Erinnere dich: unsere drei Eckpunkte sind (0, 0), (2, 0) und (1, 1).

7. Wenn v=1, verwende den Punkt (0, 0) und den zuletzt gefundenen Punkt, um einen Mittelpunkt zu berechnen.
   • Erinnere dich an die Geometrie, wie man den Mittelpunkt einer Strecke zwischen zwei Punkten (x1,x2) und (y1,y2) findet: (x1+x2)/2 und (y1+y2)/2.

An dieser Programmstelle: die letzten Werte von xs und ys sind xs[n-1] und ys[n-1], denn wir sind hierher durch Erhöhung von n gekommen, ohne ein weiteres Element zur Liste hinzugefügt zu haben.

Das erklärt den rechts abgebildeten Code. v, a and b sind temporäre lokale Variable.

8. Füge am Kopf des Programms die Anweisung
   

   Local v, a, b

   ein.

Diese If-Konstruktion lässt sich leicht kopieren und damit werden die beiden anderen Ecken, (2,0) und (1,1) angesprochen.

Anmerkung: Eine effektivere Konstruktion wäre an dieser Stelle ein If…Then…ElseIf…Else…EndIf. Versuche, ob du diesen Programmteil damit schreiben könntest.

9. Hänge die Werte von a und b ans Ende der beiden Listen dran.
   • die n-te Position ist immer eine Stelle nach dem Ende der Listen, und das ist immer erlaubt.

Wenn du die If-Anweisungen aus dem Steuerungsmenu an die richtigen Stellen eingefügt hast, dann wirst du jetzt ein weiteres EndIf am Programmende gerade noch vor letztn := n vorfinden.

10. Mit [ctrl] [B] überprüfe die Syntax des Programms und speichere es.
    • Falls Fehlermeldungen auftreten, überprüfe sorgfältig den Code. Ein vollständiges Programmlisting findest du in der Lehrerinformation.

11. Füge eine Notes-Seite ein, erzeuge eine Math Box ([ctrl] [M]) und tippe den Programmnamen, eine like Klammer und [enter].

12. Wechsle in die Graphs-Seite und bewege die Schieberegler.
    • n fügt Punkte zum Streudiagramm hinzu und reset löscht alle Punkte und setzt n zurück auf 0.
    • Der Linkspfeil am Schieberegler für n soll nicht wirksam sein. Der Linkspfeil am reset-Schieberegler ist immer ausgeschaltet.
    • reset sollte immer mit dem Wert 0 erscheinen, denn wenn das Programm einen Wechsel auf 1 entdeckt, wird sofort auf 0 zurückgesetzt.
    • Der Wert für n hat seine Grenze im Wert für Maximum in den Einstellungen des Schiebereglers.
    • Je mehr Punkte du zeichnen lässt, desto mehr wird das Bild dem Sierpinski-Dreieck ähnlich werden.

Bravo und Glückwunsch!

In dieser Übung wirst du lernen, wie man die Möglichkeiten von Zeichnen in der Programmierumgebung des TI-Nspire™ CX II-T nützt.

Lernziele:

• Zeichnen (Draw) einiger Formen
• Umgehen mit dem Zeichenschirm
• Ein Programm mit Zeichnen-Befehlen starten und beenden
• Ändern der Zeichenfarbe

Zeichnen einer Geraden

1. Beginn ein neues Dokument und öffne den Programmeditor. Gib dem Programm den Namen formen.
2. Drück [menu] und wähl Zeichnen > Formen. Hier siehst du die verfügbaren Formen (in englischer Sprache).
3. Wähl DrawLine.

4. Du musst die Endpunkte der Geraden, (x1, y1) und (x2, y2), angeben.
5. Das Eingabeformat des Befehls ist:
   DrawLine x1, y1, x2, y2
6. Beginn mit den folgenden Werten:
   DrawLine 10, 20, 100, 120

Beachte: Die Zeichnen-Befehle benötigen keine Klammern. Ihre Benützung führt zu einer Fehlermeldung.

7. Drück [ctrl] [R] um das Programm aufzurufen, und drück dann [enter] in der Calculator App, um es auszuführen.

Nun siehst du einen Schirm wie rechts abgebildet. Das ist ein eigenes „Zeichenfenster” zur Ausgabe von Zeichnen-Befehlen. (10,20) ist der linke obere Endpunkt der Geraden und (100,120) der rechte untere. Die Titelleiste zeigt mit „Fertig” an, dass das Programm beendet wurde. Der Rechner zeigt die Zeichnung weiterhin an. Drück eine beliebige Taste, um das Zeichenfenster zu schließen und zur Calculator App zu-rückzukehren.

Zeichnen eines Rechtecks

8. Geh zum Programmeditor zurück und füg unter dem DrawLine-Befehl eine Programmzeile für das Zeichnen eines Rechtecks hinzu; wähl dazu die Anweisung DrawRect über menu > Zeichnen > Formen
   DrawRect 10,20,100,120
   Nimm die gleichen Werte, die du für den DrawLine-Befehl verwendet hast.

Kannst du dir vorstellen, was geschehen wird?

9. Drück [ctrl] [R] und starte das Programm nochmals. Warum reicht die Gerade nicht bis in die untere rechte Ecke des Rechtecks?
   
   Der DrawRect-Befehl hat das Eingabeformat:
   DrawRect x, y, Breite, Höhe
   
   Welche Breite und Höhe müsste das Rechteck haben, dass die Gerade zur Diagonalen des Rechtecks wird?

Sicherlich wirst du jetzt die Abmessungen des Schirms wissen wollen? Versuch vorher, mit einer Geraden eine Diagonale des Schirms zu zeichnen.

Die Abmessungen des Bildschirms

• Die Zeichenfläche hat die Abmessungen 318 x 212 (Pixel = Bildpunkte).
• Die linke obere Ecke des Zeichenfensters hat die Koordinaten (0,0).
• Die rechte untere Ecke hat die Koordinaten (317,211).

10. Der Befehl DrawLine 0, 0, 317, 211 zeichnet eine Bildschirmdiagonale.

11. Schreib den Befehl zum Zeichnen der anderen Diagonale.

Weitere Formen

DrawCircle x, y, r zeichnet einen Kreis mit dem Mittelpunkt in (x,y) und dem Radius r.

Beispiel:

12. DrawCircle 159, 106, 50
    FillRect und FillCircle sind ähnlich; sie füllen die Formen mit der aktuellen Farbe.

Ändern der Zeichenfarbe

1. Füg im Programmeditor zwischen zwei Zeilen den SetColor-Befehl ein:
   menu > Zeichnen > Steuern > SetColor

R, G, B

Die Zeichenfarbe wird durch drei Werte festgelegt: die Anteile von Rot, Grün und Blau werden gemischt. Jeder dieser Werte muss im Bereich zwischen 0 und 255 liegen.

SetColor Rotwert, Grünwert, Blauwert

Beispiel:

SetColor 128, 191, 30

14. Setz den SetColor-Befehl vor das Zeichnen des Objekts.
15. Versuch, ein Programm zu schreiben, das 100 zufällige Kreise in verschiedenen Farben zeichnen lässt. Verwende dazu eine For-EndFor-Schleife.

Wenn du die Kreislinie und die Kreisfläche in unterschiedlichen Farben zeichnen willst, dann musst du zwei Befehle verwenden:

Setcolor 255, 0, 0	Farbe Rot
FillCircle 100, 100, 50	die Kreisfläche
SetColor 0, 0, 0	Farbe Schwarz
DrawCircle 100, 100, 50	die Kreislinie

… Das zeichnet einen schwarzen Kreis, der rot gefüllt ist. Aber, wenn du zuerst den Kreis zeichnest (draw) und nachher füllst (fill), wirst du den schwarzen Kreis nicht sehen, da er von der roten Fläche überdeckt wird. Versuch das!

In dieser Übung wirst du das Zeichenfenster ändern und untersuchen, wie sich das auf die Zeichnen-Befehle auswirkt. Außerdem wirst du SetPen und DrawArc kennenlernen.

Lernziele:

• Ändern der Einstellungen des Zeichenfensters
• Ändern des Zeichenstifts
• Zeichnen von Bögen und Ellipsen; erkennen des Zusammenhangs zwischen Bögen und Rechtecken

Der voreingestellte Zeichenschirm ist ungewohnt: die linke obere Ecke ist (0,0) und die y-Werte (senkrechte Koordinaten) steigen, wenn man am Schirm nach unten geht. Das ist wie ein auf den Kopf gestellter 1. Quadrant. Die meisten grafischen Programmierumgebungen verhalten sich so. Die SetWindow-Anweisung erlaubt uns, mit besser gewohnten Koordinaten zu arbeiten; das hat aber einen Einfluss auf das Zeichnen der Formen.

Fenstereinstellungen

1. Beginn mit einem neuen Programm und nenn es fenster.
2. Zeichne eine Diagonale auf den Schirm als Bezugsgröße:
   DrawLine 0, 0, 317, 211
3. Starte das Programm (drück [ctrl] [R], dann [enter]) und überzeug dich, ob du es richtig gemacht hast. Du solltest eine Gerade sehen, die von der linken oberen in die rechte untere Ecke des Zeichenfensters verläuft.

4. Setz hinter die DrawLine-Anweisung eine SetWindow-Anweisung. Du findest sie über menu > Zeichnen > Steuerung > SetWindow.

5. Um einen Zeichenschirm zu erzeugen, der dem Standardschirm der Graphs App entspricht, schreib nun
   SetWindow -10, 10, -6.667, 6.667
   Wenn du das Programm startest, wirst du vorerst keine Änderung erkennen. Die Diagonale wird wieder von links oben nach rechts unten verlaufen.
   
   Die Syntax (das Eingabeformat) für SetWindow ist:
   SetWindow xmin, xmax, ymin, ymax

Auswirkung auf die Zeichnung

6. Zeichne nach dem SetWindow-Befehl ein Rechteck mit einer Ecke in (0,0) mit der Breite 3 und der Höhe 2:
   DrawRect 0, 0, 3, 2
   Starte das Programm nochmals. Siehst du das Rechteck nahe der Schirm-mitte? Der Ursprung (0,0) liegt nun im Zentrum des Fensters und x- und y-Koordinaten verhalten sich wie im gewohnten Graphs-Fenster. Die Breite des Rechtecks wird nach rechts und die Höhe nach oben gemessen. Eine Längeneinheit entspricht ungefähr der Graphs-Einheit. Die ursprüngliche Dia-gonale verbleibt am Schirm. Die SetWindow-Anweisung wirkt sich nicht auf früher gezeichnete Objekte aus.

Ändern des Zeichenstifts

7. Mit dem SetPen-Befehl kannst du Dicke und Stil der mit Zeichnen-Anweisungen erzeugten Linien ändern.
   Die Syntax ist:
   SetPen Dicke, Stil
   Beispiel: setz vor die DrawRect-Anweisung
   SetPen 3, 3
   Dicke and Stil können Werte von 1 bis 3 annehmen.
   Probier alle Möglichkeiten aus!

Zeichnen eines Bogens

8. DrawArc ist ähnlich wie DrawRect. Den weiteren Nutzen sehen wir gleich.
9. Setz in einem neuen Programm die Fensterwerte auf -10, 10, -7, 7 und zeichne das Rechteck mit der Ecke in (-2,-2) mit Breite = Höhe = 4:
   SetWindow -10, 10, -7, 7
   DrawRect -2, -2, 4, 4
   Das Programm sollte ein Quadrat in der Mitte des Schirms erzeugen.

10. Ändere die Zeichenfarbe auf Rot mit SetColor 255,0,0.
11. Wähl DrawArc über menu > Zeichnen > Formen. Nimm die gleichen Werte wie in DrawRect und füg für den Bogen zwei weitere Parameter hinzu: den Anfangswinkel und den Bogenwinkel:
    DrawArc -2, -2, 4, 4, 0, 90
12. Das Programm erzeugt einen 90° Kreisbogen gegen den Uhrzeigersinn.
    Der Bogen ist dem Rechteck eingeschrieben und läuft von 0° (Ost) bis 90° (Nord). Lösch oder versteck das Rechteck (mach es mit © zu einem Kommentar). Ändere die Gestalt des Bogens, indem du Breite, Höhe, Anfangs- und Bogenwinkel variierst. Im Falle einer Fehlermeldung, musst du die Werte entsprechend ändern.

Zeichne ein Gesicht

Im vorigen Beispiel hast du mit gleichen Werten für Breite und Höhe einen Kreisbogen gezeichnet. Mit verschiedenen Werten lassen sich auch elliptische Bögen erzeugen.

13. Versuch diesen Code, der das „Smile” – wie rechts abgebildet – zeichnet. Kannst du zwei Augen und die Nase hinzufügen?
    SetWindow −10, 10, −7, 7
    © DrawRect −2,−2,4,4 ← das ist ein Kommentar und wird ignoriert.
    SetColor 255, 0, 0
    SetPen 3, 1
    DrawArc −2, −2, 4, 2, −180, 180

Um eine Codezeile in einen Kommentar zu verwandeln, setz die Schreibmarke an den Zeilenanfang und wähl menu > Aktionen > Kommentar einfügen. Das ©-Symbol wird eingefügt und die Zeile wird beim Programmlauf übersprungen. Damit kannst du den Code ohne Durchführung für eine mögliche spätere Verwendung bewahren.

In dieser Übung wirst du ein Programm schreiben, um einen Punkt zu zeichnen, diesen automatisch zu bewegen und dabei seine Koordinaten anzuzeigen. Mit [esc] wird das Programm abgebrochen.

Lernziele:

• Zeichnen eines Punkts
• Diesen Punkt automatisch bewegen
• Anzeigen seiner Koordinaten
• Mit getKey(0) auf einen Tastendruck warten

Zeichnen von Punkten

Bis jetzt hast du Formen (Gerade, Rechteck, Kreis, Bogen) gezeichnet. Es gibt ein weiteres Werkzeug: PlotXY lässt dich einen Punkt mit seinen Koordinaten (x,y) setzen.

Die Syntax dieser Anweisung ist: PlotXY x, y, Stil

x, y sind die Koordinaten des Punkts auf Basis der aktuellen Fenstereinstellung.

Stil ist ein Wert von 1 bis 13 und bestimmt Größe/Form des Punkts. Er ist anzugeben.

Zeichnen eines Punkts

1. Beginn ein neues Programm und nenn es anim_pkt.
2. Stell angenehme Fensterwerte ein: SetWindow -15, 15, -10, 10
3. Beginn mit dem Zeichnen eines Punkts in den Koordinatenursprung:
   x:=0
   y:=0
   PlotXY x, y, 1

PlotXY (zu finden über menu > Zeichnen > Formen) zeichnet (x,y) im Stil 1. Wir verwenden die Variablen x und y, da sie im Programm geändert werden, um den Punkt zu bewegen. Probier einige andere Stile (1 -13 für den dritten Parameter).

Die Hauptschleife

Wir werden die getkey(0)-Anweisung (menu > I/O) zur Abfrage der [esc] Taste für den Programmabbruch verwenden:

4. Füg hinter die PlotXY-Anweisung ein:

k:=” ”(nichts zwischen den Anführungszeichen)

While k≠”esc”

(Schleifenkörper)

k:=getKey(0)

EndWhile

Bewegen des Punkts

Die Schleife wird den Punkt durch Veränderung der x-Koordinate sich scheinbar bewegen lassen. Doch vorerst muss er von seiner aktuellen Stelle entfernt werden. Wir „löschen“ ihn, indem wir ihn in der Hintergrundfarbe (weiß) zeichnen …

5. Schreib in den Schleifenkörper zwischen While and getKey(0):
   

   SetColor 255,255,255	Farbe weiß
   PlotXY x, y, 1	lösche aktuellen Punkt
   x:=x+1	erhöhe x um 1
   SetColor 0, 0, 0	Farbe schwarz
   PlotXY x, y, 1	zeichne den nächsten Punkt
   Wait 0.5	warte eine halbe Sekunde

Wait findet sich über menu > Steuerung und erteilt dem Rechner den Auftrag, den Prozess für diese Anzahl von Sekunden zu unterbrechen.

Führ das Programm aus und du wirst den Punkt nach rechts wandern sehen. Er wird dann vom Schirm verschwinden.

Drück [esc], um das Programm zu beenden und verbessre es so, dass der Punkt innerhalb der Zeichengrenzen bleibt:

6. Füg nach x := x + 1 die folgenden Anweisungen ein:
   

   if x > 15	rechten Schirmrand erreicht?
   x := -15	dann kehr zurück an den linken Rand

   Herausforderung: Kannst du den Punkt umkehren lassen, so dass er sich nach Erreichen des rechten Rands wieder nach links bewegt – und dann wieder nach rechts …?

Anzeigen der Koordinaten

Während der Anzeige des Zeichenschirms sind E/A-Anweisungen wie Disp und Request nicht verfügbar. Um Text im Zeichenfenster auszugeben müssen wir die Anweisung DrawText (über menu > Zeichnen > DrawText) verwenden.

Syntax:     DrawText Objekt1, Objekt2, Objekt3, …

Objekt sind: Zeichenketten wie “Hello, world!”
     Zahlen
     Variable
     Ausdrücke

Beispiel (ohne Programmierung): Gib im Calculator ein:
     drawtext 30, 50, “Der Wert von x ist “, x
     (Dein Wert für x ist möglicherweise ein anderer!)

7. Aber zurück zu unserem Programm. Füg einige Anweisungen zur Anzeige der Koordinaten des bewegten Punkts vor der Wait-Anweisung ein.
   

   SetColor 0, 0, 0	Farbe schwarz
   DrawText -15, -10, “(“, x,” ,”, y, ”)”	zeige (x,y)

Führ das Programm aus und beobachte, wie die Koordinaten in der linken unteren Ecke der Zeichenfläche angezeigt werden. Leider werden die Werte jeweils über die vorhergehenden geschrieben und damit unleserlich!

12. Aktiviere jetzt den Schieberegler, um mehr Würfe zu simulieren.
    • Wenn k größere Werte annimmt, dann musst du die Fenstereinstellungen anpassen. Wähle dazu menu> Fenster/Zoom> Zoom-Daten.

Welche Summe tritt am häufigsten auf? Welche am seltensten? Warum?

Schreib ein Programm, das ein Objekt mit Hilfe der Pfeil-tasten am Schirm bewegen lässt (interaktive Animation). Das ist die Grundlage vieler Videospiele.

Lernziele:

• Tastatureingaben mit getKey(1) auswerten
• Ändern von Koordinaten abhängig von Eingaben über die Tastatur
• Löschen und Neuzeichnen einer Form

In der vorigen Übung hast du einen Punkt automatisch über den Bildschirm bewegen lassen und mit getKey(0) das Pro-gramm beendet. Jetzt wirst du ein Programm schreiben, mit dem der Benützer den Punkt (oder eine andere Form) mit den Pfeiltasten bewegt. Dazu wirst du getKey(1) verwenden; es hält den Prozess an und wartet auf die nächste Tastatur-eingabe. Nur die Pfeiltasten („hoch“, „tief“, „rechts“, „links“) und die [esc]-Taste sind dafür wichtig.

Der Beginn: Zeichnen des Punkts

1. Beginn ein neues Programm anim_pkt2.
2. SetWindow NICHT VERWENDEN!
   Das voreingestellte Zeichenfenster ist (0...317) x (0...211).
3. Der Startpunkt liegt nahe beim Zentrum des Schirms (159,106):
   x := 159
   y := 106
   PlotXY x, y, 1

Die Hauptschleife

4. Die Hauptschleife läuft bis die [esc]-Taste gedrückt wird
   

   k := getKey(1)	warten auf Tastendruck (beginnen)
   While k ≠ “esc”	so lange bis [esc]
   Schleifenkörper
   k := getKey(1)	warten auf Tastendruck (fortsetzen)
   EndWhile EndPrgm

Die Pfeiltasten

5. Die vier Pfeiltasten heißen ”up”, ”down”, ”left” und ”right”. Mit k übernehmen wir die eingegebene Richtung und ändern entsprechend x oder y:
   If k = “left”
   x := x – 1 (1 ist angenommen; könnte größer sein)
   Erinnre dich, das ist die einfachste Form der If-Anweisung (weder Then noch Else). Ergänz die drei anderen If-Anweisungen für die restlichen Pfeiltasten.

Neuzeichnen des Punkts

6. Zeichne den Punkt nach den vier If-Anweisungen mit den neuen Koordinaten.
   PlotXY x, y, 1

Programmtest

Verwend die Pfeiltasten und beende das Programm mit [esc]. Wenn alles richtig ist, bewegt sich der Punkt … und hinterlässt eine Spur.

Was geschieht, wenn der Punkt den Schirmrand erreicht? Jetzt verlässt er den Zeichenbereich. Nun gibt es mehrere Möglichkeiten: einfach stehen bleiben und nicht weiter gehen, irgendwohin gehen oder wie üblich, auf die entgegengesetzte Seite des Schirms wechseln. Das wird auch als Rundum- oder Toral-Methode bezeichnet.

Projektabschluss

In Übung 3 hast du gelernt, wie man einen Punkt „ausradiert“. Ergänz das Pro-gramm so, dass sich der Punkt nur scheinbar bewegt.

Ergänz den Code um vier If-Anweisungen, um das Randproblem zu lösen:
If x > 317
x:= ?

Kannst du eine ganze Gruppe von Formen bewegen?

Bis jetzt haben wir nur einen Punkt manuell bewegt. Überleg, den Punkt durch einige Formen zu ersetzen. Eine wirksame Möglichkeit ist es, dafür ein eigenes Programm (ein Unterprogramm) zu schreiben. Schreib im aktuellen Problem ein neues Programm – formzeich(x,y) – und verwend dann in anim_pkt2 die Anweisung

formzeich(x, y) anstelle von PlotXY x,y,1M.

Rechts kannst du ein Beispiel sehen.

Zeichne in formzeich(x, y) einige Formen und verwend (x,y) als Bezugspunkt. Dein Objekt kann aus mehreren Teilen in unterschiedlichen Farben bestehen.

Überleg, die Clear-Anweisung (menu > Draw > Clear) zum Löschen der Figuren einzusetzen. Clear ohne Argumente leert den Schirm. Um nur einen rechteckigen Teil zu löschen, nimm:

Clear x, y, Breite, Höhe (ähnlich wie DrawRect)

Viel Spaß dabei!