Całka oznaczona f(x) w przedziale <a,b>

mam napisac programik obliczajacy calke oznaczona funkcji f(x) w przedziale <a,b> dwoma metodami:

1. metoda trapezow (kwadratura trapezu):
   polega na aproksymowaniu funkcji podcalkowej za pomoca linii prostej dla kazdego podprzedzialu. Calke z poprzedzialu obliczamy w sposob przyblizony za pomoca wzoru

s=(b-a/2)(f(a)+f(b))

gdzie f jest funkcja podcalkowa, a jest poczatkiem, b-koncem przedzialu. Wzor mozna zapisac takze

s=((f(a)+f(a+h))/2)*h, gdzie h jest dlugoscia podprzedzialu

2. metoda Simpsona (kwadratura parabol)
   metoda polega na aproksymowaniu fukncji podcalkowej parabolami dla kazdego podprzedzialu. Calke z poprzedzialu obliczamy w sposob przyblizony za pomoca wzoru:

s=((b-a)/2)(f(a)+4f((a+b)/2)+f(b))

moze ktos juz kiedys cos takiego robil, albo potrafi mi powiedziec, jak sie w ogóle do tego zabrac? z gory dzieki za pomoc :)

Sprawdź w dowolnym skrypcie z Metod Numerycznych. Powinny być schematy blokowe programów.

DevilHimself napisał(a)

Sprawdź w dowolnym skrypcie z Metod Numerycznych. Powinny być schematy blokowe programów.

ekhmm nie bardzo rozumiem szczerze mowiac o czym mowisz ;-P mozna jasniej ??

METODA PROSTOKATOW

#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/prostokątów podziałowych
  double xp,xk,s,dx;
  int i;

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

  cout << "Obliczanie  calki oznaczonej\n"
          "za pomoca metody prostokatow\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 *= dx;
  cout << "Wartosc calki wynosi : " << setw(8) << s
       << "\n\n";
  system("PAUSE"); return 0;
}

METODA TRAPEZOW

#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;

  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"
          "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\n";
  system("PAUSE"); return 0;
}

METODA SIMPSONA

#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 = 10; //liczba punktów podziałowych
  double xp,xk,s,st,dx,x;
  int i;

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

  cout << "Obliczanie calki oznaczonej\n"
          " za pomoca metody Simpsona\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; st = 0;
  dx = (xk - xp) / N;
  for(i = 1; i <= N; i++)
  {
    x = xp + i * dx;
    st += f(x - dx / 2);
    if(i < N) s += f(x);
  };
  s = dx / 6 * (f(xp) + f(xk) + 2 * s + 4 * st);
  cout << "Wartosc calki wynosi : " << setw(8) << s
       << "\n\n";
  system("PAUSE"); return 0;
}

programy dzialaja pod kompilatorem Dev-C++ 4.9.9.2

dzieki wielkie za pomoc ;) teraz poobczajam co i jak i biore sie za swoj program ^^ :-)

rudnik napisał(a)

dzieki wielkie za pomoc ;) teraz poobczajam co i jak i biore sie za swoj program ^^ :-)

Jak sie chcesz zabrać za "swój" program nie mając pojęcia na czym polega metoda Simpsona i prostokątów? (wiem że jestem upierdliwy ;) )

krzwaw83 napisał(a)

METODA PROSTOKATOW

#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/prostokątów podziałowych
  double xp,xk,s,dx;
  int i;

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

  cout << "Obliczanie  calki oznaczonej\n"
          "za pomoca metody prostokatow\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 *= dx;
  cout << "Wartosc calki wynosi : " << setw(8) << s
       << "\n\n";
  system("PAUSE"); return 0;
}

czy mógłby mi ktos powiedziec co dzieje sie w tych linijkach??

cout.precision(3);      // 3 cyfry po przecinku
cout.setf(ios::fixed);  // format stałoprzecinkowy
.
.
.
cout << "Wartosc calki wynosi : " << setw(8) << s
       << "\n\n";