internal static TrendType Sign(STAT sample1D, double alpha)
{
var x = sample1D.d;
int N = x.Length;
var c = Enumerable.Range(0, N - 1).Where(i => x[i + 1] >= x[i]).Count();
double E = (1d / 2) * (N - 1);
double D = 1d / 12 * (N + 1);
double S = (c - E) / Math.Sqrt(D);
//var u = BHData.Common.Quantile.Get_Quantile_normalization(BHData.Common.Constant.ParameterForQuantile);
var u = Kvantili.Normal(alpha);
if (Math.Abs(S) < u)
{
return(TrendType.Flat);
}
else if (S < -u)
{
return(TrendType.Falling);
}
else
{
return(TrendType.Growing);
}
}
internal static TrendType Abbe(STAT sample, double alpha)
{
int N = sample.d.Length;
var elements = sample.d;
double xAv = sample.Expectation;
double q2 = Enumerable.Range(0, N - 1).Sum(i => Math.Pow(elements[i] - elements[i + 1], 2)) / (N - 1);
double s2 = elements.Sum(e => Math.Pow(e - xAv, 2)) / (N - 1);
double y = q2 / (2 * s2);
double u = (y - 1) * Math.Sqrt((N * N - 1) / (N - 2));
//var kv = Quantile.Get_Quantile_normalization(Constant.ParameterForQuantile);
var kv = Kvantili.Normal(alpha);
if (Math.Abs(u) < kv)
{
return(TrendType.Flat);
}
else if (u < -kv)
{
return(TrendType.Falling);
}
else
{
return(TrendType.Growing);
}
}
public ExteendedCoef GetPartialCoefCorrelationInfo(int i, int j)
{
//значение
double rij = PartialR[i][j];
//значимость
int w = PartialR.GetLength(0) - 2;
int NN = PartialR.GetLength(0) * N;
double V = NN - w - 2; //Это чисто мое обозначение для упрощения кол-ва степеней свободы
double t = (rij * Math.Sqrt(V) / Math.Sqrt(1 - rij * rij));
string state = Math.Abs(t) < Kvantili.Student(0.05, V) ? "Не значущий" : "Значущий";
//интервальное оценивание
double V1 = Math.Log((1 + rij) / (1 - rij)) / 2.0 - Kvantili.Normal(0.05) / (V - 1);
double V2 = Math.Log((1 + rij) / (1 - rij)) / 2.0 + Kvantili.Normal(0.05) / (V - 1);
double bottomborder = (Math.Exp(2 * V1) - 1) / (Math.Exp(2 * V1) + 1);
double Topborder = (Math.Exp(2 * V2) - 1) / (Math.Exp(2 * V2) + 1);
return(new ExteendedCoef()
{
info = Environment.NewLine + "Частковий коефіцієнт кореляції r(" + i + ")(" + j + "):",
BottomValue = bottomborder,
Value = rij,
TopValue = Topborder,
State = state
});
}
internal static TrendType ExtremalPoint(STAT sample1D, double alpha)
{
var p = 0;
var x = sample1D.d;
int N = x.Length;
for (int i = 1; i < N - 1; i++)
{
if ((x[i] > x[i - 1] && x[i] > x[i + 1]) || (x[i - 1] > x[i] && x[i + 1] > x[i]))
{
p++;
}
}
double E = (2d / 3) * (N - 2);
double D = (1d / 90) * (16 * N - 29);
double S = (p - E) / Math.Sqrt(D);
//var u = BHData.Common.Quantile.Get_Quantile_normalization(BHData.Common.Constant.ParameterForQuantile);
var u = Kvantili.Normal(alpha);
if (Math.Abs(S) < u)
{
return(TrendType.Flat);
}
else if (S < -u)
{
return(TrendType.Falling);
}
else
{
return(TrendType.Growing);
}
}
//совпадение к н-меных ДК матриц
public static string ComparingKNdimDC(STATND[] stats, double alpha)
{
int k, n;
int[] Nd;
Vector[] Averagexd;
double[] Sd;
//начало работы с к н-мерными = заполнение переменных
StartWorkWithKNdim(stats, out k, out n, out Nd, out Averagexd, out Sd);
double S = 0;
int N = 0;
for (int i = 0; i < k; i++)
{
S += Sd[i] * (Nd[i] - 1);
N += Nd[i];
}
S /= (N - k);
double V = 0; //статистика
for (int i = 0; i < k; i++)
{
V += (Nd[i] - 1) / 2d * Math.Log(Math.Abs(S / Sd[i]));
}
//делаем выводы
double kv = Kvantili.Hi2(alpha, n * (n + 1) * (k - 1) / 2);
//для удобства
string resultStr = "";
Func <double, double> r = val => Math.Round(val, 4);
Action <string> mess2log = str => resultStr += str + Environment.NewLine;
mess2log("V = " + r(V));
mess2log("kv = " + r(kv));
if (V <= kv)
{
//гипотезу принято; ДК совпадают
mess2log("V<kv");
mess2log("Гіпотезу прийнято!");
mess2log("DC співпадають!");
}
else
{
//гипотезу не принято
mess2log("V>kv");
mess2log("Гіпотезу НЕ прийнято!");
mess2log("DC НЕ співпадають!");
}
return(resultStr);
}
//значимость множественных коэф корреляции
public string SignificanceOfMultipleR(int i)
{
int NN = stats[0].d.Length * N;
double r = MultipleR[i];
double f = (NN - n - 1) / (double)n * r * r / (1 - r * r);
string res = f > Kvantili.Fishera(0.05, n, NN - n - 1) ? "Значущий" : "Не значущий";// or < ! но пока пусть будет так
return(String.Format("{1}Множинний коефіцієнт ({0}) - {2}", i, Environment.NewLine, res));
}
//значимость статистики Кендалла
public string MeasureOfConnectionKendella_significance()
{
double Tau = kendal;
double Uk = Kvantili.Normal(alpha / 2.0);
double U = 3 * Tau / Math.Sqrt(2 * (2 * N + 5)) * Math.Sqrt(N * (N - 1));
string significance = "Tau = " + Math.Round(Tau, 4) + Environment.NewLine + "U(" + (1 - alpha / 2.0) + ")= " + Math.Round(Uk, 4) + Environment.NewLine;
significance += "U = " + Math.Round(U, 4) + Environment.NewLine;
if (Math.Abs(U) <= Uk)
{
significance += "Оцінка значуща!";
}
else
{
significance += "Оцінка не значуща!";
}
return(significance);
}
//значимость коеф сообщений Пирсона
public string СoefficientConnectionsPirsona_significance()
{
double C = Math.Sqrt(Hi2 / (N + Hi2));
double nu = (SizeN - 1) * (SizeM - 1);
double Hi2k = Kvantili.Hi2(1 - alpha, nu);
string significance = "C = " + Math.Round(C, 4) + Environment.NewLine + "Hi^2(" + (1 - alpha) + ", " + nu + ")= " + Math.Round(Hi2k, 4) + Environment.NewLine;
significance += "Hi^2 = " + Math.Round(Hi2, 4) + Environment.NewLine;
if (Hi2 >= Hi2k)
{
significance += "Оцінка значуща!";
}
else
{
significance += "Оцінка не значуща!";
}
return(significance);
}
//проверка незавизимости X, Y
public string IndependenceHypothesis()
{
CalcHi2();
string result = "Перевірка незалежності X та Y";
double kv = Kvantili.Hi2(alpha, (SizeM - 1) * (SizeN - 1));
result += String.Format("Hi2 = {0}\nKvantil = {1}\n", Hi2, kv);
if (Hi2 > kv)
{
result += "Гіпотеза вірна";
}
else
{
result += "Гіпотеза НЕ вірна\nІснує зв'язок";
}
return(result);
}
//значимость Стюарта
public string CheckSignificanceOfStuart()
{
//минимум
double min = Math.Min(SizeM, SizeN);
//сумма под корнем
double Sum = 0;
for (int i = 0; i < SizeN; i++)
{
for (int j = 0; j < SizeM; j++)
{
double A = 0, B = 0;
//считаем А
for (int k = 0; k < SizeN; k++)
{
for (int l = 0; l < SizeM; l++)
{
A += nij[k][l];
}
}
for (int k = 0; k < i - 1; k++)
{
for (int l = 0; l < j - 1; l++)
{
A += nij[k][l];
}
}
//считаем B
for (int k = 0; k < SizeN; k++)
{
for (int l = 0; l < j - 1; l++)
{
B += nij[k][l];
}
}
for (int k = 0; k < i - 1; k++)
{
for (int l = 0; l < SizeM; l++)
{
B += nij[k][l];
}
}
//считаем саму сумму
Sum += nij[i][j] * Math.Pow(A - B, 2);
}
}
double sigma = 2 * min / (N * N * N * (min - 1)) * Math.Sqrt(N * N * Sum - 4 * N * (P - Q));
//проверка на значимость(работа с квантилем)
double Tau = this.stuart;
double tk = Kvantili.Student(alpha, SizeM + SizeN - 2);
double t = Tau / sigma;
string significance = "Tau = " + Math.Round(Tau, 4) + Environment.NewLine + "t(" + (1 - alpha / 2.0) + ", " + (SizeM + SizeN - 2) + " )= " + Math.Round(tk, 4) + Environment.NewLine;
significance += "T = " + Math.Round(t, 4) + Environment.NewLine;
if (Math.Abs(t) <= tk)
{
significance += "Оцінка значуща!";
}
else
{
significance += "Оцінка не значуща!";
}
return(significance);
}
private static RegressionResult GetConfidenceIntervalsOnRegressionParametrs(double alpha, int n, List <STAT> XStats, STAT yStat, Vector YVector, Vector ExtendedparamsVector)
{
//это величина доьавлением/отниманием которой получаются доверительные интервалы на параметры регресии
double[] confidenceValues = new double[n + 1];
//берем исходные иксы
List <Vector> XInputVectors = XStats.Select(stat => new Vector(stat.d)).ToList();
//добавляю игрекв первую колонку
XInputVectors.Insert(0, YVector);
Matrix X = Matrix.Create.JoinVectors(XInputVectors);
//ищем квантиль
int N = XStats[0].d.Length * n;
int Nu = N - n; //по формуле N-n
double kv = Kvantili.Student(alpha, Nu);
//коэф детерминации
XStats.Add(yStat); //добавляем y к иксам, чтобы получить общую матрицу
STATND STATNDForR = new STATND(XStats.ToArray()); //заносим полученную матрицу в многомерный анализ
double MultipleR = STATNDForR.GetMultipleR(n);
double DeterminationCoef = MultipleR * MultipleR;
//ищем остаточную дисперсию и сигму
double S2 = (double)(N - 1) / (N - n) * yStat.Dispersia * (1 - DeterminationCoef);
double sigma = Math.Sqrt(S2);
//значимость параметров
string[] paramsState = new string[7];
double KvForParams = Kvantili.Student(alpha, N - n);
//ищем сkk
Matrix C = (X.Transpose() * X).Inverse();
for (int i = 0; i < n + 1; i++)
{
//дл интервальных оценок
double Ckk = C[i, i];
confidenceValues[i] = kv * sigma * Math.Sqrt(Ckk);
//проверка параметров регрессии на значимость
paramsState[i] = Math.Abs(ExtendedparamsVector[i] / (sigma * Math.Sqrt(Ckk))) <= KvForParams? "не значущий": "Значущий";
}
//переносим из массива в вектор
Vector ConfidenceVector = new Vector(confidenceValues);
//доверительные границы
Vector topLimits = ExtendedparamsVector + ConfidenceVector;
Vector bottomLimits = ExtendedparamsVector - ConfidenceVector;
//проверка значимости регрессии
string state = "";
double f = (double)(N - n - 1) / n * DeterminationCoef * DeterminationCoef / (1 - DeterminationCoef * DeterminationCoef);
int Nu1 = n;
int Nu2 = N - n - 1;
Func <double, double> r = v => Math.Round(v, 4);
Action <string> Add2Log = s => state += s + Environment.NewLine;
Add2Log("f = " + r(f));
Add2Log("kv = " + r(kv));
if (f > kv)
{
Add2Log("f > kv");
Add2Log("Регресійна модель Значуща");
}
else
{
Add2Log("f <= kv");
Add2Log("Регресійна модель НЕ Значуща");
}
//Интервалы дисперсии
double nominator = S2 * (N - n);
double TopDisp = nominator / Kvantili.Hi2((2d - alpha) / 2, N - n);
double BottomDisp = nominator / Kvantili.Hi2(-alpha / 2d, N - n);
string disprsionIntervals = String.Format("{0}<={1}<={2}", r(BottomDisp), r(S2), r(TopDisp));
RegressionResult result = new RegressionResult()
{
BotoomConfidenceLimits = bottomLimits,
RegressionParams = ExtendedparamsVector,
TopConfidenceLimits = topLimits,
R = DeterminationCoef,
state = state,
ParamsState = paramsState,
DispersionIntervals = disprsionIntervals
};
return(result);
}
//равенство двух многомерных средних в случае равных ДК
public static string ComparingTwoNdimAverage(STATND xStat, STATND yStat, double alpha)
{
//проверки
if (!xStat.CheckingLengthOfStats())
{
throw new ChekingLengthOfStatsException("xStat");
}
if (!yStat.CheckingLengthOfStats())
{
throw new ChekingLengthOfStatsException("yStat");
}
int nLen1 = xStat.N;
int nLen2 = yStat.N;
if (nLen1 != nLen2)
{
throw new DIfferentDimentionsLengthException();
}
//конец проверок
//вынос нужных переменных
int N1 = xStat.GetStat(0).d.Length; //длинна всех признаков по иксу
int N2 = yStat.GetStat(0).d.Length; //длинна всех признаков по y
int n = nLen1; //количество признаков (должно быть одинаковым для x и y)
double[][] S0 = ArrayMatrix.GetJaggedArray(n, n);
double[][] S1 = ArrayMatrix.GetJaggedArray(n, n);
//лямбды для удобного получения x и y
Func <int, int, double> x = (NumberOfDim, NumberOfElementInDim) => xStat.GetStat(NumberOfDim).d[NumberOfElementInDim];
Func <int, int, double> y = (NumberOfDim, NumberOfElementInDim) => yStat.GetStat(NumberOfDim).d[NumberOfElementInDim];
//лямбды для получения суммы
Func <int, double> xSum = NumberOfDim => xStat.GetStat(NumberOfDim).d.Sum();
Func <int, double> ySum = NumberOfDim => yStat.GetStat(NumberOfDim).d.Sum();
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
double CommonDenominator = N1 + N2 - 2;
double S0Temp = 0;
double S1Temp = 0;
//по формулам
for (int l = 0; l < N1; l++)
{
S0Temp += x(i, l) * x(j, l);
}
for (int l = 0; l < N2; l++)
{
S0Temp += y(i, l) * y(j, l);
}
S1Temp = S0Temp; //до этого места формулы одинаковые
//подсчет частей, которые отличаются
S0Temp -= ((xSum(i) + ySum(i)) * (xSum(j) + ySum(j))) / (N1 + N2);
S1Temp -= (xSum(i) * xSum(j)) / N1;
S1Temp -= (ySum(i) * ySum(j)) / N2;
//перенос значений в матрицу
S0[i][j] = S0Temp / CommonDenominator;
S1[i][j] = S1Temp / CommonDenominator;
}
}
//перенос значений в сложный тип - матрицу(для нахождения определителей)
Matrix S0Matrix = new Matrix(S0);
Matrix S1Matrix = new Matrix(S1);
//подсчет статистики
double V = N1 + N2 - 2 - n / 2d;
V *= Math.Log(Math.Abs(S1Matrix.Determinant() / S0Matrix.Determinant()));
//для удобства
string resultStr = "";
Func <double, double> r = val => Math.Round(val, 4);
Action <string> mess2log = str => resultStr += str + Environment.NewLine;
//делаем выводы
double kv = Kvantili.Hi2(alpha, n);
mess2log("V = " + r(V));
mess2log("kv = " + r(kv));
if (V <= kv)
{
//гипотезу принято;//средние совпадают
mess2log("V<kv");
mess2log("Гіпотезу прийнято!");
mess2log("Середні співпадають!");
}
else
{
//гипотезу не принято
mess2log("V>kv");
mess2log("Гіпотезу НЕ прийнято!");
mess2log("Середні НЕ співпадають!");
}
return(resultStr);
}
//совпадение к н-меных средних при расхождении ДК матриц
public static string ComparingKNdimAverage(STATND[] stats, double alpha)
{
int k, n;
int[] Nd;
Vector[] Averagexd;
double[] Sd;
//начало работы с к н-мерными = заполнение переменных
StartWorkWithKNdim(stats, out k, out n, out Nd, out Averagexd, out Sd);
//подсчет обобщенного среднего
Vector GenerilizedAverage; //само обобщенное среднее
double leftPart = 0;
Vector RightPart = Vector.Create.New(n);
for (int i = 0; i < k; i++)
{
double commonPart = Nd[i] / Sd[i];
leftPart += commonPart;
RightPart += commonPart * Averagexd[i];
}
GenerilizedAverage = RightPart / leftPart; //обобщенное среднее подсчитано
double V = 0; //результирующая статистика
for (int i = 0; i < k; i++)
{
Vector v = Averagexd[i] - GenerilizedAverage;
V += Nd[i] * v / Sd[i] * v;
}
//делаем выводы
double kv = Kvantili.Hi2(alpha, n * (k - 1));
//для удобства
string resultStr = "";
Func <double, double> r = val => Math.Round(val, 4);
Action <string> mess2log = str => resultStr += str + Environment.NewLine;
mess2log("V = " + r(V));
mess2log("kv = " + r(kv));
if (V <= kv)
{
//гипотезу принято; средние совпадают
mess2log("V<kv");
mess2log("Гіпотезу прийнято!");
mess2log("Середні співпадають!");
}
else
{
//гипотезу не принято
mess2log("V>kv");
mess2log("Гіпотезу НЕ прийнято!");
mess2log("Середні НЕ співпадають!");
}
return(resultStr);
}