#include <iostream>
#include <math.h>
#include <cmath>
#include <vector>
#include <Windows.h>
#include <stdlib.h>
#include <fstream>
#include <string.h>
#include <time.h>
#include <iomanip>
using namespace std;

/* Рандом даёт ток целое число, поэтому отказались от этого
    int flag = 0;
    double r,h;

    h = (Array[CountSegments + 1].x - Array[0].x) / CountSegments;
    if (CountSegments % 2 == 0)
        flag = 1;

    if (flag == 1) {
        for (int i = 1; i < CountSegments + 1; i=i+2) {
            r = (rand() % h + 1);
            Array[i].x = h + r;
            Array[i].y = (*f)(Array[i].x);
            Array[i + 1].x = h - r;
            Array[i + 1].y = (*f)(Array[i + 1].x);
        }
    }
    else {
        Array[1].x = Array[0].x+h;
        Array[1].y = (*f)(Array[1].x);
        for (int i = 2; i < CountSegments; i=i+2) {
            r = (rand() % 3 + 1);
            Array[i].x = h+r;
            Array[i].y = (*f)(Array[i].x);
            Array[i+1].x = h-r;
            Array[i+1].y = (*f)(Array[i+1].x);
        }

    }

*/

typedef double(*functiontype)(double x);
typedef struct Node
{
    double x, y;
} Node;
typedef double(*method)(double x, Node* Array, int Count, double* DD_massiv);
typedef struct Interval
{
    double InitialNode, EndNode;
} Interval;
const double PI = 3.141592653589793238463;

//Равномерная сетка
void ValueUniformTable(functiontype* f, Node* Array, double Initial, double End, int CountNodes)
{
    double step = abs(Initial - End) / (CountNodes - 1);
    Array[0].x = Initial; Array[0].y = (*f)(Array[0].x);
    for (int i = 1; i < CountNodes; i++)
    {
        Array[i].x = Array[i - 1].x + step;
    }
}

//Неравномерная сетка
void ValueIrregularTable(functiontype* f, Node* Array, double Initial, double End, int CountSegments) //Инитиал и Енд запихать в Array
{
    int i;
    double alpha,h;

    Array[0].x = Initial;
    Array[CountSegments+1].x = End;
    Array[0].y = (*f)(Array[0].x);
    Array[CountSegments+1].y = (*f)(Array[CountSegments+1].x);

    h = (Array[CountSegments + 1].x - Array[0].x) / CountSegments;
    alpha = 2 * PI / CountSegments;

    cout << Array[0].x << Array[0].y << endl;
    for (i = 1; i < CountSegments; i++) {
        Array[i].x = Array[i].x+h+cos(alpha*i);
        Array[i].y = (*f)(Array[0].x);
        cout << Array[i].x << Array[i].y << endl;
    }
    cout << Array[CountSegments + 1].x << Array[CountSegments + 1].y << endl;

}

double Myfunc(double x)
{
    return x * x;
}
functiontype Func = &Myfunc;

/* Принимает на вход коэффициенты матриц в виде массива. Заполняет массив прогоночных коэффициентов
 matrix_coeffs - двумерный массив вида [[a1,b1,c1,d1],[a2,b2,c2,d2],...,[an,bn,cn,dn]
надо сделать чтобы а1=с1=0, переделать под ашки
*/
void tridiagonal_matrix_algorithm(double** matrix_coeffs, int matrix_size) {
    int i;
    double denominator;
    double K, E, K_prev = 0, E_prev = 0; //Прогоночные коэффициенты
    double* x_massiv = new double[matrix_size];

    double** coeffs_massiv; //Двумерный массив, хранящий прогоночные коэффициенты, 0 - Кси, 1 - Эта
    coeffs_massiv = new double*[matrix_size+1];
    for (i = 0; i < matrix_size; i++)
        coeffs_massiv[i] = new double[2];

    coeffs_massiv[0][0] = 0; coeffs_massiv[0][1] = 0;
    matrix_coeffs[0][0] = 0; matrix_coeffs[matrix_size - 1][2] = 0; //а1=с1=0

    //Прямой ход
    for (i = 1; i <= matrix_size; i++) { //Ищем K_i+1 и E_i+1 на iом шаге
        denominator = (matrix_coeffs[i - 1][0] * K_prev + matrix_coeffs[i - 1][1]);
        K = -(matrix_coeffs[i - 1][2]) / denominator;
        E = (matrix_coeffs[i - 1][3] - matrix_coeffs[i - 1][0] * E_prev) / denominator;
        K_prev = K;
        E_prev = E;
        coeffs_massiv[i][0] = K; coeffs_massiv[i][1] = E;
    }

    //Обратный ход
    x_massiv[matrix_size - 1] = coeffs_massiv[matrix_size][1];
    for (i = matrix_size - 2; i >= 0; i--) {
        x_massiv[i] = coeffs_massiv[i + 1][0] * x_massiv[i + 1] + coeffs_massiv[i + 1][1];
    }

}

void get_matrix_coeffs(double Initial, double End, int matrix_size, functiontype* f, double** matrix_coeffs, Node* Array) {
    int i;
    double h1,h2,h_prev;
    //double* gamma_massiv = new double[matrix_size]; //Гаммы яв решением ур, т.е. ответом.

    matrix_coeffs = new double*[matrix_size];
    for (i = 0; i < matrix_size; i++)
        matrix_coeffs[i] = new double[3];


    for (i = 1; i <= matrix_size; i++) {
        h1 = Array[i].x - Array[i-1].x;  //i
        h2 = Array[i+1].x - Array[i].x; //i+1
        h_prev = h2;
        matrix_coeffs[i - 1][0] = h1;
        matrix_coeffs[i - 1][1] = 2*(h1+h2);
        matrix_coeffs[i - 1][1] = h2;
    }

}

int main()
{
    setlocale(LC_ALL, "RUS");
    functiontype Func = &Myfunc;
    double Initial = 0, End = 5;
    int CountSegments;
    cout << "Введите N: ";
    cin >> CountSegments;


    //Построение сетки
    Node* ArrayUniformNodes = new Node[CountSegments+1];
    //ValueUniformTable(&Func, ArrayUniformNodes, Initial, End, CountSegments);
    ValueIrregularTable(&Func, ArrayUniformNodes, Initial, End, CountSegments);

    /*//Заполнение массива коэффициентами матрицы
    double** matrix_coeffs;
    get_matrix_coeffs(Initial,End, CountSegments, &Func, matrix_coeffs, ArrayUniformNodes);

    //Получение ответа в x_massiv
    double* x_massiv = new double[CountSegments+1];
    tridiagonal_matrix_algorithm(matrix_coeffs, CountSegments+1);
    */

    cout << endl;
    system("pause");
    return 0;
}