Пример #1
0
        private void btnRealizarPrueba_Click(object sender, EventArgs e)
        {
            try
            {
                txtBox_NrosGenerar.Focus();
                int cant_numeros = Convert.ToInt32(txtBox_NrosGenerar.Text);
                int nroIntervalos;
                int cant_minima;

                if (rbtn5.Checked)
                {
                    cant_minima   = 30;
                    nroIntervalos = 5;
                }
                else if (rbtn10.Checked)
                {
                    cant_minima   = 5 * 10;
                    nroIntervalos = 10;
                }
                else if (rbtn15.Checked)
                {
                    cant_minima   = 5 * 15;
                    nroIntervalos = 15;
                }
                else if (rbtnOtro.Checked)
                {
                    int otroNum = int.Parse(txtBox_Otro.Text);
                    cant_minima   = 5 * otroNum;
                    nroIntervalos = otroNum;
                }
                else
                {
                    return;
                }

                // ------------------------ Distribuciones ------------------------

                if (cant_numeros >= cant_minima)
                {
                    dgvPruebaChiCuadrado.Rows.Clear();
                    dgvValoresGenerados.Rows.Clear();
                    float[] lista_pseudos    = new float[cant_numeros];
                    float[] lista_aleatorios = new float[cant_numeros];

                    // variables para el histograma (para todas las distribuciones)
                    int[,] matrizFrecuencias = new int[2, nroIntervalos];

                    // DISTRIBUCIÓN UNIFORME --> LISTO
                    if (rdbUniforme.Checked)
                    {
                        float a;
                        float b;

                        try
                        {
                            a = float.Parse(txtBoxA.Text);
                            b = float.Parse(txtBoxB.Text);
                        }
                        catch
                        {
                            MessageBox.Show("Complete las casillas correctamente.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            txtBoxA.Focus();
                            return;
                        }
                        if (a >= b)
                        {
                            MessageBox.Show("El límite inferior A no puede ser mayor o igual al límite superior B. Ingrese nuevamente los valores", "Atención", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                            return;
                        }

                        //PASO 1 --> SE PROCEDE A LLENAR TABLA DE ALEATORIOS

                        // pseudoaleatorios
                        generadorPseudo = new GeneradorLenguaje();
                        lista_pseudos   = generadorPseudo.generarPseudoaleatorios(cant_numeros);
                        // aleatorios
                        generadorAleatorio = new GeneradorUniforme(a, b);
                        lista_aleatorios   = generadorAleatorio.generarNumeros(lista_pseudos);

                        generadorAleatorio.llenar_dgv(dgvValor, lista_aleatorios);

                        //PASO 2 --> SE PROCEDE A LLENAR TABLA DE FRECUENCIAS ESPERADAS

                        float tamañoIntervalo_Uniforme = (b - a) / nroIntervalos;

                        float[] fo_array    = new float[nroIntervalos];
                        float   fe_uniforme = (float)cant_numeros / (float)nroIntervalos;
                        float[] desde       = new float[nroIntervalos];
                        float[] hasta       = new float[nroIntervalos];

                        //determinación de intervalos
                        desde[0] = a;
                        hasta[0] = a + tamañoIntervalo_Uniforme;
                        for (int i = 1; i < nroIntervalos; i++)
                        {
                            desde[i] = hasta[i - 1];
                            hasta[i] = hasta[i - 1] + tamañoIntervalo_Uniforme;
                        }
                        //determinación de frecuencia observada
                        for (int i = 0; i < cant_numeros; i++)
                        {
                            for (int j = 0; j < nroIntervalos; j++)
                            {
                                if (lista_aleatorios[i] < hasta[j])
                                {
                                    fo_array[j] += 1;
                                    break;
                                }
                            }
                        }

                        // ------ Carga matriz y Array de frecuencias esperadas ------

                        float[] fe_array = new float[nroIntervalos];
                        for (int i = 0; i < nroIntervalos; i++)
                        {
                            fe_array[i]             = fe_uniforme;
                            matrizFrecuencias[1, i] = Convert.ToInt32(fo_array[i]);
                            matrizFrecuencias[0, i] = Convert.ToInt32(fe_uniforme);
                        }

                        // ------ Tabla ji-Cuadrada  ------

                        prueba = new JICuadrada();
                        prueba.realizar_prueba_en_dgv(dgvPruebaChiCuadrado, desde, hasta, fo_array, fe_array);
                    }

                    // DISTRIBUCIÓN NORMAL: BOX MULLER
                    else if (rdbNormalBoxMuller.Checked)
                    {
                        float media             = float.Parse(txtBoxMedia.Text);
                        float desvacionEstandar = float.Parse(txtBoxDesviacion.Text);
                        if (cant_numeros >= 0)
                        {
                            //PASO 1 --> SE PROCEDE A LLENAR TABLA DE ALEATORIOS

                            // pseudoaleatorios
                            generadorPseudo = new GeneradorLenguaje();
                            lista_pseudos   = generadorPseudo.generarPseudoaleatorios(cant_numeros * 2);
                            // aleatorios
                            generadorAleatorio = new GeneradorNormal(media, desvacionEstandar, "box_muller");
                            lista_aleatorios   = generadorAleatorio.generarNumeros(lista_pseudos);

                            generadorAleatorio.llenar_dgv(dgvValor, lista_aleatorios);
                            // aleatorios BoxMuller 1
                            float[] aleatorios_BM1 = new float[cant_numeros];
                            Array.Copy(lista_aleatorios, 0, aleatorios_BM1, 0, cant_numeros);


                            //PASO 2 Determinación de intervalos, marcas de clases y P()s
                            float[] desde       = new float[nroIntervalos];
                            float[] hasta       = new float[nroIntervalos];
                            float[] marca_clase = new float[nroIntervalos];
                            float[] p_          = new float[nroIntervalos];

                            float menor_aleatorio = aleatorios_BM1.Min();
                            float mayor_aleatorio = aleatorios_BM1.Max();

                            desde[0] = menor_aleatorio;
                            float tamaño_intervalo = (1 + mayor_aleatorio - menor_aleatorio) / nroIntervalos;
                            hasta[0] = menor_aleatorio + tamaño_intervalo;

                            marca_clase[0] = (desde[0] + hasta[0]) / 2;

                            p_[0] = Math.Abs(calcularDensidadNormal(media, desvacionEstandar, marca_clase[0], hasta[0], desde[0]));

                            for (int i = 1; i < nroIntervalos; i++)
                            {
                                desde[i]       = hasta[i - 1];
                                hasta[i]       = hasta[i - 1] + tamaño_intervalo;
                                marca_clase[i] = (desde[i] + hasta[i]) / 2;
                                p_[i]          = Math.Abs(calcularDensidadNormal(media, desvacionEstandar, marca_clase[i], hasta[i], desde[i]));
                            }

                            // PASO 3 Frecuencias observadas y esperadas
                            float[] fo_array = new float[nroIntervalos];
                            float[] fe_array = new float[nroIntervalos];
                            for (int k = 0; k < nroIntervalos; k++)
                            {
                                // fe
                                fe_array[k] = p_[k] * (float)cant_numeros;
                            }
                            for (int i = 0; i < cant_numeros; i++)
                            {
                                for (int j = 0; j < nroIntervalos; j++)
                                {
                                    // fo
                                    if (aleatorios_BM1[i] < hasta[j])
                                    {
                                        fo_array[j] += 1;

                                        break;
                                    }
                                }
                            }
                            for (int i = 0; i < nroIntervalos; i++)
                            {
                                dgvValoresGenerados.Rows.Add(string.Format("[ " + "{0:N2}", desde[i]) + " ; " + string.Format("{0:N2}", hasta[i]) + " )", string.Format("{0:N2}", marca_clase[i]), fo_array[i], string.Format("{0:N4}", p_[i]), string.Format("{0:N4}", fe_array[i]));
                            }


                            // ------ Carga de matriz para histograma ------

                            for (int i = 0; i < nroIntervalos; i++)
                            {
                                matrizFrecuencias[1, i] = Convert.ToInt32(fo_array[i]);
                                matrizFrecuencias[0, i] = Convert.ToInt32(fe_array[i]);
                            }

                            // ----- Juntando intervalos adyacentes necesarios -----

                            vector_fe_mayor_5(desde, hasta, fe_array, fo_array);

                            // ------ Tabla ji-Cuadrada  ------

                            prueba = new JICuadrada();
                            prueba.realizar_prueba_en_dgv(dgvPruebaChiCuadrado, desde, hasta, fo_array, fe_array);
                        }
                    }

                    // DISTRIBUCIÓN NORMAL: CONVOLUCIÓN
                    else if (rdbNormalConvolucion.Checked)
                    {
                        //PASO 1 --> SE PROCEDE A LLENAR TABLA DE ALEATORIOS

                        float media      = float.Parse(txtBoxMedia.Text);
                        float desviacion = float.Parse(txtBoxDesviacion.Text);

                        // pseudoaleatorios
                        generadorPseudo = new GeneradorLenguaje();
                        lista_pseudos   = generadorPseudo.generarPseudoaleatorios(cant_numeros * 12);

                        // aleatorios
                        generadorAleatorio = new GeneradorNormal(media, desviacion, "convolucion");
                        lista_aleatorios   = generadorAleatorio.generarNumeros(lista_pseudos);

                        generadorAleatorio.llenar_dgv(dgvValor, lista_aleatorios);


                        //PASO 2 Determinación de intervalos, marcas de clases y P()s
                        float[] desde       = new float[nroIntervalos];
                        float[] hasta       = new float[nroIntervalos];
                        float[] marca_clase = new float[nroIntervalos];
                        float[] p_          = new float[nroIntervalos];

                        float menor_aleatorio = lista_aleatorios.Min();
                        float mayor_aleatorio = lista_aleatorios.Max();
                        desde[0] = menor_aleatorio;
                        float tamaño_intervalo = (1 + mayor_aleatorio - menor_aleatorio) / nroIntervalos;
                        hasta[0]       = menor_aleatorio + tamaño_intervalo;
                        marca_clase[0] = (desde[0] + hasta[0]) / 2;
                        p_[0]          = Math.Abs(calcularDensidadNormal(media, desviacion, marca_clase[0], desde[0], hasta[0]));

                        for (int i = 1; i < nroIntervalos; i++)
                        {
                            desde[i]       = hasta[i - 1];
                            hasta[i]       = hasta[i - 1] + tamaño_intervalo;
                            marca_clase[i] = (desde[i] + hasta[i]) / 2;
                            p_[i]          = Math.Abs(calcularDensidadNormal(media, desviacion, marca_clase[i], desde[i], hasta[i]));
                        }

                        // PASO 2 Frecuencias observadas y esperadas
                        float[] fo_array = new float[nroIntervalos];
                        float[] fe_array = new float[nroIntervalos];
                        for (int k = 0; k < nroIntervalos; k++)
                        {
                            // fe
                            fe_array[k] = p_[k] * (float)cant_numeros;
                        }
                        for (int i = 0; i < cant_numeros; i++)
                        {
                            for (int j = 0; j < nroIntervalos; j++)
                            {
                                // fo
                                if (lista_aleatorios[i] < hasta[j])
                                {
                                    fo_array[j] += 1;

                                    break;
                                }
                            }
                        }
                        for (int i = 0; i < nroIntervalos; i++)
                        {
                            dgvValoresGenerados.Rows.Add(string.Format("[ " + "{0:N2}", desde[i]) + " ; " + string.Format("{0:N2}", hasta[i]) + " )", string.Format("{0:N2}", marca_clase[i]), fo_array[i], string.Format("{0:N4}", p_[i]), string.Format("{0:N4}", fe_array[i]));
                        }


                        // ------ Histograma ------

                        for (int i = 0; i < nroIntervalos; i++)
                        {
                            matrizFrecuencias[1, i] = Convert.ToInt32(fo_array[i]);
                            matrizFrecuencias[0, i] = Convert.ToInt32(fe_array[i]);
                        }

                        // ----- Juntando intervalos adyacentes necesarios -----

                        vector_fe_mayor_5(desde, hasta, fe_array, fo_array);

                        // ------ Tabla ji-Cuadrada  ------

                        prueba = new JICuadrada();
                        prueba.realizar_prueba_en_dgv(dgvPruebaChiCuadrado, desde, hasta, fo_array, fe_array);
                    }

                    // DISTRIBUCIÓN POISSON
                    else if (rdbPoisson.Checked)
                    {
                        dgvValor.Rows.Clear();
                        int[]            variablesPoisson = new int[cant_numeros];
                        int              cantidadVar      = variablesPoisson.Length;
                        double           lambda           = double.Parse(txtBoxLambda.Text);
                        GeneradorPoisson generadorPoisson = new GeneradorPoisson();
                        variablesPoisson = generadorPoisson.generarNumerosPoisson(cant_numeros, lambda);

                        int[] numerosPoisson = generadorPoisson.generarNumerosPoisson(cant_numeros, lambda);
                        generadorPoisson.llenar_dgv(dgvValor, numerosPoisson);

                        int minimo = variablesPoisson.Min();
                        int maximo = variablesPoisson.Max();
                        int h      = 0;

                        // -------------- Histograma --------------
                        matrizFrecuencias = new int[2, cant_numeros];
                        for (int i = minimo; i < maximo + 1; i++)
                        {
                            int    fo       = 0;
                            double pPoisson = 0;
                            int    fe       = 0;

                            for (int j = 0; j < variablesPoisson.Length; j++)
                            {
                                if (variablesPoisson[j] == minimo)
                                {
                                    fo = fo + 1;
                                }
                            }

                            pPoisson = calcularDensidadPoisson(minimo, lambda);
                            fe       = (int)Math.Round(Convert.ToDouble(variablesPoisson.Length * pPoisson), 0, MidpointRounding.ToEven);

                            dgvValoresGenerados.Rows.Add(minimo, " - ", fo, string.Format("{0:N4}", pPoisson), fe);


                            matrizFrecuencias[0, h] = Convert.ToInt32(fe);
                            matrizFrecuencias[1, h] = fo;
                            fo       = 0;
                            fe       = 0;
                            pPoisson = 0;
                            minimo   = minimo + 1;
                            h++;
                        }

                        nroIntervalos = dgvValoresGenerados.Rows.Count;
                        // -------------- \ Histograma --------------

                        string  intJiCuadrado = "";
                        int     foJiCuadrado  = 0;
                        int     feJiCuadrado  = 0;
                        float   estadisticoAC = 0;
                        int     contador      = -1;
                        float[] estadisticos  = new float[100];

                        for (int i = 0; i < dgvValoresGenerados.Rows.Count; i++)
                        {
                            intJiCuadrado = intJiCuadrado.ToString() + " " + Convert.ToInt32(dgvValoresGenerados.Rows[i].Cells[0].Value).ToString();
                            foJiCuadrado  = foJiCuadrado + Convert.ToInt32(dgvValoresGenerados.Rows[i].Cells[2].Value);
                            feJiCuadrado  = feJiCuadrado + Convert.ToInt32(dgvValoresGenerados.Rows[i].Cells[4].Value);


                            if (feJiCuadrado >= 5)
                            {
                                contador = contador + 1;
                                float estadistico = (float)Math.Pow((feJiCuadrado - foJiCuadrado), 2) / feJiCuadrado;
                                estadisticoAC          = estadisticoAC + estadistico;
                                estadisticos[contador] = estadistico;
                                dgvPruebaChiCuadrado.Rows.Add(intJiCuadrado, foJiCuadrado, feJiCuadrado, string.Format("{0:N4}", estadistico), string.Format("{0:N4}", estadisticoAC));

                                intJiCuadrado = "";
                                foJiCuadrado  = 0;
                                feJiCuadrado  = 0;
                            }
                            else
                            {
                                if (i == dgvValoresGenerados.Rows.Count - 1)
                                {
                                    float estAc = 0;
                                    for (int j = 0; j < contador; j++)
                                    {
                                        estAc = estAc + estadisticos[j];
                                    }
                                    float estadistico =
                                        (float)Math.Pow(((Convert.ToInt32(dgvPruebaChiCuadrado.Rows[contador].Cells[2].Value) + feJiCuadrado) - (Convert.ToInt32(dgvPruebaChiCuadrado.Rows[contador].Cells[1].Value) + foJiCuadrado)), 2) / (Convert.ToInt32(dgvPruebaChiCuadrado.Rows[contador].Cells[2].Value) + feJiCuadrado);
                                    dgvPruebaChiCuadrado.Rows[contador].Cells[0].Value = dgvPruebaChiCuadrado.Rows[contador].Cells[0].Value.ToString() + "" + intJiCuadrado.ToString();
                                    dgvPruebaChiCuadrado.Rows[contador].Cells[1].Value = Convert.ToInt32(dgvPruebaChiCuadrado.Rows[contador].Cells[1].Value) + foJiCuadrado;
                                    dgvPruebaChiCuadrado.Rows[contador].Cells[2].Value = Convert.ToInt32(dgvPruebaChiCuadrado.Rows[contador].Cells[2].Value) + feJiCuadrado;
                                    dgvPruebaChiCuadrado.Rows[contador].Cells[3].Value = string.Format("{0:N4}", estadistico);
                                    estAc = estAc + estadistico;
                                    dgvPruebaChiCuadrado.Rows[contador].Cells[4].Value = string.Format("{0:N4}", estAc);
                                }
                            }
                        }
                        dgvPruebaChiCuadrado.Rows[dgvPruebaChiCuadrado.Rows.Count - 1].Cells[4].Style.BackColor = Color.Orange;
                    }

                    // DISTRIBUCIÓN EXPONENCIAL
                    else if (rdbExponencial.Checked)
                    {
                        float media = float.Parse(txtBoxMedia.Text);


                        //PASO 1 --> SE PROCEDE A LLENAR TABLA DE ALEATORIOS

                        // pseudoaleatorios
                        generadorPseudo = new GeneradorLenguaje();
                        lista_pseudos   = generadorPseudo.generarPseudoaleatorios(cant_numeros);
                        // aleatorios
                        generadorAleatorio = new GeneradorExponencial(media);
                        lista_aleatorios   = generadorAleatorio.generarNumeros(lista_pseudos);

                        generadorAleatorio.llenar_dgv(dgvValor, lista_aleatorios);


                        //PASO 2 Determinación de intervalos, marcas de clases y P()s
                        float   lambda      = 1 / media;
                        float[] desde       = new float[nroIntervalos];
                        float[] hasta       = new float[nroIntervalos];
                        float[] marca_clase = new float[nroIntervalos];
                        float[] p_          = new float[nroIntervalos];

                        float menor_aleatorio = lista_aleatorios.Min();
                        float mayor_aleatorio = lista_aleatorios.Max();

                        desde[0] = menor_aleatorio;
                        float tamaño_intervalo = (1 + mayor_aleatorio - menor_aleatorio) / nroIntervalos;
                        hasta[0] = menor_aleatorio + tamaño_intervalo;

                        marca_clase[0] = (desde[0] + hasta[0]) / 2;

                        p_[0] = Math.Abs(calcularDensidadExponencial(marca_clase[0], hasta[0], desde[0], lambda));

                        for (int i = 1; i < nroIntervalos; i++)
                        {
                            desde[i]       = hasta[i - 1];
                            hasta[i]       = hasta[i - 1] + tamaño_intervalo;
                            marca_clase[i] = (desde[i] + hasta[i]) / 2;
                            p_[i]          = Math.Abs(calcularDensidadExponencial(marca_clase[i], hasta[i], desde[i], lambda));
                        }

                        // PASO 3 Frecuencias observadas y esperadas
                        float[] fo_array = new float[nroIntervalos];
                        float[] fe_array = new float[nroIntervalos];
                        for (int k = 0; k < nroIntervalos; k++)
                        {
                            // fe
                            fe_array[k] = p_[k] * (float)cant_numeros;
                        }
                        for (int i = 0; i < cant_numeros; i++)
                        {
                            for (int j = 0; j < nroIntervalos; j++)
                            {
                                // fo
                                if (lista_aleatorios[i] < hasta[j])
                                {
                                    fo_array[j] += 1;

                                    break;
                                }
                            }
                        }
                        for (int i = 0; i < nroIntervalos; i++)
                        {
                            dgvValoresGenerados.Rows.Add(string.Format("[ " + "{0:N2}", desde[i]) + " ; " + string.Format("{0:N2}", hasta[i]) + " )", string.Format("{0:N2}", marca_clase[i]), fo_array[i], string.Format("{0:N4}", p_[i]), string.Format("{0:N4}", fe_array[i]));
                        }


                        // ------ Carga de matriz para histograma ------

                        for (int i = 0; i < nroIntervalos; i++)
                        {
                            matrizFrecuencias[1, i] = Convert.ToInt32(fo_array[i]);
                            matrizFrecuencias[0, i] = Convert.ToInt32(fe_array[i]);
                        }

                        // ----- Juntando intervalos adyacentes necesarios -----

                        vector_fe_mayor_5(desde, hasta, fe_array, fo_array);

                        // ------ Tabla ji-Cuadrada  ------

                        prueba = new JICuadrada();
                        prueba.realizar_prueba_en_dgv(dgvPruebaChiCuadrado, desde, hasta, fo_array, fe_array);
                    }

                    // Histograma para todas las distribuciones
                    histograma1 = new Histograma();
                    histograma1.cargarHistograma(nroIntervalos, matrizFrecuencias, cant_numeros);
                }
                else
                {
                    MessageBox.Show("Debe solicitar al menos " + cant_minima.ToString() + " números.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    txtBox_NrosGenerar.Clear();
                    txtBox_NrosGenerar.Focus();
                }
            }
            catch
            {
                Clases.IOException exception = new Clases.IOException();
            }
        }
        private void btnGenerar_Click(object sender, EventArgs e)
        {
            int cantidadNumeros;

            try
            {
                cantidadNumeros = int.Parse(txtBox_NrosGenerar.Text);
            }
            catch
            {
                MessageBox.Show("Ingrese una cantidad válida.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                txtBox_NrosGenerar.Focus();
                return;
            }
            if (cantidadNumeros == 0)
            {
                MessageBox.Show("Ingrese una cantidad válida.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                txtBox_NrosGenerar.Focus();
                return;
            }


            generadorPseudo = new GeneradorLenguaje();

            float[] numerosPseudo;
            float[] numerosAleatorios;

            if (rdbUniforme.Checked)
            {
                float a;
                float b;

                try
                {
                    a = float.Parse(txtInterA.Text);
                    b = float.Parse(txtInterB.Text);
                }
                catch
                {
                    MessageBox.Show("Complete las casillas correctamente.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    txtInterA.Focus();
                    return;
                }

                //tener en cuenta que no estamos validando que A sea menor a B, pero anda lo mismo
                generador_aleatorio = new GeneradorUniforme(a, b);

                //tener en cuenta q esto entrega pseudoaleatorios SOLO de 4 decimales (aviso por las dudas)
                numerosPseudo = generadorPseudo.generarPseudoaleatorios(cantidadNumeros);

                numerosAleatorios = generador_aleatorio.generarNumeros(numerosPseudo);
                generador_aleatorio.llenar_dgv(dgvNumeros, numerosAleatorios);
            }

            else if (rdbExponencial.Checked)
            {
                float media;

                try
                {
                    media = float.Parse(txtMedia.Text);
                }
                catch
                {
                    MessageBox.Show("Complete las casillas correctamente.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    txtMedia.Focus();
                    return;
                }

                generador_aleatorio = new GeneradorExponencial(media);

                //tener en cuenta q esto entrega pseudoaleatorios SOLO de 4 decimales (aviso por las dudas)
                numerosPseudo = generadorPseudo.generarPseudoaleatorios(cantidadNumeros);

                numerosAleatorios = generador_aleatorio.generarNumeros(numerosPseudo);
                generador_aleatorio.llenar_dgv(dgvNumeros, numerosAleatorios);
            }

            else if (rdbNormalBoxMuller.Checked)
            {
                float media;
                float desviacion;

                try
                {
                    media      = float.Parse(txtMedia.Text);
                    desviacion = float.Parse(txtDesviacion.Text);
                }
                catch
                {
                    MessageBox.Show("Complete las casillas correctamente.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    txtMedia.Focus();
                    return;
                }

                generador_aleatorio = new GeneradorNormal(media, desviacion, "box_muller");

                numerosPseudo = generadorPseudo.generarPseudoaleatorios(cantidadNumeros * 2);

                numerosAleatorios = generador_aleatorio.generarNumeros(numerosPseudo);

                generador_aleatorio.llenar_dgv(dgvNumeros, numerosAleatorios);
            }

            else if (rdbNormalConvolucion.Checked)
            {
                float media;
                float desviacion;

                try
                {
                    media      = float.Parse(txtMedia.Text);
                    desviacion = float.Parse(txtDesviacion.Text);
                }
                catch
                {
                    MessageBox.Show("Complete las casillas correctamente.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    txtMedia.Focus();
                    return;
                }

                generador_aleatorio = new GeneradorNormal(media, desviacion, "convolucion");

                numerosPseudo = generadorPseudo.generarPseudoaleatorios(cantidadNumeros * 12);

                numerosAleatorios = generador_aleatorio.generarNumeros(numerosPseudo);

                generador_aleatorio.llenar_dgv(dgvNumeros, numerosAleatorios);
            }

            else if (rdbPoisson.Checked)
            {
                float lambda;

                try
                {
                    lambda = float.Parse(txtLambda.Text);
                }
                catch
                {
                    MessageBox.Show("Complete las casillas correctamente.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    txtLambda.Focus();
                    return;
                }

                GeneradorPoisson generador      = new GeneradorPoisson();
                int[]            numerosPoisson = generador.generarNumerosPoisson(cantidadNumeros, lambda);
                generador.llenar_dgv(dgvNumeros, numerosPoisson);
            }
        }