narzędzie wiersza poleceń do drukowania statystyk liczb w Linuksie

Using" st " ( https://github.com/nferraz/st )

$ st numbers.txt
N    min   max   sum   mean  stddev
10   1     10    55    5.5   3.02765

Lub:

$ st numbers.txt --transpose
N      10
min    1
max    10
sum    55
mean   5.5
stddev 3.02765

(zastrzeżenie: napisałem to narzędzie :))

Dla średniej, mediany i odchylenia standardowego można użyć awk. Na przykład średnia zostanie wydrukowana w następujący sposób:

awk '{a+=$1} END{print a/NR}' myfile

(NR jest zmienną awk dla liczby rekordów, $1 oznacza pierwszy (oddzielony spacjami) argument linii ($0 będzie całą linią, która również tutaj będzie działać, ale w zasadzie będzie mniej bezpieczna, chociaż dla obliczeń prawdopodobnie i tak pobierze pierwszy argument) i END oznacza, że następujące polecenia będą wykonywany po przetworzeniu całego pliku (można też zainicjalizować a do 0 w instrukcji BEGIN{a=0})).

Dla min/max, można rury sort & head/tail :

sort -n myfile | head -n1
sort -n myfile | tail -n1

Y. A. narzędziem, które może być używane do obliczania statystyk i dystrybucji widoku w trybie ASCII jest ministat . Jest to narzędzie z FreeBSD, ale również pakowane dla popularnych dystrybucji Linuksa, takich jak Debian / Ubuntu.

Przykład użycia:

$ cat test.log 
Handled 1000000 packets.Time elapsed: 7.575278
Handled 1000000 packets.Time elapsed: 7.569267
Handled 1000000 packets.Time elapsed: 7.540344
Handled 1000000 packets.Time elapsed: 7.547680
Handled 1000000 packets.Time elapsed: 7.692373
Handled 1000000 packets.Time elapsed: 7.390200
Handled 1000000 packets.Time elapsed: 7.391308
Handled 1000000 packets.Time elapsed: 7.388075

$ cat test.log| awk '{print $5}' | ministat -w 74
x <stdin>
+--------------------------------------------------------------------------+
| x                                                                        |
|xx                                   xx    x x                           x|
|   |__________________________A_______M_________________|                 |
+--------------------------------------------------------------------------+
    N           Min           Max        Median           Avg        Stddev
x   8      7.388075      7.692373       7.54768     7.5118156    0.11126122

Tak, nazywa się perl
a oto zwięzłe jednoliniowe:

perl -e 'use List::Util qw(max min sum); @a=();while(<>){$sqsum+=$_*$_; push(@a,$_)}; $n=@a;$s=sum(@a);$a=$s/@a;$m=max(@a);$mm=min(@a);$std=sqrt($sqsum/$n-($s/$n)*($s/$n));$mid=int @a/2;@srtd=sort @a;if(@a%2){$med=$srtd[$mid];}else{$med=($srtd[$mid-1]+$srtd[$mid])/2;};print "records:$n\nsum:$s\navg:$a\nstd:$std\nmed:$med\max:$m\min:$mm";'

Przykład

$ cat tt
1
3
4
5
6.5
7.
2
3
4

Oraz polecenie

cat tt | perl -e 'use List::Util qw(max min sum); @a=();while(<>){$sqsum+=$_*$_; push(@a,$_)}; $n=@a;$s=sum(@a);$a=$s/@a;$m=max(@a);$mm=min(@a);$std=sqrt($sqsum/$n-($s/$n)*($s/$n));$mid=int @a/2;@srtd=sort @a;if(@a%2){$med=$srtd[$mid];}else{$med=($srtd[$mid-1]+$srtd[$mid])/2;};print "records:$n\nsum:$s\navg:$a\nstd:$std\nmed:$med\max:$m\min:$mm";'
records:9
sum:35.5
avg:3.94444444444444
std:1.86256162380447
med:4
max:7.
min:1

data_hacks jest narzędziem wiersza poleceń Pythona do podstawowych statystyk.

Pierwszy przykład z tej strony daje pożądane rezultaty:

$ cat /tmp/data | histogram.py
# NumSamples = 29; Max = 10.00; Min = 1.00
# Mean = 4.379310; Variance = 5.131986; SD = 2.265389
# each * represents a count of 1
    1.0000 -     1.9000 [     1]: *
    1.9000 -     2.8000 [     5]: *****
    2.8000 -     3.7000 [     8]: ********
    3.7000 -     4.6000 [     3]: ***
    4.6000 -     5.5000 [     4]: ****
    5.5000 -     6.4000 [     2]: **
    6.4000 -     7.3000 [     3]: ***
    7.3000 -     8.2000 [     1]: *
    8.2000 -     9.1000 [     1]: *
    9.1000 -    10.0000 [     1]: *

Średnia:

awk '{sum += $1} END {print "mean = " sum/NR;}' filename

Mediana:

gawk -v max=128 '

    function median(c,v,  j) { 
       asort(v,j); 
       if (c % 2) return j[(c+1)/2]; 
       else return (j[c/2+1]+j[c/2])/2.0; 
    } 

    { 
       count++;
       values[count]=$1;  
       if (count >= max) { 
         print  median(count,values); count=0; 
       } 
    } 

    END { 
       print  "median = " median(count,values); 
    }' filename

Tryb:

awk '{c[$1]++;} END {for (i in count) {if (c[i]>max) {max=i;}} print "mode = " max;}' filename

Ten tryb obliczania wymaga parzystej liczby próbek, ale widzisz, jak to działa...

Odchylenie Standardowe:

awk '{sum+=$1; sumsq+=$1*$1;} END {print "stdev = " sqrt(sumsq/NR - (sum/NR)**2);}' filename

Na wszelki wypadek, jest datastat, prosty program do obsługi Linuksa proste statystyki z wiersza poleceń. Na przykład,

cat file.dat | datastat

Wyświetli średnią wartość we wszystkich wierszach dla każdej kolumny pliku.dat. Jeśli chcesz znać odchylenie standardowe, min, max, możesz dodać --dev, --min i --max odpowiednio opcje.

datastat ma możliwość agregowania wierszy na podstawie wartości jednej lub więcej kolumn "klucza". Na przykład,

cat file.dat | datastat -k 1

Will twórz, dla każdej innej wartości znalezionej w pierwszej kolumnie ("klucz"), średnią wszystkich innych wartości kolumn zagregowanych między wszystkimi wierszami o tej samej wartości na kluczu. Możesz użyć więcej kolumn jako pól kluczowych (np.-k 1-3, - k 2,4 itd...).

Jest napisany w C++, działa szybko i z małym zajęciem pamięci, i może być ładnie piped z innymi narzędziami, takimi jak cut, grep, sed, sort, awk itd.

Możesz również rozważyć użycie clistats. Jest to wysoce konfigurowalne narzędzie interfejsu wiersza poleceń do obliczania statystyk dla strumienia rozdzielonych liczb wejściowych.

Opcje Wejścia/Wyjścia

Dane wejściowe mogą być z pliku, standardowego wejścia lub rury
• wyjście może być zapisane do pliku, standardowego wyjścia lub rury
• Output używa nagłówków zaczynających się od"#", aby włączyć Orurowanie do gnuplot

Opcje parsowania

• Signal, w tym celu należy wykonać następujące czynności:]}
• Można ustawić znak komentarza i ogranicznika
• kolumny mogą być odfiltrowane z przetwarzania
• wiersze mogą być odfiltrowane z przetwarzania na podstawie ograniczenia numerycznego
• wiersze mogą być odfiltrowane z przetwarzania na podstawie ograniczenia ciągu
• początkowe wiersze nagłówka mogą być pomijane
• stała liczba wierszy może być przetwarzana
• zduplikowane ograniczniki mogą być ignorowane
• wiersze mogą być reshaped into columns
• ściśle egzekwuj, aby przetwarzane były tylko wiersze o tej samej wielkości
• wiersz zawierający tytuły kolumn może być użyty do tytułowania statystyk wyjściowych

Opcje statystyk

• statystyki zbiorcze (Liczba, Minimum, Średnia, maksimum, odchylenie standardowe)
• Kowariancja
• korelacja
• przesunięcie najmniejszych kwadratów
• najmniejsze nachylenie kwadratów
• Histogram
• surowe dane po filtrowaniu

Uwaga: jestem autor.

Stwierdziłem, że chcę to zrobić w rurociągu powłoki, i uzyskanie wszystkich właściwych argumentów dla R zajęło trochę czasu. Oto co wymyśliłem:

seq 10 | R --slave -e 'x <- scan(file="stdin",quiet=TRUE); summary(x)' Min. 1st Qu. Median Mean 3rd Qu. Max. 1.00 3.25 5.50 5.50 7.75 10.00

The --slave option " Make (s) r run as quietly as possible...It oznacza-ciche i-nie-Bezpieczne." opcja -e mówi R, aby traktował następujący ciąg jako kod R. Pierwsza instrukcja odczytuje ze standard in i przechowuje to, co jest odczytywane w zmiennej o nazwie "x". Opcja quiet=TRUE do scan funkcja blokuje pisanie linijki mówiącej, ile przedmiotów zostało przeczytanych. Drugie stwierdzenie dotyczy summary funkcja do x, która generuje wyjście.

#!/usr/bin/perl
#
# stdev - figure N, min, max, median, mode, mean, & std deviation
#
# pull out all the real numbers in the input
# stream and run standard calculations on them.
# they may be intermixed with other test, need
# not be on the same or different lines, and 
# can be in scientific notion (avagadro=6.02e23).
# they also admit a leading + or -.
#
# Tom Christiansen
# [email protected]

use strict;
use warnings;

use List::Util qw< min max >;

#
my $number_rx = qr{

  # leading sign, positive or negative
    (?: [+-] ? )

  # mantissa
    (?= [0123456789.] )
    (?: 
        # "N" or "N." or "N.N"
        (?:
            (?: [0123456789] +     )
            (?:
                (?: [.] )
                (?: [0123456789] * )
            ) ?
      |
        # ".N", no leading digits
            (?:
                (?: [.] )
                (?: [0123456789] + )
            ) 
        )
    )

  # abscissa
    (?:
        (?: [Ee] )
        (?:
            (?: [+-] ? )
            (?: [0123456789] + )
        )
        |
    )
}x;

my $n = 0;
my $sum = 0;
my @values = ();

my %seen = ();

while (<>) {
    while (/($number_rx)/g) {
        $n++;
        my $num = 0 + $1;  # 0+ is so numbers in alternate form count as same
        $sum += $num;
        push @values, $num;
        $seen{$num}++;
    } 
} 

die "no values" if $n == 0;

my $mean = $sum / $n;

my $sqsum = 0;
for (@values) {
    $sqsum += ( $_ ** 2 );
} 
$sqsum /= $n;
$sqsum -= ( $mean ** 2 );
my $stdev = sqrt($sqsum);

my $max_seen_count = max values %seen;
my @modes = grep { $seen{$_} == $max_seen_count } keys %seen;

my $mode = @modes == 1 
            ? $modes[0] 
            : "(" . join(", ", @modes) . ")";
$mode .= ' @ ' . $max_seen_count;

my $median;
my $mid = int @values/2;
if (@values % 2) {
    $median = $values[ $mid ];
} else {
    $median = ($values[$mid-1] + $values[$mid])/2;
} 

my $min = min @values;
my $max = max @values;

printf "n is %d, min is %g, max is %d\n", $n, $min, $max;
printf "mode is %s, median is %g, mean is %g, stdev is %g\n", 
    $mode, $median, $mean, $stdev;

Istnieje również proste-r, które może zrobić prawie wszystko, co R może, ale z mniejszą liczbą naciśnięć klawiszy:

Https://code.google.com/p/simple-r/

Aby obliczyć podstawowe statystyki opisowe, należy wpisać jeden z:

r summary file.txt
r summary - < file.txt
cat file.txt | r summary -

Dla każdego odchylenia średniego, mediany, min, max i std kod będzie wynosił:

seq 1 100 | r mean - 
seq 1 100 | r median -
seq 1 100 | r min -
seq 1 100 | r max -
seq 1 100 | r sd -

Nie ma żadnego prostego-R!

Jeszcze jedno narzędzie: https://www.gnu.org/software/datamash/

# Example: calculate the sum and mean of values 1 to 10:
$ seq 10 | datamash sum 1 mean 1
55 5.5

Może być bardziej powszechnie pakowane (pierwsze narzędzie, które znalazłem wstępnie zapakowane przynajmniej dla nix)

Using xsv :

$ echo '3 1 4 1 5 9 2 6 5 3 5 9' |tr ' ' '\n' > numbers-one-per-line.csv

$ xsv stats -n < numbers-one-per-line.csv 
field,type,sum,min,max,min_length,max_length,mean,stddev
0,Integer,53,1,9,1,1,4.416666666666667,2.5644470922381863

# mode/median/cardinality not shown by default since it requires storing full file in memory:
$ xsv stats -n --everything < numbers-one-per-line.csv | xsv table
field  type     sum  min  max  min_length  max_length  mean               stddev              median  mode  cardinality
0      Integer  53   1    9    1           1           4.416666666666667  2.5644470922381863  4.5     5     7

Inne narzędzie: tsv-summarize, z narzędzia tsv eBay . Min, max, średnia, mediana, odchylenie standardowe są obsługiwane. Przeznaczony do dużych zbiorów danych. Przykład:

$ seq 10 | tsv-summarize --min 1 --max 1 --median 1 --stdev 1
1    10    5.5    3.0276503541

Zastrzeżenie: jestem autorem.