public string formarCadenaRegla(Regla regla)
{
string retorno = "";
retorno += "SI ";
string[] antecedentes = regla.listarAntecedentes();
string[] consecuentes = regla.listarConsecuentes();
for (int i = 0; i < antecedentes.Length; i++)
{
if (i != 0)
{
retorno += " Y ";
}
Hecho hecho = base_conocimiento.leerHecho(antecedentes[i]);
retorno += hecho.hecho;
}
retorno += " ENTONCES ";
for (int i = 0; i < consecuentes.Length; i++)
{
if (i != 0)
{
retorno += " Y ";
}
Hecho hecho = base_conocimiento.leerHecho(consecuentes[i]);
retorno += hecho.hecho;
}
return(retorno);
}
/// <summary>
/// método que comprueba la integridad de las reglas
/// </summary>
/// <returns>Lista de errores encontrados</returns>
private List <string> comprobarIntegridadReglas()
{
List <string> errores_comprobacion = new List <string>();
string[] reglas = this.manejador_archivos.listarArchivosEnDirectorio(AccesoDatos.REGLA);
bool existen_variables_de_inicio_en_los_antecedentes = false;
bool existen_variables_objetivo_en_el_consecuente = false;
for (int i = 0; i < reglas.Length; i++)
{
Regla regla = manejador_archivos.extraerRegla(reglas[i]);
if (!regla.chequeo_de_consistencia)
{
errores_comprobacion.Add("Regla no chequeada " + regla.id_regla + " : " + regla);
}
if (!regla.id_regla.Equals(reglas[i]))
{
errores_comprobacion.Add("Regla corrupta (Eliminada)" + regla.id_regla + " : " + regla);
manejador_archivos.eliminarRegla(reglas[i]);
}
Hecho hecho_consecuente = manejador_archivos.extraerHecho(regla.id_hecho_consecuente);
if (hecho_consecuente.hecho_objetivo)
{
existen_variables_objetivo_en_el_consecuente = true;
}
if (hecho_consecuente.hecho_preguntable_al_usuario)
{
errores_comprobacion.Add("Regla " + regla.id_regla + "(Consecuente preguntable al usuario) : " + regla);
regla.chequeo_de_consistencia = false;
manejador_archivos.actualizarRegla(regla);
}
if (!existen_variables_de_inicio_en_los_antecedentes)
{
string[] antecedentes = regla.listarAntecedentes();
for (int k = 0; k < antecedentes.Length && !existen_variables_de_inicio_en_los_antecedentes; k++)
{
Hecho hecho_antecedente = manejador_archivos.extraerHecho(antecedentes[k]);
if (hecho_antecedente.hecho_preguntable_al_usuario)
{
existen_variables_de_inicio_en_los_antecedentes = true;
}
}
}
}
if (leerMetadatos().tipo_de_encadenamiento == MetadatosBaseDeConocimiento.ENCADENAMIENTO_HACIA_ADELANTE &&
!existen_variables_de_inicio_en_los_antecedentes)
{
errores_comprobacion.Add("No existen reglas con variables de inicio en el antecedente");
}
if (leerMetadatos().tipo_de_encadenamiento == MetadatosBaseDeConocimiento.ENCADENAMIENTO_HACIA_ATRAS &&
!existen_variables_objetivo_en_el_consecuente)
{
errores_comprobacion.Add("No existen reglas con variables objetivo en su consecuente.");
}
return(errores_comprobacion);
}
int[] motor_inferencia_evento_confimar_hecho(string id_hecho, string id_regla)
{
Regla regla = base_conocimiento.leerRegla(id_regla);
Hecho hecho = base_conocimiento.leerHecho(id_hecho);
Variable variable = base_conocimiento.leerVariable(hecho.id_variable);
string[] lista_de_antecedentes = regla.listarAntecedentes();
Hecho[] hechos_antecedente = new Hecho[lista_de_antecedentes.Length];
for (int i = 0; i < lista_de_antecedentes.Length; i++)
{
hechos_antecedente[i] = base_conocimiento.leerHecho(lista_de_antecedentes[i]);
}
dialogo = new FormDialogoPanel(ventana_validar_hecho);
dialogo.FormClosing += dialogo_FormClosing;
ventana_validar_hecho.evento_respuesta_lista += evento_ventana_respuesta_lista;
ventana_validar_hecho.inciarConsultaHecho(id_regla, hecho, hechos_antecedente, variable.ruta_texto_descriptivo);
dialogo.ShowDialog(ventana_padre);
if (terminar_inferencia)
{
return(null);
}
int[] respuestas = new int[3];
if (ventana_validar_hecho.hecho_validado)
{
respuestas[0] = ConstantesShell.HECHO_CONFIRMADO;
}
else
{
respuestas[0] = ConstantesShell.HECHO_DESCARTADO;
}
if (ventana_validar_hecho.se_soluciono_el_problema)
{
respuestas[1] = ConstantesShell.PROBLEMA_SOLUCIONADO;
}
else
{
respuestas[1] = ConstantesShell.PROBLEMA_NO_SOLUCIONADO;
}
if (ventana_validar_hecho.continuar_inferencia)
{
respuestas[2] = ConstantesShell.CONTINUAR_PROCESO;
}
else
{
respuestas[2] = ConstantesShell.DETENER_PROCESO;
}
return(respuestas);
}
public void inicializarTextBoxAntecedentes()
{
string[] lista_de_hechos = regla_actual.listarAntecedentes();
for (int i = 0; i < lista_de_hechos.Length; i++)
{
Hecho hecho = base_conocimiento.leerHecho(lista_de_hechos[i]);
listBox_hechos.Items.Add(new ElementosListBox()
{
id = hecho.id_hecho,
info = hecho.hecho
});
}
}
/// <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);
}