Программа вычисления интеграла методом трапеций

[shewlett]

Нужно написать программу, позволяющую вычислить интеграл от функции 1.2(900-x)(cos(0.05223*x))^3 методом трапеций.
Кое-какие наброски есть, но что делать дальше не знаю. Программа не работает, понимаю, что куча ошибок, но не знаю каких и как исправить. Помогите.

program rfr;
  var dx,x1,x2,e,i:real;
function Fx(x:real):real;
  begin
  Fx:=1.2*(900-x)*(exp(3*ln(cos*(0.05223*x))));
  end;
procedure CountViaTrap;
  var xx1,xx2,xx3:real;
  c:longint;
    begin
    writeln('Vsego interaciy:',round(abs(x2-x1)/e));
    i:=0;
    for c:=1 to round(abs(x2-x1)/e) do begin
    write('Interaciya',c,chr(13));
    xx1:=Fx(x1+c*e);
    xx2:=Fx(x1+c*e+e);
    if xx2>xx1 then xx3:=xx1 else xx3:=xx2;
    i:=i+abs(xx2-xx1)*e+abs(xx3)*e;
    end;
  writeln('Integral=', i);
  end;
      begin
      writeln('Vvedite ishodnie znacheniya:');
      write('Nachalnoe znachenie x(x1)=');readln(x1);
      write('Konechnoe znachenie x(x2)=');readln(x2);
      write('Tochnost vichisleniyya(e)=');readln(e);
      countViaTrap;
end.

[type_Oleg]

Вы не поверите, но ошибка всего одна. Вот тут

Fx:=1.2*(900-x)*(exp(3*ln(cos*(0.05223*x))));

Удалите * после cos, и будет щастье.
Я проверил, считает правильно. Проверяйте - тут

Только e - это не точность вычисления, а всего лишь шаг интегрирования. Точность сложнее определить.

[FPaul]

Точность можно определить используя правило Рунге (Wikipedia).
Я когда-то из любопытства собирал тестовую прогу для разных методов

{
 Программа для вычисления интеграла
 численными методами Симпсона, левых и правых прямоугольников, трапеций
 с заданной погрешностью вычислений
}
program AnyInt;

const
  {коэффициенты пропорциональности из правила Рунге для различных
   методов интегрирования
   Delta_2N=Q*Abs(I_2N - I_N)
  }
  Qsymp = 1 / 15;
  Qsqr  = 1 / 3;
const
  EpsConst = 0.00001;

  {интегрируемая функция}
  function F(x: real): real;
  begin
    F := sin(x);
    {  F:=exp(2*sin(x)) * sin(5+2*cos(x));}
  end;

  function IntSympson(a, b: real; n: integer): real;
  var
    Res: real;
    h: real; {величина шага}
    x: real;
    i: integer;
  begin
    h := (b - a) / n;
    Res := F(a) + F(b);
    i := 1;
    while i < n do
    begin
      x := a + i * h;
      Res := Res + 4 * F(x);
      Inc(i);
      x := a + i * h;
      Res := Res + 2 * F(x);
      Inc(i);
    end;
    Res := Res * h / 3;
    IntSympson := Res;
  end;

  function IntSquareR(a, b: real; n: integer): real;
  var
    Res: real;
    h: real; {величина шага}
    x: real;
    i: integer;
  begin
    h := (b - a) / n;
    Res := 0;
    i := 1;
    while i <= n do
    begin
      x := a + i * h;
      Res := Res + F(x);
      Inc(i);
    end;
    Res := h * Res;
    IntSquareR := Res;
  end;

  function IntSquareL(a, b: real; n: integer): real;
  var
    Res: real;
    h: real; {величина шага}
    x: real;
    i: integer;
  begin
    h := (b - a) / n;
    Res := 0;
    i := 0;
    while i < n do
    begin
      x := a + i * h;
      Res := Res + F(x);
      Inc(i);
    end;
    Res := h * Res;
    IntSquareL := Res;
  end;

  function IntTrap(a, b: real; n: integer): real;
  var
    Res: real;
    h: real; {величина шага}
    x: real;
    i: integer;
  begin
    h := (b - a) / n;
    Res := (F(a) + F(b)) / 2;
    i := 1;
    while i < n do
    begin
      x := a + i * h;
      Res := Res + F(x);
      Inc(i);
    end;
    Res := h * Res;
    IntTrap := Res;
  end;

var
  a, b,           {границы интегрирования}
  Eps: real;   {погрешность численного интегрирования}

  n: integer;{количество подинтервалов интегрирования}
  Icur,           {значение интеграла на текущем шаге итерации}
  Ipre: real;   {значение интеграла на предыдущем шаге итерации}

begin
  WriteLn('====================================');
  a := 0;
  b := Pi;
  Eps := EpsConst;

  WriteLn('Sympson');
  n := 2;
  Icur := IntSympson(a, b, n);
  repeat
    Ipre := Icur;
    n := 2 * n;                {увеличиваем количество подинтервалов}
    Icur := IntSympson(a, b, n);
    WriteLn('I=', Icur: 10: 8, ' при n=', n, ', e=', Abs(Icur - Ipre): 10: 8);
  until Qsymp * Abs(Icur - Ipre) < Eps;
  WriteLn('I=', Icur: 10: 8, ' при n=', n, ', e=', Abs(Icur - Ipre): 10: 8);

  WriteLn('------------------------------------');
  WriteLn('Right Squaries');
  n := 2;
  Icur := IntSquareR(a, b, n);
  repeat
    Ipre := Icur;
    n := 2 * n;                {увеличиваем количество подинтервалов}
    Icur := IntSquareR(a, b, n);
    WriteLn('I=', Icur: 10: 8, ' при n=', n, ', e=', Abs(Icur - Ipre): 10: 8);
  until Qsqr * Abs(Icur - Ipre) < Eps;
  WriteLn('I=', Icur: 10: 8, ' при n=', n, ', e=', Abs(Icur - Ipre): 10: 8);

  WriteLn('------------------------------------');
  WriteLn('Left Squaries');
  n := 2;
  Icur := IntSquareL(a, b, n);
  repeat
    Ipre := Icur;
    n := 2 * n;                {увеличиваем количество подинтервалов}
    Icur := IntSquareL(a, b, n);
    WriteLn('I=', Icur: 10: 8, ' при n=', n, ', e=', Abs(Icur - Ipre): 10: 8);
  until Qsqr * Abs(Icur - Ipre) < Eps;
  WriteLn('I=', Icur: 10: 8, ' при n=', n, ', e=', Abs(Icur - Ipre): 10: 8);

  WriteLn('------------------------------------');
  WriteLn('Trapec');
  n := 2;
  Icur := IntTrap(a, b, n);
  repeat
    Ipre := Icur;
    n := 2 * n;                {увеличиваем количество подинтервалов}
    Icur := IntTrap(a, b, n);
    WriteLn('I=', Icur: 10: 8, ' при n=', n, ', e=', Abs(Icur - Ipre): 10: 8);
  until Qsqr * Abs(Icur - Ipre) < Eps;
  WriteLn('I=', Icur: 10: 8, ' при n=', n, ', e=', Abs(Icur - Ipre): 10: 8);
end.

[FPaul]

Или покороче, но для TurboPascal потебуется лёгкие косметические изменения

{
 Программа для вычисления интеграла
 численными методами Симпсона, левых и правых прямоугольников, трапеций
 с заданной погрешностью вычислений
}
program AnyInt;

const
  {коэффициенты пропорциональности из правила Рунге для различных
   методов интегрирования
   Delta_2N=Q*Abs(I_2N - I_N)
  }
  Qsymp = 1 / 15;
  Qsqr  = 1 / 3;
const
  EpsConst = 0.00001;
type
  TMethodFunc = function(a, b: real; n: integer): real;
  TIntegralFunc = function(x: real): real;

  {интегрируемая функция}
  function F(x: real): real;
  begin
    F := sin(x);
    {  F:=exp(2*sin(x)) * sin(5+2*cos(x));}
  end;

  function IntSympson(a, b: real; n: integer): real;
  var
    Res: real;
    h: real; {величина шага}
    x: real;
    i: integer;
  begin
    h := (b - a) / n;
    Res := F(a) + F(b);
    i := 1;
    while i < n do
    begin
      x := a + i * h;
      Res := Res + 4 * F(x);
      Inc(i);
      x := a + i * h;
      Res := Res + 2 * F(x);
      Inc(i);
    end;
    Res := Res * h / 3;
    IntSympson := Res;
  end;

  function IntSquareR(a, b: real; n: integer): real;
  var
    Res: real;
    h: real; {величина шага}
    x: real;
    i: integer;
  begin
    h := (b - a) / n;
    Res := 0;
    i := 1;
    while i <= n do
    begin
      x := a + i * h;
      Res := Res + F(x);
      Inc(i);
    end;
    Res := h * Res;
    IntSquareR := Res;
  end;

  function IntSquareL(a, b: real; n: integer): real;
  var
    Res: real;
    h: real; {величина шага}
    x: real;
    i: integer;
  begin
    h := (b - a) / n;
    Res := 0;
    i := 0;
    while i < n do
    begin
      x := a + i * h;
      Res := Res + F(x);
      Inc(i);
    end;
    Res := h * Res;
    IntSquareL := Res;
  end;

  function IntTrap(a, b: real; n: integer): real;
  var
    Res: real;
    h: real; {величина шага}
    x: real;
    i: integer;
  begin
    h := (b - a) / n;
    Res := (F(a) + F(b)) / 2;
    i := 1;
    while i < n do
    begin
      x := a + i * h;
      Res := Res + F(x);
      Inc(i);
    end;
    Res := h * Res;
    IntTrap := Res;
  end;

  function Integral(Method: TMethodFunc; F: TIntegralFunc; a, b, Eps, Q: real): real;
  var
    n: integer;   {количество подинтервалов интегрирования}
    Icur,         {значение интеграла на текущем шаге итерации}
    Ipre: real;   {значение интеграла на предыдущем шаге итерации}
  begin
    n := 2;
    Icur := Method(a, b, n);
    repeat
      Ipre := Icur;
      n := 2 * n;                {увеличиваем количество подинтервалов}
      Icur := Method(a, b, n);
      WriteLn('I=', Icur: 10: 8, ' при n=', n, ', e=', Abs(Icur - Ipre): 10: 8);
    until Q * Abs(Icur - Ipre) < Eps;
    writeln('Итог:');
    WriteLn('I=', Icur: 10: 8, ' при n=', n, ', e=', Abs(Icur - Ipre): 10: 8);
    Integral := Icur;
  end;

var
  a, b,        {границы интегрирования}
  Eps: real;   {погрешность численного интегрирования}

begin
  WriteLn('====================================');
  a := 0;
  b := Pi;
  Eps := EpsConst;

  WriteLn('Sympson');
  Integral(@IntSympson, @F, a, b, Eps, Qsymp);

  WriteLn('------------------------------------');
  WriteLn('Right Squaries');
  Integral(@IntSquareR, @F, a, b, Eps, Qsqr);

  WriteLn('------------------------------------');
  WriteLn('Left Squaries');
  Integral(@IntSquareL, @F, a, b, Eps, Qsqr);

  WriteLn('------------------------------------');
  WriteLn('Trapec');
  Integral(@IntTrap, @F, a, b, Eps, Qsqr);
end.

[shewlett]

Спасибо за помощь!