Esempio n. 1
0
        public static double[] CheckOutstanding(double[] data, out double[] clearData, float alpha)
        {
            List <double> dataList  = new List <double>(data);
            List <double> trashList = new List <double>();
            bool          changes;

            do
            {
                changes = false;
                data    = dataList.ToArray();
                double mean = StatisticsProcessor.Srednee(data);
                double S    = Math.Sqrt(StatisticsProcessor.Dispersion(data));

                double Xmax  = StatisticsProcessor.FindMax(data);
                double TnMax = (Xmax - mean) / S;
                if (TnMax > TTable(alpha, (uint)(data.Length)))
                {
                    changes = true;
                    dataList.Remove(Xmax);
                    trashList.Add(Xmax);
                }

                double Xmin  = StatisticsProcessor.FindMin(data);
                double TnMin = (mean - Xmin) / S;
                if (TnMin > TTable(alpha, (uint)(data.Length)))
                {
                    changes = true;
                    dataList.Remove(Xmin);
                    trashList.Add(Xmin);
                }
            }while (changes);

            clearData = dataList.ToArray();
            return(trashList.Count > 0 ? trashList.ToArray() : null);
        }
Esempio n. 2
0
        public static bool CheckZn(double[] data, Zakon zn, float alpha)
        {
            double[] ΔLeft, ΔRight;
            int[]    v;
            int      k = StatisticsProcessor.ToIntervals(data, out ΔLeft, out ΔRight, out v);

            double σв   = Math.Sqrt(StatisticsProcessor.Dispersion(data));
            double mean = StatisticsProcessor.Srednee(data);

            double[] p = new double[k];

            for (int i = 0; i < k; i++)
            {
                double x1 = ΔLeft[i];
                double x2 = ΔRight[i];

                switch (zn)
                {
                case Zakon.Ravnom:
                    p[i] = FxRavnom(x2, mean - 1.732 * σв, mean + 1.732 * σв) -
                           FxRavnom(x1, mean - 1.732 * σв, mean + 1.732 * σв);
                    break;

                case Zakon.Exponential:
                    p[i] = FxExponential(x2, 1f / mean) - FxExponential(x1, 1f / mean);
                    break;

                case Zakon.Normal:
                    p[i] = FxNormal((x2 - mean) / σв) - FxNormal((x1 - mean) / σв);
                    break;
                }
            }

            double χSqr = 0;

            for (int i = 0; i < k; i++)
            {
                χSqr += (v[i] - data.Length * p[i]) * (v[i] - data.Length * p[i]) / data.Length / p[i];
            }

            int s = 0;

            switch (zn)
            {
            case Zakon.Ravnom:
                s = 2;
                break;

            case Zakon.Exponential:
                s = 1;
                break;

            case Zakon.Normal:
                s = 2;
                break;
            }

            return(χSqr < χSqrTable(alpha, (uint)(k - s - 1)));
        }
Esempio n. 3
0
        private void DrawMetrolog(Graphics g, float zoom_x, float zoom_y)
        {
            DrawAxes(g, ptMargins.Y);

            PointF[] polyPts  = new PointF[Y.Length];
            float    ptDeltaX = sz.Height / 400;
            float    ptDeltaY = sz.Width / 400;

            Pen penCrosses = new Pen(penColor, 5);

            penCrosses.EndCap = penCrosses.StartCap = LineCap.Round;

            double min = StatisticsProcessor.FindMin(Y);

            for (int i = 0; i < Y.Length; i++)
            {
                polyPts[i].X = i * zoom_x + ptMargins.X;
                polyPts[i].Y = (float)(Y[i] - min) * zoom_y + ptMargins.Y;

                g.DrawLine(penCrosses,
                           PointF.Add(polyPts[i], new SizeF(-ptDeltaX, -ptDeltaY)),
                           PointF.Add(polyPts[i], new SizeF(+ptDeltaX, +ptDeltaY)));
                g.DrawLine(penCrosses,
                           PointF.Add(polyPts[i], new SizeF(+ptDeltaX, -ptDeltaY)),
                           PointF.Add(polyPts[i], new SizeF(-ptDeltaX, +ptDeltaY)));
            }

            if (Y.Length > 1)
            {
                g.DrawLines(new Pen(penColor, 2), polyPts);
            }

            DrawValues(g, ptMargins.Y - (float)min * zoom_y, zoom_x, zoom_y);

            Pen penMids = new Pen(Color.Orange);

            int i0 = 0;

            for (int il = 0; il < indsd.Count; il++)
            {
                int      i  = indsd[il];
                double[] y1 = new double[i - i0];
                Array.Copy(Y, i0, y1, 0, i - i0);

                float mid = (float)StatisticsProcessor.Srednee(y1);

                float gy = (float)(mid - min) * zoom_y + ptMargins.Y;

                g.DrawLine(penMids, ptMargins.X + i0 * zoom_x, gy, ptMargins.X + i * zoom_x, gy);

                i0 = i;
            }
        }