TI Codes: TI-Nspire™ Technologie

In deze eerste les van Unit 1, leer je over de TI-Nspire™ CX Basic Programma-editor en hoe je jouw eerste programma schrijft, opslaat en uitvoert.

Doelen:

• De programma-editor starten vanuit de toepassing Rekenmachine
• Je eerste programma schrijven
• Een programma opslaan en uitvoeren

Introductie van de programma-editor

Start met een nieuw document en voeg de toepassing Rekenmachine (calculator) toe.

Start in de toepassing Rekenmachine een nieuw programma door het volgende te selecteren:

Menu > Functies & Programma’s> Programma- editor> Nieuw…

In het veld Naam: typ de naam van je eerste programma, hallo, en kies [enter].

Laat het type staan op Programma en bibliotheek toegang (Library Access) op Geen (None). We bespreken type en bibliotheek in een van de volgende lessen

Jouw scherm zou er nu zo uit moeten zien als het scherm hiernaast. Aan de linkerkant staat de toepassing Rekenmachine en aan de rechterkant de programma-editor. Je bewerkt het programma in de programma-editor en voert het uit in de Rekenmachine. Hierdoor kun je het programma eenvoudig testen terwijl je het schrijft.

Op de rekenmachine kun je op ctrl-tab drukken om heen en weer te schakelen tussen de panelen. Een toepassing is geselecteerd wanner de rand donker is.

De programma-code hoort binnen het blok Prgm … EndPrgm in de editor. Selecteer menu > I/O > Disp terwijl de tekst-cursor binnen het gestippelde blok staat.

Typ het format met de dubbele aanhalingstekens “ “ (voor een letterlijke tekst) in door te drukken op ctrl en vervolgens op de vermenigvuldigtoets en typ daarna binnen de aanhalingstekens de tekst hallo, wereld!.

Voordat je een bewerkt programma kunt uitvoeren, moet je het programma eerst ‘opslaan’ in het geheugen. Om een programma op te slaan kies je: menu> Syntax controleren en opslaan > Syntax controleren en opslaan (of je gebruikt de sneltoetscombinatie ctrl-B op de rekenmachine.)

Om het programma uit te voeren schakel je om naar de toepassing Rekenmachine en typ je de naam van het programma in op de onderste (edit) regel gevolgd door een linkerhaakje en selecteer je vervolgens [enter]. Als alles correct is gedaan dan toont je programma de tekst ‘hallo, wereld!’ als het resultaat van de uitvoering van het programma.

Bewaar het document onder de naam hallo_programma.

Gefeliciteerd! Je hebt het eerste TI-Nspire™ CX Basic programma geschreven!

In deze tweede les van Unit 1, leer je over het verzenden van argumenten naar programma’s en over het weergeven van de resultaten van uitdrukkingen.

Doelen:

• Argumenten gebruiken in een programma
• Uitdrukkingen gebruiken in Disp-opdrachten

Waarom zijn er haakjes nodig in een programma?

De haakjes achter de naam van een programma zijn altijd nodig en zorgen ervoor dat een programma ‘argumenten’ (parameters) accepteert. Er zijn twee soorten argumenten: de formele argumenten die altijd bestaan uit variabelen en de ‘werkelijke’ variabelen die bestaan uit waarden, variabelen of uitdrukkingen die een waarde produceren.

Laten we een programma schrijven dat de schuine zijde in een rechthoekige driehoek berekent.

Voeg eerst de toepassing Rekenmachine toe aan een nieuwe pagina en start met een nieuw programma door het volgende te selecteren:
Menu > Functies en Programma’s > Programma-editor > Nieuw

Noem het programma Schuinezijde en kies [enter]
Typ binnen de haakjes achter de programmanaam de formele argumenten a,b en plaats dan de cursor binnen het gestippelde vak..

Het programma

In dit programma gebruiken we één opdracht om de waarde van de schuine zijde van een rechthoekige driehoek weer te geven, waarvan de lengtes van de rechthoekszijden als argumenten aan het programma worden doorgegeven.

Disp √(a^2 + b^2)

Kies, zodra de programmacode is ingevoerd, ‘controleer de syntax en bewaar’ door menu > Syntax controleren en opslaan > Syntax controleren en opslaan te selecteren (of gebruik de sneltoetscombinatie ctrl-B op de rekenmachine.)<./p>

Het programma uitvoeren

Schakel nu over naar de toepassing Rekenmachine en typ de naam van het programma, een linkerhaakje en twee waarden gescheiden door een komma (binnen de aangeboden haakjes) en kies [enter]. Zorg ervoor dat je waarden gebruikt waarvoor je het antwoord weet om te testen of het programma goed werkt!

Je kunt ook uitdrukkingen invoeren in plaats van getallen, bijvoorbeeld:

Schuinezijde (2*7, 9-5)

Sla je document op om het programma te bewaren.

In deze derde les van Unit 1 leer je het belangrijkste verschil tussen een programma en een functie.

Doelen:

• Een programma en een functie schrijven die hetzelfde lijken te doen.
• De verschillen tussen een programma en een functie verkennen.

Wat is een functie?

In TI-Nspire™ CX is het doel van een functie om een waarde terug te geven. In het plaatje rechts voeren het programma schuinezijde en de functie schuin dezelfde opdracht uit. Let op het gebruik van de opdracht Return in de functie. Merk ook op dat de uitvoer van de functie in de toepassing Rekenmachine op dezelfde regel wordt weergegeven als de functienaam en niet op een aparte regel zoals in het programma. De functie ‘vertegenwoordigt’ een waarde die gebruikt kan worden voor andere bewerkingen, zelfs voor het tekenen van grafieken!

Een functie creëren

Selecteer in de toepassing Rekenmachine menu > Programma-editor toevoegen > Nieuw…

Geef de functie de naam schuin en verander het Type in Functie in plaats van in Programma. Kies [enter] om het nieuwe programma te maken.

Donec id elit non mi porta gravida at eget metus.

Cras mattis consectetur purus sit:

• Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.
• Lorem ipsum dolor sit amet, consectetur adipiscing elit.
• Morbi leo risus, porta ac consectetur ac, vestibulum at eros.

Donec id elit non mi porta gravida at eget metus.

Cras mattis consectetur purus sit:

• Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.
• Lorem ipsum dolor sit amet, consectetur adipiscing elit.
• Morbi leo risus, porta ac consectetur ac, vestibulum at eros.

Donec id elit non mi porta gravida at eget metus.

Cras mattis consectetur purus sit:

• Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.
• Lorem ipsum dolor sit amet, consectetur adipiscing elit.
• Morbi leo risus, porta ac consectetur ac, vestibulum at eros.

In deze toepassing van Unit 1 ontdek je de flexibiliteit van de opdracht Disp en ontwikkel je je eigen programma. Je moet de oefenbladen van Unit 1 volledig hebben doorgewerkt voor je met deze activiteit begint.

Doelen:

• Disp-opdrachten verfraaien om betekenisvolle informatie te produceren met behulp van letterlijke teksten (strings)
• Je eigen formule-programma schrijven

De opdracht Disp kan meer dan een onderdeel tegelijk weergeven op het scherm.

Bestudeer het scherm aan de rechterkant waarin het programma ‘schuinezijde’ is aangepast. Het programma ‘herhaalt’ de argumenten a en b met passende labels en geeft dan de berekende lengte van de schuine zijde weer, ook met een passend label.

De onderdelen tussen de aanhalingstekens worden ‘letterlijke teksten’ (literal strings) genoemd. Een ‘string’ is een reeks aaneengeregen tekens.

Wanneer je je programma bewerkt vergeet dan niet om de syntax te controleren en het op te slaan door menu > Syntax controleren en opslaan > Syntax controleren en opslaan te selecteren (of de sneltoetscombinatie ctrl-B op de rekenmachine te gebruiken) voor het programma uit te voeren.

Denk eraan om de komma te gebruiken als scheidingsteken tussen de onderdelen die weergegeven moeten worden op het scherm. Er moet een komma staan tussen de tekst binnen de aanhalingstekens en de waarden a, b en de uitdrukking

Schrijf een programma dat een of meer argumenten nodig heeft en vervolgens het resultaat van een berekening gebaseerd op die argumenten weergeeft.

De berekening kan elke willekeurige formule zijn. Hier zie je en aantal suggesties:

Het programma moet de uitvoer duidelijk beschrijven (van een label voorzien).

In deze eerste les van Unit 2, gebruik je variabelen in een programma en ontdek je het effect ervan in het document.

Doelen:

• Een variabele gebruiken in een programma
• De invloed leren kennen die het creëren van een variabele in een programma heeft op de rest van het document
• Verkennen wat de ‘speelruimte’ is van argumenten in een programma

Een waarde opslaan in een variabele

Soms is het nodig om een waarde toe te kennen aan een variabele binnen je programma. In ons voorbeeld gebruiken we de formule van Heron voor het berekenen van de oppervlakte van een driehoek op basis van de lengtes van de drie zijden. Dit is in een formule in twee stappen:

Bepaal eerst de halve omtrek: s=1/2(a+b+c)
En dan de oppervlakte: A=(s*(s-a)*(s-b)*(s-c))^0,5

De programma-regels staan in de schermafbeelding rechts.

Merk op dat het symbool [ := ], en niet alleen een =-teken, is gebruikt om de waarde van een berekening toe te kennen aan een variabele.

[:=] betekent “krijgt (‘gets’) de waarde van …” of, eenvoudiger, “krijgt”, dus de opdracht

s:=1/2*(a+b+c) wordt gelezen als “s krijgt de halve (1/2) omtrek van de driehoek”

Op de TI-Nspire™ vind je deze combinatie van symbolen [:=] boven de ‘template’-toets [ ]. Op een computer of op de rekenmachine kun je ook de twee tekens [:=] apart typen. Op de rekenmachine vind je de dubbele punt op de ‘interpunctietoets’ rechts van de letter G en het =-teken meteen onder [ctrl]-toets, dus op de rekenmachine is het eenvoudiger om gewoon [ ] te typen.

De operator ‘opslaan’ (store) gebruiken

Je kunt de operator opslaan (→) gebruiken in plaats van krijgt [:=].

Bekijk de programmaregels rechts. Merk op dat de opdrachten in de omgekeerde volgorde staan, waarbij eerst de berekening komt en dan de operator ‘store’ (ctrl-var) en dan de variabele. Dit is de volgorde waarin de opdrachten worden uitgevoerd (van links naar rechts).

Ofwel de operator ‘krijgt’ [:=] of wel de operator ‘opslaan’ (→) kan worden gebruikt in elke toekenningsopdracht. Onthoud alleen wel wat de volgorde in de opdracht is voor elke methode.

Beide methodes kennen een waarde (meestal het resultaat van een berekening) toe aan een variabele en daarom worden dit toekenningsopdrachten genoemd.

Laten we nu het volledige programma heron(a,b,c) zoals dat te zien is in de schermafbeelding invoeren.

Als het programma is ingevoerd controleer dan de syntax en sla het programma op door menu > Syntax controleren en opslaan > Syntax controleren en opslaan te selecteren (of de sneltoetscombinatie ctrl-B op de rekenmachine te gebruiken.)

Test het programma met de bekende waarden 3, 4, 5 om je ervan te verzekeren dat je het resultaat 6 krijgt voor de oppervlakte (waarom is die 6?)

Selecteer vervolgens in de toepassing Rekenmachine (Calculator) de var-toets en let op de lijst met variabelen. De variabelen heron en s verschijnen in de lijst. heron is de naam van het programma en s is gecreëerd door het programma. Maar a, b, en c zijn ook gebruikt in het programma. Waar zijn zij?

Het antwoord zit in het feit dat a, b, & c argumenten (parameters) zijn voor het programma en, als argumenten, alleen binnen het programma bestaan en niet gecreëerd zijn in het document. In feite willen we eigenlijk de variabele s ook niet in het document hebben! In de volgende les zullen we leren hoe we dit ‘bij-effect’ kunnen verhelpen.

Vergeet niet om het document op te slaan zodat je het programma opslaat! We gaan dit programma gebruiken in de volgende les.

In deze tweede les van Unit 2 leer je over het ‘declareren’ van lokale variabelen in een programma

Doelen:

• De noodzaak van lokale variabelen begrijpen
• Lokale variabelen gebruiken in programma's

Begin met het openen van het document dat het programma heron bevat, dat je in oefenblad 1 schreef, zoals je kunt zien in het plaatje rechts.

Bedenk dat het probleem in dit programma is dat het onbedoeld de variabele s creëert in het document. Dit is onwenselijk en we zullen nu leren hoe we dit probleem kunnen voorkomen.

Voeg onder het sleutelwoord Prgm de volgende opdracht toe:

Local s     je kunt Local vinden in menu > Variabelen definiëren

Wanneer deze opdracht is ingevoerd check dan de syntax en slag het programma op door menu > Syntax controleren en opslaan > Syntax controleren en opslaan te selecteren (of door de sneltoetscombinatie ctrl-B op de rekenmachine te gebruiken.)

Gebruik in de toepassing Rekenmachine de opdracht DelVar s om de variabele s te verwijderen.

(Variabele wissen is te vinden in menu > Acties.)

Voer het programma heron uit.

Druk op var en merk op dat de enige variabele het programma heron zelf is.

Wat is er gebeurd?

Wanneer je ‘declareert’ (of stelt) dat een variabele ‘Local’ is, vertelt dit de TI-Nspire™ CX om de variabele te creëren terwijl het programma wordt uitgevoerd en de variabele te verwijderen wanneer het programma eindigt, zodat de variabele nergens in de huidige opgave meer bestaat. Dit neemt het probleem weg dat de variabele s wordt gecreëerd in de opgave en daar blijft. Ook is het zo, dat als de opgave deze variabele al gebruikt, het Local maken van de variabele binnen het programma de waarde van de variabele niet verandert omdat in plats daarvan het programma zijn eigen (tijdelijke) variabele maakt,

Samenvatting

De ‘speelveld’ van een variabele is de plaats waar de variabele bestaat. In de TI-Nspire™ CX, ‘leven’ variabelen in de actuele TNS opgave. Het toevoegen van een opgave aan een document geeft je een ‘schone lei’ voor de variabelen. Opgave 2 in een document weet niets van de variabelen in opgave 1 en omgekeerd.

Als programma’s in dezelfde opgave dezelfde variabelen gebruiken dan kan dat onbedoeld of bedoeld variabelen creëren of gebruiken in de actuele opgave. Soms kan het logisch zijn om de programmavariabelen en de variabelen in de opgave aan elkaar te verbinden, maar houd dat in gaten wanneer je programma’s schrijft.

Het declareren van variabelen als Local voorkomt dat het programma deze variabelen in de opgave creëert of beïnvloedt.

Functies, aan de andere kant, gaan op een andere manier om met het principe ‘speelveld’ zoals we zullen zien in de volgende les. Blijf erbij!

In deze derde les van Unit 2 leer je over de invloed van functies op globale variabelen.

Doelen:

• De invloed van een functie op globale variabelen vergelijken met die van programma’s
• Programmacode kopiëren en plakken van het ene programma naar het andere of binnen hetzelfde programma

We beginnen deze les met het document dat het programma heron bevat wat je hier rechts ziet.

Voeg nog een Rekenmachine-toepassing toe aan het document en creëer dan een nieuw programma. Verander het Type in Functie.

Voeg de argumenten a, b, c toe binnen de haakjes en kopieer de twee toekenningsopdrachten van het programma naar de functie.

Om te kopiëren en plakken op de rekenmachine, doe je het volgende:

• Houd de SHIFT-toets ingedrukt terwijl je de tekstcursor over de gewenste tekst beweegt.
• Druk op ctrl-C om de tekst naar het klembord te kopiëren.
• Schakel over naar de functie en plaats de cursor op de gewenste positie
• Druk op ctrl-V om te plakken

Om het programma op te slaan selecteer menu > Syntax controleren en opslaan > > Syntax controleren en opslaan (of gebruik je de sneltoetscombinatie ctrl-B op de rekenmachine.)

Schakel over naar de toepassing Rekenmachine en voer de functie uit.

Zie je de foutmelding?

Wat is er mis?

De variabele s is een globale variabele omdat deze niet lokaal is ‘gedeclareerd’. Dit is niet toegestaan in een functie, hoewel het dat wel is in een programma. Herinner je dat het doel van een functie is om een waarde terug te geven. Om globale variabelen te beschermen tegen onbedoelde veranderingen (de ‘neveneffecten’) verhindert het besturingssysteem dat functies globale variabelen veranderen.

De oplossing: voeg de opdracht Local s toe aan het begin van de functie, sla het programma op met menu > Syntax controleren en opslaan > > Syntax controleren en opslaan (or door de sneltoetscombinatie ctrl-B op de rekenmachine te gebruiken) en test vervolgens de functie. Voila!

In deze toepassing van Unit 2, ga je een programma schrijven dat enkele eenvoudige toekenningsopdrachten en wat rekenwerk gebruikt om een ‘magisch’ programma uit te voeren. De oefenbladen van Unit 2 moeten zijn doorgewerkt voor je aan deze activiteit begint.

Doelen:

• Een programma schrijven vanuit gegeven instructies
• De toekenningsopdracht gebruiken
• Het raadsel binnen een programma ontdekken

Programmaraadsel

Schrijf een programma dat twee argumenten a en b heeft en vervolgens:

• a bij b optelt en het resultaat opslaat b
• a van b aftrekt en het resultaat opslaat in a
• a van b aftrekt en het resultaat opslaat in b
• a en b op het scherm weergeeft

Sla je programma op en test het. Wat is het effect? Werk het met elke twee getallen?

Op het eerste gezicht lijkt het alsof dezelfde waarde (via de aftrekinstructies) wordt opgeslagen in a en b, maar… is dat wel zo?

In deze eerste les van Unit 3, leer je hoe je met Request input van de gebruiker kunt vragen terwijl het programma wordt uitgevoerd. Verder leer je over tekenreeksen (strings) en de meest basale voorwaardelijke opdracht: If

Doelen:

• Request en RequestStr gebruiken voor input
• String-variabelen en aaneenschakeling onderzoeken
• Opdrachten schrijven met If en voorwaarden

Invoer (input) overzicht

Tot nu toe hebben we alleen waarden kunnen geven aan een programma of functie om ermee te werken door argumenten te gebruiken. Er zijn in de TI-Nspire™ CX twee vergelijkbare opdrachten die het mogelijk maken om waarden in te voeren in een programma terwijl het wordt uitgevoerd. Deze opdrachten staan bekend als invoer(input)- opdrachten:

1. Request “bericht”, variabele (voor numerieke invoer)
   
   en
   
   
2. RequestStr “bericht”, variabele (voor string(tekst)-invoer)

Deze opdrachten vind je in het menu I/O van de programma-editor.

Typen variabelen en hun invoer

• Een numerieke variabele kan een reëel of complex getal, lijst of matrix bevatten. De variabele kan worden gebruikt in algebraïsche uitdrukkingen en de waarde ervan wordt gebruikt tijdens de berekening van de uitdrukkingen.
• Een string-variabele (tekenreeks) kan elke willekeurige tekst bevatten bestaande uit letters, cijfers en de meeste interpunctietekens. De variabele kan niet worden gebruikt in algebraïsche uitdrukkingen. Merk op dat cijfers wel mogen worden gebruikt in de tekenreeksen (strings).
• Het “bericht” wordt ook wel de ‘prompt’ genoemd. Het beschrijft voor de gebruiker wat er moet worden ingevoerd tijdens de uitvoering van de opdracht.
• De variabele kan elke willekeurige letter of woord zijn als dit tenminste niet is gereserveerd. Je herkent een gereserveerd woord als je ziet dat de stijl verandert van cursief in normaal terwijl je typt.

Aaneenschakeling van tekenreeksen (strings)

Twee tekenreeksen (variabelen of letterlijke teksten of een combinatie) kunnen worden gecombineerd tot een langere reeks (aaneenschakeling) met behulp van de bewerking ‘&’. Dit teken bevindt zich in het menu met tekens, ctrl-.

Voorbeeld:

vnaam:=”Jan”
anaam:=”Jansen”
volledig:=vnaam & ” “ & anaam

Dit geeft als resultaat dat de variabele volledig de tekenreeks “Jan Jansen” beva

Het progrmma rechts (in het Engels) bevat geen argumenten en twee variabelen name (naam) en age (leeftijd). Er is geen verschil tussen de namen van numerieke variabelen en stringvariabelen.

De tweede Request –opdracht (voor leeftijd) schakelt de naam uit de eerste opdracht aaneen met de tekst “s age”. Typ geen spatie voor de s.

Opmerking: De naam van het programma, can_vote (mag stemmen), kan een onderstrepingsteken (_) bevatten. Dit teken kun je vinden op de interpunctie-toets rechts van de toets ‘G’.

Voorwaarden

Een voorwaarde is een uitdrukking die uitgewerkt wordt tot waar (true) of onwaar (false). Voorwaarden maken gebruik van de relationele bewerkingen die je kunt vinden met ctrl =, dit breng het keuzevak met de relationele bewerkingen in beeld.

Merk op dat = ontbreekt omdat dit direct op de toets zelf staat!

Voorwaarden kunnen ook gebruik maken van de logische bewerkingen and, or, not en xor die je alleen kunt vinden in de catalogus. Ook zijn nand, nor, implies, if and only if, en een isPrime( )-functie beschikbaar in TI-Nspire

Voorbeelden van voorwaarden:

• x > 0 and y > 0 (dit is waar als x groter is dan 0 en y groter is dan 0; Let op de spaties voor en na ‘and ’)
• uren > 40
• tijd ≤ 0
• leeftijd ≥ 18
• c² = a² + b²
• isPrime(n)

De ‘basale’ If-opdracht

De eenvoudigste vorm van alle If –opdrachten is

If voorwaarde
voer deze opdracht uit

Een voorbeeld van deze opdracht kun je vinden in het Engelse programma can_vote() (mag stemmen) dat je hier rechts ziet. Als de waarde van de variabele age (leeftijd) groter dan of gelijk is aan 18, dan wordt de opdracht Disp daaronder uitgevoerd, anders wordt deze overgeslagen. Deze vorm van de If-opdracht is bruikbaar voor eenvoudige bewerkingen waarbij geen alternatieve acties nodig zijn.

Inspringen

Merk op dat de Disp-opdracht is ingesprongen. Het inspringen van opdrachten is toegestaan op de TI-Nspire™ CX en inspringen helpt om het programma voor mensen beter leesbaar te maken. Voor de computer maakt dit niets uit, maar moet de Disp-opdracht wel op de regel meteen onder de If-opdracht staan.

Het programma uitvoeren

• Schakel, na het controleren van de syntax en het opslaan van het progrmma met “Syntx controleren en opslaan”, over naar de toepassing Rekenmachine en voer het programma uit. Je moet haakjes gebruiken achter de programmanaam ook al zijn er geen argumenten.
• De eerste RequestStr-opdracht geeft een dialoogvenster weer. Typ een naam en selecteer [enter].

• De tweede Request-opdracht geeft een bericht weer dat bestaat uit de naam van de gebruiker en het woord ‘age’ en dat een getal verwacht. Typ een getal voor leeftijd en selecteer [enter].
• De resultaten van het programma worden als uitvoer weergegeven op het scherm van de toepassing Rekenmachine. Als de leeftijd groter is dan 18 dan wordt de tekst ‘Please register to vote.’ weergegeven, anders wordt er niets getoond.

In deze tweede les van Unit 3, leer je over If…Then…EndIf opdrachten.

Doelen:

• De structuur If…Then…EndIf verkennen
• Samengestelde voorwaarden maken met relationele en logische bewerkingen
• Een programma schrijven dat gebieden van het coördinatenstelsel onderzoekt en daarin de structuur If…Then…EndIf gebruiken.

Zoals je kunt zien op de schermafbeelding rechts, worden er vier verschillende soorten sjablonen voor If –opdrachten aangeboden in TI-Nspire™ CX. Zij worden gebruikt om voorwaardelijke opdrachten te verwerken. Dit wordt soms ‘aftakken’ (branching) in een programma genoemd omdat de computer een van de verschillende routes door het programma kan volgen.

Het is aan te raden om deze structuren uit het menu te selecteren omdat alle noodzakelijke onderdelen dan zullen worden ingevoegd in het programma op de juiste plekken. Je gaat dan terug en hoeft alleen maar de ‘lege plekken’ in te vullen.

De afbeelding rechts laat het tussenresultaat zien van het selecteren van 2: If…Then…Endif uit het menu Besturing. De volgende taak is om de voorwaarde in de vullen (tussen If en Then) en de actie (tussen If en Endif).

We gaan een programma schrijven dat de gebruiker waarden laat invoeren voor de variabelen x en y, vervolgens bepaalt in welk kwadrant het punt (x,y) ligt en tenslotte de tekens voor de coördinaten in dat kwadrant vastlegt.

Het eerste (onvolledige) deel van het programma zie je hier rechts

Boven de opdracht If moet je nog twee Request-opdrachten toevoegen (een voor x en een voor y). Daarna kan je de If…EndIf structuur kopiëren, plakken en bewerken voor de andere drie kwadranten.

Denk eraan om het sleutelwoord ‘and’ van de omliggende tekst te scheiden met spaties.

Kopieer en plak de programmacode die je opnieuw wilt gebruiken en aanpassen voor de actuele voorwaarde. Test je programma met een groot aantal verschillende waarden voor x en y. (Zijn er waarden die niet het gewenste resultaat opleveren? Hoe ga je eventuele problemen oplossen?)

Selecteren, kopiëren en plakken op TI-Nspire™ CX

Selecteer tekst door de SHIFT-toets ingedrukt te houden terwijl je met de pijltje over de tekst beweegt.

Gebruik dan ctrl-C en ctrl-V om te kopiëren en te plakken.

Vergeet niet om je bestand op te slaan zodat je programma wordt opgeslagen. Het volledige programma (de code) zie je hieronder:

In deze derde les van Unit 3 leer je de clausule Else en het gebruik van ElseIf.

Doelen:

• If…Then…Else opdrachten ontwerpen zodat er acties zijn voor zowel de waarde waar als voor de waarde onwaar van de conditie.
• De clausule ElseIf gebruiken om verschillende mogelijke voorwaarden binnen één blokstructuur af te handelen

Soms is het nodig om een actie te laten uitvoeren als een voorwaarde waar is en een andere actie als dezelfde voorwaarde onwaar is. Dit is het moment dat de clausule Else in beeld komt.

Bij het selecteren van de structuur If…Then…Else…EndIf uit met menu Besturing worden alle vier de sleutelwoorden in het programma geplakt en kun je de ontbrekende stukken van de programmacode invullen..

Het programma:

Voor een bepaalde cursus zijn er drie toetsen en voor de cursus kun je slagen of zakken. Er is een gemiddeld cijfer van 6,5 (ofwel een score van 65%) nodig om te slagen. Schrijf een programma dat de drie toetsscores ontvangt, het gemiddelde ervan berekent en uiteindelijk het bericht “gezakt” of “geslaagd” weergeeft.

• Bepaal eerst welke methode he wilt gebruiken om de drie scores in het programma te krijgen: argumenten of Request-opdrachten?
• Hoe wordt het gemiddelde berekend?
• Voor de uitvoer van het programma gaan we de opdracht Text uit het menu I/O gebruiken

Voor het gemak zullen we drie argumenten voor de drie toetsscores gebruiken.

Het gemiddelde van de drie scores is het totaal van de scores gedeeld door 3.

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

Gebruik een decimale punt na de 3 (of een komma afhankelijk van de instellingen) om je ervan te verzekeren dat het resultaat een decimale benadering is.

Voltooi tenslotte de If-structuur en gebruik Text-opdrachten om ofwel “geslaagd” ofwel “gezakt” weer te geven. (Hoe zou je ervoor kunnen zorgen dat ook het gemiddelde in het tekstvak wordt getoond?)

In deze toepassing van Unit 3, leer je over de tekens van de dierenriem (sterrenbeelden) en schrijf je een programma dat je vertelt wat jouw sterrenbeeld is. Je moet de oefenbladen van Unit 3 hebben doorgewerkt voor je aan deze activiteit begint.

Doelen:

• If… then… elseif… then endif in een programma gebruiken.
  Werken met het converteren van datums.

De sterrenbeelden van de dierenriem (Zodiac)

In de sterrenkunde en astrologie is de dierenriem een verdeling van de hemel in 12 gelijke gebieden. Die gebieden zijn genoemd naar de sterrenbeelden die ongeveer binnen deze gebieden vallen. De Babyloniërs bedachten deze verdeling rond 1000–500 voor Christus. Zij begonnen hun kalenderjaar met de zogenaamde lente-equinox (de eerste dag van de lente), daarom is de ram (Aries) het eerste teken van de dierenriem en hoort dit bij de periode van 21 maart tot 20 april.

Het programma

In deze les zullen we een programma schrijven dat de gebruiker een maand en een dag laat invoeren en vervolgens het teken van de dierenriem (sterrenbeeld) laat zien voor deze datum. Het programma maakt gebruik van een omvangrijke If…Then structuur.

De gebruiker zal het nummer van de maand (month) en het nummer van de dag (day) invullen volgens onze kalender. Vervolgens beepaalt het programma het nummer van die dag in het jaar (14 april 14 is 104^de dag van het jaar) en gebruikt het If-opdrachten om het juiste sterrenbeeld te bepalen.

We moeten eerst de daums in de tabel hieronder omzetten in dagnummers (van het jaar). Op de TI-Nspire™ CX kunnen we de functie dbd gebruiken:

dbd(12.3114,03.2115) geeft het aantal dagen vanaf 31 dec 2014
(12.3114) tot 21 maart 2015 (03.2115).

Dus 21 maart is de 80^e dag van het jaar, zoals je kunt zien in de schermafbeelding rechts. Maak de dag# gedeelten van de tabel hieronder af met behulp van je TI-Nspire™ CX.

Hier zie je de data (intervallen) voor elk sterrenbeeld.:

In ons programma, is het nodig om de ingevoerde maand en dag om te zetten in het format MM.DDYY wat vereist is voor de functie dbd( )

Je kunt dit doen met:
dagcode := maand + dag/100 + .0015

Vervolgens kunnen we het dagnummer bepalen met:
dagnum := dbd(12.3114, dagcode)

Rechts zie je een testprogramma dat alleen de waarden van dagcode en dagnum weergeeft. Deze test verzekert ons ervan dat deze uitdrukkingen werken zoals bedoeld.

We zijn nu klaar om de rest van het dierenriemprogramma te schrijven.

Bouw een lange If…then…elseIf…then…elseIf…-opdracht om te bepalen welk sterrenbeeld correct is. Elke ‘actie’ slaat het corresponderende sterrenbeeld op in de variabele zodteken. Pas op met Steenbok!

Test je programma grondig verwijzend naar de dierenriem tabel hierboven.

Merk op dat je kunt ‘>=’ kunt schrijven en dat de bewerking ‘Syntax controleren en opslaan’ dit omzet in het enkele symbool ≥ .

Als de functie dbd( ) ongeldige informatie ontvangt (zoals maand 13 of dag 45) dan treedt er een fout op en stopt het programma.

Om er zeker van de zijn dat er geldige informatie wordt ingevoerd, zullen we een lus (loop) moeten bouwen om herhaaldelijk te vragen om de gegevens totdat de goede getallen zijn ingevoerd. We zullen lussen (loops) bespreken in de volgende unit. Blijf erbij!

In deze les leer je over je het lus-,concept dat wordt gebruikt bij programmeren en onderzoek je de For… lus

Doelen:

• Het concept van een lus bij het programmeren beschrijven.
• Een programma en functies schrijven met de For…EndFor-structuur.

Over Lussen

De TI-Basic programmeertaal maakt het mogelijk om een serie opdrachten steeds weer opnieuw te verwerken. Dit herhalen van opdrachten wordt ‘lussen’ (looping) genoemd.

De drie lus-structuren die je in deze unit gaat leren zijn elk te vinden door Menu > Besturing te selecteren in het menu van de programma-editor. (Zie For…, While…, en Loop… hier rechts)

De While… en Loop… structuren zullen we in extra lessen van deze Unit verkennen. Ga voor meer informatie over de extra besturingsstructuren in dit menu naar de Handleiding op de TI website over programmeren (codes).

For…EndFor

De For… lus wordt gebruikt om de waarden uit een rekenkundige rij te verwerken. Dit proces staat bekend als ‘iteratie’.

Het selecteren van de For…EndFor-opdracht uit het menu Besturing geeft je de benodigde onderdelen om de rest van de structuur op te bouwen:

For , , ,

EndFor

De komma’s achter het woord For geven aan dat je vier elementen moet opgeven:
For i, 1, n, 1

De komma’s achter het woord For geven aan dat je vier elementen moet opgeven:
For i, 1, n, 1

1. i is de besturingsvariabele van de lus: Het eerste element moet een variabele zijn.
2. 1 is de beginwaarde: Elke keer dat de lus wordt verwerkt neemt deze waardes aan of hij telt het aantal lussen vanaf de gespecificeerde startwaarde (1).
3. n is de eindwaarde: Elke keer dat de lus wordt verwerkt neemt hij of waardes aan of telt hij het aantal lussen tot de gespecificeerde eindwaarde (n).
4. 1 is de waarde van de stapgrootte: Elke keer dat de lus wordt verwerkt neemt hij waardes aan of telt hij het aantal lussen van begin tot eind met de gespecificeerde waarde van de stapgrootte (1).

Elke of alle van de laatste drie elementen kunnen getallen of variabelen zijn.

Het programma uitvoeren

Het uitvoeren van het programma dat in het plaatje hierboven is weergegeven geeft het resultaat hier rechts.

• De waarde voor n is een argument van het programma
• De besturingsvariabele van de lus is een lokale (local) variabele; hij heeft geen invloed op de rest van de opgave.
• De lus begint met i=1 en toont de waardes van i en i².

• Na de Disp-opdracht geeft de EndFor opdracht de besturing weer terug aan de For opdracht waarbij de stapgrootte bij i is opgeteld.
• Als de resulterende waarde kleiner of gelijk is aan de eindwaarde dan wordt de lus opnieuw uitgevoerd met de opgehoogde waarde voor i.
• Dit proces herhaalt zich totdat de eindwaarde wordt bereikt of overschreden.

Nadat de lus stopt, zal i groter dan de eindwaarde zijn geworden! Geloof je het niet? Voeg een extra Disp i opdracht toe na de EndFor-opdracht en test het maar.

In Deze les leer je over de flexibele van de lussen: While…

Doelen:

• Een eenvoudige while-lus schrijven
• De while-lus gebruiken om er zeker van te zijn dat er geldige gegevens worden ingevoerd

Het machtige While…

De lus While…EndWhile zal zich blijven herhalen zolang de ervan waar is. Dat ziet er zo uit:

<initialiseer de voorwaarde>
While <voorwaarde>
<kern van de lus>
EndWhile

• Initialiseren verwijst naar het instellen van een of meer variabelen zodat de While-opdracht in staat is de voorwaarde de eerste keer correct uit te werken. Het initialiseren stelt een waarde van waar of onwaar vast voor de variabele. Als de beginvoorwaarde onwaar is dan wordt de lus volledig overgeslagen. Als de voorwaarde waar is dan wordt de kern van de lus verwerkt.
• De <voorwaarde> is een logische uitdrukking, bijvoorbeeld X>0.
• De <kern van de lus> is een willekeurige verzameling opdrachten, die andere lussen en If structuren kan bevatten. De <kern van de lus> wordt verwerkt telkens als de <voorwaarde> waar is.
• Het sleutelwoord EndWhile wordt gebruikt om het einde (de bodem) van de aan te duiden. Bij de opdracht EndWhile maakt het programma een ‘lus’ terug naar de opdracht While en test de opnieuw. Als de voorwaarde onwaar is wordt de lus overgeslagen. Als de voorwaarde waar is wordt de kern van de lus opnieuw verwerkt.

De k:=1 aan het begin van het programma stelt de beginvoorwaarde in op een bekende waarde van onwaar. Zonder deze initialisatie, zou de variabele k een of andere opgeslagen waarde kunnen hebben en daarmee een onbekende waarde in het programma kunnen introduceren.

Ergens in de <kern van de lus> moet een opdracht voorkomen die effect heeft op de voorwaarde zodat de lus uiteindelijk zal stoppen en de opdrachten na de lus zullen worden verwerkt. Gewoonlijk staat deze opdracht dichtbij het eind (de bodem) van de <kern van de lus>. k:=k+1 zorgt ervoor dat k zal toenemen en uiteindelijk groter wordt dan n.

Het programma demonstreert het While -equivalent van de For-lus:
For k,1, n
Disp k
EndFor

Nagaan of Input geldig is met While…End

We zullen een gedeelte van een programma (code-segment) schrijven dat ervoor zorgt dat de gebruiker een positief getal invoert, haar vertelt wanneer de invoer ongeldig is en dan verzoekt om een andere waarde in de plaats ervan in te voeren.

De uitvoer van dit programmagedeelte staat hier rechts waarbij enkele niet-positieve getallen zijn ingevoerd om het effect te zien. Kijk eens of je dit programmagedeelte kunt schrijven zonder te spieken op de volgende pagina!

1. We beginnen met het maken van een nieuw programma. De naam die we hier hebben gebruikt is valid.
2. Creëer een lokale variabele n en gebruik de opdracht Request om een waarde te ontvangen van de gebruiker. Merk op dat er gevraagd wordt om een positief getal.

3. Voeg een While-structuur in vanuit het menu Besturing. Zowel het While- als het EndWhile-commando worden in het programma geplakt en de cursor verschijnt achter het woord While.

4. Typ de voorwaarde n>=0.
   • Krijg de <= bewerking door [ctrl] [=] te selecteren.

5. Voltooi tenslotte de kern van de lus door te zorgen voor een foutmelding met behulp van een Text –opdracht en door een extra Request-opdracht op te nemen om de gebruiker opnieuw een waarde voor n in te laten voeren.

Het programma valid( ) dat je hier rechts ziet, leverde de interactie zoals beschreven op de vorige pagina.

Merk op dat er TWEE Request-opdrachten zijn.

• De eerste wordt gebruikt om de voorwaarde (n<=0) te initialiseren. Als er hier een positief getal is ingevoerd, dan zal de lus helemaal niet worden verwerkt..
• Maar als er 0 of een negatief getal is ingevoerd dan zal de kern van de lus de foutmelding weergeven en om een andere waarde vragen. De lus zal herhaald worden zolang er een niet-positieve waarde wordt ingevoerd.

De lus zal herhaald worden zolang er een niet-positieve waarde wordt ingevoerd.

In deze les leer je over de universele Loop…EndLoop-structuur.

Doelen:

• De Loop…EndLoop-structuur gebruiken
• De opdracht Exit gebruiken om een lus te verlaten

Wat is zo’n Loop…EndLoop eigenlijk?

De Loop…EndLoop-structuur laat ons een meer flexibele lus-structuur creëren. Het voert opdrachten in de kern van de lus herhaaldelijk uit. Merk op dat de lus eindeloos zal worden uitgevoerd, tenzij er ergens in de kern van de lus een Exit-instructie wordt uitgevoerd.

Als het programma geen Exit-opdracht tegenkomt dan zal de lus een oneindige lus zijn. Als je per ongeluk in een oneindige lus terecht komt op de rekenmachine, druk dan op ON/HOME en houd dit ingedrukt totdat het programma onderbroken wordt.

De Loop…EndLoop-structuur wordt minstens één keer verwerkt aangezien er geen voorwaarde is waar aan voldaan moet worden om de lus in te gaan.

Exit forceert het programma om de opdracht meteen na EndLoop te verwerken.

Voorbeeld: Hoeveel toevalsgetallen van 1 tot en met 6 kun je genereren voordat twee opeenvolgende getallen gelijk zijn aan elkaar?

Bekijk in het programma hier rechts het gebruik van Loop…EndLoop met een voorwaardelijke Exit-opdracht. Wanneer de toevalsgetallengenerator randInt(1,6) twee opeenvolgende identieke waarden produceert dan verlaat het programma de lus om de Disp-opdracht aan het eind van het programma te verwerken.

Je vindt Exit in menu>Overzendingen

Hetzelfde effect kan worden gerealiseerd met een While-lus.

Opmerking over de syntax: Let in het programma hierboven op het gebruik van de dubbele punt ( : ) om twee opdrachten op dezelfde regel te scheiden. Dit is alleen gedaan om het hele programma op het scherm te laten passen. Het ‘gereserveerde’ woord Exit is te vinden in menu>Overzendingen.

Programma: Raad mijn getal

Om het gebruik van Loop…EndLoop te demonstreren, ontwikkelen we een spel voor 2 spelers waarin het gaat om het raden van een willekeurig getal tussen 1 en 10. Wanneer een speler het getal raadt, dan eindigt het programma met een bericht aan de winnaar. Een voorbeeld van de uitvoer van zo’n programma zie je hier rechts.

1. Begin met een nieuw programma genaamd raadspel.
2. Start met het instellen (initialiseren) van het spel. Identificeer drie variabelen: het nummer van de speler, het getal van de computer en de gok van de speler, het raadgetal.

De computer kiest een willekeurig getal tussen 1 en 10. We beginnen met de speler met het nummer 0. Dit maakt het eenvoudiger om het spelersnummer te veranderen zoals we snel zullen zien!

3. Bouw vervolgens de lus waarin we eerst de speler vragen om een gok in te voeren. De volledige opdracht is:
   Request "Speler "&string(speler)&" raad?", raadgetal
   • Het symbool ‘&’ is bedoeld voor het aaneenschakelen van tekenreeksen (strings). Het gevraagde deel van een Request-opdracht moet een string zijn daarom wordt de speler-variabele omgezet in een string met behulp van de functie string( ) die te vinden is in de catalogus.

4. Bouw vervolgens de Exit-voorwaarde. Wanneer een speler het getal raadt, dan verlaat het programma de lus. Gebruik hier de eenvoudige If-opdracht:
   If raadgetal=getalExit
   Bedenk dat If zonder Then de volgende opdracht uitvoert wanneer de voorwaarde waar is; in andere gevallen wordt de volgende opdracht overgeslagen.
5. Om te wisselen van speler zullen we een slimme opdracht gebruiken:
   speler := 1 - speler
   deze unieke opdracht schakelt de waarde van speler tussen 0 en 1. Dat wil zeggen: wanneer speler is 0 dan verandert de opdracht dit in 1 en wanneer speler is 1 verandert de opdracht dit in 0.

6. Voeg tenslotte een opdracht toe na de lus, om de winnaar te feliciteren:
   
   Text “speler ”&string(speler)& “wint!”
   
   Tip: Als je het niet prettig vindt om ‘speler 0’ en ‘speler 1’ te zien, tel dan gewoon 1 op bij de variabele speler in deze opdracht en in de opdracht Request. De gebruiker ziet dan een 1 of een 2 hoewel de computer 0 en 1 gebruikt voor de spelers!
7. Bewaar het document voordat je het programma uit gaat voeren voor het geval je vastraakt in een oneindige lus! Zodra het programma begint, moet je doorspelen totdat er een winnaar is. Je kunt niet ontsnappen aan de Request-opdracht.

Deze toepassing maakt gebruik van lussen om zoveel variabelen als nodig in te voeren en zorgt, als uitbreiding, voor een controle op de geldigheid van variabelen en maakt gebruik van “If”-opdrachten om een passend bericht weer te geven.

Doelen:

• De opdrachten teller (Counter) en accumulator gebruiken.
• Een lus gebruiken in een programma om een onbepaalde hoeveelheid gegevens te verkrijgen
• Een ‘vlag’-waarde gebruiken om een lus te beëindigen.

Geneste structuren

• Nesten is de programmeertechniek waarbij de ene besturingsstructuur binnen een andere wordt geplaatst.
• De term is afgeleid van het idee van het plaatsen van de ene kartonnen doos in de andere om zo ruimte te besparen.
• Een programmeur plaatst lussen binnen lussen, If-structuren binnen lussen en lussen binnen If-structuren om de complexere taken die nodig zijn voor het programma te realiseren.
• Het is belangrijk om een volledige structuur in zijn geheel binnen een blok van een andere structuur te plaatsen om fouten te voorkomen.

• Het programma rechts toont een While-lus en een If-structuur binnen een andere While-lus.
• Merk het veelvuldig gebruik van de opdracht EndWhile op; de computer ‘weet’ welke EndWhile bij welke While hoort.
• Het inspringen van de regels is alleen gedaan voor het visuele effect; het helpt om de logica binnen het programma te verduidelijken.

Het programma stelt eerst een lus in om door te gaan totdat de ingevoerde waarde gelijk is aan nul. Vervolgens gaat het na of a<0. Als dat zo is toont het programma het bericht “Moet een niet negatief getal zijn!” en vraagt het om een andere waarde voor a. Wanneer a echter niet negatief is dan worden de wortelberekening, ook een If-opdracht, en alle Disp-opdrachten uitgevoerd

Samenvatting van de drie lussen:

For( wordt gebruikt bij ‘tellen’ of bij het verwerken van een rekenkundige rij van waarden (iteratie).

While wordt gebruikt wanneer je mogelijk de volledige kern van een lus kunt overslaan.

Loop wordt gebruikt wanneer je zeker weet dat je de kern van een lus minstens een keer wilt uitvoeren; deze moet een Exit-opdracht bevatten, gewoonlijk als deel van een If-opdracht.

Unit 4 Toepassing: Programma “Berichten van de bank”

En klant van een bank heeft verschillende rekeningen bij dezelfde bank. De bank eist een minimaal gemiddeld saldo van €1000 op alle rekeningen om geen servicekosten te hoeven betalen.

Als het gemiddelde tussen €1000 en €1250 ligt dan stuurt de bank de klant een bericht met de waarschuwing dat de klant mogelijk servicekosten moeten gaan betalen.

Wanneer het gemiddelde boven €1250 komt stoort de bank een bericht naar de klant om te bedenken voor het bewaren van een goed gemiddeld saldo.

We gaan een programma schrijven dat de gebruikers informatie geeft over hun rekeningen. De gebruiker voert de saldi van de rekeningen in. Het programma zal dan de gemiddelde saldi bepalen en het aantal rekeningen, de gemiddelde saldi en een passend bericht weergeven. Dit bericht kan zijn:

“SERVICE FEE CHARGED” (“ER WORDEN SERVICEKOSTEN IN REKENING GEBRACHT”),
“IN DANGER OF A SERVICE FEE” (U LOOPT HET RISICO SERVICEKOSTEN TE MOETEN BETALEN),
en “THANK YOU FOR YOUR BUSINESS!” (BEDANKT VOOR UW ZAKEN).

We kunnen twee manieren gebruiken voor het in laten voeren van een onbekend aantal waarden:

• Manier 1: Vraag eerst om het totaalaantal rekeningen en gebruik een For-lus om de waarden in te voeren.
• Manier 2: Vraag om de bedragen, maar gebruik een ‘vlag’-waarde, bijvoorbeeld -999, om aan te geven dat er niet nog meer rekening zijn. Deze manier maakt gebruik van een While-lus of een Repeat-lus

In beide gevallen zullen we een lopend totaal van de ingevoerde waarden moeten bijhouden.

Bij manier 2, moeten we ook de saldi tellen zodat we het totaal door dat aantal kunnen delen, de volgende informatie zal nuttig zijn …

Jouw programma zou het volgende moeten weergeven: 1) het aantal saldi dat is ingevoerd, 2) het gemiddelde van de saldi en 3) een passend bericht gebaseerd op het gemiddelde saldo

Tellers en accumulatoren

Een opdracht zoals c:=c+1 wordt een ‘teller’ genoemd omdat deze, telkens wanner hij wordt uitgevoerd, 1 optelt bij de variabele c.

Een opdracht zoals t:=t+n wordt een ‘accumulator’ genoemd omdat deze een lopend totaal van de waarden van de variabele n bijhoudt. De waarde van n wordt opgeteld bij de variabele t en vervolgens wordt die som weer ‘terug’ opgeslagen in variabele t. Aan het eind van een lus zal t het totaal van de n waarden bevatten

Op de volgende pagina zie je een voorbeeld (in het Engels) waarin een teller (counter), een accumulator (total) en een ‘vlag’-waarde (-999) worden gebruikt om het aantal bedragen bij te houden dat ingevoerd wordt in een programma:

De While-lus hierboven blijft tellen en de bedragen optellen zolang er geen -999 wordt ingevoerd. Zodra -999 wordt ingevoerd stopt de lus en worden de resultaten weergegeven.

Uitbreiding
Als onderdeel van je invoer-routine kun je een controle uitvoeren om er zeker van te zijn dat het bedrag dat is ingevoerd een geldig bedrag is (groter dan 0) en om een passende actie uit te voeren wanneer dat niet zo is.

In deze les leer je hoe je lijsten kunt gebruiken in programma’s om interessante puntenwolken te produceren.

Doelen:

• De basis van lijsten in programma’s beschrijven
• Programma’s schrijven die lijsten gebruiken om puntenwolken te creëren.

TI-Nspire™ Basic biedt geen rechtstreekse grafische opdrachten. Een programma kan functies definiëren waarvan de grafieken getekend kunnen worden en kan lijsten creëren om puntenwolken te produceren, maar kan niet rechtstreeks punten plotten.

In deze unit, ontwikkelen we drie krachtige ideeën:

1. Werken met lijsten in een programma;
2. Een toepassing Grafieken instellen om een puntenwolk van deze lijsten weer te geven;
3. Dynamische programma’s creëren die op aanvraag kunnen worden uitgevoerd.

Lijsten definiëren

Lijsten worden beschreven met behulp van accolades { }. Om een lege lijst te creëren, gebruik je een opdracht als mijnlijst:={ } met niets tussen de haakjes.

De elementen van de lijst (waarden tussen de haakjes) worden aangeroepen met rechte haken na de lijstnaam, zoals in mijnlijst[3], wat verwijst naar het derde element in mijnlijst.

Je kunt elementen aan een lijst toevoegen door een waarde op de slaan op de positie meteen na de laatste waarde van de lijst. Bijvoorbeeld: als een lijst 3 elementen bevat bijvoorbeeld 12, 7 en 2 dan kun je een waarde aan deze lijst toevoegen door deze op te slaan in element nummer [4]. Het invoeren van mijnlijst[4]:=17 resulteert in mijnlijst = {12, 7, 2, 17}. Dim(lijstnaam) vertelt je hoeveel elementen de lijst heeft en wordt vaak gebruikt om een element aan een lijst toe te voegen, op deze manier: mylist[Dim(mijnijst)+1):=<een waarde>.

Willekeurige punten programmeren

We beginnen met het schrijven van een programma dat een willekeurig stippenpatroon creëert in een Grafiekentoepassing.

1. Creëer een nieuw programma (wij hebben het randots genoemd) en gebruik het argument n in de editor.
   • n stelt het aantal punten voor dat het programma gaat creëren.
     Het programma zal twee ‘globale’ lijsten met toevalsgetallen creëren (of aanpassen) om te gebruiken in een puntenwolk in de grafiekentoepassing.

Generatoren van toevalsgetallen

De TI-Nspire heeft verschillende functies voor toevalsgetallen. De twee meest voorkomende zijn rand() en randInt( ).

• rand() creëert een willekeurig decimaal getal tussen 0 en 1.
• randInt(a,b) creëert een willekeurig geheel getal tussen a en b (met inbegrip van a en b), dus randInt(1,6) creëert een willekeurig getal tussen 1 en 6. Probeer het in de Rekenmachinetoepassing.

Onze eerste poging om een lijst met toevalgetallen te krijgen:

xs := randInt(-10, 10, n)
ys := randInt(-6, 6, n)

1. Het derde argument in de twee functies hierboven zorgt ervoor dat de functie randInt een lijst met n willekeurige gehele getallen creëert in het gespecificeerde interval in plaats van een enkel toevalsgetal.

2. Kies ctrl-B om het programma op te slaan. Voer het programma uit in de toepassing Rekenmachine met een klein argument, bijvoorbeeld 5 en bekijk de waarden van de x-en en y-s. Jouw waarden zullen waarschijnlijk anders zijn dan die hier rechts.

3. Voeg een toepassing Grafieken toe aan de opgave en stel een puntenwolk in van de (xs,ys) door menu > Grafiek invoeren/bewerken > Puntenwolk te selecteren.
4. Voer xs in als de xlist, gebruik het pijltje omlaag om naar de ylist te gaan en voer ys in.
5. Druk op [enter].

Snap je waarom we juist deze intervallen hebben gekozen voor de toevalsgetallen? (Bestudeer de standaardvensterinstellingen).

Ga, nu we het programma hebben getest, terug naar de toepassing rekenmachine en voer het programma opnieuw uit met een grotere (maar niet te grote) waarde voor n, ga vervolgens terug naar de grafiek en bekijk het resultaat.

In deze les leer je over het aansturen van individuele elementen in lijsten en ontdek je hoe je een programma dynamisch kunt uitvoeren vanuit een wiskundevak in Notities.

Doelen:

• Reële decimale toevalsgetallen genereren in een gewenst interval
• De interactieve mogelijkheid van wiskundevakken in de toepassing Notities gebruiken om een programma dynamisch uit te voeren.

In de vorige les…

… schreven we een programma dat twee lijsten met gehele toevalsgetallen genereert en deze lijsten in de vorm van een puntenwolk weergeeft in de toepassing Grafieken. Herinner je de uitvoer van het programma randots(n) die hier rechts is weergegeven.

Dit programma beperkte zich tot het uitsluitend genereren van gehele waarden voor x- en y-coördinaten van de puntenwolk, waardoor alle punten op de roosterpunten van de grafiek liggen. In deze activiteit zullen we het programma uitbreiden met niet-gehele waarden, zodat de punten in de puntenwolk dichter op elkaar liggen.

In plaats van randInt(-10, 10) gaan we de functie rand( ) gebruiken om een decimaal getal tussen 0 en 1 te genereren en vervolgens ‘schalen’ we dit zo dat de punten het scherm vullen (als we het standaardvenster gebruiken).

Laten we eerst de uitvoer van de functie rand() en rand(k) onderzoeken in de toepassing Rekenmachine. Merk op dat de functie rand() zonder argument een enkel decimaal toevalsgetal tussen 0 en 1 genereert. Met het argument 3, geeft dit echter een lijst met drie decimale getallen tussen 0 en 1. Deze lijst kan vervolgens worden gebruikt als deel van een uitdrukking om deze waarden zo te bewerken dat ze buiten het interval [0, 1] komen. Zo produceert 5*rand(3) een lijst met drie decimale toevalsgetallen tussen 0 en 5.

We moeten deze kennis gebruiken om een decimaal toevalsgetal te genereren tussen -10 en 10. Dat is een interval van 20 eenheden. We beginnen de uitdrukking met -10 en tellen daar een toevalsgetal tussen 0 en 20 bij op met 20*rand( ).

1. In ons programma randots(n) verander je nu de functies randInt in een uitdrukking waarin je in plaats daarvan rand( ) gebruikt…
   xs := -10 + 20*rand(n)
   ys:= -6 + 12*rand(n)
   Deze uitdrukkingen genereren n waarden voor xs tussen -10 en 10 en n waarden voor ys tussen -6 en 6.

2. Voer het programma uit in de toepassing Rekenmachine en bekijk de waarden van xs en ys.

3. Bekijk tenslotte de puntenwolk van (xs,ys).

4. Voer het programma opnieuw uit met een grotere waarde voor het argument.
   • Rechts zie je een plaatje na het uitvoeren van randots(50) waarin de decimale waarden zijn gebruikt die gegenereerd zijn door rand( ).

Dynamische programma’s

1. Om te zorgen dat een programma dynamisch wordt uitgevoerd voeg je een Notities-toepassing toe aan de opgave.
2. Voeg een wiskundevak toe binnen Notities door de drukken op menu>Invoegen>Wiskunde-vak.
3. Typ de naam van het programma met een variabele als argument (wij gebruikten k) in het vak en drup op [enter]. (Of druk op de toets var en selecteer de programmanaam)
   • Je zult een foutmelding zien omdat je argument een ongedefinieerde variabele is. Dit wordt binnenkort verholpen.

De actuele parameter die je gebruikt hoeft niet dezelfde te zijn als het argument dat je gebruikte in de programma-editor. Het is de waarde die wordt doorgegeven aan het argument van het programma.

4. In de Grafiekentoepassing die de puntenwolk bevat voeg je een schuifknop in (menu > Acties > schuifknop invoegen).
5. Geef de variabele dezelfde naam als die van het argument dat je gebruikt hebt in het wiskundevak. Wij gebruikten k.
6. Stel de waarde in op 1, de ondergrens op1 en de bovengrens op 100 zoals in het plaatje hiernaast.
7. Druk op [enter] om de schuifknop te plaatsen.
8. Verplaats de schuifknop naar een handige plek en druk dan opnieuw op [enter] of [klik] opnieuw om deze neer te zetten.

Je zult zien dat alle punten verdwijnen op één op na. Dit is een resultaat van de reactie van het programma op de nieuwe waarde voor k (in onze demo) waardoor het programma gaat reageren vanuit het wiskundevak op de Notitiespagina.

Als je naar de Notitiespagina kijkt zal je zien dat de foutmelding is vervangen door het woord ‘gereed’ (‘Done’). Het programma wordt netjes uitgevoerd nu het argument k is gedefinieerd.

9. Bedien nu de schuifknop voor k. Elke keer dat de waarde van k verandert zorgt dit ervoor dat het programma wordt uitgevoerd en daarmee een nieuwe verzameling punten voor de puntenwolk genereert.

In deze les leer je hoe je dynamische programma’s kunt gebruiken om andere typen grafieken te produceren met gebruikmaking van de ‘plot’-toepassing van Data & Statistiek.

Doelen:

• Een programma schrijven dat op dynamische wijze een grafische weergave vernieuwt
• Een programma schrijven dat een een echte gebeurtenis simuleert (het werpen van twee dobbelstenen) en de resultaten weergeeft (plot) in een betekenisvolle grafiek

Dynamische programma’s kunnen veel meer produceren dan willekeurige puntenwolken! In deze les ontwikkelen we een demonstratie van de verdeling van de som van twee eerlijke 6-zijdige dobbelstenen wanneer deze een groot (variërend) aantal keer geworpen worden.

Wanneer je met een tweetal 6-zijdige dobbelstenen gooit dan kan de som van de waarden op de twee dobbelstenen lopen van een laagste waarde van 2 (door twee enen te gooien) tot en met een hoogste waarde van 12 (door twee zessen te gooien. Maar, zijn de de tien totalen allemaal even waarschijnlijk of komen sommige totalen vaker voor dan andere? Laten we een TI-Nspire-opgave ontwerpen waarmee we het experiment kunnen simuleren door een programma te gebruiken.

1. Begin met een nieuwe Opgave.
2. Kies doc > Invoegen > Programma editor > Nieuw…
   Het programma bevat maar een opdracht en geen argument:
   sommen:=randInt(1, 6, k) + randInt(1, 6, k)
   Er zijn twee globale variabelen vastgelegd:
   k stelt het aantal worpen voor. sommen is een lijst die k ‘sommen’ van de twee geworpen dobbelstenen bevat.
3. Druk op ctrl-B om het programma op te slaan.

4. Voeg een toepassing Notities in.
5. Voeg een wiskundevak in door te selecteren: menu > invoegen > wiskunde-vak.
6. Typ de naam van het programma en een een stel haakjes in en druk op [enter].

Wees niet verbaasd wanneer een foutmelding verschijnt: de variabele k heeft immers nog geen waarde.

7. Voeg een toepassing Data & Statistiek toe.
8. Voeg een schuifknop in (menu>Acties>schuiknop invoegen) voor de variabele k met een waarde van 1, een minimum van 1, een maximum van 500 en een stapgrootte van 1.
   Deze variabele stelt het aantal worpen met de dobbelstenen voor.
9. Plaats de schuifknop bovenaan de pagina.

Nu k is gedefinieerd wordt het programma uitgevoerd binnen de toepassing Notities en zie je ‘bijschrift: sommen’ bovenaan de toepassing staan en een punt dat de som van de ogen van één paar dobbelstenen voorstelt.

Gebruik de schuifknop nu nog niet!

10. Klik onderin de toepassing en selecteer sommen voor de horizontale as.
    • Het resultaat is een verticaal puntendiagram van de lijst met totalen (sommen).

11. Verander het plottype in histogram door menu > Plot Type > Histogram te selecteren.

12. Activeer nu de schuifknop om meer totalen (sommen) te genereren.
    • Naarmate k toeneemt zal je het kijkvenster moeten aanpassen door menu > Window/Zoom > Zoom Data te selecteren.

Welke som komt het meeste voor? Welke zijn het zeldzaamst? Waarom?

In deze toepassing ontwikkelen we een project om het ‘chaos spel’ te spelen dat de zeef van Sierpinski, een beroemde fractal, genereert.

Doelen:

• Een programma schrijven dat een interessant plaatje genereert (de zeef van Sierpinski)
• De toegestane acties op een schuifknop besturen

De zeef van Sierpinski

De zeef (of driehoek) van Sierpinski is een fractal die wordt gevormd door te beginnen met een gelijkzijdige driehoek en achtereenvolgens de ‘middelste’ driehoeken te verwijderen zoals in de afbeelding hierboven te zien is. Dit kan oneindig vaak gedaan worden, zodat de de zeef oneindig veel gaten heeft en elk gedeelte van de afbeelding gelijk is aan de afbeelding zelf (zelfgelijkheid).

Een andere manier om de zeef te genereren, die we in dit project zullen gebruiken, heet het Chaos spel, waarbij dit de regels zijn:

1. Kies drie (3) punten in een vlak om drie hoekpunten te vormen (0,0), (2,0), en (1,1). We snappen dat dit geen gelijkzijdige driehoek is.
2. Begin met het kiezen van een willekeurig punt (bij voorkeur binnen de driehoek, maar dat maakt eigenlijk niet uit) en beschouw dat punt als je huidige’ positie’.
3. Kies willekeurig een van de drie hoekpunten.
4. Beweeg de helft van de afstand tussen je huidige positie en het geselecteerde hoekpunt in de richting van dit hoekpunt. (Dat wil zeggen: bereken het middelpunt van het lijnstuk tussen je huidige positie en dat hoekpunt).
5. Plot deze nieuwe ‘huidige’ positie.
6. Herhaal dit proces vanaf stap 3.

We zullen een groeiende puntenwolk gebruiken om dit spel visueel te maken. Tijdens dit project zullen we leren hoe we een puntenwolk opnieuw kunnen instellen (‘resetten’) en hoe we voorkomen dat een schuifknop ‘terugloopt’ (door het gedeelte met het pijltje naar links of naar beneden van een geminimaliseerde schuifknop uit te schakelen).

1. Begin met een nieuw document en voeg een toepassing Grafieken toe.
2. Verplaats de oorsprong naar de linkeronderhoek van de pagina en rek de assen uit zodat de x-as loopt van 0 tot ruim 2 en de y-as van 0 tot iets boven 1 [omdat de hoekpunten van onze driehoek (0,0), (2,0) en (1,1) zijn].
3. Pak de grafiek ergens vast om de oorsprong te verplaatsen en pak de assen vast om de schaal op de x-as uit te rekken. Dit is subjectief en kan later worden aangepast.

Het is altijd een goed idee om je document nu te bewaren en het regelmatig op te slaan (gebruik crtl-s) tijdens dit project voor het geval er onderweg iets mis gaat.

4. Stel een puntenwolk in van xs en ys (menu > Grafiek invoeren/bewerken > Puntenwolk).
   • Deze variabelen zijn nog niet gedefinieerd dus er zal nog geen grafiek verschijnen wanneer je op [enter] drukt.

5. Voeg twee schuifknoppen in (menu > Acties > Schuifknop invoegen):
   • n – waarde 0, minimum 0, maximum 2000, stapgrootte 1, horizontaal en geminimaliseerd.
   • reset – waarde 0, minimum 0, maximum 1, stapgrootte 1, horizontaal en geminimaliseerd.
6. Plaats deze schuifknoppen in de rechterbovenhoek van het scherm zodat ze de driehoek niet in de weg zitten.

Je bent nu klaar met de toepassing Grafieken.

Programmeren

1. Voeg een nieuwe pagina toe (ctrl-doc) en voeg een programma-editor in (doc > Invoegen > Programma Editor > Nieuw…).
2. Geef het programma de naam sierpinski.

3. Voeg hier de opdracht Local toe voor het geval er later nog hulpvariabelen nodig zijn in het programma.
   • Gebruik de variabele xxx als een tijdelijke plaatsvervanger.
4. Begin je programmacode met het concept ‘reset’.
   • Wanneer de schuifknop reset wordt gebruikt, wis je alle gegevens in de lijsten xs en ys en stel je de variabelen reset en n opnieuw in op 0.
   • Initialiseer deze ook voor de eerste keer dat je het programma probeert uit te voeren (wanneer n is 0) (en reset is niet 1).

Het instellen van reset:=0 in dit gedeelte van het programma lijkt misschien een vreemde keuze maar het resultaat is dat de waarde van reset op het scherm altijd 0 lijkt te zijn. Klikken op de knop reset zorgt ervoor dat reset 1 wordt, hetgeen de uitvoering van het programma forceert. Vervolgens zet het programma de waarde van reset onmiddellijk terug op 0 (tegelijk met de andere acties in dit deel van het programma).

Voorkomen dat de waarde van n afneemt

We willen dat de waarde van n (het aantal punten dat geplot wordt) toeneemt en niet afneemt. Doe dit door de laatste (vorige) waarde van n bij te houden en deze te vergelijken met de nieuwe (huidige) waarde van n. Als de nieuwe waarde kleiner is dan de laatste (vorige) waarde, dan wordt deze genegeerd door n in te stellen op de laatste (vorige) waarde.

1. Gebruik de variabele lastn om de vorige waarde van n in op te slaan. Dit gebeurt helemaal aan het eind van het programma:
   lastn := n
   EndPrgm

Het volgende deel van het programma gaat na of n kleiner is dan de vorige n (wanneer het pijltje naar links op de schuifknop is aangeklikt).

2. Voeg na het programmagedeelte voor het initialiseren, toe:
   If n < lastn Then
   n := lastn
   Else
3. Initialiseer lastn ook in de eerste If structuur:
   lastn:=0

4. Bouw vervolgens de lijsten voor de puntenwolk op.
   • Het eerste punt is speciaal omdat dit elk willekeurig punt kan zijn. Dus, als n is 1, dan kennen we een toevalsgetal toe aan xs[1] en ys[1]:
     Else
     If n = 1 Then
     xs[1] := rand()
     ys[1] := rand()
     Else

De functie rand( ) genereert een willekeurig decimaal getal tussen 0 en 1, dus in feite is dit punt een willekeurig punt in het vierkant tussen (0,0) en (1,1).

We zijn nu klaar om de kern van het algoritme dat aan het begin werd beschreven te gaan aanpakken. We herhalen het hier om ons geheugen op te frissen:

5. Kies willekeurig een van de drie hoekpunten.
6. Beweeg de helft van de afstand tussen je huidige positie en het geselecteerde hoekpunt in de richting van dit hoekpunt (dat wil zeggen: bereken het middelpunt van het lijnstuk tussen je huidige positie en dat hoekpunt).
7. Plot deze nieuwe huidige positie.

Herhaal vanaf stap 3

8. Gebruik v := randint(1,3) om een willekeurig geheel getal te selecteren, dit helpt om de drie hoekpunten te onderscheiden.
9. Bouw een serie opdrachten gebaseerd op v om het volgende midden (middelpunt) te berekenen.
   • Herinner je dat de hoekpunten die we hebben gekozen (0, 0), (2, 0) en (1, 1) zijn.

10. Als v=1 gebruik dan (willekeurig) het punt (0, 0) en het laatste punt in de lijst om het midden te berekenen.
    • Herinner je uit de meetkundelessen dat de coördinaten van het midden tussen twee punten (x1, x2) en (y1, y2) gelijk zijn aan (x1+x2)/2 en (y1+y2)/2.

Deze analyse leidt tor de programmacode die je hier rechts ziet. v, a en b zijn tijdelijke, lokale variabelen.

11. Bewerk bovenin het programma de opdracht Local zodat deze wordt:
    Local v, a, b

We kunnen dan eenvoudig deze If-structuur dupliceren om de andere twee hoekpunten (dit zijn (2,0) en (1,1)) te behandelen.

Opmerking: Hier zou de If…Then…ElseIf…Else…EndIf –structuur een efficiëntere structuur zijn. Bekijk of je dit gedeelte van het programma kunt schrijven met deze structuur.

12. Voeg de waarden van a en b toe aan het eind van onze twee lijsten.
    • De n^de positie is in feite een plek voorbij het eind van de lijsten en dit is altijd toegestaan.

Als je de If-structuren hebt geselecteerd uit het menu Besturing en je de blokken op de goede plek hebt ingevoegd dan zal je een EndIf onderaan het programma hebben precies voor lastn:=n.

13. Druk op ctrl-B om ‘Syntax controleren en opslaan’ te selecteren.
    • Als er fouten zijn dan moet je je programma zorgvuldig controleren. Het volledige programma is toegevoegd aan het eind van dit document.

14. Voeg een toepassing Notities toe; voeg een wiskundevak in (ctrl-M); en typ de naam van het programma en een linkerhaakje en druk op [enter].

15. Schakel om naar de toepassing Grafieken en test de twee schuifknoppen:
    • n voegt punten toe aan de puntenwolk en reset zou alle punten moeten wissen en n opnieuw instellen op 0.
    • De knop met het pijltje naar links op de schuifknop n zou niet moeten werken en het pijltje naar links op de schuifknop reset zou altijd uitgeschakeld moeten zijn.
    • reset zal altijd 0 lijken te zijn omdat het programma de verandering ervan in 1 opmerkt en dit onmiddellijk terug-verandert in 0.
    • De waarde van n wordt begrensd door de maximumwaarde die je hebt ingevoerd in de instellingen voor de schuifknop.
    • Hoe meer punten je plot, hoe beter het plaatje lijkt op de zeef van Sierpinski.