using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace ConsoleApplication2
{

    class Program
    {

        static void Main(string[] args)
        {

            double l, step, nn;
            int n, i, j, num1, n1;
            double kc, kpr1; //kc - коэффициент пастели, kpr1 - жесткость пружины.
            double EI;
            int left, right;            //l = 20;
            step = 0.5;
            Console.Write("Введите размер балки (м) : ");
            l = int.Parse(Console.ReadLine());
            Console.Write("Коэффициент пастели балки: ");
            kc = int.Parse(Console.ReadLine());
            Console.Write("Закрепление левого конца балки (0 - шарнирное; 1 - жесткое) : ");
            left = int.Parse(Console.ReadLine());
            Console.Write("Закрепление правого конца балки (0 - шарнирное; 1 - жесткое) : ");
            right = int.Parse(Console.ReadLine());
            nn = l / step;
            n = (int)nn;
            double[] Q = new double[n + 1];
            for (i = 0; i < n + 1; i++)
            {
                Q[i] = 0;

            }
            double lp1, kk, P1;
            int k;
            double l1, l2, lpr1;
            double kkl1, kkl2, kklp1;
            int kl1, kl2, klp1;
            double lq11, lq12, kk1, kk2, Q1;
            int k1, k2;
            //lp1 = 5;
            Console.Write("Первая подпорка находится на (м) от начала балки : ");
            l1 = double.Parse(Console.ReadLine());
            Console.Write("Вторая подпорка находится на (м) от начала балки : ");
            l2 = double.Parse(Console.ReadLine());
            Console.Write("Введите значения точечной нагрузки P (кH) : ");
            P1 = double.Parse(Console.ReadLine());
            Console.Write("Введите где расположена точечная нагрузка (м) от начала балки: ");
            lp1 = double.Parse(Console.ReadLine());
            Console.Write("Введите значения распределенной нагрузки Q (кH) : ");
            Q1 = double.Parse(Console.ReadLine());
            Console.Write("Введите начальное положение распределенной нагрузки (м) от начала: ");
            lq11 = double.Parse(Console.ReadLine());
            Console.Write("Введите конечное положение распределенной нагрузки (м) от начала: ");
            lq12 = double.Parse(Console.ReadLine());
            Console.Write("Пружина, поддерживающая балку находится на (м) от начала: ");
            lpr1 = double.Parse(Console.ReadLine());
            Console.Write("Коэффициент жесткости пружины: ");
            kpr1 = double.Parse(Console.ReadLine());
            kk = lp1 / step;
            k = (int)kk;
            //P1 = 20;
            Q[k] = P1 * step * step * step / 1000;
            //lq11 = 15;
            //lq12 = 18;
            kk1 = lq11 / step;
            k1 = (int)kk1;
            kk2 = lq12 / step;
            k2 = (int)kk2;
            //Q1 = 15;
            for (i = k1; i <= k2; i++)
            {
                Q[i] = Q1 * step * step * step * step / 1000;
            }
            //Построение массива нагрузок: step - 1 - true. Build successful
            double[] N = new double[n + 1];
            for (i = 0; i < n + 1; i++)
            {
                N[i] = 0;
            }
            //l2 = 6;
            //lpr1 = 19;
            kkl1 = l1 / step;
            kl1 = (int)kkl1;
            kkl2 = l2 / step;
            kl2 = (int)kkl2;
            kklp1 = lpr1 / step;
            klp1 = (int)kklp1;
            N[kl1] = 999;
            N[kl2] = 999;
            N[klp1] = 999;
            //Построение массива для задания системы уравнений : step - 2 - true. Build successful


            EI = 15;
            //kc = 1;
            //kpr1 = 0.75;
            double[] CP = new double[n + 1];
            for (i = 0; i < n + 1; i++)
            {
                if (i == klp1)
                {
                    CP[i] = kpr1 / EI;
                }
                else CP[i] = kc / EI;
            }
            //Построение массива жесткости: step - 3 - true. Build successful

            double[] W = new double[n + 1];
            for (i = 0; i < n + 1; i++)
            {
                W[i] = 9999;

            }
            W[0] = 0;
            W[n] = 0;
            W[kl1] = 0;
            W[kl2] = 0;
            //Построение массива W: step - 4 - true. Build successful

            //СТРОИМ МАТРИЦУ КОЭФФИЦИЕНТОВ!!!!!!!!!

            double[,] DOPa = new double[n + 1, n + 2];
            for (i = 0; i < n + 1; i++)
            {
                for (j = 0; j < n + 2; j++)
                {
                    DOPa[i, j] = 0;

                }
            }
            num1 = n + 1;
            for (i = 0; i < n + 1; i++)
            {
                if (W[i] == 0)
                {
                    num1--;
                }


            }
            for (i = 2; i < n - 1; i++)
            {
                DOPa[i, i - 2] = 1;
                DOPa[i, i - 1] = -4;
                DOPa[i, i] = 6 + CP[i] * step * step * step * step;
                DOPa[i, i + 1] = -4;
                DOPa[i, i + 2] = 1;
                DOPa[i, n + 1] = Q[i];
            }


            DOPa[1, 0] = -4;
            DOPa[1, 1] = 6 + CP[1] * step * step * step * step;
            DOPa[1, 2] = -4;
            DOPa[1, 3] = 1;
            DOPa[1, n + 1] = Q[1];
            DOPa[n - 1, n - 3] = 1;
            DOPa[n - 1, n - 2] = -4;
            DOPa[n - 1, n - 1] = 6 + CP[n - 1] * step * step * step * step;
            DOPa[n - 1, n] = -4;
            DOPa[n - 1, n + 1] = Q[n - 1];
            //left = 1;
            //right = 0;
            if (left == 1)
            {
                DOPa[1, 1]++;
            }
            if (left == 0)
            {
                DOPa[1, 1]--;
            }
            if (right == 1)
            {
                DOPa[n - 1, n - 1]++;
            }
            if (right == 0)
            {
                DOPa[n - 1, n - 1]--;
            }
            //СОСТАВИЛИ МАССИВ для коэффициентов: step - 5 - true. Build successful
            //Убираем ненужные строки и столбцы

            double[,] DOPa1 = new double[num1, n + 2];
            k = 0;
            for (i = 0; i < n + 1; i++)
            {
                if (W[i] != 0)
                {
                    for (j = 0; j < n + 2; j++)
                    {
                        DOPa1[k, j] = DOPa[i, j];

                    }
                    k++;
                }
            }
            //Убрали ненужные строки

            double[,] a = new double[num1, num1 + 1];
            k = 0;
            for (j = 0; j < n + 1; j++)
            {
                if (W[j] != 0)
                {
                    for (i = 0; i < num1; i++)
                    {
                        a[i, k] = DOPa1[i, j];

                    }
                    k++;
                }
            }
            for (i = 0; i < num1; i++)
            {
                a[i, num1] = DOPa1[i, n + 1];
            }

            //метод гаусса
            n1 = n;
            n = num1;
            double b;

            for (i = 0; i < n; i++)
            {
                k = i;
                //Проверка на неравенство нулю ведущего элемента
                //Если он равен нулю, то меняем строки местами
                if (a[k, k] == 0)
                {
                    for (j = k; j < n + 1; j++)
                    {
                        b = a[k, j];
                        a[k, j] = a[k + 1, j];
                        a[k + 1, j] = b;
                    }
                }
                //Делаем единичный элемент
                b = a[k, k];
                for (j = 0; j < n + 1; j++)
                {
                    a[k, j] = a[k, j] / b;
                }


                for (i = k + 1; i < n; i++)
                {
                    double y = a[i, k];
                    for (j = 0; j < n + 1; j++)
                    {


                        double s = a[k, j] * y;
                        double m = a[i, j] - s;
                        a[i, j] = m;



                    }

                }

                i = k;

            }
            //Прямой ход закончен





            for (i = 0; i < n - 1; i++)
            {
                k = n - 1 - i;
                for (i = 0; i < k; i++)
                {
                    double y = a[i, k];
                    for (j = 0; j < n + 1; j++)
                    {
                        double s = a[k, j] * y;
                        double m = a[i, j] - s;
                        a[i, j] = m;
                    }

                }
                i = n - 1 - k;
            }

            //Обратный ход - закончен.

            double[] DOPW = new double[n];

            //Делаем вывод прогибов.

            for (i = 0; i < n; i++)
            {
                DOPW[i] = a[i, n];
            }
            //Построение итогого массива прогибов.
            k = 0;
            for (i = 0; i < n1 + 1; i++)
            {
                if (W[i] != 0)
                {
                    W[i] = DOPW[k];
                    k++;


                }
            }

            //Построение массива длин.
            double[] X = new double[n1 + 1];
            X[0] = 0;
            for (i = 1; i < n1 + 1; i++)
            {
                X[i] = X[i - 1] + step;

            }

            Console.WriteLine();
            Console.Clear();
            Console.Write("Вывод значений прогибов W при конкретных значениях X");
            Console.WriteLine();


            StreamWriter V = new StreamWriter(@"E:\W.txt");
            for (i = 0; i < n1 + 1; i++)
            {

                k = i + 1;
                Console.Write("W [ " + i + " ] = " + W[i] + "\t" + " при X = " + X[i] + "\t");
                Console.WriteLine();
                V.WriteLine(W[i]);

            }
            Console.ReadLine();
            /*
            for (i = 0; i < num1; i++)
            {
            for (j = 0; j < num1 + 1; j++)

            {

            Console.Write("a [ " + i +" , " + j + " ] = " + a[i , j] + "\t");
                    Console.WriteLine();

        }
            }
        Console.ReadLine();*/
        }
    }
}