Hier is een eenvoudig Fortran-programma dat de numerieke integratie van de functie sin(x) uitvoert op het interval [0, 3.14159] met behulp van de trapeziumregel en 1000 deelintervallen: ```fortran program numerieke_integratie implicit none ! Variabelen declareren integer, parameter :: n = 1000 ! Aantal deelintervallen real(8), parameter :: a = 0.0 ! Ondergrens van het interval real(8), parameter :: b = 3.14159 ! Bovengrens van het interval real(8) :: h ! Breedte van elk deelinterval real(8) :: som, x, f_x, result ! Berekenen van de breedte van de intervallen h = (b - a) / n ! Initialiseren van de som met de helft van de eerste en laatste waarde som = 0.5 * (sin(a) + sin(b)) ! Loop over de interne punten do i = 1, n - 1 x = a + i * h f_x = sin(x) som = som + f_x end do ! Eindresultaat berekenen result = h * som ! Resultaat tonen print *, 'De benadering van de integraal van sin(x) van ', a, ' tot ', b, ' is ', result end program numerieke_integratie ``` **Uitleg van de opbouw:** - **Parameters & Variabelen:** - `n` bepaalt het aantal deelintervallen (hier 1000). - `a` en `b` zijn de onder- en bovengrenzen van de integratie. - `h` is de breedte van elk interval, berekend door `(b - a)/n`. - `som` houdt de cumulatieve som bij volgens de trapeziumregel. - **Berekening:** - De begin- en eindwaarden worden meegeteld met een factor 0.5, omdat de trapeziumregel de eerste en laatste punten slechts voor de helft mee telt. - De loop voegt de waarden van sin(x) bij elke interne punt toe. - Het eindresultaat wordt berekend door `h * som`. **Tips voor verbetering:** - **Nauwkeurigheid verhogen:** - Gebruik een groter aantal deelintervallen (`n`). - Overweeg adaptieve methoden die het aantal intervallen aanpassen op basis van de functievariatie. - **Efficiëntie:** - Cache de sin(x) evaluaties indien mogelijk. - Overweeg vectorisatie of parallelisatie (bijvoorbeeld via OpenMP) voor grote `n`. - **Andere methoden:** - Simpson's regel geeft vaak betere nauwkeurigheid voor hetzelfde aantal intervallen. - Ga voor hogere precisie door gebruik te maken van dubbele precisie (`real(8)`), wat hier al is gedaan. Met deze basis kun je verder experimenteren en optimaliseren afhankelijk van je eisen voor nauwkeurigheid en snelheid.

Absoluut. Hier is een gedetailleerde uitleg en een Fortran-programma dat numerieke integratie uitvoert met de trapeziumregel. ### Het Fortran-programma ```fortran program trapezium_regel implicit none ! Declaratie van variabelen integer, parameter :: n = 1000 ! Aantal deelintervallen real, parameter :: a = 0.0 ! Ondergrens interval real, parameter :: b = 3.14159 ! Bovengrens interval real :: h, x, integraal_resultaat integer :: i ! Bereken de breedte van elk deelinterval h = (b - a) / real(n) ! Initialiseer de integraal met de gemiddelde waarde van de randen integraal_resultaat = (sin(a) + sin(b)) / 2.0 ! Loop over alle binnenpunten do i = 1, n-1 x = a + i * h integraal_resultaat = integraal_resultaat + sin(x) end do ! Vermenigvuldig met h voor het eindresultaat integraal_resultaat = integraal_resultaat * h ! Output het resultaat write(*,*) "Benaderde integraal van sin(x) van 0 tot pi: ", integraal_resultaat write(*,*) "Analytische oplossing (2.0): ", 2.0 write(*,*) "Fout: ", abs(integraal_resultaat - 2.0) end program trapezium_regel ``` ### Opbouw van het programma: Stap voor Stap 1. **Declaratie (`implicit none`)**: Zorgt dat alle variabelen expliciet gedeclareerd moeten worden. Dit voorkomt typefouten en is een goede programmeerstijl. 2. **Parameters (`integer, parameter`, `real, parameter`)**: * `n = 1000`: Het opgegeven aantal deelintervallen. * `a = 0.0` en `b = 3.14159`: De grenzen van het integratie-interval. Deze worden als `parameter` gedeclareerd omdat het constante waarden zijn. 3. **Berekening intervalbreedte (`h`)**: De stapgrootte `h` wordt berekend door de lengte van het interval `(b - a)` te delen door het aantal stappen `n`. 4. **Initialisatie integraal**: De trapeziumregel formule is `h * [ (f(a) + f(b))/2 + Σ f(x_i) ]`. Hier initialiseren we de som met het gemiddelde van de functiewaarden aan de randen `(sin(a) + sin(b)) / 2.0`. 5. **Hoofdlus (`do i = 1, n-1`)**: Deze lus berekent de som van de functiewaarden op alle *binnenpunten*. Voor elk deelinterval `i` wordt de `x`-waarde berekend (`x = a + i * h`) en de waarde `sin(x)` wordt opgeteld bij het totaal. 6. **Finalisatie**: Na de lus wordt de totale som vermenigvuldigd met de stapgrootte `h` om het finale numerieke integraalresultaat te krijgen. 7. **Output**: Het programma print het numerieke resultaat, de analytische oplossing (voor sin(x) van 0 tot π is dit 2.0) en de absolute fout. ### Tips voor het Verbeteren van Nauwkeurigheid en Efficiëntie 1. **Vergroot het aantal deelintervallen (`n`)**: * Dit is de meest voor de hand liggende methode. Hoe groter `n`, hoe kleiner `h`, en hoe beter de benadering. Verdubbel `n` om de fout ruwweg met een factor 4 te verkleinen (de fout van de trapeziumregel is evenredig met `h²`). 2. **Gebruik een andere (krachtigere) methode**: * **Simpson's regel**: Deze methode is veel nauwkeuriger voor vloeiende functies zoals `sin(x)`. De fout is evenredig met `h⁴`. Voor hetzelfde aantal deelintervallen krijg je een veel beter resultaat. Simpson's regel vereist wel een *even* aantal deelintervallen. * **Adaptieve integratie**: In plaats van over het hele interval een vaste `h` te gebruiken, past deze techniek de stapgrootte automatisch aan. Kleine stappen waar de functie verandert en grotere stappen waar de functie vlak is. Dit is zeer efficiënt voor lastige functies. 3. **Gebruik `double precision`**: * Standaard gebruikt Fortran `real` voor enkelvoudige precisie (ongeveer 7 significante cijfers). Voor een betere nauwkeurigheid, vooral bij een zeer groot aantal deelintervallen, kan afrondingsfout een probleem worden. * **Vervang `real` door `real(kind=8)`** of declareer variabelen als `double precision`. Dit geeft je ongeveer 15 significante cijfers en minimaliseert afrondingsfouten. * *Voorbeeld:* `real(kind=8) :: h, x, integraal_resultaat` 4. **Vermijd herhaalde berekening van constanten**: * Je programma is hier al efficiënt. De waarde `h` wordt één keer buiten de lus berekend. Een inefficiënte implementatie zou `h` steeds opnieuw in de lus berekenen. 5. **Convergentie testen**: * Schrijf een lus die de integraal berekent voor steeds grotere `n` (bijv. `n = 10, 100, 1000, 10000`). Plot de fout tegen `n` op een log-logschaal om het convergentiegedrag (`h²`) te zien. Stop wanneer de gewenste nauwkeurigheid is bereikt. ### Voorbeeld van een verbetering (Double Precision + Simpson's Regel) ```fortran program simpson_regel implicit none integer, parameter :: n = 1000 ! Moet even zijn real(kind=8), parameter :: a = 0.0d0, b = 3.14159d0 real(kind=8) :: h, x, integraal_resultaat integer :: i h = (b - a) / dble(n) integraal_resultaat = sin(a) + sin(b) ! Eerste en laatste punt ! Oneven punten (index 1, 3, 5, ... n-1) do i = 1, n-1, 2 x = a + i * h integraal_resultaat = integraal_resultaat + 4.0d0 * sin(x) end do ! Even punten (index 2, 4, 6, ... n-2) do i = 2, n-2, 2 x = a + i * h integraal_resultaat = integraal_resultaat + 2.0d0 * sin(x) end do integraal_resultaat = (integraal_resultaat * h) / 3.0d0 write(*,*) "Simpson benadering: ", integraal_resultaat write(*,*) "Fout: ", abs(integraal_resultaat - 2.0d0) end program simpson_regel ``` Je zult zien dat de fout met Simpson's regel en `n=1000` vele malen kleiner is dan met de trapeziumregel.