HANDLEIDING FORTRAN

HOOFDSTUK 1: FORTRAN

1.4 Intermezzo: FORTRAN/DOS oefeningen

Om iets in FORTRAN te kunnen doen is het nodig om variabelen in te kunnen lezen van het toetsenbord en naar het scherm weg te kunnen schrijven. Daarom onderbreken we de taalbeschrijving, vertellen eerst de eenvoudigste manier van lezen en schrijven, en lopen vooruit op een paar andere FORTRAN statements, die we later wat uitgebreider zullen behandelen, maar nu al nodig hebben.

De eenvoudigste leesopdracht voor het inlezen van een aantal variabelen ``var1, var2, ...'' heeft de volgende vorm:

        READ (UNIT=5, FMT=*, END=kkkkk) var1, var2, ....

De variabelen worden ingelezen van unit 5, dit is meestal het toetsenbord. Met ``FMT=*'' wordt aangeduid dat het FORMAT aan de compiler overgelaten wordt en ``kkkkk'' is een FORTRAN LABEL (1 tot 5 cijfers), waarheen het programma springt als een END-OF-FILE (afgekort EOF) conditie gedetecteerd wordt (in DOS gebeurt dit na invoer van het character CTRL-Z van het toetsenbord).

Het schrijven naar het scherm gaat als volgt:

        WRITE (UNIT=6, FMT=*) var1, var2, ...

Hierbij geeft unit 6 het scherm aan. Merk op dat er bij het schrijven van informatie geen EOF konditie op kan treden.
Voorbeeld:

  C PROGRAMMA VOOR KWADRATEN:
  C     DIT PROGRAMMA BEVAT EEN LOOP DIE VERLATEN WORDT ALS ER EEN EOF CONDITIE
  C     ONTDEKT WORDT (DO UNTIL EOF).
  C
        DOUBLE PRECISION QUADR
  C
    100 CONTINUE
           READ  (UNIT=5, FMT=*, END=200) QUADR
           WRITE (UNIT=6, FMT=*) 'HET KWADRAAT IS: ', QUADR*QUADR
        GO TO 100
  C
    200 CONTINUE
        END

In het write statement wordt een character constante tezamen met een double precision real naar het scherm geschreven. Merk op dat vermenigvuldiging in FORTRAN met een ``*'' aangegeven wordt. Statement ``GO TO 100'' is een niet-conditionele sprongopdracht, waarbij 100 het label van het executeerbare statement CONTINUE is. Dit laatste statement doet niets (het is een ``dummy'' opdracht), de programmacontrole zorgt ervoor dat het erop volgende executeerbare statement (in dit geval de READ) wordt uitgevoerd. Bij EOF detectie springt het programma naar het statement dat label 200 heeft.

Het programma wordt --- net zoals alle FORTRAN (sub)programma's --- afgesloten met een END statement. Dit statement vertelt de compiler dat dit het einde van de programmacode is en dat er geen andere statements van dit (sub)programma meer volgen.

In het volgende voorbeeld wordt een real array A van dimensie 1000 gedeclareerd. Integer LA geeft de lengte van het array. In de GO TO loop wordt het array gevuld vanaf het toetsenbord; de loop wordt beëindigd ofwel door EOF (de normale konditie), ofwel door uit het array te lopen (de abnormale conditie), waarop executie van het programma stopt (met het STOP statement). We komen later terug op het IF ... THEN ... ELSE statement.

In de tweede helft van het programma worden de ingelezen variabelen (de elementen van A) met behulp van een DO loop naar het scherm geschreven. Het WRITE statement wordt achtereenvolgens uitgevoerd voor de waarden I=1,2,...,N. Het CONTINUE statement wordt gewoonlijk gebruikt om het einde van een DO loop aan te geven. Het commando DO 30 I=1,N laat de computer alle statements t/m het statement met label 30 uitvoeren voor I oplopend van 1 t/m N.

        DIMENSION A(1000)
        LA = 1000
  C
  C     LEES RECORDS VAN TOETSENBORD TOT 'END OF FILE'.
  C     HET TOETSENBORD IS GEWOONLIJK UNIT 5.
  C
        I = 0
     10 I = I + 1
  C         LEES ALLEEN VOLGENDE GETAL ALS WE NIET UIT HET ARRAY LOPEN
            IF (I .LT. LA) THEN
               READ (UNIT=5, FMT=*, END=20) A(I)
            ELSE
               WRITE (UNIT=6, FMT=*) 'TE VEEL VARIABELEN, PROGRAMMA STOPT'
               STOP
            ENDIF
        GO TO 10
  C
  C     MERK OP DAT A(I) OP DIT PUNT GEEN WAARDE HEEFT, HET ARRAY
  C     IS INGELEZEN TOT EN MET I-1
     20 N = I - 1
        WRITE (UNIT=6, FMT=*) 'AANTAL INGELEZEN DATA', N
  C
        DO 30 I=1,N
            WRITE (UNIT=6, FMT=*) A(I)
     30 CONTINUE
  C
        END

OPGAVEN:

1. Maak een programma dat reals ``echoot'', d.w.z. inleest van het toetsenbord en naar het scherm schrijft. Zet een leesopdracht en een corresponderende schrijfopdracht in een oneindige loop, en spring naar een label buiten de loop via de END optie van de READ. Schrijf dan het totaal aantal ingelezen (en geschreven) variabelen op de terminal en beëindig executie.
2. Maak een programma dat N! berekent. Lees de integer N in en bereken via een DO loop N!

           N! = 1 * 2 * 3 * ... * N
   

   Zet het hele programma in een loop tot EOF, zoals in de vorige opgave, en bereken de faculteit van 1 t/m zo hoog mogelijk. Voor zekere N krijg je een foutenboodschap, waarom?
3. Maak een programma dat N! berekent als een real. Doe hetzelfde als in de vorige opgave maar met N real.
   Aanwijzing: R = REAL(I) maakt van de integer I een real R. Probeer hoe hoog je nu kan komen met N.
4. Maak een programma dat N! berekent in double precision. Doe hetzelfde als in de vorige opgave maar met N double precision.
   Aanwijzing: D = DBLE(I) maakt van de integer I een double precision real D. Probeer hoe hoog je nu kan komen met N.
5. Maak een programma dat log N! berekent in double precision. De FORTRAN natuurlijke logarithme is LOG, d.w.z. D = LOG(R) geeft aan D de waarde log(R). Bereken log(N!) via iteratie met behulp van

           log (N!) = log ((N-1)!) + log(N)     voor  N <= 100
   

   Zet de tussenresultaten in een double precision array DOUBLE PRECISION DLFAC(100) en schrijf de waarde EXP(DLFAC(N)) naar het scherm ter controle.