public PointEstimateWInterval(double[] chain, double cred = 90, double?overexpo = null) : base()
{
Estimate = GeomMean(chain);
CredibleIntervalProb = cred;
OverExpoInfo = overexpo != null?String.Format(nfi, " Overexposure risk: {0}%", ToSignificantDigits((double)overexpo, 2)) : "";
IntervalLowerBound = new Quantile((100 - CredibleIntervalProb) / 200).Compute(chain)[0];
IntervalUpperBound = new Quantile(1 - (100 - CredibleIntervalProb) / 200).Compute(chain)[0];
}
private Dict median(double[] chaine, double conf)
{
Array.Sort(chaine);
var med = new Dict();
double est = chaine[chaine.Length / 2];
double lcl = new Quantile((100 - conf) / 200).Compute(chaine)[0];
double ucl = new Quantile(1 - (100 - conf) / 200).Compute(chaine)[0];
med.Add("est", est);
med.Add("lcl", lcl);
med.Add("ucl", ucl);
return(med);
}
static void Main(string[] args)
{
int N = Int32.Parse(Console.ReadLine());
int[] arr;
arr = Array.ConvertAll(Console.ReadLine().Split(' '), Int32.Parse);
Array.Sort(arr);
Console.WriteLine(Quantile.getQuantile(arr, QuantileType.Q1));
Console.WriteLine(Quantile.getQuantile(arr, QuantileType.Q2));
Console.WriteLine(Quantile.getQuantile(arr, QuantileType.Q3));
}
private TemplateTree.Quantile AimTemplateTreeQuantileFromXsdQuantile(Quantile quantile)
{
int bins = 0;
int.TryParse(quantile.bins, out bins);
int defaultBin = 0;
int.TryParse(quantile.defaultBin, out defaultBin);
return(new TemplateTree.Quantile
{
Bins = bins,
DefaultBin = defaultBin,
DefaultAnswer = false,
MaxValue = quantile.maxValue,
MinValue = quantile.minValue,
ValueLabel = quantile.valueLabel
});
}
internal void Populate(Metric metric, DateTime now)
{
var summary = new Advanced.DataContracts.Summary();
var quantiles = new Quantile[_objectives.Count];
lock (_bufLock)
{
lock (_lock)
{
// Swap bufs even if hotBuf is empty to set new hotBufExpTime.
SwapBufs(now);
FlushColdBuf();
summary.sample_count = _count;
summary.sample_sum = _sum;
for (var idx = 0; idx < _sortedObjectives.Length; idx++)
{
var rank = _sortedObjectives[idx];
var q = _headStream.Count == 0 ? double.NaN : _headStream.Query(rank);
quantiles[idx] = new Quantile
{
quantile = rank,
value = q
};
}
}
}
if (quantiles.Length > 0)
{
Array.Sort(quantiles, _quantileComparer);
}
for (var i = 0; i < quantiles.Length; i++)
{
summary.quantile.Add(quantiles[i]);
}
metric.summary = summary;
}
public void QuantileTest()
{
const double tau = 2.0 * Math.PI;
var actual = new Matrix(4, 1);
var expected = new Matrix(4, 1);
actual.InRandomize();
expected.InRandomize();
var autoErr = new Quantile().Evaluate(actual, expected);
var error = 0.0;
for (var i = 0; i < actual.Rows; i++)
{
for (var j = 0; j < actual.Columns; j++)
{
error += actual[i, j] - expected[i, j] >= 0.0
? (tau - 1.0) * (expected[i, j] - actual[i, j])
: tau * (expected[i, j] - actual[i, j]);
}
}
error /= actual.Rows * actual.Columns;
Assert.IsTrue(Math.Abs(error - autoErr) < 0.01, new Quantile().Type().ToString() + " Forward!");
var autoDErr = new Quantile().Backward(actual, expected);
var dErr = new Matrix(actual.Rows, actual.Columns);
for (var i = 0; i < actual.Rows; i++)
{
for (var j = 0; j < actual.Columns; j++)
{
dErr[i, j] = actual[i, j] - expected[i, j] >= 0.0
? 1.0 - tau
: -tau;
}
}
Assert.IsTrue(Math.Abs(dErr.FrobeniusNorm() - autoDErr.FrobeniusNorm()) < 0.01, new Quantile().Type().ToString() + " Backward!");
}
private ChainComparison(double[] probs, double[] criteria)
{
if ((probs == null) || (criteria == null))
{
throw new ArgumentNullException("probs or criteria cannot be null array");
}
if ((probs.Length == 0) || (criteria.Length == 0))
{
throw new ArgumentException("probs or/and criteria array is empty.");
}
if (probs.Length != criteria.Length)
{
throw new ArgumentException("probs and criteria must be of the same length.");
}
for (int i = 0; i < probs.Length; i++)
{
if (probs[i] <= 0 || probs[i] >= 1)
{
throw new ArgumentException("each probability must be within the interval (0, 1).");
}
if (criteria[i] <= 0)
{
throw new ArgumentException("each criteria must be greater than 0.");
}
}
this.quantileDefinition = new double[probs.Length];
Array.Copy(probs, this.quantileDefinition, probs.Length);
this.tolerance = new double[probs.Length];
Array.Copy(criteria, this.tolerance, probs.Length);
this.Quantile = new Quantile(this.quantileDefinition);
}
static void Main(string[] args)
{
int N = Int32.Parse(Console.ReadLine());
int[] X = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse);
int[] F = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse);
List <int> S = new List <int>();
for (int i = 0; i < X.Length; i++)
{
for (int j = 0; j < F[i]; j++)
{
S.Add(X[i]);
}
}
int[] s = S.ToArray();
Array.Sort(s);
Console.WriteLine((Quantile.GetQuantile(s, QuantileType.Q3) - Quantile.GetQuantile(s, QuantileType.Q1)).ToString("0.0"));
}
public ChainComparison()
{
this.quantileDefinition = ChainComparison.defaultQuantileDefinition;
this.tolerance = ChainComparison.defaultTolerance;
this.Quantile = new Quantile(this.quantileDefinition);
}
