laba2.4 (Delphi)

program laba2_4;
uses
    System.SysUtils;

type
    TwoDimensionalArray = Array of Array of Double;

function InputOrderFromConsole(): Integer; Forward;
function InputMatrixFromConsole(): Double; Forward;


function InputPath(): String;
var
    Path: String;
    IsCorrect: Boolean;
begin
    repeat
        IsCorrect := True;
        Readln(Path);

        if not FileExists(Path) then
        begin
            IsCorrect := False;
            Writeln('Файл не найден! Введите абсолютную ссылку на файл');
        end;
    until IsCorrect;
    InputPath := Path;
end;

function InputOrderFromFile(Path: String): Integer;
var
    Order: Integer;
    Flag: Boolean;
    InputFile: TextFile;
begin
    AssignFile(InputFile, Path);
    Reset(InputFile);
    Flag := True;

    Writeln('Порядок матрицы считывается из файла...');
    try
        Readln(InputFile, Order);
    except
        Flag := False;
        Order := InputOrderFromConsole();
    end;

    if (Flag) and ((Order < 2) or (Order > 6)) then
    begin
        Order := InputOrderFromConsole();
    end;

    CloseFile(InputFile);
    InputOrderFromFile := Order;
end;

function InputOrderFromConsole(): Integer;
var
    Order: Integer;
    IsCorrect: Boolean;
begin
    Writeln('В вашем файле вписан некорректный порядок матрицы. Введите порядок из косоли!');

    repeat
        IsCorrect := True;
        try
            Readln(Order);
        except
            Writeln('Введите целое число!');
            IsCorrect := False;
        end;

        if (IsCorrect) and ((Order < 2) or (Order > 6)) then
        begin
            Writeln('Некорректные данные. Введите порядок из диапазона [2;6]');
            IsCorrect := False;
        end;
    until IsCorrect;
    InputOrderFromConsole := Order;
end;

procedure InputMatrixFromFile(var Matrix: TwoDimensionalArray; Path: String);
var
    I, J: Integer;
    IsCorrect: Boolean;
    InputFile: TextFile;
begin
    AssignFile(InputFile, Path);
    Reset(InputFile);
    Readln(InputFile);

    Writeln('Матрица считывается из файла');
    for I := 0 to High(Matrix) do
    begin
        for J := 0 to High(Matrix) do
        begin
            try
                Read(InputFile, Matrix[I][J]);
            except
                Writeln('В вашем файле некорректный элемент матрицы a', i + 1, j + 1, '. Введите его из консоли!');
                Matrix[I][J] := InputMatrixFromConsole();
                Read(InputFile);
            end;
        end;
        Readln(InputFile);
    end;
    CloseFile(InputFile);
end;

function InputMatrixFromConsole(): Double;
var
    Element: Double;
    IsCorrect: Boolean;
begin
    repeat
        IsCorrect := True;
        try
            Readln(Element);
        except
            Writeln('Введите число!');
            IsCorrect := False;
        end;
    until IsCorrect;
    InputMatrixFromConsole := Element;
end;

procedure PrintMatrix(Matrix: TwoDimensionalArray);
var
    I, J: Integer;
begin
    for I := 0 to High(Matrix) do
    begin
        for J := 0 to High(Matrix) do
        begin
            Write(FormatFloat('0.####',Matrix[I][J]), '  ');
        end;
        Writeln;
    end;
end;

procedure DoInsertionSort(var Matrix: TwoDimensionalArray);
var
    I, J, K: Integer;
    Current: Double;

begin
    for I := 0 to High(Matrix) do
    begin
        for J := 0 to High(Matrix) do
        begin
            Current := Matrix[I][J];
            K := J;

            while (K > 0) and (Current < Matrix[I][K - 1]) do
            begin
                 Matrix[I][K] := matrix[I][K - 1];
                 K := K - 1;
            end;
            Matrix[I][K] := Current;
        end;
    end;
end;

procedure DoBubbleSortForStrings(var Matrix: TwoDimensionalArray);
var
    I, J, K: Integer;
    Temp: Double;

begin
    for K := 0 to High(Matrix) do
    begin
        for I := 0 to High(Matrix) - 1 do
        begin
            if Matrix[I][High(Matrix)] > Matrix[I + 1][High(Matrix)] then
            begin
                for J := 0 to High(Matrix) do
                begin
                    Temp := Matrix[I][J];
                    Matrix[I][J] := Matrix[I + 1][J];
                    Matrix[I + 1][J] := Temp;
                end;
            end;
        end;
    end;
end;

procedure OutputToFile(Matrix: TwoDimensionalArray; Path: String);
var
    OutputFile: TextFile;
    I, J: Integer;
begin
    AssignFile(OutputFile, Path);
    Reset(OutputFile);
    Rewrite(OutputFile);

    for I := 0 to High(Matrix) do
    begin
        for J := 0 to High(Matrix) do
        begin
            Write(OutputFile, FormatFloat('0.####',Matrix[I][J]), '  ');
        end;
        Writeln(OutputFile);
    end;
    CloseFile(OutputFile);
    Writeln('Данные успешно записаны в файл!');
end;

procedure Main();
var
    Order: Integer;
    Matrix: TwoDimensionalArray;
    PathInput, PathOutput: String;
begin
    Writeln('Дана матрица A порядка n.');
    Writeln('Программа отсортировывает строки матрицы');
    Writeln('в порядке возрастания наибольших элементов в каждой строке.');
    Writeln('(Порядок матрицы должен быть в диапазоне целых чисел от 2 до 6)');
    Writeln;

    Writeln('Введите абсолютную ссылку на файл ввода');
    PathInput := InputPath();
    Writeln('Введите абсолютную ссылку на файл вывода');
    PathOutput := InputPath();

    Order := InputOrderFromFile(PathInput);
    SetLength(Matrix, Order, Order);
    InputMatrixFromFile(Matrix, PathInput);
    Writeln('Исходная матрица:');
    PrintMatrix(Matrix);

    DoInsertionSort(Matrix);
    Writeln('Отсортированная матрица:');
    PrintMatrix(Matrix);

    OutputToFile(Matrix, PathOutput);
    Readln;
end;

begin
    Main;
end.