static public double SizeClassesFind(StatisticSample valueSample)
{
if (valueSample.Sample.Count < 100)
{
switch (valueSample.Sample.Count % 2)
{
case 0:
return(Math.Sqrt(valueSample.Sample.Count) - 1);
case 1:
return(Math.Sqrt(valueSample.Sample.Count));
default:
break;
}
}
else
{
switch (valueSample.Sample.Count % 2)
{
case 0:
return(Math.Pow(valueSample.Sample.Count, 1.0 / 3.0) - 1);
case 1:
return(Math.Pow(valueSample.Sample.Count, 1.0 / 3.0));
default:
break;
}
}
return(0);
}
static private List <int> FindFrequencyDivision(StatisticSample valueSample, List <double> xDivision)
{
List <int> zFrequencyDivision = new List <int> {
};
for (int i = 0; i < xDivision.Count; i++)
{
int count = 0;
foreach (var el in valueSample.SampleDataRanking)
{
if (i == xDivision.Count - 1)
{
;
}
else if (i == xDivision.Count - 2 && xDivision[i] <= el.SampleData && xDivision[i + 1] >= el.SampleData)
{
count += el.SampleDataFrequency;
}
else if (xDivision[i] <= el.SampleData && xDivision[i + 1] > el.SampleData)
{
count += el.SampleDataFrequency;
}
}
zFrequencyDivision.Add(count);
}
return(zFrequencyDivision);
}
static public void DivisionInClass(StatisticSample valueSample)
{
ICollection <SamplePrimaryDivisionINClass> SampleDivisionData = new List <SamplePrimaryDivisionINClass> {
};
//
//
List <double> xDivision = FindXDivision(valueSample);
//
List <int> xDivisionFrequency = FindFrequencyDivision(valueSample, xDivision);
//
List <double> RelativeFrequencyDivision = FindRelativeFrequencyDivision(valueSample, xDivisionFrequency);
//
for (int i = 0; i < xDivision.Count; i++)
{
SampleDivisionData.Add(
new SamplePrimaryDivisionINClass
{
SampleDivisionData = Math.Round(xDivision[i], valueSample.RoundValue),
SampleDivisionDataFrequency = xDivisionFrequency[i],
SampleDivisionDataRelativeFrequency = Math.Round(RelativeFrequencyDivision[i], valueSample.RoundValue)
});
}
valueSample.SampleDivisionINClass = new ObservableCollection <SamplePrimaryDivisionINClass>(SampleDivisionData);
}
static public double KolmogorovTest_Invoke(StatisticSample statisticSamples, int k = 500)
{
ICollection <SampleRanking> SampleCollection = new List <SampleRanking>(statisticSamples.SampleDataRanking);
ICollection <double> EmpiricalCollection = new List <double>();
foreach (var el in SampleCollection)
{
double fr = 0;
foreach (var el2 in SampleCollection)
{
if (el2.SampleData <= el.SampleData)
{
fr++;
}
}
EmpiricalCollection.Add(fr / statisticSamples.SampleDataRanking.Count);
}
double dmax = DMaxFindPlus(EmpiricalCollection, statisticSamples.DistributionSampleEmpirical);
double KolmogorovValueLoop = 0;
double z = Math.Sqrt(statisticSamples.SampleDataRanking.Count) * dmax;
for (double i = 1; i < 30000; i++)
{
KolmogorovValueLoop += (Math.Pow(-1.0, i) * Math.Exp(-2.0 * Math.Pow(i, 2.0) * Math.Pow(z, 2.0)));
}
KolmogorovValueLoop = 1 + 2 * KolmogorovValueLoop;
return(Math.Round(KolmogorovValueLoop, 4));
}
static public ICollection <DataValueHistogram> CreateEmpiricalDataValue(StatisticSample valueSample)
{
List <DataValueHistogram> answer = new List <DataValueHistogram> {
};
double pz = valueSample.SampleDivisionINClass.First().SampleDivisionDataRelativeFrequency;
answer.Add(new DataValueHistogram {
x = valueSample.SampleDivisionINClass.First().SampleDivisionData, p = pz
});
foreach (var el in valueSample.SampleDivisionINClass)
{
if (el == valueSample.SampleDivisionINClass.First())
{
continue;
}
else
{
pz += el.SampleDivisionDataRelativeFrequency;
answer.Add(new DataValueHistogram {
x = Math.Round(el.SampleDivisionData, valueSample.RoundValue), p = Math.Round(pz, valueSample.RoundValue)
});
}
}
return(answer);
}
static public void SampleRanking(StatisticSample valueSample)
{
//
ICollection <SampleRanking> SampleRankingData = new List <SampleRanking> {
};
List <double> dataSample = removeEqualse(valueSample.Sample);
dataSample.Sort();
//
List <int> dataSampleFrequency = findDataFrequency(dataSample, valueSample.Sample);
//
List <double> DataRelativeFrequency = findDataRelativeFrequency(dataSampleFrequency);
for (int i = 0; i < dataSample.Count; i++)
{
SampleRankingData.Add(
new Models.SampleRanking {
SampleData = Math.Round(dataSample[i], valueSample.RoundValue),
SampleDataFrequency = dataSampleFrequency[i],
SampleDataRelativeFrequency = Math.Round(DataRelativeFrequency[i], valueSample.RoundValue)
});
}
valueSample.SampleDataRanking = new ObservableCollection <SampleRanking>(SampleRankingData);
}
static public double PearsonTest_Invoke(StatisticSample statisticSamples, int k = 500)
{
double x = 0;
List <double> Sample = new List <double>(statisticSamples.Sample);
List <double> n = new List <double>();
List <double> p = new List <double>();
List <double> E = new List <double>();
for (int i = 0; i < statisticSamples.ClassSize - 1; i++)
{
double nValue = 0;
foreach (var el in statisticSamples.Sample)
{
if (el > statisticSamples.HistogramDataValue.ElementAt(i).x&& el <= statisticSamples.HistogramDataValue.ElementAt(i + 1).x)
{
nValue++;
}
}
double xl = statisticSamples.HistogramDataValue.ElementAt(i).x, xr = statisticSamples.HistogramDataValue.ElementAt(i + 1).x;
double pl = -1, pr = -1;
for (int j = 0; j < statisticSamples.DistributionSampleEmpirical.Count; j++)
{
if (xl < statisticSamples.DistributionSampleEmpirical.ElementAt(j).X&& pl == -1)
{
pl = statisticSamples.DistributionSampleEmpirical.ElementAt(j).Y;
}
if (xr < statisticSamples.DistributionSampleEmpirical.ElementAt(j).X&& pr == -1)
{
pr = statisticSamples.DistributionSampleEmpirical.ElementAt(j).Y;
}
}
pl = pl == -1 ? 0 : pl;
pr = pr == -1 ? 0 : pr;
p.Add(pr - pl);
E.Add(statisticSamples.Sample.Count * p[i]);
n.Add(nValue);
if (E[i] != 0)
{
x += (Math.Pow(n[i] - E[i], 2.0) / E[i]);
}
else
{
x += 0;
}
}
return(Math.Round(x, 4));
}
static private List <double> FindRelativeFrequencyDivision(StatisticSample valueSample, List <int> xDivisionFrequency)
{
List <double> RelativeFrequencyDivision = new List <double> {
};
foreach (var el in xDivisionFrequency)
{
RelativeFrequencyDivision.Add((double)el / (double)valueSample.Sample.Count);
}
return(RelativeFrequencyDivision);
}
static public void QuantitiveCharacteristics(StatisticSample valueSample)
{
var quantitiveCharacteristics = valueSample.QuantitiveCharactacteristics;
double A = valueSample.Sample.Count < 40 ? 0.5 : (valueSample.Sample.Count < 100 ? 0.25 : 0.1);
int v1 = valueSample.Sample.Count == 10 ? 10 : (valueSample.Sample.Count == 30 ? 30 : 120);
Quantiles quantiles = new Quantiles();
quantiles.TQuantiles();
double ourOdeltaX = Math.Round(ourODeltaX_Find(valueSample.Sample), valueSample.RoundValue);
double ourOSC = Math.Round(ourOSC_Find(valueSample.Sample), valueSample.RoundValue);
double ourOAC = Math.Round(ourOAC_Find(valueSample.Sample), valueSample.RoundValue);
double ourOEC = Math.Round(ourOEC_Find(valueSample.Sample), valueSample.RoundValue);
double t = quantiles.T_a0_05[v1];
double pMax = 0;
foreach (var el in valueSample.SampleDivisionINClass)
{
if (el.SampleDivisionDataRelativeFrequency > pMax)
{
pMax = el.SampleDivisionDataRelativeFrequency;
}
}
valueSample.IntervalProtocol = "";
valueSample.IntervalProtocol += $"\no1 | 0.95% | o2 | СКВ" +
$"\n{quantitiveCharacteristics.AritmeitcMean - Math.Round(t * ourOdeltaX, valueSample.RoundValue)} | Середнє арифметичне | {quantitiveCharacteristics.AritmeitcMean + Math.Round(t * ourOdeltaX, valueSample.RoundValue)} | " +
$"{Math.Round(quantitiveCharacteristics.AritmeitcMean / Math.Sqrt(valueSample.Sample.Count), valueSample.RoundValue)}" +
$"\n{quantitiveCharacteristics.RouteMeanSquare - Math.Round(t * ourOSC, valueSample.RoundValue)} | Середньоквадратичне | {quantitiveCharacteristics.RouteMeanSquare + Math.Round(t * ourOSC, valueSample.RoundValue)} | " +
$"{Math.Round(quantitiveCharacteristics.RouteMeanSquare / Math.Sqrt(valueSample.Sample.Count), valueSample.RoundValue)}" +
$"\n{quantitiveCharacteristics.Skewness - Math.Round(t * ourOAC, valueSample.RoundValue)} | Коефіцієнт асиметрії | {quantitiveCharacteristics.Skewness + Math.Round(t * ourOAC, valueSample.RoundValue)} | " +
$"{Math.Round(quantitiveCharacteristics.Skewness / Math.Sqrt(valueSample.Sample.Count), valueSample.RoundValue)}" +
$"\n{quantitiveCharacteristics.CounterKurtosis - Math.Round(t * ourOEC, valueSample.RoundValue)} | Коефіц контрексцесу | {quantitiveCharacteristics.CounterKurtosis + Math.Round(t * ourOEC, valueSample.RoundValue)} | " +
$"{Math.Round(quantitiveCharacteristics.CounterKurtosis / Math.Sqrt(valueSample.Sample.Count), valueSample.RoundValue)}";
//
valueSample.QuantitiveCharactacteristics = quantitiveCharacteristics;
valueSample.QuantitiveCharactacteristics.AritmeitcMeanConfidenceInterval = new ObservableCollection <XYData> {
new XYData {
X = quantitiveCharacteristics.AritmeitcMean - quantitiveCharacteristics.RouteMeanSquare, Y = pMax / 2.0, A = 0.95
},
new XYData {
X = quantitiveCharacteristics.AritmeitcMean + quantitiveCharacteristics.RouteMeanSquare, Y = pMax / 2.0, A = 0.95
}
};
}
static public StatisticSample Move(StatisticSample valueSample)
{
ObservableCollection <double> ourXi = new ObservableCollection <double> {
};
foreach (var el in valueSample.Sample)
{
double ourNum = valueSample.Sample.First() + el + 0.1;
ourXi.Add(ourNum);
}
valueSample.Sample = ourXi;
return(valueSample);
}
static public double AbbeTestRun(StatisticSample statisticSample)
{
double d = 0;
for (int i = 0; i < statisticSample.Sample.Count - 1; i++)
{
d += Math.Pow(statisticSample.Sample.ElementAt(i + 1) - statisticSample.Sample.ElementAt(i), 2);
}
d *= (1.0 / (statisticSample.Sample.Count - 1));
double q = d / (2.0 * Math.Pow(statisticSample.QuantitiveCharactacteristics.RouteMeanSquare, 2.0));
return(Math.Round((q - 1.0) * Math.Sqrt((Math.Pow(statisticSample.Sample.Count - 1.0, 2.0) - 1.0) / (statisticSample.Sample.Count - 2.0)), statisticSample.RoundValue));
}
static private List <double> FindXDivision(StatisticSample valueSample)
{
List <double> xDivision = new List <double> {
};
double stepSize = (valueSample.SampleDataRanking.Last().SampleData - valueSample.SampleDataRanking.First().SampleData) / (valueSample.ClassSize);
valueSample.StepSize = stepSize;
for (int i = 0; i <= valueSample.ClassSize; i++)
{
xDivision.Add((i) * stepSize + valueSample.SampleDataRanking.First().SampleData);
}
return(xDivision);
}
static public StatisticSample Log(StatisticSample valueSample)
{
ObservableCollection <double> ourXi = new ObservableCollection <double> {
};
foreach (var el in valueSample.Sample)
{
double ourNum = Math.Log(el);
ourXi.Add(ourNum);
}
valueSample.Sample = ourXi;
return(valueSample);
}
static public StatisticSample Standartization(StatisticSample valueSample)
{
double MED = QuantitiveCharacteristicsService.MEDFind(valueSample.Sample);
double MAD = QuantitiveCharacteristicsService.MADFind(valueSample.Sample);
ObservableCollection <double> ourXi = new ObservableCollection <double> {
};
foreach (var el in valueSample.Sample)
{
double ourNum = (el - MED);
ourNum /= MAD;
ourXi.Add(ourNum);
}
valueSample.Sample = ourXi;
return(valueSample);
}
static public StatisticSample ArcSinDistributionEmpirical(ICollection <SampleRanking> valueSampleRanking, StatisticSample valueSample)
{
List <DistributionSamples> valueDistributionSample = new List <DistributionSamples> {
};
ICollection <double> valueDoubleTemp = new List <double> {
};
foreach (var el in valueSampleRanking)
{
valueDoubleTemp.Add(el.SampleData);
}
double ArtiheticMean = QuantitiveCharacteristicsService.ArithmeticalMean(valueDoubleTemp);
double AritheticMeanDouble = QuantitiveCharacteristicsService.ArithmeticMeanDouble(valueDoubleTemp);
double AValue = Math.Sqrt(2) * Math.Sqrt((AritheticMeanDouble - Math.Pow(ArtiheticMean, 2.0)));
for (int i = 0; i < valueDoubleTemp.Count; i++)
{
if (valueDoubleTemp.ElementAt(i) < -AValue)
{
valueDistributionSample.Add(new DistributionSamples {
X = valueDoubleTemp.ElementAt(i), Y = 0
});
}
else if (valueDoubleTemp.ElementAt(i) > -AValue && valueDoubleTemp.ElementAt(i) < AValue)
{
double temp = 0.5;
temp += (0.5 * Math.Asin(valueDoubleTemp.ElementAt(i) / AValue));
if (temp > 1)
{
temp = 1;
}
else if (temp < 0)
{
temp = 0;
}
valueDistributionSample.Add(new DistributionSamples {
X = valueDoubleTemp.ElementAt(i), Y = temp
});
}
else
{
valueDistributionSample.Add(new DistributionSamples {
X = valueDoubleTemp.ElementAt(i), Y = 1
});
}
}
valueSample.DistributionSampleEmpirical = new ObservableCollection <DistributionSamples>(valueDistributionSample);
return(valueSample);
}
//Функція щільності розподілу ймовірностей
static public StatisticSample NormalDistribution(ICollection <SampleRanking> valueSampleRanking, StatisticSample valueSample)
{
List <DistributionSamples> valueDistributionSample = new List <DistributionSamples> {
};
ICollection <double> valueDoubleTemp = new List <double> {
};
foreach (var el in valueSampleRanking)
{
valueDoubleTemp.Add(el.SampleData);
}
double ArtiheticMean = QuantitiveCharacteristicsService.ArithmeticalMean(valueDoubleTemp);
double AritheticMeanDouble = QuantitiveCharacteristicsService.ArithmeticMeanDouble(valueDoubleTemp);
double NSize = valueDoubleTemp.Count;
NSize = NSize / (NSize - 1);
double ourO = NSize * Math.Sqrt((AritheticMeanDouble - Math.Pow(ArtiheticMean, 2.0)));
for (int i = 0; i < valueDoubleTemp.Count; i++)
{
double ourT = 1 / (ourO * Math.Sqrt(2 * Math.PI));
double ourT2 = Math.Exp(-((Math.Pow(valueDoubleTemp.ElementAt(i) - ArtiheticMean, 2) / (2 * Math.Pow(ourO, 2)))));
ourT *= ourT2;
ourT *= valueSample.StepSize;
valueDistributionSample.Add(new DistributionSamples {
X = valueDoubleTemp.ElementAt(i), Y = ourT
});
}
valueSample.DistributionSample = new ObservableCollection <DistributionSamples>(valueDistributionSample);
return(valueSample);
}
static public StatisticSample ArcSinDistribution(ICollection <SampleRanking> valueSampleRanking, StatisticSample valueSample)
{
List <DistributionSamples> valueDistributionSample = new List <DistributionSamples> {
};
ICollection <double> valueDoubleTemp = new List <double> {
};
foreach (var el in valueSampleRanking)
{
valueDoubleTemp.Add(el.SampleData);
}
double ArtiheticMean = QuantitiveCharacteristicsService.ArithmeticalMean(valueDoubleTemp);
double AritheticMeanDouble = QuantitiveCharacteristicsService.ArithmeticMeanDouble(valueDoubleTemp);
double AValue = Math.Sqrt(2) * Math.Sqrt((AritheticMeanDouble - Math.Pow(ArtiheticMean, 2.0)));
for (int i = 0; i < valueDoubleTemp.Count; i++)
{
if (valueDoubleTemp.ElementAt(i) > -AValue && valueDoubleTemp.ElementAt(i) < AValue)
{
valueDistributionSample.Add(new DistributionSamples {
X = valueDoubleTemp.ElementAt(i), Y = 1 / (3.14 * Math.Sqrt(AValue * AValue - valueDoubleTemp.ElementAt(i) * valueDoubleTemp.ElementAt(i))) * valueSample.StepSize
});
}
}
valueSample.DistributionSample = new ObservableCollection <DistributionSamples>(valueDistributionSample);
return(valueSample);
}
//Функція розподілу ймовірностей
static public StatisticSample NormalDistributionEmpirical(ICollection <SampleRanking> valueSampleRanking, StatisticSample valueSample)
{
List <DistributionSamples> valueDistributionSample = new List <DistributionSamples> {
};
ICollection <double> valueDoubleTemp = new List <double> {
};
foreach (var el in valueSampleRanking)
{
valueDoubleTemp.Add(el.SampleData);
}
double ArtiheticMean = QuantitiveCharacteristicsService.ArithmeticalMean(valueDoubleTemp);
double AritheticMeanDouble = QuantitiveCharacteristicsService.ArithmeticMeanDouble(valueDoubleTemp);
double NSize = valueDoubleTemp.Count;
NSize = NSize / (NSize - 1);
double ourO = NSize * Math.Sqrt((AritheticMeanDouble - Math.Pow(ArtiheticMean, 2.0)));
for (int i = 0; i < valueDoubleTemp.Count; i++)
{
valueDistributionSample.Add(new DistributionSamples {
X = valueDoubleTemp.ElementAt(i), Y = ourFFind((valueDoubleTemp.ElementAt(i) - ArtiheticMean) / ourO)
});
}
valueSample.DistributionSampleEmpirical = new ObservableCollection <DistributionSamples>(valueDistributionSample);
double DM = Math.Pow(ourO, 2.0) / valueDoubleTemp.Count;
double DO = Math.Pow(ourO, 2.0) / (valueDoubleTemp.Count * 2.0);
double UA = 1.9 + 0.04;
valueSample.HistogramLowerLimit = new ObservableCollection <Models.Histograma.DataValueHistogram> {
};
valueSample.HistogramUpperLimit = new ObservableCollection <Models.Histograma.DataValueHistogram> {
};
foreach (var el in valueSample.DistributionSampleEmpirical)
{
double dFdM = (1.0 / (ourO * Math.Sqrt(2.0 * Math.PI))) * Math.Exp(-(Math.Pow(el.X - ArtiheticMean, 2.0) / (2.0 * Math.Pow(ourO, 2.0))));
double dFdO = ((el.X - ArtiheticMean) / (Math.Pow(ourO, 2.0) * Math.Sqrt(2.0 * Math.PI))) * Math.Exp(-(Math.Pow(el.X - ArtiheticMean, 2.0) / (2.0 * Math.Pow(ourO, 2.0))));
double S_Variance = Math.Pow(dFdM, 2.0) * DM + Math.Pow(dFdO, 2.0) * DO;
double f1 = el.Y + UA * Math.Sqrt(S_Variance), f2 = el.Y - UA * Math.Sqrt(S_Variance);
f1 = f1 < 0 ? 0 : f1 > 1 ? 1 : f1;
f2 = f2 < 0 ? 0 : f2 > 1 ? 1 : f2;
valueSample.HistogramUpperLimit.Add(new Models.Histograma.DataValueHistogram {
x = el.X, p = f1
});
valueSample.HistogramLowerLimit.Add(new Models.Histograma.DataValueHistogram {
x = el.X, p = f2
});
}
return(valueSample);
}
static public StatisticSample ExponentialDistributionEmpirical(ICollection <SampleRanking> valueSampleRanking, StatisticSample valueSample)
{
List <DistributionSamples> valueDistributionSample = new List <DistributionSamples> {
};
ICollection <double> valueDoubleTemp = new List <double> {
};
foreach (var el in valueSampleRanking)
{
valueDoubleTemp.Add(el.SampleData);
}
double ArtiheticMean = QuantitiveCharacteristicsService.ArithmeticalMean(valueDoubleTemp);
double LambdaValue = 1 / ArtiheticMean;
for (int i = 0; i < valueDoubleTemp.Count; i++)
{
valueDistributionSample.Add(new DistributionSamples {
X = valueDoubleTemp.ElementAt(i), Y = valueDoubleTemp.ElementAt(i) < 0 ? 0 : 1 - Math.Exp((-LambdaValue) * valueDoubleTemp.ElementAt(i))
});
}
valueSample.DistributionSampleEmpirical = new ObservableCollection <DistributionSamples>(valueDistributionSample);
valueSample.HistogramLowerLimit = new ObservableCollection <Models.Histograma.DataValueHistogram> {
};
valueSample.HistogramUpperLimit = new ObservableCollection <Models.Histograma.DataValueHistogram> {
};
double UA = 1.9 + 0.04;
foreach (var el in valueSample.DistributionSampleEmpirical)
{
double S_Variance = Math.Pow(el.X, 2.0) * Math.Exp(-2 * LambdaValue * el.X) * Math.Pow(LambdaValue, 2.0) / valueDoubleTemp.Count;
double f1 = el.Y + UA * Math.Sqrt(S_Variance), f2 = el.Y - UA * Math.Sqrt(S_Variance);
f1 = f1 < 0 ? 0 : f1 > 1 ? 1 : f1;
f2 = f2 < 0 ? 0 : f2 > 1 ? 1 : f2;
valueSample.HistogramUpperLimit.Add(new Models.Histograma.DataValueHistogram {
x = el.X, p = f1
});
valueSample.HistogramLowerLimit.Add(new Models.Histograma.DataValueHistogram {
x = el.X, p = f2
});
}
return(valueSample);
}
static public StatisticSample EvenDistribution(ICollection <SampleRanking> valueSampleRanking, StatisticSample valueSample)
{
List <DistributionSamples> valueDistributionSample = new List <DistributionSamples> {
};
ICollection <double> valueDoubleTemp = new List <double> {
};
foreach (var el in valueSampleRanking)
{
valueDoubleTemp.Add(el.SampleData);
}
double ArithmeticMean = QuantitiveCharacteristicsService.ArithmeticalMean(valueDoubleTemp);
double RouteMean = QuantitiveCharacteristicsService.ArithmeticMeanDouble(valueDoubleTemp);
double lambdaValue = 1 / ArithmeticMean;
double aValue = ArithmeticMean - Math.Sqrt(3 * (RouteMean - Math.Pow(ArithmeticMean, 2.0)));
double bValue = ArithmeticMean + Math.Sqrt(3 * (RouteMean - Math.Pow(ArithmeticMean, 2.0)));
for (int i = 0; i < valueDoubleTemp.Count; i++)
{
valueDistributionSample.Add(new DistributionSamples {
X = valueDoubleTemp.ElementAt(i), Y = valueDoubleTemp.ElementAt(i) < aValue || valueDoubleTemp.ElementAt(i) > bValue ? 0 : valueSample.StepSize * (1 / (bValue - aValue))
});
}
valueSample.DistributionSample = new ObservableCollection <DistributionSamples>(valueDistributionSample);
return(valueSample);
}
static public StatisticSample ExponentialDistribution(ICollection <SampleRanking> valueSampleRanking, StatisticSample valueSample)
{
List <DistributionSamples> valueDistributionSample = new List <DistributionSamples> {
};
ICollection <double> valueDoubleTemp = new List <double> {
};
foreach (var el in valueSampleRanking)
{
valueDoubleTemp.Add(el.SampleData);
}
double ArithmeticMean = QuantitiveCharacteristicsService.ArithmeticalMean(valueDoubleTemp);
double lambdaValue = 1 / ArithmeticMean;
for (int i = 0; i < valueDoubleTemp.Count; i++)
{
valueDistributionSample.Add(new DistributionSamples {
X = valueDoubleTemp.ElementAt(i), Y = valueDoubleTemp.ElementAt(i) < 0 ? 0 : valueSample.StepSize * lambdaValue * Math.Exp((-lambdaValue) * valueDoubleTemp.ElementAt(i))
});
}
valueSample.DistributionSample = new ObservableCollection <DistributionSamples>(valueDistributionSample);
return(valueSample);
}
static public String EvenDistributionInterval(ICollection <SampleRanking> valueSampleRanking, StatisticSample valueSample)
{
List <DistributionSamples> valueDistributionSample = new List <DistributionSamples> {
};
ICollection <double> valueDoubleTemp = new List <double> {
};
foreach (var el in valueSampleRanking)
{
valueDoubleTemp.Add(el.SampleData);
}
double ArithmeticMean = QuantitiveCharacteristicsService.ArithmeticalMean(valueDoubleTemp);
double RouteMean = QuantitiveCharacteristicsService.ArithmeticMeanDouble(valueDoubleTemp);
double lambdaValue = 1 / ArithmeticMean;
double aValue = ArithmeticMean - Math.Sqrt(3 * (RouteMean - Math.Pow(ArithmeticMean, 2.0)));
double bValue = ArithmeticMean + Math.Sqrt(3 * (RouteMean - Math.Pow(ArithmeticMean, 2.0)));
double ourDAValue = Math.Pow((bValue - aValue), 2) / (12.0 * valueDoubleTemp.Count);
double ourDBValue = (Math.Pow((bValue - aValue), 4) + 15.0 * Math.Pow(aValue + bValue, 2) * Math.Pow(bValue - aValue, 2)) / (180.0 * valueDoubleTemp.Count);
double cov = (aValue + bValue) * Math.Pow(bValue - aValue, 2) / (12 * valueDoubleTemp.Count);
aValue = Math.Round(aValue, valueSample.RoundValue);
bValue = Math.Round(bValue, valueSample.RoundValue);
String returnValue = $"\n##############################################" +
$"\nДовірче оцінювання: a | b" +
$"\nОцінка: {aValue} | {bValue}" +
$"\nДисперсія: {Math.Round(ourDAValue, valueSample.RoundValue)} | {Math.Round(ourDBValue,valueSample.RoundValue)}" +
$"\nВерхня межа: {aValue + Math.Round(Math.Sqrt(ourDAValue), valueSample.RoundValue)} | {bValue + Math.Round(Math.Sqrt(ourDBValue), valueSample.RoundValue)}" +
$"\nНижня межа: {aValue - Math.Round(Math.Sqrt(ourDAValue), valueSample.RoundValue)} | {bValue - Math.Round(Math.Sqrt(ourDBValue), valueSample.RoundValue)}" +
$"\n##############################################";
return(returnValue);
}
static public String ExponentialDistributionInterval(ICollection <SampleRanking> valueSampleRanking, StatisticSample valueSample)
{
List <DistributionSamples> valueDistributionSample = new List <DistributionSamples> {
};
ICollection <double> valueDoubleTemp = new List <double> {
};
foreach (var el in valueSampleRanking)
{
valueDoubleTemp.Add(el.SampleData);
}
double ArithmeticMean = QuantitiveCharacteristicsService.ArithmeticalMean(valueDoubleTemp);
double lambdaValue = 1 / ArithmeticMean;
double ourDLambda = Math.Pow(lambdaValue, 2) / valueDoubleTemp.Count;
lambdaValue = Math.Round(lambdaValue, valueSample.RoundValue);
ourDLambda = Math.Round(ourDLambda, valueSample.RoundValue);
String returnValue = $"\n##############################################" +
$"\nДовірче оцінювання: LambdaValue" +
$"\nОцінка: {Math.Round(lambdaValue, valueSample.RoundValue)}" +
$"\nДисперсія: {Math.Round(ourDLambda, valueSample.RoundValue)}" +
$"\nВерхня межа: {lambdaValue + Math.Round(Math.Sqrt(ourDLambda), valueSample.RoundValue)}" +
$"\nНижня межа: {lambdaValue - Math.Round(Math.Sqrt(ourDLambda), valueSample.RoundValue)}" +
$"\n##############################################";
return(returnValue);
}
static public StatisticSample EvenDistributionEmpirical(ICollection <SampleRanking> valueSampleRanking, StatisticSample valueSample)
{
List <DistributionSamples> valueDistributionSample = new List <DistributionSamples> {
};
ICollection <double> valueDoubleTemp = new List <double> {
};
foreach (var el in valueSampleRanking)
{
valueDoubleTemp.Add(el.SampleData);
}
double ArtiheticMean = QuantitiveCharacteristicsService.ArithmeticalMean(valueDoubleTemp);
double AritheticMeanDouble = QuantitiveCharacteristicsService.ArithmeticMeanDouble(valueDoubleTemp);
double LambdaValue = 1 / ArtiheticMean;
double AValue = ArtiheticMean - Math.Sqrt(3 * (AritheticMeanDouble - Math.Pow(ArtiheticMean, 2.0)));
double BValue = ArtiheticMean + Math.Sqrt(3 * (AritheticMeanDouble - Math.Pow(ArtiheticMean, 2.0)));
for (int i = 0; i < valueDoubleTemp.Count; i++)
{
valueDistributionSample.Add(new DistributionSamples {
X = valueDoubleTemp.ElementAt(i), Y = valueDoubleTemp.ElementAt(i) < AValue ?
0 : valueDoubleTemp.ElementAt(i) >= AValue && valueDoubleTemp.ElementAt(i) < BValue ?
(valueDoubleTemp.ElementAt(i) - AValue) / (BValue - AValue) : 1
});
}
valueSample.DistributionSampleEmpirical = new ObservableCollection <DistributionSamples>(valueDistributionSample);
valueSample.HistogramLowerLimit = new ObservableCollection <Models.Histograma.DataValueHistogram> {
};
valueSample.HistogramUpperLimit = new ObservableCollection <Models.Histograma.DataValueHistogram> {
};
double UA = 1.9 + 0.04;
double ourDAValue = Math.Pow((BValue - AValue), 2) / (12.0 * valueDoubleTemp.Count);
double ourDBValue = (Math.Pow((BValue - AValue), 4) + 15.0 * Math.Pow(AValue + BValue, 2) * Math.Pow(BValue - AValue, 2)) / (180.0 * valueDoubleTemp.Count);
double cov = (AValue + BValue) * Math.Pow(BValue - AValue, 2) / (12 * valueDoubleTemp.Count);
foreach (var el in valueSample.DistributionSampleEmpirical)
{
double S_Variance = (Math.Pow(el.X - BValue, 2.0) / Math.Pow(BValue - AValue, 4.0)) * ourDAValue +
(Math.Pow(el.X - AValue, 2.0) / Math.Pow(BValue - AValue, 4.0)) * ourDBValue +
((el.X - AValue) * (el.X - BValue) / Math.Pow(BValue - AValue, 4.0)) * cov;
double f1 = el.Y + UA * Math.Sqrt(S_Variance), f2 = el.Y - UA * Math.Sqrt(S_Variance);
f1 = f1 < 0 ? 0 : f1 > 1 ? 1 : f1;
f2 = f2 < 0 ? 0 : f2 > 1 ? 1 : f2;
valueSample.HistogramUpperLimit.Add(new Models.Histograma.DataValueHistogram {
x = el.X, p = f1
});
valueSample.HistogramLowerLimit.Add(new Models.Histograma.DataValueHistogram {
x = el.X, p = f2
});
}
return(valueSample);
}
static public StatisticSample VWeibullDistributionEmpirical(ICollection <SampleRanking> valueSampleRanking, StatisticSample valueSample)
{
List <DistributionSamples> valueDistributionSample = new List <DistributionSamples> {
};
ICollection <double> valueDoubleTemp = new List <double> {
};
foreach (var el in valueSampleRanking)
{
valueDoubleTemp.Add(el.SampleData);
}
double ArtiheticMean = QuantitiveCharacteristicsService.ArithmeticalMean(valueDoubleTemp);
double AritheticMeanDouble = QuantitiveCharacteristicsService.ArithmeticMeanDouble(valueDoubleTemp);
double LambdaValue = 1 / ArtiheticMean;
double AValue = 1;
double BValue = 1.5;
for (int i = 0; i < valueDoubleTemp.Count; i++)
{
valueDistributionSample.Add(new DistributionSamples
{
X = valueDoubleTemp.ElementAt(i),
Y = (1.0 - Math.Exp(-Math.Pow(valueDoubleTemp.ElementAt(i), BValue) / AValue))
});
}
valueSample.DistributionSampleEmpirical = new ObservableCollection <DistributionSamples>(valueDistributionSample);
return(valueSample);
}
//Довірчі інтервали
static public String NormalDistributionInterval(ICollection <SampleRanking> valueSampleRanking, StatisticSample valueSample)
{
List <DistributionSamples> valueDistributionSample = new List <DistributionSamples> {
};
ICollection <double> valueDoubleTemp = new List <double> {
};
foreach (var el in valueSampleRanking)
{
valueDoubleTemp.Add(el.SampleData);
}
double ArtiheticMean = Math.Round(QuantitiveCharacteristicsService.ArithmeticalMean(valueDoubleTemp), valueSample.RoundValue); //Мат сподівання
double AritheticMeanDouble = Math.Round(QuantitiveCharacteristicsService.ArithmeticMeanDouble(valueDoubleTemp), valueSample.RoundValue);
double NSize = valueDoubleTemp.Count;
NSize = NSize / (NSize - 1);
double ourO = Math.Round(NSize * Math.Sqrt((AritheticMeanDouble - Math.Pow(ArtiheticMean, 2.0))), valueSample.RoundValue);
double ourDArithmeticMean = Math.Round(Math.Pow(ourO, 2) / valueDoubleTemp.Count, valueSample.RoundValue);
double ourDO = Math.Round(Math.Pow(ourO, 2) / (2 * valueDoubleTemp.Count), valueSample.RoundValue);
ourO = Math.Round(ourO, valueSample.RoundValue);
ourDArithmeticMean = Math.Round(ourDArithmeticMean, valueSample.RoundValue);
ourDO = Math.Round(ourDO, valueSample.RoundValue);
String returnValue = $"\n##############################################" +
$"\nДовірче оцінювання: m | Sigma" +
$"\nОцінка: {ArtiheticMean} | {ourO}" +
$"\nДисперсія: {ourDArithmeticMean} | {ourDO}" +
$"\nВерхня межа: {ArtiheticMean + Math.Round(Math.Sqrt(ourDArithmeticMean), valueSample.RoundValue)} | {ourO + Math.Round(Math.Sqrt(ourDO), valueSample.RoundValue)}" +
$"\nНижня межа: {ArtiheticMean - Math.Round(Math.Sqrt(ourDArithmeticMean), valueSample.RoundValue)} | {ourO - Math.Round(Math.Sqrt(ourDO), valueSample.RoundValue)}" +
$"\n##############################################";
return(returnValue);
}
static public void StartStatisticOperation(StatisticSample valueSample)
{
StatisticSampleRanking.SampleRanking(valueSample);
StatisticDivisionInClass.DivisionInClass(valueSample);
}
