UNIVERSITATEA DE VEST TIMIŞOARA

FACULTATEA DE MATEMATICA SI INFORMATICA

SPECIALIZAREA INFORMATICA

TEME - PROIECT INDIVIDUAL

STUDENT:

Făsui Ionuț Bogdan

Anul II , gr 2

Timişoara 2011
//P8_1

/* Definiti si implementati clasa Dreptunghi, avand ca date membri: lungimea si latimea si ca functii

memebri: un constructor, SetLungime, SetLatime, GetLungime, GetLatime, Arie si Perimetru */

#include<stdio.h>

class Dreptunghi

public:

int lungime, latime;

Dreptunghi();

int getLungime();

void setLungime(int lungime);

int getLatime();

void setLatime(int latime);

int Arie();

int Perimetru();

};

Dreptunghi:: Dreptunghi()

(*this).lungime=0;

(*this).latime=0;

int Dreptunghi:: getLungime()

return (*this).lungime;

void Dreptunghi:: setLungime(int lungime)

(*this).lungime=lungime;
}

int Dreptunghi:: getLatime()

return (*this).latime;

void Dreptunghi:: setLatime(int latime)

(*this).latime=latime;

int Dreptunghi:: Arie()

int arie;

return arie=lungime*latime;

int Dreptunghi:: Perimetru()

int perimetru;

return perimetru=2*(lungime+latime);

int main()

Dreptunghi d;

d.setLungime(4);

d.setLatime(3);

printf("Latimea dreptunghiului este: %d\n", d.getLatime());

printf("Lungimea dreptunghiului este: %d", d.getLungime());

printf("\nAria dreptunghiului este: %d",d.Arie());

 printf("\nPerimetrul dreptunghiului este: %d",d.Perimetru());

return 0;

#include <iostream>

#include <cmath>

using namespace std;

class Punct3 {

public:

double x;

double y;

double z;

public:

Punct3()

(*this).x=0;

(*this).y=0;

(*this).z=0;

void setX(double x)

(*this).x=x;

void setY(double y)

(*this).y=y;

}
 void setZ(double z)

(*this).z=z;

double getX()

return (*this).x;

double getY()

return (*this).y;

double getZ()

return (*this).z;

Punct3 rotatieX(float u)

Punct3 q=Punct3();

q.x=(*this).x;

q.y=(*this).y*cos(u)-(*this).z*sin(u);

q.z=(*this).y*sin(u)+(*this).z*cos(u);

return q;

Punct3 rotatieY(float u)

Punct3 q=Punct3();

q.x=(*this).x*cos(u)+(*this).z*sin(u);
 q.y=(*this).y;

q.z=-((*this).y)*sin(u)+(*this).z*cos(u);

return q;

Punct3 rotatieZ(float u)

Punct3 q=Punct3();

q.x=(*this).x*cos(u)-(*this).y*sin(u);

q.y=(*this).x*sin(u)+(*this).y*cos(u);

q.z=(*this).z;

return q;

};

double distanta(Punct3 p, Punct3 q)

double k;

k=abs(p.x-q.x)+abs(p.y-q.y)+abs(p.z-q.z);

return k;

int operator==(Punct3 p, Punct3 q)

if(p.x==q.x && p.y==q.y && p.z==q.z)

return 1;

else return 0;

/*void operator<<(Punct3 p)

printf("Coordonata x este %2.2f\n",p.getX());

 printf("Coordonata y este %2.2f\n",p.getY());

printf("Coordonata z este %2.2f\n",p.getZ());

}*/

int main()

float t;

Punct3 p=Punct3();

p.setX(1);

p.setY(2);

p.setZ(3);

cout<<"Coordonata x este "<<p.getX()<<endl;

cout<<"Coordonata y este "<<p.getY()<<endl;

cout<<"Coordonata z este "<<p.getZ()<<endl;

cout<<"Dati un unghi";

cin>>t;

printf("Rotatie in jurul lui x: \n");

Punct3 r=p.rotatieX(t);

printf("Coordonata x este %2.2f\n",r.getX());

printf("Coordonata y este %2.2f\n",r.getY());

printf("Coordonata z este %2.2f\n",r.getZ());

printf("\nRotatie in jurul lui y: \n");

Punct3 s=p.rotatieY(t);

printf("Coordonata x este %2.2f\n",s.getX());

printf("Coordonata y este %2.2f\n",s.getY());

printf("Coordonata z este %2.2f\n",s.getZ());

printf("\nRotatie in jurul lui z: \n");

Punct3 v=p.rotatieZ(t);

printf("Coordonata x este %2.2f\n",v.getX());

 printf("Coordonata y este %2.2f\n",v.getY());

printf("Coordonata z este %2.2f\n",v.getZ());

//testarea functiei distanta

printf("\nDistanta este: %f\n", distanta(r,s));

//supraincarcarea operatorului ==

if(operator==(p,p)==1)

printf("\nPunctele coincid.\n");

else printf("\nPunctele nu coincid.\n");

return 0;

//supraincarcarea operatorului <<

/* operator<<(p);*/

}
//P8_3

/* Proiectati si implementati o clasa Aleator, care genereaza o secventa de numere intregi

pseudoaleatoare, folosind metoda congruentei liniare. In aceasta metoda se folosesc 4 intregi:

samanta, inmultitorul, incrementul si modulul. Cu formula:

(samanta * inmultitor + increment) % modul se genereaza cate un numar aleator, care devine

samanta. In acest mod se genereaza "modulo" numerele diferite.

Constructorul clasei are ca argumente samanta initiala, inmultitorul, incrementul si modulul.

Se vor prevedea functii membri pentru:

- schimbarea samantei;

- generara urmatorului numar din secventa de numere aleatoare.

*/

#include<stdio.h>

class Aleator

private:

int samanta, inmultitor, increment, modul;

public:

Aleator(int s,int i, int in, int m);

int getSamanta();

int getInmultitor();

int getIncrement();

int getModul();

void setSamanta(int samanta);

int generare();

};
Aleator:: Aleator(int s,int i, int in, int m)

(*this).samanta=s;

(*this).inmultitor=i;

(*this).increment=in;

(*this).modul=m;

int Aleator:: getSamanta()

return (*this).samanta;

int Aleator:: getInmultitor()

return (*this).inmultitor;

int Aleator:: getIncrement()

return (*this).increment;

int Aleator:: getModul()

return (*this).modul;

void Aleator:: setSamanta(int samanta) //samanta este noua samanta, (*this).samanta=samanta initiala

(*this).samanta=samanta;

int Aleator:: generare()

{

int s;

s=((*this).samanta * (*this).inmultitor + (*this).increment) % (*this).modul;

return s;

int main()

int n; //cate numere generam

Aleator nr1=Aleator(6,3,4,5);

printf("Samanta=%d\nInmultitor=%d\nIncrement=%d\nModul=
%d\n",nr1.getSamanta(),nr1.getInmultitor(),nr1.getIncrement(), nr1.getModul());

printf("Dati numarul de numere aleatoare care vreti sa fie generate: ");

scanf("%d",&n);

printf("Numerele sunt:\n");

do

nr1.setSamanta(nr1.generare());

printf("%d ",nr1.getSamanta());

n=n-1;

} while(n!=0);

return 0;

//P8_5
#include<iostream>

using namespace std;

class multime { public:

int reprezentant;

unsigned char*p;

multime(int);

multime(multime&m);

~multime();

int apartine(int k);

void adauga(int k);

void scoate(int k);

void operator +=(multime m);

void operator *=(multime m);

friend multime operator +(multime m1,multime m2);

friend multime operator *(multime m1,multime m2);

};

multime::multime(int rep=1)

{int i;

reprezentant=rep;

p=new unsigned char[rep];

 for(i=0;i<reprezentant;i++)

p[i]=0;

multime::multime(multime&m)

{int i;

reprezentant=m.reprezentant;

for(i=0;i<reprezentant;i++)

p[i]=m.p[i];}

multime::~multime()

{delete p;}

int multime::apartine(int k)

{unsigned char nr_bit=7-k%8,masca=1;

int nr_octet=k/8;

masca=masca<<nr_bit;

if(p[nr_octet]&masca) return 1;

else return 0;

void multime:: adauga(int k)

{unsigned char nr_bit=7-k%8,masca=1;

int nr_octet=k/8;

masca=masca<<nr_bit;

p[nr_octet]=p[nr_octet] | masca;

}
void multime::scoate(int k)

{unsigned char nr_bit=7-k%8,masca=1;

int nr_octet=k/8;

masca=masca<<nr_bit;

masca=~masca;

p[nr_octet]=p[nr_octet] & masca;

void multime:: operator +=(multime m)

{unsigned char *p1;

int i;

if(m.reprezentant>reprezentant)

{ p1=new unsigned char[m.reprezentant];

for(i=0;i<reprezentant;i++)

p1[i]=p[i]| m.p[i];

for(i=reprezentant; i<m.reprezentant;i++)

p1[i]=m.p[i];

reprezentant=m.reprezentant;

delete p;

p=p1;

else

for(i=0;i<m.reprezentant;i++)

p[i]=p[i]| m.p[i];

void multime:: operator *=(multime m)

{

int i;

if(m.reprezentant>reprezentant)

for(i=0;i<reprezentant;i++)

p[i]=p[i]& m.p[i];

else

{for(i=0;i<m.reprezentant;i++)

p[i]=p[i]| m.p[i];

reprezentant=m.reprezentant;

multime operator +(multime m1,multime m2)

{multime m=m1;

m+=m2;

return m;

multime operator *(multime m1,multime m2)

{multime m=m1;

m*=m2;

return m;

//P8_6
#include<iostream>

using namespace std;

class Parabola

{double a,b,c;

public:

void parabola()

{a=b=c=0;}

void sch_coef(double a,double b,double c);

float reta();

double retb();

double retc();

double eval(double x);

int nr_rad();

friend Parabola operator +(Parabola p1,Parabola p2);

friend Parabola operator *(double k,Parabola p);

};

void Parabola:: sch_coef(double a,double b,double c)

{(*this).a=a;

(*this).b=b;

(*this).c=c;

float Parabola:: reta()

{return a;}

double Parabola::retb()

{return b;}
double Parabola::retc()

{return c;}

double Parabola::eval(double x)

{return a*x*x+b*x+c;}

int Parabola::nr_rad()

{double delta;

if(a!=0)

{delta=b*b-4*a*c;

if(delta>=0)

return 2;

else

return 0;

else if (b!=0) return 1;

else return -1;

Parabola operator +( Parabola p1,Parabola p2)

{Parabola pp;

pp.a=p1.a+p2.a;

pp.b=p1.b+p2.b;

pp.c=p1.c+p2.c;

return pp;

Parabola operator *( double k,Parabola p)

{Parabola pp;
 pp.a=k*p.a;

pp.b=k*p.b;

pp.c=k*p.c;

return pp;

int main()

{}

//P8_7
#include <iostream>

using namespace std;

class vector

public:

int d;

int v[20];

public:

vector()

(*this).d=10;

for(int i=0;i<10;i++)

(*this).v[i]=0;

vector(int d)

int i;

(*this).d=d;

for(i=0;i<d;i++)

(*this).v[i]=0;

vector(vector const &m)

int i;

(*this).d=m.d;

for(i=0;i<d;i++)

(*this).v[i]=m.v[i];
}

~vector();

int getD()

return (*this).d;

void setD(int d)

(*this).d=d;

vector operator+=(vector u)

vector rez;

if(u.d==d)

rez.d=d;

for(int i=0;i<d;i++)

rez.v[i]=v[i]+u.v[i];

return rez;

else printf("Eroare!Vectori de dimensiuni diferite!\n");

vector operator-=(vector u)

vector rez;

if(u.d==d)

{
 rez.d=d;

for(int i=0;i<d;i++)

rez.v[i]=v[i]-u.v[i];

return rez;

else printf("Eroare!Vectori de dimensiuni diferite!\n");

void afisare()

cout << "Elementele vectorului sunt: ";

for(int i=0;i<(*this).d;i++)

printf("%d ", v[i]);

friend istream & operator >> (istream & fl, vector &v);

};

istream & operator >> (istream & fl, vector &v)

fl >> v.d;

for (int i = 0; i < v.d; i++)

fl >> v.v[i];

return fl;

ostream & operator << (ostream & fl, vector &v)

for (int i = 0; i < v.d; i++)

fl << v.v[i] << " ";

fl<<endl;
 return fl;

int operator==(vector v1, vector v2)

if(v1.d!=v2.d)

return 0;

else

for(int i=0;i<v1.d;i++)

if(v1.v[i]!=v2.v[i])

return 0;

return 1;

vector operator+(vector v1, vector v2)

vector rez;

if(v1.d==v2.d)

rez.d=v1.d;

for(int i=0;i<v1.d;i++)

rez.v[i]=v1.v[i]+v2.v[i];

return rez;

else printf("Eroare!Vectori de dimensiuni diferite!\n");

vector operator-(vector v1, vector v2)

vector rez;
 if(v1.d==v2.d)

rez.d=v1.d;

for(int i=0;i<v1.d;i++)

rez.v[i]=v1.v[i]-v2.v[i];

return rez;

else printf("Eroare!Vectori de dimensiuni diferite!\n");

double operator*(vector v1, vector v2)

double rez=0;

if(v1.d==v2.d)

for(int i=0;i<v1.d;i++)

rez=rez+v1.v[i]*v2.v[i];

return rez;

else printf("Eroare!Vectori de dimensiuni diferite!\n");

int main()

vector v1,v2,reza,rezs,v3,v4,vect;

double prodscalar;

cout<<"dati elementele vectorului, incepand cu d-dimensiunea vectorului ";cin>>v1;cout<<endl;

cout<<"vectorul are dimensiunea "<<v1.getD()<<endl;

v1.afisare();cout<<endl;

v2=vector();v2.afisare();cout<<endl;
 cout<<"dati elementele vectorului, incepand cu d-dimensiunea vectorului ";cin>>v2;cout<<endl;

cout<<"vectorul are dimensiunea "<<v2.getD()<<" si elementele "<<v2;

v3=v1+=v2;

v4=v1-=v2;

cout<<"dupa adunare: "<<v3;cout<<endl;

cout<<"dupa scadere: "<<v4;cout<<endl;

reza=v1+v2;cout<<"dupa adunare: "<<reza<<endl;

rezs=v1-v2;cout<<"dupa scadere: "<<rezs<<endl;

prodscalar=v1*v2;cout<<"produsul scalar al vectorilor este: "<<prodscalar<<endl;

vect=vector(v1);vect.afisare();cout<<endl;

if(v1==vect)

printf("vectorii sunt egali!");

else printf("vectorii sunt diferiti!");

return 0;

//P8_8
#include <iostream>

#include<math.h>

using namespace std;

class Matrice

public:

int n;

float m[10][10];

Matrice(int n)

(*this).n=n;

for(int i=0;i<n;i++)

for(int j=0;j<n;j++)

m[i][j]=0;

Matrice()

(*this).n=10;

for(int i=0;i<n;i++)

for(int j=0;j<n;j++)

(*this).m[i][j]=0;

~Matrice(){}

Matrice(Matrice const &sursa)

(*this).n=sursa.n;

for(int i=0;i<n;i++)

for(int j=0;j<n;j++)
 (*this).m[i][j]=sursa.m[i][j];

void citire()

int i,j;

printf("Introduceti elementele matricei: \n");

for(i=0;i<n;i++)

for(j=0;j<n;j++)

printf("m[%d][%d]=",i,j);

scanf("%f",&m[i][j]);

void afisare()

int i,j;

printf("Elementele matricei sunt: \n");

for(i=0;i<n;i++)

for(j=0;j<n;j++)

printf("%7.2f ",m[i][j]);

printf("\n");

int getDim()

return (*this).n;

}
void setDim(int n)

(*this).n=n;

Matrice submatrice(Matrice sursa,int indice1,int indice2)

int i,n;

n=sursa.getDim();

Matrice d=Matrice(sursa);

for(i=0;i<n;i++)

int c=indice2;

while(c<n)

d.m[i][c]=d.m[i][c+1];

c++;

for(i=0;i<n;i++)

int c=indice1;

while(c<n)

d.m[c][i]=d.m[c+1][i];

c++;

}
 d.setDim(n-1);

return d;

float det(Matrice sursa)

{ float rez=0;

int p=sursa.getDim();

switch(p){

case 1: return sursa.m[0][0];break;

case 2: return sursa.m[0][0]*sursa.m[1][1]-sursa.m[0][1]*sursa.m[1][0];break;

case 3: return sursa.m[0][0]*sursa.m[1][1]*sursa.m[2][2]+sursa.m[0][1]*sursa.m[1]

[2]*sursa.m[2][0]+sursa.m[1][0]*sursa.m[2][1]*sursa.m[0][2]-sursa.m[0][2]*sursa.m[1][1]*sursa.m[2]
[0]-sursa.m[2][1]*sursa.m[1][2]*sursa.m[0][0]-sursa.m[2][2]*sursa.m[1][0]*sursa.m[0][1];break;

default:{

for(int i=0;i<p;i++)

Matrice s=sursa.submatrice(sursa,0,i);

rez=rez+sursa.m[0][i]*pow((-1),i)*s.det(s);

return rez;

break;

Matrice inversa(Matrice const &sursa)

float d=det(sursa);//determinantul matricei

if(d!=0)
 {

(*this).n=sursa.n;

for(int i=0;i<n;i++)

for(int j=0;j<n;j++)

(*this).m[j][i]=sursa.m[i][j];//calculul transpusei

Matrice t=(*this);//salvarea transpusei

for(int i=0;i<n;i++)

for(int j=0;j<n;j++)

Matrice s=submatrice(t,i,j);//calculul matricei formate prin eliminarea liniei i si

coloanei j in transpusa

(*this).m[i][j]=(1/d)*pow(-1,(i+j))*s.det(s);//calculul inversei

return *this;

else printf("Eroare!Matricea nu este inversabila!\n");

Matrice operator +=(Matrice alta)

int i,j;

Matrice rez;

if(alta.n!=(*this).n)

printf("Matricile au dimensiuni diferite deci nu se pot aduna!\n");

else

rez.n=(*this).n;

for(i=0;i<n;i++)

for(j=0;j<n;j++)
 rez.m[i][j]=alta.m[i][j]+(*this).m[i][j];

return rez;

Matrice operator -=(Matrice alta)

int i,j;

Matrice rez;

if(alta.n!=(*this).n)

printf("Matricile au dimensiuni diferite deci nu se pot scadea!\n");

else

rez.n=(*this).n;

for(i=0;i<n;i++)

for(j=0;j<n;j++)

rez.m[i][j]=(*this).m[i][j]-alta.m[i][j];

return rez;

Matrice operator*=(Matrice alta)

int i,j,k;

float sum=0;

Matrice rez;

if(alta.n!=(*this).n)

printf("Matricile au dimensiuni diferite deci nu se pot inmultii!\n");

else

{
 rez.n=(*this).n;

for(i=0;i<n;i++)

for(j=0;j<n;j++)

sum=0;

for(k=0;k<n;k++)

sum=sum+((*this).m[i][k]*alta.m[k][j]);

rez.m[i][j]=sum;

return rez;

friend istream & operator >> (istream & fl, Matrice &m);

};

int operator==(Matrice a, Matrice b)

int i,j;

if(a.n!=b.n) return 0;

else

for(i=0;i<a.n;i++)

for(j=0;j<a.n;j++)

if(a.m[i][j]!=b.m[i][j]) return 0;

return 1;

Matrice operator +(Matrice a,Matrice b)

{
 int i,j;

Matrice rez;

if(a.n!=b.n)

printf("Matricile au dimensiuni diferite deci nu se pot aduna!\n");

else

rez.n=a.n;

for(i=0;i<a.n;i++)

for(j=0;j<b.n;j++)

rez.m[i][j]=a.m[i][j]+b.m[i][j];

return rez;

Matrice operator -(Matrice a,Matrice b)

int i,j;

Matrice rez;

if(a.n!=b.n)

printf("Matricile au dimensiuni diferite deci nu se pot scadea!\n");

else

rez.n=a.n;

for(i=0;i<a.n;i++)

for(j=0;j<b.n;j++)

rez.m[i][j]=a.m[i][j]-b.m[i][j];

return rez;

}
Matrice operator*(Matrice a,Matrice b)

int i,j,k;

float sum=0;

Matrice rez;

if(a.n!=b.n)

printf("Matricile au dimensiuni diferite deci nu se pot inmultii!\n");

else

rez.n=a.n;

for(i=0;i<a.n;i++)

for(j=0;j<a.n;j++)

sum=0;

for(k=0;k<a.n;k++)

sum=sum+(a.m[i][k]*b.m[k][j]);

rez.m[i][j]=sum;

return rez;

istream & operator >> (istream & fl, Matrice &m)

int i,j;

fl >> m.n;

for (i = 0; i < m.n; i++)

 for(j = 0; j < m.n; j++)

fl >> m.m[i][j];

return fl;

ostream & operator << (ostream & fl, Matrice &m)

int i, j;

for (i = 0; i < m.n; i++)

for(j = 0; j < m.n; j++)

fl<<m.m[i][j]<< " ";

fl<<endl;

return fl;

int main()

Matrice m=Matrice(4);

m.citire();

printf("dupa citire ");

m.afisare();

Matrice n=Matrice(m);

printf("dupa utilizarea constructorului de copiere ");

n.afisare();

printf("dimensiunea matricei n este: %dx%d\n",n.getDim(),n.getDim());

if(m==n) printf("matricile sunt egale!\n");

else printf("matricile nu sunt egale!\n");

 Matrice reza=(m+=n);

printf("dupa adunare ");

reza.afisare();

Matrice rezs=(m-=n);

printf("dupa scadere ");

rezs.afisare();

Matrice rezi=(m*=n);

printf("dupa inmultire ");

rezi.afisare();

printf("determinantul matricii este:%.2f \n",n.det(n));

Matrice trans=trans.inversa(m);

trans.afisare();

Matrice v;

cout<<"Dati elemetele matricei v, incepand cu n-dimensiunea matricei: "<<endl;cin>>v;

cout<<"matricea v este: "<<endl;

cout<<v;

return 0;

//P_9
#include <iostream>

#define pi 3.14

class Forma

protected:

double x,y;

public:

Forma(double h=0,double v=0)

(*this).x=h;

(*this).y=v;

virtual double Perimetru(){}

virtual double Arie()=0;

};

class Dreptunghi : public Forma

public:

Dreptunghi(double h=0,double v=0):Forma(x,y){}

double getX()

return (*this).x;

void setX(double x)

(*this).x=x;

}
 double getY()

return (*this).y;

void setY(double y)

(*this).y=y;

double Perimetru()

double x=(*this).x;

double y=(*this).y;

return 2*(x+y);

double Arie()

return (*this).x*(*this).y;

};

class Cerc : public Forma

protected:

double raza;

public:

Cerc(double h=0,double v=0,double r=0):Forma(x,y)

(*this).raza=r;

}
 void setRaza(double raza)

(*this).raza=raza;

double getRaza()

return (*this).raza;

double Perimetru()

return 2*pi*raza;

double Arie()

return pi*(*this).raza*(*this).raza;

};

int main()

Dreptunghi d=Dreptunghi(10,15);

Cerc c=Cerc(10,15,5);

d.setX(10);

d.setY(20);

printf("Dreptungiul cu latimea %.2f si lungimea %.2f are perimetrul %.2f si aria

%.2f\n",d.getX(),d.getY(),d.Perimetru(),d.Arie());

printf("Cercul cu raza %.2f are perimetrul %.2f si aria %.2f\n",c.getRaza(),c.Perimetru(),c.Arie());

return 0; }

//P8_10
#include <iostream>

class Dreptunghi

public:

double lungime,latime;

Dreptunghi(double lung,double lat)

(*this).lungime=lung;

(*this).latime=lat;

virtual double Arie()

return 2*((*this).lungime+(*this).latime);

virtual double Volum()

return 0;

};

class Paralelipiped:public Dreptunghi

public:

double inaltime;

Paralelipiped(double lung, double lat, double h):Dreptunghi(lung, lat)

(*this).inaltime=h;

}
 double Arie()

return
2*(*this).lungime*(*this).lungime+2*(*this).inaltime*(*this).latime+2*(*this).inaltime*(*this).lungime;

double Volum()

return (*this).lungime*(*this).latime*(*this).inaltime;

};

int main()

Dreptunghi d=Dreptunghi(20,10);

Paralelipiped p=Paralelipiped(20,10,5);

printf("dreptunghiul cu lungimea %.2f si latime %.2f are\n aria %.2f si volumul

%.2f\n",d.lungime,d.latime,d.Arie(),d.Volum());

printf("paralelipipedul cu lungimea %.2f, latime %.2f si inaltimea %.2f are\n aria %.2f si volumul
%.2f\n",p.lungime,p.latime,p.inaltime,p.Arie(),p.Volum());

return 0;