void NUMmad (double *x, long n, double *location, int wantlocation, double *mad, double *work) {
double *tmp = work;
*mad = NUMundefined;
if (n < 1) {
Melder_throw (U"The dimension must be at least 1");
}
if (n == 1) {
*location = x[1];
return;
}
autoNUMvector<double> atmp;
if (work == 0) {
atmp.reset (1, n);
tmp = atmp.peek();
}
for (long i = 1; i <= n; i++) {
tmp[i] = x[i];
}
if (wantlocation) {
NUMsort_d (n, tmp);
*location = NUMquantile (n, tmp, 0.5);
}
for (long i = 1; i <= n; i++) {
tmp[i] = fabs (tmp[i] - *location);
}
NUMsort_d (n, tmp);
*mad = 1.4826 * NUMquantile (n, tmp, 0.5);
}
void Graphics_quantileQuantilePlot (Graphics g, long numberOfQuantiles, double xdata[], long xnumberOfData, double ydata[], long ynumberOfData, double xmin, double xmax, double ymin, double ymax, int labelSize, const wchar_t *plotLabel) {
int fontSize = Graphics_inqFontSize (g);
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
Graphics_setFontSize (g, labelSize);
autoNUMvector<double> xsorted (NUMvector_copy<double> (xdata, 1, xnumberOfData), 1);
autoNUMvector<double> ysorted (NUMvector_copy<double> (ydata, 1, ynumberOfData), 1);
NUMsort_d (xnumberOfData, xsorted.peek());
NUMsort_d (ynumberOfData, ysorted.peek());
long numberOfData = xnumberOfData < ynumberOfData ? xnumberOfData : ynumberOfData;
numberOfQuantiles = numberOfData < numberOfQuantiles ? numberOfData : numberOfQuantiles;
double un = pow (0.5, 1.0 / numberOfQuantiles);
double u1 = 1 - un;
if (xmin == xmax) {
xmin = NUMquantile (xnumberOfData, xsorted.peek(), u1);
xmax = NUMquantile (xnumberOfData, xsorted.peek(), un);
}
if (ymin == ymax) {
ymin = NUMquantile (ynumberOfData, ysorted.peek(), u1);
ymax = NUMquantile (ynumberOfData, ysorted.peek(), un);
}
for (long i = 1; i <= numberOfQuantiles; i++) {
double ui = i == 1 ? u1 : (i == numberOfQuantiles ? un : (i - 0.3175) / (numberOfQuantiles + 0.365));
double qx = NUMquantile (xnumberOfData, xsorted.peek(), ui);
double qy = NUMquantile (ynumberOfData, ysorted.peek(), ui);
if (qx < xmin || qx > xmax || qy < ymin || qy > ymax) continue; // outside area
Graphics_text (g, qx, qy, plotLabel);
}
Graphics_setLineType (g, Graphics_DOTTED);
Graphics_line (g, xmin, ymin, xmax, ymax);
Graphics_setLineType (g, Graphics_DRAWN);
Graphics_setFontSize (g, fontSize);
}
double * Sampled_getSortedValues (Sampled me, long ilevel, int unit, long *return_numberOfValues) {
long isamp, numberOfDefinedSamples = 0;
autoNUMvector <double> values (1, my nx);
for (isamp = 1; isamp <= my nx; isamp ++) {
double value = my v_getValueAtSample (isamp, ilevel, unit);
if (value == NUMundefined) continue;
values [++ numberOfDefinedSamples] = value;
}
if (numberOfDefinedSamples) NUMsort_d (numberOfDefinedSamples, values.peek());
if (return_numberOfValues) *return_numberOfValues = numberOfDefinedSamples;
return values.transfer();
}
autoPointProcess PointProcess_createPoissonProcess (double startingTime, double finishingTime, double density) {
try {
long nt = NUMrandomPoisson ((finishingTime - startingTime) * density);
autoPointProcess me = PointProcess_create (startingTime, finishingTime, nt);
my nt = nt;
for (long i = 1; i <= nt; i ++)
my t [i] = NUMrandomUniform (startingTime, finishingTime);
NUMsort_d (my nt, my t);
return me;
} catch (MelderError) {
Melder_throw (U"PointProcess (Poisson process) not created.");
}
}
double * Sampled_getSortedValues (I, long ilevel, int unit, long *return_numberOfValues) {
iam (Sampled);
long isamp, numberOfDefinedSamples = 0;
double *values = NUMdvector (1, my nx);
if (values == NULL) return NULL;
for (isamp = 1; isamp <= my nx; isamp ++) {
double value = our getValueAtSample (me, isamp, ilevel, unit);
if (value == NUMundefined) continue;
values [++ numberOfDefinedSamples] = value;
}
if (numberOfDefinedSamples) NUMsort_d (numberOfDefinedSamples, values);
if (return_numberOfValues) *return_numberOfValues = numberOfDefinedSamples;
return values;
}
double Sampled_getQuantile (I, double xmin, double xmax, double quantile, long ilevel, int unit) {
iam (Sampled);
long i, imin, imax, numberOfDefinedSamples = 0;
double *values = NUMdvector (1, my nx), result = NUMundefined;
iferror return NUMundefined;
Function_unidirectionalAutowindow (me, & xmin, & xmax);
if (! Function_intersectRangeWithDomain (me, & xmin, & xmax)) return NUMundefined;
Sampled_getWindowSamples (me, xmin, xmax, & imin, & imax);
for (i = imin; i <= imax; i ++) {
double value = our getValueAtSample (me, i, ilevel, unit);
if (NUMdefined (value)) {
values [++ numberOfDefinedSamples] = value;
}
}
if (numberOfDefinedSamples >= 1) {
NUMsort_d (numberOfDefinedSamples, values);
result = NUMquantile (numberOfDefinedSamples, values, quantile);
}
NUMdvector_free (values, 1);
return result;
}
double Sampled_getQuantile (Sampled me, double xmin, double xmax, double quantile, long ilevel, int unit) {
try {
autoNUMvector <double> values (1, my nx);
Function_unidirectionalAutowindow (me, & xmin, & xmax);
if (! Function_intersectRangeWithDomain (me, & xmin, & xmax)) return NUMundefined;
long imin, imax, numberOfDefinedSamples = 0;
Sampled_getWindowSamples (me, xmin, xmax, & imin, & imax);
for (long i = imin; i <= imax; i ++) {
double value = my v_getValueAtSample (i, ilevel, unit);
if (NUMdefined (value)) {
values [++ numberOfDefinedSamples] = value;
}
}
double result = NUMundefined;
if (numberOfDefinedSamples >= 1) {
NUMsort_d (numberOfDefinedSamples, values.peek());
result = NUMquantile (numberOfDefinedSamples, values.peek(), quantile);
}
return result;
} catch (MelderError) {
Melder_throw (me, ": quantile not computed.");
}
}
void Graphics_boxAndWhiskerPlot (Graphics g, double data[], long ndata, double x, double r, double w, double ymin, double ymax) {
int lineType = Graphics_inqLineType (g);
Melder_assert (r > 0 && w > 0);
if (ndata < 3) {
return;
}
/*
Sort the data (ascending: data[1] <= ... <= data[ndata]).
Get the median (q50) and the upper and lower quartile points
(q25 and q75).
Now q25 and q75 are the lower and upper hinges, respectively.
The fances can be calcultaed from q25 and q75.
The spread is defined as the interquartile range or midrange
|q75 - q25|.
The fences are defined as:
(lower/upper) innerfence = (lower/upper) hinge +/- 1.5 hspread
(lower/upper) outerfence = (lower/upper) hinge +/- 3.0 hspread
*/
NUMsort_d (ndata, data);
if (ymax <= ymin) {
ymin = data[1]; ymax = data[ndata];
}
if (data[1] > ymax || data[ndata] < ymin) {
return;
}
double mean = 0;
for (long i = 1; i <= ndata; i++) {
mean += data[i];
}
mean /= ndata;
double q25 = NUMquantile (ndata, data, 0.25);
double q50 = NUMquantile (ndata, data, 0.5);
double q75 = NUMquantile (ndata, data, 0.75);
double hspread = fabs (q75 - q25);
double lowerOuterFence = q25 - 3.0 * hspread;
double lowerInnerFence = q25 - 1.5 * hspread;
double upperInnerFence = q75 + 1.5 * hspread;
double upperOuterFence = q75 + 3.0 * hspread;
/*
Decide whether there are outliers that have to be drawn.
First process data from below (data are sorted).
*/
long i = 1, ie = ndata;
while (i <= ie && data[i] < ymin) {
i++;
}
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
while (i <= ie && data[i] < lowerOuterFence) {
Graphics_text (g, x, data[i], L"o"); i++;
}
while (i <= ie && data[i] < lowerInnerFence) {
Graphics_text (g, x, data[i], L"*"); i++;
}
double lowerWhisker = data[i] < q25 ? data[i] : lowerInnerFence;
if (lowerWhisker > ymax) {
return;
}
// Next process data from above.
i = ndata; ie = i;
while (i >= ie && data[i] > ymax) {
i--;
}
while (i >= ie && data[i] > upperOuterFence) {
Graphics_text (g, x, data[i], L"o"); i--;
}
while (i >= ie && data[i] > upperInnerFence) {
Graphics_text (g, x, data[i], L"*"); i--;
}
double upperWhisker = data[i] > q75 ? data[i] : upperInnerFence;
if (upperWhisker < ymin) {
return;
}
/*
Determine what parts of the "box" have to be drawn within the
range [ymin, ymax].
Horizontal lines first.
*/
double y1 = lowerWhisker;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - r, y1, x + r, y1);
}
y1 = q25;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - w, y1, x + w, y1);
}
y1 = q50;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - w, y1, x + w, y1);
}
y1 = q75;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - w, y1, x + w, y1);
}
y1 = upperWhisker;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - r, y1, x + r, y1);
}
// Extension: draw the mean too.
y1 = mean;
if (ymax > y1 && ymin < y1) {
Graphics_setLineType (g, Graphics_DOTTED);
Graphics_line (g, x - w, y1, x + w, y1);
Graphics_setLineType (g, lineType);
}
// Now process the vertical lines.
y1 = lowerWhisker;
double y2 = q25;
if (ymax > y1 && ymin < y2) {
y1 = y1 > ymin ? y1 : ymin;
y2 = y2 < ymax ? y2 : ymax;
Graphics_line (g, x, y1, x, y2);
}
y1 = q25; y2 = q75;
if (ymax > y1 && ymin < y2) {
y1 = y1 > ymin ? y1 : ymin;
y2 = y2 < ymax ? y2 : ymax;
Graphics_line (g, x - w, y1, x - w, y2);
Graphics_line (g, x + w, y1, x + w, y2);
}
y1 = q75; y2 = upperWhisker;
if (ymax > y1 && ymin < y2) {
y1 = y1 > ymin ? y1 : ymin;
y2 = y2 < ymax ? y2 : ymax;
Graphics_line (g, x, y1, x, y2);
}
}
