task3_v1

program t3;

uses cthreads, ptcGraph;

type
    function_t = function(x: double): double;

{$F+}

{ функция 1 }
function Func1(x: double): double;
begin
    Func1 := 3 * (0.5 / (x + 1) + 1);
end;

{ первая производная функции 1 }
function Func1prime1 (x: double): double;
begin
    Func1prime1 := -6 / ((2 * x + 2) * (2 * x + 2));
end;

{ вторая производная функции 1 }
function Func1prime2 (x: double): double;
begin
    Func1prime2 := 3 * ((x + 1) * (x + 1) * (x + 1));
end;


{ функция 2 }
function Func2 (x: double): double;
begin
    Func2 := 2.5 * x - 9.5;
end;

{ первая производная функции 2 }
function Func2prime1 (x: double): double;
begin
    Func2prime1 := 2.5;
end;

{ вторая производная функции 2 }
function Func2prime2 (x: double): double;
begin
    Func2prime2 := 0;
end;


{ функция 3 }
function Func3 (x: double): double;
begin
    Func3 := 5 / x;
end;

{ первая производная функции 3 }
function Func3prime1 (x: double): double;
begin
    Func3prime1 := -5 / (x * x);
end;

{ вторая производная функции 3 }
function Func3prime2 (x: double): double;
begin
    Func3prime2 := 10 / (x * x * x);
end;

{ функция, которая находит абсциссу точки пересечения функций;
функция1, первая производная функции1, вторая производная функции1,
функция2, первая производная функции2, вторая производная функции2,
начало, конец, точность
h(x) = f(x) - g(x) }
function Root(f, f1, f2: function_t; g, g1, g2: function_t; a, b: double; eps1: double): double;
var x, x0: double;
begin
    if (f(a) - g(a)) * (f2(a) - g2(a)) > 0 then
    begin
        x0 := a;
    end
    else if (f(b) - g(b)) * (f2(b) - g2(b)) > 0 then
    begin
        x0 := b;
    end
    else writeln('Неверный интервал');

    x := x0 - (f(x0) - g(x0)) / (f1(x0) - g1(x0));

    while abs(x - x0) >= eps1 do
    begin
        x0 := x - (f(x) - g(x)) / (f1(x) - g1(x));
        x := x0 - (f(x0) - g(x0)) / (f1(x0) - g1(x0));
        writeln(x, ' сходимость корня');
    end;

    Root := x;
end;

function Integral(f: function_t; a, b: double; eps2: double): double;
{ число разбиений - n }
var n: integer = 4;
    i: integer;
    h, firstIntegral, secondIntegral, s, aCopy: double;
begin

repeat
    n := n + 1;

    h := (b - a) / n;
    firstIntegral := 0;
    aCopy := a;

    for i := 1 to n do
    begin
        s := (f(aCopy) + f(aCopy + h)) / 2 * h;
        firstIntegral := firstIntegral + s;
        aCopy := aCopy + h;
    end;

    h := (b - a) / (2 * n);
    secondIntegral := 0;
    aCopy := a;

    for i := 1 to (2 * n) do
    begin
        s := (f(aCopy) + f(aCopy + h)) / 2 * h;
        secondIntegral := secondIntegral + s;
        aCopy := aCopy + h;
    end;

    writeln(firstIntegral, ' ', secondIntegral, ' первый интеграл и второй интеграл');

until (1 / 3 * abs(firstIntegral - secondIntegral) <= eps2);

    Integral := secondIntegral;
end;

procedure Graph(f1, f2, f3: function_t; x1, x2, x3: double);
    var
        GD, { graph driver }
        GM, { graph mode }
        n, { количество засечек }
        x0, y0, { начальные координаты }
        x_coord, y_coord, { координаты на графике }
        xLeft, xRight, yDown, yUp, { значения на осях }
        borderLeft, borderRight, borderDown, borderUp, { граница }
        i,
        runner: integer;
        scaleX, scaleY, { масштаб }
        x, dx, x_num,
        y, dy, y_num: real;
        word, point1, point2, point3: string;
    begin
        GD := VGA;
        GM := VGAHi;

        InitGraph(GD, GM, '');
        SetColor(12109509);

        { сколько отступаем слева и справа, расположение графика }
        borderLeft := 50; borderRight := GetMaxX - 50;
        borderDown := 50; borderUp := GetMaxY - 50;
        xLeft := 0; xRight := 6; dx := 0.5;
        yDown := -1; yUp := 5; dy := 0.5;

        { сопоставление координат }
        scaleX := (borderRight - borderLeft) / (xRight - xLeft); { масшnаб по X }
        scaleY := (borderUp - borderDown) / (yUp - yDown); { масштаб по Y }
        x0 := borderRight - trunc(xRight*scaleX); { точка (0, 0) в нашей СК }
        y0 := borderDown + trunc(yUp*scaleY);

        { изображение осей }
        Line(borderLeft, y0, borderRight, y0); { ось X }
        Line(x0, borderDown, x0, borderUp); { ось Y }


        { подписываем оси }
        SetColor(6139362);
        SetTextStyle(1, 0, 1);
        OutTextXY(GetMaxX - 30, y0, 'OX');
        OutTextXY(x0, 30, 'OY');

        { засечки на OX }
        SetColor(16044095);
        OutTextXY(x0 - 10, y0 + 10, '0');
        n := round((xRight - xLeft) / dx) + 1;

        for i := 1 to n do
        begin
            { координата на бумаге }
            x_num := xLeft + (i - 1)*dx;

            { координата в окне }
            x_coord := borderLeft + trunc((x_num - xLeft) * scaleX);

            { оставляем штрих }
            Line(x_coord, y0 - 3, x_coord, y0 + 3);

            { оставляем число, если не нуль }
            str(x_num:0:1, word);
            if (abs(x_num) > 1E-10) then
                OutTextXY(x_coord - TextWidth(word) div 2, y0 + 10, word)
        end;

        { рисуем засечки на OY }
        n := round((yUp - yDown)/dy) + 1;
        for i := 1 to n do
        begin
            y_num := yDown + (i - 1)*dy;

            { координата в окне }
            y_coord := borderUp - trunc((y_num - yDown)*scaleY);

            { оставляем штрих }
            Line(x0-3, y_coord, x0+3, y_coord);

            { оставляем число, если не нуль }
            str(y_num:0:1, word);
            if (abs(y_num) > 1E-10) then
                OutTextXY(x0+10, y_coord - TextHeight(word) div 2, word)
        end;

        { график F1 }
        SetColor(9062);
        OutTextXY(x0+50, y0-trunc(Func1(0) * scaleY)-90, 'y = 3 * (0.5 / (x + 1) + 1)');
        x := xLeft;

        while (x <= xRight) do
        begin
            { вычисляем значение функции }
            y := Func1(x);

            { координаты в окне }
            x_coord := x0 + round(x * scaleX);
            y_coord := y0 - round(y * scaleY);

            if (y_coord >= borderDown) and (y_coord <= borderUp) then
            begin
                PutPixel(x_coord, y_coord, 9062);
                PutPixel(x_coord - 1, y_coord - 1, 9062)
            end;

            x := x + 0.00001
        end;

        { график F2 }
        SetColor(15000);
        OutTextXY(x0 - trunc(scaleX) - 50, y0 - trunc(Func2(-1) * scaleY) + 20, 'y = 2.5 * x - 9.5');
        x := -1;

        while (x <= xRight) do
        begin
            { вычисляем значение функции }
            y := Func2(x);
            { координаты в окне }
            x_coord := x0 + round(x*scaleX);
            y_coord := y0 - round(y*scaleY);

            if (y_coord >= borderDown) and (y_coord <= borderUp) then
            begin
                PutPixel(x_coord, y_coord, 15000);
                PutPixel(x_coord-1, y_coord-1, 15000)
            end;
            x := x + 0.00001
        end;

        { график F3 }
        SetColor(896269);
        OutTextXY(x0 - trunc(scaleX) - 90, y0 - trunc(Func3(-1) * scaleY) - 30, 'y = exp(-x)');
        x := xLeft;
        while (x <= xRight) do
        begin
            { вычисляем значение функции }
            y := Func3(x);
            { координаты в окне }
            x_coord := x0 + round(x * scaleX);
            y_coord := y0 - round(y * scaleY);

            if (y_coord >= borderDown) and (y_coord <= borderUp) then
            begin
                PutPixel(x_coord, y_coord, 896269);
                PutPixel(x_coord - 1, y_coord - 1, 896269)
            end;
            x := x + 0.00001
        end;

        { отмечаем точки пересечения }
        SetColor(13611962);
        Str(x1:0:4, point1);
        Str(x2:0:4, point2);
        Str(x3:0:4, point3);
        point1 := 'x1 =' + point1;
        point2 := 'x2 =' + point2;
        point3 := 'x3 =' + point3;
        OutTextXY(x0 + trunc(x1*scaleX) - 70, y0 + 40, point1);
        OutTextXY(x0 + trunc(x2*scaleX), y0 + 40, point2);
        OutTextXY(x0 + trunc(x3*scaleX) - 30, y0 + 55, point3);

        { опускаем перпендикуляры }
        line(x0 + round(x1 * scaleX), y0 - round(Func1(x1) * scaleY), x0 + round(x1 * scaleX), y0);
        line(x0 + round(x2 * scaleX), y0 - round(Func3(x2) * scaleY), x0 + round(x2 * scaleX), y0);
        line(x0 + round(x3 * scaleX), y0 - round(Func1(x3) * scaleY), x0 + round(x3 * scaleX), y0);

        SetColor(1234565);
        x := x1;
        while (x <= x3) do
        begin
            if (y0 - round(func2(x) * scaleY)) < (y0 - round(func3(x) * scaleY)) then
                line(x0 + round(x * scaleX), y0 - round(func1(x) * scaleY),
                     x0 + round(x * scaleX), y0 - round(func2(x) * scaleY))
            else
                line(x0 + round(x * scaleX), y0 - round(func1(x) * scaleY),
                     x0 + round(x * scaleX), y0 - round(func3(x) * scaleY));
            x += 0.00001;
        end;
        Readln;
    end;

{СДЕЛАТЬ, ЧТОБ ЭПСИЛОНЫ ВВОДИЛИСЬ С КЛАВИАТУРЫ}
{коориднаты абсцисс точек пересечения}
var x1, x2, x3: double;
    code: integer;
{вычисленные значения интегралов соответсвующих функций}
    i1, i2, i3, i: double;
    eps1, eps2: double;

begin
    if ParamCount <> 2 then
    begin
        writeln('Неверное число аргументов во входной строке!');
        Halt(1);
    end;

    val(ParamStr(1), eps1, code);
    val(ParamStr(2), eps2, code);

    if (eps1 < 0) or (eps1 > 1) or (eps2 < 0) or (eps2 > 1) then
    begin
        writeln('Некорректный epsilon');
        Halt(1);
    end;

    x1 := Root(@Func1, @Func1prime1, @Func1prime2, @Func3, @Func3prime1, @Func3prime2, 1, 2, eps1);
    x2 := Root(@Func2, @Func2prime1, @Func2prime2, @Func3, @Func3prime1, @Func3prime2, 4, 5, eps1);
    x3 := Root(@Func1, @Func1prime1, @Func1prime2, @Func2, @Func2prime1, @Func2prime2, 5, 5.5, eps1);

   writeln(x1:0:10, ' - первый корень');
   writeln(x2:0:10, ' - второй корень');
   writeln(x3:0:10, ' - третий корень');

//    writeln(Integral(@Func1, x1, x3, 0.001));
//    writeln(Integral(@Func2, x2, x3, 0.001));
//    writeln(Integral(@Func3, x1, x2, 0.001));

   i1 := Integral(@Func1, x1, x3, eps2);
   i2 := Integral(@Func2, x2, x3, eps2);
   i3 := Integral(@Func3, x1, x2, eps2);

   {площадь криволинейного треугольника}
   i := i1 - i2 - i3;

   writeln(i:0:10, ' - площадь криволинейного треугольника');
   Graph(@Func1, @Func2, @Func3, x1, x2, x3);
end.