Hier is een eenvoudig Fortran-programma dat een numeriek gegevensbestand opent, de gegevens leest, het gemiddelde berekent en het resultaat schrijft. Ik geef ook advies over bestands-I/O en enkele voorbeelden van subroutines. **Voorbeeldprogramma:** ```fortran program data_analyse implicit none ! Variabelen declareren integer :: unit_in, unit_out, ios real, allocatable :: data(:) integer :: count, i real :: sum, average character(len=*), parameter :: filename_in = 'data.txt' character(len=*), parameter :: filename_out = 'result.txt' ! Bestandsunits unit_in = 10 unit_out = 20 ! Open het gegevensbestand voor lezen open(unit=unit_in, file=filename_in, status='old', action='read', iostat=ios) if (ios /= 0) then print *, 'Fout bij openen van ', filename_in stop end if ! Lees het aantal gegevens eerst ! (Optioneel: je kunt dynamisch lezen of eerst tellen) ! Hier gaan we ervan uit dat je weet hoeveel data er is ! of dat je het dynamisch wilt doen ! Bijvoorbeeld: gegevens tellen count = 0 do read(unit_in, *, iostat=ios) data_tmp if (ios /= 0) exit count = count + 1 end do rewind(unit_in) ! Gegevens in array opslaan allocate(data(count)) do i = 1, count read(unit_in, *, iostat=ios) data(i) if (ios /= 0) then print *, 'Fout bij lezen op data index ', i stop end if end do close(unit_in) ! Bereken het gemiddelde sum = sum(data) average = sum / real(count) ! Resultaat wegschrijven open(unit=unit_out, file=filename_out, status='replace', action='write') write(unit_out, '(A, F10.4)') 'Gemiddelde: ', average close(unit_out) ! Vrijmaken deallocate(data) print *, 'Analyse voltooid. Resultaat opgeslagen in ', filename_out end program data_analyse ``` **Advies over bestands-I/O in Fortran:** - Gebruik `open` met de juiste status (`'old'` voor bestaande bestanden, `'replace'` voor nieuwe). - Gebruik `iostat` voor foutafhandeling na `open`, `read`, en `write`. - Voor grote datasets is het efficiënter om de gegevens in blokken te lezen of te schrijven, afhankelijk van je toepassing. - Gebruik `rewind` om de bestandspositie terug te zetten wanneer je opnieuw wilt lezen. - Vermijd onnodig herhaald openen en sluiten; open één keer, lees alle gegevens, sluit af. **Voorbeeld subroutines:** *Lezen van gegevens in een array:* ```fortran subroutine read_data(filename, data, count) implicit none character(len=*), intent(in) :: filename real, allocatable, intent(out) :: data(:) integer, intent(out) :: count integer :: unit, ios, i real :: temp ! Open bestand open(unit=unit, file=filename, status='old', action='read', iostat=ios) if (ios /= 0) then print *, 'Fout bij openen bestand.' stop end if ! Tellen data count = 0 do read(unit, *, iostat=ios) temp if (ios /= 0) exit count = count + 1 end do rewind(unit) allocate(data(count)) do i = 1, count read(unit, *, iostat=ios) data(i) if (ios /= 0) then print *, 'Fout bij lezen data op index ', i stop end if end do close(unit) end subroutine read_data ``` *Schrijven van resultaten:* ```fortran subroutine write_result(filename, result) implicit none character(len=*), intent(in) :: filename real, intent(in) :: result integer :: unit, ios unit = 30 open(unit=unit, file=filename, status='replace', action='write', iostat=ios) if (ios /= 0) then print *, 'Fout bij openen resultaatbestand' stop end if write(unit, '(A, F10.4)') 'Gemiddelde: ', result close(unit) end subroutine write_result ``` Deze aanpak zorgt voor overzichtelijkheid, herbruikbaarheid en goede foutafhandeling. **Kort samengevat:** - Open bestanden één keer, gebruik `iostat` voor foutcontrole. - Lees gegevens in een lus, of eerst tellen en daarna in één keer lezen. - Gebruik dynamische arrays (`allocate`) voor variabele datahoeveelheid. - Schrijf resultaten op een gestructureerde manier. Indien je verdere hulp nodig hebt bij specifieke analyses of optimalisaties, laat het gerust weten!

Hier is een Fortran-programma dat aan je specificaties voldoet: ```fortran program data_analyse implicit none ! Declaratie van variabelen character(len=100) :: bestandsnaam real, dimension(:), allocatable :: data real :: som, gemiddelde integer :: i, n, iostat logical :: bestand_bestaat ! Bestandsnaam instellen bestandsnaam = 'data.txt' ! Controleren of bestand bestaat inquire(file=bestandsnaam, exist=bestand_bestaat) if (.not. bestand_bestaat) then write(*,*) 'Fout: Bestand ', trim(bestandsnaam), ' bestaat niet!' stop endif ! Bestand openen en gegevens inlezen call lees_bestand(bestandsnaam, data, n) ! Gemiddelde berekenen if (n > 0) then som = 0.0 do i = 1, n som = som + data(i) end do gemiddelde = som / real(n) ! Resultaat weergeven write(*,*) 'Aantal datapunten: ', n write(*,*) 'Gemiddelde: ', gemiddelde else write(*,*) 'Geen gegevens gevonden in bestand' endif ! Geheugen vrijgeven if (allocated(data)) deallocate(data) contains subroutine lees_bestand(bestandsnaam, data, n) character(len=*), intent(in) :: bestandsnaam real, dimension(:), allocatable, intent(out) :: data integer, intent(out) :: n integer :: i, iostat, eenheid real :: waarde ! Eerst tellen we het aantal regels n = 0 open(newunit=eenheid, file=bestandsnaam, status='old', action='read') do read(eenheid, *, iostat=iostat) waarde if (iostat /= 0) exit n = n + 1 end do close(eenheid) ! Geheugen alloceren if (n > 0) then allocate(data(n)) ! Gegevens inlezen open(newunit=eenheid, file=bestandsnaam, status='old', action='read') do i = 1, n read(eenheid, *) data(i) end do close(eenheid) endif end subroutine lees_bestand end program data_analyse ``` ## Advies voor efficiënte bestands-I/O in Fortran: ### 1. **Gebruik `newunit` voor bestandseenheden** ```fortran open(newunit=unit, file='bestand.txt') ``` - Automatische eenheidstoewijzing voorkomt conflicten ### 2. **Altijd foutcontrole toepassen** ```fortran open(newunit=unit, file='bestand.txt', iostat=ierror) if (ierror /= 0) then write(*,*) 'Fout bij openen bestand' stop endif ``` ### 3. **Gebruik buffered I/O voor grote bestanden** ```fortran open(newunit=unit, file='groot_bestand.txt', buffered='yes') ``` ### 4. **Efficiënte subroutines voor bestandsverwerking:** **Voorbeeld: Bestand in één keer inlezen** ```fortran subroutine snel_inlezen(bestandsnaam, data) character(len=*), intent(in) :: bestandsnaam real, dimension(:), allocatable, intent(out) :: data integer :: n, unit ! Tel aantal regels n = aantal_regels(bestandsnaam) ! Lees alle gegevens in één keer if (n > 0) then allocate(data(n)) open(newunit=unit, file=bestandsnaam) read(unit, *) data close(unit) endif end subroutine ``` **Voorbeeld: Gegevens efficiënt wegschrijven** ```fortran subroutine schrijf_gegevens(bestandsnaam, data) character(len=*), intent(in) :: bestandsnaam real, dimension(:), intent(in) :: data integer :: unit open(newunit=unit, file=bestandsnaam, action='write') write(unit, '(F10.4)') data ! Geformatteerde uitvoer close(unit) end subroutine ``` ### 5. **Gebruik direct access voor grote datasets** ```fortran open(newunit=unit, file='data.bin', form='unformatted', & access='direct', recl=4*n) ``` ### 6. **Belangrijke tips:** - Gebruik `implicit none` om typefouten te voorkomen - Check altijd de return status van I/O-operaties - Sluit bestanden altijd af met `close()` - Gebruik `allocate()` en `deallocate()` voor dynamische arrays Het bovenstaande programma is efficiënt voor middelgrote bestanden. Voor zeer grote datasets kun je overwegen om: - Stream I/O te gebruiken - Gegevens in chunks te verwerken - Binaire bestandsformaten te gebruiken voor betere prestaties