Если вы хотите быстро взглянуть на распределение последовательности значений, диаграмма «стебель-лист» - невероятно простой, но мощный инструмент. Чтобы научить компьютер рисовать, потребуется несколько минут, или вы можете сделать это вручную.
Единственная проблема в том, что он не сохраняет порядок значений, который иногда содержит полезную информацию. Я пытался придумать такой же простой способ построить таймсерию с сохраненным порядком, но ничего не придумал.
Очевидное решение, заключающееся в создании регулярной диаграммы таймсерий со временем по оси X и значениями по оси Y, страдает от проблемы, заключающейся в том, что требуется довольно много подготовительной работы перед тем, как перейти к фактическому рендерингу. Это далеко не так концептуально просто, как сюжет со стеблями и листьями.
Есть что-то такое? Или то, о чем я прошу, невозможно?
О, и еще одно важное требование, которое я почти забыл: я бы хотел, чтобы это можно было легко распечатать на терминале с строчной буферизацией ...
Причина, по которой я спрашиваю здесь, заключается в том, что моим основным вариантом использования для этого являются показатели работоспособности и другие образцы с серверов. При исключении причин неисправности системы было бы неплохо быстро получить интуитивное представление о том, как некоторая подсистема вела себя с течением времени.
Я не уверен, что это полностью то, что я ищу, так как это немного сложно, но пока что удовлетворяет мои потребности:
Я начал работать с температурами, которые удобно находились в диапазоне 25–60 ° C, поэтому я мог просто воспроизвести последовательность * чтобы создать из них своего рода гистограмму:
$ cat temps2.txt | perl -pe 'print "*" x $_ . " ";'
******************************************** 44.0
*************************************************** 51.0
******************************************* 43.0
********************************************* 45.0
************************************** 38.0
**************************************** 40.0
*********************************** 35.0
************************************ 36.0
******************************** 32.0
******************************** 32.0
******************************* 31.0
******************************* 31.0
******************************** 32.0
******************************** 32.0
******************************* 31.0
************************************ 36.0
******************************** 32.0
************************************ 36.0
******************************* 31.0
*********************************** 35.0
************************************ 36.0
************************************ 36.0
********************************* 33.0
******************************* 31.0
******************************** 32.0
******************************* 31.0
********************************* 33.0
******************************** 32.0
******************************** 32.0
************************************ 36.0
Конечно, это работает только со значениями, которые находятся в удобном диапазоне, но глупо эффективно, когда они есть - а когда их нет, можно просто добавить некоторые арифметические манипуляции с $_ переменная, указывающая количество повторов.
Например, средняя длина очереди выполнения процессора каждую секунду (которая для меня находится в диапазоне 0–8) может быть умножена на 10, чтобы на выходе были видны сдвиги:
$ cat runq.txt | perl -pe 'print "*" x ($_ * 10) . " ";'
0
0
0
0
******************** 2
********** 1
******************** 2
**************************************** 4
****************************** 3
**************************************** 4
****************************** 3
****************************** 3
******************** 2
******************** 2
********** 1
********** 1
********** 1
************************************************************ 6
********** 1
********** 1
********** 1
0
0
Это полностью удовлетворило бы мои потребности.
Конечно, будучи собой, я пошел по этому пути за борт и создал большой скрипт, который включает автоматический расчет и обновление преобразований координат, а также потоковое вычисление системных средних и естественных ограничений процесса:
$ cat temps2.txt | ./limits.pl
----------------------------------------------------------------
X: 51.0 [ | * ]
X: 43.0 [ * | ]
X: 45.0 [ | ]
X: 38.0 [ * | ]
X: 40.0 [ * | ]
X: 35.0 [ * | ]
X: 36.0 [ * | ]
X: 32.0 [ * | ]
X: 32.0 [ * | ]
X: 31.0 [* | ]
X: 31.0 [* | ]
X: 32.0 [ * | ]
X: 32.0 [ * | ]
X: 31.0 [* | ]
X: 36.0 [ * ]
X: 32.0 [ * | ]
X: 36.0 [ | ]
X: 31.0 [ * | ]
X: 35.0 [ *| ]
X: 36.0 [ | ]
X: 36.0 [ * ]
X: 33.0 [ * | ]
X: 31.0 [ * | ]
X: 32.0 [ * | ]
X: 31.0 [ * | ]
X: 33.0 [ *| ]
X: 32.0 [ * | ]
X: 32.0 [ * | ]
X: 36.0 [ |* ]
UPL=42.1
Xbar=35.2
LPL=28.2
Неочищенный исходный код этого скрипта также прилагается. Это первый черновик, извините, пожалуйста, за неправильный код.
#!/usr/bin/env perl
use v5.26;
use strict;
use warnings;
use List::Util qw( min max );
my $max_width = 52;
my $n = 0;
my $xbar = 0;
my $mrbar = 0;
my $lpl;
my $upl;
sub print_values {
print "\n";
printf "UPL=%.1f\n", $upl;
printf "Xbar=%.1f\n", $xbar;
printf "LPL=%.1f\n", $lpl;
}
$SIG{INT} = \&print_values;
my $min_y;
my $max_y;
my $xprev;
while (my $x = <>) {
$n++;
$xbar *= $n - 1;
$xbar += $x;
$xbar /= $n;
if (defined($xprev)) {
my $mr = abs ($x - $xprev);
$mrbar *= $n - 2;
$mrbar += $mr;
$mrbar /= $n - 1;
$lpl = $xbar - $mrbar * 2.66;
$upl = $xbar + $mrbar * 2.66;
my $space_changed;
# If any point is about to be drawn outside of the screen space, expand
# the space to include the currently drawn points and then some.
if (min($lpl, $x) < $min_y or max($upl, $x) > $max_y) {
my $min_diff = abs($min_y - min($lpl, $x));
my $max_diff = abs($max_y - max($upl, $x));
# Change min and max values in slightly larger steps to avoid
# changing the space too often with a drifting process.
$min_y -= $min_diff * 2;
$max_y += $max_diff * 2;
$space_changed = 1;
}
if ($min_y == $max_y) {
$max_y = $min_y + 1;
}
my %screen_coords;
$screen_coords{lpl} = $lpl;
$screen_coords{upl} = $upl;
$screen_coords{xbar} = $xbar;
$screen_coords{x} = $x;
# Transform the recorded values to the screen space.
for my $coord (keys %screen_coords) {
# Set offset to 0.
$screen_coords{$coord} -= $min_y;
# Divide by range to scale down to 0–1.
$screen_coords{$coord} /= ($max_y - $min_y);
# Scale up again to proper width.
$screen_coords{$coord} *= ($max_width - 1);
}
# Render the recorded values into an array of characters.
my @characters = split('', ' ' x $max_width);
$characters[$screen_coords{xbar}] = '|';
$characters[$screen_coords{lpl}] = '[';
$characters[$screen_coords{upl}] = ']';
$characters[$screen_coords{x}] = '*';
# Print a separator whenever the space needs to be expanded.
if ($space_changed) {
printf ('-' x ($max_width + 12) . "\n");
}
printf "X: %7.1f %s\n", $x, join('', @characters);
} else {
$min_y = $x;
$max_y = $x;
}
$xprev = $x;
}
print_values;