const byte numberElem = 8; //кол-во элементов в схеме
        const int dt = 1;
        int j;
        double[] P = new double[20]; //вероятность безотказной работы
        Function func = new Function(numberElem);   //класс генерации случайных чисел

        public Form1()
        {
            InitializeComponent();
        }

        double verOtkaz()
        {
            double fi = 0;

            double[] x = new double[numberElem]; ; //элементы схемы
            
            func.generation();
                        
            //вероятности отказа
            x[0] = func.exponentFunc(Convert.ToDouble(maskedTextBox1.Text), 0);
            x[1] = func.maxValueFunc(Convert.ToDouble(maskedTextBox1.Text), 1);
            x[2] = func.giperExponentFunc(Convert.ToDouble(maskedTextBox1.Text), Convert.ToDouble(textBox4.Text), 2);
            x[3] = func.exponentFunc(Convert.ToDouble(maskedTextBox1.Text), 3);
            x[4] = func.maxValueFunc(Convert.ToDouble(maskedTextBox1.Text), 4);
            x[5] = func.giperExponentFunc(Convert.ToDouble(maskedTextBox1.Text), Convert.ToDouble(textBox4.Text), 5);
            x[6] = func.exponentFunc(Convert.ToDouble(maskedTextBox1.Text), 6);
            x[7] = func.maxValueFunc(Convert.ToDouble(maskedTextBox1.Text), 7);

            fi = Math.Round((1 - StructFunc(x)), 7);

            return fi;
        }

        double StructFunc(double[] x)
        {
            ///<summary>
            /// структурная функция
            ///</summary>
            ///<param name = "x">массив элементов цепи</param>
           
            return (1 -
                    (1 - x[0] * x[1]) *
                    (1 - x[6] * x[7]) *
                    (1 - x[0] * x[4] * x[7]) *
                    (1 - x[6] * x[4] * x[1]) *
                    (1 - x[3] * x[2] * x[1]) *
                    (1 - x[3] * x[5] * x[7]) *
                    (1 - x[0] * x[2] * x[5] * x[7]) *
                    (1 - x[6] * x[5] * x[2] * x[1]) *
                    (1 - x[3] * x[2] * x[4] * x[7]) *
                    (1 - x[3] * x[5] * x[4] * x[1])
                    );
        }

        void button1_Click(object sender, EventArgs e)
        {        
            //построение графика вероятности безотказной работы(ВБР)
            //chart1.Series[0].Points.Clear();

            /*P[j] = verOtkaz();
            listBox1.Items.Add(verOtkaz());
            chart1.Series[0].Points.AddXY(j, P[j]);
            j++;*/

           for (j = 0; j < 20; j += dt)
            {
                //вероятность отказа всей системы:
                P[j] = verOtkaz();
                listBox1.Items.Add(verOtkaz());
                chart1.Series[0].Points.AddXY(j, P[j]);
            }
        }

\
 class Function
    { 
        ///<summary>
        ///класс генерации случаянных чисел
        ///</summary>
        ///<param name ="quantElem">кол-во элементов в цепи (от 0 до 255)</param>
        
        private double[] r1;    //массив псевдослучаянных чисел
        private double[] r2;    //массив псевдослучаянных чисел
        private byte quantElem; 

        public Function(byte q)
        {
            /// <summary>
            /// конструктор класса
            /// </summary>
            /// <param name = "numberElem">количество элементов в цепи</param>

            quantElem = q;
        }

        public void generation()
        {
            ///<summary>
            ///генерация псевдослучаянных чисел
            ///</summary>
            /// <param name = "numberElem">количество элементов в цепи</param>
            
            Random rand = new Random();     //генератор псевдослучаянных чисел  
            r1 = new double[quantElem];    //создание массива псевдослучаянных чисел
            r2 = new double[quantElem];    //создание массива псевдослучаянных чисел
            
            // заполнение массивов псевдослучаянными числами
            for (int i = 0; i < quantElem; i++)
            {
                r1[i] = rand.NextDouble();
                r2[i] = rand.NextDouble();
            }
        }
                
        public double maxValueFunc(double lamda, byte numberElem)
        {
            ///<summary>
            ///распределение максимального значения
            ///</summary>
            ///<param name = "lamda">параметр лямда(параметр масштаба)</param>
            ///<param name = "numberElem">номер элемента, для которого вычисляется случаянная величина</param>

            int n = r1.Length;  //число элементов массива псевдослучаянных чисел
            double mu = 0;      //мода
            double x;           //случаянное число
            double r;           //значение распределения

            // вычисление моды(среднее) //
            for (int i = 0; i < n; i++)
            {
                mu += r1[i];
            }

            mu /= n;
            // ------ //
            
            x = (mu - lamda * Math.Log(-Math.Log(r1[numberElem]))); //генерация случаяного числа

            r = Math.Round((Math.Exp(-Math.Exp(-(x - mu) / lamda))), 3);

            return r; 
        }

        public double exponentFunc(double lamda, byte numberElem)
        {
            ///<summary>
            ///экспоненциальное распределение
            ///</summary>
            ///<param name = "lamda">параметр лямда(параметр масштаба)</param>
            ///<param name = "numberElem">номер элемента, для которого вычисляется случаянная величина</param>

            double x;   //случаеное число
            double r;   //значение распределения

            x = ((-1 / lamda) * Math.Log(r1[numberElem]));  //генерация случаяного числа

            r = Math.Round((1 - Math.Exp(-lamda * x)), 3);

            return r;
        }

        public double giperExponentFunc(double lamda, double ro, byte numberElem)
        {
            ///<summary>
            ///гиперэкспоненциальное распределение
            ///</summary>
            ///<param name = "lamda">параметр лямда(параметр масштаба)</param>
            ///<param name = "ro">параметр ро(параметр формы, ро больше 0, но меньше 0.5) </param>
            ///<param name = "numberElem">номер элемента, для которого вычисляется случаянная величина</param>

            double x;   //случаяное число
            double r;   //значение распределения

            //генерация случаяного числа
            if(r1[numberElem] < ro)
            {
                x = ((-1/(2 * ro * lamda)) * Math.Log(r2[numberElem]));
            }
            else
            {
                x = ((-1/(2 * (1 - ro) * lamda)) * Math.Log(r2[numberElem]));
            }

            r = Math.Round((1 - ro * Math.Exp(-2 * ro * lamda * x) - (1 - ro) * Math.Exp(-2 * (1 - ro) * lamda * x)), 3);

            return r;
        }
    }
}