Hoe werkt het gebruik van formaten en arrays in Fortran?

In Fortran worden formatteermethoden gebruikt om variabelen op verschillende manieren af te drukken, afhankelijk van de specificaties van het formaat. Bij het gebruik van numerieke formaten moeten we bijzonder zorgvuldig omgaan met de keuze van het formaat, aangezien dit de weergegeven waarde kan beïnvloeden. Bijvoorbeeld, als de waarde van een variabele wordt afgedrukt met het formaat f10.5, zoals in het geval van de waarde 1234.56787, blijft deze ongewijzigd (1234.56787). Maar wanneer we dezelfde waarde afdrukken met een ander formaat, zoals f10.3, zal de waarde worden afgerond naar 1234.568. In nog kleinere formaten, zoals f8.1, wordt de waarde verder afgerond en verschijnt deze als 1234.6. Dit komt doordat het formaat specificeert hoeveel cijfers er na de komma mogen worden weergegeven en hoe de getallen moeten worden afgerond.

Bij het gebruik van formaten is het ook essentieel te begrijpen hoe Fortran de waarden weergeeft binnen verschillende kolommen, zoals in het geval van het format 15. Het gebruik van formaten zoals t15 bepaalt namelijk de beginpositie van de gegevens, waardoor bepaalde waarden op de juiste plaats op het scherm of de uitvoer worden gepresenteerd. Dit is van belang bij het werken met complexe gegevensweergaven in bijvoorbeeld wetenschappelijke of technische programma's, waarbij de presentatie van de gegevens een grote rol speelt.

Een ander belangrijk aspect van Fortran is het gebruik van arrays. Arrays zijn in wezen verzamelingen van gegevens van hetzelfde type, die op een efficiënte manier kunnen worden opgeslagen en verwerkt. In het geval van een eenvoudig voorbeeld, waarbij we de hoogste en laagste cijfers willen vinden van de scores van 10 studenten, zou een array ons in staat stellen de scores op een gestructureerde manier op te slaan en deze vervolgens te verwerken zonder de noodzaak om elke score apart in een individuele variabele te stoppen. Door de scores in een array op te slaan, kunnen we gemakkelijk toegang krijgen tot elke score via de index van het array, wat de code overzichtelijker en efficiënter maakt.

Bijvoorbeeld, door een array te declareren als DIMENSION M(10) kunnen we de scores van de 10 studenten opslaan in de variabelen M(1) tot M(10). Vervolgens kunnen we de hoogste en laagste score bepalen door een eenvoudige do-loop te gebruiken, waarin we elke waarde in de array vergelijken met de huidige hoogste en laagste score. Het gebruik van arrays maakt niet alleen het beheer van gegevens eenvoudiger, maar biedt ook een flexibele manier om de gegevens te manipuleren.

Wanneer we arrays in Fortran gebruiken, is het van cruciaal belang om de juiste dimensies van de array te specificeren, zodat de array voldoende ruimte biedt voor de gegevens die we willen opslaan. Arrays kunnen ook meerdere dimensies hebben, wat hen bijzonder geschikt maakt voor toepassingen waarin gegevens in tabellen of matrices moeten worden opgeslagen. Bijvoorbeeld, een twee-dimensionale array DIMENSION A(10, 10) kan 100 elementen bevatten, die op een gestructureerde manier kunnen worden benaderd door middel van rij- en kolomindexen.

Arrays kunnen in verschillende vormen en formaten worden gedeclareerd, afhankelijk van de aard van de gegevens. In het geval van bijvoorbeeld numerieke waarden kunnen we een array declareren als REAL A(100) voor 100 reële getallen, terwijl voor karaktergegevens een array kan worden gedeclareerd als CHARACTER*20 D(15), waarbij de array D 15 elementen bevat van maximaal 20 tekens.

Deze flexibiliteit maakt arrays tot een krachtig hulpmiddel voor het verwerken van gegevens in Fortran, wat essentieel is voor het ontwikkelen van efficiënte en schaalbare programma's, vooral wanneer grote hoeveelheden gegevens moeten worden opgeslagen en bewerkt. Het gebruik van arrays is dus van fundamenteel belang voor het schrijven van programma's die werken met grotere datasets, en het is belangrijk dat de programmeur goed begrijpt hoe de gegevens in arrays kunnen worden opgeslagen en bewerkt.

Het is eveneens van belang om te weten dat Fortran bij het werken met arrays geen grenzen aan de array-indices oplegt, wat betekent dat de indexen flexibel kunnen worden gedefinieerd. Dit maakt het eenvoudiger om gegevens dynamisch te verwerken, afhankelijk van de behoeften van het programma. Arrays kunnen op verschillende manieren worden gemanipuleerd, en hun gebruik is een essentieel onderdeel van het schrijven van effectieve en onderhoudbare Fortran-code.

Hoe te Werken met Arrays in Fortran: Het Vinden van de Hoogste en Laagste Scores

Het gebruik van arrays is een essentieel onderdeel van programmeren in Fortran, vooral als het gaat om het verwerken van gegevens zoals scores. In de onderstaande code wordt bijvoorbeeld het maximale en minimale cijfer uit een reeks gescoord. Dit proces wordt uitgevoerd door een array van cijfers te analyseren en de hoogste en laagste waarden, evenals hun posities, te vinden. Laten we eens kijken naar hoe dit in zijn werk gaat.

De code die wordt gepresenteerd begint met het aannemen van de eerste waarde in de array als zowel het grootste als het kleinste cijfer. Vervolgens wordt een lus (DO-lus) gebruikt om door de array te itereren. Bij elke iteratie wordt gecontroleerd of de huidige waarde groter is dan de grootste waarde of kleiner dan de kleinste waarde. Als dat het geval is, wordt de variabele die de grootste of kleinste waarde bijhoudt bijgewerkt, evenals de positie van deze waarde.

In de onderstaande code wordt het programma geïmplementeerd als volgt:

fortran
Copy code
write(*,*) (M(I),I=1,10)
BIG = M(1)   ! Begin met de eerste waarde als de grootste
PB = 1       ! De positie van de grootste waarde
SMALL = M(1) ! Begin met de eerste waarde als de kleinste
PS = 1       ! De positie van de kleinste waarde
DO I = 2, 10
    IF (BIG.LT.M(I)) THEN
        BIG = M(I)
        PB = I
    ENDIF
    IF (SMALL.GT.M(I)) THEN
        SMALL = M(I)
        PS = I
    ENDIF
END DO
WRITE(*,*) 'THE HIGHEST SCORE IS', BIG, " IT'S POSITION ", PB
WRITE(*,*) 'THE LOWEST SCORE IS', SMALL, " IT'S POSITION ", PS
STOP

Een belangrijk concept dat in dit programma aan bod komt, is de zogenaamde "Implied DO Loop". Dit is een alternatieve manier van het gebruik van loops in Fortran, die vaak wordt toegepast om gegevens in arrays sneller en efficiënter te verwerken. In plaats van een standaard DO-loop die elke waarde één voor één verwerkt, maakt de Implied DO Loop het mogelijk om meerdere waarden in één enkele opdracht te verwerken.

In dit voorbeeld:

fortran
Copy code
WRITE(*,*) (M(I), I=1,10)

wordt de "Implied DO Loop" gebruikt om de waarden van de array M(I) in één keer weer te geven. Dit bespaart tijd en maakt de code korter en leesbaarder. Als de gegevens op dezelfde manier moeten worden gelezen, kan een soortgelijke constructie worden gebruikt:

fortran
Copy code
READ(*,*) (M(I), I=1,10)

Een ander belangrijk concept in de Fortran-programmering is het werken met multidimensionale arrays, zoals A(m,n), en het lezen of schrijven van gegevens naar en van dergelijke arrays. Voor een tweedimensionale array kunnen we de volgende Implied DO Loops gebruiken:

fortran
Copy code
READ(*,*) ((A(I,J), J=1,n), I=1,m)

WRITE(*,*) ((A(I,J), J=1,n), I=1,m)

Hier wordt de buitenste lus over de rijen (m) geschreven, terwijl de binnenste lus over de kolommen (n) gaat. Dit maakt het mogelijk om gegevens op een gestructureerde manier in een multidimensionale array te verwerken, wat handig is voor bijvoorbeeld matrices of tabellen met meerdere gegevenssets.

fortran
Copy code
DO I = 1, nd
    nf(nv(I)) = nf(nv(I)) + 1
END DO

Dit fragment verhoogt de frequentie van het getal nv(I) in de array nf. Dit kan bijzonder nuttig zijn voor toepassingen zoals het genereren van een frequentietabel of het analyseren van de verdeling van gegevens binnen een specifiek bereik.

Hoewel de voorbeelden zich richten op het vinden van maximale en minimale waarden, of het tellen van frequenties, zijn de principes van werken met arrays en DO-loops van toepassing op veel andere situaties. Het begrijpen van deze concepten is belangrijk voor het ontwikkelen van geavanceerdere programma's die grotere hoeveelheden gegevens moeten verwerken, zoals in wetenschappelijke simulaties, data-analyse of grafische toepassingen.

Hoe Werkt Data File Handling in Fortran voor Studentenresultaten?

In Fortran is het werken met data-bestanden een belangrijke vaardigheid voor het beheren van grote hoeveelheden gegevens, zoals de resultaten van studenten. In dit hoofdstuk onderzoeken we hoe we dergelijke bestanden kunnen openen, gegevens kunnen toevoegen, lezen, ordenen en zelfs de inhoud naar een ander bestand kunnen schrijven.

pgsql
Copy code
C:\G77\work>type marks.dat
1   aditya birla                            65
2   pradipto bagchi                       49
3   sukhen haldar                         56
4   keya seth                              77
5   vijay baul                              72

Gegevens Toevoegen aan een Bestaand Bestanden

Voordat we met andere bestandsbewerkingen beginnen, moeten we weten hoe we gegevens kunnen toevoegen aan een bestaand bestand. Dit doen we door het bestand in de "append" modus te openen. In Fortran kan dit worden bereikt door de volgende code te gebruiken:

fortran
Copy code
open(1, file='marks.dat', access='append')
write(*,*) 'Input no. of students'
read(*,*) ns
do i=1,ns
    write(*,*) 'Enter rollno,name,mark of a student one after another'
    read(*,*) rn
    read(*,14) name
    read(*,*) mark
    write(1,15) rn, name, mark
enddo

Door deze code uit te voeren, kunnen we extra records toevoegen aan marks.dat. Het bestand bevat nu records van vijf nieuwe studenten, en het resultaat wordt als volgt weergegeven:

Copy code
1   aditya birla 65

2   pradipto bagchi 49
3   sukhen haldar 56
4   keya seth 77
5   vijay baul 72
6   papia nandi 82
7   bimal mazumdar 50
8   satya banerjee 61
9   dinesh bajpai 76
10 kamal saha 77

Gegevens Lezen en Weergeven op het Scherm

Stel je voor dat we de eerste vijf records willen lezen en afdrukken op het scherm. Dit kan eenvoudig worden gedaan met de volgende Fortran-code:

fortran
Copy code
open(1, file='marks.dat')
do i=1,5
    read(1,15,END=20) rn, name, mark
    write(*,15) rn, name, mark
enddo
20 write(*,*) 'END OF DATA'

Het resultaat op het scherm zou er als volgt uitzien:

sql
Copy code
1   aditya birla 65

2   pradipto bagchi 49
3   sukhen haldar 56
4   keya seth 77
5   vijay baul 72
END OF DATA

Deze techniek van sequentieel lezen betekent dat we gegevens alleen van boven naar beneden kunnen verwerken, wat betekent dat we eerst de bovenste records moeten lezen voordat we toegang krijgen tot de latere. Dit kan een beperking zijn wanneer je bijvoorbeeld alleen het vierde record nodig hebt; in dat geval moeten we eerst de drie bovenliggende records lezen.

Gegevens Sorteren en Schrijven naar een Nieuw Bestand

Een van de krachtigste functies van data-bestanden is de mogelijkheid om gegevens te sorteren. Laten we zeggen dat we een ranglijst willen genereren op basis van de cijfers van de studenten. Dit kunnen we doen door de volgende stappen te volgen:

1. Lees de gegevens uit het bestand marks.dat.

2. Toont de gegevens op het scherm om te controleren of alles correct is gelezen.

3. Sorteer de gegevens op aflopende volgorde van de cijfers.

4. Schrijf de gesorteerde gegevens naar een ander bestand en toon ze ook op het scherm.

De bijbehorende code zou er als volgt uitzien:

fortran
Copy code
open(3, file=inpf)

open(4, file=outf)
do i=1,n
    read(3,15,END=20) rn(i), name(i), mark(i)
    write(*,15) rn(i), name(i), mark(i)
enddo
20 write(*,*) 'End of input data'
! Sorteer de gegevens
do i=1,n-1
    do j=i+1,n
        if (mark(i).lt.mark(j)) then
            trn = rn(i)
            rn(i) = rn(j)
            rn(j) = trn
            tname = name(i)
            name(i) = name(j)
            name(j) = tname
            tmark = mark(i)
            mark(i) = mark(j)
            mark(j) = tmark
        endif
    enddo
enddo
! Schrijf de ranglijst naar een nieuw bestand
write(*,*) 'Rank list'
write(*,*) ' Rank Roll NO. Name Marks'
write(4,*) 'Rank list'
write(4,*) ' Rank Roll NO. Name Marks'
do i=1,n
    write(*,16) i, rn(i), name(i), mark(i)
    write(4,16) i, rn(i), name(i), mark(i)
enddo

Na het uitvoeren van dit programma kunnen we de nieuwe gesorteerde lijst zien, zowel op het scherm als in het bestand rank.dat:

pgsql
Copy code
Rank list
Rank Roll NO. Name Marks
1 6 papia nandi 82
2 4 keya seth 77
3 10 kamal saha 77
4 9 dinesh bajpai 76
5 5 vijay baul 72
6 1 aditya birla 65
7 8 satya banerjee 61
8 3 sukhen haldar 56
9 7 bimal mazumdar 50
10 2 pradipto bagchi 49

Bestanden in Fortran en Hun Beperkingen

Daarnaast is het belangrijk om te begrijpen dat deze bestanden ASCII-bestanden zijn, wat betekent dat ze tekstgebaseerd zijn en daardoor niet direct uitvoerbaar zijn zoals bijvoorbeeld binaire programma's. Dit maakt ze ideaal voor gegevensopslag en -uitwisseling, maar minder geschikt voor snel uitvoerende programma's.

Wat is Belangrijk om te Begrijpen?