Здравствуйте, Антон Р..

Код в приложении

Приложение:
{
Составить програму вычисления определенного интеграла от заданной функции
при различных значениях верхнего предела интегрирования b и фиксированном
значении нижнего предела интегрирования 1 методом левых прямоугольников.
Заданная функция: f (x) = (e^x) / (x + 0.4)
}
Program Integral;

{ Подпрограмма вычисления значения заданной функции }
Function F (x : Real) : Real;
begin
F := exp (x) / (x + 0.4);
end;

{
Подпрограмма получения длины разбиения отрезка по заданой точности
Т.к. заданная функция на отрезке [1, b] монотонно возрастает, то
количество точек разбиения для достижения может быть определено.

Действительно:
Т.к. для любых x1<=x2, принадлежащих отрезку [1, b], f(x1)<=f(x2),
то элементы выражения для определения интеграла для метода левых и
правых прямоугольников находятся в таком же соотношении: элемент
левого прямоугольника не больше элемента правого прямоугольника.

Соответственно, вычисленное значение интеграла методом левых
прямоугольников (Iл) не больше вычисленного значения интеграла
методом правых прямоугольников (Iп): Iл<=Iп.

Кроме этого, нам известны соотношения (I - истинное значение
интеграла):
1. I = Iл + Rл (Rл>=0, т.к. функция возрастающая)
2. I = Iп - Rп (Rп>=0)

Отсюда следует, что Iл+Rл=Iп-Rп, т.е. Iп-Iл=Rл+Rп

Пусть нам задана необходимая точность вычисления R
Т.е. необходимо добиться того, чтобы Rл<=R
Если потребовать аналогичного соотношения для Rп получим:
Rл+Rп<=R+R=2R

Раскрывая выражения для методов левых и правых многоугольников и
вычитая первое из второго, получаем:
Iп-Iл = f(b)*dx-f(a)*dx = (f(b)-f(a))*dx
Подставляя вместо левого выражения заведомо большую величину,
получаем:
(f(b)-f(a))*dx<=2R, т.е. dx<=2R/(f(b)-f(a))

Раскрывая выражение для dx как (b-a)/n, получаем:
(b-a)/n <= 2R/(f(b)-f(a)) => n >= (f(b)-f(a))*(b-a)/2R

Т.к. нас интересует минимальная точность, то в качестве n примем
наименьшее целое число, превосходящее указанное выражение.
}
Function GetFrag (a : Real; b : Real; R : Real) : Real;
var
n : Word;

begin
n := Round (0.5 + (((F (b) - F (a)) * (b - a)) / (2 * R)));

writeln ('Количество точек разбиения: ', n);

GetFrag := (b - a) / n;
end;

{
Подпрограмма вычисления значения интеграла методом левых прямоугольников
Параметры:
a, b - границы отрезка
r - допустимая погрешность вычисления
}
Function CalcLRect (a : Real; b : Real; R : Real) : Real;
var
x : Real;
dx : Real;
s : Real;

begin
s := 0;
x := a;
dx := GetFrag (a, b, r);

writeln ('Длина элемента разбиения: ', dx:7:5);

while x < b do
begin
s := s + F (x) * dx;
x := x + dx;
end;

CalcLRect := s;
end;

Const
cMinX = 1.0;

b1 = 4.0;
b2 = 4.5;
b3 = 5.0;
b4 = 5.5;

Var
R : Real;
I : Real;

Begin
write ('Введите требуемую точность вычислений: '); readln (R);
writeln;
writeln ('Вычисление интеграла на отрезке [', cMinX:3:1, '; ', b1:3:1, ']:');
I := CalcLRect (cMinX, b1, R);
writeln ('Значение интеграла равно ', I:10:7);
writeln;
writeln ('Вычисление интеграла на отрезке [', cMinX:3:1, '; ', b2:3:1, ']:');
I := CalcLRect (cMinX, b2, R);
writeln ('Значение интеграла равно ', I:10:7);
writeln;
writeln ('Вычисление интеграла на отрезке [', cMinX:3:1, '; ', b3:3:1, ']:');
I := CalcLRect (cMinX, b3, R);
writeln ('Значение интеграла равно ', I:10:7);
writeln;
writeln ('Вычисление интеграла на отрезке [', cMinX:3:1, '; ', b4:3:1, ']:');
I := CalcLRect (cMinX, b4, R);
writeln ('Значение интеграла равно ', I:10:7);
End.