ed.t

//CountAnyFunction - тип указателя на функцию, которая принимает 2 параметра
//типа double и сама возвращает значение типа double
#include <iostream>
#include <conio.h>
#include <windows.h>
#include <iomanip>

using namespace std;

void Swap(double*, double*);
double FindModule(double);
double Block();

void SelectMenu();
int Block_Switch();
int Block_Int();

double CountY(double, int);
double CountS(double, int);
double CountResidual(double, int);

typedef double(*CountAnyFunction) (double, int);
void OutRez(CountAnyFunction, double, double, double, int);

void OutRezAll(CountAnyFunction, CountAnyFunction, CountAnyFunction, double, double, double, int);



int main()
{
    system("color 08");
    setlocale(0, "rus");
    HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);

    double a = 0, b = 0, h = 0;
    int n = 0;



    cout << "\n\t---------------------------------------------------------------------------------------------" << endl << endl
         << "\tFor each {x}, varying from {a} to {b} in step {h}: " << endl
         << "\t1.Find function values  Y(x);" << endl
         << "\t2.Amounts S(x);" << endl
         << "\t3.|Y(x)–S(x)|;" << endl
         << "\tThe values {a, b, h, n} are entered from the keyboard" << endl << endl
         << "\t----------------------------------------------------------------------------------------------" << endl << endl;;

    do {

        cout << "\tEnter the lower limit {a}... ";
        a = Block();
        cout << endl;

        cout << "\tEnter the upper limit {b}... ";
        b = Block();
        cout << endl;

        if (a > b) {

            SetConsoleTextAttribute(console, FOREGROUND_RED);
            cout << "ERROR! You've entered a lowerlimit larger than the upper one, cause of that they'll swap places: ";
            SetConsoleTextAttribute(console, FOREGROUND_INTENSITY);

            Swap(&a, &b);

            cout << "a = " << setprecision(10) << a << ", " << "b = " << setprecision(10) << b << ". " << endl << endl;


        }

        else if (a == b) {
            SetConsoleTextAttribute(console, FOREGROUND_RED);
            cout << "!ERROR You have entered equal limits, the program cannot be executed. Try again... " << endl << endl;
            SetConsoleTextAttribute(console, FOREGROUND_INTENSITY);
            continue;
        }

        cout << "\tEnter step {h} to change variable {x} from limit {a} to {b}...";
        h = FindModule(Block());
        cout << endl;

        cout << "\tEnter the upper limit of the number {n}, and {n} is an integer...";

        n = FindModule(Block_Int());
        if (n == 0) {

            SetConsoleTextAttribute(console, FOREGROUND_RED);
            cout << "\n !ERROR {n} can't be equal to 0. Try again... " << endl << endl;
            SetConsoleTextAttribute(console, FOREGROUND_INTENSITY);
            continue;
        }
        cout << endl;

        break;

    } while (true);

    cout << "\n\t-----------------------------------------------------------------------------------------------" << endl << endl;


    SelectMenu();

    int choice = 0;


    cout << "\tYour choise:";
    choice = Block_Switch();

    switch (choice) {
    case 1:

        cout << setw(21) << " Y " << endl;
        OutRez(CountY, a, b, h, n);
        break;

    case 2:
        cout << setw(21) << " S " << endl;
        OutRez(CountS, a, b, h, n);
        break;

    case 3:
        cout << setw(24) << " |Y - S| " << endl;
        OutRez(CountResidual, a, b, h, n);
        break;

    case 4:
        cout << "\t_____________________________________________________________________" << endl
            << setw(10) << "|"
            << setw(10) << "Y"
            << setw(10) << "|"
            << setw(10) << "S"
            << setw(10) << "|"
            << setw(16) << "|Y - S|" << setw(10) << "|" << endl;

        OutRezAll(CountY, CountS, CountResidual, a, b, h, n);
        break;

    }



    cout << "\n\n\t ----------------------------------------------------------------------------------------------" << endl << endl;


    return 0;
}

void Swap(double* a, double* b) {

    double additional = 0;
    additional = *a;
    *a = *b;
    *b = additional;

}

double FindModule(double x) {

    if (x < 0)
        x = -x;

    return x;
}

double Block() {

    int c = 0;
    int arr[20];
    int size = 0;
    double sumFirst = 0;
    double sumSecond = 0;
    double sum = 0;

    int  fullStop = -1;
    bool forMinus = false;

    while (c != 13 || size == 0) {          //enter
        c = _getch();

        if ((c >= 48 && c <= 57) || (c == 46 && size != 0) || (c == 45)) {

            if (c == 46) {          //'.'
                if (fullStop != -1) {
                    continue;
                }
                fullStop = size;
                arr[size] = c - 48;
                size++;
                cout << '.';
            }

            else if (c == 45) {         //'-'
                if (forMinus == true || size != 0) {
                    continue;
                }
                forMinus = true;
                cout << '-';
            }

            else {
                cout << c - 48;
                arr[size] = c - 48;
                size++;
            }
        }
    }


    for (int i = 0; i < size; i++)
    {
        if (i < fullStop)
            sumFirst += arr[i] * pow(10, fullStop - i - 1);
        else if (i == fullStop)
            continue;
        else if (i > fullStop)
            sumSecond += arr[i] * pow(10, size - i - 1);


    }

    for (int i = 0; i < size; i++) {
        if (fullStop != -1)
            sum = sumFirst + sumSecond / (pow(10, size - fullStop - 1));
        else            //(fullStop = -1)
            sum = sumSecond;


    }

    if (forMinus == true)
        sum = -sum;

    cout << endl;

    return sum;

}

void SelectMenu() {

    cout << "\n\tTo display different expressions on the screen, type from the keyboard: " << endl << endl
         << "\t\t1.To derive a number Y(x) " << endl
         << "\t\t2.To derive a number S(x) " << endl
         << "\t\t3.To derive a number |Y(x) - S(x)| " << endl
         << "\t\t4.To get all the expressions out " << endl << endl;

}

int Block_Switch() {

    int c;

    while (true) {
        c = _getch();
        if (c >= '1' && c <= '4') {
            cout << c - 48 << endl;
            break;
        }
    }

    cout << endl;
    return c - 48;

}

int Block_Int() {

    int c = 0;
    int arr[20];
    int size = 0;
    int sum = 0;

    bool forMinus = false;

    while (c != 13 || size == 0) {          //enter
        c = _getch();

        if ((c >= 48 && c <= 57) || (c == 45)) {

            if (c == 45) {          //'-'
                if (forMinus == true || size != 0) {
                    continue;
                }
                forMinus = true;
                cout << '-';
            }
            else {
                cout << c - 48;
                arr[size] = c - 48;
                size++;
            }

        }
    }

    for (int i = 0; i < size; i++)
    {

        sum += arr[i] * pow(10, size - i - 1);

    }

    if (forMinus == true)
        sum = -sum;
    cout << "   ";
    return sum;

}

double CountY(double x, int n) {

    double Y = 0;
    Y = (1 + x * x) / 2.0 * atan(x) - x / 2.0;
    return Y;

}

double CountS(double x, int n) {

    double E = 1, p = 0, S = 1;

    for (int k = 1; k <= n; k++) {

        E = -E * (x * x) / (2.0 * k * (2.0 * k - 1));
        p = (2.0 * k * k + 1) * E;

        S += p;

    }

    return S;
}

double CountResidual(double x, int n) {

    double residual = CountY(x, n) - CountS(x, n);

    return FindModule(residual);

}

void OutRez(CountAnyFunction anyFunction, double a, double b, double h, int n) {

    for (double x = a; x <= b; x += h) {

        cout << setw(22) << setprecision(5) << fixed << anyFunction(x, n) << endl;

    }

}

void OutRezAll(CountAnyFunction anyFunctionY, CountAnyFunction anyFunctionS, CountAnyFunction anyFunctionYS, double a, double b, double h, int n) {

    for (double x = a; x <= b; x += h) {

        cout << setw(22) << setprecision(5) << CountY(x, n)
             << setw(20) << setprecision(5) << CountS(x, n)
             << setw(23) << setprecision(5) << fixed << CountResidual(x, n) << endl;


    }

}