Exemplo n.º 1
0
        private void button1_Click(object sender, EventArgs e)
        {
            bool fin = true;
            lambda = Convert.ToDouble(textBox2.Text);         //получаем интенсивность прихода заявок в систему
               // tprih = Convert.ToInt32(textBox3.Text);             //среднее время прихода заявок
            timeModel = Convert.ToDouble(textBox4.Text)*60; //чтобы время моделирования было в минутах
            timeObsl = Convert.ToInt32(textBox1.Text);
            tIn = 1 / lambda;
               //tObs = 1 / mu;
            P = Poison();                                     //С помощью распределения Пуассона получаем вероятность прихода заявки в систему
            int i = 1;
            int k = 0;                                        //счетчик заявок
            int newReq;
            Channel chan1 = new Channel(i, true);             //создаем первый канал
            i++;
            Channel chan2 = new Channel(i, true);             //создаем второй канал
            double f = dt;
            countRequest = 0;
            double timeperiod = 0;
            int tpstart = 0;
            int tpend = 0;
            int tstart = timeObsl - 5;
            int tend = timeObsl + 5;
            tpstart = Convert.ToInt32(100/lambda - 35);
            tpend = Convert.ToInt32(100/lambda + 35);
            double tok = 0;
            //timeperiod = 1 / lambda;
            while (fin)
            {
                //получим новый промежуток времени, в течение которого приходит заявка
                timeperiod = (rand.Next(tpstart, tpend))/100;
                tok = f + timeperiod;
                //
                if (isRequested())
                {
                    countRequest++;
                    newReq = rand.Next(tstart, tend); //генерируем время обслуживания новой заявки
                    state1 = chan1.getState();
                    state2 = chan2.getState();
                    countQ1 = chan1.que.Count;
                    countQ2 = chan2.que.Count;
                    //проверим состояния каналов обслуживания, свободны или нет
                    if (state1 != 0 && state2 != 0) //если оба заняты в данный момент
                    {
                        if (countQ1 != 0) //пуста ли очередь первого канала
                        {
                            if (countQ2 == 0)
                            {
                                chan2.insertRequestToQueue(newReq, f);
                                countQ2++;
                            }
                            else
                            {
                                if (countQ1 <= countQ2)
                                {
                                    chan1.insertRequestToQueue(newReq, f);
                                    countQ1++;
                                }
                                else
                                {
                                    chan2.insertRequestToQueue(newReq, f);
                                    countQ2++;
                                }
                            }
                        }
                        else
                        {
                            if (countQ2 == 0) //два канала со свободной очередью, куда закинем нашу заявку?
                            {
                                chan1.insertRequestToQueue(newReq, f);
                                countQ1++;
                            }
                            else  // в этой ситуации все ок, в первый канал заявку загнали и готово
                            {
                                chan1.insertRequestToQueue(newReq, f);
                                countQ1++;
                            }
                        }
                        k++;
                    }
                    else if (state1 == 0 && state2 == 0) //оба канала не заняты
                    {
                        if (countQ1 != 0 && countQ2 != 0) //обе очереди не пусты, тогда сначала надо загрузить из них каналы
                        {
                            chan1.setTime(chan1.popReqQueue());
                            delta1 = f - chan1.popReqQueueTime();
                            chan1.setTimeReq(delta1);
                            chan1.setState(1);
                            chan1.setcountReqInChannel(1);
                            chan1.setcountTimeReq(delta1);
                            chan2.setTime(chan2.popReqQueue());
                            delta2 = f - chan2.popReqQueueTime();
                            chan2.setTimeReq(delta2);
                            chan2.setState(1);
                            chan2.setcountReqInChannel(1);
                            chan2.setcountTimeReq(delta2);
                            countQ1--;
                            countQ2--;
                            if (countQ1 <= countQ2)
                                chan1.insertRequestToQueue(newReq, f);
                            else
                                chan2.insertRequestToQueue(newReq, f);
                        }
                        else if (countQ1 == 0) //канал свободен, очередь пуста. Занимаем канал на обслуживание
                        {
                            chan1.setState(1);
                            chan1.setTime(newReq);
                            chan1.setTimeReq(0);
                            chan1.setcountReqInChannel(1);
                            chan1.setcountTimeReq(0);
                        }
                        else if (countQ2 == 0) //ну если предыдущее условие не сработало, то проверяем это
                        {
                            chan2.setState(1);
                            chan2.setTime(newReq);
                            chan2.setTimeReq(0);
                            chan2.setcountReqInChannel(1);
                            chan2.setcountTimeReq(0);
                        }
                    }
                    else   //один из каналов не занят
                    {
                        if (state1 == 0) //первый канал свободен
                        {
                            if (countQ1 == 0) //его очередь пуста, простая ситуация, сразу же занимаем канал
                            {
                                chan1.setState(1);
                                chan1.setTime(newReq);
                                chan1.setTimeReq(0);
                                chan1.setcountReqInChannel(1);
                                chan1.setcountTimeReq(0);
                            }
                            else //его очередь не пуста, поэтому сначала занимаем канал заявкой из очереди, а новую заявку отправляем в меньшую очередь
                            {
                                chan1.setTime(chan1.popReqQueue());
                                delta1 = f - chan1.popReqQueueTime();
                                chan1.setTimeReq(delta1);
                                chan1.setState(1);
                                chan1.setcountReqInChannel(1);
                                chan1.setcountTimeReq(delta1);
                                countQ1--;
                                if (countQ1 <= countQ2)
                                    chan1.insertRequestToQueue(newReq, f);
                                else
                                    chan2.insertRequestToQueue(newReq, f);
                            }
                        }
                        else if (state2 == 0) //второй канал свободен, все происходит по аналогии с первым
                        {
                            if (countQ2 == 0)
                            {
                                chan2.setState(1);
                                chan2.setTime(newReq);
                                chan2.setTimeReq(0);
                                chan2.setcountReqInChannel(1);
                                chan2.setcountTimeReq(0);
                            }
                            else
                            {
                                chan2.setTime(chan2.popReqQueue());
                                delta2 = f - chan2.popReqQueueTime();
                                chan2.setTimeReq(delta2);
                                chan2.setState(1);
                                chan2.setcountReqInChannel(1);
                                chan2.setcountTimeReq(delta2);
                                countQ2--;
                                if (countQ1 <= countQ2)
                                    chan1.insertRequestToQueue(newReq, f);
                                else
                                    chan2.insertRequestToQueue(newReq, f);
                            }
                        }
                    }

                }
                else   //если заявка в систему не пришла
                {
                    state1 = chan1.getState();
                    state2 = chan2.getState();
                    countQ1 = chan1.que.Count;
                    countQ2 = chan2.que.Count;
                    if (state1 == 0 && countQ1 == 0)   // если канал свободен и его очередь пуста, то суммируем квант времени простоя с тем. что уже накоплено
                    {
                        chan1.setTimePause(dt);
                    }
                    else if (state1 == 0 && countQ1 > 0)
                    {
                        chan1.setTime(chan1.popReqQueue());
                        delta1 = f - chan1.popReqQueueTime();
                        chan1.setTimeReq(delta1);
                        chan1.setState(1);
                        chan1.setcountReqInChannel(1);
                        chan1.setcountTimeReq(delta1);
                    }
                    if (state2 == 0 && countQ2 == 0) //аналогично
                    {
                        chan2.setTimePause(dt);
                    }
                    else if (state2 == 0 && countQ2 > 0)
                    {
                        chan2.setTime(chan2.popReqQueue());
                        delta2 = f - chan2.popReqQueueTime();
                        chan2.setTimeReq(delta2);
                        chan2.setState(1);
                        chan2.setcountReqInChannel(1);
                        chan2.setcountTimeReq(delta2);
                    }
                }
                if (chan1.getState() == 1)
                    chan1.serviceRequests(dt); //не забываем, что каналы должны обрабатывать свои заявки
                if (chan2.getState() == 1)
                    chan2.serviceRequests(dt);
                f += dt;
                if (f >= timeModel)
                    fin = false;
                else
                {
                    while (f <= tok)
                    {
                        state1 = chan1.getState();
                        state2 = chan2.getState();
                        countQ1 = chan1.que.Count;
                        countQ2 = chan2.que.Count;
                        if (state1 == 0 && countQ1 == 0)   // если канал свободен и его очередь пуста, то суммируем квант времени простоя с тем. что уже накоплено
                        {
                            chan1.setTimePause(dt);
                        }
                        else if (state1 == 0 && countQ1 > 0)
                        {
                            chan1.setTime(chan1.popReqQueue());
                            delta1 = f - chan1.popReqQueueTime();
                            chan1.setTimeReq(delta1);
                            chan1.setState(1);
                            chan1.setcountReqInChannel(1);
                            chan1.setcountTimeReq(delta1);
                        }
                        if (state2 == 0 && countQ2 == 0) //аналогично
                        {
                            chan2.setTimePause(dt);
                        }
                        else if (state2 == 0 && countQ2 > 0)
                        {
                            chan2.setTime(chan2.popReqQueue());
                            delta2 = f - chan2.popReqQueueTime();
                            chan2.setTimeReq(delta2);
                            chan2.setState(1);
                            chan2.setcountReqInChannel(1);
                            chan2.setcountTimeReq(delta2);
                        }
                        if (chan1.getState() == 1)
                            chan1.serviceRequests(dt); //не забываем, что каналы должны обрабатывать свои заявки
                        if (chan2.getState() == 1)
                            chan2.serviceRequests(dt);
                        f += dt;
                        if (f >= timeModel)
                            fin = false;
                    }
                }

            }
            //рассчитаем необходимые величины
            //Mcl = (chan1.getcountTimeReq() + chan2.getcountTimeReq()) / (chan1.getcountReqInChannel() + chan2.getcountReqInChannel()); //рассчитали матожидание времени заявки в системе

            //Mpr = (chan1.getTimePause() + chan2.getTimePause())/2;
            double sum11=0, sum21 = 0, tmp1 = 0;
            double sum12 = 0, sum22 = 0, tmp2 = 0;
            Queue<double> Qu1 = new Queue<double>();
            Queue<double> Qu2 = new Queue<double>();
            Qu1 = chan1.getSumTimeReq();
            Qu2 = chan2.getSumTimeReq();
            int n = Qu1.Count + Qu2.Count;
            while (Qu1.Count != 0)
            {
                tmp1 = Qu1.Dequeue();
                sum11 += tmp1;         //для расчета и дисперсии, и матожидания
                sum21 += tmp1 * tmp1;    //для расчета дисперсии понадобится
            }
            while (Qu2.Count != 0)
            {
                tmp2 = Qu2.Dequeue();
                sum12 += tmp2;         //для расчета и дисперсии, и матожидания
                sum22 += tmp2 * tmp2;    //для расчета дисперсии понадобится
            }
            Mcl = Math.Round(((sum11+sum12) / n), 2);
            label1.Text = Convert.ToString(Mcl);
            SKOcl = Math.Round((Math.Sqrt(((sum21+sum22)-((sum11+sum12)*(sum11+sum12))/n)/(n-1))), 2);
            label10.Text = Convert.ToString(SKOcl);
            SOcl = Math.Round((SKOcl/(Math.Sqrt(n))), 2);
            label24.Text = Convert.ToString(SOcl);
            Qu1.Clear();
            Qu2.Clear();
            Qu1 = chan1.getSumPause();
            Qu2 = chan2.getSumPause();
            n = Qu1.Count + Qu2.Count;
            sum11 = 0; sum12 = 0;
            sum21 = 0; sum22 = 0;
            tmp1  = 0; tmp2  = 0;
            while (Qu1.Count != 0)
            {
                if (Qu1 != null)
                {
                    tmp1 = Qu1.Dequeue();
                    sum11 += tmp1;         //для расчета и дисперсии, и матожидания
                    sum21 += tmp1 * tmp1;    //для расчета дисперсии понадобится
                }
            }
            while (Qu2.Count != 0)
            {
                if (Qu2 != null)
                {
                    tmp2 = Qu2.Dequeue();
                    sum12 += tmp2;         //для расчета и дисперсии, и матожидания
                    sum22 += tmp2 * tmp2;    //для расчета дисперсии понадобится
                }
            }
            Mpr = Math.Round(((sum11 + sum12) / n), 2);
            label2.Text = Convert.ToString(Mpr);
            SKOpr = Math.Round((Math.Sqrt(((sum21 + sum22) - ((sum11 + sum12) * (sum11 + sum12)) / n) / (n - 1))), 2);
            label11.Text = Convert.ToString(SKOpr);
            SOpr = Math.Round((SKOpr / (Math.Sqrt(n))), 2);
            label25.Text = Convert.ToString(SOpr);
            sum11 = 0;
            sum21 = 0;
            sum11 = f - chan1.getTimePause();
            sum21 = f - chan2.getTimePause();
            sum12 = sum11*sum11;
            sum22 = sum21*sum21;
            Mwc = Math.Round(((sum11 + sum21) / 2), 2); //матожидание времени работы системы
            label8.Text = Convert.ToString(Mwc);
            SKOwc = Math.Round((Math.Sqrt(((sum12 + sum22) - ((sum11*sum11+sum21*sum21)/2))/(2-1))), 2);
            label12.Text = Convert.ToString(SKOwc);
            SOwc = Math.Round((SKOwc / (Math.Sqrt(n))), 2);
            label27.Text = Convert.ToString(SOwc);
        }
Exemplo n.º 2
0
        private void button2_Click(object sender, EventArgs e)
        {
            lambda = Convert.ToDouble(textBox2.Text);         //получаем интенсивность прихода заявок в систему
            timeModel = Convert.ToDouble(textBox4.Text) * 60; //чтобы время моделирования было в минутах
            timeObsl = Convert.ToInt32(textBox1.Text);
            double timePereriv = Convert.ToDouble(textBox5.Text);
            Queue<double> queSys = new Queue<double>();                  //общая очередь
            Queue<double> queTimeSys = new Queue<double>();         //моменты прихода заявки в систему
            bool fin = true;

            tIn = 1 / lambda;
            P = Poison();                                     //С помощью распределения Пуассона получаем вероятность прихода заявки в систему
            int i = 1;
            int newReq;
            Channel chan1 = new Channel(i);             //создаем первый канал
            i++;
            Channel chan2 = new Channel(i);             //создаем второй канал
            double f = dt;
            countRequest = 0;

            int tstart = timeObsl - 5;
            int tend = timeObsl + 5;
            int tpstart = Convert.ToInt32(100 / lambda - 35);
            int tpend = Convert.ToInt32(100 / lambda + 35);
            double tok = 0;
            double timeperiod = 0;

            while (fin)
            {
                //получим новый промежуток времени, в течение которого приходит заявка
                timeperiod = (rand.Next(tpstart, tpend)) / 100; //можно поиграиться и поизменять 100 на 10, понаблюдать за результатами: они интересны.
                tok = f + timeperiod;
                //
                if (isRequested())
                {
                    countRequest++;
                    newReq = rand.Next(tstart, tend); //генерируем время обслуживания новой заявки
                    state1 = chan1.getState();
                    state2 = chan2.getState();
                    countQ1 = queSys.Count;
                    //проверим состояния каналов обслуживания, свободны или нет
                    if (state1 != 0 && state2 != 0) //если оба заняты в данный момент, то заявку отправляем в единую очередь
                    {
                        queSys.Enqueue(newReq);
                        queTimeSys.Enqueue(f);
                      //  if (state1 == 2)   //если канал в состоянии паузы
                     //   {
                     //       chan1.wait(dt, timePereriv);
                     //   }
                     //   if (state2 == 2)
                     //   {
                     //       chan2.wait(dt, timePereriv);
                     //   }
                    }
                    else if (state1 == 0 || state2 == 0) //если каналы в состоянии готовности принять новую заявку (хотя бы один из них)
                    {
                        if (countQ1 != 0) //очередь не пуста, поэтому загружаем каналы
                        {
                            queSys.Enqueue(newReq);   //добавили новую заявку в очередь
                            queTimeSys.Enqueue(f);
                            if (state1 == 0)
                            {
                                if (queSys != null)
                                    chan1.setTime(queSys.Dequeue());
                                delta1 = f - queTimeSys.Dequeue();
                                chan1.setTimeReq(delta1);
                                chan1.setState(1);
                                chan1.setcountReqInChannel(1);
                                chan1.setcountTimeReq(delta1);
                            }
                            if (state2 == 0)
                            {
                                if (queSys != null)
                                    chan2.setTime(queSys.Dequeue());
                                delta2 = f - queTimeSys.Dequeue();
                                chan2.setTimeReq(delta2);
                                chan2.setState(1);
                                chan2.setcountReqInChannel(1);
                                chan2.setcountTimeReq(delta2);
                            }
                        }
                        else //очередь пуста
                        {
                            if (state1 == 0)
                            {
                                chan1.setState(1);
                                chan1.setTime(newReq);
                                chan1.setTimeReq(0);
                                chan1.setcountReqInChannel(1);
                                chan1.setcountTimeReq(0);
                                chan2.setTimePause(dt);   //канал простаивает
                            }
                            if (state2 == 0)
                            {
                                chan2.setState(1);
                                chan2.setTime(newReq);
                                chan2.setTimeReq(0);
                                chan2.setcountReqInChannel(1);
                                chan2.setcountTimeReq(0);
                                chan1.setTimePause(dt);   //канал простаивает
                            }
                        }
                    }
                }
                else   //если заявка в систему не пришла
                {
                    state1 = chan1.getState();
                    state2 = chan2.getState();
                    countQ1 = queSys.Count;
                    if (state1 == 0 && countQ1 == 0)   // если канал свободен и его очередь пуста, то суммируем квант времени простоя с тем. что уже накоплено
                    {
                        chan1.setTimePause(dt);
                    }
                    if (state2 == 0 && countQ1 == 0) //аналогично
                    {
                        chan2.setTimePause(dt);
                    }
                    if (state1 == 0 && countQ1 > 0)
                    {
                        chan1.setTime(queSys.Dequeue());
                        delta1 = f - queTimeSys.Dequeue();
                        chan1.setTimeReq(delta1);
                        chan1.setState(1);
                        chan1.setcountReqInChannel(1);
                        chan1.setcountTimeReq(delta1);
                        countQ1 = queSys.Count;
                    }
                    if (state2 == 0 && countQ1 > 0)
                    {
                        chan2.setTime(queSys.Dequeue());
                        delta2 = f - queTimeSys.Dequeue();
                        chan2.setTimeReq(delta2);
                        chan2.setState(1);
                        chan2.setcountReqInChannel(1);
                        chan2.setcountTimeReq(delta2);
                        countQ1 = queSys.Count;
                    }

                }
                if (chan1.getState() == 2)
                    chan1.wait(dt, timePereriv);
                if (chan2.getState() == 2)
                    chan2.wait(dt, timePereriv);
                if (chan1.getState() == 1)
                    chan1.serviceRequestsDop(dt); //не забываем, что каналы должны обрабатывать свои заявки
                if (chan2.getState() == 1)
                    chan2.serviceRequestsDop(dt);
                f += dt;
                if (f >= timeModel)
                    fin = false;
                else
                {
                    while (f <= tok)
                    {
                        state1 = chan1.getState();
                        state2 = chan2.getState();
                        countQ1 = queSys.Count;
                        if (countQ1 == 0)   // если канал свободен и его очередь пуста, то суммируем квант времени простоя с тем. что уже накоплено
                        {
                            if (state1 == 0)
                                chan1.setTimePause(dt);
                            if (state2 == 0)
                                chan2.setTimePause(dt);
                        }
                        if (state1 == 0 && countQ1 > 0)
                        {
                            chan1.setTime(queSys.Dequeue());
                            delta1 = f - queTimeSys.Dequeue();
                            chan1.setTimeReq(delta1);
                            chan1.setState(1);
                            chan1.setcountReqInChannel(1);
                            chan1.setcountTimeReq(delta1);
                            countQ1 = queSys.Count;
                        }
                        if (state2 == 0 && countQ1 > 0)
                        {
                            chan2.setTime(queSys.Dequeue());
                            delta2 = f - queTimeSys.Dequeue();
                            chan2.setTimeReq(delta2);
                            chan2.setState(1);
                            chan2.setcountReqInChannel(1);
                            chan2.setcountTimeReq(delta2);
                            countQ1 = queSys.Count;
                        }
                        if (chan1.getState() == 2)
                            chan1.wait(dt, timePereriv);
                        if (chan2.getState() == 2)
                            chan2.wait(dt, timePereriv);
                        if (chan1.getState() == 1)
                            chan1.serviceRequestsDop(dt); //не забываем, что каналы должны обрабатывать свои заявки
                        if (chan2.getState() == 1)
                            chan2.serviceRequestsDop(dt);
                        f += dt;
                        if (f >= timeModel)
                            fin = false;
                    }
                }
            }
            //рассчитаем статистические величины
            double sum11 = 0, sum21 = 0, tmp1 = 0;
            double sum12 = 0, sum22 = 0, tmp2 = 0;
            Queue<double> Qu1 = new Queue<double>();
            Queue<double> Qu2 = new Queue<double>();
            Qu1 = chan1.getSumTimeReq();
            Qu2 = chan2.getSumTimeReq();
            int n = (chan1.getcountReqInChannel() + chan2.getcountReqInChannel());
            while (Qu1.Count != 0)
            {
                if (Qu1.Count != 0)
                {
                    tmp1 = Qu1.Dequeue();
                    sum11 += tmp1;         //для расчета и дисперсии, и матожидания
                    sum21 += tmp1 * tmp1;    //для расчета дисперсии понадобится
                }
            }
            while (Qu2.Count != 0)
            {
                if (Qu2.Count != 0)
                {
                    tmp2 = Qu2.Dequeue();
                    sum12 += tmp2;         //для расчета и дисперсии, и матожидания
                    sum22 += tmp2 * tmp2;    //для расчета дисперсии понадобится
                }
            }
            //время нахождения заявки в сети
            Mcl = Math.Round(((sum11 + sum12) / n), 2);
            label1.Text = Convert.ToString(Mcl);
            SKOcl = Math.Round((Math.Sqrt(((sum21 + sum22) - ((sum11 + sum12) * (sum11 + sum12)) / n) / (n - 1))), 2);
            label10.Text = Convert.ToString(SKOcl);
            //время простоя каналов по причине отсутствия заявок в сети
            Qu1.Clear();
            Qu2.Clear();
            Qu1 = chan1.getSumPause();
            Qu2 = chan2.getSumPause();
            n = Qu1.Count + Qu2.Count;
            sum11 = 0; sum12 = 0;
            sum21 = 0; sum22 = 0;
            tmp1 = 0; tmp2 = 0;
            while (Qu1.Count != 0)
            {
                    tmp1 = Qu1.Dequeue();
                    sum11 += tmp1;         //для расчета и дисперсии, и матожидания
                    sum21 += tmp1 * tmp1;    //для расчета дисперсии понадобится
            }
            while (Qu2.Count != 0)
            {
                    tmp2 = Qu2.Dequeue();
                    sum12 += tmp2;         //для расчета и дисперсии, и матожидания
                    sum22 += tmp2 * tmp2;    //для расчета дисперсии понадобится
            }
            Mpr = Math.Round(((sum11 + sum12) / n), 2);
            label2.Text = Convert.ToString(Mpr);
            SKOpr = Math.Round((Math.Sqrt(((sum21 + sum22) - ((sum11 + sum12) * (sum11 + sum12)) / n) / (n - 1))), 2);
            label11.Text = Convert.ToString(SKOpr);
            sum11 = 0;
            sum21 = 0;
            sum11 = f - chan1.getTimePause();
            sum21 = f - chan2.getTimePause();
            sum12 = sum11 * sum11;
            sum22 = sum21 * sum21;
            Mwc = Math.Round(((sum11 + sum21) / 2), 2); //матожидание времени работы системы
            label8.Text = Convert.ToString(Mwc);
            SKOwc = Math.Round((Math.Sqrt(((sum12 + sum22) - ((sum11 * sum11 + sum21 * sum21) / 2)) / (2 - 1))), 2);
            label12.Text = Convert.ToString(SKOwc);
            //далее считаем матожидание и дисперсию перерывов для каналов
            Qu1.Clear();
            Qu2.Clear();
            Qu1 = chan1.getSumTimePereriv();
            Qu2 = chan2.getSumTimePereriv();
            n = Qu1.Count + Qu2.Count;
            sum11 = 0; sum12 = 0;
            sum21 = 0; sum22 = 0;
            tmp1 = 0; tmp2 = 0;
            while (Qu1.Count != 0)
            {
                    tmp1 = Qu1.Dequeue();
                    sum11 += tmp1;         //для расчета и дисперсии, и матожидания
                    sum21 += tmp1 * tmp1;    //для расчета дисперсии понадобится
            }
            while (Qu2.Count != 0)
            {
                    tmp2 = Qu2.Dequeue();
                    sum12 += tmp2;         //для расчета и дисперсии, и матожидания
                    sum22 += tmp2 * tmp2;    //для расчета дисперсии понадобится
            }
            Motd = Math.Round(((sum11 + sum12) / n), 2);
            label9.Text = Convert.ToString(Motd);
            SKOotd = Math.Round((Math.Sqrt(((sum21 + sum22) - ((sum11 + sum12) * (sum11 + sum12)) / n) / (n - 1))), 2);
            label13.Text = Convert.ToString(SKOotd);
        }