laba.2.3.Gay_ss(Delphi)

Program Laba_2_3;

{$APPTYPE CONSOLE}

Uses
  System.SysUtils;
Const
  MIN_SIZE = 2;
  MAX_SIZE = 10;
  MIN_VALUE = -1000;
  MAX_VALUE = 1000;
Type
  TMatrix = Array Of Array Of Double;
  TArr = Array Of Double;
  TSet = Set Of Char;

Procedure OutputTaskInfo();
Begin
  Writeln('Данная программа выполняет «прямой ход» в решении СЛАУ методом Гаусса.');
  Writeln('Диапазон ввода значений количества уравнений в системе: ', MIN_SIZE, '...', MAX_SIZE, '.');
  Writeln('Диапазон ввода значений коэффициентов при переменных: ', MIN_VALUE, '...', MAX_VALUE, '.');
End;

Function InputPathToFile(): String;
Var
  Path: String;
  IsCorrect: Boolean;
Begin
  Write('Укажите путь к файлу: ');

  Repeat
    IsCorrect := True;
    Readln(Path);

    If Not FileExists(Path) Then
    Begin
      Write('По указанному пути файл не найден! Укажите правильный путь: ');
      IsCorrect := False;
    End
    Else If ExtractFileExt(Path) <> '.txt' Then
    Begin
      Write('Ошибка, неправильный тип файла! Укажите правильный путь: ');
      IsCorrect := False;
    End;
  Until IsCorrect;

  InputPathToFile := Path;
End;

Function GetVerificationOfChoice(): Integer;
Var
  Choice: Integer;
  IsCorrect: Boolean;
Begin
  Repeat
    IsCorrect := True;
    Try
      Readln(Choice);
    Except
      Writeln('Проверьте корректность ввода данных!');
      IsCorrect := False;
    End;

    If IsCorrect And ((Choice <> 0) And (Choice <> 1)) Then
    Begin
      Writeln('Для выбора введите 0 или 1!');
      IsCorrect := False;
    End;

  Until IsCorrect;

  GetVerificationOfChoice := Choice;
End;

Function InputSizeFromConsole(): Integer;
Var
  Size: Integer;
  IsCorrect: Boolean;
Begin
  Write('Введите значение количества уравнений системы: ');

  Repeat
    IsCorrect := True;
    Try
      Readln(Size);
    Except
      Writeln('Проверьте корректность ввода данных!');
      IsCorrect := False;
    End;

    If (IsCorrect And ((Size < MIN_SIZE) Or (Size > MAX_SIZE))) Then
    Begin
      Writeln('Введите значение от ', MIN_SIZE, ' до ', MAX_SIZE, '!');
      IsCorrect := False;
    End;

  Until IsCorrect;

  InputSizeFromConsole := Size;
End;

Function InputSizeFromFile(Const Path: String): Integer;
Var
  Size: Integer;
  IsCorrect: Boolean;
  InputFile: TextFile;
Begin
  AssignFile (InputFile, Path);
  Reset(InputFile);

  IsCorrect := True;

  Writeln('Происходит чтение количества уравнений системы...');

  Try
    Readln(InputFile, Size);
  Except
    IsCorrect := False;
    Writeln('Ошибка при чтении данных! Введите количество уравнений с консоли!');
    Size := InputSizeFromConsole();
  End;

  If (IsCorrect And(((Size < MIN_SIZE) Or (Size > MAX_SIZE)))) Then
  Begin
    Writeln('В файле введено некорректное количество уравнений! Введите размер с консоли!');
    Size := InputSizeFromConsole();
  End;

  InputSizeFromFile := Size;
  CloseFile (InputFile);
End;

Procedure OutputSize(Const Choice, Size: Integer; Path: String);
Var
  OutputFile: TextFile;
  IsCorrect: Boolean;
Begin
  If Choice = 0 Then
    Writeln('Количество уравнений в системе равно: ', Size);

  If Choice = 1 Then
  Begin
    Writeln('Вывод количества уравнений в файл...');

    Repeat
      IsCorrect := True;
      AssignFile(OutputFile, Path);

      Try
        Rewrite(OutputFile);
      Except
        Writeln('Ошибка! Измените параметры файла или укажите новую ссылку!');
        IsCorrect := False;
        Path := InputPathToFile();
      End;

    Until IsCorrect;

    Write(OutputFile, Size);
    Write(OutputFile, #13);

    Close(OutputFile);
    Writeln('Данные успешно записаны в файл!');
  End;
End;

Function FillMatrixFromConsole(Const Size: Integer): TMatrix;
Var
  Matrix: TMatrix;
  IsCorrect: Boolean;
  I, J, Columns: Integer;
Begin
  SetLength(Matrix, Size, Size + 1);

  For I := Low(Matrix) To High(Matrix) Do
    For J := Low(Matrix[0]) To High(Matrix[0]) Do
    Begin
      Write('Введите значение коэфф-та в ', I + 1, '-ом уравнении при ', J + 1, '-ой позиции: ');

      Repeat
        IsCorrect := True;

        Try
          Read(Matrix[I, J]);
        Except
          Writeln('Проверьте корректность ввода данных!');
          IsCorrect := False;
        End;

        If (IsCorrect And ((Matrix[I, J] < MIN_VALUE) Or (Matrix[I, J] > MAX_VALUE))) Then
          Begin
            Writeln('Введите число от ', MIN_VALUE, ' до ', MAX_VALUE, '!');
            IsCorrect := False;
          End;

      Until IsCorrect;
    End;

  FillMatrixFromConsole := Matrix;
End;

Function FillMatrixFromFile(Const Size: Integer; Const Path: String): TMatrix;
Var
  Matrix: TMatrix;
  IsCorrect: Boolean;
  InputFile: TextFile;
  I, J, Count, Columns: Integer;
  Symbol: AnsiChar;
Begin
  AssignFile(InputFile, Path);
  Reset(InputFile);
  Readln(InputFile);

  SetLength(Matrix, Size, Size + 1);
  Count := 0;

  Writeln('Происходит чтение системы уравнений...');

  While Not Eof(InputFile) Do
  Begin
    Read(InputFile, Symbol);

    If Symbol = ' ' Then
      Inc(Count);
  End;

  Close(InputFile);

  If Count > Size * (Size + 1) Then
  Begin
    Writeln('Ошибка при чтении системы! Введите систему с консоли!');
    Matrix := FillMatrixFromConsole(Size);
  End
  Else
  Begin
    AssignFile(InputFile, Path);
    Reset(InputFile);
    Readln(InputFile);

    For I := Low(Matrix) To High(Matrix) Do
    Begin
      For J := Low(Matrix[0]) To High(Matrix[0]) Do
      Begin
        Repeat
          IsCorrect := True;

          Try
            Read(InputFile, Matrix[I, J]);
          Except
            Writeln('Ошибка при чтении системы! Введите систему с консоли!');
            IsCorrect := False;
            Matrix := FillMatrixFromConsole(Size);
          End;

          If (IsCorrect And ((Matrix[I, J] < MIN_VALUE) Or (Matrix[I, J] > MAX_VALUE))) Then
          Begin
            Writeln('Ошибка при чтении системы! Введите систему с консоли!');
            IsCorrect := False;
            Matrix := FillMatrixFromConsole(Size);
          End;
        Until IsCorrect;
      End;
    End;

    Close(InputFile);
  End;

  FillMatrixFromFile := Matrix;
End;

Procedure OutputMatrix(Const Choice: Integer; Const Matrix: TMatrix; Path: String);
Var
  OutputFile: TextFile;
  IsCorrect: Boolean;
  I, J: Integer;
Begin
  If Choice = 0 Then
  Begin
    Writeln('Вывод начальной системы уравнений: ');

    For I := Low(Matrix) To High(Matrix) Do
    Begin
      Write('|');
      For J := Low(Matrix) To High(Matrix) Do
        Write(' ', Matrix[I, J]:5:0, ' ');
      Write('| ', Matrix[I, High(Matrix) + 1]:5:0, ';');
      Writeln('');
    End;
  End;

  If Choice = 1 Then
  Begin
    Writeln('Вывод начальной системы уравнений в файл...');

    Repeat
      IsCorrect := True;
      AssignFile(OutputFile, Path);

      Try
        Append(OutputFile);
      Except
        Writeln('Ошибка! Измените параметры файла или укажите новую ссылку!');
        IsCorrect := False;
        Path := InputPathToFile();
      End;

    Until IsCorrect;

    For I := Low(Matrix) To High(Matrix) Do
    Begin
      Write(OutputFile, '|');
      For J := Low(Matrix) To High(Matrix) Do
        Write(OutputFile, ' ', Matrix[I, J]:5:0, ' ');
      Write(OutputFile, '| ', Matrix[I, High(Matrix) + 1]:5:0, ';');
      Writeln(OutputFile, '');
    End;
    Write(OutputFile, #13);

    Close(OutputFile);
    Writeln('Данные успешно записаны в файл!');
  End;
End;

Function CreateTriangleMatrix(const Matrix: TMatrix): TMatrix;
Var
  I, J, K, StartPosJ, FinalPosJ: Integer;
  Temp: Real;
  TriangleMatrix: TMatrix;
Begin
  SetLength(TriangleMatrix, Length(Matrix), Length(Matrix[0]));

  For I := Low(Matrix) To High(Matrix) Do
    For J := Low(Matrix[0]) To High(Matrix[0]) Do
      TriangleMatrix[I, J] := Matrix[I, J];

  For I := 0 To High(TriangleMatrix) Do
     Begin
       StartPosJ := I + 1;

       For J := StartPosJ To High(TriangleMatrix) Do
          Begin
            Temp := TriangleMatrix[J ,I] / TriangleMatrix[I, I];

            For K := I To High(TriangleMatrix) Do
              TriangleMatrix[J, K] := TriangleMatrix[J, K] - Temp * TriangleMatrix[I, K];

              TriangleMatrix[J, High(TriangleMatrix[0])] := TriangleMatrix[J, High(TriangleMatrix[0])] - Temp * TriangleMatrix[I, High(TriangleMatrix[0])];
          end;
     end;

     CreateTriangleMatrix := TriangleMatrix;
End;

Procedure OutputTriangleMatrix(Const Choice: Integer; Const Matrix: TMatrix; Path: String);
Var
  OutputFile: TextFile;
  IsCorrect: Boolean;
  I, J: Integer;
Begin
  If Choice = 0 Then
  Begin
    Writeln('Вывод преобразованной системы: ');

    For I := Low(Matrix) To High(Matrix) Do
    Begin
      Write('|');
      For J := Low(Matrix) To High(Matrix) Do
        Write(' ', Matrix[I, J]:5:2, ' ');
      Write('| ', Matrix[I, High(Matrix) + 1]:5:2, ';');
      Writeln('');
    End;
  End;

  If Choice = 1 Then
  Begin
    Writeln('Вывод преобразованной системы в файл...');

    Repeat
      IsCorrect := True;
      AssignFile(OutputFile, Path);

      Try
        Append(OutputFile);
      Except
        Writeln('Ошибка! Измените параметры файла или укажите новую ссылку!');
        IsCorrect := False;
        Path := InputPathToFile();
      End;

    Until IsCorrect;

    For I := Low(Matrix) To High(Matrix) Do
    Begin
      Write(OutputFile, '|');
      For J := Low(Matrix) To High(Matrix) Do
        Write(OutputFile, ' ', Matrix[I, J]:5:2, ' ');
      Write(OutputFile, '| ', Matrix[I, High(Matrix) + 1]:5:2, ';');
      Writeln(OutputFile, '');
    End;
    Write(OutputFile, #13);

    Close(OutputFile);
    Writeln('Данные успешно записаны в файл!');
  End;
End;

Procedure InitializeArrWithZeros(Var Arr: TArr);
Var
  I: Integer;
Begin
  For I := 0 To High(Arr) Do
    Arr[I] := 0;
End;

Function FindRoots(Const TriangleMatrix: TMatrix): TArr;
Var
  I, J, K, Pos, FinalPosJ: Integer;
  AnsArr: TArr;
  Temp, Dividend: Real;
Begin
  SetLength(AnsArr, Length(TriangleMatrix));
  InitializeArrWithZeros(AnsArr);
  Pos := High(TriangleMatrix);
  K := 1;
  Dividend := 0;

  For I := 0 To High(AnsArr) Do
  Begin
    If (TriangleMatrix[Pos, Pos] <> 0) Then
    Begin
      Dividend := TriangleMatrix[Pos, Pos + K];
      FinalPosJ := I - 1;

      For J := 0 To FinalPosJ Do
        Dividend :=  Dividend - TriangleMatrix[Pos, Pos + I - J] * AnsArr[J];

      Temp := Dividend / TriangleMatrix[Pos, Pos];
    End
    Else
      Temp := 0;

    AnsArr[I] := Temp;
    Dec(Pos);
    Inc(K);
  End;

  FindRoots := AnsArr;
End;

Procedure OutputAnsArr (Const Choice: Integer; Const AnsArr: TArr; Path: String);
Var
  OutputFile: TextFile;
  IsCorrect: Boolean;
  I: Integer;
Begin
  If Choice = 0 Then
  Begin
    Writeln('Вывод полученных корней: ');

    For I := Low(AnsArr) To High(AnsArr) Do
    Begin
      Writeln('Значение ', I + 1, '-ой переменной равно: ', AnsArr[I]:5:2, '.');
    End;
  End;

  If Choice = 1 Then
  Begin
    Writeln('Вывод полученных корней в файл...');

    Repeat
      IsCorrect := True;
      AssignFile(OutputFile, Path);

      Try
        Append(OutputFile);
      Except
        Writeln('Ошибка! Измените параметры файла или укажите новую ссылку!');
        IsCorrect := False;
        Path := InputPathToFile();
      End;

    Until IsCorrect;

    For I := Low(AnsArr) To High(AnsArr) Do
    Begin
      Writeln(OutputFile, 'Значение ', I + 1, '-ой переменной равно: ', AnsArr[I]:5:2, '.');
    End;
    Write(OutputFile, #13);

    Close(OutputFile);
    Writeln('Данные успешно записаны в файл!');
  End;
End;

Function ProcessUserInput(Var SSet: TSet): TMatrix;
Var
  PathToIn: String;
  ChoiceForInput, Size: Integer;
  Matrix: TMatrix;
Begin
  Writeln('Вы желаете вводить данные с консоли(0) или из файла(1)?');
  ChoiceForInput := GetVerificationOfChoice();

  If ChoiceForInput = 0 Then
  Begin
      Size := InputSizeFromConsole();
      Matrix := FillMatrixFromConsole(Size);
  End;

  If ChoiceForInput = 1 Then
  Begin
    PathToIn := InputPathToFile();
    Size := InputSizeFromFile(PathToIn);
    Matrix := FillMatrixFromFile(Size, PathToIn);
  End;

  ProcessUserInput := Matrix;
End;

Procedure ProcessUserOutput(Const Size: Integer; Const Matrix, TriangleMatrix: TMatrix; Const AnsArr: TArr);
Var
  PathToOut: String;
  ChoiceForOutput: Integer;
Begin
  Writeln('Вы желаете получить данные в консоль(0) или в файл(1)?');
  ChoiceForOutput := GetVerificationOfChoice();
  If ChoiceForOutput = 1 Then
    PathToOut := InputPathToFile();

  OutputSize(ChoiceForOutput, Size, PathToOut);
  OutputMatrix(ChoiceForOutput, Matrix, PathToOut);
  OutputTriangleMatrix(ChoiceForOutput, TriangleMatrix, PathToOut);
  OutputAnsArr(ChoiceForOutput, AnsArr, PathToOut);
End;

Procedure Main();
Var
  Size: Integer;
  SSet: TSet;
  AnsArr: TArr;
  Matrix, TriangleMatrix: TMatrix;
Begin
  OutputTaskInfo();
  Matrix := ProcessUserInput(SSet);
  TriangleMatrix := CreateTriangleMatrix(Matrix);
  AnsArr := FindRoots(TriangleMatrix);
  ProcessUserOutput(Length(Matrix), Matrix, TriangleMatrix, AnsArr);
End;

Begin
  Main();
  Readln;
  Readln;
End.