h.hofstede (h.hofstede@hogeland.nl)

OEPS...Een FOUT!
-  maar wr?? -
       
Als je een programma hebt gemaakt en je laat het voor de eerste keer "lopen" dan is dat altijd even een spannend moment.
Het kan namelijk maar zo gebeuren dat er allemaal onzin uitkomt of zelfs helemaal niets!
't Is namelijk nogal moeilijk om (vooral iets grotere) programma's in n keer foutloos te maken.

Wat te doen in zo'n vervelend geval?
Nou, daar is maar n antwoord op:
       

Ga gewoon lekker "computertje spelen"

       
Doe alsof je het mannetje in je machine bent dat alles in die geheugens stopt en voor je uitrekent.  Maak een lijstje met alle gebruikte geheugens en zet daarachter welk getal er in staat. Loop vervolgens je eigen programma stap voor stap langs en hopelijk zie je wel waar het fout gaat.
Ok, dat laatste klinkt nogal; vaag.....  Voorbeeldje dus maar!
 
Voorbeeld.  (ik heb de regels even genummerd).
Hiernaast staat een programma om de wortel van een getal te berekenen. (neem even aan dat je geen wortelknop hebt op je rekenmachine).
Het lost de vergelijking  W2 = X op bij een ingevoerde X en met een ingevoerde nauwkeurigheid D.

Het neemt als eerste benadering voor de wortel van X de waarde 1/2X (regel 4).
In regel 5 wordt getest of de wortel al dicht genoeg bij de echte wortel ligt.
Als dat niet zo is, dan wordt in regel 6 de volgende benadering gemaakt.
Net zolang totdat het verschil tussen X en W2 kleiner is dan D (regel 5)
:  PROGRAM WORTEL
1 :  ClrHome
2 :  Input"X^2 = ?", X
3 :  Input"nauwkeurigheid?", D
4 :  X/2
W
5 :  While X  - W^2   > D
6 :  X/W
W
7 :  End
8 :  Disp W
       
Dit programma werkt van geen kanten!

Het geeft bijvoorbeeld dat de wortel van 25 gelijk is aan 12,5 en dat de wortel van 6 gelijk is aan 3.

Ok, dan ga ik het naspelen met bijv. X = 25 en D = 0,01
Ik maak een tabelletjes met de geheugens  X, D, W en de berekening  X - W2 , en ga bijhouden wat er na elke programmastap in het geheugen staat. Dat heet een geheugenschema maken.
Dat zie je hiernaast, en daarin zie je ook direct wat er fout gaat.
De eerste keer is de afwijking  X - W2 gelijk aan -131,25 en dat ligt een heel eind van de echte wortel 5 af. Maar omdat dat een negatief getal is, is het niet groter dan D!!

Ok, dat gaan we fixen....
Omdat het alleen gaat om de grootte van de afwijking moeten we die altijd positief maken. Dat kan door de functie  abs  (bij  MATH - NUM - 1: abs) te gebruiken (de absolute waarde).
Verander daarom regel 5 in:
regel X D W X-W2
1 - - - -
2 25 - - -
3   0,01 - -
4     12,5 -
5       -131,25
6        
         
         
         
         

5 :   While abs(X  - W^2)  ˃ D

       
Laat het programma maar weer lopen.....

......Nou, gefeliciteerd hoor; nu gebeurt er helemaal niets meer!!!
Ok:  de rekenmachine uitzetten en opnieuw een geheugenschema maken:

Hiernaast zie je wat er misgaat.
De regels 5 en 6 blijven zich steeds maar herhalen, en de wortel W gaat heen en weer tussen de waarden 12,5 en 2.

12,5 is te groot, en dan is 2 te klein, dan 12,5 weer te groot, dan 2 weer te klein, en dat gaat zo maar door.

Het is beter om als nieuwe benadering van W niet X/W te nemen, maar het gemiddelde van  X/W en W.  Dat zou hier het gemiddelde van 12,5 en 2 opleveren en dat is 7,25 en dat ligt tenminste wl dichter bij de echte wortel.

Verander regel 6 daarom in:
regel X D W X-W2
1 - - - -
2 25 - - -
3   0,01 - -
4     12,5 -
5       131,25
6     2  
5       21
6     12,5  
5       131,25
....        

6 :  (X/W + W)/2 → W

       
En YES!!  Nu lukt het:  de rekenmachine geeft  als benadering van 25 de waarde  5,000012953
Maar wacht eens even... dat is veel nauwkeuriger dan de gevraagde 0,01......
Hoe kan dat?  Gaat er nog iets mis, of wordt die benaderde wortel bij de laatste stap ineens heel veel nauwkeuriger?
We kunnen nu wel weer een geheugenschema maken, maar er is ook een handigere manier om de kijken wat er gebeurt.

Laat gewoon elke benadering steeds op het scherm verschijnen, dan zie je vanzelf wat er aan de hand is.
Dus voeg tussen regel 6 en regel 7 in:    regel  6b :  Disp W
       
Voor X = 25 en D = 0,01  en voor X = 625 en D = 0,01 geeft dat de volgende beelden:
       

       
Je ziet dat bij X = 25 de n na laatste stap gelijk was aan  5,011394107 en inderdaad nog niet nauwkeurig genoeg. Bij X = 625 was de n na laatste stap  25,00174697 en die was al goed genoeg! Toch wordt nog een volgende stap berekend.
Hoe komt dat?
Dat komt omdat we testen  of  X - W2 > D. We kijken dus of het gevonden kwadraat dicht genoeg bij het echte kwadraat ligt. Inderdaad is 25,001746972 = 625,0873516 en nog niet nauwkeurig genoeg.

(Als je echt de nauwkeurigheid van de wortel wilt hebben, moet je misschien steeds de laatst gevonden wortel vergelijken met de vorige gevonden wortel, en dan stoppen als het verschil tussen beiden klein genoeg is geworden).

Laatste test:  probeer voor de grap eens  X = -25  en D = 0,01......
 

While ... End

 

simuleren

   
  OPGAVEN
   
1. Onderzoek wat er in het laatste voorbeeld verkeerd gaat en repareer het programma.
       
2. Onderzoek door een geheugenschema te maken wat het programma hiernaast doet.
PROGRAM ?????
:  INPUT"GETAL 1?", A
:  INPUT"GETAL 2?", B
:  INPUT"GETAL 3?", C
:  D = 2
:  While B < C
:       B → E
:       A + B  →  B
:       E → A

:       D + 1 → D
:  End
:  Disp  D
       
     
       

h.hofstede (h.hofstede@hogeland.nl)