private static QuantilCharacteristic CalculateKurtosis(ref double[] array)
        {
            QuantilCharacteristic kurtosisCharacteristic = new QuantilCharacteristic();

            double quantilStudent = QuantilCalculator.StudentQuantil((1.0 - (alpha / 2)), (array.Length - 1));
            double aver = CalculateAverage(ref array);
            double sum = 0;
            double sum2 = 0;
            double _e, _v;

            for (int i = 0; i < array.Length; i++)
            {
                sum += Math.Pow(array[i] - aver, 4);
                sum2 += Math.Pow(array[i], 2) - Math.Pow(aver, 2);
            }

            _v = sum2 / array.Length;
            _e = sum / (array.Length * Math.Pow(_v, 2));

            kurtosisCharacteristic.value = ((Math.Pow(array.Length, 2.0) - 1.0) / ((array.Length - 2.0) * (array.Length - 3.0))) * ((_e - 3.0) + (6.0 / (array.Length + 1.0)));
            kurtosisCharacteristic.standardDeviation = Math.Sqrt(((24.0 * (double)array.Length) * ((double)array.Length - 2.0) * ((double)array.Length - 3.0)) /
                                                           (((double)array.Length + 1.0) * ((double)array.Length + 1.0) * ((double)array.Length + 3.0) * ((double)array.Length + 5.0)));
            kurtosisCharacteristic.confidenceInterval.min = kurtosisCharacteristic.value - (quantilStudent * kurtosisCharacteristic.standardDeviation);
            kurtosisCharacteristic.confidenceInterval.max = kurtosisCharacteristic.value + (quantilStudent * kurtosisCharacteristic.standardDeviation);


            kurtosisCharacteristic.value = Math.Round(kurtosisCharacteristic.value, 4);
            kurtosisCharacteristic.standardDeviation = Math.Round(kurtosisCharacteristic.standardDeviation, 4);
            kurtosisCharacteristic.confidenceInterval.min = Math.Round(kurtosisCharacteristic.confidenceInterval.min, 4);
            kurtosisCharacteristic.confidenceInterval.max = Math.Round(kurtosisCharacteristic.confidenceInterval.max, 4);

            return kurtosisCharacteristic;
        }
        private static QuantilCharacteristic CalculateSkewness(ref double[] array)
        {
            QuantilCharacteristic skewnessCharacteristic = new QuantilCharacteristic();

            double quantilStudent = QuantilCalculator.StudentQuantil((1.0 - (alpha / 2)), (array.Length - 1));
            double aver = CalculateAverage(ref array);
            double sum = 0;
            double sum2 = 0;
            double _a, _v;

            for (int i = 0; i < array.Length; i++)
            {
                sum += Math.Pow(array[i] - aver, 3);
                sum2 += Math.Pow(array[i], 2) - Math.Pow(aver, 2);
            }

            _v = sum2 / array.Length;
            _a = sum / (array.Length * Math.Pow(_v, 3.0 / 2.0));

            skewnessCharacteristic.value = _a * (Math.Sqrt(array.Length * (array.Length - 1)) / (array.Length - 2));
            skewnessCharacteristic.standardDeviation = Math.Sqrt((6.0 * ((double)array.Length - 2.0)) / (((double)array.Length + 1.0) * ((double)array.Length + 3.0)));
            skewnessCharacteristic.confidenceInterval.min = skewnessCharacteristic.value - (quantilStudent * skewnessCharacteristic.standardDeviation);
            skewnessCharacteristic.confidenceInterval.max = skewnessCharacteristic.value + (quantilStudent * skewnessCharacteristic.standardDeviation);

            skewnessCharacteristic.value = Math.Round(skewnessCharacteristic.value, 4);
            skewnessCharacteristic.standardDeviation = Math.Round(skewnessCharacteristic.standardDeviation, 4);
            skewnessCharacteristic.confidenceInterval.min = Math.Round(skewnessCharacteristic.confidenceInterval.min, 4);
            skewnessCharacteristic.confidenceInterval.max = Math.Round(skewnessCharacteristic.confidenceInterval.max, 4);

            return skewnessCharacteristic;
        }
        private static QuantilCharacteristic CalculateMedian(ref double[] array)
        {
            QuantilCharacteristic medianCharacteristic = new QuantilCharacteristic();

            if ((array.Length % 2) == 1)
            {
                medianCharacteristic.value = array[array.Length / 2];
            }
            else
            {
                medianCharacteristic.value = (array[array.Length / 2] + array[(array.Length / 2) - 1]) / 2.0;
            }

            medianCharacteristic.value = Math.Round(medianCharacteristic.value, 4);

            return medianCharacteristic;
        }
        private static QuantilCharacteristic CalculateStandardDeviation(ref double[] array)
        {
            QuantilCharacteristic standardDeviationCharacteristic = new QuantilCharacteristic();

            double sum = 0;
            double aver = CalculateAverage(ref array);
            double quantilStudent = QuantilCalculator.StudentQuantil((1.0 - (alpha / 2)), (array.Length - 1));

            for (int i = 0; i < array.Length; i++)
            {
                sum += Math.Pow(array[i] - aver, 2);
            }

            standardDeviationCharacteristic.value = sum / (double)(array.Length - 1);
            standardDeviationCharacteristic.standardDeviation = Math.Sqrt(standardDeviationCharacteristic.value / (2.0 * (double)array.Length));
            standardDeviationCharacteristic.confidenceInterval.min = Math.Sqrt(standardDeviationCharacteristic.value) - (quantilStudent * standardDeviationCharacteristic.standardDeviation);
            standardDeviationCharacteristic.confidenceInterval.max = Math.Sqrt(standardDeviationCharacteristic.value) + (quantilStudent * standardDeviationCharacteristic.standardDeviation);

            standardDeviationCharacteristic.value = Math.Round(standardDeviationCharacteristic.value, 4);
            standardDeviationCharacteristic.standardDeviation = Math.Round(standardDeviationCharacteristic.standardDeviation, 4);
            standardDeviationCharacteristic.confidenceInterval.min = Math.Round(standardDeviationCharacteristic.confidenceInterval.min, 4);
            standardDeviationCharacteristic.confidenceInterval.max = Math.Round(standardDeviationCharacteristic.confidenceInterval.max, 4);

            return standardDeviationCharacteristic;
        }
        private static QuantilCharacteristic CalculateAverageWithDeviationAndIntervals(ref double[] array)
        {
            double quantilStudent = QuantilCalculator.StudentQuantil((1.0 - (alpha / 2)), (array.Length - 1));
            QuantilCharacteristic averageCharacteristic = new QuantilCharacteristic();
            double sum = 0;

            for (int i = 0; i < array.Length; i++)
            {
                sum += array[i];
            }

            averageCharacteristic.value = sum / (double)array.Length;
            averageCharacteristic.standardDeviation = Math.Sqrt(CalculateStandardDeviation(ref array).value / (double)array.Length);
            averageCharacteristic.confidenceInterval.min = averageCharacteristic.value - (quantilStudent * averageCharacteristic.standardDeviation);
            averageCharacteristic.confidenceInterval.max = averageCharacteristic.value + (quantilStudent * averageCharacteristic.standardDeviation);

            averageCharacteristic.value = Math.Round(averageCharacteristic.value, 4);
            averageCharacteristic.standardDeviation = Math.Round(averageCharacteristic.standardDeviation, 4);
            averageCharacteristic.confidenceInterval.min = Math.Round(averageCharacteristic.confidenceInterval.min, 4);
            averageCharacteristic.confidenceInterval.max = Math.Round(averageCharacteristic.confidenceInterval.max, 4);

            return averageCharacteristic;
        }