Esempio n. 1
0
        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);
            }
        }
Esempio n. 2
0
        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);
            }
        }
Esempio n. 3
0
        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);
            }
        }
Esempio n. 4
0
        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
            });
        }
Esempio n. 5
0
        //значимость статистики Кендалла
        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);
        }