Ejemplo n.º 1
0
        /// <summary>
        /// Obtiene cada caracter de la cadena y según el ID así ingresa los vertices
        /// a una lista
        /// </summary>
        /// <param name="permutacion"></param>
        public void agregarListaProb(string permutacion, List <Vertice> vertices1, Matriz
                                     matrizAdyacencia1, Matriz matrizAdyacencia2, ref bool encuentraRelacion,
                                     ref List <funcion> listaFunciones)
        {
            for (int i = 0; i < permutacion.Length; i++)
            {
                for (int j = 0; j < listaVertices.Count; j++)
                {
                    if ((int)permutacion[i] == listaVertices[j].ID)
                    {
                        // Si el ID de la cadena es igual al ID de un vertice se agrega
                        // ese vertice al array
                        numeros.Add(listaVertices[j]);
                        break;
                    }
                }
            }


            List <Vertice> vertices2 = new List <Vertice>(numeros);

            if (vertices1.Count > 9)
            {
                // En caso de que la cantidad de vértices sea mayor a nueve, solo se
                // genera una función de isomorfismo.
                Matriz posibleMatriz = OperacionesMatriz.generarMatrizPosible(vertices1,
                                                                              vertices2);
                if (Isomorfismo.gradosListasCoinciden(vertices1, vertices2) &&
                    // Es verdadero si paras el producto de
                    // (posibleMatriz)*(matrizAdyacencia2)*(matryzAdyacencia2Transpuesta)
                    // se genera la matriz de adyacencia del primer grafo.
                    matrizAdyacencia1.equivalent(OperacionesMatriz.multiplicar(
                                                     posibleMatriz, matrizAdyacencia2, OperacionesMatriz.transpose(
                                                         posibleMatriz))))
                {
                    encuentraRelacion = true;
                    funcion f = new funcion();
                    f.V1 = vertices1;
                    f.V2 = vertices2;
                    listaFunciones.Add(f);
                    funcionIsomorfica = listaFunciones;
                }
            }
            else
            {
                listasProbabilidades.Add(vertices2);
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Función encargada de buscar y, en caso de encontrar, generar tantas funciones
        /// de isomorfismo como sean posibles.
        /// </summary>
        /// <param name="g1"> Primer grafo </param>
        /// <param name="g2"> Segundo grafo </param>
        /// <param name="barraProgreso"> Barra que indicará el progreso de la búsqueda de
        /// las funciones de isomorfismo </param>
        /// <param name="cbFunciones"> comboBox en el que se almacenarán los nombres de
        /// las funciones a medida que vayan siendo encontradas </param>
        /// <param name="listaFunciones"> Lista en la que se almacenará la información de
        /// cada una de las funciones encontradas</param>
        /// <returns></returns>
        static bool encuentraFuncionAdyacencia(Grafo g1, Grafo g2,
                                               ProgressBar barraProgreso, ComboBox cbFunciones,
                                               ref List <funcion> listaFunciones)
        {
            // Variable booleana que indica si se encontró o no al menos una función de
            // isomorfismo para los dos grafos dados
            bool pruebaSuperada = false;

            // Instancia e inicia un stopWatch para verificar el tiempo de que el algo-
            // ritmo tarda en encontrar las funciones
            Stopwatch sw = new Stopwatch();

            sw.Start();

            // Lista que almacena las funciones generadas.
            List <funcion> lstFuncionesEncontradas = new List <funcion>();

            // Instancia que servirá para obtener todas las permutaciones de vértices en
            // un grafo
            PermutadorVertices p = new PermutadorVertices();

            // Lista que almacena los vértices del primer grafo
            List <Vertice> vertices1 = g1.lstVertices;



            // Se crean las matrices de adyacencia de los dos grafos
            Matriz matrizAdyacencia1 = g1.matrizAdyacencia();
            Matriz matrizAdyacencia2 = g2.matrizAdyacencia();

            // Lista de que almacena todas las posibles permutaciones de vértices del
            // primer grafo
            List <List <Vertice> > permutacionesV2 = p.combinar(g2.lstVertices, vertices1, matrizAdyacencia1, matrizAdyacencia2, ref pruebaSuperada, ref listaFunciones);

            barraProgreso.Maximum = permutacionesV2.Count;


            int numeroFunciones = 0;

            // Realiza el proceso por cada una de las permutaciones realizadas para el
            // listado de vértices del segundo grafo
            if (pruebaSuperada)
            {
                cbFunciones.Items.Add(string.Format("Funcion #1", numeroFunciones));
                sw.Stop();
            }
            else
            {
                foreach (List <Vertice> vertices2 in permutacionesV2)
                {
                    barraProgreso.Value++;
                    // Se genera una posible matriz con los dos listados de vértices
                    Matriz posibleMatriz = OperacionesMatriz.generarMatrizPosible(vertices1,
                                                                                  vertices2);
                    // Verifica que en la permutación actual almenos coincidan los grados de
                    // los vértices, de lo contrario es inútil continuar buscando la matriz.
                    if (gradosListasCoinciden(vertices1, vertices2) &&
                        // Es verdadero si para el producto de
                        // (posibleMatriz)*(matrizAdyacencia2)*(matryzAdyacencia2Transpuesta)
                        // se genera la matriz de adyacencia del primer grafo.
                        matrizAdyacencia1.equivalent(OperacionesMatriz.multiplicar(
                                                         posibleMatriz, matrizAdyacencia2, OperacionesMatriz.transpose(
                                                             posibleMatriz))))
                    {
                        funcion funcionNueva = new funcion(); // Se crea una nueva función
                        funcionNueva.V1 = vertices1;
                        funcionNueva.V2 = vertices2;
                        // La función creada se añade a la lista de funciones
                        lstFuncionesEncontradas.Add(funcionNueva);
                        numeroFunciones++;
                        cbFunciones.Items.Add(string.Format("Funcion #{0}", numeroFunciones));
                        pruebaSuperada = true;
                        if (vertices1.Count > 9)
                        {
                            break;
                        }
                    }
                }
            }

            listaFunciones = lstFuncionesEncontradas;
            sw.Stop();
            // Muestra información del proceso al usuario
            string msg = String.Format("El programa tardó {0} minutos {1} segundos con {2} milisegu" +
                                       "ndos en intentar encontrar las funciones", sw.Elapsed.Minutes, sw.Elapsed.Seconds,
                                       sw.Elapsed.Milliseconds);

            if (vertices1.Count > 9)
            {
                msg = msg + "\nEl proyecto aún no puede generar todas las funciones de isomorfismo "
                      + "para una cantidad de vértices mayor a 9.\nSi desea colaborar al proyecto puede " +
                      "aportar al siguiente repositorio: https://github.com/MynorXico/ProyectoIsomorfismo";
            }
            MessageBox.Show(msg, "Información", MessageBoxButtons.OK,
                            MessageBoxIcon.Information);
            return(pruebaSuperada);
        }