FORTRAN: 1. FORTRAN

HANDLEIDING FORTRAN

HOOFDSTUK 1: FORTRAN

1.7 Executeerbare statements

FORTRAN kent onder meer de volgende executeerbare statements: assignment, control en I/O statements. Assignment statements kennen een waarde toe aan een variabele. Control statements veranderen de volgorde van executie van de FORTRAN statements van een programma. De belangrijkste control statements zijn:

       GO TO, IF, DO, CALL, RETURN, STOP, END

I/O statements lezen en schrijven data van en naar het centrale geheugen. I/O kan geschieden van en naar disk, tape, floppy, kaartlezer, printer, enz.

Assignment statement
Een assignment statement is van de vorm variabele = expressie. De expressie heeft een goed gedefinieerde waarde (het resultaat van de expressie) en is van een van de bovengenoemde 6 types. Deze waarde wordt na evaluatie aan de variabele toegekend. Dus bijvoorbeeld:
```
       A = 2.0 / 3.0 + 1.0
       B = 2 / 3
```
geeft de real variabele A de waarde 1.66666 en de real B de waarde 0.000000 (denk er aan dat een real constante een decimale punt bevat en een integer constante niet). In de tweede regel hebben we een arithmetische expressie met integer waarde, die toegekend moet worden aan de real variabele B. FORTRAN evalueert eerst de expressie en converteert dan naar het type van het linkerlid.
Ander voorbeeld:
```
       L = I .GT. J
```
Als L als logical gedeclareerd is, krijgt L de waarde van de relationele expressie. Als L geen logical is volgt een foutmelding van de compiler.
Vraag: wat is de waarde van L in onderstaande voorbeeld?
```
       LOGICAL L
       L = ( 2./4. **2 .EQ. (2./4.)**2 )
```
Een voorbeeld van een assignment van een character variabele:
```
       CHARACTER*5  L1, L2
       CHARACTER*10 L
       L1 = 'AAP  '
       L2 = 'NOOT '
       L  = L1 // L2
```
De character konstanten worden toegekend aan de character variabelen L1 en L2, en daarna krijgt L een geconcateneerde waarde.
Control statement -- keuze: GO TO statement
Het GO TO (of GOTO) statement dient om de uitvoering van programma-instructies op een andere plaats in het programma --- aangegeven door een label --- verder te laten gaan.
Voorbeeld:
```
           GO TO 100
           RADIUS = R
       100 A = B/C
           C = 10.
```
Na executie van het statement GO TO 100 wordt het statement met label 100 uitgevoerd, d.w.z. het tweede statement wordt overgeslagen. Merk op dat het altijd overgeslagen wordt, de meeste compilers waarschuwen hiervoor. Na het derde statement wordt het vierde uitgevoerd, enz.

Control statement -- keuze: IF statement

In het algemeen wordt een GO TO gecombineerd met een IF statement. Vormen van het IF statement zijn de ``logische IF'' en de ``block IF''. In onderstaande staat ``expressie'' voor een relationele of een logische expressie (dus iets met de waarde ``waar'' of ``onwaar''), deze moet tussen haakjes. In onderstaande kan ``statement'' elk executeerbaar statement zijn. De logische IF heeft de vorm:

          IF ( expressie ) statement

De block IF heeft de vorm:

       IF ( expressie ) THEN
         statement
         statement
          ....
       ELSE
         statement
         statement
          ....
       ENDIF

of ook:

       IF ( expressie ) THEN
         statement
         statement
          ....
       ELSE IF ( expressie ) THEN
         statement
         statement
          ....
       ELSE IF ( expressie ) THEN
         statement
         statement
          ....
       ELSE
         statement
          ....
       ENDIF

Voorbeelden:
Spring naar 99999 als ``I .NE. J'' en tegelijk ``K .NE. M'':

       LOGICAL L
       L = K .NE. M
       IF ( (I .NE. J)  .AND.  L ) GO TO 99999
        ....
 99999 CONTINUE

Bepaal het maximum van I en J:

       IF ( I .LT. J ) THEN
         MAX = J
       ELSE
         MAX = I
       ENDIF

Control statement -- herhaling: DO statement
Vaak gebeurt het dat men één of meer statements een aantal malen uit wil voeren. In FORTRAN kan hiervoor de DO loop gebruikt worden. Algemene vorm:
```
       DO label var = expr1, expr2, expr3
         statement
         statement
          ....
 label CONTINUE
```
Hier is ``var'' een integer, real of double precision variabele, (maar in de praktijk vrijwel altijd een integer), ``expr1'', ``expr2'' en ``expr3'' zijn arithmetische expressies, ``label'' is een FORTRAN label en ``statement'' is een executeerbaar statement.
Bij de executie van een DO loop gebeurt het volgende. Variabele ``var'' (de loopvariabele) krijgt eerst de waarde ``expr1'', waarna alle statements t/m het gelabelde (in dit geval CONTINUE) worden uitgevoerd. Vervolgens wordt ``var'' opgehoogd met ``expr3'' (het increment) en de statements worden weer uitgevoerd. Dit gaat door tot de waarde van ``var'' groter is dan ``expr2'', in dat geval gaat de executie verder met het eerste statement na CONTINUE.
Als bij het begin van de loop de waarde van ``expr1'' groter is dan de waarde van ``expr2'', worden de statements van de do loop niet uitgevoerd!
Voorbeelden:
- Maak de elementen van een array nul (als ``expr3'' niet genoemd wordt, wordt 1 als increment genomen):
```
       DO 10 I=1,10
          A(I) = 0.
    10 CONTINUE
```
- Sommeer de diagonaalelementen van een array (de zg. trace):
```
        DIMENSION A(10,10)
        TRACE = 0.
        DO 1000 I=1,10
           TRACE = TRACE + A(I,I)
   1000 CONTINUE
```
  Als de bovengrens ``expr2'' kleiner is dan de ondergrens ``expr1'', wordt de DO loop overgeslagen. De expressies ``expr2'' en ``expr3'' worden uitgerekend voordat de loop begint, en niet meer veranderd tijdens de de loop. Als ``expr2'' of ``expr3'' afhangen van variabelen die in de loop veranderen, dan veranderen ``expr2'' en ``expr3'' niet mee.
  Voorbeeld:
```
        N = 1
        M = 5
        DO 10 K=N**2,M**2,M-N
           N = N + 10
     10 CONTINUE
```
  In dit voorbeeld neemt K achtereenvolgens de waarden 1, 5, 9, 13, 17, 21 en 25 aan; de loop wordt zeven maal uitgevoerd.
- Binnen een DO loop mag weer een DO loop staan. Dit is het nesten van DO loops. Uiteraard moeten de geneste DO loop variabelen verschillend zijn. In het volgende voorbeeld vermenigvuldigen we twee matrices, d.w.z. we berekenen
```
   $C$ _{i j} =  $sum_k=1_^n^$  A_{i k} B_{k j} 
```
  voor i,j=1,...,n.
```
  C     WE NEMEN AAN DAT MATRIX A EN B GEINITIALISEERD ZIJN
  C     EN BEREKENEN C.
        DO 30 I=1,N
           DO 20 J=1,N
              C(I,J) = 0.
              DO 10 K=1,N
                 C(I,J) = C(I,J) + A(I,K)*B(K,J)
     10       CONTINUE
     20    CONTINUE
     30 CONTINUE
```
  Men mag met een GO TO of via de END optie van READ uit een DO loop springen. De DO loop variabele houdt zijn waarde.
  Men mag nooit in het bereik van een DO loop springen, om de eenvoudige reden dat de DO loop variabele dan niet gedefinieerd is.
Control statements: RETURN, END, STOP statement
We zullen het CALL statement later behandelen en bekijken nu RETURN, END en STOP.
Een (sub)programma wordt altijd aangeroepen door een ander programma (in het geval van een hoofdprogramma is het aanroepende programma het operating systeem, bijv. DOS). Het RETURN statement geeft de executie terug aan het aanroepende programma.
END is tegelijkertijd een compiler (niet-executeerbaar) statement en een executeerbaar statement en mag een label dragen. Een END statement vertelt de compiler dat het einde van het hoofdprogramma, subroutine of functie bereikt is. Tijdens executie is END hetzelfde als RETURN, d.w.z. tijdens de executie van een hoofdprogramma wordt de controle teruggegeven aan het operating systeem, wat betekent dat het programma stopt.
Het STOP statement geeft altijd de controle terug aan het operating systeem (d.w.z. stopt de executie van het programma).
RETURN en STOP mogen overal staan, maar END moet de laatste regel van een (sub)programma zijn.
De volgende twee programmafragmenten doen hetzelfde, mits ze in een hoofdprogramma voorkomen:
```
          IF ( I .LT. 0 ) STOP
             ....
          END
```
en
```
          IF ( I .LT. 0 ) GO TO 10
             ....
       10 END
```
Als de programmafragmenten in een subprogramma voorkomen is er een groot verschil: in het eerste geval wordt de executie van het programma beëindigd; in het tweede geval gaat de executie verder met het aanroepende programma.

Updated 05-feb-1997, pfk