Laborator 1

Download source

// Daca se doreste utilizarea bibliotecii GLUT trebuie
// inclus fisierul header GL/glut.h (acesta va include
// la GL/gl.h si GL/glu.h, fisierele header pentru
// utilizarea bibliotecii OpenGL). Functiile din biblioteca
// OpenGL sunt prefixate cu gl, cele din GLU cu glu si
// cele din GLUT cu glut.
//#include
#include “glut.h”

#include
#include
#include

unsigned char prevKey;

void Display1() {
glColor3f(0.2,0.15,0.88); // albastru
glBegin(GL_LINES); // trasarea unei linii
glVertex2i(1,1); // coordonatele unui varf
glVertex2i(-1,-1);
glEnd();

glColor3f(1,0.1,0.1); // rosu
glBegin(GL_LINES);
glVertex2i(-1,1);
glVertex2i(1,-1);
glEnd();

glBegin(GL_LINES);
glVertex2d(-0.5,0);
glVertex2d(0.5,0);
glEnd();
}

void Display2() {
glColor3f(1,0.1,0.1); // rosu
glBegin(GL_LINES);
glVertex2f(1.0,1.0);
glVertex2f(0.9,0.9);
glVertex2f(0.8,0.8);
glVertex2f(0.7,0.7);
glVertex2f(0.6,0.6);
glVertex2f(0.5,0.5);
glVertex2f(-0.5,-0.5);
glVertex2f(-1.0,-1.0);
glEnd();
}

void Display3() {
// trasare puncte GL_POINTS : deseneaza n puncte
glColor3f(1,0.1,0.1); // rosu
glBegin(GL_POINTS);
glVertex2f(-0.5,0.5);
glVertex2f(-0.5,-0.5);
glVertex2f(0.5,-0.5);
glVertex2f(0.5,0.5);
glEnd();
glFlush();
}

void Display4() {
glColor3f(1,0.1,0.1); // rosu
// trasare linie poligonala GL_LINE_STRIP : (v0,v1), (v1,v2), (v_{n-2},v_{n-1})
glBegin(GL_LINE_STRIP);
glVertex2f(1.0,1.0);
glVertex2f(1.0,0.8);
glVertex2f(0.5,0.6);
glVertex2f(0.5,0.4);
// de completat …
glEnd();
}

void Display5() {
glColor3f(1,0.1,0.1); // rosu
// trasare linie poligonala inchisa GL_LINE_LOOP : (v0,v1), (v1,v2), (v_{n-1},v0)
glBegin(GL_LINE_LOOP);
glVertex2f(1.0,1.0);
glVertex2f(1.0,0.8);
glVertex2f(0.5,0.6);
glVertex2f(0.5,0.4);
glVertex2f(1.0,1.0);
// de completat …
glEnd();
}

void Display6() {
glColor3f(1,0.1,0.1); // rosu
// trasare triunghiuri GL_TRIANGLES : (v0,v1,v2), (v3,v4,v5), …
glBegin(GL_TRIANGLES);
glVertex2f(1.0,1.0);
glVertex2f(1.0,0.8);
glVertex2f(0.8,0.8);
glVertex2f(-1.0,-1.0);
glVertex2f(-1.0,-0.8);
glVertex2f(-0.8,-0.8);
// de completat …
glEnd();
}

void Display7() {
// trasare patrulatere GL_QUADS : (v0,v1,v2,v3), (v4,v5,v6,v7), …
glBegin(GL_QUADS);
// de completat …
glVertex2f(1.0,1.0);
glVertex2f(1.0,0.4);
glVertex2f(0.4,0.4);
glVertex2f(0.1,0.7);
glEnd();
}

void Display8() {
// trasare poligon convex GL_QUADS : (v0,v1,v2, …, v_{n-1})
glColor3f(0.2,0.15,0.88);
//glLineWidth(5);
glPolygonMode(GL_FRONT, GL_FILL);
glBegin(GL_POLYGON);

// de completat …
glVertex2f(0.4,0.4);
glVertex2f(-0.4,0.4);
glVertex2f(-0.65,0.0);
glVertex2f(-0.4,-0.4);
glVertex2f(0.4,-0.4);
glVertex2f(0.65,0.0);
glEnd();
glColor3f(1,1,1);
glPolygonMode(GL_FRONT, GL_FILL);
glBegin(GL_POLYGON);
// de completat …
glVertex2f(0.3,0.3);
glVertex2f(-0.3,0.3);
glVertex2f(-0.5,0.0);
glVertex2f(-0.3,-0.3);
glVertex2f(0.3,-0.3);
glVertex2f(0.5,0.0);
glEnd();

glColor3f(1,0.1,0.1);
glPolygonMode(GL_FRONT, GL_LINE);
glBegin(GL_POLYGON);
// de completat …
glVertex2f(0.3,0.3);
glVertex2f(-0.3,0.3);
glVertex2f(-0.5,0.0);
glVertex2f(-0.3,-0.3);
glVertex2f(0.3,-0.3);
glVertex2f(0.5,0.0);
glEnd();

}

void Init(void) {
// specifica culoarea unui buffer dupa ce acesta
// a fost sters utilizand functia glClear. Ultimul
// argument reprezinta transparenta (1 – opacitate
// completa, 0 – transparenta totala)
glClearColor(1.0,1.0,1.0,1.0);

// grosimea liniilor
glLineWidth(3);

// dimensiunea punctelor
glPointSize(4);

// functia void glPolygonMode (GLenum face, GLenum mode)
// controleaza modul de desenare al unui poligon
// mode : GL_POINT (numai vf. primitivei) GL_LINE (numai
// muchiile) GL_FILL (poligonul plin)
// face : tipul primitivei geometrice dpdv. al orientarii
// GL_FRONT – primitive orientate direct
// GL_BACK – primitive orientate invers
// GL_FRONT_AND_BACK – ambele tipuri
glPolygonMode(GL_FRONT, GL_LINE);
}

void Display(void) {
printf(“Call Displayn”);

// sterge buffer-ul indicat
glClear(GL_COLOR_BUFFER_BIT);

switch(prevKey) {
case ‘1′:
Display1();
break;
case ‘2′:
Display2();
break;
case ‘3′:
Display3();
break;
case ‘4′:
Display4();
break;
case ‘5′:
Display5();
break;
case ‘6′:
Display6();
break;
case ‘7′:
Display7();
break;
case ‘8′:
Display8();
break;
default:
break;
}

// forteaza redesenarea imaginii
glFlush();
}

/*
Parametrii w(latime) si h(inaltime) reprezinta noile
dimensiuni ale ferestrei
*/
void Reshape(int w, int h) {
printf(“Call Reshape : latime = %d, inaltime = %dn”, w, h);

// functia void glViewport (GLint x, GLint y,
// GLsizei width, GLsizei height)
// defineste poarta de afisare : acea suprafata dreptunghiulara
// din fereastra de afisare folosita pentru vizualizare.
// x, y sunt coordonatele pct. din stg. jos iar
// width si height sunt latimea si inaltimea in pixeli.
// In cazul de mai jos poarta de afisare si fereastra coincid
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
}

/*
Parametrul key indica codul tastei iar x, y pozitia
cursorului de mouse
*/
void KeyboardFunc(unsigned char key, int x, int y) {
printf(“Ati tastat . Mouse-ul este in pozitia %d, %d.n”,
key, x, y);
// tasta apasata va fi utilizata in Display ptr.
// afisarea unor imagini
prevKey = key;
if (key == 27) // escape
exit(0);
glutPostRedisplay();
}

/*
Codul butonului poate fi :
GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON, GLUT_RIGHT_BUTTON
Parametrul state indica starea: “apasat” GLUT_DOWN sau
“eliberat” GLUT_UP
Parametrii x, y : coordonatele cursorului de mouse
*/
void MouseFunc(int button, int state, int x, int y) {
printf(“Call MouseFunc : ati %s butonul %s in pozitia %d %dn”,
(state == GLUT_DOWN) ? “apasat” : “eliberat”,
(button == GLUT_LEFT_BUTTON) ?
“stang” :
((button == GLUT_RIGHT_BUTTON) ? “drept”: “mijlociu”),
x, y);
}

int main(int argc, char** argv) {
// Initializarea bibliotecii GLUT. Argumentele argc
// si argv sunt argumentele din linia de comanda si nu
// trebuie modificate inainte de apelul functiei
// void glutInit(int *argcp, char **argv)
// Se recomanda ca apelul oricarei functii din biblioteca
// GLUT sa se faca dupa apelul acestei functii.
glutInit(&argc, argv);

// Argumentele functiei
// void glutInitWindowSize (int latime, int latime)
// reprezinta latimea, respectiv inaltimea ferestrei
// exprimate in pixeli. Valorile predefinite sunt 300, 300.
glutInitWindowSize(300, 300);

// Argumentele functiei
// void glutInitWindowPosition (int x, int y)
// reprezinta coordonatele varfului din stanga sus
// al ferestrei, exprimate in pixeli.
// Valorile predefinite sunt -1, -1.
glutInitWindowPosition(100, 100);

// Functia void glutInitDisplayMode (unsigned int mode)
// seteaza modul initial de afisare. Acesta se obtine
// printr-un SAU pe biti intre diverse masti de display
// (constante ale bibliotecii GLUT) :
// 1. GLUT_SINGLE : un singur buffer de imagine. Reprezinta
// optiunea implicita ptr. nr. de buffere de
// de imagine.
// 2. GLUT_DOUBLE : 2 buffere de imagine.
// 3. GLUT_RGB sau GLUT_RGBA : culorile vor fi afisate in
// modul RGB.
// 4. GLUT_INDEX : modul indexat de selectare al culorii.
// etc. (vezi specificatia bibliotecii GLUT)
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

// Functia int glutCreateWindow (char *name)
// creeaza o fereastra cu denumirea data de argumentul
// name si intoarce un identificator de fereastra.
glutCreateWindow (argv[0]);

Init();

// Functii callback : functii definite in program si
// inregistrate in sistem prin intermediul unor functii
// GLUT. Ele sunt apelate de catre sistemul de operare
// in functie de evenimentul aparut

// Functia
// void glutReshapeFunc (void (*Reshape)(int width, int height))
// inregistreaza functia callback Reshape care este apelata
// oridecate ori fereastra de afisare isi modifica forma.
glutReshapeFunc(Reshape);

// Functia
// void glutKeyboardFunc (void (*KeyboardFunc)(unsigned char,int,int))
// inregistreaza functia callback KeyboardFunc care este apelata
// la actionarea unei taste.
glutKeyboardFunc(KeyboardFunc);

// Functia
// void glutMouseFunc (void (*MouseFunc)(int,int,int,int))
// inregistreaza functia callback MouseFunc care este apelata
// la apasarea sau la eliberarea unui buton al mouse-ului.
glutMouseFunc(MouseFunc);

// Functia
// void glutDisplayFunc (void (*Display)(void))
// inregistreaza functia callback Display care este apelata
// oridecate ori este necesara desenarea ferestrei: la
// initializare, la modificarea dimensiunilor ferestrei
// sau la apelul functiei
// void glutPostRedisplay (void).
glutDisplayFunc(Display);

// Functia void glutMainLoop() lanseaza bucla de procesare
// a evenimentelor GLUT. Din bucla se poate iesi doar prin
// inchiderea ferestrei aplicatiei. Aceasta functie trebuie
// apelata cel mult o singura data in program. Functiile
// callback trebuie inregistrate inainte de apelul acestei
// functii.
// Cand coada de evenimente este vida atunci este executata
// functia callback IdleFunc inregistrata prin apelul functiei
// void glutIdleFunc (void (*IdleFunc) (void))
glutMainLoop();

return 0;
}

Laboratorul 2

Arbore genealogic
(deffacts fapte
(parinti Maria_Alba Geanina_Alba Marian_Alba)
(parinti Claudia_Alba Marian_Alba Geanina_Alba)
(frati Alexandra_Popovici Ion_Popovici)
(soti Geanina_Alba Marian_Alba)
(soti Tina_Munteanu Vasile_Munteanu)
(frati Geanina_Alba Sonia_Turcescu)
(frati Geanina_Alba Marta_Leon)
(parinti Tina_Vlas Tina_Munteanu Vasile_Munteanu)
(parinti Monica_Munteanu Vasile_Munteanu Tina_Munteanu)
(frati Marian_Alba Zoe_Ungureanu)
(parinti Marian_Alba Tina_Munteanu Vasile_Munteanu)
(parinti Geanina_Alba Maia_Topala Gheoghe_Topala)
(parinti Tudor_Apostol Maia_Topala Gheoghe_Topala)
(parinti Roza_Apostol Mariana_Apostol Tudor_Apostol)
(frati Ion_Popovici Dana_Rogoz)
(parinti Alexandra_Popovici Camelia_Apostol Robert_Apostop)
(frati Camelia_Apostol Gigi_Burlacu)
(parinti Iuliana_Burlacu Nicoleta_Burlacu Gigi Burlacu)
(frati Sonia_Turcescu Tudor_Chirila)
(parinti Amanda_Low Silvia_Chirila Tudor_Chirila)
(parinti Gabriela_Leon Marta_Leon Titu_Leon)
(parinti Lidia_Turcescu Sonia_Turcescu Vasile_Turcescu)
)

(defrule meniu_principal
(not (optiune_principal ?))
=>
(printout t “1. Adauga” crlf)
(printout t “2. Cauta” crlf)
(printout t “3. Afisare” crlf)
(printout t “4. Iesire” crlf)
(printout t “Dati optiunea:” crlf)
(assert (optiune_principal (read)))
)

(defrule validare_principal
?a
(printout t “Nu ati introdus corect optiunea!” crlf)
(retract ?a)
(printout t “Introduceti din nou optiunea:” crlf)
(assert (optiune_principal (read)))
)

(defrule meniu_adauga
(optiune_principal 1)
(not (optiune_adauga ?))
=>
(printout t “1. Adauga parinti” crlf)
(printout t “2. Adauga frati/surori” crlf)
(printout t “3. Adauga sot/sotie” crlf)
(printout t “4. Iesire” crlf)
(printout t “Dati optiunea:” crlf)
(assert (optiune_adauga (read)))
)

(defrule validare_adauga
?a
(printout t “Nu ati introdus corect optiunea!” crlf)
(retract ?a)
(printout t “Introduceti din nou optiunea:” crlf)
(assert (optiune_adauga (read)))
)

(defrule adauga_parinti
?a
(printout t “Dati copilul si parintii: ” crlf)
(assert (parinti (read) (read) (read)))
(retract ?a)
)

(defrule adauga_frati
?a
(printout t “Dati frati:” crlf)
(assert (frati (read) (read)))
(retract ?a)
)

(defrule adauga_soti
?a
(printout t “Dati sot/sotie:” crlf)
(assert (soti (read) (read)))
(retract ?a)
)

(defrule adauga_iesire
?a<-(optiune_adauga 4)
?b
(retract ?a)
(retract ?b)
)

(defrule meniu_cauta
(optiune_principal 2)
(not (optiune_cauta ?))
=>
(printout t “1. Cauta frati” crlf)
(printout t “2. Cauta bunici” crlf)
(printout t “3. Cauta veri” crlf)
(printout t “4. Cauta cumnati” crlf)
(printout t “5. Cauta unchi/matusa” crlf)
(printout t “6. Cauta nepoti” crlf)
(printout t “7. Iesire” crlf)
(printout t “Dati optiunea:” crlf)
(assert (optiune_cauta (read)))
)

(defrule validare_cauta
?a
(printout t “Nu ati introdus corect optiunea!” crlf)
(retract ?a)
(printout t “Introduceti din nou optiunea:” crlf)
(assert (optiune_cauta (read)))
)

(defrule cauta_frati “facut la laborator”
(optiune_cauta 1)
(not (lista_frati $?))
=>
(printout t “Fratii pentru?” crlf)
(assert (lista_frati (read)))
)

(defrule completeaza_frati
(declare (salience 10))
?a
(retract ?a)
(assert (lista_frati $?x1 $?x2 ?x ?y))
)

(defrule completeaza_frati2
(declare (salience 12))
(or (and ?w<-(parinti ?x ?a ?b)
?q<-(parinti ?y ?a ?b)
)
(and ?w<-(parinti ?x ?a ?b)
?q
(assert (frati ?x ?y))
)

(defrule sterge_frati2
?a<-(frati ?x ?y)
?b
(retract ?a)
)

(defrule afiseaza_fratii
?a<-(optiune_cauta 1)
?b
(printout t “Frati: ” $?x crlf)
(retract ?a)
(retract ?b)
)

(defrule completeaza_parinti2
(declare (salience 12))
(or (frati ?x ?y)
(frati ?y ?x)
)
(parinti ?x ?a ?b)
(not (parinti ?y ? ?))

=>
(assert (parinti ?y ?a ?b))
)

(defrule cauta_bunici
(optiune_cauta 2)
(not (lista_bunici $?))
=>
(printout t “Bunicii pentru?” crlf)
(assert (nepot (read)))
(assert (lista_bunici))
)

(defrule completeaza_bunici
(declare (salience 10))
?a<-(nepot ?x)
?b
(retract ?b)
(assert (lista_bunici $?h ?z))
)

(defrule afisare_bunici
?a<-(optiune_cauta 2)
?b<-(lista_bunici $?h )
?c
(printout t “Bunicii: ” $?h crlf)
(retract ?a)
(retract ?b)
(retract ?c)
)

(defrule cauta_veri
(optiune_cauta 3)
(not (lista_veri $?))
=>
(printout t “Verii pentru?” crlf)
(assert (nume (read)))
(assert (lista_veri))
)
(defrule completeaza_veri1
(declare (salience 9))
?a<-(nume ?x)
?b
(retract ?b)
(assert (lista_veri $?h ?z))
)

(defrule completeaza_veri2
(declare (salience 8))
?a
(retract ?a)
(assert (lista_veri $?x1 $?x2 ?x ?z))
)
(defrule afisare_veri
?a<-(optiune_cauta 3)
?b<-(lista_veri $?h )
?c
(printout t “Veri: ” $?h crlf)
(retract ?a)
(retract ?b)
(retract ?c)
)

(defrule cauta_cumnati
(optiune_cauta 4)
(not (lista_cumnati $?))
=>
(printout t “Cumnati/cumnate pentru?” crlf)
(assert (nume (read)))
(assert (lista_cumnati))
)
(defrule completeaza_cumnati1
(declare (salience 9))
?a<-(nume ?x)
?b
(retract ?b)
(assert (lista_cumnati $?h ?z))
)

(defrule completeaza_cumnati2
(declare (salience 8))
?a
(retract ?a)
(assert (lista_cumnati $?x1 $?x2 ?x ?z))
)
(defrule afisare_cumnati
?a<-(optiune_cauta 4)
?b<-(lista_cumnati $?h )
?c
(printout t “Cumnati/Cumnate: ” $?h crlf)
(retract ?a)
(retract ?b)
(retract ?c)
)

(defrule cauta_unchi
(optiune_cauta 5)
(not (lista_unchi $?))
=>
(printout t “Unchi/matuse pentru?” crlf)
(assert (nume (read)))
(assert (lista_unchi))
)
(defrule completeaza_unchi1
(declare (salience 9))
?a<-(nume ?x)
?b
(retract ?b)
(assert (lista_unchi $?h ?z))
)

(defrule completeaza_unchi2
(declare (salience 8))
?a
(retract ?a)
(assert (lista_unchi $?x1 $?x2 ?x ?z))
)
(defrule afisare_unchi
?a<-(optiune_cauta 5)
?b<-(lista_unchi $?h )
?c
(printout t “Unchi/matuse: ” $?h crlf)
(retract ?a)
(retract ?b)
(retract ?c)
)

(defrule cauta_nepoti
(optiune_cauta 6)
(not (lista_nepoti $?))
=>
(printout t “Nepotii pentru?” crlf)
(assert (bunic (read)))
(assert (lista_nepoti))
)

(defrule completeaza_nepoti
(declare (salience 10))
?a<-(bunic ?x)
?b
(retract ?b)
(assert (lista_nepoti $?h ?z))
)

(defrule afisare_nepoti
?a<-(optiune_cauta 6)
?b<-(lista_nepoti $?h )
?c
(printout t “Nepoti: ” $?h crlf)
(retract ?a)
(retract ?b)
(retract ?c)
)

(defrule cauta_iesire
?a<-(optiune_cauta 7)
?b
(retract ?a)
(retract ?b)
)

(defrule meniu_afisare
(optiune_principal 3)
(not (optiune_afisare ?))
=>
(printout t “1. Afisare frati” crlf)
(printout t “2. Afisare soti” crlf)
(printout t “3. Afisare parinti” crlf)
(printout t “4. Afisare bunici/nepoti” crlf)
(printout t “5. Iesire” crlf)
(printout t “Dati optiunea:” crlf)
(assert (optiune_afisare (read)))
)

(defrule validare_afisare
?a
(printout t “Nu ati introdus corect optiunea!” crlf)
(retract ?a)
(printout t “Introduceti din nou optiunea:” crlf)
(assert (optiune_afisare (read)))
)

(defrule afiseaza_frati1
?a
(assert (afiseaza_frati))
(retract ?a)
)

(defrule afiseaza_frati2
(declare (salience 10))
?a
(printout t ?x ” este fratele/sora lui ” ?y crlf)
)

(defrule afiseaza_soti1
?a
(assert (afiseaza_soti))
(retract ?a)
)
(defrule afiseaza_soti2
(declare (salience 10))
?a
(printout t ?x ” este casatorit(a) cu ” ?y crlf)

)

(defrule afiseaza_parinti1
?a
(assert (afiseaza_parinti))
(retract ?a)
)
(defrule afiseaza_parinti2
(declare (salience 11))
?a
(printout t “Parintii lui ” ?x ” sunt ” ?y ” si ” ?z crlf)

)
(defrule afiseaza_bunici1
?a
(assert (afiseaza_bunici))
(retract ?a)
)

(defrule afiseaza_bunici2
(declare (salience 10))
?a
(printout t ?y ” si ” ?k ” sunt bunicii lui ” ?z crlf)
)

(defrule afisare_iesire

?a<-(optiune_afisare 5)
?b
(retract ?a)
(retract ?b)
)

Altele

Exemplu
(deffacts fapte
(curs ia pbr)
)
(defrule afisare
(curs $? ?x $?)
=>
(printout t “curs:” ?x crlf))

Exemplu
(deffacts fapte
(curs ia pbr)
)
(defrule afisare
(curs $?x)
=>
(printout t “curs:” $?x crlf))

Exemplu
(deffacts fapte
(curs ia)
(curs pbr)
)
(defrule afisare
(curs ?x)
=>
(printout t “curs:” ?x crlf))

Exemplu
(deffacts fapte
(curs ia pbr)
(prof ia cristea)
(prof pbr cristea2)
)
(defrule afisare
(curs $? ?x $?)
(prof ?x ?y)
=>
(printout t “cursul: ” ?x ” are ca profesor: ” ?y crlf))

Exemplu
(deffacts fapte
(curs ia pbr)
)
(defrule afisare
(curs $? ?x $?)
(not (prof ?x ?))
=>
(printout t “Dati prof pt: ” ?x crlf)
(assert (prof ?x (read)))
)

Laboratorul 1

Varianta 1
(deffacts a
(forma patrulater)
(unghi drept)
(laturi egale)
)
(defrule patrat
(forma patrulater)
(unghi drept)
(laturi egale)
=>
(assert (patrat))
)
(defrule dreptunghi
(forma patrulater)
(unghi drept)
(not (laturi egale))
=>
(assert (dreptunghi))
)
(defrule trapez
(forma patrulater)
(not (unghi drept))
(not (laturi egale))
=>
(assert (trapez))
)
(defrule altceva
(not (forma patrulater))
(not (unghi drept))
(not (laturi egale))
=>
(assert (altceva))
)
(defrule romb
(forma patrulater)
(not (unghi drept))
(laturi egale)
=>
(assert (romb))
)

Varianta 2
(deffacts a (patrulater da) (laturiegale nu) (unghidrept da))
(defrule test1D (patrulater da) => (assert (dotest2)))
(defrule test1N (patrulater nu) => (assert (altceva)))
(defrule test2D (dotest2)(unghidrept da) => (assert (dotest3)))
(defrule test2N (dotest2) (unghidrept nu) => (assert (dotest4)))
(defrule test3D (dotest3) (laturiegale da) => (assert (patrat)))
(defrule test3N (dotest3) (laturiegale nu) => (assert (dreptunghi)))
(defrule test4D (dotest4) (laturiegale da) => (assert (romb)))
(defrule test4N (dotest4) (laturiegale nu) => (assert (trapez)))

Varianta 3
(deffacts s (forma patrulater) (unghiuri drepte))
(defrule a (forma patrulater) => (assert (unghi)))
(defrule b (not (forma patrulater)) => (assert (altceva)))
(defrule c (unghi) (or (unghiuri drepte) (not (unghiuri drepte))) => (assert (laturi)))
(defrule e (laturi) (laturi egale) (unghiuri drepte) => (assert (patrat)))
(defrule f (laturi) (laturi egale) (not(unghiuri drepte)) => (assert (trapez)))
(defrule d (laturi) (not (laturi egale)) (unghiuri drepte) => (assert (dreptunghi)))
(defrule g (laturi) (not(laturi egale)) (not(unghiuri drepte)) => (assert (patrat)))

Varianta 4
(deffacts f
(forma patrulater)
(unghiuri nedrepte)
(laturi inegale)
)

(defrule patrat
(forma patrulater)
(unghiuri drepte)
(laturi egale)
=>
(assert (patrat))
)

(defrule dreptunghi
(forma patrulater)
(unghiuri drepte)
(laturi inegale)
=>
(assert (dreptunghi))
)

(defrule romb
(forma patrulater)
(unghiuri nedrepte)
(laturi egale)
=>
(assert (romb))
)

(defrule trapez
(forma patrulater)
(unghiuri nedrepte)
(laturi inegale)
=>
(assert (trapez))
)

(defrule altceva
(forma nepatrulater)
(unghiuri nedrepte)
(laturi inegale)
=>
(assert (altceva))
)

Varianta 5
(deffacts fapte
(forma patrulater)
)

(defrule r1
?f
(assert (unghiuridrepte))
(retract ?f)
)

(defrule r2
(unghiuridrepte)
=>
(assert (laturiegale))
)

(defrule r3
?l
(assert (patrat))
(retract ?l)
)

(defrule r4
(not(laturiegale))
?u
(assert (dreptunghi))
(retract ?u)
)

(defrule r5
(not(unghiuridrepte))
=>
(assert (laturiegale2))
)

(defrule r6
?le
(assert (romb))
(retract ?le)
)

(defrule r7
(not(laturiegale2))
=>
(assert (trapez))
)

(defrule r8
(not(forma patrulater))
=>
(assert (altceva))
)

Varianta 6
(deffacts fapte
(forma patrulater)
(unghiuri drepte)
(laturi neegale)
)

(defrule r1
?f
(assert (unghiuridrepte))
(retract ?f)
)

(defrule r2
?u<-(unghiuridrepte)
?u2
(assert (laturiegale1))
(retract ?u)
(retract ?u2)
)
(defrule r3
?u
(assert (laturiegale2))
(retract ?u)
)

(defrule r4
?l<-(laturiegale1)
?l2
(assert (patrat))
(retract ?l)
(retract ?l2)
)

(defrule r5
?l
(assert (dreptunghi))
(retract ?l)
)

(defrule r6
?l
(assert (romb))
(retract ?l)
)

(defrule r7
?l
(assert (trapez))
(retract ?l)
)

(defrule r8
(not (or (patrat) (dreptunghi) (trapez) (romb)))
=>
(assert (altceva))
)

Varianta 7
(deffacts fapte
(patrulater da)
(unghiuri da)
(laturi nu)
)

(defrule r1
(patrulater da)
=>
(assert (unghi))
)

(defrule r2
(unghi)
=>
(assert (laturi))
)

(defrule r3
(laturi)
(unghiuri da)
(laturi da)
=>
(assert (patrat))
)

(defrule r4
(laturi)
(unghiuri da)
(laturi nu)
=>
(assert (dreptunghi))
)

(defrule r5
(laturi)
(unghiuri nu)
(laturi da)
=>
(assert (romb))
)

(defrule r6
(laturi)
(unghiuri nu)
(laturi nu)
=>
(assert (trapez))
)

(defrule reg7
(patrulater nu)
=>
(assert (altceva))
)

Varianta 8
(deffacts fapte (stareinitiala))
(defrule patrulater
(stareinitiala)
=>
(printout t “Este patrulater?”)
(assert (patrulater (read)))
)
(defrule unghiuridrepte
(patrulater da)
=>
(printout t “Are ungiuri drepte?”)
(assert (unghiuridrepte (read)))
)
(defrule laturiegale
(unghiuridrepte ?)
=>
(printout t “Are laturi egale?”)
(assert (laturiegale (read)))
)
(defrule patrat
(unghiuridrepte da)
(laturiegale da)
=>(printout t “Este patrat!”)
)
(defrule dreptughi
(unghiuridrepte da)
(laturiegale nu)
=>(printout t “Este dreptunghi!”)
)
(defrule romb
(unghiuridrepte nu)
(laturiegale da)
=>(printout t “Este romb!”)
)
(defrule trapez
(unghiuridrepte nu)
(laturiegale nu)
=>(printout t “Este trapez!”)
)
(defrule altceva
(patrulater nu)
=>(printout t “Este altceva!”)
)