Hoe de Computed GOTO-verklaring en de IF-THEN-ENDIF-verklaring Werken in Programmeren

In de context van programmeerlogica speelt de controle van de stroom van uitvoering binnen een programma een essentiële rol. Twee krachtige hulpmiddelen die programmeurs kunnen gebruiken om de controle over de uitvoering van programma’s te sturen, zijn de Computed GOTO-verklaring en de IF-THEN-ENDIF-verklaring. Deze controle-instructies maken het mogelijk om efficiënt en flexibel programma’s te schrijven die reageren op variabele invoer en dynamisch kunnen aanpassen aan verschillende omstandigheden.

De Computed GOTO-verklaring wordt gebruikt om de controle van een programma over te dragen op basis van de waarde van een integer variabele. In dit geval wordt de controle over het programma naar verschillende secties gestuurd, afhankelijk van de waarde van deze variabele. Dit is vooral nuttig in programma's waar de uitvoering verschillende paden kan volgen, afhankelijk van de keuze van de gebruiker. Bijvoorbeeld, in een rekenmachineprogramma kunnen verschillende wiskundige bewerkingen – zoals optellen, aftrekken, vermenigvuldigen en delen – eenvoudig worden geïmplementeerd met behulp van de Computed GOTO-verklaring. De structuur van deze verklaring maakt het mogelijk om snel te schakelen tussen verschillende bewerkingen zonder dat er veel herhalende logica nodig is. Als de gebruiker bijvoorbeeld kiest voor een optelling, wordt de controle automatisch naar de juiste sectie gestuurd die de optelling uitvoert. Als de gebruiker echter kiest voor een andere operatie, wordt de controle naar de bijbehorende sectie gestuurd die de gekozen wiskundige bewerking uitvoert.

De kracht van de Computed GOTO-verklaring ligt in zijn eenvoud en het vermogen om het programma op een interactieve manier aan te passen. Het maakt het mogelijk voor de gebruiker om, zonder dat het hele programma opnieuw geladen hoeft te worden, nieuwe bewerkingen te kiezen en de uitvoer op basis van die keuzes aan te passen. Het is een effectieve manier om de uitvoering van een programma aan de wensen van de gebruiker aan te passen, wat in veel interactieve toepassingen, zoals rekenmachines, van groot belang is.

Een ander belangrijk type controle-instructie in veel programmeertalen is de IF-THEN-ENDIF-verklaring. Dit stelt programmeurs in staat om logische voorwaarden toe te voegen die bepalen of een bepaalde set instructies moet worden uitgevoerd. Als een opgegeven voorwaarde waar is, worden de bijbehorende statements uitgevoerd; zo niet, dan wordt de uitvoering van het programma voortgezet op het punt na de ENDIF. Dit biedt de mogelijkheid om complexe logica en voorwaarden toe te voegen aan een programma.

In de context van wiskundige berekeningen, zoals het berekenen van de sinus, cosine en exponentiële functies, kan de IF-THEN-ENDIF-verklaring worden gebruikt om te controleren of een bepaalde term in een reeks groot genoeg is om bij de som te worden opgeteld. Dit is essentieel bij het werken met oneindige reeksen, zoals die voor trigonometrische en exponentiële functies. De programma's die de cosinus, sinus en exponentiële functies berekenen, gebruiken een iteratieve benadering waarbij de termen in de reeks worden opgeteld totdat de waarde van een term kleiner wordt dan een bepaalde drempel (bijvoorbeeld 10^-8). Dit biedt een manier om de nauwkeurigheid van de berekeningen te waarborgen en tegelijkertijd de efficiëntie van het programma te verhogen door onnodige berekeningen te vermijden.

Het programma voor het berekenen van de cosinusfunctie bijvoorbeeld, start met de eerste term van de reeks en berekent vervolgens de volgende termen iteratief. Het blijft termen toevoegen totdat de waarde van de laatste berekende term kleiner is dan de drempelwaarde. Dit gebeurt binnen de IF-THEN-ENDIF-verklaring, waarbij gecontroleerd wordt of de absolute waarde van de laatste term groter is dan de drempelwaarde. Als dat het geval is, wordt de term toegevoegd aan de som en wordt de teller verhoogd. Zo niet, wordt de uitvoering van de reeks gestopt en wordt de uiteindelijke waarde van de functie weergegeven, samen met het aantal gebruikte termen en de waarde van de functie zoals berekend door de ingebouwde wiskundige functie van de programmeertaal.

Dit soort iteratieve benaderingen biedt de mogelijkheid om de nauwkeurigheid van wiskundige berekeningen te verbeteren zonder onnodige berekeningen uit te voeren. Het stelt programmeurs ook in staat om de prestaties van het programma te optimaliseren door de berekeningen te stoppen zodra de gewenste nauwkeurigheid is bereikt. Deze aanpak kan worden toegepast op verschillende wiskundige berekeningen, waaronder de berekeningen van trigonometrische functies en exponentiële functies.

Een belangrijk aspect van zowel de Computed GOTO-verklaring als de IF-THEN-ENDIF-verklaring is dat ze de programmeur de mogelijkheid geven om de uitvoering van een programma te sturen op een manier die flexibeler en dynamischer is dan bij statische controle-instructies zoals een standaard GOTO-verklaring. Beide technieken bieden meer controle over de manier waarop een programma reageert op invoer en hoe het zich aanpast aan veranderende omstandigheden tijdens de uitvoering.

Bij het gebruik van deze controle-instructies is het belangrijk dat programmeurs goed begrijpen hoe de flow van een programma zich aanpast op basis van de invoer en de voorwaarden die zijn ingesteld. De Computed GOTO-verklaring kan bijvoorbeeld worden gebruikt om gebruikersinteracties te beheren, zoals het kiezen van verschillende bewerkingen in een rekenmachine, terwijl de IF-THEN-ENDIF-verklaring essentieel is voor het werken met iteratieve wiskundige berekeningen en het beheren van voorwaarden voor het uitvoeren van bepaalde acties in een programma. Door deze technieken correct te gebruiken, kunnen programmeurs efficiëntere en meer dynamische toepassingen ontwikkelen die in staat zijn om complexere taken uit te voeren op basis van veranderende omstandigheden.

Hoe werkt controle van programma's met behulp van logische en iteratieve structuren in Fortran?

In veel gevallen is het nodig om de uitvoering van een programma te controleren op basis van bepaalde voorwaarden of herhalende handelingen uit te voeren. In de programmeertaal Fortran zijn er verschillende mechanismen voor controle die het mogelijk maken om deze taken efficiënt uit te voeren. Dit gebeurt bijvoorbeeld door logische expressies, controle-instructies zoals IF, PAUSE, en iteraties zoals DO-lussen. Het is belangrijk om te begrijpen hoe en wanneer je deze controlestructuren effectief kunt gebruiken, aangezien ze een fundamenteel onderdeel vormen van veel algoritmes.

Een van de eerste manieren waarop Fortran de controle binnen een programma aanstuurt, is via de IF-instructie. Deze instructie maakt het mogelijk om een programma afhankelijk van een logische voorwaarde verder te laten gaan. Een veelvoorkomend voorbeeld is het controleren of drie getallen de lengtes van de zijden van een driehoek kunnen vormen. De som van de lengtes van twee zijden van een driehoek moet altijd groter zijn dan de lengte van de derde zijde. In Fortran kan dit worden gecontroleerd door drie relaties aan elkaar te koppelen met de logische operator .AND.. Als aan alle drie de voorwaarden wordt voldaan, dan vormen de zijden een geldige driehoek. In de onderstaande code wordt dit geïllustreerd:

fortran
INTEGER a,b,c
PRINT*, 'Input a,b,c'
READ*, a, b, c
IF ((a+b .GT. c) .AND. (b+c .GT. a) .AND. (c+a .GT. b)) THEN
    PRINT*, a, b, c, ' form triangle'
ELSE
    PRINT*, a, b, c, ' do not form triangle'
END IF
STOP
END

De logica achter deze aanpak is simpel, maar krachtig. De voorwaarde wordt pas als waar beschouwd als alle drie de vergelijkingen (a+b > c, b+c > a, c+a > b) waar zijn. Dit zorgt ervoor dat de code eenvoudig kan bepalen of de ingevoerde zijden inderdaad een driehoek kunnen vormen.

Daarnaast komt een veelgebruikte controlemechanisme in Fortran voort uit de PAUSE-instructie. Soms wil je dat het programma tijdelijk stopt om de resultaten van eerdere berekeningen te bekijken voordat je verdergaat. Dit is handig als je bijvoorbeeld tussen verschillende stappen van het programma een beslissing moet nemen of de uitvoering moet voortzetten of stoppen. De PAUSE-instructie onderbreekt de uitvoer en vraagt de gebruiker om door te gaan door "go" in te voeren. Het gebruik van de PAUSE-instructie kan als volgt worden geïllustreerd:

fortran
WRITE(*,*) 'ENTER VALUES OF X AND Y'
READ(*,*) X, Y
WRITE(*,*) 'X,Y ', X, Y
PAUSE
WRITE(*,*) 'ENTER VALUES OF A AND B'
READ(*,*) A, B
WRITE(*,*) 'A,B ', A, B
STOP
END

Wanneer de PAUSE-instructie wordt bereikt, pauzeert het programma en wacht op de invoer van de gebruiker om door te gaan.

Naast deze eenvoudige controle-instructies biedt Fortran ook mechanismen om herhalingen in een programma in te bouwen via DO-lussen. DO-lussen maken het mogelijk om een blok van instructies meerdere keren achter elkaar uit te voeren. Dit is essentieel voor situaties waarin je een reeks handelingen meerdere keren moet herhalen, bijvoorbeeld het berekenen van een som of het uitvoeren van berekeningen op een reeks getallen. Een typisch voorbeeld is het berekenen van de som van de eerste honderd getallen:

fortran
INTEGER SUM

WRITE(*,*) 'PROGRAM TO FIND SERIES SUM S=1+2+3+4+......+100'
SUM = 0
DO 10 I = 1, 100
    SUM = SUM + I
10 CONTINUE
WRITE(*,*) 'THE SUM IS =', SUM
STOP
END

In dit voorbeeld wordt de waarde van SUM telkens met de waarde van I verhoogd, van 1 tot 100. De loop blijft herhalen totdat I groter is dan 100, waarna de uiteindelijke waarde van de som wordt weergegeven.

Een interessante uitbreiding van het DO-lusconcept is dat je de loop kunt aanpassen om specifieke reeksen van getallen te verwerken, bijvoorbeeld door alleen even of oneven getallen op te tellen. Dit kan eenvoudig worden gedaan door de incrementwaarde van de loop aan te passen. Als je bijvoorbeeld de som van alle even getallen tot 100 wilt berekenen, zou je de DO-lus als volgt schrijven:

fortran
DO I = 2, 100, 2

    SUM = SUM + I
END DO

Dit zorgt ervoor dat de lus alleen de even getallen in de opgegeven reeks verwerkt.

Een andere toepassing van de DO-lus is het berekenen van de faculteit van een getal. De faculteit van een getal is het product van alle positieve gehele getallen van 1 tot dat getal. Dit kan eenvoudig worden berekend met een DO-lus die telkens de waarde van de faculteit vermenigvuldigt met het huidige getal in de loop. In de onderstaande code wordt dit proces geïllustreerd:

fortran
WRITE(*,*) 'ENTER THE NUMBER'

READ(*,*) N
FACT = 1
DO I = 1, N
    FACT = FACT * I
END DO
WRITE(*,*) 'FACTORIAL OF ', N, ' IS ', FACT
STOP
END

In dit voorbeeld wordt de faculteit van een opgegeven getal N berekend door de variabele FACT op te bouwen door deze in elke iteratie van de loop te vermenigvuldigen met het huidige getal I.

Het is belangrijk om te begrijpen dat Fortran in staat is om niet alleen met integerwaarden te werken, maar ook met reële getallen. Dit is cruciaal wanneer de resultaten van berekeningen groter zijn dan wat met een integer kan worden opgeslagen, bijvoorbeeld bij het berekenen van faculteiten van getallen boven de 12. In dit geval wordt de faculteit in een reële variabele opgeslagen, omdat de uitkomst van een faculteit zoals 13! groter is dan het maximale integerbereik van een computer.

De mogelijkheden die Fortran biedt met deze controle-instructies zijn essentieel voor het bouwen van complexe en dynamische programma's. Het is belangrijk om deze structuren goed te begrijpen om ze effectief te kunnen gebruiken in verschillende situaties.

Hoe meet je de snelheid van een computer in GHz?

Het meten van de snelheid van een computer is niet altijd zo eenvoudig als het lijkt. Als we de snelheid in gigahertz (GHz) beschouwen, betekent dit dat de computer in staat zou moeten zijn om een miljard (10^9) operaties per seconde uit te voeren. Dit roept de vraag op: hoe snel is die snelheid in werkelijkheid? Stel je voor dat je 1.000 getallen moet tellen. Hoeveel tijd heb je daarvoor nodig? Als een computer echt in staat is om een miljard getallen per seconde te verwerken, zou dit proces in een fractie van een seconde moeten plaatsvinden. Maar hoe kunnen we dit daadwerkelijk testen?

Om de snelheid van een computer te meten, kunnen we een eenvoudige programmeertest uitvoeren. Een van de methoden is het gebruik van een lus die geen andere taken uitvoert dan het tellen van getallen. In dit geval gebruiken we de secnds(0.0) functie, die de kloktijd in seconden retourneert. Het verschil tussen de begintijd en de eindtijd van de lus geeft ons de tijd die de computer nodig had om het aantal berekeningen uit te voeren. Het volgende Fortran-programma laat zien hoe we dit kunnen doen:

fortran
C       Programma om getallen te tellen en de tijd te meten
         write(*,*)'Tellen van 10 miljard ....'
         t = secnds(0.0) ! secnds(0.0) geeft de kloktijd in seconden
         do i = 1, 1000000
            do j = 1, 10000
            enddo
         enddo
         t = secnds(0.0) - t
         write(*,*) 'Tijd om 10 miljard te tellen', t, 'seconden'
         end

Wanneer dit programma wordt uitgevoerd, zal het de tijd weergeven die nodig is om 10 miljard iteraties uit te voeren. Het resultaat kan bijvoorbeeld zijn: "Tijd om 10 miljard te tellen: 22 seconden". Dit betekent dat de computer, hoewel hij eigenlijk geen getallen optelt, wel tijd besteedt aan het controleren of de lus volledig is uitgevoerd.

Daarnaast kunnen we de cpu_time(v1) functie gebruiken om de tijd die de CPU daadwerkelijk gebruikt, te meten. Het voordeel van deze methode is dat deze de tijd in fracties van seconden teruggeeft, wat een preciezer inzicht geeft in de werkelijke prestaties van de CPU.

fortran
C       Programma om de tijd voor het tellen van de Indiase bevolking te meten

         real start, finish
         write(*,*) 'Tellen van 130 miljard ....'
         call cpu_time(start)
         do i = 1, 1000000
            do j = 1, 130000
            enddo
         enddo
         call cpu_time(finish)
         write(*,12) finish - start
12       format(f10.3,'secs')
         end

Dit programma simuleert het tellen van 130 miljard mensen, een interessante analogie voor de populatie van India. De uitvoer zou bijvoorbeeld kunnen zijn: "Tijd om 130 miljard te tellen: 302,219 seconden" — dat is meer dan 5 minuten. Dit benadrukt de complexiteit van het uitvoeren van grote hoeveelheden iteraties, zelfs voor een moderne CPU.

Werken met Datums en Tijden

Een ander belangrijk aspect van programma's die tijd meten, is het werken met datums en tijden. Fortran biedt een ingebouwde subroutine genaamd Date_and_Time(date, time, zone) die de huidige datum, tijd en tijdzone retourneert. Het is belangrijk om te begrijpen dat de waarden die door deze subroutine worden teruggegeven, als strings worden gepresenteerd, en niet als numerieke waarden. Dit betekent dat je deze waarden niet direct kunt gebruiken voor wiskundige bewerkingen. In plaats daarvan moeten ze eerst worden

Hoe de Oplossingen van Eerste Orde Differentiaalvergelijkingen te Berekenen: Euler, Runge-Kutta en Least Squares Methode

Bij het oplossen van differentiaalvergelijkingen van de eerste orde spelen de numerieke methoden een cruciale rol in het verkrijgen van oplossingen wanneer analytische oplossingen moeilijk of onmogelijk te vinden zijn. Twee van de meest gebruikte numerieke methoden zijn de Euler-methode en de Runge-Kutta-methode. Deze methoden maken het mogelijk om met behulp van discrete stappen tot een benadering van de oplossing te komen. Ook de least squares methode speelt een sleutelrol wanneer we een curve willen passen aan experimentele gegevens, zoals in de toepassing van lineaire of parabole fitting.

De Euler Methode

De Euler-methode is een eenvoudige numerieke methode die wordt gebruikt om de oplossingen van een differentiaalvergelijking van de eerste orde te benaderen. In deze methode wordt de oplossing stap voor stap berekend door de volgende benadering te gebruiken:

y_1 = y_0 + h \cdot \frac{dy}{dx}(x_0, y_0)

waar $h$ de stapgrootte is, en $\frac{dy}{dx}(x_0, y_0)$ de afgeleide van de functie op punt $(x_0, y_0)$ is. Door deze procedure iteratief toe te passen, kunnen we de oplossing benaderen over een interval van $x_0$ tot $x_n$ .

Hoewel de Euler-methode snel is, heeft het ook beperkingen, vooral als de stapgrootte te groot is. In dat geval kunnen de fouten snel oplopen, wat resulteert in onnauwkeurige resultaten.

De Runge-Kutta Methode

De Runge-Kutta-methode is een verbeterde versie van de Euler-methode en biedt een veel grotere nauwkeurigheid, vooral bij grotere stapgroottes. De meest gebruikte versie van deze methode is de vierde orde Runge-Kutta, die de volgende formules gebruikt:

k_1 = h \cdot \frac{dy}{dx}(x_0, y_0)

k_2 = h \cdot \frac{dy}{dx}(x_0 + \frac{h}{2}, y_0 + \frac{k_1}{2})

k_3 = h \cdot \frac{dy}{dx}(x_0 + \frac{h}{2}, y_0 + \frac{k_2}{2})

k_4 = h \cdot \frac{dy}{dx}(x_0 + h, y_0 + k_3)

De uiteindelijke waarde van $y_1$ wordt berekend als:

y_1 = y_0 + \frac{k_1 + 2(k_2 + k_3) + k_4}{6}

In dit geval worden de waarden van de afgeleiden op vier verschillende punten gebruikt, wat de nauwkeurigheid aanzienlijk verbetert ten opzichte van de Euler-methode. Deze methode is dus zeer geschikt voor het verkrijgen van zeer nauwkeurige oplossingen voor de meeste differentiaalvergelijkingen van de eerste orde.

Voorbeeld: Toepassing van de Runge-Kutta Methode

Stel je voor dat we de oplossing van de differentiaalvergelijking $\frac{dy}{dx} = \frac{x - y}{2}$ willen vinden met de initiële voorwaarden $x_0 = 0$ , $y_0 = 1$ , en een stapgrootte van $h = 0.1$ . Door de bovenstaande formules van de Runge-Kutta-methode toe te passen, krijgen we:

Voor $x_0 = 0$ , $y_0 = 1$ :

Na de eerste iteratie wordt de benaderde waarde van $y_1$ gelijk aan 0.953688.

Door deze berekening door te voeren voor andere waarden van $x$ , zien we dat de Runge-Kutta-methode zelfs bij een stapgrootte van $h = 0.1$ een zeer nauwkeurige oplossing oplevert, met de werkelijke waarde van $y$ tot $x = 1.0$ volledig overeenkomend met de berekende waarde.

Curve Fitting met de Least Squares Methode

Naast numerieke oplossingen voor differentiaalvergelijkingen, wordt de least squares methode vaak gebruikt voor het aanpassen van een curve aan een set van experimentele gegevens. Dit is vooral nuttig wanneer de gegevens zowel positieve als negatieve fouten bevatten, zoals vaak het geval is in experimentele metingen. De methode van de kleinste kwadraten minimaliseert de som van de kwadraten van de residuen, die het verschil representeren tussen de gemeten en de voorspelde waarden.

Lineaire Fitting

Stel dat we een set van gegevens willen aanpassen aan een lineaire functie van de vorm $y = ax + b$ . In dit geval willen we de waarden van de coëfficiënten $a$ en $b$ vinden die de som van de kwadraten van de residuen minimaliseren. De normal equations voor de lineaire fitting worden afgeleid uit de afgeleiden van de som van de kwadraten van de residuen ten opzichte van de onbekenden $a$ en $b$ :

\sum xy = a \sum x^2 + b \sum x

\sum y = a \sum x + b \cdot n

Door deze vergelijkingen op te lossen, bijvoorbeeld via Cramer's regel, krijgen we de waarden voor $a$ en $b$ . Daarna kunnen we de residuen en de bijbehorende gekwadrateerde waarden berekenen, wat een maat is voor de nauwkeurigheid van onze fit.

Parabolische Fitting

Als de gegevens beter passen bij een parabolische kromme van de vorm $y = ax^2 + bx + c$ , kunnen we een soortgelijke aanpak volgen, maar met drie onbekenden: $a$ , $b$ , en $c$ . De normale vergelijkingen voor deze situatie zijn:

\sum x^2 y = a \sum x^4 + b \sum x^3 + c \sum x^2

\sum xy = a \sum x^3 + b \sum x^2 + c \sum x

\sum y = a \sum x^2 + b \sum x + c \cdot n

Het oplossen van deze drie lineaire vergelijkingen geeft de waarden voor $a$ , $b$ , en $c$ , waarmee we de beste parabolische curve kunnen passen.

Wat te Begrijpen bij het Gebruik van Deze Methodes

Het is belangrijk om te begrijpen dat elke numerieke methode, of het nu de Euler-methode, de Runge-Kutta-methode, of de least squares fitting is, zijn beperkingen heeft. De nauwkeurigheid van de oplossing is afhankelijk van de stapgrootte (voor de numerieke methoden) en de verdeling van de gegevens (voor curve fitting). Kleiner maken van de stapgrootte kan de nauwkeurigheid verbeteren, maar leidt ook tot een groter aantal berekeningen. Evenzo, bij curve fitting, kan de keuze van het model (lineair, parabool, exponentieel, etc.) de resultaten beïnvloeden, en het is essentieel om het juiste model te kiezen op basis van de aard van de gegevens.

Hoe reken je functies en reeksen uit met behulp van controle-instructies in Fortran?

In Fortran kunnen we verschillende soorten controle-instructies gebruiken om de uitvoering van een programma te sturen. Dit stelt ons in staat om onder verschillende omstandigheden verschillende acties uit te voeren, afhankelijk van de waarde van variabelen of logische voorwaarden. Een van de belangrijke controle-instructies is de arithmetic IF-instructie, die handig kan zijn bij het evalueren van functies onder verschillende voorwaarden, of bij het uitvoeren van berekeningen met meerdere termen in een reeks. In dit hoofdstuk bespreken we hoe deze en andere controle-instructies kunnen worden toegepast, evenals een aantal technieken om de efficiëntie van een programma te verbeteren.

In het voorbeeld van een aritmethische IF gebruiken we een extra variabele om de waarde van een functie te berekenen op basis van de waarde van $X$ . Stel je voor dat we de volgende functie willen evalueren voor verschillende waarden van $X$ :

Als $X < 3$ , dan is $F = X^2 + \sin(2X)$
Als $X = 3$ , dan is $F = X^2 - \sin(2X)$
Als $X > 3$ , dan is $F = X^3 - \cos(3X)$

We gebruiken de arithmetic IF om deze voorwaarden te controleren en de bijbehorende waarde van $F$ te berekenen, afhankelijk van de invoerwaarde van $X$ . Het onderstaande programma laat zien hoe dit in de praktijk werkt:

fortran
PROGRAM function1
  PRINT *, '*** DE FUNCTIE IS ***'
  PRINT *, 'F = X^2 + SIN(2X) als X < 3'
  PRINT *, 'F = X^2 - SIN(2X) als X = 3'
  PRINT *, 'F = X^3 - COS(3X) als X > 3'
  PRINT *, 'Geef de waarde van X in:'
  READ *, X
  A = X - 3
  IF (A) 10, 20, 30
10  F = X**2 + SIN(2*X)
    PRINT *, 'Gegeven waarde is < 3'
    PRINT *, 'De waarde van de functie is ', F
    STOP
20  F = X**2 - SIN(2*X)
    PRINT *, 'Gegeven waarde is = 3'
    PRINT *, 'De waarde van de functie is ', F
    STOP
30  F = X**3 - COS(3*X)
    PRINT *, 'Gegeven waarde is > 3'
    PRINT *, 'De waarde van de functie is ', F
    STOP
END

In dit programma hebben we de variabele $A = X - 3$ gedefinieerd. Vervolgens controleren we de waarde van $A$ om de juiste tak van het programma te kiezen, afhankelijk van of $X$ kleiner, gelijk aan of groter is dan 3. Dit zorgt ervoor dat de juiste berekening van $F$ wordt uitgevoerd. Het gebruik van de arithmetic IF-instructie voorkomt onnodige herhalingen van de code, zoals herhaalde STOP-instructies, en maakt de uitvoering van het programma overzichtelijker.

Een ander belangrijk gebruik van de arithmetic IF-instructie is bij het berekenen van de som van een reeks. Stel je voor dat we de som van een reeks willen berekenen, zoals $S = 1 + X + X^2 + X^3 + \dots + X^N$ , waarbij de waarde van $N$ door de gebruiker wordt ingevoerd. Hier gebruiken we de arithmetic IF-instructie om de reeks op te bouwen, term voor term, totdat we het gewenste aantal termen hebben bereikt. Het onderstaande programma berekent de som van een dergelijke reeks:

fortran
PROGRAM series_sum

  PRINT *, 'Programma om de som van een reeks te berekenen met behulp van de arithmetic IF'
  PRINT *, 'De reeks is S = 1 + X + X^2 + X^3 + ... + X^N'
  PRINT *, 'Geef de waarden van X en N in:'
  READ *, X, N
  SUM = 1
  I = 0
  N = N - 1
10  I = I + 1
    SUM = SUM + X**I
    IF (I-N) 10, 20, 20
20  PRINT *, 'De som van de reeks is ', SUM
    STOP
END

In dit programma hebben we een variabele $SUM$ om de som van de reeks bij te houden, en een andere variabele $I$ om het aantal termen te tellen. Het programma blijft de termen optellen totdat $I$ gelijk is aan $N$ , waarna het resultaat wordt weergegeven. De controle-instructie IF (I-N) stuurt de uitvoering van de code naar de juiste plaats op basis van de waarde van $I$ .

Hoewel het gebruik van de arithmetic IF-instructie krachtig is, kunnen er situaties zijn waarin we willen controleren op logische voorwaarden in plaats van numerieke vergelijkingen. In dergelijke gevallen kunnen we de logische IF-instructie gebruiken. Deze instructie controleert een logische voorwaarde en voert een bepaalde actie uit als de voorwaarde waar is. Het algemene formaat van een logische IF is als volgt:

fortran
IF (LOGISCHE VOORWAARDE)  STAP1

STAP2

Als de logische voorwaarde waar is, wordt STAP1 uitgevoerd, anders wordt direct doorgeschakeld naar STAP2. We gebruiken logische IF-instructies bijvoorbeeld om de waarde van een functie te evalueren onder verschillende voorwaarden, zoals in het aangepaste voorbeeld waarbij de waarde van $F$ wordt berekend op basis van de waarde van $X$ :

fortran
PROGRAM function2

  PRINT *, 'Geef de waarde van X in:'
  READ *, X
  IF (X .LT. 3) F = X**2 + SIN(2*X)
  IF (X .EQ. 3) F = X**2 - SIN(2*X)
  IF (X .GT. 3) F = X**3 - COS(3*X)
  PRINT *, 'Voor', X, 'is de waarde van de functie ', F
  STOP
END

In dit geval gebruiken we de logische IF-instructie om te controleren of $X$ kleiner dan, gelijk aan of groter dan 3 is, en voeren de juiste berekening uit.

Naast de arithmetic IF en logische IF, wordt de unconditional GOTO-instructie ook vaak gebruikt om de controle naar een ander punt in het programma over te dragen, zonder enige voorwaarde. Deze instructie kan handig zijn wanneer je de uitvoering van een programma snel wilt overdragen naar een bepaald punt, maar kan in sommige gevallen leiden tot minder leesbare en moeilijker te onderhouden code.

In veel gevallen kunnen controle-instructies worden gecombineerd om complexere logica uit te voeren, zoals het valideren van gegevens, het berekenen van sommen of het bepalen van de status van een student op basis van bepaalde cijfers. Het juiste gebruik van controle-instructies kan een programma veel efficiënter maken en helpen bij het voorkomen van herhalingen of onduidelijke structuren.

Hoe een neurosymbolische benadering de regels van Sudoku en predicaatclassificatie toepast voor geavanceerde probleemoplossing
Wat zijn de belangrijkste kenmerken en klinische implicaties van nevus depigmentosus en verwante hypopigmentatiestoornissen?
Hoe kan DAIR effectief worden ingezet bij de behandeling van prosthetische gewrichtsinfecties?
Welke elektrochemische en structurele karakteriseringstechnieken zijn essentieel voor het begrijpen van Li-ionbatterijen?
Hoe het Bestuur van een Bedrijf de Cyberbeveiliging kan Beheren en Risico's kan Vermijden
Hoe beïnvloedt een recente bovenste luchtweginfectie de anesthesie bij transkatheter sluiting van een ventrikelseptumdefect bij kinderen?