median.c File Reference

Detailed Description

Computes statistical measures such as median, percentiles, average, and middle values.

This file contains functions to compute median, percentiles, averages, and the middle value of datasets. See also the find_XX() routines in rowmedian.c which return the position of the median and other statistics.

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, Y. Wang

Definition in file median.c.

#include "mdb.h"

Go to the source code of this file.

Functions
long	compute_median (double *value, double *x, long n)
	Computes the median of an array of doubles.
long	compute_percentile (double *value, double *x, long n, double percentile)
	Computes a specific percentile of an array of doubles.
long	compute_percentiles (double *position, double *percent, long positions, double *x, long n)
	Computes multiple percentiles of an array of doubles.
long	compute_percentiles_flagged (double *position, double *percent, long positions, double *x, int32_t *keep, int64_t n)
	Computes multiple percentiles of an array of doubles, considering only flagged elements.
long	compute_average (double *value, double *data, int64_t n)
	Computes the average of an array of doubles.
long	compute_middle (double *value, double *data, long n)
	Computes the middle value between the minimum and maximum of an array of doubles.
long	approximate_percentiles (double *position, double *percent, long positions, double *x, long n, long bins)
	Approximates multiple percentiles of an array of doubles using histogram bins.

Function Documentation

approximate_percentiles()

long approximate_percentiles	(	double *	position,
		double *	percent,
		long	positions,
		double *	x,
		long	n,
		long	bins )

Approximates multiple percentiles of an array of doubles using histogram bins.

Parameters

position	Pointer to the array to store the computed percentile positions.
percent	Pointer to the array of percentiles to compute (each value between 0-100).
positions	Number of percentiles to compute.
x	Pointer to the array of doubles.
n	Number of elements in the array.
bins	Number of histogram bins to use for approximation.

Returns

Returns 1 on success, 0 on failure.

Definition at line 187 of file median.c.

                                        {
  double *hist, *cdf, xMin, xMax, xCenter, xRange;
  long i, j, k;
  if (bins < 2 || positions <= 0 || n <= 0)
    return 0;
  if (!(hist = malloc(sizeof(*hist) * bins)))
    return 0;
  find_min_max(&xMin, &xMax, x, n);
  xCenter = (xMax + xMin) / 2;
  xRange = (xMax - xMin) * (1 + 1. / bins) / 2;
  xMin = xCenter - xRange;
  xMax = xCenter + xRange;
  make_histogram(hist, bins, xMin, xMax, x, n, 1);
 
  cdf = hist;
  for (i = 1; i < bins; i++)
    cdf[i] += cdf[i - 1];
  for (i = 0; i < bins; i++)
    cdf[i] /= cdf[bins - 1];
 
  for (j = 0; j < positions; j++) {
    for (i = k = 0; i < bins; i++) {
      if (cdf[i] < percent[j] / 100.0)
        k = i;
      else
        break;
    }
    position[j] = xMin + (k * (xMax - xMin)) / bins;
  }
  free(hist);
  return 1;
}

compute_average()

long compute_average	(	double *	value,
		double *	data,
		int64_t	n )

Computes the average of an array of doubles.

Parameters

value	Pointer to store the computed average value.
data	Pointer to the array of doubles.
n	Number of elements in the array.

Returns

Returns 1 on success, 0 on failure.

Definition at line 144 of file median.c.

                                                             {
  double sum;
  int64_t i;
 
  if (n <= 0)
    return 0;
 
  for (i = sum = 0; i < n; i++)
    sum += data[i];
  *value = sum / n;
  return 1;
}

compute_median()

long compute_median	(	double *	value,
		double *	x,
		long	n )

Computes the median of an array of doubles.

Parameters

value	Pointer to store the computed median value.
x	Pointer to the array of doubles.
n	Number of elements in the array.

Returns

Returns 1 on success, 0 on failure.

Definition at line 29 of file median.c.

                                                      {
  static double *data = NULL;
  static long last_n = 0;
  long i;
 
  if (n <= 0)
    return 0;
  if (n > last_n) {
    data = trealloc(data, sizeof(*data) * n);
    last_n = n;
  }
  for (i = 0; i < n; i++)
    data[i] = x[i];
  qsort((void *)data, n, sizeof(*data), double_cmpasc);
  *value = data[n / 2];
  return 1;
}

compute_middle()

long compute_middle	(	double *	value,
		double *	data,
		long	n )

Computes the middle value between the minimum and maximum of an array of doubles.

Parameters

value	Pointer to store the computed middle value.
data	Pointer to the array of doubles.
n	Number of elements in the array.

Returns

Returns 1 on success, 0 on failure.

Definition at line 165 of file median.c.

                                                         {
  double min, max;
  if (n <= 0)
    return 0;
 
  if (!find_min_max(&min, &max, data, n))
    return 0;
  *value = (min + max) / 2;
  return 1;
}

compute_percentile()

long compute_percentile	(	double *	value,
		double *	x,
		long	n,
		double	percentile )

Computes a specific percentile of an array of doubles.

Parameters

value	Pointer to store the computed percentile value.
x	Pointer to the array of doubles.
n	Number of elements in the array.
percentile	The desired percentile to compute (0-100).

Returns

Returns 1 on success, 0 on failure.

Definition at line 56 of file median.c.

                                                                             {
  static double *data = NULL;
  static long last_n = 0;
  long i;
 
  if (n <= 0 || percentile < 0 || percentile > 100)
    return 0;
  if (n > last_n) {
    data = trealloc(data, sizeof(*data) * n);
    last_n = n;
  }
  for (i = 0; i < n; i++)
    data[i] = x[i];
  qsort((void *)data, n, sizeof(*data), double_cmpasc);
  *value = data[(long)((n - 1) * (percentile / 100.0))];
  return 1;
}

compute_percentiles()

long compute_percentiles	(	double *	position,
		double *	percent,
		long	positions,
		double *	x,
		long	n )

Computes multiple percentiles of an array of doubles.

Parameters

position	Pointer to the array to store the computed percentile values.
percent	Pointer to the array of percentiles to compute (each value between 0-100).
positions	Number of percentiles to compute.
x	Pointer to the array of doubles.
n	Number of elements in the array.

Returns

Returns 1 on success, 0 on failure.

Definition at line 84 of file median.c.

                                                                                               {
  static double *data = NULL;
  static long last_n = 0;
  long ip;
 
  if (n <= 0 || positions <= 0)
    return 0;
  if (n > last_n) {
    data = trealloc(data, sizeof(*data) * n);
    last_n = n;
  }
  memcpy((char *)data, (char *)x, sizeof(*x) * n);
  qsort((void *)data, n, sizeof(*data), double_cmpasc);
  for (ip = 0; ip < positions; ip++)
    position[ip] = data[(long)((n - 1) * (percent[ip] / 100.0))];
  return 1;
}

compute_percentiles_flagged()

long compute_percentiles_flagged	(	double *	position,
		double *	percent,
		long	positions,
		double *	x,
		int32_t *	keep,
		int64_t	n )

Computes multiple percentiles of an array of doubles, considering only flagged elements.

Parameters

position	Pointer to the array to store the computed percentile values.
percent	Pointer to the array of percentiles to compute (each value between 0-100).
positions	Number of percentiles to compute.
x	Pointer to the array of doubles.
keep	Pointer to the array of flags indicating which elements to include.
n	Number of elements in the array.

Returns

Returns 1 on success, 0 on failure.

Definition at line 113 of file median.c.

                                                                                                                         {
  static double *data = NULL;
  static int64_t last_n = 0;
  int64_t ip, jp, count;
 
  if (n <= 0 || positions <= 0)
    return 0;
  for (ip=count=0; ip<n; ip++) 
    if (keep[ip])
      count++;
  if (count > last_n) {
    data = trealloc(data, sizeof(*data) * count);
    last_n = count;
  }
  for (ip=jp=0; ip<n; ip++)
    if (keep[ip])
      data[jp++] = x[ip];
  qsort((void *)data, count, sizeof(*data), double_cmpasc);
  for (ip = 0; ip < positions; ip++)
    position[ip] = data[(long)((count - 1) * (percent[ip] / 100.0))];
  return 1;
}