Вывести время в миллисекундах с начала работы программы по встроенной функции Milliseconds в PascalABC.NET

[constant_bel]

Сортировка матрицы A [m, n] методом обмена с использованием флажка (метод пузырька усовершенствованный) по возрастанию. Начальное состояние матрицы - упорядоченна по возрастанию) сортировка работает. Но не могу найти причину, почему-то не выводится время в миллисекундах с начала работы программы по встроенной функции Milliseconds. Есть ещё два кода с таким же методом, с состоянием матриц - упорядочена по убыванию и не упорядочена,- оба кода работают и выдают время как надо.

program ExchSortFlag_NxM_322;
//uses crt;
const
  n = 7;
  m = 3;
type
  oneMas = array[1..n * m] of integer;
  twoMas = array[1..n, 1..m] of integer;
var
  masTest: twoMas;
  masTemp: oneMas;
  LapsTime: real;
                                             {Заполнение и вывод на экран входящей матрицы}
procedure inputData(var masTest: twomas);
var
  i, j, idmt: integer;
begin
  idmt := 1;
  writeln('Source massiv A:');
  for j := 1 to m do
  begin
    for i := 1 to n do
    begin
      masTest[i, j] := idmt;
      write(' ', masTest[i, j]:5);
      inc(idmt);
    end;
        writeln;
  end;
end;
                                                   {Вывод на экран отсортированной матрицы}
procedure outputData(var masTest: twoMas);
var
  i, j: integer;
begin
  writeln('Sort massiv A:');
  for j := 1 to m do
  begin
    for i := 1 to n do
    begin
      write(' ', masTest[i, j]:5);
    end;
    writeln;
  end;
end;
                                                        {Сортировка матрицы A[m,n]. Методом обмена с флагом}
procedure ExchSortFlag(var masTest: twoMas; var masTemp: onemas);
var
  i, j, k, s, e, tmp, idmt: integer;
    flag: boolean;
                             {Копирование элементов двумерного массива в одномерный}
begin
  idmt := 1;
  for j := 1 to m do
  begin
    for i := 1 to n do
    begin
      masTemp[idmt] := masTest[i, j];
      inc(idmt);
    end;
  end;
                                                                       {Сортировка одномерного массива}
  s := 1;                                                               //Первый элемент масива
  e := n * m;                                                           //{Последний елемент масива
  repeat
    flag := true;                                               //   false           {установка флага }
    while e > s do                                        // если последний больше первого
    begin                                                     // выполняем
      s := s + 1;
      for i := e downto s + 1 do                      // проверка массива
        if masTemp[i] < masTemp[i - 1] then     // если i-ый элемент меньше (i-1)-го, то
        begin                                               // меняем их местами
          tmp := masTemp[i];                           
          masTemp[i] := masTemp[i - 1];
                                                                  { Улучшаем метод. Добовляем счётчик проходов. 
                                           После одного прохода один элемент будет стоять на своем месте, 
                                                                        а значит с ним сравнивать не имеет смыслы}
          masTemp[i - 1] := tmp;                       // 
          flag := false                                        // true
        end;
      //s := s+1;
    end;
  until not flag;  {Выход при flag=false, если нет то заново проверяем массив}
                                                    {Копирование элементов одномерного массива в двумерный}
  idmt := 1;
  for j := 1 to m do
  begin
    for i := 1 to n do
    begin
      masTest[i, j] := masTemp[idmt];
      inc(idmt);
    end;
  end;
end;
 
//var
  //LapsTime: real;
begin
  Milliseconds;
  inputData(masTest);
  outputData(masTest);
  ExchSortFlag(masTest, masTemp);                         
  //outputData(masTest);
  //writeln('Tims:');
  //Milliseconds;
  LapsTime := Milliseconds();    //  = Milliseconds / 1000;
  //LapsTime := MillisecondsDelta();
  Writeln('Sorting time: ', LapsTime, '  ms');
  readln;
end.

[Serge_Bliznykov]

что значит - "не выдаёт время" ?!

[constant_bel]

не выводит на єкран сообщение:

Sorting time: 20(на пример) ms

[constant_bel]

Но вот попробовал у flag поменять значения false-true местами, и вроде как напечатало: 13 ms. Это уже лучше! А всё таки, нужно же чтоб программа останавливалась(показатель-активная кнопка запуска)!?

[Serge_Bliznykov]

ну правильно, не выводит.
висит в бесконечном цикле.
скажи, ты процедуру ExchSortFlag сам писал?!

там же ошибка в логике!

смотри:

 repeat
    flag := true;                                               //   false           {установка флага }
    while e > s do 
        .....
 until not flag;

у тебя массив отсортирован, условие if masTemp[i] < masTemp[i - 1] ни разу не выполняется, flag false не становится и получили бесконечный цикл.

исправляй процедуру и всё у тебя получится!

А всё таки, нужно же чтоб программа останавливалась(показатель-активная кнопка запуска)!?

убери последний ReadLn - программа и завершится!

[constant_bel]

Да, спасибо большое! Уже здорово помог. Так по условию, - изначально как вариант, матрица должна быть упорядочена по возрастанию (как один из вариантов). Сортировка тоже по возрастанию, по этому,- визуализации к сожалению нет по факту, что происходит. Но вот два других кода можно сказать, что точно работают, так как визуализация есть. А блок Сортировки такой же, с разницей в позициях flag - false/true.
Вот на пример:
// 3.2.1.1_ExchangeSortingFlag(BubllSo rt)_NxM Сортировка матрицы A [m, n] методом обмена с использованием флажка (метод пузырька усовершенств)
//(состояние матрицы 1 - не упорядоченное)

program ExchangeSortingFlag(BubllSort);
//uses crt;
const
  n = 7; 
  m = 3;
type
  oneMas = array[1..n * m] of integer;
  twoMas = array[1..n, 1..m] of integer;
var
  masTest: twomas;
  masTemp: onemas;
                               {Заполнение и вывод на экран входящей матрицы}
procedure inputData(var masTest: twomas);
var
  i, j: integer;
begin
  randomize;
  writeln('Source massiv A:');
  for j := 1 to m do
  begin
    for i := 1 to n do
    begin
      masTest[i, j] := random(1000);
      write(' ', masTest[i, j]:5);
    end;
    writeln;
  end;
end;
                                                                          {Вывод на экран отсортированной матрицы}
procedure outputData(var masTest: twoMas);
var
  i, j: integer;
begin
  writeln('Sort massiv A:');
  for j := 1 to m do
  begin
    for i := 1 to n do
    begin
      write(' ', masTest[i, j]:5);
    end;
    writeln;
  end;
end;
                                                       {Сортировка матрицы A[m,n]. Методом обмена с флагом}
procedure ExchSortFlag(var masTest: twoMas; var masTemp: oneMas);
var
  i, j, k, s, e, tmp, idmt: integer;
  flag: boolean;
                                                 {Копирование элементов двумерного массива в одномерный}
begin
  idmt := 1;
  for j := 1 to m do
  begin
    for i := 1 to n do
    begin
      masTemp[idmt] := masTest[i, j];
      inc(idmt);
    end;
  end;
                                                                     {Сортировка одномерного массива}
  s := 0;                                                               //Первый элемент масива
  e := n * m;                                                           //{Последний елемент масива
  repeat
    flag := true;                                               //   false           {установка флага }
    while e > s do                                        // если последний больше первого
    begin                                                     // выполняем
      s := s + 1;
      for i := e downto s + 1 do                      // проверка массива
        if masTemp[i] < masTemp[i - 1] then     // если i-ый элемент меньше (i-1)-го, то
        begin                                               // меняем их местами
          tmp := masTemp[i];                           
          masTemp[i] := masTemp[i - 1];
                                                                  { Улучшаем метод. Добовляем счётчик проходов. 
                                           После одного прохода один элемент будет стоять на своем месте, 
                                                                        а значит с ним сравнивать не имеет смыслы}
          masTemp[i - 1] := tmp;                       // 
          flag := false                                        // true
        end;
      //s := s+1;
    end;
  until not flag;  {Выход при flag=false, если нет то заново проверяем массив}
                                              {Копирование элементов одномерного массива в двумерный}
  idmt := 1;
  for j := 1 to m do
  begin
    for i := 1 to n do
    begin
      masTest[i, j] := masTemp[idmt];
      inc(idmt);
    end;
  end;
end;

var
  LapsTime: real;
begin
  inputData(masTest);
  ExchSortFlag(masTest, masTemp);                               // sortselection(masTest, masTemp);
  outputData(masTest);
  //writeln('Tims:');
  Milliseconds;
  LapsTime := Milliseconds();    //  = Milliseconds / 1000;
  //LapsTime := MillisecondsDelta();
  Writeln('Sorting time: ', LapsTime, '  ms');
  //readln;
end.

Результат:
Source massiv A:
806 895 450 544 306 275 138
978 23 403 30 541 194 895
190 300 322 946 747 198 339
Sort massiv A:
23 30 138 190 194 198 275
300 306 322 339 403 450 541
544 747 806 895 895 946 978
Sorting time: 21 ms

[Serge_Bliznykov]

Sorting time: 21 ms

только я бы, на Вашем месте, определился, какое именно время Вас интересует.
Сейчас Вы вводите время с начала запуска программы (т.е. включая время, которое потратили на заполнение массива и на его вывод на экран).
Если Вы хотите вывести время выполнения процедуры ExchSortFlag
тогда нужно это записать так:

var
  LapsTime: real;
begin
  inputData(masTest);
  Milliseconds;
  ExchSortFlag(masTest, masTemp);
  LapsTime := MillisecondsDelta();   
  outputData(masTest);
  Writeln('Sorting time: ', LapsTime, '  ms');
  //readln;
end.

p.s. а матрицу можно заполнять случайными числами

[constant_bel]

Да Вы правы, мне нужно время работы всей программы без вывода матриц на экран. Вывод на экран просто для тестирования(визуализации) сортировок. Я думал над этим, чтоб вывод не влиял на время, поэтому я просто отключал все writeln/write в процедурах. Вот я поставил например:
const
n = 170;
m =130;
и при всех отключенных writeln/write в процедурах, в запусках
1). И вот вариант при:
begin
outputData(masTest);
inputData(masTest);
Milliseconds; или без //Milliseconds;
ExchSortFlag(masTest, masTemp);
LapsTime := MillisecondsDelta();
outputData(masTest);
Writeln('Sorting time: ', LapsTime, ' ms');
//readln;
end.
Выходит Sorting time: 2250/2260 ms
2). И вот вариант при:
//outputData(masTest);
//inputData(masTest);
Milliseconds; или с //Milliseconds;
//ExchSortFlag(masTest, masTemp);
LapsTime := MillisecondsDelta();
outputData(masTest);
Writeln('Sorting time: ', LapsTime, ' ms');
//readln;
end.
Выходит Sorting time: 0/10 ms
Даже при всех "включённых" writeln/write и как при первом - 1). условии
Выходит Sorting time: 2250 ms
Вывод:
1. В случае 2) ни чего не происходит (не меряет время), т. к. отключено то, что нужно мереть.
2. При первом-1) варианте со всеми "включёнными" в последнем блоке процедурами, учитывается только время работы программы без вывода матриц на экран, не смотря на то, что он (вывод матриц) присутствует!? Если это так, то это здорово! Теперь понял, что не нужно лазить по коду и отключать/включать writeln/write. Просто я хотел понять (убедится) как оно(MillisecondsDelta) работает. Так ли я всё понял?
Спасибо!

[Serge_Bliznykov]

Да, всё именно так.
согласно документации MillisecondsDelta показывает время от запуска предыдущего Milliseconds