Sisteme Expert

Nu esti logat.

Proiecte - sisteme expert

Atentie! cerinte valabile pentru toti (si se puncteaza complet numai daca sunt evidentiate in documentatie - conform cerintelor din etapa realizarii documentatiei):

  1. (20p)Sistemele expert trebuie sa contina aproximativ 70-100 de reguli (pentru echipele de 2 persoane). Pentru echipele de 3 persoane trebuie cam intre 100 si 120 reguli, iar pentru cele de o persoana 50-70 de reguli. In aceasta categorie se va puncta si corectitudinea lor. (Se primeste punctaj complet numai daca sunt facute etapele 1 si 2(la 2 partea de evidentiere a atributelor))
  2. (20p)Sa existe minim un caz de raspus al sistemului care sa aiba in istoric minim 3 reguli (exemplu: regula r1 care calculeaza valoarea atributului scop sa aiba printre premise un atribut a1 calculat cu ajutorul regulii r2 care sa aiba de asemenea printre premise un atribut calculat cu ajutorul unei reguli r3). De asemenea sa existe si un raspuns cu doar o regula doar la baza, si altul cu 2 reguli (Se primeste punctaj complet numai daca este facuta si etapa 2, cu evidentierea arborilor pentru fiecare din cazurile punctate in acest enunt).
  3. (10p)Trebuie sa aveti si intrebari cu raspuns boolean (da/nu) si intrebari cu raspuns multiplu.(se punctteaza complet numai daca e finalizata etapa 2(partea de enumerare a atributelor)).
  4. (10p)In cazul intrebarilor cu raspuns boolean trebuie sa se afiseze si optiunile da/nu.
  5. (10p)De asemenea sa existe un caz in care sistemul expert nu da solutii.
  6. (20p)Daca sistemul nu da solutii, atunci se va afisa pe ecran un mesaj in care se indica faptul ca nu exista solutii.
  7. (20p)Sa existe macar o secventa de raspunsuri la intrebari, prin care se obtine o singura solutie, si respectiv o secventa care duce la mai multe solutii posibile.
  8. (10p)Sa existe minim un atribut care este necesar doar pentru o parte din solutiile posibile. Aceste atribute vor fi evidentiate in documentatie.
  9. (10p)Sa existe minim o solutie cu mai multe cai posibile care sa duca la ea (de exemplu doua reguli care stabilesc valoarea atributului scop la acea solutie).
  10. (20p)Solutiile (in Prolog) se vor afisa in ordinea descrescatoare a factorului de certitudine.
  11. (10p)Raspunsurile la intrebari permit existenta unui factor de certitudine
  12. (20p)Este obligatoriu sa puteti afisa demonstratia pentru raspunsurile date.
  13. (20p)Sistemul expert sa admita pentru unele intrebari si raspunsurile nu_stiu si nu_conteaza (se va specifica in cerintele individuale cum marcam aceste intrebari). Daca o intrebare primeste raspunsul cu valoarea nu_stiu, atunci sistemul expert va sari peste regulile care au nevoie de valoarea acelui atribut (pentru ca nu ne putem baza pe valoarea lui). Daca o intrebare primeste raspunsul cu valoarea nu_conteaza, atunci considera testul pentru atributul asociat ca fiind adevarat in orice regula indiferent de valoarea lui.

Observatie: Cand scrieti regulile, la aceeasi concluzie puteti ajunge si pe cai total diferite (de exemplu concluzia C depinde de atributele A1,A2,A3 dar avem o regula in care depinde de atributele A5,A6,A7,A8). De asemenea daca avem o regula R1 cu concluzia C, depinzand de atributele A1,A2,A3 si cu un factor de certitudine N, putem obtine o regula R2 cu concluzia C eliminand un atribut mai putin important dintre atributele A1,A2,A3 dar punand un factor de certitudine N1 < N, deoarece R2 e o regula mai putin specifica decat R1.

Cerinte generale interfata grafica:

  1. Pentru interfata grafica: va exista un buton de reset, vizibil in orice stadiu al aplicatiei, care, la click, va reseta aplicatia la primul ecran, si va reseta si baza de cunostinte in Prolog, pentru a se permite o noua consultare.

Atentie, cerintele individuale trebuie adaugate de asemenea in documentatie. Cerintele individuale pentru programul prolog se rezolva doar in prolog (nu se puncteaza daca sunt rezolvate in Java. Cerintele individuale pentru interfata grafica se puncteaza numai daca sunt rezolvate prin Java (oricum era cam complicat sa treaca rezolvarea lor prin Prolog).

Cateva precizari importante

Lista proiecte

  1. Sistem expert care retine o baza de cunostinte medicale: simptome, diagnostice si tratamente si care poate da un diagnostic in functie de simptomele date (minim 20).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        Id_Regula@id (unde id este numarul regulii)
        Premise:(conditiile enumerate folosind asterisc intre paranteze)
             [#] atr <- valoare (pentru atribute cu valori multiple)
             [#] atr(pentru atribute booleene, valoare true)
             [#] not[atr] (pentru atribute booleene, valoare false)

        atribut_concluzie=valoare//FC= nr .
      • intrebarile vor avea formatul:
        [atribut #
        'continut intrebare' #
        val1 || val2 || val3 || .... ] .
      • scopul se va defini:
        [scop = = atr].
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      [diagnostic]
      [imagine]
      [descriere]
      [contraindicatii:
      - [nume_cod] c1
      - [nume_cod] c2
      ....
      ]
      ----------

      Cuvantul diagnostic va fi inlocuit cu numele solutiei corespunzatoare acelui diagnostic, cuvantul imagine cu calea relativa catre imaginea corespunzatoare, iar cuvantul descriere cu textul corespunzator descrierii.Contraindicatiile sunt cate una pe linie si incep cu -. Fiecare contraindicatie va avea un nume de cod, de exemplu evitat_soare, daca pentru boala diagnosticata este contraindicat ca pacientul sa fie expus la soare. Trebuie sa existe minim un caz cu cel putin 3 contraindicatii.

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      La afisarea solutiilor se va scrie sub fiecare solutie si descrierea + contraindicatii, in felul urmator:

      Solutie: nume_solutie
      Fc: fc
      Detalii: ......descriere.....
      Contraindicatii:
      - contraindicatie1
      - contraindicatie2
      ...
      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
      Doua solutii vor fi separate printr-o linie de procente.

    3. Solutiile se vor afisa cu un indice inainte, de exemplu:

      1)diagnostic_1
      2)diagnostic_2

      Trebuie sa aveti minim un set de raspunsuri din care rezulta cel putin 3 solutii (veti specifica acest set de raspunsuri in documentatie).

      Dupa afisarea solutiei, va aparea o intrebare 'Afiseaza tabelar? (da/nu)'. Daca utilizatorul va raspunde 'da', intern se va crea o matrice cu prima linie continand un blank si apoi idicii solutiilor: 1,2 .. Iar celelalte linii vor fi de forma: primul element = cod_contraindicatie, si pentru coloanele urmatoare x daca respectiva contrainidicatie apartine de solutia corespunzatoare coloanei curente si - daca nu. Aceasta matrice va fi folosita si pentru interfata grafica. Se va realiza o afisare formatata frumoasa a matricii, cu coloanele avand drept dimensiune numarul maxim de caracatere al cuvintelor de pe acea coloana.

    4. De asemenea, programul, inainte de a afisa meniul, va cere utiizatorului un nume si un prenume (atat numele cat si prenumele pot fi formate din mai multe cuvinte - citirea se va face pana la < enter> asa cum se face pentru optiunile meniului). Raspunsul il va salva intr-un predicat dinamic. Se va testa faptul ca numele e format doar din litere si caracterul '-'.

      Dupa obtinerea solutiei, programul Prolog va crea un director numit output_sistem_expert (de fapt, daca exista deja, il va folosi pe acela, iar daca nu exista, il va crea - e obligatoriu de implementat acest test pentru a primi punctaj complet pe cerinta). In acest folder va crea folderul utilizatori (tot testand daca exista sau nu). Si pentru fiecare utilizator va crea un folder cu numele prenumeUtilizator_numeUtilizator. In cazul in care sunt spatii in nume si prenume, in numele folderului vor fi inlocuite cu underscore, '_' .

      In cadrul fiecarui folder va exista un fisier html (creat prin prolog) continand intr-un paragraf data ultimei accesari, intr-un alt paragraf, numarul total de accesari, si dedesubt pe cate o linie linkurile catre fisierele t_timestamp si d_timestamp (vezi mai jos). Fisierele t_timestamp si d_timestamp corespunzatoare aceleiasi rulari sunt pe aceeasi linie.

    5. In acest folder se vor crea pentru fiecare solutie obtinuta, fisiere de forma t_timestamp.txt, unde timestamp va fi inlocuit de timestampul momentului terminarii interogarii sistemului expert. In aceste fisiere se vor scrie pe rand intrebarile si raspunsurile date de utilizator (iar la final atributul corespunzator, si prima regula care a avut nevoie de el), sub forma:

      [An/NumeLuna/Zi###Ora/Minut/Secunda]
      Intrebare: .....
      R: ....
      Atribut: ....
      Cerut de regula: ...
      ----------------------

      La inceputul intrebarii se afiseaza si data si ora curenta, in formatul precizat mai sus. Atentie NumeLuna va fi chiar numele lunii, nu numarul.

      Fiecare doua seturi intrebare-raspuns vor fi separate cu o linie ----------------------.

      Iar la final, solutiile obtinute, fiecare pe cate un rand, cu factorii de certitudine asociati (de data asta fara descrieri).

    6. Tot in folderele utilizatorilor se vor crea niste fisiere de forma d_timestamp.txt (unde timestamp va fi inlocuit de timestampul momentului terminarii interogarii sistemului) in care se vor scrie demonstratiile pentru toate solutiile. Demonstratiile pentru solutii vor fi afisate tot descrescator dupa fc, ca si solutiile. Intre fiecare doua demonstratii vom avea o linie despartitoare de forma --------------.

      In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:

      Id_Regula@id
      Premise:
           [#] atr <- valoare
           [#] atr
           [#] not[atr]

      atribut_concluzie=valoare//FC= nr
      .
      Pentru atributele obtinute de la utilizator se va afisa:
      Atribut:nume_atribut
      Obtinut de la utilizator prin perechea intrebare/raspuns:
      Intrebare:'continut intrebare'
      Raspuns:raspuns
      Cu fc:fc
      Din variantele posibile:var1, var2, var3,...

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Intrebarile vor fi afisate pe rand in aceeasi fereastra, intr-un ScrollPane (pe masura ce se raspunde la cate o intrebare, se adauga o noua intrebare la inceputul Scroll Pane-ului). Intrebarile vor fi numerotate (si deci vor aparea in panou in ordinea descrescatoare a indicelui lor). Pentru fiecare intrebare se va scrie indicele urmat de textul intrebarii, folosind font Comic Sans. Sub intrebare se vor afisa optiunile. Pentru optiuni, indiferent de tipul de intrebare, veti folosi butoane, avand drept text chiar textul optiunii. Pentru factorul de certitudine va exista un JSpinner (tot in partea dreapta, sub optiuni) cu valori de la 0 pana la maxim 100, si cu pasul 2. Un utilizator, pentru a raspunde la intrebare, Va ajusta JSpinnerul si apoi va face click pe butonul cu optiunea care ii convine. In momentul in care se face click pe un buton (se raspunde), toate optiunile-butoane se transforma in JLabeluri avand acelasi text si pozitie. Optiunea selectata va avea font bold si italic si un chenar galben. Deasupra fostei intrebari curente se afiseaza urmatoarea intrebare, cu indicele crescut cu 1.
    3. La final cand sistemul expert va afisa solutiile, raspunsul va fi de forma: Bolile deduse sunt:
        - gripa fc 85
        - rujeola fc 60
      Fiecare optiune va fi pusa intr-un JLabel. Sub optiuni va exista un JTextArea.
    4. La venirea cu cursorul pe un JLabel-raspuns(solutie posibila), in JTextArea se va afisa demonstratia pentru raspunsul respectiv. Demonstratia ramane si dupa ce se ia cursorul de pe solutie. Se schimba textul din JTextArea doar cand venim cu cursorul pe o alta solutie. Solutia selectata astfel, isi va schimba culoarea litererlor in alta culoare (de exemplu verde) si va reveni la culoarea initiala, cand e selectata o alta solutie.
    5. La click pe JLabel-ul cu solutia va fi afisata o fereastra noua. Aceasta va avea drept background o imagine corespunzatoare temei sistemului expert. In cadrul acesteia, intr-un dreptunghi cu background alb si border bleu punctat (dashed) va fi scrisa o descriere scurta a solutiei. Dreptunghiul va fi in stanga ferestrei, in dreapta ferestrei va fi o imagine corespunzatoare solutiei gasite. Lasati destul spatiu intre elemente astfel incat sa se vada si background-ul.
  2. Sistem expert care alege pentru un utilizator cel mai potrivit campion din Overwatch cu care acesta sa joace, in functie de personalitatea sa (minim 20).

    Cerinte prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        R --> id (unde id este numarul regulii)
        {atribut_concluzie ^ valoare :: fact_cert ^ nr (concluzia; nr este factorul de certitudine)
        premise ^ (conditiile intre acolade, atributele separate cu &&)
            {
             atr :==: valoare (pentru atribute cu valori multiple)
             && atr (pentru atribute booleene, valoare true)
             && \\ atr (pentru atribute booleene, valoare false)
            }
        }.
      • intrebarile vor avea formatul:
        intrebare --> atribut
        text ^ 'continut intrebare'
        opt {
        val1 | val2 | val3
        }.
      • scopul se va defini:
        scop ^ atr.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      erou: nume_erou
      imagine: cale_relativa_imagine
      abilitati: -> abilitate1 -> abilitate2 descriere:[...]

      ----------

      Cuvantul nume_erou va fi inlocuit cu numele eroului, iar dupa descriere: e va afisa textul corespunzator descrierii. Abilitatile sunt cate una pe linie si incep cu ->. Fiecare abilitate va avea un nume de cod, de exemplu fusion_cannons.

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      Dupa afisarea solutiilor se vor afisa optiunile:

      1. detaliat_abilitati
      2. detaliat_descriere
      3. detaliat_complet

      Se asteapta raspunsul utilizatorului sub forma :1,2,3. Daca utilizatorul raspunde '1', se vor afisa solutiile cu tot cu abilitati(sub fiecare solutie in parte). Pentru 2 se va afisa doar descrierea si pentru 3 ambele

    3. Se va crea o matrice cu prima linie continand un blank si apoi sirurile: 'Nr.interog', 'Ord', 'Dedus'. Iar celelalte linii vor fi de forma: primul element = nume atribut folosit in calcularea solutiei (nu e obligatoriu ca toate atributele sa fie folosite), si pentru coloanele urmatoare: numarul de dati in care valoarea atributului a fost necesara in procesul de deductie (adica o regula avea nevoie de el), al catelea atribut evaluat a fost (in cadrul procesului de deductie. De exemplu, a fost primul, punem 1 pe coloana respectiva), iar pe ultima coloana vom avea 1 daca e atribut dedus si 0 daca e obtinut de la utilizator.

    4. Programul va folosi un director numit output_overwatch (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In acest folder, dupa fiecare rulare se va crea un fisier cu numele atr[an_luna_zi_timp].txt unde an, luna si zi reprezinta anul, luna si ziua in care a fost rulat programul, iar timp este timestampul calculat de now. In acest fisier, se va afisa un tabel (matricea calculata mai sus) avand coloanele de o lungime potrivita incat sa incapa toate informatiile si sa se afiseze frumos tabelul. Se va folosi separatorul | intre coloane. Sub acest tabel se vor afisa: numarul total de evaluari de atribute, numarul total de atribute din tabel si numarul total de atribute deduse (dintre cele din tabel).
    5. Dupa afisarea solutiilor in consola, se va afisa intrebarea: 'Doriti sa vedeti imaginile? (da/nu)'. Daca utilizatorul raspunde 'da' veti deschide imaginile corespunzatoare solutiilor in chrome. Indicatie: cautati in documentatia Sicstus library(process). Puteti considera calea default a browserului: 'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe'. Mai intai veti verifica faptul ca exista executabilalul. Daca nu exista veti afisa un mesaj de forma: 'Chrome nu a fost gasit in calea default', altfel veti afisa imaginile. La prezentare se vor testa ambele cazuri punand o data calea default corecta si o data una gresita pentru afisarea mesajului.
    6. Tot in acest folder veti crea cate un fisier numit demonstratie_solutie_pt_erou[fc].txt pentru fiecare solutie in parte. Cuvantul erou din numele fisierului va fi inlocuit cu valoarea solutiei, iar fc cu factorul de certitudine. Fisierul va contine, evident, demonstratia pentru acea solutie. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      R --> id (unde id este numarul regulii)
      {atribut_concluzie ^ valoare :: fact_cert ^ nr (concluzia; nr este factorul de certitudine)
      premise ^ (conditiile intre acolade, atributele separate cu virgula)
          {
           atr :==: valoare (pentru atribute cu valori multiple)
           && atr (pentru atribute booleene, valoare true)
           && \\ atr (pentru atribute booleene, valoare false)
          }
      }.
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Intrebarile se afiseaza in interiorul unui jPane. In dreptul fiecarei intrebari se va pune indicele acesteia. "Numerotarea" intrebarilor se va face cu litere mari (adica A), B), C) etc.). Pentru optiuni se vor folosi radiobutton-uri. Initial e selectat primul radiobutton din grup. Pentru factorul de certitudine veti folosi un JComboBox cu optiuni intre 0 si 100 cu valori care cresc din 10 in 10. Initial e selectat 100. Trecerea la urmatoarea intrebare se va face cu ajutorul unui buton cuprinzand o imagine cu o sageata spre dreapta.
    3. Pe pagina va mai fi si un buton, pentru istoricul intrebarilor care va deschide un JFrame care afiseaza toate intrebarile, impreuna cu raspunsurile date de utlizator pana la acel moment (fereastra nu se actualizeaza automat daca utilizatorul mai raspunde la o intrebare. Trebuie apasat iar butonul de istoric).
    4. Dupa ce s-a raspuns si la ultima intrebare data de sistemul expert, se vor afisa solutiile, impreuna cu factorul de certitudine una sub alta cu ajutorul unor Jlabeluri. Fiecare JLabel va avea ca prim caracter o linioara, "-", ca sa dea senzatia unei liste. In dreptul fiecarui JLabel vor fi si doua butoane cu textul descriere, respectiv demonstratie.
    5. La click pe butonul de descriere se va deschide un JFrame care afiseaza descrierea solutiei respective (textul se va obtine prin apel catre sistemul expert care va folosi predicatul specificat in cerintele de Prolog). La click pe butonul pentru demonstratie, se va afisa demonstratia pentru acea solutie tot cu ajutorul unui JFrame separat.
  3. Sistem expert care sa ajute la alegerea unei placi video potrivite in functie de dorintele utilizatorului. (minim 20 de tipuri de placa video).

    Cerinte individuale prolog:

    1. Parsare:
      • Regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        >id_regula{id}(unde id este numarul regulii)
        +Premise_regula{
        > atr{val}(pentru atribute cu valori multiple)
        > atr{/t}(pentru atribute booleene, valoare true)
        > atr{/f}(pentru atribute booleene, valoare false)
        }
        +Concuzie_regula{
        > atr_concluzie{val}
        > f-cert{nr}}.(atr_concluzie e atributul-concluzie al regulii, val e valoarea sa, iar nr e factorul de certitudine)
      • intrebarile vor avea formatul:
        +Intreb-utiliz{
        > atribut{atribut_intrebare}
        > intrebare{continut_intrebare}
        > +Optiuni{
          > val1
          > val2
          > val3
        ...
          > valn(val1, val2, val3 sunt optiunile pentru intrebare, si evident pot fi oricate optiuni)   }
        }
      • scopul se va defini:
        >Scop{atr_scop}.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. Acestea vor fi scrise cu ajutorul unor inregistrari de felul:

      - placa_video=solutie - / - imagine=cale_relativa_imagine - / - descriere = text_descriere - / - sisteme_de_operare_compatibile = sistem1 ; sistem2 ; sistem3 ; ...
      >>>>>>>>>>>>>>>>>>

      Cuvantul solutie va fi inlocuit cu tipul de placa video. Cuvantul text_descriere va fi inlocuit cu descrierea (pusa intre ghilimele). Se va adauga si calea relativa catre imaginea corespunzatoare solutiei. De asemenea se vor enumera sistemele de operare care sunt compatibile cu acel tip de placa grafica. Doua descrieri vor avea intre ele un separator de forma >>>>>>>>>>>>>>>>>>

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      Solutiile se vor afisa cu tot cu descrieri si toate informatiile aditionale.

      La final, dupa afisarea solutiilor se vor afisa trei optiuni: salveaza_solutii, afis_sumar, gata:

      Daca se alege optiunea salveaza_solutii, in folderul de output al sistemului expert se va crea un fisier numit solutii_sistem_expert.txt (daca exista, va fi suprascris). In acesta vor fi scrise solutiile urmate si de descrieri in felul urmator: (atribut_solutie(valoare_solutie, fc))
      Descriere: text_descriere
      Imagine: cale_imagine
      //////////////////////////////////////////////
      Cuvantul atribut_solutie va fi inlocuit de numele atributului scop. Cuvantul valoare_solutie de valoarea atributului scop. Iar cuvantul text_descriere de descrierea efectiva

      Daca se alege optiunea afis_sumar, se vor afisa din nou solutiile, insa fara descrieri.

      Optiunea gata revine la meniul principal.

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru toate atributele boolene care sunt cuprinse in cunostintele sistemului expert in urma calcularii solutiilor, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele tuturor acestor atribute booleene. Urmatoarele linii vor corespunde, pe rand, fiecarui atribut boolean. Prin urmare, pe fiecare astfel de linie, pe prima coloana avem numele atributului boolean, iar pe urmatoarele coloane d atat atributul boolean corespunzator liniei cat si cel corespunzator coloanei au valoarea "da", n daca ambele au valoarea "nu", d/n daca atributul de pe linie are valoarea "da" si cel de pe coloana are valoarea "nu", n/d daca atributul de pe linie are valoarea "nu" iar cel de pe coloana "da".

      In meniul principal se va adauga o optiune tabel_atrib_bool. La alegerea acestei optiuni, daca deja sistemul expert a calculat o solutie, se va afisa matricea descrisa mai sus, formatata frumos astfel incat dimensiunea unei coloane sa fie egala cu dimensiunea celui mai lung element de pe acea coloana. Daca nu a fost calculata inca o solutie, se va afisa pe ecran mesajul "Sistemul expert nu a fost consultat inca."

    4. De fiecare data cand sistemul expert identifica o solutie (pentru atributul scop) in timpul rularii se va afisa pe ecran un mesaj de forma: A fost identificata solutia atribut_scop=valoare. Se vor inlocui campurile atribut_scop si valoare cu numele atributului scop si valoarea gasita.
    5. Programul va crea un director numit output_placi_video. In cadrul acestui folder va crea un fisier de output care va fi rescris la fiecare rulare. In cadrul acestui fisier vor fi scrise atributele deduse in campuri de forma: nume_atribut
      val_1 -> nr_1
      val_2 -> nr_2
      ...
      val_n -> nr_n
      #####################################
      Unde nume_atribut va fi inlocuit cu numele atributului corespunzator, iar campurile val_i, nr_i cu valoarea atributului dedus si numarul de dati in care a avut aceasta valoare pe parcurusul tuturor rularilor. De exemplu pentru atributul culoare daca de-a lungul tuturor rularilor acest atrbut a avut valoarea albastru de 3 ori, verde de 2 ori, negru de 5 ori, atunci inregistrarea ar arata: nume_atribut
      albastru -> 3
      verde -> 2
      negru -> 5
      #####################################
      Nu conteaza ordinea in care apar atributele, sau valorile lor. Nu se vor mentiona si valorile posibile dar care nu au fost atinse niciodata in vreo rulare, de cand se tine evidenta (de exemplu pentru culoare avem si valoarea posibila alb, dar presupunand ca nu a fost dedusa niciodata aceasta valoare, nu apare in lista).
    6. In folderul de output vor exista fisiere numite dem_an_timestamp.txt (unde an e anul curent iar timestamp e calculat de predicatul now), fiecare fisier cuprinzand toate demonstratiile pentru toate raspunsurile obtinute in urma consultarii.Fiecare doua demonstratii din fiser vor fi separate printr-o linie de forma "#################_nrdemonstratie". Numarul nrdemonstratie arata a cata demonstratie din fisier este. Primul lucru scris in demonstratie va fi raspunsul si factorul de certitudine pentru care se face demonstratia.

      In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare:

      regula/id (unde id este numarul regulii)
      atribut_concluzie/(valoare;fc/nr) (concluzia)
      daca :(conditiile intre acolade, atributele separate cu virgula)
           atr/valoare; (pentru atribute cu valori multiple)
           atr; (pentru atribute booleene, valoare true)
           /not atr/ (pentru atribute booleene, valoare false)
      ).
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Raspunsurile se vor afisa intr-un tabbed pane, fiecare raspuns pe alt tab. Fiecare tab va avea ca Icon corespunzator o imagine reprezentativa pentru solutie (gasiti astfel de imagini pe internet). Titlurile taburilor vor fi raspunsurile (valorile solutiilor).
    3. In interiorul fiecarui tab va fi rescris raspunsul(solutia) cu factorul de certitudine. Valoarea solutiei va fi in acelasi timp si link care imaginea pentru solutia respectiva (se va deschide in browser). In tab va mai fi si un TextArea in care e scrisa demonstratia pentru raspunsul respectiv.
    4. Pentru intrebarile cu raspuns de tip da/nu, se va folosi un JToggleButton. Cand e activat, raspunsul e considerat "da" (si se si schimba textul din buton in "da"), iar cand e dezactivat, raspunsul e considerat "nu" si textul din buton va afisa "nu" . Pentru celelalte intrebari (cu valori cu raspuns multiplu) se vor folosi elemente de tip JComboBox. Pentru factorul de certitudine veti avea tot un JcomboBox cu numere din 5 in 5. Va exista un buton cu textul "OK" care va lua in considerare raspunsul dat si va trece la urmatoarea intrebare.
    5. Intrebarile vor fi afisate toate in aceeasi fereastra. Cand se raspunde la o intrebare, textul din labelul continand intrebarea, se va schimba, la fel si optiunile afisate. Pentru fiecare intrebare la care s-a raspuns, se va adauga in interfata grafica, cate o optiune cu atributul corespunzator intrebarii, intr-un JList. Sub Jlist va fi un buton cu textul "Afiseaza intrebari". La click pe buton se va afisa cate un alert-box( Indicatie: JOptionPane.showMessageDialog(...) ) cu textul fiecarei intrebari selectate si raspunsul dat de utilizator.
  4. Sistem expert care pe baza notelor, activitatilor extracurriculare, profilului, hobby-urilor, etc. sa gaseasca facultatilie si specializarile care s-ar potrivi cel mai bine pentru un elev. (minim 20).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        Id regula:id (unde id este numarul regulii)
        Lista premise: [(lista_premiselor)
             atr==valoare & (pentru atribute cu valori multiple)
             atr & (pentru atribute booleene, valoare true)
             !atr (pentru atribute booleene, valoare false)
        ]
        Concluzie:
            [atr==valoare / fc==nr].(concluzia)
      • intrebarile vor avea formatul:
        Intrebare pentru: atribut
        Text intrebare: 'continut intrebare'
        variante: [
            val1 /
            val2 /
            val3 /
        ...
        ].
      • scopul se va defini:
        Scop sistem expert: atr.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      facultate[nume_facultate]
      abr[abreviere_nume_facultate]
      imagine[cale_relativa_imagine]
      ultimele_medii_bac:
      [an1, medie1]
      [an2, medie2]
      [an3, medie3]
      ... (completati cu restul anilor in acelasi format)
      descriere[...]
      site[...]
      ----------

      Cuvantul nume_facultate va fi inlocuit cu numele facultatii, abreviere_nume_facultate cu numele abreviat (cum e FMI pentru Facultatea de Matematica si Informatica). S va adauga si calea relativa catre imaginea corespunzatoare solutiei. Iar dupa descriere: se va afisa textul corespunzator descrierii. Ultimele medii apar cate una pe linie si reprezinta perechi de forma an, medie. Atentie, dca folositi predicatele deja definite in parserul sistemului expert va trebui sa faceti un caz separat pentru citirea numerelor reale. La final se va citi si site-ul corespunzator fiecare facultati.

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      La final, sub fiiecare solutie se va afisa un text de genul:

      Abreviere: abr
      Descriere:
      continut descriere
      ----------------------- (un separator)

      Sub afisarea solutiilor se va afisa si un meniu cu optiunile descrise mai jos + optiunea 'revenire' care revine la meniul principal.

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru o lista de facultati, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de abrevierile facultatilor. Urmatoarele linii vor corespunde fiecarui an dintre anii precizati in fisier pentru facultatile date. Astfel, pe fiecare astfel de linie, pe prima coloana avem anul, iar pe urmatoarele coloane media corespunzatoare facultatii aflate pe coloana respectiva. In caz ca pentru acel an media nu era precizata in fisier, se afiseaza '-'.

      Trebuie sa aveti minim un set de raspunsuri din care rezulta cel putin 3 solutii (veti specifica acest set de raspunsuri in documentatie). Pentru aceste solutii sa aveti si cazul in care pentru un anume an nu e precizata media (randul corespunzator acelui an lipseste). Pentru a va usura munca de documentare nu e obligatoriu ca mediile sa respecte realitatea (desi pentru un sistem expert real ar fi trebuit sa fie, evident, date corecte).

      In meniul de dupa afisarea solutiei, va aparea o optiune afis_medii, care, daca e aleasa va afisa matricea creata la acest subpunct pentru ca utilizatorul sa poata face o alegere mai informata. Se va realiza o afisare formatata frumoasa a matricii, cu coloanele avand drept dimensiune cel putin numarul maxim de caracatere al cuvintelor de pe acea coloana.

    4. Programul va folosi un director numit output_facultati (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In acest folder, dupa fiecare rulare se va crea (daca nu exista deja) cate un fisier cu numele nume_facultate.txt. In acest fisier, se va afisa la inceput de cate ori facultatea respectiva a fost data ca solutie in total pe toate rularile. Si de la al doilea rand incolo, pentru fiecare data in care facultatea a fost obtinuta ca solutie:
      [An.Luna.Zi Ora:Min:S fc:nr]
      Unde An, Luna si Zi vor fi inlocuite cu anul, luna si ziua in care s-a obtinut solutia respectiva, Ora, Min,S cu ora corespunzatoare, iar nr cu valoarea factorului de certitudine. Observatie: pe caz real un astfel de fisier ar pute fi folosit pentru calcularea unor statistici.
    5. In meniul de dupa afisarea solutiilor in consola, se va afisa si optiunea: deschide_siteuri, care va deschide in chrome pagina corespunzatoare fiecarei solutii. Indicatie: cautati in documentatia Sicstus library(process). Puteti considera calea default a browserului: 'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe'. Mai intai veti verifica faptul ca exista executabilalul. Daca nu exista veti afisa un mesaj de forma: 'Chrome nu a fost gasit in calea default', altfel veti deschide site-urile. La prezentare se vor testa ambele cazuri punand o data calea default corecta si o data una gresita pentru afisarea mesajului.
    6. In interiorul folderului output_facultati, programul va crea un director numit demonstratii_raspunsuri (daca exista, il va folosi pe acela, iar daca nu exista, il va crea), in care va exista un fisier numit dem_raspuns_timestamp.txt. Sufixul timestamp va fi numarul calculat de predicatul now. Cuvantul raspuns va fi inlocuit cu numele efectiv al solutiei pentru care este scrisa demonstratia. Prima linie a fisierelor de acest gen va fi de forma "Demonstratie pentruraspuns cu fc:nr", unde raspuns e raspunsul pentru care este afisata demonstratia, iar nr e factorul de certitudine. A doua linie va fi formata din 20 de caractere "-".In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      Id regula:id (unde id este numarul regulii)
      Lista premise: [(lista_premiselor)
           atr==valoare & (pentru atribute cu valori multiple)
           atr & (pentru atribute booleene, valoare true)
           !atr (pentru atribute booleene, valoare false)
      ]
      Concluzie:
          [atr==valoare / fc==nr].(concluzia)
      In cazul in care atributul explicat in demonstratie are valoarea obtinuta de la utilizator, se va afisa:
      Atributul atr are valoarea val data de utilizator cu fc nr.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Se va folosi un Tabbed Pane cu doua taburi: un tab cu istoricul intrebarilor si un tab cu intrebarea curenta. In momentul in care s-a raspuns la o intrebare, aceasta este mutata in primul tab, si sub enuntul intrebarii apare si raspunsul utilizatorului. Intrebarile din istoric vor fi puse cu ajutor unor jLabel-uri intr-un jScrollPane.
    3. Pentru intrebarea curenta se vor genera optiunile astfel: pentru intrebarile cu raspuns de tip da/nu (atribute booleene) se vor afisa doua jToogleButton. Cand unul este activat, automat se dezactiveaza celalalt. Pentru intrebarile cu mai multe optiuni se vor folosi radiobuttons. Pentru factorul de certitudine se va folosi un jSlider cu valori intre 0 si 100. Trecerea la urmatoarea intrebare se va face facand click pe un buton cu textul "spre urmatoarea intrebare".
    4. La final pe tabul cu intrebarile se vor afisa raspunsurile date de sistemul expert cu factorii de certitudine. In dreptul fiecarui solutii va fi si o imagine pentru solutia respectiva. Pentru solutii se vor folosi radiobuttons. Sub solutii va exista un JTextArea La selectarea unei solutii se va afisa in JtextArea demonstratia
    5. Butonul afiseaza_fapte existent la final va deschide la click pe el un nou JFrame continand un JTable cu cunostintele sistemului expert (coloanele vor avea numele atribut si valoare). Acest Jframe se va inchide automat la inchiderea Jframe-ului initial.
  5. Sistem expert care dintr-o serie de autoturisme alege cel mai potrivit autoturism de inchiriat pe baza cerintelor utilizatorului (minim 20).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        rg #id# (unde id este numarul regulii)
        atribut_concluzie ==== valoare, fc===nr, (concluzia; atentie, sunt 3 de egal acolo; dupa valoare avem o virgula)
        daca :(lista premiselor)
             #atr===valoare (pentru atribute cu valori multiple)
             atr (pentru atribute booleene, valoare true)
             #no# atr (pentru atribute booleene, valoare false)
        ).
      • intrebarile vor avea formatul:
        intrebare #atribut#
        enunt #'continut intrebare'#
        cu variantele :
             #val1
             #val2
             #val3
        ...
        .
      • scopul se va defini:
        scop#atr#
  6. Tema proiectului este legata despre limbajele de programare. Sistemul nostru va "intoarce" ce limbaj sa invatam prima data in functie de preferintele noastre : ce platforma (Mobile: android /ios , Web: front-end , back-end, ) , pentru cine vrem sa lucram (Startup sau corporatii ) ,pentru ce vrem sa invatam limbajul (bani , amuzament , tehnologie) , ce lucruri preferam sa invatam (intersante , usoare , grele ) si multe altele iar pentru acestea sa sugereze ce tip de limbaj de programare sa fie invatat (minim 20 de limbaje).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        %regula
        numar=id(unde id este numarul regulii)
        %conditii (lista_premiselor)
             % atr - valoare (pentru atribute cu valori multiple)
             % true(atr) (pentru atribute booleene, valoare true)
             % false(atr) (pentru atribute booleene, valoare false)
        %concluzie
            (atr - valoare , fc - nr).(concluzia)
      • intrebarile vor avea formatul:
        %atribut_inrebare
        atribut
        %enunt
        'continut intrebare'
        %variante
            val1 /
            val2 /
            val3 /
        ...
            valn
        .
      • scopul se va defini:
        %scop
        atr
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      #nume_solutie
      #descriere
      #imagine
      #tutoriale:
      *site1*
      *site2*
      *site3*
      ----------

      Cuvantul nume_solutie va fi inlocuit cu numele solutiei, iar cuvantul descriere cu textul corespunzator descrierii. Cuvantul imagine va contine calea relativa catre imaginea reprezentativa pentru limbaj. Iar sub #tutoriale scrise intre doua simboluri "*", cate unul pe linie, site-uri cu tutoriale pentru acele limbaje.

      Dupa ce programul afiseaza solutiile, va afisa si un submeniu cu optiunile: afis_descriere, afis_tutoriale, inapoi.

      Apelul optiunii afis_descriere se face prin:

      afis_descriere nume_solutie

      si va afisa descrierea pentru acea solutie.

      Apelul optiunii afis_tutoriale se face prin:

      afis_tutoriale nume_solutie

      si va afisa tutorialele pentru acea solutie.

      Optiunea inapoi ne intoarce la meniu initial.

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de solutiile posibile. Urmatoarele linii vor corespunde de asemenea fiecarei solutii (fiecarui limbaj). Astfel, pe fiecare astfel de linie, pe prima coloana avem limbajul, iar pe urmatoarele coloane un numar Nr=Frecv/Total. Frecv indica de cate ori solutiile respective au fost date impreuna in lista de solutii (pentru acelasi set de raspunsuri). Total indica de cate ori a fost rulat sistemul expert.

      Realizarea acestie matrici va necesita un fisier in care sa fie memorate datele din rularile vechi. Acest fisier va purta numele temp_matrice si se va afla in folderul de output al sistemului expert.

    4. Programul, la fiecare rulare va crea un folder numit output_limbaje (daca exista deja, il va sterge si-l va crea din nou). In el va exista un fisier numit statistica.txt, in care in dreptul fiecarei solutii posibile se va afisa de cate ori a fost dat ca raspuns in urma consultarilor anterioare. Se vor aduna toate raspunsurile, nu doar cele cu factor de certitudine maxim.
    5. Cand se afiseaza intrebarile se va afisa in dreptul lor si un numar. De exemplu prima intrebare se va afisa cu un "1)" in fata, a doua cu un "2)" etc.
    6. In folderul de output veti crea cate un fisier numit demonstratie_limbaj(nume_limbaj[fc]).txt pentru fiecare solutie in parte. Cuvantul nume_limbaj din numele fisierului va fi inlocuit cu valoarea solutiei, iar fc cu factorul de certitudine. Fisierul va contine, evident, demonstratia pentru acea solutie. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      %regula
      numar=id(unde id este numarul regulii)
      %conditii (lista_premiselor)
           % atr - valoare (pentru atribute cu valori multiple)
           % true(atr) (pentru atribute booleene, valoare true)
           % false(atr) (pentru atribute booleene, valoare false)
      %concluzie
          (atr - valoare , fc - nr).(concluzia)
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Se va folosi un Split Pane cu doua taburi: in partea stanga va fi istoricul intrebarilor si in partea dreapta intrebarea curenta. In momentul in care s-a raspuns la o intrebare, in partea stanga a SplitPane-ului apare un jToogleButton cu atributul intrebarii. Sub butoanele cu intrebari va fi un JtextArea. La click pe unul dintre butoane, in JTextArea se va afisa enuntul intrebarii, si raspunsul dat de utilizator.
    3. In dreapta SplitPane-ului, pentru intrebarea curenta se vor genera optiunile folosind un JList. JList-ul va accepta doar selectie unica. JListul va fi mereu indeajuns de mare incat sa afiseze toate optiunile (nu va avea scroll). Pentru factorul de certitudine se va folosi un JSlider de la 0 la 100 .
    4. La final, in partea dreapta a Split Pane-ului, dupa ce s-a raspuns si la ultima intrebare, se vor afisa raspunsurile sistemului expert, ordonate dupa factorul de certitudine (se va afisa si factorul de certitudine). Raspunsurile vor fi afisate intr-un JComboBox.
    5. La selectarea unei optiuni din JComboBox, sub acesta se va afisa imaginea reprezentativa a solutiei, si de asemenea se va deschide o fereastra noua (JFrame) avand demonstratia scrisa cu ajutorul unui JTextArea.
  7. Recomandarea unei conferințe la care să participe un utilizator, în funcție de domeniile acestuia de interes, locația acestuia și alte criterii după caz.(minim 20).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        rg->id
        (unde id este numarul regulii) if( (conditiile intre paranteze rotunde, intre doua premise avem &&)
             atr->(valoare) && (pentru atribute cu valori multiple)
             atr->(1) && (pentru atribute booleene, valoare true)
             atr->(0) (pentru atribute booleene, valoare false)
        )
        then
            (atr->valoare:fc->nr).(concluzia)
      • intrebarile vor avea formatul:
        q -> atribut
        variante(
            val1 (&)
            val2 (&)
            val3 (&)
        ...
        )
        text -> ('continut intrebare').
      • scopul se va defini:
        scop ->(atr).
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      {id_solutie}
      {nume_solutie}
      {descriere}
      {domeniu: nume_domeniu}
      {imagine: cale_relativa_imagine}
      {data: zi/luna/an}
      ----------

      Cuvantul nume_solutie va fi inlocuit cu numele solutiei, iar cuvantul descriere cu textul corespunzator descrierii. Cuvintele zi,luna,an vor fi inlocuite cu ziua, luna si anul urmatoarei conferinte de acel tip (atentie, trebuie sa fie date din viitor, evident). Toate conferintele vor avea o astfel de data. Cuvantul nume_domeniu va fi inlocuit de un nume generic de domeniu (principal pentru acea conferinta)

      Aceste informatii vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

    3. Dupa ce a terminat consultarea, dar inainte de afisarea solutiilor utilizatorului i se va afisa intrebarea: "Doriti o afisare detaliata?(da/nu)". Si se va astepta inputul utilizatorului. In cazul in care da un raspuns diferit de da/nu, se va afia mesajul: "Raspundeti prin da sau nu!". Daca utilizatorul raspunde nu, se afiseaza doar solutiile cu factorul de certitudine. Daca raspunde da, se afiseaza sub fiecare solutie si descrierea si, in plus, sub fiecare solutie, in cazul in care conferinta urmatoare e in anul curent va apare si textul "Mai poti participa la aceasta conferinta. Data: zi/luna/an", unde zi, luna, an sunt cele preluate din fisierul cu descrierile.
    4. se va adauga o optiune noua in meniu, numita Calendar. La alegerea acesteia se va afisa o matrice pentru care pe prima linie, prima casuta reprezinta un blank, iar restul sunt numerele de la 1 la 12, iar pe liniile urmatoare avem cate un nume de domeniu pe prima coloana si in restul coloanelor cate conferinte de acel tip sunt in fiecare luna (corespunzatoare coloanei).

      Trebuie sa aveti minim un domeniu cu doua conferinte in aceeasi luna (pentru a se putea testa corectitudinea rezolvarii).

    5. Programul va folosi un director numit fisiere_conferinte(daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In acest director va exista un fisier numit log_solutii.txt. Daca fisierul nu exista, programul prolog il va crea la inceputul rularii, altfel va adauga date la sfarsitul lui. Pentru fiecare rulare se va adauga data rularii si solutiile obtinute impreuna cu factorul de certitudine, astfel:
      #inceput_log
      (An_Luna_Zi, Ora_Minut_Secunda) Solutii sistem expert:
      ....
      #sfarsit_log
      Anul, luna, ziua, ora, minutul si secunda sunt toate exprimate numeric. In cazul in care una din informatiile numerice (cu exceptia anului) are o singura cifra, se va afisa precedata de un 0. De exemplu: (2017_08_11, 10_08_00).
    6. In directorul fisiere_conferinte, vor mai fi create si niste fisiere numite demonstratii_[nume_conferinta(fc(nr_fc))].txt. In numele fisierului, [nume_conferinta] si [nr_fc] vor fi inlocuite de numele solutiei identificate, si factorul de certitudine pentru acel raspuns. Fisierul respectiv va contine demonstratia doar pentru acel raspuns. La fiecare noua rulare fisierele vechi vor fi sterse si in locul lor scrise fisierele pentru solutiile actuale

      In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare:

      rg->id
      (unde id este numarul regulii) if( (conditiile intre paranteze rotunde, intre doua premise avem &&)
           atr->(valoare) && (pentru atribute cu valori multiple)
           atr->(1) && (pentru atribute booleene, valoare true)
           atr->(0) (pentru atribute booleene, valoare false)
      )
      then
          (atr->valoare:fc->nr).(concluzia)

      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. La inceputul programului, in cazul in care e prima rulare (fisierul data_ultima_accesare.txt lipseste), se va afisa un mesaj de bun venit. In cazul in care ne aflam de la a doua rulare incolo se va afisa de cate zile, ore si minute nu a mai intrat utilizatorul.
    3. Pentru toate intrebarile, optiunile vor fi generate cu ajutorul unor butoane, care vor avea si cate o imagine mica pe ele (icon) de maxim 25x25px, din specificul informaticii sau al ideii de conferinta/facultate (de exemplu, calculatoare, carti, diplome etc). Fiecare imagine va corespunde unui anumit numar de optiune, deci mereu pentru optiunea 1 a unei intrebari, se va afisa imaginea 1, pentru optiunea 2 imaginea 2 etc (pentru a arata frumos, se poate lua un icon si transformat in photoshop gimp sa fie de diverse culori rezultand astfel imaginile de folosit, ca sa nu fie totusi prea multe tipuri de iconuri, ca iese cam kitsch). Butoanele vor avea afisajul de forma: imagine-1 raspuns1, imagine-2 raspuns 2, etc. Pentru factorul de certitudine, veti folosi un JComboBox cu valori intre 0 si 100, crescand din 5 in 5. Trecerea la urmatoarea intrebare se face la click pe unul dintre butoanele-optiune.
    4. Pe pagina va mai exista un grup de radiobuttons, care va creste cu cate o optiune pentru fiecare noua intrebare la care s-a raspuns. Optiunile grupului vor consta din atributele corespunzatoare intrebarilor afisate anterior. La click pe una dintre optiuni, cu ajutorul unui JTextArea generat dinamic veti arata textul intrebarii si raspunsul utilizatorului.
    5. La final, se vor afisa raspunsurile cu factorii de certitudine, ca optiuni intr-un JList. Sub JList, se va gasi si un JTextPane. La selectarea unui anumit raspuns din lista, se va afisa in JTextPane demonstratia pentru acea solutie. Initial e selectata solutia cu fc-ul maxim, iar in JtextPane se gaseste demonstratia pentru aceasta. Pentru fiecare solutie selectata, se va afisa si imaginea corespunzatoare ei.
  8. Sistem expert care alege cel mai potrivit post (exemple: tester, programator C++, dezvoltator aplicatii web, project manager etc.) pentru un utilizator, in functie de raspunsurile acestuia. (minim 20).

    Cerinte individuale program prolog

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        reg^id (unde id este numarul regulii)
        atribut_concluzie^(valoare && factor_de_certitudine^nr) (concluzia; nr este factorul de certitudine)
        lista de premise { (conditiile intre acolade, premisele separate cu &&)
             atr^valoare && (pentru atribute cu valori multiple)
             atr &&(pentru atribute booleene, valoare true)
             ^atr (pentru atribute booleene, valoare false)
        }.
      • intrebarile vor avea formatul:
        [atribut]
        text-intrebare ^ 'continut intrebare'
        optiuni ^ {val1 // val2 // val3 // ...} .
      • scopul se va defini:
        scop^atr.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      nume_solutie /// descriere.
      limbaje:l1,l2,....
      ----------

      Cuvantul nume_solutie va fi inlocuit cu numele solutiei, iar cuvantul descriere cu textul corespunzator descrierii, iar separate prin virgule vor fi limbajele pe care ar fi recomandat ca un potential candidat sa le cunoasca.

      Dupa ce programul afiseaza solutiile, va afisa si un submeniu cu optiunile:afis_detalii, meniu_anterior, iesire.

      Pentru optiunea afis_detalii se reafiseaza detaliat solutiile (adica si cu descrierea sub fiecare dintre ele). Fiecare doua solutii vor fi separate printr-o linie de #-uri.

      Optiunea meniu_anterior ne intoarce la meniu initial

      Optiunea iesire termina programul

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru o lista de posturi, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele posturilor. Urmatoarele linii vor corespunde fiecarui limbaj dintre cele precizate in fisier pentru posturile date. Astfel, pe fiecare astfel de linie, pe prima coloana avem limbajul, iar pe urmatoarele coloane un x daca acel limbaj este necesar postului, si un - daca nu.

      Trebuie sa aveti minim un set de raspunsuri din care rezulta cel putin 3 solutii (veti specifica acest set de raspunsuri in documentatie). Pentru aceste solutii sa aveti si cazuri de limbaje comune dar si cazuri de limbaje care sunt necesare unui post dar altuia nu.

      In meniul de dupa afisarea solutiei, va aparea o optiune afis_tabel, care, daca e aleasa va afisa matricea creata la acest subpunct pentru ca utilizatorul sa poata face o alegere mai informata (avand in vedere ca limbajele cerute nu sunt obligatorii mereu pentru un post; deci poate junge pe un post si daca nu stie chiar tot, dar cu un factor de certitudine mai mic). Se va realiza o afisare formatata frumoasa a matricii, cu coloanele avand drept dimensiune cel putin numarul maxim de caracatere al cuvintelor de pe acea coloana.

    4. Minim o intrebare va da posibilitatea de a raspunde cu mai multe variante (de exemplu intrebarea despre ce limbaje cunoaste utilizatorul). Aceasta intrebare va avea un format special si va fi memorata in baza de cunostinte cu un alt tip de predicat dinamic decat restul intrebarilor (pentru a putea fi facuta diferentierea).
      rasp_multiplu[atribut]
      text-intrebare ^ 'continut intrebare'
      optiuni ^ {val1 // val2 // val3 // ...} .
      De asemenea in premisele regulilor, pentru atributele din tipul celor de mai sus se va permite specificarea unui subset de limbaje astfel: in loc de atr^valoare penru un atribut cu o singura valoare se va scrie:
      atr^(valoare1 & valoare2 & valoare3)
      si va fi echivalent cu faptul ca pentru atributul respectiv toate acele valori sunt valide.
    5. Se va crea un folder numit output_joburi. Se va adauga o optiune noua in meniul principal, numita consulta_detaliat. In cazul in care utilizatorul selecteaza aceasta optiune, programul va folosi un director numit log_joburi (daca exista, il va folosi pe acela, iar daca nu exista, il va crea) aflat in interiorul folderului output_joburi. In acest folder va exista un fisier log.txt in care se va afisa pentru ultima consultare (deci fisierul este suprascris la fiecare consultare) un fel de log al luarii deciziilor de catre sistemul expert, in felul urmator:
      • Cand va testa o regula, va scrie in fisier: "Acum testez regula N." si va afisa regula (afisarea regulii se va face in acelasi format ca si in fisierul de demonstratii). Numarul N reprezinta id-ul regulii.
      • Cand cauta valoarea pentru un atribut (vezi predicatul realizeaza_scop), va afisa "Acum caut valoarea pentru atributul Atr". Se va inlocui Atr in propozitie cu numele atributului.
      • Cand obtine valoarea pentru un atribut, fie din regula fie din raspunsul utilizatorului, va scrie "Am obtinut valoarea pentru atributul Atr cu ajutorul utilizatorului/regulii N". Va fi scris "utilizatorului" daca s-a obtinut valoarea din intrebare, respectiv "regulii N" daca s-a obtinut valoarea din regula cu id-ul N.
    6. In folderul output_joburi se va crea un folder demonstratii (prin program). In acest folder, in urma unei consultari a sistemului expert, se va crea cate un fisier numit demonstratii_sv@solutie#fc.txt pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei, iar fc cu factorul de certitudine. Fisierul va contine, evident, demonstratia pentru acea solutie. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      reg^id (unde id este numarul regulii)
      atribut_concluzie^(valoare && factor_de_certitudine^nr) (concluzia; nr este factorul de certitudine)
      lista de premise { (conditiile intre acolade, atributele separate cu virgula)
           atr^valoare && (pentru atribute cu valori multiple)
           atr &&(pentru atribute booleene, valoare true)
           ^atr (pentru atribute booleene, valoare false)
      }.
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Intrebarile vor fi afisate pe rand in aceeasi fereastra. Pentru optiuni, indiferent de tipul de intrebare, veti folosi JLabels. Fiecare optiune va avea o litera de ordine: a),b) etc. La apasarea tastei "a" se selecteaza optiunea "a". La apasarea tastei "b", optiunea b) etc. Un JLabel selectat va avea border albastru inchis si background albastru deschis. Pentru factorul de certitudine al raspunsurilor, veti avea un JSpinner care creste normal, din 1 in 1 cu valoare minima -100 si maxim 100 (initial va fi setat la 0). Va exista si un buton cu textul "am ales varianta" care, la click pe el, va lua in considerare raspunsul dat si va trece la urmatoarea intrebare.
    3. In cazul in care utilizatorul nu a ales o optiune, la click pe butonul de trecere la urmatoarea intrebare, se va afisa un mesaj-alerta de atentionare (JOptionPane.showMessageDialog) in care utilizatorului i se va spune ca nu a ales nicio optiune si nu poate trece la urmatoarea intrebare (si, evident, nu se va afisa urmatoarea intrebare pana nu selecteaza o optiune). Daca utilizatorul pune un factor de certitudine mai mic de 20, atunci se va afisa un mesaj de confirmare (JOptionPane.showConfirmDialog) in care utilizatorul va fi atentionat "Ati pus un factor de certitudine mai mic de 20. Continuati?". Daca da click pe ok (si, evident, are si o optiune selectata), atunci trece la urmatoarea intrebare. Daca da click pe cancel, ramane la intrebarea curenta.
    4. Sub intrebare si optiuni va exista si un JPane in care, pe masura ce se raspunde la cate o intrebare, se adauga un radiobutton cu atributul intrebarii. Tot in acel Jpane va fi si un JTextArea. La selectarea unui radiobutton-atribut, o sa apara in JTextArea, textul intrebarii si raspunsul dat de utilizator.
    5. La final, se vor afisa, una sub alta, intr-un ScrollPane, folosind cate un JLabel pentru fiecare, solutiile cu factorii de certitudine. In dreapta fiecarei solutii va fi si imaginea corespunzatoare. Iar sub fiecare raspuns va fi un JTextArea cu demonstratia. Fiecare doua solutii vor fi separate cu ajutorul cate unui JSeparator.
  9. Un sistem expert care ajuta utilizatorul sa aleaga o camera de supraveghere in functie de necesitatile acestuia. (minim 15 camere).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        regula/id (unde id este numarul regulii)
        atribut_concluzie/(valoare;fc/nr) (concluzia)
        daca :((conditiile intre paranteze, premisele separate cu ';')
             atr/valoare; (pentru atribute cu valori multiple)
             atr; (pentru atribute booleene, valoare true)
             /not atr/ (pentru atribute booleene, valoare false)
        ).
      • intrebarile vor avea formatul:
        intreb/atribut/
        enunt/'continut intrebare'/
        avand variantele /val1/ /val2/ /val3/.... .(fiecare varianta intre doua carctere '/')
      • scopul se va defini:
        scop/atr
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      @nume_solutie
      @descriere: [...]
      @imagine
      @pret
      ----------

      Cuvantul nume_solutie va fi inlocuit cu identificatorul solutiei. Apoi se va adauga descrierea, inlocuind "[...]" cu textul efectiv al descrierii (descrierea va fi toata pe un rand - in sensul ca nu va exista vreun '\n' in interiorul ei. De asemenea, va fi pusa intre apostrofuri.). Atentie, descrierea trebuie sa cuprinda 1-2 fraze.

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      Cand se afiseaza solutiile, sub ele se afiseaza automat si descrierea si pretul. Exemplu de afisare:

      Camera video: nume_solutie, factor certitudine: fc
      Pret: ...
      Descriere: Un nene musculos. Are o expresie deosebita.
      ============================ (un separator intre 2 solutii)
      Se inlocuiesc nume_solutie si fc cu identificatorul solutiei si factorul de certitudine corespunzator.

      Optiunea '<<<' revine la meniul principal.

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Matricea va avea doua coloane. Pe prima linie avem headerele de coloane denumite: "Atribut", "Tip". Pentru toate atributele folosite in premisele regulilor, se vor genera linii in matrice, de forma: nume_atribut, impreuna cu tipul sau. Tipul poate sa fie "boolean" sau "val multiple".

      In meniul principal se va adauga si optiunea afiseaza_atribute care va scrie matricea generara cu acest predicat.

      Afisarea matricii trebuie sa fie una frumoasa in care coloanele au lungimi egale. Se vor desprti elementele de pe cele doua coloane prin simbolul slash "/".

    4. Programul va permite comentarii in fiserul de reguli. Comentariile vor fi doar cate unul pe linie (fara alte tipuri de informatie pe acea linie) si vor incepe cu "Comentariu: " si se vor termina cu punct. Comentariile nu pot fi incluse in interiorul unei intrebar, reguli sau a scopului. Cand se parseaza fisierul programul trebuie sa sara peste aceste linii.
    5. Programul Prolog va crea (in cazul in care nu exista) un director numit output_camere. In el se va crea cate un fisier pentru fiecare solutie posibila (tot asa, prin program, fisierele sunt create numai daca nu exista). FIserele initial sunt goale. La obtinerea unei solutii, in fisierul corespunzator solutiei se vor adauga (deci fiserul deschis cu append) atributele cunoscute pentru acea solutie (fie deduse din reguli, fie obtinute din intrebari). Dupa fiecare astfel de afisare se va scrie o linie despartitoare de forma "--------------------------------". Astfel de fiecare data cand se obtine o solutie, se actulizeaza fisierul corespunzator cu noul set de atribute cunoscute.
    6. Tot in folderul output_camere se vor crea fisiere in care se vor scrie demonstratiile pentru fiecare solutie in parte. Numele fisierelor vor fi de forma demonstratie_(zi#luna#an_ora#minut#secunda).txt, unde zi, luna,an, ora, minut, secunda formeaza data calendaristica si ora in care a fos obtinuta solutia. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      regula/id (unde id este numarul regulii)
      atribut_concluzie/(valoare;fc/nr) (concluzia)
      daca :((conditiile intre paranteze, premisele separate cu ';')
           atr/valoare; (pentru atribute cu valori multiple)
           atr; (pentru atribute booleene, valoare true)
           /not atr/ (pentru atribute booleene, valoare false)
      ).
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Intrebarile vor fi afisate pe rand in aceeasi fereastra. Sub intrebare se vor afisa optiunile, numerotate cu 1,2,3 etc. Sub intrebare vor fi butoane cu numerele 1,2,3.. Daca se face click pe butonul cu indicele i, se alege de fapt optiunea cu indicele i. Pentru factorul de certitudine al raspunsurilor, veti avea un JSpinner care creste din 5 in 5 cu valoare minima -100 si maxim 100 (initial va fi setat la 100). Cand se face click pe butonul cu indicele optiunii se trece la urmatoarea intrebare, preluand si factorul de certitudine setat in prealabil.
    3. La apasarea tastei 'i' se va deschide o noua fereastra in care sunt afisate interbarile la care s-a raspuns pana acum. In cadrul ferestrei initial e afisata prima intrebare si sub ea doua butoane cu textele inainte si inapoi. Afisarea unei intrebari se face astfel. Textul intrebarii e scris cu negru, sub ele optiunile posibile sunct scrise tot cu negru, cu exceptia raspunsul dat de utilizator, care e scris cu verde.
    4. La click pe butonul inainte se afiseaza urmatoarea intrebare. La click pe butonul inapoi se afiseaza intrebarea anterioara. Cand e afisata prima intrebare, butonul inapoi este disabled. Cand e afisata ultima intrebare, butonul inainte este disabled.
    5. La final, se vor afisa, una sub alta, intr-un ScrollPane, folosind cate un JLabel pentru fiecare, solutiile cu factorii de certitudine. In dreapta fiecarei solutii va fi si imaginea corespunzatoare. La dublu-click pe textul solutiei, dar si pe imagine se va deschide o fereastra noua cu demonstratia pentru acea solutie.
  10. Sistem expert care identifica specia genului liric din care face parte o poezie (minim 20 solutii).

    Cerinte individuale program prolog

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        ~R:id~(unde id este numarul regulii)
        este adevarat ca avem : atribut_concluzie==valoare avand factor_certitudine: nr cu urmatoarele conditii indeplinite:
        atribut e egal cu valoare(pentru atribute cu valori multiple)
        atribut este adevarat (pentru atribute booleene, valoare true)
        atribut este fals . (pentru atribute booleene, valoare false)
      • intrebarile vor avea formatul:
        intrebarea pentru atribut_intrebare este
        'continut intrebare'
        cu variantele de raspuns:
        ~~val1
        ~~val2
        ~~val3 .(val1, val2, val3 sunt optiunile pentru intrebare, si evident pot fi oricate optiuni)
      • scopul se va defini:
        [!Scop sistem expert: atribut_scop!] .
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      @specie_gen_liric= nume
      @descriere= ...
      @imagine:cale_relativa_imagine
      @poezii:
      ## site1
      ## site2
      ## site3
      ... (etc)

      ----------

      Cuvantul nume va fi inlocuit cu numele speciei de gen liric. Se va adauga si calea relativa catre imaginea corespunzatoare solutiei. Iar dupa @descriere= se va afisa textul corespunzator descrierii. Sub textul @poezii apar cate una pe linie adrese http catre poezii apartinand acelei specii lirice.

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      La final, dupa afisarea solutiilor se vor afisa trei optiuni: descriere, afis_exemple, inapoi

      Daca se alege descrierea, se va afisa o intrebare de forma "Pentru care specie a genului liric vrei sa fisezi descrierea? (sol1/sol2/sol3/...)", unde sol1, sol2, sol3 sunt solutiile date de sistemul expert pentru acea consultare. Dupa ce utilizatorul raspunde o solutie, se afiseaza descrierea pentru acea solutie.

      Daca se alege optiunea afis_exemple urmata de una din solutii, de exemplu:

      afis_exemple elegie

      unde elegie este una dintre solutii, atunci se vor deschide toate exemplele intr-un browser la alegere (indicat e chrome fiindca acela e instalat in laborator). Indicatie: cautati in documentatia Sicstus library(process). Puteti considera calea default a browserului: 'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe'. Mai intai veti verifica faptul ca exista executabilalul. Daca nu exista veti afisa un mesaj de forma: 'Chrome nu a fost gasit in calea default', altfel veti afisa site-urile. La prezentare se vor testa ambele cazuri punand o data calea default corecta si o data una gresita pentru afisarea mesajului.

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru tote solutiile existente, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele solutiilor. Urmatoarele linii vor corespunde de asemenea, pe rand, fiecarei solutii. Astfel, pe fiecare astfel de linie, pe prima coloana avem solutia, iar pe urmatoarele coloane o lista de perechi av(atribut-valoare) comune (deci existente atat in regulile pentru solutia de pe linie cat si pentru solutia de pe coloana). Atributele respective vor fi doar fii directi in arbore (deci atribute care apar in regulile care au drept concluzie chiar atributul scop).

      In meniul principal se va adauga si optiunea afis_similaritati. La alegerea acestei optiuni se va afisa un nou meniu cu optiunile: scrie_tabel, detalii_>sol1<_>sol2< si home. La alegerea optiunii afis_similaritati se va deschide un fisier in notepad, continand matricea generata cum s-a precizat mai sus, dar avand drept elemente in locul listelor de av-uri comune, numarul lor. Se va realiza o afisare formatata frumoasa a matricii, cu coloanele avand drept dimensiune cel putin numarul maxim de caracatere al cuvintelor de pe acea coloana.

      La alegerea optiunii detalii_>sol1<_>sol2< se vor parsa cei doi parametri dintre parantezele unghiulare: sol1 si sol2, afisand atributele comune doar pentru acele doua solutii.

      Optiunea home va duce utilizatorul la meniul initial.

      Observatie: sistemul expert e pentru elevi. Aceasta matrice poate ajuta elevii sa invete mai bine asemanarile si diferentele dintre diversele specii lirice, dar si sa vada care sunt speciile lirice cele mai apropiate (cu numarul cel mai mare in tabelul afisat in fisier).

    4. Vor fi anumite atribute speciale ale caror valori pot fi obtinute atat din reguli cat si din intrebari (insa nu va exista nicio valoare care sa fie si tratata de intrebare, dar si de o regula). In momentul in care pentru un astfeel de atribut special e nevoie sa testam daca are o anumita valoare, verificam intai ca valoarea poate fi obtinuta din intrebare, si, daca da, atunci punem intrebarea respectiva utilizatorului; iar daca nu, incercam sa vedem daca putem obtine acea valoare dintr-o regula (daca premisele regulii respective se potrivesc cu situatia data).
    5. Programul Prolog va crea un director numit output_specii_lirice (de fapt, daca exista deja, il va folosi pe acela, iar daca nu exista, il va crea - e obligatoriu de implementat acest test daca doriti sa primiti punctaj complet pe cerinta). In acest folder se va crea un fisier numit log_sistem_expert.txt. In cadrul acestui fisier, pentru orice comanda data (fie din meniul principal, fie din cel secundar), se va afisa un rand de forma:
      (numar_rulare) [An|Luna|Zi; Ora|Minut|Secunda]. comanda
      Cuvantul numar_rulare va fi inlocuit cu numarul rularii sistemului expert in care s-a dat comanda respectiva. Numararea rularilor incepe de la 1. Pentru informatiile legate de data nu e nevoie sa completati cu 0 in cazul in care avem o singura cifra; le afisati direct. Cuvantul comanda va fi inlocuit cu numele optiunii alese din meniu.
    6. La finalul unei sesiuni de folosire, se va crea in cadrul directorului output_specii_lirice cate un fisier numit demonstratie_timestamp_(solutie(fc)).txt pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei, timestamp cu valoarea calculata de predicatul now (vezi lab. biblioteci), iar fc cu factorul de certitudine. In fiecare fisier va fi scrisa demonstratia pentru solutia respectiva. Fisierele cu demonstratiile de la o rulare anterioara vor fi sterse prin intermediul programului Prolog. Prin urmare, in folderul de output vor fi mereu doar demonstratiile pentru ultima utilizare a sistemului expert. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      ~R:id~
      este adevarat ca avem : atribut_concluzie==valoare avand factor_certitudine: nr cu urmatoarele conditii indeplinite:
      atribut e egal cu valoare
      atribut este adevarat
      atribut este fals .
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Intrebarile vor fi afisate pe rand in aceeasi fereastra. Intrebarile se vor afisa intr-un SplitPane sau nu. Daca raspunsul a fost "da, se va folosi un SplitPane, cu separator vertical. In partea stanga va fi intrebarea, iar in partea dreapta optiunile si modul de selectare a factorului de certitudine. Pentru literele intrebarilor se va folosi un font (la alegere) care simuleaza scrisul de mana.
    3. Dupa ce se raspunde la cate o intrebare, aceasta e inlocuita de urmatoarea intrebare. Pentru fiecare intrebare se va scrie indicele urmat de textul intrebarii. Indicii, pornesc de la litera a si merg pana la z (in principiu, nu prea sunt mai mult de 27 de intrebari - cate litere avem in alfabet - dar daca se depaseste numarul de intrebari, atunci dupa z veti avea indicele aa..pana la az, apoi ba pana la bz etc. - in stilul in care sunt numite coloanele si in excel). Pentru optiuni, indiferent de tipul de intrebare, veti folosi RadioButtons, Pentru factorul de certitudine al raspunsului, vor exista 10 ToogleButtons mici cu valori de la 10 la 100. Initial e selectata valoarea 100. Cand se selecteaza un ToggleButton, se deselecteaza cel selectat anterior. In coltul din dreapta-jos al ferestrei, va exista un buton cu textul ">>>" scris cu bold si avand dimensiunea 18. La click pe acest buton se transmite raspunsul utilizatorului spre programul Prolog si se trece la urmatoarea intrebare.
    4. La apasarea tastei "h" se va deschide un Dialog (JOptionPane) care va afisa un JList cu atributele tuturor intrebarilor anterioare. La selectarea unei optiuni, se va deschide o noua fereasta cu intrebarea si raspunsul dat de utilizator (folosind de exemplu un JLabel sau JTextArea) corespunzatoare atributului selectat. Fereastra de Dialog va avea si un buton de OK care o va inchide si va inchide automat si fereastra cu intrebarea afisata (in caz ca mai e deschisa).
    5. Dupa ce se raspunde si la ultima intrebare si sistemul expert calculeaza solutiile, le va afisa in partea stanga a SplitPane-ului, cu ajutorul unor JLabel-uri avand drept text numele solutiei si in paranteza factorul de certitudine (de exemplu: balada(fc:60)). Textele vor fi scrise cu albastru si vor fi subliniate. La click pe o solutie, se vor deschide in browserul default site-urile pentru specia lirica respectiva. In dreptul fiecarei solutii va exista cate un buton, care va avea textul "demonstratie" si va deschide un Dialog (JOptionPane) continand demonstratia pentru raspunsul respectiv (practic ce ar fi si in fisierul demonstratie_timestamp_(solutie(fc)).txt). In partea dreapta a SplitPane-ului cand se vine cu cursorul pe numele unei solutii, se afiseaza imaginea corespunzatoare ei.
  11. Sistem expert pentru alegerea unor benzi desenate in functie de personalitatea si gusturile unei persoane. (minim 20 tipuri de benzi desenate).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        regula@id (unde id este numarul regulii)
        lista_premise@((lista_premiselor)
             atr@valoare@ (pentru atribute cu valori multiple)
             @atr@ (pentru atribute booleene, valoare true)
             @!atr@ (pentru atribute booleene, valoare false)
        )
        concluzie@
            (atr@valoare@ , fc@nr@).(concluzia)
      • intrebarile vor avea formatul:
        intreaba @atribut
        enunt@'continut intrebare'
        variante@(
            val1 ||
            val2 ||
            val3 ||
        ...
        ).
      • scopul se va defini:
        scop@atr
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      banda_desenata --- nume_comic
      descriere --- ...
      imagini --- {cale_relativa_imagine1 , cale_relativa_imagine2 , cale_relativa_imagine3 , ...}

      ###############

      Cuvantul nume_comic va fi inlocuit cu numele benzii desenate. Se va mai adauga descrierea, dar si caile relative catre imaginile corespunzatoare solutiei (vor exista mai multe solutii cu cel putin 2 imagini). Iar dupa descriere: se va afisa textul corespunzator descrierii. Numele cailor imaginilor apar intre acolade, separate de " , ".

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      La final, dupa afisarea solutiilor va aparea o intrebare: "Afiseaza detalii? Da/Nu"

      Daca se alege raspunsul "Nu" se reine la meniul anterior.

      Daca se alege raspunsul "Da", se va deschide intr-un browser la alegere o pagina html (creata in Prolog) de forma:

      • h1- titlu mare al paginii: Solutii sistem expert"
      • in h2 fiecare solutie cu fc-ul sau
      • Sub fiecare h2 se va afisa un paragaraf cu descrierea, iar sub descriere mai multe taguri img cu imaginile.

      E indicata afisarea paginii in chrome fiindca acela e instalat in laborator). Indicatie: cautati in documentatia Sicstus library(process). Puteti considera calea default a browserului: 'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe'. Mai intai veti verifica faptul ca exista executabilalul. Daca nu exista veti afisa un mesaj de forma: 'Chrome nu a fost gasit in calea default', altfel veti afisa imaginile. La prezentare se vor testa ambele cazuri punand o data calea default corecta si o data una gresita pentru afisarea mesajului.

    3. Programul, la fiecare rulare va crea un folder numit output_benzi_desenate (daca exista deja, il va sterge si-l va crea din nou). In el va exista un fisier numit log_solutii.txt, in care pentru fiecare rulare a sistemului expert se va afisa un rand cu timesampul (cel obtinut din now) si sub el, solutiile si apoi toate cunostintele sistemului expert (practic continutul predicatelor fapt), cate una pe linie.
    4. Sa se scrie un predicat de forma atribute(-Nume,-Tip,-ListaValori) care va avea pe rand ca solutie fiecare atribut, cu tipul sau (dedus sau de_la_utilizator) si cu lista de valori posibile. Atributele vor fi obtinute din regulile si intrabarile incarcate din fierul de intrare. Se va adauga in meniul principal o optiune afiseaza_atribute care va afisa in consola pe rand toate atributele obtinute din incarcarea fisierului de intrare, in felul urmator:
      Nume: nume_atr
      Tip: tip_atr
      Valori: [lista_de_valori_posibile]
      -----------------------------------
      In caul in care fisierul nu a fost incaract inca, la alegerea optiunii afiseaza_atr se va afisa un mesaj de forma "Fisierul cu datele de intrare nu a fost incarcat inca."
    5. Se va crea un predicat care primeste un set de nume de atribute si genereaza o matrice in felul urmator. Prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele atributelor date ca parametru. Urmatoarele linii vor corespunde de asemenea fiecarui atribut (dintre cele date ca paramteru de intrare). Astfel, pe fiecare astfel de linie, pe prima coloana avem atributul, iar pe urmatoarele coloane un numar Nr=(de cate ori atributul de pe linie si cel de pe coloana au aparut impreuna in aceeasi regula). Astfel se poate calcula cat de "codependete" sunt cele doua atribute (cat de des existenta unuia necesita si existenta celuilalt pentru a ajunge la o concluzie.

      Va exista o optiune in meniu creeaza_matr_atr care va crea matricea pentru toate atributele si o va publica intr-un fisier de output atribute.txt (aflat in folderul de output al proiectului).

    6. Programul va crea in folderul de output un director numit demonstratii_raspunsuri_meniu (daca exista, il va folosi pe acela, iar daca nu exista, il va crea), in care va exista un fisier numit dem_meniu_nr.txt. Sufixul nr va fi format din concatenarea anului, lunii, zilei, orei, minutului si secundei in care fisierul a fost creat. De exemplu, daca a fost creat in data 14 aprilie 2014, ora 23:45:37, atunci numele fisierului va fi: dem_automobile_20140414234537. In cazul in care luna, ziua, ora, minutul sau secunda sunt mai mici de 10, se mai adauga un 0 in fata, asa cum s-a vazut aici pentru aprilie (vezi literele ingrosate). Fisierul va contine demonstratia pentru fiecare raspuns in parte, gasit pentru consultarea curenta. Fiecare doua demonstratii din fiser vor fi separate printr-o linie de forma "@@@@@@@@@@@raspuns@fc:nr@@@@@@", unde raspuns e raspunsul pentru care este afisata demonstratia, iar nr e factorul de certitudine.

      In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare:

      regula@id (unde id este numarul regulii)
      lista_premise@((lista premiselor)
           atr@valoare@ (pentru atribute cu valori multiple)
           @atr@ (pentru atribute booleene, valoare true)
           @!atr@ (pentru atribute booleene, valoare false)
      )
      concluzie@
          (atr@valoare@ , fc@nr@).(concluzia)
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Pentru toate intrebarile, inclusiv cele booleene, optiunile vor fi ilustrate prin butoane de tip JtoogleButton (tip de buton cu doua stari:activat si dezactivat; ca un comutator). In momentul in care se selecteaza o optiune (prin click pe buton), orice alt buton activat este dezactivat automat. Pentru factorul de certitudine al raspunsurilor, veti avea un JSpinner cu minim 0 si maxim 100, care va creste din 2 in 2 (nu din 1 in 1 cum e default). Va exista un buton cu textul "am dat raspunsul", care, la click, va lua in considerare raspunsul dat si va trece la urmatoarea intrebare.
    3. Sub intrebare va exista un JTextArea cu background portocaliu, cu istoricul intrebarilor. In momentul in care se raspunde la o intrebare, textul acesteia este adaugat in JTextArea impreuna cu raspunsul dat la inceput (restul intrebarilor fiind dedesubt in JTextArea). In locul intrebarii la care s-a raspuns, este scris textul urmatoarei intrebari si sunt afisate noile butoane
    4. Pentru afisarea solutiilor se va folosi un JSplitPane. In partea stanga vor fi afisate solutiile cu ajutorul unui grup de radiobuttons, in partea dreapta imaginea corespunzatoare solutiei selectate dintre raspunsuri, si un JTextPane cu textul demonstratiei corespunzatoare solutiei selectate.
    5. La click pe imaginea solutiei , se va afisa o alta imagine aleatoare a acestuia, diferita de cea afisata anterior. Pentru fiecare solutie vor fi minim 2 imagini posibile, dar va exista macar o solutie pentru care sa avem 3 imagini, pentru a se putea exemplifica la prezentare afisarea aleatoare.
  12. Sistem expert pentru alegerea celor mai potrivite tipuri de fursecuri in functie de situatie (petrecere, etc.) (minim 20 tipuri de fursecuri).

    Cerinte individuale program prolog

    1. Cerinte parsare
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        regula nr. id
        premisele sunt
            atr are valoarea valoare (pentru atribute cu valori multiple),
            atr este adevarat(pentru atribute booleene, valoare true),
            atr nu este adevarat(pentru atribute booleene, valoare false) atunci atr are valoarea valoare cu fc nr.
      • intrebarile vor avea formatul:
        #atribut
        {val1, val2, val3 ...}
        ### 'continut intrebare'.
      • scopul se va defini:
        scopul cautat e atr.(unde atr e atributul-scop)
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      [fursec[nume_fursec]]
      [descriere[descriere_fursec]]
      [imagine[imagine_fursec]]
      [reteta[site]]
      [ingrediente[ingr1(cantitate1);ingr2(cantitate2);ingr3(cantitate3);....]]

      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

      Cuvantul nume_fursec va fi inlocuit cu numele fursecului. Se va mai adauga descrierea, dar si calea relativa catre imaginea corespunzatoare fursecului. Iar cuvantul descriere_fursec va fi inlocuit de descrierea fursecului.

      De asemenea, pentru fiecare fursec avem precizate si ingredientele cu cantitatile lor (de exemplu:zahar(150g)), cat pentru 1kg de fursecuri de acel tip

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      La afisarea solutiilor, sub fiecare solutie se va afisa o parte din descriere: primele 7 cuvinte si apoi "[...]"

      Dupa afisarea solutiilor se va afisa un submeniu cu optiunile

      • expandare - fara parametri reafiseaza toate solutiile, avand sub fiecare solutie descrierea corespunzatoare. Optiunea accepta si un parametru - nume de solutie - afisand descrierea completa doar pentru acea solutie
      • ingrediente - fara parametri reafiseaza toate solutiile, avand sub fiecare solutie ingredientele (ordonate alfabetic) impreuna cu cantitatile lor
      • afis_retete - Daca se da optunea fara parametri, veti deschide retetele corespunzatoare solutiilor in chrome. Indicatie: cautati in documentatia Sicstus library(process). Puteti considera calea default a browserului: 'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe'. Mai intai veti verifica faptul ca exista executabilalul. Daca nu exista veti afisa un mesaj de forma: 'Chrome nu a fost gasit in calea default', altfel veti afisa imaginile. La prezentare se vor testa ambele cazuri punand o data calea default corecta si o data una gresita pentru afisarea mesajului. Optiunea accepta ca parametru si un nume de solutie, si va deschide doar pentru acea solutie imaginea in browser. E indicata afisarea paginii in chrome fiindca acesta e instalat in laborator). Optiunea poate primi si un parametru - numele solutiei - si atunci va deschide doar reteta corespunzatoare acelei solutii.
      • meniu - care ne intoarce la meniul principal
    3. minim o intrebare va avea formatul:
      #atribut[special]
      {val1, val2, val3 ...}
      ### 'continut intrebare'.
      Acest format inseamna ca intrebarea respectiva nu va primi de la utilizator ca raspuns una dintre optiuni, ci un raspuns custom, in functie de care se va calcula, printr-un predicat definit special pentru acel atribut, optiunea ce va fi atribuita ca valoare atributului. Aceasta intrebare se poate referi de exemplu la numarul de calorii pe care sa-l aiba un fursec sau la cantitatea maxima de zahar in 100g. Veti defini niste intervale de exemplu 0-50, 50-100 etc pe post de optiuni. Insa nu veti afisa optiunile pentru utilizator pentru aceasta intrebare. El va raspunde cu un numar si veti procesa acel numar calculand prin program optiunea corespunzatoare acelei intrebari.
    4. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru tote solutiile existente, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele tuturor solutiilor. Urmatoarele linii vor corespunde, pe rand, fiecarui tip de ingredient. Astfel, pe fiecare astfel de linie, pe prima coloana avem ingredientul, iar pe urmatoarele coloane cantitatile in grame (corespunzatoare coloanei) pentru solutia respectiva.

      In meniul care apare dupa afisarea solutiilor, se va adauga si optiunea afis_ingrediente. La alegerea acestei optiuni se va afisa matricea creata pentru solutii, formatata frumos astfel incat dimensiunea unei coloane sa fie egala cu dimensiunea celui mai lung element de pe acea coloana.

      Ingredientele din matrice reprezinta reuniunea ingredientelor pentru fiecare fursec-solutie. Vor exista cazuri cand unele ingrediente vor fi folosite doar pentru o parte din solutii (pentru altele lipsind). In cazul in care ingredientul lipseste, in matrice se afiseaza "-".

      In matrice se va afisa inca o coloana continand pe prima Linie titlu de coloana "Suma" iar pe restul liniilor suma gramajelor pentru ingredientul corespunzator liniei. (Un astfel de tabel ar fi util cuiva care vrea sa aplice oate solutiile sistemului expert facand un mix de fursecuri in cantitati egale.) Pentru un ingredient inexistent in componenta unui fursec, se pune zero.

    5. Programul, la fiecare rulare va crea un folder numit output_fursecuri (daca exista deja, il va sterge si-l va crea din nou). In cadrul acestui folder se va crea un fisier numit solutii_respinse_timestamp.txt In acest fisier se vor afisa Concluziile respinse + motivele. De exemplu, "Concluzia (tip_concluzie) s refuzata pentru ca astepta atr=val si am avut atr=alt_val in schimb." Se vor afisa si solutiile respinse pentru un factor de certitudine prea mic. De exemplu "Solutia s refuzata pentru ca are fc=nr>fc_min" Timestampul din numele fisierului e preluat din rezultatul predicatului now. Tipul de concluzie este "principala" daca e vorba de o concluzie scop si "secundara" daca nu.
    6. Dupa consultarea sistemului expert, programul va verifica daca exista in folderul de output un folder numit demonstratii. Daca exista, ii va sterge continutul (se poate realiza si prin stergerea si crearea directorului) si daca nu exista, il va crea. In acest folder programul va scrie cate un fisier pentru fiecare raspuns dat, cu demonstratia pentru acesta. Numele fisierelor vor fi de forma dem_fursec(nume_fursec[fc])_an(luna(zi(ora(min(secunda))))).txt. Veti inlocui nume_fursec si fc cu numele solutiei si factorul ei de certitudine. De asemenea cuvintele an, luna, zi, ora, min,secunda vor fi inlocuite cu componentele timpului curent de la crearea fisierului. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      regula nr. id
      premisele sunt
          atr are valoarea valoare (pentru atribute cu valori multiple),
          atr este adevarat(pentru atribute booleene, valoare true),
          atr nu este adevarat(pentru atribute booleene, valoare false) atunci atr are valoarea valoare cu fc nr.
      Pentru valorile obtinute de la utilizator se va scrie un rand de forma:
      Utilizator: atr=val (pentru intrebarea: "text-intrebare" cu optiunile {...})
      Veti inlocui, atr, val, text_intrebare si "..." cu valorile corespunzatoare.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Afisarea raspunsurilor se va face pe mai multe taburi (tabbed pane). Fiecare tab are un separator vertical. In partea stanga e valoarea solutiei, cu fc si cu descrierea asociata (valoarea solutiei va fi si titlul tabului). Iar in partea dreapta imaginea. La click pe imagine se deschide un Jframe continand informatii despre ingredientele necesare. Acestea vor fi puse intr-un panou continand un Jlabel cu text in format html. Ingredientele vor fi organizate intr-o lista neordonata.
    3. Pentru intrebarile cu raspuns de tip da/nu, se va folosi un checkbox (implicit nebifat), pentru celelalte se vor folosi elemente de tip JList cu selectie unica(implicit selectat primul raspuns). Pentru factorul de certitudine veti avea un TextBox. Va exista un buton cu textul "Urmatoarea intrebare" care va lua in considerare raspunsul dat si va trece la urmatoarea intrebare.
    4. Intrebarile vor fi afisate toate in aceeasi fereastra. Cand se raspunde la o intrebare, textul din labelul continand intrebarea, se va schimba, la fel si optiunile afisate. Pentru fiecare intrebare se va afisa si a cata este folosind ca indici litere mari (Intrebarea A, Intrebarea B). Intr-un TextArea nemodificabil se va afisa istoricul raspunsurilor printr-un text de forma: A:raspuns 1
      B:raspuns 2
      ...
    5. In tabul fiecarei solutii va exista un buton cu titlul demonstratie. La click pe el se deschide o alta fereastra avand un TextArea disabled cu continutul demonstratiei. Fereastra aceasta se deschide si la combinatia de taste ctrl+d. Daca se trece la un nou tab-solutie sau se inchide fereastra principala, se inchide si cea cu demonstratia. Idem pentru fereastra cu ingredientele.
  13. Sistem expert pentru alegerea celui mai potrivit parc in functie de situatie (plimbare, joaca relaxare etc.) (minim 20 de parcuri).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        regula_id
        daca{
            atr:valoare (pentru atribute cu valori multiple)
            atr (pentru atribute booleene, valoare true)
            \+ atr (pentru atribute booleene, valoare false)
        }
        atunci:
            atr:valoare fc(nr)
      • intrebarile vor avea formatul:
        ?: atribut
        cu valorile= (val1; val2; val3 ...)
        intrebare: 'continut intrebare'
      • scopul se va defini:
        scop:atr
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      parc -->[nume_parc]
      imagine --> [imagine_parc]
      ratinguri --> [exemple de ratinguri
      curatenie:5/5
      liniste:4/5
      paza: 4/5
      facilitati_sanitare: 1/5
      ...(eventual si alte facilitati)
      ]
      descriere -->[...]

      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

      Cuvantul nume_parc va fi inlocuit cu numele parcului. Se va mai adauga descrierea, dar si caile relative catre imaginile corespunzatoare solutiei. Iar dupa descriere--> se va afisa textul corespunzator descrierii.

      Pentru fiecare parc se va preciza si o cale relativa catre imagine

      De asemenea, pentru diversele parcuri avem si un rating precizat

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      In cazul in care sistemul expert a fost deja consultat si au fost calculate solutiile (se va testa prin program acest aspect), se va afisa o optiune noua in meniu detalii_solutii (nu se afiseaza daca solutiile nu sunt deja calculate).

      La alegerea otiunii detalii_solutii se afiseaza un alt meniu cu urmatoarele optiuni

      • afis_descriere - fara parametrii reafiseaza toate solutiile, avand sub fiecare solutie descrierea corespunzatoare. Optiunea accepta si un parametru - nume de solutie - afisand descrierea doar pentru acea solutie
      • afis_ratinguri - fara parametrii reafiseaza toate solutiile, avand sub fiecare solutie ratingurile (ordonand descrescator categoriile de rating, deci de la cel mai bun la cel mai slab rating). Optiunea accepta si un parametru - nume de solutie - afisand ratingurile (tot descrescator) doar pentru acea solutie
      • afis_imagini - Daca se da optunea fara parametri, veti deschide imaginile corespunzatoare solutiilor in chrome. Indicatie: cautati in documentatia Sicstus library(process). Puteti considera calea default a browserului: 'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe'. Mai intai veti verifica faptul ca exista executabilalul. Daca nu exista veti afisa un mesaj de forma: 'Chrome nu a fost gasit in calea default', altfel veti afisa imaginile. La prezentare se vor testa ambele cazuri punand o data calea default corecta si o data una gresita pentru afisarea mesajului. Optiunea accepta ca parametru si un nume de solutie, si va deschide doar pentru acea solutie imaginea in browser. E indicata afisarea paginii in chrome fiindca acesta e instalat in laborator).
      • m_principal - care ne intoarce la meniul principal
    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru tote solutiile existente, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele tuturor solutiilor. Urmatoarele linii vor corespunde, pe rand, fiecarei categorii de rating. Astfel, pe fiecare astfel de linie, pe prima coloana avem categoria de rating, iar pe urmatoarele coloane valoarea ratingului (corespunzator liniei) pentru solutia respectiva.

      In meniul afisat de detalii_solutii, se va adauga si optiunea afis_compar_rating. La alegerea acestei optiuni se va afisa matricea creata pentru solutii, formatata frumos astfel incat dimensiunea unei coloane sa fie egala cu dimensiunea celui mai lung element de pe acea coloana.

      Ratingurile din matrice reprezinta reuniunea categoriilor de rating. Vor exista cazuri cand unele ratinguri vor fi date doar pentru o parte din solutii (pentru altele lipsisnd). In cazul in care ratingul lipseste, in matrice se afiseaza "-".

      Sub matrice se va afisa inca o linie continand ratingul mediu pentru fiecare solutie de pe coloana. ratingul mediu reprezinta media tuturor ratingurilor date. Pentru un rating inexistent, nu se pune zero ci pe coloana respectiva pur si simplu nu se ia in considerare. Deci media ratingurilor pentru o solutie e suma ratingurilor date impartita la numarul de ratinguri date.

      Pentru un parc care nu are niciun rating, se va afisa pe ultima linie, pe coloana corespunzatoare lui simbolul "-".

    4. Programul Prolog va crea un director numit output_parcuri (de fapt, daca exista deja, il va folosi pe acela, iar daca nu exista, il va crea - e obligatoriu de implementat acest test daca doriti sa primiti punctaj complet pe cerinta). In acest folder se va crea un fisier numit log_stm_expert.txt. Acest fisier va fi suprascris la fiecare rulare. In el se va adauga cate o linie noua la fiecare dintre urmatoarele evenimente:
      • Adaugarea unei cunostinte noi de tip fapt in baza de cunostinte
      • Actualizarea factorului de certitudine al unui fapt deja cunoscut (se va preciza fc-ul vechi, dar si cel nou)
      • Calcularea unei valori-solutie
      Liniile din fisierul de log vor avea formatul:
      Nr_ordine) [Ora:Min:Secunda] Informatii eveniment.
      De exemplu:
      17) [09:10:05] Pentru faptul dimensiune_parc=mediu s-a acualizat factorul de certitudine de la 80 la 65.
      Numarul de ordine reprezinta numarul evenimentului din fisierul de log. Numerotarea incepe de la 1.
    5. La inceputul consultarii, imediat inainte de se afiseaza prima intrebare, se va pune si o intrebare de forma: "Doriti sa afisati pas de pas cunostintele sistemului expert?". Aceasta intrebare nu seteaza valoarea unui atribut folosit in algoritmul de deductie al sistemului expert. Insa raspunsul utilizatorului va fi memorat cumva. Daca utilizatorul raspunde "nu", sistemul expert se va comporta normal, afisand intrebarile, acceptand raspunsurile si dand solutiile la final. Daca utilizatorul raspunde "da", atunci, in urma fiecarui raspuns dat de utilizator, se vor afisa toate faptele cunoscute de sistemul expert, prin intermediul unor perechi de forma atribut-valoare.
    6. Programul, la fiecare rulare va crea in folderul de output cate un folder pentru fiecare solutie. Folderul pentru solutie va avea numele dem_solutie_timestamp. Indicatie: timestamp-ul e dat de predicatul now(X). In cazul in care exista deja un folder pentru acea solutie, evident cu alt timestamp, acel folder va fi redenumit cu noul timestamp. In acest folder va exista un fisier numit demonstratie_raspuns.txt,in care se vor afisa demonstratiile pentru solutia respectiva, dar din toate rularile (cand se obtine din nou solutia respectiva, se adauga la finalul fisierului. Doua demonstratii se vor afisa separate printr-o linie formata din 15 simboluri "-".

      La inceputul unei demonstratii se afiseaza si o linie cu data curenta: ~~~An-Luna-Zi-Ora-Minut-Secunda~~~

      In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare:

      regula_id
      daca{
          atr:valoare (pentru atribute cu valori multiple)
          atr (pentru atribute booleene, valoare true)
          \+ atr (pentru atribute booleene, valoare false)
      }
      atunci:
          atr:valoare fc(nr)
      Pentru atributele obtinute de la utilizator se va afisa un mesaj de genul:
      La intrebarea "[text_intrebare]" ([nume_atr]) utilizatorul a raspuns [valoare].
      Inlocuind campurile dintre paranteze drepte cu valorile corespunzatoare.

    Cerinte interfata grafica

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. La afisarea raspunsurilor, pentru fiecare raspuns, sa se afiseze si o imagine a parcului identificat, insa imaginile sa fie de dimensiuni descrescatoare in functie de factorul de certitudine.
    3. Pentru intrebarile cu raspuns de tip da/nu, se va folosi un grup de radiobutton-uri (implicit va fi selectat primul radiobutton), pentru celelalte se vor folosi elemente de tip JComboBox (implicit selectat un raspuns random). Raspunsurile speciale nu_stiu si nu_conteaza vor fi de asemenea incluse. Pentru factorul de certitudine veti avea un TextBox. Va exista un buton cu textul "OK" care va lua in considerare raspunsul dat si va trece la urmatoarea intrebare.
    4. Intrebarile vor fi afisate toate in aceeasi fereastra. Cand se raspunde la o intrebare, textul din labelul continand intrebarea, se va schimba, la fel si optiunile afisate. Pentru fiecare intrebare la care s-a raspuns, se va adauga in interfata grafica, cate un buton cu textul "i_nr_intrebare" (i_1, i_2 etc.). Si la click pe un astfel de buton se va afisa un alert-box( Indicatie: JOptionPane.showMessageDialog(...) ) cu textul acelei intrebari si raspunsul dat.
    5. La final, raspunsurile se vor afisa unul sub altul cu ajutorul unor Labeluri. Va exista si un buton cu textul "demonstratii" care la click va deschide un notepad cu fiserul curent de demonstratii.
  14. Sistem expert pentru alegerea celui mai potrivit tip de buchet de flori in functie de situatie (minim 20 tipuri de buchete).

    Cerinte individuale prolog:

    1. Parsare:
      • Regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        rg::id
        conditii={(conditiile intre acolade, atributele separate cu virgula)
            atr e egal cu valoare , (pentru atribute cu valori multiple)
            atr , (pentru atribute booleene, valoare true)
            atr[fals] (pentru atribute booleene, valoare false)
        }
        atunci(concluzie)
            atr e egal cu valoare fc:nr.(concluzia)
      • intrebarile vor avea formatul:
        ??? atribut
        raspunsuri posibile: val1; val2; val3 ...
        intrebare 'continut intrebare'.
      • scopul se va defini:
        scop::atr.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      {buchet: nume_buchet}
      {imagine:cale_relativa_imagine}
      {flori:
      -> floare1, nr1
      -> floare2, nr2
      -> floare3, nr3
      ... (completati cu restul tipurilor de flori)
      }
      {descriere:...}

      ----------

      Cuvantul nume_buchet va fi inlocuit cu numele buchetului. Se va adauga si calea relativa catre imaginea corespunzatoare solutiei. Iar dupa descriere: se va afisa textul corespunzator descrierii. Florile apar cate una pe linie precedate de ->, indicandu-se si numarul lor in buchet.

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      La final, dupa afisarea solutiilor se vor afisa trei optiuni: descriere, flori_componente, revenire:

      Daca se alege descrierea, se vor afisa din nou solutiile urmate si de descrieri.

      Daca se alege optiunea flori_componente, se vor afisa din nou solutiile urmate si de lista de flori componente scrise in felul urmator:

      Buchet: nume_buchet
      Flori componente:(exemple de flori)
      + 5 zambile
      + 3 lalele
      + 1 trandafiri
      ----------------------- (un separator intre 2 solutii)

      Optiunea 'revenire' revine la meniul principal.

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru o lista de buchete, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele buchetelor. Urmatoarele linii vor corespunde fiecarui buchet dintre cele precizate in lista. Astfel, pe fiecare astfel de linie, pe prima coloana avem buchetul, iar pe urmatoarele coloane o lista de flori continute atat de buchetul corespunzator liniei cat si cel al coloanei

      Trebuie sa aveti minim un set de raspunsuri din care rezulta cel putin 3 solutii (veti specifica acest set de raspunsuri in documentatie). Pentru aceste solutii sa aveti si cazuri de flori comune dar si cazuri de buchete care nu au deloc flori comune.

      In meniul de dupa afisarea solutiei, va aparea o optiune afis_tabel, care, daca e aleasa va afisa matricea creata la acest subpunct, dar avand drept elemente in locul listelor de flori comune, numarul lor. Se va realiza o afisare formatata frumoasa a matricii, cu coloanele avand drept dimensiune cel putin numarul maxim de caracatere al cuvintelor de pe acea coloana.

      Sub tabel se vor afisa doua optiuni: afis_flori care accepta doi parametri: buchet1 si buchet 2, afisand florile comune si meniu_principal care duce utilizatorul la meniul initial. Acest tabel poate servi utilizatorului pentru a face o alegere mai informata (avand in vedere ca poate totusi prefera anumite flori, iar existenta lor poate nu a fost inclusa in intrebarile sistemului expert, ajungndu-se la acele buchete datorita altor criterii posibile).

    4. Programul va crea un folder de output numit output_flori (daca exista deja, il va folosi pe cel existent; deci trebuie inclus acest test in program). In acest folder se va crea automat un director numit fisiere_log (daca exista, il va folosi pe acela, iar daca nu exista, il va crea), in care va exista un fisier numit log.txt, in care se vor scrie raspunsurile utilizatorului la fiecare intrebare, sub forma atr=val, unde atr e atributul corespunzator intrebarii, iar val e valoarea data ca raspuns de catre utilizator. Sub intrebari si raspunsuri, dupa ce sistemul a trecut prin procesul de decizie, va afisa si solutiile gasite. Pentru fiecare consultare, se va adauga, la sfarsitul fisierului log.txt, o linie departitoare ("=========================="), pentru a separa intrebarile din rulari anterioare, de intrebarile din cadrul consultarii curente.
    5. Se va scrie un predicat in prolog care sa genereze un fisier in care sa fie scrise toate valorile posibile pentru atributul scop. Acest predicat va fi apelat de predicatul care incarca fisierele de intrare (cu regulile si intrebarile) in baza de cunostinte. Numele fisierulul va avea formatul solutii_posibile_timestamp.txt, unde cuvantul timestamp va fi calculat cu ajutorul predicatului now (vezi laboratorul 5). In meniul principal se va adauga optiunea afis_buchete, care va afisa totalitatea buchetelor posibile (cate un buchet pe rand, precedat de o linioara "-").
    6. Programul, va crea automat si un folder numit demonstratii (tot in folderul de output). La fiecare rulare, continutul acestui folder va fi golit si in acest folder se va crea pentru fiecare solutie cate un fisier numit demonstratie_sol.txt (unde sol e numele solutiei). Pentru solutia cu fc maxim, numele fisierului va fi de forma demonstratie_sol(max).txt. In demonstratie, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      rg::id
      conditii={(conditiile intre acolade, atributele separate cu virgula)
          atr e egal cu valoare , (pentru atribute cu valori multiple)
          atr , (pentru atribute booleene, valoare true)
          atr[fals] (pentru atribute booleene, valoare false)
      }
      atunci(concluzie)
          atr e egal cu valoare fc:nr.(concluzia)
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Initial pe interfata grafica vom avea mai multe imagini cu buchete. Si un titlu scris in mijloc "Gaseste buchetul potrivit!", iar sub titlu, un buton cu textul "Sa incepem!", care va porni intrebarile.
    3. Pentru intrebarile cu raspuns de tip da/nu, se va folosi un jToggleButton (implicit va fi selectat raspunsul "da" corespunzand butonului activat; buton dezactivat inseamna "nu" ), pentru celelalte tipuri de intrebari se vor folosi TextFields. Pentru factorul de certitudine al raspunsurilor, veti avea un JSlider cu minim 0 si maxim 100. Va exista un buton cu textul "OK" care va lua in considerare raspunsul dat si va trece la urmatoarea intrebare (vezi in subpunctul urmator cum anume). Trecerea la urmatoarea intrebare se face dupa ce se verifica faptul ca utilizatorul a raspuns ceva corect. Daca a dat o optiune inexistenta, sau pentru o intrebare de tip !input a raspuns cu o valoare invalida, se va afisa intr-un mesaj de tip alerta (JOptionPane.showMessageDialog(...)) un text care sa atentioneze utilizatorul, si i se va stege raspunsul din text field.
    4. Intrebarile vor fi puse intr-un tabbed pane. La trecerea la o noua intrebare se va crea un nou tab. Intrebarile vechi vor putea fi accesate, dar nu si modificate (butonul "OK" va fi sters din tabul curent, atunci cand se creaza tabul cu urmatoarea intrebare).
    5. La final, se vor afisa raspunsurile cu factorii de certitudine. Va exista si un checkbox in dreptul fiecaruia, care in starea de "activat" va afisa sub raspuns un TextArea cu continutul demonstratiei pentru acel raspuns. Cand e debifat, TextArea-ul va fi ascuns.
  15. Sistem expert care identifica cel mai potrivit tablou de cumparat dintr-un set de minim 20 tablouri in functie de necesitatile cumparatorului

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        [
        Premise ? (lista_premiselor)
             atr -- valoare (pentru atribute cu valori multiple)
             atr (pentru atribute booleene, valoare true)
             !# atr (pentru atribute booleene, valoare false)
        Concluzie?
            atr -- valoare; fcert(nr).(concluzia)
        ]{id}.(unde id este numarul regulii)
      • intrebarile vor avea formatul:
        Text -- 'continut intrebare'
        Optiuni -- [
             # val1
             # val2
             # val3
        ...
        ]{atribut_intrebare}.
      • scopul se va defini:
        Scop -- atr.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. Acestea vor fi scrise cu ajutorul unor inregistrari de felul:

      Pentru nume_solutie avem:
      - [imagine: cale_relativa_imagine ]
      - [descriere: text_descriere ]
      - [pret: pret ]
      - [rame_disponibile: tip_rama_1 + tip_rama_2+ ....+tip_rama_n ]

      Fiecare camp in italic din sablonul de mai sus, va fi inlocuit cu informatia corespunzatoare. Acolo unde sunt mai multe cuvinte veti pune textul intre ghilimele.

      Aceste date vor fi citite din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      La finalul consultarii, solutiile se vor afisa (doar cu numele, factorul de certitudine si pretul).

      Sub afisarea solutiilor se va afisa urmatorul submeniu:

      Alegeti o optiune tastand prima litera a acesteia:
      - Descrieri
      - Informatii Complete
      - Ordonare dupa preturi
      - Exit

      Daca se alege optiunea D (Descrieri), se vor afisa din nou solutiile, insa doar cu descrieri.

      Daca se alege optiunea I (Informatii Complete), se vor afisa din nou solutiile, insa cu toate informatiile despre ele(descriere, factor certitudine, pret, imagine). Doua solutii vor fi separate printr-o linie formata din simboluri "=".

      Daca se alege optiunea O (Ordonare dupa preturi), se vor afisa din nou solutiile, cu factor de certitudine si pret, insa ordonate dupa pret

      Oricare dintre optiuni in afara de E (Exit) duce la reafisarea solutiilor iar apoi la reafisarea submeniului

      Optiunea E (Exit) revine la meniul principal.

    3. Va exista un fiser cu date de intrare, continand,pentru fiecare tip de rama, cate o inregistrare de forma:
      tip_rama pret
      de exemplu:
      albastra_plastic 30
      neagra_lemn 50
      ...etc. .
      Acest fisier va fi citit, iar datele din interiorul sau memorate in baza de cunostinte.
    4. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru toate solutiile existente, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele tuturor solutiilor. Urmatoarele linii vor corespunde, pe rand, fiecarui tip de rama (ordinea in care apar tipurile de rama nu e relevanta). Astfel, pe fiecare astfel de linie, pe prima coloana avem tipul de rama, iar pe urmatoarele coloane pretul total calculat pentru tablou (pret rama+ pret tablou) daca tipul de rama poate fi aplicat acelui tablou conform descrierii si x daca nu.

      In submeniul afisat dupa solutii, va aparea o optiune in plus numita Tabel Preturi (accesata prin optiunea 'T'). La alegerea acestei optiuni se va afisa matricea creata pentru solutii, formatata frumos astfel incat dimensiunea unei coloane sa fie egala cu dimensiunea celui mai lung element de pe acea coloana.

      Ramele din matrice reprezinta reuniunea ramelor pentru pentru toate solutiile oferite atunci de sistemul expert, deci nu vor fi toate ramele posibile din fisierul de descrieri ci doar subsetul pentru solutii.

    5. Programul Prolog va crea un director numit output_tablouri (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In el se va crea un fisier numit clasament_solutii.txt (acesta va fi suprascris in cazul in care exista deja de la o rulare anterioara). In interiorul acestui fisier se vor afisa toate solutiile posibile, fiecare pe cate un rand, avand in dreptul lor un numar. Acel numar reprezinta de cate ori au fost date ca solutii in urma unei consultari (de-a lungul tuturor consultarilor). Solutiile vor fi ordonate descrescator in functie de acest numar.
    6. Programul va crea in folderul de output un director numit demonstratii_calculatoare (daca exista, il va folosi pe acela, iar daca nu exista, il va crea), in care pentru fiecare rulare va crea cate un director numit dem_timestamp.txt. Sufixul timestamp va fi numarul calculat de predicatul now (dupa ce s-a terminat consultarea sistemului expert). In fiecare astfel de folder va exista cate un fisier de forma dem_raspuns.txt pentru fiecare raspuns dat de sistem in urma acelei rulari Cuvantul raspuns va fi inlocuit cu numele efectiv al solutiei pentru care este scrisa demonstratia. Prima linie a fisierelor de acest gen va fi de forma "Raspuns sistem expert:raspuns, fc:nr", unde raspuns e raspunsul pentru care este afisata demonstratia, iar nr e factorul de certitudine.

      In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:

      [
      Premise ? (lista_premiselor)
           atr -- valoare (pentru atribute cu valori multiple)
           atr (pentru atribute booleene, valoare true)
           !# atr (pentru atribute booleene, valoare false)
      Concluzie?
          atr -- valoare; fcert(nr).(concluzia)
      ]{id}.(unde id este numarul regulii)
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Fiecarei intrebari ii va corespunde un icon (imagine de 20x20px care sa simbolizeze acea intrebare; de exemplu, pentru o intrebare depre tipul de vopsea folosita, putem avea o imagine cu o pensula). Pe masura ce se raspunde la intrebari, pe un rand orizontal, aflat sub intrebare si optiuni, se va adauga icon-ul intrebarii la care tocmai s-a raspuns. Astfel daca s-a ajuns la a 4-a intrebare, avem deja icon-urile pentru intrebarile 1,2,3.
    3. La click pe unul dintre iconurile de mai sus se va afisa intr-un alt JFrame (o fereastra noua), textul intrebarii si raspunsul dat de utilizator.
    4. Raspunsurile vor fi date cu ajutorul unui Tabbed Pane. Fiecare raspuns va fi pe cate un tab. In tabul respectiv va fi afisat si factorul de certitudine si o imagine care sa ilustreze cumva meniul gasit, si un JtextArea cu demonstratia.
    5. Pentru toate intrebarile, inclusiv cele booleene, optiunile vor fi ilustrate prin butoane de tip checkbox . In momentul in care se bifeaza o optiune (prin click pe checkbox), orice alt checkbox bifat se debifeaza automat (printr-un for verificati checkboxurile bifate si le debifati). Pentru factorul de certitudine al raspunsurilor, veti avea un JSpinner cu minim 0 si maxim 100, care va creste din 5 in 5 (nu din 1 in 1 cum e default). Va exista un buton cu textul "am terminat de raspuns", care, la click, va lua in considerare raspunsul dat si va trece la urmatoarea intrebare.
  16. Sistem expert care identifica cel mai potrivit mod de comunicare electronica: facebook, sms, e-mail, skype, twitter etc pentru o situatie data (de business, de familie etc). (minim 20 tipuri de moduri de comunicare electronica).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        nr_regula: id
        [(premise)
            (atr, valoare); (pentru atribute cu valori multiple)
            (atr)(pentru atribute booleene, valoare true)
            (not atr)(pentru atribute booleene, valoare false)
        ]
        implica(concluzie)
            (atr, valoare), (fc,nr)(concluzia)
      • intrebarile vor avea formatul:
        intrebare pentru atribut
        Variante raspuns: [val1, val2, val3 ...]
        Text intrebare: 'continut intrebare'.
      • scopul se va defini in fisier:
        (scop, atr).
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      [Mod_comunicare :: solutie] --> text_descriere;
      [Imagine :: cale_relativa_imagine] calea va fi scrisa intre apostrofuri
      [Dispozitive :: telefon_mobil_clasic; smartphone; smartwatch; pc ... ]exemple de dispozitive
      ++++++++++++++++++++

      Cuvantul solutie va fi inlocuit cu tipul de comunicare. Cuvantul text_descriere va fi inlocuit cu descrierea. Se va adauga si calea relativa catre imaginea corespunzatoare solutiei. De asemenea se vor enumera dispozitivele care permit acel tip de comunicare. Doua descrieri vor avea intre ele un separator de forma ++++++++++++++++++++.

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      La final, dupa afisarea solutiilor se vor afisa trei optiuni: save_descrieri_sol, afis_info_complet, retur:

      Daca se alege optiunea save_descrieri_sol, in folderul de output al sistemului expert se va crea un fisier numit solutii.txt (daca exista, va fi suprascris). In acesta vor fi scrise solutiile urmate si de descrieri in felul urmator: atribut_solutie=valoare_solutie, fc
          text_descriere
      ===============================================
      Cuvantul atribut_solutie va fi inlocuit de numele atributului scop. Cuvantul valoare_solutie de valoarea atributului scop. Iar cuvantul text_descriere de descrierea efectiva

      Daca se alege optiunea afis_info_complet, se vor afisa din nou solutiile urmate de dispozitivele care le suporta, dar si de descrieri in formatul indicat in exemplul de afisare:

      tip_comunicare(skype)
          fc=87
      Dispozitive:
      >>smartphone
      >>tableta
      >>pc
      Descriere(Un program stil messenger).
      ----------------------- (un separator intre 2 solutii)

      Optiunea retur revine la meniul principal.

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru toate solutiile existente, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de valoarea tuturor solutiilor obtinute in urma consultarii. Urmatoarele linii vor corespunde, pe rand, tot fiecarei solutii. Astfel, pe fiecare astfel de linie, pe prima coloana avem valoarea solutiei, iar pe urmatoarele coloane lista dispozitivelor pe care se poate aplica modul de comunicare identificat de solutie.

      In meniul de dupa afisarea solutiilor va aparea si o optiune tabel_solutii. La alegerea acestei optiuni se va afisa matricea creata pentru solutii, formatata frumos astfel incat dimensiunea unei coloane sa fie egala cu dimensiunea celui mai lung element de pe acea coloana.

      Pe diagonala (deci pentru solutii identice) vom pune simbolul *.

      Pentru cazul in care avem mai multe dispozitive posibile in aceeasi casuta de tabel, dimensiunea "liniei" de tabel va fi egala cu numarul de elemente din casuta. Doua linii de tabel vor fi separate printr-o linie de minusuri("-"), iar doua coloane prin simbolul pipe "|".

      In cazul in care pentru doua solutii nu avem dispozitive comune, lasam casuta din tabel libera (la prezentare se va exemplifica aceasta cerinta si pe un astfel de caz).

      De exemplu:

                      |apel_telefonic|sms    |mesagerie_vocala|
      ---------------------------------------------------------
      apel_telefonic  |*             |mobil  |telefon_fix     |
                      |              |tableta|mobil           |
                      |              |       |tableta         |
      ---------------------------------------------------------
      sms             |mobil         |*      |mobil           |
                      |tableta       |       |tableta         |
      ---------------------------------------------------------
      mesagerie_vocala|telefon_fix   |mobil  |*               |
                      |mobil         |tableta|                |
      ---------------------------------------------------------
      						
    4. Programul va porni prin a-l intreba pe utilizator ce tip de comunicare dintre solutiile posibile considera el ca ar fi cel mai bun pentru situatia data. Solutiile sunt afisate ca variante de raspuns. Raspunsul este memorat prin intermediul programului prolog iar la final comparat cu raspunsurile obtinute de la sistemul expert. In cazul in care raspunsul lui se afla printre solutii, randul corespunzator acelei solutii va fi precedat de ###. In caz ca nu se afla printre solutii, se vor afisa atributul/atributele care au eliminat din calcul regulile corespunzatoare acelei solutii. Astfel utilizatorul va intelege de ce alegerea sa initiala nu e buna.
    5. Programul, va verifica daca exista in directorul curent un folder numit output_comunicare. Daca exista, il va folosi pe acela. Daca nu exista, il va crea. Pentru fiecare mod de comunicare gasit ca solutie, se va crea un fisier text, cu numele acestuia (de exemplu, facebook.txt, skype.txt), fisier care se va pune in folderul de output. In urma unei consultari, pentru fiecare solutie obtinuta se va adauga in fisierul corespunzator ei: factorul de certitudine, textul fiecarei intrebari puse utilizatorului, urmat de raspunsul acestuia. Intrarile din fisier pentru fiecare consultare in parte (care a avut ca solutie acel mod de comunicare) vor fi separate prin 20 caractere "#".

    6. Programul, pentru fiecare solutie a unei consultari, va crea un fisier numit demonstratie_valoarescop_fc.txt. Aceste fisiere vor fi stocate intr-un alt folder numit demonstratii (programul va sterge si va crea din nou acest folder, la fiecare rulare) aflat in folderul de output. Fiecare fisier va contine demonstratia pentru cate un raspuns in parte (in urma unei consultari). Valoarea gasita pentru atributul scop va reprezenta partea valoarescop din numele fisierului, iar factorul de certitudine, partea fc din numele fisierului.

      In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:

      nr_regula: id
      [(premise)
          (atr, valoare); (pentru atribute cu valori multiple)
          (atr)(pentru atribute booleene, valoare true)
          (not atr)(pentru atribute booleene, valoare false)
      ]
      implica(concluzie)
          (atr, valoare), (fc,nr)(concluzia)
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.
  17. Sistem expert care identifica cel mai potrivit film horror pentru o noapte petrecuta cu prietenii de Halloween. (minim 20 filme)

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        regula cu numarul id (unde id este numarul regulii)
        concluzie => valoare, fact_cert=> nr(concluzia; nr este factorul de certitudine)
        conditii =>
             @ atr/valoare (pentru atribute cu valori multiple)
             @ atr (pentru atribute booleene, valoare true)
             @ n! atr .(pentru atribute booleene, valoare false)
      • intrebarile vor avea formatul:
        intrebare 'continut intrebare'
        atribut => atribut_intrebare
        optiuni =>
        val1 ||
        val2 ||
        val3
        .
      • scopul se va defini:
        scop => atr.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. Acestea vor fi scrise cu ajutorul unor inregistrari de felul:

      [descriere]
      denumire=nume_film ;
      poster=cale_imagine_poster_film ;
      descriere_film=descrierea_filmului_scrisa_intre_ghilimele ;
      actori={nume_actor_1, nume_actor2, ...., nume_actor_n}
      [/descriere]

      Fiecare camp in italic din sablonul de mai sus, va fi inlocuit cu informatia corespunzatoare. Acolo unde sunt mai multe cuvinte veti pune textul intre ghilimele.

      Aceste date vor fi citite din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      Solutiile se vor afisa cu tot cu descrieri si toate informatiile aditionale.

      Cand sistemul expert va afisa solutiile le va afisa cu tot cu descrieri.

      Sub afisarea solutiilor se va afisa intrebarea "Reafiseaza? nu/sumar/complet"

      Daca se alege optiunea sumar, se vor afisa din nou solutiile, insa fara descrieri.

      Daca se alege optiunea complet se reafiseaza solutiile cu descrieri si lista de actori sub fiecare descriere, fiecare doua nume de actori fiind separate prin virgula.

      Optiunea nu revine la meniul principal.

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru toate solutiile existente, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele tuturor solutiilor. Urmatoarele linii vor corespunde, pe rand, fiecarui actor (ordinea in care apar actorii nu e relevanta). Astfel, pe fiecare astfel de linie, pe prima coloana avem numele actorului, iar pe urmatoarele coloane + daca in filmul corespunzator coloanei joaca actorul si - daca nu.

      In meniul principal, in cazul in care sistemul expert a fost consultat si are calculate solutii (deci in prima afisare aceasta optiune nu exista, ci doar sistemul expert a trecut printr-o consultare si nu a fost reinitializat), va aparea o optiune in plus numita tabel_actori. La alegerea acestei optiuni se va afisa matricea creata pentru solutii, formatata frumos astfel incat dimensiunea unei coloane sa fie egala cu dimensiunea celui mai lung element de pe acea coloana.

      Actorii din matrice reprezinta reuniunea actorilor pentru pentru toate solutiile oferite atunci de sistemul expert, deci nu vor fi toti actorii posibili din fisierul de descrieri ci doar subsetul pentru solutii.

      Pentru filme, deoarece unele au nume lungi pe coloane, la afisare, daca titlul e sub 10 caractere se va scrie complet, altfel se vor scrie doar primele 10 caractere din titlul filmului, umrate de "...". Iar sub matrice se vor afisa numele complete ale filmelor, cate unul pe linie, pentru ca utilizatorul sa poata face legatura cu titlurile coloanelor

    4. Programul Prolog va crea (in cazul in care nu exista) un director numit output_filme_horror (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In el se va crea un fisier numit atribute.txt (acesta va fi suprascris in cazul in care exista deja de la o rulare anterioara). In interiorul acestui fisier se vor afisa toate atributele cunoscute (cele salvate in predicatul fapt) cu valorile lor, avand in plus precizat daca sunt deduse sau calculate. In cazul in care sunt deduse se va afisa si intrebarea corespunzatoare impreuna cu optiunile scrise intre paranteze. Intre informatiile a doua atribute va exista o linie separatoare de forma =====================.
    5. Se va adauga o optiune in meniu care afiseaza regulile cu un anumit atribut-concluzie. Optiunea se va numi afiseaza_reguli si se va apela:
      afiseaza_reguli atribut_concluzie
      inlocuind campul atribut_concluzie cu numele atributului. La introducerea acestei comenzi se vor afisa toate regulile care au drept concluzie acest atribut, indiferent de valoarea primita in concluzie.
    6. In folderul de output al sistemului se va crea un folder numit demonstratii_sol. fisiere in care se vor scrie demonstratiile pentru fiecare solutie in parte. Numele fisierelor vor fi de forma demonstratie_timestamp_ora_minut_secunda.txt, unde timestamp e calculat de predicatul now, iar ora, minut, secunda reprezinta ora minutul si secunda in care a fost obtinuta solutia. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      regula cu numarul id (unde id este numarul regulii)
      concluzie => valoare, fact_cert=> nr(concluzia; nr este factorul de certitudine)
      conditii =>
           @ atr/valoare (pentru atribute cu valori multiple)
           @ atr (pentru atribute booleene, valoare true)
           @ n! atr .(pentru atribute booleene, valoare false)
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    Studentul a ceru sa faca interfata cu o alta tehnica decat cea prezentata la laborator prin urmare va trebui sa tina cont in dezvoltarea ei de urmatoarele obiective:

    1. sa pastreze toate functionalitatile din consola (absolut toate optiunile din meniu si informatiile afisate de catre sistemul expert)
    2. sa afiseze intrebarile dar si solutiile intr-o maniera interactiva
    3. sa verifice eventualul input al utilizatorului (in cazul in care foloseste textbox-uri si nu optiuni)
    4. sa afiseze imaginile si eventual linkurile corespunzatoare solutiilor
    5. sa poate fi accesate cunostintele sistemului si istoricul raspunsurilor la intrebari
  18. Sistem expert care identifica cea mai potrivita locuinta pentru un om in functie de personalitate, stare sociala si materiala, ocupatie: cort, garsoniera, palat, cabana la munte, casa la tara, rulota, vila la periferie, apartament in centrul orasului, apartament la subsol, in casa parintilor, intr-o pestera retrasa, intr-o casa inchiriata cu mai multi colegi de camera, pe statia spatiala, intr-un hotel + inca 7 locatii alese de voi (minim 20 solutii).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        r/id (unde id este numarul regulii)
        atribut_concluzie:=valoare f_cert:=nr (concluzia; nr este factorul de certitudine)
        multime_conditii:={ (conditiile intre acolade, premisele separate cu virgula)
             atr =? valoare, (pentru atribute cu valori multiple)
             atr,(pentru atribute booleene, valoare true)
             !not! atr (pentru atribute booleene, valoare false)
        }
        .
      • intrebarile vor avea formatul:
        intrebare:= {atribut ;
        text:='continut intrebare' ;
        multime_variante := [val1 val2 val3] (pot fi oricate variante, nu doar 3)
        }.
      • scopul se va defini:
        scop:=atr.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. Acestea vor fi scrise cu ajutorul unor inregistrari de felul:

      {
      %%% nume_solutie
      descriere // text_descriere ;
      imagine // cale_imagine_reprezentativa
      avantaje:
      + avantaj_1
      + avantaj_2
      ...
      + avantaj_n
      dezavantaje:
      - dezavantaj_1
      - dezavantaj_2
      ...
      - dezavantaj_n
      }

      Fiecare camp in italic din sablonul de mai sus, va fi inlocuit cu informatia corespunzatoare. Acolo unde sunt mai multe cuvinte veti pune textul intre ghilimele.

      Aceste date vor fi citite din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      Trebuie sa existe macar 2-3 solutii cu cate 2-3 avantaje si dezavantaje. Nu tratati cazurile in care informatiile lipsesc(toate solutiile au macar un avantaj si un dezavantaj)

      Solutiile se vor afisa cu tot cu descrieri

      Sub afisarea solutiilor se va afisa un submeniu cu textul "avantaje [sol]/dezavantaje [sol]/complet [sol]/reafiseaza_solutii/home"

      Daca se alege optiunea avantaje urmat de un spatiu si de valoarea uneia dintre soluti, se vor afisa avantajele pentru acea solutie.

      Daca se alege optiunea dezavantaje urmat de un spatiu si de valoarea uneia dintre soluti, se vor afisa dezavantajele pentru acea solutie.

      Daca se alege optiunea complet urmat de un spatiu si de valoarea uneia dintre soluti, se vor afisa si avantajele si dezavantajele pentru acea solutie.

      Daca se alege optiunea reafiseaza_solutii se reafiseaza solutiile

      Dupa afisarile impuse de fiecare optiune de mai sus se reafiseaza submeniul.

      Optiunea home revine la meniul principal.

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru toate solutiile date de sistemul expert, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele tuturor solutiilor. Urmatoarele linii vor corespunde, pe rand, din nou, fiecarei solutii. Astfel, pe fiecare astfel de linie, pe prima coloana avem numele solutiei, iar pe urmatoarele coloane un numar care arata de cate ori pe parcursul tuturor rularilor cele doua solutii au aparut impreuna in acelasi timp.

      Indicatie: veti avea nevoie de un fisier in care sa memorati pentru fiecare doua solutii de cate ori au aparut impreuna. Acest fisier va trebui modificat la fiecare rulare. Nu e obligatoriu sa folositi aceasa indicatie, puteti implementa solutia folosind si o alta idee.

      In meniul principal, in cazul in care sistemul expert a fost consultat si are calculate solutii (deci in prima afisare aceasta optiune nu exista, ci doar sistemul expert a trecut printr-o consultare si nu a fost reinitializat), va aparea o optiune in plus numita rel_solutii. La alegerea acestei optiuni se va afisa matricea creata pentru solutii, formatata frumos astfel incat dimensiunea unei coloane sa fie egala cu dimensiunea celui mai lung element de pe acea coloana.

    4. Cand se afiseaza optiunile intrebarilor, se vor afisa ordonate descrescator dupa frecventa cu care a fost dat fiecare raspuns pe parcursul tuturor rularilor. De exemplu daca pentru o intrebare, s-a dat raspunsul r1 de 10 ori r2 de 15 ori si r3 de 0 ori, cele 3 optiuni se vor afisa in ordinea: r2, r1, r3. Evident va fi necesar sa memorati pentru fiecare raspuns de cate ori a fost dat pe parcursul tuturor rularilor.
    5. Programul va folosi un director numit output_locuinte (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In acest folder va exista un fisier istoric.txt (rescris la fiecare rulare). Pe masura ce se face cate o noua consultare se adauga la sfarsitul acestui fisier urmatoarele:
      • o linie de forma "----------------------------------".
      • o linie cu data curenta si ora, de exemplu: 20.05.2015 16:02:37
      • o linie cu raspunsurile utilizatorului date la intrebari intr-o lista de forma: atribut1=val1, atribut2=val2 etc.
      • o linie cu solutiile gasite si factorul de certitudine asociat pentru fiecare
    6. In folderul de output, veti crea cate un fisier numit demonstratie[solutie_fc].txt pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei, iar fc cu factorul de certitudine. In fiecare fisier primul rand va fi de forma: "Demonstratie pentru scop=atribut_scop cu valoarea=solutie avand factorul de certitudine fc". Cuvantul atribut_scop va fi inlocuit cu numele atributului scop, solutie din aceasta fraza va fi inlocuit cu valoarea solutiei, iar fc cu factorul de certitudine. Dupa acest rand urmeaza demonstratia pentru acea solutie. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      r/id (unde id este numarul regulii)
      atribut_concluzie:=valoare f_cert:=nr (concluzia; nr este factorul de certitudine)
      multime_conditii:={ (conditiile intre acolade, premisele separate cu virgula)
           atr =? valoare, (pentru atribute cu valori multiple)
           atr,(pentru atribute booleene, valoare true)
           !not! atr (pentru atribute booleene, valoare false)
      }
      .
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Intrebarile vor fi afisate pe rand in aceeasi fereastra. Pentru optiuni, indiferent de tipul de intrebare, veti folosi un JLabel (cu textul optiunii) si o imagine. Imaginea va fi peste tot la fel, si anume un icon cu o motocicleta (o imagine mica 20x20 sau 30x30). In jurul imaginii si a JLabelului va fi un border albastru. Cand se face click pe JLabel sau pe imaginea asociata, se considera optiunea selectata. O optiune selectata va avea un border galben. Cand o optiune este selectata, automat se deselecteaza toate celalalte. Pentru factorul de certitudine va exista un JSlider cu valori de la 0 pana la maxim 100. Va exista si un buton cu textul "spre o noua intrebare" care, la click pe el, va lua in considerare raspunsul dat si va trece la urmatoarea intrebare.
    3. Sub intrebare si optiuni va exista si un JComboBox, in care, pe masura ce se raspunde la cate o intrebare, se adauga, cate o noua optiune, de forma atribut_intrebare=valoare (cu numele atributului asociat intrebarii la care s-a raspuns si cu valoarea data de utilizator). La selectarea unei optiuni se va afisa intr-un JLabel textul complet al intrebarii si raspunsul dat.
    4. La final, se vor afisa, unul sub altul, intr-un ScrollPane, folosind checkboxuri, raspunsurile(solutiile) cu factorii de certitudine. Initial niciun checkbox nu e selectat.
    5. La selectarea unui checkbox, e adaugat dinamic un JTextArea sub raspuns, cu textul demonstratiei pentru acel raspuns. La deselectare JTextArea-ul dispare. La dubluclick pe numele unei solutii se va deschide o fereastra noua continand descrierea si imaginea corespunzatoare solutiei.
  19. Sistem expert ce selecteaza tipurile de mancare pe care le poate manca un pacient in functie de boala pe care o are (minim 20 solutii).

    Cerinte individuale program prolog

      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        regula[id]
        (unde id este numarul regulii) daca: (conditiile enumerate cu ajutorul semnului ->)
            -> atr=valoare (pentru atribute cu valori multiple)
            -> atr=true (pentru atribute booleene, valoare true)
            -> atr=false (pentru atribute booleene, valoare false)
        atunci:
            atr=valoare cu fc=nr.(concluzia)
      • intrebarile vor avea formatul:
        intrebare[atribut]
        optiuni:
            ->val1
            ->val2
            ->val3
        ...
        text:'continut intrebare'.
      • scopul se va defini:
        scop(atr).
    1. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      ---[nume_solutie]---
      ---[descriere]----
      [...]
      ---[imagine:cale_relativa_imagine]---
      ---[ingrediente]---
      (ingredient1)
      (ingredient2)
      (ingredient3)
      ...

      ^^^^^^^^^^^^^^^^^^^^^^^^

      Cuvantul nume_solutie va fi inlocuit cu numele solutiei. Se va mai adauga descrierea, dar si calea relativa catre imaginea corespunzatoare felului de mancare. Iar textul ... dintre parantezele drepte (de sub descriere) va fi inlocuit de descrierea felului de mancare.

      De asemenea, pentru fiecare fel de mancare avem precizate si ingredientele intre paranteze rotunde, cate unul pe linie (de exemplu:(cartofi)

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      Dupa afisarea solutiilor se va afisa o intrebare de forma "Detalii? (da/nu)". Daca se raspunde "da" se vor afisa solutiile cu detalii. Daca se raspunde nu, se revine la meniul principal.

      La afisarea solutiilor cu detalii, sub fiecare solutie se va afisa descrierea in felul urmator:

      solutie
      >>>descriere:....text_descriere...
      >>>ingrediente: ingredient1, ingredient2, ....
      -----------------------------------

    2. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru tote solutiile existente, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele tuturor solutiilor. Urmatoarele linii vor corespunde, pe rand, fiecarui tip de ingredient. Astfel, pe fiecare astfel de linie, pe prima coloana avem ingredientul, iar pe urmatoarele coloane x daca ingredientul este inclus in felul de mancare de pe coloana, sau - daca nu.

      In meniul principal va aparea o optiune afis_ingrediente numai daca sistemul expert a fost deja consultat (deci daca are solutii). De exemplu dupa apelul instructiunii reinitiaza, optiunea afis_ingrediente nu va mai fi afisata, fiindca nu mai exista solutii calculate. La alegerea acestei optiuni se va afisa matricea creata pentru solutii, formatata frumos astfel incat dimensiunea unei coloane sa fie egala cu dimensiunea celui mai lung element de pe acea coloana.

      Ingredientele din matrice reprezinta reuniunea ingredientelor pentru toate solutiile. Vor exista cazuri cand unele ingrediente vor fi folosite doar pentru o parte din solutii (pentru altele lipsind). In cazul in care ingredientul lipseste, in matrice se afiseaza "-".

    3. Programul, la fiecare rulare va crea un folder numit output_mancare (daca exista deja, il va sterge si-l va crea din nou). La finalul consultarii, dupa ce s-au obtinut solutiile, se vor adauga intr-un fisier numit log_atrib_sol.txt (aflat in folderul de output) aributele impartie in doua categorii, pentru fiecare solutie: atribute folosite si atribute "in plus". Atributele "in plus" sunt cunostintele care nu intra in componenta arborilor solutiilor. Astfel de atribute se obtin cand avem cai diferite de ajungere la solutii (reguli finale cu seturi diferite de atribute). Acest fisier nu se va suprascrie la o noua consultare, ci va contine arborii pentru toate consultarile anterioare. Modul de afisare pentru o solutie este:
      Solutia: atr=val
      Atribute incluse in arbore:
      ...
      ...(perechi atr=val)
      ...
      Atribute neincluse in arbore:
      ...
      ...
      ...
      ----------------------------------------------
    4. Inaintea fiecarei intrebari se va afisa un reand de forma: "atributul atr cerut de regula id", unde atr e numele atributului asociat intrebarii, iar id e id-ul regulii care cere valoarea atributului asociat intrebarii respective. Daca utilizatorul in loc de raspuns scrie "afis_regula", regula respectiva se va afisa complet, iar dedesubt va aparea din nou promptul "|:" pentru ca utilizatorul sa raspunda totusi la intrebare.
    5. La finalul unei sesiuni de folosire, se va crea in cadrul directorului output_mancare cate un fisier numit demonstratie_c1_c2_c3_...cn_(solutie,fc).txt pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei, timestamp cu valoarea calculata de predicatul now (vezi lab. biblioteci), iar fc cu factorul de certitudine. In fiecare fisier va fi scrisa demonstratia pentru solutia respectiva. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      regula[id]
      (unde id este numarul regulii) daca: (conditiile enumerate cu ajutorul semnului ->)
          -> atr=valoare (pentru atribute cu valori multiple)
          -> atr=true (pentru atribute booleene, valoare true)
          -> atr=false (pentru atribute booleene, valoare false)
      atunci:
          atr=valoare cu fc=nr.(concluzia)
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Pentru fiecare intrebare impara o sa apara cate o imagine din domeniul medical, in interfata.
    3. Pentru toate intrebarile, optiunile vor fi generate cu ajutorul unor butoane. Butoanele vor avea textele de forma: a) raspuns1, b) raspuns 2, etc. Deci in textul butonului intra si indicele-litera. Pentru factorul de certitudine, veti folosi un JSpinner. Trecerea la urmatoarea intrebare se face la click pe unul dintre butoanele-optiune. Initial JSpinnerul are valoarea 100.
    4. Pe pagina va mai exista un JList, care va creste cu cate o optiune pentru fiecare noua intrebare la care s-a raspuns. Optiunile JListului vor consta din atributele corespunzatoare intrebarilor. La click pe una dintre optiuni, cu ajutorul unui JOptionPane.showMessageDialog veti arata intr-un dialog avand drept icon o moneda, textul intrebarii si raspunsul utilizatorului.
    5. La final, se vor afisa raspunsurile cu factorii de certitudine, ca optiuni intr-un JList. Sub JList, se va gasi si un TextArea. La selectarea unui anumit raspuns din lista, se va afisa in TextArea demonstratia pentru acel raspuns, air sub TextArea se va afisa imaginea corespunzatoare solutiei. Initial e selectat raspunsul cu fc-ul maxim, iar in TextArea se gaseste demonstratia pentru acesta.
  20. Sistem expert care identifica tehnica de prim ajutor ce trebuie folosita (minim 20 solutii).

    Cerinte individuale program prolog

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        {
        Nr_reg~id (unde id este numarul regulii)
        daca(atr << valoare) (pentru atribute cu valori multiple)
        daca(atr) (pentru atribute booleene, valoare true)
        daca(\+ atr) (pentru atribute booleene, valoare false)
        concluzie(atribut_concluzie=valoare [fc nr]).
        }.
      • intrebarile vor avea formatul:
        [?]{
        %intrebare = ['continut intrebare' / (val1 ^ val2 ^ val3 ^ ....)] (val1, val2, val3 sunt optiunile pentru intrebare)
        %atribut_intrebare::=atribut
        }.
      • scopul se va defini:
        [Scop]{atr}.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      tehnica_prim_ajutor:<nume_solutie>
      descriere<...>
      pasi:
      (1)<...>
      (2)<...>
      (3)<...>
      ...

      imagine<cale_relativa_imagine>
      ********************

      Cuvantul nume_solutie va fi inlocuit cu numele tehnicii de prim ajutor. Se va mai adauga descrierea, dar si calea relativa catre imaginea corespunzatoare solutiei. Iar dupa descriere intre lt; si > se va afisa textul corespunzator descrierii. Sub descriere vor fi scrisi pasii pentru tehnica respectiva de ajutor, numerotati pornind de la 1, cu indicele corespunzator pasului pus intre paranteze.

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      La final, dupa afisarea solutiilor va aparea o intrebare: "Afiseaza detalii? (pasi/descriere/ambele/inapoi_meniu)"

      Daca se alege raspunsul "inapoi_meniu" se reine la meniul anterior.

      Daca se alege raspunsul "pasi", se vor reafisa solutiile, avand sub fiecare lista de pasi afisati, numerotati ca si in fisierul de intrare, dar de data indicele pasului nu va aparea intre paranteze ci va fi urmat de punct:

      solutie cu fc scris
      1.<...>
      2.<...>
      3.<...>

      Daca se alege raspunsul "descriere", se vor reafisa solutiile, avand sub fiecare afisata descrierea

      Daca se alege raspunsul "ambele", se vor reafisa solutiile, avand sub fiecare afisata descrierea si pasii, asa cum s-a explicat mai sus.

      Intre informatiile pentru doua solutii se va afisa o linie-separator de forma: "##########################"

      Dupa reafisarea solutiilor cu informatiile respective, se va reafisa si meniul principal, asteptandu-se o noua comanda.

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de solutiile posibile. Urmatoarele linii vor corespunde de asemenea fiecarei solutii (fiecarei tehnici de prim ajutor). Astfel, pe fiecare astfel de linie, pe prima coloana avem tehnica de prim ajutor, iar pe urmatoarele coloane fie x daca au aparut vreodata impreuna in acelasi set de solutii date de sistemul expert, fie "-", daca nu.

      Pe diagonala veti avea doar simbolul "*" fiind vorba de asocierea solutiilor identice.

      Realizarea acestei matrici va necesita un fisier in care sa fie memorate datele din rularile vechi. Acest fisier va purta numele matr_temp.txt si se va afla in folderul de output al sistemului expert.

      Tot in acest fisier, pe primul rand al acestuia se va afisa data ultimei rulari, impreuna cu numarul de rulari de pana acum.

      Observatie: O astfel de matrice este utila pentru a vedea care solutii se aseamana intre ele. Cu ajutoul acestei matrci se pot detecta si bugurile din fisierul de reguli in cazul in care observam ca doua solutii care nu ar trebui sa aiba nimic in comun au aparut totusi impreunaintr-un set de solutii.

    4. Unele reguli vor fi scrise cu ajutorul operatorului "sau". In cadrul regulilor din fisierul de intrare sau va avea prioritate mai mare decat operatorul pentru "si" (adica invers fata de cum e in Prolog). Forma lor este:
      {
      Nr_reg~id (unde id este numarul regulii)
      daca(...)
      daca(...) sau daca(...) ("sau" se va aplica doar intre aceste doua premise de pe acest rand)
      daca(...)
      concluzie(atribut_concluzie=valoare [fc nr]).
      }.
      Pentru aceste reguli de fapt se vor genera reguli separate in cadrul sistemului expert. Atentie, id-urile regulilor nu vor mai fi numerice, ci vor fi considerate atomi. Iar regulile de acest gen vor avea id-uri de forma: numar concatenat cu literele a,b,c,d... De exemplu daca avem o regula cu doua cazuri de "sau", vom avea un total de 4 reguli in care avem doar si-uri. Adica, din regula (cu id-ul, de exemplu, egal cu 1):
      regula 1 daca A sau B si C si D sau E atunci Concluzie.
      se vor genera regulile:
      regula 1a daca A si C si D atunci Concluzie.
      regula 1b daca A si C si E atunci Concluzie.
      regula 1c daca B si C si D atunci Concluzie.
      regula 1d daca B si C si E atunci Concluzie.
    5. Programul Prolog va crea un director numit output_prim_ajutor (de fapt, daca exista deja, il va folosi pe acela, iar daca nu exista, il va crea - e obligatoriu de implementat acest test daca doriti sa primiti punctaj complet pe cerinta). In el se va face un fisier numit statistica_atribute.txt. In cadrul acestui fisier vor fi linii de forma:
      atribut | numar
      Numarul reprezinta numarul total de dati in care a fost pusa intrebarea pentru acest atribut (pe toate consultarile). Acest fisier va fi actualizat dupa fiecare consultare, adunand 1 la numerele corespunzatoare atributelor pentru care sistemul expert a pus intrebari. Deci, evident, numai atributele cu intrebari asociate vor aparea in acest fisier.

      Observatie: Un astfel de fisier e folosit pentru testarea relevantei atributelor in cadrul regulilor. Daca unele atribute, dupa multe consultari, au in continuare asociat numarul 0, e posibil sa existe o gresala in cadrul regulilor (acele atribute sa nu fie folosite deloc in reguli sau sa fie in niste reguli la care nu se poate ajunge dintr-o gresala de logica).

    6. La finalul unei sesiuni de folosire, se va crea in cadrul directorului output_prim_ajutor cate un fisier numit demonstratie###solutie###fc.txt pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei iar fc cu factorul de certitudine. In fiecare fisier va fi scrisa demonstratia pentru solutia respectiva. Fisierele cu demonstratiile de la o rularea anterioara vor fi sterse prin programul Prolog. Prin urmare, in folderul de output vor fi mereu doar demonstratiile pentru ultima utilizare a sistemului expert. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      {
      Nr_reg~id (unde id este numarul regulii)
      daca(atr << valoare) (pentru atribute cu valori multiple)
      daca(atr) (pentru atribute booleene, valoare true)
      daca(\+ atr) (pentru atribute booleene, valoare false)
      concluzie(atribut_concluzie=valoare [fc nr]).
      }.
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Intrebarile vor fi afisate pe rand in aceeasi fereastra. Dupa ce se raspunde la cate o intrebare, aceasta e inlocuita de urmatoarea intrebare. Pentru fiecare intrebare se va scrie indicele urmat de textul intrebarii. Indicii, pornesc de la 1 si cresc cu 1 pentru fiecare intrebare pusa. Sub intrebare se vor afisa optiunile. Pentru optiuni, indiferent de tipul de intrebare, veti folosi butoane. Pentru factorul de certitudine al raspunsului, vor exista 10 radiobuttons cu valori de la 10 la 100. Initial e selectata valoarea 100. In coltul din dreapta-jos al ferestrei, va exista o imagine micuta (stil icon) cu o sageata orientata spre dreapta. La click pe aceasta imagine se transmite raspunsul utilizatorului spre programul Prolog si se trece la urmatoarea intrebare.
    3. La apasarea simbolului "?" (Shift+/) se va deschide un Dialog(JOptionPane) care va afisa un Jlist cu numerele de la 1 la indicele intrebarii anterioare. La selectarea unei optiuni, Sub Jlist va fi afisata intrebarea si raspunsul dat de utilizator (folosind de exemplu un JLabel sau JTextArea). Fereastra de Dialog va avea si un buton de OK care o va inchide.
    4. Dupa ce se raspunde si la ultima intrebare si sistemul expert calculeaza solutiile, le va afisa cu ajutorul unor JLabel-uri avand drept text numele solutie si in paranteza factorul de certitudine (de exemplu: berbec(fc:60)). In dreptul fiecarei solutii vor exista doua butoane. Pe primul buton va scrie "info" si la click pe el va deschide un Jframe cu descrierea solutiei. Al doilea buton va avea textul "demonstratie" si va deschide in notepad demonstratia pentru raspunsul respectiv.
    5. Fiecare JLabel-solutie va contine si o imagine corespunzatoare, insa mica, aproape de dimensiunea textului. La click pe imagine se va deschide o fereastra(JFrame) continand imaginea marita.
  21. Sistem expert care identifica tipul de roman citit in functie de caracteristicile romanului (minim 20 solutii).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        r->id (unde id este numarul regulii)
        atr_concluzie->valoare fc -> nr (concluzia; nr este factorul de certitudine)
        premise -> ( (premisele intre paranteze, atributele separate cu +)
             atr ?=? valoare + (pentru atribute cu valori multiple)
             atr +(pentru atribute booleene, valoare true)
             nu atr (pentru atribute booleene, valoare false)
        )
        .
      • intrebarile vor avea formatul:
        interog -> atribut
        text_interog -> 'continut intrebare'
        list_optiuni -> (
        -> val1
        -> val2
        -> val3
        ).
      • scopul se va defini:
        scop -> atr.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. Acestea vor fi scrise cu ajutorul unor inregistrari de felul:

      #######nume_solutie
      # despre: text_descriere #
      # imagine: cale_relativa_imagine #
      # teme: tema_1 & tema_2, ...., tema_n}

      Fiecare camp in italic din sablonul de mai sus, va fi inlocuit cu informatia corespunzatoare. Acolo unde sunt mai multe cuvinte veti pune textul intre ghilimele.

      Aceste date vor fi citite din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      La finalul consultarii, solutiile se vor afisa initial fara descrieri (doar numele si factorul de certitudine).

      Sub afisarea solutiilor se va afisa urmatorul submeniu:

      Alegeti una din urmatoarele optiuni:
      1) Afisare detaliata
      2) Afisare teme
      3) Afisare alfabetica
      4) Iesire

      Daca se alege optiunea 1, se vor afisa din nou solutiile, insa cu descrieri.

      Daca se alege optiunea 2, se vor afisa din nou solutiile, insa cu tot cu teme in felul urmator:

      nume_solutie(fc: nr_fc)
      Teme:
      * tema_1
      * tema_2
      ...
      * tema_n
      -----------------------------------

      Linia formata din caractere "-" are rol de separator intre doua solutii (se va afisa si dupa ultima solutie)

      Daca se alege optiunea 3, se vor afisa din nou solutiile cu aceleasi informatii ca si in afisarea standard, insa vor fi ordonate alfabetic.

      Oricare din optiunile 1-3 duce la reafisarea solutiilor iar apoi la reafisarea submeniului

      Optiunea 4 revine la meniul principal.

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru toate solutiile existente, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele tuturor solutiilor. Urmatoarele linii vor corespunde, pe rand, fiecarei teme (ordinea in care apar temele ca linii in matrice nu e relevanta). Prin urmare, pe fiecare astfel de linie, pe prima coloana avem tema, iar pe urmatoarele coloane un numar corespunzator numarului de ordine al temei in lista de teme a solutiei corespunzatoare coloanei. In cazul in care tema nu tine de acea solutie, se pune un caracter -.

      In meniul secundar, va aparea o optiune in plus numita tabel_teme. La alegerea acestei optiuni se va afisa matricea creata pentru solutii, formatata frumos astfel incat dimensiunea unei coloane sa fie egala cu dimensiunea celui mai lung element de pe acea coloana.

      Temele din matrice reprezinta reuniunea temelor pentru pentru toate solutiile oferite atunci de sistemul expert, deci nu vor fi toate temele posibile din fisierul de descrieri ci doar subsetul pentru solutii.

    4. Se va implementa o functionalitate de salvare a raspunsurilor date de utilizator.

      In meniul principal se va adauga o optiune noua "salv_raspusnuri(nu)". Daca se da comanda salv_raspunsuri, cand se reafizeaza meniul daca in paarnteza scria "nu" acum va scrie "da", daca scria inainte "da" va fi afisat "nu". Daca se porneste consultarea sistemului expert avanta setata salvarea raspunsurilor la valoarea "nu", atunci nu se salveaza nimic din ce a introdus utilizatorul de la tastatura. Daca insa in paranteza scrie "da" atunci se creeaza un fisier in folderul de output numit raspunsuri_timestamp.txt (unde timestamp e inlocuit cu valoarea calculata de predicatul now). In acest fisier, pentru fiecare raspuns dat de utilizator se va scrie pe un rand nou o inregistrare de forma:

      atribut :: valoare ;
      Unde cuvantul atribut va fi inlocuit cu numele atributului corespunzator intrebarii la care s-a raspuns, iar valoare va fi chiar raspunsul dat.

    5. Programul va folosi un director numit output_romane (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In acest folder va exista un fisier log.txt in care se va afisa numai pentru ultima consultare (deci fisierul este suprascris la fiecare consultare) un fel de log al luarii deciziilor de catre sistemul expert, in felul urmator:
      • Cand va testa o regula, va scrie pe ecran: "Evaluez regula N." si va afisa regula (afisarea regulii se va face in acelasi format ca si in fisierul de demonstratii). Numarul N reprezinta id-ul regulii.
      • Cand va obtine valoarea unui atribut va scrie: fie
        • "am obtinut valoarea Val, pentru atributul Atr de la utilizator", daca a obtinut valoarea in urma unei intrebari la care a raspuns utilizatorul
        • "am obtinut valoarea Val, pentru atributul Atr din regula N", daca a obtinut valoarea aplicand regula cu id-ul N
        • "am obtinut valoarea Val, pentru atributul Atr din faptele deja stiute", daca a obtinut valoarea din faptele deja memorate in baza de cunostinte (vezi predicatul dinamic fapt)
        In propozitiile de mai sus, se vor inlocui Atr cu numele atributului, Val cu valoarea gasita si N cu id-ul regulii.
    6. In folderul de output se va crea un folder demonstratii. Continutul acestuia va fi reinnoit (sters si inlocuit) la fiecare noua consultare a sistemului expert. Veti crea cate un fisier numit demonstratii_romane(solutie-fc).txt pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei, iar fc cu factorul de certitudine. Fisierul va contine, evident, demonstratia pentru acea solutie.

      In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      r->id (unde id este numarul regulii)
      atr_concluzie->valoare fc -> nr (concluzia; nr este factorul de certitudine)
      premise -> ( (premisele intre paranteze, atributele separate cu +)
           atr ?=? valoare + (pentru atribute cu valori multiple)
           atr +(pentru atribute booleene, valoare true)
           nu atr (pentru atribute booleene, valoare false)
      )
      .
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Intrebarile vor fi afisate in interiorul unui jPane cu border vizibil (de exemplu de culoare verde) si background alb (sau oricum background diferit de restul JFrame-ului. Pentru optiuni, indiferent de tipul de intrebare, veti folosi radiobuttons. Initial e selectata optiunea din mijloc (cu indicele=[nr_optiuni/2]]). Pentru factorul de certitudine veti folosi un JComboBox cu optiuni intre 0 si 100 cu valori care cresc din 10 in 10. Initial e selectat 100. Trecerea la urmatoarea intrebare se explica in subpunctul urmator
    3. Intr-un JToolBar vor exista doua imagini, cu o sagetica spre stanga si una spre dreapta. La click pe sagetica spre dreapta, daca suntem la intrebarea curenta, se considera raspunsul dat, si se genereaza noua intrebare. La click pe sagetica spre stanga, se afiseaza intrebarea anterioara celei afisate, dar cu radiobutton-urile si JComboBox-ul disabled (nu mai putem raspunde la o intrebare veche).
    4. Dupa ce s-a raspuns si la ultima intrebare data de sistemul expert, se deschide un JFrame nou, cu mai multe taburi, care va afisa raspunsurile. Titlurile taburilor vor fi chiar valorile multiple gasite ca raspuns.
    5. In interiorul fiecarui tab va mai fi scrisa o data solutia (intr-un JLabel), cu factorul de certitudine, folosind litere de dimensiune mai mare decat in rest (de exemplu in rest erau litere de 10px, aici puneti de 20), ca sa arate ca un titlu. In acel tab va mai exista si o poza reprezentativa a solutiei gasite, si un JTextArea care va contine demonstratia pentru raspunsul respectiv.
  22. Sistem expert care identifica cel mai potrivit loc de camping (minim 20 solutii).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        r=id
        (
            atr <-> valoare (pentru atribute cu valori multiple)
            atr(true) (pentru atribute booleene, valoare true)
            atr(false) (pentru atribute booleene, valoare false)
        )
        ->
            atr <-> valoare fc <-> nrconcluzia avand nr drept factor certitudine
      • intrebarile vor avea formatul:
        >>atribut
        val <-> (val1 | val2 | val3 ...)
        text_intrebare <-> 'continut intrebare'
      • scopul se va defini:
        scop <-> atr.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      (loc_camping | nume_solutie)
      (descriere | ... )
      (facilitati | iarba verde, loc parcare, chioscuri)
      am dat cateva exemple de facilitati (imagine | cale_relativa_imagine)

      ||||||||||||||||||||

      Informatiile pentru fiecare solutie vor fi separate de urmatoarea solutie printr-o linie de forma "||||||||||||||||||||".

      Cuvantul nume_solutie va fi inlocuit cu locul de camping.

      Va fi scrisa si o scurta descriere.

      Se vor enumera si cateva facilitati (chiar daca apar deja in atributele din reguli) pentru a ajuta utilizatorul sa faca o alegere informata.

      Se va mai adauga si calea relativa catre imaginea corespunzatoare solutiei.

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      Solutiile vor fi afisate numerotate cu 1), 2), 3)....

      La afisarea solutiilor, sub fiecare solutie, va fi scris inceputul descrierii (doar primele 20 de caractere) urmat de sirul (...vezi_detalii...)". Textul corespunzator descrierii va fi precedat de ">>>" si incadrat de ghilimele. De exemplu

      loc_camping este ierbastenii_verzi fc 78
      >>>"Un loc cu multa iarb(...vezi_detalii)"

      Sub afisarea solutiilor se va afisa un nou meniu cu optiunile:

      • vezi_detalii care va primi ca parametru un nume de solutie si va afisa atat descrierea cat si facilitatile scrise cate una pe linie si precedate deun caracter #:
        loc_camping este ierbastenii_verzi fc 78
        >>>"Un loc cu multa iarba verde si frumoasa."
        Facilitati:
        #iarba verde
        #loc parcare
        #chioscuri
        Daca utilizatorul uita sa scrie parametrul-solutie, se va afisa mesajul "Mod de apelare vezi_detalii nume_solutie" si se va reafisa meniul curent (deci nu cel initial).
      • Optiunea exit care termina programul
      • Optiunea m_principal care reafiseaza meniul principal.
    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru toate solutiile existente, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele tuturor solutiilor. Urmatoarele linii vor corespunde, pe rand, fiecarei facilitati (facilitatile vor fi ordonate alfabetic, deci prima linie corespunde primei facilitati in ordinea alfabetica). Astfel, pe fiecare astfel de linie, pe prima coloana avem numele facilitatii, iar pe urmatoarele coloane da daca solutia corespunzatoare coloanei respective are facilitatea si nu daca nu.

      In meniul de dupa afisarea solutiilor va aparea o optiune tabel_facilitati. La alegerea acestei optiuni se va afisa matricea creata pentru solutii, formatata frumos astfel incat dimensiunea unei coloane sa fie egala cu dimensiunea celui mai lung element de pe acea coloana.

      Facilitatile din matrice reprezinta reuniunea caracteristicilor pentru pentru toate solutiile oferite atunci de sistemul expert, deci nu vor fi toate facilitatile posibile din fisierul de descrieri ci doar subsetul pentru solutii. Vor exista cazuri cand unele facilitati vor exista doar in descrierea unora dintre solutii, pentru altele lipsind.

    4. Programul Prolog va crea un director numit output_camping (de fapt, daca exista deja, il va folosi pe acela, iar daca nu exista, il va crea - e obligatoriu de implementat acest test daca doriti sa primiti punctaj complet pe cerinta).

      In acest folder se va mai crea un folder numit atribute (tot prin program). In folderul atribute pentru fiecare atribut (dat de utilizator) se va crea un fisier cu numele atributului (in caz ca nu exitsta deja dintr-o rulare anterioara - testul va fi facut prin program). In acest fisier cate un pe rand vor fi scrise valorile posibile pentru acel atribut si in dreptul lor numarul de dati in care au fost alese (in cadrul totalului de consultari ale ssitemului expert). Deci aceste fisiere vor fi actulizate in urma fiecarei consultari.

    5. In timpul consultarii, optiunile afisate pentru intrebari vor fi in ordinea descrescatoare a numarului de alegeri. Astfel pentru o intrebare, optiunea cea mai frecvent aleasa este prima etc.
    6. Programul, in cadrul folderului de output, la fiecare rulare va crea un folder numit dem_folder (daca exista deja, il va sterge si-l va crea din nou). In acest folder va exista un fisier numit dem.txt,in care se vor afisa demonstratiile pentru toate raspunsurile. Va fi necesar sa existe minim o secventa de raspunsuri care sa duca la solutii multiple. Fiecare demonstratie va fi precedata de un titlu de forma "Demonstratie pentru <scop> = <valoare>", inlocuind elementele dintre parantezele unghiulare cu numele scopului si valoarea pentru care este realizata demonstratia.

      In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      regula (id) (unde id este numarul regulii)
      concluzie :=: valoare, fact_cert:=:nr (concluzia; nr este factorul de certitudine)
      premise :=: ((conditiile intre acolade, atributele separate cu virgula)
           atr egal valoare ^ (pentru atribute cu valori multiple)
           atr ^ (pentru atribute booleene, valoare true)
           negat[atr] (pentru atribute booleene, valoare false)
      ). simbolul ^ e pe post de "si"
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.
  23. Sistem expert care identifica cel mai potrivit gaming PC(dintr-un set de produse existente) pentru niste specificatii date (minim 20 solutii).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        _regula/id(unde id este numarul regulii)
        _Premise:
        ___ atr === val(pentru atribute cu valori multiple)
        ___ adev(atr)(pentru atribute booleene, valoare true)
        ___ fals(atr)(pentru atribute booleene, valoare false)
        _Concuzie:
        ___ atr_concluzie === val
        ___ factor-certitudine === nr).(atr_concluzie e atributul-concluzie al regulii, val e valoarea sa, iar nr e factorul de certitudine)
      • intrebarile vor avea formatul:
        _Intreb-utiliz:
        ___ atribut_intrebare
        ___ intrebare === continut_intrebare
        _Optiuni:
        ___ val1
        ___ val2
        ___ val3
        ...
        ___ valn(val1, val2, val3 sunt optiunile pentru intrebare, si evident pot fi oricate optiuni)
      • scopul se va defini:
        _Scop : atr_scop.
    2. Se va crea inca un fisier de input in care vor fi descrise solutiile astfel:
      nume_solutie
      [*] proprietate_1 = valoare_1
      [*] proprietate_2 = valoare_2
      ...
      [*] proprietate_n = valoare_n
      >>> descriere
      ///imagine: cale_relativa_imagine
      ==========================================(linie despartitoare)
      Proprietatile vor fi specificatiile solutiei. Exemplu:
      silver_gaming_pc_ultra_performance
      culoare = negru
      [*] placa_de_baza = 'GA-B250M-DS3H'
      [*] placa_video= 'GTX 1050 Ti'
      ...
      [*] procesor = 'i3-7100'
      >>> 'cel mai avantajos gaming PC'
      ///imagine: '../imagini/beffrhbedjef.jpg'
      ==========================================(linie despartitoare)

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      Dupa ce programul afiseaza solutiile, va afisa si un submeniu cu optiunile:descrieri, sepcificatii, principal, exit.

      Pentru optiunea descrieri se reafiseaza detaliat solutiile (adica si cu descrierea sub fiecare dintre ele). Fiecare doua solutii vor fi separate printr-o linie de >-uri.

      Optiunea specificatii primeste drept argument un nume de solutie, si afiseaza specificatiile pentru acea solutie. Specificatiile vor fi afisate pe un singur rand sub forma "nume_specificatie:valoare", separate cu punct si virgula.

      Optiunea principal ne intoarce la meniu initial

      Optiunea exit termina programul

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru toate solutiile existente, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele tuturor solutiilor. Urmatoarele linii vor corespunde, pe rand, fiecarei specificatii. Astfel, pe fiecare astfel de linie, pe prima coloana avem numele specificatiei, iar pe urmatoarele coloane valoarea acesteia pentru solutia de pe coloana respectiva.

      In meniul de dupa afisarea solutiilor va aparea o optiune tabel_specificatii. La alegerea acestei optiuni se va afisa matricea creata pentru solutii, formatata frumos astfel incat dimensiunea unei coloane sa fie egala cu dimensiunea celui mai lung element de pe acea coloana.

      Specificatiile din matrice reprezinta intersectia caracteristicilor pentru pentru toate solutiile oferite atunci de sistemul expert, deci nu vor fi toate specificatiile posibile din fisierul de descrieri ci doar subsetul comun pentru solutii. Deci nu vor exista cazuri cand unele specificatii vor exista doar in descrierea unora dintre solutii, pentru altele lipsind.

    4. Programul, va verifica daca exista in directorul curent un folder numit output_pc. Daca exista, il va folosi pe acela. Daca nu exista, il va crea. In el se va grea un fisier numit atribute_reguli.txt. In acest fisier, pentru fiecare atribut care apare in premisele unei reguli, se va scrie prin program cate o line care va avea forma: nume_atribut: id1, id2, ... idn Unde nume_atribut e atributul si id-urile reprezinta id-urile regulilor in care acesta apare ca premisa.

      La fiecare incarcare noua a fiserului de reguli, fisierul atribute_reguli.txt va fi suprascris.

    5. In timpul consultarii, in loc de raspuns pentru o intrebare se poate da optiunea istoric_intrebari, care va afisa intre doua linii separator formate din #-uri toate intrebarile care s-au pus si raspunsul pentru fiecare dat de catre utilizator. Sub afisarea istoricului, se va reafisa intrebarea la care se ajunsese, asteptandu-se raspunsul utilizatorului.
    6. Programul Prolog va crea (in cazul in care nu exista) un director numit output_timestamp_demonstratii (plasat in folderul de output l proiectului), unde timestamp e valoarea calculata de predicatul now(vezi lab. biblioteci). Timestampul se va lua din momentul in care este data solutia pe ecran. La finalul unei sesiuni de folosire, se va crea in cadrul acestui director cate un fisier numit demonstratie---solutie---fc.txt pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei , iar fc cu factorul de certitudine. In fiecare fisier va fi scrisa demonstratia pentru solutia respectiva. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      _regula/id
      _Premise:
      ___ atr === val
      ___ adev(atr)
      ___ fals(atr)
      _Concuzie:
      ___ atr_concluzie === val
      ___ factor-certitudine === nr).
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Pentru intrebarile cu raspuns de tip da/nu, se vor folosi doua imagini: una cu un semn verde de bifat, iar alta cu un x rosu. La click pe semnul de bifat se va considera ca utilizatorul a raspuns "da" iar click pe x-ul rosu va insemna "nu". Pentru celelalte intrebari (cu valori cu raspuns multiplu) se vor folosi elemente de tip JComboBox (implicit selectat ultimul raspuns). Pentru factorul de certitudine veti avea un TextBox. Va exista un buton cu textul "OK" care va lua in considerare raspunsul dat si va trece la urmatoarea intrebare.
    3. Intrebarile vor fi afisate toate in aceeasi fereastra. Cand se raspunde la o intrebare, textul din labelul continand intrebarea, se va schimba, la fel si optiunile afisate. Pentru fiecare intrebare la care s-a raspuns, se va adauga in interfata grafica, cate un label cu border, al carui text va fi atributul corespunzator intrebarii. La click pe un astfel de label se va afisa un alert-box( Indicatie: JOptionPane.showMessageDialog(...) ) cu textul acelei intrebari si raspunsul dat.
    4. La final, raspunsurile se vor afisa unul sub altul cu ajutorul unor labeluri. Va exista in dreptul fiecarui label si un buton cu textul "demonstratie" care la click va deschide o fereastra noua avand un TextArea in care e scrisa demonstratia corespunzatoare.
    5. In dreapta raspunsurilor va fi un ScrolPane alb. Cand se vine cu cursorul pe un raspuns, in ScrollPane se afiseaza imaginea produsului, sub ea descrierea, apoi intr-un JTable se vor afisa si specificatiile produsului (preluate prin prolog din fisierul de descrieri)
  24. Sistem expert care identifica pentru un om decedat cauza mortii. (minim 20 solutii)

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        regula nr id (unde id este numarul regulii)
        concluzie >>> valoare, fact_cert >>> nr(concluzia; nr este factorul de certitudine)
        conditii = {
             atr ## valoare, (pentru atribute cu valori multiple)
             atr, (pentru atribute booleene, valoare true)
             nu(atr) (pentru atribute booleene, valoare false)
        }.
      • intrebarile vor avea formatul (despre proprietatea "imagine" veti avea mai multe detalii in cerintele pentru interfata grafica; insa va trebui sa schimbati programul prolog astfel incat sa memorati si calea catre imagine in predicatul interogabil):
        intrebare >>> 'continut intrebare'
        imagine >>> 'cale relativa imagine'
        atribut >>> atribut_intrebare
        optiuni >>> {
        val1 ;
        val2 ;
        val3
        }
        .
      • scopul se va defini:
        scop => atr.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      [nume_solutie]:
      #> descriere.
      #> cale_relativa_imagine
      #> cauze_posibile:
      (cauza_1)
      (cauza_2)
      ...
      (cauza_n)
      ----------

      Cuvantul nume_solutie va fi inlocuit cu numele solutiei, cuvantul descriere cu textul corespunzator descrierii, iar clae_relativa_imagine cu calea catre imaginea corespunzatoare solutiei. La final vor fi enumerate cauzele pentru acel deces (de exemplu pentru inec: neatentie, pierderea cunostintei, crima, sinucidere etc.).

      Afisarea solutiilor se va face scriind sub fiecare solutie si descrierea corespunzatoare

      Dupa ce programul afiseaza solutiile, va afisa si un submeniu cu optiunile:afis_simplu, afis_cauze, revenire.

      Pentru optiunea afis_simplu se reafiseaza solutiile fara descrieri, doar cu factorul de certitudine

      Optiunea afis_cauze va reafisa toate solutiile dar pentru fiecare scrise dedesubt cauzele posibile. Cauzele vor fi afisate cate una pe linie sub fiecare solutie.

      Optiunea revenire revine la meniul anterior

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de solutiile posibile. Urmatoarele linii vor corespunde de asemenea fiecarei solutii (fiecarei tehnici de prim ajutor). Astfel, pe fiecare astfel de linie, pe prima coloana avem tehnica de prim ajutor, iar pe urmatoarele vom avea numarul de atribute comune pentru cele doua solutii. Prin atribute comune intelegem atributele care apar in regulile din istoricul ambelor solutii (deci este vorba de atributele de care solutiile depind in mod direct; nu si de atribute aflate la o adancime mai mare in arborele regulilor)

      Pe diagonala veti avea doar simbolul "=" fiind vorba de asocierea solutiilor identice.

      In meniul secundar se va adauga si optiunea afis_matr care va afisa aceasta matrice.

      Se va realiza o afisare formatata frumoasa a matricii, cu coloanele avand drept dimensiune numarul maxim de caracatere al cuvintelor de pe acea coloana.

    4. Programul, va verifica daca exista in directorul curent un folder numit output_cauza_deces. Daca exista, il va folosi pe acela. Daca nu exista, il va crea. In acest folder se va crea un fisier numit raport.txt. Acest fisier va fi updatat la fiecare consultare. Primul rand va contine numarul total de consultari. Sub el toate solutiile posibile, avand in paranteza numarul de dati in care acestea au fost date ca solutie. Solutiile vor fi ordonate descrescator in functie de numarul din paranteza. 15
      solutie_7 (10)
      solutie_3 (8)
      solutie_4 (5)
      solutie_9 (5)
      solutie_8 (4)
      ... solutie_2 (0)
    5. In timpul consultarii, atunci cand se asteapta raspuns la o intrebare, se accepta si optiunea r. Cand programul primeste aceasta optiune, alege un raspuns random dintre cele posibile, il afiseaza pe ecran si il proceseaza ca raspuns dat de utilizator.
    6. Programul va folosi un director numit demonstratii (daca exista, il va folosi pe acela, iar daca nu exista, il va crea), care se va afla in folderul de output. In acest folder se va crea cate un fisier numit dem_timestamp_(solutie)(fc).txt pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei, fc cu factorul de certitudine, iar timestamp va fi calculat cu ajutorul predicatului now(). Fisierul va contine, evident, demonstratia pentru acea solutie. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      regula nr. id (unde id este numarul regulii)
      concluzie >>> valoare, fact_cert >>> nr(concluzia; nr este factorul de certitudine)
      conditii = {
           atr ## valoare, (pentru atribute cu valori multiple)
           atr, (pentru atribute booleene, valoare true)
           nu(atr) (pentru atribute booleene, valoare false)
      }.
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Intrebarile se afiseaza cu ajutorul unui SplitPane cu despartitor vertical. In dreptul fiecarei intrebari va fi un icon (adica imagine mica aproximativ de dimensiunea textului) reprezentativ pentru acea intrebare (de exemplu un icon cu un cutit daca intrebarea e de genul "Sunt urme de injunghiere?", sau un icon cu o explozie pentru o intrebare de genul "Exista urme de explozie?"). In partea din stanga avem intrebarea si optiunile. Pentru optiuni se va folosi un JList. Pentru factorul de certitudine se va folosi un JSlider cu valori de la 0 la 100, initial setat pe valoarea 100. Trecerea la urmatoarea intrebare se va face cu ajutorul unui buton cu textul "am raspuns".
    3. In partea din dreapta SplitPane-ului va fi un ScrollPane. pe masura ce se raspunde la cate o intrebare se adauga iconul intrebarii (inconjurat de un border) in ScrollPane. La click pe un Icon, sub lista de iconuri se va afisa un JLabel cu atributul intrebarii corespunzatoare iconului si un JTextArea cu textul intrebarii la care s-a raspuns, si pe un rand nou, tot in JTextArea, raspunsul utilizatorului .
    4. Dupa ce s-a raspuns si la ultima intrebare data de sistemul expert, in partea din stanga a SplitPane-ului se vor afisa solutiile, impreuna cu factorul de certitudine una sub alta cu ajutorul unor radiobuttons. Sub optiuni va fi un JTextArea gol. In partea din dreapta a SplitPane-ului va fi un alt JTextArea gol (iconurile si JTextArea-ul de dinainte sunt sterse).
    5. Cand se face click pe o optiune din lista de radiobuttons, in text area-ul de jos apare descrierea pentru acea solutie (incarcata prin prolog), iar in partea din dreapta a SplitPane-ului, se va afisa imaginea corespunzatoare, iar dedesubt demonstratia pentru raspunsul respectiv.
  25. Sistem expert pentru un magazin, in vederea alegerii celui mai potrivit tip de tableta pentru cerintele unui client. (minim 20 solutii)

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        r{id} (unde id este numarul regulii)
        concluzie{valoare} fact_cert {nr} (concluzia; nr este factorul de certitudine)
        premise {(conditiile intre acolade, atributele separate cu and)
             atr ## valoare and (pentru atribute cu valori multiple)
             atr and(pentru atribute booleene, valoare true)
             !!atr (pentru atribute booleene, valoare false)
        }
        .
      • intrebarile vor avea formatul:
        intreb {atribut}
        text_intreb {'continut intrebare'}
        lista_de_optiuni {
        # val1
        # val2
        # val3
        }.
      • scopul se va defini:
        scop {atr}.
  26. Sistem expert care sa identifice cel mai bun concert in functie de preferintele utilizatorului.(minim 20 solutii).

    Observatie:concertele trebuie sa aiba diferite tipuri de muzica (populara, pop, dance, rock etc.) si sa depinda si de locatie. Vezi site-ul http://metropotam.ro/evenimente/Concerte/ pentru solutii.

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        Id-regula ?# id(unde id este numarul regulii)
        Premise#(
        atr ?# val //(pentru atribute cu valori multiple)
        atr //(pentru atribute booleene, valoare true)
        ^atr)(pentru atribute booleene, valoare false)
        Concuzie#(atr_concluzie ?# val | factor-certitudine ?# nr) .(atr_concluzie e atributul-concluzie al regulii, val e valoarea sa, iar nr e factorul de certitudine)
      • intrebarile vor avea formatul:
        Intreb-utiliz#(
        atribut_intrebare,
        continut_intrebare,
        val1 /\ val2 /\ val3 /\ ...).(val1, val2, val3 sunt optiunile pentru intrebare, si evident pot fi oricate optiuni)
      • scopul se va defini:
        scop ?# atr_scop.
  27. Cel mai potrivit tip de bec pentru o anumita situatie (minim 20 solutii).

    Cerinte individuale prolog:

    1. Parsare:
      • Regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        reg: id (id-ul este identificatorul (numarul) regulii)
        premise = {(arata inceperea enumerarii premiselor)
            atr(valoare) (pentru atribute cu valori multiple)
            atr(A)(pentru atribute booleene, valoare true)
            atr(F)(pentru atribute booleene, valoare false)
        }
        =>
            atr(valoare), fc(nr) .(concluzia, definita prin atributul atr cu valoarea dintre paranteze)
      • intrebarile vor avea formatul:
        q(atribut)
        Optiuni={val1, val2, val3 ...}
        intrebare='continut intrebare' .
      • scopul se va defini in fisier:
        scop(atr) .
  28. Cea mai potrivita companie de zbor (minim 20 solutii).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        rg//id (unde id este numarul regulii)
        concluzie(valoare) cu fact_cert//nr (concluzia; nr este factorul de certitudine)
        daca -> (conditiile; premisele incep cu un +)
             + atr =? valoare (pentru atribute cu valori multiple)
             + atr (pentru atribute booleene, valoare true)
             + nu(atr) (pentru atribute booleene, valoare false)
        .
      • intrebarile vor avea formatul:
        intreb//atribut
        text('continut intrebare')
        optiuni ->
        ? val1
        ? val2
        ? val3
        .
      • scopul se va defini:
        scop//atr
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      {
      companie_zbor##nume_solutie##
      imagine##cale_relativa_imagine##
      descriere##cale_relativa_imagine##
      zboruri:
      ora1[oras_plecare1,oras_sosire1]
      ora2[oras_plecare2,oras_sosire2]
      ....

      }

      Cuvantul nume_solutie va fi inlocuit cu numele companiei de zbor. Se va mai adauga descrierea, dar si calea relativa catre imaginea corespunzatoare solutiei. Dupa linia "zboruri:" vor fi scrise zborurile pentru compania respectiva, in formatul ora[oras]; de exemplu 09:00[Paris].

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      In cazul in care sistemul expert a fost deja consultat si au fost calculate solutiile (se va testa prin program acest aspect), se vor afisa niste optiuni noi in meniul principal (nu se afiseaza daca solutiile nu sunt deja calculate):

      • Optiunea afiseaza_descriere. Aceasta trebuie apelata cu un parametru: numele solutiei. Va afisa descrierea pentru acea solutie, revenind apoi la meniul principal. In cazul in care nu se da parametru, se va afisa mesajul "Solutie=?" si pe linia urmatoare promptul "|:" si se va astepta de la utilizator introducerea numelui solutiei.
      • Optiunea afiseaza_zboruri cu comportament similar cu cel al optiunii afiseaza_descriere. Si aceasta trebuie apelata cu un parametru: numele solutiei. Va afisa zborurile, cate unul pe linie, pentru acea solutie, revenind apoi la meniul principal. In cazul in care nu se da parametru, se va afisa mesajul "Solutie=?" si pe linia urmatoare promptul "|:" si se va astepta de la utilizator introducerea numelui solutiei.
    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru o lista de companii de zbor, si un oras, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele companiilor. Urmatoarele linii vor corespunde fiecarui ore de la 00:00 la 23:00. Astfel, pe fiecare astfel de linie, pe prima coloana avem ora, iar pe urmatoarele coloane un x daca pentru orasul dat si compania de pe coloana avem un zbor la acea ora (pentru cazul in care ora unui zbor e hh:mm cu mm diferit de zero, consideram ora zborului ca fiind hh:00).

      In meniu, in cazul in care sistemul expert a fost deja consultat si au fost calculate solutiile (se va testa prin program acest aspect), se va afisa inca o optiune, afis_orar, care primeste si un parametru nume_de_oras (daca nu primeste parametrul, se va afisa mesajul "Solutie=?" si pe linia urmatoare promptul "|:" si se va astepta de la utilizator introducerea numelui solutiei). Daca optiunea e aleasa, va afisa matricea creata la acest subpunct pentru orasul dat si solutiile obtinute de sistemul expert, pentru ca utilizatorul sa poata face o alegere mai informata. Se va realiza o afisare formatata frumoasa a matricii, cu coloanele avand drept dimensiune cel putin numarul maxim de caracatere al cuvintelor de pe acea coloana.

    4. Prima intrebare a sistemului expert va fi "In ce localitate doriti sa mergeti?". Aceasta intrebare va fi tratata special. Nu va fi preluata din fisierul de reguli si intrebari incarcat si nici nu va fi memorata in predicatul dinamic interogabil deoarece nu are un atribut asociat. Optiunile ei vor fi generate automat din descrierea companiilor. Optiunile vor cuprinde toate orasele precizate pentru toate companiile de zbor (reuniunea multimilor oraselor pentru fiecare companie). In plus va avea si optiunea nespecificat (optiunile nu_stiu si nu_conteaza din cerintele generale nu vor fi afisate pentru aceasta intrebare). In cazul in care utilizatorul alege optiunea nespecificat sistemul expert se comporta normal, verificand toate regulile cu concluzie atribut-scop. Daca utilizatorul da ca raspuns un anume oras, se va calcula multimea companiilor de zbor care au zboruri spre acel oras si se va modifica programul astfel incat din start sa nu fie verificate reguli cu concluzie-scop referitoare la companii de zbor care nu au drept destinatie acel oras.
    5. Programul va folosi un director numit output_zboruri (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In acest folder, a fiecare consultare se va crea un fisier ajustari_fc.txt care va afisa pentru fiecare cunostina a sistemului expert de tip (atribut, valoare) un rand de forma:
      atribut=valoare (fc)->(fc_nou)->(fc_nou2)....
      Atributele vor fi afisate in ordine alfabetica, cate unul pe linie. Se vor inlocui cuvintele atribut si valoare cu numele atributului si valoarea sa. Primul fc va fi inlocuit in rand cu fc-ul calculat initial pentru perechea (atribut, valoare). Apoi, pentru fiecare modificare realizata asupra factorului de certitudine (prin predicatul ajustare din program)se va afisa pe randul atributului un sir de forma "->fc_nou" cu factorul de certitudine nou, rezultat in urma ajustarii.

      Fisierul ajustari_fc.txt va fi suprascris la fiecare noua rulare.

      Trebuie sa aveti minim un exemplu de raspunsuri care duc la o solutie pentru care se a afisa un atribut cu cel putin 3 ajustari.

    6. In folderul de output, veti crea cate un fisier numit demonstratie_solutie@fc_zbor.txt pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei, iar fc cu factorul de certitudine. Fisierul va contine, evident, demonstratia pentru acea solutie. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      rg//id (unde id este numarul regulii)
      concluzie(valoare) cu fact_cert//nr (concluzia; nr este factorul de certitudine)
      daca -> (conditiile intre acolade, atributele separate cu virgula)
           + atr =? valoare (pentru atribute cu valori multiple)
           + atr (pentru atribute booleene, valoare true)
           + nu(atr) (pentru atribute booleene, valoare false)
      .
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Intrebarile se afiseaza in interiorul unui jPane. In dreptul fiecarei intrebari va fi o imagine aleatoare a unei masini de curse (veti avea minim 5 imagini cu masini). Pentru optiuni se vor folosi jLabeluri cu border (alegeti voi culoarea borderului). Cand se vine cu cursorul pe JLabel acesta isi schimba backgroundul in alb. Cand se muta cursorul revine la backgroundul initial. La click pe un JLabel acesta devine optiunea selectata. JLabelul selectat va avea background-ul galben si un icon (va fi o imagine mica de dimensiunea textului) cu o masinuta de curse va aparea in dreptul Labelului respectiv. Pentru factorul de certitudine veti folosi un JComboBox cu optiuni intre 0 si 100 cu valori care cresc din 5 in 5. Initial e selectat 100. Trecerea la urmatoarea intrebare se va face cu ajutorul unui buton cu textul "catre urmatoarea intrebare".
    3. Pe pagina va mai fi si un JComboBox, pentru istoricul intrebarilor care va avea ca optiuni atributele corespunzatoare intrebarilor la care s-a raspuns deja. La selectarea unei optiuni, cu ajutorul unui JOptionPane.showMessageDialog veti arata intr-un dialog(alert), textul intrebarii si raspunsul utilizatorului.
    4. Dupa ce s-a raspuns si la ultima intrebare data de sistemul expert, se vor afisa solutiile, impreuna cu factorul de certitudine una sub alta cu ajutorul unor JToogleButtons. Initial niciun JToogleButton nu e activat.
    5. La activarea (click) jToogleButton-ului se va afisa imaginea corespunzatoare solutiei si un JTextArea imediat sub el (deci intre butoane, daca imediat sub acest buton mai era un altul cu o alta solutie), care va contine demonstratia pentru raspunsul respectiv (e practic vorba de continutul fisierului demonstratie_solutie@fc_ceai.txt). La dezactivarea butonului JTextArea-ul respectiv dispare.
  29. Sistem expert care identifica pentru un client cel mai potrivit tip de monitor. (minim 20 solutii).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        (regula)
        (#id (unde id este numarul regulii)
        #atribut_concluzie <= (valoare) #f_cert <= (nr) (concluzia; nr este factorul de certitudine)
        #multime_conditii <= ( (conditiile intre paranteze, premisele precedate de #)
             #atr <= (valoare) (pentru atribute cu valori multiple)
             #atr(pentru atribute booleene, valoare true)
             #not(atr) (pentru atribute booleene, valoare false)
        )).
      • intrebarile vor avea formatul:
        (intrebare)
        atribut <= (
        #text_intreb <= ('continut intrebare')
        #variante_enumerate <= [val1, val2, val3] (pot fi oricate variante, nu doar 3)
        ).
      • scopul se va defini:
        scop <= (atr_concluzie).
  30. Aveti un joc in care, cu masina timpului va deplasati intr-un razboi aleator. Trebuie sa gasiti cel mai potrivit tip de tanc pentru contextul in care va aflati. (minim 20 solutii).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        regula=::{
            (nr)id(#nr) (unde id este numarul regulii) ;
            (concluzie)atribut_concluzie=::valoare / fc =:: nr(#concluzie) ; (concluzia; nr este factorul de certitudine)
            premise =:: { (premisele intre acolade, precedate de pre:)
                 pre: atr =:: valoare (pentru atribute cu valori multiple)
                 pre: atr(pentru atribute booleene, valoare true)
                 pre: not atr (pentru atribute booleene, valoare false)
            }
        }.
      • intrebarile vor avea formatul:
        intrebare =:: {
        (atribut_intreb)atribut(#atribut_intreb)
        (text_intreb)'continut intrebare'(#text_intreb)
        optiuni =:: {
            val1
            val2
            val3
            }(pot fi oricate variante, nu doar 3)
        }.
      • scopul se va defini:
        scop_st_exp =:: atr_concluzie.
  31. Sistem expert care identifica cel mai potrivit oras asiatic de vizitat in functie de cerintele utilizatorului. (minim 20 solutii).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        regula%%id (unde id este numarul regulii)
        concluzie ~ atribut=valoare (fact_cert:nr)(concluzia; nr este factorul de certitudine)
        conditii ~ {
             (atr == valoare), (pentru atribute cu valori multiple)
             (atr), (pentru atribute booleene, valoare true)
             (nu!atr) (pentru atribute booleene, valoare false)
        }.
      • intrebarile vor avea formatul:
        [
        intrebare %%'continut intrebare'
        atribut ~ atribut_intrebare
        optiuni ~ {val1 # val2 # val3 }
        ]
        .
      • scopul se va defini:
        scop => atr.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      (nume_solutie)
      (descriere)
      (de_vizitat){loc1, loc2,....}
      \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

      Cuvantul nume_solutie va fi inlocuit cu identificatorul solutiei. Cuvantul descriere va fi inlocuit cu textul efectiv al descrierii (descrierea va fi toata pe un rand - in sensul ca nu va exista vreun '\n' in interiorul ei. De asemenea, va fi pusa intre apostrofuri.). Atentie, descrierea trebuie sa cuprinda 1-2 fraze.

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      Cand se afiseaza solutiile, sub ele se afiseaza automat si descrierea si pretul. Exemplu de afisare:

      nume_solutie (fc:nr_fc)
      Puteti vizita:
      * loc1
      * loc2
      ...
      Descriere: text_efectiv_descriere.
      #################################### (un separator intre 2 solutii)
      Cuvintele din sablon scrise in italic vor fi inlocuite cu valorile corespunzatoare: nume_solutie cu valoarea efectiva a solutiei, nr_fc cu valoarea factorului de certitudine, loc1, loc2,...locn locurile de vizitat, text_efectiv_descriere cu descrierea asociata solutiei.
    3. Se va crea un predicat care genereaza o matrice in felul urmator. Matricea va avea doua coloane. Pe prima linie avem headerele de coloane denumite: "Oras", "NrLocuri". Pentru toate atributele folosite in premisele regulilor, se vor genera linii in matrice, de forma: nume_atribut, impreuna cu tipul sau. Tipul poate sa fie "boolean" sau "val multiple".

      In meniul principal se va adauga si optiunea afiseaza_orase care va scrie matricea generara cu acest predicat pentru toate solutiile posibile.

      Afisarea matricii trebuie sa fie una frumoasa in care coloanele au lungimi egale. Se vor desparti elementele de pe cele doua coloane prin doua simboluri pipe '||'.

    4. Programul va folosi un director numit output_orase (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). Se va salva intr-un fisier de output, numit output.txt, fiecare consultare a sistemului expert. Numele fisierului va fi consultare_an_luna_zi_ora_minut_secunda, unde ora efectiva este cea in care s-a afisat rezulatul final pe ecran. Afisarea in fisier a consulatrii va fi de forma:
      Intrebare
      Optiune aleasa este opt_ales din optiunile posibile: opt1 opt2....
      Se va inlocui cuvantul Intrebare cu textul intrebarii, cuvantul opt_ales cu raspunsul dat de utilizator, si op1, opt2,... cu optiunile pentru intrebare.
    5. Se va afisa la final, odata cu solutiile, care este timpul mediu in care s-a raspuns la o intrebare (calculat in Prolog)
    6. In folderul de output se va crea cate un fisier numit dem_nr5timestamp_resttimestamp_(solutie)[fc].txt, pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei, fc cu factorul de certitudine, nr5timestamp cu primele 5 cifre ale timestampului, calculat cu ajutorul predicatului now(), iar resttimestamp cu restul cifrelor timestampului. Fisierul va contine, evident, demonstratia pentru acea solutie.

      In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      regula%%id (unde id este numarul regulii)
      concluzie ~ atribut=valoare (fact_cert:nr)(concluzia; nr este factorul de certitudine)
      conditii ~ {
           (atr == valoare), (pentru atribute cu valori multiple)
           (atr), (pentru atribute booleene, valoare true)
           (nu!atr) (pentru atribute booleene, valoare false)
      }.
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Intrebarile se afiseaza cu ajutorul unui SplitPane cu despartitor vertical. In partea din stanga avem intrebarea si optiunile. Pentru optiuni se va folosi un JComboBox. Pentru factorul de certitudine se va folosi un JSpinner cu valori de la 0 la 100, crescand din 10 in 10, initial setat pe valoarea 100. Trecerea la urmatoarea intrebare se va face cu ajutorul unui buton cu o imagine de router pe el si cu textul "mai departe".
    3. In partea din dreapta SplitPane-ului va fi un JTextArea. Pe masura ce se raspunde la cate o intrebare se adauga in JTextArea un rand cu textul intrebarii la care tocmai s-a raspuns,un rand cu o pereche de forma atribut=valoare unde atributul e cel corespunzator intrebarii si valoarea e raspunsul utilizatorului si un rand cu o linie despartitoare de forma "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" .
    4. Dupa ce s-a raspuns si la ultima intrebare data de sistemul expert, va disparea SplitPane-ul si se vor afisa solutiile, impreuna cu factorul de certitudine una sub alta cu ajutorul unor butoane. .
    5. Cand se face click pe un buton, se deschide un JInternalFrame in care se va va afisa o imagine corespunzatoare solutiei dar si demonstratia (folosind un ScrollPane avand in interior un JLabel), pentru raspunsul respectiv.
  32. Cel mai potrivit costum de Halloween in funcție de caracteristicile utilizatorului (varsta, statura, personalitate, tip de petrecere la care se duce). (minim 20 solutii).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        {{
            atribut_concluzie = valoare [fact_cert = nr] ; (concluzia; nr este factorul de certitudine)
            premise = [ (premisele intre paranteze drepte, precedate de +)
                 + atr[valoare] (pentru atribute cu valori multiple)
                 + atr[true](pentru atribute booleene, valoare true)
                 + atr[false] (pentru atribute booleene, valoare false)
            ]
        }}(regula:id).(unde id este numarul regulii) ;
      • intrebarile vor avea formatul:
        {{
            text_afisat = 'continut intrebare'
        valori_posibile = [
             + val1
             + val2
             + val3
            ](pot fi oricate variante, nu doar 3)
        })(intrebare:atribut).(unde atribut e atributul corespunzator intrebarii)
      • scopul se va defini:
        {{atr_concluzie}}(scop).
  33. Sistem expert (pentru un pet shop) care stabileste care este cel mai potrivit animal pentru cineva care doreste sa achizitioneze unul. (minim 20 solutii).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        regula (id) (unde id este numarul regulii)
        concluzie :=: valoare, fact_cert:=:nr (concluzia; nr este factorul de certitudine)
        premise :=: ((conditiile intre acolade, atributele separate cu virgula)
             atr egal valoare ^ (pentru atribute cu valori multiple)
             atr ^ (pentru atribute booleene, valoare true)
             negat[atr] (pentru atribute booleene, valoare false)
        ). simbolul ^ e pe post de "si"
      • intrebarile vor avea formatul:
        intrebare pentru atribut
        text :=: 'continut intrebare'
        optiuni :=: (
            val1 |
            val2 |
            val3
        )
        .
      • scopul se va defini:
        scop :=: atr.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      %%%%%%%%%%%%%%%%%%%%%%%
      animalut:::nume_solutie
      caracteristici:::(aveti mai jos niste exemple de proprietati)
      >tip_animal=mamifer
      >culoare='alb, gri, maro'
      >talie=medie
      ....
      imagine:::cale_relativa_imagine
      descriere::: ....

      %%%%%%%%%%%%%%%%%%%%%%%

      Informatiile pentru fiecare solutie vor fi incadrate de o linie de procente (deci intre doua descrieri vom avea doua astfel de linii).

      Cuvantul nume_solutie va fi inlocuit cu tipul de animalut.

      Se vor enumera apoi niste caracteristici ale animalutului (nu sunt redundate avand in vedere atributele din reguli deoarece acele atribute se refera mai mult la utilizator si la posibilitatile lui)

      Se vor mai adauga calea relativa catre imaginea corespunzatoare solutiei si descrierea.

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      La afisarea solutiilor, sub fiecare solutie, vor fi enumerate caracteristicile animalutului, intre paranteze rotunde si separate prin "punct si virgula", de exemplu:

      tip_animalut este catel fc 77
          (tip_animal=mamifer; culoare='alb, gri, maro'; talie=medie;...etc....)

      Sub afisarea solutiilor se va afisa un nou meniu cu optiunile:

      • Optiunea afis_descrieri va afisa solutiile cu tot cu descrieri insa fara caracteristici. Fiecare doua solutii for fi separate printr-o linie de egaluri: ====================================
      • Optiunea afis_tot va afisa solutiile cu tot cu descrieri si cu caracteristici, dar caracteristicile vor fi scrise cate una pe linie, precedate de o linioara. Fiecare doua solutii for fi separate printr-o linie de egaluri: ====================================
      • Optiunea iesire care termina programul
      • Optiunea back care reafiseaza meniul principal.
    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru tote solutiile existente, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele tuturor solutiilor. Urmatoarele linii vor corespunde, pe rand, fiecarei carcteristici. Astfel, pe fiecare astfel de linie, pe prima coloana avem numele caracteristicii, iar pe urmatoarele coloane valoarea caracteristicii pentru solutia corespunzatoare coloanei respective.

      In meniul de dupa afisarea solutiilor va aparea o optiune afis_matr. La alegerea acestei optiuni se va afisa matricea creata pentru solutii, formatata frumos astfel incat dimensiunea unei coloane sa fie egala cu dimensiunea celui mai lung element de pe acea coloana.

      Caracteristicile din matrice reprezinta reuniunea caracteristicilor pentru pentru toate solutiile oferite atunci de sistemul expert, deci nu vor fi toate caracteristicile posibile din fisierul de descrieri ci doar subsetul pentru solutii. Vor exista cazuri cand unele caracteristici vor exista doar in descrierea unaora dintre solutii, pentru altele lipsind. In cazul in care caracteristica lipseste, in matrice se afiseaza "-".

    4. Programul va folosi un director numit output_animalute (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In acest folder va exista un fisier log_animalute.txt in care se va aduga, pentru fiecare consultare, la finalul fisierului un text de forma descrisa mai departe. Mai intai se va afisa o linie despartitoare care sa diferentieze logul curent de cel anterior:"###########################". Apoi, pe primul rand de dupa linia despartitoare, se va afisa data sub forma zi/luna/an (ora:minute:secunde) AM/PM (ora va fi un numar doar inre 1-12), de exemplu: 20/04/2015 (03:45:23) PM. Iar sub data se va afisa pe cate un rand nou, pentru fiecare intrebare pusa, o pereche de forma atribut=valoare, unde atributul este cel corespunzator intrebarii, iar valoarea este cea data de utilizator. La final se vor afisa, fiecare pe cate un rand, solutiile gasite de sistemul expert impreuna cu factorii de certitudine.
    5. Variantele de raspuns se vor afisa precedate de un indice-litera mica astfel:
      text-intrebare
      a)optiune1 b)obtiune2 c)optiune3 ....
      Scrieti litera corespunzatoare optiunii dorite.
      Textul "Scrieti litera corespunzatoare optiunii dorite." se va afisa dupa afisarea optiunilor fiecarei intrebari. Literele din optiuni nu se pun in fisierul de intrare ci se asociaza prin program. Vom presupune ca nu avem mai multe optiuni decat litere in alfabet (o intrebare cu atat de multe optiuni ar fi chiar greu de preocesat), deci nu veti avea de tratat cazul de depasire a indicelui z. Raspunsul dat de utilizator va fi litera corespunzatoare optiunii si nu optiunea in sine, dar intern, in urma raspunsului, sistemul expert va memora perechea (atribut, optiune), nu (atribut, indice_optiune).
    6. In folderul de output veti crea cate un fisier numit dem_solutie_[fc]_timestamp.txt pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei, iar fc cu factorul de certitudine, iar timestampul e calculat cu ajutorul predicatului now. Fisierul va contine, evident, demonstratia pentru acea solutie. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      regula (id) (unde id este numarul regulii)
      concluzie :=: valoare, fact_cert:=:nr (concluzia; nr este factorul de certitudine)
      premise :=: ((conditiile intre acolade, atributele separate cu virgula)
           atr egal valoare ^ (pentru atribute cu valori multiple)
           atr ^ (pentru atribute booleene, valoare true)
           negat[atr] (pentru atribute booleene, valoare false)
      ). simbolul ^ e pe post de "si"
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Intrebarile se afiseaza cu ajuorul unui SplitPane. In partea stanga avem intrebarea, iar in partea dreapta optiunile. Pentru intrebarile booleene, optiunea se pune ca un singur checkbox: bifat inseamna "da" si nebifat inseamna "nu". Restul optiunilor se pun cu ajutorul unor radiobuttons (implicite bifata prima optiune). Pentru factorul de certitudine se va folosi un JLabel initial cu valoarea 100. La apasarea tastei -, valoarea din jLabel scade cu 5, iar la apasarea tastei + valoarea din JLabel creste cu 5. In interfata va fi specificat rolul tastelor + si -. In coltul din dreapta jos, va exista o imagine cu o sageata orientata spre dreapta, care, la click pe ea, va trece la urmatoarea intrebare. Trecerea la urmatoarea intrebare se va face cu ajutorul unui buton cu textul "catre urmatoarea intrebare".
    3. Sub SplitPane, pe masura ce se raspunde la cate o intrebare se adauga un buton avand ca text numele atributului corespunzator intrebarii la care tocmai s-a raspuns. La click pe buton se va deschide inca un JFrame (alta fereastra) in care va fi afisat textul intrebarii si raspunsul dat de utilizator.
    4. Dupa ce s-a raspuns si la ultima intrebare data de sistemul expert, se vor afisa solutiile, impreuna cu factorul de certitudine una sub alta cu ajutorul unor radiobuttons. Initial niciun radiobutton nu e selectat.
    5. La selectarea unui radiobutton, se va afisa imaginea corespunzatoare solutiei si sub optiuni, intr-un ScrollPane cu un JLabel se va afisa demonstratia pentru raspunsul respectiv. La selectarea altui radiobutton, se schimba imaginea si demonstratia, corespunzator noului raspuns selectat.
  34. Sistem expert care indica medicul specialist la care ar trebui sa se duca un pacient in functie de simptomele sale. (minim 20 solutii).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        #id
        pr:(premise)
            atr#valoare (pentru atribute cu valori multiple)
            yes:atr (pentru atribute booleene, valoare true)
            not:atr (pentru atribute booleene, valoare false)
        c:(concluzie)
            atr#valoare fc#nr.(concluzia)
      • intrebarile vor avea formatul:
        #i:atribut
        val: #val1 #val2 #val3 ...
        text_intrebare#'continut intrebare'.
      • scopul se va defini:
        scop#atr.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      #nume_solutie#
      + (descriere) ...
      + (policlinici/spitale)
      am dat cateva exemple de astfel de locuri - Spitalul pentru arsuri
      - Policlinica 10
      + (imagine) cale_relativa_imagine

      //////////////////////

      Informatiile pentru fiecare solutie vor fi separate de urmatoarea solutie printr-o linie de forma "//////////////////////".

      Cuvantul nume_solutie va fi inlocuit cu tipul de medic specialist.

      In fisier pe urmatoarea linie vom avea textul "+ (descriere)", dupa care, pe acelasi rand, va fi scrisa si o scurta descriere.

      Deoarece sistemul expert e facut in ideea de a indrepta pacientii spre medici specialisti, este important sa li se spuna si unde pot gasi acesti medici specialisti. Deci, se vor enumera si policlinici si spitale in care exista specializarea respectiva, pentru a ajuta utilizatorul sa faca o alegere informata. Policlinicile si spitalele vor fi cate unul pe rand si vor fi precedate de un -.

      Se va mai adauga si calea relativa catre imaginea corespunzatoare solutiei.

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      Dupa afisarea solutiilor, se va afisa o intrebare "Doresti sa vezi si descrierile? (da/nu)". Daca utilizatorul raspunde "Nu" se reafiseaza meniul initial. Daca raspunde "Da", se vor reafisa solutiile cu tot cu descrieri (separand fiecare doua solutii cu descrierile lor printr-o linie de forma ########################).

      Dupa ce s-au afisat solutiile cu descrieri, utilizatorul va primi o alta intrebare "Pentru care specializare doresti sa afli locatiile? (nume_specializare/inapoi_meniu)". Daca utilizatorul alege inapoi_meniu, se reafiseaza meniul initial. Daca da un nume de specializare, se va afisa si lista locatiilor unde poate gasi un medic specialist de acel tip. Lista locatiilor se va afisa numerotata cu 1) nume_locatie, 2) nume_locatie etc, fiecare locatie fiind cate una pe rand.

      Se vor trata cazurile cand utilizatorul da un raspuns invalid la intrebari

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de atribute posibile. Urmatoarele linii vor corespunde de asemenea fiecarui atribut. Astfel, pe fiecare astfel de linie, pe prima coloana avem atributul, iar pe urmatoarele coloane un numar Nr=Frecv/Total. Frecv indica de cate ori atributul de pe linie si atributul de pe coloana au fost impreuna pe primul nivel al arborelui de deductie a doua solutii). Practic trebuie sa vedeti care reguli sunt in istoricul solutiilor si sa faceti multimea atributelor din toate regulile. Apoi pentru fiecare 2 atribute incrementati numarul de aparatii impreuna in cadrul arborelui. Total indica de cate ori a fost rulat sistemul expert.

      Realizarea acestei matrici va necesita un fisier in care sa fie memorate datele din rularile vechi. Acest fisier va purta numele temporar_mat si se va afla in folderul de output al sistemului expert.

      Atentie, matricea contine la un moment dat doar atributele aparute pana atunci in solutiile gasite de sistemul expert. Trebuie sa realizati programul de asa natura incat datele sa se poata extinde cu noi atribute aparute in eventuale alte solutii.

      In meniul principal se va adauga o noua optiune matr_atribute care va scrie matricea intr-un fisier (mat_output.txt, pus tot in folderul de output al proiectului), in mod formatat frumos astfel incat elementele de pe coloane sa fie aliniate). De easemenea aceasta optiune va deschide in mod automat matricea in notepad

    4. Programul va folosi un director numit output_st_expert (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In acest folder va crea automat un alt folder numit raspunsuri_intrebari (daca exista deja, il va sterge si-l va crea din nou). In el va pune fisiere cu raspunsurile date la intrebari, in urma consultarilor. Pentru fiecare intrebare se va afisa textul intrebarii si raspunsul dat de utilizator. La final se vor adauga si solutiile cu factorii de certitudine calculati. Fisierele vor avea numele de forma rasp_timestamp.txt, unde timestampul e numarul calculat de now(X).
    5. Unele reguli vor avea impus pe premise un fc minim. Cu alte cuvinte testul premisei esueaza chiar daca perechea (atribut,valoare) este validata, in cazul in care factorul de certitudine calculat pentru aceasta valoare este mai mic decat limita minima impusa in regula. Acestte reguli speciale vor avea formatul:
      #id
      pr:
          atr#valoare (min_fc: nr)(de exemplu aici avem un factor de certitudine minim precizat)
          yes:atr
          not:atr
      c:(concluzie)
          atr#valoare fc#nr.
    6. Programul, la fiecare rulare, in folderul de output, va crea un fisier numit demonstratii_raspunsuri.txt (la fiecare rulare il va sterge si-l va crea din nou). Fisierul va contine demonstratia pentru fiecare raspuns in parte, gasit pentru consultarea curenta. Fiecare doua demonstratii din fisier vor fi separate printr-o linie de forma "--------------------------".

      In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      #id
      pr:(premise)
          atr#valoare (pentru atribute cu valori multiple)
          yes:atr (pentru atribute booleene, valoare true)
          not:atr (pentru atribute booleene, valoare false)
      c:(concluzie)
          atr#valoare fc#nr(concluzia)
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    Studentul a ceru sa faca interfata cu o alta tehnica decat cea prezentata la laborator prin urmare va trebui sa tina cont in dezvoltarea ei de urmatoarele obiective:

    1. sa pastreze toate functionalitatile din consola (absolut toate optiunile din meniu si informatiile afisate de catre sistemul expert)
    2. sa afiseze intrebarile dar si solutiile intr-o maniera interactiva
    3. sa verifice eventualul input al utilizatorului (in cazul in care foloseste textbox-uri si nu optiuni)
    4. sa afiseze imaginile si eventual linkurile corespunzatoare solutiilor
    5. sa poate fi accesate cunostintele sistemului si istoricul raspunsurilor la intrebari
  35. Sistem expert care identifica boala unei pisici in functie de simptomele sale. (minim 20 solutii).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        regula:=id(unde id este numarul regulii)
        multime_premise:={ (conditiile intre acolade, atributele separate cu virgula)
             atr==valoare ; (pentru atribute cu valori multiple)
             bool(atr) ; (pentru atribute booleene, valoare true)
             bool(\+ atr) (pentru atribute booleene, valoare false)
        }
        concluzie:=
            (atr:=valoare cu fc:=nr).(concluzia)
      • intrebarile vor avea formatul:
        intrebare:=(atribut;
            enunt:='continut intrebare';     variante:=(
                val1 ;
                val2 ;
                val3 ;
            ...
            )
        ).
      • scopul se va defini:
        scop:=atr.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      [
      boala #> nume_boala
      & imagine #> [cale_relativa_imagine]
      info_suplimentare #> {
      a)cale_site1
      b)cale_site2
      ... }
      descriere #> [....]
      ]

      Cuvantul nume_boala va fi inlocuit cu numele bolii. Se va mai adauga si calea relativa catre imaginea corespunzatoare bolii. Intre acolade sunt enumerate site-uri cu informatii suplimentare despre boala respectiva. Site-urile vor fi enumerate de la in ordinea relevantei si importantei. Dupa descriere--> se va afisa textul corespunzator descrierii.

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      In cazul in care sistemul expert a fost deja consultat si au fost calculate solutiile (se va testa prin program acest aspect), se vor afisa doua optiuni dupa afisarea solutiilor: detalii si revenire.

      La alegerea optiunii revenire, se reafiseaza meniul principal.

      La alegerea optiunii detalii se afiseaza un alt meniu cu urmatoarele optiuni

      • afis_descriere - fara parametrii reafiseaza toate solutiile, avand sub fiecare solutie descrierea corespunzatoare. Optiunea accepta si parametri: mai multe nume de solutie separate prin virgule - afisand descrierile doar pentru acele solutii
      • salveaza - creeaza un fisier text in folderul de output: solutii.txt pentru solutiile curente. Daca e apelat fara parametri, va scrie in fisier doar solutiile si factorii de certitudine. Daca e apelat cu parametrul descriere ("salveaza descriere") va scrie in fisier si toate informatiile asociate fiecarei solutii.
      • afis_info - Daca se da optunea fara parametri, veti deschide doar primul site (adica cel mai relevant, deoarece in descriere sunt ordonate dupa importanta) pentru fiecare solutie. Indicatie: cautati in documentatia Sicstus library(process). Puteti considera calea default a browserului: 'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe'. Mai intai veti verifica faptul ca exista executabilalul. Daca nu exista veti afisa un mesaj de forma: 'Chrome nu a fost gasit in calea default', altfel veti afisa imaginile. La prezentare se vor testa ambele cazuri punand o data calea default corecta si o data una gresita pentru afisarea mesajului. Optiunea accepta ca parametru si un nume de solutie, si va deschide doar pentru acea solutie toate site-urile corespunzatoare in browser. E indicata afisarea paginii in chrome fiindca acesta e instalat in laborator).
      • revenire - care ne intoarce la meniul principal
    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru un set de solutii posibile, prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de solutiile posibile. Urmatoarele linii vor corespunde de asemenea fiecarei solutii (fiecarei boli posibile). Astfel, pe fiecare astfel de linie, pe prima coloana avem boala, iar pe urmatoarele coloane lista regulilor comune in intregul istoric (tot arborele) celor doua solutii. Pentru a calcula aceasta lista trebuie calculat intai istoricul complet al fiecarei solutii si apoi facuta intersectia. Istoricul pentru fiecare fapt e doar la nivelul fiilor directi din arborele de deductie. Va trebui sa faceti un predicat recursiv care parcurge arborele si calculeaza pentru fiecare regula reuniunea istoricelor premiselor. Astfel istoricul complet al solutiei va cuprinde id-urile tuturor regulilor din arbore (deci care au participat la calcularea solutiei respective)

      Pe diagonala veti avea doar simbolul "#" fiind vorba de asocierea solutiilor identice.

      In submeniul afisat de optiunea detalii vor aparea doua optiuni noi: afis_matr si afis_istoric_comun. Optiunea afis_matr va afisa matricea (frumos formatata - adica sub o forma tabelara in care sa se vada bine liniile si coloanele) insa in locul listelor de reguli se va afisa doar numarul lor. In acest fel se pot identifica solutiile cele mai apropiate.

      Optiunea afis_istoric_comun primeste 2 parametri sol1 si sol2, reprezentand nume de solutii. Pentru acestea va afisa lista de id-uri de reguli comune.

    4. Programul Prolog va crea un director numit output_pisici (de fapt, daca exista deja, il va folosi pe acela, iar daca nu exista, il va crea - e obligatoriu de implementat acest test daca doriti sa primiti punctaj complet pe cerinta).

      Se va mai introduce o optiune in meniu (sau in cazul in care avem interfata grafica, va exista un buton care va apela predicatul Prolog care indeplineste cerinta de la acest subpunct. Optiunea noua se va numi afiseaza_solutii_posibile. Aceasta nu va depinde de consultarea sistemului expert ci va arata totalitatea solutiilor ce pot fi obtinute de sistem. La alegerea acesteia, programul va afisa pe ecran si va scrie si intr-un fisier numit solutii_posibile.txt (aflat in folderul de output) toate solutiile pe care le poate da sistemul expert, impreuna cu premisele care ar trebui sa fie adevarate pentru acea solutie (daca se face interfata grafica, la apasarea butonului, s-ar deschide o fereastra noua cu textul, in loc sa fie acesta afisat in consola). Atentie, asta nu inseamna sa afisati regulile. De exemplu:

      Avem regulile:

      regula:=14
      multime_premise:={
           temperatura==medie ;
           bool(prurit_piele) ;
           bool(\+ varsaturi)
      }
      concluzie:=
          (boala_pisica:=purici cu fc:=45).
      si
      regula:=25
      multime_premise:={
           varsta==pui ;
           bool(insecte_saritoare) ;
           bool(prurit_piele)
      }
      concluzie:=
          (boala_pisica:=purici cu fc:=85).
      Si presupunem ca sunt singurele reguli pentru solutia purici. Atunci pentru aceasta solutie se va afisa:
      Solutie posibila:purici.
      Caracteristici:
      - temperatura=medie
      - prurit_piele = da
      - varsaturi = nu
      - varsta = pui
      - insecte_saritoare = da
      Intre fiecare doua solutii (cu caracteristicile lor) se va lasa cate o linie goala.
      Atentie la regulile care nu au drept concluzie atributul scop. Acelea nu vor fi luate in considerare in aceasta afisare.
    5. Se va adauga o optiune noua in meniul principal, numita "demo". La alegerea acestei optiuni se vor afisa pe rand intrebarile sistemului expert, ca si cum un utilizator l-ar consulta, insa alegerea optiunii va fi facuta random de catre calculator. Afisarile se vor face cu un delay de o secunda: adica se afiseaza o intrebare se asteapta o secunda, se afiseaza raspunsul, se asteapta o secunda, se afiseaza noua intrebare si tot asa. La final se vor afisa solutiile ca si in cazul in care consultarea ar fi fost facuta de utilizator, adica tot cu meniul de la final si optiunile disponibile.
    6. In directorul de output va exista un fisier numit demonstratie.txt, refacut la fiecare noua consultare cu demonstratiile pentru raspunsurile date in urma acelei consultari.

      Primul rand al acestui fisier va fi de forma:

      [Demonstratii pentru consultarea sistemului expert de la data: Zi Luna An, Ora:Minut:Secunda AM/PM]

      In acest rand se va inlocui Zi cu numarul zilei, Luna cu numele lunii, An cu anul. Cuvintele Ora, Minut si Secunda se vor inlocui cu ora consultarii, minutul si secunda. Orele vor fi considerate de la 1 la 12 (nu de la 0 la 24) si succedate de AM sau PM. Daca Ora minutul sau Secunda au o singura cifra, vor fi precedate de un 0. De exemplu nu scrieti 9:23:7 ci 09:23:07.

      Fiecare demonstratie va fi precedata in fisier de un rand de forma ################_nr, unde nr e numarul demonstratiei in cadrul fisierului. Va exista minim un set de raspunsuri date de utlizator, care sa duca la solutii multiple, pentru a putea exemplifica la prezentare rezolvarea acestei cerinte.

      In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare:

      regula:=id
      (unde id este numarul regulii) multime_premise:={ (conditiile intre acolade, atributele separate cu virgula)
           atr==valoare ; (pentru atribute cu valori multiple)
           bool(atr) ; (pentru atribute booleene, valoare true)
           bool(\+ atr) (pentru atribute booleene, valoare false)
      }
      concluzie:=
          (atr:=valoare cu fc:=nr).(concluzia)
      Pentru atributele obtinute de la utilizator se va afisa un mesaj de genul:
      [nume_atr]=[valoare] dat ca raspuns de catre utilizator la intrebarea "[text_intrebare]".
      Inlocuind campurile dintre paranteze drepte cu valorile corespunzatoare.
  36. Sistem expert care alege cel mai bun actor dintr-un set de actori dati (minim 20 actori) pentru a juca un anume rol intr-un film, in functie de caracteristicile rolului respectiv.

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        regula /id\ (unde id este numarul regulii)
        concluzie atribut/valoare\ f_c/nr\(concluzia; nr este factorul de certitudine)
        conditiile:
             atr/valoare\, (pentru atribute cu valori multiple)
             /atr\ (pentru atribute booleene, valoare true)
             /not atr\ (pentru atribute booleene, valoare false)
        .
      • intrebarile vor avea formatul:
        intrebare : enunt /'continut intrebare'\
        atribut /atribut_intrebare\
        optiuni [val1 /\ val2 /\ val3 ]. (pot fi oricate optiuni, nu doar 3)
      • scopul se va defini:
        scop/atr\.
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. acestea vor fi scrise in modul urmator:

      (actor /// nume_actor
      descriere/// [...]
      site/// adresa_site
      imagine/// cale_relativa_imagine
      genuri: (gen1);(gen2);(gen3)...
      )

      ----------

      Cuvantul nume_actor va fi inlocuit cu numele actorului. Apoi se va adauga descrierea, inlocuind "[...]" cu textul efectiv al descrierii (descrierile vor avea minim doua propozitii - fraze terminate cu punct). Se va adauga si site-ul personal al actorului, dar si calea relativa catre imaginea corespunzatoare actorului. De asemenea se vor enumera genurile filmelor in care au mai aparut actorii resectivi in rolurile precedente.

      Aceste date vor fi cititie din fisier si memorate in baza de cunostinte de asa natura incat sa poata fi rezolvate cerintele urmatoare.

      Cand se afiseaza solutiile, sub ele se afiseaza si prima propozitie din descrierea fiecareia (deci textul din descriere pana la primul punct) si apoi textul "[...]".

      La final, dupa afisarea solutiilor se vor afisa trei optiuni: descriere_completa, afis_lista_genuri, '<<<':

      Daca se alege optiunea descriere_completa, se vor afisa din nou solutiile urmate si de descrieri. Sub fiecare descriere se vor afisa si genurile, cate unul pe linie, precedate de "->". Exemplu de afisare

      actor este 'Sylvester Stallone'
          cu factor de certitudine 87
      Descriere: Un nene musculos. Are o expresie deosebita.
      Genuri:
      ->comedie
      ->drama
      ->thriller
      ----------------------- (un separator intre 2 solutii)

      Daca se alege optiunea afis_lista_genuri, se vor afisa doar genurile cate unul pe linie, numerotate:

      actor este 'Sylvester Stallone'
          cu factor de certitudine 87
      Genuri:
      1. comedie
      2. drama
      3. thriller
      ----------------------- (un separator intre 2 solutii)

      Optiunea '<<<' revine la meniul principal.

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Pentru toate solutiile existente, se va calcula matricea in care prima linie contine pe prima coloana un blank urmat pe coloanele urmatoare de numele tuturor genurilor corespunzatoare solutiilor date in urma consultarii. Urmatoarele linii vor corespunde, pe rand, tot fiecarui gen (din setul de genuri calculate pentru coloane). Astfel, pe fiecare astfel de linie, pe prima coloana avem numele genului in care a jucat actorul, iar pe urmatoarele coloane lista numelor actorilor din solutie care au jucat in ambele genuri de filme(si de pe linie si de pe coloana).

      In meniul de dupa afisarea solutiilor va aparea si o optiune tabel_genuri. La alegerea acestei optiuni se va afisa matricea creata pentru solutii, formatata frumos astfel incat dimensiunea unei coloane sa fie egala cu dimensiunea celui mai lung element de pe acea coloana.

      Pe diagonala (deci pentru genuri identice) vom pune simbolul =.

      Pentru cazul in care avem mai multe nume de actori in aceeasi casuta de tabel, dimensiunea "liniei" de tabel va fi egala cu numarul de nume din casuta. Doua linii de tabel vor fi separate printr-o linie de minusuri("-"), iar doua coloane prin simbolul pipe "|".

      In cazul in care pentru doua genuri nu avem actori comuni, lasam casuta din tabel libera.

      De exemplu:

              |comedie|drama  |thriller|
      ----------------------------------
      comedie |=      |Ionel  |Bob     |
              |       |Gogu   |        |
      ----------------------------------
      drama   |Ionel  |=      |        |
              |Gogu   |       |        |
      ----------------------------------
      thriller|Bob    |       |=       |
      ----------------------------------
      						
    4. La fiecare intrebare se va arata un progress-bar (care aproximeaza la cat mai are utilizatorul de raspuns). Pentru a calcula progresul, veti imparti numarul de reguli, care au fost deja evaluate, la numarul total de reguli. Progress-bar-ul se va afisa pe o linie inainte de intrebare, incepand cu "[" si terminandu-se cu "]". Spatiile neumplute vor fi ilustrate prin "-" iar cele umplute prin "#". Vor fi in total 10 spatii. Pentru un procentaj nedivizibil cu 10 vor fi umplute N spatii din progress-bar unde N=(parte_intreaga(procentaj/10)). In dreapta progress bar-ului se va afisa si procentajul (cat la suta din reguli au fost deja parcurse). De exemplu: [----------] 0% [###-------] 30% [###-------] 39% [####------] 40% [#########-] 98%
    5. Programul va folosi un director numit output_actori (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In acest director se va crea un fisier log_masini, in care se vor afisa, doar pentru interogarea curenta:
      • fiecare intrebare pusa de sistemul expert, in ordine cronologica
      • sub fiecare intrebare se va afisa raspunsul utilizatorului
      • sub raspunsul utilizatorului, faptele cunoscute in momentul punerii intrebarii (chiar inainte de s-a pus intrebarea, adica nu va fi pus si faptul corespunzator intrebarii)
      • o linie despartitoare (intre intrebari) de forma "-----------------------"
    6. In directorul output_masini se va crea directorul demonstratii (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In directorul demonstratii, se va crea cate un fisier numit demonstratie[timestamp][solutie][fc].txt, pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei, fc cu factorul de certitudine, iar timestampul va fi calculat cu ajutorul predicatului now(X). Fisierul va contine, evident, demonstratia pentru acea solutie.

      In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      regula /id\ (unde id este numarul regulii)
      concluzie atribut/valoare\ f_c/nr\(concluzia; nr este factorul de certitudine)
      conditiile:
           atr/valoare\, (pentru atribute cu valori multiple)
           /atr\ (pentru atribute booleene, valoare true)
           /not atr\ (pentru atribute booleene, valoare false)
      .
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.
  37. O firma care vinde pitici de gradina doreste un sistem expert care sa-i ajute pe clienti sa-si aleaga cel mai potrivit pitic de acest gen. Se vor considera minim 20 de pitici posibili (de exemplu pe e-bay se gasesc variante ale acestui tip de produs: http://www.ebay.com/bhp/garden-gnome).

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        regula <id> (unde id este numarul regulii)
        atribut_concluzie <valoare / fc:nr> (concluzia)
        daca :(conditiile intre acolade, atributele separate cu virgula)
             atr<valoare> (pentru atribute cu valori multiple)
             <atr> (pentru atribute booleene, valoare true)
             <!atr!> (pentru atribute booleene, valoare false)
        ).
      • intrebarile vor avea formatul:
        interogare<atribut>
        enunt<'continut intrebare'>
        cu variantele <
             val1 /
             val2 /
             val3 /
        ...
        >.
      • scopul se va defini:
        scop<atr>.
  38. Sistem expert care identifica pentru un cartof dat subtipul din care face parte. Lista de subtipuri e cea de aici: http://www.thekitchn.com/potato-varieties-64061 (aici sunt doar numele, cauti pe wikipedia descrierea pentru fiecare)

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        r<-id (unde id este numarul regulii)
        concluzie<-(atribut_concluzie/valoare/fc<-nr) (atribut_concluzie - numele atributului concluzie; valoare - valoarea acestuia; nr - valoarea fc-ului)
        premise<-((premisele intre paranteze si separate cu bara)
             atr<-valoare | (pentru atribute cu valori multiple)
             atr | (pentru atribute booleene, valoare true)
             #! atr (pentru atribute booleene, valoare false)
        ).
      • intrebarile vor avea formatul:
        intrebare<-nume_atribut (nume_atribut este numele atributului corespunzator intrebarii)
        enunt<-'continut intrebare'
        optiuni<-(
             val1 +
             val2 +
        ...
             valn
        ).
      • scopul se va defini:
        atr<-scop.
        inlocuind atr cu numele atributului scop
  39. Sistem expert care identifica cea mai potrivita pacaleala de 1 aprilie in functie de personalitatea pacalitului. (minim 20 solutii)

  40. Sistem expert care identifica cel mai potrivit tip de ochelari de soare dintr-un set de produse date (cauti pe net tipuri de ochelari de soare de diverse forme, culori etc.) (minim 20 solutii)

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        rg ## id (unde id este numarul regulii)
        atribut_concluzie {valoare | factor certitudine:::nr} (concluzia; nr este factorul de certitudine)
        premise { (conditiile intre acolade)
             atr:::valoare (pentru atribute cu valori multiple)
             atr::: (pentru atribute booleene, valoare true)
             atr:::not (pentru atribute booleene, valoare false)
        }.
      • intrebarile vor avea formatul:
        q:::atribut
        text:::'continut intrebare'
        opt:::{val1 || val2 || val3 || ...} .
      • scopul se va defini:
        scop:::atr
    2. Programul va citi dintr-un fisier de intrare datele pentru fiecare solutie in parte. Acestea vor fi scrise cu ajutorul unor inregistrari de felul:

      (begin_descriere)
      ###(sol) nume_solutie
      ###(text) text_descriere
      ###(imagine) cale_relativa_imagine
      ###(pret) pret
      (end_descriere)

      Dupa ce s-a terminat consultarea sistemului expert, dar inainte de afisarea solutiilor se va pune intrebarea: "Cum doriti afisarea solutiilor? (detaliata/sumara/renunt)

      Daca se alege optiunea detaliata se afiseaza solutiile impreuna cu toate detaliile din fisierul de descrieri.

      Daca se alege optiunea sumara se afiseaza solutiile doar cu factorul de certitudine (afisarea standard).

      Daca se alege optiunea renunt se revine la meniul principal, fara a afisa vreo solutie.

    3. Se va crea un predicat care genereaza o matrice in felul urmator. Matricea va avea trei coloane. Pe prima linie avem headerele de coloane denumite: "Solutie", "Fc", "Pret". Pentru toate solutiile identificate in urma consultarii sitemului expert, se vor genera linii in matrice, de forma: (valoare_solutie, factor_certitudine, pret).

      In intrebarea despre afisarea solutiilor se va adauga si optiunea tabelara care va scrie matricea generara cu acest predicat.

      Afisarea matricii trebuie sa fie una frumoasa in care coloanele au lungimi egale. Se vor desparti elementele de pe cele doua coloane prin dubla bara "||".

    4. in loc de un fisier cu toate datele sistemului expert, veti avea un fisier numit scop.txt, doar cu scopul. Un fisier intrebari.txt, doar cu intrebarile si un fisier reguli.txt, doar cu regulile.
    5. Programul Prolog va crea (in cazul in care nu exista) un director numit output_ochelari (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In el se va crea un fisier numit log_solutii.txt (acesta va fi suprascris in cazul in care exista deja de la o rulare anterioara). In interiorul acestui fisier se vor adauga, dupa fiecare rulare, solutiile ordonate alfabetic impreuna cu factorii de certitudine. Pentru un set de solutii afisate formatul este acesta:

      [an/luna/zi ora:minut:secunda]
      # valoare1 cu fc = nr1
      # valoare2 cu fc = nr2
      ...
      # valoareN cu fc = nrN
      <<<<<<<>>>>>>>
      Primul rand dintr-un set de solutii specifica data si ora obtinerii solutiilor. Campurile de forma valoarei se inlocuiesc cu valorile solutiilor, iar campurile de forma nri cu factorii de certitudine.
    6. In folderul de output veti crea un fisier numit demonstratii_ochelari.txt continand toate demonstratiile pentru raspunsurile de la ultima consultare, separate prin 3 randuri de forma "###################". Primul lucru scris in demonstratie va fi raspunsul pentru care se face demonstratia.

      In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:

      rg ## id (unde id este numarul regulii)
      atribut_concluzie {valoare | factor certitudine:::nr} (concluzia; nr este factorul de certitudine)
      premise { (conditiile intre acolade, atributele separate cu virgula)
           atr:::valoare (pentru atribute cu valori multiple)
           atr::: (pentru atribute booleene, valoare true)
           atr:::not (pentru atribute booleene, valoare false)
      }.
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Se va implementa o interfata grafica care sa ofere toate functionalitatile pe care le avea aplicatia in consola (meniul principal, meniuri secundare, alte afisari cerute sau fisiere create la rulare). In subpunctele de mai jos sunt specificate niste cerinte custom legate de interfata. Tot ce nu e specificat in cerintele de mai jos despre modul in care trebuie sa arate interfata ramane la alegerea studentului ( deci decideti voi ce fel de elemente de control doriti sa adaugati: butoane, checkboxuri etc.) dar pentru punctaj complet trebuie sa aveti toate functionalitatile cerute pentru consola.
    2. Intrebarile vor fi afisate pe rand in aceeasi fereastra. Pentru optiuni, indiferent de tipul de intrebare, veti folosi radiobuttons. Radiobutton-urile vor avea culor alternate astfel: pe pozitiile impare vor avea border de culoare gri deschis si background gri inchis, iar pe pozitiile pare va fi invers: border gri inchis si background gri inchis. Pentru factorul de certitudine al raspunsurilor, veti avea un JSpinner care creste din 10 in 10 cu minim 0 si maxim 100. Va exista si JLabel cu border negru si cu textul "urmatoarea intrebare" care, la click pe el, va lua in considerare raspunsul dat si va trece la urmatoarea intrebare.
    3. Sub intrebare si optiuni va exista si un JTextArea. Cand se raspunde la o intrebare, in JTextArea apare numele atributului corespunzator intrebarii si valoarea lui, data de utilizator, astfel: atribut_1=valoare_1
      atribut_2=valoare_2
      ... atribut_k=valoare_k
    4. La final, se vor afisa, unul sub altul, folosind JLabeluri (tot cu stil alternat ca si radiobutton-urile), raspunsurile cu factorii de certitudine. In dreapta raspunsurilor(solutiilor) va fi un loc pentru imagine, iar sub raspunsuri, un ScrollPane cu un JLabel in care se va afisa demonstratia.
    5. Cand venim cu cursorul pe labelul unei solutii, imaginea solutiei identificate se va afisa in locul pentru imagine si textul demonstratiei va fi afisat in JLabel. (Atentie nu trebuie sa si dispara cand luam cursorul de pe raspuns - textul si imagina dispar doar cand de fapt sunt inlocuite de imaginea si textul demonstratiei pentru un alt raspuns peste care am adus cursorul).
  41. Un inventator doreste sa creeze robotei. Pentru acest lucru are nevoie, evident, de microcontrolere. Se va crea un sistem expert care ajuta inventatorii sa gaseasca cel mai potrivit tip de microcontroler in functie de tipul de robotel pe care doresc sa il construiasca. (minim 20 solutii)

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        #Numar regula#=id(unde id este numarul regulii)
        #concluzie#=(atr_concluzie |= val % fc |= nr).(atr_concluzie e atributul-concluzie al regulii, val e valoarea sa, iar nr e factorul de certitudine)
        #conditii#(
        atr |= val ++(pentru atribute cu valori multiple)
        atr ++(pentru atribute booleene, valoare true)
        \\atr).(pentru atribute booleene, valoare false)
      • intrebarile vor avea formatul:
        #Atributul_intrebarii#=atr_intrebare(atr_intrebare e atributul caracteristic intrebarii)
        #Textul_intrebarii#=continut_intrebare
        #Variante_raspuns#=(val1 ~ val2 ~ val3 ~ ...).(val1, val2, val3 sunt optiunile pentru intrebare, si evident pot fi oricate optiuni)
      • scopul se va defini:
        #scop#=atr_scop.
  42. Sistem expert care identifica cel mai potrivit chatbot cu care poate conversa un om in functie de interesele sale. (minim 20 solutii). Vezi lista https://www.chatbots.org/ si alegi de aici tipuri diferite de chatbots.

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        [r:id]
        conditii:
            - atr = valoare (pentru atribute cu valori multiple)
            - atr (pentru atribute booleene, valoare true)
            - not atr (pentru atribute booleene, valoare false)
        concluzie:
            atr=valoare fc=nr
      • intrebarile vor avea formatul:
        intreb: atribut
        raspunsuri posibile: val1, val2, val3 ...
        text: 'continut intrebare'
      • scopul se va defini:
        scop = atr(unde atr e atributul-scop)
  43. Sistem expert care identifica cel mai potrivit tip de muzica pentru un eveniment (de exemplu: o intalnire oficiala: muzica simfonica, o petrece studenteasca: muzica rock, pop, rap etc. Solutiile se vor stabili in functie de tipul de eveniment si personalitatea participantilor)

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        Regula: Id(id) (unde id este numarul regulii)
        Concluzie(atribut_concluzie := valoare; fc(nr))(concluzia; nr este factorul de certitudine)
        Premise((conditiile intre paranteze rotunde, atributele separate cu virgula)
             atr =?= valoare + (pentru atribute cu valori multiple)
             atr +(pentru atribute booleene, valoare true)
             ##atr (pentru atribute booleene, valoare false)
        )
        .
        Premisele, dupa cum se observa, sunt separate prin caractere "+".
      • intrebarile vor avea formatul:
        Intrebare: atribut_intrebare(atribut)
        text('continut intrebare')
        optiuni(val1 || val2 || val3 ...) .
      • scopul se va defini:
        scop_sistem_expert(atr_scop).
  44. Consideram un loc in care se intampla fenomene ciudate. De exemplu o casa in care se aud zgomote inexplicabile. Un loc in care dispar animale sau apar cercuri in lanurile de grau, radioactivitate subita etc. In functie de fenomenele care se petrec sistemul expert va identifica tipul de element/entitate parastiintifica care provoaca fenomenele respective (exemplu: fantoma, extraterestru, vampir, chupacabra etc.) Minim 20 solutii.

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        R(id) (unde id este numarul regulii)
        { if atr == valoare (pentru atribute cu valori multiple)
            and atr (pentru atribute booleene, valoare true)
            and not atr (pentru atribute booleene, valoare false)
            then atribut_concluzie=valoare fc nr.
        }
        .
      • intrebarile vor avea formatul:
        intrebare(
        text::='continut intrebare'
        atr::=atribut
        optiuni::=(val1 & val2 & val3 & ....)
        ) .
      • scopul se va defini:
        !(Scop::=atr).
  45. Sistem expert care identifica abilitatea parapsihologica cea mai probabila pe cre o are cineva in functe de caracteristicile sale. (poate sa nu aiba nicio abilitate). Vei folosi lista de la https://en.wikipedia.org/wiki/List_of_psychic_abilities

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        Numar regula: id
        avand conditiile:(premise)
            atr cu valoarea valoare (pentru atribute cu valori multiple)
            atr adevarat(pentru atribute booleene, valoare true)
            atr fals(pentru atribute booleene, valoare false)
        atunci:(concluzie)
            atrare valoarea valoare cu fc nr.(concluzia)
      • intrebarile vor avea formatul:
        intrebare pentru atribut
        cu optiunile: val1, val2, val3 ...
        si cu textul intrebarii: 'continut intrebare'.
      • scopul se va defini in fisier:
        scopul cautat este atr.
  46. Sistem expert care identifica specia unui paianjen observat in fucntie de caracteristicile acestuia (minim 20 solutii)

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        reg(id) (unde id este numarul regulii)
        atribut_concluzie ~ valoare factor cert ~ nr (concluzia; nr este factorul de certitudine)
        enumerare_premise ( (conditiile intre acolade, atributele separate cu virgula)
             atr~valoare + (pentru atribute cu valori multiple)
             atr +(pentru atribute booleene, valoare true)
             not(atr) (pentru atribute booleene, valoare false)
        )
        .
      • intrebarile vor avea formatul:
        (intrebarea pentru ~ atribut
        textul_intrebarii ~ 'continut intrebare'
        optiunile
        - val1
        - val2
        - val3
        ).
      • scopul se va defini:
        scop ~ atr.
  47. Sistem expert care identifica cel mai potrivit tip de joc de mobil in functie de personalitatea utilizatorului (minim 20 solutii)

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        r{id} (unde id este numarul regulii)
        (conditii:(conditiile enumerate folosind ~~ inaintea fiecareia)
             ~~ atr {valoare} (pentru atribute cu valori multiple)
             ~~ t[atr](pentru atribute booleene, valoare true)
             ~~ f[atr] (pentru atribute booleene, valoare false)

        atribut_concluzie{valoare,FC= nr}.
      • intrebarile vor avea formatul:
        intreb{atribut,
        'continut intrebare',
        {val1 ~ val2 ~ val3 ~ ....} }.
      • scopul se va defini:
        {scop ~ atr}.
  48. Sistem expert care identifica cea mai potrivita companie software care poate fi contactata pentru a rezolva o anumita problema in functie de caracteristicile problemei (minim 20 solutii - companii reale)

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        [(cond): {(conditiile enumerate intre acolade si separate prin [+])
             atr:{valoare} [+] (pentru atribute cu valori multiple)
             atr [+](pentru atribute booleene, valoare true)
             n(atr) (pentru atribute booleene, valoare false)
        }
        (atribut_concluzie):{valoare} (fact-cert) :{nr}
        (r):{id}]. (unde id este numarul regulii)
      • intrebarile vor avea formatul:
        [(atr_intreb):{atribut} (se va inlocui atribut cu numele atributului)
        (text):{'continut intrebare'}
        (raspunsuri):{val1 [+] val2 [+] val3 [+] ....} ].
      • scopul se va defini:
        [(scop) : {atr_scop}].(atr_scop se va inlocui cu numele atributului scop)
  49. Sistem expert care identifica cel mai potrivit stil de mobila pentru decorarea unei camere in functie de utilitatea camerei si personalitatea si statutul posesorului. Te poti inspira din aceasta lista de stiluri de mobila: http://www.connectedlines.com/styleguide/ (minim 20 de stiluri din lista respectiva)

    Cerinte individuale prolog:

    1. Parsare:
      • regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
        #reg id {(unde id este numarul regulii)
        #pentru atribut_concluzie == valoare cu factor-certitudine == nr (atributul concluie cu valoarea sa; nr reprezinta valoarea factorului de certitudine)
        avem:(conditiile enumerate mai jos)
             atr/valoare (pentru atribute cu valori multiple)
             atr (pentru atribute booleene, valoare true)
             \(atr) (pentru atribute booleene, valoare false)
        #sfarsit_regula.
      • intrebarile vor avea formatul:
        #intrebare/atribut se va inlocui atribut cu numele atributului
        #text 'continut intrebare'
        #variante val1, val2, val3, ....}
        #sfarsit_intrebare.
      • scopul se va defini:
        #scop
        atr_scopatr_scop se va inlocui cu numele atributului scop
        #sfarsit_scop.

De anul trecut

  1. Sistem expert care identifica un voievod roman (minim 20).

    Cerinte individuale program prolog

    1. regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
      rg--id
      (unde id este numarul regulii) if( (conditiile intre parantezee, atributele separate cu &&)
           atr==valoare && (pentru atribute cu valori multiple)
           atr==(1) && (pentru atribute booleene, valoare true)
           atr==(0) (pentru atribute booleene, valoare false)
      )
      then
          (atr==valoare cu fc:nr).(concluzia)
    2. intrebarile vor avea formatul:
      q -- atribut
      variante(
          val1 &&
          val2 &&
          val3 &&
      ...
      )
      text ('continut intrebare').
    3. scopul se va defini:
      scop -- atr
    4. Programul va folosi un director numit fisiere_text_voievozi(daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In acest director va exista un fisier numit data_ultima_accesare.txt. Daca fisierul nu exista, programul prolog il va crea la inceputul rularii, si va scrie acolo anul, luna, ziua, ora, minutul si secunda. Daca fisierul exista de dinainte, programul prolog va transmite cu ajutorul unui predicat, catre interfata grafica, de cate zile nu a mai intrat utilizatorul.
    5. In directorul fisiere_text_voievozi, vor mai exista si niste fisiere numite demonstratii_voievozi_[nume_voievod]_[fc].txt. In numele fisierului, [nume_voievod] si [fc] vor fi inlocuite de numele voievodului identificat, si factorul de certitudine pentru acel raspuns. Fisierul respectiv va contine demonstratia doar pentru acel raspuns.
    6. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      rg--id
      (unde id este numarul regulii) if( (conditiile intre acolade, atributele separate cu virgula)
           atr==valoare && (pentru atribute cu valori multiple)
           atr==(1) && (pentru atribute booleene, valoare true)
           atr==(0) (pentru atribute booleene, valoare false)
      )
      then
          (atr==valoare cu fc:nr).(concluzia)
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. La inceputul programului, in cazul in care e prima rulare (fisierul data_ultima_accesare.txt lipseste), se va afisa un mesaj de bun venit. In cazul in care ne aflam de la a doua rulare incolo se va afisa de cate zile, ore si minute nu a mai intrat utilizatorul.
    2. Pentru toate intrebarile, optiunile vor fi generate cu ajutorul unor butoane, care vor avea si cate o imagine mica pe ele (icon) de maxim 25x25px, din specificul temei (de exemplu o sigla istorica, un icon cu un cap de voievod etc). Fiecare imagine va corespunde unui anumit numar de optiune, deci mereu pentru optiunea 1 a unei intrebari, se va afisa imaginea 1, pentru optiunea 2 imaginea 2 etc. Butoanele vor avea afisajul de forma: imagine-1 raspuns1, imagine-2 raspuns 2, etc. Pentru factorul de certitudine, veti folosi un JComboBox cu valori intre 0 si 100, crescand din 5 in 5. Trecerea la urmatoarea intrebare se face la click pe unul dintre butoanele-optiune.
    3. Pe pagina va mai exista un grup de radiobuttons, care va creste cu cate o optiune pentru fiecare noua intrebare la care s-a raspuns. Optiunile grupului vor consta din atributele corespunzatoare intrebarilor afisate anterior. La click pe una dintre optiuni, cu ajutorul unui JTextArea generat dinamic veti arata textul intrebarii si raspunsul utilizatorului.
    4. La final, se vor afisa raspunsurile cu factorii de certitudine, ca optiuni intr-un JList. Sub JList, se va gasi si un JTextPane. La selectarea unui anumit raspuns din lista, se va afisa in JTextPane demonstratia pentru acel raspuns. Initial e selectat raspunsul cu fc-ul maxim, iar in JtextPane se gaseste demonstratia pentru acesta. Pentru fiecare raspuns selectat, se va afisa si imaginea corespunzatoare voievodului identificat.
  2. Sistem expert care identifica personajul din Life Is Strange la care se gandeste utilizatorul (minim 20 de personaje).

    Cerinte individuale program prolog

    1. regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
      regula%id% (unde id este numarul regulii)
      avem [atr_concluzie==%valoare% (fact_cert:%nr%)](atr_concluzie este numele atributului calculat de regula, iar valoare, valoarea sa; nr este factorul de certitudine)
      daca avem conditiile:
           -- atr == %valoare% (pentru atribute cu valori multiple, valoarea se pune intre procente)
           -- atr (pentru atribute booleene, valoare true)
           -- !atr! (pentru atribute booleene, valoare false)
      .
    2. Intrebarile vor avea formatul:
      (
      text_intrebare='continut intrebare'
      atribut %atribut_intrebare%
      optiuni[val1 % val2 % val3 ]
      )
      .
    3. scopul se va defini:
      scop %atr%.
    4. Veti scrie un predicat care sa calculeze si sa memoreze in baza de cunostinte cate secunde a durat sa se raspunda la fiecare intrebare in parte, si timpul total al consultarii (tot in secunde). Veti folosiun predicat dinamic numit timp_raspuns.
    5. Programul va folosi un director numit output_l_strange (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In acest folder se va crea cate un fisier numit dem_cif1#cif2_resttimestamp_[solutie[fc]].txt, pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei, fc cu factorul de certitudine, cif1,cif2 cu prima si a doua cifra a timestamp-ului, calculat cu ajutorul predicatului now(), iar resttimestamp cu restul cifrelor timestampului. Fisierul va contine, evident, demonstratia pentru acea solutie.
    6. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      regula%id%
      avem [atr_concluzie==%valoare% (fact_cert:%nr%)]
      daca avem conditiile:
           -- atr == %valoare%
           -- atr
           -- !atr!
      .
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Intrebarile se afiseaza cu ajutorul unui SplitPane cu despartitor vertical. In partea din stanga avem intrebarea si optiunile. In dreptul intrebarii va fi un JTextField (readonly - utilizatorul nu-l poate schimba in mod direct). Pentru optiuni se vor folosi JLabels cu border. La mouse over pe un JLabel, JTextField-ul ia valoarea din JLabel. Pentru factorul de certitudine se va folosi un JComboBox cu valori de la 100 la 0, descrescand din 10 in 10, initial setat pe valoarea 100. Trecerea la urmatoarea intrebare se va face apasand tasta "n"(next). In interfata grafica va exista un JLabel in care va fi precizat cum se trece la urmatoarea intrebare.
    2. In partea din dreapta SplitPane-ului va fi un JList. Pe masura ce se raspunde la cate o intrebare se adauga in JList un rand de forma atribut -> valoare(fc), unde atributul e cel corespunzator intrebarii la care tocmai s-a raspuns, valoarea e raspunsul uilizatorului, iar fc - factorul de certitudine.
    3. La click pe un element din JList se deschide un dialog(alert), cu icon informativ (cel albastru, cu i-ul intr-un cerculet), in care se va afisa textul complet al intrebarii. Veti folosi aici JOptionPane.showMessageDialog
    4. Dupa ce s-a raspuns si la ultima intrebare data de sistemul expert, va disparea SplitPane-ul si se va afisa intr-un JLabel timpul total de consultare a sistemului expert, dar si timpul mediu in care s-a raspuns la intrebare (acesti timpi vor fi preluati din prolog - vezi cerintele de mai sus, pentru prolog). Sub acest JLabel, se vor afisa solutiile, intr-un ScrollPane. Fiecare solutie va avea afisata valoarea si factorul de certitudine si intr-un JTextArea (aflat imediat sub valoare ) si demonstratia pentru acea solutie (e practic vorba de continutul fisierului dem_cif1#cif2_resttimestamp_[solutie[fc]].txt).
  3. Sistem expert care identifica cel mai potrivit loc in care utilizatorul isi poate petrece timpul liber (minim 20 de locuri).

    Cerinte individuale program prolog

    1. regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
      (regula(id)) (unde id este numarul regulii)
      pentru (atr_concluzie #= valoare) (fact_cert #= nr)(atr_concluzie este numele atributului calculat de regula, iar valoare, valoarea sa; nr este factorul de certitudine)
      pentru conditiile:
           (atr #= valoare); (pentru atribute cu valori multiple)
           (atr); (pentru atribute booleene, valoare true)
           (!!!atr) (pentru atribute booleene, valoare false)
      .
    2. Intrebarile vor avea formatul:
      (intrebare)
      pentru text_intrebare='continut intrebare'(continut_intrebare se inlocuieste cu textul efectiv al intrebarii)
      (atribut #= atribut_intrebare) (atribut_intrebare se inlocuieste cu numele atributului corespunzator intrebarii)
      optiuni (val1 ** val2 ** val3 ) .
      (variantele posibile de raspuns separate prin **)
    3. scopul se va defini:
      scop(atr).
    4. In cazul in care sistemul expert e rulat in consola, daca trece un anume timp si utilizatorul nu raspunde, se va repeta (reafisa) intrebarea (vezi laborator 6) mentionandu-se ca au trecut n secunde si utilizatorul nu s-a decis. Acest numar de secunde trebuie sa fie suficient de mare totusi pentru a nu ingreuna prezentarea.
    5. Programul va folosi un director numit output_locuri (daca exista, il va folosi pe acela, iar daca nu exista, il va crea). In acest folder se va crea cate un fisier numit dem((solutie#fc)).txt, pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei, fc cu factorul de certitudine. Fisierul va contine, evident, demonstratia pentru acea solutie. La fiecare noua interogare a sistemului expert directorul este golit.
    6. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      (regula(id))
      pentru (atr_concluzie #= valoare) (fact_cert #= nr)
      pentru conditiile:
           (atr #= valoare);
           (atr);
           (!!!atr)
      .
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Intrebarile se afiseaza cu ajutorul unui SplitPane cu despartitor orizontal. In partea de sus avem intrebarea si optiunile. Pentru intrbarile cu raspuns boolean se vor folos checkboxuri. Pentru cele cu optiuni multiple se vor folosi butoane. Pentru factorul de certitudine se va folosi JTextField initial setat pe valoarea 100. Trecerea la urmatoarea intrebare se va face cu ajutorul unui buton pe care scrie "next" si e desenata o sageata la dreapta.
    2. In partea de jos a SplitPane-ului va fi un ScrollPane. Pe masura ce se raspunde la cate o intrebare se adauga in ScrollPane cate un Panel continand pe un rand textul intrebarii si pe un al doilea rand raspunsul utilizatorului si factorul de certitudine. Intrebarile+raspunsul asociat vor fi separate prin linii orizontale albastre(la alegerea voastra cum faceti liniile).
    3. In cazul in care trec n secunde (egale cu cate erau in cerintele de prolog) si utilizatorul nu a raspuns la intrebare se afiseaza un ecran de dialog cu un mesaj de atentionare (presupunem ca sistemul expert e folosit si de altii si nu vrea sa fie blocat de un utilizator). Cerinta aceasta poate fi rezolvata complet in Java (fara comunicare cu modulul scris in Prolog)
    4. Dupa ce s-a raspuns si la ultima intrebare data de sistemul expert, va disparea SplitPane-ul si se vor afisa intr-un panou solutiile, cu ajutorul unui ScrollPane. Fiecare solutie va avea afisata valoarea si factorul de certitudine si un buton care deschide in notepad demonstratia pentru acea solutie (e practic vorba de continutul fisierului dem((solutie#fc)).txt.
  4. Sistem expert care ajuta utilizatorul sa aleaga cel mai bun tip de bicicleta in functie de necesitatile sale. (minim 20 de tipuri de bicicleta).

    Cerinte individuale program prolog

    1. regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
      Id(regula)=id (unde id este numarul regulii)
      Val(atribut_concluzie)=valoare (atribut_concluzie: numele atributului concluzie; valoare - valoarea sa) FactCert(regula)=nr (nr este factorul de certitudine)
      Conditii de indeplinit = {{(conditiile intre acolade duble, atributele separate cu virgula)
           atr <- valoare, (pentru atribute cu valori multiple)
           atr,(pentru atribute booleene, valoare true)
           **atr** (pentru atribute booleene, valoare false)
      }}
      .
    2. intrebarile vor avea formatul:
      atr(intrebare)= atribut |
      text(intrebare)='continut intrebare' |
      variante(intrebare)= val1 sau val2 sau val3 sau .... .
    3. scopul se va defini:
      scop(sistem_expert)=atr.
    4. Va mai exista un fisier numit biciclete.pl in care va fi o baza de cunostinte cu predicate de forma: info_bicicleta(id, brand, culoare, pret). De exemplu:
      relatie_rudenie(bicicleta_pegas_obisnuita, 'Pegas', verde, 1000).
      Acest fisier va fi inclus in program pentru ca va contribui la afisarea solutiei, asa cum se poate vedea mai incolo. Se va crea si un predicat de forma biciclete_brand(+NumeBrand,-ListaBiciclete). Acesta va prim ca parametru numele unui brand si va calcula in ListaBiciclete, o lista de termeni compusi de forma pret(IdBicicleta, Pret). De exemplu, pentru Pegas, o lista ar putea fi [pret(bicicleta_pegas_obisnuita,1000), pret(mountain_bike_pegas,1900)].
    5. Pentru fiecare bicicleta va exista un fisier cu numele informatii_id_bicicleta.txt. De exemplu, informatii_mountain_bike_pegas.txt. In fiecare dintre aceste fisiere va exista pentru bicicleta respectiva o scurta descriere (4-5 fraze, luate din vreo sursa online, de exemplu un magazin de biciclete - numai sa fie totusi in limba romana). In Prolog va exista un predicat ofera_informatii(...), care va primi ca parametru id-ul bicicletei pentru care se doreste citirea fisierului cu descrierea. Descrierea poate fi apoi fie returnata sub forma de atom (adica specificatiile predicatului sa fie ofera_informatii(+Nume,-Descriere), fie sa se transfere descrierea prin intermediul mai multor mesaje, catre interfata grafica - de ce e nevoie de descriere se va vedea in cerintele de mai jos).
    6. Programul Prolog va crea un director numit output_biciclete (de fapt, daca exista deja, il va folosi pe acela, iar daca nu exista, il va crea - e obligatoriu de implementat acest test pentru a primi punctaj complet pe cerinta). Veti crea cate un fisier numit demonstratie_solutie_fc_timestamp.txt pentru fiecare solutie in parte. Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei, fc cu factorul de certitudine, iar timestamp cu timestampul calculat de predicatul now(). In fiecare fisier primul rand va fi de forma: "Se demonstreaza obtinerea solutiei atribut_scop=valoare_solutie cu factorul de certitudine fc". Cuvantul atribut_scop va fi inlocuit cu numele atributului scop, solutie din aceasta fraza va fi inlocuit cu valoarea solutiei, iar fc cu factorul de certitudine. Dupa acest rand urmeaza demonstratia pentru acea solutie. Modul de afisare al demonstratiei va fi lasat la alegerea studentului.

    Cerinte interfata grafica:

    1. Intrebarile vor fi afisate pe rand in aceeasi fereastra, intr-un SplitPane (cu despartitor vertical). In partea stanga a SplitPane-ului va fi textul intrebarii, iar in partea dreapta, optiunile. Pentru optiuni, indiferent de tipul de intrebare, veti folosi un JLabel cu chenar negru si background gri-deschis. Cand cursorul mouse-ului ajunge pe un JLabel - optiune, background-ul se schimba in galben. Daca se face click, backgroundul se schimba in alb si se considera optiunea selectata. Cand o optiune este selectata, automat se deselecteaza toate celalalte. Pentru factorul de certitudine va exista un JSlider (tot in partea dreapta, sub optiuni) cu valori de la 0 pana la maxim 100. Sub JSlider, va exista si un buton cu textul "am dat raspunsul" care, la click pe el, in cazul in care a fost selectata o optiune, va lua in considerare raspunsul dat si va trece la urmatoarea intrebare. Daca nu a fost selectata nicio optiune, se va afisa un alert (JOptionPane.showMessageDialog(...)) cu textul "Selectati intai un raspuns".
    2. Sub SplitPane va exista un JList cu numere de la 1 pana la numarul intrebarii la care tocmai se raspunde. La selectia unui anumit numar din JList se va afisa intrebarea cu acel numar, si optiunile in dreapta, cu raspunsul dat in continuare selectat, insa butonul care accepta raspunsul, nu va fi afisat (pentru intrebarile la care s-a raspuns deja). De asemenea, pentru intrebarile vechi, nu se va mai schimba background-ul nici la venirea cursorului pe optiuni si nici la click pe acestea Pe masura ce se raspunde la cate o intrebare, se adauga, cate o noua optiune cu numarul de ordine al acelei intrebari, in JList.
    3. La final, se vor afisa, unul sub altul, intr-un ScrollPane, folosind radiobutton-uri, raspunsurile cu factorii de certitudine. Initial niciun checkbox nu e selectat. Sub fiecare raspuns in parte va fi si poza personajului gasit. Sub ScrollPane va fi un Panel cu titlul "Descriere" (indicatie: BorderFactory.createTitledBorder()) in care se va gasi un JTextArea.
    4. La selectarea unui radiobutton, in JTextArea se va afisa descrierea personajului selectat (preluata din fisierul informatii_personaj.txt - atentie, textul va fi transmis prin Prolog - fisierul nu se va citi in Java). Apoi va fi o line despartitoare de forma "-------------------------------------------", iar sub linie va fi demonstratia pentru raspunsul respectiv (practic ce ar fi si in fisierul demonstratie_solutie_fc_timestamp.txt).
  5. Sistem expert care identifica un jucator de baschet conform descrierii acestuia (minim 20 solutii).

    1. regulile vor avea formatul (ceea ce e scris cu gri e doar comentariu, nu face parte din format):
      [id]regula (unde id este numarul regulii)
      Cu condiitiile [(conditiile enumerate intre paranteze drepte si cu virgule intre ele)
           [atr[valoare]], (pentru atribute cu valori multiple)
           [atr],(pentru atribute booleene, valoare true)
           [not[atr]] (pentru atribute booleene, valoare false)
      ]
      atribut_concluzie[valoare,FC=nr].
    2. intrebarile vor avea formatul:
      intrebare[ [atribut]
      ['continut intrebare']
      [val1 + val2 + val3 + ....].
    3. scopul se va defini:
      [scop[atr]].
    4. Programul Prolog va crea un director numit output_baschet (de fapt, daca exista deja, il va folosi pe acela, iar daca nu exista, il va crea - e obligatoriu de implementat acest test pentru a primi punctaj complet pe cerinta). Pentru fiecare solutie data de sistemul expert se va crea in cadrul directorului output_baschet cate un fisier numit otimestamp_nume, unde timestamp e valoarea calculata de now iar nume este numele baschetbalistului. In acest fisier se va scrie demonstratia asociata (forma de afisare a demonstratiei e afisata mai jos). Cuvantul solutie din numele fisierului va fi inlocuit cu valoarea solutiei iar fc cu factorul de certitudine. In fiecare fisier va fi scrisa demonstratia pentru solutia respectiva.
    5. Sistemul expert va crea un logfile, numit log_baschet.txt in care va scrie cate o linie pentru fiecare optiune din meniu pe care a ales-o, in felul urmator:
      (YYYY.Luna.DD, HH:MM:SS) actiune
      Unde cuvantul actiune va fi inlocuit cu optiunea din meniu. Ce este in paranteza reprezinta data si ora la care s-a intamplat actiunea: YYYY- anul pe 4 cifre, Luna - luna scrisa drept cuvant (de exemplu: aprilie, mai), DD ziua formata din 2 cifre (se pune 0 in fata pentru zile cu numar sub 10), iar HH,MM,SS reprezinta ora, minutul si secunda in care s-a introdus optiunea din meniu.
    6. In demonstratii, afisarea regulilor se va face exact in forma in care au fost scrise in fisierul de intrare.:
      [id]regula
      Cu condiitiile [
           [atr[valoare]],
           [atr],
           [not[atr]]
      ]
      atribut_concluzie[valoare,FC=nr].
      Forma de afisare a celorlalte tipuri de informatii din demonstratie se lasa la alegerea studentilor.

    Cerinte interfata grafica:

    1. Intrebarile vor fi afisate pe rand in aceeasi fereastra, intr-un ScrollPane (pe masura ce se raspunde la cate o intrebare, se adauga o noua intrebare la sfarsitul Scroll Pane-ului). Intrebarile vor fi numerotate (si deci vor aparea in panou in ordinea crescatoare a indicelui lor). Indicii for fi litere mici (a,b,c etc. In cazul in care se trece de intrabarea cu indicele z se porneste de la indicele aa, asa cum sunt denimite si coloanele in excel). Pentru fiecare intrebare se va scrie indicele urmat de textul intrebarii, folosind font Times New Roman. Indicii vor fi de culoare albastra si intrebarile cu culoare neagra. Sub intrebare se vor afisa optiunile. Pentru optiuni, indiferent de tipul de intrebare, veti folosi radiobutton-uri, avand drept text chiar textul optiunii. Pentru factorul de certitudine va exista un JSpinner (tot in partea dreapta, sub optiuni) cu valori de la 0 pana la maxim 100, si cu pasul 5. Un utilizator, pentru a raspunde la intrebare, Va ajusta JSpinnerul si apoi va face click pe checkboxul cu optiunea care ii convine. La apasarea tastei 'u' (de la 'urmator') se va afisa urmatoarea intrebare. In momentul in care se apsa aceasta tasta, toate optiunile-butoane se transforma in JLabeluri avand acelasi text si pozitie. Optiunea selectata va avea font bold si italic si un chenar albastru. Sub fosta intrebare curenta se afiseaza urmatoarea intrebare, cu indicele corespunzator (se va da scroll automat, ca sa nu fie nevoit utilizatorul sa dea scroll).
    2. La final cand sistemul expert va afisa solutiile , raspunsul va fi de forma: Baschetbalistii care se potrivesc descrierii sunt:
        - George Muresan fc 85
        - Tudor Adrian fc 60
      Fiecare solutie va fi pusa intr-un JLabel.
    3. La click pe un JLabel-raspuns(solutie posibila), se va afisa imediat sub el un JTextArea. In JTextArea se va afisa demonstratia pentru raspunsul respectiv. Demonstratia ramane afisata pana se face click pe alt JLabel-solutie, moment in care JTextArea-ul anterior este ascuns si se afiseaza sub solutia pe care s-a dat click JTextArea-ul cu demonstratia corespunzatoare. Solutia selectata la un moment dat, isi va schimba culoarea litererlor in albastru (textul initial e afisat cu litere de culoare neagra) si va reveni la culoarea initiala, cand e selectata o alta solutie.
    4. La ctrl+click pe JLabel-ul raspuns va fi deschisa o fereastra avand drept singur element poza baschetbalistului selectat. La dublu-click pe poza, se va mari de doua ori. La dublu-click pe poza marita, se va micsora la loc.