/*------------------------------------------------------------*/
/*  Program chapter5_5                                        */
/*                                                            */
/*  This program computes a set of statistical measurements   */
/*  from a speech signal.                                     */

#include <stdio.h>
#include <math.h>

// #include "stat_lib.h"
//
double max( double x[], int n);
double min( double x[], int n);
double mean( double x[], int n);
double median( double x[], int n);
double variance( double x[], int n);
double std_dev( double x[], int n);

#define MAXIMUM 2500
#define FILENAME "zero1.txt"

int main(void)
{
   /*  Declare variables and function prototypes.  */
   int k=0, npts;
   double speech[MAXIMUM];
   FILE *file_in;
   double ave_power(double x[],int npts);
   double ave_magn(double x[],int npts);
   int crossings(double x[],int npts);

   /*  Read information from a data file.  */
   file_in = fopen(FILENAME,"r");
   if (file_in == NULL)
     printf ("Error opening input file. \n");
   else
   {
      while ((fscanf(file_in,"%lf",&speech[k])) == 1)
         k++;
      npts = k;

      /*  Compute and print statistics.  */
      printf("speech statistics \n");
      printf(" mean: %f \n",mean(speech,npts));
      printf(" standard deviation: %f \n",
             std_dev(speech,npts));
      printf(" variance: %f \n",variance(speech,npts));
      printf(" average power: %f \n",
             ave_power(speech,npts));
      printf(" average magnitude: %f \n",
             ave_magn(speech,npts));
      printf(" zero crossings: %d \n",
             crossings(speech,npts));

      /*  Close file and exit program.  */
      fclose(file_in);
   }

   /*  Exit program.  */
   return 0;
}
/*------------------------------------------------------------*/
/*  This function returns the average power of an array x     */
/*  with npts elements.                                       */

double ave_power(double x[],int npts)
{
   /*  Declare and initialize variables.  */
   int k;
   double sum=0;

   /*  Determine average power.  */
   for (k=0; k<=npts-1; k++)
      sum += x[k]*x[k];

   /*  Return average power.  */
   return sum/npts;
}
/*------------------------------------------------------------*/
/*  This function returns the average magnitude of an array x */
/*  with npts elements.                                       */

double ave_magn(double x[],int npts)
{
   /*  Declare and initialize variables.  */
   int k;
   double sum=0;

   /*  Determine average power.  */
   for (k=0; k<=npts-1; k++)
      sum += fabs(x[k]);

   /*  Return average magnitude.  */
   return sum/npts;
}
/*------------------------------------------------------------*/
/*  This function returns a count of the number of zero       */
/*  crossings in an array x with npts values.                 */

int crossings(double x[],int npts)
{
   /*  Declare and initialize variables.  */
   int count=0, k;

   /*  Determine number of zero crossings.  */
   for (k=0; k<=npts-2; k++)
      if (x[k]*x[k+1] < 0)
         count++;

   /*  Return number of zero crossings.  */
   return count;
}
/*------------------------------------------------------------*/

// #include "stat_lib.c"
//
#include <math.h>

/*--------------------------------------------------------*/
/* This function returns the maximum value in an array x  */
/* with n elements.                                       */

double max( double x[], int n)
{
  /* Declare variables. */
  int k; double max_x;

  /* Determine maximum value in the array. */
  max_x = x[0];
  for( k=1; k<= n-1; k++)
    if( x[k] > max_x) max_x = x[k];

  /* Return maximum value. */
  return max_x;
}

/*--------------------------------------------------------*/
/* This function returns the minimum value in an array x  */
/* with n elements.                                       */

double min( double x[], int n)
{
  /* Declare variables. */
  int k; double min_x;

  /* Determine minimum value in the array. */
  min_x = x[0];
  for( k=1; k<=n-1; k++)
    if( x[k] < min_x) min_x = x[k];

  /* Return minimum value. */
  return min_x;
}

/*-------------------------------------------------------------*/
/* This function returns the average or mean value of an       */
/* array x with n elements.                                    */

double mean( double x[], int npts)
{
  /* Declare and initialize variables. */
  int k; double sum=0;

  /* Determine mean value. */
  for( k=0; k<=npts-1; k++)
    sum += x[k];

  /* Return mean value. */
  return sum/npts;
} 

/*-------------------------------------------------------------*/
/* This function returns the median value in the sorted        */
/* array x with npts elements.                                 */

double median( double x[], int npts)
{
  /* Declare variables. */
  int k; double median_x;

  /* Determine median value. */
  k = floor( npts/ 2);
  if( npts%2 != 0)
    median_x = x[k];
  else
    median_x = ( x[k-1] + x[k])/2;

  /* Return median value. */
  return median_x; }

/*-------------------------------------------------------------*/
/* This function returns the variance of an array x            */
/* with npts elements.                                         */

double variance( double x[], int npts)
{
  /* Declare variables and function prototypes. */
  int k; double sum= 0, mu;
  double mean( double x[], int npts);

  /* Determine variance. */
  mu = mean( x, npts);
  for( k=0; k<=npts-1; k++)
    sum += ( x[k] - mu)*( x[k] - mu);

  /* Return variance. */
  return sum/(npts-1);
}

/*-------------------------------------------------------------*/
/* This function returns the standard deviation of an array x  */
/* with npts elements.                                         */

double std_dev( double x[], int npts)
{
  /* Declare function prototypes. */
  double variance( double x[], int npts);

  /* Return standard deviation. */
  return sqrt( variance( x, npts));
}