public static double Median(
PSObject values,
bool alreadySorted = false,
QuantileMethod type = QuantileMethod.Default,
bool inPlace = false
)
{
var array = Converter.ToDoubleArray(values);
return(Accord.Statistics.Measures.Median(array, alreadySorted, type, inPlace));
}
public static double Quartiles(
PSObject values,
out double q1,
out double q3,
bool alreadySorted = false,
QuantileMethod type = QuantileMethod.Default
)
{
var array = Converter.ToDoubleArray(values);
return(Accord.Statistics.Measures.Quartiles(array, out q1, out q3, alreadySorted, type, false));
}
/// <summary>
/// Computes multiple quantiles for the given sequence.
/// </summary>
///
/// <param name="values">The sequence of observations.</param>
/// <param name="probabilities">The sequence of quantile probabilities.</param>
/// <param name="type">The quantile type, 1...9.</param>
/// <param name="alreadySorted">A boolean parameter informing if the given values have already been sorted.</param>
/// <param name="inPlace">Pass true if the method is allowed to sort <paramref name="values"/> in place, overwriting the
/// its original order.</param>
///
/// <returns>Quantile value.</returns>
///
public static double[] Quantiles(this double[] values, double[] probabilities, bool alreadySorted = false, QuantileMethod type = QuantileMethod.Default, bool inPlace = false)
{
if (values == null)
{
throw new ArgumentNullException("Sequence of observations can't be null.", "values");
}
if (values.Length == 0)
{
throw new ArgumentException("Sequence of observations can't be empty.", "values");
}
if (probabilities == null)
{
throw new ArgumentNullException("Sequence of quantile probabilities can't be null.", "probabilities");
}
if (probabilities.Length == 0)
{
throw new ArgumentNullException("Sequence of quantile probabilities can't be empty.", "probabilities");
}
if (probabilities.Any(pv => pv < 0.0 || pv > 1.0))
{
throw new ArgumentException("There is invalid probability in the sequence of quantile probabilities.", "probabilities");
}
double[] result = new double[probabilities.Length];
if (!inPlace && !alreadySorted)
{
values = values.Copy();
}
switch (type)
{
case QuantileMethod.Type1: return(Q1(values, probabilities, alreadySorted, result));
case QuantileMethod.Type2: return(Q2(values, probabilities, alreadySorted, result));
case QuantileMethod.Type3: return(Q3(values, probabilities, alreadySorted, result));
case QuantileMethod.Type4: return(Q4(values, probabilities, alreadySorted, result));
case QuantileMethod.Type5: return(Q5(values, probabilities, alreadySorted, result));
case QuantileMethod.Type6: return(Q6(values, probabilities, alreadySorted, result));
case QuantileMethod.Type7: return(Q7(values, probabilities, alreadySorted, result));
case QuantileMethod.Type8: return(Q8(values, probabilities, alreadySorted, result));
case QuantileMethod.Type9: return(Q9(values, probabilities, alreadySorted, result));
default:
throw new ArgumentException("Invalid quantile type, must be between 1 and 9 (inclusive)", "type");
}
}
/// <summary>
/// Computes single quantile for the given sequence.
/// </summary>
///
/// <param name="values">The sequence of observations.</param>
/// <param name="type">The quantile type, 1...9.</param>
/// <param name="probabilities">The auantile probability.</param>
/// <param name="alreadySorted">A boolean parameter informing if the given values have already been sorted.</param>
/// <param name="inPlace">Pass true if the method is allowed to sort <paramref name="values"/> in place, overwriting the
/// its original order.</param>
///
/// <returns>Quantile value.</returns>
///
public static double Quantile(this double[] values, double probabilities, bool alreadySorted = false, QuantileMethod type = QuantileMethod.Default, bool inPlace = false)
{
return(Quantiles(values, new double[] { probabilities }, alreadySorted: alreadySorted, type: type, inPlace: inPlace)[0]);
}
/// <summary>
/// Computes the upper quartile (Q3) for the given data.
/// </summary>
///
/// <param name="values">An integer array containing the vector members.</param>
/// <param name="alreadySorted">A boolean parameter informing if the given values have already been sorted.</param>
/// <param name="type">The quartile definition that should be used. See <see cref="QuantileMethod"/> for datails.</param>
/// <param name="inPlace">Pass true if the method is allowed to sort <paramref name="values"/> in place, overwriting the
/// its original order.</param>
///
/// <returns>The third quartile of the given data.</returns>
///
public static double UpperQuartile(this double[] values, bool alreadySorted = false, QuantileMethod type = QuantileMethod.Default, bool inPlace = false)
{
return(Quantile(values, type: type, probabilities: 0.75, alreadySorted: alreadySorted, inPlace: inPlace));
}
/// <summary>
/// Computes the Quartiles of the given values.
/// </summary>
///
/// <param name="values">An integer array containing the vector members.</param>
/// <param name="q1">The first quartile.</param>
/// <param name="q3">The third quartile.</param>
/// <param name="alreadySorted">A boolean parameter informing if the given values have already been sorted.</param>
/// <param name="type">The quartile definition that should be used. See <see cref="QuantileMethod"/> for datails.</param>
/// <param name="inPlace">Pass true if the method is allowed to sort <paramref name="values"/> in place, overwriting the
/// its original order.</param>
///
/// <returns>The second quartile, the median of the given data.</returns>
///
public static double Quartiles(this double[] values, out double q1, out double q3, bool alreadySorted = false, QuantileMethod type = QuantileMethod.Default, bool inPlace = false)
{
double[] result = Quantiles(values, type: type, probabilities: new[] { 0.25, 0.5, 0.75 }, alreadySorted: alreadySorted, inPlace: inPlace);
q1 = result[0];
q3 = result[2];
return(result[1]);
}
/// <summary>
/// Computes the Quartiles of the given values.
/// </summary>
///
/// <param name="values">An integer array containing the vector members.</param>
/// <param name="alreadySorted">A boolean parameter informing if the given values have already been sorted.</param>
/// <param name="range">The inter-quartile range for the values.</param>
/// <param name="type">The quartile definition that should be used. See <see cref="QuantileMethod"/> for datails.</param>
/// <param name="inPlace">Pass true if the method is allowed to sort <paramref name="values"/> in place, overwriting the
/// its original order.</param>
///
/// <returns>The second quartile, the median of the given data.</returns>
///
public static double Quartiles(this double[] values, out DoubleRange range, bool alreadySorted = false, QuantileMethod type = QuantileMethod.Default, bool inPlace = false)
{
double[] result = Quantiles(values, type: type, probabilities: new[] { 0.25, 0.5, 0.75 }, alreadySorted: alreadySorted, inPlace: inPlace);
range = new DoubleRange(result[0], result[2]);
return(result[1]);
}
/// <summary>
/// Computes the Median of the given values.
/// </summary>
///
/// <param name="values">An integer array containing the vector members.</param>
/// <param name="alreadySorted">A boolean parameter informing if the given values have already been sorted.</param>
/// <param name="type">The quartile definition that should be used. See <see cref="QuantileMethod"/> for datails.</param>
/// <param name="inPlace">Pass true if the method is allowed to sort <paramref name="values"/> in place, overwriting the
/// its original order.</param>
///
/// <returns>The median of the given data.</returns>
///
public static double Median(this int[] values, bool alreadySorted = false, QuantileMethod type = QuantileMethod.Default, bool inPlace = false)
{
// TODO: Use T4 templates to generate separate implementations for each data type
return(Quantile(values.ToDouble(), type: type, probabilities: 0.5, alreadySorted: alreadySorted, inPlace: inPlace));
}
/// <summary>
/// Computes the circular quartiles of the given circular angles.
/// </summary>
///
/// <param name="angles">A double array containing the angles in radians.</param>
/// <param name="q1">The first quartile, as an out parameter.</param>
/// <param name="q3">The third quartile, as an out parameter.</param>
/// <param name="median">The angular median, if already known.</param>
/// <param name="wrap">
/// Whether range values should be wrapped to be contained in the circle. If
/// set to false, range values could be returned outside the [+pi;-pi] range.
/// </param>
/// <param name="type">The quartile definition that should be used. See <see cref="QuantileMethod"/> for datails.</param>
///
/// <returns>The median of the given angles.</returns>
///
public static double Quartiles(double[] angles, out double q1, out double q3, double median, bool wrap = true, QuantileMethod type = QuantileMethod.Default)
{
double[] x = new double[angles.Length];
for (int i = 0; i < angles.Length; i++)
{
x[i] = Accord.Math.Tools.Mod(angles[i] - median, 2 * Math.PI);
}
for (int i = 0; i < x.Length; i++)
{
x[i] = (x[i] < -Math.PI) ? (x[i] + (2 * Math.PI)) : (x[i]);
x[i] = (x[i] > +Math.PI) ? (x[i] - (2 * Math.PI)) : (x[i]);
}
x.Quartiles(out q1, out q3, alreadySorted: false, type: type, inPlace: true);
q1 = q1 + median;
q3 = q3 + median;
if (wrap)
{
q1 = Accord.Math.Tools.Mod(q1, 2 * Math.PI);
q3 = Accord.Math.Tools.Mod(q3, 2 * Math.PI);
}
return(median);
}
/// <summary>
/// Computes the circular quartiles of the given circular angles.
/// </summary>
///
/// <param name="angles">A double array containing the angles in radians.</param>
/// <param name="range">The sample quartiles, as an out parameter.</param>
/// <param name="median">The angular median, if already known.</param>
/// <param name="wrap">
/// Whether range values should be wrapped to be contained in the circle. If
/// set to false, range values could be returned outside the [+pi;-pi] range.
/// </param>
/// <param name="type">The quartile definition that should be used. See <see cref="QuantileMethod"/> for datails.</param>
///
/// <returns>The median of the given angles.</returns>
///
public static double Quartiles(double[] angles, out DoubleRange range, double median, bool wrap = true, QuantileMethod type = QuantileMethod.Default)
{
double q1, q3;
double q2 = Quartiles(angles, out q1, out q3, median, wrap, type: type);
Accord.Diagnostics.Debug.Assert(q2 == median);
range = new DoubleRange(q1, q3);
return(median);
}
/// <summary>
/// Computes the circular quartiles of the given circular angles.
/// </summary>
///
/// <param name="angles">A double array containing the angles in radians.</param>
/// <param name="range">The sample quartiles, as an out parameter.</param>
/// <param name="wrap">
/// Whether range values should be wrapped to be contained in the circle. If
/// set to false, range values could be returned outside the [+pi;-pi] range.
/// </param>
/// <param name="type">The quartile definition that should be used. See <see cref="QuantileMethod"/> for datails.</param>
///
/// <returns>The median of the given angles.</returns>
///
public static double Quartiles(double[] angles, out DoubleRange range, bool wrap = true, QuantileMethod type = QuantileMethod.Default)
{
return(Quartiles(angles, out range, Median(angles), wrap, type: type));
}
/// <summary>
/// Computes the circular quartiles of the given circular samples.
/// The minimum possible value for a sample must be zero and the maximum must
/// be indicated in the parameter <paramref name="length"/>.
/// </summary>
///
/// <param name="samples">A double array containing the circular samples.</param>
/// <param name="length">The maximum possible value of the samples.</param>
/// <param name="range">The sample quartiles, as an out parameter.</param>
/// <param name="median">The median value of the <paramref name="samples"/>, if already known.</param>
/// <param name="wrap">
/// Whether range values should be wrapped to be contained in the circle. If
/// set to false, range values could be returned outside the [+pi;-pi] range.
/// </param>
/// <param name="type">The quartile definition that should be used. See <see cref="QuantileMethod"/> for datails.</param>
///
/// <returns>The median of the given samples.</returns>
///
public static double Quartiles(double[] samples, double length, out DoubleRange range, double median, bool wrap = true, QuantileMethod type = QuantileMethod.Default)
{
double angleMedian = Circular.ToRadians(median, length);
double q2 = Quartiles(ToRadians(samples, length), out range, angleMedian, wrap, type: type);
range.Min = ToCircular(range.Min, length, wrap);
range.Max = ToCircular(range.Max, length, wrap);
return(ToCircular(q2, length));
}
/// <summary>
/// Computes the circular quartiles of the given circular angles.
/// </summary>
///
/// <param name="angles">A double array containing the angles in radians.</param>
/// <param name="q1">The first quartile, as an out parameter.</param>
/// <param name="q3">The third quartile, as an out parameter.</param>
/// <param name="wrap">
/// Whether range values should be wrapped to be contained in the circle. If
/// set to false, range values could be returned outside the [+pi;-pi] range.
/// </param>
/// <param name="type">The quartile definition that should be used. See <see cref="QuantileMethod"/> for datails.</param>
///
/// <returns>The median of the given angles.</returns>
///
public static double Quartiles(double[] angles, out double q1, out double q3, bool wrap = true, QuantileMethod type = QuantileMethod.Default)
{
return(Quartiles(angles, out q1, out q3, Median(angles), wrap, type: type));
}
/// <summary>
/// Computes the circular quartiles of the given circular samples.
/// The minimum possible value for a sample must be zero and the maximum must
/// be indicated in the parameter <paramref name="length"/>.
/// </summary>
///
/// <param name="samples">A double array containing the circular samples.</param>
/// <param name="length">The maximum possible value of the samples.</param>
/// <param name="q1">The first quartile, as an out parameter.</param>
/// <param name="q3">The third quartile, as an out parameter.</param>
/// <param name="median">The median value of the <paramref name="samples"/>, if already known.</param>
/// <param name="wrap">
/// Whether range values should be wrapped to be contained in the circle. If
/// set to false, range values could be returned outside the [+pi;-pi] range.
/// </param>
/// <param name="type">The quartile definition that should be used. See <see cref="QuantileMethod"/> for datails.</param>
///
/// <returns>The median of the given samples.</returns>
///
public static double Quartiles(double[] samples, double length, out double q1, out double q3, double median, bool wrap = true, QuantileMethod type = QuantileMethod.Default)
{
double angleMedian = Circular.ToRadians(median, length);
double q2 = Quartiles(ToRadians(samples, length), out q1, out q3, angleMedian, wrap, type: type);
q1 = ToCircular(q1, length, wrap);
q3 = ToCircular(q3, length, wrap);
return(ToCircular(q2, length));
}
