protected override void EndProcessing()
{
var dist = new LogisticDistribution(Location, Scale);
var obj = DistributionHelper.AddConvinienceMethods(dist);
WriteObject(obj);
}
public void LogisticTest()
{
var target = new TukeyLambdaDistribution(lambda: 0);
var logistic = new LogisticDistribution();
compare(target, logistic, 1e-5);
}
public void KendallNullDistributionTest()
{
// Pick independent distributions for x and y, which needn't be normal and needn't be related.
ContinuousDistribution xDistrubtion = new LogisticDistribution();
ContinuousDistribution yDistribution = new ExponentialDistribution();
Random rng = new Random(314159265);
// generate bivariate samples of various sizes
foreach (int n in TestUtilities.GenerateIntegerValues(8, 64, 4))
{
Sample testStatistics = new Sample();
ContinuousDistribution testDistribution = null;
for (int i = 0; i < 128; i++)
{
BivariateSample sample = new BivariateSample();
for (int j = 0; j < n; j++)
{
sample.Add(xDistrubtion.GetRandomValue(rng), yDistribution.GetRandomValue(rng));
}
TestResult result = sample.KendallTauTest();
testStatistics.Add(result.Statistic);
testDistribution = result.Distribution;
}
TestResult r2 = testStatistics.KolmogorovSmirnovTest(testDistribution);
Assert.IsTrue(r2.RightProbability > 0.05);
Assert.IsTrue(testStatistics.PopulationMean.ConfidenceInterval(0.99).ClosedContains(testDistribution.Mean));
Assert.IsTrue(testStatistics.PopulationVariance.ConfidenceInterval(0.99).ClosedContains(testDistribution.Variance));
}
}
public void ConstructorTest1()
{
var log = new LogisticDistribution(location: 0.42, scale: 1.2);
double mean = log.Mean; // 0.42
double median = log.Median; // 0.42
double mode = log.Mode; // 0.42
double var = log.Variance; // 4.737410112522892
double cdf = log.DistributionFunction(x: 1.4); // 0.693528308197921
double pdf = log.ProbabilityDensityFunction(x: 1.4); // 0.17712232827170876
double lpdf = log.LogProbabilityDensityFunction(x: 1.4); // -1.7309146649427332
double ccdf = log.ComplementaryDistributionFunction(x: 1.4); // 0.306471691802079
double icdf = log.InverseDistributionFunction(p: cdf); // 1.3999999999999997
double hf = log.HazardFunction(x: 1.4); // 0.57794025683160088
double chf = log.CumulativeHazardFunction(x: 1.4); // 1.1826298874077226
string str = log.ToString(CultureInfo.InvariantCulture); // Logistic(x; μ = 0.42, scale = 1.2)
Assert.AreEqual(0.41999999999999998, mean);
Assert.AreEqual(0.41999999999999998, median);
Assert.AreEqual(4.737410112522892, var);
Assert.AreEqual(1.1826298874077226, chf);
Assert.AreEqual(0.693528308197921, cdf);
Assert.AreEqual(0.17712232827170876, pdf);
Assert.AreEqual(-1.7309146649427332, lpdf);
Assert.AreEqual(0.57794025683160088, hf);
Assert.AreEqual(0.306471691802079, ccdf);
Assert.AreEqual(1.3999999999999997, icdf);
Assert.AreEqual("Logistic(x; μ = 0.42, scale = 1.2)", str);
}
// Идеальное количество людей для остановки без округления
public static double GetAvg(int PassengerCount, double PeakTime, double PeakWidth, int Minute, int StationCount)
{
LogisticDistribution logis = new LogisticDistribution(PeakTime, PeakWidth);
double res = PassengerCount * logis.ProbabilityDensity(Minute) / StationCount;
logis = null;
return(res);
}
public void LinearRegressionVariances()
{
// do a set of logistic regression fits
// make sure not only that the fit parameters are what they should be, but that their variances/covariances are as returned
Random rng = new Random(314159);
// define line parameters
double a0 = 2.0; double b0 = -1.0;
// do a lot of fits, recording results of each
FrameTable data = new FrameTable();
data.AddColumns <double>("a", "va", "b", "vb", "abCov", "p", "dp");
for (int k = 0; k < 128; k++)
{
// we should be able to draw x's from any distribution; noise should be drawn from a normal distribution
ContinuousDistribution xd = new LogisticDistribution();
ContinuousDistribution nd = new NormalDistribution(0.0, 2.0);
// generate a synthetic data set
BivariateSample sample = new BivariateSample();
for (int i = 0; i < 12; i++)
{
double x = xd.GetRandomValue(rng);
double y = a0 + b0 * x + nd.GetRandomValue(rng);
sample.Add(x, y);
}
// do the regression
LinearRegressionResult result = sample.LinearRegression();
// record result
UncertainValue p = result.Predict(12.0);
data.AddRow(new Dictionary <string, object>()
{
{ "a", result.Intercept.Value },
{ "va", result.Parameters.VarianceOf("Intercept") },
{ "b", result.Slope.Value },
{ "vb", result.Parameters.VarianceOf("Slope") },
{ "abCov", result.Parameters.CovarianceOf("Slope", "Intercept") },
{ "p", p.Value },
{ "dp", p.Uncertainty }
});
}
// variances of parameters should agree with predictions
Assert.IsTrue(data["a"].As <double>().PopulationVariance().ConfidenceInterval(0.99).ClosedContains(data["va"].As <double>().Median()));
Assert.IsTrue(data["b"].As <double>().PopulationVariance().ConfidenceInterval(0.99).ClosedContains(data["vb"].As <double>().Median()));
Assert.IsTrue(data["a"].As <double>().PopulationCovariance(data["b"].As <double>()).ConfidenceInterval(0.99).ClosedContains(data["abCov"].As <double>().Median()));
// variance of prediction should agree with claim
Assert.IsTrue(data["p"].As <double>().PopulationStandardDeviation().ConfidenceInterval(0.99).ClosedContains(data["dp"].As <double>().Median()));
}
public void TestLogistic()
{
ProbabilityDistribution normal = new LogisticDistribution(location: 0, scale: 1);
double[] tester = new double[100];
for (var i = 0; i < 100; i++)
{
tester[i] = normal.NextDouble();
}
string jsonResult = JsonConvert.SerializeObject(tester);
}
public void ConstructorTest1()
{
var log = new LogisticDistribution(location: 0.42, scale: 1.2);
double mean = log.Mean; // 0.42
double median = log.Median; // 0.42
double mode = log.Mode; // 0.42
double var = log.Variance; // 4.737410112522892
double cdf = log.DistributionFunction(x: 1.4); // 0.693528308197921
double pdf = log.ProbabilityDensityFunction(x: 1.4); // 0.17712232827170876
double lpdf = log.LogProbabilityDensityFunction(x: 1.4); // -1.7309146649427332
double ccdf = log.ComplementaryDistributionFunction(x: 1.4); // 0.306471691802079
double icdf = log.InverseDistributionFunction(p: cdf); // 1.3999999999999997
double hf = log.HazardFunction(x: 1.4); // 0.57794025683160088
double chf = log.CumulativeHazardFunction(x: 1.4); // 1.1826298874077226
string str = log.ToString(CultureInfo.InvariantCulture); // Logistic(x; μ = 0.42, s = 1.2)
Assert.AreEqual(0.41999999999999998, mean);
Assert.AreEqual(0.41999999999999998, median);
Assert.AreEqual(0.41999999999999998, mode);
Assert.AreEqual(4.737410112522892, var);
Assert.AreEqual(1.1826298874077226, chf);
Assert.AreEqual(0.693528308197921, cdf);
Assert.AreEqual(0.17712232827170876, pdf);
Assert.AreEqual(-1.7309146649427332, lpdf);
Assert.AreEqual(0.57794025683160088, hf);
Assert.AreEqual(0.306471691802079, ccdf);
Assert.AreEqual(1.3999999999999997, icdf);
Assert.AreEqual("Logistic(x; μ = 0.42, s = 1.2)", str);
var range1 = log.GetRange(0.95);
var range2 = log.GetRange(0.99);
var range3 = log.GetRange(0.01);
Assert.AreEqual(-3.1133267749997273, range1.Min);
Assert.AreEqual(3.9533267749997272, range1.Max);
Assert.AreEqual(-5.0941438201615066, range2.Min);
Assert.AreEqual(5.9341438201615064, range2.Max);
Assert.AreEqual(-5.0941438201615075, range3.Min);
Assert.AreEqual(5.9341438201615064, range3.Max);
Assert.AreEqual(double.NegativeInfinity, 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 void EquivalencyTest3()
{
// when ksi -> 0, the shifted log-logistic reduces to the logistic distribution.
double sigma = 0.42; // scale
double ksi = 0; // shape
double mu = 2.4; // location
var target = new ShiftedLogLogisticDistribution(location: mu, scale: sigma, shape: ksi);
var log = new LogisticDistribution(mu, sigma);
Assert.AreEqual(log.Mean, target.Mean);
Assert.AreEqual(log.Median, target.Median);
Assert.AreEqual(log.Mode, target.Mode);
Assert.AreEqual(log.Variance, target.Variance);
double actual, expected;
for (double i = -10; i < 10; i += 0.1)
{
expected = log.DistributionFunction(i);
actual = target.DistributionFunction(i);
Assert.IsTrue(expected.IsRelativelyEqual(actual, 1e-15));
expected = log.ProbabilityDensityFunction(i);
actual = target.ProbabilityDensityFunction(i);
Assert.IsTrue(expected.IsRelativelyEqual(actual, 1e-15));
expected = log.LogProbabilityDensityFunction(i);
actual = target.LogProbabilityDensityFunction(i);
Assert.IsTrue(expected.IsRelativelyEqual(actual, 1e-10));
expected = log.ComplementaryDistributionFunction(i);
actual = target.ComplementaryDistributionFunction(i);
Assert.IsTrue(expected.IsRelativelyEqual(actual, 1e-15));
double p = log.DistributionFunction(i);
expected = log.InverseDistributionFunction(p);
actual = target.InverseDistributionFunction(p);
Assert.AreEqual(expected, actual, 1e-5);
expected = log.HazardFunction(i);
actual = target.HazardFunction(i);
Assert.IsTrue(expected.IsRelativelyEqual(actual, 1e-15));
expected = log.CumulativeHazardFunction(i);
actual = target.CumulativeHazardFunction(i);
Assert.IsTrue(expected.IsRelativelyEqual(actual, 1e-15));
}
}
public FuncionLogistica(double[] eventos) : base(eventos)
{
try
{
double media = eventos.Average();
int n = eventos.Count();
double sigma = eventos.Sum(x => Math.Pow(x - media, 2)) / n;
DistribucionContinua = new LogisticDistribution(media, sigma);
this.MU = ((LogisticDistribution)DistribucionContinua).Location.ToString("0.0000");
this.S = ((LogisticDistribution)DistribucionContinua).Scale.ToString("0.0000");
Resultado = new ResultadoAjuste(StringFDP, StringInversa, DistribucionContinua.StandardDeviation, DistribucionContinua.Mean, DistribucionContinua.Variance, this);
}
catch (Exception)
{
Resultado = null;
}
}
// Округленное количество людей для одной остановки с рандомом
public static int Get(int PassengerCount, double PeakTime, double PeakWidth, int Minute, int StationCount)
{
LogisticDistribution logis = new LogisticDistribution(PeakTime, PeakWidth);
double value = PassengerCount * logis.ProbabilityDensity(Minute) * 2.02 * RNG.NextDouble() / StationCount;
int res = (int)Math.Round(value);
IdealSum += value;
RealSum += res;
if (Math.Abs(RealSum - IdealSum) >= 1)
{
int corr = (int)(Math.Floor(Math.Abs(RealSum - IdealSum)) * Math.Sign(RealSum - IdealSum));
IdealSum -= RealSum - corr;
RealSum = 0;
res -= corr;
}
logis = null;
return(res);
}
/// <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( LogisticDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 )
{
Show( ToChart( dist, function, numInterpolatedValues ) );
}
/// <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, LogisticDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 )
{
List<string> titles = new List<string>()
{
"LogisticDistribution",
String.Format("location={0}, scale={1}", dist.Location, dist.Scale)
};
UpdateContinuousDistribution( ref chart, dist, titles, function, numInterpolatedValues );
}
/// <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( LogisticDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 )
{
ChartControl chart = GetDefaultChart();
Update( ref chart, dist, function, numInterpolatedValues );
return chart;
}
public void BivariateLinearRegression()
{
// do a set of logistic regression fits
// make sure not only that the fit parameters are what they should be, but that their variances/covariances are as returned
Random rng = new Random(314159);
// define logistic parameters
double a0 = 2.0; double b0 = -1.0;
// keep track of sample of returned a and b fit parameters
BivariateSample ps = new BivariateSample();
// also keep track of returned covariance estimates
// since these vary slightly from fit to fit, we will average them
double caa = 0.0;
double cbb = 0.0;
double cab = 0.0;
// also keep track of test statistics
Sample fs = new Sample();
// do 100 fits
for (int k = 0; k < 100; k++)
{
// we should be able to draw x's from any distribution; noise should be drawn from a normal distribution
Distribution xd = new LogisticDistribution();
Distribution nd = new NormalDistribution(0.0, 2.0);
// generate a synthetic data set
BivariateSample s = new BivariateSample();
for (int i = 0; i < 25; i++)
{
double x = xd.GetRandomValue(rng);
double y = a0 + b0 * x + nd.GetRandomValue(rng);
s.Add(x, y);
}
// do the regression
FitResult r = s.LinearRegression();
// record best fit parameters
double a = r.Parameter(0).Value;
double b = r.Parameter(1).Value;
ps.Add(a, b);
// record estimated covariances
caa += r.Covariance(0, 0);
cbb += r.Covariance(1, 1);
cab += r.Covariance(0, 1);
// record the fit statistic
fs.Add(r.GoodnessOfFit.Statistic);
Console.WriteLine("F={0}", r.GoodnessOfFit.Statistic);
}
caa /= ps.Count;
cbb /= ps.Count;
cab /= ps.Count;
// check that mean parameter estimates are what they should be: the underlying population parameters
Assert.IsTrue(ps.X.PopulationMean.ConfidenceInterval(0.95).ClosedContains(a0));
Assert.IsTrue(ps.Y.PopulationMean.ConfidenceInterval(0.95).ClosedContains(b0));
Console.WriteLine("{0} {1}", caa, ps.X.PopulationVariance);
Console.WriteLine("{0} {1}", cbb, ps.Y.PopulationVariance);
// check that parameter covarainces are what they should be: the reported covariance estimates
Assert.IsTrue(ps.X.PopulationVariance.ConfidenceInterval(0.95).ClosedContains(caa));
Assert.IsTrue(ps.Y.PopulationVariance.ConfidenceInterval(0.95).ClosedContains(cbb));
Assert.IsTrue(ps.PopulationCovariance.ConfidenceInterval(0.95).ClosedContains(cab));
// check that F is distributed as it should be
Console.WriteLine(fs.KolmogorovSmirnovTest(new FisherDistribution(2, 48)).LeftProbability);
}
public void BivariateLinearRegression()
{
// do a set of logistic regression fits
// make sure not only that the fit parameters are what they should be, but that their variances/covariances are as returned
Random rng = new Random(314159);
// define line parameters
double a0 = 2.0; double b0 = -1.0;
// keep track of sample of returned a and b fit parameters
BivariateSample pSample = new BivariateSample();
// also keep track of returned covariance estimates
// since these vary slightly from fit to fit, we will average them
double caa = 0.0;
double cbb = 0.0;
double cab = 0.0;
// Record predictions for a new point
double x0 = 12.0;
Sample ySample = new Sample();
double ySigma = 0.0;
// do 100 fits
for (int k = 0; k < 128; k++)
{
// we should be able to draw x's from any distribution; noise should be drawn from a normal distribution
ContinuousDistribution xd = new LogisticDistribution();
ContinuousDistribution nd = new NormalDistribution(0.0, 2.0);
// generate a synthetic data set
BivariateSample sample = new BivariateSample();
for (int i = 0; i < 16; i++)
{
double x = xd.GetRandomValue(rng);
double y = a0 + b0 * x + nd.GetRandomValue(rng);
sample.Add(x, y);
}
// do the regression
LinearRegressionResult result = sample.LinearRegression();
// test consistancy
Assert.IsTrue(result.Intercept == result.Parameters[0].Estimate);
Assert.IsTrue(result.Intercept.Value == result.Parameters.Best[0]);
Assert.IsTrue(TestUtilities.IsNearlyEqual(result.Intercept.Uncertainty, Math.Sqrt(result.Parameters.Covariance[0, 0])));
Assert.IsTrue(result.Slope == result.Parameters[1].Estimate);
Assert.IsTrue(result.Slope.Value == result.Parameters.Best[1]);
Assert.IsTrue(TestUtilities.IsNearlyEqual(result.Slope.Uncertainty, Math.Sqrt(result.Parameters.Covariance[1, 1])));
Assert.IsTrue(TestUtilities.IsNearlyEqual(result.R.Statistic, sample.CorrelationCoefficient));
// record best fit parameters
double a = result.Parameters.Best[0];
double b = result.Parameters.Best[1];
pSample.Add(a, b);
// record estimated covariances
caa += result.Parameters.Covariance[0, 0];
cbb += result.Parameters.Covariance[1, 1];
cab += result.Parameters.Covariance[0, 1];
UncertainValue yPredict = result.Predict(x0);
ySample.Add(yPredict.Value);
ySigma += yPredict.Uncertainty;
double SST = 0.0;
foreach (double y in sample.Y)
{
SST += MoreMath.Sqr(y - sample.Y.Mean);
}
Assert.IsTrue(TestUtilities.IsNearlyEqual(SST, result.Anova.Total.SumOfSquares));
double SSR = 0.0;
foreach (double z in result.Residuals)
{
SSR += z * z;
}
Assert.IsTrue(TestUtilities.IsNearlyEqual(SSR, result.Anova.Residual.SumOfSquares));
}
caa /= pSample.Count;
cbb /= pSample.Count;
cab /= pSample.Count;
ySigma /= pSample.Count;
// check that mean parameter estimates are what they should be: the underlying population parameters
Assert.IsTrue(pSample.X.PopulationMean.ConfidenceInterval(0.95).ClosedContains(a0));
Assert.IsTrue(pSample.Y.PopulationMean.ConfidenceInterval(0.95).ClosedContains(b0));
Console.WriteLine("{0} {1}", caa, pSample.X.PopulationVariance);
Console.WriteLine("{0} {1}", cbb, pSample.Y.PopulationVariance);
// check that parameter covarainces are what they should be: the reported covariance estimates
Assert.IsTrue(pSample.X.PopulationVariance.ConfidenceInterval(0.95).ClosedContains(caa));
Assert.IsTrue(pSample.Y.PopulationVariance.ConfidenceInterval(0.95).ClosedContains(cbb));
Assert.IsTrue(pSample.PopulationCovariance.ConfidenceInterval(0.95).ClosedContains(cab));
// Check that the predicted ys conform to the model and the asserted uncertainty.
Assert.IsTrue(ySample.PopulationMean.ConfidenceInterval(0.95).ClosedContains(a0 + x0 * b0));
//Assert.IsTrue(ySample.PopulationStandardDeviation.ConfidenceInterval(0.95).ClosedContains(ySigma));
}
