/// <summary>
/// Calculate the variance value of array data. Supported data type: double/float/int.
/// </summary>
/// <param name="data">The array data to calculate statistic value.</param>
/// <typeparam name="TDataType">Supported data type: double/float/int.</typeparam>
/// <returns>The variance value of array data in specific place.</returns>
/// <exception cref="NotSupportedException">Supported data type: double/float/int.</exception>
public static double Variance <TDataType>(TDataType[] data)
{
double variance = double.NaN;
if (ReferenceEquals(typeof(TDataType), typeof(double)))
{
double[] doubleData = data as double[];
variance = ArrayStatistics.Variance(doubleData);
}
else if (ReferenceEquals(typeof(TDataType), typeof(float)))
{
float[] floatData = data as float[];
variance = ArrayStatistics.Variance(floatData);
}
else if (ReferenceEquals(typeof(TDataType), typeof(int)))
{
int[] intData = data as int[];
variance = ArrayStatistics.Variance(intData);
}
else
{
throw new NotSupportedException("Unsupported data type.");
}
return(variance);
}
private void GenerarNorm()
{
var observados = Seccionar();
double acumulador = 0;
var frecAbs = new List <double>();
var intervalos = int.Parse(txtInter.Text);
var min = Valores.Min();
var max = Valores.Max();
var paso = (max - min) / intervalos;
var mean = ArrayStatistics.Mean(Valores.ToArray());
var desEst = ArrayStatistics.StandardDeviation(Valores.ToArray());
for (double i = min; i <= max; i += paso)
{
var sup = MathNet.Numerics.Distributions.Normal.CDF(mean, desEst, i + paso);
var inf = MathNet.Numerics.Distributions.Normal.CDF(mean, desEst, i);
double esperado = Valores.Count() * (sup - inf);
frecAbs.Add(esperado);
}
for (int i = 0; i < intervalos - 1; i++)
{
acumulador = acumulador + Math.Pow(observados[i] - frecAbs[i], 2) / frecAbs[i];
}
txtAcum.Text = acumulador.ToString();
var gl = intervalos - 1 - 2;
var alpha = 0.95;
var chi = MathNet.Numerics.Distributions.ChiSquared.InvCDF(gl, alpha);
txtTabulado.Text = chi.ToString();
}
static void Benchmark(object obj, uint iterations, string suffix = null)
{
var bench = new BenchShark(true);
var result = bench.EvaluateDecoratedTasks(obj, iterations);
var results = result.FastestEvaluations.Select(x =>
{
var series = x.Iterations.Select(it => (double)it.ElapsedTicks).ToArray();
Array.Sort(series);
var summary = SortedArrayStatistics.FiveNumberSummary(series);
var ms = ArrayStatistics.MeanStandardDeviation(series);
return(new { x.Name, Mean = ms.Item1, StdDev = ms.Item2, Min = summary[0], Q1 = summary[1], Median = summary[2], Q3 = summary[3], Max = summary[4] });
}).ToArray();
var top = results[0];
var managed = results.Single(x => x.Name.StartsWith("Managed"));
var label = string.IsNullOrEmpty(suffix) ? obj.GetType().FullName : string.Concat(obj.GetType().FullName, ": ", suffix);
results.Select(x => new
{
x.Name,
Mean = Math.Round(x.Mean), StdDev = Math.Round(x.StdDev),
Min = Math.Round(x.Min), Q1 = Math.Round(x.Q1), Median = Math.Round(x.Median), Q3 = Math.Round(x.Q3), Max = Math.Round(x.Max),
TopSlowdown = Math.Round(x.Median / top.Median, 2),
ManagedSpeedup = Math.Round(managed.Median / x.Median, 2)
}).Dump(label);
}
private void GenerarEN()
{
var observados = Seccionar();
var array = Valores.ToArray();
double acumulador = 0;
var frecAbs = new List <double>();
var intervalos = int.Parse(txtInter.Text);
var min = Valores.Min();
var max = Valores.Max();
var paso = (max - min) / intervalos;
var lambda = 1 / ArrayStatistics.Mean(array);
for (double i = min; i <= max; i += paso)
{
double esperado = (MathNet.Numerics.Distributions.Exponential.CDF(lambda, i + paso) - MathNet.Numerics.Distributions.Exponential.CDF(lambda, i)) * Valores.Count();
frecAbs.Add(esperado);
}
for (int i = 0; i < intervalos; i++)
{
acumulador = acumulador + Math.Pow((observados[i] - frecAbs[i]), 2) / frecAbs[i];
}
txtAcum.Text = acumulador.ToString();
var gl = intervalos - 1 - 1;
var alpha = 0.95;
var chi = MathNet.Numerics.Distributions.ChiSquared.InvCDF(gl, alpha);
txtTabulado.Text = chi.ToString();
}
/// <summary>
/// Populate 6 month standard deviation
/// </summary>
public static double GetPriceRangeStdDev(this HistoricalData data)
{
double[] priceRange = data.High.Select((d, i) => d - data.Low[i]).ToArray();
double stdDev = ArrayStatistics.StandardDeviation(priceRange);
return(stdDev);
}
/// <summary>
/// Calculate the covariance value of two array data. Supported data type: double/float/int.
/// </summary>
/// <param name="data1">The first array data to calculate Covariance value.</param>
/// <param name="data2">The second array data to calculate Covariance value.</param>
/// <typeparam name="TDataType">Supported data type: double/float/int.</typeparam>
/// <returns>The covariance value of two array data in specific place.</returns>
/// <exception cref="NotSupportedException">Supported data type: double/float/int.</exception>
public static double Covariance <TDataType>(TDataType[] data1, TDataType[] data2)
{
double covariance = double.NaN;
if (ReferenceEquals(typeof(TDataType), typeof(double)))
{
double[] doubleData1 = data1 as double[];
double[] doubleData2 = data2 as double[];
covariance = ArrayStatistics.Covariance(doubleData1, doubleData2);
}
else if (ReferenceEquals(typeof(TDataType), typeof(float)))
{
float[] floatData1 = data1 as float[];
float[] floatData2 = data2 as float[];
covariance = ArrayStatistics.Covariance(floatData1, floatData2);
}
else if (ReferenceEquals(typeof(TDataType), typeof(int)))
{
int[] intData1 = data1 as int[];
int[] intData2 = data2 as int[];
covariance = ArrayStatistics.Covariance(intData1, intData2);
}
else
{
throw new NotSupportedException("Unsupported data type.");
}
return(covariance);
}
/// <summary>
/// Calculate the root mean sqaure value of array data. Supported data type: double/float/int.
/// </summary>
/// <param name="data">The array data to calculate statistic value.</param>
/// <typeparam name="TDataType">Supported data type: double/float/int.</typeparam>
/// <returns>The root mean square value of array data.</returns>
/// <exception cref="NotSupportedException">Supported data type: double/float/int.</exception>
public static double RootMeanSqaure <TDataType>(TDataType[] data)
{
double rootMeanSqure = double.NaN;
if (ReferenceEquals(typeof(TDataType), typeof(double)))
{
double[] doubleData = data as double[];
rootMeanSqure = ArrayStatistics.RootMeanSquare(doubleData);
}
else if (ReferenceEquals(typeof(TDataType), typeof(float)))
{
float[] floatData = data as float[];
rootMeanSqure = ArrayStatistics.RootMeanSquare(floatData);
}
else if (ReferenceEquals(typeof(TDataType), typeof(int)))
{
int[] intData = data as int[];
rootMeanSqure = ArrayStatistics.RootMeanSquare(intData);
}
else
{
throw new NotSupportedException("Unsupported data type.");
}
return(rootMeanSqure);
}
/// <summary>
/// Calculate the harmonic mean value of array data. Supported data type: double/float/int.
/// </summary>
/// <param name="data">The array data to calculate statistic value.</param>
/// <typeparam name="TDataType">Supported data type: double/float/int.</typeparam>
/// <returns>The harmonic mean value of array data.</returns>
/// <exception cref="NotSupportedException">Supported data type: double/float/int.</exception>
public static double HarmonicMean <TDataType>(TDataType[] data)
{
double harmonicMean = double.NaN;
if (ReferenceEquals(typeof(TDataType), typeof(double)))
{
double[] doubleData = data as double[];
harmonicMean = ArrayStatistics.HarmonicMean(doubleData);
}
else if (ReferenceEquals(typeof(TDataType), typeof(float)))
{
float[] floatData = data as float[];
harmonicMean = ArrayStatistics.HarmonicMean(floatData);
}
else if (ReferenceEquals(typeof(TDataType), typeof(int)))
{
int[] intData = data as int[];
harmonicMean = ArrayStatistics.HarmonicMean(intData);
}
else
{
throw new NotSupportedException("Unsupported data type.");
}
return(harmonicMean);
}
public void MeanConsistentWithNistData(string dataSet)
{
var data = _data[dataSet];
AssertHelpers.AlmostEqual(data.Mean, Statistics.Mean(data.Data), 15);
AssertHelpers.AlmostEqual(data.Mean, ArrayStatistics.Mean(data.Data), 15);
AssertHelpers.AlmostEqual(data.Mean, StreamingStatistics.Mean(data.Data), 15);
}
public void PopulationCovarianceConsistentWithPopulationVariance(string dataSet)
{
var data = _data[dataSet];
AssertHelpers.AlmostEqual(Statistics.PopulationVariance(data.Data), Statistics.PopulationCovariance(data.Data, data.Data), 10);
AssertHelpers.AlmostEqual(ArrayStatistics.PopulationVariance(data.Data), ArrayStatistics.PopulationCovariance(data.Data, data.Data), 10);
AssertHelpers.AlmostEqual(StreamingStatistics.PopulationVariance(data.Data), StreamingStatistics.PopulationCovariance(data.Data, data.Data), 10);
}
public void StandardDeviationConsistentWithNistData(string dataSet, int digits)
{
var data = _data[dataSet];
AssertHelpers.AlmostEqual(data.StandardDeviation, Statistics.StandardDeviation(data.Data), digits);
AssertHelpers.AlmostEqual(data.StandardDeviation, ArrayStatistics.StandardDeviation(data.Data), digits);
AssertHelpers.AlmostEqual(data.StandardDeviation, StreamingStatistics.StandardDeviation(data.Data), digits);
}
public void CovarianceConsistentWithVariance(string dataSet)
{
var data = _data[dataSet];
AssertHelpers.AlmostEqualRelative(Statistics.Variance(data.Data), Statistics.Covariance(data.Data, data.Data), 10);
AssertHelpers.AlmostEqualRelative(ArrayStatistics.Variance(data.Data), ArrayStatistics.Covariance(data.Data, data.Data), 10);
AssertHelpers.AlmostEqualRelative(StreamingStatistics.Variance(data.Data), StreamingStatistics.Covariance(data.Data, data.Data), 10);
}
private static double[] AutoCorrelationFft(double[] x, int kLow, int kHigh)
{
if (x == null)
{
throw new ArgumentNullException(nameof(x));
}
int N = x.Length; // Sample size
if (kLow < 0 || kLow >= N)
{
throw new ArgumentOutOfRangeException(nameof(kLow), "kMin must be zero or positive and smaller than x.Length");
}
if (kHigh < 0 || kHigh >= N)
{
throw new ArgumentOutOfRangeException(nameof(kHigh), "kMax must be positive and smaller than x.Length");
}
if (N < 1)
{
return(new double[0]);
}
int nFFT = Euclid.CeilingToPowerOfTwo(N) * 2;
Complex[] xFFT = new Complex[nFFT];
Complex[] xFFT2 = new Complex[nFFT];
double xDash = ArrayStatistics.Mean(x);
double xArrNow = 0.0d;
// copy values in range and substract mean - all the remaining parts are padded with zero.
for (int i = 0; i < x.Length; i++)
{
xFFT[i] = new Complex(x[i] - xDash, 0.0); // copy values in range and substract mean
}
Fourier.Forward(xFFT, FourierOptions.Matlab);
// maybe a Vector<Complex> implementation here would be faster
for (int i = 0; i < xFFT.Length; i++)
{
xFFT2[i] = Complex.Multiply(xFFT[i], Complex.Conjugate(xFFT[i]));
}
Fourier.Inverse(xFFT2, FourierOptions.Matlab);
double dc = xFFT2[0].Real;
double[] result = new double[kHigh - kLow + 1];
// normalize such that acf[0] would be 1.0
for (int i = 0; i < (kHigh - kLow + 1); i++)
{
result[i] = xFFT2[kLow + i].Real / dc;
}
return(result);
}
public void MeanOfEmptyMustBeNaN()
{
Assert.That(Statistics.Mean(new double[0]), Is.NaN);
Assert.That(Statistics.Mean(new[] { 2d }), Is.Not.NaN);
Assert.That(ArrayStatistics.Mean(new double[0]), Is.NaN);
Assert.That(ArrayStatistics.Mean(new[] { 2d }), Is.Not.NaN);
Assert.That(StreamingStatistics.Mean(new double[0]), Is.NaN);
Assert.That(StreamingStatistics.Mean(new[] { 2d }), Is.Not.NaN);
}
/// <summary>
/// Populate 6 month standard deviation
/// </summary>
public static double GetPriceRangeStdDevFor6Months(this HistoricalData data)
{
DateTime last6Months = DateTime.UtcNow.AddMonths(-6).Date;
int index = ((IReadOnlyList <DateTime>)data.Date).FirstAndIndex(item => item >= last6Months).Item1;
List <double> highPrices = data.High.Skip(index).ToList();
List <double> lowPrices = data.Low.Skip(index).ToList();
double rangeStdDev = ArrayStatistics.StandardDeviation(highPrices.Select((item, i) => item - lowPrices[i]).ToArray());
return(rangeStdDev);
}
public void ThrowsOnNullData()
{
double[] data = null;
// ReSharper disable InvokeAsExtensionMethod
Assert.That(() => Statistics.Minimum(data), Throws.Exception);
Assert.That(() => Statistics.Maximum(data), Throws.Exception);
Assert.That(() => Statistics.Mean(data), Throws.Exception);
Assert.That(() => Statistics.Median(data), Throws.Exception);
Assert.That(() => Statistics.Quantile(data, 0.3), Throws.Exception);
Assert.That(() => Statistics.Variance(data), Throws.Exception);
Assert.That(() => Statistics.StandardDeviation(data), Throws.Exception);
Assert.That(() => Statistics.PopulationVariance(data), Throws.Exception);
Assert.That(() => Statistics.PopulationStandardDeviation(data), Throws.Exception);
Assert.That(() => Statistics.Covariance(data, data), Throws.Exception);
Assert.That(() => Statistics.PopulationCovariance(data, data), Throws.Exception);
// ReSharper restore InvokeAsExtensionMethod
Assert.That(() => SortedArrayStatistics.Minimum(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => SortedArrayStatistics.Minimum(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => SortedArrayStatistics.Maximum(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => SortedArrayStatistics.OrderStatistic(data, 1), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => SortedArrayStatistics.Median(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => SortedArrayStatistics.LowerQuartile(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => SortedArrayStatistics.UpperQuartile(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => SortedArrayStatistics.Percentile(data, 30), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => SortedArrayStatistics.Quantile(data, 0.3), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => SortedArrayStatistics.QuantileCustom(data, 0.3, 0, 0, 1, 0), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => SortedArrayStatistics.QuantileCustom(data, 0.3, QuantileDefinition.Nearest), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => SortedArrayStatistics.InterquartileRange(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => SortedArrayStatistics.FiveNumberSummary(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => ArrayStatistics.Minimum(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => ArrayStatistics.Maximum(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => ArrayStatistics.OrderStatisticInplace(data, 1), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => ArrayStatistics.Mean(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => ArrayStatistics.Variance(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => ArrayStatistics.StandardDeviation(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => ArrayStatistics.PopulationVariance(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => ArrayStatistics.PopulationStandardDeviation(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => ArrayStatistics.Covariance(data, data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => ArrayStatistics.PopulationCovariance(data, data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => ArrayStatistics.MedianInplace(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => ArrayStatistics.QuantileInplace(data, 0.3), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => StreamingStatistics.Minimum(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => StreamingStatistics.Maximum(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => StreamingStatistics.Mean(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => StreamingStatistics.Variance(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => StreamingStatistics.StandardDeviation(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => StreamingStatistics.PopulationVariance(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => StreamingStatistics.PopulationStandardDeviation(data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => StreamingStatistics.Covariance(data, data), Throws.Exception.TypeOf <NullReferenceException>());
Assert.That(() => StreamingStatistics.PopulationCovariance(data, data), Throws.Exception.TypeOf <NullReferenceException>());
}
private static List <StatResult> NumericStat(List <string> data)
{
List <StatResult> results = new List <StatResult>();
try
{
var numData = data.Select(x => double.Parse(x)).ToList();
double min = ArrayStatistics.Minimum(numData.ToArray());
double max = ArrayStatistics.Maximum(numData.ToArray());
results.Add(new StatResult
{
Label = "Moyenne",
Result = ArrayStatistics.Mean(numData.ToArray()).ToString(CultureInfo.InvariantCulture)
});
results.Add(new StatResult
{
Label = "Médiane",
Result = ArrayStatistics.MedianInplace(numData.ToArray()).ToString(CultureInfo.InvariantCulture)
});
results.Add(new StatResult
{
Label = "Maximum",
Result = max.ToString(CultureInfo.InvariantCulture)
});
results.Add(new StatResult
{
Label = "Minimum",
Result = min.ToString(CultureInfo.InvariantCulture)
});
results.Add(new StatResult
{
Label = "Étendue",
Result = (max - min).ToString(CultureInfo.InvariantCulture)
});
results.Add(new StatResult
{
Label = "Écart-type",
Result = ArrayStatistics.StandardDeviation(numData.ToArray()).ToString(CultureInfo.InvariantCulture)
});
results.Add(new StatResult
{
Label = "Variance",
Result = ArrayStatistics.Variance(numData.ToArray()).ToString(CultureInfo.InvariantCulture)
});
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
}
return(results);
}
public void MeanConsistentWithNistData(string dataSet)
{
var data = _data[dataSet];
AssertHelpers.AlmostEqualRelative(data.Mean, Statistics.Mean(data.Data), 14);
AssertHelpers.AlmostEqualRelative(data.Mean, ArrayStatistics.Mean(data.Data), 14);
AssertHelpers.AlmostEqualRelative(data.Mean, StreamingStatistics.Mean(data.Data), 14);
AssertHelpers.AlmostEqualRelative(data.Mean, Statistics.MeanVariance(data.Data).Item1, 14);
AssertHelpers.AlmostEqualRelative(data.Mean, ArrayStatistics.MeanVariance(data.Data).Item1, 14);
AssertHelpers.AlmostEqualRelative(data.Mean, StreamingStatistics.MeanVariance(data.Data).Item1, 14);
}
public void MaximumOfEmptyMustBeNaN()
{
Assert.That(Statistics.Maximum(new double[0]), Is.NaN);
Assert.That(Statistics.Maximum(new[] { 2d }), Is.Not.NaN);
Assert.That(ArrayStatistics.Maximum(new double[0]), Is.NaN);
Assert.That(ArrayStatistics.Maximum(new[] { 2d }), Is.Not.NaN);
Assert.That(SortedArrayStatistics.Maximum(new double[0]), Is.NaN);
Assert.That(SortedArrayStatistics.Maximum(new[] { 2d }), Is.Not.NaN);
Assert.That(StreamingStatistics.Maximum(new double[0]), Is.NaN);
Assert.That(StreamingStatistics.Maximum(new[] { 2d }), Is.Not.NaN);
}
public void StandardDeviationConsistentWithNistData(string dataSet, int digits)
{
var data = _data[dataSet];
AssertHelpers.AlmostEqualRelative(data.StandardDeviation, Statistics.StandardDeviation(data.Data), digits);
AssertHelpers.AlmostEqualRelative(data.StandardDeviation, ArrayStatistics.StandardDeviation(data.Data), digits);
AssertHelpers.AlmostEqualRelative(data.StandardDeviation, StreamingStatistics.StandardDeviation(data.Data), digits);
AssertHelpers.AlmostEqualRelative(data.StandardDeviation, Math.Sqrt(Statistics.MeanVariance(data.Data).Item2), digits);
AssertHelpers.AlmostEqualRelative(data.StandardDeviation, Math.Sqrt(ArrayStatistics.MeanVariance(data.Data).Item2), digits);
AssertHelpers.AlmostEqualRelative(data.StandardDeviation, Math.Sqrt(StreamingStatistics.MeanVariance(data.Data).Item2), digits);
}
public void ArrayStatisticsConsistentWithStreamimgStatistics(string dataSet)
{
var data = _data[dataSet];
AssertHelpers.AlmostEqual(ArrayStatistics.Mean(data.Data), StreamingStatistics.Mean(data.Data), 10);
AssertHelpers.AlmostEqual(ArrayStatistics.Variance(data.Data), StreamingStatistics.Variance(data.Data), 10);
AssertHelpers.AlmostEqual(ArrayStatistics.StandardDeviation(data.Data), StreamingStatistics.StandardDeviation(data.Data), 10);
AssertHelpers.AlmostEqual(ArrayStatistics.PopulationVariance(data.Data), StreamingStatistics.PopulationVariance(data.Data), 10);
AssertHelpers.AlmostEqual(ArrayStatistics.PopulationStandardDeviation(data.Data), StreamingStatistics.PopulationStandardDeviation(data.Data), 10);
AssertHelpers.AlmostEqual(ArrayStatistics.Covariance(data.Data, data.Data), StreamingStatistics.Covariance(data.Data, data.Data), 10);
AssertHelpers.AlmostEqual(ArrayStatistics.PopulationCovariance(data.Data, data.Data), StreamingStatistics.PopulationCovariance(data.Data, data.Data), 10);
}
static double[] Rank(IEnumerable <double> series)
{
if (series == null)
{
return(new double[0]);
}
// WARNING: do not try to cast series to an array and use it directly,
// as we need to sort it (inplace operation)
var data = series.ToArray();
return(ArrayStatistics.RanksInplace(data, RankDefinition.Average));
}
public void SampleVarianceOfEmptyAndSingleMustBeNaN()
{
Assert.That(Statistics.Variance(new double[0]), Is.NaN);
Assert.That(Statistics.Variance(new[] { 2d }), Is.NaN);
Assert.That(Statistics.Variance(new[] { 2d, 3d }), Is.Not.NaN);
Assert.That(ArrayStatistics.Variance(new double[0]), Is.NaN);
Assert.That(ArrayStatistics.Variance(new[] { 2d }), Is.NaN);
Assert.That(ArrayStatistics.Variance(new[] { 2d, 3d }), Is.Not.NaN);
Assert.That(StreamingStatistics.Variance(new double[0]), Is.NaN);
Assert.That(StreamingStatistics.Variance(new[] { 2d }), Is.NaN);
Assert.That(StreamingStatistics.Variance(new[] { 2d, 3d }), Is.Not.NaN);
}
public void PopulationVarianceOfEmptyMustBeNaN()
{
Assert.That(Statistics.PopulationVariance(new double[0]), Is.NaN);
Assert.That(Statistics.PopulationVariance(new[] { 2d }), Is.Not.NaN);
Assert.That(Statistics.PopulationVariance(new[] { 2d, 3d }), Is.Not.NaN);
Assert.That(ArrayStatistics.PopulationVariance(new double[0]), Is.NaN);
Assert.That(ArrayStatistics.PopulationVariance(new[] { 2d }), Is.Not.NaN);
Assert.That(ArrayStatistics.PopulationVariance(new[] { 2d, 3d }), Is.Not.NaN);
Assert.That(StreamingStatistics.PopulationVariance(new double[0]), Is.NaN);
Assert.That(StreamingStatistics.PopulationVariance(new[] { 2d }), Is.Not.NaN);
Assert.That(StreamingStatistics.PopulationVariance(new[] { 2d, 3d }), Is.Not.NaN);
}
public void ThrowsOnNullData()
{
double[] data = null;
Assert.Throws <ArgumentNullException>(() => Statistics.Minimum(data));
Assert.Throws <ArgumentNullException>(() => Statistics.Maximum(data));
Assert.Throws <ArgumentNullException>(() => Statistics.Mean(data));
Assert.Throws <ArgumentNullException>(() => Statistics.Median(data));
Assert.Throws <ArgumentNullException>(() => Statistics.Quantile(data, 0.3));
Assert.Throws <ArgumentNullException>(() => Statistics.Variance(data));
Assert.Throws <ArgumentNullException>(() => Statistics.StandardDeviation(data));
Assert.Throws <ArgumentNullException>(() => Statistics.PopulationVariance(data));
Assert.Throws <ArgumentNullException>(() => Statistics.PopulationStandardDeviation(data));
Assert.Throws <ArgumentNullException>(() => Statistics.Covariance(data, data));
Assert.Throws <ArgumentNullException>(() => Statistics.PopulationCovariance(data, data));
Assert.Throws <ArgumentNullException>(() => SortedArrayStatistics.Minimum(data));
Assert.Throws <ArgumentNullException>(() => SortedArrayStatistics.Maximum(data));
Assert.Throws <ArgumentNullException>(() => SortedArrayStatistics.OrderStatistic(data, 1));
Assert.Throws <ArgumentNullException>(() => SortedArrayStatistics.Median(data));
Assert.Throws <ArgumentNullException>(() => SortedArrayStatistics.LowerQuartile(data));
Assert.Throws <ArgumentNullException>(() => SortedArrayStatistics.UpperQuartile(data));
Assert.Throws <ArgumentNullException>(() => SortedArrayStatistics.Percentile(data, 30));
Assert.Throws <ArgumentNullException>(() => SortedArrayStatistics.Quantile(data, 0.3));
Assert.Throws <ArgumentNullException>(() => SortedArrayStatistics.QuantileCustom(data, 0.3, 0, 0, 1, 0));
Assert.Throws <ArgumentNullException>(() => SortedArrayStatistics.QuantileCustom(data, 0.3, QuantileDefinition.Nearest));
Assert.Throws <ArgumentNullException>(() => SortedArrayStatistics.InterquartileRange(data));
Assert.Throws <ArgumentNullException>(() => SortedArrayStatistics.FiveNumberSummary(data));
Assert.Throws <ArgumentNullException>(() => ArrayStatistics.Minimum(data));
Assert.Throws <ArgumentNullException>(() => ArrayStatistics.Maximum(data));
Assert.Throws <ArgumentNullException>(() => ArrayStatistics.OrderStatisticInplace(data, 1));
Assert.Throws <ArgumentNullException>(() => ArrayStatistics.Mean(data));
Assert.Throws <ArgumentNullException>(() => ArrayStatistics.Variance(data));
Assert.Throws <ArgumentNullException>(() => ArrayStatistics.StandardDeviation(data));
Assert.Throws <ArgumentNullException>(() => ArrayStatistics.PopulationVariance(data));
Assert.Throws <ArgumentNullException>(() => ArrayStatistics.PopulationStandardDeviation(data));
Assert.Throws <ArgumentNullException>(() => ArrayStatistics.Covariance(data, data));
Assert.Throws <ArgumentNullException>(() => ArrayStatistics.PopulationCovariance(data, data));
Assert.Throws <ArgumentNullException>(() => ArrayStatistics.MedianInplace(data));
Assert.Throws <ArgumentNullException>(() => ArrayStatistics.QuantileInplace(data, 0.3));
Assert.Throws <ArgumentNullException>(() => StreamingStatistics.Minimum(data));
Assert.Throws <ArgumentNullException>(() => StreamingStatistics.Maximum(data));
Assert.Throws <ArgumentNullException>(() => StreamingStatistics.Mean(data));
Assert.Throws <ArgumentNullException>(() => StreamingStatistics.Variance(data));
Assert.Throws <ArgumentNullException>(() => StreamingStatistics.StandardDeviation(data));
Assert.Throws <ArgumentNullException>(() => StreamingStatistics.PopulationVariance(data));
Assert.Throws <ArgumentNullException>(() => StreamingStatistics.PopulationStandardDeviation(data));
Assert.Throws <ArgumentNullException>(() => StreamingStatistics.Covariance(data, data));
Assert.Throws <ArgumentNullException>(() => StreamingStatistics.PopulationCovariance(data, data));
}
public void CovarianceIsSymmetric()
{
var dataA = _data["lottery"].Data.Take(200);
var dataB = _data["lew"].Data.Take(200);
AssertHelpers.AlmostEqual(Statistics.Covariance(dataA, dataB), Statistics.Covariance(dataB, dataA), 12);
AssertHelpers.AlmostEqual(StreamingStatistics.Covariance(dataA, dataB), StreamingStatistics.Covariance(dataB, dataA), 12);
AssertHelpers.AlmostEqual(ArrayStatistics.Covariance(dataA.ToArray(), dataB.ToArray()), ArrayStatistics.Covariance(dataB.ToArray(), dataA.ToArray()), 12);
AssertHelpers.AlmostEqual(Statistics.PopulationCovariance(dataA, dataB), Statistics.PopulationCovariance(dataB, dataA), 12);
AssertHelpers.AlmostEqual(StreamingStatistics.PopulationCovariance(dataA, dataB), StreamingStatistics.PopulationCovariance(dataB, dataA), 12);
AssertHelpers.AlmostEqual(ArrayStatistics.PopulationCovariance(dataA.ToArray(), dataB.ToArray()), ArrayStatistics.PopulationCovariance(dataB.ToArray(), dataA.ToArray()), 12);
}
public void Median_CodeplexIssue5667()
{
var seq = File.ReadLines("./data/Codeplex-5667.csv").Select(double.Parse);
Assert.AreEqual(1.0, Statistics.Median(seq));
var array = seq.ToArray();
Assert.AreEqual(1.0, ArrayStatistics.MedianInplace(array));
Array.Sort(array);
Assert.AreEqual(1.0, SortedArrayStatistics.Median(array));
}
private void Initialization()
{
//Calculate initialstate and initialstatecovariance
var M = Matrix <double> .Build;
initialstate = M.Dense(4, 1);
initialstatecovariance = M.DenseDiagonal(4, 4, 0.00);
var tempyields = new double[maturities.Length];
var StaticNS4factorCalibration = new StaticNS4FactorModelCalibration();
StaticNS4factorCalibration.maturities = maturities;
var tempbeta1 = new double[30];
var tempbeta2 = new double[30];
var tempbeta3 = new double[30];
var tempbeta4 = new double[30];
Parallel.For(0, 30, i =>
{
tempyields = yields[yields.ElementAt(i).Key].Clone() as double[];
StaticNS4factorCalibration.yields = tempyields;
var temppara = StaticNS4factorCalibration.Calibration();
tempbeta1[i] = temppara[0];
tempbeta2[i] = temppara[1];
tempbeta3[i] = temppara[2];
tempbeta4[i] = temppara[3];
});
initialstate[0, 0] = ArrayStatistics.Mean(tempbeta1);
initialstate[1, 0] = ArrayStatistics.Mean(tempbeta2);
initialstate[2, 0] = ArrayStatistics.Mean(tempbeta3);
initialstate[3, 0] = ArrayStatistics.Mean(tempbeta4);
initialstatecovariance[0, 0] = ArrayStatistics.Covariance(tempbeta1, tempbeta1);
initialstatecovariance[0, 1] = ArrayStatistics.Covariance(tempbeta1, tempbeta2);
initialstatecovariance[0, 2] = ArrayStatistics.Covariance(tempbeta1, tempbeta3);
initialstatecovariance[0, 3] = ArrayStatistics.Covariance(tempbeta1, tempbeta4);
initialstatecovariance[1, 0] = ArrayStatistics.Covariance(tempbeta2, tempbeta1);
initialstatecovariance[1, 1] = ArrayStatistics.Covariance(tempbeta2, tempbeta2);
initialstatecovariance[1, 2] = ArrayStatistics.Covariance(tempbeta2, tempbeta3);
initialstatecovariance[1, 3] = ArrayStatistics.Covariance(tempbeta2, tempbeta4);
initialstatecovariance[2, 0] = ArrayStatistics.Covariance(tempbeta3, tempbeta1);
initialstatecovariance[2, 1] = ArrayStatistics.Covariance(tempbeta3, tempbeta2);
initialstatecovariance[2, 2] = ArrayStatistics.Covariance(tempbeta3, tempbeta3);
initialstatecovariance[2, 3] = ArrayStatistics.Covariance(tempbeta3, tempbeta4);
initialstatecovariance[3, 0] = ArrayStatistics.Covariance(tempbeta4, tempbeta1);
initialstatecovariance[3, 1] = ArrayStatistics.Covariance(tempbeta4, tempbeta2);
initialstatecovariance[3, 2] = ArrayStatistics.Covariance(tempbeta4, tempbeta3);
initialstatecovariance[3, 3] = ArrayStatistics.Covariance(tempbeta4, tempbeta4);
}
public void MinimumMaximumOnShortSequence()
{
var samples = new[] { -1.0, 5, 0, -3, 10, -0.5, 4 };
Assert.That(Statistics.Minimum(samples), Is.EqualTo(-3), "Min");
Assert.That(Statistics.Maximum(samples), Is.EqualTo(10), "Max");
Assert.That(ArrayStatistics.Minimum(samples), Is.EqualTo(-3), "Min");
Assert.That(ArrayStatistics.Maximum(samples), Is.EqualTo(10), "Max");
Assert.That(StreamingStatistics.Minimum(samples), Is.EqualTo(-3), "Min");
Assert.That(StreamingStatistics.Maximum(samples), Is.EqualTo(10), "Max");
Array.Sort(samples);
Assert.That(SortedArrayStatistics.Minimum(samples), Is.EqualTo(-3), "Min");
Assert.That(SortedArrayStatistics.Maximum(samples), Is.EqualTo(10), "Max");
}
public void QuantileR2InverseCDFAverageOnShortSequence(double tau, double expected)
{
// R: quantile(c(-1,5,0,-3,10,-0.5,4,0.2,1,6),probs=c(0,1,0.5,0.2,0.7,0.01,0.99,0.52,0.325),type=2)
// Mathematica: Not Supported
var samples = new[] { -1, 5, 0, -3, 10, -0.5, 4, 0.2, 1, 6 };
Assert.AreEqual(expected, Statistics.QuantileCustom(samples, tau, QuantileDefinition.R2), 1e-14);
Assert.AreEqual(expected, Statistics.QuantileCustomFunc(samples, QuantileDefinition.R2)(tau), 1e-14);
Assert.AreEqual(expected, ArrayStatistics.QuantileCustomInplace(samples, tau, QuantileDefinition.InverseCDFAverage), 1e-14);
Array.Sort(samples);
Assert.AreEqual(expected, SortedArrayStatistics.QuantileCustom(samples, tau, QuantileDefinition.InverseCDFAverage), 1e-14);
}
