Пример #1
0
            private bool Applicabile(Regola r)
            {
                bool flag = false;

                foreach (char c in r.Antecedenti)
                {
                    flag = false;
                    if (Risposta.Parametri.Contains(c))
                    {
                        flag = true;
                    }
                    else
                    {
                        foreach (Regola reg in Regole)
                        {
                            if (reg.Conseguente == c)
                            {
                                flag = true;
                                break;
                            }
                        }
                    }
                    if (!flag)
                    {
                        break;
                    }
                }
                return(flag);
            }
Пример #2
0
            public Regola(Regola reg)
            {
                this.Sigla       = reg.Sigla;
                this.Conseguente = reg.Conseguente;
                this.Antecedenti = new List <char>();

                reg.Antecedenti.ForEach(x => this.Antecedenti.Add(x));
            }
Пример #3
0
            private string Solve(Regola regola, string path)
            {
                throw new NotImplementedException();

                // lista per le soluzioni degli antecedenti
                List <string> solutions = new List <string>(regola.Antecedenti.Count);

                // per ogni antecedente della regola trova le regole che lo restituiscono come risultato
                foreach (char ant in regola.Antecedenti)
                {
                    if (Risposta.Parametri.Contains(ant) && (regola.Antecedenti.Count != Risposta.Parametri.Count))
                    {
                        continue;
                    }
                    // aggiungi la regola corrente al percorso
                    string currPath = path + regola.Sigla + "_";


                    // TO FIX --> quando una regola ha come parametro un paramentro inserito dall'utente

                    /*List<Regola> withoutParams = new List<Regola>();
                     * foreach (Regola r in Regole)
                     * {
                     *  // TODO - controlla tutti i parametri e non solo col primo
                     *  if (r.Antecedenti.Contains(Risposta.Parametri[0]))
                     *  {
                     *      withoutParams.Add(new Regola(r));
                     *      withoutParams[withoutParams.Count - 1].Antecedenti.Remove(Risposta.Parametri[0]);
                     *  }
                     * }*/


                    // ottiene la lista di regole utili e applicabili
                    List <Regola> searchIn = new List <Regola>();
                    foreach (Regola r in Regole)
                    {
                        if ((r.Conseguente == ant) && Applicabile(r))  //|| Risposta.Parametri.Contains(ant))
                        {
                            searchIn.Add(r);
                        }
                    }

                    // risolvi le regole plausibili
                    foreach (Regola r in searchIn)
                    {
                        currPath = Solve(r, currPath);
                    }

                    // controlla se il percorso è finito correttamente,
                    // cioè se gli antecedenti della regola sono solo parametri inseriti dall'utente
                    bool check = true;
                    foreach (char a in regola.Antecedenti)
                    {
                        if (!Risposta.Parametri.Contains(a))
                        {
                            check = false;
                        }
                    }
                    if (check)
                    {
                        return(currPath + "!");
                    }

                    solutions.Add(currPath);
                }

                string fullPath = Unisci(solutions);

                if (fullPath.Contains("!") && Risposta.Risultato != regola.Conseguente)
                {
                    return(fullPath);
                }

                // se il risultato della regola è uguale alla risposta, restituisci il percorso
                // altrimenti restituisci una stringa nulla --> il percorso non ha portato risultati
                //if (Risposta.Risultato == regola.Conseguente)
                return(solutions[0] + "&&&&" + solutions[1] + "&&&&" + solutions[2]);
                //else
                //    return string.Empty;
            }