Форум программистов [Powered by Invision Power Board]

Код

class Calculations
    {
        private double MySum = 0;
        //массивы искомых параметров
        //*----------------------------------*//
        private double[] myArray=new double[1763];//массив элементов выборки

        private double[] arrayOfExpectations=new double[5];//массив параметров математического ожидания 
        private double[] arrayOfDispersions=new double[5];//массив параметров дисперсии
        private double[] arrayOfParams=new double[5];//массив весов
        //*----------------------------------*//

        public Calculations(double[] MyData)
        {
            MyData = new double[1763];
            //myArray = new double[1763];

            for (int i = 1; i < MyData.Length; i++)
            {
                MySum += MyData[i];
                this.myArray[i] = MyData[i];
            }
        }
        public double ReturnResults()
        {
            return (MySum);
        }

        private double sum(double[] arrayOfExpectations, double[] arrayOfDispersions, double[] arrayOfParams,double xj)
        {
            double s = 0;
            
            for (int i = 1; i < arrayOfExpectations.Length; i++)
            {
                s += ((arrayOfParams[i] / arrayOfDispersions[i]) * Math.Exp(-0.5 * ((xj - arrayOfExpectations[i]) / arrayOfDispersions[i]) * ((xj - arrayOfExpectations[i]) / arrayOfDispersions[i])));
            }
            return s;
        }
        public double gijm(int j,double xj)
        {
            double result = 0;

            result = (arrayOfParams[j] / arrayOfDispersions[j]) * Math.Exp(-0.5 * ((xj - arrayOfExpectations[j]) / (arrayOfDispersions[j])) * ((xj - arrayOfExpectations[j]) / (arrayOfDispersions[j])));
            result = result / sum(arrayOfExpectations,arrayOfDispersions,arrayOfParams,xj);

            return result;
        }
        //получение оценок для весов в сумме
        public void updateArrayOfParams(double eps)
        {
            double[] distance = new double[5];
            double totaldistance = 0;

            while (totaldistance < eps)
            {
                for (int i = 0; i < 5; i++)
                {
                    double sum = 0;
                    double oldParams = 0;

                    oldParams = arrayOfParams[i];
                    for (int j = 0; j < myArray.Length; j++)
                    {
                        sum += gijm(i, myArray[j]);
                    }
                    sum += sum / myArray.Length;
                    arrayOfParams[i] = sum;

                    distance[i]=(arrayOfParams[i]-oldParams)*(arrayOfParams[i]-oldParams);
                    totaldistance += distance[i];
                }
                totaldistance = Math.Sqrt(totaldistance);
            }
        }
        //вычисление следующей оценки математического ожидания
        public void updateArrayOfExpectations(double eps)
        {
            double[] distance = new double[5];
            double totaldistance = 0;
            
            while (totaldistance < eps)
            {
                for (int i = 0; i < 5; i++)
                {
                    double sum1 = 0;
                    double sum2 = 0;
                    double oldExpectation = 0;

                    oldExpectation = arrayOfExpectations[i];
                    for (int j = 0; j < myArray.Length; j++)
                    {
                        sum1 += gijm(i, myArray[j]);
                    }
                    for (int j = 0; j < myArray.Length; j++)
                    {
                        sum2 += gijm(i, myArray[j]) * myArray[j];
                    }
                    arrayOfExpectations[i] = sum2 / sum1;
                    distance[i]=(arrayOfExpectations[i]-oldExpectation)*(arrayOfExpectations[i]-oldExpectation);
                    totaldistance += distance[i];
                }
                totaldistance = Math.Sqrt(totaldistance);
            }
        }
        //обновление массива дисперсий в смысле евклидовой нормы
        public void updateArrayOfDispersions(double eps)
        {
            double[] distance = new double[5];
            double totaldistance = 0;

            while (totaldistance < eps)
            {
                for (int i = 0; i < 5; i++)
                {
                    double sum1 = 0;
                    double sum2 = 0;
                    double oldDispersion = 0;


                    oldDispersion = arrayOfDispersions[i];
                    for (int j = 0; j < myArray.Length; j++)
                    {
                        sum1 += gijm(i, myArray[j]);
                    }
                    for (int j = 0; j < myArray.Length; j++)
                    {
                        sum2 += gijm(i, myArray[j]) * (myArray[j] - arrayOfExpectations[i]);
                    }
                    sum2 = Math.Sqrt(sum2);
                    arrayOfDispersions[i] = sum2 / sum1;
                    distance[i] = (arrayOfDispersions[i] - oldDispersion) * (arrayOfDispersions[i] - oldDispersion);
                    totaldistance += distance[i];
                }
                totaldistance = Math.Sqrt(totaldistance);
            }
        }
        //запуск алгоритма
        public void runAlgorithm(double eps)
        {
            updateArrayOfParams(eps);
            updateArrayOfExpectations(eps);
            updateArrayOfDispersions(eps);
        }
        public void returnArrayOfParams()
        {
            Console.Write("Вывод оценок для весов");
            Console.Write("=====================================================");
            for (int i = 0; i <= 5; i++)
            {
                Console.Write("Оценка для параметра p", i, "=", arrayOfParams[i]);
            }
        }
        public void returnArrayOfExpectations()
        {
            Console.Write("Вывод оценок для математических ожиданий");
            Console.Write("=====================================================");
            for (int i = 0; i <= 5; i++)
            {
                Console.Write("Оценка для параметра expec", i, "=", arrayOfParams[i]);
            }
        }
        public void returnArrayOfDispersions()
        {
            Console.Write("Вывод оценок для дисперсий");
            Console.Write("=====================================================");
            for (int i = 0; i <= 5; i++)
            {
                Console.Write("Оценка для параметра sigma", i, "=", arrayOfDispersions[i]);
            }
        }
    }