// расчет для вывода

                EnterParameters();
                Random();
                cl1.oP = Convert.ToDouble(cl1.n) / Convert.ToDouble(amount);
                cl2.oP = Convert.ToDouble(cl2.n) / Convert.ToDouble(amount);
                CalcEval(ref cl1);
                CalcEval(ref cl2);
                CalcError();
                cl1.Po = Convert.ToDouble(cl1.cntPo) / Convert.ToDouble(cl1.n);
                cl2.Po = Convert.ToDouble(cl2.cntPo) / Convert.ToDouble(cl2.n);
                Po = Convert.ToDouble(cl1.cntPo + cl2.cntPo) / Convert.ToDouble(amount);
                tmpCl1 = cl1;
                tmpCl2 = cl2;
                tmpAmount = amount;

// расчет для графика

        private void Graph2()
        {
            graph2 = new Graph();
            graph2.X = new List<double>();
            graph2.Y = new List<double>();

            //EnterParameters();
            double tmp = 0.0;
            cl1 = tmpCl1;
            cl2 = tmpCl2;
            amount = tmpAmount;


            for (int i = 0; i < 100; i++)
            {
                cl1.mas1.Clear();
                cl1.mas2.Clear();
                cl1.cntPo = 0;

                cl2.mas1.Clear();
                cl2.mas2.Clear();
                cl2.cntPo = 0;

                EnterParameters();
                tmp += 0.05;

                cl2.d1 += tmp;
                cl2.d2 += tmp;

                Random();
                cl1.oP = Convert.ToDouble(cl1.n) / Convert.ToDouble(amount);
                cl2.oP = Convert.ToDouble(cl2.n) / Convert.ToDouble(amount);

                CalcEval(ref cl1);
                CalcEval(ref cl2);
                CalcError();
                cl1.Po = Convert.ToDouble(cl1.cntPo) / Convert.ToDouble(cl1.n);
                cl2.Po = Convert.ToDouble(cl2.cntPo) / Convert.ToDouble(cl2.n);

                graph2.X.Add(Math.Abs((cl2.d1 + cl2.d2)/2.0 - (cl1.d1 + cl1.d2)/2.0));
                graph2.Y.Add(Convert.ToDouble(cl1.cntPo + cl2.cntPo) / Convert.ToDouble(amount));
            }

// функции расчета

private void EnterParameters()
        {
            cl1 = new Class();
            cl1.cntPo = 0;
            cl1.m1 = Convert.ToDouble(tbx_M11.Text);
            cl1.m2 = Convert.ToDouble(tbx_M12.Text);
            cl1.d1 = Math.Sqrt(Convert.ToDouble(tbx_D11.Text));
            cl1.d2 = Math.Sqrt(Convert.ToDouble(tbx_D12.Text));
            cl1.P = Convert.ToDouble(tbx_P1.Text);
            cl1.mas1 = new List<double>();
            cl1.mas2 = new List<double>();

            cl2 = new Class();
            cl2.cntPo = 0;
            cl2.m1 = Convert.ToDouble(tbx_M21.Text);
            cl2.m2 = Convert.ToDouble(tbx_M22.Text);
            cl2.d1 = Math.Sqrt(Convert.ToDouble(tbx_D21.Text));
            cl2.d2 = Math.Sqrt(Convert.ToDouble(tbx_D22.Text));
            cl2.P = Convert.ToDouble(tbx_P2.Text);
            cl2.mas1 = new List<double>();
            cl2.mas2 = new List<double>();

            amount = Convert.ToInt32(tbx_N.Text);
        }

        private void Random()
        {
            double tmpRand = 0;
            double tmpRand1 = 0;
            double tmpRand2 = 0;
            double S;
            Random newRand = new Random();

            for (int i = 0; i < amount; i++)
            {
                S = 1;
                tmpRand = newRand.NextDouble();
                while (S >= 1)
                {
                    tmpRand1 = newRand.NextDouble();
                    tmpRand2 = newRand.NextDouble();
                    S = Math.Pow((2.0 * tmpRand1 - 1.0), 2) + Math.Pow((2.0 * tmpRand2 - 1.0), 2);
                }

                if (tmpRand < cl1.P)
                {
                    GetRandom(tmpRand1, tmpRand2, S, ref cl1);
                }
                else
                {
                    GetRandom(tmpRand1, tmpRand2, S, ref cl2);
                }
            }

            cl1.n = cl1.mas1.Count;
            cl2.n = cl2.mas1.Count;
        }

        private void GetRandom(double tmp1, double tmp2, double S, ref Class cl)
        {
            double X = (2 * tmp1 - 1) * Math.Sqrt(-2 * Math.Log(S) / S);
            double Y = (2 * tmp2 - 1) * Math.Sqrt(-2 * Math.Log(S) / S);

            X = cl.d1 * X + cl.m1;
            Y = cl.d2 * Y + cl.m2;

            cl.mas1.Add(X);
            cl.mas2.Add(Y);
        }


private void CalcEval(ref Class cl)
        {
            double tmp1 = 0.0;
            double tmp2 = 0.0;

            for (int i = 0; i < cl.n; i++)
            {
                tmp1 += cl.mas1[i];
                tmp2 += cl.mas2[i];
            }
            cl.om1 = (1.0 / Convert.ToDouble(cl.n)) * tmp1;
            cl.om2 = (1.0 / Convert.ToDouble(cl.n)) * tmp2;

            tmp1 = 0.0;
            tmp2 = 0.0;

            for (int i = 0; i < cl.n; i++)
            {
                tmp1 += Math.Pow(cl.om1 - cl.mas1[i], 2);
                tmp2 += Math.Pow(cl.om2 - cl.mas2[i], 2);
            }
            cl.od1 = 1.0 / (Convert.ToDouble(cl.n) + 1.0) * tmp1;
            cl.od2 = 1.0 / (Convert.ToDouble(cl.n) + 1.0) * tmp2;
        }

 private void CalcError()
        {
            for (int i = 0; i < cl1.n; i++)
            {
                if (NormDistr(cl1.mas1[i], cl1.mas2[i], cl1) * cl1.oP < NormDistr(cl1.mas1[i], cl1.mas2[i], cl2) * cl2.oP)
                    cl1.cntPo++;
            }

            for (int i = 0; i < cl2.n; i++)
            {
                if (NormDistr(cl2.mas1[i], cl2.mas2[i], cl2) * cl2.oP < NormDistr(cl2.mas1[i], cl2.mas2[i], cl1) * cl1.oP)
                    cl2.cntPo++;
            }
        }

        private double NormDistr(double X, double Y, Class cl)
        {
            // степень нормального распределения
            double ePow = (-0.5) * (Math.Pow(X - cl.om1, 2) / cl.od1 + Math.Pow(Y - cl.om2, 2) / cl.od2);

            // нормальное распределение
            return (1.0/Math.PI*Math.Sqrt(cl.od1)*Math.Sqrt(cl.od2))*Math.Pow(Math.E, ePow);
        }