private void btnVariables_Click(object sender, EventArgs e) { variables = new InfoVariable(); this.ContentPanel.Controls.Clear(); this.ContentPanel.Controls.Add(variables); variables.Show(); }
/// <summary> /// Método que comprueba la ambiguedad recursiva de las reglas /// </summary> /// <returns></returns> private List <string> comprobarAmbiguedadRecursivaEnReglas() { List <string> errores_comprobacion = new List <string>(); List <InfoVariable> info_variables = new List <InfoVariable>(); //Inicio rellenado inicial info_variables string[] reglas = this.manejador_archivos.listarArchivosEnDirectorio(AccesoDatos.REGLA); for (int i = 0; i < reglas.Length; i++) { Regla regla = manejador_archivos.extraerRegla(reglas[i]); Hecho hecho_consecuente = manejador_archivos.extraerHecho(regla.id_hecho_consecuente); bool variable_encontrada_en_info_variables = false; for (int j = 0; j < info_variables.Count; j++) { InfoVariable info_actual = info_variables[j]; string[] antecedentes = regla.listarAntecedentes(); string variable_consecuente = hecho_consecuente.id_variable; string[] variables_antecedente = new string[antecedentes.Length]; for (int h = 0; h < antecedentes.Length; h++)//completamos la ids de las variables antecedente { Hecho hecho_antecedente = manejador_archivos.extraerHecho(antecedentes[h]); variables_antecedente[h] = hecho_antecedente.id_variable; } if (info_actual.id_variable.Equals(variable_consecuente))//si variable asociada al consecuente ya se encuentra en el analisis, agregamos las variables antecedentes a variable asociada { //info_actual.reglas_relacionadas.Add(regla.id_regla); info_actual.agregarElementoAReglasRelacionadas(regla.id_regla); variable_encontrada_en_info_variables = true; for (int k = 0; k < variables_antecedente.Length; k++) { if (!info_actual.buscarEnVariablesAsociadas(variables_antecedente[k]))//si no esta la variable la agregamos a las variables asociadas { info_actual.variables_asociadas.Add(variables_antecedente[k]); } } } else//Si el consecuente no esta en la variable principal, la buscamos en las asociadas { if (info_actual.buscarEnVariablesAsociadas(variable_consecuente)) { //info_actual.reglas_relacionadas.Add(regla.id_regla); info_actual.agregarElementoAReglasRelacionadas(regla.id_regla); bool conflicto_regla = false; for (int k = 0; k < variables_antecedente.Length; k++)//Comprobamos que el antecedente de la regla no contega la variable - lo cual provocaria ambiguedad { if (variables_antecedente[k].Equals(info_actual.id_variable)) { conflicto_regla = true; info_actual.agregarElementoAReglasEnConflicto(regla.id_regla); //info_actual.reglas_en_conflicto.Add(regla.id_regla); } } if (!conflicto_regla) //si no hubo conflicto de reglas agregamos las variables no repetidas a las variables asociadas { for (int k = 0; k < variables_antecedente.Length; k++) { if (!info_actual.buscarEnVariablesAsociadas(variables_antecedente[k]))//si no esta la variable la agregamos a las variables asociadas { info_actual.variables_asociadas.Add(variables_antecedente[k]); } } } } } info_variables[j] = info_actual; }//end analisis info variables if (!variable_encontrada_en_info_variables) { Variable variable = manejador_archivos.extraerVariable(hecho_consecuente.id_variable); InfoVariable info = new InfoVariable(); info.id_variable = variable.id_variable; info.nombre_variable = variable.nombre_variable; info.variables_asociadas = new List <string>(); string[] antecedentes = regla.listarAntecedentes(); for (int x = 0; x < antecedentes.Length; x++) { Hecho h = manejador_archivos.extraerHecho(antecedentes[x]); info.variables_asociadas.Add(h.id_variable); } info.reglas_relacionadas = new List <string>(); //Variables que se relacionan directa o recursivamente con la variable info.reglas_relacionadas.Add(regla.id_regla); info.reglas_en_conflicto = new List <string>();; //Reglas con problema de ambiguedad con la variable info_variables.Add(info); } }//end analisis de reglas //end rellenado inicial info_variables //Proceso iterativo para que todas la variables se comparen con todas bool flag_cambios = true; while (flag_cambios) { flag_cambios = false; for (int i = 0; i < info_variables.Count; i++) { for (int j = 0; j < info_variables.Count; j++) { if (i != j) { InfoVariable info_a = info_variables[i]; InfoVariable info_b = info_variables[j]; if (info_a.buscarEnVariablesAsociadas(info_b.id_variable))//si la variable b esta en las variables asociadas agregamos y analizamos las que falten { bool conflicto_regla = false; for (int k = 0; k < info_b.variables_asociadas.Count; k++)//Comprobamos que el antecedente de la regla no contega la variable - lo cual provocaria ambiguedad { if (info_b.variables_asociadas[k].Equals(info_a.id_variable)) { conflicto_regla = true; } } if (!conflicto_regla) //si no hubo conflicto de reglas agregamos las variables no repetidas a las variables asociadas { for (int k = 0; k < info_b.variables_asociadas.Count; k++) { if (!info_a.buscarEnVariablesAsociadas(info_b.variables_asociadas[k]))//si no esta la variable la agregamos a las variables asociadas { info_a.variables_asociadas.Add(info_b.variables_asociadas[k]); flag_cambios = true; } } } else//si hubo conflicto de reglas { info_a.agregarElementoAReglasEnConflicto(info_b.reglas_relacionadas); info_a.agregarElementoAReglasRelacionadas(info_b.reglas_relacionadas); } } info_variables[i] = info_a; info_variables[j] = info_b; } } } } //Rellenando reglas con errores foreach (InfoVariable info in info_variables) { if (info.reglas_en_conflicto.Count > 0) { Variable variable = manejador_archivos.extraerVariable(info.id_variable); string error = ""; error = "Variable " + variable.id_variable + " (" + variable.nombre_variable + ") Conflicto de ambiguedad \n\tReglas con conflicto : "; for (int q = 0; q < info.reglas_en_conflicto.Count; q++) { if (q != 0) { error += "|"; } error += info.reglas_en_conflicto[q]; } error += "\n\t reglas relacionadas : "; for (int q = 0; q < info.reglas_relacionadas.Count; q++) { if (q != 0) { error += "|"; } error += info.reglas_relacionadas[q]; } errores_comprobacion.Add(error); } } return(errores_comprobacion); }