示例#1
0
        //---------------------------------------------------------------------------------
        void analizar(Node nodo, CRegla regla, List <CRegla> reglas, int nivel)
        {
            var cev = (nodo.UserData as CEditorVariable);

            //-- nodo consecuente -----------------------------------
            if (cev.EsConsecuente)
            {
                regla.Consecuente = new ArrayList();
                switch (cev.Variable.tipo_variable)
                {
                case Variable.BOOLEANO:
                    regla.Consecuente.Add(cev.Variable.id_variable);
                    regla.Consecuente.Add(cev.Valor);
                    break;

                case Variable.LISTA:
                    regla.Consecuente.Add(cev.Variable.id_variable);
                    regla.Consecuente.Add(cev.Condicion);
                    regla.Consecuente.Add(cev.Valor);
                    break;

                case Variable.NUMERICO:
                    regla.Consecuente.Add(cev.Variable.id_variable);
                    regla.Consecuente.Add(cev.Condicion);
                    regla.Consecuente.Add(cev.ValorNum);
                    break;
                }
                reglas.Add(regla);
                return;
            }
            //-- nodo antecedentes -----------------------------------
            var variable   = cev.Variable;
            var tipo       = variable.tipo_variable;
            int numOutEdge = 0;

            foreach (var outEdge in nodo.OutEdges)
            {
                numOutEdge++;
                var antecedente = new ArrayList();
                antecedente.Add(variable.id_variable);
                switch (tipo)
                {
                case Variable.BOOLEANO:
                    var condicionBool = outEdge.UserData as string;
                    antecedente.Add(condicionBool);
                    break;

                case Variable.LISTA:
                    var condicionList = outEdge.UserData as string[];
                    antecedente.Add(condicionList[0]);
                    antecedente.Add(condicionList[1]);
                    break;

                case Variable.NUMERICO:
                    var condicionNum = outEdge.UserData as CValorNumerico;
                    if (condicionNum.Comparador.Equals("ENTRE"))
                    {
                        var antecedente2 = new ArrayList();
                        antecedente2.Add(variable.id_variable);
                        antecedente2.Add("MAYOR O IGUAL");
                        antecedente2.Add(condicionNum.Valor);
                        regla.Antecedentes.Add(antecedente2);

                        antecedente.Add("MENOR O IGUAL");
                        antecedente.Add(condicionNum.Valor);
                    }
                    else
                    {
                        antecedente.Add(condicionNum.Comparador);
                        antecedente.Add(condicionNum.Valor);
                    }
                    break;
                }
                if (numOutEdge == 1)
                {
                    regla.Antecedentes.Add(antecedente);
                }
                else
                {
                    regla.Antecedentes.RemoveAt(nivel);
                    regla.Antecedentes.Add(antecedente);
                }
                analizar(outEdge.TargetNode, regla.Clone() as CRegla, reglas, nivel + 1);
            }
            return;
        }
示例#2
0
        //---------------------------------------------------------------------------------
        /// <summary>
        /// Exporta la reglas a la base de conocimiento para que estén disponibles en el sistema.
        /// </summary>
        /// <returns>true si la operacion se realizó con éxito, false en caso contrario.</returns>
        public bool ExportarReglas()
        {
            //-- Chequeo de nodos consecuente -----------
            foreach (var nodo in grafico.Nodes)
            {
                var cev = nodo.UserData as CEditorVariable;
                if (cev.EsConsecuente && cev.Valor == null)
                {
                    return(false);
                }
            }

            //-- recuperacion de nodos iniciales -----------
            var nodosIniciales = new List <Node>();

            foreach (var nodo in grafico.Nodes)
            {
                bool tieneAntecesores = false;
                foreach (var inEdge in nodo.InEdges)
                {
                    tieneAntecesores = true;
                    break;
                }
                if (!tieneAntecesores)
                {
                    nodosIniciales.Add(nodo);
                }
            }

            //-- inicio de proceso recursivo ----------------
            reglas = new List <CRegla>();
            int nivel = 0;

            foreach (var nodo in nodosIniciales)
            {
                var variable = (nodo.UserData as CEditorVariable).Variable;
                var tipo     = variable.tipo_variable;
                foreach (var outEdge in nodo.OutEdges)
                {
                    var regla       = new CRegla();
                    var antecedente = new ArrayList();
                    antecedente.Add(variable.id_variable);
                    switch (tipo)
                    {
                    case Variable.BOOLEANO:
                        var condicionBool = outEdge.UserData as string;
                        antecedente.Add(condicionBool);
                        break;

                    case Variable.LISTA:
                        var condicionList = outEdge.UserData as string[];
                        antecedente.Add(condicionList[0]);
                        antecedente.Add(condicionList[1]);
                        break;

                    case Variable.NUMERICO:
                        var condicionNum = outEdge.UserData as CValorNumerico;
                        if (condicionNum.Comparador.Equals("ENTRE"))
                        {
                            var antecedente2 = new ArrayList();
                            antecedente2.Add(variable.id_variable);
                            antecedente2.Add("MAYOR O IGUAL");
                            antecedente2.Add(condicionNum.Valor);
                            regla.Antecedentes.Add(antecedente2);

                            antecedente.Add("MENOR O IGUAL");
                            antecedente.Add(condicionNum.ValorAux);
                        }
                        else
                        {
                            antecedente.Add(condicionNum.Comparador);
                            antecedente.Add(condicionNum.Valor);
                        }
                        break;
                    }
                    regla.Antecedentes.Add(antecedente);
                    analizar(outEdge.TargetNode, regla.Clone() as CRegla, reglas, nivel + 1);
                }
            }
            return(true);
        }