|
Toekennen en Logisch vergelijken
Toekennen van gehele getallen
Bestudeer het programma TOEKENN.rex om kennis te maken met toekenning
van waarden aan variabelen in REXX.
<![CDATA[
/* REXX */
a = 12 /* initialisatie */
b = 3
c = a + b /* 1 */
c = a - b /* 1 */
c = a * b /* 1 */
c = a / b /* 1 */
c = a % b /* 1 */
c = 12 * a + b / 2 - a * b * 2 / (a * c + b * 2) /* 2 */
c = c / 4 + 13 * (a + b) / 3 - a * b + 2 * a * a /* 2 */
a = a + 1 /* 3 */
b = b * 5 /* 3 */
Exit 0
]]>
Er worden drie variabelen gebruikt. Het programma is
niet veel meer dan een serie voorbeelden van een toekenning. De eerste
twee statements kennen een initiele waarde toe aan de variabelen
a en b. De volgende vijf statements (1) tonen de
vier basis reken functies (som, verschil, produkt en quotient) en hoe
ze te gebruiken. De vijfde is de modulo functie en geeft de rest bij
deling.
Dan volgen twee statements (2) die laten zien hoe een en ander
gecombineerd kan worden tot een complexe expressie. De daarop volgende
twee statements (3) dienen om een variabele met een bepaalde waarde te
verhogen.
Het zal duidelijk zijn dat geen van de gegeven voorbeelden van enig nut
zijn.
Het programma drukt niets af, dus interpreteren en testen heeft niet echt
veel zin. Wil je het programma toch testen, voeg dan Say
statements toe. Je weet inmiddels hoe dat moet.
Toekennen aan andere data types
Programma TKANDER.rex laat zien hoe nog andere datatypes gebruikt kunnen
worden. Opnieuw zijn hier een paar variabelen geinitialiseerd.
Zoals je ziet kunnen in REXX de datatypen door elkaar toegepast worden.
De variabele v krijgt als inhoud achtereenvolgens een integer,
een float, een string en een karakter.
<![CDATA[
/* REXX */
a = -27 /* initialisatie */
b = 9.7531
c = 'Jan'
d = 'A'
v = a /* v wordt integer -27 */
v = b /* v wordt float 9.7531 */
v = c /* v wordt string Jan */
v = d /* v wordt karakter A */
Exit 0
]]>
Het datatype float, ook wel bekend als
floating point, heeft een groot waardebereik, een groot
aantal decimalen en beslaat een groot aantal bytes in het geheugen.
Floating point getallen bevatten een impliciet komma-getal.
De data types van REXX
Bestudeer het programma DATATYPS.rex. Dit programma bevat alle standaard
datatypes die in de programmeertaal REXX beschikbaar zijn. Er zijn nog
andere datatypes, de structuren, maar die zullen we later behandelen.
<![CDATA[
/* REXX */
Say DataType('azAZ09','A')
Say DataType('01','B')
Say DataType('az','L')
Say DataType('azAZ','M')
Say DataType('123.45','N')
Say DataType('AZ','U')
Say DataType('12345','W')
Say DataType('1234567890ABCDEF','X')
Exit 0
]]>
In het voorbeeld worden voor ieder mogelijk datatype de REXX functie
DataType aangeroepen. Deze functie levert een TRUE of een FALSE af,
al naar gelang de inhoud van de variabele.
Wanneer een variabele slechts bestaat uit de letters a t/m z, A t/m Z,
of 0 t/m 9, dan is het type van deze variabele Alphabetic.
Wanneer een variabele slechts bestaat uit de cijfers 0 of 1, dan is
het type van deze variabele Binary.
Wanneer een variabele slechts bestaat uit de letters a t/m z, dan is
het type van deze variabele Lowercase.
Wanneer een variabele slechts bestaat uit de letters a t/m z, A t/m Z,
dan is het type van deze variabele Mixed Case.
Wanneer een variabele slechts bestaat uit de cijfers met eventueel
een decimale punt, dan is het type van deze variabele Numeric.
Wanneer een variabele slechts bestaat uit de letters A t/m Z,
dan is het type van deze variabele Uppercase.
Wanneer een variabele slechts bestaat uit cijfers,
dan is het type van deze variabele Whole Number.
Wanneer een variabele slechts bestaat uit cijfers, de letters a t/m f,
de letters A t/m F, dan is het type van deze variabele HeXadecimal.
Je zult altijd in het Reference Manual van de gebruikte interpreter
moeten kijken voor een exacte definitie van deze typen, omdat ze
implementatie afhankelijk zijn.
Logisch vergelijken
Bestudeer nu het programma VERGELYK.rex, waarin een aantal voorbeelden
van vergelijkingen staan. Het programma begint met de declaratie en
initialisatie van een negen-tal variabelen die daarna in een aantal
vergelijkingen worden gebruikt.
<![CDATA[
/* REXX */
x = 11; y = 11; z = 11
a = ' '; b = ' '; c = ' '
r = 12.987; s = 12.987; t = 12.987
/* Eerste groep */
If (x = y) Then z = -13 /* z wordt -13 */
If (x > z) Then a = 'A' /* a wordt 'A' */
If \(x > z) Then a = 'B' /* er verandert niets */
If (b <= c) Then r = 0.0 /* r wordt 0.0 */
If (r <> s) Then t = z / 2 /* t wordt -6.5 */
/* Tweede groep */
x = 77; y = 77; z = 77 /* initialisatie */
If ((x = y) & (x = 77)) Then z = 33 /* z wordt 33 */
If ((x > y) | (z > 12)) Then z = 22 /* z wordt 22 */
/* Tweede groep */
x = 77; y = 77; z = 77 /* initialisatie */
If ((x = y) & (x = 77)) Then z = 33 /* z wordt 33 */
If ((x > y) | (z > 12)) Then z = 22 /* z wordt 22 */
/* Derde groep */
If (x = x) Then z = 27.345 /* z veranderd altijd ! */
If (1) Then z = 27.345 /* TRUE, z veranderd altijd ! */
If (x <> x) Then z = 27.345 /* z veranderd niet */
If (0) Then z = 27.345 /* FALSE, z veranderd niet */
Exit 0
]]>
De eerste groep van vergelijkingen
De eerste groep van vergelijkingen geven de eenvoudigste vorm van
vergelijken weer, omdat ze slechts twee variabelen vergelijken. Elke
variabele mag vervangen worden door een constante, echter twee
constanten met elkaar vergelijken lijkt weinig zinvol. De eerste
vergelijking controleert of x gelijk is aan y en
gebruikt daarvoor een is-gelijk (=) teken als operator. REXX
gebruikt het enkele is-gelijk teken (=) zowel voor de toekenning
als de vergelijking. De tweede
vergelijking controleert of x groter is dan y.
De derde introduceert de not operator, zijnde het
BackSlah-teken, die gebruikt wordt om het resultaat van een logische
vergelijking te inverteren. De vierde controleert of b
kleiner of gelijk is aan c De laatste controleert of
r ongelijk is aan s.
In het voorgaande hoofdstuk hebben we geleerd dat als de expressie
volgend op If WAAR is, het statement van de If
wordt uitgevoerd. De resultaten van de voorbeelden staan er als
commentaar achter vermeld.
Om het voorbeeld compact te houden is hier alles zo veel mogelijk op
een regel gezet, hetgeen afwijkt van de voorgestelde standaard.
De tweede groep van vergelijkingen
De tweede groep behandelt de logische and en de logische
or. De drie variabelen krijgen eerst de waarde 77 toegekend.
De eerste vergelijking bevat de & operator, wat de
logische and is. Het statement luidt: als x
gelijk is aan y EN als x gelijk is aan
77 dan is het resultaat WAAR. Omdat dit WAAR is, wordt z 33.
De volgende vergelijking introduceert de | operator, die de
logische or is. Het statement luidt: als x
groter is dan y OF als z groter is dan
12, is het resultaat WAAR. Omdat z groter is dan 12 maakt
het niet meer uit of x groter is dan y of niet.
Het resultaat is WAAR, daarom wordt z 22.
De derde groep van vergelijkingen
In het eerste voorbeeld wordt x met zichzelf vergeleken,
hetgeen altijd WAAR zal zijn. Het statement zal WAAR opleveren
waardoor z altijd zal veranderen.
In het tweede voorbeeld wordt er helemaal niets vergeleken,
de expressie heeft direct de waarde 1,
hetgeen altijd WAAR zal zijn. Het statement zal WAAR opleveren
waardoor z altijd zal veranderen.
Her derde en laatste statement tenslotte zal altijd de waarde nul
opleveren en dus ONWAAR zijn. Het statement achter de
voorwaarde zal dus nooit worden uitgevoerd.
Evaluatie van expressies
Evaluatie van een samengestelde expressie vindt plaats van links naar
rechts en wordt volledig uitgevoerd.
De expressie moet evalueren naar TRUE of FALSE.
Soms is het handig een samengestelde expresie op te delen in een of
meerdere geneste If statements. Het programma zal dan sneller draaien.
Beslissingen (statements met een voorwaarde) zijn bijzonder belangrijk
en moeten goed doordacht worden om zo efficiënt mogelijke REXX programma's
te schrijven. Als nog niet alles wat er besproken is tot je is
doorgedrongen, raadt ik je aan een en ander nog eens door te lezen.
Voorrang regels
Het is altijd weer de vraag welke de voorrang regels zijn die de interpreter hanteert
tussen de diverse operators. Welke operators gaan voor de andere. Denk hierbij
aan vermenigvuldigen en delen die voor optellen
en aftrekken gaan. Ik wil voorstellen om dit niet aan het
toeval over te laten, doch expressies van zoveel mogelijk haakjes te voorzien.
Haakjes hebben de hoogste voorrang en maken in een klap duidelijk wat er
precies moet gebeuren. Kijk eens naar de voorbeelden uit de tweede groep
van het programma VERGELYK.rex.
| 
