#include <stdio.h>
#include <locale.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <math.h>

#define COLUMN_NUMBER 4 // число столбцов таблицы
struct I_print {        // данные для печати результатов интегрирования
    char *name;         // название функции
    double i_sum;       // значение интегральной суммы
    double i_toch;      // точное значение интеграла
    int n;              // число разбиений области интегрирования  при котором достигнута требуемая точность
};

void printDividingLine(const char horizontalSybmol, const char connectorSybmol, const int m, const int *wn) {
    putchar(connectorSybmol);
    for (int line_i = 0; line_i < m; line_i++) {
        for (int line_j = 0; line_j < wn[line_i]; line_j++) {
            putchar(horizontalSybmol);
        }
        putchar(connectorSybmol);
    }
    putchar('\n');
}

void PrintTabl(struct I_print i_prn[], int k) {
    const char SIDE_SYBMOL = '|';
    const char HORIZONTAL_SYBMOL = '-';
    const char CONNECTOR_SYBMOL = '+';

    int wn[COLUMN_NUMBER] = {12, 18, 18, 10};   // ширина столбцов таблицы
    char *title[COLUMN_NUMBER] = {(char *) "Function", (char *) "Integral", (char *) "IntSum", (char *) "N "};
    int size[COLUMN_NUMBER];
    for (int i = 0; i < COLUMN_NUMBER; i++) {
        size[i] = (int) strlen(title[i]);
    }

    // шапка таблицы
    printDividingLine(HORIZONTAL_SYBMOL, CONNECTOR_SYBMOL, COLUMN_NUMBER, wn);

    putchar(SIDE_SYBMOL);
    for (int line_i = 0; line_i < COLUMN_NUMBER; line_i++) {
        int half = (wn[line_i] - size[line_i]) / 2;
        for (int line_j = 0; line_j < half; line_j++) {
            putchar(' ');
        }
        printf("%s", title[line_i]);
        for (int line_j = 0; line_j < half; line_j++) {
            putchar(' ');
        }
        putchar(SIDE_SYBMOL);
    }
    putchar('\n');

    printDividingLine(HORIZONTAL_SYBMOL, CONNECTOR_SYBMOL, COLUMN_NUMBER, wn);

    // заполнение таблицы
    for (int i = 0; i < k; i++) {
        putchar(SIDE_SYBMOL);
        printf("%12s", i_prn[i].name);
        putchar(SIDE_SYBMOL);

        char i_toch[15];
        sprintf(i_toch, "%.10f", i_prn[i].i_toch);
        printf("%18s", i_toch);
        putchar(SIDE_SYBMOL);

        char i_sum[15];
        sprintf(i_sum, "%.10f", i_prn[i].i_sum);
        printf("%18s", i_sum);
        putchar(SIDE_SYBMOL);

        printf("%10d", i_prn[i].n);
        putchar(SIDE_SYBMOL);
        putchar('\n');
        printDividingLine(HORIZONTAL_SYBMOL, CONNECTOR_SYBMOL, COLUMN_NUMBER, wn);
    }
}

//ранндом
double irandom(int low, int up) {
    int num = (rand() % (up - low + 1)) + low;
    return num;
}

//функции
double f1(double x) {
    return x;
}

double f2(double x) {
    return sin(22 * x);
}

double f3(double x) {
    return pow(x, 4);
}

double f4(double x) {
    return atan(x);
}

//указатель на функцию
typedef double (*TPF)(double);

//метод прямоугольников
double IntRect(TPF f, double a, double b, double eps, int *n) {
    double res1 = 0.0;
    double res = 0.0;
    double delta;
    do {
        double h = ((b - a) / *n);
        double h1 = ((b - a) / (*n * 2));
        for (int i = 0; i < *n; i++) {
            res += f(a + h / 2 + i * h);
        }
        res *= h;
        for (int i = 0; i < *n; i++) {
            res1 += f(a + h1 / 2 + i * h1);
        }
        res1 *= h1;
        delta = (fabs(res1 - res)) / 3;
        *n *= 2;
    } while (delta > eps && *n < 100000);
    return res;
}

//метод трапеций
double InTrap(TPF f, double a, double b, double eps, int *n) {
    double res = f(a) + f(b);
    double res1 = f(a) + f(b);
    double delta;
    do {
        double h = ((b - a) / *n);
        double h1 = ((b - a) / (*n * 2));
        for (int i = 0; i < *n; i++) {
            res += 2 * f(a + i * h);
        }
        res *= h / 2;
        for (int i = 0; i < *n; i++) {
            res1 += 2 * f(a + i * h1);
        }
        res1 *= h1 / 2;
        delta = (fabs(res1 - res)) / 3;
        *n *= 2;
    } while (delta > eps && *n < 100000);
    return res;
}

double a1, b1;

int main() {
    int n = 1;
    setlocale(LC_ALL, "Russian");
    srand(time(0));
    rand();
    a1 = irandom(0, 1);
    b1 = irandom(2, 3);
    //массив указателей функций
    TPF arrfunc[4] = {f1, f2, f3, f4};
    //массив названий функций
    char *arrfuncname[4] = {"y=x", "y=sin(22x)", "y=x^4", "y=arctan(x)"};
    //массив погрешностей
    double arreps[5] = {0.01, 0.001, 0.0001, 0.00001, 0.000001};
    double x = (pow(b1, 2) - pow(a1, 2)) / 2.0;
    double x1 = (cos(a1 * 22.0) - cos(b1 * 22.0)) / 22.0;
    double x2 = (pow(b1, 5) - pow(a1, 5)) / 5.0;
    double x3 = b1 * atan(b1) - a1 * atan(a1) - (log(b1 * b1 + 1) - log(a1 * a1 + 1)) / 2.0;
    //массив функций для сравнения
    double arrfunc1[4] = {x, x1, x2, x3};

//вывод метода прямоугольников
    struct I_print saverect[4];
    for (int i = 0; i < 5; i++) {
        printf("Значение a: %.lf\nЗначение b: %.lf\nМетод прямоугольников. eps = %lf.\n", a1, b1, arreps[i]);
        for (int j = 0; j < 4; j++) {
            saverect[j].name = arrfuncname[j];
            saverect[j].i_toch = arrfunc1[j];
            saverect[j].i_sum = IntRect(arrfunc[j], a1, b1, arreps[i], &n);
            saverect[j].n = n;
            n = 1;

        }
        PrintTabl(saverect, 4);
    }
    //вывод метода трапеций
    struct I_print savetrap[4];
    for (int i = 0; i < 5; i++) {
        printf("Значение a: %.lf\nЗначение b: %.lf\nМетод трапеций. eps = %lf.\n", a1, b1, arreps[i]);
        for (int j = 0; j < 4; j++) {
            savetrap[j].name = arrfuncname[j];
            savetrap[j].i_toch = arrfunc1[j];
            savetrap[j].i_sum = InTrap(arrfunc[j], a1, b1, arreps[i], &n);
            savetrap[j].n = n;
            n = 1;

        }
        PrintTabl(savetrap, 4);
    }


    return 0;
}