public static double GetLambda(double[] sample)
{
List <double> arr = new List <double>(sample);
var normal2 = new MathNet.Numerics.Distributions.Normal();
arr.Sort();
double dMax = 0.0;
double dp, dm;
double MX = StatisticData.CalculateMathExpectation(sample);
double D = StatisticData.CalculateDispersoin(sample, MX);
for (int i = 0; i < arr.Count; i++)
{
double v = (arr[i] - MX) / Math.Sqrt(D);
dp = Math.Abs((double)(i + 1) / arr.Count - normal2.CumulativeDistribution(v));
dm = Math.Abs(normal2.CumulativeDistribution(v) - (double)i / arr.Count);
if (dp > dMax)
{
dMax = dp;
}
if (dm > dMax)
{
dMax = dm;
}
}
return(dMax * Math.Sqrt(arr.Count));
}
private static double CumulativeProbabilityNormalDistributionFunction(double x)
{
/*
* Related links
* https://stackoverflow.com/questions/1662943/standard-normal-distribution-z-value-function-in-c-sharp
* https://numerics.mathdotnet.com/
* https://en.wikipedia.org/wiki/Normal_distribution
* https://en.wikipedia.org/wiki/Error_function
*/
MathNet.Numerics.Distributions.Normal result = new MathNet.Numerics.Distributions.Normal();
return(result.CumulativeDistribution(x));
}
/// <summary>
/// Removes any values in the list that are outside of a two-tailed p value range.
/// Does not remove any outliers if number of value is less or equal to 3.
/// </summary>
/// <param name="values"></param>
/// <param name="pVal"></param>
/// <returns>list with no outliers</returns>
public static IEnumerable <double> removeOutliers_NormalDist(this IEnumerable <double> values, double pVal = 0.05)
{
List <double> outliers = new List <double>();
if (values.Count() > 3)
{
MathNet.Numerics.Distributions.Normal distribution = MathNet.Numerics.Distributions.Normal.Estimate(values);
foreach (double val in values)
{
double cur_p = distribution.CumulativeDistribution(val);
if (cur_p < (pVal / 2) || cur_p > (1 - (pVal / 2)))
{
outliers.Add(val);
}
}
}
return(values.Except(outliers));
}
public IΦHatResultElement Calculate(
INormalFactory normalFactory,
IΦHatResultElementFactory ΦHatResultElementFactory,
IlIndexElement lIndexElement,
IsIndexElement sIndexElement,
IΛIndexElement ΛIndexElement,
IExpectedValueΦ expectedValueΦ,
IVarianceΦ varianceΦ,
IVHat VHat,
Iυ2 υ2)
{
// https://stackoverflow.com/questions/1662943/standard-normal-distribution-z-value-function-in-c-sharp
MathNet.Numerics.Distributions.Normal normal = (MathNet.Numerics.Distributions.Normal)normalFactory.Create();
return(ΦHatResultElementFactory.Create(
sIndexElement,
lIndexElement,
ΛIndexElement,
(decimal)expectedValueΦ.GetElementAtAsdecimal(
sIndexElement,
lIndexElement,
ΛIndexElement)
+
(decimal)normal.CumulativeDistribution(
(double)(1 - υ2.GetElementAtAsdecimal(
ΛIndexElement)))
*
(decimal)Math.Pow(
Math.Sqrt(
(double)VHat.GetElementAtAsdecimal(
ΛIndexElement)),
-1)
*
(decimal)varianceΦ.GetElementAtAsdecimal(
sIndexElement,
lIndexElement,
ΛIndexElement)));
}
public decimal Calculate(
INormalFactory normalFactory,
ItIndexElement tIndexElement,
IΛIndexElement ΛIndexElement,
IExpectedValueI expectedValueI,
IVarianceI varianceI,
decimal υ2)
{
// https://stackoverflow.com/questions/1662943/standard-normal-distribution-z-value-function-in-c-sharp
MathNet.Numerics.Distributions.Normal normal = (MathNet.Numerics.Distributions.Normal)normalFactory.Create();
return
((decimal)expectedValueI.GetElementAtAsdecimal(
tIndexElement,
ΛIndexElement)
+
(decimal)normal.CumulativeDistribution((double)(1 - υ2))
*
(decimal)Math.Sqrt(
(double)varianceI.GetElementAtAsdecimal(
tIndexElement,
ΛIndexElement)));
}
internal static double probability(double x, double mean, double stdev, bool cumulative)
{
var normalDistribution = new MathNet.Numerics.Distributions.Normal(mean, stdev);
return(cumulative ? normalDistribution.CumulativeDistribution(x) : normalDistribution.Density(x));
}
//standard normal cumulative distribution function
public static double ZScore(double x)
{
MathNet.Numerics.Distributions.Normal result = new MathNet.Numerics.Distributions.Normal();
return(result.CumulativeDistribution(x));
}
public void TestMethod2()
{
List <double> inputs = new List <double>();
List <double> outputs = new List <double>();
var data = new double[] { 1, 3.1, 4.2478, 5.7856, 6.234, 7.76, 8.45, 9.37, 12, 13, 14, 3.865, 3.542, 5.54, 76, 2.354, 4.745, 6, 56, 5.4, 45, 4.235, 34, 6.43, 7.74, 4.32 };
//var data = new double[] { 1,2,2,2,2,3,3,3,3,3,3,4,4,4,4,5 };
//data = data.OrderBy(d => d).ToArray();
//ParetoShaped Data
//var data = new double[] { 10, 6.6, 5, 4, 3.3, 2.8, 2.5, 2.3, 2, 1.85 };
var mean = MathNet.Numerics.Statistics.ArrayStatistics.Mean(data);
var stDev = MathNet.Numerics.Statistics.ArrayStatistics.StandardDeviation(data);
//var distribution = new MathNet.Numerics.Distributions.Normal(mean, stDev);
var distribution = new MathNet.Numerics.Distributions.Normal(mean, stDev);
List <double> errorBefore = new List <double>();
for (int i = 0; i < data.Length; i++)
{
double cumulativeDistribution = (double)(i + 1) / (double)data.Length;
inputs.Add(cumulativeDistribution);
var actual = distribution.CumulativeDistribution(data[i]);
outputs.Add(actual);
var error = cumulativeDistribution / actual;
errorBefore.Add(error);
}
double averageErrorBefore = errorBefore.Average();
double baseLineAddition = MathNet.Numerics.Statistics.ArrayStatistics.Minimum(outputs.ToArray()) -
MathNet.Numerics.Statistics.ArrayStatistics.Minimum(inputs.ToArray());
double baseLineMultiple = 1 / (MathNet.Numerics.Statistics.ArrayStatistics.Maximum(outputs.ToArray()) - baseLineAddition);
double sigmoidAlphaValue = 1;
ActivationNetwork network = new ActivationNetwork(new SigmoidFunction(1), 1, 4, 4, 1);
//new BipolarSigmoidFunction(sigmoidAlphaValue),
//1, 3, 1);
BackPropagationLearning teacher = new BackPropagationLearning(network);
teacher.LearningRate = 0.478587;
teacher.Momentum = 0.0;
double[][] nnInputs = inputs.Select(s => new double[] { s }).ToArray();
double[][] nnOutputs = outputs.Select(s => new double[] { (s - baseLineAddition) * baseLineMultiple }).ToArray();
for (int i = 0; i < 50000; i++)
{
// run epoch of learning procedure
double error = teacher.RunEpoch(
nnInputs,
nnOutputs
) / inputs.Count;
}
List <double> errors = new List <double>();
for (int i = 0; i < nnInputs.Length; i++)
{
double actual = network.Compute(nnInputs[i])[0];
double expected = nnOutputs[i][0];
errors.Add(Math.Abs(1 - (expected / actual)));
}
double nnAverageError = errors.Average();
errors = new List <double>();
List <double[]> actuals = new List <double[]>();
for (int i = 0; i < data.Length; i++)
{
double cumulativeDistribution = (double)(i + 1) / (double)data.Length;
double aiCumulativeDistribution = network.Compute(new double[] { cumulativeDistribution })[0];
aiCumulativeDistribution = (aiCumulativeDistribution / baseLineMultiple) + baseLineAddition;
var actual = distribution.InverseCumulativeDistribution(aiCumulativeDistribution);
errors.Add(Math.Abs(1 - (data[i] / actual)));
actuals.Add(new double[] { actual, data[i] });
}
double averageError = errors.Average();
}
