统计帮助类

 class Statistics {

        public static double mode(List<double> dL) {
            List<List<double>> values = new List<List<double>>();
            dL.Sort();
            foreach (double d in dL) {
                if (doubleMatchPredicate != d) {
                    doubleMatchPredicate = d;
                    values.Add(dL.FindAll(doubleMatch));
                }
            }
            int count = 0;
            double temp = 0;
            foreach (List<double> dL2 in values) {
                if (dL2.Count > count) {
                    count = dL2.Count;
                    temp = dL2[0];
                }
            }
            return temp;
        }

        public static double median(List<double> dL) {
            dL.Sort();
            if (dL.Count % 2 == 0)
                return dL[dL.Count / 2 - 1] + (dL[dL.Count / 2 + 1] - dL[dL.Count / 2 - 1]) / 2;
            else
                return dL[(int)((float)dL.Count / 2 + .5)];

        }

        public static double standardDeviation(List<double> dL) {
            double variance = 0;
            foreach (double d in dL)
                variance += Math.Pow(d - dL.Average(), 2);
            return Math.Sqrt(variance / dL.Count);
        }

        private static double doubleMatchPredicate;
        private static bool doubleMatch(double d) {
            return doubleMatchPredicate == d;
        }

    }

    class manufacturingStatistics : Statistics {

        private static bool _sigmaShift = false;
        private static double shiftValue = 0;
 
        public static bool SigmaShift {
            set {
                _sigmaShift = value;
                if (_sigmaShift)
                    shiftValue = 1.5;
                else
                    shiftValue = 0;
            }
        }

        public static double CpK(double lowerLimit, double upperLimit, List<double> dL) {
            double zUSL = (upperLimit - dL.Average()) / standardDeviation(dL);
            double zLSL = (dL.Average() - lowerLimit) / standardDeviation(dL);
            return Math.Min(zLSL, zUSL) / 3;
        }

        public static double Cp(double lowerLimit, double upperLimit, List<double> dL) {
            double zUSL = (upperLimit - dL.Average()) / standardDeviation(dL);
            double zLSL = (dL.Average() - lowerLimit) / standardDeviation(dL);
            return Math.Max(zLSL, zUSL) / 3;
        }

        public static double Pp(double lowerLimit, double upperLimit, List<double> dL) {
            return (upperLimit - lowerLimit) / 6 * standardDeviation(dL);
        }

        public static double sigma(double lowerLimit, double upperLimit, List<double> dL) {
            return Math.Min(upperLimit - dL.Average(), dL.Average() - lowerLimit)
                / standardDeviation(dL) - shiftValue;
        }

        public static double yield(double lowerLimit, double upperLimit, List<double> dL) {
            const double a = -((8 * (Math.PI - 3)) / (3 * Math.PI * (Math.PI - 4)));
            double x = sigma(lowerLimit, upperLimit, dL) / Math.Sqrt(2);
            return Math.Sqrt(1 - Math.Exp(-Math.Pow(x, 2) * ((4 / Math.PI + a * Math.Pow(x, 2))
                / (1 + a * Math.Pow(x, 2)))));
        }

        public static double dpm(double lowerLimit, double upperLimit, List<double> dL) {
            return 1000000 - yield(lowerLimit, upperLimit, dL) * 1000000;
        }

    }