public void MeanTest()
{
LognormalDistribution target = new LognormalDistribution(0.42, 0.56);
double actual = target.Mean;
Assert.AreEqual(1.7803322425420858, actual);
}
static void Main(string[] args)
{
//
// Prueba de Kolmogorov-Smirnov
//
Console.WriteLine("\nPrueba de Kolmogorov-Smirnov");
// Muestra de 25 numeros aleatorios
LognormalDistribution logNormal = new LognormalDistribution(0, 1);
WeibullDistribution weibull = new WeibullDistribution(2, 1);
// Generamos las muestras
var logNormalSample = logNormal.Sample(25);
// Construimos la prueba de Kolmogorov smirnov:
var ksTest = new OneSampleKolmogorovSmirnovTest(logNormalSample, weibull);
Console.WriteLine(logNormalSample);
Console.WriteLine("\n");
Console.WriteLine(ksTest + "\n");
// Podemos obtener el valor del estadístico de prueba a través de la propiedad Statistic
// el valor P correspondiente a través de la propiedad Probability:
Console.WriteLine("Test statistic: {0:F4}", ksTest.Statistic);
Console.WriteLine("P-value: {0:F4}", ksTest.PValue);
// Ahora podemos imprimir los resultados de la prueba:
Console.WriteLine("Rechazar la Hipotesis nula? {0}",
ksTest.Reject() ? "si" : "no");
Console.ReadLine();
}
public void VarianceTest()
{
LognormalDistribution target = new LognormalDistribution(0.42, 0.56);
double actual = target.Variance;
Assert.AreEqual(1.1674914219333172, actual);
}
public void LogNormalDistributionConstructorTest1()
{
double location = 4.1;
LognormalDistribution target = new LognormalDistribution(location);
Assert.AreEqual(location, target.Location);
}
public void LogNormalDistributionConstructorTest2()
{
LognormalDistribution target = new LognormalDistribution();
Assert.AreEqual(0, target.Location);
Assert.AreEqual(1, target.Shape);
}
/// <summary>
/// Finds the log-normal distribution that best fits the given sample.
/// </summary>
/// <param name="sample">The sample to fit.</param>
/// <returns>The best fit parameters.</returns>
/// <exception cref="ArgumentNullException"><paramref name="sample"/> is null.</exception>
/// <exception cref="InsufficientDataException"><paramref name="sample"/> contains fewer than three values.</exception>
/// <exception cref="InvalidOperationException"><paramref name="sample"/> contains non-positive values.</exception>
public static LognormalFitResult FitToLognormal(this IReadOnlyList <double> sample)
{
if (sample == null)
{
throw new ArgumentNullException(nameof(sample));
}
if (sample.Count < 3)
{
throw new InsufficientDataException();
}
// Writing out the log likelihood from p(x), taking its derivatives wrt mu and sigma, and setting them equal
// to zero to find the minimizing values, you find that the results of the normal fit are reproduced exactly
// with x -> log x, i.e. \mu = < \log x >, \sigma^2 = < (\log x - \mu)^2 >. So we just repeat the normal fit
// logic with x -> log x.
double m, dm, s, ds;
FitToNormalInternal(sample.Select(x => Math.Log(x)), out m, out dm, out s, out ds);
LognormalDistribution distribution = new LognormalDistribution(m, s);
TestResult test = sample.KolmogorovSmirnovTest(distribution);
return(new LognormalFitResult(new UncertainValue(m, dm), new UncertainValue(s, ds), distribution, test));
}
public void ConstructorTest()
{
var log = new LognormalDistribution(location: 0.42, shape: 1.1);
double mean = log.Mean; // 2.7870954605658511
double median = log.Median; // 1.5219615583481305
double var = log.Variance; // 18.28163603621158
double cdf = log.DistributionFunction(x: 0.27); // 0.057961222885664958
double pdf = log.ProbabilityDensityFunction(x: 0.27); // 0.39035530085982068
double lpdf = log.LogProbabilityDensityFunction(x: 0.27); // -0.94069792674674835
double ccdf = log.ComplementaryDistributionFunction(x: 0.27); // 0.942038777114335
double icdf = log.InverseDistributionFunction(p: cdf); // 0.26999997937815973
double hf = log.HazardFunction(x: 0.27); // 0.41437285846720867
double chf = log.CumulativeHazardFunction(x: 0.27); // 0.059708840588116374
string str = log.ToString("N2", CultureInfo.InvariantCulture); // Lognormal(x; μ = 2.79, σ = 1.10)
Assert.AreEqual(2.7870954605658511, mean);
Assert.AreEqual(1.5219615583481305, median, 1e-7);
Assert.AreEqual(18.28163603621158, var);
Assert.AreEqual(0.059708840588116374, chf);
Assert.AreEqual(0.057961222885664958, cdf);
Assert.AreEqual(0.39035530085982068, pdf);
Assert.AreEqual(-0.94069792674674835, lpdf);
Assert.AreEqual(0.41437285846720867, hf);
Assert.AreEqual(0.942038777114335, ccdf);
Assert.AreEqual(0.26999997937815973, icdf, 1e-7);
Assert.AreEqual("Lognormal(x; μ = 2.79, σ = 1.10)", str);
}
public void ConstructorTest()
{
var log = new LognormalDistribution(location: 0.42, shape: 1.1);
double mean = log.Mean; // 2.7870954605658511
double median = log.Median; // 1.5219615583481305
double var = log.Variance; // 18.28163603621158
double cdf = log.DistributionFunction(x: 0.27); // 0.057961222885664958
double pdf = log.ProbabilityDensityFunction(x: 0.27); // 0.39035530085982068
double lpdf = log.LogProbabilityDensityFunction(x: 0.27); // -0.94069792674674835
double ccdf = log.ComplementaryDistributionFunction(x: 0.27); // 0.942038777114335
double icdf = log.InverseDistributionFunction(p: cdf); // 0.26999997937815973
double hf = log.HazardFunction(x: 0.27); // 0.41437285846720867
double chf = log.CumulativeHazardFunction(x: 0.27); // 0.059708840588116374
string str = log.ToString("N2", CultureInfo.InvariantCulture); // Lognormal(x; μ = 2.79, σ = 1.10)
Assert.AreEqual(2.7870954605658511, mean);
Assert.AreEqual(1.5219615583481305, median, 1e-7);
Assert.AreEqual(18.28163603621158, var);
Assert.AreEqual(0.059708840588116374, chf);
Assert.AreEqual(0.057961222885664958, cdf);
Assert.AreEqual(0.39035530085982068, pdf);
Assert.AreEqual(-0.94069792674674835, lpdf);
Assert.AreEqual(0.41437285846720867, hf);
Assert.AreEqual(0.942038777114335, ccdf);
Assert.AreEqual(0.26999997937815973, icdf, 1e-7);
Assert.AreEqual("Lognormal(x; μ = 2.79, σ = 1.10)", str);
}
//End of ui.cs file Contents
//-------------------------------------------------------------------------
//Begin of Random.cs file contents
/// <summary>
/// Initializes the random-number generator with a specific seed.
/// </summary>
public void Initialize(uint seed)
{
RandomNumberGenerator = new MT19937Generator(seed);
betaDist = new BetaDistribution(RandomNumberGenerator);
betaPrimeDist = new BetaPrimeDistribution(RandomNumberGenerator);
cauchyDist = new CauchyDistribution(RandomNumberGenerator);
chiDist = new ChiDistribution(RandomNumberGenerator);
chiSquareDist = new ChiSquareDistribution(RandomNumberGenerator);
continuousUniformDist = new ContinuousUniformDistribution(RandomNumberGenerator);
erlangDist = new ErlangDistribution(RandomNumberGenerator);
exponentialDist = new ExponentialDistribution(RandomNumberGenerator);
fisherSnedecorDist = new FisherSnedecorDistribution(RandomNumberGenerator);
fisherTippettDist = new FisherTippettDistribution(RandomNumberGenerator);
gammaDist = new GammaDistribution(RandomNumberGenerator);
laplaceDist = new LaplaceDistribution(RandomNumberGenerator);
lognormalDist = new LognormalDistribution(RandomNumberGenerator);
normalDist = new NormalDistribution(RandomNumberGenerator);
paretoDist = new ParetoDistribution(RandomNumberGenerator);
powerDist = new PowerDistribution(RandomNumberGenerator);
rayleighDist = new RayleighDistribution(RandomNumberGenerator);
studentsTDist = new StudentsTDistribution(RandomNumberGenerator);
triangularDist = new TriangularDistribution(RandomNumberGenerator);
weibullDist = new WeibullDistribution(RandomNumberGenerator);
poissonDist = new PoissonDistribution(RandomNumberGenerator);
// generator.randomGenerator = new MT19937Generator(seed);
}
protected override void EndProcessing()
{
var dist = new LognormalDistribution(MeanLog, ScaleLog);
var obj = DistributionHelper.AddConvinienceMethods(dist);
WriteObject(obj);
}
public override void Construct()
{
this.ParameterDictionary.Add(Statistic.Location, LognormalDistribution.Estimate(data.ToArray()).Location);
this.ParameterDictionary.Add(Statistic.Shape, LognormalDistribution.Estimate(data.ToArray()).Shape);
this.ParameterDictionary.Add(Statistic.Min, data.Min());
this.ParameterDictionary.Add(Statistic.Max, data.Max());
this.ParameterDictionary.Add(Statistic.Median, data[(data.Count / 2) - 1]);
}
public void MeanTest()
{
LognormalDistribution target = new LognormalDistribution(0.42, 0.56);
double actual = target.Mean;
Assert.AreEqual(1.7803322425420858, actual, 1e-10);
Assert.IsFalse(Double.IsNaN(actual));
}
///// <summary>
///// Computes the cumulative distribution function of the binomial distribution.
///// </summary>
///// <param name="probability">The probability of success per trial.</param>
///// <param name="numberOfTrials">The number of trials.</param>
///// <param name="valueToCalculate">The value to calculate the distribution for.</param>
///// <returns>The calculated value</returns>
///// <exception cref="ArgumentOutOfRangeException">If <paramref name="probability"/> is not in the interval [0.0,1.0].</exception>
///// <exception cref="ArgumentOutOfRangeException">If <paramref name="numberOfTrials"/> is negative.</exception>
//public double Binomial(
// double probability,
// int numberOfTrials,
// double valueToCalculate)
//{
// var distribution = new BinomialDistribution(probability, numberOfTrials);
// return distribution.CumulativeDistribution(valueToCalculate);
//}
/// <summary>
/// Computes the cumulative distribution function of the lognormal distribution.
/// </summary>
/// <param name="probability">The probability of success per trial.</param>
/// <param name="numberOfTrials">The number of trials.</param>
/// <param name="valueToCalculate">The value to calculate the distribution for.</param>
/// <returns>The calculated value</returns>
/// <exception cref="ArgumentOutOfRangeException">If <paramref name="probability"/> is not in the interval [0.0,1.0].</exception>
/// <exception cref="ArgumentOutOfRangeException">If <paramref name="numberOfTrials"/> is negative.</exception>
public double LogNormal(
double probability,
int numberOfTrials,
double valueToCalculate)
{
var distribution = new LognormalDistribution(probability, numberOfTrials);
return(distribution.CumulativeDistribution(valueToCalculate));
}
public void ConstructorTest9()
{
var original = new LognormalDistribution(location: 0.42, shape: 1.1);
var log = GeneralContinuousDistribution.FromDistributionFunction(
original.Support, original.DistributionFunction);
testLognormal(log);
}
public void LogNormalDistributionConstructorTest()
{
double location = 9.2;
double shape = 4.4;
LognormalDistribution target = new LognormalDistribution(location, shape);
Assert.AreEqual(location, target.Location);
Assert.AreEqual(shape, target.Shape);
}
public void TestGetDispersion()
{
// act
double[] res = LognormalDistribution.GetlogNormal(TestDataList);
// assert
Assert.AreEqual(trueDispersion[0], res[0]);
Assert.Pass();
}
public void DistributionFunctionTest()
{
LognormalDistribution target = new LognormalDistribution(1.7, 4.2);
double x = 2.2;
double expected = 0.414090938987083;
double actual = target.DistributionFunction(x);
Assert.AreEqual(expected, actual, 1e-15);
}
public void LogProbabilityDensityFunctionTest()
{
LognormalDistribution target = new LognormalDistribution(1.7, 4.2);
double x = 2.2;
double expected = System.Math.Log(0.0421705870979553);
double actual = target.LogProbabilityDensityFunction(x);
Assert.AreEqual(expected, actual, 1e-15);
}
public void EstimateTest2()
{
double[] observations = { 0.04, 0.12, 1.52 };
double[] weights = { 0.25, 0.50, 0.25 };
LognormalDistribution actual = LognormalDistribution.Estimate(observations, weights);
Assert.AreEqual(-1.76017314060255, actual.Location, 1e-15);
Assert.AreEqual(1.6893403335885702, actual.Shape);
}
public Distribution()
{
// Brandenburg log normal distribution
double mean = 4.700;
double mode = 3.877;
double location = Math.Log(mode) + 2.0 * (Math.Log(mean) - Math.Log(mode)) / 3.0;
double shape = Math.Sqrt(2.0 * (Math.Log(mean) - Math.Log(mode)) / 3.0);
brandenburgDistribution = new LognormalDistribution(location, shape);
}
public void ConstructorTest()
{
var log = new LognormalDistribution(location: 0.42, shape: 1.1);
double mean = log.Mean; // 2.7870954605658511
double median = log.Median; // 1.5219615583481305
double var = log.Variance; // 18.28163603621158
double mode = log.Mode; // 0.45384479528235572
double cdf = log.DistributionFunction(x: 0.27); // 0.057961222885664958
double pdf = log.ProbabilityDensityFunction(x: 0.27); // 0.39035530085982068
double lpdf = log.LogProbabilityDensityFunction(x: 0.27); // -0.94069792674674835
double ccdf = log.ComplementaryDistributionFunction(x: 0.27); // 0.942038777114335
double icdf = log.InverseDistributionFunction(p: cdf); // 0.26999997937815973
double hf = log.HazardFunction(x: 0.27); // 0.41437285846720867
double chf = log.CumulativeHazardFunction(x: 0.27); // 0.059708840588116374
string str = log.ToString("N2", CultureInfo.InvariantCulture); // Lognormal(x; μ = 2.79, σ = 1.10)
Assert.AreEqual(2.7870954605658511, mean);
Assert.AreEqual(1.5219615583481305, median, 1e-7);
Assert.AreEqual(0.45384479528235572, mode);
Assert.AreEqual(18.28163603621158, var);
Assert.AreEqual(0.059708840588116374, chf);
Assert.AreEqual(0.057961222885664958, cdf);
Assert.AreEqual(0.39035530085982068, pdf);
Assert.AreEqual(-0.94069792674674835, lpdf);
Assert.AreEqual(0.41437285846720867, hf);
Assert.AreEqual(0.942038777114335, ccdf);
Assert.AreEqual(0.26999997937815973, icdf, 1e-6);
Assert.AreEqual("Lognormal(x; μ = 2.79, σ = 1.10)", str);
var range1 = log.GetRange(0.95);
Assert.AreEqual(0.24923999017902393, range1.Min);
Assert.AreEqual(9.293720885640818, range1.Max);
var range2 = log.GetRange(0.99);
Assert.AreEqual(0.11777446636476178, range2.Min);
Assert.AreEqual(19.667797655030668, range2.Max);
var range3 = log.GetRange(0.01);
Assert.AreEqual(0.11777446636476173, range3.Min);
Assert.AreEqual(19.667797655030668, range3.Max);
Assert.AreEqual(0, log.Support.Min);
Assert.AreEqual(double.PositiveInfinity, log.Support.Max);
Assert.AreEqual(log.InverseDistributionFunction(0), log.Support.Min);
Assert.AreEqual(log.InverseDistributionFunction(1), log.Support.Max);
}
public LognormalEstimate(List <double> data) : base(data)
{
if (data.Min() <= 0)
{
this.score = -1; //negative data implies it can't be Lognormal
return;
}
this.DistributionType = Distribution.Lognormal;
this.testDistribution = LognormalDistribution.Estimate(data.ToArray());
this.RunTestOfFit();
}
public void GenerateTest()
{
LognormalDistribution target = new LognormalDistribution(2, 5);
double[] samples = target.Generate(1000000);
var actual = LognormalDistribution.Estimate(samples);
actual.Fit(samples);
Assert.AreEqual(2, actual.Location, 0.01);
Assert.AreEqual(5, actual.Shape, 0.01);
}
public void StandardTest()
{
LognormalDistribution actual = LognormalDistribution.Standard;
Assert.AreEqual(0, actual.Location);
Assert.AreEqual(1, actual.Shape);
bool thrown = false;
try { actual.Fit(new[] { 0.0 }); }
catch (InvalidOperationException) { thrown = true; }
Assert.IsTrue(thrown);
}
private void CalculateBrandenburgRange()
{
double mean = 4700.0;
double mode = 3877.0;
double location = System.Math.Log(mode) + 2.0 * (System.Math.Log(mean) - System.Math.Log(mode)) / 3.0;
double shape = System.Math.Sqrt(2.0 * (System.Math.Log(mean) - System.Math.Log(mode)) / 3.0);
LognormalDistribution logNormal = new LognormalDistribution(location, shape);
DoubleRange range = logNormal.GetRange(0.95);
SqlGeography geoCenter = SqlGeography.Point(brandenburgGate.Latitude, brandenburgGate.Longitude, 4326);
geoBrandenburgRange = geoCenter.STBuffer(mode);
GeoRangeToPolygon(geoBrandenburgRange, brandenburgRange);
}
public void CloneTest()
{
LognormalDistribution target = new LognormalDistribution(1.7, 4.2);
LognormalDistribution clone = (LognormalDistribution)target.Clone();
Assert.AreNotSame(target, clone);
Assert.AreEqual(target.Entropy, clone.Entropy);
Assert.AreEqual(target.Location, clone.Location);
Assert.AreEqual(target.Mean, clone.Mean);
Assert.AreEqual(target.Shape, clone.Shape);
Assert.AreEqual(target.StandardDeviation, clone.StandardDeviation);
Assert.AreEqual(target.Variance, clone.Variance);
}
public void EstimateTest()
{
double[] observations = { 2, 2, 2, 2, 2 };
NormalOptions options = new NormalOptions()
{
Regularization = 0.1
};
LognormalDistribution actual = LognormalDistribution.Estimate(observations, options);
Assert.AreEqual(System.Math.Log(2), actual.Location);
Assert.AreEqual(System.Math.Sqrt(0.1), actual.Shape);
}
public FuncionLogNormal(double[] eventos) : base(eventos)
{
try
{
DistribucionContinua = new LognormalDistribution();
DistribucionContinua.Fit(eventos);
media = ((LognormalDistribution)DistribucionContinua).Mean.ToString("0.0000");
sigma = ((LognormalDistribution)DistribucionContinua).StandardDeviation.ToString("0.0000");
Resultado = new ResultadoAjuste(StringFDP, StringInversa, DistribucionContinua.StandardDeviation, DistribucionContinua.Mean, DistribucionContinua.Variance, this);
}
catch (Exception)
{
Resultado = null;
}
}
public void BivariateNullAssociation()
{
Random rng = new Random(31415926);
// Create a data structure to hold the results of Pearson, Spearman, and Kendall tests.
FrameTable data = new FrameTable();
data.AddColumn <double>("r");
data.AddColumn <double>("ρ");
data.AddColumn <double>("τ");
// Create variables to hold the claimed distribution of each test statistic.
ContinuousDistribution PRD = null;
ContinuousDistribution SRD = null;
ContinuousDistribution KTD = null;
// Generate a large number of bivariate samples and conduct our three tests on each.
ContinuousDistribution xDistribution = new LognormalDistribution();
ContinuousDistribution yDistribution = new CauchyDistribution();
for (int j = 0; j < 100; j++)
{
List <double> x = new List <double>();
List <double> y = new List <double>();
for (int i = 0; i < 100; i++)
{
x.Add(xDistribution.GetRandomValue(rng));
y.Add(yDistribution.GetRandomValue(rng));
}
TestResult PR = Bivariate.PearsonRTest(x, y);
TestResult SR = Bivariate.SpearmanRhoTest(x, y);
TestResult KT = Bivariate.KendallTauTest(x, y);
PRD = PR.Statistic.Distribution;
SRD = SR.Statistic.Distribution;
KTD = KT.Statistic.Distribution;
data.AddRow(new Dictionary <string, object>()
{
{ "r", PR.Statistic.Value }, { "ρ", SR.Statistic.Value }, { "τ", KT.Statistic.Value }
});
}
Assert.IsTrue(data["r"].As <double>().KolmogorovSmirnovTest(PRD).Probability > 0.05);
Assert.IsTrue(data["ρ"].As <double>().KolmogorovSmirnovTest(SRD).Probability > 0.05);
Assert.IsTrue(data["τ"].As <double>().KolmogorovSmirnovTest(KTD).Probability > 0.05);
}
public void EstimateTest1()
{
double[] observations =
{
1.26, 0.34, 0.70, 1.75, 50.57, 1.55, 0.08, 0.42, 0.50, 3.20,
0.15, 0.49, 0.95, 0.24, 1.37, 0.17, 6.98, 0.10, 0.94, 0.38
};
LognormalDistribution actual = LognormalDistribution.Estimate(observations);
double expectedLocation = -0.307069523211925;
double expectedShape = 1.51701553338489;
Assert.AreEqual(expectedLocation, actual.Location, 1e-15);
Assert.AreEqual(expectedShape, actual.Shape, 1e-14);
}
public void ConstructorTest()
{
var log = new LognormalDistribution(location: 0.42, shape: 1.1);
double mean = log.Mean; // 2.7870954605658511
double median = log.Median; // 1.5219615583481305
double var = log.Variance; // 18.28163603621158
double mode = log.Mode; // 0.45384479528235572
double cdf = log.DistributionFunction(x: 0.27); // 0.057961222885664958
double pdf = log.ProbabilityDensityFunction(x: 0.27); // 0.39035530085982068
double lpdf = log.LogProbabilityDensityFunction(x: 0.27); // -0.94069792674674835
double ccdf = log.ComplementaryDistributionFunction(x: 0.27); // 0.942038777114335
double icdf = log.InverseDistributionFunction(p: cdf); // 0.26999997937815973
double hf = log.HazardFunction(x: 0.27); // 0.41437285846720867
double chf = log.CumulativeHazardFunction(x: 0.27); // 0.059708840588116374
string str = log.ToString("N2", CultureInfo.InvariantCulture); // Lognormal(x; μ = 2.79, σ = 1.10)
Assert.AreEqual(2.7870954605658511, mean);
Assert.AreEqual(1.5219615583481305, median, 1e-7);
Assert.AreEqual(0.45384479528235572, mode);
Assert.AreEqual(18.28163603621158, var);
Assert.AreEqual(0.059708840588116374, chf);
Assert.AreEqual(0.057961222885664958, cdf);
Assert.AreEqual(0.39035530085982068, pdf);
Assert.AreEqual(-0.94069792674674835, lpdf);
Assert.AreEqual(0.41437285846720867, hf);
Assert.AreEqual(0.942038777114335, ccdf);
Assert.AreEqual(0.26999997937815973, icdf, 1e-6);
Assert.AreEqual("Lognormal(x; μ = 2.79, σ = 1.10)", str);
var range1 = log.GetRange(0.95);
Assert.AreEqual(0.24923999017902393, range1.Min);
Assert.AreEqual(9.293720885640818, range1.Max);
var range2 = log.GetRange(0.99);
Assert.AreEqual(0.11777446636476178, range2.Min);
Assert.AreEqual(19.667797655030668, range2.Max);
var range3 = log.GetRange(0.01);
Assert.AreEqual(0.11777446636476173, range3.Min);
Assert.AreEqual(19.667797655030668, range3.Max);
}
public void GenerateTest2()
{
LognormalDistribution target = new LognormalDistribution(4, 2);
double[] samples = new double[1000000];
for (int i = 0; i < samples.Length; i++)
{
samples[i] = target.Generate();
}
var actual = LognormalDistribution.Estimate(samples);
actual.Fit(samples);
Assert.AreEqual(4, actual.Location, 0.01);
Assert.AreEqual(2, actual.Shape, 0.01);
}
public void KolmogorovNullDistributionTest()
{
// The distribution is irrelevent; pick one at random
Distribution sampleDistribution = new LognormalDistribution();
// Loop over various sample sizes
foreach (int n in TestUtilities.GenerateIntegerValues(2, 128, 16)) {
// Create a sample to hold the KS statistics
Sample testStatistics = new Sample();
// and a variable to hold the claimed null distribution, which should be the same for each test
Distribution nullDistribution = null;
// Create a bunch of samples, each with n data points
for (int i = 0; i < 256; i++) {
// Just use n+i as a seed in order to get different points each time
Sample sample = TestUtilities.CreateSample(sampleDistribution, n, 512 * n + i + 1);
// Do a KS test of the sample against the distribution each time
TestResult r1 = sample.KolmogorovSmirnovTest(sampleDistribution);
// Record the test statistic value and the claimed null distribution
testStatistics.Add(r1.Statistic);
nullDistribution = r1.Distribution;
}
// Do a Kuiper test of our sample of KS statistics against the claimed null distribution
// We could use a KS test here instead, which would be way cool and meta, but we picked Kuiper instead for variety
TestResult r2 = testStatistics.KuiperTest(nullDistribution);
Console.WriteLine("{0} {1} {2}", n, r2.Statistic, r2.LeftProbability);
Assert.IsTrue(r2.RightProbability > 0.05);
// Test moment matches, too
Console.WriteLine(" {0} {1}", testStatistics.PopulationMean, nullDistribution.Mean);
Console.WriteLine(" {0} {1}", testStatistics.PopulationVariance, nullDistribution.Variance);
Assert.IsTrue(testStatistics.PopulationMean.ConfidenceInterval(0.99).ClosedContains(nullDistribution.Mean));
Assert.IsTrue(testStatistics.PopulationVariance.ConfidenceInterval(0.99).ClosedContains(nullDistribution.Variance));
}
}
public void CloneTest()
{
LognormalDistribution target = new LognormalDistribution(1.7, 4.2);
LognormalDistribution clone = (LognormalDistribution)target.Clone();
Assert.AreNotSame(target, clone);
Assert.AreEqual(target.Entropy, clone.Entropy);
Assert.AreEqual(target.Location, clone.Location);
Assert.AreEqual(target.Mean, clone.Mean);
Assert.AreEqual(target.Shape, clone.Shape);
Assert.AreEqual(target.StandardDeviation, clone.StandardDeviation);
Assert.AreEqual(target.Variance, clone.Variance);
}
public void LogNormalDistributionConstructorTest2()
{
LognormalDistribution target = new LognormalDistribution();
Assert.AreEqual(0, target.Location);
Assert.AreEqual(1, target.Shape);
}
public void LogNormalDistributionConstructorTest1()
{
double location = 4.1;
LognormalDistribution target = new LognormalDistribution(location);
Assert.AreEqual(location, target.Location);
}
public void ConstructorTest9()
{
var original = new LognormalDistribution(location: 0.42, shape: 1.1);
var log = GeneralContinuousDistribution.FromDistributionFunction(
original.Support, original.DistributionFunction);
testLognormal(log);
}
public void LogNormalDistributionConstructorTest()
{
double location = 9.2;
double shape = 4.4;
LognormalDistribution target = new LognormalDistribution(location, shape);
Assert.AreEqual(location, target.Location);
Assert.AreEqual(shape, target.Shape);
}
public void MeanTest()
{
LognormalDistribution target = new LognormalDistribution(0.42, 0.56);
double actual = target.Mean;
Assert.AreEqual(1.7803322425420858, actual, 1e-10);
Assert.IsFalse(Double.IsNaN(actual));
}
public void GenerateTest()
{
Accord.Math.Tools.SetupGenerator(0);
LognormalDistribution target = new LognormalDistribution(2, 5);
double[] samples = target.Generate(1000000);
var actual = LognormalDistribution.Estimate(samples);
actual.Fit(samples);
Assert.AreEqual(2, actual.Location, 0.01);
Assert.AreEqual(5, actual.Shape, 0.01);
}
public void MedianTest()
{
LognormalDistribution target = new LognormalDistribution(7, 0.6);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
public void LognormalFit()
{
LognormalDistribution distribution = new LognormalDistribution(1.0, 2.0);
Sample sample = CreateSample(distribution, 100);
// fit to normal should be bad
FitResult nfit = NormalDistribution.FitToSample(sample);
Console.WriteLine("P_n = {0}", nfit.GoodnessOfFit.LeftProbability);
Assert.IsTrue(nfit.GoodnessOfFit.LeftProbability > 0.95);
// fit to lognormal should be good
FitResult efit = LognormalDistribution.FitToSample(sample);
Console.WriteLine("P_e = {0}", efit.GoodnessOfFit.LeftProbability);
Assert.IsTrue(efit.GoodnessOfFit.LeftProbability < 0.95);
Assert.IsTrue(efit.Parameter(0).ConfidenceInterval(0.95).ClosedContains(distribution.Mu));
Assert.IsTrue(efit.Parameter(1).ConfidenceInterval(0.95).ClosedContains(distribution.Sigma));
}
public void SampleMaximumLikelihoodFit()
{
// normal distriubtion
Console.WriteLine("normal");
double mu = -1.0;
double sigma = 2.0;
Distribution nd = new NormalDistribution(mu, sigma);
Sample ns = CreateSample(nd, 500);
//FitResult nr = ns.MaximumLikelihoodFit(new NormalDistribution(mu + 1.0, sigma + 1.0));
FitResult nr = ns.MaximumLikelihoodFit((IList<double> p) => new NormalDistribution(p[0], p[1]), new double[] { mu + 1.0, sigma + 1.0 });
Console.WriteLine(nr.Parameter(0));
Console.WriteLine(nr.Parameter(1));
Assert.IsTrue(nr.Dimension == 2);
Assert.IsTrue(nr.Parameter(0).ConfidenceInterval(0.95).ClosedContains(mu));
Assert.IsTrue(nr.Parameter(1).ConfidenceInterval(0.95).ClosedContains(sigma));
FitResult nr2 = NormalDistribution.FitToSample(ns);
Console.WriteLine(nr.Covariance(0,1));
// test analytic expression
Assert.IsTrue(TestUtilities.IsNearlyEqual(nr.Parameter(0).Value, ns.Mean, Math.Sqrt(TestUtilities.TargetPrecision)));
// we don't expect to be able to test sigma against analytic expression because ML value has known bias for finite sample size
// exponential distribution
Console.WriteLine("exponential");
double em = 3.0;
Distribution ed = new ExponentialDistribution(em);
Sample es = CreateSample(ed, 100);
//FitResult er = es.MaximumLikelihoodFit(new ExponentialDistribution(em + 1.0));
FitResult er = es.MaximumLikelihoodFit((IList<double> p) => new ExponentialDistribution(p[0]), new double[] { em + 1.0 });
Console.WriteLine(er.Parameter(0));
Assert.IsTrue(er.Dimension == 1);
Assert.IsTrue(er.Parameter(0).ConfidenceInterval(0.95).ClosedContains(em));
// test against analytic expression
Assert.IsTrue(TestUtilities.IsNearlyEqual(er.Parameter(0).Value, es.Mean, Math.Sqrt(TestUtilities.TargetPrecision)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(er.Parameter(0).Uncertainty, es.Mean / Math.Sqrt(es.Count), Math.Sqrt(Math.Sqrt(TestUtilities.TargetPrecision))));
// lognormal distribution
Console.WriteLine("lognormal");
double l1 = -4.0;
double l2 = 5.0;
Distribution ld = new LognormalDistribution(l1, l2);
Sample ls = CreateSample(ld, 100);
//FitResult lr = ls.MaximumLikelihoodFit(new LognormalDistribution(l1 + 1.0, l2 + 1.0));
FitResult lr = ls.MaximumLikelihoodFit((IList<double> p) => new LognormalDistribution(p[0], p[1]), new double[] { l1 + 1.0, l2 + 1.0 });
Console.WriteLine(lr.Parameter(0));
Console.WriteLine(lr.Parameter(1));
Console.WriteLine(lr.Covariance(0, 1));
Assert.IsTrue(lr.Dimension == 2);
Assert.IsTrue(lr.Parameter(0).ConfidenceInterval(0.99).ClosedContains(l1));
Assert.IsTrue(lr.Parameter(1).ConfidenceInterval(0.99).ClosedContains(l2));
// weibull distribution
Console.WriteLine("weibull");
double w_scale = 4.0;
double w_shape = 2.0;
WeibullDistribution w_d = new WeibullDistribution(w_scale, w_shape);
Sample w_s = CreateSample(w_d, 20);
//FitResult w_r = w_s.MaximumLikelihoodFit(new WeibullDistribution(1.0, 0.5));
FitResult w_r = w_s.MaximumLikelihoodFit((IList<double> p) => new WeibullDistribution(p[0], p[1]), new double[] { 2.0, 2.0 });
Console.WriteLine(w_r.Parameter(0));
Console.WriteLine(w_r.Parameter(1));
Console.WriteLine(w_r.Covariance(0, 1));
Assert.IsTrue(w_r.Parameter(0).ConfidenceInterval(0.95).ClosedContains(w_d.ScaleParameter));
Assert.IsTrue(w_r.Parameter(1).ConfidenceInterval(0.95).ClosedContains(w_d.ShapeParameter));
// logistic distribution
Console.WriteLine("logistic");
double logistic_m = -3.0;
double logistic_s = 2.0;
Distribution logistic_distribution = new LogisticDistribution(logistic_m, logistic_s);
Sample logistic_sample = CreateSample(logistic_distribution, 100);
//FitResult logistic_result = logistic_sample.MaximumLikelihoodFit(new LogisticDistribution());
FitResult logistic_result = logistic_sample.MaximumLikelihoodFit((IList<double> p) => new LogisticDistribution(p[0], p[1]), new double[] { 2.0, 3.0 });
Console.WriteLine(logistic_result.Parameter(0));
Console.WriteLine(logistic_result.Parameter(1));
Assert.IsTrue(logistic_result.Dimension == 2);
Assert.IsTrue(logistic_result.Parameter(0).ConfidenceInterval(0.95).ClosedContains(logistic_m));
Assert.IsTrue(logistic_result.Parameter(1).ConfidenceInterval(0.95).ClosedContains(logistic_s));
// beta distribution
// not yet!
/*
double beta_alpha = 0.5;
double beta_beta = 2.0;
Distribution beta_distribution = new BetaDistribution(beta_alpha, beta_beta);
Sample beta_sample = CreateSample(beta_distribution, 100);
FitResult beta_result = beta_sample.MaximumLikelihoodFit(new BetaDistribution(1.0, 1.0));
Console.WriteLine("Beta:");
Console.WriteLine(beta_result.Parameter(0));
Console.WriteLine(beta_result.Parameter(1));
Assert.IsTrue(beta_result.Dimension == 2);
Assert.IsTrue(beta_result.Parameter(0).ConfidenceInterval(0.95).ClosedContains(beta_alpha));
Assert.IsTrue(beta_result.Parameter(1).ConfidenceInterval(0.95).ClosedContains(beta_beta));
*/
}
/// <summary>
/// Updates the given chart with the specified distribution.
/// </summary>
/// <param name="chart">A chart.</param>
/// <param name="dist">The distribution.</param>
/// <param name="function">The distribution function to plot.</param>
/// <param name="numInterpolatedValues">The number of interpolated values.</param>
/// <returns>A new chart.</returns>
/// <remarks>
/// Plots the specified function of the given distribution for 0.0001 <= p <= 0.9999.
/// <br/>
/// Titles are added only if chart does not currently contain any titles.
/// <br/>
/// chart.Series[0] is replaced, or added if necessary.
/// </remarks>
public static void Update( ref ChartControl chart, LognormalDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 )
{
List<string> titles = new List<string>()
{
"LognormalDistribution",
String.Format("\u03BC={0}, \u03C3={1}", dist.Mu, dist.Sigma)
};
UpdateContinuousDistribution( ref chart, dist, titles, function, numInterpolatedValues );
}
public void DistributionFunctionTest()
{
LognormalDistribution target = new LognormalDistribution(1.7, 4.2);
double x = 2.2;
double expected = 0.414090938987083;
double actual = target.DistributionFunction(x);
Assert.AreEqual(expected, actual, 1e-15);
}
public void ConstructorTest9()
{
var original = new LognormalDistribution(location: 0.42, shape: 1.1);
var log = GeneralContinuousDistribution.FromDistributionFunction(
original.Support, original.DistributionFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.ProbabilityDensityFunction(i);
double actual = log.ProbabilityDensityFunction(i);
Assert.IsTrue(expected.IsRelativelyEqual(actual, 1e-7));
Assert.AreEqual(expected, actual, 1e-8);
}
testLognormal(log);
}
public void LogProbabilityDensityFunctionTest()
{
LognormalDistribution target = new LognormalDistribution(1.7, 4.2);
double x = 2.2;
double expected = System.Math.Log(0.0421705870979553);
double actual = target.LogProbabilityDensityFunction(x);
Assert.AreEqual(expected, actual, 1e-15);
}
/// <summary>
/// Shows a new chart in a default form.
/// </summary>
/// <param name="dist">The distribution.</param>
/// <param name="function">The distribution function to plot.</param>
/// <param name="numInterpolatedValues">The number of interpolated values.</param>
/// <remarks>
/// Equivalent to:
/// <code>
/// NMathStatsChart.Show( ToChart( dist, function, numInterpolatedValues ) );
/// </code>
/// </remarks>
public static void Show( LognormalDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 )
{
Show( ToChart( dist, function, numInterpolatedValues ) );
}
public void VarianceTest()
{
LognormalDistribution target = new LognormalDistribution(0.42, 0.56);
double actual = target.Variance;
Assert.AreEqual(1.1674914219333172, actual);
}
/// <summary>
/// Returns a new line chart plotting the specified function of the given distribution for 0.0001 <= p <= 0.9999.
/// </summary>
/// <param name="dist">The distribution.</param>
/// <param name="function">The distribution function to plot.</param>
/// <param name="numInterpolatedValues">The number of interpolated values.</param>
/// <returns>A new chart.</returns>
public static ChartControl ToChart( LognormalDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 )
{
ChartControl chart = GetDefaultChart();
Update( ref chart, dist, function, numInterpolatedValues );
return chart;
}
public void GenerateTest2()
{
LognormalDistribution target = new LognormalDistribution(4, 2);
double[] samples = new double[1000000];
for (int i = 0; i < samples.Length; i++)
samples[i] = target.Generate();
var actual = LognormalDistribution.Estimate(samples);
actual.Fit(samples);
Assert.AreEqual(4, actual.Location, 0.01);
Assert.AreEqual(2, actual.Shape, 0.01);
}
public void MeanTest()
{
LognormalDistribution target = new LognormalDistribution(0.42, 0.56);
double actual = target.Mean;
Assert.AreEqual(1.7803322425420858, actual);
}
//---------------------------------------------------------------------
public static double ComputeSize(double meanSize, double sd, SizeType fireSizeType)
{
if (fireSizeType == SizeType.duration_based)
{
//-----Edited by BRM-----
LognormalDistribution randVar = new LognormalDistribution(RandomNumberGenerator.Singleton);
//NormalDistribution randVar = new NormalDistribution(RandomNumberGenerator.Singleton);
//GammaDistribution randVar = new GammaDistribution(RandomNumberGenerator.Singleton);
//----------
randVar.Mu = meanSize; //randVar.Mu for Lognormal //randVar.Alpha for Gamma
randVar.Sigma = sd; //randVar.Sigma for Lognormal //randVar.Theta for Gamma
double sizeGenerated = randVar.NextDouble();
if (sizeGenerated < 0)
return 0;
else
return (sizeGenerated);
}
else if (fireSizeType == SizeType.size_based)
{
LognormalDistribution randVar = new LognormalDistribution(RandomNumberGenerator.Singleton);
//NormalDistribution randVar = new NormalDistribution(RandomNumberGenerator.Singleton);
//GammaDistribution randVar = new GammaDistribution(RandomNumberGenerator.Singleton);
randVar.Mu = meanSize; //randVar.Mu for Lognormal //randVar.Alpha for Gamma
randVar.Sigma = sd; //randVar.Sigma for Lognormal //randVar.Theta for Gamma
double sizeGenerated = randVar.NextDouble();
if (sizeGenerated <= 0)
return 0;
return (sizeGenerated);
}
return 0.0;
}
public void ConstructorTest8()
{
var original = new LognormalDistribution(location: 0.42, shape: 1.1);
var log = GeneralContinuousDistribution.FromDensityFunction(
original.Support, original.ProbabilityDensityFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.DistributionFunction(i);
double actual = log.DistributionFunction(i);
double diff = Math.Abs(expected - actual);
Assert.AreEqual(expected, actual, 1e-2);
Assert.IsFalse(Double.IsNaN(expected));
Assert.IsFalse(Double.IsNaN(actual));
}
testLognormal(log);
}
public void SamplePopulationMomentEstimateVariances()
{
Distribution d = new LognormalDistribution();
// for various sample sizes...
foreach (int n in TestUtilities.GenerateIntegerValues(4, 32, 8)) {
Console.WriteLine("n={0}", n);
// we are going to store values for a bunch of estimators and their uncertainties
MultivariateSample estimates = new MultivariateSample("M1", "C2", "C3", "C4");
MultivariateSample variances = new MultivariateSample("M1", "C2", "C3", "C4");
// create a bunch of samples
for (int i = 0; i < 256; i++) {
Sample s = TestUtilities.CreateSample(d, n, 512 * n + i + 1);
UncertainValue M1 = s.PopulationMean;
UncertainValue C2 = s.PopulationVariance;
UncertainValue C3 = s.PopulationMomentAboutMean(3);
UncertainValue C4 = s.PopulationMomentAboutMean(4);
estimates.Add(M1.Value, C2.Value, C3.Value, C4.Value);
variances.Add(MoreMath.Sqr(M1.Uncertainty), MoreMath.Sqr(C2.Uncertainty), MoreMath.Sqr(C3.Uncertainty), MoreMath.Sqr(C4.Uncertainty));
}
// the claimed variance should agree with the measured variance of the estimators
for (int c = 0; c < estimates.Dimension; c++) {
Console.WriteLine("{0} {1} {2}", estimates.Column(c).Name, estimates.Column(c).PopulationVariance, variances.Column(c).Mean);
Assert.IsTrue(estimates.Column(c).PopulationVariance.ConfidenceInterval(0.95).ClosedContains(variances.Column(c).Mean));
}
}
}
//---------------------------------------------------------------------
private static double GenerateRandomNum(Distribution dist, double parameter1, double parameter2)
{
double randomNum = 0.0;
if(dist == Distribution.normal)
{
NormalDistribution randVar = new NormalDistribution(RandomNumberGenerator.Singleton);
randVar.Mu = parameter1; // mean
randVar.Sigma = parameter2; // std dev
randomNum = randVar.NextDouble();
}
if(dist == Distribution.lognormal)
{
LognormalDistribution randVar = new LognormalDistribution(RandomNumberGenerator.Singleton);
randVar.Mu = parameter1; // mean
randVar.Sigma = parameter2; // std dev
randomNum = randVar.NextDouble();
}
if(dist == Distribution.gamma)
{
GammaDistribution randVar = new GammaDistribution(RandomNumberGenerator.Singleton);
randVar.Alpha = parameter1; // mean
randVar.Theta = parameter2; // std dev
randomNum = randVar.NextDouble();
}
if(dist == Distribution.Weibull)
{
WeibullDistribution randVar = new WeibullDistribution(RandomNumberGenerator.Singleton);
randVar.Alpha = parameter1; // mean
randVar.Lambda = parameter2; // std dev
randomNum = randVar.NextDouble();
}
return randomNum;
}
