Całkowanie numeryczne: Metoda prostokątów

W metodzie prostokątów (ang. rectangular integration) korzystamy z definicji całki oznaczonej Riemanna, w której wartość całki interpretowana jest jako suma pól obszarów pod wykresem krzywej w zadanym przedziale całkowania \({[x_p ; x_k]}\). Sumę tę przybliżamy przy pomocy sumy pól odpowiednio dobranych prostokątów. Sposób postępowania jest następujący:

Przedział całkowania \([x_{p};x_{k}]\) dzielimy na \(n\) równych podprzedziałów, wyznaczając punkty \(x_{1},x_{2},\dots ,x_{n}\), w których będziemy badać wysokość prostokątów.. Punkty te wyznaczamy w prosty sposób wg wzoru:

\[
x_i = x_p + \frac{i}{n} \cdot ( x_k - x_p) \quad \text{dla } i = 1,2,\dots,n
\]

Obliczamy odległość między dwoma sąsiednimi punktami - będzie to podstawa każdego prostokąta:

\[
h = \frac{x_k-x_p}{n}
\]

Dla każdego wyznaczonego w ten sposób punktu \(x_i\) obliczamy wartość funkcji \({y_i = f(x_i)}\) w tym punkcie:

\[
y_i = f(x_i), \; \text{dla} \; i = 1,2,\dots,n
\]

Obliczamy sumę iloczynów wyznaczonych wartości funkcji \(y_i\) przez odległość \(h\) między dwoma sąsiednimi punktami - da to sumę pól poszczególnych prostokątów ograniczonych wykresem funkcji:

\[
S = y_1\cdot h + y_2\cdot h +\dots + y_n\cdot h
\]

a po wyprowadzeniu wspólnego czynnika przed nawias:

\[
S = h \cdot \left(y_1+y_2+\dots+y_n\right)
\]

Otrzymana suma jest przybliżoną wartością całki oznaczonej funkcji \(f(x)\) w przedziale \({[x_p ; x_k]}\).

\[
\int\limits_{x_p}^{x_k} f(x) \, dx \approx \frac{x_k - x_p}{n} \cdot \sum_{i=1}^{n} f(x_p + i \cdot h)
\]

Przykład:

Obliczymy ręcznie przybliżoną wartość całki oznaczonej z funkcji \({f(x) = \sin(x)}\) w przedziale \({[0 ; \pi]}\).

Przedział całkowania podzielimy na \({n=4}\) równe podprzedziały, uzyskując punkty, w których wyznaczymy wysokości prostokątów:

\begin{aligned}
&x_1 = \frac{1}{4}\pi \\
&x_2 = \frac{2}{4}\pi \\
&x_3 = \frac{3}{4}\pi \\
&x_4 = \pi
\end{aligned}

Odległość między dwoma sąsiednimi punktami wynosi:

\[
h = \frac{\pi}{4} \approx 0,7854
\]

Dla każdego z wyznaczonych punktów obliczamy wartość funkcji \({f(x) = \sin(x)}\):

\[
\begin{alignat*}{2}
&y_1 = f(x_1) = \sin\frac{1}{4}\pi &&\approx 0{,}7071 \\
&y_2 = f(x_2) = \sin\frac{2}{4}\pi &&= 1{,}0000 \\
&y_3 = f(x_3) = \sin\frac{3}{4}\pi &&\approx 0{,}7071 \\
&y_4 = f(x_4) = \sin\pi &&= 0{,}0000
\end{alignat*}
\]

Obliczamy sumę pól prostokątów:

\[
\begin{aligned}
&S = h \cdot (y_1 + y_2 + y_3 + y_4) \\
&S \approx 0{,}7854 \cdot (0{,}7071 + 1{,}0000 + 0{,}7071 + 0{,}0000) \\
&S \approx 0{,}7854 \cdot 2{,}4142 \\
&S \approx 1{,}8961
\end{aligned}
\]

Dokładna wartość takiej całki oznaczonej wynosi wg tablic:

\[
\int\limits_{0}^{\pi} \sin x \, dx = 2
\]

Zatem popełniliśmy błąd równy: \({2 - 1{,}8961 = 0{,}1039}\), co stanowi nieco ponad 5% wartości dokładnej. W sumie nie jest to zły wynik, zważywszy na ilość wykonanych przez nas rachunków. Jeśli chcemy zwiększyć dokładność, to musimy zsumować więcej prostokątów, ale to zostawimy już komputerom.

do podrozdziału do strony

Specyfikacja problemu

Dane wejściowe

\(x_p\)	- początek przedziału całkowania, \({x_p \in \mathbb{R}}\).
\(x_k\)	- koniec przedziału całkowania, \({x_k \in \mathbb{R}}\).
\(n\)	- liczba podprzedziałów (prostokątów), \({n \in \mathbb{N}}\).
\(f(x)\)	- funkcja rzeczywista, której całkę liczymy.

Dane wyjściowe

\(s\)

- przybliżona wartość całki oznaczonej funkcji \(f(x)\) w przedziale \({[x_p ; x_k]}\), \({s \in \mathbb{R}}\).

Zmienne pomocnicze

\(h\)	- odległość między dwoma sąsiednimi punktami podziałowymi, \({h \in \mathbb{R}}\).
\(i\)	- licznik podprzedziałów, \({i \in \mathbb{N}}\).

Lista kroków

K01:	\(s \leftarrow 0\)
K02:	\(h \leftarrow \dfrac{x_k - x_p}{n}\)
K03:	Dla \(i = 1,2,\dots,n\), wykonuj: \(s \leftarrow s + f\left(x_p + i \cdot h \right)\)
K04:	\(s \leftarrow s \cdot h\)
K05:	Zakończ

Schemat blokowy

Po odczytaniu informacji o krańcach \(x_p\) i \(x_k\) przedziału całkowania oraz liczbie segmentów \(n\) ustawiamy sumę \(s\) na 0, obliczamy szerokość segmentów \(h\) i ustawiamy ich licznik na 1.

Rozpoczynamy pętlę iteracyjną, która wykona się \(n\) razy. Wewnątrz pętli obliczamy i-ty punkt podziałowy \(x_i\) oraz wartość funkcji \(y_i\) w tym punkcie, którą dodajemy do sumy \(s\).

Po zakończeniu pętli sumę \(s\) musimy jeszcze pomnożyć przez szerokość podstawy prostokątów, czyli przez \(h\). Po tej operacji \(s\) zawiera wartość przybliżoną całki. Zwracamy ją użytkownikowi i kończymy algorytm.

do podrozdziału do strony

Prezentowane poniżej programy wyliczają całkę oznaczoną funkcji \({f(x) = x^2 + 2x}\). Przedział całkowania jest dzielony na \({n = 1000}\) segmentów. W przedziale \({[0 ; 1]}\) całka oznaczona ma wartość dokładną równą \({\frac{4}{3} = 1{,}3333\dots}\)

C++

// Obliczanie całki oznaczonej
// metodą prostokątów
//----------------------------
//(C)2004 mgr Jerzy Wałaszek

#include <iomanip>
#include <iostream>
#include <cstdlib>

using namespace std;

// Tutaj definiujemy funkcję
double f(double x)
{
  return(x * x + 2 * x);
}

// Program główny
int main()
{
  // liczba prostokątów podziałowych
  const int N = 1000;
  double xp,xk,s,h;
  int i;

  // 3 cyfry po przecinku
  cout << setprecision(3)
  // format stałoprzecinkowy
       << fixed;

  cout << "Obliczanie  calki oznaczonej\n"
          "za pomoca metody prostokatow\n"
          "----------------------------\n"
          "(C)2004 mgr J.Walaszek  I LO"
          "\n\nf(x) = x * x + 2 * x\n\n"
          "Podaj poczatek "
          "przedzialu calkowania\n\n"
          "xp = ";
  cin >> xp;
  cout << "\nPodaj koniec "
          "przedzialu calkowania\n\n"
          "xk = ";
  cin >> xk;
  cout << endl;
  s = 0;
  h = (xk - xp) / N;
  for(i = 1; i <= N; i++)
    s += f(xp + i * h);
  s *= h;
  cout << "Wartosc calki wynosi : "
       << s
       << endl << endl;
  system("pause");
  return 0;
}

Pascal

// Obliczanie całki oznaczonej
// metodą prostokątów
// ---------------------------
// (C)2004 mgr Jerzy Wałaszek

program int_rect;

// Tutaj definiujemy funkcję
function f(x : double) : double;
begin
  f := x * x + 2 * x;
end;

// Program główny

// liczba prostokątów podziałowych
const N = 1000;

var
  xp,xk,s,h : double;
  i : integer;

begin
  writeln('Obliczanie  calki oznaczonej');
  writeln('za pomoca metody prostokatow');
  writeln('----------------------------');
  writeln('(C)2004 mgr J.Walaszek  I LO');
  writeln;
  writeln('f(x) = x * x + 2 * x');
  writeln;
  writeln('Podaj poczatek ' +
          'przedzialu calkowania');
  writeln;
  write('xp = '); readln(xp);
  writeln;
  writeln('Podaj koniec ' +
          'przedzialu calkowania');
  writeln;
  write('xk = '); readln(xk);
  writeln;
  s := 0;
  h := (xk - xp) / N;
  for i := 1 to N do
    s := s + f(xp + i * h);
  s := s * h;
  writeln('Wartosc calki wynosi : ',
          s:0:3);
  writeln;
  writeln('Nacisnij Enter...');
  readln;
end.

Basic

' Obliczanie całki oznaczonej
' metodą prostokątów
'(C)2006 mgr Jerzy Wałaszek

Public Declare _
  Function f(ByVal x As Double) _
                     As Double

' Program główny

' liczba prostokątów podziałowych
Const N = 1000
Dim As Double xp, xk, s, h
Dim i As Integer

Print "Obliczanie  calki oznaczonej"
Print "za pomoca metody prostokatow"
Print "----------------------------"
Print "(C)2006 mgr J.Walaszek  I LO"
Print
Print "f(x) = x * x + 2 * x"
Print
Print "Podaj poczatek " & _
      "przedzialu calkowania"
Print
Input "xp = ", xp
Print
Print "Podaj koniec " & _
      "przedzialu calkowania"
Print
Input "xk = ", xk
Print
s = 0
h = (xk - xp) / N
For i = 1 To N
  s += f(xp + i * h)
Next
s *= h
Print Using "Wartosc calki " & _
      "wynosi : ####.###"; s

' Gotowe
Print
Print "KONIEC. Nacisnij " & _
      "dowolny klawisz..."
Sleep
End

' Tutaj definiujemy funkcję
Public Function f(ByVal x As Double) _
                  As Double
    Return x * x + 2 * x
End Function

Python (dodatek)

# Obliczanie całki oznaczonej
# metodą prostokątów
#(C)2026 mgr Jerzy Wałaszek

# Tutaj definiujemy funkcję
def f(x):
    return x * x + 2 * x

# Program główny

# liczba prostokątów podziałowych
n = 1000

print("Obliczanie  całki oznaczonej")
print("za pomocą metody prostokątów")
print("----------------------------")
print("(C)2026 mgr J.Wałaszek  I LO")
print()
print("f(x) = x * x + 2 * x")
print()
print("Podaj początek "
      "przedziału całkowania")
print()
xp = float(input("xp = "))
print()
print("Podaj koniec "
      "przedziału całkowania")
print()
xk = float(input("xk = "))
print()
s = 0
h = (xk - xp) / n
for i in range(1,n + 1):
    s += f(xp + i * h)
s *= h
print(f"Wartość całki "
      f"wynosi : {s:.3f}")

# Gotowe
print()
input("Naciśnij Enter...")

Wynik:

Obliczanie  całki oznaczonej
za pomocą metody prostokątów
----------------------------
(C)2026 mgr J.Wałaszek  I LO

f(x) = x * x + 2 * x

Podaj początek przedziału całkowania

xp = 0

Podaj koniec przedziału całkowania

xk = 1

Wartość całki wynosi : 1.335

Naciśnij Enter...

JavaScript

<html>
  <head>
    <title>Całkowanie numeryczne
    metodą prostokątów</title>
  </head>
  <body>

<div style="overflow-x: auto;"
     align="center">
  <table
  border="0"
  cellpadding="4"
  style="border-collapse:
         collapse">
    <tr>
      <td nowrap>
        <form
        name="frm"
        style="text-align: center;
               background-color:
               #E7E7DA">
          <b>
          Obliczanie całki
          oznaczonej
          <br>&nbsp;&nbsp;
          za pomocą
          metody prostokątów
          &nbsp;&nbsp;</b><br>
          (C)2026 mgr
          Jerzy Wałaszek
          <hr>
          Całkowana funkcja:<br>
          f(x) =
          x<sup>2</sup> + 2x
          <hr>
          Przedział całkowania<br>
          x<sub>p</sub> =
          <input
          name="xp_inp"
          size="15"
          value="0"
          type="text"
          style="text-align:
                 right">
          <br>
          x<sub>k</sub> =
          <input
          name="xk_inp"
          size="15"
          value="1"
          type="text"
          style="text-align:
                 right">
          <hr>
          <input
          onclick="js_rectangle();"
          value="Oblicz całkę"
          name="B1"
          type="button">
          <hr>
          Wartość całki wynosi:
          <div id="out">.</div>
        </form>
      </td>
    </tr>
  </table>
</div>

<script language="JavaScript">

// Obliczanie całki oznaczonej
// metodą prostokątów
// (C)2004 mgr Jerzy Wałaszek

// Tutaj definiujemy funkcję
function f(x)
{
  return(x * x + 2 * x);
}

function js_rectangle()
{
  // liczba prostokątów
  var N = 1000;
  var xp,xk,s,h,i,t;

  xp = parseFloat(
       document.frm.xp_inp.value)
  xk = parseFloat(
       document.frm.xk_inp.value)
  if(isNaN(xp) || isNaN(xk))
    t = "<font color=red><b>" +
        "Popraw dane wejściowe!" +
        "</b></font>"
  else
  {
    s  = 0
    h = (xk - xp) / N
    for(i = 1; i <= N; i++)
      s += f(xp + i * h)
    s *= h
    t = Math.round(s * 1000) / 1000;
  }
  
  document.getElementById("out")
  .innerHTML = t
}

</script>

  </body>
</html>

do podrozdziału do strony

Metoda prostokątów

Algorytm całkowania metodą prostokątów

Opis algorytmu

Specyfikacja problemu

Dane wejściowe

Dane wyjściowe

Zmienne pomocnicze

Lista kroków

Schemat blokowy

Przykładowe programy