JustPaste.it

Całkowanie numeryczne - metoda trapezów

4f83044e60663c578eda528866d1c705.gif

6e18a14f536be230308b02df25ba8fba.gif

Opisana w poprzednim rozdziale metoda prostokątów nie jest zbyt dokładna, ponieważ pola użytych w niej prostokątów źle odwzorowują pole pod krzywą. Dużo lepszym rozwiązaniem jest zastosowanie zamiast nich trapezów o wysokości dx i podstawach równych odpowiednio wartości funkcji w punktach krańcowych.. Sama zasada nie zmienia się.

Przedział całkowania <xp,xk> dzielimy na n+1 równo odległych punktów x0,x1,x2,...,xn. Punkty te wyznaczamy w prosty sposób wg wzoru:

dla i = 0,1,2,...,n

xi = xp +  i (xk - xp)
n

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

dx =  xk - xp
n

Dla każdego wyznaczonego w ten sposób punktu obliczamy wartość funkcji f(x) w tym punkcie:

dla i = 0,1,2,...,n
fi = f(xi)

Pole pod wykresem funkcji przybliżane jest polami n trapezów. Pole i-tego trapezu obliczamy wg wzoru:

dla i=1,2,...,n

Pi =   fi-1 + fi dx
2

Przybliżona wartość całki jest sumą pól wszystkich otrzymanych w ten sposób trapezów:

s = P1 + P2 + ... + Pn

czyli

68fcb71f0444b3f0174e821cbddac308.gif

Wyprowadzony na końcu wzór jest podstawą przybliżonego wyliczania całki w metodzie trapezów.

25e21de027f3607105895e6b67e1e2af.gif

e0417e253a4c679ce82b2aaa0501f4bb.gif

 

Obliczymy ręcznie przybliżoną wartość całki oznaczonej z funkcji f(x) = sin(x) w przedziale <0,π>.

Przedział podzielimy na n+1 = 5 punktów:

9948d384c3044dad54e4ea71025fb4d9.gif

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

33706e1b238849d02e48d8fe04432db5.gif

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

 fo = f (xo) = sin 0   = 0,0000
02f32138866dc89ba9ffe6a5db2564eb.gif

Obliczamy sumę pól trapezów:

s = dx( f1 + f2 + f3 +   fo + f4  )
2

s = 0,7854(0.7071+1+0.7071) = 1,8961

Otrzymaliśmy wynik identyczny jak w przypadku metody prostokątów - dlaczego?

5ab1bed16fb1840f6efb937818da09a3.gif

Dane wejściowe

xp - początek przedziału całkowania,  xp b29400b740c59de05210d21716734e9c.gif R
xk - koniec przedziału całkowania,  xk b29400b740c59de05210d21716734e9c.gif R
n - liczba punktów podziałowych,  n b29400b740c59de05210d21716734e9c.gif N
f(x) - funkcja rzeczywista, której całkę liczymy

Dane wyjściowe

Wartość całki oznaczonej funkcji f(x) w przedziale <xp,xk>. Wynik jest liczbą rzeczywistą.

Zmienne pomocnicze

s - suma wysokości prostokątów, którą później zamieniamy w wartość całki,  s b29400b740c59de05210d21716734e9c.gif R
dx - odległość między dwoma sąsiednimi punktami podziałowymi,  dx b29400b740c59de05210d21716734e9c.gif R
i - licznik punktów podziałowych,  i b29400b740c59de05210d21716734e9c.gif N

30ef1684de92c07d55370cc808526555.gif

krok 1: Czytaj xp  xk
krok 2: s 8ff000644f31c527f447916e8e7f4753.gif 0
krok 3:
dx 8ff000644f31c527f447916e8e7f4753.gif   xk - xp
n
krok 4: Dla i = 1,2,...,n,   s 8ff000644f31c527f447916e8e7f4753.gif s + f(xp + i f8de95a28eacf482a4d3812c12851de8.gif dx)
krok 5:
s 8ff000644f31c527f447916e8e7f4753.gif (s +  f(xp) + f(xk)  ) f8de95a28eacf482a4d3812c12851de8.gif dx
2
krok 6: Pisz s i zakończ algorytm

01266aae6b92f654d9eeab7cd4bfb52b.gif

 

Po odczytaniu informacji o krańcach xp i xk przedziału całkowania ustawiamy sumę s na 0, obliczamy odległość dx pomiędzy sąsiednimi punktami podziałowymi i ustawiamy ich licznik na 1.

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

Po zakończeniu pętli do sumy s dodajemy średnią wartość funkcji na krańcach przedziału i całość przemnażamy przez dx Po tej operacji s zawiera wartość przybliżoną całki. Zwracamy ją użytkownikowi i kończymy algorytm.


8d225355a4abccbb1bb83ec39248a961.gif

4db141fccad64e68f6378079fc19d5c0.gif    
   
   

2081beb891cd3ed08ea8a957522fa2a8.gif

Poniższe, przykładowe programy są praktyczną realizacją omawianego w tym rozdziale algorytmu. Zapewne można je napisać bardziej efektywnie. To już twoje zadanie. Dokładny opis stosowanych środowisk programowania znajdziesz we wstępie. Programy przed opublikowaniem w serwisie edukacyjnym zostały dokładnie przetestowane. Jeśli jednak znajdziesz jakąś usterkę (co zawsze może się zdarzyć), to prześlij o niej informację do autora. Pozwoli to ulepszyć nasze artykuły. Będziemy Ci za to wdzięczni.

  
       

Prezentowane poniżej programy wyliczają całkę oznaczoną funkcji f(x) = x2 + 2x. Przedział całkowania jest dzielony na n=1000 punktów. W przedziale <0,1> całka oznaczona ma wartość dokładną równą 4/3 = 1.3333...

Wydruk z uruchomionego programu 
Obliczanie  całki oznaczonej
 za pomocą  metody trapezów
----------------------------
(C)2006 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,333

KONIEC. Naciśnij dowolny klawisz...
Microsoft Visual Basic 2005 Express Edition

 

Borland
Delphi 7.0
Personal
Edition		 
//*************************************************
//** Obliczanie całki oznaczonej metodą trapezów **
//** ------------------------------------------- **
//** (C)2004 mgr Jerzy Wałaszek  I LO w Tarnowie **
//*************************************************

program int_trapez;

{$APPTYPE CONSOLE}

//*******************************
//** Tutaj definiujemy funkcję **
//*******************************

function f(x : real) : real;
begin
  f := x * x + 2 * x;
end;

//********************
//** Program główny **
//********************

const N = 1000; //liczba punktów/trapezów podziałowych

var
  xp,xk,s,dx : real;
  i : integer;

begin
  writeln('Obliczanie  calki oznaczonej');
  writeln(' za pomoca  metody trapezow');
  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;
  dx := (xk - xp) / N;
  for i := 1 to N - 1 do s := s + f(xp + i * dx);
  s := (s + (f(xp) + f(xk)) / 2)* dx;
  writeln('Wartosc calki wynosi : ',s:8:3);
  writeln;
  writeln('Nacisnij klawisz Enter...');
  readln;
end.
Borland
C++ Builder
6.0
Personal
Edition		 
//****************************************************
//**  Obliczanie całki oznaczonej  metodą trapezów  **
//** ---------------------------------------------- **
//** (C)2004 mgr Jerzy Wałaszek     I LO w Tarnowie **
//****************************************************

#include <iomanip>
#include <iostream>

using namespace std;

//*******************************
//** Tutaj definiujemy funkcję **
//*******************************

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

//********************
//** Program główny **
//********************

int main()
{
  const int N = 1000; //liczba punktów/trapezów podziałowych
  double xp,xk,s,dx;
  int i;
  char c[1];

  cout.precision(3);      // 3 cyfry po przecinku
  cout.setf(ios::fixed);  // format stałoprzecinkowy

  cout << "Obliczanie  calki oznaczonej\n"
          " za pomoca  metody trapezow\n"
          "----------------------------\n"
          "(C)2004 mgr J.Walaszek  I LO\n\n"
          "f(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;
  dx = (xk - xp) / N;
  for(i = 1; i < N; i++) s += f(xp + i * dx);
  s = (s + (f(xp) + f(xk)) / 2) * dx;
  cout << "Wartosc calki wynosi : " << setw(8) << s
       << "\n\nNacisnij klawisz Enter";
  cin.getline(c, 1);
  cin.getline(c, 1);
}
Microsoft
Visual
Basic 2005
Express
Edition		 
'****************************************************
'**  Obliczanie całki oznaczonej  metodą trapezów  **
'** ---------------------------------------------- **
'** (C)2006 mgr Jerzy Wałaszek     I LO w Tarnowie **
'****************************************************

Module Module1

  '*******************************
  '** Tutaj definiujemy funkcję **
  '*******************************

  Public Function f(ByVal x As Double) As Double
    Return x * x + 2 * x
  End Function

  '********************
  '** Program główny **
  '********************

  Sub Main()

    Const N = 1000 'liczba punktów/trapezów podziałowych

    Dim xp, xk, s, dx As Double
    Dim i As Integer

    Console.WriteLine("Obliczanie  całki oznaczonej")
    Console.WriteLine(" za pomocą  metody trapezów")
    Console.WriteLine("----------------------------")
    Console.WriteLine("(C)2006 mgr J.Wałaszek  I LO")
    Console.WriteLine()
    Console.WriteLine("f(x) = x * x + 2 * x")
    Console.WriteLine()
    Console.WriteLine("Podaj początek przedziału całkowania")
    Console.WriteLine()
    Console.Write("xp = ") : xp = Val(Console.ReadLine())
    Console.WriteLine()
    Console.WriteLine("Podaj koniec przedziału całkowania")
    Console.WriteLine()
    Console.Write("xk = ") : xk = Val(Console.ReadLine())
    Console.WriteLine()
    s = 0
    dx = (xk - xp) / N
    For i = 1 To N - 1 : s += f(xp + i * dx) : Next
    s = (s + (f(xp) + f(xk)) / 2) * dx
    Console.WriteLine("Wartość całki wynosi : {0,8:F3}", s)

    ' Gotowe

    Console.WriteLine()
    Console.WriteLine("KONIEC. Naciśnij dowolny klawisz...")
    Console.ReadLine()

  End Sub

End Module
Python 
# -*- coding: cp1250 -*-
#*************************************************
#** Obliczanie całki oznaczonej metodą trapezów **
#** ------------------------------------------- **
#** (C)2005 mgr Jerzy Wałaszek  I LO w Tarnowie **
#*************************************************

#*******************************
#** Tutaj definiujemy funkcję **
#*******************************

def f(x):
  return x * x + 2 * x;

#********************
#** Program główny **
#********************

N = 1000 #liczba punktów/trapezów podziałowych

print "Obliczanie calki oznaczonej"
print " za pomoca metody trapezów"
print "---------------------------"
print "(C)2005 mgr J.Walaszek I LO"
print
print "f(x) = x * x + 2 * x"
print
print "Podaj poczatek przedzialu calkowania"
print
xp = float(raw_input("xp = "))
print
print "Podaj koniec przedzialu calkowania"
print
xk = float(raw_input("xk = "))
print
s = 0.
dx = (xk - xp) / N
for i in range(1, N):
  s += f(xp + i * dx)
s = (s + (f(xp) + f(xk)) / 2)* dx;
print "Wartosc calki wynosi : %8.3f" % s
print
raw_input("Koniec - nacisnij klawisz Enter...")
JavaScript 
<html>
<head>
  <title>Całkowanie numeryczne metodą trapezów</title>
</head>
<body>
<script language="JavaScript">

//****************************************************
//**  Obliczanie całki oznaczonej  metodą trapezów  **
//** ---------------------------------------------- **
//**  (C)2004 mgr Jerzy Wałaszek   I LO w Tarnowie  **
//****************************************************

//*******************************
//** Tutaj definiujemy funkcję **
//*******************************

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

function js_trapez()
{
  var N = 1000; //liczba punktów/trapezów podziałowych
  var xp,xk,s,dx,i,t;

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

</script>

<form method="POST"
      name="frm_trapez"
      style="border: 2px solid #FF9900;
             padding-left: 4px;
             padding-right: 4px;
             padding-top: 1px;
             padding-bottom: 1px;
             background-color: #FFFFCC">
  <h2 style="text-align: center">
    Obliczanie całki oznaczonej<br>
    za pomocą metody prostokątów
  </h2>
  <hr>
  <h4 style="text-align: center">
    (C)2004 mgr Jerzy Wałaszek I LO w Tarnowie
  </h4>
  <h3 style="text-align: center">
    Całkowana funkcja:
  </h3>
  <h4 style="text-align: center">
    <i>f(x) = x<sup>2</sup> + 2x</i>
  </h4>
  <p style="text-align: center">
    Tutaj określ przedział całkowania
  </p>
  <p style="text-align: center">
    Początek <i>x<sub>p</sub></i> =
    <input type="text" name="xp_inp" size="20" value="0">
    i koniec <i>x<sub>k</sub> </i>=
    <input type="text" name="xk_inp" size="20" value="1">
  </p>
  <p style="text-align: center">
    <input onclick="js_trapez();" type="button"
           value="Oblicz całkę" name="B1">
  </p>
  <h4 style="text-align: center">
    Wartość całki wynosi
  </h4>
  <p id="t_out" style="text-align: center">...</p>
</form>
</body>
</html> 
 
Dokument ten rozpowszechniany jest zgodnie z zasadami licencji
GNU Free Documentation License.

 

Źródło: mgr Jerzy Wałaszek

technologia programowanie algorytmy całkowanie