Całkowanie Numeryczne

Słowo "całkowanie" może przerażać, ale w informatyce oznacza to po prostu obliczanie pola powierzchni pod wykresem funkcji.

Na maturze często padają zadania, w których trzeba policzyć, jaką powierzchnię zajmuje figura ograniczona od góry krzywą $f(x)$, od dołu osią X, oraz z boków przedziałami $a$ i $b$. Do dyspozycji mamy dwie metody: metodę prostokątów oraz, odrobinę dokładniejszą, metodę trapezów.

Metoda Prostokątów

Ta metoda dzieli pole pod wykresem na wiele pionowych słupków (prostokątów). Jeśli szerokość każdego prostokąta to dx, to pole jednego prostokąta wynosi po prostu wysokość * szerokość, czyli f(x) * dx.

Aby policzyć całe pole, wystarczy w pętli zsumować pola wszystkich malutkich prostokątów. Im więcej prostokątów narysujemy (im mniejsze dx), tym dokładniejszy otrzymamy wynik.

Python

def f(x):
    return x * x + 2  # Przykładowa funkcja f(x) = x^2 + 2

def calka_prostokaty(a, b, n):
    szerokosc = (b - a) / n  
    pole = 0.0
    x = a + (szerokosc / 2.0)
    for i in range(n):
        pole += f(x) * szerokosc
        x += szerokosc 
    return pole

print(f"Pole (prostokąty): {calka_prostokaty(0, 10, 1000)}")

C++

#include <iostream>
using namespace std;

double f(double x) {
    return x * x + 2; 
}

double calkaProstokaty(double a, double b, int n) {
    double szerokosc = (b - a) / n;
    double pole = 0.0;
    double x = a + (szerokosc / 2.0);
    
    for (int i = 0; i < n; i++) {
        pole += f(x) * szerokosc;
        x += szerokosc;
    }
    return pole;
}

int main() {
    cout << "Pole (prostokaty): " << calkaProstokaty(0.0, 10.0, 1000) << endl;
    return 0;
}

Metoda Trapezów

Zamiast rysować płaskie prostokąty, metoda trapezów łączy punkty na wykresie ukośnymi liniami. Zamiast prostokąta powstaje trapez prostokątny. Pole takiego trapezu to standardowy wzór: $P = rac{(y_1 + y_2)}{2} \cdot h$, gdzie wysokościami trapezu (jego podstawami w pionie) są wartości funkcji na końcach małego przedziału.

Python

def calka_trapezy(a, b, n):
    szerokosc = (b - a) / n
    pole = (f(a) + f(b)) / 2.0
    
    for i in range(1, n):
        x = a + i * szerokosc
        pole += f(x)
        
    return pole * szerokosc

print(f"Pole (trapezy): {calka_trapezy(0, 10, 1000)}")

C++

#include <iostream>
using namespace std;

double fTrapez(double x) {
    return x * x + 2;
}

double calkaTrapezy(double a, double b, int n) {
    double szerokosc = (b - a) / n;
    double pole = (fTrapez(a) + fTrapez(b)) / 2.0;
    
    for (int i = 1; i < n; i++) {
        double x = a + i * szerokosc;
        pole += fTrapez(x);
    }
    
    return pole * szerokosc;
}

int main() {
    cout << "Pole (trapezy): " << calkaTrapezy(0.0, 10.0, 1000) << endl;
    return 0;
}

[!TIP] Dla dociekliwych: Optymalizacja Trapezów Zwróć uwagę na kod C++. Zamiast w pętli obliczać dla każdego trapezu (f(x1) + f(x2))/2 * dx, wyciągamy dx przed nawias. Co więcej, każda wewnętrzna "ścianka" jest jednocześnie prawym bokiem jednego trapezu i lewym drugiego, dlatego w sumie mnoży się razy 1. Jedynie skrajne krawędzie pojawiają się tylko raz, więc liczymy je jako połówki. Stąd na początku pole = (f(a) + f(b)) / 2.0;.