public static PieceConstIntensityResult PieceConstIntensity(Queue q, int m)
{
int n = q.Count;
double min = q.Min();
double dt = (q.Max() - min) / m;
int Ns = 0;
List <PieceConstIntensityClassResult> results = new List <PieceConstIntensityClassResult>();
for (int i = 0; i < m - 1; i++)
{
int ns = q.Count(x => x >= min + dt * i && x < min + dt * (i + 1));
Ns += ns;
double val = ns / dt / (n - Ns);
ConfidenceInterval cnf = new ConfidenceInterval(val,
x => x * DistributionHelper.ChiSquareDistributionQuantile(Globals.Alpha / 2, 2 * ns) / ns / 2,
x => x * DistributionHelper.ChiSquareDistributionQuantile(1 - Globals.Alpha / 2, 2 * ns) / ns / 2,
min + dt * i,
min + dt * (i + 1));
PieceConstIntensityClassResult res = new PieceConstIntensityClassResult(i + 1, cnf, ns);
results.Add(res);
}
return(new PieceConstIntensityResult(results));
}
public BenchmarkConfidence(ConfidenceInterval interval)
{
Level = interval.Level;
Lower = interval.Lower;
Margin = interval.Margin;
Mean = interval.Mean;
N = interval.N;
StandardError = interval.StandardError;
}
public void GetResultTest()
{
var confidenceInterval = new ConfidenceInterval(_data);
confidenceInterval.Calculate();
var result = confidenceInterval.Value;
result.Should().Be(4141.1432036838778);
}
public static float RandomRangeGaussian(float min, float max, ConfidenceInterval confidence)
{
float sd = (max - min) * 0.5f;
float mean = min + sd;
// Maybe it's working - can't understand completely
sd /= standartScore[(int)confidence];
float random_normal_num;
do
{
random_normal_num = RandomGaussian(mean, sd);
} while (random_normal_num > max || random_normal_num < min);
return(random_normal_num);
}
/// <summary>
/// Method to obtain the Predicted Nav Accuracy at each timestep and populate the
/// data structures that will be used to draw the graph.
/// </summary>
/// <param name="accuracyPredictedEvaluator">Evaluator for Predicted Nav Accuracy.</param>
private void ComputeValuesForPredictedAccGraph(Evaluator <NavigationAccuracyPredicted> accuracyPredictedEvaluator)
{
Duration dur = stopjd - startjd;
double timestep = Double.Parse(TimeStep.Text);
Duration ts = Duration.FromSeconds(timestep);
PredAccData.Clear();
// create a new Confidence Interval
ConfidenceInterval ci = new ConfidenceInterval();
// Initialize the progressbar with appropriate values
progressBar1.Maximum = (int)dur.TotalSeconds;
progressBar1.Step = (int)timestep;
// now we'll iterate through time by adding seconds to the start time JulianDate object -
// creating a new JulianDate each time step.
for (JulianDate jd = startjd; jd <= stopjd; jd += ts)
{
try
{
NavigationAccuracyPredicted accuracyPredicted = accuracyPredictedEvaluator.Evaluate(jd);
double txd = new XDate(jd.ToDateTime());
// Lets use the specified confidence interval for our Accuracy Predictions.
if (accuracyPredicted != null)
{
// we're using a ConfidenceInterval instance here to convert the predicted nav accuracy to a standard
// confidence percentile.
PredAccData.Add(txd,
ci.ConvertToGlobalPositioningSystemConfidence(accuracyPredicted.PositionSignalInSpace,
(int)ConfIntvlUpDown.Value,
ConfidenceIntervalVariableDimension.Three));
}
}
catch
{
}
// update the progress bar - we're done with this time step!
progressBar1.PerformStep();
}
// reset the progress bar
progressBar1.Value = 0;
}
public static StatEstimationResult StatEstimation(Queue q, int m)
{
int n = q.Count;
List <double> times = q.ToTime;
double dt = times.Last() / m;
List <StatEstimationClassResult> intervals = new List <StatEstimationClassResult>();
double ua = DistributionHelper.GetNormalDistributionQuantile(Globals.Alpha / 2);
double constantPart = ua * ua / n / dt / 2;
for (int i = 0; i < m; i++)
{
int ns = times.Count(x => x >= dt * i && (i == m - 1 || x < dt * (i + 1)));
double us = ns / dt / n;
double difPart = ua * Math.Sqrt(ns + ua * ua / 4) / n / dt;
ConfidenceInterval cnf = new ConfidenceInterval(us, x => x + constantPart - difPart, x => x + constantPart + difPart, dt * i, dt * (i + 1));
intervals.Add(new StatEstimationClassResult(i + 1, cnf));
}
return(new StatEstimationResult(intervals));
}
public StatEstimationClassResult(int cls, ConfidenceInterval conf)
{
Class = cls;
ConfInterval = conf;
}
public PieceConstIntensityClassResult(int cls, ConfidenceInterval conf, int ns)
{
Class = cls;
ConfInterval = conf;
Number = ns;
}
