Wikibooks

Programmeren in REXX/Functies deel 2: verschil tussen versies

Interactief door geschiedenis bladeren
← Vorige wijzigingVolgende wijziging →
Verwijderde inhoud Toegevoegde inhoud
VisueelWikitekst
GuyDC (overleg | bijdragen)
304 bewerkingen
GuyDC (overleg | bijdragen)
304 bewerkingen
Verbeteringen tekst - navigatiesjabloon
Regel 1:
{{Programmeren in REXX}}
In dit hoofdstuk behandelen we een tweede reeks functies die standaard met REXX functieswordt geleverd.
 
Het gaat om functies die toelaten getallen te formatteren. ofOok omfuncties tedie zettengetallen of strings omzetten van één formaat in een ander. We overlopen ook nog even hoe REXX rekent met getallen werkt en hoe we de nauwkeurigheid van de uitkomsten kunnen bepalen.
 
Zoals steeds zullen resultaten tussen « en » worden getoond. Als er sprake is van een '''pad''' karakter, dan dient dit karakter om de (kortste) string op te vullen. Standaard wordt daar de spatie voor gebruikt.
 
=Hoe rekent REXX ?=
Het resultaat van een numerischenumerieke bewerking is een karakterreeks. De regels die daarbij spelen zijn:
*Het resultaat is berekend tot een maximaal aantal significante cijfers. Standaard is de nauwkeurigheid beperkt tot 9 cijfers, maar dit aantal kan aangepast worden zoals we verder zullen leren. Indien het resultaat meer cijfers nodig heeft wordt het afgerond, dus 2/3=0.666666667;
*Behalve bij deling en machtsverheffing worden de nullen aan eind van de decimalen behouden, dus 2.40+2=2.40;
*Als het resultaat nul is dan wordt het steeds als één enkel cijfer 0 voorgesteld;
*Exponentiële notatie wordt pas gebruikt als het aantal significante cijfers voorvóór het decimaal punt groter wordt dan de nauwkeurigheid (standaardwaarde=9). Ook indien het aantal decimalen meer dan 2 maal de precisie overschrijdt, schakelt REXX over op exponentiële notatie, bijvoorbeeld:
1e6 * 1e6 «1E+12» en niet «1000000000000»
1 / 3E10 «3.33333333E-11» en niet «0.0000000000333333333»
*Alvorens een berekening aan te vatten zal REXX de spaties wegnemen. Noteer dat ".92" omgezet wordt tot "0.92". Het getal wordt dan beperkt tot het aantal significante cijfers plus één. De bewerking zelf gebeurt met het dubbele van de opgegeven nauwkeurigheid (standaard dus 2*9 cijfers);
*Noteer dat ".92" omgezet wordt tot "0.92".
*Machtsverheffing kan enkel met een exponent die een '''geheel''' positief of negatief getal is.
<!----------------------------------------------------------------------------------------------->
=NUMERIC - nauwkeurigheid van bewerkingen bepalen=
Alvorens dieper in te gaan op de numerieke functies moeten we het bevel '''numeric''' nog onder de loep nemenbespreken.
'''numeric digits''' [uitdrukking]
of
Regel 25 ⟶ 26:
'''numeric form''' [formaat]
De eerste vorm bepaalt hetde aantal cijfersnauwkeurigheid waarmee getallennumerieke internbewerkingen moeten worden opgeslagenuitgevoerd. Standaard worden daarvoor 9 significante cijfers gebruikt, dus enkel getallen tussen 0,00000001 en 999.999.999 zijn bruikbaar. Wil men met grotere getallen kunnen werken dan moet uitdrukking leiden tot een getal groter dan 9.
<br id=DIGITS>Noteer dat met de functie '''digits()''' de actuele cijfergrootte kan worden opgevraagd.</br>
say 1*999999999 &#171;999999999&#187;
say 1*9999999999 &#171;1.00000000E+10&#187;
Dus, eens men de nauwkeurigheid overschrijdt wordt het getal afgerond.
 
Met '''numeric fuzz''' kunnen we bepalen tot op hoeveel decimalencijfers debij berekeningenvergelijkingen moeten worden uitgevoerd. We bepalen hiermee m.a.w. de nauwkeurigheid van de berekeningenverwaarloosd. DeDit nauwkeurigheidaantal moet kleiner zijn dan digits().
<br id=FUZZ>De actuele decimale nauwkeurigheid kan worden opgevraagd met de functie '''fuzz'''. De "numeric fuzz" kan lokaal voor een subroutine worden veranderd.
en zal dus ook invloed hebben op eventuele afrondingen van getallen.</br>
numeric fuzz 5
say 0.123456789=0.123409876 &#171;0&#187;
numeric fuzz 6
say 0.123456789=0.123409876 &#171;1&#187;
 
Met '''numeric form''' tenslotte controleren we de vorm van de exponentiële notatie van getallen. We kunnen 2 formaten kiezen:
Regel 36 ⟶ 44:
*'''engeneering''', waarbij in het exponentieel deel de macht steeds een veelvoud van 3 is.
<br id=FORM>De actuele exponent-vorm kan men opvragen met de functie '''form()'''.</br>
numeric form scientific
say 1*9999999999 &#171;1.00000000E+10&#187;
numeric form engineering
say 1*9999999999 &#171;10.0000000E+9&#187;
 
=Manipulatie van getallen=
Regel 62 ⟶ 74:
say datatype('3','Logical') datatype(12,'O') &#171;0 0&#187;
say datatype('01000001'b,'B') &#171;0&#187;
In het laatste geval is de binaire string gelijk aan '41'x, of de letter &#171;A&#187; in het ASCII stelsel, en dat is noch een karakter 1 ('31'x) noch een karakter 0 ('30'x), dus geen string die een binair getal voorstelt.
 
Met de gelijkwaardige types '''V'''ariable en '''S'''ymbol wordt getest of de string een syntactisch geldige naam heeft om als REXX variabele gebruikt te kunnen worden.
Regel 71 ⟶ 83:
'''symbol'''(''"token"'')
Deze functie antwoord:
*'''&#171;BAD&#187;''' als het token geen geldige naam isheeft om als variabele gebruikt te worden;
*'''&#171;LIT&#171;''' als het wel een geldige naam isheeft, doch nog niet is geïnitialiseerd;
*'''&#171;VAR&#187;''' als het een geldige naam isheeft en ooktevens geïnitialiseerd is geïnitialiseerd.
Hier is het belangrijk te begrijpen dat we het te onderzoeken token als een constante moeten schrijven, anders onderzoeken we de '''inhoud''' van het token op geldigheid.
 
Regel 82 ⟶ 94:
say symbol(hello) &#171;LIT&#187;
say symbol("Hello") &#171;LIT&#187;
In het tweede geval maken we de fout de variabele niet als constante te schrijven, en dus testen we "10", en dit iswat geen geldig token is. In het derde geval lukt het nog net omdat ''hello'' nog niet geïnitialiseerd is, en dus zichzelf als waarde heeft. Maar het laatste voorbeeld is dus veelaltijd veiliger.
<!------------------------------------>
==ABS - Absolute waarde van een getal==
'''abs'''(''getal'')
Deze functie geeft de absolute waarde (positieve waarde) van het getal terug. De opgegeven parameter kan natuurlijk een uitdrukking zijn die na interpretatie in een getal resulteertmoet resulteren. Is het geen getal, andersdan ishebben erwe een uitvoeringsfout (93: Target must be a number).
say abs(24-12) &#171;12&#187;
say abs(12-24) &#171;12&#187;
Regel 93 ⟶ 105:
'''max'''(''getal''[,''getal''][,''getal'']...)
'''min'''(''getal''[,''getal''][,''getal'']...)
Deze functies antwoordengeven metrespectievelijk het grootste, respectievelijkof het kleinste van een reeks getallen (of variabelen die getallen bevatten)terug.
a=12 ; b=14
say max(a,b,24) min(4,-1*b,24) &#171;24 -14&#187;
Regel 120 ⟶ 132:
Het ''getal'' wordt eerst afgerond volgens de geldende afrondingsregels. Het resultaat is exact gelijk aan wat "getal+0" zou geven.
 
Men kan echter ook bepalen hoeveel cijfers er in het resultaat ''vóór'' en/of ''na'' de komma moeten komen. Geeft men een aantal ''vóór'' de komma diedat te klein is om het getal te kunnen bevatten, dan treedt er een fout op. Hou daarbij ook rekening met een eventueel minteken. We kunnen ook meer posities voor de komma voorzien, in welk geval er spaties vooraan worden toegevoegd. Deze functie is, zoals haar naam impliceert, nuttig om het formaat van getallen onder controle te houden, bijvoorbeeld om de decimale punten onder elkaar te aligneren.
say trunc(10.676,2) &#171;10.67&#187;
say format(10.676,,2) &#171;10.68&#187;
Regel 127 ⟶ 139:
say format(12.343392211,4,3) &#171; 12.343&#187;
say format(12.343792211,4,3) &#171; 12.344&#187;
Merk het verschil op tussen '''trunc''' en '''format''' wat de afronding betreft.
<!---------------------------------------------------------------------------->
==Omzetten van formaten==
Regel 136 ⟶ 148:
Deze functie zal de binaire waarde van karakterreeks ''string'' omzetten naar een decimaal getal. Hiermee wordt bedoeld dat de ''string'' als een opeenvolging van bits wordt gezien, en dat die reeks dan als decimaal getal wordt geïnterpreteerd.
 
Een binaire waarde kan geïnterpreteerd worden als een absolute waarde, of een getal met een teken. In het laatste geval zal het getal negatief zijn als de eerste bit op 1 staat. Lees voor meer informatie over negatieve binaire getallen het artikel [[w:2-complement|Two's complement]]. De opgegeven ''lengte'' zal bepalen of de eerste bit op 1 staat en of we dus een negatief getal bekomen.
 
Dit zijn voorbeelden op een PC, dus voor een ASCII karaktertabel:
Regel 147 ⟶ 159:
say c2d('FF'x,2) &#171;255&#187;
In het laatste 2 gevallen hebben we een lengte meegegeven. Met een lengte 1 hebben we binair "11111111", en dus het negatief
(2-complement) getal -1. Met de lengte 2 hebben we binair echter "0000000011111111", en dat isresulteert dan weer in het positief getal 255.
<!------------------------------------->
===C2X - van karakter naar hexadecimaal===
'''c2x'''(string)
Onze string wordt nu omgezet innaar zijn hexadecimale notatievoorstelling. Het resultaat is een reeks karakters (0-9 en A-F).
say c2x("A") &#171;41&#187;
say c2x(' A') &#171;2041&#187;
Regel 164 ⟶ 176:
===D2X - van decimaal naar hexadecimaal===
'''d2x'''(getal)
Het getal wordt omgezet naar hexadecimale notatievoorstelling.
say d2x(10) &#171;A&#187; (dit is '0A'x, een controlekarakter)
say d2x(c2d('K')) &#171;4B&#187;
Regel 194 ⟶ 206:
say x2b(b2x(11110000)) &#171;11110000&#187;
say x2b(4B0) &#171;010010110000&#187;
In ons [[Programmeren in REXX/Voorbeeld 2 |tweede voorbeeld]] zullen we een programma beschrijven dat handig is om met deze functies vlot te kunnen werken.
<!----------------------------------------------------------------------->
==Binair rekenen==
Regel 227 ⟶ 240:
'''bitxor'''(string1[,string2][,pad])
say c2x(bitxor('11111111'b,'A')) &#171;BE&#187; ('10111110'b)
 
{{Sjabloon:Navigatie
|Boek =Programmeren in REXX
|vorige =Bevelen, deel 2
|huidige =Functies deel 2
|volgende=Parse in detail}}
{{sub}}
Informatie afkomstig van https://nl.wikibooks.org Wikibooks NL.
Wikibooks NL is onderdeel van de wikimediafoundation.