moments.c File Reference

Detailed Description

Computes statistical moments and related measures.

This file contains functions to compute various statistical measures such as standard deviation, moments, weighted moments, correlations, averages, RMS values, and more. It also includes threaded versions of these functions for parallel computation using OpenMP.

Copyright

• (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
• (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.

License

This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.

Author

M. Borland, C. Saunders, R. Soliday

Definition in file moments.c.

#include "mdb.h"

Go to the source code of this file.

Functions
void	omp_set_num_threads (int a)
double	standardDeviation (double *x, long n)
	Calculates the standard deviation of an array of doubles.
double	standardDeviationThreaded (double *x, long n, long numThreads)
	Calculates the standard deviation of an array of doubles using multiple threads.
long	computeMoments (double *mean, double *rms, double *standDev, double *meanAbsoluteDev, double *x, long n)
	Computes the mean, RMS, standard deviation, and mean absolute deviation of an array.
long	computeMomentsThreaded (double *mean, double *rms, double *standDev, double *meanAbsoluteDev, double *x, long n, long numThreads)
	Computes the mean, RMS, standard deviation, and mean absolute deviation of an array using multiple threads.
long	computeWeightedMoments (double *mean, double *rms, double *standDev, double *meanAbsoluteDev, double *x, double *w, long n)
	Computes weighted statistical moments of an array.
long	computeWeightedMomentsThreaded (double *mean, double *rms, double *standDev, double *meanAbsoluteDev, double *x, double *w, long n, long numThreads)
	Computes weighted statistical moments of an array using multiple threads.
long	accumulateMoments (double *mean, double *rms, double *standDev, double *x, long n, long reset)
long	accumulateMomentsThreaded (double *mean, double *rms, double *standDev, double *x, long n, long reset, long numThreads)
long	accumulateWeightedMoments (double *mean, double *rms, double *standDev, double *x, double *w, long n, long reset)
long	accumulateWeightedMomentsThreaded (double *mean, double *rms, double *standDev, double *x, double *w, long n, long reset, long numThreads)
long	computeCorrelations (double *C11, double *C12, double *C22, double *x, double *y, long n)
	Computes the correlations between two datasets.
long	computeCorrelationsThreaded (double *C11, double *C12, double *C22, double *x, double *y, long n, long numThreads)
	Computes the correlations between two datasets using multiple threads.
double	arithmeticAverage (double *y, long n)
	Calculates the arithmetic average of an array of doubles.
double	arithmeticAverageThreaded (double *y, long n, long numThreads)
	Calculates the arithmetic average of an array of doubles using multiple threads.
double	rmsValue (double *y, long n)
	Calculates the RMS (Root Mean Square) value of an array of doubles.
double	rmsValueThreaded (double *y, long n, long numThreads)
	Calculates the RMS (Root Mean Square) value of an array of doubles using multiple threads.
double	meanAbsoluteDeviation (double *y, long n)
	Calculates the mean absolute deviation of an array of doubles.
double	meanAbsoluteDeviationThreaded (double *y, long n, long numThreads)
	Calculates the mean absolute deviation of an array of doubles using multiple threads.
double	weightedAverage (double *y, double *w, long n)
	Calculates the weighted average of an array of doubles.
double	weightedAverageThreaded (double *y, double *w, long n, long numThreads)
	Calculates the weighted average of an array of doubles using multiple threads.
double	weightedRMS (double *y, double *w, long n)
	Calculates the weighted RMS (Root Mean Square) value of an array of doubles.
double	weightedRMSThreaded (double *y, double *w, long n, long numThreads)
	Calculates the weighted RMS (Root Mean Square) value of an array of doubles using multiple threads.
double	weightedMAD (double *y, double *w, long n)
	Calculates the weighted mean absolute deviation of an array of doubles.
double	weightedMADThreaded (double *y, double *w, long n, long numThreads)
	Calculates the weighted mean absolute deviation of an array of doubles using multiple threads.
double	weightedStDev (double *y, double *w, long n)
	Calculates the weighted standard deviation of an array of doubles.
double	weightedStDevThreaded (double *y, double *w, long n, long numThreads)
	Calculates the weighted standard deviation of an array of doubles using multiple threads.

Function Documentation

accumulateMoments()

long accumulateMoments	(	double *	mean,
		double *	rms,
		double *	standDev,
		double *	x,
		long	n,
		long	reset )

Definition at line 324 of file moments.c.

                                                      {
  return accumulateMomentsThreaded(mean, rms, standDev, x, n, reset, 1);
}

accumulateMomentsThreaded()

long accumulateMomentsThreaded	(	double *	mean,
		double *	rms,
		double *	standDev,
		double *	x,
		long	n,
		long	reset,
		long	numThreads )

Definition at line 329 of file moments.c.

                                                                               {
  long i;
  static MDB_THREAD_LOCAL double savedSum = 0, savedSumSqr = 0;
  static MDB_THREAD_LOCAL long savedNTotal;
  double sum = savedSum, sumSqr = savedSumSqr;
  long nTotal = savedNTotal;
 
  if (reset)
    nTotal = sum = sumSqr = 0;
 
  nTotal += n;
  if (nTotal < 1) {
    savedSum = sum;
    savedSumSqr = sumSqr;
    savedNTotal = nTotal;
    return (0);
  }
 
  omp_set_num_threads(numThreads);
#pragma omp parallel shared(sum, sumSqr)
  {
    double partial_sum = 0;
    double partial_sumSqr = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      double value = x[i];
      partial_sum += value;
      partial_sumSqr += sqr(value);
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1) {
        sum += partial_sum;
        sumSqr += partial_sumSqr;
      } else {
        sum = partial_sum;
        sumSqr = partial_sumSqr;
      }
    }
  }
 
  *mean = sum / nTotal;
  *rms = sqrt(sumSqr / nTotal);
  *standDev = sqrt((sumSqr / nTotal - sqr(*mean)) * nTotal / (nTotal - 1.0));
  savedSum = sum;
  savedSumSqr = sumSqr;
  savedNTotal = nTotal;
 
  return (1);
}

accumulateWeightedMoments()

long accumulateWeightedMoments	(	double *	mean,
		double *	rms,
		double *	standDev,
		double *	x,
		double *	w,
		long	n,
		long	reset )

Definition at line 382 of file moments.c.

                                                                         {
  return accumulateWeightedMomentsThreaded(mean, rms, standDev, x, w, n, reset, 1);
}

accumulateWeightedMomentsThreaded()

long accumulateWeightedMomentsThreaded	(	double *	mean,
		double *	rms,
		double *	standDev,
		double *	x,
		double *	w,
		long	n,
		long	reset,
		long	numThreads )

Definition at line 387 of file moments.c.

                                                                                                  {
  long i;
  static MDB_THREAD_LOCAL double savedSumW = 0, savedSumWx = 0, savedSumSqrWx = 0;
  static MDB_THREAD_LOCAL long savedNTotal;
  double sumW = savedSumW, sumWx = savedSumWx, sumSqrWx = savedSumSqrWx;
  long nTotal = savedNTotal;
 
  if (reset)
    sumW = sumWx = sumSqrWx = nTotal = 0;
 
  nTotal += n;
  if (nTotal < 1) {
    savedSumW = sumW;
    savedSumWx = sumWx;
    savedSumSqrWx = sumSqrWx;
    savedNTotal = nTotal;
    return (0);
  }
 
  omp_set_num_threads(numThreads);
#pragma omp parallel shared(sumW, sumWx, sumSqrWx)
  {
    double partial_sumW = 0;
    double partial_sumWx = 0;
    double partial_sumSqrWx = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      partial_sumW += w[i];
      partial_sumWx += w[i] * x[i];
      partial_sumSqrWx += x[i] * x[i] * w[i];
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1) {
        sumW += partial_sumW;
        sumWx += partial_sumWx;
        sumSqrWx += partial_sumSqrWx;
      } else {
        sumW = partial_sumW;
        sumWx = partial_sumWx;
        sumSqrWx = partial_sumSqrWx;
      }
    }
  }
  if (sumW) {
    *mean = sumWx / sumW;
    *rms = sqrt(sumSqrWx / sumW);
    *standDev = sqrt((sumSqrWx / sumW - sqr(*mean)) * (nTotal / (nTotal - 1.0)));
    savedSumW = sumW;
    savedSumWx = sumWx;
    savedSumSqrWx = sumSqrWx;
    savedNTotal = nTotal;
    return (1);
  }
  savedSumW = sumW;
  savedSumWx = sumWx;
  savedSumSqrWx = sumSqrWx;
  savedNTotal = nTotal;
  return (0);
}

arithmeticAverage()

double arithmeticAverage	(	double *	y,
		long	n )

Calculates the arithmetic average of an array of doubles.

This function computes the arithmetic average of the given array by invoking the threaded version with a single thread.

Parameters

y	Pointer to the array of doubles.
n	Number of elements in the array.

Returns

Returns the arithmetic average as a double.

Definition at line 560 of file moments.c.

                                            {
  return arithmeticAverageThreaded(y, n, 1);
}

arithmeticAverageThreaded()

double arithmeticAverageThreaded	(	double *	y,
		long	n,
		long	numThreads )

Calculates the arithmetic average of an array of doubles using multiple threads.

This function computes the arithmetic average of the given array using the specified number of threads.

Parameters

y	Pointer to the array of doubles.
n	Number of elements in the array.
numThreads	Number of threads to use for computation.

Returns

Returns the arithmetic average as a double.

Definition at line 574 of file moments.c.

                                                                     {
  long i;
  double sum = 0;
 
  if (!n)
    return (0.0);
  omp_set_num_threads(numThreads);
#pragma omp parallel shared(sum)
  {
    double partial_sum = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      partial_sum += y[i];
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1)
        sum += partial_sum;
      else
        sum = partial_sum;
    }
  }
  return (sum / n);
}

computeCorrelations()

long computeCorrelations	(	double *	C11,
		double *	C12,
		double *	C22,
		double *	x,
		double *	y,
		long	n )

Computes the correlations between two datasets.

This function calculates the correlation coefficients C11, C12, and C22 between two arrays of doubles by invoking the threaded version with a single thread.

Parameters

C11	Pointer to store the computed C11 correlation coefficient.
C12	Pointer to store the computed C12 correlation coefficient.
C22	Pointer to store the computed C22 correlation coefficient.
x	Pointer to the first array of doubles.
y	Pointer to the second array of doubles.
n	Number of elements in each array.

Returns

Returns 1 on success, 0 on failure.

Definition at line 464 of file moments.c.

                                                                                              {
  return computeCorrelationsThreaded(C11, C12, C22, x, y, n, 1);
}

computeCorrelationsThreaded()

long computeCorrelationsThreaded	(	double *	C11,
		double *	C12,
		double *	C22,
		double *	x,
		double *	y,
		long	n,
		long	numThreads )

Computes the correlations between two datasets using multiple threads.

This function calculates the correlation coefficients C11, C12, and C22 between two arrays of doubles using the specified number of threads.

Parameters

C11	Pointer to store the computed C11 correlation coefficient.
C12	Pointer to store the computed C12 correlation coefficient.
C22	Pointer to store the computed C22 correlation coefficient.
x	Pointer to the first array of doubles.
y	Pointer to the second array of doubles.
n	Number of elements in each array.
numThreads	Number of threads to use for computation.

Returns

Returns 1 on success, 0 on failure.

Definition at line 483 of file moments.c.

                                                                                                                       {
  long i;
  double xAve = 0, yAve = 0;
 
  *C11 = *C12 = *C22 = 0;
  if (!n)
    return (0);
 
  omp_set_num_threads(numThreads);
#pragma omp parallel shared(xAve, yAve)
  {
    double partial_xAve = 0;
    double partial_yAve = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      partial_xAve += x[i];
      partial_yAve += y[i];
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1) {
        xAve += partial_xAve;
        yAve += partial_yAve;
      } else {
        xAve = partial_xAve;
        yAve = partial_yAve;
      }
    }
  }
  xAve /= n;
  yAve /= n;
 
#pragma omp parallel shared(C11, C12, C22)
  {
    double partial_C11 = 0;
    double partial_C12 = 0;
    double partial_C22 = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      double dx = x[i] - xAve;
      double dy = y[i] - yAve;
      partial_C11 += dx * dx;
      partial_C12 += dx * dy;
      partial_C22 += dy * dy;
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1) {
        *C11 += partial_C11;
        *C12 += partial_C12;
        *C22 += partial_C22;
      } else {
        *C11 = partial_C11;
        *C12 = partial_C12;
        *C22 = partial_C22;
      }
    }
  }
  *C11 /= n;
  *C12 /= n;
  *C22 /= n;
 
  return (1);
}

computeMoments()

long computeMoments	(	double *	mean,
		double *	rms,
		double *	standDev,
		double *	meanAbsoluteDev,
		double *	x,
		long	n )

Computes the mean, RMS, standard deviation, and mean absolute deviation of an array.

This function calculates multiple statistical moments of the provided data array by invoking the threaded version with a single thread.

Parameters

mean	Pointer to store the computed mean value.
rms	Pointer to store the computed RMS value.
standDev	Pointer to store the computed standard deviation.
meanAbsoluteDev	Pointer to store the computed mean absolute deviation.
x	Pointer to the array of doubles.
n	Number of elements in the array.

Returns

Returns the number of degrees of freedom (n - 1) on success, 0 on failure.

Definition at line 108 of file moments.c.

                                                                {
  return computeMomentsThreaded(mean, rms, standDev, meanAbsoluteDev, x, n, 1);
}

computeMomentsThreaded()

long computeMomentsThreaded	(	double *	mean,
		double *	rms,
		double *	standDev,
		double *	meanAbsoluteDev,
		double *	x,
		long	n,
		long	numThreads )

Computes the mean, RMS, standard deviation, and mean absolute deviation of an array using multiple threads.

This function calculates multiple statistical moments of the provided data array using the specified number of threads.

Parameters

mean	Pointer to store the computed mean value.
rms	Pointer to store the computed RMS value.
standDev	Pointer to store the computed standard deviation.
meanAbsoluteDev	Pointer to store the computed mean absolute deviation.
x	Pointer to the array of doubles.
n	Number of elements in the array.
numThreads	Number of threads to use for computation.

Returns

Returns the number of degrees of freedom (n - 1) on success, 0 on failure.

Definition at line 127 of file moments.c.

                                                                                         {
  long i;
  double sum = 0, sumSqr = 0, sum2 = 0;
  double lMean, lRms, lStDev, lMAD;
 
  if (!mean)
    mean = &lMean;
  if (!rms)
    rms = &lRms;
  if (!standDev)
    standDev = &lStDev;
  if (!meanAbsoluteDev)
    meanAbsoluteDev = &lMAD;
 
  *mean = *standDev = *meanAbsoluteDev = DBL_MAX;
 
  if (n < 1)
    return (0);
 
  omp_set_num_threads(numThreads);
 
#pragma omp parallel shared(sumSqr, sum)
  {
    double partial_sumSqr = 0;
    double partial_sum = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      double value = x[i];
      partial_sum += value;
      partial_sumSqr += sqr(value);
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1) {
        sum += partial_sum;
        sumSqr += partial_sumSqr;
      } else {
        sum = partial_sum;
        sumSqr = partial_sumSqr;
      }
    }
  }
  *mean = sum / n;
  *rms = sqrt(sumSqr / n);
 
  sum = 0;
#pragma omp parallel shared(sum, sum2)
  {
    double partial_sum = 0;
    double partial_sum2 = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      double value = x[i] - *mean;
      partial_sum2 += value * value;
      partial_sum += fabs(value);
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1) {
        sum2 += partial_sum2;
        sum += partial_sum;
      } else {
        sum2 = partial_sum2;
        sum = partial_sum;
      }
    }
  }
  if (n)
    *standDev = sqrt(sum2 / (n - 1));
  *meanAbsoluteDev = sum / n;
 
  return (n - 1);
}

computeWeightedMoments()

long computeWeightedMoments	(	double *	mean,
		double *	rms,
		double *	standDev,
		double *	meanAbsoluteDev,
		double *	x,
		double *	w,
		long	n )

Computes weighted statistical moments of an array.

This function calculates the weighted mean, RMS, standard deviation, and mean absolute deviation of the provided data array by invoking the threaded version with a single thread.

Parameters

mean	Pointer to store the computed weighted mean value.
rms	Pointer to store the computed weighted RMS value.
standDev	Pointer to store the computed weighted standard deviation.
meanAbsoluteDev	Pointer to store the computed weighted mean absolute deviation.
x	Pointer to the array of doubles.
w	Pointer to the array of weights corresponding to each data point.
n	Number of elements in the array.

Returns

Returns 1 on success, 0 on failure.

Definition at line 219 of file moments.c.

                                                                                   {
  return computeWeightedMomentsThreaded(mean, rms, standDev, meanAbsoluteDev, x, w, n, 1);
}

computeWeightedMomentsThreaded()

long computeWeightedMomentsThreaded	(	double *	mean,
		double *	rms,
		double *	standDev,
		double *	meanAbsoluteDev,
		double *	x,
		double *	w,
		long	n,
		long	numThreads )

Computes weighted statistical moments of an array using multiple threads.

This function calculates the weighted mean, RMS, standard deviation, and mean absolute deviation of the provided data array using the specified number of threads.

Parameters

mean	Pointer to store the computed weighted mean value.
rms	Pointer to store the computed weighted RMS value.
standDev	Pointer to store the computed weighted standard deviation.
meanAbsoluteDev	Pointer to store the computed weighted mean absolute deviation.
x	Pointer to the array of doubles.
w	Pointer to the array of weights corresponding to each data point.
n	Number of elements in the array.
numThreads	Number of threads to use for computation.

Returns

Returns 1 on success, 0 on failure.

Definition at line 240 of file moments.c.

                                                                                                            {
  long i;
  double sumW = 0, sum = 0, sumWx = 0, sumSqrWx = 0, sum2 = 0;
 
  double lMean, lRms, lStDev, lMAD;
 
  if (!mean)
    mean = &lMean;
  if (!rms)
    rms = &lRms;
  if (!standDev)
    standDev = &lStDev;
  if (!meanAbsoluteDev)
    meanAbsoluteDev = &lMAD;
 
  *mean = *standDev = *meanAbsoluteDev = DBL_MAX;
 
  if (n < 1)
    return (0);
 
  omp_set_num_threads(numThreads);
 
#pragma omp parallel shared(sumW, sumWx, sumSqrWx)
  {
    double partial_sumW = 0;
    double partial_sumWx = 0;
    double partial_sumSqrWx = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      partial_sumW += w[i];
      double value = x[i];
      partial_sumWx += value * w[i];
      partial_sumSqrWx += value * value * w[i];
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1) {
        sumW += partial_sumW;
        sumWx += partial_sumWx;
        sumSqrWx += partial_sumSqrWx;
      } else {
        sumW = partial_sumW;
        sumWx = partial_sumWx;
        sumSqrWx = partial_sumSqrWx;
      }
    }
  }
 
  if (sumW) {
    *mean = sumWx / sumW;
    *rms = sqrt(sumSqrWx / sumW);
#pragma omp parallel shared(sum, sum2)
    {
      double partial_sum = 0;
      double partial_sum2 = 0;
#pragma omp for
      for (i = 0; i < n; i++) {
        double value = x[i] - *mean;
        partial_sum += value * w[i];
        partial_sum2 += value * value * w[i];
      }
#pragma omp critical
      {
        /* Found this is necessary to avoid variation of results in cases that should be identical */
        if (numThreads > 1) {
          sum += partial_sum;
          sum2 += partial_sum2;
        } else {
          sum = partial_sum;
          sum2 = partial_sum2;
        }
      }
    }
    if (n)
      /* adjust for n-1 weighting */
      *standDev = sqrt((sum2 * n) / (sumW * (n - 1.0)));
    *meanAbsoluteDev = sum / sumW;
    return (1);
  }
  return (0);
}

meanAbsoluteDeviation()

double meanAbsoluteDeviation	(	double *	y,
		long	n )

Calculates the mean absolute deviation of an array of doubles.

This function computes the mean absolute deviation of the given array by invoking the threaded version with a single thread.

Parameters

y	Pointer to the array of doubles.
n	Number of elements in the array.

Returns

Returns the mean absolute deviation as a double.

Definition at line 660 of file moments.c.

                                                {
  return meanAbsoluteDeviationThreaded(y, n, 1);
}

meanAbsoluteDeviationThreaded()

double meanAbsoluteDeviationThreaded	(	double *	y,
		long	n,
		long	numThreads )

Calculates the mean absolute deviation of an array of doubles using multiple threads.

This function computes the mean absolute deviation of the given array using the specified number of threads.

Parameters

y	Pointer to the array of doubles.
n	Number of elements in the array.
numThreads	Number of threads to use for computation.

Returns

Returns the mean absolute deviation as a double.

Definition at line 674 of file moments.c.

                                                                         {
  long i;
  double ave = 0, sum = 0;
 
  if (!n)
    return (0.0);
  omp_set_num_threads(numThreads);
#pragma omp parallel shared(ave)
  {
    double partial_ave = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      partial_ave += y[i];
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1)
        ave += partial_ave;
      else
        ave = partial_ave;
    }
  }
  ave /= n;
#pragma omp parallel shared(sum)
  {
    double partial_sum = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      partial_sum += fabs(y[i] - ave);
    }
#pragma omp critical
    {
      if (numThreads > 1)
        sum += partial_sum;
      else
        sum = partial_sum;
    }
  }
  return (sum / n);
}

omp_set_num_threads()

void omp_set_num_threads

(

int

a

)

Definition at line 24 of file moments.c.

{}

rmsValue()

double rmsValue	(	double *	y,
		long	n )

Calculates the RMS (Root Mean Square) value of an array of doubles.

This function computes the RMS value of the given array by invoking the threaded version with a single thread.

Parameters

y	Pointer to the array of doubles.
n	Number of elements in the array.

Returns

Returns the RMS value as a double.

Definition at line 610 of file moments.c.

                                   {
  return rmsValueThreaded(y, n, 1);
}

rmsValueThreaded()

double rmsValueThreaded	(	double *	y,
		long	n,
		long	numThreads )

Calculates the RMS (Root Mean Square) value of an array of doubles using multiple threads.

This function computes the RMS value of the given array using the specified number of threads.

Parameters

y	Pointer to the array of doubles.
n	Number of elements in the array.
numThreads	Number of threads to use for computation.

Returns

Returns the RMS value as a double.

Definition at line 624 of file moments.c.

                                                            {
  long i;
  double sum = 0;
 
  if (!n)
    return (0.0);
  omp_set_num_threads(numThreads);
#pragma omp parallel shared(sum)
  {
    double partial_sum = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      partial_sum += y[i] * y[i];
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1)
        sum += partial_sum;
      else
        sum = partial_sum;
    }
  }
  return (sqrt(sum / n));
}

standardDeviation()

double standardDeviation	(	double *	x,
		long	n )

Calculates the standard deviation of an array of doubles.

This function computes the standard deviation of the given array by invoking the threaded version with a single thread.

Parameters

x	Pointer to the array of doubles.
n	Number of elements in the array.

Returns

Returns the standard deviation as a double.

Definition at line 37 of file moments.c.

                                            {
  return standardDeviationThreaded(x, n, 1);
}

standardDeviationThreaded()

double standardDeviationThreaded	(	double *	x,
		long	n,
		long	numThreads )

Calculates the standard deviation of an array of doubles using multiple threads.

This function computes the standard deviation of the given array using the specified number of threads.

Parameters

x	Pointer to the array of doubles.
n	Number of elements in the array.
numThreads	Number of threads to use for computation.

Returns

Returns the standard deviation as a double.

Definition at line 51 of file moments.c.

                                                                     {
  long i;
  double sum = 0, sumSqr = 0, mean;
  if (n < 1)
    return (0.0);
  omp_set_num_threads(numThreads);
#pragma omp parallel shared(sum)
  {
    double partial_sum = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      partial_sum += x[i];
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1)
        sum += partial_sum;
      else
        sum = partial_sum;
    }
  }
  mean = sum / n;
#pragma omp parallel shared(sumSqr)
  {
    double partial_sumSqr = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      double value = x[i] - mean;
      partial_sumSqr += value * value;
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1)
        sumSqr += partial_sumSqr;
      else
        sumSqr = partial_sumSqr;
    }
  }
  return sqrt(sumSqr / (n - 1));
}

weightedAverage()

double weightedAverage	(	double *	y,
		double *	w,
		long	n )

Calculates the weighted average of an array of doubles.

This function computes the weighted average of the given array by invoking the threaded version with a single thread.

Parameters

y	Pointer to the array of doubles.
w	Pointer to the array of weights corresponding to each data point.
n	Number of elements in the array.

Returns

Returns the weighted average as a double.

Definition at line 727 of file moments.c.

                                                     {
  return weightedAverageThreaded(y, w, n, 1);
}

weightedAverageThreaded()

double weightedAverageThreaded	(	double *	y,
		double *	w,
		long	n,
		long	numThreads )

Calculates the weighted average of an array of doubles using multiple threads.

This function computes the weighted average of the given array using the specified number of threads.

Parameters

y	Pointer to the array of doubles.
w	Pointer to the array of weights corresponding to each data point.
n	Number of elements in the array.
numThreads	Number of threads to use for computation.

Returns

Returns the weighted average as a double.

Definition at line 742 of file moments.c.

                                                                              {
  long i;
  double ySum = 0, wSum = 0;
 
  if (!n)
    return 0.0;
  omp_set_num_threads(numThreads);
#pragma omp parallel shared(wSum, ySum)
  {
    double partial_wSum = 0;
    double partial_ySum = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      partial_wSum += w[i];
      partial_ySum += y[i] * w[i];
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1) {
        wSum += partial_wSum;
        ySum += partial_ySum;
      } else {
        wSum = partial_wSum;
        ySum = partial_ySum;
      }
    }
  }
  if (wSum)
    return ySum / wSum;
  return 0.0;
}

weightedMAD()

double weightedMAD	(	double *	y,
		double *	w,
		long	n )

Calculates the weighted mean absolute deviation of an array of doubles.

This function computes the weighted mean absolute deviation of the given array by invoking the threaded version with a single thread.

Parameters

y	Pointer to the array of doubles.
w	Pointer to the array of weights corresponding to each data point.
n	Number of elements in the array.

Returns

Returns the weighted mean absolute deviation as a double.

Definition at line 845 of file moments.c.

                                                 {
  return weightedMADThreaded(y, w, n, 1);
}

weightedMADThreaded()

double weightedMADThreaded	(	double *	y,
		double *	w,
		long	n,
		long	numThreads )

Calculates the weighted mean absolute deviation of an array of doubles using multiple threads.

This function computes the weighted mean absolute deviation of the given array using the specified number of threads.

Parameters

y	Pointer to the array of doubles.
w	Pointer to the array of weights corresponding to each data point.
n	Number of elements in the array.
numThreads	Number of threads to use for computation.

Returns

Returns the weighted mean absolute deviation as a double.

Definition at line 860 of file moments.c.

                                                                          {
  long i;
  double mean, sum = 0, wSum = 0;
 
  if (!n)
    return (0.0);
  omp_set_num_threads(numThreads);
#pragma omp parallel shared(sum, wSum)
  {
    double partial_sum = 0;
    double partial_wSum = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      partial_sum += y[i] * w[i];
      partial_wSum += w[i];
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1) {
        sum += partial_sum;
        wSum += partial_wSum;
      } else {
        sum = partial_sum;
        wSum = partial_wSum;
      }
    }
  }
  if (!wSum)
    return 0.0;
  mean = sum / wSum;
  sum = 0;
#pragma omp parallel shared(sum)
  {
    double partial_sum = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      partial_sum += fabs(y[i] - mean) * w[i];
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1)
        sum += partial_sum;
      else
        sum = partial_sum;
    }
  }
  return sum / wSum;
}

weightedRMS()

double weightedRMS	(	double *	y,
		double *	w,
		long	n )

Calculates the weighted RMS (Root Mean Square) value of an array of doubles.

This function computes the weighted RMS value of the given array by invoking the threaded version with a single thread.

Parameters

y	Pointer to the array of doubles.
w	Pointer to the array of weights corresponding to each data point.
n	Number of elements in the array.

Returns

Returns the weighted RMS value as a double.

Definition at line 786 of file moments.c.

                                                 {
  return weightedRMSThreaded(y, w, n, 1);
}

weightedRMSThreaded()

double weightedRMSThreaded	(	double *	y,
		double *	w,
		long	n,
		long	numThreads )

Calculates the weighted RMS (Root Mean Square) value of an array of doubles using multiple threads.

This function computes the weighted RMS value of the given array using the specified number of threads.

Parameters

y	Pointer to the array of doubles.
w	Pointer to the array of weights corresponding to each data point.
n	Number of elements in the array.
numThreads	Number of threads to use for computation.

Returns

Returns the weighted RMS value as a double.

Definition at line 801 of file moments.c.

                                                                          {
  long i;
  double sum = 0, wSum = 0;
 
  if (!n)
    return (0.0);
  omp_set_num_threads(numThreads);
#pragma omp parallel shared(sum, wSum)
  {
    double partial_sum = 0;
    double partial_wSum = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      partial_sum += y[i] * y[i] * w[i];
      partial_wSum += w[i];
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1) {
        sum += partial_sum;
        wSum += partial_wSum;
      } else {
        sum = partial_sum;
        wSum = partial_wSum;
      }
    }
  }
  if (wSum)
    return sqrt(sum / wSum);
  return 0.0;
}

weightedStDev()

double weightedStDev	(	double *	y,
		double *	w,
		long	n )

Calculates the weighted standard deviation of an array of doubles.

This function computes the weighted standard deviation of the given array by invoking the threaded version with a single thread.

Parameters

y	Pointer to the array of doubles.
w	Pointer to the array of weights corresponding to each data point.
n	Number of elements in the array.

Returns

Returns the weighted standard deviation as a double.

Definition at line 922 of file moments.c.

                                                   {
  return weightedStDevThreaded(y, w, n, 1);
}

weightedStDevThreaded()

double weightedStDevThreaded	(	double *	y,
		double *	w,
		long	n,
		long	numThreads )

Calculates the weighted standard deviation of an array of doubles using multiple threads.

This function computes the weighted standard deviation of the given array using the specified number of threads.

Parameters

y	Pointer to the array of doubles.
w	Pointer to the array of weights corresponding to each data point.
n	Number of elements in the array.
numThreads	Number of threads to use for computation.

Returns

Returns the weighted standard deviation as a double.

Definition at line 937 of file moments.c.

                                                                            {
  long i;
  double mean, sum = 0, wSum = 0;
 
  if (!n)
    return (0.0);
  omp_set_num_threads(numThreads);
#pragma omp parallel shared(sum, wSum)
  {
    double partial_sum = 0;
    double partial_wSum = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      partial_sum += y[i] * w[i];
      partial_wSum += w[i];
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1) {
        sum += partial_sum;
        wSum += partial_wSum;
      } else {
        sum = partial_sum;
        wSum = partial_wSum;
      }
    }
  }
  if (!wSum)
    return 0.0;
  mean = sum / wSum;
  sum = 0;
#pragma omp parallel shared(sum)
  {
    double partial_sum = 0;
#pragma omp for
    for (i = 0; i < n; i++) {
      double value = y[i] - mean;
      partial_sum += value * value * w[i];
    }
#pragma omp critical
    {
      /* Found this is necessary to avoid variation of results in cases that should be identical */
      if (numThreads > 1)
        sum += partial_sum;
      else
        sum = partial_sum;
    }
  }
  return sqrt((sum * n) / (wSum * (n - 1.0)));
}