comparison tools/stats.c @ 0:5242703e91d3 tip

Initial checkin for AIM92 aimR8.2 (last updated May 1997).

+/*
+  stats.c      calculate some statistics (min, max, mean etc.)
+  -------
+
+*/
+
+#include <stdio.h>
+#include <math.h>
+#include "options.h"
+#include "units.h"
+#include "strmatch.h"
+
+char applic[]     = "print statistics of input files" ;
+
+static char *helpstr, *debugstr, *typestr, *statstr ;
+static char *sampstr, *frstr,    *widstr,  *sizestr ;
+static char *linestr, *precstr,  *fieldstr          ;
+
+static Options option[] = {
+    {   "help"      ,   "off"       ,  &helpstr     ,   "help"                          , DEBUG   },
+    {   "debug"     ,   "off"       ,  &debugstr    ,   "debugging switch"              , DEBUG   },
+    {   "samplerate",   "20kHz"     ,  &sampstr     ,   "samplerate "                   , VAL     },
+    {   "frame"     ,   "1"         ,  &frstr       ,   "select frames inclusively"     , VAL     },
+    {   "width"     ,   "max"       ,  &widstr      ,   "frame width"                   , VAL     },
+    {   "type"      ,   "short"     ,  &typestr     ,   "data type"                     , VAL     },
+    {   "stat"      ,   "mean"      ,  &statstr     ,   "statistic list (comma separated)"      , VAL     },
+    {   "line"      ,   "off"       ,  &linestr     ,   "force ascii output"            , SETFLAG },
+    {   "fieldwidth",   "10"        ,  &fieldstr    ,   "field width for ascii printing", SVAL    },
+    {   "precision" ,   "3"         ,  &precstr     ,   "precision for ascii printing"  , SVAL    },
+    {   "SIZE"      ,   "262144p"   ,  &sizestr     ,   "buffer size (s, ms, or p)"     , SVAL    },
+   ( char * ) 0 } ;
+
+
+typedef float (*PF)() ; /* pointer-to-function type returning float */
+
+typedef struct {        /* a struct to hold both function name and pointer */
+    char  *name ;       /* string name of function */
+    PF     func ;       /* pointer to function     */
+    char  *help ;       /* explanation of use      */
+} Func ;
+
+
+float   num(),      sum(),      sumabs(),   sumsq(),    mean()      ;
+float   rms(),      variance(), stddev(),   min(),      max()       ;
+float   absmax(),   absrange(), pc()                                            ;
+
+float   call_by_name() ;
+
+Func  statistic[] = {
+    { "n"         ,     num         ,    "sample size (ie. frame width)"                        } ,
+    { "sum"       ,     sum         ,    "area"                                                 } ,
+    { "sa"        ,     sumabs      ,    "sum of absolute values"                               } ,
+    { "ss"        ,     sumsq       ,    "sum of squares"                                       } ,
+    { "mean"      ,     mean        ,    "sum/n"                                                } ,
+    { "rms"       ,     rms         ,    "root mean square: square root of ss/n"                } ,
+    { "variance"  ,     variance    ,    "computed with n-1 degrees of freedom"                 } ,
+    { "stddev"    ,     stddev      ,    "standard deviation: square root of variance"          } ,
+    { "min"       ,     min         ,    "minimum value"                                        } ,
+    { "max"       ,     max         ,    "maximum value"                                        } ,
+    { "absmax"    ,     absmax      ,    "maximum absolute value, ie. max( |max|, |min| )"      } ,
+    { "range"     ,     absrange    ,    "max-min"                                              } ,
+    { "pc_1of2"   ,     pc          ,    "percentage correct, ie. greater first of each pair"   } ,
+   ( char * ) 0 } ;
+
+
+int    samplerate ;
+int    bytes      ;
+int    type       ;     /* datatype index */
+int    nstat      ;     /* number of statistics required */
+int    width      ;
+int    SIZE       ;
+int    lineout    ;     /* flag for forcing ascii output */
+
+float *buf ;            /* args to every stat function */
+int    n   ;
+
+main (argc, argv)
+int    argc;
+char **argv;
+{
+    FILE   *fp   ;
+    char  **list ;
+    float   y    ;
+    int     i, j, k, a, b, helpstats() ;
+
+    i = getopts( option, argc, argv ) ;
+    if ( !isoff( helpstr ) )
+	helpopts1( helpstr, argv[0], applic, option, helpstats ) ;
+
+    if ( ( type = typeindex( typestr ) ) < 0 ) {
+	fprintf( stderr, "stats: bad type [%s]\n", typestr ) ;
+	exit( 1 ) ;
+    }
+    bytes = typebytes( type ) ;
+
+    if ( selector( frstr, &a, &b ) == 0 ) {
+	fprintf(stderr,"stats: bad frame selector [%s]\n", frstr ) ;
+	exit( 1 ) ;
+    }
+
+    PRECISION  = atoi( precstr ) ;
+    FIELDWIDTH = atoi( fieldstr ) ;
+    lineout    = ison( linestr ) ;
+    samplerate = to_Hz( sampstr, 0) ;
+    SIZE       = to_p( sizestr, samplerate ) ;
+    if ( ismax( widstr ) ) width = (-1) ;
+    else                   width = to_p( widstr, samplerate ) ;
+
+    nstat  = flistsize( statistic ) ;   /* max number of statistics */
+    list   = (char **)malloc( nstat * sizeof( char *) ) ;
+    if ( ( nstat  = tokens( statstr, list, nstat, ',' ) ) == 0 ) {
+	fprintf(stderr,"stats: incorrect stat list\n" ) ;
+	exit( 1 ) ;
+    }
+
+    do {
+
+	if ( i == 0 ) fp = stdin ;
+	else if ( ( fp = fopen( argv[argc-i], "r" ) ) == (FILE *)0 ) {
+	    fprintf( stderr,"stats: can't open %s\n", argv[argc-i] ) ;
+	    exit( 1 ) ;
+	}
+
+	if ( width > 0 ) buf = (float *)malloc( width * sizeof(float) ) ;
+	else             buf = (float *)malloc( SIZE  * sizeof(float) ) ;
+
+	if ( width > 0 && a > 1 )
+	    if ( seekstart( (a-1)*width, bytes, fp ) < (a-1)*width )
+		fprintf( stderr, "stats warning: insufficient input\n" ) ;
+
+	for ( j = a ; ( j <= b || b == 0 ) && ( n = Readitem( buf, type, width, fp, SIZE ) ) > 0 ; j++ ) {
+
+	    for ( k = 0 ; k < nstat ; k++ ) {
+
+		y = call_by_name( list[k], statistic ) ;
+
+		if ( lineout )
+		    printf( "%*.*f  ", FIELDWIDTH, PRECISION, y ) ;
+		else
+		    writeitem( &y, type, 1, stdout ) ;
+	    }
+	}
+
+	free( buf ) ;
+	fclose( fp ) ;
+	if ( lineout ) printf( "\n" ) ;
+
+    } while ( --i > 0 ) ;
+
+}
+
+
+/*
+Return the number of structs in the null-terminated array of Func structs.
+*/
+
+flistsize( flist )
+Func *flist ;
+{
+    int  i ;
+
+    for ( i = 0 ; flist[i].name != (char *)0 ; i++ )
+	;
+    return i ;
+}
+
+
+/*
+Call a function given its string name. The function's address is found against
+the matching name in the given `flist'.
+The function returns an float.
+Rather than return at the first matching name, search all the list for names
+which match the (possibly abbreviated) string name. Print a warning if
+ambiguity found.
+*/
+
+float call_by_name( str, flist )
+char  *str   ;
+Func  *flist ;
+{
+    int  i, j = (-1) ;
+
+    for ( i=0 ; flist[i].name != (char *)0 ; i++ ) {
+	if ( iststr( str, flist[i].name ) ) {
+	    if ( j >= 0 )
+		fprintf( stderr,"warning: ambiguous stat names (%s and %s)\n", flist[j].name, flist[i].name ) ;
+	    j = i ;
+	}
+    }
+    return ( (*flist[j].func)() ) ;
+}
+
+
+/*
+Read items of given type up to max of SIZE items (when n=-1).
+Return n or 0 if eof.
+*/
+
+Readitem( y, type, n, fp, SIZE )
+float  *y    ;
+int     type ;
+int     n    ;
+FILE   *fp   ;
+int     SIZE ;
+{
+    if ( n == (-1) ) {
+	for ( n = 0 ; n < SIZE && readitem( &y[n], type, 1, fp ) ; n++ )
+	    ;
+	if ( n == SIZE )
+	    fprintf( stderr, "stats warning: buffer full\n" ) ;
+    }
+    else if ( readitem( y, type, n, fp ) == 0 ) return 0 ;
+
+    return n ;
+}
+
+
+/*
+Print help on request
+*/
+
+helpstats()
+{
+    int  i ;
+
+    fprintf(stderr,"\nstatistics:       \n");
+
+    for ( i = 0 ; statistic[i].name != (char *)0 ; i++ )
+	fprintf(stderr,"            %-10s  %s\n", statistic[i].name, statistic[i].help ) ;
+
+    exit( 1 ) ;
+}
+
+
+/*************************** functions ************************************/
+/* The functions all take two args: char *buf; int n;                     */
+/* These are declared externally.                                         */
+
+
+float num()
+{
+    return n ;
+}
+
+
+float sum()
+{
+    int   i ;
+    float sum = 0 ;
+
+    for ( i = 0 ; i < n ; i++ )
+	sum += buf[i] ;
+
+    return ( sum ) ;
+}
+
+
+float sumabs()
+{
+    int   i ;
+    float sum = 0 ;
+
+    for ( i = 0 ; i < n ; i++ )
+	sum += fabs( (double)buf[i] ) ;
+
+    return ( sum ) ;
+}
+
+
+float sumsq()
+{
+    int   i ;
+    float sumsq = 0 ;
+
+    for ( i = 0 ; i < n ; i++ )
+	sumsq += ( buf[i] * buf[i] ) ;
+
+    return ( sumsq ) ;
+}
+
+
+float mean()
+{
+    int   i ;
+    float sum = 0 ;
+
+    for ( i = 0 ; i < n ; i++ )
+	sum += buf[i] ;
+
+    return ( sum / n ) ;
+}
+
+
+float rms()
+{
+    int   i ;
+    float sumsq = 0 ;
+
+    for ( i = 0 ; i < n ; i++ )
+	sumsq += ( buf[i] * buf[i] ) ;
+
+    return ( sqrt( sumsq / n ) ) ;
+}
+
+
+float variance()    /* computed with n-1 degrees of freedom */
+{
+    int   i ;
+    float sum = 0, sumsq = 0 ;
+
+    for ( i = 0 ; i < n ; i++ ) {
+	sum   += buf[i]   ;
+	sumsq += ( buf[i] * buf[i] ) ;
+    }
+
+    return ( ( sumsq - sum*sum/n ) / ( n - 1 ) ) ;  /* replace n-1 by n for n degrees of freedom */
+}
+
+
+float stddev()    /* computed with n-1 degrees of freedom */
+{
+    return ( sqrt( variance( buf, n ) ) ) ;
+}
+
+
+float min()
+{
+    int   i ;
+    float min = 99999999999. ;
+
+    for ( i = 0 ; i < n ; i++ )
+	if ( buf[i] < min ) min = buf[i] ;
+    return ( min ) ;
+}
+
+
+float max()
+{
+    int   i ;
+    float max = ( -99999999999. ) ;
+
+    for ( i = 0 ; i < n ; i++ )
+	if ( buf[i] > max ) max = buf[i] ;
+
+    return ( max ) ;
+}
+
+
+float absmax()
+{
+    int   i ;
+    float min =    99999999999.   ;
+    float max = ( -99999999999. ) ;
+
+    for ( i = 0 ; i < n ; i++ ) {
+	if ( buf[i] < min ) min = buf[i] ;
+	if ( buf[i] > max ) max = buf[i] ;
+    }
+
+    if ( ( max = fabs( (double)max ) ) < ( min = fabs( (double)min ) ) )
+	max = min ;
+
+    return ( max ) ;
+}
+
+
+float absrange()
+{
+    int   i ;
+    float min =    99999999999.   ;
+    float max = ( -99999999999. ) ;
+
+    for ( i = 0 ; i < n ; i++ ) {
+	if ( buf[i] < min ) min = buf[i] ;
+	if ( buf[i] > max ) max = buf[i] ;
+    }
+
+    return ( max - min ) ;
+}
+
+
+/*
+The buf contains n/2 pairs of numbers. Calculate how many of each pair have
+the first number greater than the last, and return this as a "percentage
+correct".
+*/
+
+float pc()
+{
+    int   i ;
+    float p = 0 ;
+
+    for ( i = 0 ; i < n ; i+=2 )
+	if ( buf[i] > buf[i+1] )
+	    p++ ;
+
+    return ( ( p / (n/2) ) * 100 ) ;
+}
+
+
+